Add common utils to BoundingBox class

Author: ankandrew

open_image_models/detection/core/base.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Any, Protocol
+from typing import Any, Optional, Protocol
 
 import numpy as np
 
@@ -19,6 +19,64 @@ class BoundingBox:
     y2: int
     """Y-coordinate of the bottom-right corner"""
 
+    @property
+    def width(self) -> int:
+        """Returns the width of the bounding box."""
+        return self.x2 - self.x1
+
+    @property
+    def height(self) -> int:
+        """Returns the height of the bounding box."""
+        return self.y2 - self.y1
+
+    @property
+    def area(self) -> int:
+        """Returns the area of the bounding box."""
+        return self.width * self.height
+
+    @property
+    def center(self) -> tuple[float, float]:
+        """
+        Returns the (x, y) coordinates of the center of the bounding box.
+        """
+        cx = (self.x1 + self.x2) / 2.0
+        cy = (self.y1 + self.y2) / 2.0
+
+        return cx, cy
+
+    def intersection(self, other: "BoundingBox") -> Optional["BoundingBox"]:
+        """
+        Returns the intersection of this bounding box with another bounding box. If they do not intersect, returns None.
+        """
+        x1 = max(self.x1, other.x1)
+        y1 = max(self.y1, other.y1)
+        x2 = min(self.x2, other.x2)
+        y2 = min(self.y2, other.y2)
+
+        if x2 > x1 and y2 > y1:
+            return BoundingBox(x1, y1, x2, y2)
+
+        return None
+
+    def iou(self, other: "BoundingBox") -> float:
+        """
+        Computes the Intersection-over-Union (IoU) between this bounding box and another bounding box.
+        """
+        inter = self.intersection(other)
+
+        if inter is None:
+            return 0.0
+
+        inter_area = inter.area
+        union_area = self.area + other.area - inter_area
+        return inter_area / union_area if union_area > 0 else 0.0
+
+    def to_xywh(self) -> tuple[int, int, int, int]:
+        """
+        Converts bounding box to (x, y, width, height) format, where (x, y) is the top-left corner.
+        """
+        return self.x1, self.y1, self.width, self.height
+
 
 @dataclass(frozen=True)
 class DetectionResult:

test/open_image_models/detection/core/test_base.py

@@ -0,0 +1,107 @@
+from math import isclose
+
+import pytest
+
+from open_image_models.detection.core.base import BoundingBox
+
+# pylint: disable=too-many-positional-arguments
+
+
+@pytest.mark.parametrize(
+    "x1, y1, x2, y2, expected_width, expected_height, expected_area, expected_center",
+    [
+        (0, 0, 10, 10, 10, 10, 100, (5.0, 5.0)),
+        (2, 3, 5, 7, 3, 4, 12, (3.5, 5.0)),
+        (10, 10, 15, 13, 5, 3, 15, (12.5, 11.5)),
+    ],
+)
+def test_bounding_box_properties(x1, y1, x2, y2, expected_width, expected_height, expected_area, expected_center):
+    bbox = BoundingBox(x1, y1, x2, y2)
+    assert bbox.width == expected_width
+    assert bbox.height == expected_height
+    assert bbox.area == expected_area
+
+    actual_center = bbox.center
+    assert isclose(actual_center[0], expected_center[0], rel_tol=1e-6)
+    assert isclose(actual_center[1], expected_center[1], rel_tol=1e-6)
+
+
+@pytest.mark.parametrize(
+    "bbox, expected_xywh",
+    [
+        (BoundingBox(0, 0, 10, 10), (0, 0, 10, 10)),
+        (BoundingBox(2, 3, 5, 7), (2, 3, 3, 4)),
+        (BoundingBox(10, 10, 15, 13), (10, 10, 5, 3)),
+    ],
+)
+def test_to_xywh(bbox, expected_xywh):
+    xywh = bbox.to_xywh()
+    assert xywh == expected_xywh
+
+
+@pytest.mark.parametrize(
+    "bbox1, bbox2, expected_intersection",
+    [
+        # Overlapping case
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(5, 5, 15, 15),
+            BoundingBox(5, 5, 10, 10),
+        ),
+        # One box completely inside another
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(2, 2, 5, 5),
+            BoundingBox(2, 2, 5, 5),
+        ),
+        # Touching edges (should return None if there's no positive overlap)
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(10, 10, 12, 12),
+            None,
+        ),
+        # No overlap at all
+        (
+            BoundingBox(0, 0, 5, 5),
+            BoundingBox(6, 6, 10, 10),
+            None,
+        ),
+    ],
+)
+def test_intersection(bbox1, bbox2, expected_intersection):
+    inter = bbox1.intersection(bbox2)
+    assert inter == expected_intersection
+
+
+@pytest.mark.parametrize(
+    "bbox1, bbox2, expected_iou",
+    [
+        # Same box, IoU should equal 1.0
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(0, 0, 10, 10),
+            1.0,
+        ),
+        # Partial overlap
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(5, 5, 15, 15),
+            25 / 175,  # intersection=25, union=175, so IoU should equal 25/175
+        ),
+        # No overlap, IoU should equal 0.0
+        (
+            BoundingBox(0, 0, 5, 5),
+            BoundingBox(6, 6, 10, 10),
+            0.0,
+        ),
+        # One box inside another, ratio of areas
+        (
+            BoundingBox(0, 0, 10, 10),
+            BoundingBox(2, 2, 8, 8),
+            36 / 100,
+        ),
+    ],
+)
+def test_iou(bbox1, bbox2, expected_iou):
+    iou_value = bbox1.iou(bbox2)
+    assert isclose(iou_value, expected_iou, rel_tol=1e-5)