@@ -7,6 +7,8 @@ date_modified: 2026-10-15
 
 ### Unreleased <small>upcoming</small>
 
+- The NumPy `resize` fallback now samples the same source pixel as OpenCV for `INTER_NEAREST` when `dsize` is given. It used the exact integer ratio `x * src // dst`, while OpenCV steps through the source with the reciprocal of the size ratio. At some whole-number positions of `x * src / dst`, reciprocal multiplication rounds below the integer: a 6-pixel ramp resized to 34 wide picks pixel 2 at `x = 17`, not 3. These differences also made `sv.CompactMask.resize`, which derives its grid from this call, give different masks with and without OpenCV installed. ([#2722](https://github.com/roboflow/supervision/pull/2722))
+
 - `sv.process_video` now stops its reader when a callback or frame write fails, including callback interruption, instead of decoding the rest of the source before raising the error. Shutdown releases the source capture and waits for queued writes unless the writer itself fails; an active backend decode or write is allowed to finish. Decoding and callback errors retain their original exceptions when capture or output-writer release also fails; secondary cleanup failures are logged. ([#2720](https://github.com/roboflow/supervision/pull/2720))
 
 - `sv.LabelAnnotator`, `sv.RichLabelAnnotator` and `sv.VertexLabelAnnotator` with `smart_position=True` now separate labels whose boxes share a center. `spread_out_boxes` pushes overlapping boxes away from each other's centers, and boxes with the same center got no direction, so they stayed exactly on top of each other and only the last label was visible: two detections with the same box and same-width labels, or two key points at the same position. Such boxes are now pushed apart vertically, the earlier one upward. ([#2718](https://github.com/roboflow/supervision/pull/2718))
 
@@ -140,7 +140,7 @@ def _resize(
     fy: float = 0,
     interpolation: int = _INTER_LINEAR,
 ) -> npt.NDArray[Any]:
-    """Resize with exact nearest or OpenCV-compatible linear sampling."""
+    """Resize with OpenCV-compatible nearest or linear sampling."""
     source_height, source_width = src.shape[:2]
     width, height = dsize if dsize is not None else (0, 0)
     # Like OpenCV, when the size comes from `fx`/`fy`, pixels are mapped with
@@ -156,15 +156,16 @@ def _resize(
     if scale_from_factors:
         scale_x, scale_y = 1 / fx, 1 / fy
     else:
-        scale_x, scale_y = source_width / width, source_height / height
+        # OpenCV steps through the source with the reciprocal of the size ratio
+        # (`ifx = 1. / (dsize.width / ssize.width)`), whose rounding can put a
+        # whole-number position such as 17 * 6 / 34 just below 3.0, so the
+        # exact integer ratio would pick a different pixel there.
+        scale_x = 1 / (width / source_width)
+        scale_y = 1 / (height / source_height)
 
     if interpolation == _INTER_NEAREST:
-        if scale_from_factors:
-            y_indices = np.floor(np.arange(height) * scale_y).astype(np.int64)
-            x_indices = np.floor(np.arange(width) * scale_x).astype(np.int64)
-        else:
-            y_indices = np.arange(height) * source_height // height
-            x_indices = np.arange(width) * source_width // width
+        y_indices = np.floor(np.arange(height) * scale_y).astype(np.int64)
+        x_indices = np.floor(np.arange(width) * scale_x).astype(np.int64)
         y_indices = np.minimum(y_indices, source_height - 1)
         x_indices = np.minimum(x_indices, source_width - 1)
         return np.ascontiguousarray(src[y_indices[:, np.newaxis], x_indices])
 
@@ -201,6 +201,38 @@ def test_fallback_resize_matches_opencv(interpolation: int, atol: int) -> None:
     np.testing.assert_allclose(actual, expected, atol=atol, rtol=0)
 
 
+@pytest.mark.parametrize(
+    ("source_width", "width"),
+    [
+        pytest.param(6, 34, id="six-to-thirty-four"),
+        pytest.param(9, 51, id="nine-to-fifty-one"),
+        pytest.param(10, 74, id="ten-to-seventy-four"),
+        pytest.param(12, 34, id="twelve-to-thirty-four"),
+    ],
+)
+def test_fallback_nearest_resize_matches_opencv_at_whole_sample_positions(
+    source_width: int, width: int
+) -> None:
+    """Pick OpenCV's source pixel where `x * source_width / width` is a whole number."""
+    source = np.arange(source_width, dtype=np.uint8).reshape(1, -1)
+
+    actual = _resize(source, (width, 1), interpolation=cv2.INTER_NEAREST)
+    expected = cv2.resize(source, (width, 1), interpolation=cv2.INTER_NEAREST)
+
+    np.testing.assert_array_equal(actual, expected)
+
+
+def test_fallback_nearest_resize_matches_opencv_on_both_axes() -> None:
+    """Match OpenCV's nearest sampling grid on rows and columns of a color image."""
+    rng = np.random.default_rng(20261012)
+    source = rng.integers(0, 256, (9, 6, 3), dtype=np.uint8)
+
+    actual = _resize(source, (34, 51), interpolation=cv2.INTER_NEAREST)
+    expected = cv2.resize(source, (34, 51), interpolation=cv2.INTER_NEAREST)
+
+    np.testing.assert_array_equal(actual, expected)
+
+
 @pytest.mark.parametrize(
     ("interpolation", "atol"),
     [