main_2024.py detect target

main_2024.py

@@ -60,7 +60,7 @@ def main() -> int:
         DETECT_TARGET_MODEL_PATH = config["detect_target"]["model_path"]
         DETECT_TARGET_OVERRIDE_FULL_PRECISION = args.full
         DETECT_TARGET_SAVE_PREFIX = config["detect_target"]["save_prefix"]
-        DETECT_TARGET_ANNOTATE = args.show_annotated
+        DETECT_TARGET_SHOW_ANNOTATED = args.show_annotated
 
         FLIGHT_INTERFACE_ADDRESS = config["flight_interface"]["address"]
         FLIGHT_INTERFACE_TIMEOUT = config["flight_interface"]["timeout"]
@@ -108,7 +108,7 @@ def main() -> int:
             DETECT_TARGET_MODEL_PATH,
             DETECT_TARGET_OVERRIDE_FULL_PRECISION,
             DETECT_TARGET_SAVE_PREFIX,
-            DETECT_TARGET_ANNOTATE,
+            DETECT_TARGET_SHOW_ANNOTATED,
             video_input_to_detect_target_queue,
             detect_target_to_main_queue,
             controller,
@@ -139,6 +139,14 @@ def main() -> int:
         except queue.Empty:
             detections = None
 
+        if detections is not None:
+            print("timestamp: " + str(detections.timestamp))
+            print("detections: " + str(len(detections.detections)))
+            for detection in detections.detections:
+                print("    label: " + str(detection.label))
+                print("    confidence: " + str(detection.confidence))
+            print("")
+
         odometry_and_time = flight_interface_to_main_queue.queue.get()
 
         if odometry_and_time is not None:
@@ -151,7 +159,8 @@ def main() -> int:
             print("pitch: " + str(odometry_and_time.odometry_data.orientation.pitch))
             print("")
 
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) == ord("q"):
+            print("Exiting main loop")
             break
 
     # Teardown

modules/detect_target/detect_target.py

@@ -85,7 +85,6 @@ def run(self, data: image_and_time.ImageAndTime) -> "tuple[bool, detections_and_
 
         if self.__show_annotations:
             cv2.imshow("Annotated", image_annotated)
-            cv2.waitKey(1)
 
         return True, detections
 

tests/model_example/generate_expected.py

@@ -6,16 +6,22 @@
 import cv2
 import numpy as np
 import ultralytics
+import pathlib
 
 
 # Downloaded from: https://github.com/ultralytics/assets/releases
-MODEL_PATH = "tests/model_example/yolov8s_ultralytics_pretrained_default.pt"
+MODEL_PATH = pathlib.Path("tests/model_example/yolov8s_ultralytics_pretrained_default.pt")
+
+BUS_IMAGE_PATH = pathlib.Path("tests/model_example/bus.jpg")
+ZIDANE_IMAGE_PATH = pathlib.Path("tests/model_example/zidane.jpg")
+
+SAVE_PATH = pathlib.Path("tests/model_example")
 
 
 if __name__ == "__main__":
     model = ultralytics.YOLO(MODEL_PATH)
