Eyetracker |

Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | List of all members
pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker Class Reference
Inheritance diagram for pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker:

## Public Member Functions
| __init__ (self, display, address='192.168.71.50', udpport=49152, logfile=settings.LOGFILE, eventdetection=settings.EVENTDETECTION, saccade_velocity_threshold=35, saccade_acceleration_threshold=9500, blink_threshold=settings.BLINKTHRESH, **args)
| __del__ (self)
| __get_log_row__ (self, keys, triggers)
| __get_log_header__ (self, keys, triggers)
| __data_logger__ (self, logfile, frequency, keys, triggers, time_offset)
| start_capturing (self)
| stop_capturing (self)
| calibrate (self, calibrate=True, validate=True)
| set_current_project (self, project_name=None)
| set_current_participant (self, participant_name=None)
| __create_calibration__ (self, project_id, participant_id)
| start_logging (self, logfile, frequency, keys=["mems", "gp", "gp3", "left_eye", "right_eye"], triggers=[], time_offset=0)
| trigger (self, trigger_key, trigger_value)
| stop_logging (self)
| close (self)
| connected (self)
| drift_correction (self, pos=None, fix_triggered=False)
| fix_triggered_drift_correction (self, pos=None, min_samples=10, max_dev=60, reset_threshold=30)
| get_eyetracker_clock_async (self)
| log (self, msg)
| log_var (self, var, val)
| prepare_backdrop (self)
| prepare_drift_correction (self, pos)
| pupil_size (self)
| sample (self)
| send_command (self, cmd)
| set_backdrop (self)
| set_eye_used (self)
| start_recording (self)
| status_msg (self, msg)
| stop_recording (self)
| set_detection_type (self, eventdetection)
| wait_for_event (self, event)
| wait_for_blink_end (self)
| wait_for_blink_start (self)
| wait_for_fixation_end (self)
| wait_for_fixation_start (self)
| wait_for_saccade_end (self)
| wait_for_saccade_start (self)
| is_valid_sample (self, gazepos)
| get_data (self)
| get_mems (self)
| get_gp (self)
| get_gp3 (self)
| get_lefteyedata (self)
| get_righteyedata (self)
Public Member Functions inherited from pygaze._eyetracker.baseeyetracker.BaseEyeTracker
| __init__ (self)
| draw_drift_correction_target (self, x, y)
| draw_calibration_target (self, x, y)
| set_draw_calibration_target_func (self, func)
| set_draw_drift_correction_target_func (self, func)

## Public Attributes
| disp = display
| screen = Screen()
| dispsize = settings.DISPSIZE
| screensize = settings.SCREENSIZE
| screendist = settings.SCREENDIST
tuple | pixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2.0
| kb = Keyboard(keylist=['space', 'escape', 'q'], timeout=1)
| errorbeep = Sound(osc='saw',freq=100, length=100)
| outputfile = logfile
str | description = "experiment"
str | participant = "participant"
int | eye_used = 0
int | left_eye = 0
int | right_eye = 1
int | binocular = 2
int | maxtries = 100
tuple | prevsample = (-1,-1)
int | nvalsamples = 1000
float | fixtresh = 1.5
int | fixtimetresh = 100
| spdtresh = saccade_velocity_threshold
| accthresh = saccade_acceleration_threshold
| blinkthresh = blink_threshold
| eventdetection = eventdetection
int | weightdist = 10
| tobiiglasses = TobiiGlassesController(udpport, address)
dict | triggers_values = {}
bool | logging = False
| current_recording_id = None
| current_participant_id = None
| current_project_id = None
| logger = threading.Timer(0, self.__data_logger__, [logfile, frequency, keys, triggers, time_offset])
Public Attributes inherited from pygaze._eyetracker.baseeyetracker.BaseEyeTracker
| draw_calibration_target = func
| draw_drift_correction_target = func

## Detailed Description

    A class for Tobii Pro Glasses 2 EyeTracker objects

## Constructor & Destructor Documentation

## ◆ __init__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__init__ | ( |  | self,
|  |  | display,
|  |  | address = '192.168.71.50',
|  |  | udpport = 49152,
|  |  | logfile = settings.LOGFILE,
|  |  | eventdetection = settings.EVENTDETECTION,
|  |  | saccade_velocity_threshold = 35,
|  |  | saccade_acceleration_threshold = 9500,
|  |  | blink_threshold = settings.BLINKTHRESH,
|  | ** | args )

    Initializes a TobiiProGlassesTracker instance

            arguments
            display --  a pygaze.display.Display instance

            keyword arguments
            address -- internal ipv4/ipv6 address for Tobii Pro Glasses 2 (default =
                       '192.168.71.50', for IpV6 address use square brackets [fe80::xxxx:xxxx:xxxx:xxxx])
            udpport -- UDP port number for Tobii Pro Glasses data streaming (default = 49152)

