fix(detection): handle empty polygons in filter_polygons_by_area and polygon_to_xyxy (#2761)

* fix: handle empty polygons in filter_polygons_by_area and polygon_to_xyxy
* fix: preserve array dtype for empty polygons in polygon_to_xyxy

---------

Co-authored-by: Jirka Borovec <6035284+Borda@users.noreply.github.com>

Author: ghanashyam03

docs/changelog.md

@@ -7,6 +7,8 @@ date_modified: 2026-10-16
 
 ### Unreleased <small>upcoming</small>
 
+- `sv.filter_polygons_by_area` and `sv.polygon_to_xyxy` now accept empty polygons instead of raising a `ValueError`. Empty polygons evaluate to zero area when filtering, and `polygon_to_xyxy` returns an all-zero bounding box while preserving the input NumPy array dtype. ([#2761](https://github.com/roboflow/supervision/pull/2761))
+
 - Keypoint annotators use x/y when drawing accepted three-coordinate keypoints. Vertex and ellipse drawing no longer raises a tuple-unpacking error, and edge and label visibility checks ignore the extra coordinate. Rendering matches equivalent two-coordinate input, including missing-point and explicit-visibility handling. ([#2759](https://github.com/roboflow/supervision/pull/2759))
 
 - `sv.metrics.MeanAverageRecall` now follows COCO's last-target tie rule when multiple eligible targets have the same IoU. This preserves confidence-ordered matching and the crowd/ignore handling added in #2750. ([#2758](https://github.com/roboflow/supervision/pull/2758))

src/supervision/detection/utils/converters.py

@@ -865,6 +865,12 @@ def polygon_to_xyxy(polygon: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
 
         ```
     """
+    if len(polygon) == 0:
+        output_dtype = polygon.dtype if isinstance(polygon, np.ndarray) else np.int_
+        return np.zeros(4, dtype=output_dtype)
+
+    polygon = np.asarray(polygon)
+
     x_min, y_min = np.min(polygon, axis=0)
     x_max, y_max = np.max(polygon, axis=0)
     return np.array([x_min, y_min, x_max, y_max])

src/supervision/detection/utils/polygons.py

@@ -13,6 +13,9 @@ def _to_local_cv2_polygon(
     before conversion. Translating first preserves representable local geometry when
     absolute coordinates exceed float32 precision.
     """
+    if len(polygon) == 0:
+        return np.empty((0, 2), dtype=np.float32), np.zeros(2, dtype=polygon.dtype)
+
     origin = polygon.min(axis=0)
     if np.issubdtype(polygon.dtype, np.integer):
         local_polygon = np.asarray(

tests/detection/utils/test_converters.py

@@ -1223,11 +1223,27 @@ def test_mask_to_polygons_polygon_to_mask_round_trip() -> None:
             np.array([4, 4, 4, 4]),
             id="single-point",
         ),
+        pytest.param(
+            np.empty((0, 2), dtype=int),
+            np.array([0, 0, 0, 0]),
+            id="empty-polygon-int",
+        ),
+        pytest.param(
+            np.empty((0, 2), dtype=np.float32),
+            np.zeros(4, dtype=np.float32),
+            id="empty-polygon-float32",
+        ),
+        pytest.param(
+            [],
+            np.array([0, 0, 0, 0]),
+            id="empty-polygon-list",
+        ),
     ],
 )
 def test_polygon_to_xyxy(
-    polygon: npt.NDArray[np.int_], expected: npt.NDArray[np.int_]
+    polygon: npt.NDArray[np.number], expected: npt.NDArray[np.number]
 ) -> None:
     """polygon_to_xyxy returns the tight axis-aligned bounding box."""
     result = polygon_to_xyxy(polygon)
+    assert result.dtype == expected.dtype
     np.testing.assert_array_equal(result, expected)

tests/detection/utils/test_polygons.py

@@ -85,6 +85,30 @@
             DoesNotRaise(),
         ),  # two polygons with min_area and
         # max_area equal to the area of the second polygon
+        (
+            [np.empty((0, 2))],
+            50,
+            None,
+            [],
+            DoesNotRaise(),
+        ),  # empty polygon with min_area constraint
+        (
+            [np.empty((0, 2))],
+            None,
+            50,
+            [np.empty((0, 2))],
+            DoesNotRaise(),
+        ),  # empty polygon with max_area constraint
+        (
+            [
+                np.empty((0, 2)),
+                np.array([[0, 0], [0, 10], [10, 10], [10, 0]]),
+            ],
+            50,
+            None,
+            [np.array([[0, 0], [0, 10], [10, 10], [10, 0]])],
+            DoesNotRaise(),
+        ),  # mixed empty and valid polygons with min_area
     ],
 )
 def test_filter_polygons_by_area(