def printApplicationStatus(self):
print ''
print 'Headless ioHub Status:'
if self.eyetracker:
print '\tRunning Time: %.3f seconds.'%(Computer.getTime()-self.app_start_time)
print '\tRecording Eye Data: ',self.eyetracker.isRecordingEnabled()
print '\tPrinting Eye Events: ',self.print_eye_event_stream
print '\tPrinting Mouse Events: ',self.print_mouse_event_stream
print '\tPrinting Keyboard Events: ',self.print_keyboard_event_stream
print '\tPrinting Gaze Position: ',self.print_current_gaze_pos
print ''
def findDevice(cls, model=None, product_id=None, timeout=10.0):
tracker_info=None
# check existing detected devices
matching_tracker_infos=[tracker_info for tracker_info in cls.getDetectedTrackerList() if cls._checkForMatch(tracker_info,model,product_id) is True]
if matching_tracker_infos:
return matching_tracker_infos[0]
started_browsing_time=Computer.getTime()
while(Computer.getTime()-started_browsing_time < timeout):
try:
tb_event=TobiiTrackerBrowser.getNextEvent(timeout=0.05)
if tb_event is None:
break
if isinstance(tb_event, TrackerFoundEvent):
tracker_info=tb_event.tracker_info
if TobiiTrackerBrowser._checkForMatch(tracker_info,model,product_id) is True:
return tracker_info
except Queue.Empty:
pass
def getPos(self):
t=0.0
if self.lastPositionTime:
nextFlipTimeEstimate=self.lastPositionTime+self.reportedRetraceInterval
while nextFlipTimeEstimate < Computer.getTime():
nextFlipTimeEstimate+=self.reportedRetraceInterval
self.nextFlipTimeEstimate=nextFlipTimeEstimate
t=nextFlipTimeEstimate-self.startTime
self.pos=(self.amplX*cos(self.wX*t + self.phaseX),
self.amplY*sin(self.wY*t + self.phaseY))
return self.pos
def run(self,*args,**kwargs):
"""
"""
self.keyboard=self.devices.kb
self.display=self.devices.display
self.mouse=self.devices.mouse
self.eyetracker=self.devices.tracker
self.print_eye_event_stream=False
self.print_current_gaze_pos=False
self.print_keyboard_event_stream=False
self.print_mouse_event_stream=False
self.app_start_time=Computer.getTime()
# Loop until we get a keyboard event with the space, Enter (Return),
# or Escape key is pressed.
self.printCommandOptions()
self.printApplicationStatus()
while 1:
# if 'an event handler returns True, quit the program
if self.handleEyeTrackerEvents():
break
if self.handleKeyboardEvents():
break
if self.handleMouseEvents():
break
if self.eyetracker:
self.printGazePosition()
# discard any event we do not need from the online event queues
self.hub.clearEvents('all')
# since realtime access to events on this process does not matter in
# this demo, elt's sleep for 20 msec every loop
time.sleep(0.02)
self.eyetracker.setConnectionState(False)
self.hub.clearEvents('all')
def __init__(self, eyetracker_info=None, product_id=None, model=None, mainloop=None, create_sync_manager=True):
self._eyetracker_info=eyetracker_info
self._requested_product_id=product_id
self._requested_model=model
self._mainloop=mainloop
self._eyetracker=None
self._queue=None
self._tobiiClock = None
self._getTobiiClockResolution=None
self._getTobiiClockTime=None
self._sync_manager = None
self._syncTimeEventDeque=None
self._isRecording=False
if eyetracker_info is None:
if not TobiiTrackerBrowser.isActive():
TobiiTrackerBrowser.start()
self._eyetracker_info=TobiiTrackerBrowser.findDevice(model,product_id)
if self._eyetracker_info:
self._mainloop=TobiiTrackerBrowser.getMainLoop()
TobiiTrackerBrowser.stop()
else:
self._eyetracker_info=TobiiTrackerBrowser.findDevice(model,product_id)
if self._eyetracker_info is None:
raise exceptions.BaseException("Could not find a Tobii Eye Tracker matching requirements.")
if self._mainloop is None:
if TobiiTrackerBrowser.isActive():
self._mainloop=TobiiTrackerBrowser.getMainLoop()
else:
tobii.sdk.init()
self._mainloop = tobii.sdk.mainloop.MainloopThread()
self._mainloop.start()
self._queue=Queue.Queue()
tobii.sdk.eyetracker.Eyetracker.create_async(self._mainloop,self._eyetracker_info,self.on_eyetracker_created)
stime=Computer.getTime()
while Computer.getTime()-stime<10.0:
try:
event=self._queue.get(block=True,timeout=.1)
if isinstance(event,TobiiTrackerCreatedEvent):
self._eyetracker=event.tracker_object
self._eyetracker.events.OnFramerateChanged += self.on_external_framerate_change
self._eyetracker.events.OnHeadMovementBoxChanged += self.on_head_box_change
self._eyetracker.events.OnXConfigurationChanged += self.on_x_series_physical_config_change
break
self._queue.task_done()
except Queue.Empty:
pass
if self._eyetracker is None:
raise exceptions.BaseException("Could not connect to Tobii. Timeout.")
if create_sync_manager:
self._eyetracker.events.OnError += self.on_eyetracker_error
self._tobiiClock = Clock()
self._getTobiiClockResolution=self._tobiiClock.get_resolution
self._getTobiiClockTime=self._tobiiClock.get_time
self._syncTimeEventDeque=collections.deque(maxlen=32)
self._sync_manager = sync.SyncManager(self._tobiiClock,
self._eyetracker_info,
self._mainloop,
self.on_sync_error,
self.on_sync_status)
print '###################################'
print ''
print "Test Creating a connected TobiiTracker class, using first available Tobii:"
tobii_tracker=TobiiTracker()
print "\tCreated a Connected Tobii Tracker OK."
print "\tDetails:"
for k,v in tobii_tracker.getTrackerDetails().iteritems():
print "\t\t{0} {1}".format(k,v)
print ''
print 'Tracker Name: ',tobii_tracker.getName()
print 'Set Tracker Name (to "tracker [time]") ...'
tobii_tracker.setName('tracker %.6f'%Computer.getTime())
print 'Tracker Name now: ',tobii_tracker.getName()
print ''
print 'Tracker Head Movement Box: ',tobii_tracker.getHeadBox()
print ''
print 'Tracker Physical Placement: ',tobii_tracker.getEyeTrackerPhysicalPlacement()
print ''
print 'Tracker Enabled Extensions: ',tobii_tracker.getEnabledExtensions()
print ''
print 'Tracker Available Extensions: ',tobii_tracker.getAvailableExtensions()
print ''
def flip(self,clearBuffer=True):
Window.flip(self,clearBuffer)
return Computer.getTime()
