Removed the subdir.

pyrate/tests/sense/vision/test_obstacle_locator.py

@@ -0,0 +1,103 @@
+"""This test suite evaluates and tests behavior of the ``ObstacleLocator`` class"""
+
+# Standard library
+from csv import reader
+from math import radians
+from pathlib import Path
+
+# Typing
+from typing import cast
+from typing import Tuple
+
+# Testing
+from unittest import TestCase
+
+# Scientific
+from cv2 import imread
+
+# Module under test
+from pyrate.sense.vision.image_line import ImageLine
+from pyrate.sense.vision.obstacle_locator import ObstacleLocator
+
+
+PATH_TO_DATASET = Path(__file__).parent / "resources" / "testing_dataset_successful"
+DATASET_IMAGES_PATHS = sorted(list((PATH_TO_DATASET / "testims").glob("*.jpg")))
+DATASET_ANNOTATIONS_PATHS = sorted(list((PATH_TO_DATASET / "annotations").glob("*.txt")))
+
+PATH_TO_FAILING = (
+    Path(__file__).parent / "resources" / "testing_dataset_no_horizon" / "testims" / "Preprocessed_test_0.jpg"
+)
+IMAGE_HEIGHT, IMAGE_WIDTH = imread(PATH_TO_FAILING.as_posix()).shape[:2]
+
+
+class TestObstacleLocator(TestCase):
+
+    """Test for correct predictions made by ``ObstacleLocator``"""
+
+    @staticmethod
+    def parse_annotation(file_path: str, obstacle_locator: ObstacleLocator) -> Tuple[ImageLine, float]:
+        """Helper function to parse the ground truth labels from the dataset.
+
+        Args:
+            file_path: Label file path
+            obstacle_locator: the ObstacleLocator that returns the ImageLine that should be
+            compared to the returned ImageLine of this function
+
+        Returns:
+            ImageLine as described in the annotation, angle read from annotation
+            (for testing correct angle calculation)
+        """
+
+        with open(file_path, "rt", encoding="UTF-8") as label_file:
+            content = label_file.read().split("\n")
+
+        csvreader = reader(content, delimiter=",")
+        point_a = cast(Tuple[int, int], tuple(int(x) for x in next(csvreader)))
+        point_b = cast(Tuple[int, int], tuple(int(x) for x in next(csvreader)))
+        label_angle = radians(float(next(csvreader)[0]))
+
+        line = ImageLine.from_points(
+            image_shape=(obstacle_locator.image_width, obstacle_locator.image_height),
+            points=(point_a, point_b),
+        )
+
+        return line, label_angle
+
+    def test_horizon_angle(self):
+        """Compares ``ObstacleLocator`` horizon estimates to ground truth annotations"""
+
+        uut_ol = ObstacleLocator(image_width=IMAGE_WIDTH, image_height=IMAGE_HEIGHT)  # unit/module under test
+
+        for image_path, label_path in zip(DATASET_IMAGES_PATHS, DATASET_ANNOTATIONS_PATHS):
+            with self.subTest(image=image_path.name):
+                # Assert that we have the correct label for the test image
+                self.assertEqual(
+                    image_path.name.split(".")[0],
+                    label_path.name.split(".")[0],
+                    msg="That isn't the right label for the image. This shouldn't happen.",
+                )
+
+                image = imread(image_path.as_posix())
+
+                # read annotation and test if ImageLine calculates the line's angle correctly
+                label_image_line, label_angle = self.parse_annotation(label_path.as_posix(), uut_ol)
+                self.assertAlmostEqual(label_angle, label_image_line.angle, places=2)
+
+                result = uut_ol.detect_horizon(image)
+                horizons = result[0]
+
+                # Test that a) a horizon is detected and b) it has the correct angle
+                self.assertTrue(len(horizons) > 0, msg="No horizon was detected.")
+                self.assertAlmostEqual(
+                    horizons[0].angle, label_image_line.angle, places=1, msg="Horizon angle mismatch."
+                )
+
+    def test_missing_lines(self):
+        """Tests the branch when no horizon line is detected in the image"""
+
+        uut_ol = ObstacleLocator(image_width=IMAGE_WIDTH, image_height=IMAGE_HEIGHT)  # unit/module under test
+
+        image = imread(PATH_TO_FAILING.as_posix())
+        # ObstacleLocator does not find a horizon line in this image
+        result = uut_ol.detect_horizon(image)
+        self.assertFalse(result[0])