def __init__(self, g_pool):
super().__init__(g_pool)
self.network = ndsi.Network(callbacks=(self.on_event, ))
self.network.start()
self.selected_host = None
self._recover_in = 3
self._rejoin_in = 400
def __init__(self, num_states_changed_callback):
assert callable(num_states_changed_callback)
self.num_states_changed = num_states_changed_callback
self._attached_rec_states = {}
self._network = ndsi.Network(callbacks=(self.on_event, ))
self._network.start()
def __init__(self, linked_device, update_ui_cb):
self.update_ui_cb = update_ui_cb
self.network = ndsi.Network(
formats={ndsi.DataFormat.V4}, callbacks=(self.on_event,)
)
self.network.start()
self.sensor = GazeSensor(self.network, linked_device)
def main():
# Start auto-discovery of Pupil Invisible Companion devices
network = ndsi.Network(formats={ndsi.DataFormat.V4},
callbacks=(on_network_event, ))
network.start()
try:
# Event loop, runs until interrupted
while network.running:
# Check for recently connected/disconnected devices
if network.has_events:
network.handle_event()
# Iterate over all connected devices
for event_sensor in SENSORS.values():
# Fetch recent sensor configuration changes,
# required for pyndsi internals
while event_sensor.has_notifications:
event_sensor.handle_notification()
# Fetch recent event data
for event in event_sensor.fetch_data():
# Output: EventValue(timestamp, label)
print(event_sensor, event)
time.sleep(0.1)
# Catch interruption and disconnect gracefully
except (KeyboardInterrupt, SystemExit):
network.stop()
def __init__(self, g_pool):
super().__init__(g_pool)
self.network = ndsi.Network(callbacks=(self.on_event, ))
self.network.start()
self.selected_host = None
self._recover_in = 3
self._rejoin_in = 400
logger.warning("Make sure the `time_sync` plugin is loaded!")
def __init__(self, g_pool):
super().__init__(g_pool)
self.network = ndsi.Network(
formats={ndsi.DataFormat.V3, ndsi.DataFormat.V4},
callbacks=(self.on_event, ))
self.network.start()
self._recover_in = 3
self._rejoin_in = 400
self.cam_selection_lut = {
"eye0": ["ID0", "PI right"],
"eye1": ["ID1", "PI left"],
"world": ["ID2", "Logitech", "PI world"],
}
def __init__(self, g_pool):
super().__init__(g_pool)
self.network = ndsi.Network(callbacks=(self.on_event, ))
self.network.start()
self.selected_host = None
self._recover_in = 3
self._rejoin_in = 400
self.should_select_host = None
self.cam_selection_lut = {
"eye0": ["ID0", "PI right"],
"eye1": ["ID1", "PI left"],
"world": ["ID2", "Logitech", "PI world"],
}
logger.warning("Make sure the `time_sync` plugin is loaded!")
def __init__(self):
logger.info(f"Using NDSI protocol v{ndsi.__protocol_version__}")
self._hosts = SortedHostDict()
self.network = ndsi.Network(formats={ndsi.DataFormat.V4},
callbacks=(self.on_event, ))
self.network.start()
def __init__(self, g_pool):
super(NDSI_Manager, self).__init__(g_pool)
self.network = ndsi.Network(callbacks=(self.on_event, ))
self.network.start()
self.selected_host = None
logger.debug("%s [%s] %s %s" %
(sensor, event["seq"], event["subject"], event["control_id"]))
def on_network_event(network, event):
if event["subject"] == "attach":
sensor = network.sensor(event["sensor_uuid"],
callbacks=(on_sensor_event, ))
logger.debug("Linking sensor %s..." % sensor)
sensors[event["sensor_uuid"]] = sensor
if event["subject"] == "detach":
logger.debug("Unlinking sensor %s..." % event["sensor_uuid"])
sensors[event["sensor_uuid"]].unlink()
del sensors[event["sensor_uuid"]]
n = ndsi.Network(callbacks=(on_network_event, ))
n.start()
try:
while n.running:
if n.has_events:
n.handle_event()
for s in sensors.values():
if s.has_notifications:
s.handle_notification()
time.sleep(0.1)
except (KeyboardInterrupt, SystemExit):
n.stop()
sys.exit()
def __init__(self):
self.discovered_hosts = set() # Set of discovered hosts with gaze sensors
self.network = ndsi.Network(
formats={ndsi.DataFormat.V4}, callbacks=(self.on_event,)
)
self.network.start()
def runNDSIClient():
global quit
quit = False
# Callback functions
def on_resize(window,w, h):
h = max(h,1)
w = max(w,1)
hdpi_factor = glfwGetFramebufferSize(window)[0]/glfwGetWindowSize(window)[0]
w,h = w*hdpi_factor,h*hdpi_factor
gui.update_window(w,h)
active_window = glfwGetCurrentContext()
glfwMakeContextCurrent(window)
# norm_size = normalize((w,h),glfwGetWindowSize(window))
# fb_size = denormalize(norm_size,glfwGetFramebufferSize(window))
adjust_gl_view(w,h,window)
glfwMakeContextCurrent(active_window)
def on_iconify(window,iconfied):
pass
def on_key(window, key, scancode, action, mods):
gui.update_key(key,scancode,action,mods)
if action == GLFW_PRESS:
if key == GLFW_KEY_ESCAPE:
on_close(window)
if mods == GLFW_MOD_SUPER:
if key == 67:
# copy value to system clipboard
# ideally copy what is in our text input area
test_val = "copied text input"
glfwSetClipboardString(window,test_val)
logger.debug("set clipboard to: {}".format(test_val))
if key == 86:
# copy from system clipboard
clipboard = glfwGetClipboardString(window)
logger.debug("pasting from clipboard: {}".format(clipboard))
def on_char(window,char):
gui.update_char(char)
def on_button(window,button, action, mods):
# logger.debug "button: ", button
# logger.debug "action: ", action
gui.update_button(button,action,mods)
# pos = normalize(pos,glfwGetWindowSize(window))
# pos = denormalize(pos,(frame.img.shape[1],frame.img.shape[0]) ) # Position in img pixels
def on_pos(window,x, y):
hdpi_factor = float(glfwGetFramebufferSize(window)[0]/glfwGetWindowSize(window)[0])
x,y = x*hdpi_factor,y*hdpi_factor
gui.update_mouse(x,y)
def on_scroll(window,x,y):
gui.update_scroll(x,y)
def on_close(window):
global quit
quit = True
logger.info('Process closing from window')
# get glfw started
glfwInit()
window = glfwCreateWindow(width, height, "pyglui demo", None, None)
if not window:
exit()
glfwSetWindowPos(window,0,0)
# Register callbacks for the window
glfwSetWindowSizeCallback(window,on_resize)
glfwSetWindowCloseCallback(window,on_close)
glfwSetWindowIconifyCallback(window,on_iconify)
glfwSetKeyCallback(window,on_key)
glfwSetCharCallback(window,on_char)
glfwSetMouseButtonCallback(window,on_button)
glfwSetCursorPosCallback(window,on_pos)
glfwSetScrollCallback(window,on_scroll)
# test out new paste function
glfwMakeContextCurrent(window)
init()
basic_gl_setup()
logger.debug(glGetString(GL_VERSION))
class Temp(object):
"""Temp class to make objects"""
def __init__(self):
pass
foo = Temp()
foo.bar = 34
foo.mytext = "some text"
def set_text_val(val):
foo.mytext = val
# logger.debug 'setting to :',val
logger.debug("pyglui version: {}".format(ui.__version__))
gui = ui.UI()
gui.scale = 1.0
sensors = {}
def on_network_event(network, event):
if event['subject'] == 'attach': # and event['sensor_type'] == 'video':
wrapper = SensorUIWrapper(gui, n, event['sensor_uuid'])
sensors[event['sensor_uuid']] = wrapper
logger.info('Linking sensor {}...'.format(wrapper.sensor))
logger.debug(pprint.pformat(event))
if event['subject'] == 'detach': # and event['sensor_type'] == 'video':
logger.info('Unlinking sensor {}...'.format(event['sensor_uuid']))
sensors[event['sensor_uuid']].cleanup()
del sensors[event['sensor_uuid']]
n = ndsi.Network(callbacks=(on_network_event,))
n.start()
import os
import psutil
pid = os.getpid()
ps = psutil.Process(pid)
ts = time.time()
from pyglui import graph
logger.debug(graph.__version__)
cpu_g = graph.Line_Graph()
cpu_g.pos = (50,100)
cpu_g.update_fn = ps.cpu_percent
cpu_g.update_rate = 5
cpu_g.label = 'CPU %0.1f'
fps_g = graph.Line_Graph()
fps_g.pos = (50,100)
fps_g.update_rate = 5
fps_g.label = "%0.0f FPS"
fps_g.color[:] = .1,.1,.8,.9
on_resize(window,*glfwGetWindowSize(window))
while not quit:
try:
dt,ts = time.time()-ts,time.time()
clear_gl_screen()
cpu_g.update()
cpu_g.draw()
fps_g.add(1./dt)
fps_g.draw()
gui.update()
glfwSwapBuffers(window)
glfwPollEvents()
# handle ndsi
while n.has_events:
n.handle_event()
for s in sensors.values():
while s.sensor.has_notifications:
s.sensor.handle_notification()
except (KeyboardInterrupt, SystemExit):
quit = True
for sensor in sensors.values():
sensor.cleanup()
sensors = None
n.stop()
gui.terminate()
glfwTerminate()
logger.debug("Process done")
