def get_mask_results(self, predictions, image): """Searches each prediction box section of the input image for a mask, and generates a new prediction in the overall image based on the prediction. Args: predictions (list): List of ObjectDetectionPredictions image (numpy array): The image to inference on Returns: list: Returns a list of ObjectDetectionPrediction elements """ mask_results = [] for prediction in deepcopy(predictions): # use the person prediction to narrow the focus and search for masks new_image = edgeiq.cutout_image(image, prediction.box) mask_predictions = self.mask_detector.detect_objects(new_image, confidence_level=0.2).predictions if len(mask_predictions) > 0: pred = mask_predictions[0] # update the label with the mask model's label if it is found prediction.label = pred.label # make the new box in the original frame new_start_x = prediction.box.start_x + pred.box.start_x new_end_x = new_start_x + pred.box.width new_start_y = prediction.box.start_y + pred.box.start_y new_end_y = new_start_y + pred.box.height # send back this new box to be marked up in the frame new_box = edgeiq.BoundingBox(new_start_x, new_start_y, new_end_x, new_end_y) prediction.box = new_box else: prediction.label = "no-mask-detected" mask_results.append(prediction) return mask_results
def main(): # Step 1b: first make a detector to detect facial objects facial_detector = edgeiq.ObjectDetection( "alwaysai/res10_300x300_ssd_iter_140000") facial_detector.load(engine=edgeiq.Engine.DNN) # Step 2a: then make a classifier to classify the age of the image classifier = edgeiq.Classification("alwaysai/agenet") classifier.load(engine=edgeiq.Engine.DNN) # Step 2b: descriptions printed to console print("Engine: {}".format(facial_detector.engine)) print("Accelerator: {}\n".format(facial_detector.accelerator)) print("Model:\n{}\n".format(facial_detector.model_id)) print("Engine: {}".format(classifier.engine)) print("Accelerator: {}\n".format(classifier.accelerator)) print("Model:\n{}\n".format(classifier.model_id)) fps = edgeiq.FPS() try: with edgeiq.WebcamVideoStream(cam=0) as video_stream, \ edgeiq.Streamer() as streamer: # Allow Webcam to warm up time.sleep(2.0) fps.start() # loop detection while True: # Step 3a: track how many faces are detected in a frame count = 1 # read in the video stream frame = video_stream.read() # detect human faces results = facial_detector.detect_objects(frame, confidence_level=.5) # Step 3b: altering the labels to show which face was detected for p in results.predictions: p.label = "Face " + str(count) count = count + 1 # Step 3c: alter the original frame mark up to just show labels frame = edgeiq.markup_image(frame, results.predictions, show_labels=True, show_confidences=False) # generate labels to display the face detections on the streamer text = ["Model: {}".format(facial_detector.model_id)] text.append("Inference time: {:1.3f} s".format( results.duration)) # Step 3d: text.append("Faces:") # Step 4a: add a counter for the face detection label age_label = 1 # append each predication to the text output for prediction in results.predictions: # Step 4b: append labels for face detection & classification text.append("Face {} ".format(age_label)) age_label = age_label + 1 ## to show confidence, use the following instead of above: # text.append("Face {}: detected with {:2.2f}% confidence,".format( #count, prediction.confidence * 100)) # Step 4c: cut out the face and use for the classification face_image = edgeiq.cutout_image(frame, prediction.box) # Step 4d: attempt to classify the image in terms of age age_results = classifier.classify_image(face_image) # Step 4e: if there are predictions for age classification, # generate these labels for the output stream if age_results.predictions: text.append("is {}".format( age_results.predictions[0].label, )) else: text.append("No age prediction") ## to append classification confidence, use the following ## instead of the above if/else: # if age_results.predictions: # text.append("age: {}, confidence: {:.2f}\n".format( # age_results.predictions[0].label, # age_results.predictions[0].confidence)) # else: # text.append("No age prediction") # send the image frame and the predictions to the output stream streamer.send_data(frame, text) fps.update() if streamer.check_exit(): break finally: fps.stop() print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds())) print("approx. FPS: {:.2f}".format(fps.compute_fps())) print("Program Ending")
def main(): facial_detector = edgeiq.ObjectDetection( "alwaysai/res10_300x300_ssd_iter_140000") facial_detector.load(engine=edgeiq.Engine.DNN) print("Engine: {}".format(facial_detector.engine)) print("Accelerator: {}\n".format(facial_detector.accelerator)) print("Model:\n{}\n".format(facial_detector.model_id)) fps = edgeiq.FPS() event_video_writer = edgeiq.EventVideoWriter(pre_roll=3, post_roll=3, fps=1) try: with edgeiq.WebcamVideoStream(cam=0) as webcam, \ edgeiq.Streamer() as streamer: # Allow webcam to warm up time.sleep(2.0) fps.start() i=0 face_dict = {0: "Vignesh", 1: "Parth", 2: "Rosna", 3: "Vipul"} fireb = firebase.FirebaseApplication('https://soteria-hacksc.firebaseio.com/', None) fire_res = fireb.get('/faces_detected', None) print(fire_res) tflag = False # loop detection while True: frame = webcam.read() event_video_writer.update(frame) # detect human faces results = facial_detector.detect_objects( frame, confidence_level=.5) frame = edgeiq.markup_image( frame, results.predictions, show_labels=False) # Generate text to display on streamer text = ["Model: {}".format(facial_detector.model_id)] text.append( "Inference time: {:1.3f} s".format(results.duration)) text.append("Faces:") bb_img_list = [] for prediction in results.predictions: text.append("{:2.2f}%".format(prediction.confidence * 100)) bbox = prediction.box bb_image = edgeiq.cutout_image(frame,bbox) bb_img_list.append(bb_image) try : cv2.imwrite('./unknown_'+str(i)+'.jpg',bb_img_list[0]) unknown_image = face_recognition.load_image_file("./unknown_"+str(i)+".jpg") unknown_encoding = face_recognition.face_encodings(unknown_image)[0] except : unknown_image = face_recognition.load_image_file("./unknown.jpg") unknown_encoding = face_recognition.face_encodings(unknown_image)[0] print("Unknown face!!") j = 0 while j<4: known_image = face_recognition.load_image_file("./"+str(j)+".jpg") biden_encoding = face_recognition.face_encodings(known_image)[0] if face_recognition.compare_faces([biden_encoding], unknown_encoding)[0]: print("Face recognised: ", j) text.append("Recognised: ") text.append(face_dict[j]) fire_data = {i: {'id': face_dict[j], 'location': '34.020091, -118.286119'}} fire_result = fireb.post('/faces_detected', fire_data) print(fire_result) j += 1 alert_res = fireb.get('/alert', None) if not tflag and alert_res['bool'] == 1: print("Alert!!") text.append("Alert!!! Potential Imminent Danger around you") output_path="video_clip.avi" event_video_writer.start_event(output_path=output_path, callback_function=cb) timeout = time.time() + 30 tflag = True if tflag and time.time() > timeout: print(fps.compute_fps()) print("Video complete!") event_video_writer.finish_event() timeout = time.time() + 60*5 streamer.send_data(frame, text) # streamer.send_data(bb_img_list[0], text) fps.update() i += 1 if streamer.check_exit(): break finally: # stop fps counter and display information fps.stop() print("[INFO] elapsed time: {:.2f}".format(fps.get_elapsed_seconds())) print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps())) print("Program Ending")
def main(): # First make a detector to detect facial objects hand_detector = edgeiq.ObjectDetection("alwaysai/hand_detection") hand_detector.load(engine=edgeiq.Engine.DNN) # Then make a detector to detect the sign of the hand sign_detector = edgeiq.ObjectDetection("alwaysai/mobilenet_ssd") sign_detector.load(engine=edgeiq.Engine.DNN) # Descriptions printed to console print("Engine: {}".format(hand_detector.engine)) print("Accelerator: {}\n".format(hand_detector.accelerator)) print("Model:\n{}\n".format(hand_detector.model_id)) print("Labels:\n{}\n".format(hand_detector.labels)) print("Engine: {}".format(sign_detector.engine)) print("Accelerator: {}\n".format(sign_detector.accelerator)) print("Model:\n{}\n".format(sign_detector.model_id)) print("Labels:\n{}\n".format(sign_detector.labels)) fps = edgeiq.FPS() # Variables to limit inference counter = 0 DETECT_RATE = 10 sign_monitor = SignMonitor() try: with edgeiq.WebcamVideoStream(cam=0) as video_stream, \ edgeiq.Streamer() as streamer: # Allow Webcam to warm up time.sleep(2.0) fps.start() # Loop detection while True: counter += 1 if counter % DETECT_RATE == 0: # Read in the video stream frame = video_stream.read() # Detect human faces results = hand_detector.detect_objects(frame, confidence_level=.5) # Alter the original frame mark up to just show labels frame = edgeiq.markup_image(frame, results.predictions, show_labels=True, show_confidences=False) # Generate labels to display the face detections on the streamer text = ["Model: {}".format(hand_detector.model_id)] text.append("Inference time: {:1.3f} s".format( results.duration)) text.append("Signs:") # Add a counter for the face detection label sign_label = 1 # Append each predication to the text output for prediction in results.predictions: # Append labels for face detection & classification text.append("Sign {} ".format(sign_label)) sign_label = sign_label + 1 # Cut out the hand and use for the sign detection hand_image = edgeiq.cutout_image(frame, prediction.box) # Attempt to classiidnetify sign object sign_results = sign_detector.detect_objects( hand_image, confidence_level=.9) sign = None # If a sign was detected, append the label if sign_results.predictions: sign = sign_results.predictions[0] text.append( "sign: {}, confidence: {:.2f}\n".format( sign_results.predictions[0].label, sign_results.predictions[0].confidence)) if sign is not None: sign_monitor.update(sign.label) # Send the image frame and the predictions to the output stream streamer.send_data(frame, text) fps.update() if streamer.check_exit(): break finally: fps.stop() print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds())) print("approx. FPS: {:.2f}".format(fps.compute_fps())) print("Program Ending")
def start_file_detection_and_tracking(delivery_object, filter_for, model_name, filename, detection_confidence=.5, enable_streamer=True, streamer_show_labels=True, tracker_deregister_frames=20, tracker_max_distance=50, should_log=False): """Starts a detection loop""" obj_detect = object_detector(model_name) tracker = edgeiq.CentroidTracker( deregister_frames=tracker_deregister_frames, max_distance=tracker_max_distance) fps = edgeiq.FPS() try: # Enables video camera and streamer # TODO: add streamer disable feature here with edgeiq.FileVideoStream( filename) as video_stream, edgeiq.Streamer() as streamer: # Start tracking of frames per second fps.start() # loop detection while True: frame = video_stream.read() text = [] # Run detection # detect human faces results = obj_detect.detect_objects( frame, confidence_level=detection_confidence) # TODO: Add filter option here frame = edgeiq.markup_image(frame, results.predictions, show_labels=streamer_show_labels) # Generate text to display on streamer text.append("Model: {}".format(obj_detect.model_id)) text.append("Inference time: {:1.3f} s".format( results.duration)) predictions = [] objects = tracker.update(results.predictions) # predictions = results.predictions for (object_id, prediction) in objects.items(): # print(vars(prediction)) text.append("{}: {}: {:2.2f}%".format( object_id, prediction.label, prediction.confidence * 100)) predictions.append(prediction) if delivery.should_send_image(object_id): # Extract image face_image = edgeiq.cutout_image(frame, prediction.box) # Send data to server delivery.send_image(object_id, prediction.label, face_image) elif delivery.should_send_data(object_id): delivery.send_data(object_id, prediction.label) # if delivery.should_send_data(object_id): # delivery.send_data(object_id, prediction.label) frame = edgeiq.markup_image(frame, predictions) streamer.send_data(frame, text) fps.update() if streamer.check_exit(): break finally: # stop fps counter and display information fps.stop() if should_log == True: print("[INFO] elapsed time: {:.2f}".format( fps.get_elapsed_seconds())) print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps())) print("Program Ending")