Implementing callback function in python and return data in main loop? about ic-imaging-control-samples HOT 13 CLOSED

'''background worker class for camera data acquisition'''
from PyQt5 import QtCore
from PyQt5.QtCore import QThread, pyqtSignal, QTimer, QObject
import numpy as np 
import sys, os

# for tis grabber library
import ctypes
import tisgrabber as tis
# initialize the module (dll)
# get the current directory absolute path
abs_path_to_directory = os.path.abspath(os.path.dirname(__file__))
# add the directory to the os PATH
os.environ['PATH'] = abs_path_to_directory + os.pathsep + os.environ['PATH']

ic = ctypes.cdll.LoadLibrary("tisgrabber_x64.dll")
tis.declareFunctions(ic)
ic.IC_InitLibrary(0)



class WorkerSignals(QObject):
    '''
    Defines the signals available from a running worker thread.

    Supported signals are:

    finished
        No data
    
    error
        `tuple` (exctype, value, traceback.format_exc() )
    
    result
        `object` data returned from processing, anything    
    
    progress
        `int` to show the progress
    
    info
        `str` to show the messages or update about the procress

    '''
    finished = pyqtSignal()
    error = pyqtSignal(tuple)
    result = pyqtSignal(object)
    progress = pyqtSignal(int)
    info = pyqtSignal(str)
    alive = pyqtSignal(bool)
    connected = pyqtSignal(str)

def CreateUserData(ud, camera):
    ''' Create the user data for callback for the passed camera
    :param ud User data to create
    :param camera The camera connected to the user data
    '''
    ud.width = ctypes.c_long()
    ud.height = ctypes.c_long()
    iBitsPerPixel = ctypes.c_int()
    colorformat = ctypes.c_int()

    # Query the values
    ic.IC_GetImageDescription( camera, ud.width, ud.height, iBitsPerPixel, colorformat )

    ud.BytesPerPixel = int( iBitsPerPixel.value / 8.0 )
    ud.buffer_size = ud.width.value * ud.height.value * ud.BytesPerPixel 
    ud.getNextImage = 0

class CallbackUserdata(ctypes.Structure):
    """ Example for user data passed to the callback function. """
    def __init__(self):
        self.width = 0
        self.height = 0
        self.BytesPerPixel = 0
        self.buffer_size = 0
        self.oldbrightness = 0
        self.getNextImage = 0
        self.cvMat = None

def Callback(hGrabber, pBuffer, framenumber, pData):
    """ 

    :param: hGrabber: This is the real pointer to the grabber object.
    :param: pBuffer : Pointer to the first pixel's first byte
    :param: framenumber : Number of the frame since the stream started
    :param: pData : Pointer to additional user data structure
    """
    if pData.getNextImage == 1:
        pData.getNextImage = 2
        print("State reset")
        if pData.buffer_size > 0:
            print("data available")
            image = ctypes.cast(pBuffer, ctypes.POINTER(ctypes.c_ubyte * pData.buffer_size))

            pData.cvMat = np.ndarray(buffer = image.contents,
                            dtype = np.uint8,
                            shape = (pData.height.value,
                                    pData.width.value,
                                    pData.BytesPerPixel))
        pData.getNextImage = 0
        

