Release v2.20.0.0

.github/workflows/main.yml

@@ -538,3 +538,15 @@ jobs:
           repository: luxonis/robothub-apps
           event-type: depthai-python-release
           client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}"}'
+
+  notify_hil_workflow_linux_x86_64:
+    needs: [build-linux-x86_64]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Repository Dispatch
+        uses: peter-evans/repository-dispatch@v2
+        with:
+          token: ${{ secrets.HIL_CORE_DISPATCH_TOKEN }}
+          repository: luxonis/depthai-core-hil-tests
+          event-type: python-hil-event
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}"}'

.gitignore

@@ -38,6 +38,7 @@ wheelhouse/
 .venv
 env/
 venv/
+venv_*/
 ENV/
 env.bak/
 venv.bak/

CMakeLists.txt

@@ -107,6 +107,7 @@ pybind11_add_module(${TARGET_NAME}
     src/pipeline/node/XLinkInBindings.cpp
     src/pipeline/node/XLinkOutBindings.cpp
     src/pipeline/node/ColorCameraBindings.cpp
+    src/pipeline/node/CameraBindings.cpp
     src/pipeline/node/MonoCameraBindings.cpp
     src/pipeline/node/StereoDepthBindings.cpp
     src/pipeline/node/NeuralNetworkBindings.cpp

examples/Camera/camera_isp.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import cv2
+import depthai as dai
+import time
+
+# Connect to device and start pipeline
+with dai.Device() as device:
+    # Device name
+    print('Device name:', device.getDeviceName())
+    # Bootloader version
+    if device.getBootloaderVersion() is not None:
+        print('Bootloader version:', device.getBootloaderVersion())
+    # Print out usb speed
+    print('Usb speed:', device.getUsbSpeed().name)
+    # Connected cameras
+    print('Connected cameras:', device.getConnectedCameraFeatures())
+
+    # Create pipeline
+    pipeline = dai.Pipeline()
+    cams = device.getConnectedCameraFeatures()
+    streams = []
+    for cam in cams:
+        print(str(cam), str(cam.socket), cam.socket)
+        c = pipeline.create(dai.node.Camera)
+        x = pipeline.create(dai.node.XLinkOut)
+        c.isp.link(x.input)
+        c.setBoardSocket(cam.socket)
+        stream = str(cam.socket)
+        if cam.name:
+            stream = f'{cam.name} ({stream})'
+        x.setStreamName(stream)
+        streams.append(stream)
+
+    # Start pipeline
+    device.startPipeline(pipeline)
+    fpsCounter = {}
+    lastFpsCount = {}
+    tfps = time.time()
+    while not device.isClosed():
+        queueNames = device.getQueueEvents(streams)
+        for stream in queueNames:
+            messages = device.getOutputQueue(stream).tryGetAll()
+            fpsCounter[stream] = fpsCounter.get(stream, 0.0) + len(messages)
+            for message in messages:
+                # Display arrived frames
+                if type(message) == dai.ImgFrame:
+                    # render fps
+                    fps = lastFpsCount.get(stream, 0)
+                    frame = message.getCvFrame()
+                    cv2.putText(frame, "Fps: {:.2f}".format(fps), (10, 10), cv2.FONT_HERSHEY_TRIPLEX, 0.4, (255,255,255))
+                    cv2.imshow(stream, frame)
+
+        if time.time() - tfps >= 1.0:
+            scale = time.time() - tfps
+            for stream in fpsCounter.keys():
+                lastFpsCount[stream] = fpsCounter[stream] / scale
+            fpsCounter = {}
+            tfps = time.time()
+
+        if cv2.waitKey(1) == ord('q'):
+            break

examples/Camera/camera_preview.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import cv2
+import depthai as dai
+import time
+
+# Connect to device and start pipeline
+with dai.Device(dai.OpenVINO.DEFAULT_VERSION, dai.UsbSpeed.SUPER_PLUS) as device:
+    # Device name
+    print('Device name:', device.getDeviceName())
+    # Bootloader version
+    if device.getBootloaderVersion() is not None:
+        print('Bootloader version:', device.getBootloaderVersion())
+    # Print out usb speed
+    print('Usb speed:', device.getUsbSpeed().name)
+    # Connected cameras
+    print('Connected cameras:', device.getConnectedCameraFeatures())
+
+    # Create pipeline
+    pipeline = dai.Pipeline()
+    cams = device.getConnectedCameraFeatures()
+    streams = []
+    for cam in cams:
+        print(str(cam), str(cam.socket), cam.socket)
+        c = pipeline.create(dai.node.Camera)
+        x = pipeline.create(dai.node.XLinkOut)
+        c.preview.link(x.input)
+        c.setBoardSocket(cam.socket)
+        stream = str(cam.socket)
+        if cam.name:
+            stream = f'{cam.name} ({stream})'
+        x.setStreamName(stream)
+        streams.append(stream)
+
+    # Start pipeline
+    device.startPipeline(pipeline)
+    fpsCounter = {}
+    lastFpsCount = {}
+    tfps = time.time()
+    while not device.isClosed():
+        queueNames = device.getQueueEvents(streams)
+        for stream in queueNames:
+            messages = device.getOutputQueue(stream).tryGetAll()
+            fpsCounter[stream] = fpsCounter.get(stream, 0.0) + len(messages)
+            for message in messages:
+                # Display arrived frames
+                if type(message) == dai.ImgFrame:
+                    # render fps
+                    fps = lastFpsCount.get(stream, 0)
+                    frame = message.getCvFrame()
+                    cv2.putText(frame, "Fps: {:.2f}".format(fps), (10, 10), cv2.FONT_HERSHEY_TRIPLEX, 0.4, (255,255,255))
+                    cv2.imshow(stream, frame)
+
+        if time.time() - tfps >= 1.0:
+            scale = time.time() - tfps
+            for stream in fpsCounter.keys():
+                lastFpsCount[stream] = fpsCounter[stream] / scale
+            fpsCounter = {}
+            tfps = time.time()
+
+        if cv2.waitKey(1) == ord('q'):
+            break

examples/ColorCamera/rgb_preview.py

@@ -23,7 +23,7 @@
 # Connect to device and start pipeline
 with dai.Device(pipeline) as device:
 
-    print('Connected cameras:', device.getConnectedCameras())
+    print('Connected cameras:', device.getConnectedCameraFeatures())
     # Print out usb speed
     print('Usb speed:', device.getUsbSpeed().name)
     # Bootloader version

examples/ImageManip/image_manip_warp_mesh.py

@@ -12,7 +12,7 @@
 maxFrameSize = camRgb.getPreviewWidth() * camRgb.getPreviewHeight() * 3
 
 # Warp preview frame 1
-manip1 = pipeline.create(dai.node.Warp)
+manip1 = pipeline.create(dai.node.ImageManip)
 # Create a custom warp mesh
 tl = dai.Point2f(20, 20)
 tr = dai.Point2f(460, 20)

examples/StereoDepth/depth_colormap.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import cv2
+import depthai as dai
+import numpy as np
+
+# Closer-in minimum depth, disparity range is doubled (from 95 to 190):
+extended_disparity = False
+# Better accuracy for longer distance, fractional disparity 32-levels:
+subpixel = False
+# Better handling for occlusions:
+lr_check = True
+
+# Create pipeline
+pipeline = dai.Pipeline()
+
+# Define sources and outputs
+monoLeft = pipeline.create(dai.node.MonoCamera)
+monoRight = pipeline.create(dai.node.MonoCamera)
+depth = pipeline.create(dai.node.StereoDepth)
+xout = pipeline.create(dai.node.XLinkOut)
+
+xout.setStreamName("disparity")
+
+# Properties
+monoLeft.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+monoLeft.setBoardSocket(dai.CameraBoardSocket.LEFT)
+monoRight.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+monoRight.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+
+# Create a node that will produce the depth map (using disparity output as it's easier to visualize depth this way)
+depth.setDefaultProfilePreset(dai.node.StereoDepth.PresetMode.HIGH_DENSITY)
+# Options: MEDIAN_OFF, KERNEL_3x3, KERNEL_5x5, KERNEL_7x7 (default)
+depth.initialConfig.setMedianFilter(dai.MedianFilter.KERNEL_7x7)
+depth.setLeftRightCheck(lr_check)
+depth.setExtendedDisparity(extended_disparity)
+depth.setSubpixel(subpixel)
+
+# Create a colormap
+colormap = pipeline.create(dai.node.ImageManip)
+colormap.initialConfig.setColormap(dai.Colormap.STEREO_TURBO, depth.initialConfig.getMaxDisparity())
+colormap.initialConfig.setFrameType(dai.ImgFrame.Type.NV12)
+
+# Linking
+monoLeft.out.link(depth.left)
+monoRight.out.link(depth.right)
+depth.disparity.link(colormap.inputImage)
+colormap.out.link(xout.input)
+
+# Connect to device and start pipeline
+with dai.Device(pipeline) as device:
+
+    # Output queue will be used to get the disparity frames from the outputs defined above
+    q = device.getOutputQueue(name="disparity", maxSize=4, blocking=False)
+
+    while True:
+        inDisparity = q.get()  # blocking call, will wait until a new data has arrived
+        frame = inDisparity.getCvFrame()
+        cv2.imshow("disparity", frame)
+
+        if cv2.waitKey(1) == ord('q'):
+            break

examples/StereoDepth/depth_preview_lr.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+import cv2
+import depthai as dai
+import numpy as np
+
+# Closer-in minimum depth, disparity range is doubled (from 95 to 190):
+extended_disparity = True
+# Better accuracy for longer distance, fractional disparity 32-levels:
+subpixel = True
+# Better handling for occlusions:
+lr_check = True
+
+# Create pipeline
+pipeline = dai.Pipeline()
+
+# Define sources and outputs
+left = pipeline.create(dai.node.ColorCamera)
+right = pipeline.create(dai.node.ColorCamera)
+depth = pipeline.create(dai.node.StereoDepth)
+xout = pipeline.create(dai.node.XLinkOut)
+xoutl = pipeline.create(dai.node.XLinkOut)
+xoutr = pipeline.create(dai.node.XLinkOut)
+
+xout.setStreamName("disparity")
+xoutl.setStreamName("rectifiedLeft")
+xoutr.setStreamName("rectifiedRight")
+
+# Properties
+left.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1200_P)
+left.setBoardSocket(dai.CameraBoardSocket.LEFT)
+right.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1200_P)
+right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+right.setIspScale(2, 3)
+left.setIspScale(2, 3)
+
+
+# Create a node that will produce the depth map (using disparity output as it's easier to visualize depth this way)
+depth.setDefaultProfilePreset(dai.node.StereoDepth.PresetMode.HIGH_DENSITY)
+# Options: MEDIAN_OFF, KERNEL_3x3, KERNEL_5x5, KERNEL_7x7 (default)
+depth.initialConfig.setMedianFilter(dai.MedianFilter.KERNEL_7x7)
+depth.setInputResolution(1280, 800)
+depth.setLeftRightCheck(lr_check)
+depth.setExtendedDisparity(extended_disparity)
+depth.setSubpixel(subpixel)
+depth.setInputResolution(1280, 800)
+
+# Linking
+left.isp.link(depth.left)
+right.isp.link(depth.right)
+depth.disparity.link(xout.input)
+depth.rectifiedLeft.link(xoutl.input)
+depth.rectifiedRight.link(xoutr.input)
+
+# Connect to device and start pipeline
+with dai.Device(pipeline) as device:
+    while not device.isClosed():
+        queueNames = device.getQueueEvents()
+        for q in queueNames:
+            message = device.getOutputQueue(q).get()
+            # Display arrived frames
+            if type(message) == dai.ImgFrame:
+                frame = message.getCvFrame()
+                if 'disparity' in q:
+                    maxDisp = depth.initialConfig.getMaxDisparity()
+                    disp = (frame * (255.0 / maxDisp)).astype(np.uint8)
+                    disp = cv2.applyColorMap(disp, cv2.COLORMAP_JET)
+                    cv2.imshow(q, disp)
+                else:
+                    cv2.imshow(q, frame)
+        if cv2.waitKey(1) == ord('q'):
+            break

