implement invert cvcuda

Author: justincdavis

test/test_transforms_v2.py

@@ -5772,7 +5772,18 @@ def test_kernel_image(self, dtype, device):
     def test_kernel_video(self):
         check_kernel(F.invert_video, make_video())
 
-    @pytest.mark.parametrize("make_input", [make_image_tensor, make_image, make_image_pil, make_video])
+    @pytest.mark.parametrize(
+        "make_input",
+        [
+            make_image_tensor,
+            make_image,
+            make_image_pil,
+            make_video,
+            pytest.param(
+                make_image_cvcuda, marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
+            ),
+        ],
+    )
     def test_functional(self, make_input):
         check_functional(F.invert, make_input())
 
@@ -5783,12 +5794,30 @@ def test_functional(self, make_input):
             (F._color._invert_image_pil, PIL.Image.Image),
             (F.invert_image, tv_tensors.Image),
             (F.invert_video, tv_tensors.Video),
+            pytest.param(
+                F._color._invert_cvcuda,
+                "cvcuda.Tensor",
+                marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA"),
+            ),
         ],
     )
     def test_functional_signature(self, kernel, input_type):
+        if input_type == "cvcuda.Tensor":
+            input_type = _import_cvcuda().Tensor
         check_functional_kernel_signature_match(F.invert, kernel=kernel, input_type=input_type)
 
-    @pytest.mark.parametrize("make_input", [make_image_tensor, make_image_pil, make_image, make_video])
+    @pytest.mark.parametrize(
+        "make_input",
+        [
+            make_image_tensor,
+            make_image_pil,
+            make_image,
+            make_video,
+            pytest.param(
+                make_image_cvcuda, marks=pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
+            ),
+        ],
+    )
     def test_transform(self, make_input):
         check_transform(transforms.RandomInvert(p=1), make_input())
 
@@ -5801,6 +5830,16 @@ def test_correctness_image(self, fn):
 
         assert_equal(actual, expected)
 
+    @pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
+    @pytest.mark.parametrize("dtype", [torch.uint8, torch.float32])
+    @pytest.mark.parametrize("fn", [F.invert, transform_cls_to_functional(transforms.RandomInvert, p=1)])
+    def test_correctness_cvcuda(self, dtype, fn):
+        image = make_image(batch_dims=(1,), dtype=dtype, device="cuda")
+        cv_image = F.to_cvcuda_tensor(image)
+        actual = F.cvcuda_to_tensor(fn(cv_image))
+        expected = F.invert_image(image)
+        assert_equal(actual, expected)
+
 
 class TestPosterize:
     @pytest.mark.parametrize("dtype", [torch.uint8, torch.float32])

torchvision/transforms/v2/functional/_color.py

@@ -690,6 +690,42 @@ def invert_video(video: torch.Tensor) -> torch.Tensor:
     return invert_image(video)
 
 
+if _CVCUDA_AVAILABLE:
+    _invert_cvcuda_tensors = {}
+
+
+def _invert_cvcuda(image: "cvcuda.Tensor") -> "cvcuda.Tensor":
+    cvcuda = _import_cvcuda()
+
+    if "base" not in _invert_cvcuda_tensors:
+        _invert_cvcuda_tensors["base"] = cvcuda.as_tensor(
+            torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, device="cuda").reshape(1, 1, 1, 3).contiguous(), "NHWC"
+        )
+    if "scale" not in _invert_cvcuda_tensors:
+        _invert_cvcuda_tensors["scale"] = cvcuda.as_tensor(
+            torch.tensor([-1.0, -1.0, -1.0], dtype=torch.float32, device="cuda").reshape(1, 1, 1, 3).contiguous(),
+            "NHWC",
+        )
+
+    base = _invert_cvcuda_tensors["base"]
+    scale = _invert_cvcuda_tensors["scale"]
+
+    if image.dtype == cvcuda.Type.U8:
+        shift = 255.0
+    elif image.dtype == cvcuda.Type.F32:
+        shift = 1.0
+    else:
+        raise ValueError(f"Input image dtype must be uint8 or float32, got {image.dtype}")
+
+    # Use normalize to invert: output = (input - base) * scale * global_scale + shift
+    # For inversion: output = (input - 0) * (-1) * 1 + shift = shift - input
+    return cvcuda.normalize(image, base=base, scale=scale, globalscale=1.0, globalshift=shift)
+
+
+if _CVCUDA_AVAILABLE:
+    _register_kernel_internal(invert, _import_cvcuda().Tensor)(_invert_cvcuda)
+
+
 def permute_channels(inpt: torch.Tensor, permutation: list[int]) -> torch.Tensor:
     """Permute the channels of the input according to the given permutation.