path: root/src/argaze.test/GazeFeatures.py

#!/usr/bin/env python

""" """

__author__ = "Théo de la Hogue"
__credits__ = []
__copyright__ = "Copyright 2023, Ecole Nationale de l'Aviation Civile (ENAC)"
__license__ = "BSD"

import unittest
from dataclasses import dataclass

from argaze import GazeFeatures

import numpy
import pandas

def random_gaze_positions(size, frame_dimension: tuple[float, float] = (1, 1)):
    """ Generate random TimeStampedGazePsoitions for testing purpose.
        Timestamps are current time.
        GazePositions are random values.
    """

    import random
    import time

    ts_gaze_positions = GazeFeatures.TimeStampedGazePositions()
    
    for i in range(0, size):

        # Edit gaze position
        random_gaze_position = GazeFeatures.GazePosition((random.random() * frame_dimension[0], random.random() * frame_dimension[1]))

        # Store gaze position
        ts_gaze_positions[time.time()] = random_gaze_position

    return ts_gaze_positions

@dataclass(frozen=True)
class TestFixation(GazeFeatures.Fixation):
    """Define basic fixation class for test."""

    def __post_init__(self):

        super().__post_init__()

        points = self.positions.values()
        points_x, points_y = [p[0] for p in points], [p[1] for p in points]
        points_array = numpy.column_stack([points_x, points_y])
        centroid_array = numpy.array([numpy.mean(points_x), numpy.mean(points_y)])

        # Update frozen focus attribute using centroid
        object.__setattr__(self, 'focus', (centroid_array[0], centroid_array[1]))

@dataclass(frozen=True)
class TestSaccade(GazeFeatures.Saccade):
    """Define basic saccade for test."""

    def __post_init__(self):
        super().__post_init__()

class TestGazePositionClass(unittest.TestCase):
    """Test GazePosition class."""

    def test_new(self):
        """Test GazePosition creation."""
        
        # Check empty GazePosition
        empty_gaze_position = GazeFeatures.GazePosition()

        self.assertEqual(empty_gaze_position.value, (0, 0))
        self.assertEqual(empty_gaze_position[0], 0)
        self.assertEqual(empty_gaze_position[1], 0)

        for v in empty_gaze_position:
            self.assertEqual(v, 0)

        self.assertEqual(empty_gaze_position.precision, 0.)
        self.assertEqual(len(empty_gaze_position), 2)
        self.assertEqual(empty_gaze_position.valid, True)
        self.assertEqual(numpy.array(empty_gaze_position).shape, (2,))

        # Check integer GazePosition
        int_gaze_position = GazeFeatures.GazePosition((123, 456), precision=55)

        self.assertEqual(int_gaze_position.value, (123, 456))
        self.assertEqual(int_gaze_position[0], 123)
        self.assertEqual(int_gaze_position[1], 456)
        self.assertEqual(int_gaze_position.precision, 55)
        self.assertEqual(len(int_gaze_position), 2)
        self.assertEqual(int_gaze_position.valid, True)
        self.assertEqual(numpy.array(empty_gaze_position).shape, (2,))

        # Check float GazePosition
        float_gaze_position = GazeFeatures.GazePosition((1.23, 4.56), precision=5.5)

        self.assertEqual(float_gaze_position.value, (1.23, 4.56))
        self.assertEqual(float_gaze_position[0], 1.23)
        self.assertEqual(float_gaze_position[1], 4.56)
        self.assertEqual(float_gaze_position.precision, 5.5)
        self.assertEqual(len(float_gaze_position), 2)
        self.assertEqual(float_gaze_position.valid, True)
        self.assertEqual(numpy.array(empty_gaze_position).shape, (2,))

    def test_properties(self):
        """Test GazePosition properties cannot be modified after creation."""

        gaze_position = GazeFeatures.GazePosition()

        # Check that gaze position value setting fails
        with self.assertRaises(AttributeError):

            gaze_position.value = (123, 456)

        self.assertNotEqual(gaze_position.value, (123, 456))
        self.assertEqual(gaze_position.value, (0, 0))

    def test_overlapping(self):
        """Test GazePosition overlap method."""

        gaze_position_A = GazeFeatures.GazePosition((0, 0), precision=10)
        gaze_position_B = GazeFeatures.GazePosition((10, 0), precision=10)
        gaze_position_C = GazeFeatures.GazePosition((5, 0), precision=5)
        gaze_position_D = GazeFeatures.GazePosition((4, 0), precision=5)

        self.assertFalse(gaze_position_A.overlap(gaze_position_B))
        self.assertTrue(gaze_position_A.overlap(gaze_position_C))
        self.assertFalse(gaze_position_A.overlap(gaze_position_C, both=True))

        self.assertFalse(gaze_position_B.overlap(gaze_position_A))
        self.assertTrue(gaze_position_B.overlap(gaze_position_C))
        self.assertFalse(gaze_position_B.overlap(gaze_position_C, both=True))

        self.assertFalse(gaze_position_C.overlap(gaze_position_A))
        self.assertFalse(gaze_position_C.overlap(gaze_position_B))

    def test___repr__(self):
        """Test GazePosition string representation."""

        # Check empty GazePosition representation
        self.assertEqual(repr(GazeFeatures.GazePosition()), "{\"value\": [0, 0], \"precision\": 0.0}")

