rename nvcv as cvcuda

Author: AntoineSimoulin

test/common_utils.py

@@ -20,7 +20,7 @@
 from torch.testing._comparison import BooleanPair, NonePair, not_close_error_metas, NumberPair, TensorLikePair
 from torchvision import io, tv_tensors
 from torchvision.transforms._functional_tensor import _max_value as get_max_value
-from torchvision.transforms.v2.functional import to_image, to_nvcv_tensor, to_pil_image
+from torchvision.transforms.v2.functional import to_cvcuda_tensor, to_image, to_pil_image
 from torchvision.utils import _Image_fromarray
 
 
@@ -400,8 +400,8 @@ def make_image_pil(*args, **kwargs):
     return to_pil_image(make_image(*args, **kwargs))
 
 
-def make_image_nvcv(*args, **kwargs):
-    return to_nvcv_tensor(make_image(*args, **kwargs))
+def make_image_cvcuda(*args, **kwargs):
+    return to_cvcuda_tensor(make_image(*args, **kwargs))
 
 
 def make_keypoints(canvas_size=DEFAULT_SIZE, *, num_points=4, dtype=None, device="cpu"):

test/test_transforms_v2.py

@@ -29,7 +29,7 @@
     make_bounding_boxes,
     make_detection_masks,
     make_image,
-    make_image_nvcv,
+    make_image_cvcuda,
     make_image_pil,
     make_image_tensor,
     make_keypoints,
@@ -6740,79 +6740,105 @@ def test_functional_error(self):
 
 @pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
 @pytest.mark.skipif(not CUDA_AVAILABLE, reason="test requires CUDA")
-class TestToNVCVTensor:
-    """Tests for to_nvcv_tensor function following patterns from TestToPil"""
-
-    def test_1_channel_uint8_tensor_to_nvcv_tensor(self):
-        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.uint8, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
+class TestToCVCUDATensor:
+    """Tests for to_cvcuda_tensor function following patterns from TestToPil"""
+
+    def test_1_channel_uint8_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.uint8)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
         # Check that the conversion succeeded and format is correct
