Update SDK experiments

Author: daniilpastukhov

gen2-blur-faces/sdk/main.py

@@ -0,0 +1,49 @@
+import cv2
+import numpy as np
+
+from depthai_sdk import OakCamera
+
+NN_WIDTH, NN_HEIGHT = 300, 300
+
+
+def callback(packet, visualizer):
+    frame = packet.frame
+
+    for det in packet.detections:
+        # Expand the bounding box
+        x1, y1, x2, y2 = det.top_left[0], det.top_left[1], det.bottom_right[0], det.bottom_right[1]
+        x1 *= 0.8
+        y1 *= 0.8
+        x2 *= 1.2
+        y2 *= 1.2
+
+        bbox = np.int0([x1, y1, x2, y2])
+
+        face = frame[bbox[1]:bbox[3], bbox[0]:bbox[2]]
+        fh, fw, fc = face.shape
+        frame_h, frame_w, frame_c = frame.shape
+
+        # Create blur mask around the face
+        mask = np.zeros((frame_h, frame_w), np.uint8)
+        polygon = cv2.ellipse2Poly((bbox[0] + int(fw / 2), bbox[1] + int(fh / 2)), (int(fw / 2), int(fh / 2)), 0, 0,
+                                   360, delta=1)
+        cv2.fillConvexPoly(mask, polygon, 255)
+
+        frame_copy = frame.copy()
+        frame_copy = cv2.blur(frame_copy, (80, 80))
+        face_extracted = cv2.bitwise_and(frame_copy, frame_copy, mask=mask)
+        background_mask = cv2.bitwise_not(mask)
+        background = cv2.bitwise_and(frame, frame, mask=background_mask)
+        # Blur the face
+        frame = cv2.add(background, face_extracted)
+
+    cv2.imshow('Face blurring', frame)
+
+
+with OakCamera() as oak:
+    color = oak.create_camera('color', fps=30)
+    det_nn = oak.create_nn('face-detection-retail-0004', color)
+    det_nn.config_nn(aspect_ratio_resize_mode='letterbox')
+
+    oak.callback(det_nn, callback=callback)
+    oak.start(blocking=True)

gen2-blur-faces/sdk/requirements.txt

@@ -0,0 +1,5 @@
+opencv-python
+depthai
+depthai-sdk
+numpy
+blobconverter

gen2-class-saver-jpeg/sdk/main.py