class TestUnvalidGazePositionClass(unittest.TestCase):
    """Test UnvalidGazePosition class."""

    def test_new(self):
        """Test UnvalidGazePosition creation."""

        import math
        
        unvalid_gaze_position = GazeFeatures.UnvalidGazePosition()

        self.assertEqual(unvalid_gaze_position.value, (None, None))
        self.assertEqual(unvalid_gaze_position.precision, None)
        self.assertEqual(unvalid_gaze_position.valid, False)

    def test___repr__(self):
        """Test UnvalidGazePosition string representation."""

        self.assertEqual(repr(GazeFeatures.UnvalidGazePosition()), "{\"message\": null, \"value\": [null, null], \"precision\": null}")

class TestTimeStampedGazePositionsClass(unittest.TestCase):
    """Test TimeStampedGazePositions class."""

    def test___setitem__(self):
        """Test __setitem__ method."""

        ts_gaze_positions = GazeFeatures.TimeStampedGazePositions()
        ts_gaze_positions[0] = GazeFeatures.GazePosition()
        ts_gaze_positions[1] = GazeFeatures.UnvalidGazePosition()
        ts_gaze_positions[2] = {"value": (0, 0), "precision": 0.}

        # Check GazePosition is correctly stored and accessible as a GazePosition
        self.assertIsInstance(ts_gaze_positions[0], GazeFeatures.GazePosition)
        self.assertEqual(ts_gaze_positions[0].valid, True)

        # Check UnvalidGazePosition is correctly stored and accessible as a UnvalidGazePosition
        self.assertIsInstance(ts_gaze_positions[1], GazeFeatures.UnvalidGazePosition)
        self.assertEqual(ts_gaze_positions[1].valid, False)

        # Check dict with "value" and "precision" keys is correctly stored and accessible as a GazePosition
        self.assertIsInstance(ts_gaze_positions[2], GazeFeatures.GazePosition)
        self.assertEqual(ts_gaze_positions[2].valid, True)

        # Check that bad data type insertion fails
        with self.assertRaises(AssertionError):

            ts_gaze_positions[3] = "This string is not a gaze position value."

        # Check that dict with bad keys insertion fails
        with self.assertRaises(AssertionError):

            ts_gaze_positions[4] = {"bad_key": (0, 0), "precision": 0.}

        # Check final lenght
        self.assertEqual(len(ts_gaze_positions), 3)

    def test___repr__(self):
        """Test inherited string representation."""

        ts_gaze_positions = GazeFeatures.TimeStampedGazePositions()

        self.assertEqual(repr(GazeFeatures.TimeStampedGazePositions()), "{}")

        ts_gaze_positions[0] = GazeFeatures.GazePosition()
        
        self.assertEqual(repr(ts_gaze_positions), "{\"0\": {\"value\": [0, 0], \"precision\": 0.0}}")

        ts_gaze_positions[0] = GazeFeatures.UnvalidGazePosition()

        self.assertEqual(repr(ts_gaze_positions), "{\"0\": {\"message\": null, \"value\": [null, null], \"precision\": null}}")

    def test_from_dataframe(self):
        """Test from_dataframe classmethod."""

        data = {'Specific timestamp label': [0, 1, 2, 3, 4], 
                'Specific gaze position x label': [0, 10, numpy.nan, 30, 40], 
                'Specific gaze position y label': [0, 100, numpy.nan, 300, 400]
                }
        dataframe = pandas.DataFrame().from_dict(data)

        ts_gaze_positions = GazeFeatures.TimeStampedGazePositions.from_dataframe(dataframe, timestamp='Specific timestamp label', x='Specific gaze position x label', y='Specific gaze position y label')

        # Check buffer length
        self.assertEqual(len(ts_gaze_positions), 5)

        # Check first gaze position is correctly stored and accessible as a GazePosition
        self.assertIsInstance(ts_gaze_positions[0], GazeFeatures.GazePosition)
        self.assertEqual(ts_gaze_positions[0].precision, 0)
        self.assertEqual(ts_gaze_positions[0].valid, True)

        # Check third gaze position is correctly stored and accessible as a UnvalidGazePosition
        self.assertIsInstance(ts_gaze_positions[2], GazeFeatures.UnvalidGazePosition)
        self.assertEqual(ts_gaze_positions[2].precision, None)
        self.assertEqual(ts_gaze_positions[2].valid, False)

        data = {'Specific timestamp label': [0, 1, 2, 3, 4], 
                'Specific gaze position x label': [0, 10, numpy.nan, 30, 40], 
                'Specific gaze position y label': [0, 100, numpy.nan, 300, 400],
                'Specific precisison label': [15, 15, numpy.nan, 15, 15]
                }
        dataframe = pandas.DataFrame().from_dict(data)

        ts_gaze_positions = GazeFeatures.TimeStampedGazePositions.from_dataframe(dataframe, timestamp='Specific timestamp label', x='Specific gaze position x label', y='Specific gaze position y label', precision='Specific precisison label')

        # Check buffer length
        self.assertEqual(len(ts_gaze_positions), 5)

        # Check first gaze position is correctly stored and accessible as a GazePosition
        self.assertIsInstance(ts_gaze_positions[0], GazeFeatures.GazePosition)
        self.assertEqual(ts_gaze_positions[0].precision, 15)
        self.assertEqual(ts_gaze_positions[0].valid, True)

        # Check third gaze position is correctly stored and accessible as a UnvalidGazePosition
        self.assertIsInstance(ts_gaze_positions[2], GazeFeatures.UnvalidGazePosition)
        self.assertEqual(ts_gaze_positions[2].precision, None)
        self.assertEqual(ts_gaze_positions[2].valid, False)

    def test_as_dataframe(self):
        """Test inherited as_dataframe method."""

        ts_gaze_positions_dataframe = random_gaze_positions(10).as_dataframe()

        # Check dataframe conversion
        self.assertEqual(ts_gaze_positions_dataframe.index.name, "timestamp")
        self.assertEqual(ts_gaze_positions_dataframe.index.size, 10)

        self.assertEqual(ts_gaze_positions_dataframe.columns.size, 2)
        self.assertEqual(ts_gaze_positions_dataframe.columns[0], "value")
        self.assertEqual(ts_gaze_positions_dataframe.columns[1], "precision")

        self.assertEqual(ts_gaze_positions_dataframe["value"].dtype, 'object')
        self.assertEqual(ts_gaze_positions_dataframe["precision"].dtype, 'float64')

        # Check unvalid position conversion
        ts_gaze_positions = GazeFeatures.TimeStampedGazePositions()
        ts_gaze_positions[0] = GazeFeatures.UnvalidGazePosition()
        ts_gaze_positions_dataframe = ts_gaze_positions.as_dataframe()

        self.assertEqual(ts_gaze_positions_dataframe.index.name, "timestamp")
        self.assertEqual(ts_gaze_positions_dataframe.index.size, 1)

        self.assertEqual(ts_gaze_positions_dataframe.columns.size, 2)
        self.assertEqual(ts_gaze_positions_dataframe.columns[0], "value")
        self.assertEqual(ts_gaze_positions_dataframe.columns[1], "precision")

        self.assertEqual(ts_gaze_positions_dataframe["value"].dtype, 'object')
        self.assertEqual(ts_gaze_positions_dataframe["precision"].dtype, 'O') # Python object type

