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 set_fps(self, fps):
"""
Set the fps.
Returns
=======
fps: number
Real fps, can be slightly different than the asked one.
"""
# checking available fps
mini, maxi = self.get_fps_range()
if fps < mini:
print(f'Warning: Specified fps ({fps:.2f}) not in possible range:'
f' [{mini:.2f}, {maxi:.2f}].'
f' fps has been set to {mini:.2f}.')
fps = mini
if fps > maxi:
print(f'Warning: Specified fps ({fps:.2f}) not in possible range:'
f' [{mini:.2f}, {maxi:.2f}].'
f' fps has been set to {maxi:.2f}.')
fps = maxi
fps = ueye.c_double(fps)
new_fps = ueye.c_double()
check(ueye.is_SetFrameRate(self.h_cam, fps, new_fps))
self.current_fps = float(new_fps)
return new_fps
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_frame_rate(self, framerate_fps):
"""Sets the framerate in frames per seconds
"""
newFPS = ctypes.c_double()
nRet = ueye.is_SetFrameRate(self.hCam, float(framerate_fps), newFPS)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("SetFrameRate failed")
if newFPS.value != framerate_fps:
print("Warning actual framerate is", newFPS.value)
return newFPS.value
def setFrameRate(self, fr):
"""
Note: values out of range are automatically clipped
fr (0>float): framerate (in Hz) to be set
return (0>float): actual framerate applied
"""
newfps = ctypes.c_double()
hasWorked = ueye.is_SetFrameRate(self.cam, ctypes.c_double(fr), newfps)
self.check(hasWorked, 'setFrameRate')
return newfps.value
def set_fps(self, fps):
new_fps = ueye.ctypes.c_double()
if not ueye.is_SetFrameRate(self.cam, float(fps),
new_fps) == ueye.IS_SUCCESS:
raise RuntimeError("Frame Rate not set")
if new_fps.value != fps:
print("Warning actual fps is", new_fps.value)
else:
print("Frame rate set to %8.3f" % fps)
return new_fps.value
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 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 set_fps(self, fps):
"""
Set the frame rate in frames per second.
:param fps: frames per second to be set
:return: actual frame rate
"""
new_fps = ueye.ctypes.c_double()
if not ueye.is_SetFrameRate(self.cam, float(fps), new_fps) == ueye.IS_SUCCESS:
raise RuntimeError("Frame Rate not set")
if new_fps.value != fps:
print("Warning actual fps is", new_fps.value)
else:
print("Frame rate set to %8.3f" % fps)
return new_fps.value
def set_fps(self, fps):
"""
Set the fps.
Returns
=======
fps: number
Real fps, can be slightly different than the asked one.
"""
# checking available fps
mini, maxi = self.get_fps_range()
if fps < mini:
fps = mini
if fps > maxi:
fps = maxi
fps = ueye.c_double(fps)
new_fps = ueye.c_double()
check(ueye.is_SetFrameRate(self.h_cam, fps, new_fps))
self.current_fps = float(new_fps)
return new_fps
def setExpoureTime(self, expTime):
#Pixel-Clock Setting, the range of this camera is 7-35 MHz
nPixelClockDefault = ueye.INT(200)
nRet = ueye.is_PixelClock(self.hCam, ueye.IS_PIXELCLOCK_CMD_SET,
nPixelClockDefault,
ueye.sizeof(nPixelClockDefault))
print(nPixelClockDefault)
if nRet != ueye.IS_SUCCESS:
print("is_PixelClock ERROR")
nFrameRate = ueye.double(40.0)
nRet = ueye.is_SetFrameRate(self.hCam, ueye.IS_PIXELCLOCK_CMD_SET,
nFrameRate)
if nRet != ueye.IS_SUCCESS:
print("is_SetFrameRate ERROR")
# Working on exposure time range. Set exposure time to be 20 ms.
ms = ueye.DOUBLE(expTime)
nRet = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
ms, ueye.sizeof(ms))
if nRet != ueye.IS_SUCCESS:
print("is_Exposure ERROR")
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()
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS
)
ser.isOpen()
# init max_steering
max_steering = 255
# init camera
hcam = ueye.HIDS(0)
ret = ueye.is_InitCamera(hcam, None)
print("initCamera returns "+str(ret))
# set FPS:
targetFPS = ueye.double(40) # insert here which FPS you want
actualFPS = ueye.double(0)
ret = ueye.is_SetFrameRate(hcam,targetFPS,actualFPS)
print("is_SetFrameRate returns " + str(ret) + ", Actual FPS is: " + str(actualFPS))
# set auto gain:
if args.autogain:
ret = ueye.is_SetAutoParameter(hcam, ueye.IS_SET_ENABLE_AUTO_GAIN, ueye.double(1), ueye.double(0))
print("is_SetAutoParameter returns " + str(ret))
# set color mode
ret = ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED)
print("SetColorMode IS_CM_BGR8_PACKED returns " + str(ret))
# set region of interest
# width = 1936 # original ids properties
# height = 1216 # original ids properties
width = 1496
# 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")
#---------------------------------------------------------------------------------------------------------------------------------------
#экспозиция
error = ueye.is_SetFrameRate(hCam, fps, fps)
print("fps", fps)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
rangeMin, 8)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
rangeMax, 8)
print("range", rangeMin, rangeMax)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ex, 8)
print("экспозиция ", ex, er)
# 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
def Set_FPS(self):
if self.Movie_Switch == 1:
self.rate = ueye.DOUBLE(float(self.SetFPS_lineEdit.text()))
self.newrate = ueye.DOUBLE(float(self.SetFPS_lineEdit.text()))
self.nRet = ueye.is_SetFrameRate(self.hcam, self.rate,
self.newrate)
def ueye_set_frame_rate(hcam, framerate) -> None:
frr = ueye.double(framerate)
dummy = ueye.double(0)
err = ueye.is_SetFrameRate(hcam, frr, dummy)
_throw_if_err(hcam, err)
if nRet != ueye.IS_SUCCESS:
print("is_CaptureVideo ERROR")
# Enables the queue mode for existing image memory sequences
print(hCam, pcImageMemory, MemID, width, height, nBitsPerPixel, pitch)
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")
#---------------------------------------------------------------------------------------------------------------------------------------
#экспозиция
newFps = ueye.DOUBLE()
error = ueye.is_SetFrameRate(hCam, 2, newFps)
print("fps", newFps)
rangeMin = ueye.DOUBLE(165)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
rangeMin, 8)
rangeMax = ueye.DOUBLE(165)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
rangeMax, 8)
print("range", rangeMin, rangeMax)
ex = ueye.DOUBLE(165)
er = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ex, 8)
print("экспозиция ", ex, er)
# Continuous image display
i = 0
def setFPS(fps, hCam=0):
ms_new = ueye.c_double(fps)
new = ueye.c_double(0)
rv = ueye.is_SetFrameRate(hCam, ms_new, new)
return new
def getFrameRate(self):
fps = ctypes.c_double()
hasWorked = ueye.is_SetFrameRate(self.cam, ueye.IS_GET_FRAMERATE, fps)
self.check(hasWorked, 'getFrameRate')
return fps.value
def setFPS(self, fps):
ms_new = ueye.c_double(fps)
new = ueye.c_double(0)
rv = ueye.is_SetFrameRate(self.hCam, ms_new, new)
return new
def set_frame_rate(self, fps):
dfps = ueye.DOUBLE(0)
ueyeFps = ueye.DOUBLE(fps)
ueye.is_SetFrameRate(self.hCam, ueyeFps, dfps)
print("new Framerate: ", dfps)
def set_fps(self, fps):
fps = ueye.double(fps)
origin_fps = self.get_fps()
return ueye.is_SetFrameRate(self.h_cam, fps, fps)
# 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)
nRet = ueye.is_GetFramesPerSecond(hCam, OldFrameRate)
if nRet != ueye.IS_SUCCESS:
print("GetFrame ERROR")
else:
print("FramesPerSecond:\t", OldFrameRate.value)
# Set FRAME RATE
nRet = ueye.is_SetFrameRate(hCam, myFrameRate, c_double())
if nRet != ueye.IS_SUCCESS:
print("SetFrame ERROR:\t", nRet)
else:
print("FramesPerSecond:\t", myFrameRate)
# Set EXPOSURE TIME
# nRet = is_Exposure(m_hCam, IS_EXPOSURE_CMD_SET_EXPOSURE, (void*)&m_ExposureTime, sizeof(m_ExposureTime));
#IS_EXPOSURE_CMD_SET_EXPOSURE = 12
nRet = ueye.is_Exposure(hCam, 12, myExposure, 8) #sizeof(myExposure) )
if nRet != ueye.IS_SUCCESS:
print("Exposure ERROR:\t", nRet)
else:
print("Exposure set to:\t", myExposure)
# Set GAIN
def is_SetFrameRate(cam, FPS):
"""sets the framerate of the uEye camera"""
FPS = ueye.double(FPS)
newFPS = ueye.double()
return ueye.is_SetFrameRate(cam, FPS, newFPS)
