Fix/mAP

supervision/dataset/core.py

@@ -574,7 +574,6 @@ def from_coco(
             force_masks (bool): If True,
                 forces masks to be loaded for all annotations,
                 regardless of whether they are present.
-
         Returns:
             DetectionDataset: A DetectionDataset instance containing
                 the loaded images and annotations.

supervision/dataset/formats/coco.py

@@ -90,7 +90,10 @@ def coco_annotations_to_masks(
 
 
 def coco_annotations_to_detections(
-    image_annotations: List[dict], resolution_wh: Tuple[int, int], with_masks: bool
+    image_annotations: List[dict],
+    resolution_wh: Tuple[int, int],
+    with_masks: bool,
+    use_iscrowd: bool = False,
 ) -> Detections:
     if not image_annotations:
         return Detections.empty()
@@ -102,15 +105,26 @@ def coco_annotations_to_detections(
     xyxy = np.asarray(xyxy)
     xyxy[:, 2:4] += xyxy[:, 0:2]
 
+    data = dict()
+    if use_iscrowd:
+        iscrowd = [
+            image_annotation["iscrowd"] for image_annotation in image_annotations
+        ]
+        area = [image_annotation["area"] for image_annotation in image_annotations]
+        data = dict(
+            iscrowd=np.asarray(iscrowd, dtype=int), area=np.asarray(area, dtype=float)
+        )
+
     if with_masks:
         mask = coco_annotations_to_masks(
             image_annotations=image_annotations, resolution_wh=resolution_wh
         )
-        return Detections(
-            class_id=np.asarray(class_ids, dtype=int), xyxy=xyxy, mask=mask
-        )
+    else:
+        mask = None
 
-    return Detections(xyxy=xyxy, class_id=np.asarray(class_ids, dtype=int))
+    return Detections(
+        class_id=np.asarray(class_ids, dtype=int), xyxy=xyxy, mask=mask, data=data
+    )
 
 
 def detections_to_coco_annotations(
@@ -159,16 +173,29 @@ def detections_to_coco_annotations(
     return coco_annotations, annotation_id
 
 
+def get_coco_class_index_mapping(annotations_path: str) -> Dict[int, int]:
+    coco_data = read_json_file(annotations_path)
+    classes = coco_categories_to_classes(coco_categories=coco_data["categories"])
+    class_mapping = build_coco_class_index_mapping(
+        coco_categories=coco_data["categories"], target_classes=classes
+    )
+    inv_class_mapping = {v: k for k, v in class_mapping.items()}
+    return inv_class_mapping
+
+
 def load_coco_annotations(
     images_directory_path: str,
     annotations_path: str,
     force_masks: bool = False,
+    # use_iscrowd: bool = True,
 ) -> Tuple[List[str], List[str], Dict[str, Detections]]:
     coco_data = read_json_file(file_path=annotations_path)
     classes = coco_categories_to_classes(coco_categories=coco_data["categories"])
+
     class_index_mapping = build_coco_class_index_mapping(
         coco_categories=coco_data["categories"], target_classes=classes
     )
+
     coco_images = coco_data["images"]
     coco_annotations_groups = group_coco_annotations_by_image_id(
         coco_annotations=coco_data["annotations"]
@@ -190,7 +217,9 @@ def load_coco_annotations(
             image_annotations=image_annotations,
             resolution_wh=(image_width, image_height),
             with_masks=force_masks,
+            use_iscrowd=True,
         )
+
         annotation = map_detections_class_id(
             source_to_target_mapping=class_index_mapping,
             detections=annotation,

supervision/detection/utils.py

@@ -1325,3 +1325,77 @@ def spread_out_boxes(
         xyxy_padded[:, [2, 3]] += force_vectors
 
     return pad_boxes(xyxy_padded, px=-1)
+
+
+def _jaccard(box_a: List[float], box_b: List[float], is_crowd: bool) -> float:
+    """
+    Calculate the Jaccard index (intersection over union) between two bounding boxes.
+    If a gt object is marked as "iscrowd", a dt is allowed to match any subregion
+    of the gt. Choosing gt' in the crowd gt that best matches the dt can be done using
+    gt'=intersect(dt,gt). Since by definition union(gt',dt)=dt, computing
+    iou(gt,dt,iscrowd) = iou(gt',dt) = area(intersect(gt,dt)) / area(dt)
+
+    Args:
+        box_a (List[float]): Box coordinates in the format [x, y, width, height].
+        box_b (List[float]): Box coordinates in the format [x, y, width, height].
+        iscrowd (bool): Flag indicating if the second box is a crowd region or not.
+
+    Returns:
+        float: Jaccard index between the two bounding boxes.
+    """
+    # Smallest number to avoid division by zero
+    EPS = np.spacing(1)
+
+    xa, ya, x2a, y2a = box_a[0], box_a[1], box_a[0] + box_a[2], box_a[1] + box_a[3]
+    xb, yb, x2b, y2b = box_b[0], box_b[1], box_b[0] + box_b[2], box_b[1] + box_b[3]
+
+    # Innermost left x
+    xi = max(xa, xb)
+    # Innermost right x
+    x2i = min(x2a, x2b)
+    # Same for y
+    yi = max(ya, yb)
+    y2i = min(y2a, y2b)
+
+    # Calculate areas
+    Aa = max(x2a - xa, 0.0) * max(y2a - ya, 0.0)
+    Ab = max(x2b - xb, 0.0) * max(y2b - yb, 0.0)
+    Ai = max(x2i - xi, 0.0) * max(y2i - yi, 0.0)
+
+    if is_crowd:
+        return Ai / (Aa + EPS)
+
+    return Ai / (Aa + Ab - Ai + EPS)
+
+
+def iou_with_jaccard(
+    boxes_true: List[List[float]],
+    boxes_detection: List[List[float]],
+    is_crowd: List[bool],
+) -> np.ndarray:
+    """
+    Calculate the intersection over union (IoU) between detection bounding boxes (dt)
+    and ground-truth bounding boxes (gt).
+    Reference: https://github.com/rafaelpadilla/review_object_detection_metrics
+
+    Args:
+        boxes_true (List[List[float]]): List of ground-truth bounding boxes in the \
+            format [x, y, width, height].
+        boxes_detection (List[List[float]]): List of detection bounding boxes in the \
+            format [x, y, width, height].
+        is_crowd (List[bool]): List indicating if each ground-truth bounding box \
+            is a crowd region or not.
+
+    Returns:
+        np.ndarray: Array of IoU values of shape (len(dt), len(gt)).
+    """
+    assert len(is_crowd) == len(boxes_true), (
+        "iou(iscrowd=) must have the same length as boxes_true"
+    )
+    if len(boxes_detection) == 0 or len(boxes_true) == 0:
+        return np.array([])
+    ious = np.zeros((len(boxes_detection), len(boxes_true)), dtype=np.float64)
+    for g_idx, g in enumerate(boxes_true):
+        for d_idx, d in enumerate(boxes_detection):
+            ious[d_idx, g_idx] = _jaccard(d, g, is_crowd[g_idx])
+    return ious