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

tests/transforms/spatial/test_convert_box_points.py

@@ -0,0 +1,119 @@
+# 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 torch
+from parameterized import parameterized
+
+from monai.data.box_utils import convert_box_to_standard_mode
+from monai.transforms.spatial.array import ConvertBoxToPoints, ConvertPointsToBoxes
+from tests.test_utils import assert_allclose
+
+TEST_CASE_POINTS_2D = [
+    [
+        torch.tensor([[10, 20, 30, 40], [50, 60, 70, 80]]),
+        "xyxy",
+        torch.tensor([[[10, 20], [30, 20], [30, 40], [10, 40]], [[50, 60], [70, 60], [70, 80], [50, 80]]]),
+    ],
+    [torch.tensor([[10, 20, 20, 20]]), "ccwh", torch.tensor([[[0, 10], [20, 10], [20, 30], [0, 30]]])],
+]
+TEST_CASE_POINTS_3D = [
+    [
+        torch.tensor([[10, 20, 30, 40, 50, 60], [70, 80, 90, 100, 110, 120]]),
+        "xyzxyz",
+        torch.tensor(
+            [
+                [
+                    [10, 20, 30],
+                    [40, 20, 30],
+                    [40, 50, 30],
+                    [10, 50, 30],
+                    [10, 20, 60],
+                    [40, 20, 60],
+                    [40, 50, 60],
+                    [10, 50, 60],
+                ],
+                [
+                    [70, 80, 90],
+                    [100, 80, 90],
+                    [100, 110, 90],
+                    [70, 110, 90],
+                    [70, 80, 120],
+                    [100, 80, 120],
+                    [100, 110, 120],
+                    [70, 110, 120],
+                ],
+            ]
+        ),
+    ],
+    [
+        torch.tensor([[10, 20, 30, 10, 10, 10]]),
+        "cccwhd",
+        torch.tensor(
+            [
+                [
+                    [5, 15, 25],
+                    [15, 15, 25],
+                    [15, 25, 25],
+                    [5, 25, 25],
+                    [5, 15, 35],
+                    [15, 15, 35],
+                    [15, 25, 35],
+                    [5, 25, 35],
+                ]
+            ]
+        ),
+    ],
+    [
+        torch.tensor([[10, 20, 30, 40, 50, 60]]),
+        "xxyyzz",
+        torch.tensor(
+            [
+                [
+                    [10, 30, 50],
+                    [20, 30, 50],
+                    [20, 40, 50],
+                    [10, 40, 50],
+                    [10, 30, 60],
+                    [20, 30, 60],
+                    [20, 40, 60],
+                    [10, 40, 60],
+                ]
+            ]
+        ),
+    ],
+]
+
+TEST_CASES = TEST_CASE_POINTS_2D + TEST_CASE_POINTS_3D
+
+
+class TestConvertBoxToPoints(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_convert_box_to_points(self, boxes, mode, expected_points):
+        transform = ConvertBoxToPoints(mode=mode)
+        converted_points = transform(boxes)
+        assert_allclose(converted_points, expected_points, type_test=False)
+
+
+class TestConvertPointsToBoxes(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_convert_box_to_points(self, boxes, mode, points):
+        transform = ConvertPointsToBoxes()
+        converted_boxes = transform(points)
+        expected_boxes = convert_box_to_standard_mode(boxes, mode)
+        assert_allclose(converted_boxes, expected_boxes, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/spatial/test_grid_patch.py

@@ -0,0 +1,134 @@
+# 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 parameterized import parameterized
+
+from monai.data import MetaTensor, set_track_meta
+from monai.transforms.spatial.array import GridPatch
+from tests.test_utils import TEST_NDARRAYS, SkipIfBeforePyTorchVersion, assert_allclose
+
+A = np.arange(16).repeat(3).reshape(4, 4, 3).transpose(2, 0, 1)
+A11 = A[:, :2, :2]
+A12 = A[:, :2, 2:]
+A21 = A[:, 2:, :2]
+A22 = A[:, 2:, 2:]
+
+TEST_CASE_0 = [{"patch_size": (2, 2)}, A, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"patch_size": (2, 2), "num_patches": 3}, A, [A11, A12, A21]]
+TEST_CASE_2 = [{"patch_size": (2, 2), "num_patches": 5}, A, [A11, A12, A21, A22, np.zeros((3, 2, 2))]]
+TEST_CASE_3 = [{"patch_size": (2, 2), "offset": (0, 0)}, A, [A11, A12, A21, A22]]
+TEST_CASE_4 = [{"patch_size": (2, 2), "offset": (0, 0)}, A, [A11, A12, A21, A22]]
+TEST_CASE_5 = [{"patch_size": (2, 2), "offset": (2, 2)}, A, [A22]]
+TEST_CASE_6 = [{"patch_size": (2, 2), "offset": (0, 2)}, A, [A12, A22]]
+TEST_CASE_7 = [{"patch_size": (2, 2), "offset": (2, 0)}, A, [A21, A22]]
+TEST_CASE_8 = [{"patch_size": (2, 2), "num_patches": 3, "sort_fn": "max"}, A, [A22, A21, A12]]
+TEST_CASE_9 = [{"patch_size": (2, 2), "num_patches": 4, "sort_fn": "min"}, A, [A11, A12, A21, A22]]
+TEST_CASE_10 = [{"patch_size": (2, 2), "overlap": 0.5, "num_patches": 3}, A, [A11, A[:, :2, 1:3], A12]]
+TEST_CASE_11 = [
+    {"patch_size": (3, 3), "num_patches": 2, "constant_values": 255, "pad_mode": "constant"},
+    A,
+    [A[:, :3, :3], np.pad(A[:, :3, 3:], ((0, 0), (0, 0), (0, 2)), mode="constant", constant_values=255)],
+]
+TEST_CASE_12 = [
+    {"patch_size": (3, 3), "offset": (-2, -2), "num_patches": 2, "pad_mode": "constant"},
+    A,
+    [np.zeros((3, 3, 3)), np.pad(A[:, :1, 1:4], ((0, 0), (2, 0), (0, 0)), mode="constant")],
+]
+# Only threshold filtering
+TEST_CASE_13 = [{"patch_size": (2, 2), "threshold": 50.0}, A, [A11]]
+TEST_CASE_14 = [{"patch_size": (2, 2), "threshold": 150.0}, A, [A11, A12, A21]]
+# threshold filtering with num_patches more than available patches (no effect)
+TEST_CASE_15 = [{"patch_size": (2, 2), "num_patches": 3, "threshold": 50.0}, A, [A11]]
+# threshold filtering with num_patches less than available patches (count filtering)
+TEST_CASE_16 = [{"patch_size": (2, 2), "num_patches": 2, "threshold": 150.0}, A, [A11, A12]]
+
+TEST_CASE_META_0 = [
+    {"patch_size": (2, 2)},
+    A,
+    [A11, A12, A21, A22],
+    [{"location": [0, 0]}, {"location": [0, 2]}, {"location": [2, 0]}, {"location": [2, 2]}],
+]
+
+TEST_CASE_META_1 = [
+    {"patch_size": (2, 2)},
+    MetaTensor(x=A, meta={"path": "path/to/file"}),
+    [A11, A12, A21, A22],
+    [
+        {"location": [0, 0], "path": "path/to/file"},
+        {"location": [0, 2], "path": "path/to/file"},
+        {"location": [2, 0], "path": "path/to/file"},
+        {"location": [2, 2], "path": "path/to/file"},
+    ],
+]
+
+TEST_CASES = []
+for p in TEST_NDARRAYS:
+    TEST_CASES.append([p, *TEST_CASE_0])
+    TEST_CASES.append([p, *TEST_CASE_1])
+    TEST_CASES.append([p, *TEST_CASE_2])
+    TEST_CASES.append([p, *TEST_CASE_3])
+    TEST_CASES.append([p, *TEST_CASE_4])
+    TEST_CASES.append([p, *TEST_CASE_5])
+    TEST_CASES.append([p, *TEST_CASE_6])
+    TEST_CASES.append([p, *TEST_CASE_7])
+    TEST_CASES.append([p, *TEST_CASE_8])
+    TEST_CASES.append([p, *TEST_CASE_9])
+    TEST_CASES.append([p, *TEST_CASE_10])
+    TEST_CASES.append([p, *TEST_CASE_11])
+    TEST_CASES.append([p, *TEST_CASE_12])
+    TEST_CASES.append([p, *TEST_CASE_13])
+    TEST_CASES.append([p, *TEST_CASE_14])
+    TEST_CASES.append([p, *TEST_CASE_15])
+    TEST_CASES.append([p, *TEST_CASE_16])
+
+
+class TestGridPatch(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    @SkipIfBeforePyTorchVersion((1, 11, 1))
+    def test_grid_patch(self, in_type, input_parameters, image, expected):
+        input_image = in_type(image)
+        splitter = GridPatch(**input_parameters)
+        output = splitter(input_image)
+        self.assertEqual(len(output), len(expected))
+        for output_patch, expected_patch in zip(output, expected):
+            assert_allclose(
+                output_patch,
+                in_type(expected_patch),
+                type_test=False,
+                device_test=bool(isinstance(in_type(expected_patch), torch.Tensor)),
+            )
+
+    @parameterized.expand([TEST_CASE_META_0, TEST_CASE_META_1])
+    @SkipIfBeforePyTorchVersion((1, 9, 1))
+    def test_grid_patch_meta(self, input_parameters, image, expected, expected_meta):
+        set_track_meta(True)
+        splitter = GridPatch(**input_parameters)
+        output = splitter(image)
+        self.assertEqual(len(output), len(expected))
+        if "path" in expected_meta[0]:
+            self.assertTrue(output.meta["path"] == expected_meta[0]["path"])
+        for output_patch, expected_patch, expected_patch_meta in zip(output, expected, expected_meta):
+            assert_allclose(output_patch, expected_patch, type_test=False)
+            self.assertIsInstance(output_patch, MetaTensor)
+            self.assertEqual(output_patch.meta["location"], expected_patch_meta["location"])
+            self.assertTrue(output_patch.meta["spatial_shape"], list(output_patch.shape[1:]))
+            if "path" in expected_meta[0]:
+                self.assertEqual(output_patch.meta["path"], expected_patch_meta["path"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/spatial/test_grid_patchd.py

@@ -0,0 +1,102 @@
+# 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 parameterized import parameterized
+
+from monai.transforms.spatial.dictionary import GridPatchd
+from tests.test_utils import TEST_NDARRAYS, SkipIfBeforePyTorchVersion, assert_allclose
+
+A = np.arange(16).repeat(3).reshape(4, 4, 3).transpose(2, 0, 1)
+A11 = A[:, :2, :2]
+A12 = A[:, :2, 2:]
+A21 = A[:, 2:, :2]
+A22 = A[:, 2:, 2:]
+
+TEST_CASE_0 = [{"patch_size": (2, 2)}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"patch_size": (2, 2), "num_patches": 3}, {"image": A}, [A11, A12, A21]]
+TEST_CASE_2 = [{"patch_size": (2, 2), "num_patches": 5}, {"image": A}, [A11, A12, A21, A22, np.zeros((3, 2, 2))]]
+TEST_CASE_3 = [{"patch_size": (2, 2), "offset": (0, 0)}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_4 = [{"patch_size": (2, 2), "offset": (0, 0)}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_5 = [{"patch_size": (2, 2), "offset": (2, 2)}, {"image": A}, [A22]]
+TEST_CASE_6 = [{"patch_size": (2, 2), "offset": (0, 2)}, {"image": A}, [A12, A22]]
+TEST_CASE_7 = [{"patch_size": (2, 2), "offset": (2, 0)}, {"image": A}, [A21, A22]]
+TEST_CASE_8 = [{"patch_size": (2, 2), "num_patches": 3, "sort_fn": "max"}, {"image": A}, [A22, A21, A12]]
+TEST_CASE_9 = [{"patch_size": (2, 2), "num_patches": 4, "sort_fn": "min"}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_10 = [{"patch_size": (2, 2), "overlap": 0.5, "num_patches": 3}, {"image": A}, [A11, A[:, :2, 1:3], A12]]
+TEST_CASE_11 = [
+    {"patch_size": (3, 3), "num_patches": 2, "constant_values": 255, "pad_mode": "constant"},
+    {"image": A},
+    [A[:, :3, :3], np.pad(A[:, :3, 3:], ((0, 0), (0, 0), (0, 2)), mode="constant", constant_values=255)],
+]
+TEST_CASE_12 = [
+    {"patch_size": (3, 3), "offset": (-2, -2), "num_patches": 2, "pad_mode": "constant"},
+    {"image": A},
+    [np.zeros((3, 3, 3)), np.pad(A[:, :1, 1:4], ((0, 0), (2, 0), (0, 0)), mode="constant")],
+]
+# Only threshold filtering
+TEST_CASE_13 = [{"patch_size": (2, 2), "threshold": 50.0}, {"image": A}, [A11]]
+TEST_CASE_14 = [{"patch_size": (2, 2), "threshold": 150.0}, {"image": A}, [A11, A12, A21]]
+# threshold filtering with num_patches more than available patches (no effect)
+TEST_CASE_15 = [{"patch_size": (2, 2), "threshold": 50.0, "num_patches": 3}, {"image": A}, [A11]]
+# threshold filtering with num_patches less than available patches (count filtering)
+TEST_CASE_16 = [{"patch_size": (2, 2), "threshold": 150.0, "num_patches": 2}, {"image": A}, [A11, A12]]
+
+TEST_SINGLE = []
+for p in TEST_NDARRAYS:
+    TEST_SINGLE.append([p, *TEST_CASE_0])
+    TEST_SINGLE.append([p, *TEST_CASE_1])
+    TEST_SINGLE.append([p, *TEST_CASE_2])
+    TEST_SINGLE.append([p, *TEST_CASE_3])
+    TEST_SINGLE.append([p, *TEST_CASE_4])
+    TEST_SINGLE.append([p, *TEST_CASE_5])
+    TEST_SINGLE.append([p, *TEST_CASE_6])
+    TEST_SINGLE.append([p, *TEST_CASE_7])
+    TEST_SINGLE.append([p, *TEST_CASE_8])
+    TEST_SINGLE.append([p, *TEST_CASE_9])
+    TEST_SINGLE.append([p, *TEST_CASE_10])
+    TEST_SINGLE.append([p, *TEST_CASE_11])
+    TEST_SINGLE.append([p, *TEST_CASE_12])
+    TEST_SINGLE.append([p, *TEST_CASE_13])
+    TEST_SINGLE.append([p, *TEST_CASE_14])
+    TEST_SINGLE.append([p, *TEST_CASE_15])
+    TEST_SINGLE.append([p, *TEST_CASE_16])
+
+
+class TestGridPatchd(unittest.TestCase):
+    @parameterized.expand(TEST_SINGLE)
+    @SkipIfBeforePyTorchVersion((1, 11, 1))
+    def test_grid_patchd(self, in_type, input_parameters, image_dict, expected):
+        image_key = "image"
+        input_dict = {}
+        for k, v in image_dict.items():
+            input_dict[k] = v
+            if k == image_key:
+                input_dict[k] = in_type(v)
+        splitter = GridPatchd(keys=image_key, **input_parameters)
+        output = splitter(input_dict)
+        self.assertEqual(len(output[image_key]), len(expected))
+        for output_patch, expected_patch in zip(output[image_key], expected):
+            assert_allclose(
+                output_patch,
+                in_type(expected_patch),
+                type_test=False,
+                device_test=bool(isinstance(in_type(expected_patch), torch.Tensor)),
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/spatial/test_rand_grid_patch.py

@@ -0,0 +1,150 @@
+# 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 parameterized import parameterized
+
+from monai.data import MetaTensor, set_track_meta
+from monai.transforms.spatial.array import RandGridPatch
+from monai.utils import set_determinism
+from tests.test_utils import TEST_NDARRAYS, SkipIfBeforePyTorchVersion, assert_allclose
+
+A = np.arange(16).repeat(3).reshape(4, 4, 3).transpose(2, 0, 1)
+A11 = A[:, :2, :2]
+A12 = A[:, :2, 2:]
+A21 = A[:, 2:, :2]
+A22 = A[:, 2:, 2:]
+
+TEST_CASE_0 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0}, A, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"patch_size": (2, 2), "min_offset": 0, "num_patches": 3}, A, [A11, A12, A21]]
+TEST_CASE_2 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 0, "num_patches": 5},
+    A,
+    [A11, A12, A21, A22, np.zeros((3, 2, 2))],
+]
+TEST_CASE_3 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0}, A, [A11, A12, A21, A22]]
+TEST_CASE_4 = [{"patch_size": (2, 2)}, A, [A11, A12, A21, A22]]
+TEST_CASE_5 = [{"patch_size": (2, 2), "min_offset": 2, "max_offset": 2}, A, [A22]]
+TEST_CASE_6 = [{"patch_size": (2, 2), "min_offset": (0, 2), "max_offset": (0, 2)}, A, [A12, A22]]
+TEST_CASE_7 = [{"patch_size": (2, 2), "min_offset": 1, "max_offset": 2}, A, [A22]]
+TEST_CASE_8 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 1, "num_patches": 1, "sort_fn": "max"},
+    A,
+    [A[:, 1:3, 1:3]],
+]
+TEST_CASE_9 = [
+    {
+        "patch_size": (3, 3),
+        "min_offset": -3,
+        "max_offset": -1,
+        "sort_fn": "min",
+        "num_patches": 1,
+        "pad_mode": "constant",
+        "constant_values": 255,
+    },
+    A,
+    [np.pad(A[:, :2, 1:], ((0, 0), (1, 0), (0, 0)), mode="constant", constant_values=255)],
+]
+TEST_CASE_10 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0, "threshold": 50.0}, A, [A11]]
+TEST_CASE_11 = [{"patch_size": (2, 2), "sort_fn": "random", "num_patches": 2}, A, [A11, A12]]
+TEST_CASE_12 = [{"patch_size": (2, 2), "sort_fn": "random", "num_patches": 4}, A, [A11, A12, A21, A22]]
+TEST_CASE_13 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 1, "num_patches": 1, "sort_fn": "random"},
+    A,
+    [A[:, 1:3, 1:3]],
+]
+
+TEST_CASE_META_0 = [
+    {"patch_size": (2, 2)},
+    A,
+    [A11, A12, A21, A22],
+    [{"location": [0, 0]}, {"location": [0, 2]}, {"location": [2, 0]}, {"location": [2, 2]}],
+]
+
+TEST_CASE_META_1 = [
+    {"patch_size": (2, 2)},
+    MetaTensor(x=A, meta={"path": "path/to/file"}),
+    [A11, A12, A21, A22],
+    [
+        {"location": [0, 0], "path": "path/to/file"},
+        {"location": [0, 2], "path": "path/to/file"},
+        {"location": [2, 0], "path": "path/to/file"},
+        {"location": [2, 2], "path": "path/to/file"},
+    ],
+]
+
+TEST_SINGLE = []
+for p in TEST_NDARRAYS:
+    TEST_SINGLE.append([p, *TEST_CASE_0])
+    TEST_SINGLE.append([p, *TEST_CASE_1])
+    TEST_SINGLE.append([p, *TEST_CASE_2])
+    TEST_SINGLE.append([p, *TEST_CASE_3])
+    TEST_SINGLE.append([p, *TEST_CASE_4])
+    TEST_SINGLE.append([p, *TEST_CASE_5])
+    TEST_SINGLE.append([p, *TEST_CASE_6])
+    TEST_SINGLE.append([p, *TEST_CASE_7])
+    TEST_SINGLE.append([p, *TEST_CASE_8])
+    TEST_SINGLE.append([p, *TEST_CASE_9])
+    TEST_SINGLE.append([p, *TEST_CASE_10])
+    TEST_SINGLE.append([p, *TEST_CASE_11])
+    TEST_SINGLE.append([p, *TEST_CASE_12])
+    TEST_SINGLE.append([p, *TEST_CASE_13])
+
+
+class TestRandGridPatch(unittest.TestCase):
+    def setUp(self):
+        set_determinism(seed=1234)
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @parameterized.expand(TEST_SINGLE)
+    @SkipIfBeforePyTorchVersion((1, 11, 1))
+    def test_rand_grid_patch(self, in_type, input_parameters, image, expected):
+        input_image = in_type(image)
+        splitter = RandGridPatch(**input_parameters)
+        splitter.set_random_state(1234)
+        output = splitter(input_image)
+        self.assertEqual(len(output), len(expected))
+        for output_patch, expected_patch in zip(output, expected):
+            assert_allclose(
+                output_patch,
+                in_type(expected_patch),
+                type_test=False,
+                device_test=bool(isinstance(in_type(expected_patch), torch.Tensor)),
+            )
+
+    @parameterized.expand([TEST_CASE_META_0, TEST_CASE_META_1])
+    @SkipIfBeforePyTorchVersion((1, 9, 1))
+    def test_rand_grid_patch_meta(self, input_parameters, image, expected, expected_meta):
+        set_track_meta(True)
+        splitter = RandGridPatch(**input_parameters)
+        splitter.set_random_state(1234)
+        output = splitter(image)
+        self.assertEqual(len(output), len(expected))
+        if "path" in expected_meta[0]:
+            self.assertTrue(output.meta["path"] == expected_meta[0]["path"])
+        for output_patch, expected_patch, expected_patch_meta in zip(output, expected, expected_meta):
+            assert_allclose(output_patch, expected_patch, type_test=False)
+            self.assertTrue(isinstance(output_patch, MetaTensor))
+            self.assertTrue(output_patch.meta["location"] == expected_patch_meta["location"])
+            self.assertTrue(output_patch.meta["spatial_shape"], list(output_patch.shape[1:]))
+            if "path" in expected_meta[0]:
+                self.assertTrue(output_patch.meta["path"] == expected_patch_meta["path"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/spatial/test_rand_grid_patchd.py

@@ -0,0 +1,117 @@
+# 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 parameterized import parameterized
+
+from monai.transforms.spatial.dictionary import RandGridPatchd
+from monai.utils import set_determinism
+from tests.test_utils import TEST_NDARRAYS, SkipIfBeforePyTorchVersion, assert_allclose
+
+A = np.arange(16).repeat(3).reshape(4, 4, 3).transpose(2, 0, 1)
+A11 = A[:, :2, :2]
+A12 = A[:, :2, 2:]
+A21 = A[:, 2:, :2]
+A22 = A[:, 2:, 2:]
+
+TEST_CASE_0 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"patch_size": (2, 2), "min_offset": 0, "num_patches": 3}, {"image": A}, [A11, A12, A21]]
+TEST_CASE_2 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 0, "num_patches": 5},
+    {"image": A},
+    [A11, A12, A21, A22, np.zeros((3, 2, 2))],
+]
+TEST_CASE_3 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_4 = [{"patch_size": (2, 2)}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_5 = [{"patch_size": (2, 2), "min_offset": 2, "max_offset": 2}, {"image": A}, [A22]]
+TEST_CASE_6 = [{"patch_size": (2, 2), "min_offset": (0, 2), "max_offset": (0, 2)}, {"image": A}, [A12, A22]]
+TEST_CASE_7 = [{"patch_size": (2, 2), "min_offset": 1, "max_offset": 2}, {"image": A}, [A22]]
+TEST_CASE_8 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 1, "num_patches": 1, "sort_fn": "max"},
+    {"image": A},
+    [A[:, 1:3, 1:3]],
+]
+TEST_CASE_9 = [
+    {
+        "patch_size": (3, 3),
+        "min_offset": -3,
+        "max_offset": -1,
+        "sort_fn": "min",
+        "num_patches": 1,
+        "pad_mode": "constant",
+        "constant_values": 255,
+    },
+    {"image": A},
+    [np.pad(A[:, :2, 1:], ((0, 0), (1, 0), (0, 0)), mode="constant", constant_values=255)],
+]
+TEST_CASE_10 = [{"patch_size": (2, 2), "min_offset": 0, "max_offset": 0, "threshold": 50.0}, {"image": A}, [A11]]
+TEST_CASE_11 = [{"patch_size": (2, 2), "sort_fn": "random", "num_patches": 2}, {"image": A}, [A11, A12]]
+TEST_CASE_12 = [{"patch_size": (2, 2), "sort_fn": "random", "num_patches": 4}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_13 = [
+    {"patch_size": (2, 2), "min_offset": 0, "max_offset": 1, "num_patches": 1, "sort_fn": "random"},
+    {"image": A},
+    [A[:, 1:3, 1:3]],
+]
+
+TEST_SINGLE = []
+for p in TEST_NDARRAYS:
+    TEST_SINGLE.append([p, *TEST_CASE_0])
+    TEST_SINGLE.append([p, *TEST_CASE_1])
+    TEST_SINGLE.append([p, *TEST_CASE_2])
+    TEST_SINGLE.append([p, *TEST_CASE_3])
+    TEST_SINGLE.append([p, *TEST_CASE_4])
+    TEST_SINGLE.append([p, *TEST_CASE_5])
+    TEST_SINGLE.append([p, *TEST_CASE_6])
+    TEST_SINGLE.append([p, *TEST_CASE_7])
+    TEST_SINGLE.append([p, *TEST_CASE_8])
+    TEST_SINGLE.append([p, *TEST_CASE_9])
+    TEST_SINGLE.append([p, *TEST_CASE_10])
+    TEST_SINGLE.append([p, *TEST_CASE_11])
+    TEST_SINGLE.append([p, *TEST_CASE_12])
+    TEST_SINGLE.append([p, *TEST_CASE_13])
+
+
+class TestRandGridPatchd(unittest.TestCase):
+    def setUp(self):
+        set_determinism(seed=1234)
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @parameterized.expand(TEST_SINGLE)
+    @SkipIfBeforePyTorchVersion((1, 11, 1))
+    def test_rand_grid_patchd(self, in_type, input_parameters, image_dict, expected):
+        image_key = "image"
+        input_dict = {}
+        for k, v in image_dict.items():
+            input_dict[k] = v
+            if k == image_key:
+                input_dict[k] = in_type(v)
+        splitter = RandGridPatchd(keys=image_key, **input_parameters)
+        splitter.set_random_state(1234)
+        output = splitter(input_dict)
+        self.assertEqual(len(output[image_key]), len(expected))
+        for output_patch, expected_patch in zip(output[image_key], expected):
+            assert_allclose(
+                output_patch,
+                in_type(expected_patch),
+                type_test=False,
+                device_test=bool(isinstance(in_type(expected_patch), torch.Tensor)),
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()