Single latest frame grabbing not possible

RyanPaesschesooneVintecc

Hi all,

We are currently developing with the OAK4S. We are running into problems with the image buffers.

I have a custom threadedhostnode which contains the main logic (Communication outside, statemachines,etc). I have left most of it out because the problem lies with the receiving of the "last image" in the input queue. I expect to see the latest frame in the visualizer every 5 seconds. However this does not happen. The visualizer shows old messages (images).

class Master(dai.node.ThreadedHostNode):
    def __init__(self, name: str) -> None:
        # Handle luxonis threaded node
        super().__init__()
        self.name: str = name
        self.input_image = self.createInput()
        self.output = self.createOutput()
        self.input_image.setPossibleDatatypes(
            [
                (dai.DatatypeEnum.ImgFrame, True),
            ]
        )
        self.output.setPossibleDatatypes([(dai.DatatypeEnum.ImgFrame, True)])
        self.input_image.setMaxSize(1)
     

   def run(self):
        while self.isRunning():
            time.sleep(5) # pretend this is waiting for outside communication trigger

            # Empty the buffer:
            self.input_image.getAll()
            print(f"cleaned Buffer: {self.input_image.getSize()}/{self.input_image.getMaxSize()}")
            # Get the latest img
            msg: ADatatype | None = self.input_image.get()
            self.output.send(msg)

Now the Master threaded node is implemented with this pipeline:

def main():

    # Create a remote visualizer connection
    visualizer = dai.RemoteConnection(httpPort=8082)
    # Create device and pipeline
    device = dai.Device()
    with dai.Pipeline(device) as pipeline:
      

        engima_master: Master = Master("Master")
        # Create and configure the camera node
        camera = pipeline.create(dai.node.Camera).build(sensorFps=5)
        camera.setOutputsMaxSizePool(1)
        camera.setNumFramesPools(1, 1, 1)
        model_input = camera.requestOutput(size=(800, 800), enableUndistortion=True)

        camera.initialControl.setManualExposure(exposureTimeUs=40000, sensitivityIso=800)


      
        model_input.link(master.input_image)
        visualizer.addTopic(topicName="output", output=engima_master.output)
   
        pipeline.start()
        visualizer.registerPipeline(pipeline)
       
        # Run loop until 'q' is pressed
        while pipeline.isRunning():
            pipeline.processTasks()


if __name__ == "__main__":
    main()

I find it strange because I have set the pool size (output buffer) to 1 and the input buffer to 1.

Did I miss something

Thanks in advance

Ryan

RyanPaesschesooneVintecc

With further debugging I have found a post about Queue size and blocking (https://discuss.luxonis.com/d/6501-setting-queue-size-and-blocking-on-script-input). I have implemeted this in the example as:

self.input_image.setBlocking(False)
self.input_image.setMaxSize(1)

However, this stops the queue from being filled again:

class Master(dai.node.ThreadedHostNode):
    def __init__(self, name: str) -> None:
        # Handle luxonis threaded node
        super().__init__()
        self.name: str = name
        self.input_image = self.createInput()
        self.input_detections = self.createInput()
        self.output = self.createOutput()

        self.input_image.setPossibleDatatypes(
            [
                (dai.DatatypeEnum.ImgFrame, True),
            ]
        )
        self.output.setPossibleDatatypes([(dai.DatatypeEnum.ImgFrame, True)])

        self.input_image.setBlocking(False)
        self.input_image.setMaxSize(1)

    def run(self):
        while self.isRunning():
            time.sleep(5)
            _logger.info(f"Image buffer is {'not' if not bool(self.input_image.isFull()) else ''} full")
            msg: ADatatype | None = self.input_image.get()
            img: np.ndarray = msg.getCvFrame()  # type: ignore
            self.output.send(msg)

The output

   [2025-12-01T16:55:40Z] 2025-12-01 16:55:40,202 INFO   => Image buffer is  full                                                                                                    (master.py:38)
    [2025-12-01T16:55:42Z] 2025-12-01 16:55:42,263 INFO  => Image buffer is  full                                                                                                    (master.py:38)
    [2025-12-01T16:55:44Z] 2025-12-01 16:55:44,296 INFO  => Image buffer is not full

After this the call:

msg: ADatatype | None = self.input_image.get()

blocks the thread. I believe this must be a bug, correct me if I'm wrong.

Are there fixes for this or when will this be patched?

Kind regards

Ryan

OskarSonc

Hey @RyanPaesschesooneVintecc - setBlocking(False) only changes what happens when the queue is full (producer drops instead of blocking). It does not change get() – get() is still a blocking call. In your logs, once you see “buffer is not full”, the queue is actually empty, and the next get() just waits forever for a new frame.

For a “latest-only every 5 s” pattern, keep:

self.input_image.setMaxSize(1)
self.input_image.setBlocking(False)

but read non-blocking in run():

def run(self):
    while self.isRunning():
        time.sleep(5)
        self.input_image.tryGetAll()   # optional flush
        if (msg := self.input_image.tryGet()):
            self.output.send(msg)
        else:
            _logger.info("No frame available at trigger time")

Also I’d drop setOutputsMaxSizePool(1) / setNumFramesPools(1, 1, 1) sience those are very aggressive and can starve the camera of buffers.

Hope this helps,
Oskar

RyanPaesschesooneVintecc

Hi Oskar,

Thank you for your answer. I have found the problem.

After implementing with tryGet() the frames did not come through anymore (if the buffer was cleaned right before it). This was not expected so I deleted everything in the code with basic elements. This worked fine. After implementing everything again I noticed that the problem starts if I link the detection network to the Threaded Node.

Here I realised that the problem was the difference between the buffers. One was non-blocking and size 1 whilst the input_detections was size 3 and blocking.

When updating the code with:

self.input_image.setBlocking(False)
self.input_image.setMaxSize(1)
self.input_detections.setBlocking(False)
self.input_detections.setMaxSize(1)

The image come through again and are the last image in the buffer (so the most recent).

Thank you for your help.

Kind regards

Ryan