-        assert nvcv_img is not None
-
-    def test_1_channel_int16_tensor_to_nvcv_tensor(self):
-        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.int16, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
-
-    def test_1_channel_int32_tensor_to_nvcv_tensor(self):
-        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.int32, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
-
-    def test_1_channel_float32_tensor_to_nvcv_tensor(self):
-        img_data = torch.rand(1, 4, 4, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
-
-    def test_3_channel_uint8_tensor_to_nvcv_tensor(self):
-        img_data = torch.randint(0, 256, (3, 4, 4), dtype=torch.uint8, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
-
-    def test_3_channel_float32_tensor_to_nvcv_tensor(self):
-        img_data = torch.rand(3, 4, 4, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
+        assert cvcuda_img is not None
+
+    def test_1_channel_int16_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.int16)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
+
+    def test_1_channel_int32_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.randint(0, 256, (1, 4, 4), dtype=torch.int32)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
+
+    def test_1_channel_float32_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.rand(1, 4, 4)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
+
+    def test_3_channel_uint8_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.randint(0, 256, (3, 4, 4), dtype=torch.uint8)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
+
+    def test_3_channel_float32_tensor_to_cvcuda_tensor(self):
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.rand(3, 4, 4)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
 
     def test_unsupported_num_channels(self):
         # Test 2-channel image (not supported)
-        img_data = torch.rand(2, 5, 5, device="cuda")
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.rand(2, 5, 5)
+        img_data = img_data.cuda()
         with pytest.raises(ValueError, match="Only 1 and 3 channel images are supported"):
-            F.to_nvcv_tensor(img_data)
+            F.to_cvcuda_tensor(img_data)
 
         # Test 4-channel image (not supported)
-        img_data = torch.randint(0, 256, (4, 5, 5), dtype=torch.uint8, device="cuda")
+        img_data = torch.randint(0, 256, (4, 5, 5), dtype=torch.uint8)
+        img_data = img_data.cuda()
         with pytest.raises(ValueError, match="Only 1 and 3 channel images are supported"):
-            F.to_nvcv_tensor(img_data)
+            F.to_cvcuda_tensor(img_data)
 
     def test_invalid_input_type(self):
         with pytest.raises(TypeError, match=r"pic should be `torch.Tensor`"):
-            F.to_nvcv_tensor("invalid_input")
+            F.to_cvcuda_tensor("invalid_input")
 
     def test_invalid_dimensions(self):
         # Test 1D array (too few dimensions)
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
         with pytest.raises(ValueError, match=r"pic should be 3 or 4 dimensional"):
-            F.to_nvcv_tensor(torch.randint(0, 256, (4,), dtype=torch.uint8, device="cuda"))
+            img_data = torch.randint(0, 256, (4,), dtype=torch.uint8)
+            img_data = img_data.cuda()
+            F.to_cvcuda_tensor(img_data)
 
         # Test 2D array (no longer supported)
         with pytest.raises(ValueError, match=r"pic should be 3 or 4 dimensional"):
-            F.to_nvcv_tensor(torch.randint(0, 256, (4, 4), dtype=torch.uint8, device="cuda"))
+            img_data = torch.randint(0, 256, (4, 4), dtype=torch.uint8)
+            img_data = img_data.cuda()
+            F.to_cvcuda_tensor(img_data)
 
         # Test 5D array (too many dimensions)
         with pytest.raises(ValueError, match=r"pic should be 3 or 4 dimensional"):
-            F.to_nvcv_tensor(torch.randint(0, 256, (1, 1, 3, 4, 4), dtype=torch.uint8, device="cuda"))
+            img_data = torch.randint(0, 256, (1, 1, 3, 4, 4), dtype=torch.uint8)
+            img_data = img_data.cuda()
+            F.to_cvcuda_tensor(img_data)
 
-    def test_float64_tensor_to_nvcv_tensor(self):
+    def test_float64_tensor_to_cvcuda_tensor(self):
         # Test single channel float64 (F64 format is supported)
-        img_data = torch.rand(1, 4, 4, dtype=torch.float64, device="cuda")
-        nvcv_img = F.to_nvcv_tensor(img_data)
-        assert nvcv_img is not None
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.rand(1, 4, 4, dtype=torch.float64)
+        img_data = img_data.cuda()
+        cvcuda_img = F.to_cvcuda_tensor(img_data)
+        assert cvcuda_img is not None
 
     def test_float64_rgb_not_supported(self):
         # Test 3-channel float64 is NOT supported (no RGBf64 format in CV-CUDA)
-        img_data = torch.rand(3, 4, 4, dtype=torch.float64, device="cuda")
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
+        img_data = torch.rand(3, 4, 4, dtype=torch.float64)
+        img_data = img_data.cuda()
         with pytest.raises(TypeError, match=r"Unsupported dtype"):
-            F.to_nvcv_tensor(img_data)
+            F.to_cvcuda_tensor(img_data)
 
     @pytest.mark.parametrize("num_channels", [1, 3])
     @pytest.mark.parametrize("dtype", [torch.uint8, torch.float32, torch.float64])
@@ -6822,15 +6848,17 @@ def test_round_trip(self, num_channels, dtype):
             pytest.skip("float64 is not supported for 3-channel RGB images")
 
         # Setup: Create a tensor in CHW format (PyTorch standard)
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
         if dtype == torch.uint8:
-            original_tensor = torch.randint(0, 256, (num_channels, 4, 4), dtype=dtype, device="cuda")
+            original_tensor = torch.randint(0, 256, (num_channels, 4, 4), dtype=dtype)
         else:
-            original_tensor = torch.rand(num_channels, 4, 4, dtype=dtype, device="cuda")
+            original_tensor = torch.rand(num_channels, 4, 4, dtype=dtype)
+        original_tensor = original_tensor.cuda()
 
-        # Execute: Convert to NVCV and back to tensor
-        # CHW -> (to_nvcv_tensor) -> NVCV NHWC -> (nvcv_to_tensor) -> NCHW
-        nvcv_tensor = F.to_nvcv_tensor(original_tensor)
-        result_tensor = F.nvcv_to_tensor(nvcv_tensor)
+        # Execute: Convert to CV-CUDA and back to tensor
+        # CHW -> (to_cvcuda_tensor) -> CV-CUDA NHWC -> (cvcuda_to_tensor) -> NCHW
+        cvcuda_tensor = F.to_cvcuda_tensor(original_tensor)
+        result_tensor = F.cvcuda_to_tensor(cvcuda_tensor)
 
         # Remove batch dimension that was added during conversion since original was unbatched
         result_tensor = result_tensor.squeeze(0)
@@ -6847,15 +6875,17 @@ def test_round_trip_batched(self, num_channels, dtype, batch_size):
             pytest.skip("float64 is not supported for 3-channel RGB images")
 
         # Setup: Create a batched tensor in NCHW format
+        # Create tensor on CPU first, then move to CUDA to avoid CUDA context issues
         if dtype == torch.uint8:
-            original_tensor = torch.randint(0, 256, (batch_size, num_channels, 4, 4), dtype=dtype, device="cuda")
+            original_tensor = torch.randint(0, 256, (batch_size, num_channels, 4, 4), dtype=dtype)
         else:
-            original_tensor = torch.rand(batch_size, num_channels, 4, 4, dtype=dtype, device="cuda")
+            original_tensor = torch.rand(batch_size, num_channels, 4, 4, dtype=dtype)
+        original_tensor = original_tensor.cuda()
 
-        # Execute: Convert to NVCV and back to tensor
-        # NCHW -> (to_nvcv_tensor) -> NVCV NHWC -> (nvcv_to_tensor) -> NCHW
-        nvcv_tensor = F.to_nvcv_tensor(original_tensor)
-        result_tensor = F.nvcv_to_tensor(nvcv_tensor)
+        # Execute: Convert to CV-CUDA and back to tensor
+        # NCHW -> (to_cvcuda_tensor) -> CV-CUDA NHWC -> (cvcuda_to_tensor) -> NCHW
+        cvcuda_tensor = F.to_cvcuda_tensor(original_tensor)
+        result_tensor = F.cvcuda_to_tensor(cvcuda_tensor)
 
         # Assert: The round-trip conversion preserves the original batched tensor exactly
         torch.testing.assert_close(result_tensor, original_tensor, rtol=0, atol=0)
@@ -6865,25 +6895,25 @@ def test_round_trip_batched(self, num_channels, dtype, batch_size):
 
 @pytest.mark.skipif(not CVCUDA_AVAILABLE, reason="test requires CVCUDA")
 @pytest.mark.skipif(not CUDA_AVAILABLE, reason="test requires CUDA")
-class TestNVCVToTensor:
+class TestCVDUDAToTensor:
     @pytest.mark.parametrize("color_space", ["RGB", "GRAY"])
     @pytest.mark.parametrize(
         "fn",
-        [F.nvcv_to_tensor, transform_cls_to_functional(transforms.NVCVToTensor)],
+        [F.cvcuda_to_tensor, transform_cls_to_functional(transforms.CVCUDAToTensor)],
     )
     def test_functional_and_transform(self, color_space, fn):
-        input = make_image_nvcv(color_space=color_space)
+        input = make_image_cvcuda(color_space=color_space)
 
         output = fn(input)
 
         assert isinstance(output, torch.Tensor)
         # Convert input to tensor to compare sizes
-        input_tensor = F.nvcv_to_tensor(input)
+        input_tensor = F.cvcuda_to_tensor(input)
         assert F.get_size(output) == F.get_size(input_tensor)
 
     def test_functional_error(self):
-        with pytest.raises(TypeError, match="nvcv_img should be `nvcv.Tensor`"):
-            F.nvcv_to_tensor(object())
+        with pytest.raises(TypeError, match="cvcuda_img should be `cvcuda.Tensor`"):
+            F.cvcuda_to_tensor(object())
 
 
 class TestLambda:

torchvision/__init__.py

@@ -102,7 +102,6 @@ def _is_tracing():
 def _is_cvcuda_available() -> bool:
     try:
         import cvcuda  # type: ignore[import-not-found]
-        import nvcv  # type: ignore[import-not-found]
 
         return True
     except ImportError:

torchvision/transforms/v2/__init__.py

@@ -55,7 +55,7 @@
     ToDtype,
 )
 from ._temporal import UniformTemporalSubsample
-from ._type_conversion import NVCVToTensor, PILToTensor, ToImage, ToNVCVTensor, ToPILImage, ToPureTensor
+from ._type_conversion import CVCUDAToTensor, PILToTensor, ToCVCUDATensor, ToImage, ToPILImage, ToPureTensor
 from ._utils import check_type, get_bounding_boxes, get_keypoints, has_all, has_any, query_chw, query_size
 
 from ._deprecated import ToTensor  # usort: skip

torchvision/transforms/v2/_type_conversion.py

@@ -92,12 +92,12 @@ def transform(self, inpt: Any, params: dict[str, Any]) -> torch.Tensor:
         return inpt.as_subclass(torch.Tensor)
 
 
-class ToNVCVTensor:
-    """Convert a torch.Tensor to nvcv.Tensor
+class ToCVCUDATensor:
+    """Convert a torch.Tensor to cvcuda.Tensor
 
     This transform does not support torchscript.
 
-    Converts a torch.*Tensor of shape C x H x W to a nvcv.Tensor.
+    Converts a torch.*Tensor of shape C x H x W to a cvcuda.Tensor.
     Only 1-channel and 3-channel images are supported.
     """
 
@@ -107,38 +107,40 @@ def __init__(self):
     def __call__(self, pic):
         """
         Args:
-            pic (torch.Tensor): Image to be converted to nvcv.Tensor.
+            pic (torch.Tensor): Image to be converted to cvcuda.Tensor.
 
         Returns:
-            nvcv.Tensor: Image converted to nvcv.Tensor.
+            cvcuda.Tensor: Image converted to cvcuda.Tensor.
 
         """
-        return F.to_nvcv_tensor(pic)
+        return F.to_cvcuda_tensor(pic)
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}()"
 
 
-class NVCVToTensor:
-    """Convert a `nvcv.Tensor` to a `torch.Tensor` of the same type - this does not scale values.
+class CVCUDAToTensor:
+    """Convert a `cvcuda.Tensor` to a `torch.Tensor` of the same type - this does not scale values.
 
     This transform does not support torchscript.
 
-    Converts a `nvcv.Tensor` to a `torch.Tensor`. Supports both batched and unbatched inputs:
+    Converts a `cvcuda.Tensor` to a `torch.Tensor`. Supports both batched and unbatched inputs:
     - Unbatched: (H, W, C) or (H, W) → (C, H, W) or (1, H, W)
     - Batched: (N, H, W, C) or (N, H, W) → (N, C, H, W) or (N, 1, H, W)
 
-    The conversion happens directly on GPU when the `nvcv.Tensor` is stored on GPU,
+    The conversion happens directly on GPU when the `cvcuda.Tensor` is stored on GPU,
     avoiding unnecessary data transfers.
 
     Example:
-        >>> import nvcv
+        >>> import cvcuda
         >>> import torchvision.transforms.v2 as T
-        >>> # Create an NVCV Image (320x240 RGB)
-        >>> nvcv_img = nvcv.Image(nvcv.Size2D(320, 240), nvcv.Format.RGB8)
-        >>> tensor = T.NVCVToTensor()(nvcv_img)
+        >>> # Create a CV-CUDA tensor (320x240 RGB)
+        >>> # Note: In CV-CUDA 0.16.0+, Image/Tensor creation uses cvcuda module
+        >>> img_tensor = torch.randint(0, 255, (1, 240, 320, 3), dtype=torch.uint8, device="cuda")
+        >>> cvcuda_tensor = cvcuda.as_tensor(img_tensor, cvcuda.TensorLayout.NHWC)
+        >>> tensor = T.CVCUDAToTensor()(cvcuda_tensor)
         >>> print(tensor.shape)
-        torch.Size([3, 240, 320])
+        torch.Size([1, 3, 240, 320])
     """
 
     def __init__(self) -> None:
@@ -147,12 +149,12 @@ def __init__(self) -> None:
     def __call__(self, pic):
         """
         Args:
-            pic (nvcv.Image): NVCV Image to be converted to tensor.
+            pic (cvcuda.Tensor): CV-CUDA Tensor to be converted to tensor.
 
         Returns:
             Tensor: Converted image in CHW format.
         """
-        return F.nvcv_to_tensor(pic)
+        return F.cvcuda_to_tensor(pic)
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}()"

torchvision/transforms/v2/functional/__init__.py

@@ -162,6 +162,6 @@
     to_dtype_video,
 )
 from ._temporal import uniform_temporal_subsample, uniform_temporal_subsample_video
-from ._type_conversion import nvcv_to_tensor, pil_to_tensor, to_image, to_nvcv_tensor, to_pil_image
+from ._type_conversion import cvcuda_to_tensor, pil_to_tensor, to_cvcuda_tensor, to_image, to_pil_image
 
 from ._deprecated import get_image_size, to_tensor  # usort: skip