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)
