Fix up the examples

Author: Matevz Morato

bindings/python/examples/v3/ColorCamera/rgb_video.py

@@ -25,4 +25,4 @@
         cv2.imshow("video", videoIn.getCvFrame())
 
         if cv2.waitKey(1) == ord('q'):
-            break
+            break

bindings/python/examples/v3/HostNodes/display.py

@@ -1,28 +1,27 @@
 import depthai as dai
 import cv2
-import time
 
 
-class HostDisplay(dai.node.ThreadedHostNode):
-    def __init__(self):
-        dai.node.ThreadedHostNode.__init__(self)
-        self.input = dai.Node.Input(self)
-    def run(self):
-        while True:
-            message : dai.ImgFrame = self.input.get()
-            cv2.imshow("HostDisplay", message.getCvFrame())
-            key = cv2.waitKey(1)
-            if key == ord('q'):
-                self.stopPipeline()
-                break
+class HostDisplay(dai.node.HostNode):
+    def build(self, frameOutput: dai.Node.Output):
+        self.link_args(frameOutput) # Has to match the inputs to the `process` method
+
+        # This sends all the processing to the pipeline where it's executed by the `pipeline.runTasks()` or implicitly by `pipeline.run()` method.
+        # It's needed as the GUI window needs to be updated in the main thread, and the `process` method is by default called in a separate thread.
+        self.sendProcessingToPipeline(True)
+        return self
+
+    def process(self, message: dai.ImgFrame):
+        cv2.imshow("HostDisplay", message.getCvFrame())
+        key = cv2.waitKey(1)
+        if key == ord('q'):
+            print("Detected 'q' - stopping the pipeline...")
+            self.stopPipeline()
 
 with dai.Pipeline() as p:
     camera = p.create(dai.node.ColorCamera)
     camera.setBoardSocket(dai.CameraBoardSocket.CAM_A)
 
-    myHostDisplay = p.create(HostDisplay)
-    camera.video.link(myHostDisplay.input)
+    hostDisplay = p.create(HostDisplay).build(camera.video)
 
-    p.start()
-    while p.isRunning():
-        time.sleep(1)
+    p.run() # Will block until the pipeline is stopped by someone else (in this case it's the display node)

bindings/python/examples/v3/HostNodes/host_camera.py

@@ -23,13 +23,13 @@ def run(self):
             imgFrame.setData(frame)
             imgFrame.setWidth(frame.shape[1])
             imgFrame.setHeight(frame.shape[0])
-            imgFrame.setType(dai.ImgFrame.Type.RGB888i)
+            imgFrame.setType(dai.ImgFrame.Type.BGR888i)
             # Send the message
             self.output.send(imgFrame)
             # Wait for the next frame
             time.sleep(0.1)
 
-with dai.Pipeline() as p:
+with dai.Pipeline(createImplicitDevice=False) as p:
     hostCamera = p.create(HostCamera)
     camQueue = hostCamera.output.createQueue()
 

bindings/python/examples/v3/NNArchive/nn_archive.py

@@ -26,22 +26,17 @@
 with dai.Pipeline() as pipeline:
 
     # Define sources and outputs
-    camRgb = pipeline.create(dai.node.ColorCamera)
-    detectionNetwork = pipeline.create(dai.node.YoloDetectionNetwork)
-
+    camRgb = pipeline.create(dai.node.ColorCamera).build()
     # Properties
     camRgb.setPreviewSize(640, 640)
     camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
     camRgb.setInterleaved(False)
     camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR)
-    camRgb.setFps(30)
-
+    camRgb.setFps(15)
     nnArchive = dai.NNArchive(nnPath)
-    detectionNetwork.setNNArchive(nnArchive)
+    detectionNetwork = pipeline.create(dai.node.DetectionNetwork).build(camRgb.preview, nnArchive)
     detectionNetwork.setNumInferenceThreads(2)
 
-    # Linking
-    camRgb.preview.link(detectionNetwork.input)
 
     qRgb = detectionNetwork.passthrough.createQueue()
     qDet = detectionNetwork.out.createQueue()

bindings/python/examples/v3/RecordReplay/record_video.py

@@ -18,6 +18,7 @@ def signal_handler(sig, frame):
     cam = pipeline.create(dai.node.ColorCamera)
     cam.setBoardSocket(dai.CameraBoardSocket.RGB)
     cam.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
+    cam.setVideoSize(320, 320)
 
     videoEncoder = pipeline.create(dai.node.VideoEncoder)
     videoEncoder.setProfile(dai.VideoEncoderProperties.Profile.H264_MAIN)

bindings/python/examples/v3/RecordReplay/replay_video.py

@@ -11,6 +11,7 @@
 
 # Check if the input video file exists
 if not Path(args.inputVideo).exists():
+    print("First record a video using the record_video.py script")
     raise FileNotFoundError(f'Input video file not found: {args.inputVideo}')
 
 with dai.Pipeline() as pipeline:
@@ -20,14 +21,16 @@
 
     imageManip = pipeline.create(dai.node.ImageManip)
     imageManip.initialConfig.setResize(300, 300)
-    imageManip.setFrameType(dai.ImgFrame.Type.BGR888p)
+    imageManip.initialConfig.setFrameType(dai.ImgFrame.Type.BGR888p)
     replay.out.link(imageManip.inputImage)
     manipOutQueue = imageManip.out.createQueue()
 
     pipeline.start()
