def get_frame_extremes(cam):
"""returns the maximum and minumum time bewtween frames"""
min = ueye.double(0)
max = ueye.double(0)
intervall = ueye.double(0)
ueye.is_GetFrameTimeRange(cam, min, max, intervall)
return {'max': max.value, 'min': min.value, 'intervall': intervall.value}
def __init__(self, graphic=None, mainf=None):
self.camera = False
self.graphic = graphic
self.mainf = mainf
self.detected_devices = {}
self.nRet = None
try:
self.hid = ueye.HIDS()
self.sinfo = ueye.SENSORINFO()
self.hwnd = ueye.HWND()
self.width = ueye.INT()
self.height = ueye.INT()
self.psize = None
self.bitspixel = ueye.INT(24)
self.bytesppixel = int(self.bitspixel / 8)
self.ppcImgMem = ueye.c_mem_p()
self.pid = ueye.INT()
self.MemID = ueye.INT()
self.colorm = ueye.INT()
self.pitch = ueye.INT()
self.rect = ueye.IS_RECT()
self.maxExp = ueye.double()
self.minExp = ueye.double()
self.Exp = ueye.double()
except:
return
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 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 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 GetFPS(self):
"""
Get the camera frame rate in frames per second (float).
Returns
-------
float
Camera frame rate (frames per second)
"""
fps = ueye.double()
self.check_success(ueye.is_GetFramesPerSecond(self.h, fps))
return fps.value
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 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 GetIntegTime(self):
"""
Get Camera object integration time.
Returns
-------
float
The exposure time in s
See Also
--------
SetIntegTime
"""
exposure = ueye.double()
self.check_success(
ueye.is_Exposure(self.h, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE,
exposure, ueye.sizeof(exposure)))
return exposure.value / 1e3
def captureVideo(self):
count = 0
prevCaptureTime = 0
imageInfo = ueye.UEYEIMAGEINFO()
while (True):
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))
nRet = ueye.is_GetImageInfo(self.hCam, self.MemID, imageInfo,
ueye.sizeof(imageInfo))
if nRet != ueye.IS_SUCCESS:
print("GET IMAGE INFO ERROR")
captureTime = imageInfo.u64TimestampDevice
if ((captureTime > prevCaptureTime) and (captureTime != 0)):
exposureTime = ueye.double()
retVal = ueye.is_Exposure(self.hCam,
ueye.IS_EXPOSURE_CMD_GET_EXPOSURE,
exposureTime, 8)
self.timeStampsFile.write(
str(count).zfill(5) + " " + str(captureTime - 0) + " " +
str(exposureTime) + "\n")
cv2.imwrite("images/" + str(count).zfill(5) + ".jpg", frame)
count = count + 1
prevCaptureTime = captureTime - 0
cv2.imshow("captureVideo", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
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 captureCalibrationVideo(self):
pParam = ueye.double()
nRet = ueye.is_Exposure(self.hCam,
ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
pParam, ueye.sizeof(pParam))
if nRet != ueye.IS_SUCCESS:
print("Error getting max exposure, error code: ", nRet)
else:
print("max exposure is: ", pParam.value)
pParam = ueye.double()
pParam.value = 0
nRet = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
pParam, ueye.sizeof(pParam))
count = 0
prevCaptureTime = 0
maxExposure = pParam.value
currExposure = 0
imageInfo = ueye.UEYEIMAGEINFO()
while (currExposure <= maxExposure):
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))
nRet = ueye.is_GetImageInfo(self.hCam, self.MemID, imageInfo,
ueye.sizeof(imageInfo))
if nRet != ueye.IS_SUCCESS:
print("GET IMAGE INFO ERROR")
captureTime = imageInfo.u64TimestampDevice
if ((captureTime > prevCaptureTime) and (captureTime != 0)):
pParam = ueye.double()
pParam.value = currExposure
nRet = ueye.is_Exposure(self.hCam,
ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
pParam, ueye.sizeof(pParam))
currExposure += 0.01
self.timeStampsFile.write(
str(count).zfill(5) + " " + str(captureTime - 0) + " " +
str(currExposure) + "\n")
cv2.imwrite("images/" + str(count).zfill(5) + ".jpg", frame)
count = count + 1
prevCaptureTime = captureTime - 0
cv2.imshow("captureVideo", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
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))
print('AOI')
print(nRet)
print(rectAOI)
if nRet != ueye.IS_SUCCESS:
print("is_AOI ERROR")
width = rectAOI.s32Width
height = rectAOI.s32Height
########################################################################################################################
print('Exp')
EXPOSURE = ueye.double()
nRet = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, EXPOSURE, ueye.sizeof((EXPOSURE)))
print(nRet)
print(EXPOSURE)
EXPOSURE = ueye.double(0.5)
ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, EXPOSURE, ueye.sizeof((EXPOSURE)))
EXPOSURE = ueye.double()
nRet = ueye.is_Exposure(hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, EXPOSURE, ueye.sizeof((EXPOSURE)))
print(nRet)
print(EXPOSURE)
# Prints out some information about the camera and the sensor
print("Camera model:\t\t", sInfo.strSensorName.decode('utf-8'))
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)
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)
def get_fps(self):
fps = ueye.double()
ueye.is_GetFramesPerSecond(self.h_cam, fps)
return fps
def get_FrameTimeRange(self):
min = ueye.double()
max = ueye.double()
intervall = ueye.double()
ueye.is_GetFrameTimeRange(self.h_cam, min, max, intervall)
return min, max, intervall
def set_exposure(self, EXPOSURE):
EXPOSURE = ueye.double(EXPOSURE) ### in ms
return ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, EXPOSURE, ueye.sizeof((EXPOSURE)))
def get_exposure(self):
EXPOSURE = ueye.double() ### in ms
ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, EXPOSURE, ueye.sizeof((EXPOSURE)))
return EXPOSURE
def set_fps(self, fps):
fps = ueye.double(fps)
origin_fps = self.get_fps()
return ueye.is_SetFrameRate(self.h_cam, fps, fps)
baudrate=19200,
parity=serial.PARITY_NONE,
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