@@ -7,7 +7,7 @@ date_modified: 2026-10-16
 
 ### Unreleased <small>upcoming</small>
 
--
+- `sv.MaskAnnotator` no longer widens its blend region to the boxes of all-False masks, for dense masks and `CompactMask` alike, and skips blending when every `CompactMask` is all-False. Empty masks previously contributed their full bounding boxes, causing unnecessary image copies and blending outside the foreground region. `CompactMask` foreground counts are read from RLE without decoding; nonempty mask bounds and painted pixels are unchanged. ([#2741](https://github.com/roboflow/supervision/pull/2741))
 
 ### 0.31.0 <small>Oct 16, 2026</small>
 
 
@@ -551,19 +551,20 @@ def _compact_masks_to_roi(
 ) -> tuple[int, int, int, int] | None:
     """Return exclusive bounding-box union for compact masks.
 
-    Uses crop metadata (offsets + shapes) — no RLE decode required.
+    Uses crop metadata (offsets + shapes) and RLE foreground counts to exclude
+    all-False masks without decoding crops.
 
     Args:
         masks: Compact mask collection.
         image_shape: Image dimensions as ``(height, width)``.
 
     Returns:
-        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when empty.
+        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when no true pixels exist.
     """
-    if len(masks) == 0:
+    bboxes = masks.bbox_xyxy[masks.area > 0]
+    if len(bboxes) == 0:
         return None
     image_h, image_w = image_shape
-    bboxes = masks.bbox_xyxy  # shape (N, 4), inclusive int32
     x_min = int(bboxes[:, 0].min())
     y_min = int(bboxes[:, 1].min())
     x_max = int(bboxes[:, 2].max()) + 1  # convert inclusive to exclusive
@@ -589,8 +590,9 @@ def _masks_to_roi(
         image_shape: Image dimensions as ``(height, width)``.
         xyxy: Optional detection boxes of shape ``(N, 4)`` in
             ``[x1, y1, x2, y2]`` format. When provided, the dense path
-            first checks whether all true pixels fall within the box union;
-            if so the box bounds are returned without a full pixel scan.
+            first checks whether all true pixels fall within the union of
+            boxes whose masks have true pixels; if so the box bounds are
+            returned without a full pixel scan.
 
     Returns:
         Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when no true
@@ -605,6 +607,10 @@ def _masks_to_roi(
     # when boxes are mask-derived. Guard it with an `any()` check over the ROI so
     # loose boxes cannot clip true pixels that lie outside the box union.
     if xyxy is not None and len(xyxy) > 0:
+        if mask_array.ndim == 3 and len(xyxy) == len(mask_array):
+            # All-False masks cover no pixels, so their boxes must not widen
+            # the union; at least one box remains because some pixel is true.
+            xyxy = xyxy[mask_array.any(axis=(1, 2))]
         image_h, image_w = image_shape
         box_roi = (
             max(0, int(np.floor(xyxy[:, 0].min()))),
 
@@ -4,6 +4,7 @@
 from collections.abc import Iterator
 from pathlib import Path
 from typing import Any, cast
+from unittest.mock import patch
 
 import numpy as np
 import numpy.typing as npt
@@ -387,7 +388,10 @@ def add_weighted_spy(src1, alpha, src2, beta, gamma, dst=None, dtype=None):
         assert not np.array_equal(result, scene)
         assert blended_shapes == [(45, 60, 3)]
 
-    def test_annotate_skips_all_false_mask_blend(self, monkeypatch):
+    @pytest.mark.parametrize("compact_masks", [False, True])
+    def test_annotate_skips_all_false_mask_blend(
+        self, monkeypatch: pytest.MonkeyPatch, compact_masks: bool
+    ) -> None:
         """All-false masks must skip blending — addWeighted must not be called."""
         height, width = 30, 40
         scene = np.random.default_rng(3).integers(
@@ -397,6 +401,10 @@ def test_annotate_skips_all_false_mask_blend(self, monkeypatch):
         detections = _create_detections(
             xyxy=[[5.0, 5.0, 20.0, 20.0]], mask=[mask], class_id=[0]
         )
+        if compact_masks:
+            detections.mask = CompactMask.from_dense(
+                np.array([mask]), detections.xyxy, (height, width)
+            )
 
         call_count = []
 
@@ -413,6 +421,29 @@ def add_weighted_spy(src1, alpha, src2, beta, gamma, dst=None, dtype=None):
         assert np.array_equal(result, scene)
         assert len(call_count) == 0, "addWeighted called for all-false masks"
 
+    @pytest.mark.parametrize("compact_masks", [False, True])
+    def test_empty_mask_does_not_expand_blend(self, compact_masks: bool) -> None:
+        """An empty full-frame mask does not enlarge a sparse mask's blend region."""
+        scene = np.zeros((60, 80, 3), dtype=np.uint8)
+        masks = np.zeros((2, 60, 80), dtype=bool)
+        masks[1, 40:45, 60:65] = True
+        xyxy = np.array([[0, 0, 79, 59], [60, 40, 64, 44]], dtype=np.float32)
+        mask = (
+            CompactMask.from_dense(masks, xyxy, image_shape=(60, 80))
+            if compact_masks
+            else masks
+        )
+        detections = Detections(xyxy=xyxy, mask=mask)
+        annotator = MaskAnnotator(color=Color.RED, color_lookup=ColorLookup.INDEX)
+
+        with patch.object(cv2, "addWeighted", wraps=cv2.addWeighted) as blend:
+            result = annotator.annotate(scene=scene, detections=detections)
+
+        blend.assert_called_once()
+        assert blend.call_args.args[0].shape == (5, 5, 3)
+        np.testing.assert_array_equal(result.any(axis=2), masks[1])
+        assert result is scene
+
     def test_annotate_pixels_outside_roi_unchanged(self):
         """Pixels outside the blended ROI must be unchanged from the original scene."""
         height, width = 80, 90
 
@@ -1,4 +1,5 @@
 from contextlib import ExitStack as DoesNotRaise
+from unittest.mock import patch
 
 import numpy as np
 import numpy.typing as npt
@@ -78,6 +79,33 @@ def test_compact_masks_to_roi_single_detection_coordinates(self):
         assert x2 >= 8
         assert y2 >= 10
 
+    def test_all_false_compact_masks_have_no_roi(self) -> None:
+        """A nonempty compact collection without foreground has no ROI."""
+        masks = np.zeros((1, 60, 80), dtype=bool)
+        xyxy = np.array([[0, 0, 79, 59]], dtype=np.float32)
+        compact = CompactMask.from_dense(masks, xyxy, image_shape=(60, 80))
+
+        result = _compact_masks_to_roi(compact, (60, 80))
+
+        assert result is None
+
+    @pytest.mark.parametrize("empty_index", [0, 1])
+    def test_empty_compact_crops_do_not_expand_roi(self, empty_index: int) -> None:
+        """An empty full-frame crop leaves the foreground crop's bounds unchanged."""
+        masks = np.zeros((2, 60, 80), dtype=bool)
+        masks[1 - empty_index, 40:45, 60:65] = True
+        xyxy = np.array([[0, 0, 79, 59], [0, 0, 79, 59]], dtype=np.float32)
+        xyxy[1 - empty_index] = [60, 40, 64, 44]
+        compact = CompactMask.from_dense(masks, xyxy, image_shape=(60, 80))
+
+        with (
+            patch.object(CompactMask, "to_dense", side_effect=AssertionError),
+            patch.object(CompactMask, "crop", side_effect=AssertionError),
+        ):
+            result = _compact_masks_to_roi(compact, (60, 80))
+
+        assert result == (60, 40, 65, 45)
+
     def test_compact_masks_to_roi_two_detections_union(self):
         """Two disjoint compact masks union should span both regions."""
         masks = np.zeros((2, 30, 40), dtype=bool)
@@ -153,6 +181,20 @@ def test_masks_to_roi_dense_with_xyxy_all_false_returns_none(self):
         result = _masks_to_roi(masks, (30, 40), xyxy)
         assert result is None
 
+    @pytest.mark.parametrize("empty_index", [0, 1])
+    def test_masks_to_roi_dense_with_xyxy_ignores_empty_mask_boxes(
+        self, empty_index: int
+    ) -> None:
+        """An all-False mask's full-frame box does not widen the dense box union."""
+        masks = np.zeros((2, 60, 80), dtype=bool)
+        masks[1 - empty_index, 40:45, 60:65] = True
+        xyxy = np.array([[0, 0, 79, 59], [0, 0, 79, 59]], dtype=np.float32)
+        xyxy[1 - empty_index] = [60, 40, 64, 44]
+
+        result = _masks_to_roi(masks, (60, 80), xyxy)
+
+        assert result == (60, 40, 65, 45)
+
 
 def test_resize_masks_does_not_upscale_small_masks() -> None:
     """resize_masks returns small masks unchanged instead of upscaling."""