mirror of
https://github.com/blakeblackshear/frigate.git
synced 2025-09-26 19:41:29 +08:00
619 lines
25 KiB
Python
619 lines
25 KiB
Python
import datetime
|
|
import time
|
|
import threading
|
|
import queue
|
|
import itertools
|
|
from collections import defaultdict
|
|
import cv2
|
|
import imutils
|
|
import numpy as np
|
|
from scipy.spatial import distance as dist
|
|
import tflite_runtime.interpreter as tflite
|
|
from tflite_runtime.interpreter import load_delegate
|
|
|
|
def load_labels(path, encoding='utf-8'):
|
|
"""Loads labels from file (with or without index numbers).
|
|
Args:
|
|
path: path to label file.
|
|
encoding: label file encoding.
|
|
Returns:
|
|
Dictionary mapping indices to labels.
|
|
"""
|
|
with open(path, 'r', encoding=encoding) as f:
|
|
lines = f.readlines()
|
|
if not lines:
|
|
return {}
|
|
|
|
if lines[0].split(' ', maxsplit=1)[0].isdigit():
|
|
pairs = [line.split(' ', maxsplit=1) for line in lines]
|
|
return {int(index): label.strip() for index, label in pairs}
|
|
else:
|
|
return {index: line.strip() for index, line in enumerate(lines)}
|
|
|
|
def draw_box_with_label(frame, x_min, y_min, x_max, y_max, label, info, thickness=2, color=None, position='ul'):
|
|
if color is None:
|
|
color = (0,0,255)
|
|
display_text = "{}: {}".format(label, info)
|
|
cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), color, thickness)
|
|
font_scale = 0.5
|
|
font = cv2.FONT_HERSHEY_SIMPLEX
|
|
# get the width and height of the text box
|
|
size = cv2.getTextSize(display_text, font, fontScale=font_scale, thickness=2)
|
|
text_width = size[0][0]
|
|
text_height = size[0][1]
|
|
line_height = text_height + size[1]
|
|
# set the text start position
|
|
if position == 'ul':
|
|
text_offset_x = x_min
|
|
text_offset_y = 0 if y_min < line_height else y_min - (line_height+8)
|
|
elif position == 'ur':
|
|
text_offset_x = x_max - (text_width+8)
|
|
text_offset_y = 0 if y_min < line_height else y_min - (line_height+8)
|
|
elif position == 'bl':
|
|
text_offset_x = x_min
|
|
text_offset_y = y_max
|
|
elif position == 'br':
|
|
text_offset_x = x_max - (text_width+8)
|
|
text_offset_y = y_max
|
|
# make the coords of the box with a small padding of two pixels
|
|
textbox_coords = ((text_offset_x, text_offset_y), (text_offset_x + text_width + 2, text_offset_y + line_height))
|
|
cv2.rectangle(frame, textbox_coords[0], textbox_coords[1], color, cv2.FILLED)
|
|
cv2.putText(frame, display_text, (text_offset_x, text_offset_y + line_height - 3), font, fontScale=font_scale, color=(0, 0, 0), thickness=2)
|
|
|
|
def calculate_region(frame_shape, xmin, ymin, xmax, ymax, multiplier=2):
|
|
# size is larger than longest edge
|
|
size = int(max(xmax-xmin, ymax-ymin)*multiplier)
|
|
# if the size is too big to fit in the frame
|
|
if size > min(frame_shape[0], frame_shape[1]):
|
|
size = min(frame_shape[0], frame_shape[1])
|
|
|
|
# x_offset is midpoint of bounding box minus half the size
|
|
x_offset = int((xmax-xmin)/2.0+xmin-size/2.0)
|
|
# if outside the image
|
|
if x_offset < 0:
|
|
x_offset = 0
|
|
elif x_offset > (frame_shape[1]-size):
|
|
x_offset = (frame_shape[1]-size)
|
|
|
|
# y_offset is midpoint of bounding box minus half the size
|
|
y_offset = int((ymax-ymin)/2.0+ymin-size/2.0)
|
|
# if outside the image
|
|
if y_offset < 0:
|
|
y_offset = 0
|
|
elif y_offset > (frame_shape[0]-size):
|
|
y_offset = (frame_shape[0]-size)
|
|
|
|
return (x_offset, y_offset, x_offset+size, y_offset+size)
|
|
|
|
def intersection(box_a, box_b):
|
|
return (
|
|
max(box_a[0], box_b[0]),
|
|
max(box_a[1], box_b[1]),
|
|
min(box_a[2], box_b[2]),
|
|
min(box_a[3], box_b[3])
|
|
)
|
|
|
|
def area(box):
|
|
return (box[2]-box[0] + 1)*(box[3]-box[1] + 1)
|
|
|
|
def intersection_over_union(box_a, box_b):
|
|
# determine the (x, y)-coordinates of the intersection rectangle
|
|
intersect = intersection(box_a, box_b)
|
|
|
|
# compute the area of intersection rectangle
|
|
inter_area = max(0, intersect[2] - intersect[0] + 1) * max(0, intersect[3] - intersect[1] + 1)
|
|
|
|
if inter_area == 0:
|
|
return 0.0
|
|
|
|
# compute the area of both the prediction and ground-truth
|
|
# rectangles
|
|
box_a_area = (box_a[2] - box_a[0] + 1) * (box_a[3] - box_a[1] + 1)
|
|
box_b_area = (box_b[2] - box_b[0] + 1) * (box_b[3] - box_b[1] + 1)
|
|
|
|
# compute the intersection over union by taking the intersection
|
|
# area and dividing it by the sum of prediction + ground-truth
|
|
# areas - the interesection area
|
|
iou = inter_area / float(box_a_area + box_b_area - inter_area)
|
|
|
|
# return the intersection over union value
|
|
return iou
|
|
|
|
def clipped(obj, frame_shape):
|
|
# if the object is within 5 pixels of the region border, and the region is not on the edge
|
|
# consider the object to be clipped
|
|
box = obj[2]
|
|
region = obj[3]
|
|
if ((region[0] > 5 and box[0]-region[0] <= 5) or
|
|
(region[1] > 5 and box[1]-region[1] <= 5) or
|
|
(frame_shape[1]-region[2] > 5 and region[2]-box[2] <= 5) or
|
|
(frame_shape[0]-region[3] > 5 and region[3]-box[3] <= 5)):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def filtered(obj):
|
|
if obj[0] != 'person':
|
|
return True
|
|
return False
|
|
|
|
def create_tensor_input(frame, region):
|
|
cropped_frame = frame[region[1]:region[3], region[0]:region[2]]
|
|
|
|
# Resize to 300x300 if needed
|
|
if cropped_frame.shape != (300, 300, 3):
|
|
# TODO: use Pillow-SIMD?
|
|
cropped_frame = cv2.resize(cropped_frame, dsize=(300, 300), interpolation=cv2.INTER_LINEAR)
|
|
|
|
# Expand dimensions since the model expects images to have shape: [1, 300, 300, 3]
|
|
return np.expand_dims(cropped_frame, axis=0)
|
|
|
|
|
|
class MotionDetector():
|
|
# TODO: add motion masking
|
|
def __init__(self, frame_shape, resize_factor=4):
|
|
self.resize_factor = resize_factor
|
|
self.motion_frame_size = (int(frame_shape[0]/resize_factor), int(frame_shape[1]/resize_factor))
|
|
self.avg_frame = np.zeros(self.motion_frame_size, np.float)
|
|
self.avg_delta = np.zeros(self.motion_frame_size, np.float)
|
|
self.motion_frame_count = 0
|
|
self.frame_counter = 0
|
|
|
|
def detect(self, frame):
|
|
motion_boxes = []
|
|
|
|
# resize frame
|
|
resized_frame = cv2.resize(frame, dsize=(self.motion_frame_size[1], self.motion_frame_size[0]), interpolation=cv2.INTER_LINEAR)
|
|
|
|
# convert to grayscale
|
|
gray = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2GRAY)
|
|
|
|
# it takes ~30 frames to establish a baseline
|
|
# dont bother looking for motion
|
|
if self.frame_counter < 30:
|
|
self.frame_counter += 1
|
|
else:
|
|
# compare to average
|
|
frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(self.avg_frame))
|
|
|
|
# compute the average delta over the past few frames
|
|
# the alpha value can be modified to configure how sensitive the motion detection is.
|
|
# higher values mean the current frame impacts the delta a lot, and a single raindrop may
|
|
# register as motion, too low and a fast moving person wont be detected as motion
|
|
# this also assumes that a person is in the same location across more than a single frame
|
|
cv2.accumulateWeighted(frameDelta, self.avg_delta, 0.2)
|
|
|
|
# compute the threshold image for the current frame
|
|
current_thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
|
|
|
|
# black out everything in the avg_delta where there isnt motion in the current frame
|
|
avg_delta_image = cv2.convertScaleAbs(self.avg_delta)
|
|
avg_delta_image[np.where(current_thresh==[0])] = [0]
|
|
|
|
# then look for deltas above the threshold, but only in areas where there is a delta
|
|
# in the current frame. this prevents deltas from previous frames from being included
|
|
thresh = cv2.threshold(avg_delta_image, 25, 255, cv2.THRESH_BINARY)[1]
|
|
|
|
# dilate the thresholded image to fill in holes, then find contours
|
|
# on thresholded image
|
|
thresh = cv2.dilate(thresh, None, iterations=2)
|
|
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
|
|
cnts = imutils.grab_contours(cnts)
|
|
|
|
# loop over the contours
|
|
for c in cnts:
|
|
# if the contour is big enough, count it as motion
|
|
contour_area = cv2.contourArea(c)
|
|
if contour_area > 100:
|
|
# cv2.drawContours(resized_frame, [c], -1, (255,255,255), 2)
|
|
x, y, w, h = cv2.boundingRect(c)
|
|
motion_boxes.append((x*self.resize_factor, y*self.resize_factor, (x+w)*self.resize_factor, (y+h)*self.resize_factor))
|
|
|
|
if len(motion_boxes) > 0:
|
|
self.motion_frame_count += 1
|
|
# TODO: this really depends on FPS
|
|
if self.motion_frame_count >= 10:
|
|
# only average in the current frame if the difference persists for at least 3 frames
|
|
cv2.accumulateWeighted(gray, self.avg_frame, 0.2)
|
|
else:
|
|
# when no motion, just keep averaging the frames together
|
|
cv2.accumulateWeighted(gray, self.avg_frame, 0.2)
|
|
self.motion_frame_count = 0
|
|
|
|
return motion_boxes
|
|
|
|
class ObjectDetector():
|
|
def __init__(self, model_file, label_file):
|
|
self.labels = load_labels(label_file)
|
|
edge_tpu_delegate = None
|
|
try:
|
|
edge_tpu_delegate = load_delegate('libedgetpu.so.1.0')
|
|
except ValueError:
|
|
print("No EdgeTPU detected. Falling back to CPU.")
|
|
|
|
if edge_tpu_delegate is None:
|
|
self.interpreter = tflite.Interpreter(
|
|
model_path=model_file)
|
|
else:
|
|
self.interpreter = tflite.Interpreter(
|
|
model_path=model_file,
|
|
experimental_delegates=[edge_tpu_delegate])
|
|
|
|
self.interpreter.allocate_tensors()
|
|
|
|
self.tensor_input_details = self.interpreter.get_input_details()
|
|
self.tensor_output_details = self.interpreter.get_output_details()
|
|
|
|
def detect(self, tensor_input, threshold=.4):
|
|
self.interpreter.set_tensor(self.tensor_input_details[0]['index'], tensor_input)
|
|
self.interpreter.invoke()
|
|
boxes = np.squeeze(self.interpreter.get_tensor(self.tensor_output_details[0]['index']))
|
|
label_codes = np.squeeze(self.interpreter.get_tensor(self.tensor_output_details[1]['index']))
|
|
scores = np.squeeze(self.interpreter.get_tensor(self.tensor_output_details[2]['index']))
|
|
|
|
detections = []
|
|
for i, score in enumerate(scores):
|
|
label = self.labels[int(label_codes[i])]
|
|
|
|
if score < threshold:
|
|
break
|
|
|
|
detections.append((
|
|
label,
|
|
float(score),
|
|
boxes[i]
|
|
))
|
|
|
|
return detections
|
|
|
|
class ObjectTracker():
|
|
def __init__(self, max_disappeared):
|
|
self.tracked_objects = {}
|
|
self.disappeared = {}
|
|
self.max_disappeared = max_disappeared
|
|
|
|
def register(self, index, frame_time, obj):
|
|
id = f"{frame_time}-{index}"
|
|
obj['id'] = id
|
|
obj['frame_time'] = frame_time
|
|
obj['top_score'] = obj['score']
|
|
self.add_history(obj)
|
|
self.tracked_objects[id] = obj
|
|
self.disappeared[id] = 0
|
|
|
|
def deregister(self, id):
|
|
del self.tracked_objects[id]
|
|
del self.disappeared[id]
|
|
|
|
def update(self, id, new_obj):
|
|
self.disappeared[id] = 0
|
|
self.tracked_objects[id].update(new_obj)
|
|
self.add_history(self.tracked_objects[id])
|
|
if self.tracked_objects[id]['score'] > self.tracked_objects[id]['top_score']:
|
|
self.tracked_objects[id]['top_score'] = self.tracked_objects[id]['score']
|
|
|
|
def add_history(self, obj):
|
|
entry = {
|
|
'score': obj['score'],
|
|
'box': obj['box'],
|
|
'region': obj['region'],
|
|
'centroid': obj['centroid'],
|
|
'frame_time': obj['frame_time']
|
|
}
|
|
if 'history' in obj:
|
|
obj['history'].append(entry)
|
|
else:
|
|
obj['history'] = [entry]
|
|
|
|
def match_and_update(self, frame_time, new_objects):
|
|
if len(new_objects) == 0:
|
|
for id in list(self.tracked_objects.keys()):
|
|
if self.disappeared[id] >= self.max_disappeared:
|
|
self.deregister(id)
|
|
else:
|
|
self.disappeared[id] += 1
|
|
return
|
|
|
|
# group by name
|
|
new_object_groups = defaultdict(lambda: [])
|
|
for obj in new_objects:
|
|
new_object_groups[obj[0]].append({
|
|
'label': obj[0],
|
|
'score': obj[1],
|
|
'box': obj[2],
|
|
'region': obj[3]
|
|
})
|
|
|
|
# track objects for each label type
|
|
for label, group in new_object_groups.items():
|
|
current_objects = [o for o in self.tracked_objects.values() if o['label'] == label]
|
|
current_ids = [o['id'] for o in current_objects]
|
|
current_centroids = np.array([o['centroid'] for o in current_objects])
|
|
|
|
# compute centroids of new objects
|
|
for obj in group:
|
|
centroid_x = int((obj['box'][0]+obj['box'][2]) / 2.0)
|
|
centroid_y = int((obj['box'][1]+obj['box'][3]) / 2.0)
|
|
obj['centroid'] = (centroid_x, centroid_y)
|
|
|
|
if len(current_objects) == 0:
|
|
for index, obj in enumerate(group):
|
|
self.register(index, frame_time, obj)
|
|
return
|
|
|
|
new_centroids = np.array([o['centroid'] for o in group])
|
|
|
|
# compute the distance between each pair of tracked
|
|
# centroids and new centroids, respectively -- our
|
|
# goal will be to match each new centroid to an existing
|
|
# object centroid
|
|
D = dist.cdist(current_centroids, new_centroids)
|
|
|
|
# in order to perform this matching we must (1) find the
|
|
# smallest value in each row and then (2) sort the row
|
|
# indexes based on their minimum values so that the row
|
|
# with the smallest value is at the *front* of the index
|
|
# list
|
|
rows = D.min(axis=1).argsort()
|
|
|
|
# next, we perform a similar process on the columns by
|
|
# finding the smallest value in each column and then
|
|
# sorting using the previously computed row index list
|
|
cols = D.argmin(axis=1)[rows]
|
|
|
|
# in order to determine if we need to update, register,
|
|
# or deregister an object we need to keep track of which
|
|
# of the rows and column indexes we have already examined
|
|
usedRows = set()
|
|
usedCols = set()
|
|
|
|
# loop over the combination of the (row, column) index
|
|
# tuples
|
|
for (row, col) in zip(rows, cols):
|
|
# if we have already examined either the row or
|
|
# column value before, ignore it
|
|
if row in usedRows or col in usedCols:
|
|
continue
|
|
|
|
# otherwise, grab the object ID for the current row,
|
|
# set its new centroid, and reset the disappeared
|
|
# counter
|
|
objectID = current_ids[row]
|
|
self.update(objectID, group[col])
|
|
|
|
# indicate that we have examined each of the row and
|
|
# column indexes, respectively
|
|
usedRows.add(row)
|
|
usedCols.add(col)
|
|
|
|
# compute the column index we have NOT yet examined
|
|
unusedRows = set(range(0, D.shape[0])).difference(usedRows)
|
|
unusedCols = set(range(0, D.shape[1])).difference(usedCols)
|
|
|
|
# in the event that the number of object centroids is
|
|
# equal or greater than the number of input centroids
|
|
# we need to check and see if some of these objects have
|
|
# potentially disappeared
|
|
if D.shape[0] >= D.shape[1]:
|
|
for row in unusedRows:
|
|
id = current_ids[row]
|
|
|
|
if self.disappeared[id] >= self.max_disappeared:
|
|
self.deregister(id)
|
|
else:
|
|
self.disappeared[id] += 1
|
|
# if the number of input centroids is greater
|
|
# than the number of existing object centroids we need to
|
|
# register each new input centroid as a trackable object
|
|
else:
|
|
for col in unusedCols:
|
|
self.register(col, frame_time, group[col])
|
|
|
|
def main():
|
|
frames = 0
|
|
# frame_queue = queue.Queue(maxsize=5)
|
|
# frame_cache = {}
|
|
# frame_shape = (1080,1920,3)
|
|
frame_shape = (720,1280,3)
|
|
frame_size = frame_shape[0]*frame_shape[1]*frame_shape[2]
|
|
frame = np.zeros(frame_shape, np.uint8)
|
|
motion_detector = MotionDetector(frame_shape, resize_factor=4)
|
|
object_detector = ObjectDetector('/lab/mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite', '/lab/labelmap.txt')
|
|
# object_detector = ObjectDetector('/lab/detect.tflite', '/lab/labelmap.txt')
|
|
object_tracker = ObjectTracker(10)
|
|
|
|
# f = open('/debug/input/back.rgb24', 'rb')
|
|
f = open('/debug/back.raw_video', 'rb')
|
|
# f = open('/debug/ali-jake.raw_video', 'rb')
|
|
|
|
total_detections = 0
|
|
start = datetime.datetime.now().timestamp()
|
|
while True:
|
|
frame_detections = 0
|
|
frame_bytes = f.read(frame_size)
|
|
if not frame_bytes:
|
|
break
|
|
frame_time = datetime.datetime.now().timestamp()
|
|
|
|
# Store frame in numpy array
|
|
frame[:] = (np
|
|
.frombuffer(frame_bytes, np.uint8)
|
|
.reshape(frame_shape))
|
|
frames += 1
|
|
|
|
# look for motion
|
|
motion_boxes = motion_detector.detect(frame)
|
|
|
|
tracked_objects = object_tracker.tracked_objects.values()
|
|
|
|
# merge areas of motion that intersect with a known tracked object into a single area to look at
|
|
areas_of_interest = []
|
|
used_motion_boxes = []
|
|
for obj in tracked_objects:
|
|
x_min, y_min, x_max, y_max = obj['box']
|
|
for m_index, motion_box in enumerate(motion_boxes):
|
|
if area(intersection(obj['box'], motion_box))/area(motion_box) > .5:
|
|
used_motion_boxes.append(m_index)
|
|
x_min = min(obj['box'][0], motion_box[0])
|
|
y_min = min(obj['box'][1], motion_box[1])
|
|
x_max = max(obj['box'][2], motion_box[2])
|
|
y_max = max(obj['box'][3], motion_box[3])
|
|
areas_of_interest.append((x_min, y_min, x_max, y_max))
|
|
unused_motion_boxes = set(range(0, len(motion_boxes))).difference(used_motion_boxes)
|
|
|
|
# compute motion regions
|
|
motion_regions = [calculate_region(frame_shape, motion_boxes[i][0], motion_boxes[i][1], motion_boxes[i][2], motion_boxes[i][3], 1.2)
|
|
for i in unused_motion_boxes]
|
|
|
|
# compute tracked object regions
|
|
object_regions = [calculate_region(frame_shape, a[0], a[1], a[2], a[3], 1.2)
|
|
for a in areas_of_interest]
|
|
|
|
# merge regions with high IOU
|
|
merged_regions = motion_regions+object_regions
|
|
while True:
|
|
max_iou = 0.0
|
|
max_indices = None
|
|
region_indices = range(len(merged_regions))
|
|
for a, b in itertools.combinations(region_indices, 2):
|
|
iou = intersection_over_union(merged_regions[a], merged_regions[b])
|
|
if iou > max_iou:
|
|
max_iou = iou
|
|
max_indices = (a, b)
|
|
if max_iou > 0.1:
|
|
a = merged_regions[max_indices[0]]
|
|
b = merged_regions[max_indices[1]]
|
|
merged_regions.append(calculate_region(frame_shape,
|
|
min(a[0], b[0]),
|
|
min(a[1], b[1]),
|
|
max(a[2], b[2]),
|
|
max(a[3], b[3]),
|
|
1
|
|
))
|
|
del merged_regions[max(max_indices[0], max_indices[1])]
|
|
del merged_regions[min(max_indices[0], max_indices[1])]
|
|
else:
|
|
break
|
|
|
|
# resize regions and detect
|
|
detections = []
|
|
for region in merged_regions:
|
|
|
|
tensor_input = create_tensor_input(frame, region)
|
|
|
|
region_detections = object_detector.detect(tensor_input)
|
|
frame_detections += 1
|
|
|
|
for d in region_detections:
|
|
if filtered(d):
|
|
continue
|
|
box = d[2]
|
|
size = region[2]-region[0]
|
|
x_min = int((box[1] * size) + region[0])
|
|
y_min = int((box[0] * size) + region[1])
|
|
x_max = int((box[3] * size) + region[0])
|
|
y_max = int((box[2] * size) + region[1])
|
|
detections.append((
|
|
d[0],
|
|
d[1],
|
|
(x_min, y_min, x_max, y_max),
|
|
region))
|
|
|
|
#########
|
|
# merge objects, check for clipped objects and look again up to N times
|
|
#########
|
|
refining = True
|
|
refine_count = 0
|
|
while refining and refine_count < 4:
|
|
refining = False
|
|
|
|
# group by name
|
|
detected_object_groups = defaultdict(lambda: [])
|
|
for detection in detections:
|
|
detected_object_groups[detection[0]].append(detection)
|
|
|
|
selected_objects = []
|
|
for group in detected_object_groups.values():
|
|
|
|
# apply non-maxima suppression to suppress weak, overlapping bounding boxes
|
|
boxes = [(o[2][0], o[2][1], o[2][2]-o[2][0], o[2][3]-o[2][1])
|
|
for o in group]
|
|
confidences = [o[1] for o in group]
|
|
idxs = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
|
|
|
|
for index in idxs:
|
|
obj = group[index[0]]
|
|
if clipped(obj, frame_shape): #obj['clipped']:
|
|
box = obj[2]
|
|
# calculate a new region that will hopefully get the entire object
|
|
region = calculate_region(frame_shape,
|
|
box[0], box[1],
|
|
box[2], box[3])
|
|
|
|
tensor_input = create_tensor_input(frame, region)
|
|
# run detection on new region
|
|
refined_detections = object_detector.detect(tensor_input)
|
|
frame_detections += 1
|
|
for d in refined_detections:
|
|
if filtered(d):
|
|
continue
|
|
box = d[2]
|
|
size = region[2]-region[0]
|
|
x_min = int((box[1] * size) + region[0])
|
|
y_min = int((box[0] * size) + region[1])
|
|
x_max = int((box[3] * size) + region[0])
|
|
y_max = int((box[2] * size) + region[1])
|
|
selected_objects.append((
|
|
d[0],
|
|
d[1],
|
|
(x_min, y_min, x_max, y_max),
|
|
region))
|
|
|
|
refining = True
|
|
else:
|
|
selected_objects.append(obj)
|
|
|
|
# set the detections list to only include top, complete objects
|
|
# and new detections
|
|
detections = selected_objects
|
|
|
|
if refining:
|
|
refine_count += 1
|
|
|
|
# now that we have refined our detections, we need to track objects
|
|
object_tracker.match_and_update(frame_time, detections)
|
|
|
|
total_detections += frame_detections
|
|
|
|
# if (frames >= 700 and frames <= 1635) or (frames >= 2500):
|
|
# if (frames >= 700 and frames <= 1000):
|
|
# if (frames >= 0):
|
|
# # row1 = cv2.hconcat([gray, cv2.convertScaleAbs(avg_frame)])
|
|
# # row2 = cv2.hconcat([frameDelta, thresh])
|
|
# # cv2.imwrite(f"/lab/debug/output/{frames}.jpg", cv2.vconcat([row1, row2]))
|
|
# # # cv2.imwrite(f"/lab/debug/output/resized-frame-{frames}.jpg", resized_frame)
|
|
# # for region in motion_regions:
|
|
# # cv2.rectangle(frame, (region[0], region[1]), (region[2], region[3]), (255,128,0), 2)
|
|
# # for region in object_regions:
|
|
# # cv2.rectangle(frame, (region[0], region[1]), (region[2], region[3]), (0,128,255), 2)
|
|
# for region in merged_regions:
|
|
# cv2.rectangle(frame, (region[0], region[1]), (region[2], region[3]), (0,255,0), 2)
|
|
# for box in motion_boxes:
|
|
# cv2.rectangle(frame, (box[0], box[1]), (box[2], box[3]), (255,0,0), 2)
|
|
# for detection in detections:
|
|
# box = detection[2]
|
|
# draw_box_with_label(frame, box[0], box[1], box[2], box[3], detection[0], f"{detection[1]*100}%")
|
|
# for obj in object_tracker.tracked_objects.values():
|
|
# box = obj['box']
|
|
# draw_box_with_label(frame, box[0], box[1], box[2], box[3], obj['label'], obj['id'], thickness=1, color=(0,0,255), position='bl')
|
|
# cv2.putText(frame, str(total_detections), (10, 10), cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(0, 0, 0), thickness=2)
|
|
# cv2.putText(frame, str(frame_detections), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(0, 0, 0), thickness=2)
|
|
# cv2.imwrite(f"/lab/debug/output/frame-{frames}.jpg", frame)
|
|
# break
|
|
|
|
duration = datetime.datetime.now().timestamp()-start
|
|
print(f"Processed {frames} frames for {duration:.2f} seconds and {(frames/duration):.2f} FPS.")
|
|
print(f"Total detections: {total_detections}")
|
|
|
|
if __name__ == '__main__':
|
|
main() |