class TestGazeMovementClass(unittest.TestCase):
    """Test GazeMovement class."""

    def test_new(self):
        """Test GazeMovement creation."""
        
        abstract_gaze_movement = GazeFeatures.GazeMovement(random_gaze_positions(0))

        # Check abstract GazeMovement
        self.assertEqual(len(abstract_gaze_movement.positions), 0)
        self.assertEqual(abstract_gaze_movement.duration, -1)
        self.assertEqual(abstract_gaze_movement.amplitude, -1)
        self.assertEqual(abstract_gaze_movement.valid, False)
        self.assertEqual(abstract_gaze_movement.finished, False)

    def test_finish(self):
        """Test GazeMovement finishing."""
        
        abstract_gaze_movement = GazeFeatures.GazeMovement(random_gaze_positions(2))

        abstract_gaze_movement_ref = abstract_gaze_movement

        # Check abstract GazeMovement and its reference
        self.assertEqual(abstract_gaze_movement.finished, False)
        self.assertEqual(abstract_gaze_movement_ref.finished, False)

        # Set gaze movement as finished
        abstract_gaze_movement.finish()

        # Check abstract GazeMovement and its reference
        self.assertEqual(abstract_gaze_movement.finished, True)
        self.assertEqual(abstract_gaze_movement_ref.finished, True)

