def _cameras(): """ Get a list of ParamDicts for all cameras currently attached. """ cams = [] num = INT() if lib.is_GetNumberOfCameras(byref(num)) == IS_SUCCESS: if num >= 1: cam_list = create_camera_list(num)() cam_list.dwCount = ULONG(num.value) # This is stupid if lib.is_GetCameraList(pointer(cam_list)) == IS_SUCCESS: ids = [] repeated = [] for info in cam_list.ci: id = info.dwCameraID if id in ids: repeated.append(id) ids.append(id) if not repeated: for info in cam_list.ci: params = _ParamDict("<UC480_Camera '{}'>".format( info.SerNo)) params.module = 'cameras.uc480' params['cam_serial'] = info.SerNo params['cam_model'] = info.Model params['ueye_cam_id'] = int(info.dwCameraID) cams.append(params) else: log.info( "Some cameras have duplicate IDs. Uniquifying IDs now..." ) # Choose IDs that haven't been used yet potential_ids = [ i for i in range(1, len(ids) + 1) if i not in ids ] for id in repeated: new_id = potential_ids.pop(0) log.info("Trying to set id from {} to {}".format( id, new_id)) _id = HCAM(id) ret = lib.is_InitCamera(pointer(_id), NULL) if not ret == IS_SUCCESS: log.error( "Error connecting to camera {}".format(id)) return None # Avoid infinite recursion else: ret = lib.is_SetCameraID(_id, INT(new_id)) if not ret == IS_SUCCESS: log.error("Error setting the camera id") return None # Avoid infinite recursion # All IDs should be fixed now, let's retry cams = _cameras() else: raise Error("Error getting camera list") else: raise Error("Error getting number of attached cameras") return cams
def inet_ntop(AddressFamily, PackedIP): if AddressFamily not in (socket.AF_INET, socket.AF_INET6): raise socket.error('unknown address family') lpsaAddress = SOCKADDR() dwAddressLength = INT(ctypes.sizeof(lpsaAddress)) lpProtocolInfo = NULL lpsaAddress.sa_family = ADDRESS_FAMILY(AddressFamily) lpszAddressString = ctypes.create_unicode_buffer(128) lpdwAddressStringLength = INT(ctypes.sizeof(lpszAddressString)) if AddressFamily == socket.AF_INET: if len(PackedIP) != ctypes.sizeof(lpsaAddress.ipv4_addr): raise socket.error('packed IP wrong length for inet_ntoa') ctypes.memmove(lpsaAddress.ipv4_addr, PackedIP, 4) elif AddressFamily == socket.AF_INET6: if len(PackedIP) != ctypes.sizeof(lpsaAddress.ipv6_addr): raise socket.error('packed IP wrong length for inet_ntoa') ctypes.memmove(lpsaAddress.ipv6_addr, PackedIP, 16) res = WSAAddressToStringW( ctypes.byref(lpsaAddress), dwAddressLength, lpProtocolInfo, lpszAddressString, ctypes.byref(lpdwAddressStringLength) ) if res == 0: return lpszAddressString[:lpdwAddressStringLength.value - 1] raise socket.error(ctypes.FormatError())
def __init__(self, id=None, serial=None): """Create a UC480_Camera object. A camera can be identified by its id, serial number, or both. If no arguments are given, returns the first camera it finds. The constructor automatically opens a connection to the camera, and the user is responsible for closing it. You can do this via ``close()`` or by using the constructor as a context manager, e.g. >>> with UC480_Camera(id=1) as cam: >>> cam.save_image('image.jpg') Parameters ---------- id : int, optional The uEye camera ID serial : str, optional The serial number string of the camera. """ params = {} if id is not None: params['ueye_cam_id'] = id if serial is not None: params['cam_serial'] = serial if params: params = _get_legit_params(params) else: # If given no args, just choose the 'first' camera param_list = _cameras() if not param_list: raise Exception("No uEye cameras attached!") params = param_list[0] # For saving self._param_dict = params self._param_dict.module = 'cameras.uc480' self._param_dict['module'] = 'cameras.uc480' self._id = int(params['ueye_cam_id']) self._serial = params['cam_serial'] self._model = params['cam_model'] self._in_use = False self._width, self._height = INT(), INT() self._color_depth = INT() self._color_mode = INT() self._list_p_img_mem = None self._list_memid = None self._buffers = [] self._queue_enabled = False self._trigger_mode = IS_SET_TRIGGER_OFF self._open()
def __init__(self): HCAM.__init__(self) err = initLib(serialNum) self.cam = createGrabber() self.count = getDeviceCount() self.device = getDevice(INT(0)) self.name = getUniqueNameFromList(INT(0)) self.width = 0 self.height = 0 self.bpp = 0 self.buffer = [] openDevice(self.cam, self.device) startLive(self.cam, INT(0)) #{param: 1: show video, 0: do not show} [prepareLive has same param]
def inet_pton(AddressFamily, AddressString): if AddressFamily not in (socket.AF_INET, socket.AF_INET6): raise socket.error('unknown address family') if isinstance(AddressString, basestring): AddressString = ctypes.create_unicode_buffer(AddressString) lpProtocolInfo = NULL lpAddress = SOCKADDR() lpAddress.sa_family = ADDRESS_FAMILY(AddressFamily) lpAddressLength = INT(ctypes.sizeof(lpAddress)) res = WSAStringToAddressW( AddressString, AddressFamily, lpProtocolInfo, ctypes.byref(lpAddress), ctypes.byref(lpAddressLength) ) if res: if AddressFamily == socket.AF_INET: return ctypes.string_at(lpAddress.ipv4_addr, 4) if AddressFamily == socket.AF_INET6: return ctypes.string_at(lpAddress.ipv6_addr, 16) raise socket.error(ctypes.FormatError())
def LCIDToLocaleName(lcid): if not isinstance(lcid, LCID): lcid = LCID(lcid) lpName = (ctypes.c_wchar * 0)() cchName = INT(0) dwFlags = DWORD(0) cchName = _LCIDToLocaleName(lcid, lpName, cchName, dwFlags) if not cchName: return lpName = (ctypes.c_wchar * cchName)() _LCIDToLocaleName(lcid, lpName, cchName, dwFlags) output = '' for i in range(cchName): char = lpName[i] if char in ('\x00', 0x0): break output += char return output
def _bytes_per_line(self): num = INT() ret = lib.is_GetImageMemPitch(self._hcam, pointer(num)) if ret == IS_SUCCESS: log.debug('bytes_per_line=%d', num.value) return num.value raise Exception("Return code {}".format(ret))
def get_token_error(self) -> str: # Get any token error. Create a TOKENERRORINFO struct token_error: token_error_info = token_error_info() # get a pointer to use in the dll call lp_token_error = pointer(token_error) # Call the dll function, pass in the struct pointer to get filled. > 0 is success if self.process.GetTokenError(self.lTokenServiceHandle, lp_token_error) > 0: if lp_token_error and token_error: # Dereference the pointer/get contents content: token_error_info = lp_token_error.contents if content.error != 0: err_number: int = INT(content.error).value err_string: str = content.error_string.decode('utf-8') detailed_error_string: str = content.detailed_error_string.decode( 'utf-8') err_msg = f"Last Token Error from SDProcess: {err_number}: {TokenError(err_number).name}" f"\n{err_string}\n{detailed_error_string}" logger.debug(err_msg) return err_msg else: logger.debug("No errors reported from SDProcess.") return "No error" else: logger.debug( "SDProcess Returned NULL pointer for last token error.") return "SD Error: No handle to token error" else: logger.debug("SD Process last token error has no content.") return "No content"
def _last_img_mem(self): """ Returns a ctypes char-pointer to the starting address of the image memory last used for image capturing """ nNum = INT() pcMem = POINTER(c_char)() pcMemLast = POINTER(c_char)() lib.is_GetActSeqBuf(self._hcam, pointer(nNum), pointer(pcMem), pointer(pcMemLast)) return pcMemLast
def latest_frame(self, copy=True): nNum = INT() pcMem = POINTER(c_char)() pcMemLast = POINTER(c_char)() lib.is_GetActSeqBuf(self._hcam, pointer(nNum), pointer(pcMem), pointer(pcMemLast)) buf_ptr = cast(pcMemLast, POINTER(c_char * (self.bytes_per_line * self.height))) array = self._array_from_buffer(buffer(buf_ptr.contents)) return np.copy(array) if copy else array
def load_params(self, filename=None): """Load camera parameters from file or EEPROM. Parameters ---------- filename : str, optional By default, loads the parameters from the camera's EEPROM. Otherwise, loads it from the specified parameter file. If filename is the empty string '', will open a 'Load' dialog to select the file. """ if filename is None: cmd = IS_PARAMETERSET_CMD_LOAD_EEPROM param = c_char_p("/cam/set1") size = len(param.value) else: cmd = IS_PARAMETERSET_CMD_LOAD_FILE param = c_wchar_p(filename) size = len(param.value) ret = lib.is_ParameterSet(self._hcam, cmd, param, size) if ret == IS_INVALID_CAMERA_TYPE: raise Exception(".ini file does not match the camera model") elif ret != IS_SUCCESS: if filename != '': raise Exception("Failed to load parameter file") else: # Make sure memory is set up for right color depth depth_map = { IS_CM_MONO8: 8, IS_CM_RGBA8_PACKED: 32, IS_CM_BGRA8_PACKED: 32 } mode = lib.is_SetColorMode(self._hcam, IS_GET_COLOR_MODE) depth = depth_map[mode] if depth != self._color_depth.value: log.debug("Color depth changed from %s to %s", self._color_depth.value, depth) self._free_image_mem_seq() self._color_depth = INT(depth) self._allocate_image_mem_seq() self._color_mode = INT(mode)
def getImage(self, delay): ''' delay: timeout in ms; no timeout if delay = -1 ''' err = snapImage(self.cam, INT(delay)) xdim,ydim = self.width,self.height if err!=1: print "Error in snapImage." return 0 d = getImagePtr(self.cam) dp = ctypes.cast(d,ctypes.c_void_p) ctypes.memmove(self.buffer_temp.ctypes.data,dp,xdim*ydim*ctypes.sizeof(ctypes.c_ubyte)*3) self.image = np.frombuffer(self.buffer_temp, dtype=np.uint8).reshape(ydim,xdim,3).sum(axis=-1)
def _allocate_mem_seq(self, num_bufs): """ Create and setup the image memory for live capture """ for i in range(num_bufs): p_img_mem = POINTER(c_char)() memid = INT() lib.is_AllocImageMem(self._hcam, self._width, self._height, self._color_depth, pointer(p_img_mem), pointer(memid)) lib.is_AddToSequence(self._hcam, p_img_mem, memid) self._buffers.append(BufferInfo(p_img_mem, memid)) # Initialize display lib.is_SetImageSize(self._hcam, self._width, self._height) lib.is_SetDisplayMode(self._hcam, IS_SET_DM_DIB)
def SetWindowPos(hwnd, pos=None, size=None): if pos is None: uFlags = SWP_NOMOVE width, height = size x = INT(0) y = INT(0) cx = INT(width) cy = INT(height) else: uFlags = SWP_NOSIZE x, y = pos x = INT(x) y = INT(y) cx = INT(0) cy = INT(0) hWndInsertAfter = HWND_TOP if not IsWindowVisible(hwnd): uFlags |= SWP_SHOWWINDOW return _SetWindowPos(hwnd, hWndInsertAfter, x, y, cx, cy, uFlags)
def save_image(self, filename=None, filetype=None, freeze=None): """Save the current video image to disk. If no filename is given, this will display the 'Save as' dialog. If no filetype is given, it will be determined by the extension of the filename, if available. If neither exists, the image will be saved as a bitmap (BMP) file. Parameters ---------- filename : str, optional Filename to save image as. If not given, 'Save as' dialog will open. filetype : str, optional Filetype to save image as, e.g. 'bmp'. Useful for setting the default filetype in the 'Save as' dialog. freeze : bool, optional Freeze a frame before copying data. By default, freezes when not in live capture mode. """ if freeze is None: freeze = not self.is_live # Strip extension from filename, clear extension if it is invalid if filename is not None: filename, ext = os.path.splitext(filename) if ext.lower() not in ['.bmp', '.jpg', '.png']: ext = '.bmp' else: filename, ext = '', '.bmp' # 'filetype' flag overrides the extension. Default is .bmp if filetype: ext = '.' + filetype.lower() fdict = {'.bmp': IS_IMG_BMP, '.jpg': IS_IMG_JPG, '.png': IS_IMG_PNG} ftype_flag = fdict[ext.lower()] filename = filename + ext if filename else None if freeze: lib.is_FreezeVideo(self._hcam, self._width, self._height) lib.is_SaveImageEx(self._hcam, filename, ftype_flag, INT(0))
def GetIntSystemParametersInfo(key): rv = INT() r = SystemParametersInfoA(key, 0, byref(rv), 0) if r == 0: return None return rv.value
def disableAuto(self): for i in range(0,10): enableAutoVideoProperty(self.cam, INT(i), INT(0))
def getVideoProps(self): vidprop = c_long() for i in range(0,10): getVideoProperty(self.cam, INT(i), byref(vidprop)) print vidprop.value
def setContinuousMode(self): return setContinuousMode(self.cam, INT(0))
def shutDown(self): stopLive(self.cam) releaseGrabber(ctypes.byref(INT(self.cam)))
def _io_control(ioControlCode, hDevice, inBuffer, outBuffer, outBufferSize=None): dwIoControlCode = DWORD(ioControlCode) if inBuffer is NULL: lpInBuffer = NULL nInBufferSize = INT(0) elif 'PyCPointerType' in str(type(inBuffer)): lpInBuffer = inBuffer nInBufferSize = INT(ctypes.sizeof(inBuffer.contents.__class__)) else: lpInBuffer = ctypes.byref(inBuffer) nInBufferSize = INT(ctypes.sizeof(inBuffer.__class__)) if outBuffer is NULL: lpOutBuffer = NULL nOutBufferSize = INT(0) elif 'PyCPointerType' in str(type(outBuffer)): lpOutBuffer = outBuffer if outBufferSize is None: nOutBufferSize = INT(ctypes.sizeof(outBuffer.contents.__class__)) else: nOutBufferSize = INT(outBufferSize) else: lpOutBuffer = ctypes.byref(outBuffer) if outBufferSize is None: nOutBufferSize = INT(ctypes.sizeof(outBuffer.__class__)) else: nOutBufferSize = INT(outBufferSize) lpNumberOfBytesTransferred = DWORD() lpOverlapped = OVERLAPPED() lpEventAttributes = NULL bManualReset = BOOL(False) bInitialState = BOOL(False) lpName = NULL lpOverlapped.hEvent = CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName) if not DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, ctypes.byref(lpNumberOfBytesTransferred), ctypes.byref(lpOverlapped)): err = ctypes.GetLastError() if err != ERROR_IO_PENDING: CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) return 0 nCount = DWORD(1) bWaitAll = BOOL(False) dwMilliseconds = DWORD(INFINITE) lpHandles = (HANDLE * 1)(lpOverlapped.hEvent) response = WaitForMultipleObjects(nCount, lpHandles, bWaitAll, dwMilliseconds) if response == WAIT_OBJECT_0: bWait = BOOL(True) lpNumberOfBytesTransferred = DWORD() if not GetOverlappedResult( hDevice, ctypes.byref(lpOverlapped), ctypes.byref(lpNumberOfBytesTransferred), bWait): CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() CloseHandle(lpOverlapped.hEvent) return lpNumberOfBytesTransferred.value CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() CloseHandle(lpOverlapped.hEvent) return lpNumberOfBytesTransferred.value
def __receive_loop(self): with self.handle as hDevice: if self.use_alternate_receive: port = self.__get_first_rx_port() if port is None: del self._process_queue[:] self._process_event.set() self._process_thread.join(1.0) self._receive_thread = None return with self._learn_lock: inBuffer = IOCTL_IR_ENTER_PRIORITY_RECEIVE_PARAMS() inBuffer.Receiver = port inBuffer.TimeOut = self._packet_timeout _io_control(IOCTL_IR_ENTER_PRIORITY_RECEIVE, hDevice, inBuffer, NULL) self._process_thread = threading.Thread(target=self.__process_loop) self._process_thread.daemon = True self._process_thread.start() while not self._end_event.is_set(): with self._learn_lock: if self.use_alternate_receive: dwIoControlCode = IOCTL_IR_PRIORITY_RECEIVE outBuffer = IR_PRIORITY_RECEIVE_PARAMS() outBuffer.ByteCount = 36 outBufferSize = ctypes.sizeof( IR_PRIORITY_RECEIVE_PARAMS) offset = ctypes.sizeof(ULONG) else: dwIoControlCode = IOCTL_IR_RECEIVE outBuffer = IR_RECEIVE_PARAMS() outBuffer.ByteCount = 36 outBufferSize = ctypes.sizeof(IR_RECEIVE_PARAMS) offset = 0 offset += ctypes.sizeof(IR_ULONG_PTR) * 2 lpNumberOfBytesTransferred = DWORD() lpOverlapped = OVERLAPPED() lpEventAttributes = NULL bManualReset = BOOL(False) bInitialState = BOOL(False) lpName = NULL lpOverlapped.hEvent = CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName) if not DeviceIoControl( hDevice, DWORD(dwIoControlCode), NULL, INT(0), ctypes.byref(outBuffer), INT(outBufferSize), ctypes.byref(lpNumberOfBytesTransferred), ctypes.byref(lpOverlapped)): err = ctypes.GetLastError() if err != ERROR_IO_PENDING: CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() bWaitAll = BOOL(False) dwMilliseconds = DWORD(INFINITE) if dwIoControlCode == IOCTL_IR_PRIORITY_RECEIVE: lpEventAttributes = NULL bManualReset = BOOL(False) bInitialState = BOOL(False) lpName = NULL hEvent = self.hEvent = CreateEvent( lpEventAttributes, bManualReset, bInitialState, lpName) nCount = DWORD(2) lpHandles = (HANDLE * 2)(lpOverlapped.hEvent, hEvent) else: nCount = DWORD(1) lpHandles = (HANDLE * 1)(lpOverlapped.hEvent) response = WaitForMultipleObjects( nCount, lpHandles, bWaitAll, dwMilliseconds) if response == WAIT_OBJECT_0: bWait = BOOL(True) if not GetOverlappedResult( hDevice, ctypes.byref(lpOverlapped), ctypes.byref(lpNumberOfBytesTransferred), bWait): err = ctypes.GetLastError() if self.hEvent is not None: CloseHandle(self.hEvent) self.hEvent = None CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError(err) else: if self.hEvent is not None: CloseHandle(self.hEvent) self.hEvent = None CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) if self.hEvent is not None: CloseHandle(self.hEvent) self.hEvent = None break if self.hEvent is not None: CloseHandle(self.hEvent) self.hEvent = None CloseHandle(lpOverlapped.hEvent) byte_count = lpNumberOfBytesTransferred.value data = [] byte_count -= offset byte_count //= ctypes.sizeof(LONG) if not byte_count: continue if dwIoControlCode == IOCTL_IR_PRIORITY_RECEIVE: freq = outBuffer.CarrierFrequency else: freq = None for i in range(byte_count): data += [outBuffer.Data[i]] self._process_queue.append((freq, data[:])) self._process_event.set() if self.use_alternate_receive: _io_control(IOCTL_IR_EXIT_PRIORITY_RECEIVE, hDevice, NULL, NULL) del self._process_queue[:] self._process_event.set() self._process_thread.join(1.0) self._receive_thread = None
def set_auto_exposure(self, enable=True): """Enable or disable the auto exposure shutter.""" ret = lib.is_SetAutoParameter(self._hcam, IS_SET_ENABLE_AUTO_SHUTTER, pointer(INT(enable)), NULL) if ret != IS_SUCCESS: raise Error("Failed to set auto exposure property")
def FreezeVideo(self, wait=IS_WAIT): CALL("FreezeVideo", self, INT(wait))
def learn(self, timeout=10.0): import time if self._receive_thread is not None and self.hEvent is not None: SetEvent(self.hEvent) self._learn_lock.acquire() with self.handle as hDevice: def exit_learn(): if not self.use_alternate_receive: _io_control(IOCTL_IR_EXIT_PRIORITY_RECEIVE, hDevice, NULL, NULL) self._learn_lock.release() if not self.use_alternate_receive: port = self.__get_first_learn_port() if port is None: return inBuffer = IOCTL_IR_ENTER_PRIORITY_RECEIVE_PARAMS() inBuffer.Receiver = port inBuffer.TimeOut = self._packet_timeout _io_control(IOCTL_IR_ENTER_PRIORITY_RECEIVE, hDevice, inBuffer, NULL) result = [] frequency = None start_time = time.time() while time.time() - start_time < timeout: if self.can_flash_led: port = self.__get_first_learn_port() inBuffer = ULONG(0 | (1 << port)) _io_control(IOCTL_IR_FLASH_RECEIVER, hDevice, inBuffer, NULL) dwIoControlCode = IOCTL_IR_PRIORITY_RECEIVE outBuffer = IR_PRIORITY_RECEIVE_PARAMS() outBuffer.ByteCount = 32 outBufferSize = ctypes.sizeof(IR_PRIORITY_RECEIVE_PARAMS) lpNumberOfBytesTransferred = DWORD() lpOverlapped = OVERLAPPED() lpEventAttributes = NULL bManualReset = BOOL(False) bInitialState = BOOL(False) lpName = NULL lpOverlapped.hEvent = CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName) if not DeviceIoControl( hDevice, DWORD(dwIoControlCode), NULL, INT(0), ctypes.byref(outBuffer), INT(outBufferSize), ctypes.byref(lpNumberOfBytesTransferred), ctypes.byref(lpOverlapped)): err = ctypes.GetLastError() if err != ERROR_IO_PENDING: CancelIo(hDevice) CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() bWaitAll = BOOL(False) dwMilliseconds = DWORD(INFINITE) lpEventAttributes = NULL bManualReset = BOOL(False) bInitialState = BOOL(False) lpName = NULL hEvent = self.hEvent = CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName) nCount = DWORD(2) lpHandles = (HANDLE * 2)(lpOverlapped.hEvent, hEvent) response = WaitForMultipleObjects(nCount, lpHandles, bWaitAll, dwMilliseconds) if response == WAIT_OBJECT_0: bWait = BOOL(True) if not GetOverlappedResult( hDevice, ctypes.byref(lpOverlapped), ctypes.byref(lpNumberOfBytesTransferred), bWait): CancelIo(hDevice) CloseHandle(hEvent) self.hEvent = None CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() CloseHandle(hEvent) else: CancelIo(hDevice) CloseHandle(hEvent) self.hEvent = None CloseHandle(lpOverlapped.hEvent) raise ctypes.WinError() CloseHandle(lpOverlapped.hEvent) if self._end_event.is_set(): exit_learn() return byte_count = lpNumberOfBytesTransferred.value byte_count -= ((ctypes.sizeof(IR_ULONG_PTR) * 2) + ctypes.sizeof(ULONG)) if not byte_count: continue byte_count //= ctypes.sizeof(LONG) if frequency is None: frequency = outBuffer.CarrierFrequency.value else: frequency = max(frequency, outBuffer.CarrierFrequency.value) for i in range(byte_count): item = outBuffer.Data[i] result.append(item) if item < -6500: if len(result) > 5: code = decoder.decode(frequency, result[:]) exit_learn() return code del result[:] frequency = None exit_learn()