Most changes made

Author: achitaan

modules/detect_target/detect_target_contour.py

@@ -14,6 +14,8 @@
 
 
 MIN_CONTOUR_AREA = 100
+MAX_CIRCULARITY = 1.3
+MIN_CIRCULARITY = 0.7
 UPPER_BLUE = np.array([130, 255, 255])
 LOWER_BLUE = np.array([100, 50, 50])
 CONFIDENCE = 1.0
@@ -29,7 +31,7 @@ def __init__(
         self, image_logger: logger.Logger, show_annotations: bool = False, save_name: str = ""
     ) -> None:
         """
-        image_logger: Log annotated iamges.
+        image_logger: Log annotated images.
         show_annotations: Display annotated images.
         save_name: filename prefix for logging detections and annotated images.
         """
@@ -79,7 +81,7 @@ def detect_landing_pads_contours(
             enclosing_area = np.pi * (radius**2)
             circularity = contour_area / enclosing_area
 
-            if circularity < 0.7 or circularity > 1.3:
+            if circularity < MIN_CIRCULARITY or circularity > MAX_CIRCULARITY:
                 continue
 
             x, y, w, h = cv2.boundingRect(contour)

modules/detect_target/detect_target_factory.py

@@ -18,7 +18,7 @@ class DetectTargetOption(enum.Enum):
 
     ML_ULTRALYTICS = 0
     CV_BRIGHTSPOT = 1
-    C_CONTOUR = 2
+    CV_CONTOUR = 2
 
 
 def create_detect_target(
@@ -49,8 +49,9 @@ def create_detect_target(
                 show_annotations,
                 save_name,
             )
-        case DetectTargetOption.C_CONTOUR:
+        case DetectTargetOption.CV_CONTOUR:
             return True, detect_target_contour.DetectTargetContour(
+                local_logger,
                 show_annotations,
                 save_name,
             )

tests/unit/generate_detect_target_contour.py

@@ -7,44 +7,42 @@
 import math
 import numpy as np
 
-
-LANDING_PAD_COLOUR_BLUE = (100, 50, 50)  # BGR
+from modules import detections_and_time
 
 
-# Test functions use test fixture signature names and access class privates
-# No enable
-# pylint: disable=protected-access,redefined-outer-name
+LANDING_PAD_COLOUR_BLUE = (100, 50, 50)  # BGR
 
 
 class LandingPadImageConfig:
     """
     Represents the data required to define and generate a landing pad.
     """
+
     def __init__(
         self,
-        center: tuple[int, int],
+        centre: tuple[int, int],
         axis: tuple[int, int],
         blur: bool,
         angle: float,
     ):
         """
-
-        center: The (x, y) coordinates representing the center of the landing pad.
-        axis: The pixel lengths of the semi-major and semi-minor axes of the ellipse.
+        centre: The pixel coordinates representing the centre of the landing pad.
+        axis: The pixel lengths of the semi-major axes of the ellipse.
         blur: Indicates whether the landing pad should have a blur effect.
         angle: The rotation angle of the landing pad in degrees clockwise, where 0.0 degrees
             is where both semi major and minor are aligned with the x and y-axis respectively (0.0 <= angle <= 360.0).
         """
-        self.center = center
+        self.centre = centre
         self.axis = axis
         self.blur = blur
         self.angle = angle
 
 
 class NumpyImage:
     """
-    Holds the Numpy Array which represents an image.
+    Holds the numpy array which represents an image.
     """
+
     def __init__(self, image: np.ndarray):
         """
         image: A numpy array that represents the image.
@@ -56,46 +54,78 @@ class BoundingBox:
     """
     Holds the data that define the generated bounding boxes.
     """
-    def __init__(self, top_left: tuple[int, int], bottom_right: tuple[int, int]):
+
+    def __init__(self, top_left: tuple[float, float], bottom_right: tuple[float, float]):
         """
-        top_left: x, y coordinates representing the top left corner of the bounding box on an image.
-        bottom_right: x, y coordinates representing the bottom right corner of the bounding box on an image.
+        top_left: pixel coordinates representing the top left corner of the bounding box on an image.
+        bottom_right: pixel coordinates representing the bottom right corner of the bounding box on an image.
         """
         self.top_left = top_left
         self.bottom_right = bottom_right
 
 
 class InputImageAndExpectedBoundingBoxes:
-    '''
+    """
     Struct to hold the data needed to perform the tests.
-    '''
+    """
+
     def __init__(self, image: np.ndarray, boxes_list: np.ndarray):
         """
-        image = A numpy array that represents the image needed to be tested.
+        image: A numpy array that represents the image needed to be tested.
         bounding_box_list: A numpy array that holds a list of expected bounding box coordinates.
+
+        The bounding box coordinates are in the following format:
+            top_left_x = boxes_list[0]
+            top_left_y = boxes_list[1]
+
+            bottom_right_x = boxes_list[2]
+            bottom_right_x = boxes_list[3]
         """
         self.image = image
         self.bounding_box_list = boxes_list
 
 
+def create_detections(detections_from_file: np.ndarray) -> detections_and_time.DetectionsAndTime:
+    """
+    Create DetectionsAndTime from expected.
+    Format: [confidence, label, x_1, y_1, x_2, y_2] .
+    """
+    assert detections_from_file.shape[1] == 6
+
+    result, detections = detections_and_time.DetectionsAndTime.create(0)
+    assert result
+    assert detections is not None
+
+    for i in range(0, detections_from_file.shape[0]):
+        result, detection = detections_and_time.Detection.create(
+            detections_from_file[i][2:],
+            int(detections_from_file[i][1]),
+            detections_from_file[i][0],
+        )
+        assert result
+        assert detection is not None
+        detections.append(detection)
+
+    return detections
+
+
 def add_blurred_landing_pad(
     background: np.ndarray, landing_data: LandingPadImageConfig
 ) -> NumpyImage:
     """
-    Blurs an image and adds a singular lading pad to the background.
+    Blurs an image and adds a singular landing pad to the background.
 
     background: A numpy image.
     landing_data: Landing pad data for the landing pad to be blurred and added.
 
-
     Returns: Image with the landing pad.
     """
     x, y = background.shape[:2]
 
     mask = np.zeros((x, y), np.uint8)
     mask = cv2.ellipse(
         mask,
-        landing_data.center,
+        landing_data.centre,
         landing_data.axis,
         landing_data.angle,
         0,
@@ -125,16 +155,23 @@ def draw_landing_pad(
 
     Returns: Image with landing pad and the bounding box for the drawn landing pad.
     """
-    (h, k), (a, b) = landing_data.center, landing_data.axis
+    centre_x, centre_y = landing_data.centre
+    axis_x, axis_y = landing_data.axis
     angle_in_rad = math.radians(landing_data.angle)
-    ux, uy = a * math.cos(angle_in_rad), a * math.sin(angle_in_rad)
-    vx, vy = b * math.sin(angle_in_rad), b * math.cos(angle_in_rad)
-    width, height = 2 * math.sqrt(ux**2 + vx**2), 2 * math.sqrt(uy**2 + vy**2)
 
-    top_left = (int(max(h - (0.5) * width, 0)), int(max(k - (0.5) * height, 0)))
+    ux = axis_x * math.cos(angle_in_rad)
+    uy = axis_x * math.sin(angle_in_rad)
+
+    vx = axis_y * math.sin(angle_in_rad)
+    vy = axis_y * math.cos(angle_in_rad)
+
+    width = 2 * math.sqrt(ux**2 + vx**2)
+    height = 2 * math.sqrt(uy**2 + vy**2)
+
+    top_left = (int(max(centre_x - (0.5) * width, 0)), int(max(centre_y - (0.5) * height, 0)))
     bottom_right = (
-        int(min(h + (0.5) * width, image.shape[1])),
-        int(min(k + (0.5) * height, image.shape[0])),
+        min(centre_x + (0.5) * width, image.shape[1]),
+        min(centre_y + (0.5) * height, image.shape[0]),
     )
 
     bounding_box = BoundingBox(top_left, bottom_right)
@@ -145,7 +182,7 @@ def draw_landing_pad(
 
     image = cv2.ellipse(
         image,
-        landing_data.center,
+        landing_data.centre,
         landing_data.axis,
         landing_data.angle,
         0,
@@ -164,12 +201,11 @@ def create_test(landing_list: list[LandingPadImageConfig]) -> InputImageAndExpec
 
     Returns: The image and expected bounding box.
     """
-    image = np.full(
-        shape=(1000, 2000, 3), fill_value=255, dtype=np.int16
-    )
+    image = np.full(shape=(1000, 2000, 3), fill_value=255, dtype=np.int8)
     confidence_and_label = [1, 0]
 
     # List to hold the bounding boxes.
+    # boxes_list = [confidence, label, top_left_x, top_left_y, bottom_right_x, bottom_right_y]
     boxes_list = []
 
     for landing_data in landing_list:
@@ -179,11 +215,9 @@ def create_test(landing_list: list[LandingPadImageConfig]) -> InputImageAndExpec
             confidence_and_label + list(bounding_box.top_left + bounding_box.bottom_right)
         )
 
-    # Calculates the area of the bounding box.
+    # Sorts by the area of the bounding box
     boxes_list = sorted(
-        boxes_list,
-        reverse=True,
-        key=lambda box: abs((box[4] - box[2]) * (box[5] - box[3])),
+        boxes_list, reverse=True, key=lambda box: abs((box[4] - box[2]) * (box[5] - box[3]))
     )
 
     boxes_list = np.array(boxes_list)