Unable to interface Genie Nano M2020 camera with DeepLabCut-Live

[jadrew43]

Hi, I am using DLC-Live's base Camera class to write a class for Teledyne's Genie Nano M2020 camera. I've initiated the camera, started acquisition, and enabled a raw readout. According to get_frame_status(), the number of acquired frames increases by 1 per _capture_loop(), while unread==1 and buffer_size==100. I can print out the frame values (2D array of pixel values), and convert that array into a .jpeg matching the image seen in the camera feed, but the frame is not getting pushed to the DLC-Live GUI (use_tk_display==True). Can anyone assist this issue?

import time
from dlclivegui.camera import Camera
import pylablib as pll
from pylablib.devices import IMAQdx
import numpy as np

class m2020Cam(Camera):
    # Base camera class. Controls image capture, writing images to video, pose estimation and image display. 
    
    Parameters
    ----------
    id : [type]
        camera id
    exposure : int, optional
        exposure time in microseconds, by default None
    gain : int, optional
        gain value, by default None
    rotate : [type], optional
        [description], by default None
    crop : list, optional
        camera cropping parameters: [left, right, top, bottom], by default None
    fps : float, optional
        frame rate in frames per second, by default None
    use_tk_display : bool, optional
        flag to use tk image display (if using GUI), by default False
    display_resize : float, optional
        factor to resize images if using opencv display (display is very slow for large images), by default None
   

   def __init__(
        self,
        id="m2020",
        resolution=[600,600],#[2048, 1536],
        exposure=25.65, #microseconds
        gain=1, #1x to 251x
        rotate=None,
        crop=None,
        fps=15,
        use_tk_display=True, #true if no display module
        display_resize=1.0
    ):
       # Constructor method
        
        self.id = id
        self.exposure = exposure
        self.gain = gain
        self.rotate = rotate
        self.crop = [int(c) for c in crop] if crop else None
        self.set_im_size(resolution)
        self.fps = fps
        self.use_tk_display = use_tk_display
        self.display_resize = display_resize if display_resize else 1.0
        self.next_frame = 0

    def set_im_size(self, res):
        if not res:
            raise CameraError("Resolution is not set!")

        self.im_size = (
            (int(res[0]), int(res[1]))
            if self.crop is None
            else (self.crop[3] - self.crop[2], self.crop[1] - self.crop[0])
        )

    def set_capture_device(self):
        # Sets frame capture device with desired properties
        
        self.cam = IMAQdx.IMAQdxCamera('Cam_3')
        self.cam.start_acquisition(mode='sequence', nframes=100) #called once but read_frames continually called
        self.cam.enable_raw_readout(enable='frame') #makes it so start_acq does not run
        
        return True

    def get_image_on_time(self):
       # Gets an image from frame capture device at the appropriate time (according to fps).
        
        Returns
        -------
        `np.ndarray`
            image as a numpy array
        float
            timestamp at which frame was taken, obtained from :func:`time.time`
       
        frame = None
        while frame is None:
            cur_time = time.time()
            if cur_time > self.next_frame:
                frame = self.get_image()
                timestamp = cur_time
                self.next_frame = max(
                    self.next_frame + 1.0 / self.fps, cur_time + 0.5 / self.fps
                )
        
        return frame, timestamp

    def get_image(self):
        # Gets image from frame capture device
        
        self.cam.wait_for_frame()
        frame = read_oldest_image(return_info=True)
        return frame
        

    def close_capture_device(self):
        # Closes frame capture device
        self.cam.stop_acquisition()