def main():
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=1) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
# Generate text to display on streamer
text = "FLiR Lepton"
streamer.send_data(frame_value, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
dm = DetectionManager()
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video, \
edgeiq.Streamer() as streamer:
time.sleep(2.0)
fps.start()
while True:
image = video.read()
(image, text) = dm.update(image)
streamer.send_data(image, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def _run_detection(self):
obj_detect = edgeiq.ObjectDetection(self._model_id)
obj_detect.load(engine=self._engine)
print("Loaded model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
with edgeiq.WebcamVideoStream(cam=self.idx) as video_stream:
# Allow Webcam to warm up
time.sleep(2.0)
self._fps.start()
while True:
frame = video_stream.read()
if self._stop_event.is_set():
break
results = obj_detect.detect_objects(frame, confidence_level=.5)
frame = edgeiq.markup_image(frame,
results.predictions,
colors=obj_detect.colors)
output_results = {
"idx": self.idx,
"frame": frame,
"results": results,
"model_id": obj_detect.model_id
}
self._results_q.put(output_results)
self._fps.update()
def main():
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
check_posture = CheckPosture()
# loop detection
while True:
frame = video_stream.read()
frame, text = check_posture.update(frame)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def write_data(data):
writer.write = True
writer.text = 'Data Collection Started!'
time.sleep(0.5)
print('start signal received')
file_name = file_set_up("video")
with edgeiq.WebcamVideoStream(cam=0) as video_stream, edgeiq.VideoWriter(
file_name, fps=SAMPLE_RATE) as video_writer:
if SAMPLE_RATE > video_stream.fps:
raise RuntimeError(
"Sampling rate {} cannot be greater than the camera's FPS {}".
format(SAMPLE_RATE, video_stream.fps))
time.sleep(2.0)
print('Data Collection Started!')
while True:
t_start = time.time()
frame = video_stream.read()
video_writer.write_frame(frame)
t_end = time.time() - t_start
t_wait = (1 / SAMPLE_RATE) - t_end
if t_wait > 0:
time.sleep(t_wait)
if not writer.write:
writer.text = 'Data Collection Ended'
time.sleep(0.5)
print('Data Collection Ended')
break
def main():
pose_estimator = edgeiq.PoseEstimation("alwaysai/human-pose")
pose_estimator.load(
engine=edgeiq.Engine.DNN_OPENVINO,
accelerator=edgeiq.Accelerator.MYRIAD)
print("Loaded model:\n{}\n".format(pose_estimator.model_id))
print("Engine: {}".format(pose_estimator.engine))
print("Accelerator: {}\n".format(pose_estimator.accelerator))
fps = edgeiq.FPS()
server_comm = ServerComm()
server_comm.setup()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream:
time.sleep(2.0)
fps.start()
while True:
frame = video_stream.read()
server_comm.send_frame(frame)
fps.update()
finally:
fps.stop()
def main():
fps = edgeiq.FPS()
detector = edgeiq.AprilTagDetector(edgeiq.AprilTagFamily.TAG_16h5)
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
text = []
frame = video_stream.read()
detections = detector.detect(frame)
for detection in detections:
frame = detection.markup_image(frame, tag_id=True)
text.append(detection.tag_id)
text.append(fps.compute_fps())
streamer.send_data(frame, text)
if streamer.check_exit():
break
fps.update()
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
# load the configuration data from config.json
config = load_json(CONFIG_FILE)
scale = config.get(SCALE)
pose_estimator = edgeiq.PoseEstimation("alwaysai/human-pose")
pose_estimator.load(engine=edgeiq.Engine.DNN,
accelerator=edgeiq.Accelerator.CPU)
print("Loaded model:\n{}\n".format(pose_estimator.model_id))
print("Engine: {}".format(pose_estimator.engine))
print("Accelerator: {}\n".format(pose_estimator.accelerator))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
posture = CheckPosture(scale)
# loop detection
while True:
frame = video_stream.read()
results = pose_estimator.estimate(frame)
# Generate text to display on streamer
text = ["Model: {}".format(pose_estimator.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
for ind, pose in enumerate(results.poses):
text.append("Person {}".format(ind))
text.append('-' * 10)
text.append("Key Points:")
# update the instance key_points to check the posture
posture.set_key_points(pose.key_points)
correct_posture = posture.correct_posture()
if not correct_posture:
text.append(posture.build_message())
# make a sound to alert the user to improper posture
print("\a")
streamer.send_data(results.draw_poses(frame), text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def _video_camera_stream(camera_id):
if camera_id is None:
# Default cam index
camera_id = 0
video_stream = edgeiq.WebcamVideoStream(cam=camera_id)
time.sleep(2.0)
return video_stream
def main():
#ardunio = serial.Serial('COM1', 115200, timeout = 1)
GPIO.setmode(GPIO.BCM)
buzzer = 23
GPIO.setup(buzzer, GPIO.OUT)
obj_detect = edgeiq.ObjectDetection("alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN_OPENVINO)
print("Loaded model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.5)
predictions = edgeiq.filter_predictions_by_label(
results.predictions, ["bottle"])
frame = edgeiq.markup_image(frame,
results.predictions,
show_confidences=False,
colors=obj_detect.colors)
# Generate text to display on streamer
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("Objects:")
for prediction in predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
GPIO.output(buzzer, GPIO.HIGH)
GPIO.input(buzzer)
sleep(0.5)
GPIO.output(buzzer, GPIO.LOW)
GPIO.input(buzzer)
sleep(0.5)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
semantic_segmentation = edgeiq.SemanticSegmentation(
"alwaysai/fcn_resnet18_pascal_voc_512x320")
semantic_segmentation.load(engine=edgeiq.Engine.DNN_CUDA,
accelerator=edgeiq.Accelerator.NVIDIA)
print("Loaded model:\n{}\n".format(semantic_segmentation.model_id))
print("Engine: {}".format(semantic_segmentation.engine))
print("Accelerator: {}\n".format(semantic_segmentation.accelerator))
print("Labels:\n{}\n".format(semantic_segmentation.labels))
fps = edgeiq.FPS()
class_list = ['bottle']
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
frame = edgeiq.resize(frame, width=320)
results = semantic_segmentation.segment_image(frame)
object_map = semantic_segmentation.build_object_map(
results.class_map, class_list)
object_mask = semantic_segmentation.build_image_mask(
object_map)
# object_mask[np.where((object_mask==[0,0,0]).all(axis=2))] = [255,255,255]
# Generate text to display on streamer
text = ["Model: {}".format(semantic_segmentation.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("Legend:")
text.append(semantic_segmentation.build_legend())
blended = edgeiq.blend_images(frame, object_mask, alpha=0.5)
streamer.send_data(blended, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
label_defs = {}
obj_detect = edgeiq.ObjectDetection(
"alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN)
print("Loaded model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=1) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.5)
frame = edgeiq.markup_image(
frame, labelToString(label_defs, results.predictions), show_labels = False,
show_confidences = False, colors=obj_detect.colors,
line_thickness = 0)
frame = addNotes(frame, results.predictions)
# Generate text to display on streamer
text = ["Model: {}".format(obj_detect.model_id)]
text.append(
"Inference time: {:1.3f} s".format(results.duration))
text.append("Objects:")
text.append("fps:{:2.2f}".format(fps.compute_fps()))
for prediction in results.predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
text = "Facial Overlays with Dlib"
fps = edgeiq.FPS()
shape_predictor = "shape_predictor_68_face_landmarks.dat"
dlib_flm = facial_landmarks.Dlib_FLM(shape_predictor)
try:
with edgeiq.WebcamVideoStream(cam=0) as webcam, \
edgeiq.Streamer() as streamer:
# Allow webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = webcam.read()
resized_frame, gray_resized_frame = dlib_flm.image_preprocessor(frame)
facial_coordinates, rectangles = dlib_flm.detect_faces_shapes(gray_resized_frame)
left_eye = 0
right_eye = 0
for facial_coordinate in facial_coordinates:
for (name, (i, j)) in FACIAL_LANDMARKS_IDXS.items():
if name is 'left_eye':
left_eye = facial_coordinate[i:j]
#Uncoment if you want the patch on right eye as well.
#elif name is 'right_eye':
# right_eye = facial_coordinate[i:j]
leftEyeSize, leftEyeCenter = eye_size(left_eye)
#Uncoment if you want the patch on right eye as well.
#rightEyeSize, rightEyeCenter = eye_size(right_eye)
place_mustache(resized_frame, facial_coordinate)
#Uncoment if you want to place spectacles on the face.
#place_glasses(resized_frame, facial_coordinate)
place_eye_patch(resized_frame, leftEyeCenter, leftEyeSize)
#place_eye(resized_frame, rightEyeCenter, rightEyeSize)
streamer.send_data(resized_frame, text)
fps.update()
if streamer.check_exit():
break
finally:
# stop fps counter and display information
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main(camera, use_streamer, server_addr):
obj_detect = edgeiq.ObjectDetection("alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN)
print("Loaded model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
fps = edgeiq.FPS()
try:
streamer = None
if use_streamer:
streamer = edgeiq.Streamer().setup()
else:
streamer = CVClient(server_addr).setup()
with edgeiq.WebcamVideoStream(cam=camera) as video_stream:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.5)
frame = edgeiq.markup_image(frame,
results.predictions,
colors=obj_detect.colors)
# Generate text to display on streamer
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("Objects:")
for prediction in results.predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
if streamer is not None:
streamer.close()
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
# Set up object detection API
obj_detect = edgeiq.ObjectDetection(
"alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN)
# Set up rpi ports
GPIO.setmode(GPIO.BOARD)
GPIO.setup(LEFT_PORT, GPIO.OUT)
GPIO.setup(RIGHT_PORT, GPIO.OUT)
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.8) # Maybe filter the result to bottles or bags for demo?
image_Centering(results.predictions)
# Debug information
if(debug_On):
frame = edgeiq.markup_image(
frame, results.predictions, colors=obj_detect.colors)
# Generate text to display on streamer
text = ["Model: {}".format(obj_detect.model_id)]
text.append(
"Inference time: {:1.3f} s".format(results.duration))
text.append("Objects:")
for prediction in results.predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
streamer.send_data(frame, text)
fps.update()
time.sleep(FRAME_A_RATE)
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
def main():
obj_detect = edgeiq.ObjectDetection(
"alwaysai/res10_300x300_ssd_iter_140000")
obj_detect.load(engine=edgeiq.Engine.DNN)
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Model:\n{}\n".format(obj_detect.model_id))
centroid_tracker = edgeiq.CentroidTracker(deregister_frames=20,
max_distance=50)
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection and centroid tracker
while True:
frame = video_stream.read()
frame = edgeiq.resize(frame, width=400)
results = obj_detect.detect_objects(frame, confidence_level=.5)
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("Objects:")
objects = centroid_tracker.update(results.predictions)
# Update the label to reflect the object ID
predictions = []
for (object_id, prediction) in objects.items():
new_label = 'face {}'.format(object_id)
prediction.label = new_label
text.append(new_label)
predictions.append(prediction)
frame = edgeiq.markup_image(frame, predictions)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def start_detection(config,
did_start_callback,
enter_callback,
exit_callback,
did_end_object_callback,
should_log=True):
"""
Enable features dependent on config and pass callback down to actual detection functions
"""
global ENTER_CALLBACK
global EXIT_CALLBACK
ENTER_CALLBACK = enter_callback
EXIT_CALLBACK = exit_callback
print('alwaysai.py: start_detection: enter_callback: {}'.format(
ENTER_CALLBACK))
# Configs
od_config = alwaysai_configs.ObjectDetector(config)
ct_config = alwaysai_configs.CentroidTracker(config)
vs_config = alwaysai_configs.VideoStream(config)
od = object_detector(od_config.model_id)
t = edgeiq.CentroidTracker(deregister_frames=ct_config.deregister_frames,
max_distance=ct_config.max_distance)
en_zones_config = config.get('entry_zones', [])
ex_zones_config = config.get('exit_zones', [])
entry_zones = zones_from_config(en_zones_config)
exit_zones = zones_from_config(ex_zones_config)
vs = None
# print('alwaysai.py: start_detection: en_zones_config: {}'.format(en_zones_config))
# print('alwaysai.py: start_detection: entry_zones: {}'.format(entry_zones))
# Inits
if vs_config.mode == 'camera':
if should_log:
print('alwaysai.py: start_detection: enabling camera w/ id: {}'.
format(vs_config.camera_id))
vs = edgeiq.WebcamVideoStream(cam=vs_config.camera_id)
if vs_config.mode == 'file':
if should_log:
print('alwaysai.py: start_detection: reading from file')
vs = edgeiq.FileVideoStream(vs_config.filename, play_realtime=True)
enable_streamer = config.get('enable_streamer', False)
streamer = alwaysai_configs.DummyStreamer()
if enable_streamer:
print('alwaysai.py: start_detection: ENABLING streamer')
streamer = edgeiq.Streamer()
# Start
start_video_detection_with_streamer(vs, od_config, od, streamer, t,
entry_zones, exit_zones,
did_start_callback, did_detect,
did_end_object_callback)
def main():
text = "Facial Landmarks with Dlib"
fps = edgeiq.FPS()
shape_predictor = "shape_predictor_68_face_landmarks.dat"
dlib_flm = facial_landmarks.Dlib_FLM(shape_predictor)
try:
with edgeiq.WebcamVideoStream(cam=0) as webcam, \
edgeiq.Streamer() as streamer:
# Allow webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = webcam.read()
resized_frame, gray_resized_frame = dlib_flm.image_preprocessor(
frame)
facial_coordinates, rectangles = dlib_flm.detect_faces_shapes(
gray_resized_frame)
# Loop to markup resized_frame
for (i, rectangle) in enumerate(rectangles):
(x, y, w,
h) = dlib_flm.dlib_rectangle_to_cv_bondingbox(rectangle)
cv2.rectangle(resized_frame, (x, y), (x + w, y + h),
(0, 255, 0), 2)
cv2.putText(resized_frame, "Face #{}".format(i + 1),
(x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
for facial_coordinate in facial_coordinates:
for (x, y) in facial_coordinate:
cv2.circle(resized_frame, (x, y), 1, (255, 0, 0), -1)
streamer.send_data(resized_frame, text)
fps.update()
if streamer.check_exit():
break
finally:
# stop fps counter and display information
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
facial_detector = edgeiq.ObjectDetection(
"alwaysai/res10_300x300_ssd_iter_140000")
facial_detector.load(engine=edgeiq.Engine.DNN)
print("Engine: {}".format(facial_detector.engine))
print("Accelerator: {}\n".format(facial_detector.accelerator))
print("Model:\n{}\n".format(facial_detector.model_id))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as webcam, \
edgeiq.Streamer() as streamer:
# Allow webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = webcam.read()
# detect human faces
results = facial_detector.detect_objects(frame,
confidence_level=.5)
frame = edgeiq.markup_image(frame,
results.predictions,
colors=facial_detector.colors)
# Generate text to display on streamer
text = ["Model: {}".format(facial_detector.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("Faces:")
for prediction in results.predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
# stop fps counter and display information
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
pose_estimator = edgeiq.PoseEstimation("alwaysai/human-pose")
pose_estimator.load(engine=edgeiq.Engine.DNN_OPENVINO)
print("Loaded model:\n{}\n".format(pose_estimator.model_id))
print("Engine: {}".format(pose_estimator.engine))
print("Accelerator: {}\n".format(pose_estimator.accelerator))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = pose_estimator.estimate(frame)
pdict = dict()
myList = [None] * 15
# Generate text to display on streamer
text = ["Model: {}".format(pose_estimator.model_id)]
text.append(
"Inference time: {:1.3f} s".format(results.duration) +
"\nFPS: {:.2f}".format(fps.compute_fps()))
for ind, pose in enumerate(results.poses):
pdict["Person {}".format(ind)] = pose.key_points
df = pd.DataFrame(data=pdict,
index=pose.key_points,
columns=pdict)
print(df)
streamer.send_data(results.draw_poses(frame), text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=1) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
# HSV
frame_hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
frame_value = frame_hsv[:, :, 2]
# bilateral filter - edge-preserving image smoothing method
blurredBrightness = cv2.bilateralFilter(
frame_value, 9, 150, 150)
# Canny edge detector
thresh = 50
edges = cv2.Canny(blurredBrightness,
thresh,
thresh * 2,
L2gradient=True)
# Generate text to display on streamer
text = "Thermal Edge Detector"
streamer.send_data(edges, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def take_snapshot(data):
"""Takes a single snapshot and saves it.
"""
print('snapshot signal received')
file_name = file_set_up("image")
with edgeiq.WebcamVideoStream(cam=0) as video_stream, edgeiq.VideoWriter(
file_name, fps=SAMPLE_RATE) as video_writer:
time.sleep(2.0)
writer.text = 'Taking Snapshot'
time.sleep(1.0)
print('Taking Snapshot')
frame = video_stream.read()
video_writer.write_frame(frame)
writer.text = 'Snapshot Saved'
time.sleep(0.5)
print('Snapshot Saved')
def main():
fps = edgeiq.FPS()
try:
streamer = edgeiq.Streamer()
streamer.setup()
video_stream = edgeiq.WebcamVideoStream(
cam=0) # replace with FileVideoStream if need be
# Allow application to warm up
video_stream.start()
time.sleep(2.0)
fps.start()
text = [""]
# initialize Vaccine Trakcer
vaccine_tracker = VaccineTracker()
# loop detection
while True:
frame = video_stream.read()
vaccine_tracker.update(frame)
# draw the vaccination box in the frame
frame = edgeiq.markup_image(frame, [
edgeiq.ObjectDetectionPrediction(label="vaccination",
index=0,
box=vaccine_tracker.box,
confidence=100.00)
])
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
streamer.close()
video_stream.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main(camera, use_streamer, server_addr, stream_fps):
fps = edgeiq.FPS()
try:
streamer = None
if use_streamer:
streamer = edgeiq.Streamer().setup()
else:
streamer = CVClient(server_addr, stream_fps, sio).setup()
with edgeiq.WebcamVideoStream(cam=camera) as video_stream:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
prevModelChoice = None
while True:
if model_choice == "q":
print('Exiting program...')
if streamer is not None:
streamer.close()
fps.stop()
return
model = models[model_choice]
if model_choice != prevModelChoice and prevModelChoice is not None:
displayRuntimeStatistics(model)
frame = video_stream.read()
frame, text = runModel(model, frame, model_choice)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
if streamer is not None:
streamer.close()
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main(camera, use_streamer, server_addr, stream_fps):
fps = edgeiq.FPS()
try:
# initialize the streamer
if use_streamer:
streamer = edgeiq.Streamer().setup()
else:
streamer = CVClient(server_addr, stream_fps, sio, writer).setup()
with edgeiq.WebcamVideoStream(cam=camera) as video_stream:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
text = [""]
text.append(writer.text)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
if streamer is not None:
streamer.close()
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
obj_detect = edgeiq.ObjectDetection(
"alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN)
tracker = edgeiq.CentroidTracker(deregister_frames=30)
print("Loaded model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
prev_tracked_people = {}
logs = []
currentPeople = 0
# loop detection
while True:
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.5)
people = edgeiq.filter_predictions_by_label(results.predictions, ['person'])
tracked_people = tracker.update(people)
people = []
for (object_id, prediction) in tracked_people.items():
new_label = 'Person {}'.format(object_id)
prediction.label = new_label
people.append(prediction)
frame = edgeiq.markup_image(
frame, people, colors=obj_detect.colors)
new_entries = set(tracked_people) - set(prev_tracked_people)
for entry in new_entries:
save_snapshot(frame, entry)
logs.append('Person {} entered'.format(entry))
currentPeople += 1
new_exits = set(prev_tracked_people) - set(tracked_people)
for exit in new_exits:
logs.append('Person {} exited'.format(exit))
currentPeople -= 1
prev_tracked_people = dict(tracked_people)
# Generate text to display on streamer
text = ["Model: {}".format(obj_detect.model_id)]
text.append(
"Inference time: {:1.3f} s".format(results.duration))
text.append("Objects:")
for prediction in people:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
text.append('Current Occupancy:')
text += str(currentPeople)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def gen():
#Load in our machine learning models!
detector_config = {
"engine": edgeiq.Engine.DNN_OPENVINO,
"accelerator": edgeiq.Accelerator.MYRIAD
}
#Get the face detector:
facial_detector = edgeiq.ObjectDetection(
"alwaysai/res10_300x300_ssd_iter_140000")
facial_detector.load(**detector_config)
describe_model(facial_detector, "Face")
#Get the gender detector
gender_detector = edgeiq.Classification("alwaysai/gendernet")
gender_detector.load(**detector_config)
describe_model(gender_detector, "Gender")
#Get the age detector
age_detector = edgeiq.Classification("alwaysai/agenet")
age_detector.load(**detector_config)
describe_model(age_detector, "Age")
texts = ["No patient detected!"]
with edgeiq.WebcamVideoStream(cam=0) as webcam:
# loop detection
while True:
frame = webcam.read()
#Flip the image upside down bc of how we orient the camera
frame = np.flipud(frame)
# detect human faces
face_results = facial_detector.detect_objects(frame,
confidence_level=.5)
if len(face_results.predictions) > 0:
face = frame[face_results.predictions[0].box.
start_y:face_results.predictions[0].box.end_y,
face_results.predictions[0].box.
start_x:face_results.predictions[0].box.end_x]
#Detect gender and age
gender_results = gender_detector.classify_image(
face, confidence_level=.9)
age_results = age_detector.classify_image(face)
frame = blur_detections(frame, face_results.predictions)
# Find the index of highest confidence
if len(gender_results.predictions) > 0 and len(
age_results.predictions) > 0:
top_prediction1 = gender_results.predictions[0]
top_prediction2 = age_results.predictions[0]
texts = []
texts.append("Gender Classification:")
texts.append("{}, {:.1f}%".format(
top_prediction1.label,
top_prediction1.confidence * 100))
texts.append("Age Classification:")
texts.append("{}, {:.1f}%".format(
top_prediction2.label,
top_prediction2.confidence * 100))
else:
texts = ["No patient detected!"]
#HACK: Add a panel to the right side of the image
label_panel = np.zeros(
(frame.shape[0], frame.shape[1] // 2, frame.shape[2])) + 255
org_coords = [(frame.shape[0] // 15, i * frame.shape[1] // 10)
for i in range(1, 5)]
for i, text in enumerate(texts):
label_panel = imwrite(label_panel,
text,
org_coords[i],
thickness=1 + ((i % 2) == 0))
frame = np.concatenate((frame, label_panel), axis=1)
#Encode and deploy
ret, jpeg = cv2.imencode('.jpg', frame)
frame = jpeg.tobytes()
#yield frame
yield (b'\r\n--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
def main():
# if you would like to test an additional model, add one to the list below:
models = ["alwaysai/mobilenet_ssd", "alwaysai/ssd_inception_v2_coco_2018_01_28"]
# if you've added a model, add a new color in as a list of tuples in BGR format
# to make visualization easier (e.g. [(B, G, R)]).
colors = [[(66, 68, 179)], [(50, 227, 62)]]
detectors = []
# load all the models (creates a new object detector for each model)
for model in models:
# start up a first object detection model
obj_detect = edgeiq.ObjectDetection(model)
obj_detect.load(engine=edgeiq.Engine.DNN)
# track the generated object detection items by storing them in detectors
detectors.append(obj_detect)
# print the details of each model to the console
print("Model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
fps = edgeiq.FPS()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
text = [""]
# gather data from the all the detectors
for i in range(0, len(detectors)):
results = detectors[i].detect_objects(
frame, confidence_level=.5)
object_frame = edgeiq.markup_image(
frame, results.predictions, show_labels=False, colors=colors[i])
# for the first frame, overwrite the input feed
if i == 0:
display_frame = object_frame
else:
# otherwise, append the new marked-up frame to the previous one
display_frame = numpy.concatenate((object_frame, display_frame))
# append each prediction
for prediction in results.predictions:
text.append(
"Model {} detects {}: {:2.2f}%".format(detectors[i].model_id,
prediction.label, prediction.confidence * 100))
# send the image frame and the predictions for both
# prediction models to the output stream
streamer.send_data(display_frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
# The current frame index
frame_idx = 0
# The number of frames to skip before running detector
detect_period = 50
# if you would like to test an additional model, add one to the list below:
models = [
"alwaysai/ssd_mobilenet_v2_oidv4",
"alwaysai/ssd_inception_v2_coco_2018_01_28"
]
# include any labels that you wish to detect from any models (listed above in 'models') here in this list
detected_contraband = [
"Pen", "cell phone", "backpack", "book", "Book", "Ring binder",
"Headphones", "Calculator", "Mobile phone", "Telephone", "Microphone",
"Ipod", "Remote control"
]
# load all the models (creates a new object detector for each model)
detectors = []
for model in models:
# start up a first object detection model
obj_detect = edgeiq.ObjectDetection(model)
obj_detect.load(engine=edgeiq.Engine.DNN)
# track the generated object detection items by storing them in detectors
detectors.append(obj_detect)
# print the details of each model to the console
print("Model:\n{}\n".format(obj_detect.model_id))
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Labels:\n{}\n".format(obj_detect.labels))
tracker = edgeiq.CorrelationTracker(max_objects=5)
fps = edgeiq.FPS()
contraband_summary = ContrabandSummary()
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
predictions_to_markup = []
text = [""]
# only analyze every 'detect_period' frame (i.e. every 50th in original code)
if frame_idx % detect_period == 0:
# gather data from the all the detectors
for i in range(0, len(detectors)):
results = detectors[i].detect_objects(
frame, confidence_level=.2)
# Stop tracking old objects
if tracker.count:
tracker.stop_all()
# append each prediction
predictions = results.predictions
for prediction in predictions:
if (prediction.label.strip()
in detected_contraband):
contraband_summary.contraband_alert(
prediction.label, frame)
predictions_to_markup.append(prediction)
tracker.start(frame, prediction)
else:
# if there are objects being tracked, update the tracker with the new frame
if tracker.count:
# get the new predictions for the objects being tracked, used to markup the frame
predictions_to_markup = tracker.update(frame)
# mark up the frame with the predictions for the contraband objects
frame = edgeiq.markup_image(frame,
predictions_to_markup,
show_labels=True,
show_confidences=False,
colors=obj_detect.colors)
# send the collection of contraband detection points (string and video frame) to the streamer
text = contraband_summary.get_contraband_string()
streamer.send_data(frame, text)
frame_idx += 1
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
pose_estimator = edgeiq.PoseEstimation("alwaysai/human-pose")
pose_estimator.load(engine=edgeiq.Engine.DNN_OPENVINO,
accelerator=edgeiq.Accelerator.MYRIAD)
print("Loaded model:\n{}\n".format(pose_estimator.model_id))
print("Engine: {}".format(pose_estimator.engine))
print("Accelerator: {}\n".format(pose_estimator.accelerator))
fps = edgeiq.FPS()
y_letter = cv2.imread('letter_y.png')
m_letter = cv2.imread('m_letter.jpg')
c_letter = cv2.imread('c_letter.jpeg')
a_letter = cv2.imread('a_letter.jpg')
try:
with edgeiq.WebcamVideoStream(cam=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = pose_estimator.estimate(frame)
# Generate text to display on streamer
text = [""]
for ind, pose in enumerate(results.poses):
right_wrist_y = pose.key_points[4][1]
right_wrist_x = pose.key_points[4][0]
right_elbow_y = pose.key_points[3][1]
right_elbow_x = pose.key_points[3][0]
left_wrist_y = pose.key_points[7][1]
left_wrist_x = pose.key_points[7][0]
left_elbow_y = pose.key_points[6][1]
left_elbow_x = pose.key_points[6][0]
nose_y = pose.key_points[0][1]
nose_x = pose.key_points[0][0]
neck_y = pose.key_points[1][0]
if nose_y != -1 and neck_y != -1:
neck_distance = neck_y - nose_y
else:
neck_distance = 0
if right_wrist_y != -1 and left_wrist_y != -1 and nose_y != -1 and left_elbow_y != -1 and right_elbow_y != -1 and neck_distance > 0:
if right_wrist_y < nose_y and left_wrist_y < nose_y and right_wrist_x > right_elbow_x and left_wrist_x < left_elbow_x:
if right_wrist_y < (
nose_y -
neck_distance / 3.0) and left_wrist_y < (
nose_y - neck_distance / 3.0):
print("----------A!-------------")
overlay = edgeiq.resize(
a_letter, frame.shape[1], frame.shape[0],
False)
cv2.addWeighted(frame, 0.4, overlay, 0.6, 0,
frame)
continue
elif (nose_y - neck_distance) < right_wrist_y and (
nose_y - neck_distance) < left_wrist_y:
print("----------M!-------------")
overlay = edgeiq.resize(
m_letter, frame.shape[1], frame.shape[0],
False)
cv2.addWeighted(frame, 0.4, overlay, 0.6, 0,
frame)
continue
if right_wrist_y != -1 and left_wrist_y != -1 and nose_y != -1 and right_elbow_x and left_elbow_x and right_wrist_x and left_wrist_x:
if right_wrist_y < nose_y and left_wrist_y < nose_y and right_wrist_x < right_elbow_x and left_wrist_x > left_elbow_x:
print("----------Y!-------------")
overlay = edgeiq.resize(y_letter, frame.shape[1],
frame.shape[0], False)
cv2.addWeighted(frame, 0.4, overlay, 0.6, 0, frame)
continue
if left_wrist_x != -1 and nose_x != -1 and left_wrist_y != -1 and nose_y != -1 and right_wrist_y != -1 and nose_x != -1:
if right_wrist_x > nose_x and right_wrist_y < nose_y and left_wrist_x > nose_x:
print("----------C!-------------")
overlay = edgeiq.resize(c_letter, frame.shape[1],
frame.shape[0], False)
cv2.addWeighted(frame, 0.4, overlay, 0.6, 0, frame)
continue
streamer.send_data(results.draw_poses(frame), text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
