My Object Tracking script freezes when getting the outputQueue messages. Every time I try to run this script, it hangs with the last message being Start:: Getting messages.
Using Raspberry PI 4 and PoE Oak-1 Camera.
I have tried lowering the threadCount to 1, and lowering the outputQueue to 1, and adjusting the script to use tryGet() instead of get(). The RPI is staying under 20% CPU usage, and very little RAM usage.
This started happening after I added:
camRgb.setIspScale(2, 3) # 1080P -> 720P
camRgb.setVideoSize(W, H)
Changing the IspScale didn't seem to affect performance. Setting the video size was needed to get the preview in the right cropped location.
from pathlib import Path
import depthai as dai
import numpy as np
import time
import argparse
import json
import blobconverter
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument(
"-m",
"--model",
help="Provide model name or model path for inference",
default="best_openvino_2022.1_6shave.blob",
type=str,
)
parser.add_argument(
"-c",
"--config",
help="Provide config path for inference",
default="best_openvino_2022.1_6shave.json",
type=str,
)
parser.add_argument(
"-roi", "--roi_position", type=float, default=0.35, help="ROI Position (0-1)"
)
parser.add_argument(
"-a",
"--axis",
default=True,
action="store_true",
help="Axis for cumulative counting (default=y axis)",
)
args = parser.parse_args()
# parse config
configPath = Path(args.config)
if not configPath.exists():
raise ValueError("Path {} does not exist!".format(configPath))
with configPath.open() as f:
config = json.load(f)
nnConfig = config.get("nn_config", {})
# parse input shape
if "input_size" in nnConfig:
W, H = tuple(map(int, nnConfig.get("input_size").split("x")))
# extract metadata
metadata = nnConfig.get("NN_specific_metadata", {})
classes = metadata.get("classes", {})
coordinates = metadata.get("coordinates", {})
anchors = metadata.get("anchors", {})
anchorMasks = metadata.get("anchor_masks", {})
iouThreshold = metadata.get("iou_threshold", {})
confidenceThreshold = metadata.get("confidence_threshold", {})
print(metadata)
# parse labels
nnMappings = config.get("mappings", {})
labels = nnMappings.get("labels", {})
# get model path
nnPath = args.model
if not Path(nnPath).exists():
print("No blob found at {}.".format(nnPath))
nnPath = str(
blobconverter.from_zoo(args.model, shaves=6, zoo_type="depthai", use_cache=True)
)
# sync outputs
syncNN = True
# Create pipeline
pipeline = dai.Pipeline()
# Define sources and outputs
camRgb = pipeline.create(dai.node.ColorCamera)
camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
camRgb.setIspScale(2, 3) # 1080P -> 720P
detectionNetwork = pipeline.create(dai.node.YoloDetectionNetwork)
objectTracker = pipeline.create(dai.node.ObjectTracker)
previewOut = pipeline.create(dai.node.XLinkOut)
trackerOut = pipeline.create(dai.node.XLinkOut)
configIn = pipeline.create(dai.node.XLinkIn)
previewOut.setStreamName("preview")
trackerOut.setStreamName("tracklets")
configIn.setStreamName("config")
# Properties
camRgb.setInterleaved(False)
camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR)
camRgb.setFps(35)
camRgb.setVideoSize(W, H)
camRgb.setPreviewKeepAspectRatio(False)
camRgb.setPreviewSize(W, H)
print("SIZES:", camRgb.getVideoSize(), camRgb.getPreviewSize())
# Network specific settings
detectionNetwork.setConfidenceThreshold(confidenceThreshold)
detectionNetwork.setNumClasses(classes)
detectionNetwork.setCoordinateSize(coordinates)
detectionNetwork.setAnchors(anchors)
detectionNetwork.setAnchorMasks(anchorMasks)
detectionNetwork.setIouThreshold(iouThreshold)
detectionNetwork.setBlobPath(nnPath)
detectionNetwork.setNumInferenceThreads(2)
detectionNetwork.input.setBlocking(False)
objectTracker.setDetectionLabelsToTrack([0]) # track only person
# possible tracking types: ZERO_TERM_COLOR_HISTOGRAM, ZERO_TERM_IMAGELESS, SHORT_TERM_IMAGELESS, SHORT_TERM_KCF
objectTracker.setTrackerType(dai.TrackerType.ZERO_TERM_COLOR_HISTOGRAM)
# take the smallest ID when new object is tracked, possible options: SMALLEST_ID, UNIQUE_ID
objectTracker.setTrackerIdAssignmentPolicy(dai.TrackerIdAssignmentPolicy.UNIQUE_ID)
objectTracker.setTrackerThreshold(0.5)
# Linking
camRgb.preview.link(detectionNetwork.input)
objectTracker.passthroughTrackerFrame.link(previewOut.input)
configIn.out.link(camRgb.inputConfig)
camRgb.preview.link(objectTracker.inputTrackerFrame)
# detectionNetwork.passthrough.link(objectTracker.inputTrackerFrame)
detectionNetwork.passthrough.link(objectTracker.inputDetectionFrame)
detectionNetwork.out.link(objectTracker.inputDetections)
objectTracker.out.link(trackerOut.input)
# from https://www.pyimagesearch.com/2018/08/13/opencv-people-counter/
class TrackableObject:
def __init__(self, objectID, centroid):
# store the object ID, then initialize a list of centroids
# using the current centroid
self.objectID = objectID
self.centroids = [centroid]
# initialize a boolean used to indicate if the object has
# already been counted or not
self.counted = False
# Set initial count from counter.txt file
objectCounter = int(open("counter.txt", "r").read())
while True:
try:
# Connect to device and start pipeline
with dai.Device(pipeline) as device:
preview = device.getOutputQueue("preview", 4, False)
tracklets = device.getOutputQueue("tracklets", 4, False)
configQueue = device.getInputQueue("config")
# Max cropX & cropY
maxCropX = (
camRgb.getIspWidth() - camRgb.getVideoWidth()
) / camRgb.getIspWidth()
maxCropY = (
camRgb.getIspHeight() - camRgb.getVideoHeight()
) / camRgb.getIspHeight()
print(
"CROPS:",
maxCropX,
maxCropY,
camRgb.getIspWidth(),
camRgb.getVideoHeight(),
)
# Default crop
cropX = 0.275
cropY = 0.17
sendCamConfig = True
if sendCamConfig:
cfg = dai.ImageManipConfig()
cfg.setCropRect(cropX, cropY, maxCropX, maxCropY)
cfg.setResize(W, H)
cfg.setKeepAspectRatio(False)
configQueue.send(cfg)
print("crop - x: ", cropX, "crop - y: ", cropY)
sendCamConfig = False
startTime = time.monotonic()
counter = 0
fps = 0
trackableObjects = {}
frame = None
while True:
try:
print("Start:: Getting messages.")
imgFrame = preview.get()
print("Getting Tracklet messages.")
track = tracklets.get()
print("Done:: Getting messages.")
except RuntimeError as e:
print(f"Error Getting Image Frames: {str(e)}")
break
counter += 1
current_time = time.monotonic()
if (current_time - startTime) > 1:
fps = counter / (current_time - startTime)
counter = 0
startTime = current_time
color = (255, 0, 0)
frame = imgFrame.getCvFrame()
height = frame.shape[0]
width = frame.shape[1]
trackletsData = track.tracklets
for t in trackletsData:
to = trackableObjects.get(t.id, None)
# calculate centroid
roi = t.roi.denormalize(frame.shape[1], frame.shape[0])
x1 = int(roi.topLeft().x)
y1 = int(roi.topLeft().y)
x2 = int(roi.bottomRight().x)
y2 = int(roi.bottomRight().y)
centroid = (int((x2 - x1) / 2 + x1), int((y2 - y1) / 2 + y1))
newX = int((x2 - x1) / 2 + x1)
newY = int((y2 - y1) / 2 + y1)
# If new tracklet, save its centroid
if t.status == dai.Tracklet.TrackingStatus.NEW:
to = TrackableObject(t.id, centroid)
elif to is not None:
if not to.counted:
x = [c[0] for c in to.centroids]
direction = centroid[1] - np.mean(x)
if (
centroid[0] < args.roi_position * width
and direction < 0
and np.mean(x) > args.roi_position * width
):
objectCounter += 1
if objectCounter > 999999:
objectCounter = 0
open("counter.txt", "w").write(str(objectCounter))
to.counted = True
to.centroids.append(centroid)
trackableObjects[t.id] = to
except Exception as e:
print(f"Outer Loop Break. {str(e)}")
continue
