# Authors: The MNE-Python contributors.
# License: BSD-3-Clause
# Copyright the MNE-Python contributors.
import numpy as np
import pytest
from mne.datasets.testing import data_path, requires_testing_data
from ..calibration import Calibration, read_eyelink_calibration
# for test_read_eylink_calibration
testing_path = data_path(download=False)
fname = testing_path / "eyetrack" / "test_eyelink.asc"
# for test_create_calibration
POSITIONS = np.array([[115.0, 540.0], [960.0, 540.0], [1804.0, 540.0]])
OFFSETS = np.array([0.42, 0.23, 0.17])
GAZES = np.array([[101.5, 554.8], [9.9, -4.1], [1795.9, 539.0]])
EXPECTED_REPR = (
"Calibration |\n"
" onset: 0 seconds\n"
" model: H3\n"
" eye: right\n"
" average error: 0.5 degrees\n"
" max error: 1.0 degrees\n"
" screen size: (0.531, 0.298) meters\n"
" screen distance: 0.065 meters\n"
" screen resolution: (1920, 1080) pixels\n"
)
@pytest.mark.parametrize(
(
"onset, model, eye, avg_error, max_error, positions, offsets, gaze,"
" screen_size, screen_distance, screen_resolution"
),
[
(
0,
"H3",
"right",
0.5,
1.0,
POSITIONS,
OFFSETS,
GAZES,
(0.531, 0.298),
0.065,
(1920, 1080),
),
(None, None, None, None, None, None, None, None, None, None, None),
],
)
def test_create_calibration(
onset,
model,
eye,
avg_error,
max_error,
positions,
offsets,
gaze,
screen_size,
screen_distance,
screen_resolution,
):
"""Test creating a Calibration object."""
kwargs = dict(
onset=onset,
model=model,
eye=eye,
avg_error=avg_error,
max_error=max_error,
positions=positions,
offsets=offsets,
gaze=gaze,
screen_size=screen_size,
screen_distance=screen_distance,
screen_resolution=screen_resolution,
)
cal = Calibration(**kwargs)
assert cal["onset"] == onset
assert cal["model"] == model
assert cal["eye"] == eye
assert cal["avg_error"] == avg_error
assert cal["max_error"] == max_error
if positions is not None:
assert isinstance(cal["positions"], np.ndarray)
assert np.array_equal(cal["positions"], np.array(POSITIONS))
else:
assert cal["positions"] is None
if offsets is not None:
assert isinstance(cal["offsets"], np.ndarray)
assert np.array_equal(cal["offsets"], np.array(OFFSETS))
if gaze is not None:
assert isinstance(cal["gaze"], np.ndarray)
assert np.array_equal(cal["gaze"], np.array(GAZES))
assert cal["screen_size"] == screen_size
assert cal["screen_distance"] == screen_distance
assert cal["screen_resolution"] == screen_resolution
# test copy method
copied_obj = cal.copy()
# Check if the copied object is an instance of Calibration
assert isinstance(copied_obj, Calibration)
# Check if the an attribute of the copied object is equal to the original object
assert copied_obj["onset"] == cal["onset"]
# Modify the copied object and check if it is independent from the original object
copied_obj["onset"] = 20
assert copied_obj["onset"] != cal["onset"]
# test __repr__
if cal["onset"] is not None:
assert repr(cal) == EXPECTED_REPR # test __repr__
@requires_testing_data
@pytest.mark.parametrize("fname", [(fname)])
def test_read_calibration(fname):
"""Test reading calibration data from an eyelink asc file."""
calibrations = read_eyelink_calibration(fname)
# These numbers were pulled from the file and confirmed.
POSITIONS_L = (
[960, 540],
[960, 92],
[960, 987],
[115, 540],
[1804, 540],
[216, 145],
[1703, 145],
[216, 934],
[1703, 934],
[537, 316],
[1382, 316],
[537, 763],
[1382, 763],
)
DIFF_L = (
[9.9, -4.1],
[-7.8, 16.0],
[-1.9, -14.2],
[13.5, -14.8],
[8.1, 1.0],
[-7.0, -15.4],
[-10.1, -1.4],
[-0.3, 6.9],
[-32.3, -28.1],
[8.2, 7.6],
[9.6, 2.1],
[-10.6, -2.0],
[-11.8, 8.4],
)
GAZE_L = np.array(POSITIONS_L) + np.array(DIFF_L)
POSITIONS_R = (
[960, 540],
[960, 92],
[960, 987],
[115, 540],
[1804, 540],
[216, 145],
[1703, 145],
[216, 934],
[1703, 934],
[537, 316],
[1382, 316],
[537, 763],
[1382, 763],
)
DIFF_R = (
[-5.2, -16.1],
[23.7, 1.3],
[2.0, -9.3],
[4.4, 1.5],
[-6.5, -12.7],
[16.6, -7.5],
[5.7, -1.8],
[15.4, -3.5],
[-2.0, -10.2],
[0.1, 8.3],
[1.9, -15.8],
[-24.8, -2.3],
[3.2, -9.2],
)
GAZE_R = np.array(POSITIONS_R) + np.array(DIFF_R)
OFFSETS_R = [
0.36,
0.50,
0.20,
0.10,
0.30,
0.38,
0.13,
0.33,
0.22,
0.18,
0.34,
0.52,
0.21,
]
assert len(calibrations) == 2 # calibration[0] is left, calibration[1] is right
np.testing.assert_allclose(calibrations[0]["onset"], -6.85)
np.testing.assert_allclose(calibrations[1]["onset"], -6.85)
assert calibrations[0]["model"] == "HV13"
assert calibrations[1]["model"] == "HV13"
assert calibrations[0]["eye"] == "left"
assert calibrations[1]["eye"] == "right"
assert calibrations[0]["avg_error"] == 0.30
assert calibrations[0]["max_error"] == 0.90
assert calibrations[1]["avg_error"] == 0.31
assert calibrations[1]["max_error"] == 0.52
np.testing.assert_array_equal(POSITIONS_L, calibrations[0]["positions"])
np.testing.assert_array_equal(POSITIONS_R, calibrations[1]["positions"])
np.testing.assert_array_equal(GAZE_L, calibrations[0]["gaze"])
np.testing.assert_array_equal(GAZE_R, calibrations[1]["gaze"])
np.testing.assert_array_equal(OFFSETS_R, calibrations[1]["offsets"])
@requires_testing_data
@pytest.mark.parametrize(
"fname, axes",
[(fname, None), (fname, True)],
)
def test_plot_calibration(fname, axes):
"""Test plotting calibration data."""
import matplotlib.pyplot as plt
# Set the non-interactive backend
plt.switch_backend("agg")
if axes:
axes = plt.subplot()
calibrations = read_eyelink_calibration(fname)
cal_left = calibrations[0]
fig = cal_left.plot(show=True, show_offsets=True, axes=axes)
ax = fig.axes[0]
scatter1 = ax.collections[0]
scatter2 = ax.collections[1]
px, py = cal_left["positions"].T
gaze_x, gaze_y = cal_left["gaze"].T
assert ax.title.get_text() == f"Calibration ({cal_left['eye']} eye)"
assert len(ax.collections) == 2 # Two scatter plots
np.testing.assert_allclose(scatter1.get_offsets(), np.column_stack((px, py)))
np.testing.assert_allclose(
scatter2.get_offsets(), np.column_stack((gaze_x, gaze_y))
)
plt.close(fig)
Datasets
Models