## ◆ __del__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__del__ | ( |  | self | ) |

## Member Function Documentation

## ◆ __create_calibration__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__create_calibration__ | ( |  | self,
|  |  | project_id,
|  |  | participant_id )

## ◆ __data_logger__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__data_logger__ | ( |  | self,
|  |  | logfile,
|  |  | frequency,
|  |  | keys,
|  |  | triggers,
|  |  | time_offset )

## ◆ __get_log_header__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__get_log_header__ | ( |  | self,
|  |  | keys,
|  |  | triggers )

## ◆ __get_log_row__()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.__get_log_row__ | ( |  | self,
|  |  | keys,
|  |  | triggers )

## ◆ calibrate()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.calibrate | ( |  | self,
|  |  | calibrate = True,
|  |  | validate = True )

    Calibrates the eye tracking system

            arguments
            None

            keyword arguments
            calibrate   --  Boolean indicating if calibration should be
                        performed (default = True)
            validate    --  Boolean indicating if validation should be performed
                        (default = True)

            returns
            success --  returns True if calibration succeeded, or False if
                        not; in addition a calibration log is added to the
                        log file and some properties are updated (i.e. the
                        thresholds for detection algorithms)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ close()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.close | ( |  | self | ) |

    Neatly close connection to tracker

            arguments
            None

            returns
            None

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ connected()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.connected | ( |  | self | ) |

    Checks if the tracker is connected

            arguments
            None

            returns
            connected   --  True if connection is established, False if not

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ drift_correction()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.drift_correction | ( |  | self,
|  |  | pos = None,
|  |  | fix_triggered = False )

    Performs a drift check

            arguments
            None

            keyword arguments
            pos         -- (x, y) position of the fixation dot or None for
                           a central fixation (default = None)
            fix_triggered   -- Boolean indicating if drift check should be
                           performed based on gaze position (fix_triggered
                           = True) or on spacepress (fix_triggered =
                           False) (default = False)

            returns
            checked     -- Boolaan indicating if drift check is ok (True)
                           or not (False); or calls self.calibrate if 'q'
                           or 'escape' is pressed

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ fix_triggered_drift_correction()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.fix_triggered_drift_correction | ( |  | self,
|  |  | pos = None,
|  |  | min_samples = 10,
|  |  | max_dev = 60,
|  |  | reset_threshold = 30 )

    Performs a fixation triggered drift correction by collecting
            a number of samples and calculating the average distance from the
            fixation position

            arguments
            None

            keyword arguments
            pos         -- (x, y) position of the fixation dot or None for
                           a central fixation (default = None)
            min_samples     -- minimal amount of samples after which an
                           average deviation is calculated (default = 10)
            max_dev     -- maximal deviation from fixation in pixels
                           (default = 60)
            reset_threshold -- if the horizontal or vertical distance in
                           pixels between two consecutive samples is
                           larger than this threshold, the sample
                           collection is reset (default = 30)

            returns
            checked     -- Boolaan indicating if drift check is ok (True)
                           or not (False); or calls self.calibrate if 'q'
                           or 'escape' is pressed

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ get_data()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_data | ( |  | self | ) |

## ◆ get_eyetracker_clock_async()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_eyetracker_clock_async | ( |  | self | ) |

    Retrieve difference between tracker time and experiment time

            arguments
            None

            keyword arguments
            None

            returns
            timediff    --  tracker time minus experiment time

            return self.controller.syncmanager.convert_from_local_to_remote(self.controller.clock.get_time()) - clock.get_time()

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ get_gp()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_gp | ( |  | self | ) |

## ◆ get_gp3()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_gp3 | ( |  | self | ) |

## ◆ get_lefteyedata()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_lefteyedata | ( |  | self | ) |

## ◆ get_mems()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_mems | ( |  | self | ) |

## ◆ get_righteyedata()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.get_righteyedata | ( |  | self | ) |

## ◆ is_valid_sample()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.is_valid_sample | ( |  | self,
|  |  | gazepos )

    Checks if the sample provided is valid, based on Tobii specific
            criteria (for internal use)

            arguments
            gazepos     --  a (x,y) gaze position tuple, as returned by
                            self.sample()

            returns
            valid           --  a Boolean: True on a valid sample, False on
                            an invalid sample

    Not supported for TobiiProGlassesTracker (yet)

