def main(): labels = load_labels("models/coco_labels.txt") interpreter = make_interpreter( "models/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite") interpreter.allocate_tensors() threshold = 0.4 printInfo("ready") while True: line = sys.stdin.readline().rstrip("\n") try: rawImage = BytesIO(base64.b64decode(line)) image = Image.open(rawImage) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, threshold, scale) output = [] for obj in objs: label = labels.get(obj.id, obj.id) labelID = obj[0] score = obj[1] bbox = obj[2] output.append({"bbox": bbox, "class": label, "score": score}) printData(output, (inference_time * 1000)) except Exception as e: printError(str(e))
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-i', '--input', required=True, help='File path of image to process.') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument('-o', '--output', help='File path for the result image with annotations') parser.add_argument('-c', '--count', type=int, default=5, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() image = Image.open(args.input) scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) print('----INFERENCE TIME----') print('Note: The first inference is slow because it includes', 'loading the model into Edge TPU memory.') for _ in range(args.count): start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, args.threshold, scale) print('%.2f ms' % (inference_time * 1000)) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) if args.output: image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) image.save(args.output) image.show()
def read_root(item_id: str): image = Image.open("images/%s" % item_id) scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) print('----INFERENCE TIME----') print('Note: The first inference is slow because it includes', 'loading the model into Edge TPU memory.') for _ in range(0, 5): start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, 0.4, scale) print('%.2f ms' % (inference_time * 1000)) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) if "result.jpg": image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) image.save("result.jpg") image.show() return {"Hello": "World"}
def _detect_image(self, threshold, image): scale = detect.set_input( self.interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS), ) self.interpreter.invoke() objs = detect.get_output(self.interpreter, threshold, scale) return objs
def process(self, source): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-i', '--input', required=True, help='File path of image to process.') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument( '-o', '--output', help='File path for the result image with annotations') parser.add_argument('-c', '--count', type=int, default=1, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() self.image = source scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, args.threshold, scale) print('%.2f ms' % (inference_time * 1000)) return objs
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-i', '--input', required=True, help='File path of image folder') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() # Open Image from input argument image = Image.open(args.input) image = image.convert('RGB') #Scale Each Image scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) # Call the Interpreter and run the inference interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) # Loop over every detected object for obj in objs: draw_object(ImageDraw.Draw(image), obj, labels) image.save("prediction.jpg") print("Detected {} people in the image".format(len(objs)))
def detect_image(self, image=None, image_file=None, threshold=TF_THRESHOLD): if image_file: image = Image.open(image_file) if not self.interpreter: logger.warning( "Interpreter has not been loaded, returning plain image") return image, 1.0 scale = detect.set_input( self.interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) self.interpreter.invoke() objs = detect.get_output(self.interpreter, threshold, scale) interesting_objs = [o for o in objs if o.id in self._interesting_objs] logger.debug( f"{len(objs)} objects detected - {len(interesting_objs)} of interest" ) for obj in interesting_objs: logger.debug( f"{self._labels.get(obj.id, obj.id)} detected with probabiliy {obj.score} at {obj.bbox}" ) if len(interesting_objs): image = image.convert('RGB') best_obj = max(interesting_objs, key=lambda x: x.score) self.draw_object(ImageDraw.Draw(image), best_obj) logger.info( f"{self._labels.get(best_obj.id, best_obj.id)} detected with probabiliy {best_obj.score} at {best_obj.bbox}" ) return image, best_obj.score return None, 0
def classify(interpreter, input_index, image, labels): image = np.expand_dims(image, axis=0).astype(np.uint8) interpreter.set_tensor(input_index, image) interpreter.invoke() objs = detect.get_output(interpreter, detection_threshold) person_count = 0 # number of persons. if not objs: return(person_count) for obj in objs: label = labels.get(obj.id, obj.id) print(label + ' score: ', obj.score) if label == "person": person_count = person_count + 1 return(person_count)
def processFrame(frame, mask, interpreter, threshold): start = time.time() logging.info("==== Process Frame ====") results = [] # prepare the frame for object detection by converting (1) it # from BGR to RGB channel ordering and then (2) from a NumPy # array to PIL image format frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame = Image.fromarray(frame) # make predictions on the input frame scale = detect.set_input(interpreter, frame.size, lambda size: frame.resize(size, Image.ANTIALIAS)) interpreter.invoke() results = detect.get_output(interpreter, threshold, scale) end = time.time() logging.info('Proccessing Time: %.3f s' % (end - start)) return results
def gen(camera): """Video streaming generator function.""" while True: frame = camera.get_frame() image_file = BytesIO(frame) image = Image.open(image_file) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, threshold, scale) objs = [x for x in objs if x.score > threshold] print('%.2f ms' % (inference_time * 1000)) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) di.draw_objects(ImageDraw.Draw(image), objs, labels) outbytes = BytesIO() image.save(outbytes, format="JPEG") outbytes = outbytes.getvalue() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + outbytes + b'\r\n') print('frame rendered')
def run(input_image): image = Image.open(input_image) scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) interpreter.invoke() objs = detect.get_output(interpreter, threshold, scale) if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) image_byte_array = io.BytesIO() image.save(image_byte_array, format='JPEG') image_byte_array.seek(0) return image_byte_array.read()
def predict(): data = {"success": False} if flask.request.method == "POST": if flask.request.files.get("image"): image_file = flask.request.files["image"] image_bytes = image_file.read() image = Image.open(io.BytesIO(image_bytes)).convert('RGB') scale = detect.set_input( HOLDER['interpreter'], image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() HOLDER['interpreter'].invoke() inference_time = time.perf_counter() - start objs = detect.get_output(HOLDER['interpreter'], HOLDER['threshold'], scale) data["inference-time"] = '%.2f ms' % (inference_time * 1000) if len(objs) > 0: data["success"] = True preds = [] for obj in objs: bbox = obj.bbox preds.append({ "confidence": obj.score, "label": HOLDER['labels'].get(obj.id, obj.id), "y_min": bbox.ymin, "x_min": bbox.xmin, "y_max": bbox.ymax, "x_max": bbox.xmax, }) data["predictions"] = preds return flask.jsonify(data)
def main(): labels = load_labels() interpreter = make_interpreter() interpreter.allocate_tensors() cam = camera.Camera() stream = cam.get_stream() print("you can press Q button to terminate the process!") while True: image = load_image(stream) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) interpreter.invoke() objs = detect.get_output(interpreter, 0.4, scale) draw_objects(ImageDraw.Draw(image), objs, labels) cv.imshow("Debug", np.asarray(image)) if cv.waitKey(10) & 0xFF == ord('q'): break cam.terminate()
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-i', '--input', required=True, help='File path of image to process.') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument('-o', '--output', help='File path for the result image with annotations') parser.add_argument('-n', '--team', type=int, help='Team number') args = parser.parse_args() # Init cameras WIDTH, HEIGHT = 720, 1920 print("Connecting to Network Tables") ntinst = NetworkTablesInstance.getDefault() ntinst.startClientTeam(args.team) # """Format of these entries found in WPILib documentation.""" # detections_entry = ntinst.getTable("ML").getEntry("detections") # print("Starting camera server") cs = CameraServer.getInstance() camera = cs.startAutomaticCapture() camera.setResolution(WIDTH, HEIGHT) cv_sink = cs.getVideo() img = np.zeros(shape=(HEIGHT, WIDTH, 3), dtype=np.uint8) # output = cs.putVideo("MLOut", WIDTH, HEIGHT) labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() if args.output: fourcc = cv2.VideoWriter_fourcc(*'avc1') video = cv2.VideoWriter(args.output + ".mp4", fourcc, 10, (WIDTH, HEIGHT)) while True: if keyboard.is_pressed('q'): print("Releasing video") video.release() break t, frame = cv_sink.grabFrame(img) image = Image.fromarray(frame) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) if args.output: image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) video.write(np.array(image))
def detection_loop(filename_image, path, output): labels = load_labels(labelsPath) if labelsPath else {} interpreter = make_interpreter(modelPath) interpreter.allocate_tensors() summ = 0 #check if folder results exists, otherwise make it and make it accessible if (os.path.isdir(path + 'results') == False): #print("The output folder " + output + " does not exist! It will be created") os.system("mkdir " + path + "results") #os.system("sudo chmod 777 ./results") #make output.txt for results of the inference and make it accessible os.system("touch " + path + "results/output.txt") #os.system("sudo chmod 777 ./results/output.txt") no_files = len(filename_image) for filename, image in filename_image.items(): #image = cv2.cvtColor(img,cv2.COLOR_BGR2RGB) #image = Image.fromarray(image) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) for _ in range(1): start = time.perf_counter() #run inference by invoking the Interpreter interpreter.invoke() #calculate inference time inference_time = time.perf_counter() - start #get the output data objs = detect.get_output(interpreter, confThreshold, scale) print('\n\nIT TOOK %f ms' % (inference_time * 1000) + " on image " + filename + "\n") summ = summ + (inference_time * 1000) #os.chmod("./results/output.txt", 0o777) with open(path + "results/output.txt", "a") as f: f.write("%f \n" % (inference_time * 1000)) print('--------RESULTS--------') if not objs: #with open (path+"results/output.txt", "a") as f: # f.write("No objects detected" # ) print('No objects detected') for obj in objs: #with open (path+"results/output.txt", "a") as f: # f.write( # labels.get(obj.id, obj.id) + # "\n score: %s\n--\n" % obj.score # ) print(labels.get(obj.id, obj.id)) #print(' id: ', obj.id) print(' score: ', obj.score) #print(' bbox: ', obj.bbox) if output != None: image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) #image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB) #np_img = Image.fromarray(image) #byte_io = BytesIO() #os.system("sudo chmod 777 ./results") #spliting filename from extension split_filename = filename.split(".", 1) image.save(path + "results/" + split_filename[0] + "-annnotated.png", format='PNG') print("The average inference time over " + str(no_files) + " image files is:") print('%.7fms' % (summ / no_files))
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', default="models/hand_edgetpu.tflite", help='File path of .tflite file.') parser.add_argument('-l', '--labels', default="models/labels.txt", help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() print('----INFERENCE TIME----') print('Note: The first inference is slow because it includes', 'loading the model into Edge TPU memory.') video_capture = cv2.VideoCapture(0) video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1960) video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 1600) while video_capture.isOpened(): start = time.time() ret, frame = video_capture.read() rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(rgb) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) for obj in objs: print(obj) topLeftX = obj.bbox.xmin topLeftY = obj.bbox.ymin bottomRightX = obj.bbox.xmax bottomRightY = obj.bbox.ymax cv2.rectangle(frame, (topLeftX, topLeftY), (bottomRightX, bottomRightY), (0, 255, 0), 2) cv2.putText(frame, labels[obj.id], (topLeftX, topLeftY), cv2.FONT_HERSHEY_TRIPLEX, 1, (255, 255, 0)) end = time.time() cv2.putText(frame, 'Press ESC to EXIT. FTPS: %2f' % (1 / (end - start)), (40, 40), cv2.FONT_HERSHEY_TRIPLEX, 0.5, (0, 0, 255)) cv2.imshow("Detection", frame) if cv2.waitKey(40) & 0xFF == 27: cv2.destroyAllWindows() break video_capture.release() cv2.destroyAllWindows() print("Finished")
def main(): print("~~~ Started mask detection process ~~~\n") face_model = operational_config["models"]["face_detection"]["model"] face_threshold = operational_config["models"]["face_detection"][ "threshold"] mask_model = operational_config["models"]["mask_classifier"]["model"] mask_labels = operational_config["models"]["mask_classifier"]["labels"] mask_threshold = operational_config["models"]["mask_classifier"][ "threshold"] deployment: dict = operational_config["deployment"] conn = db.conn while True: # Get camera feed image = get_image() # Apply face detection interpreter = make_interpreter(face_model) interpreter.allocate_tensors() scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start faces = detect.get_output(interpreter, face_threshold, scale) print("Face detection inference took: %.2f ms" % (inference_time * 1000)) if not faces: print("No alert to raise\n") time.sleep(SLEEP_TIME) continue print(f"{len(faces)} Face(s) detected") for idx, face in enumerate(faces): print(f" Face {idx} ") print(f" score: {face.score}") print(f" bbox: {face.bbox}") image = image.convert("RGB") # For each face in the image crop around the ROI and detect if mask or not mask # Apply mask / no mask classifier mask_interpreter = make_interpreter(mask_model) mask_interpreter.allocate_tensors() input_details = mask_interpreter.get_input_details() output_details = mask_interpreter.get_output_details() for face in faces: height = input_details[0]["shape"][1] width = input_details[0]["shape"][2] region = image.crop(face.bbox).resize((width, height)) input_data = np.expand_dims(region, axis=0) mask_interpreter.set_tensor(input_details[0]["index"], input_data) mask_interpreter.invoke() output_data = mask_interpreter.get_tensor( output_details[0]["index"]) results = np.squeeze(output_data) top_k = results.argsort()[-5:][::-1] labels = load_labels(mask_labels) shall_raise_alert = False for i in top_k: if labels[i] != "no_mask": break proba = float(results[i] / 255.0) if proba < mask_threshold: break shall_raise_alert = True print("Alert: no mask with probability {:08.6f}: {}".format( proba, labels[i])) if not shall_raise_alert: print( f"No alerts to raise. Proba ({proba}) is below alert threshold ({mask_threshold}\n" ) time.sleep(SLEEP_TIME) continue alert = create_alert(region, proba) persist_alert(conn, alert, deployment["deployed_on"]) time.sleep(SLEEP_TIME)
def process_IN_CLOSE_WRITE(self, event): now = datetime.datetime.now() filename = str(event.pathname.split("/")[-1]) if filename.split('.')[-1].lower() != 'jpg': logger.error('unknown file type: ' + filename) logger.error('file will be skipped') return image = Image.open(event.pathname) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start inference_time_string = '%.2f ms' % (inference_time * 1000) objs = detect.get_output(interpreter, 0.1, scale) global score_with_pray global score_no_pray filename_arr = filename.split('-') file_number = int(filename_arr[-1].split('.')[0]) if file_number == 0: score_with_pray = 0 score_no_pray = 0 for obj in objs: if int(obj.id) in [1]: score_with_pray = score_with_pray + Decimal(obj.score) if int(obj.id) in [0]: score_with_pray = max(Decimal(0), score_with_pray - Decimal(obj.score)) score_no_pray = score_no_pray + Decimal(obj.score) if int(obj.id) in [0, 1]: logger.info( f'Detection: {obj.score} {labels.get(obj.id, obj.id)} inference time: {inference_time_string}' ) if not objs: label = 'NO-DETECTION' else: label = labels.get(objs[0].id, objs[0].id).upper() if score_with_pray > ALERT_THRESHOLD: logger.info("****************************") logger.info("* *") logger.info("* PREY ALERT *") logger.info("* *") logger.info("****************************") start = datetime.datetime.now() stop = datetime.datetime.now() + datetime.timedelta( minutes=CURFEW_TIME) formatted_score_with_pray = "{:.2f}".format(score_with_pray) formatted_score_no_pray = "{:.2f}".format(score_no_pray) #Remove scheduled job if exists if scheduler.get_job(JOBKEY_DISABLE_CURFEW) is not None: scheduler.remove_job(JOBKEY_DISABLE_CURFEW) logger.info("already locked, will not lock again") msg = f"Rosine mit Maus. Confidence: {formatted_score_with_pray}/{formatted_score_no_pray}. Already locked." else: lock = datetime.datetime.strptime(start.strftime('%H:%M'), '%H:%M') unlock = datetime.datetime.strptime(stop.strftime('%H:%M'), '%H:%M') start1 = timeit.default_timer() relay.lock() stop1 = timeit.default_timer() duration = str(stop1 - start1) logger.info(f"Lockout delay: {duration}") locktime = str(datetime.datetime.now()) logger.info(f"Lockout active: {locktime}") msg = f"Rosine mit Maus. Confidence: {formatted_score_with_pray}/{formatted_score_no_pray}. Locked at {locktime}. Lockout delay: {duration}." #Schedule job to unlock SureFlag after defined curfew time scheduler.add_job(relay.unlock, 'date', run_date=stop, id=JOBKEY_DISABLE_CURFEW) #send notification to iphone send_notification(msg) if file_number == 39 and score_no_pray > ALERT_THRESHOLD: formatted_score_no_pray = "{:.2f}".format(score_no_pray) formatted_score_pray = "{:.2f}".format(score_with_pray) msg = f"Rosine ohne Maus, Confidence: {formatted_score_pray}/{formatted_score_no_pray}." send_notification(msg) logger.info("Sending notification completed.") filename = ''.join( filename_arr[:-1]) + '_' + label + '_' + filename_arr[-1] s3_object_path = 'incoming/' + str(now.year) + '/' + str( now.month) + '/' + str(now.day) + '/' + str( now.hour) + '/' + filename detections = {'image': s3_object_path, 'objects': objs} detection_file = now.strftime('%Y-%m-%d') + '.txt' detection_path = f'detections/{detection_file}' s3_detection_log_path = 'incoming/' + str(now.year) + '/' + str( now.month) + '/' + str(now.day) + '/' + detection_file with open(detection_path, 'a+') as json_file: json.dump(detections, json_file) json_file.write(',\n') #Save resized img to /tmp tempFile = '/tmp/' + s3_object_path if not os.path.exists(os.path.dirname(tempFile)): os.makedirs(os.path.dirname(tempFile)) image.save(tempFile, quality=50) s3_client.upload_file(tempFile, BUCKET, s3_object_path) logger.info( f'Upload to s3 completed: {BUCKET}/{s3_object_path} size: {os.path.getsize(tempFile)}' ) #remove img from /tmp os.remove(tempFile) s3_client.upload_file(detection_path, BUCKET, s3_detection_log_path) logger.info( f'Upload to s3 completed: {BUCKET}/{s3_detection_log_path} size: {os.path.getsize(detection_path)}' ) logger.info(f'Score: {score_with_pray}/{score_no_pray}') os.remove(event.pathname) for detection_log in os.listdir('detections'): if detection_log != detection_file: logger.info(f'Delete old detection log: {detection_log}') os.remove('detections/' + detection_log)
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=False, help='File path of .tflite file.') parser.add_argument('-i', '--input_folder', required=True, help='File path of image folder') parser.add_argument( '-o', '--output', required=False, help='File path for the resultant images with annotations') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument('-c', '--count', type=int, default=5, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() image_path = os.path.join(os.path.expanduser(args.input_folder), "*.jpg") # Run Indefinitly to load the TPU or CPU constantly while True: current_run = 0 acumulated_fps = 0 for image_file in glob(image_path): # Open Image using Context Manager to avoid problems with memory with Image.open(image_file) as image: # Images MUST be converted to RGB, any other mode causes a bug in the supplied detect.py converted_img = image.convert('RGB') # Scale the Image scale = detect.set_input( interpreter, converted_img.size, lambda size: converted_img.resize(size, Image.ANTIALIAS)) # Call the Interpreter and run the inference start_time = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start_time objs = detect.get_output(interpreter, args.threshold, scale) current_run += 1 acumulated_fps += (1.0 / inference_time) print( "Done with Image {}, Number of Objects {}, Current CPU Utilization: {}, FPS: {}, Running Avg FPS: {}\n" .format(current_run, len(objs), psutil.cpu_percent(), 1.0 / inference_time, acumulated_fps / current_run))
def main(): labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter() interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # Check the type of the input tensor and height, width # is_floating_model = input_details[0]['dtype'] == np.float32 height = input_details[0]['shape'][1] width = input_details[0]['shape'][2] # Open camera camera = cv2.VideoCapture(0) camera.set(cv2.CAP_PROP_FRAME_WIDTH, 620) camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) time.sleep(1) # Allow time to open camera fps = FPS().start() while True: try: # Read frame from video and prepare for inference _, frame = camera.read() #frame = cv2.cvtColor( frame, cv2.COLOR_BGR2RGB ) # Prepare screenshot for annotation by reading it into a PIL IMAGE object image = Image.fromarray(frame) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) if not objs: print('No objects detected') # for obj in objs: # print( labels.get(obj.id, obj.id) ) # print(' id: ', obj.id) # print(' score: ', obj.score) # print(' bbox: ', obj.bbox) draw_objects(ImageDraw.Draw(image), objs, labels) frame = np.array(image) fps.update() cv2.imshow("Capture", frame) if (cv2.waitKey(1) & 0xFF == ord('q')): fps.stop() break except KeyboardInterrupt: fps.stop() break print("Approx FPS: :" + str(fps.fps()))
def main(): default_model_dir = '../all_models' default_model = 'mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite' default_labels = 'coco_labels.txt' parser = argparse.ArgumentParser() parser.add_argument('--model', help='.tflite model path', default=os.path.join(default_model_dir,default_model)) parser.add_argument('--labels', help='label file path', default=os.path.join(default_model_dir, default_labels)) parser.add_argument('--top_k', type=int, default=3, help='number of categories with highest score to display') parser.add_argument('--threshold', type=float, default=0.1, help='classifier score threshold') args = parser.parse_args() ## Digits interpreter and label file### labels = load_labels(LABEL_FILE_DIGITS) interpreter = make_interpreter(TFLITE_MODEL_DIGITS) interpreter.allocate_tensors() ####################################### cap = cv2.VideoCapture(0) ###############################For sending to the socket #cap.set(3, 320); #cap.set(4, 240); img_counter = 0 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90] ######################################################################33 while cap.isOpened(): ret, frame = cap.read() if not ret: break image = frame scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) print('----INFERENCE TIME----') print('Note: The first inference is slow because it includes', 'loading the model into Edge TPU memory.') for _ in range(args.count): start = time.monotonic() interpreter.invoke() inference_time = time.monotonic() - start objs = detect.get_output(interpreter, args.threshold, scale) print('%.2f ms' % (inference_time * 1000)) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) if args.output: image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) #################SENDING TO THE SERVER#################3 result, frame = cv2.imencode('.jpg', image, encode_param) data = pickle.dumps(frame,0) size = len(data) clientsocket.sendall(struct.pack(">L", size) + data) #connection.sendall(struct.pack(">L", size) + data) img_counter += 1 ################################################################# #cv2.imshow('frame', cv2_im) #if cv2.waitKey(1) & 0xFF == ord('q'): # break cap.release() cv2.destroyAllWindows()
def main(): print("Yo") parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument('-o', '--output', help='File path for the result image with annotations') parser.add_argument('-c', '--count', type=int, default=5, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() # initialize the camera and grab a reference to the raw camera capture # camera = PiCamera() resolution = (1280, 720) # camera.resolution = resolution # camera.framerate = 30 freq = cv2.getTickFrequency() # rawCapture = PiRGBArray(camera, size=resolution) fps = FPS().start() piVideoStream = VideoStream(usePiCamera=True, resolution=resolution, framerate=30).start() time.sleep(1) while True: t0 = cv2.getTickCount() frame = piVideoStream.read() fps.update() image_rgb_np = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # image_rgb_np_with_detections = doinference(image_rgb_np) # image_bgr_np_with_detections = cv2.cvtColor(image_rgb_np_with_detections, cv2.COLOR_RGB2BGR) # cv2.putText(frame, 'FPS: {0:.2f}'.format(fps.fps()), (30, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, # (255, 255, 0), 2, cv2.LINE_AA) # scale = detect.set_input(interpreter, resolution, lambda size: cv2.resize(image_rgb_np, size)) interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) draw_objects(frame, objs, labels) # for obj in objs: # print(labels.get(obj.id, obj.id)) # print(' id: ', obj.id) # print(' score: ', obj.score) # print(' bbox: ', obj.bbox) cv2.imshow('frame', frame) # # t1 = cv2.getTickCount() # time= (t1-t0)/freq # fps = 1/time # # clear the stream in preparation for the next frame # rawCapture.truncate(0) # # resets the time if cv2.waitKey(1) & 0xFF == ord('q'): break fps.stop() piVideoStream.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cv2.destroyAllWindows()
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=True, help='File path of .tflite file.') parser.add_argument('-i', '--input', help='File path of image to process.') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') parser.add_argument('-o', '--output', help='File path for the result image with annotations') parser.add_argument('-c', '--count', type=int, default=5, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() img_path = 'test_images/*.jpg' img_name = glob.glob(img_path) img_n = [] img_id = [] img_x = [] img_y = [] img_w = [] img_h = [] img_score = [] img_csv = {} i = 0 print(img_name[253]) for img in img_name: image = Image.open(img) scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) print('----INFERENCE TIME----') print('Note: The first inference is slow because it includes', 'loading the model into Edge TPU memory.') for _ in range(args.count): start = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, args.threshold, scale) print('%.2f ms' % (inference_time * 1000)) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) w = obj.bbox[2]-obj.bbox[0] h = obj.bbox[3]-obj.bbox[1] print('W:',w) print('H:',h) img_n.append(img) img_id.append(obj.id) img_x.append(obj.bbox[0]) img_y.append(obj.bbox[1]) img_w.append(w) img_h.append(h) img_score.append(obj.score) print(i) if args.output: image = image.convert('RGB') draw_objects(ImageDraw.Draw(image), objs, labels) image.save(args.output) image.show() i += 1 for i in range(len(img_x)): img_dict = { "image_filename": img_n[i], "label_id": img_id, "x": img_x, "y": img_y, "w": img_w, "h": img_h, "confidence": img_score } img_csv.update(img_dict) img_csv.to_csv('test.csv')
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-m', '--model', required=False, help='File path of .tflite file.') parser.add_argument('-i', '--input_folder', required=True, help='File path of image folder') parser.add_argument('-l', '--labels', help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.4, help='Score threshold for detected objects.') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() running_average_time = 0 image_path = os.path.join(os.path.expanduser(args.input_folder), "*.jpg") print("Number of images " + str(len(glob(image_path)))) # Run Once over the entire dataset with open('inference_result' + '.csv', mode='w') as accuracy_f: csv_writer = csv.writer(accuracy_f, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) csv_writer.writerow(["Current Run: ", "Inference Time: "]) current_run = 0 for image_file in glob(image_path): # Open Image using Context Manager to avoid problems with memory with Image.open(image_file) as image: # Images MUST be converted to RGB, any other mode causes a bug in the supplied detect.py converted_img = image.convert('RGB') # Scale the Image scale = detect.set_input( interpreter, converted_img.size, lambda size: converted_img.resize(size, Image.ANTIALIAS)) # Call the Interpreter and run the inference start_time = time.perf_counter() interpreter.invoke() inference_time = time.perf_counter() - start_time objs = detect.get_output(interpreter, args.threshold, scale) current_run += 1 running_average_time += inference_time csv_writer.writerow([current_run, inference_time]) print("Done with Image {}\n".format(current_run)) # Run to 400 images to be consistent with testing on Yolo if current_run == 400: break # Add the average inference time at the end of the csv file if current_run != 0: csv_writer.writerow([ "Average Inference Time: ", running_average_time / current_run ])
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-t', '--threshold', type=float, default=0.5, help='Score threshold for detected objects.') parser.add_argument('-c', '--count', type=int, default=5, help='Number of times to run inference') parser.add_argument('-tpu', '--enable-tpu', action='store_true', help='Whether TPU is enabled or not') parser.add_argument('-objects', '--detect-objects', type=str, default="bird") parser.add_argument( '-debug', '--enable-debug', action='store_true', help= 'Whether Debug is enabled or not - Webcamera viewed is displayed when in this mode' ) parser.add_argument("-cslack", "--clear-slack-files", action='store_true', help="clears files in slack") parser.add_argument("-slack", "--slack-credentials", type=str, default="config.ini", help="path to optional slack configuration") args = parser.parse_args() notifications = Notifications(args) notifications.start() objects_to_detect = args.detect_objects # if the user decided to use the Edge TPU # access folder where we have the model for the TPU if args.enable_tpu: model_dir = "/output/edgetpu/" # access another folder else: model_dir = "/output/tflite/" labels = load_labels(model_dir) interpreter = make_interpreter(model_dir, args.enable_tpu) interpreter.allocate_tensors() # begin detect video # initialize the camera and grab a reference to the raw camera capture # camera = PiCamera() resolution = (1280, 720) # camera.resolution = resolution # camera.framerate = 30 freq = cv2.getTickFrequency() # rawCapture = PiRGBArray(camera, size=resolution) fps = FPS().start() piVideoStream = VideoStream(usePiCamera=True, resolution=resolution, framerate=30).start() # enable circular stream cameraCircularStream = enableCircularCameraRecording(piVideoStream) time.sleep(1) while True: t0 = cv2.getTickCount() frame = piVideoStream.read() fps.update() image_rgb_np = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # when passing the size to the method we reverse the tuple scale = detect.set_input( interpreter, image_rgb_np.shape[:2][::-1], lambda size: cv2.resize( image_rgb_np, size, interpolation=cv2.INTER_AREA)) interpreter.invoke() objs = detect.get_output(interpreter, args.threshold, scale) # we only draw bounding boxes and detection labels in the # frame if we are in debug mode if objs and args.enable_debug: draw_objects(frame, objs, objects_to_detect, labels) # we only record to video file if not in debug mode if not args.enable_debug and detected_object(objs, objects_to_detect, labels): log_detected_objects(frame, objs, objects_to_detect, labels, notifications) # record 20 s video clip - it will freeze main thread videoFilename = recordVideoFromCamera(piVideoStream, cameraCircularStream) notification = Notification(NotificationType.VIDEO, videoFilename) notifications.notify(notification) # in debug mode we show the object detection boxes if args.enable_debug: cv2.imshow('frame', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break fps.stop() piVideoStream.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cv2.destroyAllWindows() notifications.join()
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument( '-m', '--model', default="models/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite", help='File path of .tflite file.') parser.add_argument('-i', '--input', help='File path of image to process.') parser.add_argument('-l', '--labels', default="models/coco_labels.txt", help='File path of labels file.') parser.add_argument('-t', '--threshold', type=float, default=0.7, help='Score threshold for detected objects.') parser.add_argument('-o', '--output', help='File path for the result image with annotations') parser.add_argument('-c', '--count', type=int, default=1, help='Number of times to run inference') args = parser.parse_args() labels = load_labels(args.labels) if args.labels else {} interpreter = make_interpreter(args.model) interpreter.allocate_tensors() #depth stuff config = rs.config() config.enable_stream(rs.stream.color, 640, 480) pc = rs.pointcloud() config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30) pipeline = rs.pipeline() pipeline.start(config) #decimate = rs.decimation_filter() #decimate.set_option(rs.option.filter_magnitude, 2 ** state.decimate) # setup motors Motor1 = DRV8825(dir_pin=13, step_pin=19, enable_pin=12, mode_pins=(16, 17, 20)) Motor2 = DRV8825(dir_pin=24, step_pin=18, enable_pin=4, mode_pins=(21, 22, 27)) # setup relay channel = 23 GPIO.setmode(GPIO.BCM) GPIO.setup(channel, GPIO.OUT) #Motor1.SetMicroStep('hardward','fullstep') #Motor2.SetMicroStep('hardward','fullstep') #print("Starting video capture") #cap = cv2.VideoCapture(0) print("Starting video capture") while (True): #try: frames = pipeline.wait_for_frames() #_, cv2_im = cap.read() color_frame = frames.get_color_frame() cv2_im = asanyarray(color_frame.get_data()) #cv2_im = cv2.imread(cv2_im) #cv2_im = cv2.resize(cv2_im, (640, 480)) cv2_im = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB) image = Image.fromarray(cv2_im) scale = detect.set_input( interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) #_,cv2_im = cap.read() #cv2_im = cv2.cvtColor(cv2_im,cv2.COLOR_BGR2RGB) interpreter.invoke() #inference_time = time.perf_counter() - start objs = detect.get_output(interpreter, args.threshold, scale) #image = image.convert('RGB') #image.save(args.output) #image.show() distance = 0 object_id = 0 object_Xcenter = 320 object_Ycenter = 240 for obj in objs: object_id = obj.id print("object id:", obj.id) if (object_id == 15 or object_id == 0): print("person or geese") else: break height = obj.bbox.ymax - obj.bbox.ymin width = obj.bbox.xmax - obj.bbox.xmin crop_img = cv2_im[obj.bbox.ymin:obj.bbox.ymax, obj.bbox.xmin: obj.bbox.xmax] # crop image around object try: cv2.imshow("cropped image", crop_img) except: pass #black_image = zeros((100,100)) #cv2.imshow("cropped_image", black_image) object_Xcenter = int(obj.bbox.xmin + (width / 2)) object_Ycenter = int(obj.bbox.ymin + (height / 3)) # depth stuff frames = pipeline.wait_for_frames() depth_frame = frames.get_depth_frame() #depth_frame = decimate.process(depth_frame) # Grab new intrinsics (may be changed by decimation) #depth_intrinsics = rs.video_stream_profile( # depth_frame.profile).get_intrinsics() #w, h = depth_intrinsics.width, depth_intrinsics.height depth_image = asanyarray(depth_frame.get_data()) depth_image = depth_image[ object_Ycenter:object_Ycenter + 1, object_Xcenter:object_Xcenter + 1] #[obj.bbox.ymin:obj.bbox.ymax, obj.bbox.xmin:obj.bbox.xmax] for the cropped bounding box print("depth image size:", len(depth_image)) #depth_colormap = asanyarray( # colorizer.colorize(depth_frame).get_data()) #mapped_frame, color_source = depth_frame, depth_colormap points = pc.calculate(depth_frame) #pc.map_to(mapped_frame) # Pointcloud data to arrays v, t = points.get_vertices(), points.get_texture_coordinates() #print("v:", asanyarray(v)) verts = asanyarray(v).view(float32).reshape(-1, 3) # xyz #print("verts size", verts.size) #cropped_verts = verts[obj.bbox.ymin:obj.bbox.ymax, obj.bbox.xmin:obj.bbox.xmax] texcoords = asanyarray(t).view(float32).reshape(-1, 2) # uv #print("texcoords:", texcoords) #print("height:", obj.bbox.ymax-obj.bbox.ymin, "width:", obj.bbox.xmax-obj.bbox.xmin) #print("shape[0]:", cropped_verts.shape[0], "shape[1]:", cropped_verts.shape[1]) #print("object_Xcenter:", object_Xcenter) #print("object_Ycenter:", object_Ycenter) try: distance = verts[0][0] print("distance:", distance) print("depth image:", depth_image) except Exception as e: print(e) pass # # calculating average distance is too computationally heavy # # try: # # sumOfVerts = 0 # # numOfDistancePoints = 0 # # for vert in verts: # # if vert[2] != 0: # # sumOfVerts += vert[2] # # numOfDistancePoints += 1 # # avg_distance = sumOfVerts/numOfDistancePoints # # except: # # pass # # print("AVERAGE DISTANCE:", avg_distance) # size = height*width*distance # I made up the these units to calculate size of object print("height:", height, "width:", width) #print("size:", size) #distance = str(distance) draw_objects(ImageDraw.Draw(image), objs, labels, distance) if (obj.id == 15): # geese date_string = datetime.datetime.now().strftime( "%Y-%m-%d-%H:%M:%S") open_cv_image = array(image) #open_cv_image = open_cv_image[:, :, ::-1] cv2.imwrite("images/" + str(date_string) + ".jpg", open_cv_image) file = open("text_logs/geese.txt", "a") #file.write("TIME:" + str(date_string) + " SIZE: " + size + " DISTANCE: " + distance + "\n") file.close() break # this is to speed up code and only focus on one object #print("X center:", object_Xcenter, " Y center:", object_Ycenter) cease_fire(channel) if (object_id == 0): aim_turret(object_Xcenter, object_Ycenter, Motor1, Motor2) open_cv_image = array(image) # Convert RGB to BGR #open_cv_image = open_cv_image[:, :, ::-1] cv2.imshow("image", open_cv_image) #except Exception as e: #print(e) key = cv2.waitKey(1) if key == ord("q"): break Motor1.Stop() Motor2.Stop() print("done")
img = tf.image.resize(img, (300, 300), antialias=True) converted_image = tf.image.convert_image_dtype(img, tf.uint8)[tf.newaxis, ...] print(type(converted_image)) print(converted_image.shape) interpreter.set_tensor(input_details[0]['index'], converted_image) interpreter.invoke() # The function `get_tensor()` returns a copy of the tensor data. # Use `tensor()` in order to get a pointer to the tensor. labels = load_labels('coco_ssd_mobilenet/labelmap.txt') objs = detect.get_output(interpreter, 0.4) print('-------RESULTS--------') if not objs: print('No objects detected') for obj in objs: print(labels.get(obj.id, obj.id)) print(' id: ', obj.id) print(' score: ', obj.score) print(' bbox: ', obj.bbox) # if args.output: # image = image.convert('RGB') # draw_objects(ImageDraw.Draw(image), objs, labels) # image.save(args.output)
#if floating_model: #input_data = (np.float32(input_data) - input_mean) / input_std image = Image.fromarray(frame).convert('RGB') scale = detect.set_input(interpreter, image.size, lambda size: image.resize(size, Image.ANTIALIAS)) # Perform the actual detection by running the model with the image as input #interpreter.set_tensor(input_details[0]['index'],input_data) #t1 = cv2.getTickCount() interpreter.invoke() # Retrieve detection results #boxes = interpreter.get_tensor(output_details[0]['index'])[0] # Bounding box coordinates of detected objects #classes = interpreter.get_tensor(output_details[1]['index'])[0] # Class index of detected objects #scores = interpreter.get_tensor(output_details[2]['index'])[0] # Confidence of detected objects #num = interpreter.get_tensor(output_details[3]['index'])[0] # Total number of detected objects (inaccurate and not needed) objs = detect.get_output(interpreter, min_conf_threshold, scale) # Loop over all detections and draw detection box if confidence is above minimum threshold for obj in objs: if ((obj.score > min_conf_threshold) and (obj.score <= 1.0)): print('Detected {}'.format(labels[int(obj.id)])) # Get bounding box coordinates and draw box # Interpreter can return coordinates that are outside of image dimensions, need to force them to be within image using max() and min() ymin = int(max(1, (obj.bbox.ymin))) xmin = int(max(1, (obj.bbox.xmin))) ymax = int(min(imH, (obj.bbox.ymax))) xmax = int(min(imW, (obj.bbox.xmax))) cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (10, 255, 0), 2) # Draw label object_name = labels[int(