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)