class TestUnvalidGazeMovementClass(unittest.TestCase):
    """Test UnvalidGazeMovement class."""

    def test_new(self):
        """Test UnvalidGazeMovement creation."""
        
        unvalid_gaze_movement = GazeFeatures.UnvalidGazeMovement('test')

        # Check UnvalidGazeMovement
        self.assertEqual(len(unvalid_gaze_movement.positions), 0)
        self.assertEqual(unvalid_gaze_movement.duration, -1)
        self.assertEqual(unvalid_gaze_movement.amplitude, -1)
        self.assertEqual(unvalid_gaze_movement.valid, False)
        self.assertEqual(unvalid_gaze_movement.finished, False)
        self.assertEqual(unvalid_gaze_movement.message, 'test')

class TestScanStepClass(unittest.TestCase):
    """Test ScanStep class."""

    def test_new(self):
        """Test ScanStep creation."""

        fixation = TestFixation(random_gaze_positions(10))
        saccade = TestSaccade(random_gaze_positions(2))

        scan_step = GazeFeatures.ScanStep(fixation, saccade)

        # Check aoi scan step creation
        self.assertEqual(scan_step.first_fixation, fixation)
        self.assertEqual(scan_step.last_saccade, saccade)
        self.assertGreater(scan_step.duration, 0)

def build_scan_path(size, frame_dimension: tuple[float, float] = (1, 1)):
    """Build scan path"""

    scan_path = GazeFeatures.ScanPath()

    for i in range(size):

        fixation = TestFixation(random_gaze_positions(10, frame_dimension))
        ts, _ = fixation.positions.first
        scan_path.append_fixation(ts, fixation)

        saccade = TestSaccade(random_gaze_positions(2, frame_dimension))
        ts, _ = saccade.positions.first
        scan_path.append_saccade(ts, saccade)

    return scan_path

