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