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

tests/transforms/test_rand_crop_by_pos_neg_label.py

@@ -0,0 +1,152 @@
+# 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 copy import deepcopy
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import RandCropByPosNegLabel
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = [
+    [
+        {
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "spatial_size": [2, 2, -1],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "image_threshold": 0,
+        },
+        {"img": np.random.randint(0, 2, size=[3, 3, 3, 3])},
+        (3, 2, 2, 3),
+    ],
+    [
+        {
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "spatial_size": [2, 2, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "image_threshold": 0,
+        },
+        {"img": np.random.randint(0, 2, size=[3, 3, 3, 3])},
+        (3, 2, 2, 2),
+    ],
+    [
+        {
+            "label": None,
+            "spatial_size": [2, 2, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "image_threshold": 0,
+        },
+        {
+            "img": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+        },
+        (3, 2, 2, 2),
+    ],
+    [
+        {
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "spatial_size": [4, 4, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "allow_smaller": True,
+        },
+        {"img": np.random.randint(0, 2, size=[3, 3, 3, 3])},
+        (3, 3, 3, 2),
+    ],
+    [
+        {
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "spatial_size": [4, 4, 4],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "allow_smaller": True,
+        },
+        {"img": np.random.randint(0, 2, size=[3, 3, 3, 3])},
+        (3, 3, 3, 3),
+    ],
+]
+
+
+class TestRandCropByPosNegLabel(unittest.TestCase):
+    @staticmethod
+    def convert_data_type(im_type, d, keys=("img", "image", "label")):
+        out = deepcopy(d)
+        for k, v in out.items():
+            if k in keys and isinstance(v, np.ndarray):
+                out[k] = im_type(v)
+        return out
+
+    @parameterized.expand(TESTS)
+    def test_type_shape(self, input_param, input_data, expected_shape):
+        results = []
+        for p in TEST_NDARRAYS_ALL:
+            input_param_mod = self.convert_data_type(p, input_param)
+            input_data_mod = self.convert_data_type(p, input_data)
+            cropper = RandCropByPosNegLabel(**input_param_mod)
+            cropper.set_random_state(0)
+            result = cropper(**input_data_mod)
+            self.assertListEqual(cropper.spatial_size, input_param["spatial_size"])
+
+            self.assertIsInstance(result, list)
+            self.assertTupleEqual(result[0].shape, expected_shape)
+
+            # check for same results across numpy, torch.Tensor and torch.cuda.Tensor
+            result = np.asarray([i if isinstance(i, np.ndarray) else i.cpu().numpy() for i in result])
+            results.append(np.asarray(result))
+            if len(results) > 1:
+                np.testing.assert_allclose(results[0], results[-1])
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_data, _expected_shape):
+        for p in TEST_NDARRAYS_ALL:
+            input_param_mod = self.convert_data_type(p, input_param)
+            input_data_mod = self.convert_data_type(p, input_data)
+            cropper = RandCropByPosNegLabel(**input_param_mod)
+            # non-lazy
+            cropper.set_random_state(0)
+            expected = cropper(**input_data_mod)
+            self.assertIsInstance(expected[0], MetaTensor)
+            # lazy
+            cropper.set_random_state(0)
+            cropper.lazy = True
+            pending_result = cropper(**input_data_mod)
+            for i, _pending_result in enumerate(pending_result):
+                self.assertIsInstance(_pending_result, MetaTensor)
+                assert_allclose(_pending_result.peek_pending_affine(), expected[i].affine)
+                assert_allclose(_pending_result.peek_pending_shape(), expected[i].shape[1:])
+                # only support nearest
+                result = apply_pending(_pending_result, overrides={"mode": "nearest", "align_corners": False})[0]
+                # compare
+                assert_allclose(result, expected[i], rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_crop_by_pos_neg_labeld.py

@@ -0,0 +1,172 @@
+# 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 copy import deepcopy
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import RandCropByPosNegLabeld
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = [
+    [
+        {
+            "keys": ["image", "extra", "label"],
+            "label_key": "label",
+            "spatial_size": [-1, 2, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image_key": None,
+            "image_threshold": 0,
+        },
+        {
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "extra": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+        },
+        (3, 3, 2, 2),
+    ],
+    [
+        {
+            "keys": ["image", "extra", "label"],
+            "label_key": "label",
+            "spatial_size": [2, 2, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image_key": None,
+            "image_threshold": 0,
+        },
+        {
+            "image": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "extra": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+            "label": np.random.randint(0, 2, size=[3, 3, 3, 3]),
+        },
+        (3, 2, 2, 2),
+    ],
+    [
+        {
+            "keys": ["image", "extra", "label"],
+            "label_key": "label",
+            "spatial_size": [2, 2, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image_key": None,
+            "image_threshold": 0,
+        },
+        {"image": np.zeros([3, 3, 3, 3]) - 1, "extra": np.zeros([3, 3, 3, 3]), "label": np.ones([3, 3, 3, 3])},
+        (3, 2, 2, 2),
+    ],
+    [
+        {
+            "keys": ["image", "extra", "label"],
+            "label_key": "label",
+            "spatial_size": [4, 4, 2],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image_key": None,
+            "image_threshold": 0,
+            "allow_smaller": True,
+        },
+        {"image": np.zeros([3, 3, 3, 3]) - 1, "extra": np.zeros([3, 3, 3, 3]), "label": np.ones([3, 3, 3, 3])},
+        (3, 3, 3, 2),
+    ],
+    [
+        {
+            "keys": ["image", "extra", "label"],
+            "label_key": "label",
+            "spatial_size": [4, 4, 4],
+            "pos": 1,
+            "neg": 1,
+            "num_samples": 2,
+            "image_key": None,
+            "image_threshold": 0,
+            "allow_smaller": True,
+        },
+        {"image": np.zeros([3, 3, 3, 3]) - 1, "extra": np.zeros([3, 3, 3, 3]), "label": np.ones([3, 3, 3, 3])},
+        (3, 3, 3, 3),
+    ],
+]
+
+
+class TestRandCropByPosNegLabeld(unittest.TestCase):
+    @staticmethod
+    def convert_data_type(im_type, d, keys=("img", "image", "label")):
+        out = deepcopy(d)
+        for k, v in out.items():
+            if k in keys and isinstance(v, np.ndarray):
+                out[k] = im_type(v)
+        return out
+
+    @parameterized.expand(TESTS)
+    def test_type_shape(self, input_param, input_data, expected_shape):
+        for p in TEST_NDARRAYS_ALL:
+            input_param_mod = self.convert_data_type(p, input_param)
+            input_data_mod = self.convert_data_type(p, input_data)
+            cropper = RandCropByPosNegLabeld(**input_param_mod)
+            cropper.set_random_state(0)
+            result = cropper(input_data_mod)
+            self.assertListEqual(cropper.cropper.spatial_size, input_param["spatial_size"])
+
+            self.assertIsInstance(result, list)
+
+            _len = len(tuple(input_data.keys()))
+            self.assertTupleEqual(tuple(result[0].keys())[:_len], tuple(input_data.keys()))
+            for k in ("image", "extra", "label"):
+                self.assertTupleEqual(result[0][k].shape, expected_shape)
+                for i, item in enumerate(result):
+                    self.assertEqual(item[k].meta["patch_index"], i)
+
+    def test_correct_center(self):
+        cropper = RandCropByPosNegLabeld(keys="label", label_key="label", spatial_size=[3, 3])
+        cropper.set_random_state(0)
+        test_image = {"label": np.asarray([[[1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 1]]])}
+        result = cropper(test_image)
+        np.testing.assert_allclose(result[0]["label"], np.asarray([[[0, 0, 1], [0, 0, 0], [0, 0, 0]]]))
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_data, _expected_shape):
+        for p in TEST_NDARRAYS_ALL:
+            input_param_mod = self.convert_data_type(p, input_param)
+            input_data_mod = self.convert_data_type(p, input_data)
+            cropper = RandCropByPosNegLabeld(**input_param_mod)
+            # non-lazy
+            cropper.set_random_state(0)
+            expected = cropper(input_data_mod)
+            self.assertIsInstance(expected[0]["image"], MetaTensor)
+            # lazy
+            cropper.set_random_state(0)
+            cropper.lazy = True
+            pending_result = cropper(input_data_mod)
+            for i, _pending_result in enumerate(pending_result):
+                self.assertIsInstance(_pending_result["image"], MetaTensor)
+                assert_allclose(_pending_result["image"].peek_pending_affine(), expected[i]["image"].affine)
+                assert_allclose(_pending_result["image"].peek_pending_shape(), expected[i]["image"].shape[1:])
+                # only support nearest
+                overrides = {"mode": "nearest", "align_corners": False}
+                result_image = apply_pending(_pending_result["image"], overrides=overrides)[0]
+                result_extra = apply_pending(_pending_result["extra"], overrides=overrides)[0]
+                # compare
+                assert_allclose(result_image, expected[i]["image"], rtol=1e-5)
+                assert_allclose(result_extra, expected[i]["extra"], rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_cucim_dict_transform.py

@@ -0,0 +1,162 @@
+# 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 RandCuCIMd
+from monai.utils import optional_import, set_determinism
+from tests.test_utils import HAS_CUPY, skip_if_no_cuda
+
+_, has_cut = optional_import("cucim.core.operations.expose.transform")
+cp, _ = optional_import("cupy")
+
+set_determinism(seed=0)
+
+TEST_CASE_COLOR_JITTER_1 = [
+    {"name": "color_jitter", "brightness": 0.0, "contrast": 0.0, "saturation": 0.0, "hue": 0.0},
+    np.array([[[0, 1], [2, 3]], [[0, 10], [20, 30]], [[0, 50], [100, 150]]], dtype=np.uint8),
+    np.array([[[0, 1], [2, 3]], [[0, 10], [20, 30]], [[0, 50], [100, 150]]], dtype=np.uint8),
+]
+
+TEST_CASE_FLIP_1 = [
+    {"name": "image_flip", "spatial_axis": -1},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[1.0, 0.0], [3.0, 2.0]], [[1.0, 0.0], [3.0, 2.0]], [[1.0, 0.0], [3.0, 2.0]]], dtype=np.float32),
+]
+
+TEST_CASE_RAND_ROTATE_1 = [
+    {"name": "rand_image_rotate_90", "prob": 1.0, "max_k": 1, "spatial_axis": (-2, -1)},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[1.0, 3.0], [0.0, 2.0]], [[1.0, 3.0], [0.0, 2.0]], [[1.0, 3.0], [0.0, 2.0]]], dtype=np.float32),
+]
+
+TEST_CASE_RAND_ROTATE_2 = [
+    {"name": "rand_image_rotate_90", "prob": 0.0, "max_k": 1, "spatial_axis": (-2, -1)},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+]
+
+TEST_CASE_SCALE_INTENSITY_1 = [
+    {"name": "scale_intensity_range", "a_min": 0.0, "a_max": 4.0, "b_min": 0.0, "b_max": 1.0, "clip": False},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[0.0, 0.25], [0.5, 0.75]], [[0.0, 0.25], [0.5, 0.75]], [[0.0, 0.25], [0.5, 0.75]]], dtype=np.float32),
+]
+
+TEST_CASE_ZOOM_1 = [
+    {"name": "zoom", "zoom_factor": (0.5, 0.5)},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.concatenate([np.ones((1, 3, 3), dtype=np.float32) * 1.0, np.ones((1, 3, 3), dtype=np.float32) * 2.0]),
+]
+
+TEST_CASE_RAND_ZOOM_1 = [
+    {"name": "rand_zoom", "prob": 1.0, "min_zoom": 0.5, "max_zoom": 0.5},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.concatenate([np.ones((1, 3, 3), dtype=np.float32) * 1.0, np.ones((1, 3, 3), dtype=np.float32) * 2.0]),
+]
+
+TEST_CASE_RAND_ZOOM_2 = [
+    {"name": "rand_zoom", "prob": 0.0, "min_zoom": 0.5, "max_zoom": 0.5},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+]
+
+
+@skip_if_no_cuda
+@unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+@unittest.skipUnless(has_cut, "cuCIM transforms are required.")
+class TestRandCuCIMDict(unittest.TestCase):
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_numpy_single(self, params, input, expected):
+        input = {"image": np.copy(input)}
+        output = RandCuCIMd(keys="image", **params)(input)["image"]
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, np.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_numpy_batch(self, params, input, expected):
+        input = {"image": np.copy(input[cp.newaxis, ...])}
+        expected = expected[cp.newaxis, ...]
+        output = RandCuCIMd(keys="image", **params)(input)["image"]
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, np.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_cupy_single(self, params, input, expected):
+        input = {"image": cp.asarray(input)}
+        expected = cp.asarray(expected)
+        output = RandCuCIMd(keys="image", **params)(input)["image"]
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, cp.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_cupy_batch(self, params, input, expected):
+        input = {"image": cp.asarray(input)[cp.newaxis, ...]}
+        expected = cp.asarray(expected)[cp.newaxis, ...]
+        output = RandCuCIMd(keys="image", **params)(input)["image"]
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, cp.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_cucim_transform.py