-    image_bus = cv2.imread("tests/model_example/bus.jpg")
-    image_zidane = cv2.imread("tests/model_example/zidane.jpg")
+    image_bus = cv2.imread(BUS_IMAGE_PATH)
+    image_zidane = cv2.imread(ZIDANE_IMAGE_PATH)
 
     # ultralytics saves as .jpg , bad for testing reproducibility
     results_bus = model.predict(
@@ -35,15 +41,15 @@
     image_zidane_annotated = results_zidane[0].plot(conf=True)
 
 	# Generate expected
-    bus_expected = results_bus[0].boxes.xyxy.detach().cpu().numpy()
-    zidane_expected = results_zidane[0].boxes.xyxy.detach().cpu().numpy()
+    bounding_box_bus = results_bus[0].boxes.xyxy.detach().cpu().numpy()
+    bounding_box_zidane = results_zidane[0].boxes.xyxy.detach().cpu().numpy()
 
     # Save image
-    cv2.imwrite("tests/model_example/bus_annotated.png", image_bus_annotated)
-    cv2.imwrite("tests/model_example/zidane_annotated.png", image_zidane_annotated)
+    cv2.imwrite(f"{SAVE_PATH}/bus_annotated.png", image_bus_annotated)
+    cv2.imwrite(f"{SAVE_PATH}/zidane_annotated.png", image_zidane_annotated)
 
 	# Save expected to text file
-    np.savetxt("tests/model_example/bus_expected.txt", bus_expected)
-    np.savetxt("tests/model_example/zidane_expected.txt", zidane_expected)
+    np.savetxt(f"{SAVE_PATH}/bounding_box_bus.txt", bounding_box_bus)
+    np.savetxt(f"{SAVE_PATH}/bounding_box_zidane.txt", bounding_box_zidane)
 
     print("Done!")

tests/test_detect_target.py

@@ -7,7 +7,6 @@
 import numpy as np
 import pytest
 import torch
-import ultralytics
 
 from modules.detect_target import detect_target
 from modules import image_and_time
@@ -19,12 +18,10 @@
 OVERRIDE_FULL =                 False  # Tests are able to handle both full and half precision.
 IMAGE_BUS_PATH =                "tests/model_example/bus.jpg"
 IMAGE_BUS_ANNOTATED_PATH =      "tests/model_example/bus_annotated.png"
+BOUNDING_BOX_BUS_PATH =         "tests/model_example/bounding_box_bus.txt"
 IMAGE_ZIDANE_PATH =             "tests/model_example/zidane.jpg"
 IMAGE_ZIDANE_ANNOTATED_PATH =   "tests/model_example/zidane_annotated.png"
-
-model = ultralytics.YOLO(MODEL_PATH)
-expected_bus = np.loadtxt("tests/model_example/bus_expected.txt")
-expected_zidane = np.loadtxt("tests/model_example/zidane_expected.txt")
+BOUNDING_BOX_ZIDANE_PATH =      "tests/model_example/bounding_box_zidane.txt"
 
 @pytest.fixture()
 def detector():
@@ -58,85 +55,83 @@ def image_zidane():
     assert zidane_image is not None
     yield zidane_image
 
+@pytest.fixture()
+def expected_bus():
+    """
+    Load expected bus image.
+    """
+    expected_bus = np.loadtxt(BOUNDING_BOX_BUS_PATH)
+    assert expected_bus is not None
+    yield expected_bus
 
-def rmse(actual: np.ndarray,
-         expected: np.ndarray) -> float:
-        """
-        Helper function to compute root mean squared error.
-        """
-        mean_squared_error = np.square(actual - expected).mean()
-
-        return np.sqrt(mean_squared_error)
-
-
-def test_rmse():
-        """
-        Root mean squared error.
-        """
-        # Setup
-        sample_actual = np.array([1, 2, 3, 4, 5])
-        sample_expected = np.array([1.6, 2.5, 2.9, 3, 4.1])
-        EXPECTED_ERROR = np.sqrt(0.486)
-
-        # Run
-        actual_error = rmse(sample_actual, sample_expected)
-
-        # Test
-        np.testing.assert_almost_equal(actual_error, EXPECTED_ERROR)
-
+@pytest.fixture()
+def expected_zidane():
+    """
+    Load expected Zidane image.
+    """
+    expected_zidane = np.loadtxt(BOUNDING_BOX_ZIDANE_PATH)
+    assert expected_zidane is not None
+    yield expected_zidane
 
 class TestDetector:
     """
     Tests `DetectTarget.run()` .
     """
 
-    __IMAGE_DIFFERENCE_TOLERANCE = 1
+    __BOUNDING_BOX_TOLERANCE = 1e-7
 
     def test_single_bus_image(self,
                               detector: detect_target.DetectTarget,
-                              image_bus: image_and_time.ImageAndTime):
+                              image_bus: image_and_time.ImageAndTime,
+                              expected_bus: np.ndarray):
         """
         Bus image.
         """
         # Run
         result, actual = detector.run(image_bus)
-        detections = actual.detections
 
         # Test
         assert result
         assert actual is not None
-        assert detections is not None
+
+        detections = actual.detections
 
-        error = 0
+        assert len(detections) == expected_bus.shape[0]
 
-        for i in range(0, len(detections)):
-            error += rmse([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2], expected_bus[i])
-        assert (error / len(detections)) < self.__IMAGE_DIFFERENCE_TOLERANCE
+        errors = np.full((1, expected_bus.shape[1]), 1)
+
+        for i in range(0, expected_bus.shape[0]):
+            errors = np.abs(np.array([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2]) - expected_bus[i])
+            assert all(e < self.__BOUNDING_BOX_TOLERANCE for e in errors)
 
     def test_single_zidane_image(self,
                                  detector: detect_target.DetectTarget,
-                                 image_zidane: image_and_time.ImageAndTime):
+                                 image_zidane: image_and_time.ImageAndTime,
+                                 expected_zidane: np.ndarray):
         """
         Zidane image.
         """
         # Run
         result, actual = detector.run(image_zidane)
-        detections = actual.detections
 
         # Test
         assert result
         assert actual is not None
-        assert detections is not None
 
-        error = 0
+        detections = actual.detections
+
+        assert len(detections) == expected_zidane.shape[0]
 
-        for i in range(0, len(detections)):
-            error += rmse([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2], expected_zidane[i])
-        assert (error / len(detections)) < self.__IMAGE_DIFFERENCE_TOLERANCE
+        errors = np.full((1, expected_zidane.shape[0]), 1)
+
+        for i in range(0, expected_zidane.shape[0]):
+            errors = np.abs(np.array([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2]) - expected_zidane[i])
+            assert all(e < self.__BOUNDING_BOX_TOLERANCE for e in errors)
 
     def test_multiple_zidane_image(self,
                                    detector: detect_target.DetectTarget,
-                                   image_zidane: image_and_time.ImageAndTime):
+                                   image_zidane: image_and_time.ImageAndTime,
+                                   expected_zidane: np.ndarray):
         """
         Multiple Zidane images.
         """
@@ -157,15 +152,16 @@ def test_multiple_zidane_image(self,
         for i in range(0, IMAGE_COUNT):
             output: "tuple[bool, detections_and_time.DetectionsAndTime | None]" = outputs[i]
             result, actual = output
-
-            detections = actual.detections
 
             assert result
             assert actual is not None
-            assert detections is not None
+
+            detections = actual.detections
+
+            assert len(detections) == expected_zidane.shape[0]
 
-            error = 0
+            errors = np.full((1, expected_zidane.shape[0]), 1)
 
-            for i in range(0, len(detections)):
-                error += rmse([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2], expected_zidane[i])
-            assert (error / len(detections)) < self.__IMAGE_DIFFERENCE_TOLERANCE
+            for i in range(0, expected_zidane.shape[0]):
+                errors = np.abs(np.array([detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2]) - expected_zidane[i])
+                assert all(e < self.__BOUNDING_BOX_TOLERANCE for e in errors)