def __init__(self, g_pool, frame_size, frame_rate, name=None, preferred_names=(), uid=None, uvc_controls={}): import platform super().__init__(g_pool) self.uvc_capture = None self._restart_in = 3 assert name or preferred_names or uid if platform.system() == 'Windows': self.verify_drivers() self.devices = uvc.Device_List() devices_by_name = {dev['name']: dev for dev in self.devices} # if uid is supplied we init with that if uid: try: self.uvc_capture = uvc.Capture(uid) except uvc.OpenError: logger.warning("No avalilable camera found that matched {}".format(preferred_names)) except uvc.InitError: logger.error("Camera failed to initialize.") except uvc.DeviceNotFoundError: logger.warning("No camera found that matched {}".format(preferred_names)) # otherwise we use name or preffered_names else: if name: preferred_names = (name,) else: pass assert preferred_names # try to init by name for name in preferred_names: for d_name in devices_by_name.keys(): if name in d_name: uid_for_name = devices_by_name[d_name]['uid'] try: self.uvc_capture = uvc.Capture(uid_for_name) except uvc.OpenError: logger.info("{} matches {} but is already in use or blocked.".format(uid_for_name, name)) except uvc.InitError: logger.error("Camera failed to initialize.") else: break # check if we were sucessfull if not self.uvc_capture: logger.error("Init failed. Capture is started in ghost mode. No images will be supplied.") self.name_backup = preferred_names self.frame_size_backup = frame_size self.frame_rate_backup = frame_rate self._intrinsics = load_intrinsics(self.g_pool.user_dir, self.name, self.frame_size) else: self.configure_capture(frame_size, frame_rate, uvc_controls) self.name_backup = (self.name,) self.frame_size_backup = frame_size self.frame_rate_backup = frame_rate
def __init__(self, g_pool, frame_size, frame_rate, name=None, preferred_names=None, uid=None, uvc_controls={}, **settings): super(UVC_Source, self).__init__(g_pool) self.uvc_capture = None self.devices = uvc.Device_List() devices_by_name = {dev['name']: dev for dev in self.devices} devices_by_uid = {dev['uid']: dev for dev in self.devices} #if uid is supplied we init with that if uid: try: self.uvc_capture = uvc.Capture(uid) except uvc.OpenError: raise AvalilabeDeviceNotFoundError( "No avalilable camera found that matched %s" % preferred_names) except uvc.InitError: raise InitialisationError("Camera failed to initialize.") except uvc.DeviceNotFoundError as e: raise AvalilabeDeviceNotFoundError( "No camera found that matched %s" % preferred_names) #otherwise we use name or preffered_names else: if name: preferred_names = [name] else: pass assert preferred_names #try to init by name for name in preferred_names: if name in devices_by_name: uid_for_name = devices_by_name[name]['uid'] try: self.uvc_capture = uvc.Capture(uid_for_name) except uvc.OpenError: logger.info( "%s matches %s but is already in use or blocked." % (uid_for_name, name)) except uvc.InitError as e: raise InitialisationError( "Camera failed to initialize.") else: break #check if we where sucessfull if not self.uvc_capture: raise AvalilabeDeviceNotFoundError( "No avalilable camera found that matched %s" % preferred_names) self.update_capture(frame_size, frame_rate, uvc_controls)
def __init__(self, name): """Note: All class members, which are not process variables should be prefixed with _""" # initial image, the heght, width and number of plane could be approxiamate h, w, p = 4, 3, 3 image = np.arange(h * w * p).astype('uint8').reshape(h, w, p) pars = { 'count': LDO('R','Image count', [0]), 'image': LDO('R','Image', image), 'sleep': LDO('RWE','Sleep time between image acquisitions',[1.], units='s', opLimits=(0.02,10)), 'shape': LDO('R','Frame shape Y,X,Planes', [0,0,0]), 'fps': LDO('R','Frames/s', [0]), 'imgps': LDO('R','Images/s', [0], units='img/s'), 'subscribe': LDO('RWE','Subscribe to image', ['On'],legalValues\ = ['On','Off']), } super().__init__(name, pars) dev_list = uvc.device_list() print(dev_list) self._cap = uvc.Capture(dev_list[0]["uid"]) print(f'available modes: {self._cap.avaible_modes}') frame_mode = (640, 480, 30) try: self._cap.frame_mode = (640, 480, 30) #self._cap.frame_mode = (960, 720, 15) self.fps.value[0] = self._cap.frame_mode[2] except Exception as e: printw(f'Failed to setup frame mode {frame_mode}: {e}') thread = threading.Thread(target=self._state_machine) thread.daemon = False thread.start()
def test_cap(i, mode=(640, 480, 30), format='bgr', bandwidth_factor=1.3): print("started cap: %s\n" % i) cap = uvc.Capture(dev_list[i]['uid']) # cap.print_info() cap.bandwidth_factor = bandwidth_factor cap.frame_mode = mode title = cap.name + ' - ' + str(mode) + ' - ' + format ts = time() while True: frame = cap.get_frame_robust() print("%s - %s" % (title, time() - ts)) ts = time() if USE_CV2: if format == 'bgr': data = frame.bgr elif format == 'gray': data = frame.gray cv2.imshow(title, data) k = cv2.waitKey(1) if k == 27: break cap = None
def __init__(self, config, bus): self.input_thread = Thread(target=self.run_input, daemon=True) self.bus = bus bus = config['bus'] ports = config['ports'] # to find proper bus and ports numbers run # python -c "import uvc; from pprint import pprint; pprint(uvc.device_list())" self.sleep = config.get('sleep', 0.1) self.cap = None dev_list = uvc.device_list() for dev in dev_list: if dev['bus_number'] == bus and dev['bus_ports'] == ports: self.cap = uvc.Capture(dev["uid"]) self.cap.frame_mode = self.cap.avaible_modes[0] self.cap.bandwidth_factor = 1.2 # when incomplete pictures are being received, increase bandwidth_factor # when "no space left on device" error, decrease bandwidth_factor # for more info see https://docs.pupil-labs.com/#jpeg-size-estimation-and-custom-video-backends return import pprint error = "camera not found on bus %i and ports %s\n" % (bus, str(ports)) error += "avalable cameras:\n" error += pprint.pformat(uvc.device_list()) self.bus.report_error(error) print(error, file=sys.stderr)
def run(self): self.capturing.value = 1 dev_list = uvc.device_list() cap = uvc.Capture(dev_list[self.source]['uid']) self.__setup_eye_cam(cap) cap.frame_mode = self.mode attempt, attempts = 0, 6 gamma, color, flip = 1, True, False while attempt < attempts: try: frame = cap.get_frame(2.0) img = self.__adjust_gamma(frame.bgr, gamma) img = self.__cvtBlackWhite(img, color) img = self.__flip_img(img, flip) if img is not None: attempt = 0 shared_img = self.__get_shared_np_array(img) np.copyto(shared_img, img) except Exception as e: traceback.print_exc() cap = self.__reset_mode(cap) attempt += 1 if self.pipe.poll(): msg = self.pipe.recv() if msg == "stop": break elif msg == "gamma": gamma = self.pipe.recv() elif msg == "color": color = self.pipe.recv() elif msg == "flip": flip = self.pipe.recv() self.capturing.value = 0 print("camera", self.source, "closed")
def __init__(self, uvc_id): super(Bridge, self).__init__() self.data_seq = 0 self.note_seq = 0 # init capture self.cap = uvc.Capture(uvc_id) logger.info('Initialised uvc device {}'.format(self.cap.name)) # init pyre self.network = Pyre(socket.gethostname() + self.cap.name[-4:]) self.network.join(GROUP) self.network.start() logger.info('Bridging under "{}"'.format(self.network.name())) # init sensor sockets ctx = zmq.Context() generic_url = 'tcp://*:*' public_ep = self.network.endpoint() self.note, self.note_url = self.bind(ctx, zmq.PUB, generic_url, public_ep) self.data, self.data_url = self.bind(ctx, zmq.PUB, generic_url, public_ep, set_hwm=1) self.cmd, self.cmd_url = self.bind(ctx, zmq.PULL, generic_url, public_ep)
def test_cap(i, mode=(640, 480, 30), format='bgr', bandwidth_factor=1.3): print("started cap: %s\n" % i) cap = uvc.Capture(dev_list[i]['uid']) # cap.print_info() cap.bandwidth_factor = bandwidth_factor cap.frame_mode = mode title = cap.name + ' - ' + str(mode) + ' - ' + format ts = time() while True: frame = cap.get_frame_robust() print("%s - %s" % (title, time() - ts)) ts = time() # uncomment below lines for opencv preview # if format == 'bgr': # data = frame.bgr # elif format == 'gray': # data = frame.gray # cv2.imshow(title,data) # k = cv2.waitKey(1) # if k == 27: # break cap = None
def re_init_capture(self, uid): current_size = self.uvc_capture.frame_size current_fps = self.uvc_capture.frame_rate self.deinit_gui() self.uvc_capture.close() self.uvc_capture = uvc.Capture(uid) self.update_capture(current_size, current_fps) self.init_gui()
def _re_init_capture(self, uid): current_size = self.uvc_capture.frame_size current_fps = self.uvc_capture.frame_rate current_uvc_controls = self._get_uvc_controls() self.uvc_capture.close() self.uvc_capture = uvc.Capture(uid) self.configure_capture(current_size, current_fps, current_uvc_controls) self.update_menu()
def check_mode_availability(self, source, mode): dev_list = uvc.device_list() cap = uvc.Capture(dev_list[source]['uid']) if mode not in cap.avaible_modes: m = cap.avaible_modes[0] mode = (m[1], m[0], m[2]) self.shared_array = self.create_shared_array(mode) self.mode = mode return mode
def __reset_mode(self, cap): print("resetting...") mode = cap.frame_mode cap.close() time.sleep(0.5) dev_list = uvc.device_list() cap2 = uvc.Capture(dev_list[self.source]['uid']) print("Trying mode:", mode) cap2.frame_mode = mode cap2.bandwidth_factor = 1.3 return cap2
def init_capture(self,uid,size,fps): if uid is not None: self.capture = uvc.Capture(uid) else: self.capture = Fake_Capture() self.uid = uid self.frame_size = size self.frame_rate = fps if 'C930e' in self.capture.name: logger.debug('Timestamp offset for c930 applied: -0.1sec') self.ts_offset = -0.1 else: self.ts_offset = 0.0 #UVC setting quirks: controls_dict = dict([(c.display_name,c) for c in self.capture.controls]) try: controls_dict['Auto Focus'].value = 0 except KeyError: pass if "Pupil Cam1" in self.capture.name or "USB2.0 Camera" in self.capture.name: self.capture.bandwidth_factor = 1.3 if "ID0" in self.capture.name or "ID1" in self.capture.name: try: # Auto Exposure Priority = 1 leads to reduced framerates under low light and corrupt timestamps. controls_dict['Auto Exposure Priority'].value = 1 except KeyError: pass try: controls_dict['Absolute Exposure Time'].value = 59 except KeyError: pass try: controls_dict['Auto Focus'].value = 0 except KeyError: pass
def __set_fps_modes(self): self.fps_res, self.modes = {}, {} dev_list = uvc.device_list() cap = uvc.Capture(dev_list[self.source]['uid']) for i in range(len(cap.avaible_modes)): mode = cap.avaible_modes[i] fps = mode[2] if fps not in self.fps_res.keys(): self.fps_res[fps] = [] self.modes[fps] = [] resolution = str(mode[0]) + " x " + str(mode[1]) self.modes[fps].append(mode) self.fps_res[fps].append(resolution) if self.mode not in cap.avaible_modes: self.mode = sorted(cap.avaible_modes)[0] cap.close()
def my_name(i, title, mode=(640, 480, 120), format='bgr', bandwidth_factor=1.3): # get the ID of the camera and define it as an object cap = uvc.Capture(dev_list[i]['uid']) # set the bandwidth factor # to know more about what it is https://github.com/pupil-labs/pupil-docs/blob/master/developer-docs/usb-bandwidth-sync.md cap.bandwidth_factor = bandwidth_factor cap.frame_mode = mode while True: # get the ID of the camera and define it as an object frame = cap.get_frame_robust() data = frame.img if title == 'LEFT EYE CAPTURE': # vertical flip just to orient the video in the right view data = cv2.flip(data, 1) out_left_eye.write(data) cv2.imshow(title, data) cv2.moveWindow(title, 60, 0) if title == 'RIGHT EYE CAPTURE': # horizontal flip just to orient the video in the right view data = cv2.flip(data, 0) out_right_eye.write(data) cv2.imshow(title, data) cv2.moveWindow(title, np.size(data, 1) + 70, 0) if title == 'MOUTH CAPTURE': # horizontal flip just to orient the video in the right view data = cv2.flip(data, 0) out_mouth.write(data) cv2.imshow(title, data) cv2.moveWindow(title, int((np.size(data, 1) / 2) + 60), np.size(data, 0) + 40) k = cv2.waitKey(1) if k == 27: cv2.destroyAllWindows() exit(0)
def __init__(self, uid, timebase=None): if timebase == None: logger.debug("Capture will run with default system timebase") self.timebase = c_double(0) elif hasattr(timebase, 'value'): logger.debug("Capture will run with app wide adjustable timebase") self.timebase = timebase else: logger.error( "Invalid timebase variable type. Will use default system timebase" ) self.timebase = c_double(0) self.use_hw_ts = self.check_hw_ts_support() self._last_timestamp = self.get_now() self.capture = uvc.Capture(uid) self.uid = uid if 'C930e' in self.capture.name: logger.debug('Timestamp offset for c930 applied: -0.1sec') self.ts_offset = -0.1 else: self.ts_offset = 0.0 if "USB 2.0 Camera" in self.capture.name: self.capture.bandwidth_factor = 1.2 logger.debug('avaible modes %s' % self.capture.avaible_modes) controls_dict = dict([(c.display_name, c) for c in self.capture.controls]) try: controls_dict['Auto Focus'].value = 0 except KeyError: pass try: # Auto Exposure Priority = 1 leads to reduced framerates under low light and corrupt timestamps. controls_dict['Auto Exposure Priority'].value = 0 except KeyError: pass self.sidebar = None self.menu = None
def init_capture(self,uid): self.uid = uid if uid is not None: self.capture = uvc.Capture(uid) else: self.capture = Fake_Capture() if 'C930e' in self.capture.name: logger.debug('Timestamp offset for c930 applied: -0.1sec') self.ts_offset = -0.1 else: self.ts_offset = 0.0 #UVC setting quirks: controls_dict = dict([(c.display_name,c) for c in self.capture.controls]) try: controls_dict['Auto Focus'].value = 0 except KeyError: pass if "Pupil Cam1" in self.capture.name or "USB2.0 Camera" in self.capture.name: self.capture.bandwidth_factor = 1.8 if "ID0" in self.capture.name or "ID1" in self.capture.name: self.capture.bandwidth_factor = 1.3 try: controls_dict['Auto Exposure Priority'].value = 1 except KeyError: pass try: controls_dict['Saturation'].value = 0 except KeyError: pass try: controls_dict['Absolute Exposure Time'].value = 63 except KeyError: pass try: controls_dict['Auto Focus'].value = 0 except KeyError: pass
def __init__(self, uid_or_device_index, use_uvc: bool): if use_uvc: import uvc lg.info('using uvc as backend') devices = uvc.device_list() lg.info('there are {} camera devices, devices:'.format( len(devices))) select_device = None for d in devices: lg.info(d) if d['uid'] == uid_or_device_index: select_device = d lg.info('opening {}'.format(select_device['uid'])) self.cap = uvc.Capture(select_device['uid']) else: lg.info('using opencv as camera backend') self.cap = cv2.VideoCapture(uid_or_device_index) #self.cap.set(cv2.CAP_PROP_EXPOSURE,30) assert self.cap.isOpened(), 'can not open {}'.format( uid_or_device_index)
def re_init(self, uid, size=(640, 480), fps=30): current_size = self.capture.frame_size current_fps = self.capture.frame_rate self.capture = None #recreate the bar with new values menu_conf = self.menu.configuration self.deinit_gui() self.use_hw_ts = self.check_hw_ts_support() self.capture = uvc.Capture(uid) self.uid = uid self.frame_size = current_size self.frame_rate = current_fps controls_dict = dict([(c.display_name, c) for c in self.capture.controls]) try: controls_dict['Auto Focus'].value = 0 except KeyError: pass # try: # # exposure_auto_priority == 1 # # leads to reduced framerates under low light and corrupt timestamps. # self.capture.set_control(controls_dict['Exposure, Auto Priority']['id'], 0) # except KeyError: # pass self.init_gui(self.sidebar) self.menu.configuration = menu_conf if 'C930e' in self.capture.name: logger.debug('Timestamp offset for c930 applied: -0.1sec') self.ts_offset = -0.1 else: self.ts_offset = 0.0
def _init_capture(self, uid): self.uvc_capture = uvc.Capture(uid) self.configure_capture(self.frame_size_backup, self.frame_rate_backup, self._get_uvc_controls()) self.update_menu()
def __init__( self, g_pool, frame_size, frame_rate, name=None, preferred_names=(), uid=None, uvc_controls={}, check_stripes=True, exposure_mode="manual", *args, **kwargs, ): super().__init__(g_pool, *args, **kwargs) self.uvc_capture = None self._last_ts = None self._restart_in = 3 assert name or preferred_names or uid if platform.system() == "Windows": self.verify_drivers() self.devices = uvc.Device_List() devices_by_name = {dev["name"]: dev for dev in self.devices} # if uid is supplied we init with that if uid: try: self.uvc_capture = uvc.Capture(uid) except uvc.OpenError: logger.warning( "No avalilable camera found that matched {}".format( preferred_names)) except uvc.InitError: logger.error("Camera failed to initialize.") except uvc.DeviceNotFoundError: logger.warning( "No camera found that matched {}".format(preferred_names)) # otherwise we use name or preffered_names else: if name: preferred_names = (name, ) else: pass assert preferred_names # try to init by name for name in preferred_names: for d_name in devices_by_name.keys(): if name in d_name: uid_for_name = devices_by_name[d_name]["uid"] try: self.uvc_capture = uvc.Capture(uid_for_name) break except uvc.OpenError: logger.info( f"{uid_for_name} matches {name} but is already in use " "or blocked.") except uvc.InitError: logger.error("Camera failed to initialize.") if self.uvc_capture: break # checkframestripes will be initialized accordingly in configure_capture() self.enable_stripe_checks = check_stripes self.exposure_mode = exposure_mode self.stripe_detector = None self.preferred_exposure_time = None # check if we were sucessfull if not self.uvc_capture: logger.error( "Could not connect to device! No images will be supplied.") self.name_backup = preferred_names self.frame_size_backup = frame_size self.frame_rate_backup = frame_rate self.exposure_time_backup = None self._intrinsics = load_intrinsics(self.g_pool.user_dir, self.name, self.frame_size) else: self.configure_capture(frame_size, frame_rate, uvc_controls) self.name_backup = (self.name, ) self.frame_size_backup = frame_size self.frame_rate_backup = frame_rate controls_dict = dict([(c.display_name, c) for c in self.uvc_capture.controls]) try: self.exposure_time_backup = controls_dict[ "Absolute Exposure Time"].value except KeyError: self.exposure_time_backup = None self.backup_uvc_controls = {}
def _init_capture(self, uid, backup_uvc_controls={}): self.uvc_capture = uvc.Capture(uid) self.configure_capture(self.frame_size_backup, self.frame_rate_backup, backup_uvc_controls) self.update_menu()
import logging import pygame from pygame.locals import * logging.basicConfig(level=logging.INFO) SCREEN_SIZE = (1280, 720) CAP_MODE = (1280, 720, 30) # TODO: how to add int to tuple? pygame.init() screen = pygame.display.set_mode(SCREEN_SIZE) pygame.display.set_caption('wtfcam') dev_list = uvc.device_list() print dev_list cap = uvc.Capture(dev_list[0]['uid']) # TODO: choosable camera print cap.avaible_modes cap.frame_mode = CAP_MODE while True: for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) frame = cap.get_frame_robust() # TODO: fails with anything else than RGB surf = pygame.image.fromstring(frame.bgr.tostring(), SCREEN_SIZE, 'RGB', True).convert() screen.blit(surf, (0, 0)) pygame.display.update() pygame.time.delay(100)
import tensorflow.contrib.eager as tfe import torch import Model_UNet_Segmentation_PupilLabs import numpy as np import time opts = tf.GPUOptions(per_process_gpu_memory_fraction=0.2) conf = tf.ConfigProto(gpu_options=opts) tfe.enable_eager_execution(config=conf) device = torch.device("cuda") logging.basicConfig(level=logging.INFO) dev_list = uvc.device_list() print(dev_list) cap_world = uvc.Capture(dev_list[1]["uid"]) cap_right = uvc.Capture(dev_list[0]["uid"]) cap_left = uvc.Capture(dev_list[2]["uid"]) # Uncomment the following lines to configure the Pupil 200Hz IR cameras: # controls_dict = dict([(c.display_name, c) for c in cap.controls]) # controls_dict['Auto Exposure Mode'].value = 1 # controls_dict['Gamma'].value = 200 print(cap_world.avaible_modes) cap_world.frame_mode = (1280, 720, 60) cap_left.frame_mode = (320, 240, 120) cap_right.frame_mode = (320, 240, 120) model = Model_UNet_Segmentation_PupilLabs.UNet4f16ch_seg_reg() print('Loading Model....') model.load_state_dict(
lock.release() # release object print(f"key input:{key}") if key == TERMINATE: print("Closing key_check...") time.sleep(1) break # Camera open devices = uvc.Device_List() if not devices: print("EyeTracker not found") sys.exit(1) for i in range(len(devices)): if devices[i]['name'] == 'Pupil Cam1 ID0': cap[0] = uvc.Capture(devices[i]['uid']) cap[0].frame_mode = (640, 480, 60) if devices[i]['name'] == 'Pupil Cam1 ID1': cap[1] = uvc.Capture(devices[i]['uid']) cap[1].frame_mode = (640, 480, 60) # Eye detector init trk = EyeDetector.alloc(len(EYES)) # for FPS calculation tm = cv2.TickMeter() tm.start() count = 0 max_count = 100 fps = 0
def __init__(self): rospy.init_node('{}_node'.format(DEFAULT_CAMERA_NAME), argv=sys.argv) self.image_topic = rospy.get_param('~image', DEFAULT_IMAGE_TOPIC) self.camera_topic = rospy.get_param('~camera', DEFAULT_CAMERA_TOPIC) self.calibration = rospy.get_param('~calibration', '') self.encoding = rospy.get_param('~encoding', 'mono8') self.width = rospy.get_param('~width', DEFAULT_WIDTH) self.height = rospy.get_param('~height', DEFAULT_HEIGHT) self.fps = rospy.get_param('~fps', DEFAULT_FPS) self.cam_prod_id = rospy.get_param('~cam_prod_id', 9760) self.contrast = rospy.get_param('~contrast', 0) self.sharpness = rospy.get_param('~sharpness', 1) self.gamma = rospy.get_param('~gamma', 80) self.exposure_abs = rospy.get_param('~exposure', 50) #50 - self.brightness = rospy.get_param('~brightness', 1) self.hue = rospy.get_param('~hue', 0) self.saturation = rospy.get_param('~saturation', 0) self.pwr_line_freq = rospy.get_param('~pwr_line_freq', 1) self.backlight_comp = rospy.get_param('~backlight_comp', 0) self.auto_exposure = rospy.get_param('~auto_exposure', 8) self.auto_exp_prio = rospy.get_param('~auto_exp_prio', 0) self.white_bal_auto = rospy.get_param('~white_bal_auto', True) self.white_bal = rospy.get_param('~white_bal', 4600) # possible values to set can be found by running "rosrun uvc_camera uvc_camera_node _device:=/dev/video0", see http://github.com/ros-drivers/camera_umd.git dev_list = uvc.device_list() for i in range(0, len(dev_list)): print dev_list[i] rospy.loginfo( 'available device %i: idProd: %i - comparing to idProd: %i' % (i, int(dev_list[i]["idProduct"]), self.cam_prod_id)) if i == self.cam_prod_id: #int(dev_list[i]["idProduct"]) == self.cam_prod_id: rospy.loginfo("connecting to camera idProd: %i, device %i" % (self.cam_prod_id, i)) self.cap = uvc.Capture(dev_list[i]["uid"]) #self.cap.set(CV_CAP_PROP_CONVERT_RGB, false) rospy.loginfo("successfully connected to camera %i" % i) rospy.loginfo('starting cam at %ifps with %ix%i resolution' % (self.fps, self.width, self.height)) self.cap.frame_mode = (self.width, self.height, self.fps) frame = self.cap.get_frame_robust() self.controls_dict = dict([(c.display_name, c) for c in self.cap.controls]) self.controls_dict[ 'Brightness'].value = self.brightness #10 #[-64,64], not 0 (no effect)!! self.controls_dict['Contrast'].value = self.contrast #0 #[0,95] self.controls_dict['Hue'].value = self.hue #[-2000,2000] self.controls_dict['Saturation'].value = self.saturation #[0,100] self.controls_dict['Sharpness'].value = self.sharpness #1 #[1,100] self.controls_dict['Gamma'].value = self.gamma #[80,300] self.controls_dict[ 'Power Line frequency'].value = self.pwr_line_freq #1:50Hz, 2:60Hz self.controls_dict[ 'Backlight Compensation'].value = self.backlight_comp #True or False self.controls_dict[ 'Absolute Exposure Time'].value = self.exposure_abs #[78,10000] set Auto Exposure Mode to 1 self.controls_dict[ 'Auto Exposure Mode'].value = self.auto_exposure #1:manual, 8:apperturePriority self.controls_dict[ 'Auto Exposure Priority'].value = self.auto_exp_prio #1:manual, 8:apperturePriority self.controls_dict[ 'White Balance temperature,Auto'].value = self.white_bal_auto self.controls_dict[ 'White Balance temperature'].value = self.white_bal #[2800,6500] rospy.loginfo("These camera settings will be applied:") for c in self.cap.controls: rospy.loginfo('%s: %i' % (c.display_name, c.value)) self.manager = CameraInfoManager(cname=DEFAULT_CAMERA_NAME, url='file://' + self.calibration, namespace=DEFAULT_CAMERA_NAME) self.manager.loadCameraInfo() # Needs to be called before getter! self.camera_info = self.manager.getCameraInfo() self.bridge = CvBridge() self.image_publisher = rospy.Publisher(self.image_topic, Image, queue_size=1) self.camera_publisher = rospy.Publisher(self.camera_topic, CameraInfo, queue_size=1) self.seq = 0 self.counter = 0
# if tookPicture: # print(tookPicture, [len(image) if image is not None else 0]) # cv2.imshow("Test Picture", image) # displays captured image # cv2.imwrite("test.jpg", image) # else: # print('Couldn\'t take a picture') cv2.findTransformECC() from __future__ import print_function import uvc import logging logging.basicConfig(level=logging.INFO) dev_list = uvc.device_list() print(dev_list) cap = uvc.Capture(dev_list[0]['uid']) # Uncomment the following lines to configure the Pupil 200Hz IR cameras: # controls_dict = dict([(c.display_name, c) for c in cap.controls]) # controls_dict['Auto Exposure Mode'].value = 1 # controls_dict['Gamma'].value = 200 print(cap.avaible_modes) for x in range(10): print(x) cap.frame_mode = (640, 480, 30) for x in range(100): frame = cap.get_frame_robust() print(frame.img.shape) #cv2.imshow("img",frame.gray) #cv2.waitKey(1)
def my_name(i, title, mode=(640, 480, 60), format='gray', bandwidth_factor=1.3): # get the ID of the camera and define it as an object cap = uvc.Capture(dev_list[i]['uid']) # set the bandwidth factor # to know more about what it is https://github.com/pupil-labs/pupil-docs/blob/master/developer-docs/usb-bandwidth-sync.md cap.bandwidth_factor = bandwidth_factor # set the resolution of the capture cap.frame_mode = mode # logic to select the correct server to access the camera of interest if title == 'LEFT EYE CAPTURE': # sock1.connect((TCP_IP, TCP_PORT1)) sock2.connect((TCP_IP, TCP_PORT2)) print(title) if title == 'RIGHT EYE CAPTURE': # sock3.connect((TCP_IP, TCP_PORT3)) sock4.connect((TCP_IP, TCP_PORT4)) print(title) if title == 'MOUTH CAPTURE': # sock5.connect((TCP_IP, TCP_PORT5)) sock6.connect((TCP_IP, TCP_PORT6)) print(title) # title = cap.name + ' - ' + str(mode) + ' - ' + format while True: # capture every frame from the video frame = cap.get_frame_robust() data = frame.img # encoding done in order to adjust the quality of the frames that needs to be transmitted # be default it is it can range from 0 to 100, 100 being the highest quality # curently being transmitted at 55% compression encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 45] if title == 'LEFT EYE CAPTURE': # vertical flip just to orient the video in the right view data = cv2.flip(data, 1) # encode the image as a jpg compressed before transmission result, imgencode = cv2.imencode('.jpg', data, encode_param) data = np.array(imgencode) stringData = data.tostring() str1 = str(len(stringData)).ljust(16) # sock1.send(str1.encode()) # size of the data sock2.send(stringData) # the data decimg = cv2.imdecode(data, 1) cv2.imshow('CLIENT ' + title, decimg) # leye cv2.moveWindow('CLIENT ' + title, 0, np.size(decimg, 0) + 40) if title == 'RIGHT EYE CAPTURE': # horizontal flip just to orient the video in the right view data = cv2.flip(data, 0) # encode the image as a jpg compressed before transmission result, imgencode = cv2.imencode('.jpg', data, encode_param) data = np.array(imgencode) stringData = data.tostring() str2 = str(len(stringData)).ljust(16) # sock3.send(str2.encode()) # size of the data sock4.send(stringData) # the data decimg = cv2.imdecode(data, 1) cv2.imshow('CLIENT ' + title, decimg) # reye cv2.moveWindow('CLIENT ' + title, np.size(decimg, 1) + 10, np.size(decimg, 0) + 40) if title == 'MOUTH CAPTURE': # horizontal flip just to orient the video in the right view data = cv2.flip(data, 0) # encode the image as a jpg compressed before transmission result, imgencode = cv2.imencode('.jpg', data, encode_param) data = np.array(imgencode) stringData = data.tostring() str3 = str(len(stringData)).ljust(16) # sock5.send(str3.encode()) # size of the data sock6.send(stringData) # the data decimg = cv2.imdecode(data, 1) cv2.imshow('CLIENT ' + title, decimg) # reye cv2.moveWindow('CLIENT ' + title, 2 * np.size(decimg, 1) + 20, np.size(decimg, 0) + 40) k = cv2.waitKey(1) if k == 27: cv2.destroyAllWindows() sock.close() exit(0)
from time import time, sleep from datetime import datetime import os import numpy as np # print (uvc.is_accessible(0)) dev_list = uvc.device_list() print "Compatible devices found:\n\t" + str(dev_list) cam_uid = '' for d in dev_list: if d['name'] == "USB 2.0 Camera": cam_uid = d['uid'] if cam_uid == '': print "No compatible cameras found, exiting :(" exit() cap = uvc.Capture(cam_uid) for c in cap.controls: # if 'Focus' in c.display_name: # c.value = c.def_val if 'Auto Exposure Mode' in c.display_name: c.value = c.def_val # if 'Absolute Exposure Time' in c.display_name: # c.value = c.def_val print "{} = {} {} (def:{}, min:{}, max:{})".format(c.display_name, str(c.value), str(c.unit), str(c.def_val), str(c.min_val), str(c.max_val)) print cap.name + " has the following available modes:\n\t" + str( cap.avaible_modes)
from __future__ import print_function import uvc import logging logging.basicConfig(level=logging.INFO) dev_list = uvc.device_list() print(dev_list) cap = uvc.Capture(dev_list[0]["uid"]) # Uncomment the following lines to configure the Pupil 200Hz IR cameras: # controls_dict = dict([(c.display_name, c) for c in cap.controls]) # controls_dict['Auto Exposure Mode'].value = 1 # controls_dict['Gamma'].value = 200 print(cap.avaible_modes) for x in range(10): print(x) cap.frame_mode = (640, 480, 30) for x in range(100): frame = cap.get_frame_robust() print(frame.img.shape) # cv2.imshow("img",frame.gray) # cv2.waitKey(1) cap = None