def set_hmd_lens_configuration(core_eyetracker, lens_configuration): if not isinstance(lens_configuration, HMDLensConfiguration): raise ValueError("Lens configuration must be a HMDLensConfiguration object.") status = __call_function("set_hmd_lens_configuration", (core_eyetracker, lens_configuration.left, lens_configuration.right)) _on_error_raise_exception(status[0])
def hmd_based_calibration_collect_data(core_eyetracker, x, y, z): status = __call_function("hmd_based_calibration_collect_data", (core_eyetracker, x, y, z)) try: _on_error_raise_exception(status[0]) return _tobii_pro_calibration_success except EyeTrackerOperationFailedError: pass return _tobii_pro_calibration_failure
def set_display_area(core_eyetracker, display_area): if not isinstance(display_area, DisplayArea): raise ValueError("Display area must be a DisplayArea object.") status = __call_function("set_display_area", (core_eyetracker, display_area.top_left, display_area.top_right, display_area.bottom_left)) _on_error_raise_exception(status[0])
def hmd_based_calibration_compute_and_apply(core_eyetracker): status = __call_function("calibration_compute_and_apply", (core_eyetracker,)) try: _on_error_raise_exception(status[0]) result = __call_function("hmd_based_calibration_get_calibration_points", (core_eyetracker,)) _on_error_raise_exception(result[0]) return (_tobii_pro_calibration_success, [TobiiProCalibrationPoint(x) for x in result[1]]) except EyeTrackerOperationFailedError: pass return (_tobii_pro_calibration_failure,)
def unsubscribe_from(self, subscription_type, callback=None): '''Unsubscribes from data for the eye tracker. See @ref find_all_eyetrackers or EyeTracker.__init__ on how to create an EyeTracker object. You can unsubscribe from @ref EYETRACKER_EXTERNAL_SIGNAL, @ref EYETRACKER_EYE_IMAGES, @ref EYETRACKER_GAZE_DATA, @ref EYETRACKER_HMD_GAZE_DATA, @ref EYETRACKER_USER_POSITION_GUIDE, @ref EYETRACKER_NOTIFICATION_CONNECTION_LOST, @ref EYETRACKER_NOTIFICATION_CONNECTION_RESTORED, @ref EYETRACKER_NOTIFICATION_CALIBRATION_MODE_ENTERED, @ref EYETRACKER_NOTIFICATION_CALIBRATION_MODE_LEFT, @ref EYETRACKER_NOTIFICATION_CALIBRATION_CHANGED, @ref EYETRACKER_NOTIFICATION_TRACK_BOX_CHANGED, @ref EYETRACKER_NOTIFICATION_DISPLAY_AREA_CHANGED, @ref EYETRACKER_NOTIFICATION_GAZE_OUTPUT_FREQUENCY_CHANGED, @ref EYETRACKER_NOTIFICATION_EYE_TRACKING_MODE_CHANGED, @ref EYETRACKER_NOTIFICATION_DEVICE_FAULTS, @ref EYETRACKER_NOTIFICATION_DEVICE_WARNINGS, @ref EYETRACKER_TIME_SYNCHRONIZATION_DATA or @ref EYETRACKER_STREAM_ERRORS. <CodeExample>gaze_data.py</CodeExample> Args: subscription_type: Type of data to unsubscribe from. callback: Callback sent to subscribe_to or None to unsubscribe all subscriptions of this type. ''' global _available_notification_subscriptions global _EYETRACKER_NOTIFICATIONS_BASE # Special handling of notification subscribtions. if subscription_type in _available_notification_subscriptions.keys(): with self.__notification_subscription_lock: if subscription_type in self.__notification_subscriptions: if callback in self.__notification_subscriptions[ subscription_type]: del self.__notification_subscriptions[ subscription_type][callback] if callback is None or len( self.__notification_subscriptions[ subscription_type]) == 0: del self.__notification_subscriptions[ subscription_type] if len(self.__notification_subscriptions) == 0: self.unsubscribe_from(_EYETRACKER_NOTIFICATIONS, None) else: if subscription_type not in _subscription_types: _on_error_raise_exception(_invalid_parameter) with self.__subscription_lock: if subscription_type in self.__subscriptions: if callback in self.__subscriptions[subscription_type]: del self.__subscriptions[subscription_type][callback] if callback is None or len( self.__subscriptions[subscription_type]) == 0: del self.__subscriptions[subscription_type] interop.unsubscribe_from( _subscription_types[subscription_type] ["type_index"], self, self.__core_eyetracker)
def subscribe_to(subscription_type, stream_name, tracker, core_eyetracker, callback): global __callbacks global __callback_lock global __subscribe_lock with __subscribe_lock: subscription_tuple = (subscription_type, core_eyetracker) with __callback_lock: __callbacks.setdefault(subscription_tuple, {})[tracker] =\ TobiiProCallback(core_eyetracker, stream_name, callback) count = len(__callbacks[subscription_tuple]) if count == 1: status = __call_function("subscribe_to", (subscription_type, core_eyetracker, lambda x: __subscription_callback(subscription_type, core_eyetracker, x))) _on_error_raise_exception(status[0])
def screen_based_monocular_calibration_collect_data(core_eyetracker, x, y, eye_to_calculate): result = __call_function("screen_based_monocular_calibration_collect_data", (core_eyetracker, x, y, eye_to_calculate)) try: _on_error_raise_exception(result[0]) except EyeTrackerOperationFailedError: return result[0] calibration_status = _tobii_pro_calibration_failure if result[1] == _tobii_pro_selected_eye_left: calibration_status = _tobii_pro_calibration_success_left_eye elif result[1] == _tobii_pro_selected_eye_right: calibration_status = _tobii_pro_calibration_success_right_eye elif result[1] == _tobii_pro_selected_eye_both: calibration_status = _tobii_pro_calibration_success return calibration_status
def subscribe_to(self, subscription_type, callback, as_dictionary=False): '''Subscribes to data for the eye tracker. See @ref find_all_eyetrackers or EyeTracker.__init__ on how to create an EyeTracker object. You can subscribe to @ref EYETRACKER_EXTERNAL_SIGNAL, @ref EYETRACKER_EYE_IMAGES, @ref EYETRACKER_HMD_GAZE_DATA, @ref EYETRACKER_GAZE_DATA, @ref EYETRACKER_USER_POSITION_GUIDE, @ref EYETRACKER_NOTIFICATION_CONNECTION_LOST, @ref EYETRACKER_NOTIFICATION_CONNECTION_RESTORED, @ref EYETRACKER_NOTIFICATION_CALIBRATION_MODE_ENTERED, @ref EYETRACKER_NOTIFICATION_CALIBRATION_MODE_LEFT, @ref EYETRACKER_NOTIFICATION_CALIBRATION_CHANGED, @ref EYETRACKER_NOTIFICATION_TRACK_BOX_CHANGED, @ref EYETRACKER_NOTIFICATION_DISPLAY_AREA_CHANGED, @ref EYETRACKER_NOTIFICATION_GAZE_OUTPUT_FREQUENCY_CHANGED, @ref EYETRACKER_NOTIFICATION_EYE_TRACKING_MODE_CHANGED, @ref EYETRACKER_NOTIFICATION_DEVICE_FAULTS, @ref EYETRACKER_NOTIFICATION_DEVICE_WARNINGS, @ref EYETRACKER_TIME_SYNCHRONIZATION_DATA or @ref EYETRACKER_STREAM_ERRORS. <CodeExample>gaze_data.py</CodeExample> Args: subscription_type: Type of data to subscribe to. callback: Callback receiveing the data. See documentation of subscription types for details. as_dictionary: If True, the callback will receive a dictionary with values instead of a custom object. ''' global _available_notification_subscriptions global _EYETRACKER_NOTIFICATIONS_BASE global _subscription_types if not callable(callback): _on_error_raise_exception(_invalid_parameter) # Special handling of notification subscribtions. if subscription_type in _available_notification_subscriptions.keys(): with self.__notification_subscription_lock: # Subscribing more than once for the same type with the same callback is invalid. if ((subscription_type in self.__notification_subscriptions and callback in self.__notification_subscriptions[subscription_type])): _on_error_raise_exception(_invalid_operation) count = len(self.__notification_subscriptions) self.__notification_subscriptions.setdefault( subscription_type, {})[callback] = as_dictionary if count == 0: self.subscribe_to(_EYETRACKER_NOTIFICATIONS, self.__notification_callback) else: if subscription_type not in _subscription_types: _on_error_raise_exception(_invalid_parameter) with self.__subscription_lock: # Subscribing more than once for the same type with the same callback is invalid. if subscription_type in self.__subscriptions and callback in self.__subscriptions[ subscription_type]: _on_error_raise_exception(_invalid_operation) self.__subscriptions.setdefault(subscription_type, {})[callback] = as_dictionary if len(self.__subscriptions[subscription_type]) == 1: interop.subscribe_to( _subscription_types[subscription_type]["type_index"], _subscription_types[subscription_type]["stream_name"], self, self.__core_eyetracker, lambda x, st=subscription_type: self. __subscription_callback(st, x))
def screen_based_monocular_calibration_compute_and_apply(core_eyetracker): status = __call_function("monocular_calibration_compute_and_apply", (core_eyetracker,)) try: _on_error_raise_exception(status[0]) result = __call_function("screen_based_calibration_get_calibration_points", (core_eyetracker,)) _on_error_raise_exception(result[0]) calibration_status = _tobii_pro_calibration_failure if status[1] == _tobii_pro_selected_eye_left: calibration_status = _tobii_pro_calibration_success_left_eye elif status[1] == _tobii_pro_selected_eye_right: calibration_status = _tobii_pro_calibration_success_right_eye elif status[1] == _tobii_pro_selected_eye_both: calibration_status = _tobii_pro_calibration_success return (calibration_status, [TobiiProCalibrationPoint(x) for x in result[1]]) except EyeTrackerOperationFailedError: return (_tobii_pro_calibration_failure,)
def unsubscribe_from(subscription_type, tracker, core_eyetracker): global __callbacks global __callback_lock global __subscribe_lock with __subscribe_lock: subscription_tuple = (subscription_type, core_eyetracker) unsubscribe = False with __callback_lock: if subscription_tuple in __callbacks: if tracker in __callbacks[subscription_tuple]: del __callbacks[subscription_tuple][tracker] if len(__callbacks[subscription_tuple]) == 0: del __callbacks[subscription_tuple] unsubscribe = True if unsubscribe: status = __call_function("unsubscribe_from", (subscription_type, core_eyetracker)) _on_error_raise_exception(status[0])
def get_hmd_lens_configuration(core_eyetracker): result = __call_function("get_hmd_lens_configuration", (core_eyetracker,)) _on_error_raise_exception(result[0]) return HMDLensConfiguration(result[1]['left'], result[1]['right'])
def get_device_data(core_eyetracker): result = __call_function("get_device_data", (core_eyetracker,)) _on_error_raise_exception(result[0]) return TobiiProEyeTrackerData(result[1])
def get_display_area(core_eyetracker): result = __call_function("get_display_area", (core_eyetracker,)) _on_error_raise_exception(result[0]) return DisplayArea(result[1])
def calibration_apply(core_eyetracker, data): if not isinstance(data, bytes): raise ValueError("Calibration data must be applied with a bytes object.") status = __call_function("calibration_apply", (core_eyetracker, data)) _on_error_raise_exception(status[0])
def calibration_retrieve(core_eyetracker): result = __call_function("calibration_retrieve", (core_eyetracker,)) _on_error_raise_exception(result[0]) return result[1]
def set_gaze_output_frequency(core_eyetracker, frame_rate): status = __call_function("set_gaze_output_frequency", (core_eyetracker, frame_rate)) _on_error_raise_exception(status[0])
def clear_applied_licenses(core_eyetracker): status = __call_function("clear_applied_licenses", (core_eyetracker,)) _on_error_raise_exception(status[0])
def get_system_time_stamp(): result = __call_function("get_system_time_stamp", ()) _on_error_raise_exception(result[0]) return result[1]
def set_device_name(core_eyetracker, device_name): status = __call_function("set_device_name", (core_eyetracker, device_name)) _on_error_raise_exception(status[0])
def calibration_leave_calibration_mode(core_eyetracker): status = __call_function("calibration_leave_calibration_mode", (core_eyetracker,)) _on_error_raise_exception(status[0])
def set_eye_tracking_mode(core_eyetracker, eye_tracking_mode): status = __call_function("set_eye_tracking_mode", (core_eyetracker, eye_tracking_mode)) _on_error_raise_exception(status[0])
def get_eye_tracking_mode(core_eyetracker): result = __call_function("get_eye_tracking_mode", (core_eyetracker,)) _on_error_raise_exception(result[0]) return result[1]
def get_device(address): result = __call_function("get_device", (address,)) _on_error_raise_exception(result[0]) return TobiiProEyeTrackerData(result[1])
def apply_licenses(core_eyetracker, licenses): result = __call_function("apply_licenses", (core_eyetracker, licenses)) _on_error_raise_exception(result[0]) return tuple([FailedLicense(key, validation) for key, validation in zip(licenses, result[1]) if validation != 0])
def get_track_box(core_eyetracker): result = __call_function("get_track_box", (core_eyetracker,)) _on_error_raise_exception(result[0]) return TrackBox(result[1])
def get_gaze_output_frequency(core_eyetracker): result = __call_function("get_gaze_output_frequency", (core_eyetracker,)) _on_error_raise_exception(result[0]) return result[1]
def get_sdk_version(): result = __call_function("get_sdk_version", ()) _on_error_raise_exception(result[0]) return result[1]
def screen_based_calibration_discard_data(core_eyetracker, x, y): status = __call_function("screen_based_calibration_discard_data", (core_eyetracker, x, y)) _on_error_raise_exception(status[0])
def __call_function(function_name, arguments): result_callback = TobiiProResultCallback() call_result = tobii_research_interop.call_function(function_name, arguments, result_callback) _on_error_raise_exception(call_result) return result_callback.get_result()
def screen_based_monocular_calibration_discard_data(core_eyetracker, x, y, eye_to_calculate): status = __call_function("screen_based_monocular_calibration_discard_data", (core_eyetracker, x, y, eye_to_calculate)) _on_error_raise_exception(status[0])