def init_gui(self):
# initialize the menu
self.menu = ui.Scrolling_Menu('Gaze Correction (k-means)')
self.g_pool.gui.append(self.menu)
self.menu.append(ui.Button('Close',self.unset_alive))
self.menu.append(ui.Info_Text('This plugin applies to all gaze the bias found by the offline screen detector plugin.'))
def update_menu(self):
logger.debug("update_menu")
try:
del self.menu[:]
except AttributeError:
return
from pyglui import ui
if not self.online:
self.menu.append(ui.Info_Text("Capture initialization failed."))
return
self.menu.append(
ui.Switch("record_depth", self, label="Record Depth Stream"))
self.menu.append(
ui.Switch("preview_depth", self, label="Preview Depth"))
if self._available_modes is not None:
def frame_size_selection_getter():
if self.device_id:
frame_size = sorted(self._available_modes[rs.stream.color],
reverse=True)
labels = [
"({}, {})".format(t[0], t[1]) for t in frame_size
]
return frame_size, labels
else:
return [self.frame_size_backup
], [str(self.frame_size_backup)]
selector = ui.Selector(
"frame_size",
self,
selection_getter=frame_size_selection_getter,
label="Color Resolution",
)
self.menu.append(selector)
def frame_rate_selection_getter():
if self.device_id:
avail_fps = [
fps for fps in self._available_modes[rs.stream.color][
self.frame_size]
]
return avail_fps, [str(fps) for fps in avail_fps]
else:
return [self.frame_rate_backup
], [str(self.frame_rate_backup)]
selector = ui.Selector(
"frame_rate",
self,
selection_getter=frame_rate_selection_getter,
label="Color Frame Rate",
)
self.menu.append(selector)
def depth_frame_size_selection_getter():
if self.device_id:
depth_sizes = sorted(
self._available_modes[rs.stream.depth], reverse=True)
labels = [
"({}, {})".format(t[0], t[1]) for t in depth_sizes
]
return depth_sizes, labels
else:
return (
[self.depth_frame_size_backup],
[str(self.depth_frame_size_backup)],
)
selector = ui.Selector(
"depth_frame_size",
self,
selection_getter=depth_frame_size_selection_getter,
label="Depth Resolution",
)
self.menu.append(selector)
def depth_frame_rate_selection_getter():
if self.device_id:
avail_fps = [
fps for fps in self._available_modes[rs.stream.depth][
self.depth_frame_size]
]
return avail_fps, [str(fps) for fps in avail_fps]
else:
return (
[self.depth_frame_rate_backup],
[str(self.depth_frame_rate_backup)],
)
selector = ui.Selector(
"depth_frame_rate",
self,
selection_getter=depth_frame_rate_selection_getter,
label="Depth Frame Rate",
)
self.menu.append(selector)
def reset_options():
logger.debug("reset_options")
self.reset_device(self.device_id)
sensor_control = ui.Growing_Menu(label="Sensor Settings")
sensor_control.append(
ui.Button("Reset device options to default", reset_options))
self.menu.append(sensor_control)
else:
logger.debug("update_menu: self._available_modes is None")
def update_menu(self):
del self.menu[:]
from pyglui import ui
ui_elements = []
# lets define some helper functions:
def gui_load_defaults():
for c in self.uvc_capture.controls:
try:
c.value = c.def_val
except:
pass
def gui_update_from_device():
for c in self.uvc_capture.controls:
c.refresh()
def set_frame_size(new_size):
self.frame_size = new_size
if self.uvc_capture is None:
ui_elements.append(ui.Info_Text('Capture initialization failed.'))
self.menu.extend(ui_elements)
return
ui_elements.append(ui.Info_Text('{} Controls'.format(self.name)))
sensor_control = ui.Growing_Menu(label='Sensor Settings')
sensor_control.append(ui.Info_Text("Do not change these during calibration or recording!"))
sensor_control.collapsed = False
image_processing = ui.Growing_Menu(label='Image Post Processing')
image_processing.collapsed = True
sensor_control.append(ui.Selector(
'frame_size', self,
setter=set_frame_size,
selection=self.uvc_capture.frame_sizes,
label='Resolution'
))
def frame_rate_getter():
return (self.uvc_capture.frame_rates, [str(fr) for fr in self.uvc_capture.frame_rates])
sensor_control.append(ui.Selector('frame_rate', self, selection_getter=frame_rate_getter, label='Frame rate'))
if ("Pupil Cam" in self.uvc_capture.name):
blacklist = ['Auto Focus', 'Absolute Focus', 'Absolute Iris ',
'Scanning Mode ', 'Zoom absolute control', 'Pan control',
'Tilt control', 'Roll absolute control',
'Privacy Shutter control']
else:
blacklist = []
for control in self.uvc_capture.controls:
c = None
ctl_name = control.display_name
if ctl_name in blacklist:
continue
# now we add controls
if control.d_type == bool:
c = ui.Switch('value', control, label=ctl_name, on_val=control.max_val, off_val=control.min_val)
elif control.d_type == int:
c = ui.Slider('value', control, label=ctl_name, min=control.min_val, max=control.max_val, step=control.step)
elif type(control.d_type) == dict:
selection = [value for name, value in control.d_type.items()]
labels = [name for name, value in control.d_type.items()]
c = ui.Selector('value', control, label=ctl_name, selection=selection, labels=labels)
else:
pass
# if control['disabled']:
# c.read_only = True
# if ctl_name == 'Exposure, Auto Priority':
# # the controll should always be off. we set it to 0 on init (see above)
# c.read_only = True
if c is not None:
if control.unit == 'processing_unit':
image_processing.append(c)
else:
sensor_control.append(c)
ui_elements.append(sensor_control)
if image_processing.elements:
ui_elements.append(image_processing)
ui_elements.append(ui.Button("refresh",gui_update_from_device))
ui_elements.append(ui.Button("load defaults",gui_load_defaults))
if ("Pupil Cam2" in self.uvc_capture.name):
def set_check_stripes(check_stripes):
self.check_stripes = check_stripes
if self.check_stripes:
self.checkframestripes = Check_Frame_Stripes()
logger.info("Check Stripes for camera {} is now on".format(self.uvc_capture.name))
else:
self.checkframestripes = None
logger.info("Check Stripes for camera {} is now off".format(self.uvc_capture.name))
ui_elements.append(ui.Switch('check_stripes', self, setter=set_check_stripes, label="Check Stripes"))
self.menu.extend(ui_elements)
def player(rec_dir, ipc_pub_url, ipc_sub_url,
ipc_push_url, user_dir, app_version):
# general imports
from time import sleep
import logging
import errno
from glob import glob
from copy import deepcopy
from time import time
# networking
import zmq
import zmq_tools
import numpy as np
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx, ipc_sub_url, topics=('notify',))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.INFO)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
try:
# imports
from file_methods import Persistent_Dict, load_object
# display
import glfw
# check versions for our own depedencies as they are fast-changing
from pyglui import __version__ as pyglui_version
from pyglui import ui, cygl
from pyglui.cygl.utils import Named_Texture, RGBA
import gl_utils
# capture
from video_capture import File_Source, EndofVideoFileError
# helpers/utils
from version_utils import VersionFormat
from methods import normalize, denormalize, delta_t, get_system_info
from player_methods import correlate_data, is_pupil_rec_dir, load_meta_info
# Plug-ins
from plugin import Plugin, Plugin_List, import_runtime_plugins
from plugin_manager import Plugin_Manager
from vis_circle import Vis_Circle
from vis_cross import Vis_Cross
from vis_polyline import Vis_Polyline
from vis_light_points import Vis_Light_Points
from vis_watermark import Vis_Watermark
from vis_fixation import Vis_Fixation
from vis_scan_path import Vis_Scan_Path
from vis_eye_video_overlay import Vis_Eye_Video_Overlay
from seek_control import Seek_Control
from video_export_launcher import Video_Export_Launcher
from offline_surface_tracker import Offline_Surface_Tracker
# from marker_auto_trim_marks import Marker_Auto_Trim_Marks
from fixation_detector import Offline_Fixation_Detector
from batch_exporter import Batch_Exporter, Batch_Export
from log_display import Log_Display
from annotations import Annotation_Player
from raw_data_exporter import Raw_Data_Exporter
from log_history import Log_History
from pupil_producers import Pupil_From_Recording, Offline_Pupil_Detection
from gaze_producers import Gaze_From_Recording, Offline_Calibration
from system_graphs import System_Graphs
assert VersionFormat(pyglui_version) >= VersionFormat('1.13'), 'pyglui out of date, please upgrade to newest version'
runtime_plugins = import_runtime_plugins(os.path.join(user_dir, 'plugins'))
system_plugins = [Log_Display, Seek_Control, Plugin_Manager, System_Graphs, Batch_Export]
user_plugins = [Vis_Circle, Vis_Fixation, Vis_Polyline, Vis_Light_Points,
Vis_Cross, Vis_Watermark, Vis_Eye_Video_Overlay, Vis_Scan_Path,
Offline_Fixation_Detector, Batch_Exporter,
Video_Export_Launcher, Offline_Surface_Tracker, Raw_Data_Exporter,
Annotation_Player, Log_History,
Pupil_From_Recording, Offline_Pupil_Detection, Gaze_From_Recording,
Offline_Calibration] + runtime_plugins
plugins = system_plugins + user_plugins
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal hdpi_factor
hdpi_factor = float(glfw.glfwGetFramebufferSize(window)[0] / glfw.glfwGetWindowSize(window)[0])
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
g_pool.camera_render_size = w-int(icon_bar_width*g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *g_pool.camera_render_size)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, g_pool.camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y*scroll_factor)
def on_drop(window, count, paths):
for x in range(count):
new_rec_dir = paths[x].decode('utf-8')
if is_pupil_rec_dir(new_rec_dir):
logger.debug("Starting new session with '{}'".format(new_rec_dir))
ipc_pub.notify({"subject": "player_drop_process.should_start", "rec_dir": new_rec_dir})
glfw.glfwSetWindowShouldClose(window, True)
else:
logger.error("'{}' is not a valid pupil recording".format(new_rec_dir))
tick = delta_t()
def get_dt():
return next(tick)
video_path = [f for f in glob(os.path.join(rec_dir, "world.*"))
if os.path.splitext(f)[1] in ('.mp4', '.mkv', '.avi', '.h264', '.mjpeg')][0]
pupil_data_path = os.path.join(rec_dir, "pupil_data")
meta_info = load_meta_info(rec_dir)
# log info about Pupil Platform and Platform in player.log
logger.info('Application Version: {}'.format(app_version))
logger.info('System Info: {}'.format(get_system_info()))
icon_bar_width = 50
window_size = None
hdpi_factor = 1.0
# create container for globally scoped vars
g_pool = Global_Container()
g_pool.app = 'player'
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
g_pool.camera_render_size = None
# sets itself to g_pool.capture
File_Source(g_pool, video_path)
# load session persistent settings
session_settings = Persistent_Dict(os.path.join(user_dir, "user_settings_player"))
if VersionFormat(session_settings.get("version", '0.0')) != app_version:
logger.info("Session setting are a different version of this app. I will not use those.")
session_settings.clear()
width, height = session_settings.get('window_size', g_pool.capture.frame_size)
window_pos = session_settings.get('window_position', window_position_default)
glfw.glfwInit()
main_window = glfw.glfwCreateWindow(width, height, "Pupil Player: "+meta_info["Recording Name"]+" - "
+ rec_dir.split(os.path.sep)[-1], None, None)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
window_size = (g_pool.camera_render_size[0] + int(icon_bar_width*g_pool.gui_user_scale*hdpi_factor),
glfw.glfwGetFramebufferSize(main_window)[1])
logger.warning(icon_bar_width*g_pool.gui_user_scale*hdpi_factor)
glfw.glfwSetWindowSize(main_window, *window_size)
# load pupil_positions, gaze_positions
g_pool.pupil_data = load_object(pupil_data_path)
g_pool.binocular = meta_info.get('Eye Mode', 'monocular') == 'binocular'
g_pool.version = app_version
g_pool.timestamps = g_pool.capture.timestamps
g_pool.get_timestamp = lambda: 0.
g_pool.new_seek = True
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.meta_info = meta_info
g_pool.min_data_confidence = session_settings.get('min_data_confidence', 0.6)
g_pool.pupil_positions = []
g_pool.gaze_positions = []
g_pool.fixations = []
g_pool.notifications_by_frame = correlate_data(g_pool.pupil_data['notifications'], g_pool.timestamps)
g_pool.pupil_positions_by_frame = [[] for x in g_pool.timestamps] # populated by producer`
g_pool.gaze_positions_by_frame = [[] for x in g_pool.timestamps] # populated by producer
g_pool.fixations_by_frame = [[] for x in g_pool.timestamps] # populated by the fixation detector plugin
# def next_frame(_):
# try:
# g_pool.capture.seek_to_frame(g_pool.capture.get_frame_index() + 1)
# except(FileSeekError):
# logger.warning("Could not seek to next frame.")
# else:
# g_pool.new_seek = True
# def prev_frame(_):
# try:
# g_pool.capture.seek_to_frame(g_pool.capture.get_frame_index() - 1)
# except(FileSeekError):
# logger.warning("Could not seek to previous frame.")
# else:
# g_pool.new_seek = True
# def toggle_play(new_state):
# if g_pool.capture.get_frame_index() >= g_pool.capture.get_frame_count()-5:
# g_pool.capture.seek_to_frame(1) # avoid pause set by hitting trimmark pause.
# logger.warning("End of video - restart at beginning.")
# g_pool.capture.play = new_state
def set_data_confidence(new_confidence):
g_pool.min_data_confidence = new_confidence
notification = {'subject': 'min_data_confidence_changed'}
notification['_notify_time_'] = time()+.8
g_pool.ipc_pub.notify(notification)
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def purge_plugins():
for p in g_pool.plugins:
if p.__class__ in user_plugins:
p.alive = False
g_pool.plugins.clean()
def do_export(_):
export_range = g_pool.seek_control.trim_left, g_pool.seek_control.trim_right
export_dir = os.path.join(g_pool.rec_dir, 'exports', '{}-{}'.format(*export_range))
try:
os.makedirs(export_dir)
except OSError as e:
if e.errno != errno.EEXIST:
logger.error("Could not create export dir")
raise e
else:
overwrite_warning = "Previous export for range [{}-{}] already exsits - overwriting."
logger.warning(overwrite_warning.format(*export_range))
else:
logger.info('Created export dir at "{}"'.format(export_dir))
notification = {'subject': 'should_export', 'range': export_range, 'export_dir': export_dir}
g_pool.ipc_pub.notify(notification)
def reset_restart():
logger.warning("Resetting all settings and restarting Player.")
glfw.glfwSetWindowShouldClose(main_window, True)
ipc_pub.notify({'subject': 'clear_settings_process.should_start'})
ipc_pub.notify({'subject': 'player_process.should_start', 'rec_dir': rec_dir, 'delay': 2.})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get('gui_scale', 1.)
g_pool.menubar = ui.Scrolling_Menu("Settings", pos=(-500, 0), size=(-icon_bar_width, 0), header_pos='left')
g_pool.iconbar = ui.Scrolling_Menu("Icons", pos=(-icon_bar_width,0),size=(0,0),header_pos='hidden')
g_pool.timelines = ui.Container((0, 0), (0, 0), (0, 0))
g_pool.timelines.horizontal_constraint = g_pool.menubar
g_pool.user_timelines = ui.Timeline_Menu('User Timelines', pos=(0., -150.),
size=(0., 0.), header_pos='headline')
g_pool.user_timelines.color = RGBA(a=0.)
g_pool.user_timelines.collapsed = True
# add container that constaints itself to the seekbar height
vert_constr = ui.Container((0, 0), (0, -50.), (0, 0))
vert_constr.append(g_pool.user_timelines)
g_pool.timelines.append(vert_constr)
general_settings = ui.Growing_Menu('General', header_pos='headline')
general_settings.append(ui.Button('Reset window size',
lambda: glfw.glfwSetWindowSize(main_window, g_pool.capture.frame_size[0], g_pool.capture.frame_size[1])))
general_settings.append(ui.Selector('gui_user_scale', g_pool, setter=set_scale, selection=[.8, .9, 1., 1.1, 1.2]+list(np.arange(1.5, 5.1, .5)), label='Interface Size'))
general_settings.append(ui.Info_Text('Player Version: {}'.format(g_pool.version)))
general_settings.append(ui.Info_Text('Capture Version: {}'.format(meta_info['Capture Software Version'])))
general_settings.append(ui.Info_Text('Data Format Version: {}'.format(meta_info['Data Format Version'])))
general_settings.append(ui.Slider('min_data_confidence', g_pool, setter=set_data_confidence,
step=.05, min=0.0, max=1.0, label='Confidence threshold'))
general_settings.append(ui.Button('Restart with default settings', reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon('collapsed', general_settings, label=chr(0xe8b8), on_val=False, off_val=True, setter=toggle_general_settings, label_font='pupil_icons')
icon.tooltip = 'General Settings'
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100), (100, -100))
g_pool.export_button = ui.Thumb('export',
label=chr(0xe2c4),
getter=lambda: False,
setter=do_export,
hotkey='e',
label_font='pupil_icons')
g_pool.quickbar.extend([g_pool.export_button])
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.timelines)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
# we always load these plugins
default_plugins = [('Plugin_Manager', {}), ('Seek_Control', {}), ('Log_Display', {}),
('Vis_Scan_Path', {}), ('Vis_Polyline', {}), ('Vis_Circle', {}), ('System_Graphs', {}),
('Video_Export_Launcher', {}), ('Pupil_From_Recording', {}), ('Gaze_From_Recording', {})]
g_pool.plugins = Plugin_List(g_pool, session_settings.get('loaded_plugins', default_plugins))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
g_pool.gui.configuration = session_settings.get('ui_config', {})
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
# trigger on_resize
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
def handle_notifications(n):
subject = n['subject']
if subject == 'start_plugin':
g_pool.plugins.add(
g_pool.plugin_by_name[n['name']], args=n.get('args', {}))
elif subject.startswith('meta.should_doc'):
ipc_pub.notify({'subject': 'meta.doc',
'actor': g_pool.app,
'doc': player.__doc__})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({'subject': 'meta.doc',
'actor': p.class_name,
'doc': p.on_notify.__doc__})
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
# grab new frame
if g_pool.capture.play or g_pool.new_seek:
g_pool.new_seek = False
try:
new_frame = g_pool.capture.get_frame()
except EndofVideoFileError:
# end of video logic: pause at last frame.
g_pool.capture.play = False
logger.warning("end of video")
frame = new_frame.copy()
events = {}
events['frame'] = frame
# report time between now and the last loop interation
events['dt'] = get_dt()
# pupil and gaze positions are added by their respective producer plugins
events['pupil_positions'] = []
events['gaze_positions'] = []
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
glfw.glfwMakeContextCurrent(main_window)
# render visual feedback from loaded plugins
if gl_utils.is_window_visible(main_window):
gl_utils.glViewport(0, 0, *g_pool.camera_render_size)
g_pool.capture._recent_frame = frame
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
unused_elements = g_pool.gui.update()
for b in unused_elements.buttons:
button, action, mods = b
x, y = glfw.glfwGetCursorPos(main_window)
pos = x * hdpi_factor, y * hdpi_factor
pos = normalize(pos, g_pool.camera_render_size)
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_click(pos, button, action)
for key, scancode, action, mods in unused_elements.keys:
for p in g_pool.plugins:
p.on_key(key, scancode, action, mods)
for char_ in unused_elements.chars:
for p in g_pool.plugins:
p.on_char(char_)
glfw.glfwSwapBuffers(main_window)
# present frames at appropriate speed
g_pool.capture.wait(frame)
glfw.glfwPollEvents()
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['min_data_confidence'] = g_pool.min_data_confidence
session_settings['gui_scale'] = g_pool.gui_user_scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_size'] = glfw.glfwGetWindowSize(main_window)
session_settings['window_position'] = glfw.glfwGetWindowPos(main_window)
session_settings['version'] = str(g_pool.version)
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.capture.cleanup()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
except:
import traceback
trace = traceback.format_exc()
logger.error('Process Player crashed with trace:\n{}'.format(trace))
finally:
logger.info("Process shutting down.")
ipc_pub.notify({'subject': 'player_process.stopped'})
sleep(1.0)
def session(rec_dir):
# Callback functions
def on_resize(window, w, h):
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
graph.adjust_size(w, h)
adjust_gl_view(w, h)
for p in g_pool.plugins:
p.on_window_resize(window, w, h)
def on_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_char(window, char):
g_pool.gui.update_char(char)
def on_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
pos = glfwGetCursorPos(window)
pos = normalize(pos, glfwGetWindowSize(window))
pos = denormalize(
pos,
(frame.img.shape[1], frame.img.shape[0])) # Position in img pixels
for p in g_pool.plugins:
p.on_click(pos, button, action)
def on_pos(window, x, y):
hdpi_factor = float(
glfwGetFramebufferSize(window)[0] / glfwGetWindowSize(window)[0])
g_pool.gui.update_mouse(x * hdpi_factor, y * hdpi_factor)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * y_scroll_factor)
def on_drop(window, count, paths):
for x in range(count):
new_rec_dir = paths[x]
if is_pupil_rec_dir(new_rec_dir):
logger.debug("Starting new session with '%s'" % new_rec_dir)
global rec_dir
rec_dir = new_rec_dir
glfwSetWindowShouldClose(window, True)
else:
logger.error("'%s' is not a valid pupil recording" %
new_rec_dir)
tick = delta_t()
def get_dt():
return next(tick)
video_path = [
f for f in glob(os.path.join(rec_dir, "world.*"))
if f[-3:] in ('mp4', 'mkv', 'avi')
][0]
timestamps_path = os.path.join(rec_dir, "world_timestamps.npy")
pupil_data_path = os.path.join(rec_dir, "pupil_data")
#parse info.csv file
meta_info_path = os.path.join(rec_dir, "info.csv")
with open(meta_info_path) as info:
meta_info = dict(
((line.strip().split('\t')) for line in info.readlines()))
rec_version = read_rec_version(meta_info)
if rec_version >= VersionFormat('0.5'):
pass
elif rec_version >= VersionFormat('0.4'):
update_recording_0v4_to_current(rec_dir)
elif rec_version >= VersionFormat('0.3'):
update_recording_0v3_to_current(rec_dir)
timestamps_path = os.path.join(rec_dir, "timestamps.npy")
else:
logger.Error("This recording is to old. Sorry.")
return
timestamps = np.load(timestamps_path)
# Initialize capture
cap = File_Capture(video_path, timestamps=list(timestamps))
# load session persistent settings
session_settings = Persistent_Dict(os.path.join(user_dir, "user_settings"))
if session_settings.get("version",
VersionFormat('0.0')) < get_version(version_file):
logger.info(
"Session setting are from older version of this app. I will not use those."
)
session_settings.clear()
width, height = session_settings.get('window_size', cap.frame_size)
window_pos = session_settings.get('window_position', (0, 0))
main_window = glfwCreateWindow(
width, height, "Pupil Player: " + meta_info["Recording Name"] + " - " +
rec_dir.split(os.path.sep)[-1], None, None)
glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfwMakeContextCurrent(main_window)
cygl.utils.init()
# load pupil_positions, gaze_positions
pupil_data = load_object(pupil_data_path)
pupil_list = pupil_data['pupil_positions']
gaze_list = pupil_data['gaze_positions']
# create container for globally scoped vars
g_pool = Global_Container()
g_pool.app = 'player'
g_pool.binocular = meta_info.get('Eye Mode', 'monocular') == 'binocular'
g_pool.version = get_version(version_file)
g_pool.capture = cap
g_pool.timestamps = timestamps
g_pool.play = False
g_pool.new_seek = True
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.rec_version = rec_version
g_pool.meta_info = meta_info
g_pool.pupil_positions_by_frame = correlate_data(pupil_list,
g_pool.timestamps)
g_pool.gaze_positions_by_frame = correlate_data(gaze_list,
g_pool.timestamps)
g_pool.fixations_by_frame = [[] for x in g_pool.timestamps
] #populated by the fixation detector plugin
def next_frame(_):
try:
cap.seek_to_frame(cap.get_frame_index())
except FileSeekError:
pass
g_pool.new_seek = True
def prev_frame(_):
try:
cap.seek_to_frame(cap.get_frame_index() - 2)
except FileSeekError:
pass
g_pool.new_seek = True
def set_scale(new_scale):
g_pool.gui.scale = new_scale
g_pool.gui.collect_menus()
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def purge_plugins():
for p in g_pool.plugins:
if p.__class__ in user_launchable_plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui = ui.UI()
g_pool.gui.scale = session_settings.get('gui_scale', 1)
g_pool.main_menu = ui.Growing_Menu("Settings",
pos=(-350, 20),
size=(300, 400))
g_pool.main_menu.append(
ui.Button("Close Pupil Player",
lambda: glfwSetWindowShouldClose(main_window, True)))
g_pool.main_menu.append(
ui.Slider('scale',
g_pool.gui,
setter=set_scale,
step=.05,
min=0.75,
max=2.5,
label='Interface Size'))
g_pool.main_menu.append(ui.Info_Text('Player Version: %s' %
g_pool.version))
g_pool.main_menu.append(ui.Info_Text('Recording Version: %s' %
rec_version))
g_pool.main_menu.append(
ui.Selector('Open plugin',
selection=user_launchable_plugins,
labels=[
p.__name__.replace('_', ' ')
for p in user_launchable_plugins
],
setter=open_plugin,
getter=lambda: "Select to load"))
g_pool.main_menu.append(ui.Button('Close all plugins', purge_plugins))
g_pool.main_menu.append(
ui.Button(
'Reset window size', lambda: glfwSetWindowSize(
main_window, cap.frame_size[0], cap.frame_size[1])))
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100), (120, -100))
g_pool.play_button = ui.Thumb('play',
g_pool,
label='Play',
hotkey=GLFW_KEY_SPACE)
g_pool.play_button.on_color[:] = (0, 1., .0, .8)
g_pool.forward_button = ui.Thumb('forward',
getter=lambda: False,
setter=next_frame,
hotkey=GLFW_KEY_RIGHT)
g_pool.backward_button = ui.Thumb('backward',
getter=lambda: False,
setter=prev_frame,
hotkey=GLFW_KEY_LEFT)
g_pool.quickbar.extend(
[g_pool.play_button, g_pool.forward_button, g_pool.backward_button])
g_pool.gui.append(g_pool.quickbar)
g_pool.gui.append(g_pool.main_menu)
#we always load these plugins
system_plugins = [('Trim_Marks', {}), ('Seek_Bar', {})]
default_plugins = [('Log_Display', {}), ('Scan_Path', {}),
('Vis_Polyline', {}), ('Vis_Circle', {}),
('Export_Launcher', {})]
previous_plugins = session_settings.get('loaded_plugins', default_plugins)
g_pool.notifications = []
g_pool.delayed_notifications = {}
g_pool.plugins = Plugin_List(g_pool, plugin_by_name,
system_plugins + previous_plugins)
for p in g_pool.plugins:
if p.class_name == 'Trim_Marks':
g_pool.trim_marks = p
break
# Register callbacks main_window
glfwSetFramebufferSizeCallback(main_window, on_resize)
glfwSetKeyCallback(main_window, on_key)
glfwSetCharCallback(main_window, on_char)
glfwSetMouseButtonCallback(main_window, on_button)
glfwSetCursorPosCallback(main_window, on_pos)
glfwSetScrollCallback(main_window, on_scroll)
glfwSetDropCallback(main_window, on_drop)
#trigger on_resize
on_resize(main_window, *glfwGetFramebufferSize(main_window))
g_pool.gui.configuration = session_settings.get('ui_config', {})
# gl_state settings
basic_gl_setup()
g_pool.image_tex = Named_Texture()
#set up performace graphs:
pid = os.getpid()
ps = psutil.Process(pid)
ts = cap.get_timestamp() - .03
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 110)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = 'CPU %0.1f'
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 110)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f REC FPS"
pupil_graph = graph.Bar_Graph(max_val=1.0)
pupil_graph.pos = (260, 110)
pupil_graph.update_rate = 5
pupil_graph.label = "Confidence: %0.2f"
while not glfwWindowShouldClose(main_window):
#grab new frame
if g_pool.play or g_pool.new_seek:
g_pool.new_seek = False
try:
new_frame = cap.get_frame_nowait()
except EndofVideoFileError:
#end of video logic: pause at last frame.
g_pool.play = False
update_graph = True
else:
update_graph = False
frame = new_frame.copy()
events = {}
#report time between now and the last loop interation
events['dt'] = get_dt()
#new positons we make a deepcopy just like the image is a copy.
events['gaze_positions'] = deepcopy(
g_pool.gaze_positions_by_frame[frame.index])
events['pupil_positions'] = deepcopy(
g_pool.pupil_positions_by_frame[frame.index])
if update_graph:
#update performace graphs
for p in events['pupil_positions']:
pupil_graph.add(p['confidence'])
t = new_frame.timestamp
if ts != t:
dt, ts = t - ts, t
fps_graph.add(1. / dt)
g_pool.play_button.status_text = str(frame.index)
#always update the CPU graph
cpu_graph.update()
# publish delayed notifiactions when their time has come.
for n in g_pool.delayed_notifications.values():
if n['_notify_time_'] < time():
del n['_notify_time_']
del g_pool.delayed_notifications[n['subject']]
g_pool.notifications.append(n)
# notify each plugin if there are new notifactions:
while g_pool.notifications:
n = g_pool.notifications.pop(0)
for p in g_pool.plugins:
p.on_notify(n)
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.update(frame, events)
#check if a plugin need to be destroyed
g_pool.plugins.clean()
# render camera image
glfwMakeContextCurrent(main_window)
make_coord_system_norm_based()
g_pool.image_tex.update_from_frame(frame)
g_pool.image_tex.draw()
make_coord_system_pixel_based(frame.img.shape)
# render visual feedback from loaded plugins
for p in g_pool.plugins:
p.gl_display()
graph.push_view()
fps_graph.draw()
cpu_graph.draw()
pupil_graph.draw()
graph.pop_view()
g_pool.gui.update()
#present frames at appropriate speed
cap.wait(frame)
glfwSwapBuffers(main_window)
glfwPollEvents()
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['gui_scale'] = g_pool.gui.scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_size'] = glfwGetWindowSize(main_window)
session_settings['window_position'] = glfwGetWindowPos(main_window)
session_settings['version'] = g_pool.version
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
cap.close()
g_pool.gui.terminate()
glfwDestroyWindow(main_window)
def player(
rec_dir, ipc_pub_url, ipc_sub_url, ipc_push_url, user_dir, app_version, debug
):
# general imports
from time import sleep
import logging
from glob import glob
from time import time, strftime, localtime
# networking
import zmq
import zmq_tools
import numpy as np
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx, ipc_sub_url, topics=("notify",))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
try:
from background_helper import IPC_Logging_Task_Proxy
IPC_Logging_Task_Proxy.push_url = ipc_push_url
from tasklib.background.patches import IPCLoggingPatch
IPCLoggingPatch.ipc_push_url = ipc_push_url
# imports
from file_methods import Persistent_Dict, next_export_sub_dir
from OpenGL.GL import GL_COLOR_BUFFER_BIT
# display
import glfw
glfw.ERROR_REPORTING = "raise"
# check versions for our own depedencies as they are fast-changing
from pyglui import __version__ as pyglui_version
from pyglui import ui, cygl
from pyglui.cygl.utils import Named_Texture, RGBA
import gl_utils
# capture
from video_capture import File_Source
# helpers/utils
from version_utils import parse_version
from methods import normalize, denormalize, delta_t, get_system_info
import player_methods as pm
from pupil_recording import PupilRecording
from csv_utils import write_key_value_file
# Plug-ins
from plugin import Plugin, Plugin_List, import_runtime_plugins
from plugin_manager import Plugin_Manager
from vis_circle import Vis_Circle
from vis_cross import Vis_Cross
from vis_polyline import Vis_Polyline
from vis_light_points import Vis_Light_Points
from vis_watermark import Vis_Watermark
from vis_fixation import Vis_Fixation
from seek_control import Seek_Control
from surface_tracker import Surface_Tracker_Offline
# from marker_auto_trim_marks import Marker_Auto_Trim_Marks
from fixation_detector import Offline_Fixation_Detector
from log_display import Log_Display
from annotations import Annotation_Player
from raw_data_exporter import Raw_Data_Exporter
from log_history import Log_History
from pupil_producers import Pupil_From_Recording, Offline_Pupil_Detection
from gaze_producer.gaze_from_recording import GazeFromRecording
from gaze_producer.gaze_from_offline_calibration import (
GazeFromOfflineCalibration,
)
from pupil_detector_plugins.detector_base_plugin import PupilDetectorPlugin
from system_graphs import System_Graphs
from system_timelines import System_Timelines
from blink_detection import Offline_Blink_Detection
from audio_playback import Audio_Playback
from video_export.plugins.imotions_exporter import iMotions_Exporter
from video_export.plugins.eye_video_exporter import Eye_Video_Exporter
from video_export.plugins.world_video_exporter import World_Video_Exporter
from head_pose_tracker.offline_head_pose_tracker import (
Offline_Head_Pose_Tracker,
)
from video_capture import File_Source
from video_overlay.plugins import Video_Overlay, Eye_Overlay
from pupil_recording import (
assert_valid_recording_type,
InvalidRecordingException,
)
assert parse_version(pyglui_version) >= parse_version(
"1.28"
), "pyglui out of date, please upgrade to newest version"
process_was_interrupted = False
def interrupt_handler(sig, frame):
import traceback
trace = traceback.format_stack(f=frame)
logger.debug(f"Caught signal {sig} in:\n" + "".join(trace))
nonlocal process_was_interrupted
process_was_interrupted = True
signal.signal(signal.SIGINT, interrupt_handler)
runtime_plugins = import_runtime_plugins(os.path.join(user_dir, "plugins"))
runtime_plugins = [
p for p in runtime_plugins if not issubclass(p, PupilDetectorPlugin)
]
system_plugins = [
Log_Display,
Seek_Control,
Plugin_Manager,
System_Graphs,
System_Timelines,
Audio_Playback,
]
user_plugins = [
Vis_Circle,
Vis_Fixation,
Vis_Polyline,
Vis_Light_Points,
Vis_Cross,
Vis_Watermark,
Eye_Overlay,
Video_Overlay,
Offline_Fixation_Detector,
Offline_Blink_Detection,
Surface_Tracker_Offline,
Raw_Data_Exporter,
Annotation_Player,
Log_History,
Pupil_From_Recording,
Offline_Pupil_Detection,
GazeFromRecording,
GazeFromOfflineCalibration,
World_Video_Exporter,
iMotions_Exporter,
Eye_Video_Exporter,
Offline_Head_Pose_Tracker,
] + runtime_plugins
plugins = system_plugins + user_plugins
def consume_events_and_render_buffer():
gl_utils.glViewport(0, 0, *g_pool.camera_render_size)
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.get_clipboard_string(main_window).decode()
except (AttributeError, glfw.GLFWError):
# clipbaord is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard and user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.set_clipboard_string(main_window, user_input.clipboard)
for b in user_input.buttons:
button, action, mods = b
x, y = glfw.get_cursor_pos(main_window)
pos = gl_utils.window_coordinate_to_framebuffer_coordinate(
main_window, x, y, cached_scale=None
)
pos = normalize(pos, g_pool.camera_render_size)
pos = denormalize(pos, g_pool.capture.frame_size)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
glfw.swap_buffers(main_window)
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal content_scale
if w == 0 or h == 0:
return
# Always clear buffers on resize to make sure that there are no overlapping
# artifacts from previous frames.
gl_utils.glClear(GL_COLOR_BUFFER_BIT)
gl_utils.glClearColor(0, 0, 0, 1)
content_scale = gl_utils.get_content_scale(window)
framebuffer_scale = gl_utils.get_framebuffer_scale(window)
g_pool.gui.scale = content_scale
window_size = w, h
g_pool.camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *g_pool.camera_render_size)
# Minimum window size required, otherwise parts of the UI can cause openGL
# issues with permanent effects. Depends on the content scale, which can
# potentially be dynamically modified, so we re-adjust the size limits every
# time here.
min_size = int(2 * icon_bar_width * g_pool.gui.scale / framebuffer_scale)
glfw.set_window_size_limits(
window,
min_size,
min_size,
glfw.DONT_CARE,
glfw.DONT_CARE,
)
# Needed, to update the window buffer while resizing
consume_events_and_render_buffer()
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = gl_utils.window_coordinate_to_framebuffer_coordinate(
window, x, y, cached_scale=None
)
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, g_pool.camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, paths):
for path in paths:
try:
assert_valid_recording_type(path)
_restart_with_recording(path)
return
except InvalidRecordingException as err:
logger.debug(str(err))
for plugin in g_pool.plugins:
if plugin.on_drop(paths):
break
def _restart_with_recording(rec_dir):
logger.debug("Starting new session with '{}'".format(rec_dir))
ipc_pub.notify(
{"subject": "player_drop_process.should_start", "rec_dir": rec_dir}
)
glfw.set_window_should_close(g_pool.main_window, True)
tick = delta_t()
def get_dt():
return next(tick)
recording = PupilRecording(rec_dir)
meta_info = recording.meta_info
# log info about Pupil Platform and Platform in player.log
logger.info("Application Version: {}".format(app_version))
logger.info("System Info: {}".format(get_system_info()))
logger.debug(f"Debug flag: {debug}")
icon_bar_width = 50
window_size = None
content_scale = 1.0
# create container for globally scoped vars
g_pool = SimpleNamespace()
g_pool.app = "player"
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
g_pool.camera_render_size = None
video_path = recording.files().core().world().videos()[0].resolve()
File_Source(
g_pool,
timing="external",
source_path=video_path,
buffered_decoding=True,
fill_gaps=True,
)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(user_dir, "user_settings_player")
)
if parse_version(session_settings.get("version", "0.0")) != app_version:
logger.info(
"Session setting are a different version of this app. I will not use those."
)
session_settings.clear()
width, height = g_pool.capture.frame_size
width += icon_bar_width
width, height = session_settings.get("window_size", (width, height))
window_name = f"Pupil Player: {meta_info.recording_name} - {rec_dir}"
glfw.init()
glfw.window_hint(glfw.SCALE_TO_MONITOR, glfw.TRUE)
main_window = glfw.create_window(width, height, window_name, None, None)
window_position_manager = gl_utils.WindowPositionManager()
window_pos = window_position_manager.new_window_position(
window=main_window,
default_position=window_position_default,
previous_position=session_settings.get("window_position", None),
)
glfw.set_window_pos(main_window, window_pos[0], window_pos[1])
glfw.make_context_current(main_window)
cygl.utils.init()
g_pool.main_window = main_window
g_pool.version = app_version
g_pool.timestamps = g_pool.capture.timestamps
g_pool.get_timestamp = lambda: 0.0
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.meta_info = meta_info
g_pool.min_data_confidence = session_settings.get(
"min_data_confidence", MIN_DATA_CONFIDENCE_DEFAULT
)
g_pool.min_calibration_confidence = session_settings.get(
"min_calibration_confidence", MIN_CALIBRATION_CONFIDENCE_DEFAULT
)
# populated by producers
g_pool.pupil_positions = pm.PupilDataBisector()
g_pool.gaze_positions = pm.Bisector()
g_pool.fixations = pm.Affiliator()
g_pool.eye_movements = pm.Affiliator()
def set_data_confidence(new_confidence):
g_pool.min_data_confidence = new_confidence
notification = {"subject": "min_data_confidence_changed"}
notification["_notify_time_"] = time() + 0.8
g_pool.ipc_pub.notify(notification)
def do_export(_):
left_idx = g_pool.seek_control.trim_left
right_idx = g_pool.seek_control.trim_right
export_range = left_idx, right_idx + 1 # exclusive range.stop
export_ts_window = pm.exact_window(g_pool.timestamps, (left_idx, right_idx))
export_dir = os.path.join(g_pool.rec_dir, "exports")
export_dir = next_export_sub_dir(export_dir)
os.makedirs(export_dir)
logger.info('Created export dir at "{}"'.format(export_dir))
export_info = {
"Player Software Version": str(g_pool.version),
"Data Format Version": meta_info.min_player_version,
"Export Date": strftime("%d.%m.%Y", localtime()),
"Export Time": strftime("%H:%M:%S", localtime()),
"Frame Index Range:": g_pool.seek_control.get_frame_index_trim_range_string(),
"Relative Time Range": g_pool.seek_control.get_rel_time_trim_range_string(),
"Absolute Time Range": g_pool.seek_control.get_abs_time_trim_range_string(),
}
with open(os.path.join(export_dir, "export_info.csv"), "w") as csv:
write_key_value_file(csv, export_info)
notification = {
"subject": "should_export",
"range": export_range,
"ts_window": export_ts_window,
"export_dir": export_dir,
}
g_pool.ipc_pub.notify(notification)
def reset_restart():
logger.warning("Resetting all settings and restarting Player.")
glfw.set_window_should_close(main_window, True)
ipc_pub.notify({"subject": "clear_settings_process.should_start"})
ipc_pub.notify(
{
"subject": "player_process.should_start",
"rec_dir": rec_dir,
"delay": 2.0,
}
)
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
g_pool.gui = ui.UI()
g_pool.menubar = ui.Scrolling_Menu(
"Settings", pos=(-500, 0), size=(-icon_bar_width, 0), header_pos="left"
)
g_pool.iconbar = ui.Scrolling_Menu(
"Icons", pos=(-icon_bar_width, 0), size=(0, 0), header_pos="hidden"
)
g_pool.timelines = ui.Container((0, 0), (0, 0), (0, 0))
g_pool.timelines.horizontal_constraint = g_pool.menubar
g_pool.user_timelines = ui.Timeline_Menu(
"User Timelines", pos=(0.0, -150.0), size=(0.0, 0.0), header_pos="headline"
)
g_pool.user_timelines.color = RGBA(a=0.0)
g_pool.user_timelines.collapsed = True
# add container that constaints itself to the seekbar height
vert_constr = ui.Container((0, 0), (0, -50.0), (0, 0))
vert_constr.append(g_pool.user_timelines)
g_pool.timelines.append(vert_constr)
def set_window_size():
# Get current capture frame size
f_width, f_height = g_pool.capture.frame_size
# Get current display scale factor
content_scale = gl_utils.get_content_scale(main_window)
framebuffer_scale = gl_utils.get_framebuffer_scale(main_window)
display_scale_factor = content_scale / framebuffer_scale
# Scale the capture frame size by display scale factor
f_width *= display_scale_factor
f_height *= display_scale_factor
# Increas the width to account for the added scaled icon bar width
f_width += icon_bar_width * display_scale_factor
# Set the newly calculated size (scaled capture frame size + scaled icon bar width)
glfw.set_window_size(main_window, int(f_width), int(f_height))
general_settings = ui.Growing_Menu("General", header_pos="headline")
general_settings.append(ui.Button("Reset window size", set_window_size))
general_settings.append(
ui.Info_Text(f"Minimum Player Version: {meta_info.min_player_version}")
)
general_settings.append(ui.Info_Text(f"Player Version: {g_pool.version}"))
general_settings.append(
ui.Info_Text(f"Recording Software: {meta_info.recording_software_name}")
)
general_settings.append(
ui.Info_Text(
f"Recording Software Version: {meta_info.recording_software_version}"
)
)
general_settings.append(
ui.Info_Text(
"High level data, e.g. fixations, or visualizations only consider gaze data that has an equal or higher confidence than the minimum data confidence."
)
)
general_settings.append(
ui.Slider(
"min_data_confidence",
g_pool,
setter=set_data_confidence,
step=0.05,
min=0.0,
max=1.0,
label="Minimum data confidence",
)
)
general_settings.append(
ui.Button("Restart with default settings", reset_restart)
)
g_pool.menubar.append(general_settings)
icon = ui.Icon(
"collapsed",
general_settings,
label=chr(0xE8B8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font="pupil_icons",
)
icon.tooltip = "General Settings"
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
g_pool.quickbar = ui.Stretching_Menu("Quick Bar", (0, 100), (100, -100))
g_pool.export_button = ui.Thumb(
"export",
label=chr(0xE2C5),
getter=lambda: False,
setter=do_export,
hotkey="e",
label_font="pupil_icons",
)
g_pool.quickbar.extend([g_pool.export_button])
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.timelines)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
# we always load these plugins
default_plugins = [
("Plugin_Manager", {}),
("Seek_Control", {}),
("Log_Display", {}),
("Raw_Data_Exporter", {}),
("Vis_Polyline", {}),
("Vis_Circle", {}),
("System_Graphs", {}),
("System_Timelines", {}),
("World_Video_Exporter", {}),
("Pupil_From_Recording", {}),
("GazeFromRecording", {}),
("Audio_Playback", {}),
]
g_pool.plugins = Plugin_List(
g_pool, session_settings.get("loaded_plugins", default_plugins)
)
# Manually add g_pool.capture to the plugin list
g_pool.plugins._plugins.append(g_pool.capture)
g_pool.plugins._plugins.sort(key=lambda p: p.order)
g_pool.capture.init_ui()
general_settings.insert(
-1,
ui.Text_Input(
"rel_time_trim_section",
getter=g_pool.seek_control.get_rel_time_trim_range_string,
setter=g_pool.seek_control.set_rel_time_trim_range_string,
label="Relative time range to export",
),
)
general_settings.insert(
-1,
ui.Text_Input(
"frame_idx_trim_section",
getter=g_pool.seek_control.get_frame_index_trim_range_string,
setter=g_pool.seek_control.set_frame_index_trim_range_string,
label="Frame index range to export",
),
)
# Register callbacks main_window
glfw.set_framebuffer_size_callback(main_window, on_resize)
glfw.set_key_callback(main_window, on_window_key)
glfw.set_char_callback(main_window, on_window_char)
glfw.set_mouse_button_callback(main_window, on_window_mouse_button)
glfw.set_cursor_pos_callback(main_window, on_pos)
glfw.set_scroll_callback(main_window, on_scroll)
glfw.set_drop_callback(main_window, on_drop)
toggle_general_settings(True)
g_pool.gui.configuration = session_settings.get("ui_config", {})
# If previously selected plugin was not loaded this time, we will have an
# expanded menubar without any menu selected. We need to ensure the menubar is
# collapsed in this case.
if all(submenu.collapsed for submenu in g_pool.menubar.elements):
g_pool.menubar.collapsed = True
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
# trigger on_resize
on_resize(main_window, *glfw.get_framebuffer_size(main_window))
def handle_notifications(n):
subject = n["subject"]
if subject == "start_plugin":
g_pool.plugins.add(
g_pool.plugin_by_name[n["name"]], args=n.get("args", {})
)
elif subject.startswith("meta.should_doc"):
ipc_pub.notify(
{"subject": "meta.doc", "actor": g_pool.app, "doc": player.__doc__}
)
for p in g_pool.plugins:
if (
p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify
):
ipc_pub.notify(
{
"subject": "meta.doc",
"actor": p.class_name,
"doc": p.on_notify.__doc__,
}
)
while not glfw.window_should_close(main_window) and not process_was_interrupted:
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
events = {}
# report time between now and the last loop interation
events["dt"] = get_dt()
# pupil and gaze positions are added by their respective producer plugins
events["pupil"] = []
events["gaze"] = []
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
glfw.make_context_current(main_window)
glfw.poll_events()
# render visual feedback from loaded plugins
if gl_utils.is_window_visible(main_window):
gl_utils.glViewport(0, 0, *g_pool.camera_render_size)
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.get_clipboard_string(main_window).decode()
except (AttributeError, glfw.GLFWError):
# clipbaord is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard and user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.set_clipboard_string(main_window, user_input.clipboard)
for b in user_input.buttons:
button, action, mods = b
x, y = glfw.get_cursor_pos(main_window)
pos = gl_utils.window_coordinate_to_framebuffer_coordinate(
main_window, x, y, cached_scale=None
)
pos = normalize(pos, g_pool.camera_render_size)
pos = denormalize(pos, g_pool.capture.frame_size)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
# present frames at appropriate speed
g_pool.seek_control.wait(events["frame"].timestamp)
glfw.swap_buffers(main_window)
session_settings["loaded_plugins"] = g_pool.plugins.get_initializers()
session_settings["min_data_confidence"] = g_pool.min_data_confidence
session_settings[
"min_calibration_confidence"
] = g_pool.min_calibration_confidence
session_settings["ui_config"] = g_pool.gui.configuration
session_settings["window_position"] = glfw.get_window_pos(main_window)
session_settings["version"] = str(g_pool.version)
session_window_size = glfw.get_window_size(main_window)
if 0 not in session_window_size:
f_width, f_height = session_window_size
if platform.system() in ("Windows", "Linux"):
f_width, f_height = (
f_width / content_scale,
f_height / content_scale,
)
session_settings["window_size"] = int(f_width), int(f_height)
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.destroy_window(main_window)
except Exception:
import traceback
trace = traceback.format_exc()
logger.error("Process Player crashed with trace:\n{}".format(trace))
finally:
logger.info("Process shutting down.")
ipc_pub.notify({"subject": "player_process.stopped"})
sleep(1.0)
def world(
timebase,
eye_procs_alive,
ipc_pub_url,
ipc_sub_url,
ipc_push_url,
user_dir,
version,
preferred_remote_port,
hide_ui,
debug,
):
"""Reads world video and runs plugins.
Creates a window, gl context.
Grabs images from a capture.
Maps pupil to gaze data
Can run various plug-ins.
Reacts to notifications:
``eye_process.started``
``start_plugin``
``should_stop``
Emits notifications:
``eye_process.should_start``
``eye_process.should_stop``
``world_process.started``
``world_process.stopped``
``recording.should_stop``: Emits on camera failure
``launcher_process.should_stop``
Emits data:
``gaze``: Gaze data from current gaze mapping plugin.``
``*``: any other plugin generated data in the events
that it not [dt,pupil,gaze].
"""
# We defer the imports because of multiprocessing.
# Otherwise the world process each process also loads the other imports.
# This is not harmful but unnecessary.
# general imports
from time import sleep
import logging
# networking
import zmq
import zmq_tools
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=("notify", ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
def launch_eye_process(eye_id, delay=0):
n = {
"subject": "eye_process.should_start.{}".format(eye_id),
"eye_id": eye_id,
"delay": delay,
}
ipc_pub.notify(n)
def stop_eye_process(eye_id):
n = {
"subject": "eye_process.should_stop.{}".format(eye_id),
"eye_id": eye_id,
"delay": 0.2,
}
ipc_pub.notify(n)
def start_stop_eye(eye_id, make_alive):
if make_alive:
launch_eye_process(eye_id)
else:
stop_eye_process(eye_id)
def detection_enabled_getter() -> int:
return int(g_pool.pupil_detection_enabled)
def detection_enabled_setter(value: int):
is_on = bool(value)
g_pool.pupil_detection_enabled = is_on
n = {"subject": "pupil_detector.set_enabled", "value": is_on}
ipc_pub.notify(n)
try:
from background_helper import IPC_Logging_Task_Proxy
IPC_Logging_Task_Proxy.push_url = ipc_push_url
from tasklib.background.patches import IPCLoggingPatch
IPCLoggingPatch.ipc_push_url = ipc_push_url
from OpenGL.GL import GL_COLOR_BUFFER_BIT
# display
import glfw
from gl_utils import GLFWErrorReporting
GLFWErrorReporting.set_default()
from version_utils import parse_version
from pyglui import ui, cygl, __version__ as pyglui_version
assert parse_version(pyglui_version) >= parse_version(
"1.27"), "pyglui out of date, please upgrade to newest version"
from pyglui.cygl.utils import Named_Texture
import gl_utils
# helpers/utils
from file_methods import Persistent_Dict
from methods import normalize, denormalize, delta_t, get_system_info, timer
from uvc import get_time_monotonic
logger.info("Application Version: {}".format(version))
logger.info("System Info: {}".format(get_system_info()))
logger.debug(f"Debug flag: {debug}")
import audio
# Plug-ins
from plugin import (
Plugin,
System_Plugin_Base,
Plugin_List,
import_runtime_plugins,
)
from plugin_manager import Plugin_Manager
from calibration_choreography import (
available_calibration_choreography_plugins,
CalibrationChoreographyPlugin,
patch_loaded_plugins_with_choreography_plugin,
)
available_choreography_plugins = available_calibration_choreography_plugins(
)
from gaze_mapping import registered_gazer_classes
from gaze_mapping.gazer_base import GazerBase
from pupil_detector_plugins.detector_base_plugin import PupilDetectorPlugin
from fixation_detector import Fixation_Detector
from recorder import Recorder
from display_recent_gaze import Display_Recent_Gaze
from time_sync import Time_Sync
from network_api import NetworkApiPlugin
from pupil_groups import Pupil_Groups
from surface_tracker import Surface_Tracker_Online
from log_display import Log_Display
from annotations import Annotation_Capture
from log_history import Log_History
from blink_detection import Blink_Detection
from video_capture import (
source_classes,
manager_classes,
Base_Manager,
Base_Source,
)
from pupil_data_relay import Pupil_Data_Relay
from remote_recorder import Remote_Recorder
from accuracy_visualizer import Accuracy_Visualizer
from system_graphs import System_Graphs
from camera_intrinsics_estimation import Camera_Intrinsics_Estimation
from hololens_relay import Hololens_Relay
from head_pose_tracker.online_head_pose_tracker import Online_Head_Pose_Tracker
# UI Platform tweaks
if platform.system() == "Linux":
scroll_factor = 10.0
window_position_default = (30, 30)
elif platform.system() == "Windows":
scroll_factor = 10.0
window_position_default = (8, 90)
else:
scroll_factor = 1.0
window_position_default = (0, 0)
process_was_interrupted = False
def interrupt_handler(sig, frame):
import traceback
trace = traceback.format_stack(f=frame)
logger.debug(f"Caught signal {sig} in:\n" + "".join(trace))
nonlocal process_was_interrupted
process_was_interrupted = True
signal.signal(signal.SIGINT, interrupt_handler)
icon_bar_width = 50
window_size = None
camera_render_size = None
content_scale = 1.0
# g_pool holds variables for this process they are accessible to all plugins
g_pool = SimpleNamespace()
g_pool.debug = debug
g_pool.app = "capture"
g_pool.process = "world"
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.timebase = timebase
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.eye_procs_alive = eye_procs_alive
g_pool.preferred_remote_port = preferred_remote_port
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
# manage plugins
runtime_plugins = import_runtime_plugins(
os.path.join(g_pool.user_dir, "plugins"))
runtime_plugins = [
p for p in runtime_plugins
if not issubclass(p, PupilDetectorPlugin)
]
user_plugins = [
Pupil_Groups,
NetworkApiPlugin,
Time_Sync,
Surface_Tracker_Online,
Annotation_Capture,
Log_History,
Fixation_Detector,
Blink_Detection,
Remote_Recorder,
Accuracy_Visualizer,
Camera_Intrinsics_Estimation,
Hololens_Relay,
Online_Head_Pose_Tracker,
]
system_plugins = ([
Log_Display,
Display_Recent_Gaze,
Recorder,
Pupil_Data_Relay,
Plugin_Manager,
System_Graphs,
] + manager_classes + source_classes)
plugins = (system_plugins + user_plugins + runtime_plugins +
available_choreography_plugins + registered_gazer_classes())
user_plugins += [
p for p in runtime_plugins if not isinstance(
p,
(
Base_Manager,
Base_Source,
System_Plugin_Base,
CalibrationChoreographyPlugin,
GazerBase,
),
)
]
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
default_capture_name = "UVC_Source"
default_capture_settings = {
"preferred_names": [
"Pupil Cam1 ID2",
"Logitech Camera",
"(046d:081d)",
"C510",
"B525",
"C525",
"C615",
"C920",
"C930e",
],
"frame_size": (1280, 720),
"frame_rate":
30,
}
default_plugins = [
(default_capture_name, default_capture_settings),
("Pupil_Data_Relay", {}),
("UVC_Manager", {}),
("NDSI_Manager", {}),
("HMD_Streaming_Manager", {}),
("File_Manager", {}),
("Log_Display", {}),
("Dummy_Gaze_Mapper", {}),
("Display_Recent_Gaze", {}),
# Calibration choreography plugin is added below by calling
# patch_loaded_plugins_with_choreography_plugin
("Recorder", {}),
("NetworkApiPlugin", {}),
("Fixation_Detector", {}),
("Blink_Detection", {}),
("Accuracy_Visualizer", {}),
("Plugin_Manager", {}),
("System_Graphs", {}),
]
def consume_events_and_render_buffer():
gl_utils.glViewport(0, 0, *camera_render_size)
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.get_clipboard_string(main_window).decode()
except (AttributeError, glfw.GLFWError):
# clipboard is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.set_clipboard_string(main_window, user_input.clipboard)
for button, action, mods in user_input.buttons:
x, y = glfw.get_cursor_pos(main_window)
pos = gl_utils.window_coordinate_to_framebuffer_coordinate(
main_window, x, y, cached_scale=None)
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
glfw.swap_buffers(main_window)
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal camera_render_size
nonlocal content_scale
if w == 0 or h == 0:
return
# Always clear buffers on resize to make sure that there are no overlapping
# artifacts from previous frames.
gl_utils.glClear(GL_COLOR_BUFFER_BIT)
gl_utils.glClearColor(0, 0, 0, 1)
content_scale = gl_utils.get_content_scale(window)
framebuffer_scale = gl_utils.get_framebuffer_scale(window)
g_pool.gui.scale = content_scale
window_size = w, h
camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *camera_render_size)
# Minimum window size required, otherwise parts of the UI can cause openGL
# issues with permanent effects. Depends on the content scale, which can
# potentially be dynamically modified, so we re-adjust the size limits every
# time here.
min_size = int(2 * icon_bar_width * g_pool.gui.scale /
framebuffer_scale)
glfw.set_window_size_limits(
window,
min_size,
min_size,
glfw.DONT_CARE,
glfw.DONT_CARE,
)
# Needed, to update the window buffer while resizing
with gl_utils.current_context(main_window):
consume_events_and_render_buffer()
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = gl_utils.window_coordinate_to_framebuffer_coordinate(
window, x, y, cached_scale=None)
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, paths):
for plugin in g_pool.plugins:
if plugin.on_drop(paths):
break
tick = delta_t()
def get_dt():
return next(tick)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir, "user_settings_world"))
if parse_version(session_settings.get("version",
"0.0")) != g_pool.version:
logger.info(
"Session setting are from a different version of this app. I will not use those."
)
session_settings.clear()
g_pool.min_data_confidence = 0.6
g_pool.min_calibration_confidence = session_settings.get(
"min_calibration_confidence", 0.8)
g_pool.pupil_detection_enabled = bool(
session_settings.get("pupil_detection_enabled", True))
g_pool.active_gaze_mapping_plugin = None
g_pool.capture = None
audio.set_audio_mode(
session_settings.get("audio_mode", audio.get_default_audio_mode()))
def handle_notifications(noti):
subject = noti["subject"]
if subject == "pupil_detector.set_enabled":
g_pool.pupil_detection_enabled = noti["value"]
elif subject == "start_plugin":
try:
g_pool.plugins.add(g_pool.plugin_by_name[noti["name"]],
args=noti.get("args", {}))
except KeyError as err:
logger.error(f"Attempt to load unknown plugin: {err}")
elif subject == "stop_plugin":
for p in g_pool.plugins:
if p.class_name == noti["name"]:
p.alive = False
g_pool.plugins.clean()
elif subject == "eye_process.started":
noti = {
"subject": "pupil_detector.set_enabled",
"value": g_pool.pupil_detection_enabled,
}
ipc_pub.notify(noti)
elif subject == "set_min_calibration_confidence":
g_pool.min_calibration_confidence = noti["value"]
elif subject.startswith("meta.should_doc"):
ipc_pub.notify({
"subject": "meta.doc",
"actor": g_pool.app,
"doc": world.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
"subject": "meta.doc",
"actor": p.class_name,
"doc": p.on_notify.__doc__,
})
elif subject == "world_process.adapt_window_size":
set_window_size()
elif subject == "world_process.should_stop":
glfw.set_window_should_close(main_window, True)
width, height = session_settings.get("window_size",
(1280 + icon_bar_width, 720))
# window and gl setup
glfw.init()
glfw.window_hint(glfw.SCALE_TO_MONITOR, glfw.TRUE)
if hide_ui:
glfw.window_hint(glfw.VISIBLE, 0) # hide window
main_window = glfw.create_window(width, height,
"Pupil Capture - World", None, None)
window_position_manager = gl_utils.WindowPositionManager()
window_pos = window_position_manager.new_window_position(
window=main_window,
default_position=window_position_default,
previous_position=session_settings.get("window_position", None),
)
glfw.set_window_pos(main_window, window_pos[0], window_pos[1])
glfw.make_context_current(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def reset_restart():
logger.warning("Resetting all settings and restarting Capture.")
glfw.set_window_should_close(main_window, True)
ipc_pub.notify({"subject": "clear_settings_process.should_start"})
ipc_pub.notify({
"subject": "world_process.should_start",
"delay": 2.0
})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is opened, the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
# setup GUI
g_pool.gui = ui.UI()
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-400, 0),
size=(-icon_bar_width, 0),
header_pos="left")
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos="hidden")
g_pool.quickbar = ui.Stretching_Menu("Quick Bar", (0, 100),
(120, -100))
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
general_settings = ui.Growing_Menu("General", header_pos="headline")
def set_window_size():
# Get current capture frame size
f_width, f_height = g_pool.capture.frame_size
# Get current display scale factor
content_scale = gl_utils.get_content_scale(main_window)
framebuffer_scale = gl_utils.get_framebuffer_scale(main_window)
display_scale_factor = content_scale / framebuffer_scale
# Scale the capture frame size by display scale factor
f_width *= display_scale_factor
f_height *= display_scale_factor
# Increas the width to account for the added scaled icon bar width
f_width += icon_bar_width * display_scale_factor
# Set the newly calculated size (scaled capture frame size + scaled icon bar width)
glfw.set_window_size(main_window, int(f_width), int(f_height))
general_settings.append(ui.Button("Reset window size",
set_window_size))
general_settings.append(
ui.Selector(
"Audio mode",
None,
getter=audio.get_audio_mode,
setter=audio.set_audio_mode,
selection=audio.get_audio_mode_list(),
))
general_settings.append(
ui.Switch(
"pupil_detection_enabled",
label="Pupil detection",
getter=detection_enabled_getter,
setter=detection_enabled_setter,
))
general_settings.append(
ui.Switch(
"eye0_process",
label="Detect eye 0",
setter=lambda alive: start_stop_eye(0, alive),
getter=lambda: eye_procs_alive[0].value,
))
general_settings.append(
ui.Switch(
"eye1_process",
label="Detect eye 1",
setter=lambda alive: start_stop_eye(1, alive),
getter=lambda: eye_procs_alive[1].value,
))
general_settings.append(
ui.Info_Text("Capture Version: {}".format(g_pool.version)))
general_settings.append(
ui.Button("Restart with default settings", reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon(
"collapsed",
general_settings,
label=chr(0xE8B8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font="pupil_icons",
)
icon.tooltip = "General Settings"
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
loaded_plugins = session_settings.get("loaded_plugins",
default_plugins)
# Resolve the active calibration choreography plugin
loaded_plugins = patch_loaded_plugins_with_choreography_plugin(
loaded_plugins, app=g_pool.app)
session_settings["loaded_plugins"] = loaded_plugins
# plugins that are loaded based on user settings from previous session
g_pool.plugins = Plugin_List(g_pool, loaded_plugins)
if not g_pool.capture:
# Make sure we always have a capture running. Important if there was no
# capture stored in session settings.
g_pool.plugins.add(g_pool.plugin_by_name[default_capture_name],
default_capture_settings)
# Register callbacks main_window
glfw.set_framebuffer_size_callback(main_window, on_resize)
glfw.set_key_callback(main_window, on_window_key)
glfw.set_char_callback(main_window, on_window_char)
glfw.set_mouse_button_callback(main_window, on_window_mouse_button)
glfw.set_cursor_pos_callback(main_window, on_pos)
glfw.set_scroll_callback(main_window, on_scroll)
glfw.set_drop_callback(main_window, on_drop)
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
toggle_general_settings(True)
# now that we have a proper window we can load the last gui configuration
g_pool.gui.configuration = session_settings.get("ui_config", {})
# If previously selected plugin was not loaded this time, we will have an
# expanded menubar without any menu selected. We need to ensure the menubar is
# collapsed in this case.
if all(submenu.collapsed for submenu in g_pool.menubar.elements):
g_pool.menubar.collapsed = True
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
# trigger setup of window and gl sizes
g_pool.trigger_main_window_redraw = lambda: on_resize(
main_window, *glfw.get_framebuffer_size(main_window))
g_pool.trigger_main_window_redraw()
if session_settings.get("eye1_process_alive", True):
launch_eye_process(1, delay=0.6)
if session_settings.get("eye0_process_alive", True):
launch_eye_process(0, delay=0.3)
ipc_pub.notify({"subject": "world_process.started"})
logger.warning("Process started.")
if platform.system() == "Darwin":
# On macOS, calls to glfw.swap_buffers() deliberately take longer in case of
# occluded windows, based on the swap interval value. This causes an FPS drop
# and leads to problems when recording. To side-step this behaviour, the swap
# interval is set to zero.
#
# Read more about window occlusion on macOS here:
# https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/WorkWhenVisible.html
glfw.swap_interval(0)
# Event loop
while not glfw.window_should_close(
main_window) and not process_was_interrupted:
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
# a dictionary that allows plugins to post and read events
events = {}
# report time between now and the last loop interation
events["dt"] = get_dt()
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
# "blacklisted" events that were already sent
del events["pupil"]
del events["gaze"]
# delete if exists. More expensive than del, so only use it when key might not exist
events.pop("annotation", None)
# send new events to ipc:
if "frame" in events:
del events["frame"] # send explicitly with frame publisher
if "depth_frame" in events:
del events["depth_frame"]
if "audio_packets" in events:
del events["audio_packets"]
del events["dt"] # no need to send this
for data in events.values():
assert isinstance(data, (list, tuple))
for d in data:
ipc_pub.send(d)
glfw.make_context_current(main_window)
# render visual feedback from loaded plugins
glfw.poll_events()
if window_should_update() and gl_utils.is_window_visible(
main_window):
gl_utils.glViewport(0, 0, *camera_render_size)
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.get_clipboard_string(main_window).decode()
except (AttributeError, glfw.GLFWError):
# clipboard is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.set_clipboard_string(main_window,
user_input.clipboard)
for button, action, mods in user_input.buttons:
x, y = glfw.get_cursor_pos(main_window)
pos = gl_utils.window_coordinate_to_framebuffer_coordinate(
main_window, x, y, cached_scale=None)
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
glfw.swap_buffers(main_window)
session_settings["loaded_plugins"] = g_pool.plugins.get_initializers()
session_settings["ui_config"] = g_pool.gui.configuration
session_settings["version"] = str(g_pool.version)
session_settings["eye0_process_alive"] = eye_procs_alive[0].value
session_settings["eye1_process_alive"] = eye_procs_alive[1].value
session_settings[
"min_calibration_confidence"] = g_pool.min_calibration_confidence
session_settings[
"pupil_detection_enabled"] = g_pool.pupil_detection_enabled
session_settings["audio_mode"] = audio.get_audio_mode()
if not hide_ui:
glfw.restore_window(main_window) # need to do this for windows os
session_settings["window_position"] = glfw.get_window_pos(
main_window)
session_window_size = glfw.get_window_size(main_window)
if 0 not in session_window_size:
f_width, f_height = session_window_size
if platform.system() in ("Windows", "Linux"):
f_width, f_height = (
f_width / content_scale,
f_height / content_scale,
)
session_settings["window_size"] = int(f_width), int(f_height)
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.destroy_window(main_window)
glfw.terminate()
except Exception:
import traceback
trace = traceback.format_exc()
logger.error("Process Capture crashed with trace:\n{}".format(trace))
finally:
# shut down eye processes:
stop_eye_process(0)
stop_eye_process(1)
logger.info("Process shutting down.")
ipc_pub.notify({"subject": "world_process.stopped"})
sleep(1.0)
def init_gui(self, sidebar):
sorted_controls = [c for c in self.controls.itervalues()]
sorted_controls.sort(key=lambda c: c.order)
self.menu = ui.Growing_Menu(label='Camera Settings')
cameras = Camera_List()
camera_names = [c.name for c in cameras]
camera_ids = [c.src_id for c in cameras]
self.menu.append(
ui.Selector('src_id',
self,
selection=camera_ids,
labels=camera_names,
label='Capture Device',
setter=self.re_init_cam_by_src_id))
hardware_ts_switch = ui.Switch('hardware_timestamps',
None,
getter=lambda: False,
label='use hardware timestamps')
hardware_ts_switch.read_only = True
self.menu.append(hardware_ts_switch)
for control in sorted_controls:
name = control.pretty_name
c = None
if control.type == "bool":
c = ui.Switch('value',
control,
setter=control.set_val,
label=name)
elif control.type == 'int':
c = ui.Slider('value',
control,
min=control.min,
max=control.max,
step=control.step,
setter=control.set_val,
label=name)
elif control.type == "menu":
if control.menu is None:
selection = range(control.min, control.max + 1,
control.step)
labels = selection
else:
#this is currenlty not implemented
selection = [c.val for c in control.menu]
labels = [c.name for c in control.menu]
c = ui.Selector('value',
control,
selection=selection,
labels=labels,
label=name,
setter=control.set_val)
else:
pass
# print control.type
# if control.flags == "inactive":
# c.read_only = True
if c is not None:
self.menu.append(c)
self.menu.append(ui.Button("refresh",
self.controls.update_from_device))
self.menu.append(
ui.Button("load defaults", self.controls.load_defaults))
self.sidebar = sidebar
#add below geneal settings
self.sidebar.insert(1, self.menu)
def world(timebase, eyes_are_alive, ipc_pub_url, ipc_sub_url, ipc_push_url,
user_dir, version):
"""Reads world video and runs plugins.
Creates a window, gl context.
Grabs images from a capture.
Maps pupil to gaze data
Can run various plug-ins.
Reacts to notifications:
``set_detection_mapping_mode``
``eye_process.started``
``start_plugin``
Emits notifications:
``eye_process.should_start``
``eye_process.should_stop``
``set_detection_mapping_mode``
``world_process.started``
``world_process.stopped``
``recording.should_stop``: Emits on camera failure
``launcher_process.should_stop``
Emits data:
``gaze``: Gaze data from current gaze mapping plugin.``
``*``: any other plugin generated data in the events
that it not [dt,pupil,gaze].
"""
# We defer the imports because of multiprocessing.
# Otherwise the world process each process also loads the other imports.
# This is not harmful but unnecessary.
# general imports
import logging
# networking
import zmq
import zmq_tools
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=('notify', ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.INFO)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
# display
import glfw
from pyglui import ui, graph, cygl, __version__ as pyglui_version
assert pyglui_version >= '1.2'
from pyglui.cygl.utils import Named_Texture
import gl_utils
# monitoring
import psutil
# helpers/utils
from version_utils import VersionFormat
from file_methods import Persistent_Dict
from methods import normalize, denormalize, delta_t, get_system_info, timer
from uvc import get_time_monotonic
logger.info('Application Version: {}'.format(version))
logger.info('System Info: {}'.format(get_system_info()))
import audio
# trigger pupil detector cpp build:
import pupil_detectors
del pupil_detectors
# Plug-ins
from plugin import Plugin, Plugin_List, import_runtime_plugins
from calibration_routines import calibration_plugins, gaze_mapping_plugins
from fixation_detector import Fixation_Detector_3D
from recorder import Recorder
from display_recent_gaze import Display_Recent_Gaze
from time_sync import Time_Sync
from pupil_remote import Pupil_Remote
from pupil_groups import Pupil_Groups
from surface_tracker import Surface_Tracker
from log_display import Log_Display
from annotations import Annotation_Capture
from log_history import Log_History
from frame_publisher import Frame_Publisher
from blink_detection import Blink_Detection
from video_capture import source_classes, manager_classes
from pupil_data_relay import Pupil_Data_Relay
from remote_recorder import Remote_Recorder
# UI Platform tweaks
if platform.system() == 'Linux':
scroll_factor = 10.0
window_position_default = (0, 0)
elif platform.system() == 'Windows':
scroll_factor = 10.0
window_position_default = (8, 31)
else:
scroll_factor = 1.0
window_position_default = (0, 0)
# g_pool holds variables for this process they are accesible to all plugins
g_pool = Global_Container()
g_pool.app = 'capture'
g_pool.process = 'world'
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.timebase = timebase
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.eyes_are_alive = eyes_are_alive
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
# manage plugins
runtime_plugins = import_runtime_plugins(
os.path.join(g_pool.user_dir, 'plugins'))
user_launchable_plugins = [
Pupil_Groups, Frame_Publisher, Pupil_Remote, Time_Sync,
Surface_Tracker, Annotation_Capture, Log_History, Fixation_Detector_3D,
Blink_Detection, Remote_Recorder
] + runtime_plugins
system_plugins = [
Log_Display, Display_Recent_Gaze, Recorder, Pupil_Data_Relay
]
plugin_by_index = (system_plugins + user_launchable_plugins +
calibration_plugins + gaze_mapping_plugins +
manager_classes + source_classes)
name_by_index = [p.__name__ for p in plugin_by_index]
plugin_by_name = dict(zip(name_by_index, plugin_by_index))
default_capture_settings = {
'preferred_names': [
"Pupil Cam1 ID2", "Logitech Camera", "(046d:081d)", "C510", "B525",
"C525", "C615", "C920", "C930e"
],
'frame_size': (1280, 720),
'frame_rate':
30
}
default_plugins = [("UVC_Source", default_capture_settings),
('Pupil_Data_Relay', {}), ('UVC_Manager', {}),
('Log_Display', {}), ('Dummy_Gaze_Mapper', {}),
('Display_Recent_Gaze', {}),
('Screen_Marker_Calibration', {}), ('Recorder', {}),
('Pupil_Remote', {}), ('Fixation_Detector_3D', {})]
# Callback functions
def on_resize(window, w, h):
if gl_utils.is_window_visible(window):
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
graph.adjust_size(w, h)
gl_utils.adjust_gl_view(w, h)
for p in g_pool.plugins:
p.on_window_resize(window, w, h)
def on_iconify(window, iconified):
g_pool.iconified = iconified
def on_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_char(window, char):
g_pool.gui.update_char(char)
def on_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
pos = glfw.glfwGetCursorPos(window)
pos = normalize(pos, glfw.glfwGetWindowSize(main_window))
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_click(pos, button, action)
def on_pos(window, x, y):
hdpi_factor = float(
glfw.glfwGetFramebufferSize(window)[0] /
glfw.glfwGetWindowSize(window)[0])
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
tick = delta_t()
def get_dt():
return next(tick)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir, 'user_settings_world'))
if session_settings.get("version", VersionFormat('0.0')) < g_pool.version:
logger.info(
"Session setting are from older version of this app. I will not use those."
)
session_settings.clear()
g_pool.iconified = False
g_pool.detection_mapping_mode = session_settings.get(
'detection_mapping_mode', '3d')
g_pool.active_calibration_plugin = None
g_pool.active_gaze_mapping_plugin = None
g_pool.capture_manager = None
audio.audio_mode = session_settings.get('audio_mode',
audio.default_audio_mode)
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def set_scale(new_scale):
g_pool.gui.scale = new_scale
g_pool.gui.collect_menus()
def launch_eye_process(eye_id, delay=0):
n = {
'subject': 'eye_process.should_start.{}'.format(eye_id),
'eye_id': eye_id,
'delay': delay
}
ipc_pub.notify(n)
def stop_eye_process(eye_id):
n = {'subject': 'eye_process.should_stop', 'eye_id': eye_id}
ipc_pub.notify(n)
def start_stop_eye(eye_id, make_alive):
if make_alive:
launch_eye_process(eye_id)
else:
stop_eye_process(eye_id)
def set_detection_mapping_mode(new_mode):
n = {'subject': 'set_detection_mapping_mode', 'mode': new_mode}
ipc_pub.notify(n)
def handle_notifications(n):
subject = n['subject']
if subject == 'set_detection_mapping_mode':
if n['mode'] == '2d':
if ("Vector_Gaze_Mapper"
in g_pool.active_gaze_mapping_plugin.class_name):
logger.warning(
"The gaze mapper is not supported in 2d mode. Please recalibrate."
)
g_pool.plugins.add(plugin_by_name['Dummy_Gaze_Mapper'])
g_pool.detection_mapping_mode = n['mode']
elif subject == 'start_plugin':
g_pool.plugins.add(plugin_by_name[n['name']],
args=n.get('args', {}))
elif subject == 'eye_process.started':
n = {
'subject': 'set_detection_mapping_mode',
'mode': g_pool.detection_mapping_mode
}
ipc_pub.notify(n)
elif subject.startswith('meta.should_doc'):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': g_pool.app,
'doc': world.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': p.class_name,
'doc': p.on_notify.__doc__
})
# window and gl setup
glfw.glfwInit()
width, height = session_settings.get('window_size', (1280, 720))
main_window = glfw.glfwCreateWindow(width, height, "Pupil Capture - World")
window_pos = session_settings.get('window_position',
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
# setup GUI
g_pool.gui = ui.UI()
g_pool.gui.scale = session_settings.get('gui_scale', 1)
g_pool.sidebar = ui.Scrolling_Menu("Settings",
pos=(-350, 0),
size=(0, 0),
header_pos='left')
general_settings = ui.Growing_Menu('General')
general_settings.append(
ui.Slider('scale',
g_pool.gui,
setter=set_scale,
step=.05,
min=1.,
max=2.5,
label='Interface size'))
general_settings.append(
ui.Button(
'Reset window size', lambda: glfw.glfwSetWindowSize(
main_window, g_pool.capture.frame_size[0], g_pool.capture.
frame_size[1])))
general_settings.append(
ui.Selector('audio_mode', audio, selection=audio.audio_modes))
general_settings.append(
ui.Selector('detection_mapping_mode',
g_pool,
label='detection & mapping mode',
setter=set_detection_mapping_mode,
selection=['2d', '3d']))
general_settings.append(
ui.Switch('eye0_process',
label='Detect eye 0',
setter=lambda alive: start_stop_eye(0, alive),
getter=lambda: eyes_are_alive[0].value))
general_settings.append(
ui.Switch('eye1_process',
label='Detect eye 1',
setter=lambda alive: start_stop_eye(1, alive),
getter=lambda: eyes_are_alive[1].value))
selector_label = "Select to load"
labels = [p.__name__.replace('_', ' ') for p in user_launchable_plugins]
user_launchable_plugins.insert(0, selector_label)
labels.insert(0, selector_label)
general_settings.append(
ui.Selector('Open plugin',
selection=user_launchable_plugins,
labels=labels,
setter=open_plugin,
getter=lambda: selector_label))
general_settings.append(
ui.Info_Text('Capture Version: {}'.format(g_pool.version)))
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100), (120, -100))
g_pool.capture_source_menu = ui.Growing_Menu('Capture Source')
g_pool.capture_source_menu.collapsed = True
g_pool.calibration_menu = ui.Growing_Menu('Calibration')
g_pool.calibration_menu.collapsed = True
g_pool.capture_selector_menu = ui.Growing_Menu('Capture Selection')
g_pool.sidebar.append(general_settings)
g_pool.sidebar.append(g_pool.capture_selector_menu)
g_pool.sidebar.append(g_pool.capture_source_menu)
g_pool.sidebar.append(g_pool.calibration_menu)
g_pool.gui.append(g_pool.sidebar)
g_pool.gui.append(g_pool.quickbar)
# plugins that are loaded based on user settings from previous session
g_pool.plugins = Plugin_List(
g_pool, plugin_by_name,
session_settings.get('loaded_plugins', default_plugins))
#We add the calibration menu selector, after a calibration has been added:
g_pool.calibration_menu.insert(
0,
ui.Selector(
'active_calibration_plugin',
getter=lambda: g_pool.active_calibration_plugin.__class__,
selection=calibration_plugins,
labels=[p.__name__.replace('_', ' ') for p in calibration_plugins],
setter=open_plugin,
label='Method'))
#We add the capture selection menu, after a manager has been added:
g_pool.capture_selector_menu.insert(
0,
ui.Selector('capture_manager',
setter=open_plugin,
getter=lambda: g_pool.capture_manager.__class__,
selection=manager_classes,
labels=[b.gui_name for b in manager_classes],
label='Manager'))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetWindowIconifyCallback(main_window, on_iconify)
glfw.glfwSetKeyCallback(main_window, on_key)
glfw.glfwSetCharCallback(main_window, on_char)
glfw.glfwSetMouseButtonCallback(main_window, on_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
# trigger setup of window and gl sizes
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
# now the we have aproper window we can load the last gui configuration
g_pool.gui.configuration = session_settings.get('ui_config', {})
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
# set up performace graphs:
pid = os.getpid()
ps = psutil.Process(pid)
ts = g_pool.get_timestamp()
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 130)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = 'CPU %0.1f'
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 130)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f FPS"
pupil0_graph = graph.Bar_Graph(max_val=1.0)
pupil0_graph.pos = (260, 130)
pupil0_graph.update_rate = 5
pupil0_graph.label = "id0 conf: %0.2f"
pupil1_graph = graph.Bar_Graph(max_val=1.0)
pupil1_graph.pos = (380, 130)
pupil1_graph.update_rate = 5
pupil1_graph.label = "id1 conf: %0.2f"
pupil_graphs = pupil0_graph, pupil1_graph
if session_settings.get('eye1_process_alive', False):
launch_eye_process(1, delay=0.6)
if session_settings.get('eye0_process_alive', True):
launch_eye_process(0, delay=0.3)
ipc_pub.notify({'subject': 'world_process.started'})
logger.warning('Process started.')
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
#a dictionary that allows plugins to post and read events
events = {}
# report time between now and the last loop interation
events['dt'] = get_dt()
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
# update performace graphs
if 'frame' in events:
t = events["frame"].timestamp
dt, ts = t - ts, t
try:
fps_graph.add(1. / dt)
except ZeroDivisionError:
pass
for p in events["pupil_positions"]:
pupil_graphs[p['id']].add(p['confidence'])
cpu_graph.update()
# send new events to ipc:
del events['pupil_positions'] # already on the wire
del events['gaze_positions'] # sent earlier
if 'frame' in events:
del events['frame'] #send explicity with frame publisher
del events['dt'] #no need to send this
for topic, data in events.items():
assert (isinstance(data, (list, tuple)))
for d in data:
ipc_pub.send(topic, d)
glfw.glfwMakeContextCurrent(main_window)
# render visual feedback from loaded plugins
if window_should_update() and gl_utils.is_window_visible(main_window):
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
graph.push_view()
fps_graph.draw()
cpu_graph.draw()
pupil0_graph.draw()
pupil1_graph.draw()
graph.pop_view()
g_pool.gui.update()
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
glfw.glfwRestoreWindow(main_window) # need to do this for windows os
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['gui_scale'] = g_pool.gui.scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_size'] = glfw.glfwGetWindowSize(main_window)
session_settings['window_position'] = glfw.glfwGetWindowPos(main_window)
session_settings['version'] = g_pool.version
session_settings['eye0_process_alive'] = eyes_are_alive[0].value
session_settings['eye1_process_alive'] = eyes_are_alive[1].value
session_settings['detection_mapping_mode'] = g_pool.detection_mapping_mode
session_settings['audio_mode'] = audio.audio_mode
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
glfw.glfwTerminate()
g_pool.capture.deinit_gui()
# shut down eye processes:
stop_eye_process(0)
stop_eye_process(1)
logger.info("Process shutting down.")
ipc_pub.notify({'subject': 'world_process.stopped'})
# shut down launcher
n = {'subject': 'launcher_process.should_stop'}
ipc_pub.notify(n)
zmq_ctx.destroy()
def update_menu(self):
try:
del self.menu[:]
except AttributeError:
return
from pyglui import ui
if self.device is None:
self.menu.append(ui.Info_Text("Capture initialization failed."))
return
def align_and_restart(val):
self.align_streams = val
self.restart_device()
self.menu.append(ui.Switch("record_depth", self, label="Record Depth Stream"))
self.menu.append(ui.Switch("preview_depth", self, label="Preview Depth"))
self.menu.append(
ui.Switch(
"align_streams", self, label="Align Streams", setter=align_and_restart
)
)
def toggle_depth_display():
def on_depth_mouse_button(window, button, action, mods):
if button == glfw.GLFW_MOUSE_BUTTON_LEFT and action == glfw.GLFW_PRESS:
self.mouse_drag = True
if (
button == glfw.GLFW_MOUSE_BUTTON_LEFT
and action == glfw.GLFW_RELEASE
):
self.mouse_drag = False
if self.depth_window is None:
self.pitch = 0
self.yaw = 0
win_size = glfw.glfwGetWindowSize(self.g_pool.main_window)
self.depth_window = glfw.glfwCreateWindow(
win_size[0], win_size[1], "3D Point Cloud"
)
glfw.glfwSetMouseButtonCallback(
self.depth_window, on_depth_mouse_button
)
active_window = glfw.glfwGetCurrentContext()
glfw.glfwMakeContextCurrent(self.depth_window)
gl_utils.basic_gl_setup()
gl_utils.make_coord_system_norm_based()
# refresh speed settings
glfw.glfwSwapInterval(0)
glfw.glfwMakeContextCurrent(active_window)
native_presets = [
("None", None),
("Best Quality", rs_preset.RS_PRESET_BEST_QUALITY),
("Largest image", rs_preset.RS_PRESET_LARGEST_IMAGE),
("Highest framerate", rs_preset.RS_PRESET_HIGHEST_FRAMERATE),
]
def set_stream_preset(val):
if self.stream_preset != val:
self.stream_preset = val
self.restart_device()
self.menu.append(
ui.Selector(
"stream_preset",
self,
setter=set_stream_preset,
labels=[preset[0] for preset in native_presets],
selection=[preset[1] for preset in native_presets],
label="Stream preset",
)
)
color_sizes = sorted(
self._available_modes[rs_stream.RS_STREAM_COLOR], reverse=True
)
selector = ui.Selector(
"frame_size",
self,
# setter=,
selection=color_sizes,
label="Resolution" if self.align_streams else "Color Resolution",
)
selector.read_only = self.stream_preset is not None
self.menu.append(selector)
def color_fps_getter():
avail_fps = [
fps
for fps in self._available_modes[rs_stream.RS_STREAM_COLOR][
self.frame_size
]
if self.depth_frame_rate % fps == 0
]
return avail_fps, [str(fps) for fps in avail_fps]
selector = ui.Selector(
"frame_rate",
self,
# setter=,
selection_getter=color_fps_getter,
label="Color Frame Rate",
)
selector.read_only = self.stream_preset is not None
self.menu.append(selector)
if not self.align_streams:
depth_sizes = sorted(
self._available_modes[rs_stream.RS_STREAM_DEPTH], reverse=True
)
selector = ui.Selector(
"depth_frame_size",
self,
# setter=,
selection=depth_sizes,
label="Depth Resolution",
)
selector.read_only = self.stream_preset is not None
self.menu.append(selector)
def depth_fps_getter():
avail_fps = [
fps
for fps in self._available_modes[rs_stream.RS_STREAM_DEPTH][
self.depth_frame_size
]
if fps % self.frame_rate == 0
]
return avail_fps, [str(fps) for fps in avail_fps]
selector = ui.Selector(
"depth_frame_rate",
self,
selection_getter=depth_fps_getter,
label="Depth Frame Rate",
)
selector.read_only = self.stream_preset is not None
self.menu.append(selector)
def reset_options():
if self.device:
try:
self.device.reset_device_options_to_default(self.controls.keys())
except pyrs.RealsenseError as err:
logger.info("Resetting some device options failed")
logger.debug("Reason: {}".format(err))
finally:
self.controls.refresh()
self.menu.append(ui.Button("Point Cloud Window", toggle_depth_display))
sensor_control = ui.Growing_Menu(label="Sensor Settings")
sensor_control.append(
ui.Button("Reset device options to default", reset_options)
)
for ctrl in sorted(self.controls.values(), key=lambda x: x.range.option):
# sensor_control.append(ui.Info_Text(ctrl.description))
if (
ctrl.range.min == 0.0
and ctrl.range.max == 1.0
and ctrl.range.step == 1.0
):
sensor_control.append(
ui.Switch("value", ctrl, label=ctrl.label, off_val=0.0, on_val=1.0)
)
else:
sensor_control.append(
ui.Slider(
"value",
ctrl,
label=ctrl.label,
min=ctrl.range.min,
max=ctrl.range.max,
step=ctrl.range.step,
)
)
self.menu.append(sensor_control)
def _add_manager_buttons_to_menu(self):
self.menu.append(ui.Button("Cancel all", self.cancel_all_tasks))
self.menu.append(
ui.Button("Remove finished from list",
self.remove_completed_tasks))
def world(timebase, eyes_are_alive, ipc_pub_url, ipc_sub_url, ipc_push_url,
user_dir, version):
"""Reads world video and runs plugins.
Creates a window, gl context.
Grabs images from a capture.
Maps pupil to gaze data
Can run various plug-ins.
Reacts to notifications:
``set_detection_mapping_mode``
``eye_process.started``
``start_plugin``
Emits notifications:
``eye_process.should_start``
``eye_process.should_stop``
``set_detection_mapping_mode``
``world_process.started``
``world_process.stopped``
``recording.should_stop``: Emits on camera failure
``launcher_process.should_stop``
Emits data:
``gaze``: Gaze data from current gaze mapping plugin.``
``*``: any other plugin generated data in the events
that it not [dt,pupil,gaze].
"""
# We defer the imports because of multiprocessing.
# Otherwise the world process each process also loads the other imports.
# This is not harmful but unnecessary.
# general imports
from time import sleep
import logging
# networking
import zmq
import zmq_tools
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=("notify", ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
def launch_eye_process(eye_id, delay=0):
n = {
"subject": "eye_process.should_start.{}".format(eye_id),
"eye_id": eye_id,
"delay": delay,
}
ipc_pub.notify(n)
def stop_eye_process(eye_id):
n = {
"subject": "eye_process.should_stop.{}".format(eye_id),
"eye_id": eye_id,
"delay": 0.2,
}
ipc_pub.notify(n)
def start_stop_eye(eye_id, make_alive):
if make_alive:
launch_eye_process(eye_id)
else:
stop_eye_process(eye_id)
def set_detection_mapping_mode(new_mode):
n = {"subject": "set_detection_mapping_mode", "mode": new_mode}
ipc_pub.notify(n)
try:
# display
import glfw
from version_utils import VersionFormat
from pyglui import ui, cygl, __version__ as pyglui_version
assert VersionFormat(pyglui_version) >= VersionFormat(
"1.23"), "pyglui out of date, please upgrade to newest version"
from pyglui.cygl.utils import Named_Texture
import gl_utils
# helpers/utils
from file_methods import Persistent_Dict
from methods import normalize, denormalize, delta_t, get_system_info, timer
from uvc import get_time_monotonic
logger.info("Application Version: {}".format(version))
logger.info("System Info: {}".format(get_system_info()))
import audio
# trigger pupil detector cpp build:
import pupil_detectors
del pupil_detectors
# Plug-ins
from plugin import (
Plugin,
System_Plugin_Base,
Plugin_List,
import_runtime_plugins,
)
from plugin_manager import Plugin_Manager
from calibration_routines import (
calibration_plugins,
gaze_mapping_plugins,
Calibration_Plugin,
Gaze_Mapping_Plugin,
)
from fixation_detector import Fixation_Detector
from recorder import Recorder
from display_recent_gaze import Display_Recent_Gaze
from time_sync import Time_Sync
from pupil_remote import Pupil_Remote
from pupil_groups import Pupil_Groups
from surface_tracker import Surface_Tracker
from log_display import Log_Display
from annotations import Annotation_Capture
from log_history import Log_History
from frame_publisher import Frame_Publisher
from blink_detection import Blink_Detection
from video_capture import (
source_classes,
manager_classes,
Base_Manager,
Base_Source,
)
from pupil_data_relay import Pupil_Data_Relay
from remote_recorder import Remote_Recorder
from audio_capture import Audio_Capture
from accuracy_visualizer import Accuracy_Visualizer
# from saccade_detector import Saccade_Detector
from system_graphs import System_Graphs
from camera_intrinsics_estimation import Camera_Intrinsics_Estimation
from hololens_relay import Hololens_Relay
from background_helper import IPC_Logging_Task_Proxy
IPC_Logging_Task_Proxy.push_url = ipc_push_url
# UI Platform tweaks
if platform.system() == "Linux":
scroll_factor = 10.0
window_position_default = (30, 30)
elif platform.system() == "Windows":
scroll_factor = 10.0
window_position_default = (8, 90)
else:
scroll_factor = 1.0
window_position_default = (0, 0)
icon_bar_width = 50
window_size = None
camera_render_size = None
hdpi_factor = 1.0
# g_pool holds variables for this process they are accessible to all plugins
g_pool = Global_Container()
g_pool.app = "capture"
g_pool.process = "world"
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.timebase = timebase
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.eyes_are_alive = eyes_are_alive
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
# manage plugins
runtime_plugins = import_runtime_plugins(
os.path.join(g_pool.user_dir, "plugins"))
user_plugins = [
Audio_Capture,
Pupil_Groups,
Frame_Publisher,
Pupil_Remote,
Time_Sync,
Surface_Tracker,
Annotation_Capture,
Log_History,
Fixation_Detector,
Blink_Detection,
Remote_Recorder,
Accuracy_Visualizer,
Camera_Intrinsics_Estimation,
Hololens_Relay,
]
system_plugins = ([
Log_Display,
Display_Recent_Gaze,
Recorder,
Pupil_Data_Relay,
Plugin_Manager,
System_Graphs,
] + manager_classes + source_classes)
plugins = (system_plugins + user_plugins + runtime_plugins +
calibration_plugins + gaze_mapping_plugins)
user_plugins += [
p for p in runtime_plugins if not isinstance(
p,
(
Base_Manager,
Base_Source,
System_Plugin_Base,
Calibration_Plugin,
Gaze_Mapping_Plugin,
),
)
]
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
default_capture_settings = {
"preferred_names": [
"Pupil Cam1 ID2",
"Logitech Camera",
"(046d:081d)",
"C510",
"B525",
"C525",
"C615",
"C920",
"C930e",
],
"frame_size": (1280, 720),
"frame_rate":
30,
}
default_plugins = [
("UVC_Source", default_capture_settings),
("Pupil_Data_Relay", {}),
("UVC_Manager", {}),
("Log_Display", {}),
("Dummy_Gaze_Mapper", {}),
("Display_Recent_Gaze", {}),
("Screen_Marker_Calibration", {}),
("Recorder", {}),
("Pupil_Remote", {}),
("Accuracy_Visualizer", {}),
("Plugin_Manager", {}),
("System_Graphs", {}),
]
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal camera_render_size
nonlocal hdpi_factor
if w == 0 or h == 0:
return
hdpi_factor = glfw.getHDPIFactor(window)
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *camera_render_size)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
paths = [paths[x].decode("utf-8") for x in range(count)]
for p in g_pool.plugins:
p.on_drop(paths)
tick = delta_t()
def get_dt():
return next(tick)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir, "user_settings_world"))
if VersionFormat(session_settings.get("version",
"0.0")) != g_pool.version:
logger.info(
"Session setting are from a different version of this app. I will not use those."
)
session_settings.clear()
g_pool.min_calibration_confidence = session_settings.get(
"min_calibration_confidence", 0.8)
g_pool.detection_mapping_mode = session_settings.get(
"detection_mapping_mode", "3d")
g_pool.active_calibration_plugin = None
g_pool.active_gaze_mapping_plugin = None
g_pool.capture = None
audio.audio_mode = session_settings.get("audio_mode",
audio.default_audio_mode)
def handle_notifications(noti):
subject = noti["subject"]
if subject == "set_detection_mapping_mode":
if noti["mode"] == "2d":
if ("Vector_Gaze_Mapper"
in g_pool.active_gaze_mapping_plugin.class_name):
logger.warning(
"The gaze mapper is not supported in 2d mode. Please recalibrate."
)
g_pool.plugins.add(
g_pool.plugin_by_name["Dummy_Gaze_Mapper"])
g_pool.detection_mapping_mode = noti["mode"]
elif subject == "start_plugin":
g_pool.plugins.add(g_pool.plugin_by_name[noti["name"]],
args=noti.get("args", {}))
elif subject == "stop_plugin":
for p in g_pool.plugins:
if p.class_name == noti["name"]:
p.alive = False
g_pool.plugins.clean()
elif subject == "eye_process.started":
noti = {
"subject": "set_detection_mapping_mode",
"mode": g_pool.detection_mapping_mode,
}
ipc_pub.notify(noti)
elif subject == "set_min_calibration_confidence":
g_pool.min_calibration_confidence = noti["value"]
elif subject.startswith("meta.should_doc"):
ipc_pub.notify({
"subject": "meta.doc",
"actor": g_pool.app,
"doc": world.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
"subject": "meta.doc",
"actor": p.class_name,
"doc": p.on_notify.__doc__,
})
width, height = session_settings.get("window_size",
(1280 + icon_bar_width, 720))
# window and gl setup
glfw.glfwInit()
main_window = glfw.glfwCreateWindow(width, height,
"Pupil Capture - World")
window_pos = session_settings.get("window_position",
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
window_size = (
camera_render_size[0] +
int(icon_bar_width * g_pool.gui_user_scale * hdpi_factor),
glfw.glfwGetFramebufferSize(main_window)[1],
)
logger.warning(icon_bar_width * g_pool.gui_user_scale *
hdpi_factor)
glfw.glfwSetWindowSize(main_window, *window_size)
def reset_restart():
logger.warning("Resetting all settings and restarting Capture.")
glfw.glfwSetWindowShouldClose(main_window, True)
ipc_pub.notify({"subject": "clear_settings_process.should_start"})
ipc_pub.notify({
"subject": "world_process.should_start",
"delay": 2.0
})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is opened, the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
# setup GUI
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get("gui_scale", 1.0)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-400, 0),
size=(-icon_bar_width, 0),
header_pos="left")
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos="hidden")
g_pool.quickbar = ui.Stretching_Menu("Quick Bar", (0, 100),
(120, -100))
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
general_settings = ui.Growing_Menu("General", header_pos="headline")
general_settings.append(
ui.Selector(
"gui_user_scale",
g_pool,
setter=set_scale,
selection=[0.6, 0.8, 1.0, 1.2, 1.4],
label="Interface size",
))
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
general_settings.append(ui.Button("Reset window size",
set_window_size))
general_settings.append(
ui.Selector("audio_mode", audio, selection=audio.audio_modes))
general_settings.append(
ui.Selector(
"detection_mapping_mode",
g_pool,
label="detection & mapping mode",
setter=set_detection_mapping_mode,
selection=["disabled", "2d", "3d"],
))
general_settings.append(
ui.Switch(
"eye0_process",
label="Detect eye 0",
setter=lambda alive: start_stop_eye(0, alive),
getter=lambda: eyes_are_alive[0].value,
))
general_settings.append(
ui.Switch(
"eye1_process",
label="Detect eye 1",
setter=lambda alive: start_stop_eye(1, alive),
getter=lambda: eyes_are_alive[1].value,
))
general_settings.append(
ui.Info_Text("Capture Version: {}".format(g_pool.version)))
general_settings.append(
ui.Button("Restart with default settings", reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon(
"collapsed",
general_settings,
label=chr(0xE8B8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font="pupil_icons",
)
icon.tooltip = "General Settings"
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
# plugins that are loaded based on user settings from previous session
g_pool.plugins = Plugin_List(
g_pool, session_settings.get("loaded_plugins", default_plugins))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
toggle_general_settings(True)
# now that we have a proper window we can load the last gui configuration
g_pool.gui.configuration = session_settings.get("ui_config", {})
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
# trigger setup of window and gl sizes
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
if session_settings.get("eye1_process_alive", True):
launch_eye_process(1, delay=0.6)
if session_settings.get("eye0_process_alive", True):
launch_eye_process(0, delay=0.3)
ipc_pub.notify({"subject": "world_process.started"})
logger.warning("Process started.")
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
# a dictionary that allows plugins to post and read events
events = {}
# report time between now and the last loop interation
events["dt"] = get_dt()
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
# "blacklisted" events that were already sent
del events["pupil"]
del events["gaze"]
# delete if exists. More expensive than del, so only use it when key might not exist
events.pop("annotation", None)
# send new events to ipc:
if "frame" in events:
del events["frame"] # send explicitly with frame publisher
if "depth_frame" in events:
del events["depth_frame"]
if "audio_packets" in events:
del events["audio_packets"]
del events["dt"] # no need to send this
for data in events.values():
assert isinstance(data, (list, tuple))
for d in data:
ipc_pub.send(d)
glfw.glfwMakeContextCurrent(main_window)
# render visual feedback from loaded plugins
if window_should_update() and gl_utils.is_window_visible(
main_window):
gl_utils.glViewport(0, 0, *camera_render_size)
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.glfwGetClipboardString(
main_window).decode()
except AttributeError: # clipboard is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.glfwSetClipboardString(main_window,
user_input.clipboard.encode())
for button, action, mods in user_input.buttons:
x, y = glfw.glfwGetCursorPos(main_window)
pos = x * hdpi_factor, y * hdpi_factor
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_click(pos, button, action)
for key, scancode, action, mods in user_input.keys:
for p in g_pool.plugins:
p.on_key(key, scancode, action, mods)
for char_ in user_input.chars:
for p in g_pool.plugins:
p.on_char(char_)
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
glfw.glfwRestoreWindow(main_window) # need to do this for windows os
session_settings["loaded_plugins"] = g_pool.plugins.get_initializers()
session_settings["gui_scale"] = g_pool.gui_user_scale
session_settings["ui_config"] = g_pool.gui.configuration
session_settings["window_position"] = glfw.glfwGetWindowPos(
main_window)
session_settings["version"] = str(g_pool.version)
session_settings["eye0_process_alive"] = eyes_are_alive[0].value
session_settings["eye1_process_alive"] = eyes_are_alive[1].value
session_settings[
"min_calibration_confidence"] = g_pool.min_calibration_confidence
session_settings[
"detection_mapping_mode"] = g_pool.detection_mapping_mode
session_settings["audio_mode"] = audio.audio_mode
session_window_size = glfw.glfwGetWindowSize(main_window)
if 0 not in session_window_size:
session_settings["window_size"] = session_window_size
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
glfw.glfwTerminate()
except:
import traceback
trace = traceback.format_exc()
logger.error("Process Capture crashed with trace:\n{}".format(trace))
finally:
# shut down eye processes:
stop_eye_process(0)
stop_eye_process(1)
logger.info("Process shutting down.")
ipc_pub.notify({"subject": "world_process.stopped"})
sleep(1.0)
def world(timebase, eyes_are_alive, ipc_pub_url, ipc_sub_url, ipc_push_url,
user_dir, version):
"""Reads world video and runs plugins.
Creates a window, gl context.
Grabs images from a capture.
Maps pupil to gaze data
Can run various plug-ins.
Reacts to notifications:
``set_detection_mapping_mode``
``eye_process.started``
``start_plugin``
Emits notifications:
``eye_process.should_start``
``eye_process.should_stop``
``set_detection_mapping_mode``
``world_process.started``
``world_process.stopped``
``recording.should_stop``: Emits on camera failure
``launcher_process.should_stop``
Emits data:
``gaze``: Gaze data from current gaze mapping plugin.``
``*``: any other plugin generated data in the events
that it not [dt,pupil,gaze].
"""
# We defer the imports because of multiprocessing.
# Otherwise the world process each process also loads the other imports.
# This is not harmful but unnecessary.
# general imports
from time import sleep
import logging
# networking
import zmq
import zmq_tools
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=('notify', ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
# logger.setLevel(logging.DEBUG)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
def launch_eye_process(eye_id, delay=0):
n = {
'subject': 'eye_process.should_start.{}'.format(eye_id),
'eye_id': eye_id,
'delay': delay
}
ipc_pub.notify(n)
def stop_eye_process(eye_id):
n = {
'subject': 'eye_process.should_stop.{}'.format(eye_id),
'eye_id': eye_id,
'delay': 0.2
}
ipc_pub.notify(n)
def start_stop_eye(eye_id, make_alive):
if make_alive:
launch_eye_process(eye_id)
else:
stop_eye_process(eye_id)
def set_detection_mapping_mode(new_mode):
n = {'subject': 'set_detection_mapping_mode', 'mode': new_mode}
ipc_pub.notify(n)
try:
# display
import glfw
from version_utils import VersionFormat
from pyglui import ui, cygl, __version__ as pyglui_version
assert VersionFormat(pyglui_version) >= VersionFormat(
'1.9'), 'pyglui out of date, please upgrade to newest version'
from pyglui.cygl.utils import Named_Texture
import gl_utils
# helpers/utils
from file_methods import Persistent_Dict
from methods import normalize, denormalize, delta_t, get_system_info, timer
from uvc import get_time_monotonic
logger.info('Application Version: {}'.format(version))
logger.info('System Info: {}'.format(get_system_info()))
import audio
# trigger pupil detector cpp build:
import pupil_detectors
del pupil_detectors
# Plug-ins
from plugin import Plugin, System_Plugin_Base, Plugin_List, import_runtime_plugins
from plugin_manager import Plugin_Manager
from calibration_routines import calibration_plugins, gaze_mapping_plugins, Calibration_Plugin, Gaze_Mapping_Plugin
from fixation_detector import Fixation_Detector
from recorder import Recorder
from display_recent_gaze import Display_Recent_Gaze
from time_sync import Time_Sync
from pupil_remote import Pupil_Remote
from pupil_groups import Pupil_Groups
from surface_tracker import Surface_Tracker
from log_display import Log_Display
from annotations import Annotation_Capture
from log_history import Log_History
from frame_publisher import Frame_Publisher
from blink_detection import Blink_Detection
from video_capture import source_classes, manager_classes, Base_Manager, Base_Source
from pupil_data_relay import Pupil_Data_Relay
from remote_recorder import Remote_Recorder
from audio_capture import Audio_Capture
from accuracy_visualizer import Accuracy_Visualizer
from emse_numero_plugin import Emse_numero_plugin
# from saccade_detector import Saccade_Detector
from system_graphs import System_Graphs
from camera_intrinsics_estimation import Camera_Intrinsics_Estimation
# UI Platform tweaks
if platform.system() == 'Linux':
scroll_factor = 10.0
window_position_default = (30, 30)
elif platform.system() == 'Windows':
scroll_factor = 10.0
window_position_default = (8, 31)
else:
scroll_factor = 1.0
window_position_default = (0, 0)
icon_bar_width = 50
window_size = None
camera_render_size = None
hdpi_factor = 1.0
# g_pool holds variables for this process they are accesible to all plugins
g_pool = Global_Container()
g_pool.app = 'capture'
g_pool.process = 'world'
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.timebase = timebase
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.eyes_are_alive = eyes_are_alive
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
# manage plugins
runtime_plugins = import_runtime_plugins(
os.path.join(g_pool.user_dir, 'plugins'))
user_plugins = [
Audio_Capture, Pupil_Groups, Frame_Publisher, Pupil_Remote,
Time_Sync, Surface_Tracker, Annotation_Capture, Log_History,
Fixation_Detector, Blink_Detection, Remote_Recorder,
Accuracy_Visualizer, Camera_Intrinsics_Estimation,
Emse_numero_plugin
]
system_plugins = [
Log_Display, Display_Recent_Gaze, Recorder, Pupil_Data_Relay,
Plugin_Manager, System_Graphs
] + manager_classes + source_classes
plugins = system_plugins + user_plugins + runtime_plugins + calibration_plugins + gaze_mapping_plugins
user_plugins += [
p for p in runtime_plugins
if not isinstance(p, (Base_Manager, Base_Source,
System_Plugin_Base, Calibration_Plugin,
Gaze_Mapping_Plugin))
]
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
default_capture_settings = {
'preferred_names': [
"Pupil Cam1 ID2", "Logitech Camera", "(046d:081d)", "C510",
"B525", "C525", "C615", "C920", "C930e"
],
'frame_size': (1280, 720),
'frame_rate':
30
}
default_plugins = [("UVC_Source", default_capture_settings),
('Pupil_Data_Relay', {}), ('UVC_Manager', {}),
('Log_Display', {}), ('Dummy_Gaze_Mapper', {}),
('Display_Recent_Gaze', {}),
('Screen_Marker_Calibration', {}), ('Recorder', {}),
('Pupil_Remote', {}), ('Plugin_Manager', {}),
('System_Graphs', {})]
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal camera_render_size
nonlocal hdpi_factor
hdpi_factor = float(
glfw.glfwGetFramebufferSize(window)[0] /
glfw.glfwGetWindowSize(window)[0])
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *camera_render_size)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
paths = [paths[x].decode('utf-8') for x in range(count)]
for p in g_pool.plugins:
p.on_drop(paths)
tick = delta_t()
def get_dt():
return next(tick)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir, 'user_settings_world'))
if VersionFormat(session_settings.get("version",
'0.0')) != g_pool.version:
logger.info(
"Session setting are from a different version of this app. I will not use those."
)
session_settings.clear()
g_pool.detection_mapping_mode = session_settings.get(
'detection_mapping_mode', '3d')
g_pool.active_calibration_plugin = None
g_pool.active_gaze_mapping_plugin = None
g_pool.capture = None
audio.audio_mode = session_settings.get('audio_mode',
audio.default_audio_mode)
def handle_notifications(n):
subject = n['subject']
if subject == 'set_detection_mapping_mode':
if n['mode'] == '2d':
if ("Vector_Gaze_Mapper"
in g_pool.active_gaze_mapping_plugin.class_name):
logger.warning(
"The gaze mapper is not supported in 2d mode. Please recalibrate."
)
g_pool.plugins.add(
g_pool.plugin_by_name['Dummy_Gaze_Mapper'])
g_pool.detection_mapping_mode = n['mode']
elif subject == 'start_plugin':
g_pool.plugins.add(g_pool.plugin_by_name[n['name']],
args=n.get('args', {}))
elif subject == 'stop_plugin':
for p in g_pool.plugins:
if p.class_name == n['name']:
p.alive = False
g_pool.plugins.clean()
elif subject == 'eye_process.started':
n = {
'subject': 'set_detection_mapping_mode',
'mode': g_pool.detection_mapping_mode
}
ipc_pub.notify(n)
elif subject.startswith('meta.should_doc'):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': g_pool.app,
'doc': world.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': p.class_name,
'doc': p.on_notify.__doc__
})
# window and gl setup
glfw.glfwInit()
width, height = session_settings.get('window_size',
(1280 + icon_bar_width, 720))
main_window = glfw.glfwCreateWindow(width, height,
"Pupil Capture - World")
window_pos = session_settings.get('window_position',
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
window_size = camera_render_size[0] + \
int(icon_bar_width * g_pool.gui_user_scale * hdpi_factor), \
glfw.glfwGetFramebufferSize(main_window)[1]
logger.warning(icon_bar_width * g_pool.gui_user_scale *
hdpi_factor)
glfw.glfwSetWindowSize(main_window, *window_size)
def reset_restart():
logger.warning("Resetting all settings and restarting Capture.")
glfw.glfwSetWindowShouldClose(main_window, True)
ipc_pub.notify({'subject': 'clear_settings_process.should_start'})
ipc_pub.notify({
'subject': 'world_process.should_start',
'delay': 2.
})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
# setup GUI
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get('gui_scale', 1.)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-400, 0),
size=(-icon_bar_width, 0),
header_pos='left')
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos='hidden')
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100),
(120, -100))
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
general_settings = ui.Growing_Menu('General', header_pos='headline')
general_settings.append(
ui.Selector('gui_user_scale',
g_pool,
setter=set_scale,
selection=[.6, .8, 1., 1.2, 1.4],
label='Interface size'))
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
general_settings.append(ui.Button('Reset window size',
set_window_size))
general_settings.append(
ui.Selector('audio_mode', audio, selection=audio.audio_modes))
general_settings.append(
ui.Selector('detection_mapping_mode',
g_pool,
label='detection & mapping mode',
setter=set_detection_mapping_mode,
selection=['2d', '3d']))
general_settings.append(
ui.Switch('eye0_process',
label='Detect eye 0',
setter=lambda alive: start_stop_eye(0, alive),
getter=lambda: eyes_are_alive[0].value))
general_settings.append(
ui.Switch('eye1_process',
label='Detect eye 1',
setter=lambda alive: start_stop_eye(1, alive),
getter=lambda: eyes_are_alive[1].value))
general_settings.append(
ui.Info_Text('Capture Version: {}'.format(g_pool.version)))
general_settings.append(
ui.Button('Restart with default settings', reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon('collapsed',
general_settings,
label=chr(0xe8b8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font='pupil_icons')
icon.tooltip = 'General Settings'
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
# plugins that are loaded based on user settings from previous session
g_pool.plugins = Plugin_List(
g_pool, session_settings.get('loaded_plugins', default_plugins))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
toggle_general_settings(False)
# now the we have aproper window we can load the last gui configuration
g_pool.gui.configuration = session_settings.get('ui_config', {})
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
# trigger setup of window and gl sizes
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
if session_settings.get('eye1_process_alive', False):
launch_eye_process(1, delay=0.6)
if session_settings.get('eye0_process_alive', True):
launch_eye_process(0, delay=0.3)
ipc_pub.notify({'subject': 'world_process.started'})
logger.warning('Process started.')
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
#a dictionary that allows plugins to post and read events
events = {}
# report time between now and the last loop interation
events['dt'] = get_dt()
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
# send new events to ipc:
del events['pupil_positions'] # already on the wire
del events['gaze_positions'] # sent earlier
if 'frame' in events:
del events['frame'] # send explicity with frame publisher
if 'depth_frame' in events:
del events['depth_frame']
if 'audio_packets' in events:
del events['audio_packets']
del events['dt'] # no need to send this
for topic, data in events.items():
assert (isinstance(data, (list, tuple)))
for d in data:
ipc_pub.send(topic, d)
glfw.glfwMakeContextCurrent(main_window)
# render visual feedback from loaded plugins
if window_should_update() and gl_utils.is_window_visible(
main_window):
gl_utils.glViewport(0, 0, *camera_render_size)
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
unused_elements = g_pool.gui.update()
for button, action, mods in unused_elements.buttons:
pos = glfw.glfwGetCursorPos(main_window)
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_click(pos, button, action)
for key, scancode, action, mods in unused_elements.keys:
for p in g_pool.plugins:
p.on_key(key, scancode, action, mods)
for char_ in unused_elements.chars:
for p in g_pool.plugins:
p.on_char(char_)
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
glfw.glfwRestoreWindow(main_window) # need to do this for windows os
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['gui_scale'] = g_pool.gui_user_scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_size'] = glfw.glfwGetWindowSize(main_window)
session_settings['window_position'] = glfw.glfwGetWindowPos(
main_window)
session_settings['version'] = str(g_pool.version)
session_settings['eye0_process_alive'] = eyes_are_alive[0].value
session_settings['eye1_process_alive'] = eyes_are_alive[1].value
session_settings[
'detection_mapping_mode'] = g_pool.detection_mapping_mode
session_settings['audio_mode'] = audio.audio_mode
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
glfw.glfwTerminate()
except:
import traceback
trace = traceback.format_exc()
logger.error('Process Capture crashed with trace:\n{}'.format(trace))
finally:
# shut down eye processes:
stop_eye_process(0)
stop_eye_process(1)
logger.info("Process shutting down.")
ipc_pub.notify({'subject': 'world_process.stopped'})
sleep(1.0)
def player(rec_dir, ipc_pub_url, ipc_sub_url, ipc_push_url, user_dir,
app_version):
# general imports
from time import sleep
import logging
from glob import glob
from time import time, strftime, localtime
# networking
import zmq
import zmq_tools
import numpy as np
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=('notify', ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
try:
# imports
from file_methods import Persistent_Dict, next_export_sub_dir
# display
import glfw
# check versions for our own depedencies as they are fast-changing
from pyglui import __version__ as pyglui_version
from pyglui import ui, cygl
from pyglui.cygl.utils import Named_Texture, RGBA
import gl_utils
# capture
from video_capture import init_playback_source
# helpers/utils
from version_utils import VersionFormat
from methods import normalize, denormalize, delta_t, get_system_info
import player_methods as pm
from csv_utils import write_key_value_file
# Plug-ins
from plugin import Plugin, Plugin_List, import_runtime_plugins
from plugin_manager import Plugin_Manager
from vis_circle import Vis_Circle
from vis_cross import Vis_Cross
from vis_polyline import Vis_Polyline
from vis_light_points import Vis_Light_Points
from vis_watermark import Vis_Watermark
from vis_fixation import Vis_Fixation
# from vis_scan_path import Vis_Scan_Path
from vis_eye_video_overlay import Vis_Eye_Video_Overlay
from seek_control import Seek_Control
from video_export_launcher import Video_Export_Launcher
from offline_surface_tracker import Offline_Surface_Tracker
# from marker_auto_trim_marks import Marker_Auto_Trim_Marks
from fixation_detector import Offline_Fixation_Detector
from batch_exporter import Batch_Exporter, Batch_Export
from log_display import Log_Display
from annotations import Annotation_Player
from raw_data_exporter import Raw_Data_Exporter
from log_history import Log_History
from pupil_producers import Pupil_From_Recording, Offline_Pupil_Detection
from gaze_producers import Gaze_From_Recording, Offline_Calibration
from system_graphs import System_Graphs
from system_timelines import System_Timelines
from blink_detection import Offline_Blink_Detection
from audio_playback import Audio_Playback
from imotions_exporter import iMotions_Exporter
from eye_video_exporter import Eye_Video_Exporter
assert VersionFormat(pyglui_version) >= VersionFormat(
'1.23'), 'pyglui out of date, please upgrade to newest version'
runtime_plugins = import_runtime_plugins(
os.path.join(user_dir, 'plugins'))
system_plugins = [
Log_Display, Seek_Control, Plugin_Manager, System_Graphs,
Batch_Export, System_Timelines, Audio_Playback
]
user_plugins = [
Vis_Circle,
Vis_Fixation,
Vis_Polyline,
Vis_Light_Points,
Vis_Cross,
Vis_Watermark,
Vis_Eye_Video_Overlay,
# Vis_Scan_Path,
Offline_Fixation_Detector,
Offline_Blink_Detection,
Batch_Exporter,
Video_Export_Launcher,
Offline_Surface_Tracker,
Raw_Data_Exporter,
Annotation_Player,
Log_History,
Pupil_From_Recording,
Offline_Pupil_Detection,
Gaze_From_Recording,
iMotions_Exporter,
Eye_Video_Exporter,
Offline_Calibration
] + runtime_plugins
plugins = system_plugins + user_plugins
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal hdpi_factor
if w == 0 or h == 0:
return
hdpi_factor = glfw.getHDPIFactor(window)
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
g_pool.camera_render_size = w - int(
icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *g_pool.camera_render_size)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, g_pool.camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
for x in range(count):
new_rec_dir = paths[x].decode('utf-8')
if pm.is_pupil_rec_dir(new_rec_dir):
logger.debug(
"Starting new session with '{}'".format(new_rec_dir))
ipc_pub.notify({
"subject": "player_drop_process.should_start",
"rec_dir": new_rec_dir
})
glfw.glfwSetWindowShouldClose(window, True)
else:
logger.error("'{}' is not a valid pupil recording".format(
new_rec_dir))
tick = delta_t()
def get_dt():
return next(tick)
meta_info = pm.load_meta_info(rec_dir)
# log info about Pupil Platform and Platform in player.log
logger.info('Application Version: {}'.format(app_version))
logger.info('System Info: {}'.format(get_system_info()))
icon_bar_width = 50
window_size = None
hdpi_factor = 1.0
# create container for globally scoped vars
g_pool = Global_Container()
g_pool.app = 'player'
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
g_pool.camera_render_size = None
valid_ext = ('.mp4', '.mkv', '.avi', '.h264', '.mjpeg', '.fake')
video_path = [
f for f in glob(os.path.join(rec_dir, "world.*"))
if os.path.splitext(f)[1] in valid_ext
][0]
init_playback_source(g_pool,
timing='external',
source_path=video_path,
buffered_decoding=True)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(user_dir, "user_settings_player"))
if VersionFormat(session_settings.get("version",
'0.0')) != app_version:
logger.info(
"Session setting are a different version of this app. I will not use those."
)
session_settings.clear()
width, height = g_pool.capture.frame_size
width += icon_bar_width
width, height = session_settings.get('window_size', (width, height))
window_pos = session_settings.get('window_position',
window_position_default)
window_name = "Pupil Player: {} - {}".format(
meta_info["Recording Name"],
os.path.split(rec_dir)[-1])
glfw.glfwInit()
main_window = glfw.glfwCreateWindow(width, height, window_name, None,
None)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
window_size = (
g_pool.camera_render_size[0] +
int(icon_bar_width * g_pool.gui_user_scale * hdpi_factor),
glfw.glfwGetFramebufferSize(main_window)[1])
logger.warning(icon_bar_width * g_pool.gui_user_scale *
hdpi_factor)
glfw.glfwSetWindowSize(main_window, *window_size)
# load pupil_positions, gaze_positions
g_pool.binocular = meta_info.get('Eye Mode',
'monocular') == 'binocular'
g_pool.version = app_version
g_pool.timestamps = g_pool.capture.timestamps
g_pool.get_timestamp = lambda: 0.
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.meta_info = meta_info
g_pool.min_data_confidence = session_settings.get(
'min_data_confidence', 0.6)
g_pool.min_calibration_confidence = session_settings.get(
'min_calibration_confidence', 0.8)
# populated by producers
g_pool.pupil_positions = pm.Bisector()
g_pool.pupil_positions_by_id = (pm.Bisector(), pm.Bisector())
g_pool.gaze_positions = pm.Bisector()
g_pool.fixations = pm.Affiliator()
def set_data_confidence(new_confidence):
g_pool.min_data_confidence = new_confidence
notification = {'subject': 'min_data_confidence_changed'}
notification['_notify_time_'] = time() + .8
g_pool.ipc_pub.notify(notification)
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def purge_plugins():
for p in g_pool.plugins:
if p.__class__ in user_plugins:
p.alive = False
g_pool.plugins.clean()
def do_export(_):
left_idx = g_pool.seek_control.trim_left
right_idx = g_pool.seek_control.trim_right
export_range = left_idx, right_idx + 1 # exclusive range.stop
export_dir = os.path.join(g_pool.rec_dir, 'exports')
export_dir = next_export_sub_dir(export_dir)
os.makedirs(export_dir)
logger.info('Created export dir at "{}"'.format(export_dir))
export_info = {
'Player Software Version':
str(g_pool.version),
'Data Format Version':
meta_info['Data Format Version'],
'Export Date':
strftime("%d.%m.%Y", localtime()),
'Export Time':
strftime("%H:%M:%S", localtime()),
'Frame Index Range:':
g_pool.seek_control.get_frame_index_trim_range_string(),
'Relative Time Range':
g_pool.seek_control.get_rel_time_trim_range_string(),
'Absolute Time Range':
g_pool.seek_control.get_abs_time_trim_range_string()
}
with open(os.path.join(export_dir, 'export_info.csv'), 'w') as csv:
write_key_value_file(csv, export_info)
notification = {
'subject': 'should_export',
'range': export_range,
'export_dir': export_dir
}
g_pool.ipc_pub.notify(notification)
def reset_restart():
logger.warning("Resetting all settings and restarting Player.")
glfw.glfwSetWindowShouldClose(main_window, True)
ipc_pub.notify({'subject': 'clear_settings_process.should_start'})
ipc_pub.notify({
'subject': 'player_process.should_start',
'rec_dir': rec_dir,
'delay': 2.
})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get('gui_scale', 1.)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-500, 0),
size=(-icon_bar_width, 0),
header_pos='left')
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos='hidden')
g_pool.timelines = ui.Container((0, 0), (0, 0), (0, 0))
g_pool.timelines.horizontal_constraint = g_pool.menubar
g_pool.user_timelines = ui.Timeline_Menu('User Timelines',
pos=(0., -150.),
size=(0., 0.),
header_pos='headline')
g_pool.user_timelines.color = RGBA(a=0.)
g_pool.user_timelines.collapsed = True
# add container that constaints itself to the seekbar height
vert_constr = ui.Container((0, 0), (0, -50.), (0, 0))
vert_constr.append(g_pool.user_timelines)
g_pool.timelines.append(vert_constr)
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
general_settings = ui.Growing_Menu('General', header_pos='headline')
general_settings.append(ui.Button('Reset window size',
set_window_size))
general_settings.append(
ui.Selector('gui_user_scale',
g_pool,
setter=set_scale,
selection=[.8, .9, 1., 1.1, 1.2] +
list(np.arange(1.5, 5.1, .5)),
label='Interface Size'))
general_settings.append(
ui.Info_Text('Player Version: {}'.format(g_pool.version)))
general_settings.append(
ui.Info_Text('Capture Version: {}'.format(
meta_info['Capture Software Version'])))
general_settings.append(
ui.Info_Text('Data Format Version: {}'.format(
meta_info['Data Format Version'])))
general_settings.append(
ui.Info_Text(
'High level data, e.g. fixations, or visualizations only consider gaze data that has an equal or higher confidence than the minimum data confidence.'
))
general_settings.append(
ui.Slider('min_data_confidence',
g_pool,
setter=set_data_confidence,
step=.05,
min=0.0,
max=1.0,
label='Minimum data confidence'))
general_settings.append(
ui.Button('Restart with default settings', reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon('collapsed',
general_settings,
label=chr(0xe8b8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font='pupil_icons')
icon.tooltip = 'General Settings'
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100),
(100, -100))
g_pool.export_button = ui.Thumb('export',
label=chr(0xe2c5),
getter=lambda: False,
setter=do_export,
hotkey='e',
label_font='pupil_icons')
g_pool.quickbar.extend([g_pool.export_button])
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.timelines)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
# we always load these plugins
default_plugins = [('Plugin_Manager', {}), ('Seek_Control', {}),
('Log_Display', {}), ('Raw_Data_Exporter', {}),
('Vis_Polyline', {}), ('Vis_Circle', {}),
('System_Graphs', {}), ('System_Timelines', {}),
('Video_Export_Launcher', {}),
('Pupil_From_Recording', {}),
('Gaze_From_Recording', {}), ('Audio_Playback', {})]
g_pool.plugins = Plugin_List(
g_pool, session_settings.get('loaded_plugins', default_plugins))
# Manually add g_pool.capture to the plugin list
g_pool.plugins._plugins.append(g_pool.capture)
g_pool.plugins._plugins.sort(key=lambda p: p.order)
g_pool.capture.init_ui()
general_settings.insert(
-1,
ui.Text_Input(
'rel_time_trim_section',
getter=g_pool.seek_control.get_rel_time_trim_range_string,
setter=g_pool.seek_control.set_rel_time_trim_range_string,
label='Relative time range to export'))
general_settings.insert(
-1,
ui.Text_Input(
'frame_idx_trim_section',
getter=g_pool.seek_control.get_frame_index_trim_range_string,
setter=g_pool.seek_control.set_frame_index_trim_range_string,
label='Frame index range to export'))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
toggle_general_settings(True)
g_pool.gui.configuration = session_settings.get('ui_config', {})
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
# trigger on_resize
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
def handle_notifications(n):
subject = n['subject']
if subject == 'start_plugin':
g_pool.plugins.add(g_pool.plugin_by_name[n['name']],
args=n.get('args', {}))
elif subject.startswith('meta.should_doc'):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': g_pool.app,
'doc': player.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
'subject': 'meta.doc',
'actor': p.class_name,
'doc': p.on_notify.__doc__
})
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
events = {}
# report time between now and the last loop interation
events['dt'] = get_dt()
# pupil and gaze positions are added by their respective producer plugins
events['pupil'] = []
events['gaze'] = []
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
glfw.glfwMakeContextCurrent(main_window)
# render visual feedback from loaded plugins
if gl_utils.is_window_visible(main_window):
gl_utils.glViewport(0, 0, *g_pool.camera_render_size)
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.glfwGetClipboardString(
main_window).decode()
except AttributeError: # clipbaord is None, might happen on startup
clipboard = ''
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard and user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.glfwSetClipboardString(main_window,
user_input.clipboard.encode())
for b in user_input.buttons:
button, action, mods = b
x, y = glfw.glfwGetCursorPos(main_window)
pos = x * hdpi_factor, y * hdpi_factor
pos = normalize(pos, g_pool.camera_render_size)
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_click(pos, button, action)
for key, scancode, action, mods in user_input.keys:
for p in g_pool.plugins:
p.on_key(key, scancode, action, mods)
for char_ in user_input.chars:
for p in g_pool.plugins:
p.on_char(char_)
# present frames at appropriate speed
g_pool.seek_control.wait(events['frame'].timestamp)
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['min_data_confidence'] = g_pool.min_data_confidence
session_settings[
'min_calibration_confidence'] = g_pool.min_calibration_confidence
session_settings['gui_scale'] = g_pool.gui_user_scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_position'] = glfw.glfwGetWindowPos(
main_window)
session_settings['version'] = str(g_pool.version)
session_window_size = glfw.glfwGetWindowSize(main_window)
if 0 not in session_window_size:
session_settings['window_size'] = session_window_size
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
except:
import traceback
trace = traceback.format_exc()
logger.error('Process Player crashed with trace:\n{}'.format(trace))
finally:
logger.info("Process shutting down.")
ipc_pub.notify({'subject': 'player_process.stopped'})
sleep(1.0)
def _create_delete_button(self):
return ui.Button(label=self.delete_button_label,
function=self._on_click_delete)
def init_gui(self):
self.menu = ui.Scrolling_Menu(self.menu_title())
self.g_pool.gui.append(self.menu)
def set_h_fov(new_fov):
self.h_fov = new_fov
self.pix_per_degree = float(
self.g_pool.capture.frame_size[0]) / new_fov
self.notify_all({
'subject': 'fixations_should_recalculate',
'delay': 1.
})
def set_v_fov(new_fov):
self.v_fov = new_fov
self.pix_per_degree = float(
self.g_pool.capture.frame_size[1]) / new_fov
self.notify_all({
'subject': 'fixations_should_recalculate',
'delay': 1.
})
def set_duration(new_value):
self.min_duration = new_value
self.notify_all({
'subject': 'fixations_should_recalculate',
'delay': 1.
})
def set_dispersion(new_value):
self.max_dispersion = new_value
self.notify_all({
'subject': 'fixations_should_recalculate',
'delay': 1.
})
def jump_next_fixation(_):
ts = self.last_frame_ts
for f in self.fixations:
if f['timestamp'] > ts:
self.g_pool.capture.seek_to_frame(f['mid_frame_index'])
self.g_pool.new_seek = True
return
logger.error('could not seek to next fixation.')
self.menu.append(ui.Button('Close', self.close))
self.menu.append(
ui.Info_Text(
'This plugin detects fixations based on a dispersion threshold in terms of degrees of visual angle. It also uses a min duration threshold.'
))
self.menu.append(
ui.Info_Text(
"Press the export button or type 'e' to start the export."))
self.menu.append(
ui.Slider('min_duration',
self,
min=0.0,
step=0.05,
max=1.0,
label='Duration threshold',
setter=set_duration))
self.menu.append(
ui.Slider('max_dispersion',
self,
min=self.dispersion_slider_min,
step=self.dispersion_slider_stp,
max=self.dispersion_slider_max,
label='Dispersion threshold',
setter=set_dispersion))
self.menu.append(
ui.Switch('show_fixations', self, label='Show fixations'))
self.menu.append(
ui.Slider('h_fov',
self,
min=5,
step=1,
max=180,
label='Horizontal FOV of scene camera',
setter=set_h_fov))
self.menu.append(
ui.Slider('v_fov',
self,
min=5,
step=1,
max=180,
label='Vertical FOV of scene camera',
setter=set_v_fov))
self.add_button = ui.Thumb('jump_next_fixation',
setter=jump_next_fixation,
getter=lambda: False,
label=chr(0xf051),
hotkey='f',
label_font='fontawesome',
label_offset_x=0,
label_offset_y=2,
label_offset_size=-24)
self.add_button.status_text = 'Next Fixation'
self.g_pool.quickbar.append(self.add_button)
def player(rec_dir, ipc_pub_url, ipc_sub_url, ipc_push_url, user_dir,
app_version):
# general imports
from time import sleep
import logging
from glob import glob
from time import time, strftime, localtime
# networking
import zmq
import zmq_tools
import numpy as np
# zmq ipc setup
zmq_ctx = zmq.Context()
ipc_pub = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=("notify", ))
# log setup
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
try:
from background_helper import IPC_Logging_Task_Proxy
IPC_Logging_Task_Proxy.push_url = ipc_push_url
from tasklib.background.patches import IPCLoggingPatch
IPCLoggingPatch.ipc_push_url = ipc_push_url
# imports
from file_methods import Persistent_Dict, next_export_sub_dir
# display
import glfw
# check versions for our own depedencies as they are fast-changing
from pyglui import __version__ as pyglui_version
from pyglui import ui, cygl
from pyglui.cygl.utils import Named_Texture, RGBA
import gl_utils
# capture
from video_capture import File_Source
# helpers/utils
from version_utils import VersionFormat
from methods import normalize, denormalize, delta_t, get_system_info
import player_methods as pm
from csv_utils import write_key_value_file
# Plug-ins
from plugin import Plugin, Plugin_List, import_runtime_plugins
from plugin_manager import Plugin_Manager
from vis_circle import Vis_Circle
from vis_cross import Vis_Cross
from vis_polyline import Vis_Polyline
from vis_light_points import Vis_Light_Points
from vis_watermark import Vis_Watermark
from vis_fixation import Vis_Fixation
# from vis_scan_path import Vis_Scan_Path
from seek_control import Seek_Control
from surface_tracker import Surface_Tracker_Offline
# from marker_auto_trim_marks import Marker_Auto_Trim_Marks
from fixation_detector import Offline_Fixation_Detector
from eye_movement import Offline_Eye_Movement_Detector
from log_display import Log_Display
from annotations import Annotation_Player
from raw_data_exporter import Raw_Data_Exporter
from log_history import Log_History
from pupil_producers import Pupil_From_Recording, Offline_Pupil_Detection
from gaze_producer.gaze_from_recording import GazeFromRecording
from gaze_producer.gaze_from_offline_calibration import (
GazeFromOfflineCalibration, )
from system_graphs import System_Graphs
from system_timelines import System_Timelines
from blink_detection import Offline_Blink_Detection
from audio_playback import Audio_Playback
from video_export.plugins.imotions_exporter import iMotions_Exporter
from video_export.plugins.eye_video_exporter import Eye_Video_Exporter
from video_export.plugins.world_video_exporter import World_Video_Exporter
from head_pose_tracker.offline_head_pose_tracker import Offline_Head_Pose_Tracker
from video_capture import File_Source
from video_overlay.plugins import Video_Overlay, Eye_Overlay
assert VersionFormat(pyglui_version) >= VersionFormat(
"1.24"), "pyglui out of date, please upgrade to newest version"
runtime_plugins = import_runtime_plugins(
os.path.join(user_dir, "plugins"))
system_plugins = [
Log_Display,
Seek_Control,
Plugin_Manager,
System_Graphs,
System_Timelines,
Audio_Playback,
]
user_plugins = [
Vis_Circle,
Vis_Fixation,
Vis_Polyline,
Vis_Light_Points,
Vis_Cross,
Vis_Watermark,
Eye_Overlay,
Video_Overlay,
# Vis_Scan_Path,
Offline_Fixation_Detector,
Offline_Eye_Movement_Detector,
Offline_Blink_Detection,
Surface_Tracker_Offline,
Raw_Data_Exporter,
Annotation_Player,
Log_History,
Pupil_From_Recording,
Offline_Pupil_Detection,
GazeFromRecording,
GazeFromOfflineCalibration,
World_Video_Exporter,
iMotions_Exporter,
Eye_Video_Exporter,
Offline_Head_Pose_Tracker,
] + runtime_plugins
plugins = system_plugins + user_plugins
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal hdpi_factor
if w == 0 or h == 0:
return
hdpi_factor = glfw.getHDPIFactor(window)
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
g_pool.camera_render_size = w - int(
icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(*window_size)
g_pool.gui.collect_menus()
for p in g_pool.plugins:
p.on_window_resize(window, *g_pool.camera_render_size)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
pos = x, y
pos = normalize(pos, g_pool.camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
for p in g_pool.plugins:
p.on_pos(pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
paths = [paths[x].decode("utf-8") for x in range(count)]
for path in paths:
if pm.is_pupil_rec_dir(path):
_restart_with_recording(path)
return
for plugin in g_pool.plugins:
if plugin.on_drop(paths):
break
def _restart_with_recording(rec_dir):
logger.debug("Starting new session with '{}'".format(rec_dir))
ipc_pub.notify({
"subject": "player_drop_process.should_start",
"rec_dir": rec_dir
})
glfw.glfwSetWindowShouldClose(g_pool.main_window, True)
tick = delta_t()
def get_dt():
return next(tick)
meta_info = pm.load_meta_info(rec_dir)
# log info about Pupil Platform and Platform in player.log
logger.info("Application Version: {}".format(app_version))
logger.info("System Info: {}".format(get_system_info()))
icon_bar_width = 50
window_size = None
hdpi_factor = 1.0
# create container for globally scoped vars
g_pool = SimpleNamespace()
g_pool.app = "player"
g_pool.zmq_ctx = zmq_ctx
g_pool.ipc_pub = ipc_pub
g_pool.ipc_pub_url = ipc_pub_url
g_pool.ipc_sub_url = ipc_sub_url
g_pool.ipc_push_url = ipc_push_url
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
g_pool.camera_render_size = None
valid_ext = (".mp4", ".mkv", ".avi", ".h264", ".mjpeg", ".fake")
video_path = [
f for f in glob(os.path.join(rec_dir, "world.*"))
if os.path.splitext(f)[1] in valid_ext
][0]
File_Source(
g_pool,
timing="external",
source_path=video_path,
buffered_decoding=True,
fill_gaps=True,
)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(user_dir, "user_settings_player"))
if VersionFormat(session_settings.get("version",
"0.0")) != app_version:
logger.info(
"Session setting are a different version of this app. I will not use those."
)
session_settings.clear()
width, height = g_pool.capture.frame_size
width += icon_bar_width
width, height = session_settings.get("window_size", (width, height))
window_pos = session_settings.get("window_position",
window_position_default)
window_name = "Pupil Player: {} - {}".format(
meta_info["Recording Name"],
os.path.split(rec_dir)[-1])
glfw.glfwInit()
main_window = glfw.glfwCreateWindow(width, height, window_name, None,
None)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
window_size = (
g_pool.camera_render_size[0] +
int(icon_bar_width * g_pool.gui_user_scale * hdpi_factor),
glfw.glfwGetFramebufferSize(main_window)[1],
)
logger.warning(icon_bar_width * g_pool.gui_user_scale *
hdpi_factor)
glfw.glfwSetWindowSize(main_window, *window_size)
# load pupil_positions, gaze_positions
g_pool.binocular = meta_info.get("Eye Mode",
"monocular") == "binocular"
g_pool.version = app_version
g_pool.timestamps = g_pool.capture.timestamps
g_pool.get_timestamp = lambda: 0.0
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.meta_info = meta_info
g_pool.min_data_confidence = session_settings.get(
"min_data_confidence", MIN_DATA_CONFIDENCE_DEFAULT)
g_pool.min_calibration_confidence = session_settings.get(
"min_calibration_confidence", MIN_CALIBRATION_CONFIDENCE_DEFAULT)
# populated by producers
g_pool.pupil_positions = pm.Bisector()
g_pool.pupil_positions_by_id = (pm.Bisector(), pm.Bisector())
g_pool.gaze_positions = pm.Bisector()
g_pool.fixations = pm.Affiliator()
g_pool.eye_movements = pm.Affiliator()
def set_data_confidence(new_confidence):
g_pool.min_data_confidence = new_confidence
notification = {"subject": "min_data_confidence_changed"}
notification["_notify_time_"] = time() + 0.8
g_pool.ipc_pub.notify(notification)
def do_export(_):
left_idx = g_pool.seek_control.trim_left
right_idx = g_pool.seek_control.trim_right
export_range = left_idx, right_idx + 1 # exclusive range.stop
export_ts_window = pm.exact_window(g_pool.timestamps,
(left_idx, right_idx))
export_dir = os.path.join(g_pool.rec_dir, "exports")
export_dir = next_export_sub_dir(export_dir)
os.makedirs(export_dir)
logger.info('Created export dir at "{}"'.format(export_dir))
export_info = {
"Player Software Version":
str(g_pool.version),
"Data Format Version":
meta_info["Data Format Version"],
"Export Date":
strftime("%d.%m.%Y", localtime()),
"Export Time":
strftime("%H:%M:%S", localtime()),
"Frame Index Range:":
g_pool.seek_control.get_frame_index_trim_range_string(),
"Relative Time Range":
g_pool.seek_control.get_rel_time_trim_range_string(),
"Absolute Time Range":
g_pool.seek_control.get_abs_time_trim_range_string(),
}
with open(os.path.join(export_dir, "export_info.csv"), "w") as csv:
write_key_value_file(csv, export_info)
notification = {
"subject": "should_export",
"range": export_range,
"ts_window": export_ts_window,
"export_dir": export_dir,
}
g_pool.ipc_pub.notify(notification)
def reset_restart():
logger.warning("Resetting all settings and restarting Player.")
glfw.glfwSetWindowShouldClose(main_window, True)
ipc_pub.notify({"subject": "clear_settings_process.should_start"})
ipc_pub.notify({
"subject": "player_process.should_start",
"rec_dir": rec_dir,
"delay": 2.0,
})
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get("gui_scale", 1.0)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-500, 0),
size=(-icon_bar_width, 0),
header_pos="left")
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos="hidden")
g_pool.timelines = ui.Container((0, 0), (0, 0), (0, 0))
g_pool.timelines.horizontal_constraint = g_pool.menubar
g_pool.user_timelines = ui.Timeline_Menu("User Timelines",
pos=(0.0, -150.0),
size=(0.0, 0.0),
header_pos="headline")
g_pool.user_timelines.color = RGBA(a=0.0)
g_pool.user_timelines.collapsed = True
# add container that constaints itself to the seekbar height
vert_constr = ui.Container((0, 0), (0, -50.0), (0, 0))
vert_constr.append(g_pool.user_timelines)
g_pool.timelines.append(vert_constr)
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
general_settings = ui.Growing_Menu("General", header_pos="headline")
general_settings.append(ui.Button("Reset window size",
set_window_size))
general_settings.append(
ui.Selector(
"gui_user_scale",
g_pool,
setter=set_scale,
selection=[0.8, 0.9, 1.0, 1.1, 1.2] +
list(np.arange(1.5, 5.1, 0.5)),
label="Interface Size",
))
general_settings.append(
ui.Info_Text("Player Version: {}".format(g_pool.version)))
general_settings.append(
ui.Info_Text("Capture Version: {}".format(
meta_info["Capture Software Version"])))
general_settings.append(
ui.Info_Text("Data Format Version: {}".format(
meta_info["Data Format Version"])))
general_settings.append(
ui.Info_Text(
"High level data, e.g. fixations, or visualizations only consider gaze data that has an equal or higher confidence than the minimum data confidence."
))
general_settings.append(
ui.Slider(
"min_data_confidence",
g_pool,
setter=set_data_confidence,
step=0.05,
min=0.0,
max=1.0,
label="Minimum data confidence",
))
general_settings.append(
ui.Button("Restart with default settings", reset_restart))
g_pool.menubar.append(general_settings)
icon = ui.Icon(
"collapsed",
general_settings,
label=chr(0xE8B8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font="pupil_icons",
)
icon.tooltip = "General Settings"
g_pool.iconbar.append(icon)
user_plugin_separator = ui.Separator()
user_plugin_separator.order = 0.35
g_pool.iconbar.append(user_plugin_separator)
g_pool.quickbar = ui.Stretching_Menu("Quick Bar", (0, 100),
(100, -100))
g_pool.export_button = ui.Thumb(
"export",
label=chr(0xE2C5),
getter=lambda: False,
setter=do_export,
hotkey="e",
label_font="pupil_icons",
)
g_pool.quickbar.extend([g_pool.export_button])
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.timelines)
g_pool.gui.append(g_pool.iconbar)
g_pool.gui.append(g_pool.quickbar)
# we always load these plugins
default_plugins = [
("Plugin_Manager", {}),
("Seek_Control", {}),
("Log_Display", {}),
("Raw_Data_Exporter", {}),
("Vis_Polyline", {}),
("Vis_Circle", {}),
("System_Graphs", {}),
("System_Timelines", {}),
("World_Video_Exporter", {}),
("Pupil_From_Recording", {}),
("GazeFromRecording", {}),
("Audio_Playback", {}),
]
g_pool.plugins = Plugin_List(
g_pool, session_settings.get("loaded_plugins", default_plugins))
# Manually add g_pool.capture to the plugin list
g_pool.plugins._plugins.append(g_pool.capture)
g_pool.plugins._plugins.sort(key=lambda p: p.order)
g_pool.capture.init_ui()
general_settings.insert(
-1,
ui.Text_Input(
"rel_time_trim_section",
getter=g_pool.seek_control.get_rel_time_trim_range_string,
setter=g_pool.seek_control.set_rel_time_trim_range_string,
label="Relative time range to export",
),
)
general_settings.insert(
-1,
ui.Text_Input(
"frame_idx_trim_section",
getter=g_pool.seek_control.get_frame_index_trim_range_string,
setter=g_pool.seek_control.set_frame_index_trim_range_string,
label="Frame index range to export",
),
)
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
toggle_general_settings(True)
g_pool.gui.configuration = session_settings.get("ui_config", {})
# gl_state settings
gl_utils.basic_gl_setup()
g_pool.image_tex = Named_Texture()
# trigger on_resize
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
def handle_notifications(n):
subject = n["subject"]
if subject == "start_plugin":
g_pool.plugins.add(g_pool.plugin_by_name[n["name"]],
args=n.get("args", {}))
elif subject.startswith("meta.should_doc"):
ipc_pub.notify({
"subject": "meta.doc",
"actor": g_pool.app,
"doc": player.__doc__
})
for p in g_pool.plugins:
if (p.on_notify.__doc__
and p.__class__.on_notify != Plugin.on_notify):
ipc_pub.notify({
"subject": "meta.doc",
"actor": p.class_name,
"doc": p.on_notify.__doc__,
})
while not glfw.glfwWindowShouldClose(main_window):
# fetch newest notifications
new_notifications = []
while notify_sub.new_data:
t, n = notify_sub.recv()
new_notifications.append(n)
# notify each plugin if there are new notifications:
for n in new_notifications:
handle_notifications(n)
for p in g_pool.plugins:
p.on_notify(n)
events = {}
# report time between now and the last loop interation
events["dt"] = get_dt()
# pupil and gaze positions are added by their respective producer plugins
events["pupil"] = []
events["gaze"] = []
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.recent_events(events)
# check if a plugin need to be destroyed
g_pool.plugins.clean()
glfw.glfwMakeContextCurrent(main_window)
glfw.glfwPollEvents()
# render visual feedback from loaded plugins
if gl_utils.is_window_visible(main_window):
gl_utils.glViewport(0, 0, *g_pool.camera_render_size)
g_pool.capture.gl_display()
for p in g_pool.plugins:
p.gl_display()
gl_utils.glViewport(0, 0, *window_size)
try:
clipboard = glfw.glfwGetClipboardString(
main_window).decode()
except AttributeError: # clipbaord is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard and user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.glfwSetClipboardString(main_window,
user_input.clipboard.encode())
for b in user_input.buttons:
button, action, mods = b
x, y = glfw.glfwGetCursorPos(main_window)
pos = x * hdpi_factor, y * hdpi_factor
pos = normalize(pos, g_pool.camera_render_size)
pos = denormalize(pos, g_pool.capture.frame_size)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
# present frames at appropriate speed
g_pool.seek_control.wait(events["frame"].timestamp)
glfw.glfwSwapBuffers(main_window)
session_settings["loaded_plugins"] = g_pool.plugins.get_initializers()
session_settings["min_data_confidence"] = g_pool.min_data_confidence
session_settings[
"min_calibration_confidence"] = g_pool.min_calibration_confidence
session_settings["gui_scale"] = g_pool.gui_user_scale
session_settings["ui_config"] = g_pool.gui.configuration
session_settings["window_position"] = glfw.glfwGetWindowPos(
main_window)
session_settings["version"] = str(g_pool.version)
session_window_size = glfw.glfwGetWindowSize(main_window)
if 0 not in session_window_size:
session_settings["window_size"] = session_window_size
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
except:
import traceback
trace = traceback.format_exc()
logger.error("Process Player crashed with trace:\n{}".format(trace))
finally:
logger.info("Process shutting down.")
ipc_pub.notify({"subject": "player_process.stopped"})
sleep(1.0)
def world(pupil_queue, timebase, launcher_pipe, eye_pipes, eyes_are_alive,
user_dir, version, cap_src):
"""world
Creates a window, gl context.
Grabs images from a capture.
Receives Pupil coordinates from eye process[es]
Can run various plug-ins.
"""
import logging
# Set up root logger for this process before doing imports of logged modules.
logger = logging.getLogger()
logger.setLevel(logging.INFO)
#silence noisy modules
logging.getLogger("OpenGL").setLevel(logging.ERROR)
# create formatter
formatter = logging.Formatter(
'%(processName)s - [%(levelname)s] %(name)s : %(message)s')
# create file handler which logs even debug messages
fh = logging.FileHandler(os.path.join(user_dir, 'capture.log'), mode='w')
fh.setLevel(logger.level)
fh.setFormatter(formatter)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logger.level + 10)
ch.setFormatter(formatter)
# add the handlers to the logger
logger.addHandler(fh)
logger.addHandler(ch)
#setup thread to recv log recrods from other processes.
def log_loop(logging):
import zmq
ctx = zmq.Context()
sub = ctx.socket(zmq.SUB)
sub.bind('tcp://127.0.0.1:502020')
sub.setsockopt(zmq.SUBSCRIBE, "")
while True:
record = sub.recv_pyobj()
logger = logging.getLogger(record.name)
logger.handle(record)
import threading
log_thread = threading.Thread(target=log_loop, args=(logging, ))
log_thread.setDaemon(True)
log_thread.start()
# create logger for the context of this function
logger = logging.getLogger(__name__)
# We defer the imports because of multiprocessing.
# Otherwise the world process each process also loads the other imports.
# This is not harmful but unnecessary.
#general imports
from time import time, sleep
import numpy as np
#display
import glfw
from pyglui import ui, graph, cygl
from pyglui.cygl.utils import Named_Texture
from gl_utils import basic_gl_setup, adjust_gl_view, clear_gl_screen, make_coord_system_pixel_based, make_coord_system_norm_based
#check versions for our own depedencies as they are fast-changing
from pyglui import __version__ as pyglui_version
assert pyglui_version >= '0.8'
#monitoring
import psutil
# helpers/utils
from file_methods import Persistent_Dict
from methods import normalize, denormalize, delta_t, get_system_info
from video_capture import autoCreateCapture, FileCaptureError, EndofVideoFileError, CameraCaptureError
from version_utils import VersionFormat
import audio
# Plug-ins
from plugin import Plugin_List, import_runtime_plugins
from calibration_routines import calibration_plugins, gaze_mapping_plugins
from recorder import Recorder
from show_calibration import Show_Calibration
from display_recent_gaze import Display_Recent_Gaze
from pupil_server import Pupil_Server
from pupil_sync import Pupil_Sync
from surface_tracker import Surface_Tracker
from log_display import Log_Display
from annotations import Annotation_Capture
from pupil_remote import Pupil_Remote
from log_history import Log_History
logger.info('Application Version: %s' % version)
logger.info('System Info: %s' % get_system_info())
#UI Platform tweaks
if platform.system() == 'Linux':
scroll_factor = 10.0
window_position_default = (0, 0)
elif platform.system() == 'Windows':
scroll_factor = 1.0
window_position_default = (8, 31)
else:
scroll_factor = 1.0
window_position_default = (0, 0)
#g_pool holds variables for this process
g_pool = Global_Container()
# make some constants avaiable
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.app = 'capture'
g_pool.pupil_queue = pupil_queue
g_pool.timebase = timebase
# g_pool.launcher_pipe = launcher_pipe
g_pool.eye_pipes = eye_pipes
g_pool.eyes_are_alive = eyes_are_alive
#manage plugins
runtime_plugins = import_runtime_plugins(
os.path.join(g_pool.user_dir, 'plugins'))
user_launchable_plugins = [
Show_Calibration, Pupil_Remote, Pupil_Server, Pupil_Sync,
Surface_Tracker, Annotation_Capture, Log_History
] + runtime_plugins
system_plugins = [Log_Display, Display_Recent_Gaze, Recorder]
plugin_by_index = system_plugins + user_launchable_plugins + calibration_plugins + gaze_mapping_plugins
name_by_index = [p.__name__ for p in plugin_by_index]
plugin_by_name = dict(zip(name_by_index, plugin_by_index))
default_plugins = [('Log_Display', {}), ('Dummy_Gaze_Mapper', {}),
('Display_Recent_Gaze', {}),
('Screen_Marker_Calibration', {}), ('Recorder', {})]
# Callback functions
def on_resize(window, w, h):
if not g_pool.iconified:
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
graph.adjust_size(w, h)
adjust_gl_view(w, h)
for p in g_pool.plugins:
p.on_window_resize(window, w, h)
def on_iconify(window, iconified):
g_pool.iconified = iconified
def on_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_char(window, char):
g_pool.gui.update_char(char)
def on_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
pos = glfw.glfwGetCursorPos(window)
pos = normalize(pos, glfw.glfwGetWindowSize(main_window))
pos = denormalize(
pos,
(frame.img.shape[1], frame.img.shape[0])) # Position in img pixels
for p in g_pool.plugins:
p.on_click(pos, button, action)
def on_pos(window, x, y):
hdpi_factor = float(
glfw.glfwGetFramebufferSize(window)[0] /
glfw.glfwGetWindowSize(window)[0])
x, y = x * hdpi_factor, y * hdpi_factor
g_pool.gui.update_mouse(x, y)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
tick = delta_t()
def get_dt():
return next(tick)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir, 'user_settings_world'))
if session_settings.get("version", VersionFormat('0.0')) < g_pool.version:
logger.info(
"Session setting are from older version of this app. I will not use those."
)
session_settings.clear()
# Initialize capture
cap = autoCreateCapture(cap_src, timebase=g_pool.timebase)
default_settings = {'frame_size': (1280, 720), 'frame_rate': 30}
previous_settings = session_settings.get('capture_settings', None)
if previous_settings and previous_settings['name'] == cap.name:
cap.settings = previous_settings
else:
cap.settings = default_settings
# Test capture
try:
frame = cap.get_frame()
except CameraCaptureError:
logger.error("Could not retrieve image from capture")
cap.close()
launcher_pipe.send("Exit")
return
g_pool.iconified = False
g_pool.capture = cap
g_pool.pupil_confidence_threshold = session_settings.get(
'pupil_confidence_threshold', .6)
g_pool.detection_mapping_mode = session_settings.get(
'detection_mapping_mode', '2d')
g_pool.active_calibration_plugin = None
audio.audio_mode = session_settings.get('audio_mode',
audio.default_audio_mode)
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def set_scale(new_scale):
g_pool.gui.scale = new_scale
g_pool.gui.collect_menus()
def launch_eye_process(eye_id, blocking=False):
if eyes_are_alive[eye_id].value:
logger.error("Eye%s process already running." % eye_id)
return
launcher_pipe.send(eye_id)
eye_pipes[eye_id].send(
('Set_Detection_Mapping_Mode', g_pool.detection_mapping_mode))
if blocking:
#wait for ready message from eye to sequentialize startup
eye_pipes[eye_id].send('Ping')
eye_pipes[eye_id].recv()
logger.warning('Eye %s process started.' % eye_id)
def stop_eye_process(eye_id, blocking=False):
if eyes_are_alive[eye_id].value:
eye_pipes[eye_id].send('Exit')
if blocking:
while eyes_are_alive[eye_id].value:
sleep(.1)
def start_stop_eye(eye_id, make_alive):
if make_alive:
launch_eye_process(eye_id)
else:
stop_eye_process(eye_id)
def set_detection_mapping_mode(new_mode):
if new_mode == '2d':
for p in g_pool.plugins:
if "Vector_Gaze_Mapper" in p.class_name:
logger.warning(
"The gaze mapper is not supported in 2d mode. Please recalibrate."
)
p.alive = False
g_pool.plugins.clean()
for alive, pipe in zip(g_pool.eyes_are_alive, g_pool.eye_pipes):
if alive.value:
pipe.send(('Set_Detection_Mapping_Mode', new_mode))
g_pool.detection_mapping_mode = new_mode
#window and gl setup
glfw.glfwInit()
width, height = session_settings.get('window_size',
(frame.width, frame.height))
main_window = glfw.glfwCreateWindow(width, height, "World")
window_pos = session_settings.get('window_position',
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
g_pool.main_window = main_window
#setup GUI
g_pool.gui = ui.UI()
g_pool.gui.scale = session_settings.get('gui_scale', 1)
g_pool.sidebar = ui.Scrolling_Menu("Settings",
pos=(-350, 0),
size=(0, 0),
header_pos='left')
general_settings = ui.Growing_Menu('General')
general_settings.append(
ui.Slider('scale',
g_pool.gui,
setter=set_scale,
step=.05,
min=1.,
max=2.5,
label='Interface size'))
general_settings.append(
ui.Button(
'Reset window size', lambda: glfw.glfwSetWindowSize(
main_window, frame.width, frame.height)))
general_settings.append(
ui.Selector('audio_mode', audio, selection=audio.audio_modes))
general_settings.append(
ui.Selector('detection_mapping_mode',
g_pool,
label='detection & mapping mode',
setter=set_detection_mapping_mode,
selection=['2d', '3d']))
general_settings.append(
ui.Switch('eye0_process',
label='Detect eye 0',
setter=lambda alive: start_stop_eye(0, alive),
getter=lambda: eyes_are_alive[0].value))
general_settings.append(
ui.Switch('eye1_process',
label='Detect eye 1',
setter=lambda alive: start_stop_eye(1, alive),
getter=lambda: eyes_are_alive[1].value))
general_settings.append(
ui.Selector('Open plugin',
selection=user_launchable_plugins,
labels=[
p.__name__.replace('_', ' ')
for p in user_launchable_plugins
],
setter=open_plugin,
getter=lambda: "Select to load"))
general_settings.append(
ui.Slider('pupil_confidence_threshold',
g_pool,
step=.01,
min=0.,
max=1.,
label='Minimum pupil confidence'))
general_settings.append(
ui.Info_Text('Capture Version: %s' % g_pool.version))
g_pool.sidebar.append(general_settings)
g_pool.calibration_menu = ui.Growing_Menu('Calibration')
g_pool.sidebar.append(g_pool.calibration_menu)
g_pool.gui.append(g_pool.sidebar)
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100), (120, -100))
g_pool.gui.append(g_pool.quickbar)
g_pool.capture.init_gui(g_pool.sidebar)
#plugins that are loaded based on user settings from previous session
g_pool.notifications = []
g_pool.delayed_notifications = {}
g_pool.plugins = Plugin_List(
g_pool, plugin_by_name,
session_settings.get('loaded_plugins', default_plugins))
#We add the calibration menu selector, after a calibration has been added:
g_pool.calibration_menu.insert(
0,
ui.Selector(
'active_calibration_plugin',
getter=lambda: g_pool.active_calibration_plugin.__class__,
selection=calibration_plugins,
labels=[p.__name__.replace('_', ' ') for p in calibration_plugins],
setter=open_plugin,
label='Method'))
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetWindowIconifyCallback(main_window, on_iconify)
glfw.glfwSetKeyCallback(main_window, on_key)
glfw.glfwSetCharCallback(main_window, on_char)
glfw.glfwSetMouseButtonCallback(main_window, on_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
# gl_state settings
basic_gl_setup()
g_pool.image_tex = Named_Texture()
g_pool.image_tex.update_from_frame(frame)
# refresh speed settings
glfw.glfwSwapInterval(0)
#trigger setup of window and gl sizes
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
#now the we have aproper window we can load the last gui configuration
g_pool.gui.configuration = session_settings.get('ui_config', {})
#set up performace graphs:
pid = os.getpid()
ps = psutil.Process(pid)
ts = frame.timestamp
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 130)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = 'CPU %0.1f'
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 130)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f FPS"
pupil_graph = graph.Bar_Graph(max_val=1.0)
pupil_graph.pos = (260, 130)
pupil_graph.update_rate = 5
pupil_graph.label = "Confidence: %0.2f"
if session_settings.get('eye1_process_alive', False):
launch_eye_process(1, blocking=True)
if session_settings.get('eye0_process_alive', True):
launch_eye_process(0, blocking=False)
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
# Get an image from the grabber
try:
frame = g_pool.capture.get_frame()
except CameraCaptureError:
logger.error("Capture from camera failed. Starting Fake Capture.")
settings = g_pool.capture.settings
g_pool.capture.close()
g_pool.capture = autoCreateCapture(None, timebase=g_pool.timebase)
g_pool.capture.init_gui(g_pool.sidebar)
g_pool.capture.settings = settings
g_pool.notifications.append({'subject': 'should_stop_recording'})
continue
except EndofVideoFileError:
logger.warning("Video file is done. Stopping")
break
#update performace graphs
t = frame.timestamp
dt, ts = t - ts, t
try:
fps_graph.add(1. / dt)
except ZeroDivisionError:
pass
cpu_graph.update()
#a dictionary that allows plugins to post and read events
events = {}
#report time between now and the last loop interation
events['dt'] = get_dt()
#receive and map pupil positions
recent_pupil_positions = []
while not g_pool.pupil_queue.empty():
p = g_pool.pupil_queue.get()
recent_pupil_positions.append(p)
pupil_graph.add(p['confidence'])
events['pupil_positions'] = recent_pupil_positions
# publish delayed notifiactions when their time has come.
for n in g_pool.delayed_notifications.values():
if n['_notify_time_'] < time():
del n['_notify_time_']
del g_pool.delayed_notifications[n['subject']]
g_pool.notifications.append(n)
# notify each plugin if there are new notifications:
while g_pool.notifications:
n = g_pool.notifications.pop(0)
for p in g_pool.plugins:
p.on_notify(n)
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.update(frame, events)
#check if a plugin need to be destroyed
g_pool.plugins.clean()
# render camera image
glfw.glfwMakeContextCurrent(main_window)
if g_pool.iconified:
pass
else:
g_pool.image_tex.update_from_frame(frame)
make_coord_system_norm_based()
g_pool.image_tex.draw()
make_coord_system_pixel_based((frame.height, frame.width, 3))
# render visual feedback from loaded plugins
for p in g_pool.plugins:
p.gl_display()
if not g_pool.iconified:
graph.push_view()
fps_graph.draw()
cpu_graph.draw()
pupil_graph.draw()
graph.pop_view()
g_pool.gui.update()
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
glfw.glfwRestoreWindow(main_window) #need to do this for windows os
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings[
'pupil_confidence_threshold'] = g_pool.pupil_confidence_threshold
session_settings['gui_scale'] = g_pool.gui.scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['capture_settings'] = g_pool.capture.settings
session_settings['window_size'] = glfw.glfwGetWindowSize(main_window)
session_settings['window_position'] = glfw.glfwGetWindowPos(main_window)
session_settings['version'] = g_pool.version
session_settings['eye0_process_alive'] = eyes_are_alive[0].value
session_settings['eye1_process_alive'] = eyes_are_alive[1].value
session_settings['detection_mapping_mode'] = g_pool.detection_mapping_mode
session_settings['audio_mode'] = audio.audio_mode
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
g_pool.gui.terminate()
glfw.glfwDestroyWindow(main_window)
glfw.glfwTerminate()
g_pool.capture.close()
#shut down eye processes:
stop_eye_process(0, blocking=True)
stop_eye_process(1, blocking=True)
#shut down laucher
launcher_pipe.send("Exit")
logger.info("Process Shutting down.")
def init_gui(self,sidebar):
#lets define some helper functions:
def gui_load_defaults():
for c in self.capture.controls:
try:
c.value = c.def_val
except:
pass
def set_size(new_size):
self.frame_size = new_size
menu_conf = self.menu.configuration
self.deinit_gui()
self.init_gui(self.sidebar)
self.menu.configuration = menu_conf
def gui_update_from_device():
for c in self.capture.controls:
c.refresh()
def gui_init_cam_by_uid(requested_id):
if requested_id is None:
self.re_init_capture(None)
else:
for cam in uvc.device_list():
if cam['uid'] == requested_id:
if is_accessible(requested_id):
self.re_init_capture(requested_id)
else:
logger.error("The selected Camera is already in use or blocked.")
return
logger.warning("could not reinit capture, src_id not valid anymore")
return
#create the menu entry
self.menu = ui.Growing_Menu(label='Camera Settings')
cameras = uvc.device_list()
camera_names = ['Fake Capture']+[c['name'] for c in cameras]
camera_ids = [None]+[c['uid'] for c in cameras]
self.menu.append(ui.Selector('uid',self,selection=camera_ids,labels=camera_names,label='Capture device', setter=gui_init_cam_by_uid) )
sensor_control = ui.Growing_Menu(label='Sensor Settings')
sensor_control.append(ui.Info_Text("Do not change these during calibration or recording!"))
sensor_control.collapsed=False
image_processing = ui.Growing_Menu(label='Image Post Processing')
image_processing.collapsed=True
sensor_control.append(ui.Selector('frame_size',self,setter=set_size, selection=self.capture.frame_sizes,label='Resolution' ) )
sensor_control.append(ui.Selector('frame_rate',self, selection=self.capture.frame_rates,label='Frame rate' ) )
for control in self.capture.controls:
c = None
ctl_name = control.display_name
#now we add controls
if control.d_type == bool :
c = ui.Switch('value',control,label=ctl_name, on_val=control.max_val, off_val=control.min_val)
elif control.d_type == int:
c = ui.Slider('value',control,label=ctl_name,min=control.min_val,max=control.max_val,step=control.step)
elif type(control.d_type) == dict:
selection = [value for name,value in control.d_type.iteritems()]
labels = [name for name,value in control.d_type.iteritems()]
c = ui.Selector('value',control, label = ctl_name, selection=selection,labels = labels)
else:
pass
# if control['disabled']:
# c.read_only = True
# if ctl_name == 'Exposure, Auto Priority':
# # the controll should always be off. we set it to 0 on init (see above)
# c.read_only = True
if c is not None:
if control.unit == 'processing_unit':
image_processing.append(c)
else:
sensor_control.append(c)
self.menu.append(sensor_control)
if image_processing.elements:
self.menu.append(image_processing)
self.menu.append(ui.Button("refresh",gui_update_from_device))
self.menu.append(ui.Button("load defaults",gui_load_defaults))
self.sidebar = sidebar
#add below geneal settings
self.sidebar.insert(1,self.menu)
def append_section_menu(self, sec, collapsed=True):
section_menu = ui.Growing_Menu('Gaze Section')
section_menu.collapsed = collapsed
section_menu.color = RGBA(*sec['color'])
def make_validate_fn(sec, key):
def validate(input_obj):
try:
assert type(input_obj) in (tuple, list)
assert type(input_obj[0]) is int
assert type(input_obj[1]) is int
assert 0 <= input_obj[0] <= input_obj[1] <= len(
self.g_pool.timestamps)
except:
pass
else:
sec[key] = input_obj
return validate
def make_calibrate_fn(sec):
def calibrate():
self.calibrate_section(sec)
return calibrate
def make_remove_fn(sec):
def remove():
del self.menu[self.sections.index(sec) - len(self.sections)]
del self.sections[self.sections.index(sec)]
self.correlate_and_publish()
return remove
section_menu.append(
ui.Selector('calibration_method',
sec,
label="Calibration Method",
labels=['Circle Marker', 'Natural Features'],
selection=['circle_marker', 'natural_features']))
section_menu.append(
ui.Selector('mapping_method',
sec,
label='Calibration Mode',
selection=['2d', '3d']))
section_menu.append(
ui.Text_Input('status',
sec,
label='Calbiration Status',
setter=lambda _: _))
section_menu[-1].read_only = True
section_menu.append(
ui.Text_Input('calibration_range',
sec,
label='Calibration range',
setter=make_validate_fn(sec, 'calibration_range')))
section_menu.append(
ui.Text_Input('mapping_range',
sec,
label='Mapping range',
setter=make_validate_fn(sec, 'mapping_range')))
section_menu.append(ui.Button('Recalibrate', make_calibrate_fn(sec)))
section_menu.append(ui.Button('Remove section', make_remove_fn(sec)))
self.menu.append(section_menu)
def eye(
timebase,
is_alive_flag,
ipc_pub_url,
ipc_sub_url,
ipc_push_url,
user_dir,
version,
eye_id,
overwrite_cap_settings=None,
hide_ui=False,
):
"""reads eye video and detects the pupil.
Creates a window, gl context.
Grabs images from a capture.
Streams Pupil coordinates.
Reacts to notifications:
``set_detection_mapping_mode``: Sets detection method
``eye_process.should_stop``: Stops the eye process
``recording.started``: Starts recording eye video
``recording.stopped``: Stops recording eye video
``frame_publishing.started``: Starts frame publishing
``frame_publishing.stopped``: Stops frame publishing
``start_eye_plugin``: Start plugins in eye process
Emits notifications:
``eye_process.started``: Eye process started
``eye_process.stopped``: Eye process stopped
Emits data:
``pupil.<eye id>``: Pupil data for eye with id ``<eye id>``
``frame.eye.<eye id>``: Eye frames with id ``<eye id>``
"""
# We deferr the imports becasue of multiprocessing.
# Otherwise the world process each process also loads the other imports.
import zmq
import zmq_tools
zmq_ctx = zmq.Context()
ipc_socket = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
pupil_socket = zmq_tools.Msg_Streamer(zmq_ctx, ipc_pub_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=("notify", ))
# logging setup
import logging
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.NOTSET)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
if is_alive_flag.value:
# indicates eye process that this is a duplicated startup
logger.warning("Aborting redundant eye process startup")
return
with Is_Alive_Manager(is_alive_flag, ipc_socket, eye_id, logger):
# general imports
import traceback
import numpy as np
import cv2
# display
import glfw
from pyglui import ui, graph, cygl
from pyglui.cygl.utils import draw_points, RGBA, draw_polyline
from pyglui.cygl.utils import Named_Texture
from gl_utils import basic_gl_setup, adjust_gl_view, clear_gl_screen
from gl_utils import make_coord_system_pixel_based
from gl_utils import make_coord_system_norm_based
from gl_utils import is_window_visible, glViewport
from ui_roi import UIRoi
# monitoring
import psutil
# Plug-ins
from plugin import Plugin_List
# helpers/utils
from uvc import get_time_monotonic
from file_methods import Persistent_Dict
from version_utils import VersionFormat
from methods import normalize, denormalize, timer
from av_writer import JPEG_Writer, MPEG_Writer
from ndsi import H264Writer
from video_capture import source_classes, manager_classes
from background_helper import IPC_Logging_Task_Proxy
from pupil_detector_plugins import available_detector_plugins
from pupil_detector_plugins.manager import PupilDetectorManager
IPC_Logging_Task_Proxy.push_url = ipc_push_url
def interrupt_handler(sig, frame):
import traceback
trace = traceback.format_stack(f=frame)
logger.debug(f"Caught signal {sig} in:\n" + "".join(trace))
# NOTE: Interrupt is handled in world/service/player which are responsible for
# shutting down the eye process properly
signal.signal(signal.SIGINT, interrupt_handler)
# UI Platform tweaks
if platform.system() == "Linux":
scroll_factor = 10.0
window_position_default = (600, 300 * eye_id + 30)
elif platform.system() == "Windows":
scroll_factor = 10.0
window_position_default = (600, 90 + 300 * eye_id)
else:
scroll_factor = 1.0
window_position_default = (600, 300 * eye_id)
icon_bar_width = 50
window_size = None
camera_render_size = None
hdpi_factor = 1.0
# g_pool holds variables for this process
g_pool = SimpleNamespace()
# make some constants avaiable
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.app = "capture"
g_pool.eye_id = eye_id
g_pool.process = f"eye{eye_id}"
g_pool.timebase = timebase
g_pool.ipc_pub = ipc_socket
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
default_detector_cls, available_detectors = available_detector_plugins(
)
plugins = (manager_classes + source_classes + available_detectors +
[PupilDetectorManager])
g_pool.plugin_by_name = {p.__name__: p for p in plugins}
preferred_names = [
f"Pupil Cam3 ID{eye_id}",
f"Pupil Cam2 ID{eye_id}",
f"Pupil Cam1 ID{eye_id}",
]
if eye_id == 0:
preferred_names += ["HD-6000"]
default_capture_settings = (
"UVC_Source",
{
"preferred_names": preferred_names,
"frame_size": (320, 240),
"frame_rate": 120,
},
)
default_plugins = [
# TODO: extend with plugins
default_capture_settings,
("UVC_Manager", {}),
# Detector needs to be loaded first to set `g_pool.pupil_detector`
(default_detector_cls.__name__, {}),
("PupilDetectorManager", {}),
]
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal camera_render_size
nonlocal hdpi_factor
active_window = glfw.glfwGetCurrentContext()
glfw.glfwMakeContextCurrent(window)
hdpi_factor = glfw.getHDPIFactor(window)
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
for g in g_pool.graphs:
g.scale = hdpi_factor
g.adjust_window_size(w, h)
adjust_gl_view(w, h)
glfw.glfwMakeContextCurrent(active_window)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_iconify(window, iconified):
g_pool.iconified = iconified
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x *= hdpi_factor
y *= hdpi_factor
g_pool.gui.update_mouse(x, y)
if g_pool.u_r.active_edit_pt:
pos = normalize((x, y), camera_render_size)
if g_pool.flip:
pos = 1 - pos[0], 1 - pos[1]
pos = denormalize(pos, g_pool.capture.frame_size)
g_pool.u_r.move_vertex(g_pool.u_r.active_pt_idx, pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
paths = [paths[x].decode("utf-8") for x in range(count)]
for plugin in g_pool.plugins:
if plugin.on_drop(paths):
break
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir,
"user_settings_eye{}".format(eye_id)))
if VersionFormat(session_settings.get("version",
"0.0")) != g_pool.version:
logger.info(
"Session setting are from a different version of this app. I will not use those."
)
session_settings.clear()
g_pool.iconified = False
g_pool.capture = None
g_pool.flip = session_settings.get("flip", False)
g_pool.display_mode = session_settings.get("display_mode",
"camera_image")
g_pool.display_mode_info_text = {
"camera_image":
"Raw eye camera image. This uses the least amount of CPU power",
"roi":
"Click and drag on the blue circles to adjust the region of interest. The region should be as small as possible, but large enough to capture all pupil movements.",
"algorithm":
"Algorithm display mode overlays a visualization of the pupil detection parameters on top of the eye video. Adjust parameters within the Pupil Detection menu below.",
}
def set_display_mode_info(val):
g_pool.display_mode = val
g_pool.display_mode_info.text = g_pool.display_mode_info_text[val]
def toggle_general_settings(collapsed):
# this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
# Initialize glfw
glfw.glfwInit()
if hide_ui:
glfw.glfwWindowHint(glfw.GLFW_VISIBLE, 0) # hide window
title = "Pupil Capture - eye {}".format(eye_id)
width, height = session_settings.get("window_size",
(640 + icon_bar_width, 480))
main_window = glfw.glfwCreateWindow(width, height, title, None, None)
window_pos = session_settings.get("window_position",
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
# UI callback functions
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
# gl_state settings
basic_gl_setup()
g_pool.image_tex = Named_Texture()
g_pool.image_tex.update_from_ndarray(
np.ones((1, 1), dtype=np.uint8) + 125)
# setup GUI
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get("gui_scale", 1.0)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-500, 0),
size=(-icon_bar_width, 0),
header_pos="left")
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos="hidden")
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.iconbar)
general_settings = ui.Growing_Menu("General", header_pos="headline")
general_settings.append(
ui.Selector(
"gui_user_scale",
g_pool,
setter=set_scale,
selection=[0.8, 0.9, 1.0, 1.1, 1.2],
label="Interface Size",
))
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width *= 2
f_height *= 2
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
def uroi_on_mouse_button(button, action, mods):
if g_pool.display_mode == "roi":
if action == glfw.GLFW_RELEASE and g_pool.u_r.active_edit_pt:
g_pool.u_r.active_edit_pt = False
# if the roi interacts we dont want
# the gui to interact as well
return
elif action == glfw.GLFW_PRESS:
x, y = glfw.glfwGetCursorPos(main_window)
# pos = normalize(pos, glfw.glfwGetWindowSize(main_window))
x *= hdpi_factor
y *= hdpi_factor
pos = normalize((x, y), camera_render_size)
if g_pool.flip:
pos = 1 - pos[0], 1 - pos[1]
# Position in img pixels
pos = denormalize(
pos,
g_pool.capture.frame_size) # Position in img pixels
if g_pool.u_r.mouse_over_edit_pt(pos,
g_pool.u_r.handle_size,
g_pool.u_r.handle_size):
# if the roi interacts we dont want
# the gui to interact as well
return
general_settings.append(ui.Button("Reset window size",
set_window_size))
general_settings.append(
ui.Switch("flip", g_pool, label="Flip image display"))
general_settings.append(
ui.Selector(
"display_mode",
g_pool,
setter=set_display_mode_info,
selection=["camera_image", "roi", "algorithm"],
labels=["Camera Image", "ROI", "Algorithm"],
label="Mode",
))
g_pool.display_mode_info = ui.Info_Text(
g_pool.display_mode_info_text[g_pool.display_mode])
general_settings.append(g_pool.display_mode_info)
g_pool.menubar.append(general_settings)
icon = ui.Icon(
"collapsed",
general_settings,
label=chr(0xE8B8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font="pupil_icons",
)
icon.tooltip = "General Settings"
g_pool.iconbar.append(icon)
toggle_general_settings(False)
plugins_to_load = session_settings.get("loaded_plugins",
default_plugins)
if overwrite_cap_settings:
# Ensure that overwrite_cap_settings takes preference over source plugins
# with incorrect settings that were loaded from session settings.
plugins_to_load.append(overwrite_cap_settings)
g_pool.plugins = Plugin_List(g_pool, plugins_to_load)
g_pool.writer = None
g_pool.u_r = UIRoi(
(g_pool.capture.frame_size[1], g_pool.capture.frame_size[0]))
roi_user_settings = session_settings.get("roi")
if roi_user_settings and tuple(
roi_user_settings[-1]) == g_pool.u_r.get()[-1]:
g_pool.u_r.set(roi_user_settings)
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetWindowIconifyCallback(main_window, on_iconify)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
# load last gui configuration
g_pool.gui.configuration = session_settings.get("ui_config", {})
# set up performance graphs
pid = os.getpid()
ps = psutil.Process(pid)
ts = g_pool.get_timestamp()
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 50)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = "CPU %0.1f"
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 50)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f FPS"
g_pool.graphs = [cpu_graph, fps_graph]
# set the last saved window size
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
should_publish_frames = False
frame_publish_format = "jpeg"
frame_publish_format_recent_warning = False
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
logger.warning("Process started.")
frame = None
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
if notify_sub.new_data:
t, notification = notify_sub.recv()
subject = notification["subject"]
if subject.startswith("eye_process.should_stop"):
if notification["eye_id"] == eye_id:
break
elif subject == "recording.started":
if notification["record_eye"] and g_pool.capture.online:
record_path = notification["rec_path"]
raw_mode = notification["compression"]
start_time_synced = notification["start_time_synced"]
logger.info(
"Will save eye video to: {}".format(record_path))
video_path = os.path.join(record_path,
"eye{}.mp4".format(eye_id))
if raw_mode and frame and g_pool.capture.jpeg_support:
g_pool.writer = JPEG_Writer(
video_path, start_time_synced)
elif hasattr(g_pool.capture._recent_frame,
"h264_buffer"):
g_pool.writer = H264Writer(
video_path,
g_pool.capture.frame_size[0],
g_pool.capture.frame_size[1],
g_pool.capture.frame_rate,
)
else:
g_pool.writer = MPEG_Writer(
video_path, start_time_synced)
elif subject == "recording.stopped":
if g_pool.writer:
logger.info("Done recording.")
try:
g_pool.writer.release()
except RuntimeError:
logger.error("No eye video recorded")
g_pool.writer = None
elif subject.startswith("meta.should_doc"):
ipc_socket.notify({
"subject": "meta.doc",
"actor": "eye{}".format(eye_id),
"doc": eye.__doc__,
})
elif subject.startswith("frame_publishing.started"):
should_publish_frames = True
frame_publish_format = notification.get("format", "jpeg")
elif subject.startswith("frame_publishing.stopped"):
should_publish_frames = False
frame_publish_format = "jpeg"
elif (subject.startswith("start_eye_plugin")
and notification["target"] == g_pool.process):
try:
g_pool.plugins.add(
g_pool.plugin_by_name[notification["name"]],
notification.get("args", {}),
)
except KeyError as err:
logger.error(f"Attempt to load unknown plugin: {err}")
for plugin in g_pool.plugins:
plugin.on_notify(notification)
event = {}
for plugin in g_pool.plugins:
plugin.recent_events(event)
frame = event.get("frame")
if frame:
f_width, f_height = g_pool.capture.frame_size
# TODO: Roi should be its own plugin. This way we could put it at the
# appropriate order for recent_events() to process frame resolution
# changes immediately after the backend.
if (g_pool.u_r.array_shape[0], g_pool.u_r.array_shape[1]) != (
f_height,
f_width,
):
g_pool.pupil_detector.on_resolution_change(
(g_pool.u_r.array_shape[1], g_pool.u_r.array_shape[0]),
g_pool.capture.frame_size,
)
g_pool.u_r = UIRoi((f_height, f_width))
if should_publish_frames:
try:
if frame_publish_format == "jpeg":
data = frame.jpeg_buffer
elif frame_publish_format == "yuv":
data = frame.yuv_buffer
elif frame_publish_format == "bgr":
data = frame.bgr
elif frame_publish_format == "gray":
data = frame.gray
assert data is not None
except (AttributeError, AssertionError, NameError):
if not frame_publish_format_recent_warning:
frame_publish_format_recent_warning = True
logger.warning(
'{}s are not compatible with format "{}"'.
format(type(frame), frame_publish_format))
else:
frame_publish_format_recent_warning = False
pupil_socket.send({
"topic":
"frame.eye.{}".format(eye_id),
"width":
frame.width,
"height":
frame.height,
"index":
frame.index,
"timestamp":
frame.timestamp,
"format":
frame_publish_format,
"__raw_data__": [data],
})
t = frame.timestamp
dt, ts = t - ts, t
try:
fps_graph.add(1.0 / dt)
except ZeroDivisionError:
pass
if g_pool.writer:
g_pool.writer.write_video_frame(frame)
result = event.get("pupil_detection_result", None)
if result is not None:
pupil_socket.send(result)
cpu_graph.update()
# GL drawing
if window_should_update():
if is_window_visible(main_window):
glfw.glfwMakeContextCurrent(main_window)
clear_gl_screen()
glViewport(0, 0, *camera_render_size)
for p in g_pool.plugins:
p.gl_display()
glViewport(0, 0, *camera_render_size)
# render the ROI
g_pool.u_r.draw(g_pool.gui.scale)
if g_pool.display_mode == "roi":
g_pool.u_r.draw_points(g_pool.gui.scale)
glViewport(0, 0, *window_size)
# render graphs
fps_graph.draw()
cpu_graph.draw()
# render GUI
try:
clipboard = glfw.glfwGetClipboardString(
main_window).decode()
except AttributeError: # clipboard is None, might happen on startup
clipboard = ""
g_pool.gui.update_clipboard(clipboard)
user_input = g_pool.gui.update()
if user_input.clipboard != clipboard:
# only write to clipboard if content changed
glfw.glfwSetClipboardString(
main_window, user_input.clipboard.encode())
for button, action, mods in user_input.buttons:
x, y = glfw.glfwGetCursorPos(main_window)
pos = x * hdpi_factor, y * hdpi_factor
pos = normalize(pos, camera_render_size)
# Position in img pixels
pos = denormalize(pos, g_pool.capture.frame_size)
# TODO: remove when ROI is plugin
uroi_on_mouse_button(button, action, mods)
for plugin in g_pool.plugins:
if plugin.on_click(pos, button, action):
break
for key, scancode, action, mods in user_input.keys:
for plugin in g_pool.plugins:
if plugin.on_key(key, scancode, action, mods):
break
for char_ in user_input.chars:
for plugin in g_pool.plugins:
if plugin.on_char(char_):
break
# update screen
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
# END while running
# in case eye recording was still runnnig: Save&close
if g_pool.writer:
logger.info("Done recording eye.")
g_pool.writer.release()
g_pool.writer = None
session_settings["loaded_plugins"] = g_pool.plugins.get_initializers()
# save session persistent settings
session_settings["gui_scale"] = g_pool.gui_user_scale
session_settings["roi"] = g_pool.u_r.get()
session_settings["flip"] = g_pool.flip
session_settings["display_mode"] = g_pool.display_mode
session_settings["ui_config"] = g_pool.gui.configuration
session_settings["version"] = str(g_pool.version)
if not hide_ui:
glfw.glfwRestoreWindow(
main_window) # need to do this for windows os
session_settings["window_position"] = glfw.glfwGetWindowPos(
main_window)
session_window_size = glfw.glfwGetWindowSize(main_window)
if 0 not in session_window_size:
session_settings["window_size"] = session_window_size
session_settings.close()
for plugin in g_pool.plugins:
plugin.alive = False
g_pool.plugins.clean()
glfw.glfwDestroyWindow(main_window)
g_pool.gui.terminate()
glfw.glfwTerminate()
logger.info("Process shutting down.")
def session(rec_dir):
system_plugins = [Log_Display, Seek_Bar, Trim_Marks]
user_launchable_plugins = [
Video_Export_Launcher, Raw_Data_Exporter, Vis_Circle, Vis_Cross,
Vis_Polyline, Vis_Light_Points, Vis_Fixation, Scan_Path,
Gaze_Position_2D_Fixation_Detector, Pupil_Angle_3D_Fixation_Detector,
Vis_Watermark, Manual_Gaze_Correction, Show_Calibration,
Offline_Surface_Tracker, Batch_Exporter, Eye_Video_Overlay,
Annotation_Player, Log_History
] #,Marker_Auto_Trim_Marks
user_launchable_plugins += import_runtime_plugins(
os.path.join(user_dir, 'plugins'))
available_plugins = system_plugins + user_launchable_plugins
name_by_index = [p.__name__ for p in available_plugins]
index_by_name = dict(zip(name_by_index, range(len(name_by_index))))
plugin_by_name = dict(zip(name_by_index, available_plugins))
# Callback functions
def on_resize(window, w, h):
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
graph.adjust_size(w, h)
adjust_gl_view(w, h)
for p in g_pool.plugins:
p.on_window_resize(window, w, h)
def on_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_char(window, char):
g_pool.gui.update_char(char)
def on_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
pos = glfwGetCursorPos(window)
pos = normalize(pos, glfwGetWindowSize(window))
pos = denormalize(
pos,
(frame.img.shape[1], frame.img.shape[0])) # Position in img pixels
for p in g_pool.plugins:
p.on_click(pos, button, action)
def on_pos(window, x, y):
hdpi_factor = float(
glfwGetFramebufferSize(window)[0] / glfwGetWindowSize(window)[0])
g_pool.gui.update_mouse(x * hdpi_factor, y * hdpi_factor)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * y_scroll_factor)
def on_drop(window, count, paths):
for x in range(count):
new_rec_dir = paths[x]
if is_pupil_rec_dir(new_rec_dir):
logger.debug("Starting new session with '%s'" % new_rec_dir)
global rec_dir
rec_dir = new_rec_dir
glfwSetWindowShouldClose(window, True)
else:
logger.error("'%s' is not a valid pupil recording" %
new_rec_dir)
tick = delta_t()
def get_dt():
return next(tick)
update_recording_to_recent(rec_dir)
video_path = [
f for f in glob(os.path.join(rec_dir, "world.*"))
if f[-3:] in ('mp4', 'mkv', 'avi')
][0]
timestamps_path = os.path.join(rec_dir, "world_timestamps.npy")
pupil_data_path = os.path.join(rec_dir, "pupil_data")
meta_info = load_meta_info(rec_dir)
rec_version = read_rec_version(meta_info)
app_version = get_version(version_file)
# log info about Pupil Platform and Platform in player.log
logger.info('Application Version: %s' % app_version)
logger.info('System Info: %s' % get_system_info())
timestamps = np.load(timestamps_path)
# Initialize capture
cap = File_Capture(video_path, timestamps=list(timestamps))
# load session persistent settings
session_settings = Persistent_Dict(os.path.join(user_dir, "user_settings"))
if session_settings.get("version",
VersionFormat('0.0')) < get_version(version_file):
logger.info(
"Session setting are from older version of this app. I will not use those."
)
session_settings.clear()
width, height = session_settings.get('window_size', cap.frame_size)
window_pos = session_settings.get('window_position', (0, 0))
main_window = glfwCreateWindow(
width, height, "Pupil Player: " + meta_info["Recording Name"] + " - " +
rec_dir.split(os.path.sep)[-1], None, None)
glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfwMakeContextCurrent(main_window)
cygl.utils.init()
# load pupil_positions, gaze_positions
pupil_data = load_object(pupil_data_path)
pupil_list = pupil_data['pupil_positions']
gaze_list = pupil_data['gaze_positions']
# create container for globally scoped vars
g_pool = Global_Container()
g_pool.app = 'player'
g_pool.binocular = meta_info.get('Eye Mode', 'monocular') == 'binocular'
g_pool.version = app_version
g_pool.capture = cap
g_pool.timestamps = timestamps
g_pool.play = False
g_pool.new_seek = True
g_pool.user_dir = user_dir
g_pool.rec_dir = rec_dir
g_pool.rec_version = rec_version
g_pool.meta_info = meta_info
g_pool.pupil_positions_by_frame = correlate_data(pupil_list,
g_pool.timestamps)
g_pool.gaze_positions_by_frame = correlate_data(gaze_list,
g_pool.timestamps)
g_pool.fixations_by_frame = [[] for x in g_pool.timestamps
] #populated by the fixation detector plugin
def next_frame(_):
try:
cap.seek_to_frame(cap.get_frame_index())
except FileSeekError:
logger.warning("Could not seek to next frame.")
else:
g_pool.new_seek = True
def prev_frame(_):
try:
cap.seek_to_frame(cap.get_frame_index() - 2)
except FileSeekError:
logger.warning("Could not seek to previous frame.")
else:
g_pool.new_seek = True
def toggle_play(new_state):
logger.warning('play%s' % new_state)
if cap.get_frame_index() > cap.get_frame_count() - 1:
cap.seek_to_frame(1) #avoid pause set by hitting trimmark pause.
logger.warning("End of video - restart at beginning.")
g_pool.play = new_state
def set_scale(new_scale):
g_pool.gui.scale = new_scale
g_pool.gui.collect_menus()
def open_plugin(plugin):
if plugin == "Select to load":
return
g_pool.plugins.add(plugin)
def purge_plugins():
for p in g_pool.plugins:
if p.__class__ in user_launchable_plugins:
p.alive = False
g_pool.plugins.clean()
def do_export(_):
export_range = slice(g_pool.trim_marks.in_mark,
g_pool.trim_marks.out_mark)
export_dir = os.path.join(
g_pool.rec_dir, 'exports',
'%s-%s' % (export_range.start, export_range.stop))
try:
os.makedirs(export_dir)
except OSError as e:
if e.errno != errno.EEXIST:
logger.error("Could not create export dir")
raise e
else:
logger.warning(
"Previous export for range [%s-%s] already exsits - overwriting."
% (export_range.start, export_range.stop))
else:
logger.info('Created export dir at "%s"' % export_dir)
notification = {
'subject': 'should_export',
'range': export_range,
'export_dir': export_dir
}
g_pool.notifications.append(notification)
g_pool.gui = ui.UI()
g_pool.gui.scale = session_settings.get('gui_scale', 1)
g_pool.main_menu = ui.Growing_Menu("Settings",
pos=(-350, 20),
size=(300, 400))
g_pool.main_menu.append(
ui.Button("Close Pupil Player",
lambda: glfwSetWindowShouldClose(main_window, True)))
g_pool.main_menu.append(
ui.Slider('scale',
g_pool.gui,
setter=set_scale,
step=.05,
min=0.75,
max=2.5,
label='Interface Size'))
g_pool.main_menu.append(ui.Info_Text('Player Version: %s' %
g_pool.version))
g_pool.main_menu.append(ui.Info_Text('Recording Version: %s' %
rec_version))
selector_label = "Select to load"
labels = [p.__name__.replace('_', ' ') for p in user_launchable_plugins]
user_launchable_plugins.insert(0, selector_label)
labels.insert(0, selector_label)
g_pool.main_menu.append(
ui.Selector('Open plugin',
selection=user_launchable_plugins,
labels=labels,
setter=open_plugin,
getter=lambda: selector_label))
g_pool.main_menu.append(ui.Button('Close all plugins', purge_plugins))
g_pool.main_menu.append(
ui.Button(
'Reset window size', lambda: glfwSetWindowSize(
main_window, cap.frame_size[0], cap.frame_size[1])))
g_pool.quickbar = ui.Stretching_Menu('Quick Bar', (0, 100), (120, -100))
g_pool.play_button = ui.Thumb('play',
g_pool,
label=unichr(0xf04b).encode('utf-8'),
setter=toggle_play,
hotkey=GLFW_KEY_SPACE,
label_font='fontawesome',
label_offset_x=5,
label_offset_y=0,
label_offset_size=-24)
g_pool.play_button.on_color[:] = (0, 1., .0, .8)
g_pool.forward_button = ui.Thumb('forward',
label=unichr(0xf04e).encode('utf-8'),
getter=lambda: False,
setter=next_frame,
hotkey=GLFW_KEY_RIGHT,
label_font='fontawesome',
label_offset_x=5,
label_offset_y=0,
label_offset_size=-24)
g_pool.backward_button = ui.Thumb('backward',
label=unichr(0xf04a).encode('utf-8'),
getter=lambda: False,
setter=prev_frame,
hotkey=GLFW_KEY_LEFT,
label_font='fontawesome',
label_offset_x=-5,
label_offset_y=0,
label_offset_size=-24)
g_pool.export_button = ui.Thumb('export',
label=unichr(0xf063).encode('utf-8'),
getter=lambda: False,
setter=do_export,
hotkey='e',
label_font='fontawesome',
label_offset_x=0,
label_offset_y=2,
label_offset_size=-24)
g_pool.quickbar.extend([
g_pool.play_button, g_pool.forward_button, g_pool.backward_button,
g_pool.export_button
])
g_pool.gui.append(g_pool.quickbar)
g_pool.gui.append(g_pool.main_menu)
#we always load these plugins
system_plugins = [('Trim_Marks', {}), ('Seek_Bar', {})]
default_plugins = [('Log_Display', {}), ('Scan_Path', {}),
('Vis_Polyline', {}), ('Vis_Circle', {}),
('Video_Export_Launcher', {})]
previous_plugins = session_settings.get('loaded_plugins', default_plugins)
g_pool.notifications = []
g_pool.delayed_notifications = {}
g_pool.plugins = Plugin_List(g_pool, plugin_by_name,
system_plugins + previous_plugins)
# Register callbacks main_window
glfwSetFramebufferSizeCallback(main_window, on_resize)
glfwSetKeyCallback(main_window, on_key)
glfwSetCharCallback(main_window, on_char)
glfwSetMouseButtonCallback(main_window, on_button)
glfwSetCursorPosCallback(main_window, on_pos)
glfwSetScrollCallback(main_window, on_scroll)
glfwSetDropCallback(main_window, on_drop)
#trigger on_resize
on_resize(main_window, *glfwGetFramebufferSize(main_window))
g_pool.gui.configuration = session_settings.get('ui_config', {})
# gl_state settings
basic_gl_setup()
g_pool.image_tex = Named_Texture()
#set up performace graphs:
pid = os.getpid()
ps = psutil.Process(pid)
ts = cap.get_timestamp() - .03
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 110)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = 'CPU %0.1f'
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 110)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f REC FPS"
pupil_graph = graph.Bar_Graph(max_val=1.0)
pupil_graph.pos = (260, 110)
pupil_graph.update_rate = 5
pupil_graph.label = "Confidence: %0.2f"
while not glfwWindowShouldClose(main_window):
#grab new frame
if g_pool.play or g_pool.new_seek:
g_pool.new_seek = False
try:
new_frame = cap.get_frame_nowait()
except EndofVideoFileError:
#end of video logic: pause at last frame.
g_pool.play = False
logger.warning("end of video")
update_graph = True
else:
update_graph = False
frame = new_frame.copy()
events = {}
#report time between now and the last loop interation
events['dt'] = get_dt()
#new positons we make a deepcopy just like the image is a copy.
events['gaze_positions'] = deepcopy(
g_pool.gaze_positions_by_frame[frame.index])
events['pupil_positions'] = deepcopy(
g_pool.pupil_positions_by_frame[frame.index])
if update_graph:
#update performace graphs
for p in events['pupil_positions']:
pupil_graph.add(p['confidence'])
t = new_frame.timestamp
if ts != t:
dt, ts = t - ts, t
fps_graph.add(1. / dt)
g_pool.play_button.status_text = str(frame.index)
#always update the CPU graph
cpu_graph.update()
# publish delayed notifiactions when their time has come.
for n in g_pool.delayed_notifications.values():
if n['_notify_time_'] < time():
del n['_notify_time_']
del g_pool.delayed_notifications[n['subject']]
g_pool.notifications.append(n)
# notify each plugin if there are new notifactions:
while g_pool.notifications:
n = g_pool.notifications.pop(0)
for p in g_pool.plugins:
p.on_notify(n)
# allow each Plugin to do its work.
for p in g_pool.plugins:
p.update(frame, events)
#check if a plugin need to be destroyed
g_pool.plugins.clean()
# render camera image
glfwMakeContextCurrent(main_window)
make_coord_system_norm_based()
g_pool.image_tex.update_from_frame(frame)
g_pool.image_tex.draw()
make_coord_system_pixel_based(frame.img.shape)
# render visual feedback from loaded plugins
for p in g_pool.plugins:
p.gl_display()
graph.push_view()
fps_graph.draw()
cpu_graph.draw()
pupil_graph.draw()
graph.pop_view()
g_pool.gui.update()
#present frames at appropriate speed
cap.wait(frame)
glfwSwapBuffers(main_window)
glfwPollEvents()
session_settings['loaded_plugins'] = g_pool.plugins.get_initializers()
session_settings['gui_scale'] = g_pool.gui.scale
session_settings['ui_config'] = g_pool.gui.configuration
session_settings['window_size'] = glfwGetWindowSize(main_window)
session_settings['window_position'] = glfwGetWindowPos(main_window)
session_settings['version'] = g_pool.version
session_settings.close()
# de-init all running plugins
for p in g_pool.plugins:
p.alive = False
g_pool.plugins.clean()
cap.close()
g_pool.gui.terminate()
glfwDestroyWindow(main_window)
def init_gui(self):
from pyglui import ui
ui_elements = []
# lets define some helper functions:
def gui_load_defaults():
for c in self.uvc_capture.controls:
try:
c.value = c.def_val
except:
pass
def gui_update_from_device():
for c in self.uvc_capture.controls:
c.refresh()
def set_frame_size(new_size):
self.frame_size = new_size
if self.uvc_capture is None:
ui_elements.append(ui.Info_Text('Capture initialization failed.'))
self.g_pool.capture_source_menu.extend(ui_elements)
return
ui_elements.append(ui.Info_Text('{} Controls'.format(self.name)))
sensor_control = ui.Growing_Menu(label='Sensor Settings')
sensor_control.append(ui.Info_Text("Do not change these during calibration or recording!"))
sensor_control.collapsed = False
image_processing = ui.Growing_Menu(label='Image Post Processing')
image_processing.collapsed = True
sensor_control.append(ui.Selector(
'frame_size', self,
setter=set_frame_size,
selection=self.uvc_capture.frame_sizes,
label='Resolution'
))
def frame_rate_getter():
return (self.uvc_capture.frame_rates, [str(fr) for fr in self.uvc_capture.frame_rates])
sensor_control.append(ui.Selector('frame_rate', self, selection_getter=frame_rate_getter, label='Frame rate'))
for control in self.uvc_capture.controls:
c = None
ctl_name = control.display_name
# now we add controls
if control.d_type == bool:
c = ui.Switch('value', control, label=ctl_name, on_val=control.max_val, off_val=control.min_val)
elif control.d_type == int:
c = ui.Slider('value', control, label=ctl_name, min=control.min_val, max=control.max_val, step=control.step)
elif type(control.d_type) == dict:
selection = [value for name, value in control.d_type.items()]
labels = [name for name, value in control.d_type.items()]
c = ui.Selector('value', control, label=ctl_name, selection=selection, labels=labels)
else:
pass
# if control['disabled']:
# c.read_only = True
# if ctl_name == 'Exposure, Auto Priority':
# # the controll should always be off. we set it to 0 on init (see above)
# c.read_only = True
if c is not None:
if control.unit == 'processing_unit':
image_processing.append(c)
else:
sensor_control.append(c)
ui_elements.append(sensor_control)
if image_processing.elements:
ui_elements.append(image_processing)
ui_elements.append(ui.Button("refresh",gui_update_from_device))
ui_elements.append(ui.Button("load defaults",gui_load_defaults))
self.g_pool.capture_source_menu.extend(ui_elements)
def _create_calculate_button(self, gaze_mapper):
return ui.Button(
label="Calculate" if gaze_mapper.empty() else "Recalculate",
function=self._on_click_calculate,
)
def init_gui(self):
self.monitor_idx = 0
self.monitor_names = [glfwGetMonitorName(m) for m in glfwGetMonitors()]
#primary_monitor = glfwGetPrimaryMonitor()
self.info = ui.Info_Text(
"Measure gaze mapping accuracy and precision using a screen based animation: After having calibrated on the screen run this test. To compute results set your world cam FOV and click 'calculate results'."
)
self.g_pool.calibration_menu.append(self.info)
self.menu = ui.Growing_Menu('Controls')
self.g_pool.calibration_menu.append(self.menu)
self.menu.append(
ui.Selector('monitor_idx',
self,
selection=range(len(self.monitor_names)),
labels=self.monitor_names,
label='Monitor'))
self.menu.append(ui.Switch('fullscreen', self, label='Use Fullscreen'))
submenu = ui.Growing_Menu('Error Calculation')
submenu.append(ui.Text_Input('fov', self, 'diagonal camera FV'))
submenu.append(ui.Text_Input('res', self, 'diagonal resolution'))
submenu[-1].read_only = True
submenu.append(
ui.Slider('outlier_thresh',
self,
label='outlier threshold deg',
min=0,
max=10))
submenu.append(ui.Button('calculate result', self.calc_result))
accuracy_help = '''Accuracy is calculated as the average angular
offset (distance) (in degrees of visual angle)
between fixations locations and the corresponding
locations of the fixation targets.'''.replace(
"\n", " ").replace(" ", '')
precision_help = '''Precision is calculated as the Root Mean Square (RMS)
of the angular distance (in degrees of visual angle)
between successive samples during a fixation.'''.replace(
"\n", " ").replace(" ", '')
submenu.append(ui.Info_Text(accuracy_help))
submenu.append(ui.Text_Input('accuracy', self, 'angular accuracy'))
submenu.append(ui.Info_Text(precision_help))
submenu.append(ui.Text_Input('precision', self, 'diagonal resolution'))
self.menu.append(submenu)
submenu = ui.Growing_Menu('Advanced Detector Settings')
submenu.collapsed = True
submenu.append(
ui.Slider('sample_duration',
self,
step=1,
min=10,
max=100,
label='Sample duration'))
self.menu.append(submenu)
self.button = ui.Thumb('active',
self,
setter=self.toggle,
label='Calibrate',
hotkey='c')
self.button.on_color[:] = (.3, .2, 1., .9)
self.g_pool.quickbar.insert(0, self.button)
def ui_elements(self):
ui_elements = []
if self.uvc_capture is None:
ui_elements.append(ui.Info_Text("Local USB: camera disconnected!"))
return ui_elements
ui_elements.append(ui.Info_Text(f"Camera: {self.name} @ Local USB"))
# lets define some helper functions:
def gui_load_defaults():
for c in self.uvc_capture.controls:
try:
c.value = c.def_val
except Exception:
pass
def gui_update_from_device():
for c in self.uvc_capture.controls:
c.refresh()
def set_frame_size(new_size):
self.frame_size = new_size
def set_frame_rate(new_rate):
self.frame_rate = new_rate
self.update_menu()
sensor_control = ui.Growing_Menu(label="Sensor Settings")
sensor_control.append(
ui.Info_Text(
"Do not change these during calibration or recording!"))
sensor_control.collapsed = False
image_processing = ui.Growing_Menu(label="Image Post Processing")
image_processing.collapsed = True
sensor_control.append(
ui.Selector(
"frame_size",
self,
setter=set_frame_size,
selection=self.uvc_capture.frame_sizes,
label="Resolution",
))
def frame_rate_getter():
return (
self.uvc_capture.frame_rates,
[str(fr) for fr in self.uvc_capture.frame_rates],
)
# TODO: potential race condition through selection_getter. Should ensure that
# current selection will always be present in the list returned by the
# selection_getter. Highly unlikely though as this needs to happen between
# having clicked the Selector and the next redraw.
# See https://github.com/pupil-labs/pyglui/pull/112/commits/587818e9556f14bfedd8ff8d093107358745c29b
sensor_control.append(
ui.Selector(
"frame_rate",
self,
selection_getter=frame_rate_getter,
setter=set_frame_rate,
label="Frame rate",
))
if ("Pupil Cam2" in self.uvc_capture.name
or "Pupil Cam3" in self.uvc_capture.name):
special_settings = {200: 28, 180: 31}
def set_exposure_mode(exposure_mode):
self.exposure_mode = exposure_mode
if self.exposure_mode == "auto":
self.preferred_exposure_time = Exposure_Time(
max_ET=special_settings.get(self.frame_rate, 32),
frame_rate=self.frame_rate,
mode=self.exposure_mode,
)
else:
self.preferred_exposure_time = None
logger.info(
f"Exposure mode for camera {self.uvc_capture.name} is now set to "
f"{exposure_mode} mode")
self.update_menu()
sensor_control.append(
ui.Selector(
"exposure_mode",
self,
setter=set_exposure_mode,
selection=["manual", "auto"],
labels=["manual mode", "auto mode"],
label="Exposure Mode",
))
sensor_control.append(
ui.Slider(
"exposure_time",
self,
label="Absolute Exposure Time",
min=1,
max=special_settings.get(self.frame_rate, 32),
step=1,
))
if self.exposure_mode == "auto":
sensor_control[-1].read_only = True
if "Pupil Cam" in self.uvc_capture.name:
blacklist = [
"Auto Focus",
"Absolute Focus",
"Absolute Iris ",
"Scanning Mode ",
"Zoom absolute control",
"Pan control",
"Tilt control",
"Roll absolute control",
"Privacy Shutter control",
]
else:
blacklist = []
if ("Pupil Cam2" in self.uvc_capture.name
or "Pupil Cam3" in self.uvc_capture.name):
blacklist += [
"Auto Exposure Mode",
"Auto Exposure Priority",
"Absolute Exposure Time",
]
for control in self.uvc_capture.controls:
c = None
ctl_name = control.display_name
if ctl_name in blacklist:
continue
# now we add controls
if control.d_type == bool:
c = ui.Switch(
"value",
control,
label=ctl_name,
on_val=control.max_val,
off_val=control.min_val,
)
elif control.d_type == int:
c = ui.Slider(
"value",
control,
label=ctl_name,
min=control.min_val,
max=control.max_val,
step=control.step,
)
elif type(control.d_type) == dict:
selection = [value for name, value in control.d_type.items()]
labels = [name for name, value in control.d_type.items()]
c = ui.Selector("value",
control,
label=ctl_name,
selection=selection,
labels=labels)
else:
pass
# if control['disabled']:
# c.read_only = True
# if ctl_name == 'Exposure, Auto Priority':
# # the controll should always be off. we set it to 0 on init (see above)
# c.read_only = True
if c is not None:
if control.unit == "processing_unit":
image_processing.append(c)
else:
sensor_control.append(c)
ui_elements.append(sensor_control)
if image_processing.elements:
ui_elements.append(image_processing)
ui_elements.append(ui.Button("refresh", gui_update_from_device))
if "Pupil Cam2" in self.uvc_capture.name:
def set_check_stripes(enable_stripe_checks):
self.enable_stripe_checks = enable_stripe_checks
if self.enable_stripe_checks:
self.stripe_detector = Check_Frame_Stripes()
logger.debug(
f"Check Stripes for camera {self.uvc_capture.name} is now on"
)
else:
self.stripe_detector = None
logger.debug(
f"Check Stripes for camera {self.uvc_capture.name} is now off"
)
ui_elements.append(
ui.Switch(
"enable_stripe_checks",
self,
setter=set_check_stripes,
label="Check Stripes",
))
return ui_elements
def update(self,frame,events):
self.current_frame_idx = frame.index
if self.video_export_queue:
self.video_export(self.video_export_queue.pop(0))
if self.surface_export_queue:
self.surface_export(self.surface_export_queue.pop(0))
if self.sections == None:
plugins = [p for p in self.g_pool.plugins if isinstance(p,Offline_Marker_Detector)]
if plugins:
marker_tracker_plugin = plugins[0]
else:
self.update_bar_indicator(False)
return
if marker_tracker_plugin.cache.complete:
#make a marker signal 0 = none, 1 = in, -1=out
in_id = self.in_marker_id
out_id = self.out_marker_id
logger.debug("Looking for trim mark markers: %s,%s"%(in_id,out_id))
in_out_signal = [0]*len(marker_tracker_plugin.cache)
for idx,frame in enumerate(marker_tracker_plugin.cache):
# marker = {'id':msg,'verts':r,'verts_norm':r_norm,'centroid':centroid,"frames_since_true_detection":0}
for marker in frame:
if marker['id'] == in_id:
in_out_signal[idx] +=1
if marker['id'] == out_id:
in_out_signal[idx] -=1
# make a smooth signal
in_out_smooth = np.convolve(in_out_signal,[2./30]*30,mode='same') #mean filter with sum 2 and len 60,
#Mode 'same' returns output of length max(signal, filter).
# find falling edges of in markers clusters
i = -1
in_falling_edge_idx = []
for t,g in groupby(in_out_smooth,lambda x:x>=1):
s = i + 1
i += len(list(g))
if t:
in_falling_edge_idx.append(i)
# find rising edges of out markers clusters
i = -1
out_rising_edge_idx = []
for t,g in groupby(in_out_smooth,lambda x:x<=-1):
s = i + 1
i += len(list(g))
if t:
out_rising_edge_idx.append(s)
events = [('out',idx)for idx in out_rising_edge_idx]+[('in',idx)for idx in in_falling_edge_idx]
manual_markers = [('in',idx) for idx in self.man_in_marks] + [('out',idx) for idx in self.man_out_marks]
events += manual_markers
events.sort(key=lambda x: x[1])
events = [('in',0)]+ events + [('out',len(marker_tracker_plugin.cache))]
self.sections = []
for t,g in groupby(events,lambda x:x[0]):
if t == "in":
last_in_marker_of_this_cluster = list(g)[-1]
section_in_index = last_in_marker_of_this_cluster[1]
else:
#t=="out"
fist_out_marker_of_this_clutser = g.next() #first item in cluster
section_out_index = fist_out_marker_of_this_clutser[1]
self.sections.append((section_in_index,section_out_index))
self.sections = [(s,e) for s,e in self.sections if e-s>10]#we filter out tiny sections
# because they can happen with out markers at video start and in marker at video end.
# Lines for areas that have been cached
self.gl_display_ranges = []
for r in self.sections: # [[0,1],[3,4]]
self.gl_display_ranges += (r[0],0),(r[1],0) #[(0,0),(1,0),(3,0),(4,0)]
if self.sections:
self.activate_section=self.sections[0]
self.menu.elements[:] = []
self.menu.append(ui.Button('remove',self.unset_alive))
self.menu.label
self.menu.append(ui.Slider('in_marker_id',self,min=0,step=1,max=63,label='IN marker id'))
self.menu.append(ui.Slider('out_marker_id',self,min=0,step=1,max=63,label='OUT marker id'))
self.menu.append(ui.Selector('active_section',self,selection=self.sections,setter=self.activate_section,label='set section'))
self.menu.append(ui.Button('video export all sections',self.enqueue_video_export))
self.menu.append(ui.Button('surface export all sections',self.enqueue_surface_export))
self.menu.append(ui.Button('add in_mark here',self.add_manual_in_mark))
self.menu.append(ui.Selector('man_in_mark',selection=self.man_in_marks,setter=self.del_man_in_mark,getter=lambda:"select one",label='del manual in marker'))
self.menu.append(ui.Button('add out mark here',self.add_manual_out_mark))
self.menu.append(ui.Selector('man_out_mark',selection=self.man_out_marks,setter=self.del_man_out_mark,getter=lambda:"select one",label='del manual out marker'))
else:
self.menu.label = "Marker Auto Trim Marks: Waiting for Cacher to finish"
def _create_new_button(self):
return ui.Button(label=self.new_button_label,
function=self._on_click_new_button)
def eye(timebase,
is_alive_flag,
ipc_pub_url,
ipc_sub_url,
ipc_push_url,
user_dir,
version,
eye_id,
overwrite_cap_settings=None):
"""reads eye video and detects the pupil.
Creates a window, gl context.
Grabs images from a capture.
Streams Pupil coordinates.
Reacts to notifications:
``set_detection_mapping_mode``: Sets detection method
``eye_process.should_stop``: Stops the eye process
``recording.started``: Starts recording eye video
``recording.stopped``: Stops recording eye video
``frame_publishing.started``: Starts frame publishing
``frame_publishing.stopped``: Stops frame publishing
Emits notifications:
``eye_process.started``: Eye process started
``eye_process.stopped``: Eye process stopped
Emits data:
``pupil.<eye id>``: Pupil data for eye with id ``<eye id>``
``frame.eye.<eye id>``: Eye frames with id ``<eye id>``
"""
# We deferr the imports becasue of multiprocessing.
# Otherwise the world process each process also loads the other imports.
import zmq
import zmq_tools
zmq_ctx = zmq.Context()
ipc_socket = zmq_tools.Msg_Dispatcher(zmq_ctx, ipc_push_url)
pupil_socket = zmq_tools.Msg_Streamer(zmq_ctx, ipc_pub_url)
notify_sub = zmq_tools.Msg_Receiver(zmq_ctx,
ipc_sub_url,
topics=("notify", ))
# logging setup
import logging
logging.getLogger("OpenGL").setLevel(logging.ERROR)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(logging.INFO)
logger.addHandler(zmq_tools.ZMQ_handler(zmq_ctx, ipc_push_url))
# create logger for the context of this function
logger = logging.getLogger(__name__)
if is_alive_flag.value:
# indicates eye process that this is a duplicated startup
logger.warning('Aborting redundant eye process startup')
return
with Is_Alive_Manager(is_alive_flag, ipc_socket, eye_id, logger):
# general imports
import numpy as np
import cv2
# display
import glfw
from pyglui import ui, graph, cygl
from pyglui.cygl.utils import draw_points, RGBA, draw_polyline
from pyglui.cygl.utils import Named_Texture
from gl_utils import basic_gl_setup, adjust_gl_view, clear_gl_screen
from gl_utils import make_coord_system_pixel_based
from gl_utils import make_coord_system_norm_based
from gl_utils import is_window_visible, glViewport
from ui_roi import UIRoi
# monitoring
import psutil
# helpers/utils
from uvc import get_time_monotonic
from file_methods import Persistent_Dict
from version_utils import VersionFormat
from methods import normalize, denormalize, timer
from av_writer import JPEG_Writer, AV_Writer
from ndsi import H264Writer
from video_capture import source_classes
from video_capture import manager_classes
# Pupil detectors
from pupil_detectors import Detector_2D, Detector_3D, Detector_Dummy
pupil_detectors = {
Detector_2D.__name__: Detector_2D,
Detector_3D.__name__: Detector_3D,
Detector_Dummy.__name__: Detector_Dummy
}
# UI Platform tweaks
if platform.system() == 'Linux':
scroll_factor = 10.0
window_position_default = (600, 300 * eye_id + 30)
elif platform.system() == 'Windows':
scroll_factor = 10.0
window_position_default = (600, 31 + 300 * eye_id)
else:
scroll_factor = 1.0
window_position_default = (600, 300 * eye_id)
icon_bar_width = 50
window_size = None
camera_render_size = None
hdpi_factor = 1.
# g_pool holds variables for this process
g_pool = Global_Container()
# make some constants avaiable
g_pool.user_dir = user_dir
g_pool.version = version
g_pool.app = 'capture'
g_pool.process = 'eye{}'.format(eye_id)
g_pool.timebase = timebase
g_pool.ipc_pub = ipc_socket
def get_timestamp():
return get_time_monotonic() - g_pool.timebase.value
g_pool.get_timestamp = get_timestamp
g_pool.get_now = get_time_monotonic
# Callback functions
def on_resize(window, w, h):
nonlocal window_size
nonlocal camera_render_size
nonlocal hdpi_factor
active_window = glfw.glfwGetCurrentContext()
glfw.glfwMakeContextCurrent(window)
hdpi_factor = float(
glfw.glfwGetFramebufferSize(window)[0] /
glfw.glfwGetWindowSize(window)[0])
g_pool.gui.scale = g_pool.gui_user_scale * hdpi_factor
window_size = w, h
camera_render_size = w - int(icon_bar_width * g_pool.gui.scale), h
g_pool.gui.update_window(w, h)
g_pool.gui.collect_menus()
for g in g_pool.graphs:
g.scale = hdpi_factor
g.adjust_window_size(w, h)
adjust_gl_view(w, h)
glfw.glfwMakeContextCurrent(active_window)
def on_window_key(window, key, scancode, action, mods):
g_pool.gui.update_key(key, scancode, action, mods)
def on_window_char(window, char):
g_pool.gui.update_char(char)
def on_iconify(window, iconified):
g_pool.iconified = iconified
def on_window_mouse_button(window, button, action, mods):
g_pool.gui.update_button(button, action, mods)
def on_pos(window, x, y):
x *= hdpi_factor
y *= hdpi_factor
g_pool.gui.update_mouse(x, y)
if g_pool.u_r.active_edit_pt:
pos = normalize((x, y), camera_render_size)
if g_pool.flip:
pos = 1 - pos[0], 1 - pos[1]
pos = denormalize(pos, g_pool.capture.frame_size)
g_pool.u_r.move_vertex(g_pool.u_r.active_pt_idx, pos)
def on_scroll(window, x, y):
g_pool.gui.update_scroll(x, y * scroll_factor)
def on_drop(window, count, paths):
paths = [paths[x].decode('utf-8') for x in range(count)]
g_pool.capture_manager.on_drop(paths)
g_pool.capture.on_drop(paths)
# load session persistent settings
session_settings = Persistent_Dict(
os.path.join(g_pool.user_dir,
'user_settings_eye{}'.format(eye_id)))
if VersionFormat(session_settings.get("version",
'0.0')) != g_pool.version:
logger.info(
"Session setting are from a different version of this app. I will not use those."
)
session_settings.clear()
g_pool.iconified = False
g_pool.capture = None
g_pool.capture_manager = None
g_pool.flip = session_settings.get('flip', False)
g_pool.display_mode = session_settings.get('display_mode',
'camera_image')
g_pool.display_mode_info_text = {
'camera_image':
"Raw eye camera image. This uses the least amount of CPU power",
'roi':
"Click and drag on the blue circles to adjust the region of interest. The region should be as small as possible, but large enough to capture all pupil movements.",
'algorithm':
"Algorithm display mode overlays a visualization of the pupil detection parameters on top of the eye video. Adjust parameters within the Pupil Detection menu below."
}
capture_manager_settings = session_settings.get(
'capture_manager_settings', ('UVC_Manager', {}))
manager_class_name, manager_settings = capture_manager_settings
manager_class_by_name = {c.__name__: c for c in manager_classes}
g_pool.capture_manager = manager_class_by_name[manager_class_name](
g_pool, **manager_settings)
if eye_id == 0:
cap_src = ["Pupil Cam2 ID0", "Pupil Cam1 ID0", "HD-6000"]
else:
cap_src = ["Pupil Cam2 ID1", "Pupil Cam1 ID1"]
# Initialize capture
default_settings = ('UVC_Source', {
'preferred_names': cap_src,
'frame_size': (320, 240),
'frame_rate': 120
})
capture_source_settings = overwrite_cap_settings or session_settings.get(
'capture_settings', default_settings)
source_class_name, source_settings = capture_source_settings
source_class_by_name = {c.__name__: c for c in source_classes}
g_pool.capture = source_class_by_name[source_class_name](
g_pool, **source_settings)
assert g_pool.capture
g_pool.u_r = UIRoi(
(g_pool.capture.frame_size[1], g_pool.capture.frame_size[0]))
roi_user_settings = session_settings.get('roi')
if roi_user_settings and tuple(
roi_user_settings[-1]) == g_pool.u_r.get()[-1]:
g_pool.u_r.set(roi_user_settings)
pupil_detector_settings = session_settings.get(
'pupil_detector_settings', None)
last_pupil_detector = pupil_detectors[session_settings.get(
'last_pupil_detector', Detector_2D.__name__)]
g_pool.pupil_detector = last_pupil_detector(g_pool,
pupil_detector_settings)
def set_display_mode_info(val):
g_pool.display_mode = val
g_pool.display_mode_info.text = g_pool.display_mode_info_text[val]
def set_detector(new_detector):
g_pool.pupil_detector.deinit_ui()
g_pool.pupil_detector.cleanup()
g_pool.pupil_detector = new_detector(g_pool)
g_pool.pupil_detector.init_ui()
def toggle_general_settings(collapsed):
#this is the menu toggle logic.
# Only one menu can be open.
# If no menu is open the menubar should collapse.
g_pool.menubar.collapsed = collapsed
for m in g_pool.menubar.elements:
m.collapsed = True
general_settings.collapsed = collapsed
# Initialize glfw
glfw.glfwInit()
title = "Pupil Capture - eye {}".format(eye_id)
width, height = g_pool.capture.frame_size
width *= 2
height *= 2
width += icon_bar_width
width, height = session_settings.get('window_size', (width, height))
main_window = glfw.glfwCreateWindow(width, height, title, None, None)
window_pos = session_settings.get('window_position',
window_position_default)
glfw.glfwSetWindowPos(main_window, window_pos[0], window_pos[1])
glfw.glfwMakeContextCurrent(main_window)
cygl.utils.init()
# UI callback functions
def set_scale(new_scale):
g_pool.gui_user_scale = new_scale
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
# gl_state settings
basic_gl_setup()
g_pool.image_tex = Named_Texture()
g_pool.image_tex.update_from_ndarray(
np.ones((1, 1), dtype=np.uint8) + 125)
# setup GUI
g_pool.gui = ui.UI()
g_pool.gui_user_scale = session_settings.get('gui_scale', 1.)
g_pool.menubar = ui.Scrolling_Menu("Settings",
pos=(-500, 0),
size=(-icon_bar_width, 0),
header_pos='left')
g_pool.iconbar = ui.Scrolling_Menu("Icons",
pos=(-icon_bar_width, 0),
size=(0, 0),
header_pos='hidden')
g_pool.gui.append(g_pool.menubar)
g_pool.gui.append(g_pool.iconbar)
general_settings = ui.Growing_Menu('General', header_pos='headline')
general_settings.append(
ui.Selector('gui_user_scale',
g_pool,
setter=set_scale,
selection=[.8, .9, 1., 1.1, 1.2],
label='Interface Size'))
def set_window_size():
f_width, f_height = g_pool.capture.frame_size
f_width *= 2
f_height *= 2
f_width += int(icon_bar_width * g_pool.gui.scale)
glfw.glfwSetWindowSize(main_window, f_width, f_height)
def uroi_on_mouse_button(button, action, mods):
if g_pool.display_mode == 'roi':
if action == glfw.GLFW_RELEASE and g_pool.u_r.active_edit_pt:
g_pool.u_r.active_edit_pt = False
# if the roi interacts we dont want
# the gui to interact as well
return
elif action == glfw.GLFW_PRESS:
x, y = glfw.glfwGetCursorPos(main_window)
# pos = normalize(pos, glfw.glfwGetWindowSize(main_window))
x *= hdpi_factor
y *= hdpi_factor
pos = normalize((x, y), camera_render_size)
if g_pool.flip:
pos = 1 - pos[0], 1 - pos[1]
# Position in img pixels
pos = denormalize(
pos,
g_pool.capture.frame_size) # Position in img pixels
if g_pool.u_r.mouse_over_edit_pt(pos,
g_pool.u_r.handle_size,
g_pool.u_r.handle_size):
# if the roi interacts we dont want
# the gui to interact as well
return
general_settings.append(ui.Button('Reset window size',
set_window_size))
general_settings.append(
ui.Switch('flip', g_pool, label='Flip image display'))
general_settings.append(
ui.Selector('display_mode',
g_pool,
setter=set_display_mode_info,
selection=['camera_image', 'roi', 'algorithm'],
labels=['Camera Image', 'ROI', 'Algorithm'],
label="Mode"))
g_pool.display_mode_info = ui.Info_Text(
g_pool.display_mode_info_text[g_pool.display_mode])
general_settings.append(g_pool.display_mode_info)
detector_selector = ui.Selector(
'pupil_detector',
getter=lambda: g_pool.pupil_detector.__class__,
setter=set_detector,
selection=[Detector_Dummy, Detector_2D, Detector_3D],
labels=['disabled', 'C++ 2d detector', 'C++ 3d detector'],
label="Detection method")
general_settings.append(detector_selector)
g_pool.menubar.append(general_settings)
icon = ui.Icon('collapsed',
general_settings,
label=chr(0xe8b8),
on_val=False,
off_val=True,
setter=toggle_general_settings,
label_font='pupil_icons')
icon.tooltip = 'General Settings'
g_pool.iconbar.append(icon)
toggle_general_settings(False)
g_pool.pupil_detector.init_ui()
g_pool.capture.init_ui()
g_pool.capture_manager.init_ui()
g_pool.writer = None
def replace_source(source_class_name, source_settings):
g_pool.capture.deinit_ui()
g_pool.capture.cleanup()
g_pool.capture = source_class_by_name[source_class_name](
g_pool, **source_settings)
g_pool.capture.init_ui()
if g_pool.writer:
logger.info("Done recording.")
g_pool.writer.release()
g_pool.writer = None
g_pool.replace_source = replace_source # for ndsi capture
# Register callbacks main_window
glfw.glfwSetFramebufferSizeCallback(main_window, on_resize)
glfw.glfwSetWindowIconifyCallback(main_window, on_iconify)
glfw.glfwSetKeyCallback(main_window, on_window_key)
glfw.glfwSetCharCallback(main_window, on_window_char)
glfw.glfwSetMouseButtonCallback(main_window, on_window_mouse_button)
glfw.glfwSetCursorPosCallback(main_window, on_pos)
glfw.glfwSetScrollCallback(main_window, on_scroll)
glfw.glfwSetDropCallback(main_window, on_drop)
# load last gui configuration
g_pool.gui.configuration = session_settings.get('ui_config', {})
# set up performance graphs
pid = os.getpid()
ps = psutil.Process(pid)
ts = g_pool.get_timestamp()
cpu_graph = graph.Bar_Graph()
cpu_graph.pos = (20, 50)
cpu_graph.update_fn = ps.cpu_percent
cpu_graph.update_rate = 5
cpu_graph.label = 'CPU %0.1f'
fps_graph = graph.Bar_Graph()
fps_graph.pos = (140, 50)
fps_graph.update_rate = 5
fps_graph.label = "%0.0f FPS"
g_pool.graphs = [cpu_graph, fps_graph]
# set the last saved window size
on_resize(main_window, *glfw.glfwGetFramebufferSize(main_window))
should_publish_frames = False
frame_publish_format = 'jpeg'
# create a timer to control window update frequency
window_update_timer = timer(1 / 60)
def window_should_update():
return next(window_update_timer)
logger.warning('Process started.')
frame = None
# Event loop
while not glfw.glfwWindowShouldClose(main_window):
if notify_sub.new_data:
t, notification = notify_sub.recv()
subject = notification['subject']
if subject.startswith('eye_process.should_stop'):
if notification['eye_id'] == eye_id:
break
elif subject == 'set_detection_mapping_mode':
if notification['mode'] == '3d':
if not isinstance(g_pool.pupil_detector, Detector_3D):
set_detector(Detector_3D)
detector_selector.read_only = True
elif notification['mode'] == '2d':
if not isinstance(g_pool.pupil_detector, Detector_2D):
set_detector(Detector_2D)
detector_selector.read_only = False
else:
if not isinstance(g_pool.pupil_detector,
Detector_Dummy):
set_detector(Detector_Dummy)
detector_selector.read_only = True
elif subject == 'recording.started':
if notification['record_eye'] and g_pool.capture.online:
record_path = notification['rec_path']
raw_mode = notification['compression']
logger.info(
"Will save eye video to: {}".format(record_path))
video_path = os.path.join(record_path,
"eye{}.mp4".format(eye_id))
if raw_mode and frame and g_pool.capture.jpeg_support:
g_pool.writer = JPEG_Writer(
video_path, g_pool.capture.frame_rate)
elif hasattr(g_pool.capture._recent_frame,
'h264_buffer'):
g_pool.writer = H264Writer(
video_path, g_pool.capture.frame_size[0],
g_pool.capture.frame_size[1],
g_pool.capture.frame_rate)
else:
g_pool.writer = AV_Writer(
video_path, g_pool.capture.frame_rate)
elif subject == 'recording.stopped':
if g_pool.writer:
logger.info("Done recording.")
g_pool.writer.release()
g_pool.writer = None
elif subject.startswith('meta.should_doc'):
ipc_socket.notify({
'subject': 'meta.doc',
'actor': 'eye{}'.format(eye_id),
'doc': eye.__doc__
})
elif subject.startswith('frame_publishing.started'):
should_publish_frames = True
frame_publish_format = notification.get('format', 'jpeg')
elif subject.startswith('frame_publishing.stopped'):
should_publish_frames = False
frame_publish_format = 'jpeg'
elif subject.startswith('start_eye_capture') and notification[
'target'] == g_pool.process:
replace_source(notification['name'], notification['args'])
g_pool.capture.on_notify(notification)
# Get an image from the grabber
event = {}
g_pool.capture.recent_events(event)
frame = event.get('frame')
g_pool.capture_manager.recent_events(event)
if frame:
f_width, f_height = g_pool.capture.frame_size
if (g_pool.u_r.array_shape[0],
g_pool.u_r.array_shape[1]) != (f_height, f_width):
g_pool.pupil_detector.on_resolution_change(
(g_pool.u_r.array_shape[1], g_pool.u_r.array_shape[0]),
g_pool.capture.frame_size)
g_pool.u_r = UIRoi((f_height, f_width))
if should_publish_frames:
try:
if frame_publish_format == "jpeg":
data = frame.jpeg_buffer
elif frame_publish_format == "yuv":
data = frame.yuv_buffer
elif frame_publish_format == "bgr":
data = frame.bgr
elif frame_publish_format == "gray":
data = frame.gray
else:
raise AttributeError()
except AttributeError:
pass
else:
pupil_socket.send(
'frame.eye.%s' % eye_id, {
'width': frame.width,
'height': frame.height,
'index': frame.index,
'timestamp': frame.timestamp,
'format': frame_publish_format,
'__raw_data__': [data]
})
t = frame.timestamp
dt, ts = t - ts, t
try:
fps_graph.add(1. / dt)
except ZeroDivisionError:
pass
if g_pool.writer:
g_pool.writer.write_video_frame(frame)
# pupil ellipse detection
result = g_pool.pupil_detector.detect(
frame, g_pool.u_r, g_pool.display_mode == 'algorithm')
if result is not None:
result['id'] = eye_id
# stream the result
pupil_socket.send('pupil.%s' % eye_id, result)
cpu_graph.update()
# GL drawing
if window_should_update():
if is_window_visible(main_window):
glfw.glfwMakeContextCurrent(main_window)
clear_gl_screen()
if frame:
# switch to work in normalized coordinate space
if g_pool.display_mode == 'algorithm':
g_pool.image_tex.update_from_ndarray(frame.img)
elif g_pool.display_mode in ('camera_image', 'roi'):
g_pool.image_tex.update_from_ndarray(frame.gray)
else:
pass
glViewport(0, 0, *camera_render_size)
make_coord_system_norm_based(g_pool.flip)
g_pool.image_tex.draw()
f_width, f_height = g_pool.capture.frame_size
make_coord_system_pixel_based((f_height, f_width, 3),
g_pool.flip)
if frame and result:
if result['method'] == '3d c++':
eye_ball = result['projected_sphere']
try:
pts = cv2.ellipse2Poly(
(int(eye_ball['center'][0]),
int(eye_ball['center'][1])),
(int(eye_ball['axes'][0] / 2),
int(eye_ball['axes'][1] / 2)),
int(eye_ball['angle']), 0, 360, 8)
except ValueError as e:
pass
else:
draw_polyline(
pts, 2,
RGBA(0., .9, .1,
result['model_confidence']))
if result['confidence'] > 0:
if 'ellipse' in result:
pts = cv2.ellipse2Poly(
(int(result['ellipse']['center'][0]),
int(result['ellipse']['center'][1])),
(int(result['ellipse']['axes'][0] / 2),
int(result['ellipse']['axes'][1] / 2)),
int(result['ellipse']['angle']), 0, 360,
15)
confidence = result['confidence'] * 0.7
draw_polyline(pts, 1,
RGBA(1., 0, 0, confidence))
draw_points([result['ellipse']['center']],
size=20,
color=RGBA(1., 0., 0., confidence),
sharpness=1.)
glViewport(0, 0, *camera_render_size)
make_coord_system_pixel_based((f_height, f_width, 3),
g_pool.flip)
# render the ROI
g_pool.u_r.draw(g_pool.gui.scale)
if g_pool.display_mode == 'roi':
g_pool.u_r.draw_points(g_pool.gui.scale)
glViewport(0, 0, *window_size)
make_coord_system_pixel_based((*window_size[::-1], 3),
g_pool.flip)
# render graphs
fps_graph.draw()
cpu_graph.draw()
# render GUI
unused_elements = g_pool.gui.update()
for butt in unused_elements.buttons:
uroi_on_mouse_button(*butt)
make_coord_system_pixel_based((*window_size[::-1], 3),
g_pool.flip)
g_pool.pupil_detector.visualize(
) # detector decides if we visualize or not
# update screen
glfw.glfwSwapBuffers(main_window)
glfw.glfwPollEvents()
# END while running
# in case eye recording was still runnnig: Save&close
if g_pool.writer:
logger.info("Done recording eye.")
g_pool.writer = None
glfw.glfwRestoreWindow(main_window) # need to do this for windows os
# save session persistent settings
session_settings['gui_scale'] = g_pool.gui_user_scale
session_settings['roi'] = g_pool.u_r.get()
session_settings['flip'] = g_pool.flip
session_settings['display_mode'] = g_pool.display_mode
session_settings['ui_config'] = g_pool.gui.configuration
session_settings[
'capture_settings'] = g_pool.capture.class_name, g_pool.capture.get_init_dict(
)
session_settings[
'capture_manager_settings'] = g_pool.capture_manager.class_name, g_pool.capture_manager.get_init_dict(
)
session_settings['window_size'] = glfw.glfwGetWindowSize(main_window)
session_settings['window_position'] = glfw.glfwGetWindowPos(
main_window)
session_settings['version'] = str(g_pool.version)
session_settings[
'last_pupil_detector'] = g_pool.pupil_detector.__class__.__name__
session_settings[
'pupil_detector_settings'] = g_pool.pupil_detector.get_settings()
session_settings.close()
g_pool.capture.deinit_ui()
g_pool.capture_manager.deinit_ui()
g_pool.pupil_detector.deinit_ui()
g_pool.pupil_detector.cleanup()
g_pool.capture_manager.cleanup()
g_pool.capture.cleanup()
glfw.glfwDestroyWindow(main_window)
g_pool.gui.terminate()
glfw.glfwTerminate()
logger.info("Process shutting down.")
def add_auto_select_button(self):
from pyglui import ui
self.menu.append(
ui.Button("Start with default devices", self.auto_select_manager))