def Set_Values(cam, exposure, gain, blacklevel, automode): """sets the exposure time and gain of the camera""" exposure = ueye.double(exposure) expo = ueye.double() gain = ueye.int(gain) # sets the exposure time and gain with the values # or sets them automatically if automode is False: ueye.is_SetHardwareGain(cam, gain, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER) ueye.is_Exposure(cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure, ueye.ueye.sizeof(exposure)) expo = exposure ueye.is_Blacklevel(cam, ueye.IS_BLACKLEVEL_CMD_SET_OFFSET, blacklevel) elif automode is True: pval1 = ueye.double(1) pval2 = ueye.double(0) ueye.is_SetAutoParameter(cam, ueye.IS_SET_ENABLE_AUTO_GAIN, pval1, pval2) pval1 = ueye.double(1) pval2 = ueye.double(0) ueye.is_SetAutoParameter(cam, ueye.IS_SET_ENABLE_AUTO_SHUTTER, pval1, pval2) return Get_Values(cam.value, expo.value)
def info(self): print('======================= Camera info ==========================') if self.sensorInfo.strSensorName.decode('utf8')[-1] == 'C': print('COLOR sensor detected.') elif self.sensorInfo.strSensorName.decode('utf8')[-1] == 'M': print('MONOCHROMATIC sensor detected.') elif self.sensorInfo.strSensorName.decode( 'utf8')[-1] != 'C' and self.sensorInfo.strSensorName.decode( 'utf8')[-1] != 'M': print( 'WARNING: Unknown sensor type (mono/RGB). Image capturing will not work correctly.' ) print('--------------------------------------------------------------') #print('Current maximal acquisition speed: ' + str(self.currentFPS) + ' fps') expTimeMin = ueye.c_double(0) expTimeMax = ueye.c_double(1000) ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN, expTimeMin, ueye.sizeof(expTimeMin)) ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX, expTimeMax, ueye.sizeof(expTimeMax)) print('Exposure time range: ' + str(round(expTimeMin.value * 1000, 3)) + ' to ' + str(round(expTimeMax.value * 1000, 3)) + ' us') print('--------------------------------------------------------------') for i in self.sensorInfo._fields_: print(str(i[0]) + ": " + str(eval('self.sensorInfo.%s' % i[0])))
def possible_exposure_time(self): """Query the min, max and increment in ms """ min_ms = ctypes.c_double() max_ms = ctypes.c_double() inc_ms = ctypes.c_double() nRet = ueye.is_Exposure( self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN, min_ms, ctypes.sizeof(min_ms), ) if nRet != ueye.IS_SUCCESS: raise RuntimeError("IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN failed") nRet = ueye.is_Exposure( self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX, max_ms, ctypes.sizeof(max_ms), ) if nRet != ueye.IS_SUCCESS: raise RuntimeError("IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX failed") nRet = ueye.is_Exposure( self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_INC, inc_ms, ctypes.sizeof(inc_ms), ) if nRet != ueye.IS_SUCCESS: raise RuntimeError("IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_INC failed") return min_ms.value, max_ms.value, inc_ms.value
def setExposure(self, ms): ms_old = ueye.c_double(0) rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ms_old, ueye.sizeof(ms_old)) ems = ueye.c_double(ms) rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ems, ueye.sizeof(ems)) ms_old = ueye.c_double(0) rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ms_old, ueye.sizeof(ms_old)) return rv
def main(config_path="/home/oran/Pictures/Settings/default-camera-settings.ini" ): print(config_path) # we need a QApplication, that runs our QT Gui Framework app = PyuEyeQtApp() # a basic qt window view = PyuEyeQtView() view.resize(1920 / 1.5, 1080 / 1.5) view.show() #update_config_gain(update={'red': '0','green' : '0','blue':'0'},set=True) #update_config_exposure(update=70,set=True) # view.user_callback = adjust_manually view.user_callback = print_means # view.user_callback = adjust_manually # camera class to simplify uEye API access cam = Camera() cam.init() # cam.set cam.set_colormode(ueye.IS_CM_BGR8_PACKED) pParam = ueye.wchar_p() pParam.value = config_path ueye.is_ParameterSet(1, ueye.IS_PARAMETERSET_CMD_LOAD_FILE, pParam, 0) # cam.set(cv2.cv.CV_CAP_PROP_EXPOSURE, 10) # cam.__getattribute__('is_CameraStatus') # cam.__setattr__('GetCameraInfo',0) #cam.set_aoi(0,0, 1280, 1024) cam.set_aoi(0, 0, 4912, 3684) cam.alloc() cam.capture_video() ueye._is_GetError ueye.is_Exposure(1, ueye.c_uint(1), ueye.c_void_p(), cbSizeOfParam=ueye.c_int(0)) # ueye.IS_EXPOSURE_CMD_GET_FINE_INCREMENT_RANGE_MIN = 20 # ueye.IS_EXPOSURE_CMD_GET_FINE_INCREMENT_RANGE_MAX = 21 # a thread that waits for new images and processes all connected views thread = FrameThread(cam, view) thread.start() # update_config_gain() # cleanup app.exit_connect(thread.stop) app.exec_() thread.stop() thread.join() cam.stop_video() cam.exit()
def Get_Values(cam, exposure): """gets the current exposure time and gain of the camera""" exposure = ueye.double(exposure) gain = ueye.int() ueye.is_Exposure(cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, exposure, ueye.sizeof(exposure)) gain = ueye.is_SetHardwareGain(cam, ueye.IS_GET_MASTER_GAIN, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER) return exposure.value, gain
def set_intTime(self, intTime): intTime = intTime / 1000 """ Set the exposure time in microseconds. """ expTime = ueye.c_double(intTime) ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, expTime, ueye.sizeof(expTime)) wert = ueye.c_double() sizeo = ueye.sizeof(wert) ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, wert, sizeo)
def initialize_camera_settings(self): '''Sets pixel_clock, fps, exposure, autofocus, autogain based on self.config.''' # get max pixel clock pixel_clock_range = (ueye.c_uint * 3)() ret = ueye.is_PixelClock(self.input, ueye.IS_PIXELCLOCK_CMD_GET_RANGE, pixel_clock_range, 3 * ueye.sizeof(ueye.UINT())) log.info(f'pixel_clock max: {pixel_clock_range[0]}, pixel_clock min: {pixel_clock_range[1]}, ret val: {ret}') # set max pixel clock pixel_clock = ueye.c_int(pixel_clock_range[1]) ret = ueye.is_PixelClock(self.input, ueye.IS_PIXELCLOCK_CMD_SET, pixel_clock, ueye.sizeof(pixel_clock)) self.config['pixel_clock'] = pixel_clock.value log.info(f'Actual pixel clock: {pixel_clock}, ret val: {ret}') # max out frame rate target_frame_rate = ueye.double(self.config.get('fps')) actual_frame_rate = ueye.double(0.0) ret = ueye.is_SetFrameRate(self.input, target_frame_rate, actual_frame_rate) self.config['fps'] = actual_frame_rate.value log.info(f'Attempted to set frame rate to {target_frame_rate}, ret value: {ret}, actual frame rate: {actual_frame_rate}') # max out exposure target_exposure = ueye.double(self.config.get('exposure')) actual_exposure = ueye.double(0.0) ret = ueye.is_Exposure(self.input, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, target_exposure, ueye.sizeof(target_exposure)) get_ret = ueye.is_Exposure(self.input, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, actual_exposure, ueye.sizeof(actual_exposure)) self.config['exposure'] = actual_exposure.value log.info(f'Attempted to set exposure to {target_exposure}, ret value: {ret}, actual frame rate: {actual_exposure}') # set autofocus limits if self.config.get('focus_min') is not None and self.config.get('focus_max') is not None: limit = ueye.AUTOFOCUS_LIMIT() limit.sMin = ueye.c_int(self.config['focus_min']) limit.sMax = ueye.c_int(self.config['focus_max']) ret = ueye.is_Focus(self.input, ueye.FOC_CMD_SET_AUTOFOCUS_LIMIT, limit, ueye.sizeof(limit)); if ret == ueye.IS_SUCCESS: log.info(f'Successfully set focus min: {self.config["focus_min"]}, focus max: {self.config["focus_max"]}') else: log.error('Failed to set focus min/max.') # enable autofocus if self.config.get('autofocus'): ret = ueye.is_Focus(self.input, ueye.FOC_CMD_SET_ENABLE_AUTOFOCUS, None, 0) if ret == ueye.IS_SUCCESS: log.info(f'Successfully set autofocus to {self.config.get("autofocus")}.') else: log.error('Failed to set autofocus.') # enable autogain if self.config.get('autogain'): ret = ueye.is_SetAutoParameter(self.input, ueye.IS_SET_ENABLE_AUTO_GAIN, ueye.double(1), ueye.double(0)) if ret == ueye.IS_SUCCESS: log.info(f'Successfully set autogain to {self.config.get("autogain")}.') else: log.error('Failed to set autogain.')
def SetIntegTime(self, integ_time): """ Sets the exposure time in s. Currently assumes that we will want to go as fast as possible at this exposure time and also sets the frame rate to match. Parameters ---------- iTime : float Exposure time in s Returns ------- None See Also -------- GetIntegTime """ new_fps = ueye.double() self.check_success( ueye.is_SetFrameRate(self.h, 1 / integ_time, new_fps)) # by default, set exposure time to max for this frame rate # "If 0 is passed, the exposure time is set to the maximum value of 1/frame rate." exposure = ueye.double(0) self.check_success( ueye.is_Exposure(self.h, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure, ueye.sizeof(exposure)))
def getExposureTime(self): self.exposureTime=ueye.c_double() if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, self.exposureTime, ueye.sizeof(ueye.c_double)): self.status=True _logger.error("Error retrinving Exposure time") return True return False
def set_full_auto(self): print("full auto") disable = ueye.DOUBLE(0) enable = ueye.DOUBLE(1) zero = ueye.DOUBLE(0) ms = ueye.DOUBLE(20) rate = ueye.DOUBLE(50) newrate = ueye.DOUBLE() number = ueye.UINT() nRet = ueye.is_SetAutoParameter(self.h_cam, ueye.IS_SET_ENABLE_AUTO_GAIN, enable, zero); print('AG:',nRet) nRet = ueye.is_SetAutoParameter(self.h_cam, ueye.IS_SET_ENABLE_AUTO_SHUTTER, enable, zero); print('A_SHUTTER:',nRet) nRet = ueye.is_SetFrameRate(self.h_cam, rate, newrate); print('FR:',nRet,newrate) nRet = ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ms, ueye.sizeof(ms)); print('EXP:',nRet,ms) nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET_NUMBER, number, ueye.sizeof(number)) print('PxCLK #:',nRet, number) PCrange = (ctypes.c_uint * 3)() nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET_RANGE, PCrange, 3*ueye.sizeof(number)) print('PxCLK range:', nRet, PCrange[0], PCrange[1], PCrange[2]) list_pixel_clocks = (ctypes.c_uint * 150)() nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET_LIST, list_pixel_clocks, number*ueye.sizeof(number)) list_np = np.frombuffer(list_pixel_clocks, int) print('PxCLK list:', nRet, list_np[0:number.value]) nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET, number, ueye.sizeof(number)) print('PxCLK current:',nRet, number) nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET_DEFAULT, number, ueye.sizeof(number)) print('PxCLK default:',nRet, number) nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_SET, ueye.UINT(20), ueye.sizeof(number)) print('PxCLK set:',nRet, number) nRet = ueye.is_PixelClock(self.h_cam, ueye.IS_PIXELCLOCK_CMD_GET, number, ueye.sizeof(number)) print('PxCLK current:',nRet, number)
def Set_Exp(self): if self.Movie_Switch == 1: self.exposure = ueye.DOUBLE(float(self.SetExp_lineEdit.text())) self.expms = ueye.DOUBLE(self.exposure) self.nRet = ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.expms, ueye.sizeof(self.expms))
def set_parameters(self, disable_exposure=True): # Change image format # formatID = ueye.UINT(5) # Change image format to 2048x1536 formatID = ueye.UINT(8) # Change image format to 1280x960 nRet = ueye.is_ImageFormat(self.hCam, ueye.IMGFRMT_CMD_SET_FORMAT, formatID, ueye.sizeof(formatID)) if disable_exposure: # Disable auto exposure dblEnable = ueye.DOUBLE(0) dblDummy = ueye.DOUBLE(0) ueye.is_SetAutoParameter( self.hCam, ueye.IS_SET_ENABLE_AUTO_SENSOR_GAIN_SHUTTER, dblEnable, dblDummy) # Set new exposure value from .ini-file config = configparser.ConfigParser() config.read('image_tools/cam_adjustments.ini') exposure = float(config['EXPOSURE']['exposure']) newExposure = ueye.DOUBLE(exposure) ret = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, newExposure, ueye.sizeof(newExposure)) # Disable autofocus ueye.is_Focus(self.hCam, ueye.FOC_CMD_SET_DISABLE_AUTOFOCUS, None, 0)
def getExposureRange(self): ExposureRange=[ueye.c_double() for i in range(3)] self.ExposureRange=(ueye.c_double*3)(*ExposureRange) if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE, self.ExposureRange, ueye.sizeof(self.ExposureRange)): _logger.error("Error retrinving exposure range") self.status=True return True
def get_exposure(self, verbose=False): ret = ueye.DOUBLE() check( ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ret, ueye.sizeof(ret))) if verbose: print('Exposure: {}'.format(str(ret))) return ret
def get_exposure(self): self.ret = ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, self.brig, 8) if self.ret == ueye.IS_SUCCESS: print(' currently set exposure time %8.3f ms' % self.brig) return self.brig
def get_exposure_range(self, verbose=False): ret = (ueye.DOUBLE * 3)() check( ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE, ret, ueye.sizeof(ret))) if verbose: print('Exposure range: min={}, max={}, step={}'.format( str(ret[0].value), str(ret[1].value), str(ret[2].value))) return ret
def setExposure(self, exp_val): ''' Exposure time in ms. ''' val_formated = ctypes.c_double(float(exp_val)) val_size = ctypes.c_int32(ctypes.sizeof(val_formated)) hasWorked = ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, val_formated, val_size) self.check(hasWorked, 'is_Exposure')
def getExposure(self): ''' Exposure time in ms. ''' val_formated = ctypes.c_double(0) val_size = ctypes.c_int32(ctypes.sizeof(val_formated)) hasWorked = ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, val_formated, val_size) self.check(hasWorked, 'is_Exposure') return val_formated.value
def setExposureTime(self, value): self.getExposureRange() if (value<self.ExposureRange[0].value) & (value>self.ExposureRange[1].value): self.status=True return True ran=np.arange(self.ExposureRange[0].value, self.ExposureRange[1].value, self.ExposureRange[2].value) nwv=ueye.c_double(ran[np.abs(ran-value).argmin()]) if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, nwv, ueye.sizeof(nwv)): self.status=True return True return False
def get_exposure(self): """ Get the current exposure. Returns ======= exposure: number Current exposure. """ exposure = ueye.c_double() check(ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, exposure, 8)) return exposure
def set_exposure(self, value): self.stopacquire() # range is 0 to 33 ms value = value * 33 / 100 self.brig = ueye.double(value) print(self.brig) self.ret = ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.brig, 8) if self.ret == ueye.IS_SUCCESS: print(' aa tried to changed exposure time to %8.3f ms' % self.brig) self.acquireimage()
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_exposure(self): """ Get the current exposure. Returns ======= exposure: number Current exposure. """ exposure = ueye.c_double() self.nRet = ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, exposure, 8) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_Exposure") return exposure
def set_exposure(self, exposure): """ Set the exposure. Returns ======= exposure: number Real exposure, can be slightly different than the asked one. """ new_exposure = ueye.c_double(exposure) check( ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, new_exposure, 8)) return new_exposure
def current_exposure_time(self): """Query the current exposure time in ms """ exposure_ms = ctypes.c_double() nRet = ueye.is_Exposure( self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, exposure_ms, ctypes.sizeof(exposure_ms), ) if nRet != ueye.IS_SUCCESS: raise RuntimeError("IS_EXPOSURE_CMD_GET_EXPOSURE failed") return exposure_ms.value
def set_exposure_time(self, exposure_ms): """ Set exposure time in milliseconds. If 0 is passed, the exposure time is set to the maximum value of 1/frameRate. :param exposure_ms: exposure time to be set in ms :return: None """ exposure_ms_double = ueye.ctypes.c_double(exposure_ms) if not ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure_ms_double, ueye.ctypes.sizeof(exposure_ms_double)) == ueye.IS_SUCCESS: raise RuntimeError("Exposure time not set") actual = exposure_ms_double.value print("Exposure time is set to", actual, "ms") if actual != exposure_ms: print("Warning: actual value of exposure time is", actual, "ms")
def set_exposure(self, exposure): """ Set the exposure. Returns ======= exposure: number Real exposure, can be slightly different than the asked one. """ exposure = ueye.c_double(exposure) self.nRet = ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure, 8) if self.nRet != ueye.IS_SUCCESS: error_log(self.nRet, "is_Exposure")
def set_exposure_time(self, exposure_ms): """Sets exposure time in ms. If 0 is passed, the exposure time is set to the maximum value of 1/frame rate. """ exposure_ms_double = ctypes.c_double(exposure_ms) nRet = ueye.is_Exposure( self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, exposure_ms_double, ctypes.sizeof(exposure_ms_double), ) if nRet != ueye.IS_SUCCESS: raise RuntimeError("IS_EXPOSURE_CMD_SET_EXPOSURE failed") actual = exposure_ms_double.value if actual != exposure_ms: print("Warning: actual value of exposure time is", actual, "ms")
def configure(self, parameters): # Exposure varies by camera: 0.020ms to 69.847 for UI-3250 model (check uEye cockpit for specifics) # Gain (master) can be set between 0-100 # Black level can be set between 0-255 # Gamma can be set between 0.01 and 10 #Set dict keys to all lower case parameters = dict((k.lower(), v) for k, v in parameters.items()) if 'exposure' in parameters: #Doesn't do anything err = ueye.is_Exposure( self._cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ueye.DOUBLE(parameters['exposure']), ueye.sizeof(ueye.DOUBLE(parameters['exposure']))) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>configure>exposure>', err) if 'gain' in parameters: err = ueye.is_SetHardwareGain(self._cam, ueye.INT(parameters['gain']), ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>configure>gain>', err) if 'black_level' in parameters: err = ueye.is_Blacklevel( self._cam, ueye.IS_BLACKLEVEL_CMD_SET_OFFSET, ueye.INT(parameters['black_level']), ueye.sizeof(ueye.INT(parameters['black_level']))) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>configure>black_level>', err) if 'gamma' in parameters: # Digital gamma correction err = ueye.is_Gamma( self._cam, ueye.IS_GAMMA_CMD_SET, ueye.INT(int(parameters['gamma'] * 100)), ueye.sizeof(ueye.INT(int(parameters['gamma'] * 100)))) if err != ueye.IS_SUCCESS: raise CameraException(self._cam, 'ueye>configure>gamma>', err)