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, g_pool):
super().__init__(g_pool)
self.devices = uvc.Device_List()
self.cam_selection_lut = {
"eye0": ["ID0"],
"eye1": ["ID1"],
"world": ["ID2", "Logitech"],
}
def __init__(self, g_pool):
super().__init__(g_pool)
self.devices = uvc.Device_List()
self.cam_selection_lut = {
"eye0": ["ID0"],
"eye1": ["ID1"],
"world": ["ID2", "Logitech"],
}
# Do not show RealSense cameras in selection, since they are not supported
# anymore in Pupil Capture since v1.22 and won't work.
self.ignore_patterns = ["RealSense"]
def __init__(self, g_pool):
super().__init__(g_pool)
self.devices = uvc.Device_List()
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__(self, g_pool, check_devices=True):
super(UVC_Manager, self).__init__(g_pool)
# self.last_check_ts = 0.
# self.check_intervall = 3.5
# self.check_devices = check_devices
self.devices = uvc.Device_List()
global key
global lock
while True:
# Fetch key input
lock.acquire() # lock object
key = ord(getch())
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
"res" : None,
"def" : 0,
"caption" : 'Frame Rate',
"readonly" : False,
"map" : [{
'value' : idx,
'caption': '%.1f Hz'%fr
} for idx,fr in enumerate(self.cap.frame_rates)]
}
})
def bind(self, ctx, sock_type, url, public_ep, set_hwm=None):
sock = ctx.socket(sock_type)
if set_hwm: sock.set_hwm(set_hwm)
sock.bind(url)
ep = sock.last_endpoint
port = ep.split(':')[-1]
public_ep.split(':')[-1]
public_addr = public_ep.split(':')[:-1]
return sock, ':'.join(public_addr+[port])
if __name__ == '__main__':
uuid = None
dev_list = uvc.Device_List()
for dev in dev_list:
uuid = dev['uid']
if uvc.is_accessible(uuid):
break
if uuid: Bridge(uuid).loop()
