Refactor DetectionResult class and YOLO

Author: eugene123tw

model_api/python/model_api/models/detection_model.py

@@ -67,7 +67,7 @@ def parameters(cls):
 
         return parameters
 
-    def _resize_detections(self, detection_result: DetectionResult, meta: dict) -> DetectionResult:
+    def _resize_detections(self, detection_result: DetectionResult, meta: dict):
         """Resizes detection bounding boxes according to initial image shape.
 
         It implements image resizing depending on the set `resize_type`(see `ImageModel` for details).
@@ -76,9 +76,6 @@ def _resize_detections(self, detection_result: DetectionResult, meta: dict) -> D
         Args:
             detection_result (DetectionList): detection result with coordinates in normalized form
             meta (dict): the input metadata obtained from `preprocess` method
-
-        Returns:
-            - list of detections with resized and clipped coordinates to fit the initial image
         """
         input_img_height, input_img_widht = meta["original_shape"][:2]
         inverted_scale_x = input_img_widht / self.w
@@ -99,8 +96,7 @@ def _resize_detections(self, detection_result: DetectionResult, meta: dict) -> D
         boxes[:, 1::2] = (boxes[:, 1::2] * self.h - pad_top) * inverted_scale_y
         boxes[:, 0::2] = np.clip(boxes[:, 0::2], 0, input_img_widht)
         boxes[:, 1::2] = np.clip(boxes[:, 1::2], 0, input_img_height)
-        detection_result.bboxes = boxes
-        return detection_result
+        np.round(boxes, out=boxes)
 
     def _filter_detections(self, detection_result: DetectionResult, box_area_threshold=0.0):
         """Filters detections by confidence threshold and box size threshold

model_api/python/model_api/models/result_types/detection.py

@@ -45,20 +45,23 @@ def __init__(
         feature_vector: np.ndarray | None = None,
     ):
         super().__init__()
-        self.bboxes = bboxes
-        self.labels = labels
-        self.scores = scores if scores is not None else np.zeros(len(bboxes))
-        self.label_names = None if label_names is None else label_names
-        self.saliency_map = saliency_map
-        self.feature_vector = feature_vector
+        self._bboxes = bboxes
+        self._labels = labels
+        self._scores = scores if scores is not None else np.zeros(len(bboxes))
+        self._label_names = ["#"] * len(bboxes) if label_names is None else label_names
+        self._saliency_map = saliency_map
+        self._feature_vector = feature_vector
+
+    def __len__(self) -> int:
+        return len(self._bboxes)
 
     def __str__(self) -> str:
         return (
-            f"bboxes: {self.bboxes.shape}, "
-            f"labels: {len(self.labels)}, "
-            f"scores: {len(self.scores)}, "
-            f"{array_shape_to_str(self.saliency_map)}, "
-            f"{array_shape_to_str(self.feature_vector)}"
+            f"Num of boxes: {self._bboxes.shape}, "
+            f"Num of labels: {len(self._labels)}, "
+            f"Num of scores: {len(self._scores)}, "
+            f"Saliency Map: {array_shape_to_str(self._saliency_map)}, "
+            f"Feature Vec: {array_shape_to_str(self._feature_vector)}"
         )
 
     def get_obj_sizes(self) -> np.ndarray:
@@ -67,7 +70,73 @@ def get_obj_sizes(self) -> np.ndarray:
         Returns:
             np.ndarray: Object sizes in dim of (N,).
         """
-        return (self.bboxes[:, 2] - self.bboxes[:, 0]) * (self.bboxes[:, 3] - self.bboxes[:, 1])
+        return (self._bboxes[:, 2] - self._bboxes[:, 0]) * (self._bboxes[:, 3] - self._bboxes[:, 1])
+
+    @property
+    def bboxes(self) -> np.ndarray:
+        return self._bboxes
+
+    @bboxes.setter
+    def bboxes(self, value):
+        if not isinstance(value, np.ndarray):
+            msg = "Bounding boxes must be numpy array."
+            raise ValueError(msg)
+        self._bboxes = value
+
+    @property
+    def labels(self) -> np.ndarray:
+        return self._labels
+
+    @labels.setter
+    def labels(self, value):
+        if not isinstance(value, np.ndarray):
+            msg = "Labels must be numpy array."
+            raise ValueError(msg)
+        self._labels = value
+
+    @property
+    def scores(self) -> np.ndarray:
+        return self._scores
+
+    @scores.setter
+    def scores(self, value):
+        if not isinstance(value, np.ndarray):
+            msg = "Scores must be numpy array."
+            raise ValueError(msg)
+        self._scores = value
+
+    @property
+    def label_names(self) -> list[str]:
+        return self._label_names
+
+    @label_names.setter
+    def label_names(self, value):
+        if not isinstance(value, list):
+            msg = "Label names must be list."
+            raise ValueError(msg)
+        self._label_names = value
+
+    @property
+    def saliency_map(self) -> np.ndarray:
+        return self._saliency_map
+
+    @saliency_map.setter
+    def saliency_map(self, value):
+        if not isinstance(value, np.ndarray):
+            msg = "Saliency map must be numpy array."
+            raise ValueError(msg)
+        self._saliency_map = value
+
+    @property
+    def feature_vector(self) -> np.ndarray:
+        return self._feature_vector
+
+    @feature_vector.setter
+    def feature_vector(self, value):
+        if not isinstance(value, np.ndarray):
+            msg = "Feature vector must be numpy array."
+            raise ValueError(msg)
+        self._feature_vector = value
 
 
 class SingleOutputParser:

model_api/python/model_api/models/utils.py

@@ -53,19 +53,15 @@ def get_contours(
     return combined_contours
 
 
-def clip_detections(detections: DetectionResult, size: tuple[int, int]) -> DetectionResult:
+def clip_detections(detections: DetectionResult, size: tuple[int, int]):
     """Clip bounding boxes to image size.
 
     Args:
         detections (DetectionResult): detection results including boxes, labels and scores.
         size (tuple[int, int]): image size of format (height, width).
-
-    Returns:
-        DetectionResult: clipped detection results.
     """
     detections.bboxes[:, 0::2] = np.clip(detections.bboxes[:, 0::2], 0, size[1])
     detections.bboxes[:, 1::2] = np.clip(detections.bboxes[:, 1::2], 0, size[0])
-    return detections
 
 
 class OutputTransform: