Lidar Parser updates and unit tests

Author: Mmoyv27

modules/lidar_oscillation.py

@@ -0,0 +1,47 @@
+"""
+Representing a LiDAR Oscillation
+"""
+
+from . import lidar_detection
+
+
+class LidarOscillation:
+    """
+    Class to represent a collection of LiDAR readings that make up an oscillation.
+    """
+
+    __create_key = object()
+
+    @classmethod
+    def create(
+        cls, readings: list[lidar_detection.LidarDetection]
+    ) -> "tuple[bool, LidarOscillation | None]":
+        """
+        Create a new LidarOscillation object from a list of LidarReading objects.
+        """
+        if not readings:
+            return False, None
+        return True, LidarOscillation(cls.__create_key, readings)
+
+    def __init__(
+        self, class_private_create_key: object, readings: list[lidar_detection.LidarDetection]
+    ) -> None:
+        """
+        Private constructor, use create() method to instantiate.
+        """
+        assert class_private_create_key is LidarOscillation.__create_key, "Use the create() method"
+
+        self.readings = readings
+        angles = [reading.angle for reading in readings]
+        self.min_angle = min(angles)
+        self.max_angle = max(angles)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the LiDAR oscillation data.
+        """
+        reading_strs = []
+        for reading in self.readings:
+            reading_strs.append(str(reading))
+        formatted_readings = ", ".join(reading_strs)
+        return f"LidarOscillation: {len(self.readings)} readings, Min angle: {self.min_angle}, Max angle: {self.max_angle}, Readings: {formatted_readings}."

modules/lidar_parser/lidar_parser.py

@@ -23,11 +23,10 @@ class LidarParser:
     Class to handle parsing of LiDAR data stream and detecting complete oscillations.
     """
 
-    def __init__(self, class_private_create_key: object) -> None:
+    def __init__(self) -> None:
         """
         Private constructor for LidarParser. Use create() method.
         """
-        assert class_private_create_key is LidarParser.__create_key, "Use the create() method"
 
         self.lidar_readings = []
         self.current_oscillation = None
