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 detect_classes(interpreter, image, input_details, output_details, img):
image2 = image.copy()
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
image = image.resize((width, height))
# add N dim
input_data = np.expand_dims(image, axis=0)
scale = detect.set_input(interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
interpreter.invoke()
tensor = interpreter.tensor(interpreter.get_output_details()[3]['index'])()
count = int(np.squeeze(tensor))
tensor = interpreter.tensor(interpreter.get_output_details()[1]['index'])()
class_id = np.squeeze(tensor)
tensor = interpreter.tensor(interpreter.get_output_details()[0]['index'])()
box = np.squeeze(tensor)
tensor = interpreter.tensor(interpreter.get_output_details()[2]['index'])()
Probability = np.squeeze(tensor)
# print(interpreter.tensor(16)())
labels = load_labels(label_file)
_, height, width, _ = interpreter.get_input_details()[0]['shape']
image = image.convert('RGB')
retstr = []
net_w, net_h = 300, 300
x_offset, x_scale = (net_w - net_w) / 2. / net_w, float(net_w) / net_w
y_offset, y_scale = (net_h - net_h) / 2. / net_h, float(net_h) / net_h
for i in range(count):
if Probability[i] > 0.50:
box[i][0] = int((box[i][0] - x_offset) / x_scale * width)
box[i][2] = int((box[i][2] - x_offset) / x_scale * width)
box[i][1] = int((box[i][1] - y_offset) / y_scale * height)
box[i][3] = int((box[i][3] - y_offset) / y_scale * height)
retstr.append("Class : {} , Probability : {}.".format(
labels[int(class_id[i])], Probability[i]))
print("Class : {} , Probability : {} , Bounding_box : {} ".format(
labels[int(class_id[i])], Probability[i], box[i]))
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 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 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 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 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 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 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 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)
print("{} - found objects:".format(fname))
for j in range(n_obj):
cl_id = int(classes[i][j]) + 1
label = cl_id
score = scores[i][j]
if score < 0.5:
continue
box = boxes[i][j]
print(" ", cl_id, label, score, box)
ip = lite.Interpreter(model_path=model_path)
ip.allocate_tensors()
image = Image.open('/Users/xiao/inference_edge_tpu/a1_4.png')
scale = detect.set_input(ip, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
# inp_id = ip.get_input_details()[0]["index"]
# out_det = ip.get_output_details()
# out_id0 = out_det[0]["index"]
# out_id1 = out_det[1]["index"]
# out_id2 = out_det[2]["index"]
# out_id3 = out_det[3]["index"]
# img = get_mobilenet_input('/Users/xiao/inference_edge_tpu/a1_4.png', is_quant=is_quant)
# print(img.shape)
# ip.set_tensor(inp_id, img)
# ip.invoke()
# boxes = ip.get_tensor(out_id0)
# classes = ip.get_tensor(out_id1)
# scores = ip.get_tensor(out_id2)
# num_det = ip.get_tensor(out_id3)
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',
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 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():
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():
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():
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 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")
while (True):
data["Cycle Time"] = ((time.perf_counter() - loop_start_time) * 1000,
"ms")
loop_start_time = time.perf_counter()
start = time.perf_counter()
frame = cap.read()
data["Capture time"] = ((time.perf_counter() - loop_start_time) * 1000,
"ms")
start = time.perf_counter()
image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
size = (image.shape[1], image.shape[0])
scale = detect.set_input(
interpreter, size, lambda size: cv2.resize(
image, size, interpolation=cv2.INTER_NEAREST))
data["Scaling time"] = ((time.perf_counter() - start) * 1000, "ms")
start = time.perf_counter()
interpreter.invoke()
objs = detect.get_output(interpreter, 0.4, scale)
data["Inference time"] = ((time.perf_counter() - start) * 1000, "ms")
start = time.perf_counter()
center_v = 240
center_h = 320
max_score = 0
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')