class TestScanPathClass(unittest.TestCase):
    """Test ScanPath class."""

    def test_new(self):
        """Test ScanPath creation."""

        # Check aoi scan step creation
        scan_path = GazeFeatures.ScanPath()

        self.assertEqual(len(scan_path), 0)
        self.assertEqual(scan_path.duration, 0)

    def test_append(self):
        """Test ScanPath append methods."""

        scan_path = GazeFeatures.ScanPath()

        # Append a saccade that should be ignored
        saccade = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade.positions.first

        new_step = scan_path.append_saccade(ts, saccade)

        # Check that no scan step have been created yet
        self.assertEqual(len(scan_path), 0)
        self.assertEqual(scan_path.duration, 0)
        self.assertEqual(new_step, None)

        # Append first fixation
        fixation_A = TestFixation(random_gaze_positions(10))
        ts, _ = fixation_A.positions.first

        new_step = scan_path.append_fixation(ts, fixation_A)

        # Check that no scan step have been created yet
        self.assertEqual(len(scan_path), 0)
        self.assertEqual(scan_path.duration, 0)
        self.assertEqual(new_step, None)

        # Append consecutive saccade
        saccade_A = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade_A.positions.first

        new_step_A = scan_path.append_saccade(ts, saccade_A)

        # Check that new scan step have been created
        self.assertEqual(len(scan_path), 1)
        self.assertEqual(scan_path.duration, new_step_A.duration)
        self.assertEqual(new_step_A.first_fixation, fixation_A)
        self.assertEqual(new_step_A.last_saccade, saccade_A)
        self.assertEqual(new_step_A.duration, fixation_A.duration + saccade_A.duration)

        # Append 2 consecutive fixations then a saccade
        fixation_B1 = TestFixation(random_gaze_positions(10))
        ts, _ = fixation_B1.positions.first

        new_step = scan_path.append_fixation(ts, fixation_B1)

        # Check that no scan step have been created yet
        self.assertEqual(len(scan_path), 1)
        self.assertEqual(scan_path.duration, new_step_A.duration)
        self.assertEqual(new_step, None)

        fixation_B2 = TestFixation(random_gaze_positions(10))
        ts, _ = fixation_B2.positions.first

        new_step = scan_path.append_fixation(ts, fixation_B2)

        # Check that no scan step have been created yet
        self.assertEqual(len(scan_path), 1)
        self.assertEqual(scan_path.duration, new_step_A.duration)
        self.assertEqual(new_step, None)

        saccade_B = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade_B.positions.first

        new_step_B = scan_path.append_saccade(ts, saccade_B)

        # Check that new scan step have been created
        self.assertEqual(len(scan_path), 2)
        self.assertEqual(scan_path.duration, new_step_A.duration + new_step_B.duration)
        self.assertEqual(new_step_B.first_fixation, fixation_B2)
        self.assertEqual(new_step_B.last_saccade, saccade_B)
        self.assertEqual(new_step_B.duration, fixation_B2.duration + saccade_B.duration)

