def init_cam(hcam): # get fps # hcam_fps = is_GetFramesPerSecond(hcam, None) # set color mode ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED) # set region of interest rect_aoi = ueye.IS_RECT() rect_aoi.s32X = ueye.int(0) rect_aoi.s32Y = ueye.int(0) rect_aoi.s32Width = ueye.int(width) rect_aoi.s32Height = ueye.int(height) ueye.is_AOI(hcam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) # allocate memory mem_ptr = ueye.c_mem_p() mem_id = ueye.int() ueye.is_AllocImageMem(hcam, width, height, bitspixel, mem_ptr, mem_id) ueye.is_SetImageMem(hcam, mem_ptr, mem_id) # continuous capture to memory ueye.is_CaptureVideo(hcam, ueye.IS_DONT_WAIT) return mem_ptr
def convert_image_data(self): rect_aoi = ueye.IS_RECT() bits_per_pixel = 24 converted_image_data = ImageData() conversion_params = ueye.BUFFER_CONVERSION_PARAMS() ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) converted_image_data.memory_pointer = self.converted_memory_pointer converted_image_data.memory_id = self.converted_memory_id converted_image_data.width = rect_aoi.s32Width converted_image_data.height = rect_aoi.s32Height converted_image_data.bits_per_pixel = bits_per_pixel conversion_params.nDestPixelFormat = ueye.IS_CM_RGB8_PACKED conversion_params.pSourceBuffer = self.img_data.memory_pointer conversion_params.pDestBuffer = converted_image_data.memory_pointer conversion_params.nDestPixelConverter = ueye.IS_CONV_MODE_SOFTWARE_3X3 conversion_params.nDestColorCorrectionMode = ueye.IS_CCOR_DISABLE conversion_params.nDestGamma = ueye.INT(100) conversion_params.nDestSaturationU = ueye.INT(100) conversion_params.nDestSaturationV = ueye.INT(100) conversion_params.nDestEdgeEnhancement = ueye.INT(0) ueye.is_Convert(self.hCam, ueye.IS_CONVERT_CMD_APPLY_PARAMS_AND_CONVERT_BUFFER, conversion_params, ueye.sizeof(conversion_params)) return converted_image_data
def get_aoi(self): rect_aoi = ueye.IS_RECT() ueye.is_AOI(self.h_cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) return Rect(rect_aoi.s32X.value, rect_aoi.s32Y.value, rect_aoi.s32Width.value, rect_aoi.s32Height.value)
def get_aoi(self): rect_aoi = ueye.IS_RECT() ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) # --- --- # x, y, width, height = rect_aoi.s32X.value, rect_aoi.s32Y.value, rect_aoi.s32Width.value, rect_aoi.s32Height.value # --- --- # #self.frame_buffer = np.zeros([height,width]) #self.frame_color_buffer = np.zeros([height,width,3]) return x, y, width, height
def get_aoi(self): """ Get the current area of interest. Returns ======= rect: Rect object Area of interest """ ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) return Rect(self.rectAOI.s32X.value, self.rectAOI.s32Y.value, self.rectAOI.s32Width.value, self.rectAOI.s32Height.value)
def Camera_Initialization(self): self.hcam = ueye.HIDS(0) self.ret = ueye.is_InitCamera(self.hcam, None) self.ret = ueye.is_SetColorMode(self.hcam, ueye.IS_CM_MONO12) self.IDS_FPS = float(50) self.newrate = ueye.DOUBLE(self.IDS_FPS) self.rate = ueye.DOUBLE(self.IDS_FPS) self.IDS_exposure = float(20) self.width = 2056 self.height = 1542 self.rect_aoi = ueye.IS_RECT() self.rect_aoi.s32X = ueye.int(0) self.rect_aoi.s32Y = ueye.int(0) self.rect_aoi.s32Width = ueye.int(self.width) self.rect_aoi.s32Height = ueye.int(self.height) ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_SET_AOI, self.rect_aoi, ueye.sizeof(self.rect_aoi)) self.mem_ptr = ueye.c_mem_p() self.mem_id = ueye.int() self.bitspixel = 16 self.ret = ueye.is_AllocImageMem(self.hcam, self.width, self.height, self.bitspixel, self.mem_ptr, self.mem_id) self.ret = ueye.is_SetImageMem(self.hcam, self.mem_ptr, self.mem_id) self.ret = ueye.is_CaptureVideo(self.hcam, ueye.IS_DONT_WAIT) #self.lineinc = self.width * int((self.bitspixel + 7) / 8) self.lineinc = self.width * int(self.bitspixel / 8) self.nRet = ueye.is_SetFrameRate(self.hcam, self.rate, self.newrate) self.expms = ueye.DOUBLE(self.IDS_exposure) self.nRet = ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.expms, ueye.sizeof(self.expms)) self.pixelclock = ueye.c_uint(197) self.nRet = ueye.is_PixelClock(self.hcam, ueye.IS_PIXELCLOCK_CMD_SET, self.pixelclock, 4) #pixelclock = ueye.c_uint() #ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, pixelclock, 4) self.nRet = ueye.is_SetHardwareGain(self.hcam, 100, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER) #gg = ueye.c_uint() #ueye.is_SetHWGainFactor(hcam, ueye.IS_GET_MASTER_GAIN_FACTOR, gg) self.nRet = ueye.is_SetHardwareGamma(self.hcam, ueye.IS_SET_HW_GAMMA_ON)
def get_aoi(self): """ Get the current area of interest. Returns ======= rect: Rect object Area of interest """ rect_aoi = ueye.IS_RECT() ueye.is_AOI(self.h_cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) return Rect(rect_aoi.s32X.value, rect_aoi.s32Y.value, rect_aoi.s32Width.value, rect_aoi.s32Height.value)
def init_cam(hcam): # get fps # hcam_fps = is_GetFramesPerSecond(hcam, None) # set color mode ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED) # set region of interest rect_aoi = ueye.IS_RECT() rect_aoi.s32X = ueye.int(0) rect_aoi.s32Y = ueye.int(0) rect_aoi.s32Width = ueye.int(width) rect_aoi.s32Height = ueye.int(height) ueye.is_AOI(hcam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) # # # set parameters, see ids doc for parameter setting flow chart # ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, exp, ueye.sizeof(pclock)) # pclock = ueye.int(220) # ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, pclock, ueye.sizeof(pclock)) # # expo_rng = ueye.is_Exposure(hcam, IS_EXPOSURE_CMD_GET_CAPS, ncap, size(ncap)) # ftime_rng = ueye.is_GetFrameTimeRange() # expo_rng = (expo_rng[0], max(expo_rng[1], ftime_rng[1])) # # fps_actual = ueye.cdouble() # ueye.is_SetFrameRate(hcam, ueye.cdouble(fps_set), byref(fps_actual)) # # exp_cap = ueye.uint32() # ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_GET_EXPOSURE_RANGE, ueye.byref(exp_cap), ueye.sizeof(exp_cap)) # exp_cur = ueye.cdouble() # in s # ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_SET_EXPOSURE, ueye.byref(exp_cur), ueye.sizeof(exp_cur)) # ueye.is_SetGainBoost() # ueye.is_Gamma() # ueye.is_SetHWGainFactor() # # allocate memory mem_ptr = ueye.c_mem_p() mem_id = ueye.int() ueye.is_AllocImageMem(hcam, width, height, bitspixel, mem_ptr, mem_id) ueye.is_SetImageMem(hcam, mem_ptr, mem_id) # continuous capture to memory ueye.is_CaptureVideo(hcam, ueye.IS_DONT_WAIT) return mem_ptr
def setAOI(self): self.ret = ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if self.ret != ueye.IS_SUCCESS: print("is_AOI ERROR") self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height
def Init_Cam(width=640, heigth=480, gain_boost=1): """inits the uEye camera""" # inits next available cam cam = ueye.HIDS(0) ueye.is_InitCamera(cam, None) ueye.is_EnableAutoExit(cam, ueye.IS_ENABLE_AUTO_EXIT) # sets the Colourmode of the camera ueye.is_SetColorMode(cam, ueye.IS_CM_SENSOR_RAW8) # sets the trigger ret = ueye.is_SetExternalTrigger(cam, ueye.IS_SET_TRIGGER_SOFTWARE) mode = ueye.int(0) # sets the blacklevel ueye.is_Blacklevel(cam, ueye.IS_BLACKLEVEL_CMD_SET_MODE, mode, ueye.sizeof(mode)) # sets the size of the image rectAOI = ueye.IS_RECT() rectAOI.s32X = 44 rectAOI.s32Y = 0 rectAOI.s32Width = 480 rectAOI.s32Height = 480 ueye.is_AOI(cam, ueye.IS_AOI_IMAGE_SET_AOI, rectAOI, ueye.sizeof(rectAOI)) # allocates memory with given size width = ueye.int(width) heigth = ueye.int(heigth) bitspixel = ueye.int(8) pcImgMem = ueye.c_mem_p() pid = ueye.int() ueye.is_AllocImageMem(cam, 480, heigth, bitspixel, pcImgMem, pid) # sets the image memory as active ueye.is_SetImageMem(cam, pcImgMem, pid) # activates video mode ueye.is_CaptureVideo(cam, ueye.IS_DONT_WAIT) # sets gain boost mode if gain_boost == 1: ueye.is_SetGainBoost(cam, ueye.IS_SET_GAINBOOST_ON) else: ueye.is_SetGainBoost(cam, ueye.IS_SET_GAINBOOST_OFF) return cam, ret, pcImgMem, pid
def show_image(self): nRet = ueye.is_InitCamera(self.h_cam, None) nRet = ueye.is_SetDisplayMode(self.h_cam, ueye.IS_SET_DM_DIB) nRet = ueye.is_AOI(self.h_cam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) self.width = self.rectAOI.s32Width self.height = self.rectAOI.s32Height nRet = ueye.is_AllocImageMem(self.h_cam, self.width, self.height, self.nBitsPerPixel, self.pcImageMemory, self.MemID) nRet = ueye.is_SetImageMem(self.h_cam, self.pcImageMemory, self.MemID) nRet = ueye.is_SetColorMode(self.h_cam, self.ColorMode) nRet = ueye.is_CaptureVideo(self.h_cam, ueye.IS_DONT_WAIT) nRet = ueye.is_InquireImageMem(self.h_cam, self.pcImageMemory, self.MemID, self.width, self.height, self.nBitsPerPixel, self.pitch) while nRet == ueye.IS_SUCCESS: array = ueye.get_data(self.pcImageMemory, self.width, self.height, self.nBitsPerPixel, self.pitch, copy=False) frame = np.reshape( array, (self.height.value, self.width.value, self.bytes_per_pixel)) frame = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5) size = (self.height, self.width) new_camera_matrix, roi = cv2.getOptimalNewCameraMatrix( self.camera_matrix, self.dist_coeff, size, 1, size) dst = cv2.undistort(frame, self.camera_matrix, self.dist_coeff, None, new_camera_matrix) x, y, w, h = roi self.dst = dst[y:y + h, x:x + w] self.detect_colors() self.extrinsic_calibration() cv2.imshow("camera", self.dst) if cv2.waitKey(1) & 0xFF == ord('q'): break elif cv2.waitKey(1) & 0xFF == ord('t'): cv2.imwrite("/home/lennart/dorna/camera/images/gps.bmp", self.dst) elif cv2.waitKey(100) & 0xFF == ord('l'): self.found_container = False self.container_world_position.clear() print("Behälterposition zurückgesetzt") ueye.is_FreeImageMem(self.h_cam, self.pcImageMemory, self.MemID) ueye.is_ExitCamera(self.h_cam) cv2.destroyAllWindows()
def set_aoi(self, x, y, width, height): rect_aoi = ueye.IS_RECT() rect_aoi.s32X = ueye.int(x) rect_aoi.s32Y = ueye.int(y) rect_aoi.s32Width = ueye.int(width) rect_aoi.s32Height = ueye.int(height) return ueye.is_AOI(self.h_cam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi))
def alloc(self, h_cam): rect_aoi = ueye.IS_RECT() memory_id = ueye.int() memory_pointer = ueye.c_mem_p() bits_per_pixel = 8 ueye.is_AOI(h_cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) ueye.is_AllocImageMem(h_cam, rect_aoi.s32Width, rect_aoi.s32Height, bits_per_pixel, memory_pointer, memory_id) ueye.is_SetImageMem(h_cam, memory_pointer, memory_id) self.img_data.memory_pointer = memory_pointer self.img_data.memory_id = memory_id self.img_data.width = rect_aoi.s32Width self.img_data.height = rect_aoi.s32Height self.img_data.bits_per_pixel = bits_per_pixel ueye.is_AllocImageMem(h_cam, rect_aoi.s32Width, rect_aoi.s32Height, 24, self.converted_memory_pointer, self.converted_memory_id)
def __get_dimensions(self): if not ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_GET_AOI, self.rect_aoi, ueye.sizeof(self.rect_aoi)) == ueye.IS_SUCCESS: raise RuntimeError("Dimensions not fetched") self.width = self.rect_aoi.s32Width self.height = self.rect_aoi.s32Height print("Sensor dimensions acquired")
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 set_aoi(self, x, y, width, height): rect_aoi = ueye.IS_RECT() rect_aoi.s32X = ueye.int(x) rect_aoi.s32Y = ueye.int(y) rect_aoi.s32Width = ueye.int(width) rect_aoi.s32Height = ueye.int(height) # --- --- # hasWorked = ueye.is_AOI( self.cam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) # set and return the success of AOI change #print('SET AOI: ', hasWorked ) return hasWorked
def getAOI(self): self.AOI=ueye.IS_RECT() if ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_GET_AOI, self.AOI, ueye.sizeof(self.AOI)): _logger.error("Error retrinving AOI") self.status=True return True x0=self.AOI.s32X.value y0=self.AOI.s32Y.value width=self.AOI.s32Width.value height=self.AOI.s32Height.value self.xaxis=np.arange(width)+x0 self.yaxis=np.arange(height)+y0 return False
def GetROI(self): """ Returns ------- The ROI, [x1, y1, x2, y2] in the numpy convention used by SetROI """ aoi = ueye.IS_RECT() self.check_success( ueye.is_AOI(self.h, ueye.IS_AOI_IMAGE_GET_AOI, aoi, ueye.sizeof(aoi))) x0, y0 = aoi.s32X.value, aoi.s32Y.value return x0, y0, x0 + aoi.s32Width.value, y0 + aoi.s32Height.value
def __init__(self, h_cam, img_buff): self.x = ueye.int() self.y = ueye.int() self.bits = ueye.int() self.pitch = ueye.int() self.img_buff = img_buff rect_aoi = ueye.IS_RECT() check(ueye.is_AOI(h_cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi))) self.width = rect_aoi.s32Width.value self.height = rect_aoi.s32Height.value check(ueye.is_InquireImageMem(h_cam, self.img_buff.mem_ptr, self.img_buff.mem_id, self.x, self.y, self.bits, self.pitch))
def initialize_dimensions(self): ''' Gets dimensions of the camera. Sets: self.width self.height ''' log.info('Getting camera dimensions...') rectAOI = ueye.IS_RECT() nRet = ueye.is_AOI(self.input, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI)) if nRet != ueye.IS_SUCCESS: log.error("is_AOI ERROR") self.width = rectAOI.s32Width self.height = rectAOI.s32Height self.config['res'] = (self.width.value, self.height.value)
def set_aoi(self, x, y, width, height): """ Set the area of interest. Parameters ========== x, y, width, height: integers Position and size of the area of interest. """ rect_aoi = ueye.IS_RECT() rect_aoi.s32X = ueye.int(x) rect_aoi.s32Y = ueye.int(y) rect_aoi.s32Width = ueye.int(width) rect_aoi.s32Height = ueye.int(height) return ueye.is_AOI(self.h_cam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi))
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 getImageData(self): # --- set AOI --- # rect_aoi = ueye.IS_RECT() hasWorked = ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) self.check(hasWorked, 'getImageData') # --- --- # x = ueye.int() y = ueye.int() bits = ueye.int() pitch = ueye.int() self.frame_width = rect_aoi.s32Width.value self.frame_height = rect_aoi.s32Height.value hasWorked = ueye.is_InquireImageMem(self.cam, self.img_buffer.mem_ptr, self.img_buffer.mem_id, x, y, bits, pitch) self.check(hasWorked, 'getImageData') self.imgdata = ueye.get_data(self.img_buffer.mem_ptr, self.frame_width, self.frame_height, bits, pitch, True)
def setAOI(self, x0, y0, width, height): self.AOI=ueye.IS_RECT() if (x0<0)|((x0+width)>self.sensorInfo.nMaxWidth.value): self.status=True return True if (y0<0)|((y0+height)>self.sensorInfo.nMaxHeight.value): self.status=True return True self.AOI.s32X.value=x0 self.AOI.s32Y.value=y0 self.AOI.s32Width.value=width self.AOI.s32Height.value=height self.xaxis=np.arange(width)+x0 self.yaxis=np.arange(height)+y0 if ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_SET_AOI, self.AOI, ueye.sizeof(self.AOI)): self.status=True return True return False
def allocate_memory(self): """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_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI)) if nRet != ueye.IS_SUCCESS: print("is_AOI ERROR") nRet = ueye.is_AllocImageMem(self.hCam, self.rectAOI.s32Width, self.rectAOI.s32Height, 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, cam, img_buffer): self.x = ueye.int() self.y = ueye.int() self.bits = ueye.int() self.pitch = ueye.int() self.img_buff = img_buffer rect_aoi = ueye.IS_RECT() nRet = ueye.is_AOI(cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi)) if nRet != ueye.IS_SUCCESS: error_log(nRet, "is_Aoi") self.width = rect_aoi.s32Width.value self.height = rect_aoi.s32Height.value nRet = ueye.is_InquireImageMem(cam, self.img_buff.mem_ptr, self.img_buff.mem_id, self.x, self.y, self.bits, self.pitch) if nRet != ueye.IS_SUCCESS: error_log(nRet, "is_InquireImageMem")
def SetROI(self, x1, y1, x2, y2): """ Set the ROI via coordinates (as opposed to via an index). Parameters ---------- x1 : int Left x-coordinate, zero-indexed y1 : int Top y-coordinate, zero-indexed x2 : int Right x-coordinate, (excluded from ROI) y2 : int Bottom y-coordinate, (excluded from ROI) Returns ------- None """ logger.debug('setting ROI: %d, %d, %d, %d' % (x1, y1, x2, y2)) limits = ROI_LIMITS[self.sensor_type] x1 = max(x1, limits['xmin']) y1 = max(y1, limits['ymin']) x2 = min(x2, self.GetCCDWidth()) y2 = min(y2, self.GetCCDHeight()) x_change = (x2 - x1) % limits['xstep'] y_change = (y2 - y1) % limits['ystep'] x2 -= x_change y2 -= y_change logger.debug('adjusted ROI: %d, %d, %d, %d' % (x1, y1, x2, y2)) aoi = ueye.IS_RECT(x1, y1, x2 - x1, y2 - y1) self.check_success( ueye.is_AOI(self.h, ueye.IS_AOI_IMAGE_SET_AOI, aoi, ueye.sizeof(aoi))) # have to set the integration time explicitly after changing AOI self.SetIntegTime(self.GetIntegTime())
import time uEyeDll = ctypes.cdll.LoadLibrary(r"C:\Windows\System32\uEye_api_64.dll") cam = ctypes.c_uint32(0) hWnd = ctypes.c_voidp() msg = uEyeDll.is_InitCamera(ctypes.byref(cam), hWnd) uEyeDll.is_EnableAutoExit(cam, ctypes.c_uint(1)) col = ueye.c_int(0) mod = ueye.c_int(0) ueye.is_GetColorDepth(cam, col, mod) ueye.is_SetColorMode(cam, ueye.IS_CM_MONO8) imageSize = ueye.IS_SIZE_2D() imageSize.s32Width = ueye.c_int(224) imageSize.s32Height = ueye.c_int(224) ueye.is_AOI(cam, ueye.IS_AOI_IMAGE_SET_SIZE, imageSize, ueye.sizeof(imageSize)) width_py = imageSize.s32Width height_py = imageSize.s32Height pixels_py = 8 width = width_py height = height_py bitspixel = ctypes.c_int(pixels_py) pcImgMem = ctypes.c_char_p() pid = ctypes.c_int() uEyeDll.is_AllocImageMem(cam, width, height, bitspixel, ctypes.byref(pcImgMem), ctypes.byref(pid)) uEyeDll.is_SetImageMem(cam, pcImgMem, pid) ImageData = np.ones((224, 224), dtype=np.uint8) uEyeDll.is_SetExternalTrigger(cam, ueye.IS_SET_TRIGGER_OFF) #exp = ctypes.c_double() #print("Setting exposure time.")
# 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() #---------------------------------------------------------------------------------------------------------------------------------------
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)