## ◆ log()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.log | ( |  | self,
|  |  | msg )

    Writes a message to the log file

            arguments
            msg     -- a string to include in the log file

            returns
            Nothing -- uses native log function of iViewX to include a line
                       in the log file

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ log_var()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.log_var | ( |  | self,
|  |  | var,
|  |  | val )

    Writes a variable to the log file

            arguments
            var     -- variable name
            val     -- variable value

            returns
            Nothing -- uses native log function of iViewX to include a line
                       in the log file in a "var NAME VALUE" layout

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ prepare_backdrop()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.prepare_backdrop | ( |  | self | ) |

    Not supported for TobiiProGlassesTracker (yet)

## ◆ prepare_drift_correction()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.prepare_drift_correction | ( |  | self,
|  |  | pos )

    Not supported for TobiiProGlassesTracker (yet)

## ◆ pupil_size()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.pupil_size | ( |  | self | ) |

    Returns newest available pupil size

            arguments
            None

            returns
            pupilsize   --  a float or -1 on an error

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ sample()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.sample | ( |  | self | ) |

    Returns newest available gaze position

            arguments
            None

            returns
            sample  -- an (x,y) tuple or a (-1,-1) on an error

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ send_command()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.send_command | ( |  | self,
|  |  | cmd )

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ set_backdrop()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.set_backdrop | ( |  | self | ) |

    Not supported for TobiiProGlassesTracker (yet)

## ◆ set_current_participant()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.set_current_participant | ( |  | self,
|  |  | participant_name = None )

## ◆ set_current_project()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.set_current_project | ( |  | self,
|  |  | project_name = None )

## ◆ set_detection_type()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.set_detection_type | ( |  | self,
|  |  | eventdetection )

    Set the event detection type to either PyGaze algorithms, or
            native algorithms as provided by the manufacturer (only if
            available: detection type will default to PyGaze if no native
            functions are available)

            arguments
            eventdetection  --  a string indicating which detection type
                            should be employed: either 'pygaze' for
                            PyGaze event detection algorithms or
                            'native' for manufacturers algorithms (only
                            if available; will default to 'pygaze' if no
                            native event detection is available)
            returns     --  detection type for saccades, fixations and
                            blinks in a tuple, e.g.
                            ('pygaze','native','native') when 'native'
                            was passed, but native detection was not
                            available for saccade detection

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ set_eye_used()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.set_eye_used | ( |  | self | ) |

    Logs the eye_used variable, based on which eye was specified
            (if both eyes are being tracked, the left eye is used)

            arguments
            None

            returns
            Nothing -- logs which eye is used by calling self.log_var, e.g.
                       self.log_var("eye_used", "right")

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ start_capturing()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.start_capturing | ( |  | self | ) |

## ◆ start_logging()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.start_logging | ( |  | self,
|  |  | logfile,
|  |  | frequency,
|  |  | keys = ["mems", "gp", "gp3", "left_eye", "right_eye"],
|  |  | triggers = [],
|  |  | time_offset = 0 )

## ◆ start_recording()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.start_recording | ( |  | self | ) |

    Starts recording eye position

            arguments
            recording_id

            returns
            None        -- sets self.recording to True when recording is
                       successfully started

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ status_msg()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.status_msg | ( |  | self,
|  |  | msg )

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ stop_capturing()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.stop_capturing | ( |  | self | ) |

## ◆ stop_logging()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.stop_logging | ( |  | self | ) |

## ◆ stop_recording()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.stop_recording | ( |  | self | ) |

    Stop recording eye position

            arguments
            None

            returns
            Nothing -- sets self.recording to False when recording is
                       successfully started

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ trigger()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.trigger | ( |  | self,
|  |  | trigger_key,
|  |  | trigger_value )

