monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

tests/transforms/test_rand_shift_intensity.py

@@ -0,0 +1,52 @@
+# 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 RandShiftIntensity
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandShiftIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_value(self, p):
+        shifter = RandShiftIntensity(offsets=1.0, prob=1.0)
+        shifter.set_random_state(seed=0)
+        im = p(self.imt)
+        result = shifter(im, factor=1.0)
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        expected = self.imt + np.random.uniform(low=-1.0, high=1.0)
+        assert_allclose(result, expected, type_test="tensor")
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        scaler = RandShiftIntensity(offsets=3.0, channel_wise=True, prob=1.0)
+        scaler.set_random_state(seed=0)
+        im = p(self.imt)
+        result = scaler(im)
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        channel_num = self.imt.shape[0]
+        factor = [np.random.uniform(low=-3.0, high=3.0) for _ in range(channel_num)]
+        expected = p(np.stack([np.asarray((self.imt[i]) + factor[i]) for i in range(channel_num)]).astype(np.float32))
+        assert_allclose(result, expected, atol=0, rtol=1e-5, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_shift_intensityd.py

@@ -0,0 +1,67 @@
+# 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 IntensityStatsd, RandShiftIntensityd
+from monai.utils.enums import PostFix
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandShiftIntensityd(NumpyImageTestCase2D):
+    def test_value(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            shifter = RandShiftIntensityd(keys=[key], offsets=1.0, prob=1.0)
+            shifter.set_random_state(seed=0)
+            result = shifter({key: p(self.imt)})
+            np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
+            expected = self.imt + np.random.uniform(low=-1.0, high=1.0)
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+    def test_factor(self):
+        key = "img"
+        stats = IntensityStatsd(keys=key, ops="max", key_prefix="orig")
+        shifter = RandShiftIntensityd(keys=[key], offsets=1.0, factor_key=["orig_max"], prob=1.0)
+        data = {key: self.imt, PostFix.meta(key): {"affine": None}}
+        shifter.set_random_state(seed=0)
+        result = shifter(stats(data))
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        expected = self.imt + np.random.uniform(low=-1.0, high=1.0) * np.nanmax(self.imt)
+        np.testing.assert_allclose(result[key], expected)
+
+    def test_channel_wise(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = RandShiftIntensityd(keys=[key], offsets=3.0, prob=1.0, channel_wise=True)
+            scaler.set_random_state(seed=0)
+            result = scaler({key: p(self.imt)})
+            np.random.seed(0)
+            # simulate the randomize function of transform
+            np.random.random()
+            channel_num = self.imt.shape[0]
+            factor = [np.random.uniform(low=-3.0, high=3.0) for _ in range(channel_num)]
+            expected = p(
+                np.stack([np.asarray((self.imt[i]) + factor[i]) for i in range(channel_num)]).astype(np.float32)
+            )
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_simulate_low_resolution.py

@@ -0,0 +1,83 @@
+# 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 RandSimulateLowResolution
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            dict(prob=1.0, zoom_range=(0.8, 0.81)),
+            p(
+                np.array(
+                    [
+                        [
+                            [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]],
+                            [[16, 17, 18, 19], [20, 21, 22, 23], [24, 25, 26, 27], [28, 29, 30, 31]],
+                            [[32, 33, 34, 35], [36, 37, 38, 39], [40, 41, 42, 43], [44, 45, 46, 47]],
+                            [[48, 49, 50, 51], [52, 53, 54, 55], [56, 57, 58, 59], [60, 61, 62, 63]],
+                        ]
+                    ]
+                )
+            ),
+            np.array(
+                [
+                    [
+                        [
+                            [0.0000, 0.6250, 1.3750, 2.0000],
+                            [2.5000, 3.1250, 3.8750, 4.5000],
+                            [5.5000, 6.1250, 6.8750, 7.5000],
+                            [8.0000, 8.6250, 9.3750, 10.0000],
+                        ],
+                        [
+                            [10.0000, 10.6250, 11.3750, 12.0000],
+                            [12.5000, 13.1250, 13.8750, 14.5000],
+                            [15.5000, 16.1250, 16.8750, 17.5000],
+                            [18.0000, 18.6250, 19.3750, 20.0000],
+                        ],
+                        [
+                            [22.0000, 22.6250, 23.3750, 24.0000],
+                            [24.5000, 25.1250, 25.8750, 26.5000],
+                            [27.5000, 28.1250, 28.8750, 29.5000],
+                            [30.0000, 30.6250, 31.3750, 32.0000],
+                        ],
+                        [
+                            [32.0000, 32.6250, 33.3750, 34.0000],
+                            [34.5000, 35.1250, 35.8750, 36.5000],
+                            [37.5000, 38.1250, 38.8750, 39.5000],
+                            [40.0000, 40.6250, 41.3750, 42.0000],
+                        ],
+                    ]
+                ]
+            ),
+        ]
+    )
+
+
+class TestRandGaussianSmooth(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        randsimlowres = RandSimulateLowResolution(**arguments)
+        randsimlowres.set_random_state(seed=0)
+        result = randsimlowres(image)
+        assert_allclose(result, expected_data, rtol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_simulate_low_resolutiond.py

@@ -0,0 +1,73 @@
+# 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 RandSimulateLowResolutiond
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            dict(keys=["img", "seg"], prob=1.0, zoom_range=(0.8, 0.81)),
+            {"img": p(np.arange(64).reshape(1, 4, 4, 4)), "seg": p(np.arange(64).reshape(1, 4, 4, 4))},
+            np.array(
+                [
+                    [
+                        [
+                            [0.0000, 0.6250, 1.3750, 2.0000],
+                            [2.5000, 3.1250, 3.8750, 4.5000],
+                            [5.5000, 6.1250, 6.8750, 7.5000],
+                            [8.0000, 8.6250, 9.3750, 10.0000],
+                        ],
+                        [
+                            [10.0000, 10.6250, 11.3750, 12.0000],
+                            [12.5000, 13.1250, 13.8750, 14.5000],
+                            [15.5000, 16.1250, 16.8750, 17.5000],
+                            [18.0000, 18.6250, 19.3750, 20.0000],
+                        ],
+                        [
+                            [22.0000, 22.6250, 23.3750, 24.0000],
+                            [24.5000, 25.1250, 25.8750, 26.5000],
+                            [27.5000, 28.1250, 28.8750, 29.5000],
+                            [30.0000, 30.6250, 31.3750, 32.0000],
+                        ],
+                        [
+                            [32.0000, 32.6250, 33.3750, 34.0000],
+                            [34.5000, 35.1250, 35.8750, 36.5000],
+                            [37.5000, 38.1250, 38.8750, 39.5000],
+                            [40.0000, 40.6250, 41.3750, 42.0000],
+                        ],
+                    ]
+                ]
+            ),
+        ]
+    )
+
+
+class TestRandGaussianSmoothd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        converter = RandSimulateLowResolutiond(**arguments)
+        converter.set_random_state(seed=0)
+        result = converter(image)
+        assert_allclose(result["img"], expected_data, rtol=1e-4, type_test=False)
+        assert_allclose(result["seg"], expected_data, rtol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_spatial_crop.py

@@ -0,0 +1,107 @@
+# 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.meta_tensor import MetaTensor
+from monai.transforms import RandScaleCrop, RandSpatialCrop
+from monai.transforms.lazy.functional import apply_pending
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_SHAPES = [
+    [{"roi_size": [3, 3, -1], "random_center": True}, (3, 3, 3, 4), (3, 3, 3, 4)],
+    [{"roi_size": [3, 3, 3], "random_center": True}, (3, 3, 3, 3), (3, 3, 3, 3)],
+    [{"roi_size": [3, 3, 3], "random_center": False}, (3, 3, 3, 3), (3, 3, 3, 3)],
+    [{"roi_size": [3, 3, 2], "random_center": False, "random_size": False}, (3, 3, 3, 3), (3, 3, 3, 2)],
+]
+
+TEST_VALUES = [
+    [
+        {"roi_size": [3, 3], "random_center": False},
+        np.array([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+    ]
+]
+
+TEST_RANDOM_SHAPES = [
+    [
+        {"roi_size": [3, 3, 3], "max_roi_size": [5, -1, 4], "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 4, 4, 3),
+    ],
+    [{"roi_size": 3, "max_roi_size": 4, "random_center": True, "random_size": True}, (1, 4, 5, 6), (1, 3, 4, 3)],
+]
+
+func1 = {RandSpatialCrop: {"roi_size": [8, 7, -1], "random_center": True, "random_size": False}}
+func2 = {RandScaleCrop: {"roi_scale": [0.5, 0.6, -1.0], "random_center": True, "random_size": True}}
+func3 = {RandScaleCrop: {"roi_scale": [1.0, 0.5, -1.0], "random_center": False, "random_size": False}}
+
+TESTS_COMBINE = []
+TESTS_COMBINE.append([[func1, func2, func3], (3, 10, 10, 8)])
+TESTS_COMBINE.append([[func1, func2], (3, 8, 8, 4)])
+TESTS_COMBINE.append([[func2, func2], (3, 8, 8, 4)])
+
+
+class TestRandSpatialCrop(CropTest):
+    Cropper = RandSpatialCrop
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        self.crop_test(input_param, input_shape, expected_shape)
+
+    @parameterized.expand(TEST_VALUES)
+    def test_value(self, input_param, input_data):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = RandSpatialCrop(**input_param)
+                result = cropper(im_type(input_data))
+                roi = [(2 - i // 2, 2 + i - i // 2) for i in cropper._size]
+                assert_allclose(result, input_data[:, roi[0][0] : roi[0][1], roi[1][0] : roi[1][1]], type_test="tensor")
+
+    @parameterized.expand(TEST_RANDOM_SHAPES)
+    def test_random_shape(self, input_param, input_shape, expected_shape):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = RandSpatialCrop(**input_param)
+                cropper.set_random_state(seed=123)
+                input_data = im_type(np.random.randint(0, 2, input_shape))
+                expected = cropper(input_data)
+                self.assertTupleEqual(expected.shape, expected_shape)
+
+                # lazy
+                # reset random seed to ensure the same results
+                cropper.set_random_state(seed=123)
+                cropper.lazy = True
+                pending_result = cropper(input_data)
+                self.assertIsInstance(pending_result, MetaTensor)
+                assert_allclose(pending_result.peek_pending_affine(), expected.affine)
+                assert_allclose(pending_result.peek_pending_shape(), expected.shape[1:])
+                # only support nearest
+                result = apply_pending(pending_result, overrides={"mode": "nearest", "align_corners": False})[0]
+                # compare
+                assert_allclose(result, expected, rtol=1e-5)
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+    @parameterized.expand(TESTS_COMBINE)
+    def test_combine_ops(self, funcs, input_shape):
+        self.crop_test_combine_ops(funcs, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_spatial_crop_samples.py

@@ -0,0 +1,128 @@
+# 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.meta_tensor import MetaTensor
+from monai.transforms import RandSpatialCropSamples
+from monai.transforms.lazy.functional import apply_pending
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_CASE_1 = [
+    {"roi_size": [3, 3, 3], "num_samples": 4, "random_center": True, "random_size": False},
+    (3, 4, 4, 4),
+    [(3, 3, 3, 3), (3, 3, 3, 3), (3, 3, 3, 3), (3, 3, 3, 3)],
+    np.array(
+        [
+            [
+                [[21, 22, 23], [25, 26, 27], [29, 30, 31]],
+                [[37, 38, 39], [41, 42, 43], [45, 46, 47]],
+                [[53, 54, 55], [57, 58, 59], [61, 62, 63]],
+            ],
+            [
+                [[85, 86, 87], [89, 90, 91], [93, 94, 95]],
+                [[101, 102, 103], [105, 106, 107], [109, 110, 111]],
+                [[117, 118, 119], [121, 122, 123], [125, 126, 127]],
+            ],
+            [
+                [[149, 150, 151], [153, 154, 155], [157, 158, 159]],
+                [[165, 166, 167], [169, 170, 171], [173, 174, 175]],
+                [[181, 182, 183], [185, 186, 187], [189, 190, 191]],
+            ],
+        ]
+    ),
+]
+
+TEST_CASE_2 = [
+    {"roi_size": [3, 3, 3], "num_samples": 8, "random_center": False, "random_size": True},
+    (3, 4, 4, 4),
+    [(3, 4, 4, 3), (3, 4, 3, 3), (3, 3, 4, 4), (3, 4, 4, 4), (3, 3, 3, 4), (3, 3, 3, 3), (3, 3, 3, 3), (3, 3, 3, 3)],
+    np.array(
+        [
+            [
+                [[21, 22, 23], [25, 26, 27], [29, 30, 31]],
+                [[37, 38, 39], [41, 42, 43], [45, 46, 47]],
+                [[53, 54, 55], [57, 58, 59], [61, 62, 63]],
+            ],
+            [
+                [[85, 86, 87], [89, 90, 91], [93, 94, 95]],
+                [[101, 102, 103], [105, 106, 107], [109, 110, 111]],
+                [[117, 118, 119], [121, 122, 123], [125, 126, 127]],
+            ],
+            [
+                [[149, 150, 151], [153, 154, 155], [157, 158, 159]],
+                [[165, 166, 167], [169, 170, 171], [173, 174, 175]],
+                [[181, 182, 183], [185, 186, 187], [189, 190, 191]],
+            ],
+        ]
+    ),
+]
+
+TEST_INVERSE_LIST = [
+    [(1, 2, 2), {"roi_size": (1, 1), "num_samples": 4, "random_size": False}],
+    [(1, 3, 2), {"roi_size": (1, 1), "num_samples": 100, "random_size": False}],
+    [(3, 10, 11, 12), {"roi_size": (3, 5, 4), "num_samples": 7, "random_size": False}],
+    [(3, 10, 11, 12), {"roi_size": (10, 11, 12), "num_samples": 3, "random_size": False}],
+    [(3, 10, 11, 12), {"roi_size": (3, 4, 5), "num_samples": 100, "random_size": False}],
+]
+
+
+class TestRandSpatialCropSamples(CropTest):
+    Cropper = RandSpatialCropSamples
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_shape(self, input_param, input_shape, expected_shape, expected_last_item):
+        input_data = np.arange(192).reshape(*input_shape)
+
+        for p in TEST_NDARRAYS_ALL:
+            xform = RandSpatialCropSamples(**input_param)
+            xform.set_random_state(1234)
+            result = xform(p(input_data))
+
+            np.testing.assert_equal(len(result), input_param["num_samples"])
+            for i, (item, expected) in enumerate(zip(result, expected_shape)):
+                self.assertTupleEqual(item.shape, expected)
+                self.assertEqual(item.meta["patch_index"], i)
+            assert_allclose(result[-1], expected_last_item, type_test="tensor")
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_pending_ops(self, input_param, input_shape, _expected_shape, _expected_last_item):
+        input_data = np.arange(192).reshape(*input_shape)
+
+        for p in TEST_NDARRAYS_ALL:
+            xform = RandSpatialCropSamples(**input_param)
+            image = p(input_data)
+            # non-lazy
+            xform.set_random_state(1234)
+            expected = xform(image)
+            self.assertIsInstance(expected[0], MetaTensor)
+            # lazy
+            xform.set_random_state(1234)
+            xform.lazy = True
+            pending_result = xform(image)
+            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_spatial_crop_samplesd.py

@@ -0,0 +1,147 @@
+# 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.meta_tensor import MetaTensor
+from monai.transforms import Compose, DivisiblePadd, RandSpatialCropSamplesd
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_CASE_1 = [
+    {"keys": ["img", "seg"], "num_samples": 4, "roi_size": [2, 2, 2], "random_center": True, "random_size": True},
+    {"img": np.arange(81).reshape(3, 3, 3, 3), "seg": np.arange(81, 0, -1).reshape(3, 3, 3, 3)},
+    [(3, 2, 2, 2), (3, 2, 3, 3), (3, 2, 3, 2), (3, 2, 3, 2)],
+    {
+        "img": np.array(
+            [
+                [[[1, 2], [4, 5], [7, 8]], [[10, 11], [13, 14], [16, 17]]],
+                [[[28, 29], [31, 32], [34, 35]], [[37, 38], [40, 41], [43, 44]]],
+                [[[55, 56], [58, 59], [61, 62]], [[64, 65], [67, 68], [70, 71]]],
+            ]
+        ),
+        "seg": np.array(
+            [
+                [[[80, 79], [77, 76], [74, 73]], [[71, 70], [68, 67], [65, 64]]],
+                [[[53, 52], [50, 49], [47, 46]], [[44, 43], [41, 40], [38, 37]]],
+                [[[26, 25], [23, 22], [20, 19]], [[17, 16], [14, 13], [11, 10]]],
+            ]
+        ),
+    },
+]
+
+TEST_CASE_2 = []
+for p in TEST_NDARRAYS_ALL:
+    TEST_CASE_2.append(
+        [
+            {
+                "keys": ["img", "seg"],
+                "num_samples": 8,
+                "roi_size": [2, 2, 3],
+                "random_center": False,
+                "random_size": True,
+            },
+            {"img": p(np.arange(81).reshape(3, 3, 3, 3)), "seg": p(np.arange(81, 0, -1).reshape(3, 3, 3, 3))},
+            [
+                (3, 2, 2, 3),
+                (3, 2, 2, 3),
+                (3, 3, 3, 3),
+                (3, 2, 3, 3),
+                (3, 3, 3, 3),
+                (3, 2, 3, 3),
+                (3, 2, 3, 3),
+                (3, 3, 2, 3),
+            ],
+            {
+                "img": p(
+                    np.array(
+                        [
+                            [[[0, 1, 2], [3, 4, 5]], [[9, 10, 11], [12, 13, 14]], [[18, 19, 20], [21, 22, 23]]],
+                            [[[27, 28, 29], [30, 31, 32]], [[36, 37, 38], [39, 40, 41]], [[45, 46, 47], [48, 49, 50]]],
+                            [[[54, 55, 56], [57, 58, 59]], [[63, 64, 65], [66, 67, 68]], [[72, 73, 74], [75, 76, 77]]],
+                        ]
+                    )
+                ),
+                "seg": p(
+                    np.array(
+                        [
+                            [[[81, 80, 79], [78, 77, 76]], [[72, 71, 70], [69, 68, 67]], [[63, 62, 61], [60, 59, 58]]],
+                            [[[54, 53, 52], [51, 50, 49]], [[45, 44, 43], [42, 41, 40]], [[36, 35, 34], [33, 32, 31]]],
+                            [[[27, 26, 25], [24, 23, 22]], [[18, 17, 16], [15, 14, 13]], [[9, 8, 7], [6, 5, 4]]],
+                        ]
+                    )
+                ),
+            },
+        ]
+    )
+
+
+class TestRandSpatialCropSamplesd(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, *TEST_CASE_2])
+    def test_shape(self, input_param, input_data, expected_shape, expected_last):
+        xform = RandSpatialCropSamplesd(**input_param)
+        xform.set_random_state(1234)
+        result = xform(input_data)
+        _len = len(tuple(input_data.keys()))
+        self.assertTupleEqual(tuple(result[0].keys())[:_len], tuple(input_data.keys()))
+        for item, expected in zip(result, expected_shape):
+            self.assertTupleEqual(item["img"].shape, expected)
+            self.assertTupleEqual(item["seg"].shape, expected)
+        for i, item in enumerate(result):
+            self.assertEqual(item["img"].meta["patch_index"], i)
+            self.assertEqual(item["seg"].meta["patch_index"], i)
+        assert_allclose(item["img"], expected_last["img"], type_test=False)
+        assert_allclose(item["seg"], expected_last["seg"], type_test=False)
+
+    def test_deep_copy(self):
+        data = {"img": np.ones((1, 10, 11, 12))}
+        num_samples = 3
+        sampler = RandSpatialCropSamplesd(
+            keys=["img"], roi_size=(3, 3, 3), num_samples=num_samples, random_center=True, random_size=False
+        )
+        transform = Compose([DivisiblePadd(keys="img", k=5), sampler])
+        samples = transform(data)
+        self.assertEqual(len(samples), num_samples)
+        for sample in samples:
+            self.assertEqual(len(sample["img"].applied_operations), len(transform))
+
+    @parameterized.expand([TEST_CASE_1, *TEST_CASE_2])
+    def test_pending_ops(self, input_param, input_data, _expected_shape, _expected_last):
+        xform = RandSpatialCropSamplesd(**input_param)
+        # non-lazy
+        xform.set_random_state(1234)
+        expected = xform(input_data)
+        self.assertIsInstance(expected[0]["img"], MetaTensor)
+
+        # lazy
+        xform.set_random_state(1234)
+        xform.lazy = True
+        pending_result = xform(input_data)
+        for i, _pending_result in enumerate(pending_result):
+            self.assertIsInstance(_pending_result["img"], MetaTensor)
+            assert_allclose(_pending_result["img"].peek_pending_affine(), expected[i]["img"].affine)
+            assert_allclose(_pending_result["img"].peek_pending_shape(), expected[i]["img"].shape[1:])
+            # only support nearest
+            overrides = {"mode": "nearest", "align_corners": False}
+            result_img = apply_pending(_pending_result["img"], overrides=overrides)[0]
+            result_seg = apply_pending(_pending_result["seg"], overrides=overrides)[0]
+            # compare
+            assert_allclose(result_img, expected[i]["img"], rtol=1e-5)
+            assert_allclose(result_seg, expected[i]["seg"], rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()