@@ -0,0 +1,68 @@
+import csv
+import time
+from pathlib import Path
+
+import cv2
+from depthai_sdk import OakCamera
+
+labels = ['background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
+          'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+
+# Create data folder
+Path('data').mkdir(parents=True, exist_ok=True)
+
+
+def create_folders():
+    Path(f'data/raw').mkdir(parents=True, exist_ok=True)
+    for text in labels:
+        Path(f'data/{text}').mkdir(parents=True, exist_ok=True)
+
+
+def callback(packet, visualizer):
+    original_frame = packet.frame
+
+    timestamp = int(time.time() * 10000)
+    raw_frame_path = f'data/raw/{timestamp}.jpg'
+    cv2.imwrite(raw_frame_path, original_frame)
+
+    frame = visualizer.draw(original_frame.copy())
+
+    for detection in packet.detections:
+        bbox = (*detection.top_left, *detection.bottom_right)
+
+        det_frame = original_frame[bbox[1]:bbox[3], bbox[0]:bbox[2]]
+
+        cropped_path = f'data/{detection.label}/{timestamp}_cropped.jpg'
+        overlay_path = f'data/{detection.label}/{timestamp}_overlay.jpg'
+
+        cv2.imwrite(cropped_path, det_frame)
+        cv2.imwrite(overlay_path, frame)
+
+        data = {
+            'timestamp': timestamp,
+            'label': detection.label,
+            'left': bbox[0],
+            'top': bbox[1],
+            'right': bbox[2],
+            'bottom': bbox[3],
+            'raw_frame': raw_frame_path,
+            'overlay_frame': overlay_path,
+            'cropped_frame': cropped_path,
+        }
+        dataset.writerow(data)
+
+    cv2.imshow('Class saver', frame)
+
+
+with OakCamera() as oak, open('data/dataset.csv', 'w') as csvfile:
+    create_folders()
+
+    dataset = csv.DictWriter(csvfile, ['timestamp', 'label', 'left', 'top', 'right', 'bottom',
+                                       'raw_frame', 'overlay_frame', 'cropped_frame'])
+    dataset.writeheader()
+
+    color = oak.create_camera('color')
+    nn = oak.create_nn('mobilenet-ssd', color)
+
+    oak.visualize(nn.out.main, callback=callback, fps=True)
+    oak.start(blocking=True)

gen2-class-saver-jpeg/sdk/requirements.txt

@@ -0,0 +1,3 @@
+opencv-python
+depthai
+blobconverter

gen2-container-encoding/sdk/main.py

@@ -0,0 +1,7 @@
+from depthai_sdk import OakCamera
+
+with OakCamera() as oak:
+    color = oak.create_camera('color', resolution='4K', encode='h264')
+    oak.record(color.out.main, path='records')
+
+    oak.start(blocking=True)

gen2-container-encoding/sdk/requirements.txt

@@ -0,0 +1,3 @@
+av
+depthai
+depthai-sdk

gen2-crowdcounting/sdk/main.py

@@ -0,0 +1,32 @@
+import cv2
+import numpy as np
+
+from depthai_sdk import OakCamera
+
+NN_WIDTH = 426
+NN_HEIGHT = 240
+
+
+def callback(packet, visualizer):
+    nn_data = packet.img_detections
+    lay1 = np.array(nn_data.getFirstLayerFp16()).reshape((30, 52))  # density map output is 1/8 of input size
+    count = np.sum(lay1)  # predicted count is the sum of the density map
+    cv2.putText(packet.frame, f'Predicted count: {count:.2f}', (2, 30),
+                cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 2)
+
+    output = np.array(lay1) * 255
+    output = output.astype(np.uint8)
+    output_colors = cv2.applyColorMap(output, cv2.COLORMAP_VIRIDIS)
+    output_colors = cv2.resize(output_colors, (packet.frame.shape[1], packet.frame.shape[0]),
+                               interpolation=cv2.INTER_LINEAR)
+
+    cv2.addWeighted(packet.frame, 1.0, output_colors, 0.5, 0, packet.frame)
+    cv2.imshow('Crowd counting', packet.frame)
+
+
+with OakCamera(replay='../vids/vid1.mp4') as oak:
+    color = oak.create_camera('color', fps=5)
+    nn = oak.create_nn('../models/vgg_openvino_2021.4_6shave.blob', color)
+
+    oak.callback(nn.out.main, callback=callback)
+    oak.start(blocking=True)

gen2-crowdcounting/sdk/requirements.txt

@@ -0,0 +1,5 @@
+opencv-python
+depthai
+depthai-sdk
+gdown
+numpy

gen2-cumulative-object-counting/sdk/main.py

@@ -0,0 +1,113 @@
+import cv2
+import numpy as np
+from depthai import TrackerType, TrackerIdAssignmentPolicy, Tracklet
+
+from depthai_sdk import OakCamera, BboxStyle, TextPosition
+
+tracked_objects = {}
+counter = {'up': 0, 'down': 0, 'left': 0, 'right': 0}
+
+ROI_POS = 0.5
+AXIS = 1
+
+
+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
+
+
+def get_centroid(roi):
+    x1 = roi.topLeft().x
+    y1 = roi.topLeft().y
+    x2 = roi.bottomRight().x
+    y2 = roi.bottomRight().y
+    return ((x2 - x1) / 2 + x1, (y2 - y1) / 2 + y1)
+
+
+def callback(packet, visualizer):
+    height, width = packet.frame.shape[:2]
+
+    for t in packet.daiTracklets.tracklets:
+        to = tracked_objects.get(t.id, None)
+
+        # calculate centroid
+        roi = t.roi.denormalize(width, height)
+        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))
+
+        # If new tracklet, save its centroid
+        if t.status == Tracklet.TrackingStatus.NEW:
+            to = TrackableObject(t.id, centroid)
+        elif to is not None and not to.counted:
+            if AXIS == 0:
+                x = [c[0] for c in to.centroids]
+                direction = centroid[0] - np.mean(x)
+
+                if centroid[0] > ROI_POS * width and direction > 0 and np.mean(x) < ROI_POS * width:
+                    counter['right'] += 1
+                    to.counted = True
+                elif centroid[0] < ROI_POS * width and direction < 0 and np.mean(x) > ROI_POS * width:
+                    counter['left'] += 1
+                    to.counted = True
+
+            elif AXIS == 1:
+                y = [c[1] for c in to.centroids]
+                direction = centroid[1] - np.mean(y)
+
+                if centroid[1] > ROI_POS * height and direction > 0 and np.mean(y) < ROI_POS * height:
+                    counter['down'] += 1
+                    to.counted = True
+                elif centroid[1] < ROI_POS * height and direction < 0 and np.mean(y) > ROI_POS * height:
+                    counter['up'] += 1
+                    to.counted = True
+
+            to.centroids.append(centroid)
+
+        tracked_objects[t.id] = to
+
+        if t.status != Tracklet.TrackingStatus.LOST and t.status != Tracklet.TrackingStatus.REMOVED:
+            text = 'ID {}'.format(t.id)
+
+            cv2.putText(packet.frame, text, (centroid[0] - 10, centroid[1] - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
+            cv2.circle(packet.frame, (centroid[0], centroid[1]), 4, (255, 255, 255), -1)
+
+        counter_str = f'Up: {counter["up"]}\nDown: {counter["down"]}\n' \
+            if AXIS == 1 \
+            else f'Left: {counter["left"]}\nRight: {counter["right"]}'
+
+        visualizer.add_line(pt1=(0, int(ROI_POS * height)),
+                            pt2=(width, int(ROI_POS * height)),
+                            color=(255, 255, 255),
+                            thickness=2)
+
+        visualizer.add_text(counter_str, position=TextPosition.BOTTOM_LEFT)
+        frame = visualizer.draw(packet.frame)
+
+        cv2.imshow('People tracking', frame)
+
+
+with OakCamera(replay='../demo/example_01.mp4') as oak:
+    color = oak.create_camera('color')
+    nn = oak.create_nn('mobilenet-ssd', color, nn_type='mobilenet', tracker=True)
+
+    nn.config_tracker(tracker_type=TrackerType.ZERO_TERM_COLOR_HISTOGRAM,
+                      assignment_policy=TrackerIdAssignmentPolicy.SMALLEST_ID)
+
+    visualizer = oak.visualize(nn.out.tracker, callback=callback, fps=True)
+    visualizer.detections(
+        hide_label=True,
+        bbox_style=BboxStyle.ROUNDED_RECTANGLE
+    )
+
+    oak.start(blocking=True)

gen2-cumulative-object-counting/sdk/requirements.txt

@@ -0,0 +1,6 @@
+numpy>=1.21
+opencv_python
+depthai
+depthai-sdk
+scipy
+blobconverter