class TestAOIScanStepClass(unittest.TestCase):
    """Test AOIScanStep class."""

    def test_new(self):
        """Test AOIScanStep creation."""

        movements = GazeFeatures.TimeStampedGazeMovements()

        fixation = TestFixation(random_gaze_positions(10))
        ts, _ = fixation.positions.first
        movements[ts] = fixation

        saccade = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade.positions.first
        movements[ts] = saccade

        aoi_scan_step = GazeFeatures.AOIScanStep(movements, 'Test')

        # Check aoi scan step creation
        self.assertEqual(len(aoi_scan_step.movements), 2)
        self.assertEqual(aoi_scan_step.aoi, 'Test')
        self.assertEqual(aoi_scan_step.first_fixation, fixation)
        self.assertEqual(aoi_scan_step.last_saccade, saccade)
        self.assertGreater(aoi_scan_step.duration, 0)

    def test_error(self):
        """Test AOIScanStep creation error."""

        movements = GazeFeatures.TimeStampedGazeMovements()

        saccade = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade.positions.first
        movements[ts] = saccade

        fixation = TestFixation(random_gaze_positions(10))
        ts, _ = fixation.positions.first
        movements[ts] = fixation

        # Check that aoi scan step creation fail
        with self.assertRaises(GazeFeatures.AOIScanStepError):

            aoi_scan_step = GazeFeatures.AOIScanStep(movements, 'Test')

def build_aoi_scan_path(expected_aois, aoi_path):
    """Build AOI scan path"""

    aoi_scan_path = GazeFeatures.AOIScanPath(expected_aois)

    # Append a hidden last step to allow last given step creation
    aoi_path.append(aoi_path[-2])

    for aoi in aoi_path:

        fixation = TestFixation(random_gaze_positions(10))
        ts, _ = fixation.positions.first
        aoi_scan_path.append_fixation(ts, fixation, aoi)

        saccade = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade.positions.first
        aoi_scan_path.append_saccade(ts, saccade)

    return aoi_scan_path

