def initialize_color_mode(self):
'''
Initializes color mode.
Sets:
self.m_nColorMode
self.bits_per_pixel
self.bytes_per_pixel
'''
# get color mode
sensor_info = ueye.SENSORINFO()
color_mode = int.from_bytes(sensor_info.nColorMode.value, byteorder='big')
self.m_nColorMode = ueye.INT()
# determine the number of bits/bytes per pixel through the color mode
bits_per_pixel = ueye.INT(24)
if color_mode == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.input, bits_per_pixel, self.m_nColorMode)
# TODO: unimplemented bayer pixel format
elif color_mode == ueye.IS_COLORMODE_CBYCRY:
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED
bits_per_pixel = ueye.INT(32)
# TODO: test this once we get a suitable camera
self.config['pixel_format'] = 'bgra'
else:
self.m_nColorMode = ueye.IS_CM_MONO8
bits_per_pixel = ueye.INT(8)
self.config['pixel_format'] = 'gray'
self.bytes_per_pixel = int(bits_per_pixel / 8)
self.bits_per_pixel = bits_per_pixel
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 _allocate_memory(self):
# Allocates memory on the PC and camera
# 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._cam, self._nBitsPerPixel,
self._m_nColorMode)
self._bytes_per_pixel = self._nBitsPerPixel / 8
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 = self._nBitsPerPixel / 8
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 = self._nBitsPerPixel / 8
else:
# for monochrome camera models use Y8 mode
self._m_nColorMode = ueye.IS_CM_MONO8
self._nBitsPerPixel = ueye.INT(8)
self._bytes_per_pixel = self._nBitsPerPixel / 8
# allocate memory for an image
err = ueye.is_AllocImageMem(
self._cam,
self._width,
self._height,
self._nBitsPerPixel,
self._ppc_img_mem,
self._mem_id,
)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>_allocate_memory>', err)
# make the image memory 'active'
err = ueye.is_SetImageMem(self._cam, self._ppc_img_mem, self._mem_id)
if err != ueye.IS_SUCCESS:
raise CameraException(self._cam, 'ueye>_allocate_memory>', err)
def __get_color_mode(self):
# Set the right color mode
if int.from_bytes(self.sensor_info.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_BAYER:
ueye.is_GetColorDepth(self.cam, self.bits_per_pixel,
self.color_mode)
self.bytes_per_pixel = int(self.bits_per_pixel / 8)
print("IS_COLORMODE_BAYER: ", )
print("\tcolor_mode: \t\t", self.color_mode)
print("\tnBitsPerPixel: \t\t", self.bits_per_pixel)
print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel)
print()
elif int.from_bytes(self.sensor_info.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.color_mode = ueye.IS_CM_BGRA8_PACKED
self.bits_per_pixel = ueye.INT(32)
self.bytes_per_pixel = int(self.bits_per_pixel / 8)
print("IS_COLORMODE_CBYCRY: ", )
print("\tcolor_mode: \t\t", self.color_mode)
print("\tnBitsPerPixel: \t\t", self.bits_per_pixel)
print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel)
print()
elif int.from_bytes(self.sensor_info.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
self.color_mode = ueye.IS_CM_MONO10
self.bits_per_pixel = ueye.INT(16)
self.bytes_per_pixel = int(self.bits_per_pixel / 8)
print("IS_COLORMODE_MONOCHROME: ", )
print("\tcolor_mode: \t\t", self.color_mode)
print("\tnBitsPerPixel: \t\t", self.bits_per_pixel)
print("\tbytes_per_pixel: \t\t", self.bytes_per_pixel)
print()
else:
self.color_mode = ueye.IS_CM_MONO8
self.bits_per_pixel = ueye.INT(8)
self.bytes_per_pixel = int(self.bits_per_pixel / 8)
import ctypes
import numpy as np
from pyueye import ueye
import copy
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)
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')
# 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)
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)
def get_colordepth(self):
pnCol = ueye.int()
pnColMode = ueye.int()
ret = ueye.is_GetColorDepth(self.h_cam, pnCol, pnColMode)
return pnCol, pnColMode
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 __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 __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 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")
