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])
