def allocate_memory(self):
'''
Allocates memory on the PC and camera
'''
#allocate memory
self.width = 2048
self.height = 1088
c_width = ctypes.c_int(self.width)
c_height = ctypes.c_int(self.height)
c_pixel_bits = ctypes.c_int(self.color_mode.bits_per_pixel)
#the starting memory address for the image, will be returned
self.ppcImgMem = pue.c_mem_p()
#the ID for the allocated image, will be returned
self.pid = ctypes.c_int()
#allocate memory for an image
err = pue.is_AllocImageMem(self.cam, c_width, c_height, c_pixel_bits,
self.ppcImgMem, self.pid)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam, 'ueye>allocate_memory>', err)
# make the image memory 'active'
err = pue.is_SetImageMem(self.cam, self.ppcImgMem, self.pid)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam, 'ueye>allocate_memory>', err)
#create an array in python to which to copy the image
self.image_data = np.zeros(
(self.height, self.width, self.color_mode.channels),
dtype=self.color_mode.dtype)
def __init__(self):
self.hCam = ueye.HIDS(
1
) # 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.f_length = (652.7396, 653.3803) # FocalLength
self.p_center = (321.8104, 259.7124) # PrincipalPoint
self.intrinsic = np.array(
[[self.f_length[0], 0, self.p_center[0]],
[0, self.f_length[1], self.p_center[1]], [0, 0, 1]],
dtype=np.float)
self.offset = [0, 0, 50] #milimeter
# ---------------------------------------------------------------------------------------------------------------------------------------
print("In hand camera initilized")
def __init__(self):
self.cam = ueye.HIDS(0)
self.cam_info = ueye.CAMINFO()
self.sensor_info = ueye.SENSORINFO()
self.image_memory = ueye.c_mem_p()
self.memory_id = ueye.int()
self.rect_aoi = ueye.IS_RECT()
self.bits_per_pixel = ueye.INT(24)
self.bytes_per_pixel = int(self.bits_per_pixel / 8)
self.pitch = ueye.INT()
self.color_mode = ueye.INT()
self.width = 0
self.height = 0
self.status = 'IDLE'
self.data = []
self.lock = Lock()
self.pipe = 0
self.offset_x = 2
self.offset_y = 2
self.__init_camera()
self.__get_camera_info()
self.__get_sensor_info()
#self.__default()
self.__display_mode()
self.__get_color_mode()
self.__get_dimensions()
self.__memory_allocation()
self.__set_color_mode()
self.__set_events()
self.__mandatory_shit()
print("Color mode {}".format(self.color_mode))
print("Bits per pixel {}".format(self.bits_per_pixel))
print("Bytes per pixel {}".format(self.bytes_per_pixel))
def __init__(self, camID, buffer_count=3):
# Variables
self.cam = ueye.HIDS(camID)
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(8)
self.channels = 3
self.m_nColorMode = ueye.IS_CM_SENSOR_RAW8
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.buffer_count = buffer_count
self.img_buffer = []
self.mode_filename = 0
self.pixelclock = 0
self.exposure = 0
self.width = 0
self.height = 0
self.nRet = 0
self.camID = camID
self.current_fps = 0
self.FPS = 0
self.gain = 0
self.rGain = 0
self.bGain = 0
self.gGain = 0
def __init__(self):
# Variabeln für Kameraverarbeitung
self.h_cam = ueye.HIDS(0)
self.pitch = ueye.INT()
self.ColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.pitch = ueye.INT()
self.pcImageMemory = ueye.c_mem_p()
self.rectAOI = ueye.IS_RECT()
self.MemID = ueye.int()
self.width = None
self.height = None
self.size_of_square = 3.6 # Zentimeter
self.nx = 8
self.ny = 6
self.n_im = 0
self.gray = None
self.objectpoints = None
self.imagepoints = None
self.camera_matrix = None
self.dist_coeff = None
self.mean_error = 0
# Pfad zum Speichern der Bilder angeben
self.path = os.path.dirname(os.path.abspath(sys.argv[0])) + "/images/"
def __init__(self, parent=None):
self.converted_memory_pointer = ueye.c_mem_p()
self.converted_memory_id = ueye.int()
self.img_data = ImageData()
self.capturing = False
self.hCam = 0
self.init()
ueye.is_SetColorMode(self.hCam, ueye.IS_CM_RGB8_PACKED)
self.alloc(self.hCam)
self.qt_image = None
ueye.is_CaptureVideo(self.hCam, Wait=True)
QWidget.__init__(self, parent, flags=Qt.Widget)
self.graphics_scene = QGraphicsScene()
self.graphics_view = QGraphicsView(self.graphics_scene)
self.graphics_view.setViewportUpdateMode(
QGraphicsView.FullViewportUpdate)
self.start_stop_button = QPushButton("start/stop")
self.event = ueye.HANDLE(int())
self.frame_event_id = ueye.IS_SET_EVENT_FRAME
self.image_data_copy = None
self.pil_image = None
self.pix_map = None
self.width = 0
self.height = 0
self.threads = []
layout = QVBoxLayout()
layout.addWidget(self.start_stop_button, alignment=Qt.AlignTop)
layout.addWidget(self.graphics_view)
self.setLayout(layout)
self.start_stop_button.clicked.connect(self.switch_capturing)
def setBuffer(self, size): self.bufCount=size if self.Imgs is not None: for i in range(self.bufCount): rv=ueye.is_FreeImageMem (self.hcam, self.Imgs[i], self.bufIds[i]) if rv: self.status=True return True self.bufIds[i] = 0 if self.getAOI(): self.status=True return True self.imgWidth=self.AOI.s32Width.value self.imgHeight=self.AOI.s32Height.value self.Imgs=[ueye.c_mem_p() for i in range(size)] self.bufIds=[ueye.c_int() for i in range(size)] for i in range(self.bufCount): rv=ueye.is_AllocImageMem(self.hcam, self.imgWidth, self.imgHeight,self.bitsPixel, self.Imgs[i], self.bufIds[i]) if rv: self.status=True return True rv=ueye.is_AddToSequence (self.hcam, self.Imgs[i], self.bufIds[i]) if rv: self.status=True return True self.LineInc=ueye.c_int() rv=ueye.is_GetImageMemPitch (self.hcam, self.LineInc) if rv: self.status=True return True return False
def grabanimage():
camera_port = 0
ramp_frames = 40
camera = cv2.VideoCapture(camera_port)
################## original (access camera thru cv2) ##########################
# def get_image():
# retval, im = camera.read()
# return im
#
# for i in xrange(ramp_frames):
# temp = get_image()
# print("Taking image...")
## Take the actual image we want to keep
# camera_capture = get_image()
# file = "USBtemp.png"
## A nice feature of the imwrite method is that it will automatically choose the
## correct format based on the file extension you provide. Convenient!
# cv2.imwrite(file, camera_capture)
############# reading from IDS camera (added 6/1/19 by Abner) #################
def get_image(w, h):
im = ueye.get_data(mem_ptr, w, h, bitspixel, lineinc, copy=True)
return im
# init camera
hcam = ueye.HIDS(0)
initTrigger = ueye.is_InitCamera(hcam, None)
# load camera parameters
memory = ueye.int(128)
# cameraSettingFile = ueye.wchar_p('/media/pi/USB30FD/Frostad Research Group/Biofilm Project/Code/FINAL_Biofilm Project.ini')
ret = ueye.is_ParameterSet(hcam, ueye.IS_PARAMETERSET_CMD_LOAD_FILE,
cameraSettingFile, memory)
# set color mode
ret = ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED)
# set width and height -- FIND FUNCTION TO OUTPUT IMAGE RESOLUTION
width = 2560
height = 1920
# allocate memory
mem_ptr = ueye.c_mem_p()
mem_id = ueye.int()
bitspixel = 24 # for colormode = IS_CM_BGR8_PACKED
ret = ueye.is_AllocImageMem(hcam, width, height, bitspixel, mem_ptr,
mem_id)
# set active memory region
ret = ueye.is_SetImageMem(hcam, mem_ptr, mem_id)
# continuous capture to memory
ret = ueye.is_CaptureVideo(hcam, ueye.IS_DONT_WAIT)
# get data from camera and display
lineinc = width * int((bitspixel + 7) / 8)
for i in xrange(ramp_frames):
temp = get_image(width, height)
print("Taking image...")
# Take the actual image we want to keep
camera_capture = get_image(width, height)
file = "USBtemp.png"
def __init__(self, frames_avg=1):
""" Object constructor, called when creating instance of the BaslerCam class """
self.CamID = ueye.HIDS(1)
self.intTime = 15000
self.iniFile = ""
self.frames_avg = frames_avg
self.connected = False
self.binningEnabled = False
# ctypes process parameters
self.memPointer = ueye.c_mem_p()
self.memID = ueye.c_int()
self.pPitch = ueye.c_int()
self.bitdepth = 16 #ueye.c_int(8)
self.FPS = 8
self.currentFPS = self.FPS
self.pixelClock = 80
# Sensor dimension variables: variable type in native python + fixed sensorSize in ctypes formats
self.sensorHeight_ctype = ueye.c_int(3088)
self.sensorWidth_ctype = ueye.c_int(2076)
self.currentWidth = 3088
self.currentHeight = 2076
# Initialize camera
self.connect()
def init_cam(hcam):
# get fps
# hcam_fps = is_GetFramesPerSecond(hcam, None)
# set color mode
ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED)
# set region of interest
rect_aoi = ueye.IS_RECT()
rect_aoi.s32X = ueye.int(0)
rect_aoi.s32Y = ueye.int(0)
rect_aoi.s32Width = ueye.int(width)
rect_aoi.s32Height = ueye.int(height)
ueye.is_AOI(hcam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi,
ueye.sizeof(rect_aoi))
# allocate memory
mem_ptr = ueye.c_mem_p()
mem_id = ueye.int()
ueye.is_AllocImageMem(hcam, width, height, bitspixel, mem_ptr, mem_id)
ueye.is_SetImageMem(hcam, mem_ptr, mem_id)
# continuous capture to memory
ueye.is_CaptureVideo(hcam, ueye.IS_DONT_WAIT)
return mem_ptr
def __init__(self, graphic=None, mainf=None):
self.camera = False
self.graphic = graphic
self.mainf = mainf
self.detected_devices = {}
self.nRet = None
try:
self.hid = ueye.HIDS()
self.sinfo = ueye.SENSORINFO()
self.hwnd = ueye.HWND()
self.width = ueye.INT()
self.height = ueye.INT()
self.psize = None
self.bitspixel = ueye.INT(24)
self.bytesppixel = int(self.bitspixel / 8)
self.ppcImgMem = ueye.c_mem_p()
self.pid = ueye.INT()
self.MemID = ueye.INT()
self.colorm = ueye.INT()
self.pitch = ueye.INT()
self.rect = ueye.IS_RECT()
self.maxExp = ueye.double()
self.minExp = ueye.double()
self.Exp = ueye.double()
except:
return
def __init__(self):
# Variabeln für Kameraverarbeitung
self.h_cam = ueye.HIDS(0)
self.pitch = ueye.INT()
self.ColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.pitch = ueye.INT()
self.pcImageMemory = ueye.c_mem_p()
self.rectAOI = ueye.IS_RECT()
self.MemID = ueye.int()
self.width = None
self.height = None
self.dst = None
self.path_images = os.path.dirname(os.path.abspath(
sys.argv[0])) + "/images/"
# laden der intrinsischen Kalibriermatrix
self.load_calibration_config()
# Variabeln zur Farberkennung
self.found_container = False
self.contours_rectangle = []
blue_lower = [50, 0, 0]
blue_upper = [255, 75, 75]
self.boundaries = [(blue_lower, blue_upper)]
self.cX = None
self.cY = None
self.cX_container = None
self.cY_container = None
# Variablen zur Positionsbestimmung
self.container_world_position = []
self.ball_position = []
self.container_position = []
self.qr_centres = []
self.world_points = []
self.qr_codes = None
self.image_points_of_qr_codes = None
self.localization_qr_codes = []
self.world_localization_qr_codes = []
self.increment = 0.25
self.results = 0
# Wahl des Ansatzes
self.method = 0
while self.method <= 0 or self.method >= 4:
try:
self.method = eval(
input(
"Mit welchem Ansatz sollen die Positionen ermittelt werden?\n (1) GPS-Ansatz\n "
"(2) Vergleichsansattz\n (3) Berechnen der Weltkoordinaten\n"
))
except NameError:
self.method = 0
except SyntaxError:
self.method = 0
except TypeError:
self.method = 0
def __init__(self):
self.hcam = ueye.HIDS(0)
self.membuf = ueye.c_mem_p()
self.memid = ueye.int()
self.pitch = -1
self.framerate = -1
self.imgwidth = None
self.imgheight = None
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
class cam:
camID = 0
vc = None
mem_ptr = ueye.c_mem_p()
mem_id = ueye.int()
mem_size = (0,0)
def __init__(self, _camID):
self.camID=_camID
self.vc = ueye.HIDS(_camID)
if not (ueye.is_InitCamera(self.vc, None)==0):
raise ValueError('Failed to open camera')
#reserve memory
self.mem_size = self.getMaxSize()
ueye.is_AllocImageMem(self.vc, self.mem_size[0], self.mem_size[1],24,self.mem_ptr, self.mem_id)
#set active memory region
ueye.is_SetImageMem(self.vc, self.mem_ptr, self.mem_id)
#continuous capture to memory
ueye.is_CaptureVideo(self.vc, ueye.IS_DONT_WAIT)
def setSize(self,_size):
#TODO
#test size:
if self.getSize() != _size:
raise ValueError('Failed to set camera size')
def getSize(self):
_h,_w = self.getFrame().shape[0:2]
return (_w,_h)
def getMaxSize(self):
sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(self.vc, sensorinfo)
return (sensorinfo.nMaxWidth.value,sensorinfo.nMaxHeight.value)
def getID(self):
return self.camID
def getFrame(self):
lineinc = self.mem_size[0] * int((24 + 7) / 8)
frame = ueye.get_data(self.mem_ptr, self.mem_size[0], self.mem_size[1], 24, lineinc, copy=True)
frame = np.reshape(frame, (self.mem_size[1],self.mem_size[0], 3))
return frame
def close(self):
ueye.is_StopLiveVideo(self.vc, ueye.IS_FORCE_VIDEO_STOP)
ueye.is_ExitCamera(self.vc)
def __init__(self, cam_ID = 0):
# Several parameters are unused, but may be needed in the future
self.hCam = ueye.HIDS(cam_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(32) # 32 bits for color camera
self.channels = 3 # 3: channels for color mode(RGB); take 1 channel for monochrome
self.m_nColorMode = ueye.IS_CM_BGRA8_PACKED # RGB32
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
def Camera_Initialization(self):
self.hcam = ueye.HIDS(0)
self.ret = ueye.is_InitCamera(self.hcam, None)
self.ret = ueye.is_SetColorMode(self.hcam, ueye.IS_CM_MONO12)
self.IDS_FPS = float(50)
self.newrate = ueye.DOUBLE(self.IDS_FPS)
self.rate = ueye.DOUBLE(self.IDS_FPS)
self.IDS_exposure = float(20)
self.width = 2056
self.height = 1542
self.rect_aoi = ueye.IS_RECT()
self.rect_aoi.s32X = ueye.int(0)
self.rect_aoi.s32Y = ueye.int(0)
self.rect_aoi.s32Width = ueye.int(self.width)
self.rect_aoi.s32Height = ueye.int(self.height)
ueye.is_AOI(self.hcam, ueye.IS_AOI_IMAGE_SET_AOI, self.rect_aoi,
ueye.sizeof(self.rect_aoi))
self.mem_ptr = ueye.c_mem_p()
self.mem_id = ueye.int()
self.bitspixel = 16
self.ret = ueye.is_AllocImageMem(self.hcam, self.width, self.height,
self.bitspixel, self.mem_ptr,
self.mem_id)
self.ret = ueye.is_SetImageMem(self.hcam, self.mem_ptr, self.mem_id)
self.ret = ueye.is_CaptureVideo(self.hcam, ueye.IS_DONT_WAIT)
#self.lineinc = self.width * int((self.bitspixel + 7) / 8)
self.lineinc = self.width * int(self.bitspixel / 8)
self.nRet = ueye.is_SetFrameRate(self.hcam, self.rate, self.newrate)
self.expms = ueye.DOUBLE(self.IDS_exposure)
self.nRet = ueye.is_Exposure(self.hcam,
ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
self.expms, ueye.sizeof(self.expms))
self.pixelclock = ueye.c_uint(197)
self.nRet = ueye.is_PixelClock(self.hcam, ueye.IS_PIXELCLOCK_CMD_SET,
self.pixelclock, 4)
#pixelclock = ueye.c_uint()
#ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, pixelclock, 4)
self.nRet = ueye.is_SetHardwareGain(self.hcam, 100,
ueye.IS_IGNORE_PARAMETER,
ueye.IS_IGNORE_PARAMETER,
ueye.IS_IGNORE_PARAMETER)
#gg = ueye.c_uint()
#ueye.is_SetHWGainFactor(hcam, ueye.IS_GET_MASTER_GAIN_FACTOR, gg)
self.nRet = ueye.is_SetHardwareGamma(self.hcam,
ueye.IS_SET_HW_GAMMA_ON)
def 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 init_cam(hcam):
# get fps
# hcam_fps = is_GetFramesPerSecond(hcam, None)
# set color mode
ueye.is_SetColorMode(hcam, ueye.IS_CM_BGR8_PACKED)
# set region of interest
rect_aoi = ueye.IS_RECT()
rect_aoi.s32X = ueye.int(0)
rect_aoi.s32Y = ueye.int(0)
rect_aoi.s32Width = ueye.int(width)
rect_aoi.s32Height = ueye.int(height)
ueye.is_AOI(hcam, ueye.IS_AOI_IMAGE_SET_AOI, rect_aoi, ueye.sizeof(rect_aoi))
#
# # set parameters, see ids doc for parameter setting flow chart
# ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, exp, ueye.sizeof(pclock))
# pclock = ueye.int(220)
# ueye.is_PixelClock(hcam, ueye.IS_PIXELCLOCK_CMD_GET, pclock, ueye.sizeof(pclock))
#
# expo_rng = ueye.is_Exposure(hcam, IS_EXPOSURE_CMD_GET_CAPS, ncap, size(ncap))
# ftime_rng = ueye.is_GetFrameTimeRange()
# expo_rng = (expo_rng[0], max(expo_rng[1], ftime_rng[1]))
#
# fps_actual = ueye.cdouble()
# ueye.is_SetFrameRate(hcam, ueye.cdouble(fps_set), byref(fps_actual))
#
# exp_cap = ueye.uint32()
# ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_GET_EXPOSURE_RANGE, ueye.byref(exp_cap), ueye.sizeof(exp_cap))
# exp_cur = ueye.cdouble() # in s
# ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_SET_EXPOSURE, ueye.byref(exp_cur), ueye.sizeof(exp_cur))
# ueye.is_SetGainBoost()
# ueye.is_Gamma()
# ueye.is_SetHWGainFactor()
#
# allocate memory
mem_ptr = ueye.c_mem_p()
mem_id = ueye.int()
ueye.is_AllocImageMem(hcam, width, height, bitspixel, mem_ptr, mem_id)
ueye.is_SetImageMem(hcam, mem_ptr, mem_id)
# continuous capture to memory
ueye.is_CaptureVideo(hcam, ueye.IS_DONT_WAIT)
return mem_ptr
def __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):
# Variabeln für Kameraverarbeitung
self.h_cam = ueye.HIDS(0)
self.pitch = ueye.INT()
self.ColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.pitch = ueye.INT()
self.pcImageMemory = ueye.c_mem_p()
self.rectAOI = ueye.IS_RECT()
self.MemID = ueye.int()
self.width = None
self.height = None
self.dst = None
self.path_images = os.path.dirname(os.path.abspath(
sys.argv[0])) + "/images/"
# laden der intrinsischen Kalibriermatrix
self.load_calibration_config()
# Variabeln zur Farberkennung
blue_lower = [50, 0, 0]
blue_upper = [255, 75, 75]
red_lower = [0, 0, 100]
red_upper = [50, 50, 255]
green_lower = [0, 75, 50]
green_upper = [50, 255, 150]
self.blue_boundaries = [(blue_lower, blue_upper)]
self.red_boundaries = [(red_lower, red_upper)]
self.green_boundaries = [(green_lower, green_upper)]
# Variablen zur Positionsbestimmung
self.found_blue_container = False
self.found_red_container = False
self.found_green_container = False
self.qr_centres = []
self.world_points = []
self.localization_qr_codes = []
self.world_localization_qr_codes = []
self.results = 0
# Farbbereiche
self.blue = Color(self.blue_boundaries, "blue")
self.red = Color(
self.red_boundaries,
"red",
)
self.green = Color(self.green_boundaries, "green")
def __init__(self, camID):
super().__init__()
# Define the variables that will be used to retrieve the properties
# of the camera (generic dictionnaries from ueye)
# -----------------------------------------------
self.hcam = ueye.HIDS(
camID
) # 0 for the first available camera - 1-254 when we already have a specified ID
self.sensor_info = ueye.SENSORINFO()
self.cam_info = ueye.CAMINFO()
self.rectAOI = ueye.IS_RECT()
self.pcImageMemory = ueye.c_mem_p()
self.MemID = ueye.int()
self.pitch = ueye.INT()
def Init_Cam(width=640, heigth=480, gain_boost=1):
"""inits the uEye camera"""
# inits next available cam
cam = ueye.HIDS(0)
ueye.is_InitCamera(cam, None)
ueye.is_EnableAutoExit(cam, ueye.IS_ENABLE_AUTO_EXIT)
# sets the Colourmode of the camera
ueye.is_SetColorMode(cam, ueye.IS_CM_SENSOR_RAW8)
# sets the trigger
ret = ueye.is_SetExternalTrigger(cam, ueye.IS_SET_TRIGGER_SOFTWARE)
mode = ueye.int(0)
# sets the blacklevel
ueye.is_Blacklevel(cam, ueye.IS_BLACKLEVEL_CMD_SET_MODE, mode,
ueye.sizeof(mode))
# sets the size of the image
rectAOI = ueye.IS_RECT()
rectAOI.s32X = 44
rectAOI.s32Y = 0
rectAOI.s32Width = 480
rectAOI.s32Height = 480
ueye.is_AOI(cam, ueye.IS_AOI_IMAGE_SET_AOI, rectAOI, ueye.sizeof(rectAOI))
# allocates memory with given size
width = ueye.int(width)
heigth = ueye.int(heigth)
bitspixel = ueye.int(8)
pcImgMem = ueye.c_mem_p()
pid = ueye.int()
ueye.is_AllocImageMem(cam, 480, heigth, bitspixel, pcImgMem, pid)
# sets the image memory as active
ueye.is_SetImageMem(cam, pcImgMem, pid)
# activates video mode
ueye.is_CaptureVideo(cam, ueye.IS_DONT_WAIT)
# sets gain boost mode
if gain_boost == 1:
ueye.is_SetGainBoost(cam, ueye.IS_SET_GAINBOOST_ON)
else:
ueye.is_SetGainBoost(cam, ueye.IS_SET_GAINBOOST_OFF)
return cam, ret, pcImgMem, pid
def alloc(self, h_cam):
rect_aoi = ueye.IS_RECT()
memory_id = ueye.int()
memory_pointer = ueye.c_mem_p()
bits_per_pixel = 8
ueye.is_AOI(h_cam, ueye.IS_AOI_IMAGE_GET_AOI, rect_aoi,
ueye.sizeof(rect_aoi))
ueye.is_AllocImageMem(h_cam, rect_aoi.s32Width, rect_aoi.s32Height,
bits_per_pixel, memory_pointer, memory_id)
ueye.is_SetImageMem(h_cam, memory_pointer, memory_id)
self.img_data.memory_pointer = memory_pointer
self.img_data.memory_id = memory_id
self.img_data.width = rect_aoi.s32Width
self.img_data.height = rect_aoi.s32Height
self.img_data.bits_per_pixel = bits_per_pixel
ueye.is_AllocImageMem(h_cam, rect_aoi.s32Width, rect_aoi.s32Height, 24,
self.converted_memory_pointer,
self.converted_memory_id)
def GetNextBuffer(self):
""" Get the next valid image buffer"""
self.NewSeqBuf1=ueye.c_mem_p()
tries=0
while True:
rv= ueye.is_GetImageMem(self.hcam, self.NewSeqBuf1)
if self.NewSeqBuf1.value != self.LastSeqBuf1.value:
break
tries+=1
if tries ==3:
return True
rv=ueye.is_EnableEvent(self.hcam, ueye.IS_SET_EVENT_FRAME)
rv= ueye.is_WaitEvent(self.hcam, ueye.IS_SET_EVENT_FRAME, 1000)
rv=ueye.is_DisableEvent(self.hcam, ueye.IS_SET_EVENT_FRAME)
self.LastSeqBuf1.value=self.NewSeqBuf1.value
return False
def __init__(self):
rospy.init_node("coordinates_publisher")
self.coordinates_pub = rospy.Publisher("/coordinates",
Coordinates,
queue_size=1)
self.coordinates_msg = Coordinates()
self.h_cam = ueye.HIDS(0)
self.pitch = ueye.INT()
self.ColorMode = ueye.IS_CM_BGRA8_PACKED
self.nBitsPerPixel = ueye.INT(32)
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.pitch = ueye.INT()
self.pcImageMemory = ueye.c_mem_p()
self.rectAOI = ueye.IS_RECT()
self.MemID = ueye.int()
self.width = None
self.height = None
self.dst = None
self.load_calibration_config()
self.found_container = False
self.contours_rectangle = []
blue_lower = [51, 0, 0]
blue_upper = [255, 62, 62]
self.boundaries = [(blue_lower, blue_upper)]
self.cX = None
self.cY = None
self.cX_container = None
self.cY_container = None
self.container_world_position = []
self.ball_position = []
self.container_position = []
self.qr_centres = []
self.world_points = []
self.qr_codes = None
self.image_points_of_qr_codes = None
self.localization_qr_codes = []
self.world_localization_qr_codes = []
self.increment = 0.25
def initialize(self):
self.hcam = ueye.HIDS(self.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) # 8 bit for monochrome 24 for color
self.channels = 3 # 3: for color mode(RGB); 1 channel for monochrome
self.m_nColorMode = ueye.INT(24) # Y8/RGB16/RGB24/REG32
self.bytes_per_pixel = int(self.nBitsPerPixel / 8)
self.ret = ueye.is_InitCamera(self.hcam, None)
if self.ret != ueye.IS_SUCCESS:
print("is_InitCamera ERROR")
self.setAOI()
self.setmemory()
self.acquireimage()
def __init__(self, serial):
nc=ueye.c_int()
self.status=True
self._bgImage=0
self.bg=0
if ueye.is_GetNumberOfCameras(nc):
_logger.error("Error Wrong number of cameras")
return
lst=ueye.UEYE_CAMERA_LIST((ueye.UEYE_CAMERA_INFO*nc.value))
lst.dwCount=nc.value
ueye.is_GetCameraList(lst)
index=None
for i in range(nc.value):
_logger.info("Got the following ccd: %s"%lst.uci[i].SerNo)
if (lst.uci[i].SerNo==serial):
index=i
break
if index is None:
_logger.error("SerNo %s not found."%serial)
return
if lst.uci[index].dwStatus:
_logger.error("Camera %d is already busy."%index)
self.hcam=ueye.HIDS(index)
if ueye.is_InitCamera(self.hcam, None):
_logger.error("Error inializating camera.")
self.status=True
return
self.bufCount=0
self.bitsPixel=8
self.Imgs=None
self.LastSeqBuf1=ueye.c_mem_p(1)
self.acq=False
self.grabbingCB=dummy
self.grabbing=False
self.setColorMode(ueye.IS_CM_MONO8)
if self.LoadSettings():
_logger.error("error laoding camera settings")
sys.exit()
self.status=False
def __init__(self):
super().__init__()
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(
16) # take 8 bits per pixel for monochrome
self.m_nColorMode = ueye.INT() # Y8/RGB16/RGB24/REG32
self.bytes_per_pixel = ueye.INT()
self.width = None
self.height = None
self.data = None
self.data1 = None
self.data2 = None
self.flag = True
self.autoParameter = ctypes.c_int(ueye.IS_AUTOPARAMETER_ENABLE)
def initialize_memory(self):
'''
Allocates image memory.
Sets:
self.mem_id
self.mem_image
'''
mem_id = ueye.int()
mem_image = ueye.c_mem_p()
nRet = ueye.is_AllocImageMem(self.input, self.width, self.height, self.bits_per_pixel, mem_image, mem_id)
if nRet != ueye.IS_SUCCESS:
log.error("is_AllocImageMem ERROR")
else:
# Makes the specified image memory the active memory
nRet = ueye.is_SetImageMem(self.input, mem_image, mem_id)
if nRet != ueye.IS_SUCCESS:
log.error("is_SetImageMem ERROR")
else:
# Set the desired color mode
nRet = ueye.is_SetColorMode(self.input, self.m_nColorMode)
self.mem_id = mem_id
self.mem_image = mem_image