@@ -41,24 +40,26 @@ def run(
         """
         Process a single LidarDetection and return the oscillation if complete.
         """
-
         self.lidar_readings.append(lidar_detection)
-
         current_angle = lidar_detection.angle
+
         if self.last_angle is None:
             self.last_angle = current_angle
             return False, None
 
+        # Detect oscillation on angle change with correct direction reset
         if current_angle > self.last_angle and self.direction == Direction.DOWN:
             result, oscillation = lidar_oscillation.LidarOscillation.create(self.lidar_readings)
             self.direction = Direction.UP
             self.lidar_readings = []
+            self.last_angle = current_angle
             return result, oscillation
 
         elif current_angle < self.last_angle and self.direction == Direction.UP:
             result, oscillation = lidar_oscillation.LidarOscillation.create(self.lidar_readings)
             self.direction = Direction.DOWN
             self.lidar_readings = []
+            self.last_angle = current_angle
             return result, oscillation
 
         elif self.direction is Direction.NONE:

modules/lidar_parser/lidar_parser_worker.py

@@ -19,7 +19,7 @@ def lidar_oscillation_worker(
     """
 
     parser = lidar_parser.LidarParser()
-    if not result:
+    if not parser:
         print("Failed to initialise LidarParser.")
         return
 
@@ -28,8 +28,7 @@ def lidar_oscillation_worker(
 
         lidar_reading: lidar_detection.LidarDetection = detection_in_queue.queue.get()
         if lidar_reading is None:
-            continue
-
+            break
         result, oscillation = parser.run(lidar_reading)
         if not result:
             continue

tests/unit/test_lidar_parser.py

@@ -0,0 +1,177 @@
+"""
+Unit tests for lidar_parser module.
+"""
+
+import pytest
+from modules import lidar_detection
+from modules import lidar_oscillation
+from modules.lidar_parser import lidar_parser
+
+ANGLE_UP = 15.0
+ANGLE_DOWN = -15.0
+
+
+@pytest.fixture()
+def lidar_parser_instance() -> lidar_parser.LidarParser:  # type: ignore
+    parser = lidar_parser.LidarParser()
+    yield parser
+
+
+@pytest.fixture()
+def lidar_detection_up() -> lidar_detection.LidarDetection:  # type: ignore
+    result, detection = lidar_detection.LidarDetection.create(5.0, ANGLE_UP)
+    assert result
+    assert detection is not None
+    yield detection
+
+
+@pytest.fixture()
+def higher_angle_detection_up(lidar_detection_up: lidar_detection.LidarDetection) -> lidar_detection.LidarDetection:  # type: ignore
+    result, higher_detection = lidar_detection.LidarDetection.create(
+        5.0, lidar_detection_up.angle + 5.0
+    )
+    assert result
+    assert higher_detection is not None
+    yield higher_detection
+
+
+@pytest.fixture()
+def lidar_detection_down() -> lidar_detection.LidarDetection:  # type: ignore
+    result, detection = lidar_detection.LidarDetection.create(5.0, ANGLE_DOWN)
+    assert result
+    assert detection is not None
+    yield detection
+
+
+@pytest.fixture()
+def lower_angle_detection_down(lidar_detection_up: lidar_detection.LidarDetection) -> lidar_detection.LidarDetection:  # type: ignore
+    result, lower_detection = lidar_detection.LidarDetection.create(
+        5.0, lidar_detection_up.angle - 5.0
+    )
+    assert result
+    assert lower_detection is not None
+    yield lower_detection
+
+
+class TestLidarParser:
+    """
+    Tests for the LidarParser run() method.
+    """
+
+    def test_initial_run_no_oscillation(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+    ) -> None:
+        result, oscillation = lidar_parser_instance.run(lidar_detection_up)
+        assert not result
+        assert oscillation is None
+
+    def test_oscillation_detected_up_to_down(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+        higher_angle_detection_up: lidar_detection.LidarDetection,
+        lidar_detection_down: lidar_detection.LidarDetection,
+    ) -> None:
+
+        lidar_parser_instance.run(lidar_detection_up)
+        lidar_parser_instance.run(higher_angle_detection_up)
+        result, oscillation = lidar_parser_instance.run(lidar_detection_down)
+        assert result
+        assert oscillation is not None
+
+    def test_no_oscillation_on_same_direction(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+    ) -> None:
+
+        for _ in range(5):
+            result, oscillation = lidar_parser_instance.run(lidar_detection_up)
+            assert not result
+            assert oscillation is None
+
+    def test_direction_initialization_on_first_run(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+        lower_angle_detection_down: lidar_detection.LidarDetection,
+    ) -> None:
+
+        lidar_parser_instance.run(lidar_detection_up)
+        lidar_parser_instance.run(lower_angle_detection_down)
+        assert lidar_parser_instance.direction == lidar_parser.Direction.DOWN
+
+    def test_oscillation_reset_after_detection(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+        higher_angle_detection_up: lidar_detection.LidarDetection,
+        lidar_detection_down: lidar_detection.LidarDetection,
+    ) -> None:
+
+        lidar_parser_instance.run(lidar_detection_up)
+        lidar_parser_instance.run(higher_angle_detection_up)
+        result, oscillation = lidar_parser_instance.run(lidar_detection_down)
+        assert result
+        assert oscillation is not None
+        assert len(lidar_parser_instance.lidar_readings) == 0
+
+    def test_alternating_up_down_oscillations(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+        higher_angle_detection_up: lidar_detection.LidarDetection,
+        lidar_detection_down: lidar_detection.LidarDetection,
+    ) -> None:
+        """
+        Test the parser with alternating up and down angles to simulate multiple oscillations.
+        """
+        oscillation_count = 0
+
+        # Detect the first oscillation with three readings: two up, one down
+        lidar_parser_instance.run(lidar_detection_up)
+        lidar_parser_instance.run(higher_angle_detection_up)
+        result, oscillation = lidar_parser_instance.run(lidar_detection_down)
+
+        if result:
+            oscillation_count += 1
+            assert oscillation is not None
+
+        # Subsequent oscillations should alternate and be detected on every change of angle
+        for i in range(4):
+            if i % 2 == 0:  # Every even index provides an upward reading
+                result, oscillation = lidar_parser_instance.run(higher_angle_detection_up)
+            else:  # Every odd index provides a downward reading
+                result, oscillation = lidar_parser_instance.run(lidar_detection_down)
+
+            if result:
+                oscillation_count += 1
+                assert oscillation is not None
+
+        # Verify that five oscillations were detected in total
+        assert oscillation_count == 5
+
+    def test_no_oscillation_with_single_reading(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+    ) -> None:
+        result, oscillation = lidar_parser_instance.run(lidar_detection_up)
+        assert not result
+        assert oscillation is None
+
+    def test_oscillation_on_direction_change_after_none(
+        self,
+        lidar_parser_instance: lidar_parser.LidarParser,
+        lidar_detection_up: lidar_detection.LidarDetection,
+        higher_angle_detection_up: lidar_detection.LidarDetection,
+        lidar_detection_down: lidar_detection.LidarDetection,
+    ) -> None:
+        lidar_parser_instance.run(lidar_detection_up)
+        lidar_parser_instance.run(higher_angle_detection_up)
+        assert lidar_parser_instance.direction == lidar_parser.Direction.UP
+        result, oscillation = lidar_parser_instance.run(lidar_detection_down)
+        assert result
+        assert oscillation is not None