monai-weekly 1.5.dev2505__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/transforms/test_squeezedim.py

@@ -0,0 +1,62 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data import MetaTensor
+from monai.transforms import SqueezeDim
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS, TESTS_FAIL = [], []
+for p in TEST_NDARRAYS:
+    TESTS.append([{"dim": None}, p(np.random.rand(1, 2, 1, 3)), (2, 3)])
+    TESTS.append([{"dim": 2}, p(np.random.rand(1, 2, 1, 8, 16)), (1, 2, 8, 16)])
+    TESTS.append([{"dim": -1}, p(np.random.rand(1, 1, 16, 8, 1)), (1, 1, 16, 8)])
+    TESTS.append([{}, p(np.random.rand(1, 2, 1, 3)), (2, 1, 3)])
+
+    TESTS_FAIL.append([ValueError, {"dim": -2}, p(np.random.rand(1, 1, 16, 8, 1))])
+    TESTS_FAIL.append([TypeError, {"dim": 0.5}, p(np.random.rand(1, 1, 16, 8, 1))])
+
+
+class TestSqueezeDim(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, test_data, expected_shape):
+        result = SqueezeDim(**input_param)(test_data)
+        self.assertTupleEqual(result.shape, expected_shape)
+        if "dim" in input_param and input_param["dim"] == 2 and isinstance(result, MetaTensor):
+            assert_allclose(result.affine.shape, [3, 3])
+
+    @parameterized.expand(TESTS_FAIL)
+    def test_invalid_inputs(self, exception, input_param, test_data):
+        with self.assertRaises(exception):
+            SqueezeDim(**input_param)(test_data)
+
+    def test_affine_ill_inputs(self):
+        img = MetaTensor(
+            np.random.rand(1, 2, 1, 3),
+            affine=[
+                [-0.7422, 0.0, 0.0, 186.3210],
+                [0.0, 0.0, -3.0, 70.6580],
+                [0.0, -0.7422, 0.0, 189.4130],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
+        )
+        with self.assertWarns(UserWarning):
+            SqueezeDim(dim=2)(img)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_squeezedimd.py

@@ -0,0 +1,98 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data import MetaTensor
+from monai.transforms import SqueezeDimd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS, TESTS_FAIL = [], []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "dim": None},
+            {"img": p(np.random.rand(1, 2, 1, 3)), "seg": p(np.random.randint(0, 2, size=[1, 2, 1, 3]))},
+            (2, 3),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "dim": 2},
+            {"img": p(np.random.rand(1, 2, 1, 8, 16)), "seg": p(np.random.randint(0, 2, size=[1, 2, 1, 8, 16]))},
+            (1, 2, 8, 16),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "dim": -1},
+            {"img": p(np.random.rand(1, 1, 16, 8, 1)), "seg": p(np.random.randint(0, 2, size=[1, 1, 16, 8, 1]))},
+            (1, 1, 16, 8),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"]},
+            {"img": p(np.random.rand(1, 2, 1, 3)), "seg": p(np.random.randint(0, 2, size=[1, 2, 1, 3]))},
+            (2, 1, 3),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "dim": 0},
+            {"img": p(np.random.rand(1, 2, 1, 3)), "seg": p(np.random.randint(0, 2, size=[1, 2, 1, 3]))},
+            (2, 1, 3),
+        ]
+    )
+
+    TESTS_FAIL.append(
+        [
+            ValueError,
+            {"keys": ["img", "seg"], "dim": -2},
+            {"img": p(np.random.rand(1, 1, 16, 8, 1)), "seg": p(np.random.randint(0, 2, size=[1, 1, 16, 8, 1]))},
+        ]
+    )
+
+    TESTS_FAIL.append(
+        [
+            TypeError,
+            {"keys": ["img", "seg"], "dim": 0.5},
+            {"img": p(np.random.rand(1, 1, 16, 8, 1)), "seg": p(np.random.randint(0, 2, size=[1, 1, 16, 8, 1]))},
+        ]
+    )
+
+
+class TestSqueezeDim(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, test_data, expected_shape):
+        result = SqueezeDimd(**input_param)(test_data)
+        self.assertTupleEqual(result["img"].shape, expected_shape)
+        self.assertTupleEqual(result["seg"].shape, expected_shape)
+        if "dim" in input_param and isinstance(result["img"], MetaTensor) and input_param["dim"] == 2:
+            assert_allclose(result["img"].affine.shape, [3, 3])
+
+    @parameterized.expand(TESTS_FAIL)
+    def test_invalid_inputs(self, exception, input_param, test_data):
+        with self.assertRaises(exception):
+            SqueezeDimd(**input_param)(test_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_std_shift_intensity.py

@@ -0,0 +1,76 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from monai.transforms import ShiftIntensity, StdShiftIntensity
+from monai.utils import dtype_numpy_to_torch
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestStdShiftIntensity(NumpyImageTestCase2D):
+    def test_value(self):
+        for p in TEST_NDARRAYS:
+            imt = p(self.imt)
+            factor = np.random.rand()
+            offset = np.std(self.imt) * factor
+            shifter = ShiftIntensity(offset=offset)
+            expected = shifter(imt)
+            std_shifter = StdShiftIntensity(factor=factor)
+            result = std_shifter(imt)
+            assert_allclose(result, expected, atol=0, rtol=1e-5, type_test=False)
+
+    def test_zerostd(self):
+        for p in TEST_NDARRAYS:
+            image = p(np.ones([2, 3, 3], dtype=np.float32))
+            for nonzero in [True, False]:
+                for channel_wise in [True, False]:
+                    factor = np.random.rand()
+                    std_shifter = StdShiftIntensity(factor=factor, nonzero=nonzero, channel_wise=channel_wise)
+                    result = std_shifter(image)
+                    assert_allclose(result, image, atol=0, rtol=1e-5, type_test=False)
+
+    def test_nonzero(self):
+        for p in TEST_NDARRAYS:
+            image = p(np.asarray([[4.0, 0.0, 2.0], [0, 2, 4]]))  # std = 1
+            factor = np.random.rand()
+            std_shifter = StdShiftIntensity(factor=factor, nonzero=True)
+            result = std_shifter(image)
+            expected = p(np.asarray([[4 + factor, 0, 2 + factor], [0, 2 + factor, 4 + factor]], dtype=np.float32))
+            assert_allclose(result, expected, atol=0, rtol=1e-5, type_test=False)
+
+    def test_channel_wise(self):
+        for p in TEST_NDARRAYS:
+            image = p(np.stack((np.asarray([1.0, 2.0]), np.asarray([1.0, 1.0]))))  # std: 0.5, 0
+            factor = np.random.rand()
+            std_shifter = StdShiftIntensity(factor=factor, channel_wise=True)
+            result = std_shifter(image)
+            expected = p(
+                np.stack((np.asarray([1 + 0.5 * factor, 2 + 0.5 * factor]), np.asarray([1, 1]))).astype(np.float32)
+            )
+            assert_allclose(result, expected, atol=0, rtol=1e-5, type_test=False)
+
+    def test_dtype(self):
+        trans_dtype = np.float32
+        for dtype in [int, np.float32, np.float64]:
+            image = np.random.rand(2, 2, 2).astype(dtype)
+            factor = np.random.rand()
+            std_shifter = StdShiftIntensity(factor=factor, dtype=trans_dtype)
+            result = std_shifter(image)
+            np.testing.assert_equal(result.dtype, dtype_numpy_to_torch(trans_dtype))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_std_shift_intensityd.py

@@ -0,0 +1,74 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from monai.transforms import ShiftIntensityd, StdShiftIntensityd
+from monai.utils import dtype_numpy_to_torch
+from tests.test_utils import NumpyImageTestCase2D
+
+
+class TestStdShiftIntensityd(NumpyImageTestCase2D):
+    def test_value(self):
+        key = "img"
+        factor = np.random.rand()
+        offset = np.std(self.imt) * factor
+        shifter = ShiftIntensityd(keys=[key], offset=offset)
+        expected = shifter({key: self.imt})
+        std_shifter = StdShiftIntensityd(keys=[key], factor=factor)
+        result = std_shifter({key: self.imt})
+        np.testing.assert_allclose(result[key], expected[key], rtol=1e-5)
+
+    def test_zerostd(self):
+        key = "img"
+        image = np.ones([2, 3, 3])
+        for nonzero in [True, False]:
+            for channel_wise in [True, False]:
+                factor = np.random.rand()
+                std_shifter = StdShiftIntensityd(keys=[key], factor=factor, nonzero=nonzero, channel_wise=channel_wise)
+                result = std_shifter({key: image})
+                np.testing.assert_allclose(result[key], image, rtol=1e-5)
+
+    def test_nonzero(self):
+        key = "img"
+        image = np.asarray([[4.0, 0.0, 2.0], [0, 2, 4]])  # std = 1
+        factor = np.random.rand()
+        std_shifter = StdShiftIntensityd(keys=[key], factor=factor, nonzero=True)
+        result = std_shifter({key: image})
+        expected = np.asarray([[4 + factor, 0, 2 + factor], [0, 2 + factor, 4 + factor]])
+        np.testing.assert_allclose(result[key], expected, rtol=1e-5)
+
+    def test_channel_wise(self):
+        key = "img"
+        image = np.stack((np.asarray([1.0, 2.0]), np.asarray([1.0, 1.0])))  # std: 0.5, 0
+        factor = np.random.rand()
+        std_shifter = StdShiftIntensityd(keys=[key], factor=factor, channel_wise=True)
+        result = std_shifter({key: image})
+        expected = np.stack((np.asarray([1 + 0.5 * factor, 2 + 0.5 * factor]), np.asarray([1, 1])))
+        np.testing.assert_allclose(result[key], expected, rtol=1e-5)
+
+    def test_dtype(self):
+        key = "img"
+        trans_dtype = np.float32
+        for dtype in [int, np.float32, np.float64]:
+            image = np.random.rand(2, 2, 2).astype(dtype)
+            factor = np.random.rand()
+            std_shifter = StdShiftIntensityd(keys=[key], factor=factor, dtype=trans_dtype)
+            result = std_shifter({key: image})
+            np.testing.assert_equal(result[key].dtype, dtype_numpy_to_torch(trans_dtype))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_threshold_intensity.py

@@ -0,0 +1,38 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ThresholdIntensity
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, {"threshold": 5, "above": True, "cval": 0}, (0, 0, 0, 0, 0, 0, 6, 7, 8, 9)])
+    TESTS.append([p, {"threshold": 5, "above": False, "cval": 0}, (0, 1, 2, 3, 4, 0, 0, 0, 0, 0)])
+    TESTS.append([p, {"threshold": 5, "above": True, "cval": 5}, (5, 5, 5, 5, 5, 5, 6, 7, 8, 9)])
+
+
+class TestThresholdIntensity(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, in_type, input_param, expected_value):
+        test_data = in_type(np.arange(10))
+        result = ThresholdIntensity(**input_param)(test_data)
+        assert_allclose(result, in_type(expected_value), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_threshold_intensityd.py

@@ -0,0 +1,58 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ThresholdIntensityd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            p,
+            {"keys": ["image", "label", "extra"], "threshold": 5, "above": True, "cval": 0},
+            (0, 0, 0, 0, 0, 0, 6, 7, 8, 9),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"keys": ["image", "label", "extra"], "threshold": 5, "above": False, "cval": 0},
+            (0, 1, 2, 3, 4, 0, 0, 0, 0, 0),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"keys": ["image", "label", "extra"], "threshold": 5, "above": True, "cval": 5},
+            (5, 5, 5, 5, 5, 5, 6, 7, 8, 9),
+        ]
+    )
+
+
+class TestThresholdIntensityd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, in_type, input_param, expected_value):
+        test_data = {"image": in_type(np.arange(10)), "label": in_type(np.arange(10)), "extra": in_type(np.arange(10))}
+        result = ThresholdIntensityd(**input_param)(test_data)
+        assert_allclose(result["image"], in_type(expected_value), type_test="tensor")
+        assert_allclose(result["label"], in_type(expected_value), type_test="tensor")
+        assert_allclose(result["extra"], in_type(expected_value), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_contiguous.py

@@ -0,0 +1,47 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+
+from monai.transforms import convert_to_contiguous
+from tests.test_utils import assert_allclose
+
+
+class TestToContiguous(unittest.TestCase):
+    def test_contiguous_dict(self):
+        tochange = np.moveaxis(np.zeros((2, 3, 4)), 0, -1)
+        test_dict = {"test_key": [[1]], 0: np.array(0), 1: np.array([0]), "nested": {"nested": [tochange]}}
+        output = convert_to_contiguous(test_dict)
+        self.assertEqual(output["test_key"], [[1]])
+        assert_allclose(output[0], np.array(0))
+        assert_allclose(output[1], np.array([0]))
+        self.assertTrue(output["nested"]["nested"][0].flags.c_contiguous)
+
+    def test_contiguous_seq(self):
+        tochange = torch.zeros(2, 3, 4).transpose(0, 1)
+        test_seq = [[[1]], np.array(0), np.array([0]), torch.tensor(1.0), [[tochange]], "test_string", (1, 2, 3)]
+        output = convert_to_contiguous(test_seq)
+        self.assertEqual(output[0], [[1]])
+        assert_allclose(output[1], np.array(0))
+        assert_allclose(output[2], np.array([0]))
+        assert_allclose(output[3], torch.tensor(1.0))
+        self.assertTrue(output[4][0][0].is_contiguous())
+        self.assertEqual(output[5], "test_string")
+        self.assertEqual(output[6], (1, 2, 3))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_cupy.py

@@ -0,0 +1,112 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from unittest import skipUnless
+
+import numpy as np
+import torch
+
+from monai.transforms import ToCupy
+from monai.utils import optional_import
+from tests.test_utils import HAS_CUPY, skip_if_no_cuda
+
+cp, _ = optional_import("cupy")
+
+
+@skipUnless(HAS_CUPY, "CuPy is required.")
+class TestToCupy(unittest.TestCase):
+    def test_cupy_input(self):
+        test_data = cp.array([[1, 2], [3, 4]], dtype=cp.float32)
+        test_data = cp.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupy()(test_data)
+        self.assertTrue(result.dtype == cp.float32)
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_cupy_input_dtype(self):
+        test_data = cp.array([[1, 2], [3, 4]], dtype=cp.float32)
+        test_data = cp.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupy(cp.uint8)(test_data)
+        self.assertTrue(result.dtype == cp.uint8)
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_numpy_input(self):
+        test_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        test_data = np.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupy()(test_data)
+        self.assertTrue(result.dtype == cp.float32)
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_numpy_input_dtype(self):
+        test_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        test_data = np.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupy(np.uint8)(test_data)
+        self.assertEqual(result.dtype, cp.uint8)
+        self.assertIsInstance(result, cp.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_tensor_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToCupy()(test_data)
+        self.assertEqual(result.dtype, cp.float32)
+        self.assertIsInstance(result, cp.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    @skip_if_no_cuda
+    def test_tensor_cuda_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32).cuda()
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToCupy()(test_data)
+        self.assertEqual(result.dtype, cp.float32)
+        self.assertIsInstance(result, cp.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    @skip_if_no_cuda
+    def test_tensor_cuda_input_dtype(self):
+        test_data = torch.tensor([[1, 2], [3, 4]], dtype=torch.uint8).cuda()
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+
+        result = ToCupy(dtype="float32")(test_data)
+        self.assertEqual(result.dtype, cp.float32)
+        self.assertIsInstance(result, cp.ndarray)
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_list_tuple(self):
+        test_data = [[1, 2], [3, 4]]
+        result = ToCupy(wrap_sequence=True)(test_data)
+        cp.testing.assert_allclose(result, cp.asarray(test_data))
+        test_data = ((1, 2), (3, 4))
+        result = ToCupy(wrap_sequence=True)(test_data)
+        cp.testing.assert_allclose(result, cp.asarray(test_data))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_to_cupyd.py

@@ -0,0 +1,76 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from unittest import skipUnless
+
+import numpy as np
+import torch
+
+from monai.transforms import ToCupyd
+from monai.utils import optional_import
+from tests.test_utils import HAS_CUPY, skip_if_no_cuda
+
+cp, _ = optional_import("cupy")
+
+
+@skipUnless(HAS_CUPY, "CuPy is required.")
+class TestToCupyd(unittest.TestCase):
+    def test_cupy_input(self):
+        test_data = cp.array([[1, 2], [3, 4]])
+        test_data = cp.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_numpy_input(self):
+        test_data = np.array([[1, 2], [3, 4]])
+        test_data = np.rot90(test_data)
+        self.assertFalse(test_data.flags["C_CONTIGUOUS"])
+        result = ToCupyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data)
+
+    def test_tensor_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]])
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToCupyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data.numpy())
+
+    @skip_if_no_cuda
+    def test_tensor_cuda_input(self):
+        test_data = torch.tensor([[1, 2], [3, 4]]).cuda()
+        test_data = test_data.rot90()
+        self.assertFalse(test_data.is_contiguous())
+        result = ToCupyd(keys="img")({"img": test_data})["img"]
+        self.assertTrue(isinstance(result, cp.ndarray))
+        self.assertTrue(result.flags["C_CONTIGUOUS"])
+        cp.testing.assert_allclose(result, test_data.cpu().numpy())
+
+    def test_list_tuple(self):
+        test_data = [[1, 2], [3, 4]]
+        result = ToCupyd(keys="img", wrap_sequence=True)({"img": test_data})["img"]
+        cp.testing.assert_allclose(result, cp.asarray(test_data))
+        test_data = ((1, 2), (3, 4))
+        result = ToCupyd(keys="img", wrap_sequence=True)({"img": test_data})["img"]
+        cp.testing.assert_allclose(result, cp.asarray(test_data))
+
+
+if __name__ == "__main__":
+    unittest.main()