def initCamera(self): try: self.hcam = ueye.HIDS(0) self.pccmem = ueye.c_mem_p() self.memID = ueye.c_int() self.hWnd = ctypes.c_voidp() ueye.is_InitCamera(self.hcam, self.hWnd) ueye.is_SetDisplayMode(self.hcam, 0) self.sensorinfo = ueye.SENSORINFO() ueye.is_GetSensorInfo(self.hcam, self.sensorinfo) return self.OP_OK except: return self.OP_ERR
def connect(self): """ Connects to the USB camera, creates main controlling object + prints out confirmation """ connectRet = ueye.is_InitCamera(self.CamID, None) if connectRet == 0: # on succesful connection self.connected = True self.sensorInfo = ueye.SENSORINFO() print('IDS camera connected.') ueye.is_GetSensorInfo(self.CamID, self.sensorInfo) self.sensorHeight_ctype, self.sensorWidth_ctype = self.sensorInfo.nMaxHeight, self.sensorInfo.nMaxWidth self.currentHeight, self.currentWidth = self.sensorHeight_ctype.value, self.sensorWidth_ctype.value # Settings block ueye.is_PixelClock(self.CamID, ueye.IS_PIXELCLOCK_CMD_SET, ueye.c_int(self.pixelClock), ueye.sizeof(ueye.c_int(self.pixelClock))) self.currentFPS = ueye.c_double(0) #ueye.is_SetFrameRate(self.CamID, ueye.c_int(self.FPS),self.currentFPS) ueye.is_SetDisplayMode(self.CamID, ueye.IS_SET_DM_DIB) ueye.is_SetColorMode(self.CamID, ueye.IS_CM_SENSOR_RAW12) ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_GAIN, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_SENSOR_GAIN, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_SHUTTER, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_SENSOR_SHUTTER, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_WHITEBALANCE, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetAutoParameter( self.CamID, ueye.IS_SET_ENABLE_AUTO_SENSOR_WHITEBALANCE, ueye.c_double(0), ueye.c_double(0)) ueye.is_SetHardwareGain(self.CamID, ueye.c_int(0), ueye.c_int(0), ueye.c_int(0), ueye.c_int(0)) # Show a pattern (for testing) #ueye.is_SetSensorTestImage(self.CamID,ueye.IS_TEST_IMAGE_HORIZONTAL_GREYSCALE, ueye.c_int(0)) else: print('Camera connecting failure...')
def getSensorInfo(self): self.sensorInfo=ueye.SENSORINFO() if ueye.is_GetSensorInfo(self.hcam, self.sensorInfo): self.status=True _logger.error("Error retriving sensor information.") return True return False
def __init__(self): super(CamDialog, self).__init__() loadUi('cam.ui', self) self.image=None self.roi_color=None self.startButton.clicked.connect(self.start_webcam) self.stopButton.clicked.connect(self.stop_webcam) # self.detectButton.setCheckable(True) # self.detectButton.toggled.connect(self.detect_webcam_face) self.face_Enabled=False self.faceCascade=cv2.CascadeClassifier('haarcascade_frontalface_default.xml') self.hCam = ueye.HIDS(0) # 0: first available camera; 1-254: The camera with the specified camera ID self.sInfo = ueye.SENSORINFO() self.cInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() self.rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = ueye.INT(24) # 24: bits per pixel for color mode; take 8 bits per pixel for monochrome self.channels = 3 # 3: channels for color mode(RGB); take 1 channel for monochrome self.m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 self.bytes_per_pixel = int(self.nBitsPerPixel / 8) self.nRet = ueye.is_InitCamera(self.hCam, None) self.nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo) self.nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo) self.nRet = ueye.is_ResetToDefault(self.hCam) self.nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel, self.m_nColorMode) self.nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height self.nRet = ueye.is_AllocImageMem(self.hCam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID) self.nRet = ueye.is_SetImageMem(self.hCam, self.pcImageMemory, self.MemID) self.nRet = ueye.is_SetColorMode(self.hCam, self.m_nColorMode) self.nRet = ueye.is_CaptureVideo(self.hCam, ueye.IS_DONT_WAIT) self.nRet = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory, self.MemID, self.width, self.height, self.nBitsPerPixel, self.pitch) self.xp=[] self.yp=[] self.lxp=[] self.lyp = [] self.rxp = [] self.ryp = [] self.sx = 200 self.sy = 150 self.endx = 600 self.endy = 450 # self.avgx = 0 # self.avgy = 0 self.holeflag = 0 self.lflag = 0 self.rflag = 0
def return_devices(self, variable): cam_num = ueye.INT() ueye.is_GetNumberOfCameras(cam_num) for i in range(cam_num.value): hid = ueye.HIDS(cam_num) s = ueye.is_InitCamera(self.hid, self.hwnd) r = ueye.is_GetSensorInfo(self.hid, self.sinfo) sname = self.sinfo.strSensorName.decode('UTF-8') self.detected_devices[sname] = i + 1 variable.insert('end', sname) ueye.is_ExitCamera(self.hid)
def connect_device(self, name): """ Connect to camera specified by name. """ cam_num = self.detected_devices[name] cam_num = ueye.INT(cam_num) ueye.is_GetNumberOfCameras(cam_num) s = ueye.is_InitCamera(self.hid, self.hwnd) r = ueye.is_GetSensorInfo(self.hid, self.sinfo) self.configure_device() self.camera = True
def initCamera(self): try: self.hcam = ueye.HIDS(0) self.pccmem = ueye.c_mem_p() self.memID = ueye.c_int() self.hWnd = ctypes.c_voidp() ueye.is_InitCamera(self.hcam, self.hWnd) ueye.is_SetDisplayMode(self.hcam, 0) self.sensorinfo = ueye.SENSORINFO() ueye.is_GetSensorInfo(self.hcam, self.sensorinfo) auto_res = ueye.is_SetAutoParameter(self.hcam, ueye.IS_SET_ENABLE_AUTO_SHUTTER, ctypes.c_double(1), ctypes.c_double(1)) try: auto_res = ueye.GetExposureRange() print auto_res except Exception as Ex: print Ex pass print auto_res return self.OP_OK except Exception as ex: logging.exception("Error during camera initialization!") return self.OP_ERR
def __init__(self, cam_id, name): self._cam = ueye.HIDS(cam_id) self._cam_name = name self._sInfo = ueye.SENSORINFO() self._sFPS = ueye.DOUBLE() self._connect() # Query additional information about the sensor type used in the camera err = ueye.is_GetSensorInfo(self._cam, self._sInfo) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>close>GetSensorInfo>', err) # Reset camera to default settings err = ueye.is_ResetToDefault(self._cam) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>close>ResetToDefault>', err) # Set display mode to DIB err = ueye.is_SetDisplayMode(self._cam, ueye.IS_SET_DM_DIB) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>close>SetDisplayMode>', err) # Core Camera Variables self._width = ueye.INT(self._sInfo.nMaxWidth.value) self._height = ueye.INT(self._sInfo.nMaxHeight.value) self._pitch = ueye.INT() self._ppc_img_mem = ueye.c_mem_p() self._mem_id = ueye.INT() self._nBitsPerPixel = ueye.INT() self._m_nColorMode = ueye.INT() self._bytes_per_pixel = ueye.INT() self._video_capture = False self._done_saving = True # Allicate memory for frames self._allocate_memory() # Start collection of frames self.start_video_capture() # Get frames per second err = ueye.is_GetFramesPerSecond(self._cam, self._sFPS) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>close>GetFramesPerSecond>', err) # Start new thread to save frame threading.Thread(target=self._update).start()
def connect_device(self, variable): if not variable.curselection(): messagebox.showinfo(title='Error', message='No' + 'device selected!') return index = variable.curselection()[0] name = variable.get(index) cam_num = self.detected_devices[name] cam_num = ueye.INT(cam_num) ueye.is_GetNumberOfCameras(cam_num) s = ueye.is_InitCamera(self.hid, self.hwnd) r = ueye.is_GetSensorInfo(self.hid, self.sinfo) self.configure_device() self.configure_graph() self.camera = True
def run(self): a = ueye.is_InitCamera(self.hCam, None) b = ueye.is_GetCameraInfo(self.hCam, self.cInfo) c = ueye.is_GetSensorInfo(self.hCam, self.sInfo) d = ueye.is_ResetToDefault(self.hCam) e = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) g = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height h = ueye.is_AllocImageMem(self.hCam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID) i = ueye.is_SetImageMem(self.hCam, self.pcImageMemory, self.MemID) f = ueye.is_SetColorMode(self.hCam, ueye.IS_CM_MONO12) ueye.is_CaptureVideo(self.hCam, ueye.IS_WAIT) j = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory, self.MemID, self.width, self.height, self.nBitsPerPixel, self.pitch) self.IMAGE_FILE_PARAMS = ueye.IMAGE_FILE_PARAMS( self.pcImageMemory, self.MemID) self.IMAGE_FILE_PARAMS.nFileType = ueye.IS_IMG_PNG self.k = ueye.sizeof(self.IMAGE_FILE_PARAMS) # ueye.is_AutoParameter(self.hCam, ueye.IS_AES_CMD_SET_ENABLE, self.autoParameter, ueye.sizeof(self.autoParameter)) while self.flag: self.data = np.ctypeslib.as_array( ctypes.cast(self.pcImageMemory, ctypes.POINTER(ctypes.c_ubyte)), (self.height * self.pitch, )) self.data.dtype = 'uint16' self.CameraSignal.emit(self.data) time.sleep(0.1) ueye.is_FreeImageMem(self.hCam, self.pcImageMemory, self.MemID) ueye.is_ExitCamera(self.hCam)
def return_devices(self): """ Return list of connected camera. """ varOut = [] cam_num = ueye.INT() ueye.is_GetNumberOfCameras(cam_num) for i in range(cam_num.value): hid = ueye.HIDS(cam_num) s = ueye.is_InitCamera(self.hid, self.hwnd) r = ueye.is_GetSensorInfo(self.hid, self.sinfo) sname = self.sinfo.strSensorName.decode('UTF-8') self.detected_devices[sname] = i+1 varOut.append(sname) ueye.is_ExitCamera(self.hid) return varOut
def __init__(self, device_number=0, nbits=8): Camera.__init__(self) self.initialized = False if nbits not in (8, 10, 12): raise RuntimeError( 'Supporting only 8, 10 or 12 bit depth, requested %d bit' % (nbits)) self.nbits = nbits self.h = ueye.HIDS(device_number) self.check_success(ueye.is_InitCamera(self.h, None)) self.initialized = True # get chip size sensor_info = ueye.SENSORINFO() self.check_success(ueye.is_GetSensorInfo(self.h, sensor_info)) self._chip_size = (sensor_info.nMaxWidth, sensor_info.nMaxHeight) self.sensor_type = sensor_info.strSensorName.decode().split( 'x')[0] + 'x' self.SetROI(0, 0, self._chip_size[0], self._chip_size[1]) self.check_success( ueye.is_SetColorMode(self.h, getattr(ueye, 'IS_CM_MONO%d' % self.nbits))) self.SetAcquisitionMode(self.MODE_CONTINUOUS) self._buffers = [] self.full_buffers = queue.Queue() self.free_buffers = None self.n_full = 0 self.n_accum = 1 self.n_accum_current = 0 self.SetIntegTime(0.1) self.Init()
def Cameras_stream(): #Variables hCam1 = ueye.HIDS(1) #0: first available camera; 1-254: The camera with the specified camera ID hCam2 = ueye.HIDS(2) #0: first available camera; 1-254: The camera with the specified camera ID sInfo = ueye.SENSORINFO() cInfo = ueye.CAMINFO() pcImageMemory = ueye.c_mem_p() pcImageMemory2 = ueye.c_mem_p() MemID = ueye.int() MemID2 = ueye.int() rectAOI = ueye.IS_RECT() pitch = ueye.INT() nBitsPerPixel = ueye.INT(24) #24: bits per pixel for color mode; take 8 bits per pixel for monochrome channels = 3 #3: channels for color mode(RGB); take 1 channel for monochrome m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 bytes_per_pixel = int(nBitsPerPixel / 8) #--------------------------------------------------------------------------------------------------------------------------------------- # print("START") # print() # Starts the driver and establishes the connection to the camera nRet1 = ueye.is_InitCamera(hCam1, None) if nRet1 != ueye.IS_SUCCESS: pass # print("is_InitCamera ERROR") else: print(f'Camera 1 : SUCCESS') nRet2 = ueye.is_InitCamera(hCam2, None) if nRet2 != ueye.IS_SUCCESS: pass # print("is_InitCamera ERROR") else: print(f'Camera 2 : SUCCESS') # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet1 = ueye.is_GetCameraInfo(hCam1, cInfo) if nRet1 != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") nRet2 = ueye.is_GetCameraInfo(hCam2, cInfo) if nRet2 != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet1 = ueye.is_GetSensorInfo(hCam1, sInfo) if nRet1 != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") nRet1 = ueye.is_ResetToDefault( hCam1) if nRet1 != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB nRet1 = ueye.is_SetDisplayMode(hCam1, ueye.IS_SET_DM_DIB) nRet2 = ueye.is_SetDisplayMode(hCam2, ueye.IS_SET_DM_DIB) # Set the right color mode if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # setup the color depth to the current windows setting ueye.is_GetColorDepth(hCam1, nBitsPerPixel, m_nColorMode) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_BGRA8_PACKED nBitsPerPixel = ueye.INT(32) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) bytes_per_pixel = int(nBitsPerPixel / 8) print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet1 = ueye.is_AOI(hCam1, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI)) if nRet1 != ueye.IS_SUCCESS: print("is_AOI ERROR") width = rectAOI.s32Width height = rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", width) print("Maximum image height:\t", height) print() #--------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel nRet1 = ueye.is_AllocImageMem(hCam1, width, height, nBitsPerPixel, pcImageMemory, MemID) if nRet1 != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam1, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam1, m_nColorMode) if nRet1 != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam1, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam2, m_nColorMode) # Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel nRet = ueye.is_AllocImageMem(hCam2, width, height, nBitsPerPixel, pcImageMemory2, MemID2) if nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam2, pcImageMemory2, MemID2) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam2, m_nColorMode) nRet = ueye.is_AllocImageMem(hCam2, width, height, nBitsPerPixel, pcImageMemory2, MemID2) if nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam2, pcImageMemory2, MemID2) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam2, m_nColorMode) # Activates the camera's live video mode (free run mode) nRet = ueye.is_CaptureVideo(hCam1, ueye.IS_DONT_WAIT) if nRet != ueye.IS_SUCCESS: print("is_CaptureVideo ERROR") nRet = ueye.is_CaptureVideo(hCam2, ueye.IS_DONT_WAIT) if nRet != ueye.IS_SUCCESS: print("is_CaptureVideo ERROR") # Enables the queue mode for existing image memory sequences nRet = ueye.is_InquireImageMem(hCam1, pcImageMemory, MemID, width, height, nBitsPerPixel, pitch) if nRet != ueye.IS_SUCCESS: print("is_InquireImageMem ERROR") else: print("Press q to leave the programm") nRet2 = ueye.is_InquireImageMem(hCam2, pcImageMemory2, MemID, width, height, nBitsPerPixel, pitch) if nRet2 != ueye.IS_SUCCESS: print("is_InquireImageMem ERROR") else: print("Press q to leave the programm") #--------------------------------------------------------------------------------------------------------------------------------------- # Continuous image display while(nRet == ueye.IS_SUCCESS) and (nRet2 == ueye.IS_SUCCESS): # In order to display the image in an OpenCV window we need to... # ...extract the data of our image memory array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False) array2 = ueye.get_data(pcImageMemory2, width, height, nBitsPerPixel, pitch, copy=False) # bytes_per_pixel = int(nBitsPerPixel / 8) # ...reshape it in an numpy array... frame = np.reshape(array,(height.value, width.value, bytes_per_pixel)) frame2 = np.reshape(array2,(height.value, width.value, bytes_per_pixel)) # ...resize the image by a half # frame = cv2.resize(frame,(0,0),fx=0.5, fy=0.5) #--------------------------------------------------------------------------------------------------------------------------------------- #Include image data processing here #--------------------------------------------------------------------------------------------------------------------------------------- #...and finally display it if __name__=="__main__": cv2.imshow("SimpleLive_Python_uEye_OpenCV", frame) cv2.imshow("SimpleLive_Python_uEye_OpenCV 2", frame2) # Press q if you want to end the loop if cv2.waitKey(1) & 0xFF == ord('q'): break #--------------------------------------------------------------------------------------------------------------------------------------- # Releases an image memory that was allocated using is_AllocImageMem() and removes it from the driver management ueye.is_FreeImageMem(hCam1, pcImageMemory, MemID) ueye.is_FreeImageMem(hCam2, pcImageMemory2, MemID2) # Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera ueye.is_ExitCamera(hCam1) ueye.is_ExitCamera(hCam2) # Destroys the OpenCv windows cv2.destroyAllWindows() print() print("END")
from pyueye import ueye hcam = ueye.HIDS(0) pccmem = ueye.c_mem_p() memID = ueye.c_int(0) ueye.is_InitCamera(hcam, None) sensorinfo = ueye.SENSORINFO() ueye.is_GetSensorInfo(hcam, sensorinfo) ueye.is_SetColorMode(hcam, ueye.IS_CM_SENSOR_RAW8) ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth, sensorinfo.nMaxHeight, 8, pccmem, memID) ueye.is_SetImageMem(hcam, pccmem, memID) ueye.is_SetExternalTrigger(hcam, ueye.IS_SET_TRIGGER_SOFTWARE) wertSet = ueye.c_double(1) nret = ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, wertSet, ueye.sizeof(wertSet)) print(wertSet) help(ueye.is_Exposure) wert = ueye.c_double() sizeo = ueye.sizeof(wert) nret = ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, wert, sizeo) print(wert) nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT) print(nret) FileParams = ueye.IMAGE_FILE_PARAMS() FileParams.pwchFileName = "c:\python-test-image.png" FileParams.nFileType = ueye.IS_IMG_PNG FileParams.ppcImageMem = None
def __init__(self, pathToParameterSets, fps): self.hCam = ueye.HIDS(0) self.sInfo = ueye.SENSORINFO() self.cInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() self.rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = ueye.INT(24) self.channels = 3 self.m_nColorMode = ueye.INT() self.bytes_per_pixel = int(self.nBitsPerPixel / 8) self.timeStampsFilePath = "times.txt" self.timeStampsFile = open(self.timeStampsFilePath, 'w') self.FPS = ctypes.c_double(int(fps)) self.pathToParameterSets = pathToParameterSets nRet = ueye.is_InitCamera(self.hCam, None) if nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo) if nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo) if nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") if int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", self.m_nColorMode) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() #loading parameter set file pParam = ueye.wchar_p() pParam.value = self.pathToParameterSets nRet = ueye.is_ParameterSet(self.hCam, ueye.IS_PARAMETERSET_CMD_LOAD_FILE, pParam, 0) if nRet != ueye.IS_SUCCESS: print("Setting parameter set error") #setting fps newFPS = ctypes.c_double(0) ueye.is_SetFrameRate(self.hCam, self.FPS, newFPS) if nRet != ueye.IS_SUCCESS: print("Setting fps ERROR") else: print("FPS is: ", newFPS) # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", self.cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", self.width) print("Maximum image height:\t", self.height) print()
def ueye_get_sensor_info(hcam) -> ueye.SENSORINFO: sensor_info = ueye.SENSORINFO() err = ueye.is_GetSensorInfo(hcam, sensor_info) _throw_if_err(hcam, err) return sensor_info
def getMaxSize(self): sensorinfo = ueye.SENSORINFO() ueye.is_GetSensorInfo(self.vc, sensorinfo) return (sensorinfo.nMaxWidth.value,sensorinfo.nMaxHeight.value)
print("START") print() # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(hCam, None) if nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(hCam, cInfo) if nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(hCam, sInfo) if nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault( hCam) if nRet != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB) # # Set the right color mode # if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # # setup the color depth to the current windows setting # ueye.is_GetColorDepth(hCam, nBitsPerPixel, m_nColorMode) # bytes_per_pixel = int(nBitsPerPixel / 8)
def initialize_camera(): #--------------------------------------------------------------------------------------------------------------------------------------- print("START") print() # Starts the driver and establishes the connection to the camera CameraApi.nRet = ueye.is_InitCamera(CameraApi.hCam, None) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to CameraApi.nRet = ueye.is_GetCameraInfo(CameraApi.hCam, CameraApi.cInfo) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera CameraApi.nRet = ueye.is_GetSensorInfo(CameraApi.hCam, CameraApi.sInfo) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") CameraApi.nRet = ueye.is_ResetToDefault(CameraApi.hCam) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB CameraApi.nRet = ueye.is_SetDisplayMode(CameraApi.hCam, ueye.IS_SET_DM_DIB) # Set the right color mode if int.from_bytes(CameraApi.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # setup the color depth to the current windows setting ueye.is_GetColorDepth(CameraApi.hCam, CameraApi.nBitsPerPixel, CameraApi.m_nColorMode) CameraApi.bytes_per_pixel = int(CameraApi.nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ", ) print("\tm_nColorMode: \t\t", CameraApi.m_nColorMode) print("\tnBitsPerPixel: \t\t", CameraApi.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", CameraApi.bytes_per_pixel) print() elif int.from_bytes(CameraApi.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_BGRA8_PACKED nBitsPerPixel = ueye.INT(32) CameraApi.bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", CameraApi.bytes_per_pixel) print() elif int.from_bytes(CameraApi.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) CameraApi.bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", CameraApi.bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) CameraApi.bytes_per_pixel = int(nBitsPerPixel / 8) print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image CameraApi.nRet = ueye.is_AOI(CameraApi.hCam, ueye.IS_AOI_IMAGE_GET_AOI, CameraApi.rectAOI, ueye.sizeof(CameraApi.rectAOI)) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") CameraApi.width = CameraApi.rectAOI.s32Width CameraApi.height = CameraApi.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", CameraApi.sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", CameraApi.cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", CameraApi.width) print("Maximum image height:\t", CameraApi.height) print() #--------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel CameraApi.nRet = ueye.is_AllocImageMem(CameraApi.hCam, CameraApi.width, CameraApi.height, CameraApi.nBitsPerPixel, CameraApi.pcImageMemory, CameraApi.MemID) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory CameraApi.nRet = ueye.is_SetImageMem(CameraApi.hCam, CameraApi.pcImageMemory, CameraApi.MemID) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode CameraApi.nRet = ueye.is_SetColorMode(CameraApi.hCam, CameraApi.m_nColorMode) # Activates the camera's live video mode (free run mode) CameraApi.nRet = ueye.is_CaptureVideo(CameraApi.hCam, ueye.IS_DONT_WAIT) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_CaptureVideo ERROR") # Enables the queue mode for existing image memory sequences CameraApi.nRet = ueye.is_InquireImageMem( CameraApi.hCam, CameraApi.pcImageMemory, CameraApi.MemID, CameraApi.width, CameraApi.height, CameraApi.nBitsPerPixel, CameraApi.pitch) if CameraApi.nRet != ueye.IS_SUCCESS: print("is_InquireImageMem ERROR") else: print("Press q to leave the programm")
def __init__(self, index): self.hCam = ueye.HIDS( index ) # 0: first available camera; 1-254: The camera with the specified camera ID self.sInfo = ueye.SENSORINFO() self.cInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() self.rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = ueye.INT( 24 ) # 24: bits per pixel for color mode; take 8 bits per pixel for monochrome channels = 3 # 3: channels for color mode(RGB); take 1 channel for monochrome self.m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 self.bytes_per_pixel = int(self.nBitsPerPixel / 8) # --------------------------------------------------------------------------------------------------------------------------------------- # print( "START" ) # print() # Starts the driver and establishes the connection to the camera self.nRet = ueye.is_InitCamera(self.hCam, None) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that self.cInfo # points to self.nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera self.nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_GetSensorInfo ERROR") self.nRet = ueye.is_ResetToDefault(self.hCam) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_ResetToDefault ERROR") # Set display mode to DIB self.nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) # Set the right color mode if int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # setup the color depth to the current windows setting ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel, self.m_nColorMode) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED self.nBitsPerPixel = ueye.INT(32) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image self.nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_AOI ERROR") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", self.cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", self.width) print("Maximum image height:\t", self.height) print() # --------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by width and height and its color depth # defined by nBitsPerPixel self.nRet = ueye.is_AllocImageMem(self.hCam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory self.nRet = ueye.is_SetImageMem(self.hCam, self.pcImageMemory, self.MemID) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_SetImageMem ERROR") else: # Set the desired color mode self.nRet = ueye.is_SetColorMode(self.hCam, self.m_nColorMode) # Activates the camera's live video mode (free run mode) self.nRet = ueye.is_CaptureVideo(self.hCam, ueye.IS_DONT_WAIT) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_CaptureVideo ERROR") # Enables the queue mode for existing image memory sequences self.nRet = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory, self.MemID, self.width, self.height, self.nBitsPerPixel, self.pitch) if self.nRet != ueye.IS_SUCCESS: raise Exception("is_InquireImageMem ERROR") else: print("Camera Connection success")
def Setup(self): # Setup camera's driver and color mode # Starts the driver and establishes the connection to the camera self.nRet = ueye.is_InitCamera(self.cam, None) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_InitCamera") self.nRet = ueye.is_SetExternalTrigger(self.cam, ueye.IS_SET_TRIGGER_LO_HI) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_SetExternalTrigger") # You can query additional information about the sensor type used in the camera self.nRet = ueye.is_GetSensorInfo(self.cam, self.sInfo) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_GetSensorInfo") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to self.nRet = ueye.is_GetCameraInfo(self.cam, self.cInfo) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_GetCameraInfo") # Set Auto Gain #self.set_gain_auto(1) # Take params from json param_from_json(self) # Set Gain self.set_gain(self.gain, self.rGain, self.gGain, self.bGain) # Set Pixelclock self.set_pixelclock(self.pixelclock) # Set Exposure self.set_exposure(self.exposure) # Set display mode to DIB self.nRet = ueye.is_SetDisplayMode(self.cam, ueye.IS_SET_DM_DIB) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_SetDisplayMode") self.get_bit_per_pixel(self.m_nColorMode) # Set Color Mode to BGR8 self.nRet = ueye.is_SetColorMode(self.cam, self.m_nColorMode) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_SetColorMode") # Set AOI self.nRet = ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_SET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_AOI") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", self.cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", self.width) print("Maximum image height:\t", self.height) print("Exposure:\t\t", self.get_exposure()) print("Frame rate:\t\t", self.current_fps) print("PixelClock:\t\t", self.get_pixelclock()) print("Gain:\t\t\t", self.get_gain()) print("rGain:\t\t\t", self.rGain) print("bGain:\t\t\t", self.bGain) print("gGain:\t\t\t", self.gGain) print("Color mode:\t\t", self.m_nColorMode) print("Bits per pixel:\t\t", int(self.bits_per_pixel)) print() self.alloc() self.nRet = self.capture_video() if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_CaptureVideo") print("Press \'Ctrl + C\' to leave the programm") print()
def cameraInit(load_parameters_EEPROM=load_parameters_EEPROM): """Initializes the camera with the correct parameters""" global mBuff, bpp, pitch, channels, bytes_per_pixel, tt hCam = ueye.HIDS(0) # 0: first available camera; 1-254: The camera with the specified camera ID sInfo = ueye.SENSORINFO() cInfo = ueye.CAMINFO() # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(hCam, None) logger.debug("Setting Camera Data") if nRet != ueye.IS_SUCCESS: logger.info("is_InitCamera ERROR, camera not connected?") return -1, 0 # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(hCam, cInfo) if nRet != ueye.IS_SUCCESS: logger.info("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(hCam, sInfo) if nRet != ueye.IS_SUCCESS: logger.info("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault(hCam) if nRet != ueye.IS_SUCCESS: logger.info("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB) if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode logger.info("Setting colormode to black and white") m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) bytes_per_pixel = int(nBitsPerPixel / 8) logger.info(f"IS_COLORMODE_MONOCHROME: ") logger.info(f"\tm_nColorMode: \t\t{m_nColorMode}") logger.info(f"\tnBitsPerPixel: \t\t{nBitsPerPixel}") logger.info(f"\tbytes_per_pixel: \t\t {bytes_per_pixel}") if load_parameters_EEPROM: logger.debug("Loading parameters from EEPROM") nullint = ueye._value_cast(0, ueye.ctypes.c_uint) rvv = ueye.is_ParameterSet(hCam, ueye.IS_PARAMETERSET_CMD_LOAD_EEPROM, nullint, nullint) # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI(hCam, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI)) if nRet != ueye.IS_SUCCESS: logger.error("is_AOI ERROR") width = rectAOI.s32Width height = rectAOI.s32Height # Prints out some information about the camera and the sensor logger.info(f"Camera model:\t\t {sInfo.strSensorName.decode('utf-8')}") logger.info(f"Camera serial no.:\t {cInfo.SerNo.decode('utf-8')}") logger.info(f"Maximum image width:\t {width}") logger.info(f"Maximum image height:\t {height}") # --------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel nRet = ueye.is_AllocImageMem(hCam, width, height, nBitsPerPixel, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: logger.info("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: logger.info("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam, m_nColorMode) # Activates the camera's live video mode (free run mode) nRet = ueye.is_CaptureVideo(hCam, ueye.IS_DONT_WAIT) if nRet != ueye.IS_SUCCESS: logger.info("is_CaptureVideo ERROR") # Enables the queue mode for existing image memory sequences nRet = ueye.is_InquireImageMem(hCam, pcImageMemory, MemID, width, height, nBitsPerPixel, pitch) if nRet != ueye.IS_SUCCESS: logger.info("is_InquireImageMem ERROR") else: logger.info("Press q to leave the programm") # --------------------------------------------------------------------------------------------------------------------------------------- # shutter = int.from_bytes(sInfo.bGlobShutter.value, byteorder='big') # rvv = ueye.is_ParameterSet(hCam,ueye.IS_PARAMETERSET_CMD_LOAD_EEPROM,nullint,nullint) # Continuous image display tt = ueye.is_AOI(hCam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) width = rect_aoi.s32Width.value height = rect_aoi.s32Height.value for i in range(numBuffers): buff = ImageBuffer() ueye.is_AllocImageMem(hCam, width, height, bpp, buff.mem_ptr, buff.mem_id) ueye.is_AddToSequence(hCam, buff.mem_ptr, buff.mem_id) buffs.append(buff) rvIQ = ueye.is_InitImageQueue(hCam, 0) nRet = ueye.IS_SUCCESS ret = ueye.is_WaitForNextImage(hCam, 100, mBuff.mem_ptr, mBuff.mem_id) rr = ueye.is_GetActSeqBuf(hCam, buffCurrent.mem_id, buffLast.mem_ptr, buffLast.mem_ptr) if (not ret): # cnt+=1 array = ueye.get_data(mBuff.mem_ptr, width, height, bpp, pitch, copy=True) ueye.is_UnlockSeqBuf(hCam, mBuff.mem_id, mBuff.mem_ptr) return nRet, hCam
def __get_sensor_info(self): if not ueye.is_GetSensorInfo(self.cam, self.sensor_info) == ueye.IS_SUCCESS: raise RuntimeError("Sensor Info not fetched") print("Sensor info acquired")
def open_connection(self, camID): """ Function taking care of the Thorlabs camera initialization. Parameters ---------- camID : int - indicate the handle of the camera we want to intialize. """ # Starts the driver and establishes the connection to the camera # -------------------------------------------------------------- self.hcam = ueye.HIDS(camID) Init = ueye.is_InitCamera(self.hcam, None) if Init != ueye.IS_SUCCESS: print( "is_InitCamera ERROR - make sure the camera is properly connected" ) self.cam_initialized.emit('') return # Reads out the data hard-coded in the non-volatile camera memory and # writes it to the data structure that cInfo points to # ---------------------------------------------------- read_cam_info = ueye.is_GetCameraInfo(self.hcam, self.cam_info) if read_cam_info != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") self.cam_initialized.emit('') return # You can query additional information about the sensor type used in # the camera # ---------- read_sensor_info = ueye.is_GetSensorInfo(self.hcam, self.sensor_info) if read_sensor_info != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") self.cam_initialized.emit('') return # Reset buffer and all the display parameters to the default values # ----------------------------------------------------------------- reset = ueye.is_ResetToDefault(self.hcam) if reset != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") self.cam_initialized.emit('') return # Set display mode to DIB - the image is directly saved on the RAM # ---------------------------------------------------------------- ueye.is_SetDisplayMode(self.hcam, ueye.IS_SET_DM_DIB) # Set the color mode according to the sensor properties # ----------------------------------------------------- if int.from_bytes(self.sensor_info.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED self.nBitsPerPixel = ueye.INT(32) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) self.color_mode = 'RGB' elif int.from_bytes(self.sensor_info.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) self.color_mode = 'Monochrome' else: print('Error : the camera type is unknown.') self.cam_initialized.emit('') return # Define a dictionary with the main properties of the camera selected # ------------------------------------------------------------------- ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) self.Properties = { 'Camera sensor model (from IDS)': self.sensor_info.strSensorName.decode('utf-8'), 'Camera s/n': self.cam_info.SerNo.decode('utf-8'), 'Color mode': self.color_mode, 'Image width': int(self.rectAOI.s32Width), 'Image height': int(self.rectAOI.s32Height), } # Indicate that the initialization procedure was completed # -------------------------------------------------------- print('Success : Thorlabs camera was found and initialized') self.cam_initialized.emit(self.Properties['Camera s/n'])
def __init__(self, cam_num=0): self.name = f"IDS Camera {cam_num:}" self.hCam = ueye.HIDS(cam_num) self.sInfo = ueye.SENSORINFO() self.cInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() self.rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = ueye.INT( 24 ) # 24: bits per pixel for color mode; take 8 bits per pixel for monochrome self.channels = ( 3 # 3: channels for color mode(RGB); take 1 channel for monochrome ) self.m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 self.bytes_per_pixel = int(self.nBitsPerPixel / 8) # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(self.hCam, None) if nRet != ueye.IS_SUCCESS: raise RuntimeError(f"is_InitCamera ERROR {nRet:}") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo) if nRet != ueye.IS_SUCCESS: raise RuntimeError("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo) if nRet != ueye.IS_SUCCESS: raise RuntimeError("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault(self.hCam) if nRet != ueye.IS_SUCCESS: raise RuntimeError("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) # Set the right color mode if (int.from_bytes(self.sInfo.nColorMode.value, byteorder="big") == ueye.IS_COLORMODE_BAYER): # setup the color depth to the current windows setting ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel, self.m_nColorMode) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ") print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif (int.from_bytes(self.sInfo.nColorMode.value, byteorder="big") == ueye.IS_COLORMODE_CBYCRY): # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED self.nBitsPerPixel = ueye.INT(32) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ") print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif (int.from_bytes(self.sInfo.nColorMode.value, byteorder="big") == ueye.IS_COLORMODE_MONOCHROME): # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ") print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) # print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI( self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI), ) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sInfo.strSensorName.decode("utf-8")) print("Camera serial no.:\t", self.cInfo.SerNo.decode("utf-8")) print("Maximum image width:\t", self.width) print("Maximum image height:\t", self.height) print() nRet = ueye.is_AllocImageMem( self.hCam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID, ) if nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(self.hCam, self.pcImageMemory, self.MemID) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(self.hCam, self.m_nColorMode)
def __init__(self, deviceID): self.deviceID = deviceID DeviceID = self.deviceID | ueye.IS_USE_DEVICE_ID self.hCam = ueye.HIDS(DeviceID) self.sensorInfo = ueye.SENSORINFO() self.camInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = 10 #24: bits per pixel for color mode; take 8 bits per pixel for monochrome channels = 1 #3: channels for color mode(RGB); take 1 channel for monochrome m_nColorMode = ueye.IS_CM_MONO10 # Y8/RGB16/RGB24/REG32 bytes_per_pixel = int(self.nBitsPerPixel / 8) #nColorMode = IS_CM_MONO10; #self.nBitsPerPixel = 10; # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(self.hCam, None) if nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that self.camInfo points to nRet = ueye.is_GetCameraInfo(self.hCam, self.camInfo) if nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(self.hCam, self.sensorInfo) if nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault(self.hCam) if nRet != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) if int.from_bytes(self.sensorInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_MONO10 self.nBitsPerPixel = ueye.INT(10) self.bytes_per_pixel = int(self.nBitsPerPixel / 7) + 1 print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) + 1 print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI)) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") self.width = rectAOI.s32Width self.height = rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sensorInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", self.camInfo.SerNo.decode('utf-8')) print("Maximum image self.width:\t", self.width) print("Maximum image self.height:\t", self.height) print() #--------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by self.width # and self.height and its color depth defined by self.nBitsPerPixel nRet = ueye.is_AllocImageMem(self.hCam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID) if nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(self.hCam, self.pcImageMemory, self.MemID) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(self.hCam, m_nColorMode)
def main(): from pyueye import ueye import numpy as np import cv2 import sys import os import tensorflow as tf import SoundTheAlarm import time # --------------------------------------------------------------------------------------------------------------------------------------- # This is needed since the notebook is stored in the object_detection folder. sys.path.append("..") # Import utilites from utils import label_map_util from utils import visualization_utils as vis_util # Name of the directory containing the object detection module we're using MODEL_NAME = 'inference_graph' # Grab path to current working directory CWD_PATH = os.getcwd() # Path to frozen detection graph .pb file, which contains the model that is used # for object detection. PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') # Path to label map file PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') # Number of classes the object detector can identify NUM_CLASSES = 3 ## Load the label map. # Label maps map indices to category names, so that when our convolution # network predicts `5`, we know that this corresponds to `king`. # Here we use internal utility functions, but anything that returns a # dictionary mapping integers to appropriate string labels would be fine label_map = label_map_util.load_labelmap(PATH_TO_LABELS) categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True) category_index = label_map_util.create_category_index(categories) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Output tensors are the detection boxes, scores, and classes # Each box represents a part of the image where a particular object was detected detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0') # Each score represents level of confidence for each of the objects. # The score is shown on the result image, together with the class label. detection_scores = detection_graph.get_tensor_by_name('detection_scores:0') detection_classes = detection_graph.get_tensor_by_name('detection_classes:0') # Number of objects detected num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Variables hCam = ueye.HIDS(0) # 0: first available camera; 1-254: The camera with the specified camera ID sInfo = ueye.SENSORINFO() cInfo = ueye.CAMINFO() pcImageMemory = ueye.c_mem_p() MemID = ueye.int() rectAOI = ueye.IS_RECT() pitch = ueye.INT() nBitsPerPixel = ueye.INT(24) # 24: bits per pixel for color mode; take 8 bits per pixel for monochrome channels = 3 # 3: channels for color mode(RGB); take 1 channel for monochrome m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 ueye.is_SetColorMode(hCam, ueye.IS_CM_BGR8_PACKED) bytes_per_pixel = int(nBitsPerPixel / 8) # --------------------------------------------------------------------------------------------------------------------------------------- print("START") print() # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(hCam, None) if nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(hCam, cInfo) if nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(hCam, sInfo) if nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault(hCam) if nRet != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB) # Set the right color mode if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # setup the color depth to the current windows setting ueye.is_GetColorDepth(hCam, nBitsPerPixel, m_nColorMode) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_BGRA8_PACKED nBitsPerPixel = ueye.INT(32) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) bytes_per_pixel = int(nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", m_nColorMode) print("\tnBitsPerPixel: \t\t", nBitsPerPixel) print("\tbytes_per_pixel: \t\t", bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode m_nColorMode = ueye.IS_CM_MONO8 nBitsPerPixel = ueye.INT(8) bytes_per_pixel = int(nBitsPerPixel / 8) print("else") # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI(hCam, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI)) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") width = rectAOI.s32Width height = rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", width) print("Maximum image height:\t", height) print() # --------------------------------------------------------------------------------------------------------------------------------------- # Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel nRet = ueye.is_AllocImageMem(hCam, width, height, nBitsPerPixel, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: print("is_AllocImageMem ERROR") else: # Makes the specified image memory the active memory nRet = ueye.is_SetImageMem(hCam, pcImageMemory, MemID) if nRet != ueye.IS_SUCCESS: print("is_SetImageMem ERROR") else: # Set the desired color mode nRet = ueye.is_SetColorMode(hCam, m_nColorMode) # Activates the camera's live video mode (free run mode) nRet = ueye.is_CaptureVideo(hCam, ueye.IS_DONT_WAIT) if nRet != ueye.IS_SUCCESS: print("is_CaptureVideo ERROR") # Enables the queue mode for existing image memory sequences nRet = ueye.is_InquireImageMem(hCam, pcImageMemory, MemID, width, height, nBitsPerPixel, pitch) if nRet != ueye.IS_SUCCESS: print("is_InquireImageMem ERROR") else: print("Press q to leave the programm") # -----------------------------------start image loop--------------------------------------------------------------- # Continuous image display while (nRet == ueye.IS_SUCCESS): # In order to display the image in an OpenCV window we need to... # ...extract the data of our image memory array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False) # bytes_per_pixel = int(nBitsPerPixel / 8) # ...reshape it in an numpy array... frame = np.reshape(array, (height.value, width.value, bytes_per_pixel)) frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) # ------------------------------------------network_run--------------------------------------------------------- frame_expanded = np.expand_dims(frame, axis=0) # Perform the actual detection by running the model with the image as input (boxes, scores, classes, num) = sess.run( [detection_boxes, detection_scores, detection_classes, num_detections], feed_dict={image_tensor: frame_expanded}) # print("check this point-2") # Draw the results of the detection (aka 'visualize the results') vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.85) counter = [] add = 0 while add < (NUM_CLASSES + 1): counter.append(0) add += 1 element = 0 # i used this loop to configure the alarm for i in classes[0]: # it uses the variables to count how many of each object appear in each image if (scores[0][element]) > 0.85: #=min_score_thresh # use it to feed an alarm detector script based on counter[int(i)] += 1 # what "should" and "shouldn't" appear element += 1 else: break #the break stops from iterating through the entire array, which is uneccessary ####---the alarm protocol---#### #if counter[2] and counter[3]: #if not counter[1]: #SoundTheAlarm.sound_loop() print("number of each class", counter) # All the results have been drawn on the frame, so it's time to display it. frame = cv2.resize(frame, None, fx=0.5, fy=0.5) cv2.destroyAllWindows() # -------------------------------------------------------------------------------------------------------------- # ...and finally display it cv2.imshow("SimpleLive_Python_uEye_OpenCV", frame) # Press q if you want to end the loop if cv2.waitKey(1) & 0xFF == ord('q'): break time.sleep(0.5) # ------------------------------------------------------------------------------------------------------------------ # Releases an image memory that was allocated using is_AllocImageMem() and removes it from the driver management ueye.is_FreeImageMem(hCam, pcImageMemory, MemID) # Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera ueye.is_ExitCamera(hCam) # Destroys the OpenCv windows cv2.destroyAllWindows() print() print("END")
def UEye420_Snapper(Exposure, Gain, File_Location, pixel_clock): from pyueye import ueye import ctypes import time saved = False while saved == False: #CCD Settings and Start-Up hcam = ueye.HIDS(0) pccmem = ueye.c_mem_p() memID = ueye.c_int() hWnd = ctypes.c_voidp() ueye.is_InitCamera(hcam, hWnd) ueye.is_SetDisplayMode(hcam, 0) sensorinfo = ueye.SENSORINFO() ueye.is_GetSensorInfo(hcam, sensorinfo) ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth, sensorinfo.nMaxHeight, 24, pccmem, memID) ueye.is_SetImageMem(hcam, pccmem, memID) ueye.is_SetDisplayPos(hcam, 100, 100) PIXELCLOCK_CMD_SET = 6 PIXELCLOCK_CMD_GET = 4 pixel = ctypes.c_uint(pixel_clock) ueye.is_PixelClock(hcam, PIXELCLOCK_CMD_SET, pixel, ctypes.sizeof(pixel)) print('PX=', pixel) exposure_time = ctypes.c_double( Exposure) #Exposure time in miliseconds value = ctypes.c_int(Gain) ueye.is_SetHWGainFactor(hcam, ueye.IS_SET_MASTER_GAIN_FACTOR, value) ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure_time, ctypes.sizeof(ctypes.c_double)) print('Exposure (ms) =', exposure_time) print('Gain = ', Gain) time.sleep(float(Exposure * 1e-4) * 1.0 + 0.2) #Some time for CCD to set new exposure time #initially set to float(Exposure*1e-4)*1.0+1.0 and it works then nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT) #Freeze/Snap #Save Parameters FileParams = ueye.IMAGE_FILE_PARAMS() FileParams.pwchFileName = (File_Location) FileParams.nFileType = ueye.IS_IMG_BMP FileParams.ppcImageMem = None FileParams.pnImageID = None #IF nret is '1' Image is not saved if nret is "0" Image is saved nret = ueye.is_ImageFile(hcam, ueye.IS_IMAGE_FILE_CMD_SAVE, FileParams, ueye.sizeof(FileParams)) if nret == 0: saved = True print('Image Saved!') if nret == 1: print('Error Image is not Saved!') #Shutting the CCD-Down. ueye.is_FreeImageMem(hcam, pccmem, memID) ueye.is_ExitCamera(hcam)
def __init__(self): #Variables self.hCam = ueye.HIDS(0) #0: first available camera; 1-254: The camera with the specified camera ID self.sInfo = ueye.SENSORINFO() self.cInfo = ueye.CAMINFO() self.pcImageMemory = ueye.c_mem_p() self.MemID = ueye.int() self.rectAOI = ueye.IS_RECT() self.pitch = ueye.INT() self.nBitsPerPixel = ueye.INT(24) #24: bits per pixel for color mode; take 8 bits per pixel for monochrome self.channels = 3 #3: channels for color mode(RGB); take 1 channel for monochrome self.m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32 self.bytes_per_pixel = int(self.nBitsPerPixel / 8) self.exposure = ueye.DOUBLE(10) # Starts the driver and establishes the connection to the camera nRet = ueye.is_InitCamera(self.hCam, None) if nRet != ueye.IS_SUCCESS: print("is_InitCamera ERROR") # Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo) if nRet != ueye.IS_SUCCESS: print("is_GetCameraInfo ERROR") # You can query additional information about the sensor type used in the camera nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo) if nRet != ueye.IS_SUCCESS: print("is_GetSensorInfo ERROR") nRet = ueye.is_ResetToDefault(self.hCam) if nRet != ueye.IS_SUCCESS: print("is_ResetToDefault ERROR") # Set display mode to DIB nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB) # Set the right color mode if int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER: # setup the color depth to the current windows setting ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel, self.m_nColorMode) self.nBitsPerPixel = ueye.INT(32) #------------Added this because it gets changed on linux and that f***s everything up. self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_BAYER: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED self.nBitsPerPixel = ueye.INT(32) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_CBYCRY: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() elif int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME: # for color camera models use RGB32 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("IS_COLORMODE_MONOCHROME: ", ) print("\tm_nColorMode: \t\t", self.m_nColorMode) print("\tnBitsPerPixel: \t\t", self.nBitsPerPixel) print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel) print() else: # for monochrome camera models use Y8 mode self.m_nColorMode = ueye.IS_CM_MONO8 self.nBitsPerPixel = ueye.INT(8) self.bytes_per_pixel = int(self.nBitsPerPixel / 8) print("else") nRet = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.exposure, ueye.sizeof(self.exposure))#TODO # Can be used to set the size and position of an "area of interest"(AOI) within an image nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height # Prints out some information about the camera and the sensor print("Camera model:\t\t", self.sInfo.strSensorName.decode('utf-8')) print("Camera serial no.:\t", self.cInfo.SerNo.decode('utf-8')) print("Maximum image width:\t", self.width) print("Maximum image height:\t", self.height) print() #Allocate image dimensions self.update_image_memory()