@@ -0,0 +1,162 @@
+# 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 RandCuCIM
+from monai.utils import optional_import, set_determinism
+from tests.test_utils import HAS_CUPY, skip_if_no_cuda
+
+_, has_cut = optional_import("cucim.core.operations.expose.transform")
+cp, _ = optional_import("cupy")
+
+set_determinism(seed=0)
+
+TEST_CASE_COLOR_JITTER_1 = [
+    {"name": "color_jitter", "brightness": 0.0, "contrast": 0.0, "saturation": 0.0, "hue": 0.0},
+    np.array([[[0, 1], [2, 3]], [[0, 10], [20, 30]], [[0, 50], [100, 150]]], dtype=np.uint8),
+    np.array([[[0, 1], [2, 3]], [[0, 10], [20, 30]], [[0, 50], [100, 150]]], dtype=np.uint8),
+]
+
+TEST_CASE_FLIP_1 = [
+    {"name": "image_flip", "spatial_axis": -1},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[1.0, 0.0], [3.0, 2.0]], [[1.0, 0.0], [3.0, 2.0]], [[1.0, 0.0], [3.0, 2.0]]], dtype=np.float32),
+]
+
+TEST_CASE_RAND_ROTATE_1 = [
+    {"name": "rand_image_rotate_90", "prob": 1.0, "max_k": 1, "spatial_axis": (-2, -1)},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[1.0, 3.0], [0.0, 2.0]], [[1.0, 3.0], [0.0, 2.0]], [[1.0, 3.0], [0.0, 2.0]]], dtype=np.float32),
+]
+
+TEST_CASE_RAND_ROTATE_2 = [
+    {"name": "rand_image_rotate_90", "prob": 0.0, "max_k": 1, "spatial_axis": (-2, -1)},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+]
+
+TEST_CASE_SCALE_INTENSITY_1 = [
+    {"name": "scale_intensity_range", "a_min": 0.0, "a_max": 4.0, "b_min": 0.0, "b_max": 1.0, "clip": False},
+    np.array([[[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]], [[0.0, 1.0], [2.0, 3.0]]], dtype=np.float32),
+    np.array([[[0.0, 0.25], [0.5, 0.75]], [[0.0, 0.25], [0.5, 0.75]], [[0.0, 0.25], [0.5, 0.75]]], dtype=np.float32),
+]
+
+TEST_CASE_ZOOM_1 = [
+    {"name": "zoom", "zoom_factor": (0.5, 0.5)},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.concatenate([np.ones((1, 3, 3), dtype=np.float32) * 1.0, np.ones((1, 3, 3), dtype=np.float32) * 2.0]),
+]
+
+TEST_CASE_RAND_ZOOM_1 = [
+    {"name": "rand_zoom", "prob": 1.0, "min_zoom": 0.5, "max_zoom": 0.5},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.concatenate([np.ones((1, 3, 3), dtype=np.float32) * 1.0, np.ones((1, 3, 3), dtype=np.float32) * 2.0]),
+]
+
+TEST_CASE_RAND_ZOOM_2 = [
+    {"name": "rand_zoom", "prob": 0.0, "min_zoom": 0.5, "max_zoom": 0.5},
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+    np.mgrid[:3, 1:4].astype(dtype=np.float32),
+]
+
+
+@skip_if_no_cuda
+@unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+@unittest.skipUnless(has_cut, "cuCIM transforms are required.")
+class TestRandCuCIM(unittest.TestCase):
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_numpy_single(self, params, input, expected):
+        input = np.copy(input)
+        output = RandCuCIM(**params)(input)
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, np.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_numpy_batch(self, params, input, expected):
+        input = np.copy(input[cp.newaxis, ...])
+        expected = expected[cp.newaxis, ...]
+        output = RandCuCIM(**params)(input)
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, np.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_cupy_single(self, params, input, expected):
+        input = cp.asarray(input)
+        expected = cp.asarray(expected)
+        output = RandCuCIM(**params)(input)
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, cp.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_COLOR_JITTER_1,
+            TEST_CASE_FLIP_1,
+            TEST_CASE_RAND_ROTATE_1,
+            TEST_CASE_RAND_ROTATE_2,
+            TEST_CASE_SCALE_INTENSITY_1,
+            TEST_CASE_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_1,
+            TEST_CASE_RAND_ZOOM_2,
+        ]
+    )
+    def test_tramsforms_cupy_batch(self, params, input, expected):
+        input = cp.asarray(input)[cp.newaxis, ...]
+        expected = cp.asarray(expected)[cp.newaxis, ...]
+        output = RandCuCIM(**params)(input)
+        self.assertTrue(output.dtype == expected.dtype)
+        self.assertTrue(isinstance(output, cp.ndarray))
+        cp.testing.assert_allclose(output, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()