class CameraWorker(QThread):
    signals = WorkerSignals()

    def __init__(self,parent=None,camera_id='tis',hardware_trigger = False, exposure = 1/30, fps = 30.0, video_format ="Y800 (1280x720)", gain= 1):
        super(CameraWorker, self).__init__(parent)
        
        self.ok = False
        self.data = None
        
        self.threadactive = True
        self.camera_id = camera_id
        
        self.click_image= False
        self.name = 'Camera{}'.format(camera_id)
        print('from thread',self.camera_id)
        
        # initialize the camera as the worker class attribute
        self.Camera =  ic.IC_CreateGrabber()
        
        
        ic.IC_OpenVideoCaptureDevice(self.Camera, camera_id.encode("utf-8")) # it opens the camera with camera model but the unique id (with serial number would have been more stable for multi-camera setup)

        if ic.IC_IsDevValid(self.Camera) == 1:
            # the code passes the DevValid check point no problem until here.

            print('camera is valid')
            ic.IC_SetFrameRate(self.Camera, ctypes.c_float(fps))
            ic.IC_SetVideoFormat(self.Camera, video_format.encode("utf-8"))
            
            
            ic.IC_SetPropertySwitch(self.Camera, "Exposure".encode("utf-8"), "Auto".encode("utf-8"), 0)
            ic.IC_SetPropertyAbsoluteValue(self.Camera, "Exposure".encode("utf-8"), "Value".encode("utf-8"), ctypes.c_float(exposure))
            
            ic.IC_SetPropertySwitch(self.Camera, "Gain".encode("utf-8"), "Auto".encode("utf-8"), 0)
            ic.IC_SetPropertyAbsoluteValue(self.Camera, "Gain".encode("utf-8"), "Value".encode("utf-8"), ctypes.c_float(gain))
            
            if hardware_trigger:
                ic.IC_SetPropertySwitch(self.Camera, "Trigger".encode("utf-8"), "Enable".encode("utf-8"), 1) #switch to harware trigger mode
            else:
                ic.IC_SetPropertySwitch(self.Camera, "Trigger".encode("utf-8"), "Enable".encode("utf-8"), 0)   
            
            # passes the set properties 
            ic.IC_SetContinuousMode(self.Camera, 1)
            ic.IC_StartLive( self.Camera, 0)
            # camera starts 
            # ########
            # this part passes as well
            Callbackfunc =  ic.FRAMEREADYCALLBACK(Callback)
            self.CameraState = CallbackUserdata()  
            ic.IC_SetFrameReadyCallback(self.Camera, Callbackfunc, self.CameraState)
            CreateUserData(self.CameraState, self.Camera)
           
       
    @QtCore.pyqtSlot()
    def run(self):
               
        """start the camera acquisition"""
        i = 0
        fps = []
        self.CameraState.getNextImage = 1
        while self.threadactive:
            
            if self.CameraState.getNextImage == 0:
                # ########
                # this should return (emit) the image data to the main UI but nothing happens.

                print('State Changed')
                image = self.CameraState.cvMat
                self.data = {"id":self.camera_id, "image":image}
                self.signals.result.emit(self.data)
                self.CameraState.getNextImage = 1
            
            QThread.msleep(1)
            
            
        ic.IC_StopLive(self.Camera)
        ic.IC_ReleaseGrabber(self.Camera)
        self.signals.finished.emit()
        # self.stop()
        self.signals.alive.emit(False)
        
    
        
    def stop(self):
        self.threadactive = False
        QThread.msleep(100)
        self.quit()
        self.wait()
        self.exit()

            self.CameraState = CallbackUserdata()  
            ic.IC_SetFrameReadyCallback(self.Camera, Callbackfunc, self.CameraState)
            CreateUserData(self.CameraState, self.Camera)

    @QtCore.pyqtSlot()
    def run(self):
               
        """start the camera acquisition"""
        i = 0
        fps = []
        self.CameraState.getNextImage = 1
        
        while self.threadactive:
            i+=1
            print("while loop count {}".format(i)) # this counter works and update the value of i 
            if self.CameraState.getNextImage == 0:
                # the self.CameraState.getNextImage  does not update and stays same
                # CallBackUserData assigned to the callback never updates and doesn't shows any errors.
                # 
                # this should return (emit) the image data to the main UI but nothing happens.
                print('State Changed')
                image = self.CameraState.cvMat
                self.data = {"id":self.camera_id, "image":image}
                self.signals.result.emit(self.data)
                self.CameraState.getNextImage = 1
            
            QThread.msleep(1)

def frameReadyCallback(hGrabber, pBuffer, framenumber, pData):
    """ This is an example callback function for image processing with 
        opencv. The image data in pBuffer is converted into a cv Matrix
        and with cv.mean() the average brightness of the image is
        measuered.
    :param: hGrabber: This is the real pointer to the grabber object.
    :param: pBuffer : Pointer to the first pixel's first byte
    :param: framenumber : Number of the frame since the stream started
    :param: pData : Pointer to additional user data structure
    """
    # print("camera {}". format(pData.index))
    Width = ctypes.c_long()
    Height = ctypes.c_long()
    BitsPerPixel = ctypes.c_int()
    colorformat = ctypes.c_int()

    # Query the image description values
    print(hGrabber) # --> This returns an integer value
    ic.IC_GetImageDescription(hGrabber, Width, Height, BitsPerPixel, colorformat)

    # Calculate the buffer size
    bpp = int(BitsPerPixel.value/8.0)
    buffer_size = Width.value * Height.value * bpp

    if buffer_size > 0:
        image = ctypes.cast(pBuffer, 
                            ctypes.POINTER(
                                ctypes.c_ubyte * buffer_size))

        pData.cvMat = np.ndarray(buffer=image.contents,
                                dtype=np.uint8,
                                shape=(Height.value,
                                        Width.value,
                                        bpp))

        pData.signals.newimage.emit(pData)

Traceback (most recent call last):
  File "_ctypes/callbacks.c", line 232, in 'calling callback function'
  File "///", line 54, in frameReadyCallback
    ic.IC_GetImageDescription(hGrabber, Width, Height, BitsPerPixel, colorformat)
ctypes.ArgumentError: argument 1: <class 'TypeError'>: expected LP_HGRABBER instance instead of int