class TestAOIScanPathClass(unittest.TestCase):
    """Test AOIScanPath class."""

    def test_new(self):
        """Test AOIScanPath creation."""

        # Check aoi scan step creation
        aoi_scan_path = GazeFeatures.AOIScanPath()

        self.assertEqual(len(aoi_scan_path), 0)

    def test_append(self):
        """Test AOIScanPath append methods."""

        aoi_scan_path = GazeFeatures.AOIScanPath(['Foo', 'Bar'])

        # Append fixation on A aoi
        fixation_A = TestFixation(random_gaze_positions(10))
        ts, _ = fixation_A.positions.first

        new_step = aoi_scan_path.append_fixation(ts, fixation_A, 'Foo')

        # Check that no aoi scan step have been created yet
        self.assertEqual(len(aoi_scan_path), 0)
        self.assertEqual(aoi_scan_path.duration, 0)
        self.assertEqual(new_step, None)

        # Append saccade
        saccade_A = TestSaccade(random_gaze_positions(2))
        ts, _ = saccade_A.positions.first

        new_step = aoi_scan_path.append_saccade(ts, saccade_A)

        # Check that no aoi scan step have been created yet
        self.assertEqual(len(aoi_scan_path), 0)
        self.assertEqual(aoi_scan_path.duration, 0)
        self.assertEqual(new_step, None)

        # Append fixation on B aoi
        fixation_B = TestFixation(random_gaze_positions(10))
        ts, _ = fixation_B.positions.first

        new_step_A = aoi_scan_path.append_fixation(ts, fixation_B, 'Bar')

        # Check a first aoi scan step have been created once a new fixation is appened
        self.assertEqual(len(aoi_scan_path), 1)
        self.assertEqual(aoi_scan_path.duration, new_step_A.duration)
        self.assertEqual(len(new_step_A.movements), 2)
        self.assertEqual(new_step_A.aoi, 'Foo')
        self.assertEqual(new_step_A.letter, 'A')

        first_ts, _ = fixation_A.positions.first 
        last_ts, _ = saccade_A.positions.last

        self.assertEqual(new_step_A.duration, last_ts - first_ts)

        # Check letter affectation
        self.assertEqual(aoi_scan_path.get_letter_aoi('A'), 'Foo')

    def test_append_error(self):
        """Test AOIScanPath append error."""

        aoi_scan_path = GazeFeatures.AOIScanPath(['Foo', 'Bar'])

        # Append fixation on A aoi
        fixation = TestFixation(random_gaze_positions(10))
        ts, _ = fixation.positions.first

        new_step = aoi_scan_path.append_fixation(ts, fixation, 'Foo')

        # Check that no aoi scan step have been created yet
        self.assertEqual(len(aoi_scan_path), 0)
        self.assertEqual(new_step, None)

        # Append fixation on B aoi
        fixation = TestFixation(random_gaze_positions(10))
        ts, _ = fixation.positions.first

        # Check that aoi scan step creation fail when fixation is appened after another fixation
        with self.assertRaises(GazeFeatures.AOIScanStepError):

            new_step = aoi_scan_path.append_fixation(ts, fixation, 'Bar')

        # Check that unexpected aoi scan step creation fail
        with self.assertRaises(GazeFeatures.AOIScanStepError):

            new_step = aoi_scan_path.append_fixation(ts, fixation, 'Shu')

    def test_letter_index_and_string_reprentation(self):
        """Test AOIScanPath letter index and string representation feature."""

        aoi_scan_path = build_aoi_scan_path(['Foo', 'Bar', 'Shu'], ['Bar', 'Shu', 'Foo', 'Bar'])

        # Check first step
        self.assertEqual(aoi_scan_path[0].aoi, 'Bar')
        self.assertEqual(aoi_scan_path[0].letter, 'A')

        # Check second step
        self.assertEqual(aoi_scan_path[1].aoi, 'Shu')
        self.assertEqual(aoi_scan_path[1].letter, 'B')

        # Check thrird step
        self.assertEqual(aoi_scan_path[2].aoi, 'Foo')
        self.assertEqual(aoi_scan_path[2].letter, 'C')

        # Check fourth step
        self.assertEqual(aoi_scan_path[3].aoi, 'Bar')
        self.assertEqual(aoi_scan_path[3].letter, 'A')

        # Check letter affectation
        self.assertEqual(aoi_scan_path.get_letter_aoi('A'), 'Bar')
        self.assertEqual(aoi_scan_path.get_letter_aoi('B'), 'Shu')
        self.assertEqual(aoi_scan_path.get_letter_aoi('C'), 'Foo')

        # Check string representation
        self.assertEqual(str(aoi_scan_path), 'ABCA')

    def test_transition_matrix(self):
        """Test AOIScanPath transition matrix feature."""

        aoi_scan_path = build_aoi_scan_path(['Foo', 'Bar', 'Shu'], ['Bar', 'Shu', 'Foo'])

        # Check transition matrix ([destination][departure])
        self.assertEqual(aoi_scan_path.transition_matrix['Foo']['Foo'], 0)
        self.assertEqual(aoi_scan_path.transition_matrix['Bar']['Bar'], 0)
        self.assertEqual(aoi_scan_path.transition_matrix['Shu']['Shu'], 0)

        self.assertEqual(aoi_scan_path.transition_matrix['Foo']['Bar'], 0)
        self.assertEqual(aoi_scan_path.transition_matrix['Foo']['Shu'], 1)

        self.assertEqual(aoi_scan_path.transition_matrix['Bar']['Foo'], 0)
        self.assertEqual(aoi_scan_path.transition_matrix['Bar']['Shu'], 0)

        self.assertEqual(aoi_scan_path.transition_matrix['Shu']['Foo'], 0)
        self.assertEqual(aoi_scan_path.transition_matrix['Shu']['Bar'], 1)

    def test_transition_matrix(self):
        """Test AOIScanPath fixations count feature."""

        aoi_scan_path = build_aoi_scan_path(['Foo', 'Bar', 'Shu'], ['Bar', 'Shu', 'Foo'])

        # Check fixations count
        scan_fixations_count, aoi_fixations_count = aoi_scan_path.fixations_count()

        self.assertEqual(scan_fixations_count, 3)
        self.assertEqual(aoi_fixations_count['Foo'], 1)
        self.assertEqual(aoi_fixations_count['Bar'], 1)
        self.assertEqual(aoi_fixations_count['Shu'], 1)

if __name__ == '__main__':

    unittest.main()