examples/VideoEncoder/disparity_colormap_encoding.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import depthai as dai
+
+# Create pipeline
+pipeline = dai.Pipeline()
+
+# Create left/right mono cameras for Stereo depth
+monoLeft = pipeline.create(dai.node.MonoCamera)
+monoLeft.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+monoLeft.setBoardSocket(dai.CameraBoardSocket.LEFT)
+
+monoRight = pipeline.create(dai.node.MonoCamera)
+monoRight.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+monoRight.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+
+# Create a node that will produce the depth map
+depth = pipeline.create(dai.node.StereoDepth)
+depth.setDefaultProfilePreset(dai.node.StereoDepth.PresetMode.HIGH_DENSITY)
+depth.initialConfig.setMedianFilter(dai.MedianFilter.KERNEL_7x7)
+depth.setLeftRightCheck(False)
+depth.setExtendedDisparity(False)
+# Subpixel disparity is of UINT16 format, which is unsupported by VideoEncoder
+depth.setSubpixel(False)
+monoLeft.out.link(depth.left)
+monoRight.out.link(depth.right)
+
+# Colormap
+colormap = pipeline.create(dai.node.ImageManip)
+colormap.initialConfig.setColormap(dai.Colormap.TURBO, depth.initialConfig.getMaxDisparity())
+colormap.initialConfig.setFrameType(dai.ImgFrame.Type.NV12)
+
+videoEnc = pipeline.create(dai.node.VideoEncoder)
+# Depth resolution/FPS will be the same as mono resolution/FPS
+videoEnc.setDefaultProfilePreset(monoLeft.getFps(), dai.VideoEncoderProperties.Profile.H264_HIGH)
+
+# Link
+depth.disparity.link(colormap.inputImage)
+colormap.out.link(videoEnc.input)
+
+xout = pipeline.create(dai.node.XLinkOut)
+xout.setStreamName("enc")
+videoEnc.bitstream.link(xout.input)
+
+# Connect to device and start pipeline
+with dai.Device(pipeline) as device:
+
+    # Output queue will be used to get the encoded data from the output defined above
+    q = device.getOutputQueue(name="enc")
+
+    # The .h265 file is a raw stream file (not playable yet)
+    with open('disparity.h264', 'wb') as videoFile:
+        print("Press Ctrl+C to stop encoding...")
+        try:
+            while True:
+                videoFile.write(q.get().getData())
+        except KeyboardInterrupt:
+            # Keyboard interrupt (Ctrl + C) detected
+            pass
+
+    print("To view the encoded data, convert the stream file (.mjpeg) into a video file (.mp4) using a command below:")
+    print("ffmpeg -framerate 30 -i disparity.mjpeg -c copy video.mp4")

examples/device/device_all_boot_bootloader.py

@@ -0,0 +1,6 @@
+import depthai as dai
+
+devices = dai.Device.getAllConnectedDevices()
+
+for device in devices:
+    dai.XLinkConnection.bootBootloader(device)

examples/device/device_boot_non_exclusive.py

@@ -0,0 +1,10 @@
+import depthai as dai
+import time
+
+cfg = dai.Device.Config()
+cfg.nonExclusiveMode = True
+
+with dai.Device(cfg) as device:
+    while not device.isClosed():
+        print('CPU usage:',device.getLeonCssCpuUsage().average)
+        time.sleep(1)