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(cam=0, video_file=None, debug=False):
if video_file is not None:
video_stream_class = edgeiq.FileVideoStream
kwargs = {'path': video_file, 'play_realtime': True}
else:
video_stream_class = edgeiq.WebcamVideoStream
kwargs = {'cam': cam}
edgeiq.WebcamVideoStream.more = lambda x: True
pose_estimator = edgeiq.PoseEstimation("alwaysai/human-pose")
if edgeiq.is_jetson():
pose_estimator.load(engine=edgeiq.Engine.TENSOR_RT)
else:
pose_estimator.load(engine=edgeiq.Engine.DNN)
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()
jj = JumpingJacksTracker()
try:
with video_stream_class(**kwargs) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while video_stream.more():
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))
if len(results.poses) > 0:
jj.update(results.poses[0])
else:
text.append('No poses found')
text.append("Jumping jacks: {}".format(jj.count))
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
if debug is True:
jj.save_history()
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=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 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 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 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():
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():
#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():
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 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():
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 __init__(self, camera_idx, engine, model_id, *args, **kwargs):
super().__init__(*args, **kwargs)
self.idx = camera_idx
self._engine = engine
self._model_id = model_id
self._results_q = CircularQueue(2)
self._stop_event = threading.Event()
self._prev_results = None
self._fps = edgeiq.FPS()
def get_components(config):
# print("alwaysai_helper.py: get_components")
fps = edgeiq.FPS()
fps.start()
obj_detector = object_detector_from(config)
streamer = streamer_from(config)
tracker = tracker_from(config)
video_stream = video_stream_from(config)
return {
FPS: fps,
OBJECT_DETECTOR: obj_detector,
STREAMER: streamer,
TRACKER: tracker,
VIDEO_STREAM: video_stream
}
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():
semantic_segmentation = edgeiq.SemanticSegmentation("alwaysai/enet")
semantic_segmentation.load(engine=edgeiq.Engine.DNN_CUDA)
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()
try:
with edgeiq.FileVideoStream('toronto.mp4', play_realtime=True) as video_stream, \
edgeiq.Streamer() as streamer: # play_realtime simulates video feed from a camera
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = video_stream.read()
results = semantic_segmentation.segment_image(frame)
# 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())
mask = semantic_segmentation.build_image_mask(
results.class_map)
blended = edgeiq.blend_images(frame, 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():
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 main():
"""Run object detector and centroid tracker."""
tracker = edgeiq.CorrelationTracker(
max_objects=5, enter_cb=face_enters, exit_cb=face_exits)
fps = edgeiq.FPS()
try:
with edgeiq.oak.Oak('alwaysai/face_detection_0200_oak',
sensor=edgeiq.Sensor.res_1080,
video_mode=edgeiq.VideoMode.preview) as oak_camera, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
fps.start()
# loop detection and tracking
while True:
frame = oak_camera.get_frame()
results = oak_camera.get_model_result(confidence_level=.6)
if results:
fps.update()
text = ["Faces Detected:"]
objects = tracker.update(results.predictions, frame)
# Update the label to reflect the object ID
predictions = []
for (object_id, prediction) in objects.items():
prediction.label = "face {}".format(object_id)
text.append("{}".format(prediction.label))
predictions.append(prediction)
text.append(("approx. FPS: {:.2f}".
format(fps.compute_fps())))
frame = edgeiq.markup_image(frame, predictions)
streamer.send_data(frame, text)
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("Program Ending")
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():
"""Run object detector."""
fps = edgeiq.FPS()
try:
with edgeiq.Oak('alwaysai/ssd_v2_coco_oak') as oak_camera,\
edgeiq.Streamer() as streamer:
# Allow Oak camera to warm up
time.sleep(2.0)
fps.start()
# loop detection
while True:
frame = oak_camera.get_frame()
results = oak_camera.get_model_result(confidence_level=.8)
if results:
fps.update()
text = ["Oak Camera Detections:"]
text.append("approx. FPS: {:.2f}".format(
fps.compute_fps()))
text.append("Objects:")
for prediction in results.predictions:
center = tuple(
int(round(val)) for val in prediction.box.center)
b, g, r = frame[center[1], center[0]]
cname = getColorName(r, g, b)
text.append("{}: {:2.2f}% color = {}".format(
prediction.label, prediction.confidence * 100,
cname))
# Mark up image for display
frame = edgeiq.markup_image(frame, results.predictions)
streamer.send_data(frame, text)
if streamer.check_exit():
break
finally:
fps.stop()
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("Program Ending")
def pose_estimation():
"""
Oak.get_model_result can return different results based on the purpose of the model running on the camera.
This function shows how to work with pose estimation models.
"""
fps = edgeiq.FPS()
with edgeiq.Oak('alwaysai/human_pose_oak') as camera, edgeiq.Streamer(
) as streamer:
fps.start()
while True:
text = ['FPS: {:2.2f}'.format(fps.compute_fps())]
frame = camera.get_frame()
result = camera.get_model_result()
# Check for inferencing results. Oak.get_model_result is a non-blocking call and will return None when new data is not available.
if result:
frame = result.draw_poses(frame)
text.append("Poses:")
for ind, pose in enumerate(result.poses):
text.append("Person {}".format(ind))
text.append('-' * 10)
text.append("Key Points:")
for key_point in pose.key_points:
text.append(str(key_point))
streamer.send_data(frame, text)
if streamer.check_exit():
break
fps.update()
print('fps = {}'.format(fps.compute_fps()))
def depth_stream():
"""
This function shows how to retrieve the depth stream from the camera.
"""
fps = edgeiq.FPS()
with Oak('alwaysai/mobilenet_ssd_oak',
capture_depth=True) as camera, edgeiq.Streamer() as streamer:
fps.start()
while True:
text = ['FPS: {:2.2f}'.format(fps.compute_fps())]
depth = camera.get_depth()
if depth is not None:
streamer.send_data(depth, text)
fps.update()
if streamer.check_exit():
break
print('fps = {}'.format(fps.compute_fps()))
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 object_detection():
"""
Oak.get_model_result can return different results based on the purpose of the model running on the camera.
This function shows how to work with object detection models.
"""
fps = edgeiq.FPS()
with edgeiq.Oak('alwaysai/mobilenet_ssd_oak') as camera, edgeiq.Streamer(
) as streamer:
fps.start()
while True:
text = ['FPS: {:2.2f}'.format(fps.compute_fps())]
frame = camera.get_frame()
result = camera.get_model_result(confidence_level=.75)
# Check for inferencing results. Oak.get_model_result is a non-blocking call and will return None when new data is not available.
if result:
frame = edgeiq.markup_image(frame, result.predictions)
text.append("Objects:")
for prediction in result.predictions:
text.append("{}: {:2.2f}%".format(
prediction.label, prediction.confidence * 100))
streamer.send_data(frame, text)
if streamer.check_exit():
break
fps.update()
print('fps = {}'.format(fps.compute_fps()))
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 fps_monitor():
return edgeiq.FPS()