-    while pipeline.isRunning():
+    while pipeline.isRunning() and replay.isRunning():
         outFrame : dai.ImgFrame = manipOutQueue.get()
         outFrameCv = outFrame.getCvFrame()
         cv2.imshow("video", outFrameCv)
         if cv2.waitKey(1) == ord('q'):
+            print("Stopping pipeline")
+            pipeline.stop()
             break

bindings/python/examples/v3/SpatialDetection/spatial_tiny_yolo.py

@@ -31,7 +31,7 @@
 with dai.Pipeline() as p:
     # Define sources and outputs
     camRgb = p.create(dai.node.ColorCamera)
-    spatialDetectionNetwork = p.create(dai.node.YoloSpatialDetectionNetwork)
+    spatialDetectionNetwork = p.create(dai.node.YoloSpatialDetectionNetwork).build()
     monoLeft = p.create(dai.node.MonoCamera)
     monoRight = p.create(dai.node.MonoCamera)
     stereo = p.create(dai.node.StereoDepth)

bindings/python/examples/v3/SpatialDetection/spatial_with_host_nodes.py

@@ -29,14 +29,13 @@
 class SpatialVisualizer(dai.node.HostNode):
     def __init__(self):
         dai.node.HostNode.__init__(self)
-        self.depthIn = self.inputs["depth"]
-        self.detectionsIn = self.inputs["detections"]
-        self.rgbIn = self.inputs["rgb"]
-
-    def processGroup(self, messages: dai.MessageGroup):
-        depthPreview = messages["depth"].getCvFrame()
-        detections = messages["detections"]
-        rgbPreview = messages["rgb"].getCvFrame()
+        self.sendProcessingToPipeline(True)
+    def build(self, depth:dai.Node.Output, detections: dai.Node.Output, rgb: dai.Node.Output):
+        self.link_args(depth, detections, rgb) # Must match the inputs to the process method
+
+    def process(self, depthPreview: dai.ImgFrame, detections: dai.ImgDetections, rgbPreview: dai.ImgFrame):
+        depthPreview = depthPreview.getCvFrame()
+        rgbPreview = rgbPreview.getCvFrame()
         depthFrameColor = self.processDepthFrame(depthPreview)
         self.displayResults(rgbPreview, depthFrameColor, detections.detections)
 
@@ -90,7 +89,7 @@ def drawDetections(self, frame, detection, frameWidth, frameHeight):
 with dai.Pipeline() as p:
     # Define sources and outputs
     camRgb = p.create(dai.node.ColorCamera)
-    spatialDetectionNetwork = p.create(dai.node.YoloSpatialDetectionNetwork)
+    spatialDetectionNetwork = p.create(dai.node.YoloSpatialDetectionNetwork).build()
     monoLeft = p.create(dai.node.MonoCamera)
     monoRight = p.create(dai.node.MonoCamera)
     stereo = p.create(dai.node.StereoDepth)
@@ -127,12 +126,6 @@ def drawDetections(self, frame, detection, frameWidth, frameHeight):
     camRgb.preview.link(spatialDetectionNetwork.input)
     visualizer.labelMap = spatialDetectionNetwork.getClasses()
 
+    visualizer.build(stereo.depth, spatialDetectionNetwork.out, camRgb.preview)
 
-    camRgb.preview.link(visualizer.rgbIn)
-    spatialDetectionNetwork.passthroughDepth.link(visualizer.depthIn)
-    spatialDetectionNetwork.out.link(visualizer.detectionsIn)
-
-    p.start()
-
-    while p.isRunning():
-        time.sleep(0.1)
+    p.run()

bindings/python/examples/v3/StereoDepth/stereo_autocreate.py

@@ -5,16 +5,7 @@
 import time
 
 class StereoVisualizer(dai.node.HostNode):
-    def __init__(self):
-        dai.node.HostNode.__init__(self)
-        self.inputDepth = self.inputs["disparity"]
-
-    def build(self, output: dai.Node.Output):
-        output.link(self.inputDepth)
-        return self
-
-    def processGroup(self, messages: dai.MessageGroup):
-        inFrame : dai.ImgFrame = messages["disparity"]
+    def process(self, inFrame: dai.ImgFrame):
         outFrame = inFrame.getFrame()
 
         # Colorize the disparity map
@@ -33,8 +24,7 @@ def processGroup(self, messages: dai.MessageGroup):
     # Allow stereo inputs to be created automatically
     # NOTE: This is a naive implementation, it will not handle correctly the case where cameras have already been created
     stereo = pipeline.create(dai.node.StereoDepth).build(autoCreateCameras=True)
-    visualizer = pipeline.create(StereoVisualizer).build(stereo.disparity)
+    visualizer = pipeline.create(StereoVisualizer)
+    visualizer.link_args(stereo.disparity)
 
-    pipeline.start()
-    while pipeline.isRunning():
-        time.sleep(0.1)
+    pipeline.run()

bindings/python/src/pipeline/PipelineBindings.cpp

@@ -183,7 +183,7 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack){
                      throw std::invalid_argument(std::string(py::str(class_)) + " is not a subclass of depthai.node");
                  }
                  return node;
-             })
+             }, py::keep_alive<1,0>())
         // TODO(themarpe) DEPRECATE, use pipeline.create([class name])
         // templated create<NODE> function
         .def("createXLinkIn", &Pipeline::create<node::XLinkIn>)