Add direct XYWH-CXCYWH conversion for better performance (#9326)

raimbekovm · zy1git · Zhitao Yu · web-flow · commit 0cf8cabb4a9a · 2026-02-23T22:03:14.000-08:00
Co-authored-by: zy1git &lt;zycoding1@gmail.com&gt;
Co-authored-by: Zhitao Yu &lt;zhitao@fb.com&gt;
diff --git a/test/test_transforms_v2.py b/test/test_transforms_v2.py
@@ -53,6 +53,14 @@
 from torchvision.transforms.v2 import functional as F
 from torchvision.transforms.v2._utils import check_type, is_pure_tensor
 from torchvision.transforms.v2.functional._geometry import _get_perspective_coeffs, _parallelogram_to_bounding_boxes
+from torchvision.transforms.v2.functional._meta import (
+    _cxcywh_to_xywh,
+    _cxcywh_to_xyxy,
+    _xywh_to_cxcywh,
+    _xywh_to_xyxy,
+    _xyxy_to_cxcywh,
+    _xyxy_to_xywh,
+)
 from torchvision.transforms.v2.functional._utils import _get_kernel, _import_cvcuda, _register_kernel_internal
 
 
@@ -4314,8 +4322,14 @@ def test_kernel_noop(self, format, inplace):
         assert output._version == input_version
 
     @pytest.mark.parametrize(("old_format", "new_format"), old_new_formats)
-    def test_kernel_inplace(self, old_format, new_format):
-        input = make_bounding_boxes(format=old_format).as_subclass(torch.Tensor)
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.int64])
+    def test_kernel_inplace(self, old_format, new_format, dtype):
+        if not dtype.is_floating_point and (
+            tv_tensors.is_rotated_bounding_format(old_format) or tv_tensors.is_rotated_bounding_format(new_format)
+        ):
+            pytest.xfail("Rotated bounding boxes should be floating point tensors")
+
+        input = make_bounding_boxes(format=old_format, dtype=dtype).as_subclass(torch.Tensor)
         input_version = input._version
 
         output_out_of_place = F.convert_bounding_box_format(input, old_format=old_format, new_format=new_format)
@@ -4412,6 +4426,26 @@ def test_errors(self):
                 input_tv_tensor, old_format=input_tv_tensor.format, new_format=input_tv_tensor.format
             )
 
+    @pytest.mark.parametrize(
+        "old_format",
+        [tv_tensors.BoundingBoxFormat.XYWH, tv_tensors.BoundingBoxFormat.CXCYWH],
+    )
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float64, torch.int32, torch.int64])
+    @pytest.mark.parametrize("device", cpu_and_cuda())
+    def test_xywh_cxcywh_direct_conversion_parity(self, old_format, dtype, device):
+
+        bounding_boxes = make_bounding_boxes(format=old_format, dtype=dtype, device=device)
+        input_tensor = bounding_boxes.as_subclass(torch.Tensor).clone()
+
+        if old_format == tv_tensors.BoundingBoxFormat.XYWH:
+            actual = _xywh_to_cxcywh(input_tensor.clone(), inplace=False)
+            expected = _xyxy_to_cxcywh(_xywh_to_xyxy(input_tensor.clone(), inplace=False), inplace=False)
+        else:
+            actual = _cxcywh_to_xywh(input_tensor.clone(), inplace=False)
+            expected = _xyxy_to_xywh(_cxcywh_to_xyxy(input_tensor.clone(), inplace=False), inplace=False)
+
+        torch.testing.assert_close(actual, expected)
+
     def test_cxcywh_to_xyxy_odd_dimensions(self):
         # Non-regression test for https://github.com/pytorch/vision/issues/8887
         # Integer bounding boxes with odd width/height produced incorrect results
diff --git a/torchvision/transforms/v2/functional/_meta.py b/torchvision/transforms/v2/functional/_meta.py
@@ -176,6 +176,46 @@ def _xyxy_to_xywh(xyxy: torch.Tensor, inplace: bool) -> torch.Tensor:
     return xywh
 
 
+def _xywh_to_cxcywh(xywh: torch.Tensor, inplace: bool) -> torch.Tensor:
+    if not inplace:
+        xywh = xywh.clone()
+
+    # cx = x + width / 2, cy = y + height / 2, width and height stay the same
+    xywh[..., :2].add_(xywh[..., 2:].div(2, rounding_mode=None if xywh.is_floating_point() else "floor"))
+
+    return xywh
+
+
+def _cxcywh_to_xywh(cxcywh: torch.Tensor, inplace: bool) -> torch.Tensor:
+    # For integer tensors, use float arithmetic to match the behavior of the
+    # two-step conversion CXCYWH -> XYXY -> XYWH (where _cxcywh_to_xyxy uses
+    # float arithmetic, see PR #9322).
+    original = cxcywh
+    dtype = cxcywh.dtype
+    need_cast = not cxcywh.is_floating_point()
+
+    if need_cast:
+        cxcywh = cxcywh.float()
+    elif not inplace:
+        cxcywh = cxcywh.clone()
+
+    half_wh = cxcywh[..., 2:] / 2
+    # x = cx - w/2, y = cy - h/2
+    cxcywh[..., :2].sub_(half_wh)
+
+    if need_cast:
+        # For integer types, truncation of x1/y1 and x2/y2 (= x1 + w, y1 + h) can change
+        # the effective width/height. Recompute w/h to match the two-step path.
+        x2y2 = (cxcywh[..., :2] + cxcywh[..., 2:]).to(dtype)
+        cxcywh = cxcywh.to(dtype)
+        cxcywh[..., 2:] = x2y2 - cxcywh[..., :2]
+        if inplace:
+            original[:] = cxcywh
+            return original
+
+    return cxcywh
+
+
 def _cxcywh_to_xyxy(cxcywh: torch.Tensor, inplace: bool) -> torch.Tensor:
     # For integer tensors, use float arithmetic to match the behavior of
     # `torchvision.ops._box_convert._box_cxcywh_to_xyxy`.
@@ -316,7 +356,11 @@ def _convert_bounding_box_format(
     if tv_tensors.is_rotated_bounding_format(old_format) ^ tv_tensors.is_rotated_bounding_format(new_format):
         raise ValueError("Cannot convert between rotated and unrotated bounding boxes.")
 
-    # TODO: Add _xywh_to_cxcywh and _cxcywh_to_xywh to improve performance
+    if old_format == BoundingBoxFormat.XYWH and new_format == BoundingBoxFormat.CXCYWH:
+        return _xywh_to_cxcywh(bounding_boxes, inplace)
+    if old_format == BoundingBoxFormat.CXCYWH and new_format == BoundingBoxFormat.XYWH:
+        return _cxcywh_to_xywh(bounding_boxes, inplace)
+
     if old_format == BoundingBoxFormat.XYWH:
         bounding_boxes = _xywh_to_xyxy(bounding_boxes, inplace)
     elif old_format == BoundingBoxFormat.CXCYWH:
