def initCamera(self):
try:
self.hcam = ueye.HIDS(0)
self.pccmem = ueye.c_mem_p()
self.memID = ueye.c_int()
self.hWnd = ctypes.c_voidp()
ueye.is_InitCamera(self.hcam, self.hWnd)
ueye.is_SetDisplayMode(self.hcam, 0)
self.sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(self.hcam, self.sensorinfo)
return self.OP_OK
except:
return self.OP_ERR
def connect(self):
""" Connects to the USB camera, creates main controlling object + prints out confirmation """
connectRet = ueye.is_InitCamera(self.CamID, None)
if connectRet == 0: # on succesful connection
self.connected = True
self.sensorInfo = ueye.SENSORINFO()
print('IDS camera connected.')
ueye.is_GetSensorInfo(self.CamID, self.sensorInfo)
self.sensorHeight_ctype, self.sensorWidth_ctype = self.sensorInfo.nMaxHeight, self.sensorInfo.nMaxWidth
self.currentHeight, self.currentWidth = self.sensorHeight_ctype.value, self.sensorWidth_ctype.value
# Settings block
ueye.is_PixelClock(self.CamID, ueye.IS_PIXELCLOCK_CMD_SET,
ueye.c_int(self.pixelClock),
ueye.sizeof(ueye.c_int(self.pixelClock)))
self.currentFPS = ueye.c_double(0)
#ueye.is_SetFrameRate(self.CamID, ueye.c_int(self.FPS),self.currentFPS)
ueye.is_SetDisplayMode(self.CamID, ueye.IS_SET_DM_DIB)
ueye.is_SetColorMode(self.CamID, ueye.IS_CM_SENSOR_RAW12)
ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_GAIN,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SENSOR_GAIN,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SHUTTER,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SENSOR_SHUTTER,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_WHITEBALANCE,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(
self.CamID, ueye.IS_SET_ENABLE_AUTO_SENSOR_WHITEBALANCE,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetHardwareGain(self.CamID, ueye.c_int(0), ueye.c_int(0),
ueye.c_int(0), ueye.c_int(0))
# Show a pattern (for testing)
#ueye.is_SetSensorTestImage(self.CamID,ueye.IS_TEST_IMAGE_HORIZONTAL_GREYSCALE, ueye.c_int(0))
else:
print('Camera connecting failure...')
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 __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 initCamera(self):
try:
self.hcam = ueye.HIDS(0)
self.pccmem = ueye.c_mem_p()
self.memID = ueye.c_int()
self.hWnd = ctypes.c_voidp()
ueye.is_InitCamera(self.hcam, self.hWnd)
ueye.is_SetDisplayMode(self.hcam, 0)
self.sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(self.hcam, self.sensorinfo)
auto_res = ueye.is_SetAutoParameter(self.hcam, ueye.IS_SET_ENABLE_AUTO_SHUTTER, ctypes.c_double(1), ctypes.c_double(1))
try:
auto_res = ueye.GetExposureRange()
print auto_res
except Exception as Ex:
print Ex
pass
print auto_res
return self.OP_OK
except Exception as ex:
logging.exception("Error during camera initialization!")
return self.OP_ERR
def __init__(self, cam_id, name):
self._cam = ueye.HIDS(cam_id)
self._cam_name = name
self._sInfo = ueye.SENSORINFO()
self._sFPS = ueye.DOUBLE()
self._connect()
# Query additional information about the sensor type used in the camera
err = ueye.is_GetSensorInfo(self._cam, self._sInfo)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>close>GetSensorInfo>', err)
# Reset camera to default settings
err = ueye.is_ResetToDefault(self._cam)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>close>ResetToDefault>', err)
# Set display mode to DIB
err = ueye.is_SetDisplayMode(self._cam, ueye.IS_SET_DM_DIB)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>close>SetDisplayMode>', err)
# Core Camera Variables
self._width = ueye.INT(self._sInfo.nMaxWidth.value)
self._height = ueye.INT(self._sInfo.nMaxHeight.value)
self._pitch = ueye.INT()
self._ppc_img_mem = ueye.c_mem_p()
self._mem_id = ueye.INT()
self._nBitsPerPixel = ueye.INT()
self._m_nColorMode = ueye.INT()
self._bytes_per_pixel = ueye.INT()
self._video_capture = False
self._done_saving = True
# Allicate memory for frames
self._allocate_memory()
# Start collection of frames
self.start_video_capture()
# Get frames per second
err = ueye.is_GetFramesPerSecond(self._cam, self._sFPS)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>close>GetFramesPerSecond>',
err)
# Start new thread to save frame
threading.Thread(target=self._update).start()
def __init__(self, verbose=False, output_dir='images'):
self.new_msg = False
self.idx = 0
self.last_msg = None
self.verbose = verbose
self.calib = None
self.output_dir_orig = path.join(output_dir, 'orig')
self.output_dir_undist = path.join(output_dir, 'undist')
if not path.exists(self.output_dir_orig):
makedirs(self.output_dir_orig)
if not path.exists(self.output_dir_undist):
makedirs(self.output_dir_undist)
# camera class to simplify uEye API access
self.verbose_print("Start uEye interface")
self.cam = Camera()
try:
self.cam.init()
except uEyeException:
self.verbose_print("Camera init failed")
self.cam = None
return
check(
ueye.is_SetExternalTrigger(self.cam.handle(),
ueye.IS_SET_TRIGGER_SOFTWARE))
self.cam.set_colormode(ueye.IS_CM_BGR8_PACKED)
self.cam.set_aoi(0, 0, 2048, 2048)
# pixel clock
self.verbose_print("Pixel clock")
self.cam.get_pixel_clock_range(self.verbose)
self.cam.set_pixel_clock(20)
self.cam.get_pixel_clock(self.verbose)
# set expo
self.verbose_print("Expo")
self.cam.get_exposure_range(self.verbose)
self.cam.set_exposure(1.)
self.cam.get_exposure(self.verbose)
self.verbose_print("Init done")
self.buff = self.cam.alloc_single()
check(ueye.is_SetDisplayMode(self.cam.handle(), ueye.IS_SET_DM_DIB))
self.verbose_print("Alloc done")
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 configure_camera(self, mode='RGB8', **kwargs):
err = pue.is_SetDisplayMode(self.cam, pue.IS_SET_DM_DIB)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam,
'ueye>configure_image>set_display_mode>',
err)
err = pue.is_SetExternalTrigger(self.cam, pue.IS_SET_TRIGGER_SOFTWARE)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam,
'ueye>configure_image>set_trigger>', err)
err = pue.is_SetHardwareGain(self.cam, 0, 24, 0, 30)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam,
'ueye>configure_image>set_hardware_gain>',
err)
err = pue.is_SetHardwareGamma(self.cam, pue.IS_SET_HW_GAMMA_OFF)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam,
'ueye>configure_image>set_hardware_gamma>',
err)
'''
def Cameras_stream():
#Variables
hCam1 = ueye.HIDS(1) #0: first available camera; 1-254: The camera with the specified camera ID
hCam2 = ueye.HIDS(2) #0: first available camera; 1-254: The camera with the specified camera ID
sInfo = ueye.SENSORINFO()
cInfo = ueye.CAMINFO()
pcImageMemory = ueye.c_mem_p()
pcImageMemory2 = ueye.c_mem_p()
MemID = ueye.int()
MemID2 = ueye.int()
rectAOI = ueye.IS_RECT()
pitch = ueye.INT()
nBitsPerPixel = ueye.INT(24) #24: bits per pixel for color mode; take 8 bits per pixel for monochrome
channels = 3 #3: channels for color mode(RGB); take 1 channel for monochrome
m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32
bytes_per_pixel = int(nBitsPerPixel / 8)
#---------------------------------------------------------------------------------------------------------------------------------------
# print("START")
# print()
# Starts the driver and establishes the connection to the camera
nRet1 = ueye.is_InitCamera(hCam1, None)
if nRet1 != ueye.IS_SUCCESS:
pass
# print("is_InitCamera ERROR")
else:
print(f'Camera 1 : SUCCESS')
nRet2 = ueye.is_InitCamera(hCam2, None)
if nRet2 != ueye.IS_SUCCESS:
pass
# print("is_InitCamera ERROR")
else:
print(f'Camera 2 : SUCCESS')
# Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to
nRet1 = ueye.is_GetCameraInfo(hCam1, cInfo)
if nRet1 != ueye.IS_SUCCESS:
print("is_GetCameraInfo ERROR")
nRet2 = ueye.is_GetCameraInfo(hCam2, cInfo)
if nRet2 != ueye.IS_SUCCESS:
print("is_GetCameraInfo ERROR")
# You can query additional information about the sensor type used in the camera
nRet1 = ueye.is_GetSensorInfo(hCam1, sInfo)
if nRet1 != ueye.IS_SUCCESS:
print("is_GetSensorInfo ERROR")
nRet1 = ueye.is_ResetToDefault( hCam1)
if nRet1 != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
# Set display mode to DIB
nRet1 = ueye.is_SetDisplayMode(hCam1, ueye.IS_SET_DM_DIB)
nRet2 = ueye.is_SetDisplayMode(hCam2, ueye.IS_SET_DM_DIB)
# Set the right color mode
if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(hCam1, nBitsPerPixel, m_nColorMode)
bytes_per_pixel = int(nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ", )
print("\tm_nColorMode: \t\t", m_nColorMode)
print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", bytes_per_pixel)
print()
elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_BGRA8_PACKED
nBitsPerPixel = ueye.INT(32)
bytes_per_pixel = int(nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
print("\tm_nColorMode: \t\t", m_nColorMode)
print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", bytes_per_pixel)
print()
elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_MONO8
nBitsPerPixel = ueye.INT(8)
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
nRet1 = ueye.is_AOI(hCam1, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI))
if nRet1 != 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()
#---------------------------------------------------------------------------------------------------------------------------------------
# Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel
nRet1 = ueye.is_AllocImageMem(hCam1, width, height, nBitsPerPixel, pcImageMemory, MemID)
if nRet1 != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(hCam1, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
print("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(hCam1, m_nColorMode)
if nRet1 != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(hCam1, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
print("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(hCam2, m_nColorMode)
# 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_AllocImageMem(hCam2, width, height, nBitsPerPixel, pcImageMemory2, MemID2)
if nRet != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(hCam2, pcImageMemory2, MemID2)
if nRet != ueye.IS_SUCCESS:
print("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(hCam2, m_nColorMode)
nRet = ueye.is_AllocImageMem(hCam2, width, height, nBitsPerPixel, pcImageMemory2, MemID2)
if nRet != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(hCam2, pcImageMemory2, MemID2)
if nRet != ueye.IS_SUCCESS:
print("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(hCam2, m_nColorMode)
# Activates the camera's live video mode (free run mode)
nRet = ueye.is_CaptureVideo(hCam1, ueye.IS_DONT_WAIT)
if nRet != ueye.IS_SUCCESS:
print("is_CaptureVideo ERROR")
nRet = ueye.is_CaptureVideo(hCam2, 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(hCam1, pcImageMemory, MemID, width, height, nBitsPerPixel, pitch)
if nRet != ueye.IS_SUCCESS:
print("is_InquireImageMem ERROR")
else:
print("Press q to leave the programm")
nRet2 = ueye.is_InquireImageMem(hCam2, pcImageMemory2, MemID, width, height, nBitsPerPixel, pitch)
if nRet2 != ueye.IS_SUCCESS:
print("is_InquireImageMem ERROR")
else:
print("Press q to leave the programm")
#---------------------------------------------------------------------------------------------------------------------------------------
# Continuous image display
while(nRet == ueye.IS_SUCCESS) and (nRet2 == ueye.IS_SUCCESS):
# In order to display the image in an OpenCV window we need to...
# ...extract the data of our image memory
array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False)
array2 = ueye.get_data(pcImageMemory2, width, height, nBitsPerPixel, pitch, copy=False)
# bytes_per_pixel = int(nBitsPerPixel / 8)
# ...reshape it in an numpy array...
frame = np.reshape(array,(height.value, width.value, bytes_per_pixel))
frame2 = np.reshape(array2,(height.value, width.value, bytes_per_pixel))
# ...resize the image by a half
# frame = cv2.resize(frame,(0,0),fx=0.5, fy=0.5)
#---------------------------------------------------------------------------------------------------------------------------------------
#Include image data processing here
#---------------------------------------------------------------------------------------------------------------------------------------
#...and finally display it
if __name__=="__main__":
cv2.imshow("SimpleLive_Python_uEye_OpenCV", frame)
cv2.imshow("SimpleLive_Python_uEye_OpenCV 2", frame2)
# Press q if you want to end the loop
if cv2.waitKey(1) & 0xFF == ord('q'):
break
#---------------------------------------------------------------------------------------------------------------------------------------
# Releases an image memory that was allocated using is_AllocImageMem() and removes it from the driver management
ueye.is_FreeImageMem(hCam1, pcImageMemory, MemID)
ueye.is_FreeImageMem(hCam2, pcImageMemory2, MemID2)
# Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera
ueye.is_ExitCamera(hCam1)
ueye.is_ExitCamera(hCam2)
# Destroys the OpenCv windows
cv2.destroyAllWindows()
print()
print("END")
os.makedirs(directory)
for i in range(20):
if i == 3:
print('apontar para a cara AGORA!')
sleep(6)
timestamp_cara = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
#INIT
hcam = ueye.HIDS(0)
pccmem = ueye.c_mem_p()
memID = ueye.c_int()
hWnd = ctypes.c_voidp()
ueye.is_InitCamera(hcam, hWnd)
ueye.is_SetDisplayMode(hcam, 0)
sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(hcam, sensorinfo)
#TAKE PHOTO
ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth, sensorinfo.nMaxHeight,
24, pccmem, memID)
ueye.is_SetImageMem(hcam, pccmem, memID)
ueye.is_SetDisplayPos(hcam, 100, 100)
nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT)
print(nret)
timestamp = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
img_name = "img_" + timestamp + ".jpg"
img_path = directory + img_name
def show_image(self):
# Kamera initialisieren
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:
# Daten der Kamera auslesen
array = ueye.get_data(self.pcImageMemory,
self.width,
self.height,
self.nBitsPerPixel,
self.pitch,
copy=False)
# Bild zuschneiden
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)
# optimale Kameramatrix erstellen
self.new_camera_matrix, roi = cv2.getOptimalNewCameraMatrix(
self.camera_matrix, self.dist_coeff, size, 1, size)
# Bild entzerren
dst = cv2.undistort(frame, self.camera_matrix, self.dist_coeff,
None, self.new_camera_matrix)
x, y, w, h = roi
self.dst = dst[y:y + h, x:x + w]
# Farbmasken erstellen
self.blue.create_color_mask(self.dst, self.found_blue_container)
self.red.create_color_mask(self.dst, self.found_red_container)
self.green.create_color_mask(self.dst, self.found_green_container)
# Kamera extrinsisch kalibrieren
self.extrinsic_calibration()
# Bild auf dem Bildschirm ausgeben
cv2.imshow("camera", self.dst)
# mit q Kamera schließen
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# mit t Bild aufnehemen
elif cv2.waitKey(100) & 0xFF == ord('t'):
cv2.imwrite(self.path_images + "image.bmp", self.dst)
print("Bild aufgenommen")
# mit l Position der Behälter zurücksetzen
elif cv2.waitKey(100) & 0xFF == ord('l'):
self.found_blue_container = False
self.found_red_container = False
self.found_green_container = False
print("Behälterposition zurückgesetzt")
ueye.is_FreeImageMem(self.h_cam, self.pcImageMemory, self.MemID)
ueye.is_ExitCamera(self.h_cam)
cv2.destroyAllWindows()
def main():
from pyueye import ueye
import numpy as np
import cv2
import sys
import os
import tensorflow as tf
import SoundTheAlarm
import time
# ---------------------------------------------------------------------------------------------------------------------------------------
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
# Import utilites
from utils import label_map_util
from utils import visualization_utils as vis_util
# Name of the directory containing the object detection module we're using
MODEL_NAME = 'inference_graph'
# Grab path to current working directory
CWD_PATH = os.getcwd()
# Path to frozen detection graph .pb file, which contains the model that is used
# for object detection.
PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb')
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt')
# Number of classes the object detector can identify
NUM_CLASSES = 3
## Load the label map.
# Label maps map indices to category names, so that when our convolution
# network predicts `5`, we know that this corresponds to `king`.
# Here we use internal utility functions, but anything that returns a
# dictionary mapping integers to appropriate string labels would be fine
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES,
use_display_name=True)
category_index = label_map_util.create_category_index(categories)
# Load the Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
# Define input and output tensors (i.e. data) for the object detection classifier
# Input tensor is the image
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Output tensors are the detection boxes, scores, and classes
# Each box represents a part of the image where a particular object was detected
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represents level of confidence for each of the objects.
# The score is shown on the result image, together with the class label.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
# Number of objects detected
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# Variables
hCam = ueye.HIDS(0) # 0: first available camera; 1-254: The camera with the specified camera ID
sInfo = ueye.SENSORINFO()
cInfo = ueye.CAMINFO()
pcImageMemory = ueye.c_mem_p()
MemID = ueye.int()
rectAOI = ueye.IS_RECT()
pitch = ueye.INT()
nBitsPerPixel = ueye.INT(24) # 24: bits per pixel for color mode; take 8 bits per pixel for monochrome
channels = 3 # 3: channels for color mode(RGB); take 1 channel for monochrome
m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32
ueye.is_SetColorMode(hCam, ueye.IS_CM_BGR8_PACKED)
bytes_per_pixel = int(nBitsPerPixel / 8)
# ---------------------------------------------------------------------------------------------------------------------------------------
print("START")
print()
# Starts the driver and establishes the connection to the camera
nRet = ueye.is_InitCamera(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(hCam, 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(hCam, sInfo)
if nRet != ueye.IS_SUCCESS:
print("is_GetSensorInfo ERROR")
nRet = ueye.is_ResetToDefault(hCam)
if nRet != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
# Set display mode to DIB
nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB)
# Set the right color mode
if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(hCam, nBitsPerPixel, m_nColorMode)
bytes_per_pixel = int(nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ", )
print("\tm_nColorMode: \t\t", m_nColorMode)
print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", bytes_per_pixel)
print()
elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_BGRA8_PACKED
nBitsPerPixel = ueye.INT(32)
bytes_per_pixel = int(nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
print("\tm_nColorMode: \t\t", m_nColorMode)
print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", bytes_per_pixel)
print()
elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_MONO8
nBitsPerPixel = ueye.INT(8)
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()
# ---------------------------------------------------------------------------------------------------------------------------------------
# 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_AllocImageMem(hCam, width, height, nBitsPerPixel, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# 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)
# 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")
# -----------------------------------start image loop---------------------------------------------------------------
# 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
array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False)
# bytes_per_pixel = int(nBitsPerPixel / 8)
# ...reshape it in an numpy array...
frame = np.reshape(array, (height.value, width.value, bytes_per_pixel))
frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
# ------------------------------------------network_run---------------------------------------------------------
frame_expanded = np.expand_dims(frame, axis=0)
# Perform the actual detection by running the model with the image as input
(boxes, scores, classes, num) = sess.run(
[detection_boxes, detection_scores, detection_classes, num_detections],
feed_dict={image_tensor: frame_expanded})
# print("check this point-2")
# Draw the results of the detection (aka 'visualize the results')
vis_util.visualize_boxes_and_labels_on_image_array(
frame,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.85)
counter = []
add = 0
while add < (NUM_CLASSES + 1):
counter.append(0)
add += 1
element = 0 # i used this loop to configure the alarm
for i in classes[0]: # it uses the variables to count how many of each object appear in each image
if (scores[0][element]) > 0.85: #=min_score_thresh # use it to feed an alarm detector script based on
counter[int(i)] += 1 # what "should" and "shouldn't" appear
element += 1
else:
break #the break stops from iterating through the entire array, which is uneccessary
####---the alarm protocol---####
#if counter[2] and counter[3]:
#if not counter[1]:
#SoundTheAlarm.sound_loop()
print("number of each class", counter)
# All the results have been drawn on the frame, so it's time to display it.
frame = cv2.resize(frame, None, fx=0.5, fy=0.5)
cv2.destroyAllWindows()
# --------------------------------------------------------------------------------------------------------------
# ...and finally display it
cv2.imshow("SimpleLive_Python_uEye_OpenCV", frame)
# Press q if you want to end the loop
if cv2.waitKey(1) & 0xFF == ord('q'):
break
time.sleep(0.5)
# ------------------------------------------------------------------------------------------------------------------
# Releases an image memory that was allocated using is_AllocImageMem() and removes it from the driver management
ueye.is_FreeImageMem(hCam, pcImageMemory, MemID)
# Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera
ueye.is_ExitCamera(hCam)
# Destroys the OpenCv windows
cv2.destroyAllWindows()
print()
print("END")
def __init__(self, cam_num=0):
self.name = f"IDS Camera {cam_num:}"
self.hCam = ueye.HIDS(cam_num)
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)
# Starts the driver and establishes the connection to the camera
nRet = ueye.is_InitCamera(self.hCam, None)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError(f"is_InitCamera ERROR {nRet:}")
# 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:
raise RuntimeError("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:
raise RuntimeError("is_GetSensorInfo ERROR")
nRet = ueye.is_ResetToDefault(self.hCam)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_ResetToDefault ERROR")
# Set display mode to DIB
nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB)
# Set the right color mode
if (int.from_bytes(self.sInfo.nColorMode.value,
byteorder="big") == ueye.IS_COLORMODE_BAYER):
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel,
self.m_nColorMode)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ")
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()
elif (int.from_bytes(self.sInfo.nColorMode.value,
byteorder="big") == ueye.IS_COLORMODE_CBYCRY):
# for color camera models use RGB32 mode
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ")
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()
elif (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: ")
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()
else:
# for monochrome camera models use Y8 mode
self.m_nColorMode = ueye.IS_CM_MONO8
self.nBitsPerPixel = ueye.INT(8)
self.bytes_per_pixel = int(self.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(
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()
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, self.m_nColorMode)
# 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(hCam, 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(hCam, sInfo)
if nRet != ueye.IS_SUCCESS:
print("is_GetSensorInfo ERROR")
nRet = ueye.is_ResetToDefault( hCam)
if nRet != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
# Set display mode to DIB
nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB)
# # Set the right color mode
# if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
# # setup the color depth to the current windows setting
# ueye.is_GetColorDepth(hCam, nBitsPerPixel, m_nColorMode)
# bytes_per_pixel = int(nBitsPerPixel / 8)
# print("IS_COLORMODE_BAYER: ", )
# print("\tm_nColorMode: \t\t", m_nColorMode)
# print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
# print("\tbytes_per_pixel: \t\t", bytes_per_pixel)
# print()
# elif int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# # for color camera models use RGB32 mode
# m_nColorMode = ueye.IS_CM_BGRA8_PACKED
def __init__(self, index):
self.hCam = ueye.HIDS(
index
) # 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
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)
# ---------------------------------------------------------------------------------------------------------------------------------------
# print( "START" )
# print()
# Starts the driver and establishes the connection to the camera
self.nRet = ueye.is_InitCamera(self.hCam, None)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_InitCamera ERROR")
# Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that self.cInfo
# points to
self.nRet = ueye.is_GetCameraInfo(self.hCam, self.cInfo)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_GetCameraInfo ERROR")
# You can query additional information about the sensor type used in the camera
self.nRet = ueye.is_GetSensorInfo(self.hCam, self.sInfo)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_GetSensorInfo ERROR")
self.nRet = ueye.is_ResetToDefault(self.hCam)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_ResetToDefault ERROR")
# Set display mode to DIB
self.nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB)
# Set the right color mode
if int.from_bytes(self.sInfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel,
self.m_nColorMode)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ", )
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()
elif int.from_bytes(self.sInfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
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()
elif 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: ", )
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()
else:
# for monochrome camera models use Y8 mode
self.m_nColorMode = ueye.IS_CM_MONO8
self.nBitsPerPixel = ueye.INT(8)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("else")
# Can be used to set the size and position of an "area of interest"(AOI) within an image
self.nRet = ueye.is_AOI(self.hCam, ueye.IS_AOI_IMAGE_GET_AOI,
self.rectAOI, ueye.sizeof(self.rectAOI))
if self.nRet != ueye.IS_SUCCESS:
raise Exception("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()
# ---------------------------------------------------------------------------------------------------------------------------------------
# Allocates an image memory for an image having its dimensions defined by width and height and its color depth
# defined by nBitsPerPixel
self.nRet = ueye.is_AllocImageMem(self.hCam, self.width, self.height,
self.nBitsPerPixel,
self.pcImageMemory, self.MemID)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
self.nRet = ueye.is_SetImageMem(self.hCam, self.pcImageMemory,
self.MemID)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_SetImageMem ERROR")
else:
# Set the desired color mode
self.nRet = ueye.is_SetColorMode(self.hCam, self.m_nColorMode)
# Activates the camera's live video mode (free run mode)
self.nRet = ueye.is_CaptureVideo(self.hCam, ueye.IS_DONT_WAIT)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_CaptureVideo ERROR")
# Enables the queue mode for existing image memory sequences
self.nRet = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory,
self.MemID, self.width,
self.height, self.nBitsPerPixel,
self.pitch)
if self.nRet != ueye.IS_SUCCESS:
raise Exception("is_InquireImageMem ERROR")
else:
print("Camera Connection success")
def initialize_camera():
#---------------------------------------------------------------------------------------------------------------------------------------
print("START")
print()
# Starts the driver and establishes the connection to the camera
CameraApi.nRet = ueye.is_InitCamera(CameraApi.hCam, None)
if CameraApi.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
CameraApi.nRet = ueye.is_GetCameraInfo(CameraApi.hCam, CameraApi.cInfo)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_GetCameraInfo ERROR")
# You can query additional information about the sensor type used in the camera
CameraApi.nRet = ueye.is_GetSensorInfo(CameraApi.hCam, CameraApi.sInfo)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_GetSensorInfo ERROR")
CameraApi.nRet = ueye.is_ResetToDefault(CameraApi.hCam)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
# Set display mode to DIB
CameraApi.nRet = ueye.is_SetDisplayMode(CameraApi.hCam,
ueye.IS_SET_DM_DIB)
# Set the right color mode
if int.from_bytes(CameraApi.sInfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(CameraApi.hCam, CameraApi.nBitsPerPixel,
CameraApi.m_nColorMode)
CameraApi.bytes_per_pixel = int(CameraApi.nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ", )
print("\tm_nColorMode: \t\t", CameraApi.m_nColorMode)
print("\tnBitsPerPixel: \t\t", CameraApi.nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", CameraApi.bytes_per_pixel)
print()
elif int.from_bytes(CameraApi.sInfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_BGRA8_PACKED
nBitsPerPixel = ueye.INT(32)
CameraApi.bytes_per_pixel = int(nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
print("\tm_nColorMode: \t\t", m_nColorMode)
print("\tnBitsPerPixel: \t\t", nBitsPerPixel)
print("\tbytes_per_pixel: \t\t", CameraApi.bytes_per_pixel)
print()
elif int.from_bytes(CameraApi.sInfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
m_nColorMode = ueye.IS_CM_MONO8
nBitsPerPixel = ueye.INT(8)
CameraApi.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", CameraApi.bytes_per_pixel)
print()
else:
# for monochrome camera models use Y8 mode
m_nColorMode = ueye.IS_CM_MONO8
nBitsPerPixel = ueye.INT(8)
CameraApi.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
CameraApi.nRet = ueye.is_AOI(CameraApi.hCam, ueye.IS_AOI_IMAGE_GET_AOI,
CameraApi.rectAOI,
ueye.sizeof(CameraApi.rectAOI))
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_AOI ERROR")
CameraApi.width = CameraApi.rectAOI.s32Width
CameraApi.height = CameraApi.rectAOI.s32Height
# Prints out some information about the camera and the sensor
print("Camera model:\t\t",
CameraApi.sInfo.strSensorName.decode('utf-8'))
print("Camera serial no.:\t", CameraApi.cInfo.SerNo.decode('utf-8'))
print("Maximum image width:\t", CameraApi.width)
print("Maximum image height:\t", CameraApi.height)
print()
#---------------------------------------------------------------------------------------------------------------------------------------
# Allocates an image memory for an image having its dimensions defined by width and height and its color depth defined by nBitsPerPixel
CameraApi.nRet = ueye.is_AllocImageMem(CameraApi.hCam, CameraApi.width,
CameraApi.height,
CameraApi.nBitsPerPixel,
CameraApi.pcImageMemory,
CameraApi.MemID)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
CameraApi.nRet = ueye.is_SetImageMem(CameraApi.hCam,
CameraApi.pcImageMemory,
CameraApi.MemID)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_SetImageMem ERROR")
else:
# Set the desired color mode
CameraApi.nRet = ueye.is_SetColorMode(CameraApi.hCam,
CameraApi.m_nColorMode)
# Activates the camera's live video mode (free run mode)
CameraApi.nRet = ueye.is_CaptureVideo(CameraApi.hCam,
ueye.IS_DONT_WAIT)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_CaptureVideo ERROR")
# Enables the queue mode for existing image memory sequences
CameraApi.nRet = ueye.is_InquireImageMem(
CameraApi.hCam, CameraApi.pcImageMemory, CameraApi.MemID,
CameraApi.width, CameraApi.height, CameraApi.nBitsPerPixel,
CameraApi.pitch)
if CameraApi.nRet != ueye.IS_SUCCESS:
print("is_InquireImageMem ERROR")
else:
print("Press q to leave the programm")
def Setup(self):
# Setup camera's driver and color mode
# Starts the driver and establishes the connection to the camera
self.nRet = ueye.is_InitCamera(self.cam, None)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_InitCamera")
self.nRet = ueye.is_SetExternalTrigger(self.cam, ueye.IS_SET_TRIGGER_LO_HI)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_SetExternalTrigger")
# You can query additional information about the sensor type used in the camera
self.nRet = ueye.is_GetSensorInfo(self.cam, self.sInfo)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_GetSensorInfo")
# Reads out the data hard-coded in the non-volatile camera memory and writes it to the data structure that cInfo points to
self.nRet = ueye.is_GetCameraInfo(self.cam, self.cInfo)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_GetCameraInfo")
# Set Auto Gain
#self.set_gain_auto(1)
# Take params from json
param_from_json(self)
# Set Gain
self.set_gain(self.gain, self.rGain, self.gGain, self.bGain)
# Set Pixelclock
self.set_pixelclock(self.pixelclock)
# Set Exposure
self.set_exposure(self.exposure)
# Set display mode to DIB
self.nRet = ueye.is_SetDisplayMode(self.cam, ueye.IS_SET_DM_DIB)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_SetDisplayMode")
self.get_bit_per_pixel(self.m_nColorMode)
# Set Color Mode to BGR8
self.nRet = ueye.is_SetColorMode(self.cam, self.m_nColorMode)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_SetColorMode")
# Set AOI
self.nRet = ueye.is_AOI(self.cam, ueye.IS_AOI_IMAGE_SET_AOI, self.rectAOI, ueye.sizeof(self.rectAOI))
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_AOI")
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("Exposure:\t\t", self.get_exposure())
print("Frame rate:\t\t", self.current_fps)
print("PixelClock:\t\t", self.get_pixelclock())
print("Gain:\t\t\t", self.get_gain())
print("rGain:\t\t\t", self.rGain)
print("bGain:\t\t\t", self.bGain)
print("gGain:\t\t\t", self.gGain)
print("Color mode:\t\t", self.m_nColorMode)
print("Bits per pixel:\t\t", int(self.bits_per_pixel))
print()
self.alloc()
self.nRet = self.capture_video()
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_CaptureVideo")
print("Press \'Ctrl + C\' to leave the programm")
print()
def open_connection(self, camID):
"""
Function taking care of the Thorlabs camera initialization.
Parameters
----------
camID : int - indicate the handle of the camera we want to intialize.
"""
# Starts the driver and establishes the connection to the camera
# --------------------------------------------------------------
self.hcam = ueye.HIDS(camID)
Init = ueye.is_InitCamera(self.hcam, None)
if Init != ueye.IS_SUCCESS:
print(
"is_InitCamera ERROR - make sure the camera is properly connected"
)
self.cam_initialized.emit('')
return
# Reads out the data hard-coded in the non-volatile camera memory and
# writes it to the data structure that cInfo points to
# ----------------------------------------------------
read_cam_info = ueye.is_GetCameraInfo(self.hcam, self.cam_info)
if read_cam_info != ueye.IS_SUCCESS:
print("is_GetCameraInfo ERROR")
self.cam_initialized.emit('')
return
# You can query additional information about the sensor type used in
# the camera
# ----------
read_sensor_info = ueye.is_GetSensorInfo(self.hcam, self.sensor_info)
if read_sensor_info != ueye.IS_SUCCESS:
print("is_GetSensorInfo ERROR")
self.cam_initialized.emit('')
return
# Reset buffer and all the display parameters to the default values
# -----------------------------------------------------------------
reset = ueye.is_ResetToDefault(self.hcam)
if reset != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
self.cam_initialized.emit('')
return
# Set display mode to DIB - the image is directly saved on the RAM
# ----------------------------------------------------------------
ueye.is_SetDisplayMode(self.hcam, ueye.IS_SET_DM_DIB)
# Set the color mode according to the sensor properties
# -----------------------------------------------------
if int.from_bytes(self.sensor_info.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.color_mode = 'RGB'
elif int.from_bytes(self.sensor_info.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)
self.color_mode = 'Monochrome'
else:
print('Error : the camera type is unknown.')
self.cam_initialized.emit('')
return
# Define a dictionary with the main properties of the camera selected
# -------------------------------------------------------------------
ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_GET_AOI, self.rectAOI,
ueye.sizeof(self.rectAOI))
self.Properties = {
'Camera sensor model (from IDS)':
self.sensor_info.strSensorName.decode('utf-8'),
'Camera s/n':
self.cam_info.SerNo.decode('utf-8'),
'Color mode':
self.color_mode,
'Image width':
int(self.rectAOI.s32Width),
'Image height':
int(self.rectAOI.s32Height),
}
# Indicate that the initialization procedure was completed
# --------------------------------------------------------
print('Success : Thorlabs camera was found and initialized')
self.cam_initialized.emit(self.Properties['Camera s/n'])
def UEye420_Snapper(Exposure, Gain, File_Location, pixel_clock):
from pyueye import ueye
import ctypes
import time
saved = False
while saved == False:
#CCD Settings and Start-Up
hcam = ueye.HIDS(0)
pccmem = ueye.c_mem_p()
memID = ueye.c_int()
hWnd = ctypes.c_voidp()
ueye.is_InitCamera(hcam, hWnd)
ueye.is_SetDisplayMode(hcam, 0)
sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(hcam, sensorinfo)
ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth,
sensorinfo.nMaxHeight, 24, pccmem, memID)
ueye.is_SetImageMem(hcam, pccmem, memID)
ueye.is_SetDisplayPos(hcam, 100, 100)
PIXELCLOCK_CMD_SET = 6
PIXELCLOCK_CMD_GET = 4
pixel = ctypes.c_uint(pixel_clock)
ueye.is_PixelClock(hcam, PIXELCLOCK_CMD_SET, pixel,
ctypes.sizeof(pixel))
print('PX=', pixel)
exposure_time = ctypes.c_double(
Exposure) #Exposure time in miliseconds
value = ctypes.c_int(Gain)
ueye.is_SetHWGainFactor(hcam, ueye.IS_SET_MASTER_GAIN_FACTOR, value)
ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
exposure_time, ctypes.sizeof(ctypes.c_double))
print('Exposure (ms) =', exposure_time)
print('Gain = ', Gain)
time.sleep(float(Exposure * 1e-4) * 1.0 +
0.2) #Some time for CCD to set new exposure time
#initially set to float(Exposure*1e-4)*1.0+1.0 and it works then
nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT) #Freeze/Snap
#Save Parameters
FileParams = ueye.IMAGE_FILE_PARAMS()
FileParams.pwchFileName = (File_Location)
FileParams.nFileType = ueye.IS_IMG_BMP
FileParams.ppcImageMem = None
FileParams.pnImageID = None
#IF nret is '1' Image is not saved if nret is "0" Image is saved
nret = ueye.is_ImageFile(hcam, ueye.IS_IMAGE_FILE_CMD_SAVE, FileParams,
ueye.sizeof(FileParams))
if nret == 0:
saved = True
print('Image Saved!')
if nret == 1:
print('Error Image is not Saved!')
#Shutting the CCD-Down.
ueye.is_FreeImageMem(hcam, pccmem, memID)
ueye.is_ExitCamera(hcam)
def __init__(self):
#Variables
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.exposure = ueye.DOUBLE(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 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")
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)
# Set the right color mode
if int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.hCam, self.nBitsPerPixel, self.m_nColorMode)
self.nBitsPerPixel = ueye.INT(32) #------------Added this because it gets changed on linux and that f***s everything up.
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_BAYER: ", )
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()
elif int.from_bytes(self.sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
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()
elif 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: ", )
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()
else:
# for monochrome camera models use Y8 mode
self.m_nColorMode = ueye.IS_CM_MONO8
self.nBitsPerPixel = ueye.INT(8)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("else")
nRet = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.exposure, ueye.sizeof(self.exposure))#TODO
# 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()
#Allocate image dimensions
self.update_image_memory()
def cameraInit(load_parameters_EEPROM=load_parameters_EEPROM):
"""Initializes the camera with the correct parameters"""
global mBuff, bpp, pitch, channels, bytes_per_pixel, tt
hCam = ueye.HIDS(0) # 0: first available camera; 1-254: The camera with the specified camera ID
sInfo = ueye.SENSORINFO()
cInfo = ueye.CAMINFO()
# Starts the driver and establishes the connection to the camera
nRet = ueye.is_InitCamera(hCam, None)
logger.debug("Setting Camera Data")
if nRet != ueye.IS_SUCCESS:
logger.info("is_InitCamera ERROR, camera not connected?")
return -1, 0
# 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(hCam, cInfo)
if nRet != ueye.IS_SUCCESS:
logger.info("is_GetCameraInfo ERROR")
# You can query additional information about the sensor type used in the camera
nRet = ueye.is_GetSensorInfo(hCam, sInfo)
if nRet != ueye.IS_SUCCESS:
logger.info("is_GetSensorInfo ERROR")
nRet = ueye.is_ResetToDefault(hCam)
if nRet != ueye.IS_SUCCESS:
logger.info("is_ResetToDefault ERROR")
# Set display mode to DIB
nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB)
if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
logger.info("Setting colormode to black and white")
m_nColorMode = ueye.IS_CM_MONO8
nBitsPerPixel = ueye.INT(8)
bytes_per_pixel = int(nBitsPerPixel / 8)
logger.info(f"IS_COLORMODE_MONOCHROME: ")
logger.info(f"\tm_nColorMode: \t\t{m_nColorMode}")
logger.info(f"\tnBitsPerPixel: \t\t{nBitsPerPixel}")
logger.info(f"\tbytes_per_pixel: \t\t {bytes_per_pixel}")
if load_parameters_EEPROM:
logger.debug("Loading parameters from EEPROM")
nullint = ueye._value_cast(0, ueye.ctypes.c_uint)
rvv = ueye.is_ParameterSet(hCam, ueye.IS_PARAMETERSET_CMD_LOAD_EEPROM, nullint, nullint)
# 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:
logger.error("is_AOI ERROR")
width = rectAOI.s32Width
height = rectAOI.s32Height
# Prints out some information about the camera and the sensor
logger.info(f"Camera model:\t\t {sInfo.strSensorName.decode('utf-8')}")
logger.info(f"Camera serial no.:\t {cInfo.SerNo.decode('utf-8')}")
logger.info(f"Maximum image width:\t {width}")
logger.info(f"Maximum image height:\t {height}")
# ---------------------------------------------------------------------------------------------------------------------------------------
# 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_AllocImageMem(hCam, width, height, nBitsPerPixel, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
logger.info("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(hCam, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
logger.info("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(hCam, m_nColorMode)
# Activates the camera's live video mode (free run mode)
nRet = ueye.is_CaptureVideo(hCam, ueye.IS_DONT_WAIT)
if nRet != ueye.IS_SUCCESS:
logger.info("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:
logger.info("is_InquireImageMem ERROR")
else:
logger.info("Press q to leave the programm")
# ---------------------------------------------------------------------------------------------------------------------------------------
# shutter = int.from_bytes(sInfo.bGlobShutter.value, byteorder='big')
# rvv = ueye.is_ParameterSet(hCam,ueye.IS_PARAMETERSET_CMD_LOAD_EEPROM,nullint,nullint)
# Continuous image display
tt = ueye.is_AOI(hCam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi, ueye.sizeof(rect_aoi))
width = rect_aoi.s32Width.value
height = rect_aoi.s32Height.value
for i in range(numBuffers):
buff = ImageBuffer()
ueye.is_AllocImageMem(hCam,
width, height, bpp,
buff.mem_ptr, buff.mem_id)
ueye.is_AddToSequence(hCam, buff.mem_ptr, buff.mem_id)
buffs.append(buff)
rvIQ = ueye.is_InitImageQueue(hCam, 0)
nRet = ueye.IS_SUCCESS
ret = ueye.is_WaitForNextImage(hCam,
100,
mBuff.mem_ptr,
mBuff.mem_id)
rr = ueye.is_GetActSeqBuf(hCam, buffCurrent.mem_id, buffLast.mem_ptr, buffLast.mem_ptr)
if (not ret):
# cnt+=1
array = ueye.get_data(mBuff.mem_ptr, width, height, bpp, pitch, copy=True)
ueye.is_UnlockSeqBuf(hCam, mBuff.mem_id, mBuff.mem_ptr)
return nRet, hCam
def configure_device(self):
"""
Configure camera.
"""
self.nRet = ueye.is_ResetToDefault(self.hid)
if self.nRet != ueye.IS_SUCCESS:
print('Reset ERROR')
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN, self.minExp, 8)
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX, self.maxExp, 8)
self.nRet = ueye.is_SetDisplayMode(self.hid, ueye.IS_SET_DM_DIB)
if self.nRet != ueye.IS_SUCCESS:
print('Display Mode ERROR')
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, self.minExp, 8 )
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, self.Exp, 8 )
# Set the right color mode
if int.from_bytes(self.sinfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.hid, self.bitspixel, self.colorm)
self.bytesppixel = int(self.bitspixel / 8)
elif int.from_bytes(self.sinfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.colorm = ueye.IS_CM_BGRA8_PACKED
self.bitspixel = ueye.INT(32)
self.bytesppixel = int(self.bitspixel / 8)
elif int.from_bytes(self.sinfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
self.colorm = ueye.IS_CM_MONO8
self.bitspixel = ueye.INT(8)
self.bytesppixel = int(self.bitspixel / 8)
else:
# for monochrome camera models use Y8 mode
self.colorm = ueye.IS_CM_MONO8
self.bitspixel = ueye.INT(8)
self.bytesppixel = int(self.bitspixel / 8)
self.nRet = ueye.is_AOI(self.hid, ueye.IS_AOI_IMAGE_GET_AOI, self.rect,
ueye.sizeof(self.rect))
self.width = self.rect.s32Width
self.height = self.rect.s32Height
self.pixelSizeMicron = self.sinfo.wPixelSize.value / 100
if self.nRet != ueye.IS_SUCCESS:
print('AOI ERROR')
self.nRet = ueye.is_AllocImageMem(self.hid, self.width, self.height,
self.bitspixel, self.ppcImgMem,
self.MemID)
if self.nRet != ueye.IS_SUCCESS:
print('AllocImageMem ERROR')
else:
self.nRet = ueye.is_SetImageMem(self.hid, self.ppcImgMem, self.MemID)
if self.nRet != ueye.IS_SUCCESS:
print('SetImageMem ERROR')
else:
self.nRet = ueye.is_SetColorMode(self.hid, self.colorm)
self.nRet = ueye.is_CaptureVideo(self.hid, ueye.IS_DONT_WAIT)
#if self.nRet != ueye.IS_SUCCESS:
#print('CaptureVideo ERROR')
self.nRet = ueye.is_InquireImageMem(self.hid, self.ppcImgMem, self.MemID,
self.width, self.height, self.bitspixel,
self.pitch)
if self.nRet != ueye.IS_SUCCESS:
print('InquireImageMem ERROR')
def set_displaymode(self, displaymode):
check(ueye.is_SetDisplayMode(self.h_cam, displaymode))
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)
def __init__(self, camId=0):
print("Initializing camera module")
self.hCam = ueye.HIDS(camId)
# 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")
nRet = ueye.is_ResetToDefault(self.hCam)
if nRet != ueye.IS_SUCCESS:
print("is_ResetToDefault ERROR")
nRet = ueye.is_SetDisplayMode(self.hCam, ueye.IS_SET_DM_DIB)
# for monochrome camera models use Y8 mode
self.m_nColorMode = ueye.IS_CM_MONO8
self.nBitsPerPixel = ueye.INT(8)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
print("Monochrome Mode")
# Area of interest can be set here
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)
# 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_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, self.m_nColorMode)
# Activates the camera's live video mode (free run mode)
nRet = ueye.is_CaptureVideo(self.hCam, ueye.IS_DONT_WAIT)
if nRet != ueye.IS_SUCCESS:
print("is_CaptureVideo ERROR")
ueye.is_SetRopEffect(self.hCam, ueye.IS_SET_ROP_MIRROR_UPDOWN, 1, 0)
ueye.is_SetRopEffect(self.hCam, ueye.IS_SET_ROP_MIRROR_LEFTRIGHT, 1, 0)
# Enables the queue mode for existing image memory sequences
nRet = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory,
self.MemID, self.width, self.height,
self.nBitsPerPixel, self.pitch)
if nRet != ueye.IS_SUCCESS:
print("is_InquireImageMem ERROR")
# enable trigger for new frame
ueye.is_EnableEvent(self.hCam, ueye.IS_SET_EVENT_FRAME)
print("Initialized!")
def show_image(self):
# Kamera initialisieren
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:
# Daten der Kamera auslesen
array = ueye.get_data(self.pcImageMemory,
self.width,
self.height,
self.nBitsPerPixel,
self.pitch,
copy=True)
# Bild zuschneiden
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)
# Kamerabild ausgeben
cv2.imshow("camera", frame)
# mit q Kamera schließen
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# mit t Bild aufnehmen und speichern, wenn ein Schachbrettmuster erkannt wird
elif cv2.waitKey(1) & 0xFF == ord('t'):
ret, corners = cv2.findChessboardCorners(
frame, (self.nx, self.ny), None)
if ret:
im_name = self.path + str(self.n_im) + ".bmp"
cv2.imwrite(im_name, frame)
self.n_im = self.n_im + 1
print("Bild", self.n_im, "aufgenommen.")
else:
print("Kein Chessboard gefunden")
# mit d Schachbrettlinien zeichnen und speichern
elif cv2.waitKey(1) & 0xFF == ord('d'):
self.draw_chessboard_corners(True)
# mit c Kamera intrinsisch kalibrieren
elif cv2.waitKey(1) & 0xFF == ord('c'):
if self.n_im > 0:
self.calibrate()
else:
print("Vorher Bilder aufnehmen!")
ueye.is_FreeImageMem(self.h_cam, self.pcImageMemory, self.MemID)
ueye.is_ExitCamera(self.h_cam)
cv2.destroyAllWindows()
def __display_mode(self):
if not ueye.is_SetDisplayMode(self.cam, ueye.IS_SET_DM_DIB) == ueye.IS_SUCCESS:
raise RuntimeError("Display mode error")
