Eye Tracking Data

1. Overview

SightLab exports eye tracking data including:

• The x, y, z coordinates of the gaze intersection point (combined and per eye)

• Rotational values for each eye (left and right)

2. Coordinate System

2.1 Intersect Point Coordinates

• System: 3D Cartesian coordinate system (X, Y, Z)

• Origin: Center of the virtual environment

• Axes:

  • Positive X: Extends to the right

  • Positive Y: Extends upward

  • Positive Z: Extends outward from the screen

• Units: Meters

• Reference: Coordinates are relative to the parent object's coordinate system

2.2 Eye Rotation

• Represents the rotational orientation of each eye

• Measured in degrees

• Represented as Euler angles

3. Data Types

3.1 Gaze Intersection Data

• Combined gaze: x, y, z coordinates of where the combined gaze intersects with objects in the scene

• Individual eye gaze: x, y, z coordinates for each eye's gaze intersection

3.2 Eye Rotation Data

• Left eye rotation: Rotational values for the left eye in Euler angles

• Right eye rotation: Rotational values for the right eye in Euler angles

4. Data Collection Process

The eye tracking data is collected and processed in the updateGazeObject function within the "sightlab" module. Here's a breakdown of the process:

1. Retrieve the eye tracker's transformation matrix

2. Combine it with the main view matrix to get the gaze direction in the virtual environment

3. Create a line representing the gaze direction

4. Check for intersection with objects in the scene

5. Update the gaze point object's position if there's a valid intersection

6. Record the time, intersection point, main view position, and other relevant flags

5. Code Explanation

def updateGazeObject(self):

    self.eyeTracker = vizconnect.getTracker('eye_tracker').getRaw()    gazeMat = self.eyeTracker.getMatrix()

    gazeMat.postMult(viz.MainView.getMatrix())

    line = gazeMat.getLineForward(1000)

    info = viz.intersect(line.begin, line.end)

    if info.valid and self.gazePointObject is not None:

        self.gazePointObject.setPosition(info.point)

• The function retrieves the eye tracker's matrix, which represents its position and orientation

• It combines this with the main view matrix to get the gaze direction in the virtual environment

• A line is created to represent the gaze direction

• The viz.intersect() function checks if this line intersects with any objects in the scene

• If there's a valid intersection, the gaze point object's position is updated to the intersection point

For Individual Eye Data

def updateTrialData(self, currentTime, point, eyeTracker, maxDistance, label):            

        leftGazeMat = eyeTracker.getMatrix(viz.LEFT_EYE)

        leftEuler = leftGazeMat.getEuler()

        leftGazeMat.postMult(viz.MainView.getMatrix())

        line = leftGazeMat.getLineForward(maxDistance)

        leftInfo = viz.intersect(line.begin, line.end)

        #leftEuler = vizmat.AngleBetweenVector(viz.MainView.getMatrix().getForward(), leftGazeMat.getForward())

        if leftInfo.valid:

            left_eye = leftInfo.point

        else:

            left_eye = vizmat.MoveAlongVector(line.begin, line, maxDistance)

        rightGazeMat = eyeTracker.getMatrix(viz.RIGHT_EYE)

        rightEuler = rightGazeMat.getEuler()

        rightGazeMat.postMult(viz.MainView.getMatrix())

        line = rightGazeMat.getLineForward(maxDistance)

        #rightEuler = vizmat.AngleBetweenVector(viz.MainView.getMatrix().getForward(), rightGazeMat.getForward())

        rightInfo = viz.intersect(line.begin, line.end)

        if leftInfo.valid:

            right_eye = rightInfo.point

        else:

            right_eye = vizmat.MoveAlongVector(line.begin, line, maxDistance)

• Retrieves gaze matrices for the left and right eyes from the eye tracker.

• Extracts the Euler angles (orientation) from these gaze matrices.

• Transforms the gaze matrices to the main view's coordinate system.

• Creates forward gaze lines from the eye positions to a specified maximum distance.

• Performs intersection tests to check if these gaze lines intersect with any objects in the virtual environment.

• Records the intersection points if valid; otherwise, records the points at the maximum distance along the gaze lines.

• Updates the trial data with the calculated gaze intersection points and Euler angles for both eyes.

6. Data Usage and Interpretation

• The x, y, z coordinates of the intersection point represent where the user's gaze meets objects in the virtual environment

• Combined gaze data can be used for general gaze tracking, while individual eye data allows for more detailed analysis

• Eye rotation data can be used to analyze eye movements and potentially detect specific eye behaviors

7. Additional Data

• Additional data based on the VR system in use (e.g., pupil diameter, eye openness)

• Fixation State: Indicates whether the gaze is in a fixation or saccade state

• Saccade Angle: The angle of eye movement during a saccade

• Saccade Velocity: Average and peak velocity during a saccade

• Retrieving the count of views or gaze events for each object in a scene.

• Calculating the total gaze duration and the average gaze duration per object based on total gaze time divided by the number of gaze events.

• Time to First Fixation: Measuring the time it takes for a participant to first fixate on a specific area of interest after a stimulus is presented.

• Fixation Sequence Analysis: The order in which different areas of interest are fixated upon, which can indicate the cognitive process or strategy employed by the viewer.

• Heatmaps

• Scan Paths

• Walk Paths

• Interactive playback

• Area of Interest (AOI) Analysis: Defining specific regions within the visual scene to examine how much and how long subjects look at these areas.

• Gaze Contingent Display: Changing what is shown on the screen based on where the user is looking, often used in dynamic experiments.

For more information see the eye tracking metrics page

Sample Trial Data