def __init__(self):
# client configuration
self.id = "waiting_room"
self.box = edgeiq.BoundingBox(0, 0, 1920, 1080)
self.server_event_url = "http://localhost:5001/" # configure as needed
self.chairs = { # configure as needed
# 'chair1': 1
}
self.capacity = 4 # configure as needed
# detection models
self.detector = self.load_model("alwaysai/yolov3")
self.mask_detector = self.load_model("<username>/<model_name>") # train and use your model here!
# labels of interest (used to filter predictions)
self.interest_items = {
"person": InterestItem(16, 42, "person", ["person"])
}
# tracker to associate object ids with predictions
self.centroid_tracker = edgeiq.CentroidTracker(deregister_frames=4, max_distance=130)
self.covid_event_log = {}
self.event_log = {}
self.send_setup()
def __init__(self):
self.id = "vaccination_area"
self._send_events = False
self.server_event_url = "http://localhost:5001/" # configure as needed
self._start_time = time.time()
# detection model
self.detector = self.load_model("alwaysai/yolov3")
self.centroid_tracker = edgeiq.CentroidTracker(
deregister_frames=4, max_distance=130) # configure as needed
# vaccination box
self.box = edgeiq.BoundingBox(1269, 187, 1920,
1080) # configure as needed
# for overall vaccination logic, configure as needed
self.current_ids = []
self.timestamp = None
self.total_vaccinations = 0
self.vaccination_time = 30
self.scheduled_vaccinations = 20
self.doses_per_vial = 10
self.last_apt = datetime.datetime.today().replace(hour=16, minute=45)
self.send_event(0)
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 detection_base(model, confidence, image_array):
detector = edgeiq.ObjectDetection(
model) # model example: "alwaysai/res10_300x300_ssd_iter_140000"
detector.load(engine=edgeiq.Engine.DNN)
centroid_tracker = edgeiq.CentroidTracker(deregister_frames=100,
max_distance=50)
results = detector.detect_objects(image_array,
confidence_level=confidence)
objects = centroid_tracker.update(results.predictions)
predictions = []
for (object_id, prediction) in objects.items():
prediction.label = "{}: {}".format(prediction.label, object_id)
predictions.append(prediction)
image = edgeiq.markup_image(image_array, predictions)
return image, results, None
def _centroid_tracker_from(config):
# print("alwaysai_helper.py: _centroid_tracker")
frames = config.get(CENTROID_FRAMES, 20)
distance = config.get(CENTROID_MAX, 50)
return edgeiq.CentroidTracker(deregister_frames=frames,
max_distance=distance)
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 main():
fps = edgeiq.FPS()
# Change parameter to alwaysai/human_pose_eyecloud to run the human pose model.
with edgeiq.EyeCloud('alwaysai/mobilenet_ssd_eyecloud'
) as camera, edgeiq.Streamer() as streamer:
fps.start()
centroid_tracker = edgeiq.CentroidTracker(deregister_frames=20, max_distance=100)
number=0
while True:
text = ["FPS:{}".format(fps.compute_fps())]
frame = camera.get_frame()
#print('image sequence = {}'.format(frame.sequence_index))
result = camera.get_model_result(confidence_level=0.9)
# Check for inferencing results.
if result:
#print('model sequence = {}'.format(result.sequence_index))
text.append("Model: {}".format(camera.model_id))
if camera.model_purpose == 'PoseEstimation':
frame = result.draw_poses(frame)
text.append("Inference time: {:1.3f} s".format(result.duration))
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))
elif camera.model_purpose == 'ObjectDetection':
#移除交并比过大的检测框
if(len(result.predictions)>1):
for i,prediction in enumerate(result.predictions):
for j in range((len(result.predictions)-1),i,-1):
#print("i：%s j：%s"%(i,j))
IOU=prediction.box.compute_overlap(result.predictions[j].box)
print(IOU)
if(IOU>0.3):
#print("距离过近")
result.predictions.pop()
#划定FOV有效检测区
for i,prediction in enumerate(result.predictions):
if(prediction.box.center[0]<500 or prediction.box.center[0]>1300):
result.predictions.pop(i)
#print("x：%s y：%s"%(prediction.box.center[0],prediction.box.center[1]))
objects = centroid_tracker.update(result.predictions)
text.append("Inference time: {:1.3f} s".format(result.duration))
text.append("Objects:")
for (object_id, prediction) in objects.items():
new_label = 'person {}'.format(object_id)
if(object_id+1>number):
number=object_id+1
prediction.label = new_label
text.append("{}: {:2.2f}%".format(prediction.label, prediction.confidence * 100))
result.predictions.append(prediction)
frame = edgeiq.markup_image(frame, result.predictions)
text.append("people pass: {}".format(number))
elif camera.model_purpose == 'Classification':
if len(result.predictions) > 0:
top_prediction = result.predictions[0]
text = "Classification: {}, {:.2f}%".format(
top_prediction.label,
top_prediction.confidence * 100)
else:
text = None
cv2.putText(frame, text, (5, 25), cv2.FONT_HERSHEY_SIMPLEX,
0.4, (0, 0, 255), 2)
cv2.rectangle(frame,(500,0),(1300,1080),(255,0,0), 2)
streamer.send_data(frame, text)
if streamer.check_exit():
break
fps.update()
print('fps = {}'.format(fps.compute_fps()))
def main():
# Spin up the object detector
obj_detect = edgeiq.ObjectDetection("alwaysai/" + OBJECT_DETECTION_MODEL)
obj_detect.load(engine=edgeiq.Engine.DNN_CUDA,
accelerator=edgeiq.Accelerator.NVIDIA)
print("Engine: {}".format(obj_detect.engine))
print("Accelerator: {}\n".format(obj_detect.accelerator))
print("Model:\n{}\n".format(obj_detect.model_id))
print("Labels:\n{}\n".format(obj_detect.labels))
# Prepare to track frames per second calculations
fps = edgeiq.FPS()
# Load any prior instance of the tracker, otherwise spin up a new one
centroid_tracker = file_manager.load(
CENTROID_TRACKER,
edgeiq.CentroidTracker(deregister_frames=TRACKER_DEREGISTER_FRAMES,
max_distance=TRACKER_MAX_DISTANCE))
# Load any prior instance of the metrics data, otherwise start a new one
metrics = file_manager.load(METRICS_MANAGER,
metrics_manager.MetricsManager())
try:
if IP_CAMERA_FEED is not None:
stream_details = edgeiq.IPVideoStream(IP_CAMERA_FEED)
else:
stream_details = edgeiq.WebcamVideoStream(cam=0)
with stream_details 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:
metrics.newLoop()
frame = video_stream.read()
results = obj_detect.detect_objects(
frame, confidence_level=DETECT_CONFIDENCE_THRESHOLD)
# Ignore detections of anything other than people
filter = edgeiq.filter_predictions_by_label(
results.predictions, ['person'])
# Adding info for streamer display
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("People currently detected:")
objects = centroid_tracker.update(filter)
# Store active predictions for just this loop
predictions = []
# Store the active object ids for just this loop
if len(objects.items()) == 0:
# No people detected
text.append("-- NONE")
for (object_id, prediction) in objects.items():
metrics.addTimeFor(object_id)
timeForId = metrics.timeForId(object_id)
# Correcting for fact that index 0 is first object in an array
idAdjusted = object_id + 1
# Display text with bounding box in video
new_label = "Person {i} | {t} sec".format(i=idAdjusted,
t=timeForId)
prediction.label = new_label
text.append(new_label)
predictions.append(prediction)
# Add metrics to text going to streamer
m = metrics.currentMetrics()
text.append("") # Spacing
text.append("Total people seen: {}".format(m["count"]))
text.append("Total time: {} sec".format(m["total"]))
text.append("Average time: {0:.1f} sec".format(m["avg"]))
text.append("Longest individual time: {} sec".format(m["max"]))
# Update output streamer
frame = edgeiq.markup_image(frame, predictions)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
fps.stop()
# TODO: Update to save every few seconds in case a crash occurs
file_manager.save(metrics, METRICS_MANAGER)
file_manager.save(centroid_tracker, CENTROID_TRACKER)
print("elapsed time: {:.2f}".format(fps.get_elapsed_seconds()))
print("approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
#detects the object
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=0) as video_stream, \
edgeiq.Streamer() as streamer:
# Allow Webcam to warm up
time.sleep(2.0)
tracker = edgeiq.CentroidTracker(deregister_frames=20,
max_distance=50)
fps.start()
objects = {}
objectsCopy = {}
# loop detection
while True:
frame = video_stream.read()
frame = edgeiq.resize(frame, width=600)
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("Item Count:")
objectsCopy = objects.copy()
objects = tracker.update(results.predictions)
if len(objects) < len(objectsCopy):
for key in objects:
del objectsCopy[key]
for key in objectsCopy:
text.append(
("%s has been stolen!" %
objectsCopy[key].label).format(results.duration))
#if len(objects) < count:
# print('something left the frame')
#count = len(objects)
#predictions = []
#for (object_id, prediction) in objects.items():
# new_label = 'Object {}'.format(object_id)
# prediction.label = new_label
# text.append(new_label)
# predictions.append(prediction)
#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():
cam_type = os.environ.get('OPENNCC_CAM')
print(cam_type)
model_name = None
if cam_type is None:
model_name = "abhatikar/package_detector"
package_detector = edgeiq.ObjectDetection(model_name)
cam_type = os.environ.get('NCS2_CAM')
if cam_type is None:
cam_type = "webcam"
package_detector.load(engine=edgeiq.Engine.DNN)
else:
cam_type = "ncs2"
package_detector.load(engine=edgeiq.Engine.DNN_OPENVINO)
else:
cam_type = "openncc"
model_name = "abhatikar/package_detector_ncc"
# add a centroid tracker to see if a new package arrives
centroid_tracker = edgeiq.CentroidTracker(deregister_frames=10,
max_distance=50)
if cam_type is not "openncc":
# Descriptions printed to console
print("Engine: {}".format(package_detector.engine))
print("Accelerator: {}\n".format(package_detector.accelerator))
print("Model:\n{}\n".format(package_detector.model_id))
print("Labels:\n{}\n".format(package_detector.labels))
fps = edgeiq.FPS()
# Variables to limit inference
counter = 0
DETECT_RATE = 10
# Object to monitor the system
pm = PackageMonitor()
if cam_type is "openncc":
video_stream = edgeiq.EyeCloud(model_name).start()
else:
video_stream = edgeiq.WebcamVideoStream(cam=0).start()
try:
with edgeiq.Streamer() as streamer:
# Allow the camera to warm up
time.sleep(2.0)
fps.start()
# Loop detection
while True:
counter += 1
# Run this loop whenever there's a package detected or every DETECT_RATE frames
if pm.package_is_detected() or counter % DETECT_RATE == 0:
# Read in the video stream
if cam_type is "openncc":
frame = video_stream.get_frame()
# Check for packages in the new frame
package_results = video_stream.get_model_result(
confidence_level=.90)
else:
frame = video_stream.read()
# Check for packages in the new frame
package_results = package_detector.detect_objects(
frame, confidence_level=.90)
if package_results is not None:
# update the package predictions
objects = centroid_tracker.update(
package_results.predictions)
pm.set_packages(objects)
# Generate labels to display the face detections on the streamer
text = ["Model: {}".format(model_name)]
text.append("Inference time: {:1.3f} s".format(
package_results.duration))
predictions = []
# update labels for each identified package to print to the screen
for (object_id, prediction) in objects.items():
new_label = 'Package {}'.format(object_id)
prediction.label = new_label
text.append(new_label)
predictions.append(prediction)
# Alter the original frame mark up to show tracking labels
frame = edgeiq.markup_image(frame,
predictions,
show_labels=True,
show_confidences=False,
line_thickness=3,
font_size=1,
font_thickness=3)
# Do some action based on state
text.append(pm.action())
# Send the image frame and the predictions to the output stream
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
video_stream.stop()
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(self):
# This is code from the person-counter app
# TODO rework this to use a callback, observer-pattern, or generator
obj_detect = edgeiq.ObjectDetection("alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN_OPENVINO)
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()
# Object to store time info for detected people
allPeople = {}
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()
results = obj_detect.detect_objects(frame,
confidence_level=.5)
# Ignore detections of anything other than people
filter = edgeiq.filter_predictions_by_label(
results.predictions, ['person'])
# Adding info for streamer display
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("People currently detected:")
objects = centroid_tracker.update(filter)
# Store active predictions for just this loop
predictions = []
# Store the active object ids for just this loop
active_ids = []
if len(objects.items()) == 0:
# No people detected
text.append("-- NONE")
for (object_id, prediction) in objects.items():
seenTime = traffic_manager.timeSeenFor(
object_id, allPeople)
# Correct id displayed for start of array at index 0
actualPersonNumber = object_id + 1
# Display general data on person seen
new_label = "-- Person {i} | {t} sec".format(
i=actualPersonNumber, t=seenTime)
active_ids.append(object_id)
prediction.label = new_label
text.append(new_label)
predictions.append(prediction)
# Update output streamer
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_file_detection_and_tracking(delivery_object,
filter_for,
model_name,
filename,
detection_confidence=.5,
enable_streamer=True,
streamer_show_labels=True,
tracker_deregister_frames=20,
tracker_max_distance=50,
should_log=False):
"""Starts a detection loop"""
obj_detect = object_detector(model_name)
tracker = edgeiq.CentroidTracker(
deregister_frames=tracker_deregister_frames,
max_distance=tracker_max_distance)
fps = edgeiq.FPS()
try:
# Enables video camera and streamer
# TODO: add streamer disable feature here
with edgeiq.FileVideoStream(
filename) as video_stream, edgeiq.Streamer() as streamer:
# Start tracking of frames per second
fps.start()
# loop detection
while True:
frame = video_stream.read()
text = []
# Run detection
# detect human faces
results = obj_detect.detect_objects(
frame, confidence_level=detection_confidence)
# TODO: Add filter option here
frame = edgeiq.markup_image(frame,
results.predictions,
show_labels=streamer_show_labels)
# Generate text to display on streamer
text.append("Model: {}".format(obj_detect.model_id))
text.append("Inference time: {:1.3f} s".format(
results.duration))
predictions = []
objects = tracker.update(results.predictions)
# predictions = results.predictions
for (object_id, prediction) in objects.items():
# print(vars(prediction))
text.append("{}: {}: {:2.2f}%".format(
object_id, prediction.label,
prediction.confidence * 100))
predictions.append(prediction)
if delivery.should_send_image(object_id):
# Extract image
face_image = edgeiq.cutout_image(frame, prediction.box)
# Send data to server
delivery.send_image(object_id, prediction.label,
face_image)
elif delivery.should_send_data(object_id):
delivery.send_data(object_id, prediction.label)
# if delivery.should_send_data(object_id):
# delivery.send_data(object_id, prediction.label)
frame = edgeiq.markup_image(frame, predictions)
streamer.send_data(frame, text)
fps.update()
if streamer.check_exit():
break
finally:
# stop fps counter and display information
fps.stop()
if should_log == True:
print("[INFO] elapsed time: {:.2f}".format(
fps.get_elapsed_seconds()))
print("[INFO] approx. FPS: {:.2f}".format(fps.compute_fps()))
print("Program Ending")
def main():
obj_detect = edgeiq.ObjectDetection("alwaysai/mobilenet_ssd")
obj_detect.load(engine=edgeiq.Engine.DNN_OPENVINO)
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:
metrics_manager.newLoop()
frame = video_stream.read()
results = obj_detect.detect_objects(frame, confidence_level=.8)
# Ignore detections of anything other than people
filter = edgeiq.filter_predictions_by_label(
results.predictions, ['person'])
# Adding info for streamer display
text = ["Model: {}".format(obj_detect.model_id)]
text.append("Inference time: {:1.3f} s".format(
results.duration))
text.append("People currently detected:")
objects = centroid_tracker.update(filter)
# Store active predictions for just this loop
predictions = []
# Store the active object ids for just this loop
if len(objects.items()) == 0:
# No people detected
text.append("-- NONE")
for (object_id, prediction) in objects.items():
metrics_manager.addTimeFor(object_id)
timeForId = metrics_manager.timeForId(object_id)
# Correcting for fact that index 0 is first object in an array
idAdjusted = object_id + 1
# Display text with bounding box in video
new_label = "Person {i} | {t} sec".format(i=idAdjusted,
t=timeForId)
prediction.label = new_label
text.append(new_label)
predictions.append(prediction)
# Add metrics to text going to streamer
metrics = metrics_manager.currentMetrics()
text.append("") # Spacing
text.append("Total people seen: {}".format(metrics["count"]))
text.append("Total time: {} sec".format(metrics["total"]))
text.append("Average time: {0:.1f} sec".format(metrics["avg"]))
text.append("Longest individual time: {} sec".format(
metrics["max"]))
# Update output streamer
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")