## ◆ wait_for_blink_end()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_blink_end | ( |  | self | ) |

    Waits for a blink end and returns the blink ending time

            arguments
            None

            returns
            timestamp       --  blink ending time in milliseconds, as
                            measured from experiment begin time

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_blink_start()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_blink_start | ( |  | self | ) |

    Waits for a blink start and returns the blink starting time

            arguments
            None

            returns
            timestamp       --  blink starting time in milliseconds, as
                            measured from experiment begin time

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_event()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_event | ( |  | self,
|  |  | event )

    Waits for event

            arguments
            event       -- an integer event code, one of the following:
                        3 = STARTBLINK
                        4 = ENDBLINK
                        5 = STARTSACC
                        6 = ENDSACC
                        7 = STARTFIX
                        8 = ENDFIX

            returns
            outcome -- a self.wait_for_* method is called, depending on the
                       specified event; the return values of corresponding
                       method are returned

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_fixation_end()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_fixation_end | ( |  | self | ) |

    Returns time and gaze position when a fixation has ended;
            function assumes that a 'fixation' has ended when a deviation of
            more than self.pxfixtresh from the initial fixation position has
            been detected (self.pxfixtresh is created in self.calibration,
            based on self.fixtresh, a property defined in self.__init__)

            arguments
            None

            returns
            time, gazepos   -- time is the starting time in milliseconds (from
                           expstart), gazepos is a (x,y) gaze position
                           tuple of the position from which the fixation
                           was initiated

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_fixation_start()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_fixation_start | ( |  | self | ) |

    Returns starting time and position when a fixation is started;
            function assumes a 'fixation' has started when gaze position
            remains reasonably stable (i.e. when most deviant samples are
            within self.pxfixtresh) for five samples in a row (self.pxfixtresh
            is created in self.calibration, based on self.fixtresh, a property
            defined in self.__init__)

            arguments
            None

            returns
            time, gazepos   -- time is the starting time in milliseconds (from
                           expstart), gazepos is a (x,y) gaze position
                           tuple of the position from which the fixation
                           was initiated

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_saccade_end()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_saccade_end | ( |  | self | ) |

    Returns ending time, starting and end position when a saccade is
            ended; based on Dalmaijer et al. (2013) online saccade detection
            algorithm

            arguments
            None

            returns
            endtime, startpos, endpos   -- endtime in milliseconds (from
                                   expbegintime); startpos and endpos
                                   are (x,y) gaze position tuples

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## ◆ wait_for_saccade_start()

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.wait_for_saccade_start | ( |  | self | ) |

    Returns starting time and starting position when a saccade is
            started; based on Dalmaijer et al. (2013) online saccade detection
            algorithm

            arguments
            None

            returns
            endtime, startpos   -- endtime in milliseconds (from expbegintime);
                           startpos is an (x,y) gaze position tuple

    Not supported for TobiiProGlassesTracker (yet)

Reimplemented from pygaze._eyetracker.baseeyetracker.BaseEyeTracker.

## Member Data Documentation

## ◆ accthresh

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.accthresh = saccade_acceleration_threshold

## ◆ binocular

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.binocular = 2

## ◆ blinkthresh

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.blinkthresh = blink_threshold

## ◆ current_participant_id

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.current_participant_id = None

## ◆ current_project_id

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.current_project_id = None

## ◆ current_recording_id

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.current_recording_id = None

## ◆ description

str pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.description = "experiment"

## ◆ disp

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.disp = display

## ◆ dispsize

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.dispsize = settings.DISPSIZE

## ◆ errorbeep

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.errorbeep = Sound(osc='saw',freq=100, length=100)

## ◆ eventdetection

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.eventdetection = eventdetection

## ◆ eye_used

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.eye_used = 0

## ◆ fixtimetresh

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.fixtimetresh = 100

## ◆ fixtresh

float pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.fixtresh = 1.5

## ◆ kb

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.kb = Keyboard(keylist=['space', 'escape', 'q'], timeout=1)

## ◆ left_eye

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.left_eye = 0

## ◆ logger

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.logger = threading.Timer(0, self.__data_logger__, [logfile, frequency, keys, triggers, time_offset])

## ◆ logging

bool pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.logging = False

## ◆ maxtries

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.maxtries = 100

## ◆ nvalsamples

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.nvalsamples = 1000

## ◆ outputfile

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.outputfile = logfile

## ◆ participant

str pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.participant = "participant"

## ◆ pixpercm

tuple pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.pixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2.0

## ◆ prevsample

tuple pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.prevsample = (-1,-1)

## ◆ right_eye

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.right_eye = 1

## ◆ screen

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.screen = Screen()

## ◆ screendist

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.screendist = settings.SCREENDIST

## ◆ screensize

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.screensize = settings.SCREENSIZE

## ◆ spdtresh

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.spdtresh = saccade_velocity_threshold

## ◆ tobiiglasses

pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.tobiiglasses = TobiiGlassesController(udpport, address)

## ◆ triggers_values

dict pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.triggers_values = {}

## ◆ weightdist

int pygaze._eyetracker.libtobiiglasses.TobiiGlassesTracker.weightdist = 10

The documentation for this class was generated from the following file:

- C:/Users/lurax/eyetrackingTobii/pygaze/_eyetracker/libtobiiglasses.py