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

tests/transforms/test_spacingd.py

@@ -0,0 +1,178 @@
+# 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.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.data.utils import affine_to_spacing
+from monai.transforms import Spacingd
+from monai.utils import ensure_tuple_rep
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_DEVICES, assert_allclose, skip_if_quick
+
+TESTS: list[tuple] = []
+for device in TEST_DEVICES:
+    TESTS.append(
+        (
+            "spacing 3d",
+            {"image": MetaTensor(torch.ones((2, 10, 15, 20)), affine=torch.eye(4))},
+            dict(keys="image", pixdim=(1, 2, 1.4)),
+            (2, 10, 8, 15),
+            torch.as_tensor(np.diag([1, 2, 1.4, 1.0])),
+            *device,
+        )
+    )
+    TESTS.append(
+        (
+            "spacing 2d",
+            {"image": MetaTensor(torch.ones((2, 10, 20)), affine=torch.eye(3))},
+            dict(keys="image", pixdim=(1, 2)),
+            (2, 10, 10),
+            torch.as_tensor(np.diag((1, 2, 1))),
+            *device,
+        )
+    )
+    TESTS.append(
+        (
+            "spacing 2d no metadata",
+            {"image": MetaTensor(torch.ones((2, 10, 20)))},
+            dict(keys="image", pixdim=(1, 2)),
+            (2, 10, 10),
+            torch.as_tensor(np.diag((1, 2, 1, 1))),
+            *device,
+        )
+    )
+    TESTS.append(
+        (
+            "interp all",
+            {
+                "image": MetaTensor(np.arange(20).reshape((2, 1, 10)), affine=torch.eye(4)),
+                "seg": MetaTensor(torch.ones((2, 1, 10)), affine=torch.eye(4)),
+            },
+            dict(keys=("image", "seg"), mode="nearest", pixdim=(1, 0.2)),
+            (2, 1, 46),
+            torch.as_tensor(np.diag((1, 0.2, 1, 1))),
+            *device,
+        )
+    )
+    TESTS.append(
+        (
+            "interp sep",
+            {
+                "image": MetaTensor(torch.ones((2, 1, 10)), affine=torch.eye(4)),
+                "seg": MetaTensor(torch.ones((2, 1, 10)), affine=torch.eye(4)),
+            },
+            dict(keys=("image", "seg"), mode=("bilinear", "nearest"), pixdim=(1, 0.2)),
+            (2, 1, 46),
+            torch.as_tensor(np.diag((1, 0.2, 1, 1))),
+            *device,
+        )
+    )
+    TESTS.append(
+        (
+            "interp sep",
+            {
+                "image": MetaTensor(torch.ones((2, 1, 10)), affine=torch.eye(4)),
+                "seg1": MetaTensor(torch.ones((2, 1, 10)), affine=torch.diag(torch.tensor([2, 2, 2, 1]))),
+                "seg2": MetaTensor(torch.ones((2, 1, 10)), affine=torch.eye(4)),
+            },
+            dict(keys=("image", "seg1", "seg2"), mode=("bilinear", "nearest", "nearest"), pixdim=(1, 1, 1)),
+            (2, 1, 10),
+            torch.as_tensor(np.diag((1, 1, 1, 1))),
+            *device,
+        )
+    )
+
+TESTS_TORCH = []
+for track_meta in (False, True):
+    for device in TEST_DEVICES:
+        TESTS_TORCH.append([{"keys": "seg", "pixdim": [0.2, 0.3, 1]}, torch.ones(2, 1, 2, 3), track_meta, *device])
+
+
+class TestSpacingDCase(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_spacingd(self, _, data, kw_args, expected_shape, expected_affine, device):
+        data = {k: v.to(device) for k, v in data.items()}
+        tr = Spacingd(**kw_args)
+        call_param = {"data": data}
+        res = tr(**call_param)
+        # test lazy
+        if not isinstance(kw_args["keys"], str):  # multiple keys
+            kw_args["mode"] = ensure_tuple_rep(kw_args["mode"], len(kw_args["keys"]))
+            init_param = kw_args.copy()
+            for key, mode in zip(kw_args["keys"], kw_args["mode"]):
+                init_param["keys"], init_param["mode"] = key, mode
+                test_resampler_lazy(tr, res, init_param, call_param, output_key=key)
+        else:
+            test_resampler_lazy(tr, res, kw_args, call_param, output_key=kw_args["keys"])
+        in_img = data["image"]
+        out_img = res["image"]
+        self.assertEqual(in_img.device, out_img.device)
+        # no change in number of keys
+        self.assertEqual(tuple(sorted(data)), tuple(sorted(res)))
+        np.testing.assert_allclose(out_img.shape, expected_shape)
+        assert_allclose(out_img.affine, expected_affine)
+
+    @parameterized.expand(TESTS_TORCH)
+    def test_orntd_torch(self, init_param, img: torch.Tensor, track_meta: bool, device):
+        set_track_meta(track_meta)
+        tr = Spacingd(**init_param)
+        call_param = {"data": {"seg": img.to(device)}}
+        res_data = tr(**call_param)  # type: ignore
+        res = res_data["seg"]
+
+        if track_meta:
+            test_resampler_lazy(tr, res_data, init_param, call_param, output_key="seg")
+            self.assertIsInstance(res, MetaTensor)
+            assert isinstance(res, MetaTensor)  # for mypy type narrowing
+            new_spacing = affine_to_spacing(res.affine, 3)
+            assert_allclose(new_spacing, init_param["pixdim"], type_test=False)
+            self.assertNotEqual(img.shape, res.shape)
+        else:
+            self.assertIsInstance(res, torch.Tensor)
+            self.assertNotIsInstance(res, MetaTensor)
+            self.assertNotEqual(img.shape, res.shape)
+
+    @skip_if_quick
+    def test_space_same_shape(self):
+        affine_1 = np.array(
+            [
+                [1.499277e00, 2.699563e-02, 3.805804e-02, -1.948635e02],
+                [-2.685805e-02, 1.499757e00, -2.635604e-12, 4.438188e01],
+                [-3.805194e-02, -5.999028e-04, 1.499517e00, 4.036536e01],
+                [0.000000e00, 0.000000e00, 0.000000e00, 1.000000e00],
+            ]
+        )
+        affine_2 = np.array(
+            [
+                [1.499275e00, 2.692252e-02, 3.805728e-02, -1.948635e02],
+                [-2.693010e-02, 1.499758e00, -4.260525e-05, 4.438188e01],
+                [-3.805190e-02, -6.406730e-04, 1.499517e00, 4.036536e01],
+                [0.000000e00, 0.000000e00, 0.000000e00, 1.000000e00],
+            ]
+        )
+        img_1 = MetaTensor(np.zeros((1, 238, 145, 315)), affine=affine_1)
+        img_2 = MetaTensor(np.zeros((1, 238, 145, 315)), affine=affine_2)
+        out = Spacingd(("img_1", "img_2"), pixdim=1)({"img_1": img_1, "img_2": img_2})
+        self.assertEqual(out["img_1"].shape, out["img_2"].shape)  # ensure_same_shape True
+        out = Spacingd(("img_1", "img_2"), pixdim=1, ensure_same_shape=False)({"img_1": img_1, "img_2": img_2})
+        self.assertNotEqual(out["img_1"].shape, out["img_2"].shape)  # ensure_same_shape False
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_spatial_crop.py

@@ -0,0 +1,82 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import CenterScaleCrop, CenterSpatialCrop, SpatialCrop
+from tests.croppers import CropTest
+
+TESTS = [
+    [{"roi_center": [1, 1, 1], "roi_size": [2, 2, 2]}, (3, 3, 3, 3), (3, 2, 2, 2)],
+    [{"roi_center": [1, 1, 1], "roi_size": [2, 2, 2]}, (3, 1, 1, 1), (3, 1, 1, 1)],
+    [{"roi_start": [0, 0, 0], "roi_end": [2, 2, 2]}, (3, 3, 3, 3), (3, 2, 2, 2)],
+    [{"roi_start": [0, 0], "roi_end": [2, 2]}, (3, 3, 3, 3), (3, 2, 2, 3)],
+    [{"roi_start": [0, 0, 0, 0, 0], "roi_end": [2, 2, 2, 2, 2]}, (3, 3, 3, 3), (3, 2, 2, 2)],
+    [{"roi_start": [0, 0, 0, 0, 0], "roi_end": [8, 8, 8, 2, 2]}, (3, 3, 3, 3), (3, 3, 3, 3)],
+    [
+        {"roi_slices": [slice(s, e) for s, e in zip([None, None, None], [None, None, None])]},
+        (3, 11, 12, 15),
+        (3, 11, 12, 15),
+    ],
+    [{"roi_slices": [slice(s, e) for s, e in zip([1, None, 0], [None, None, None])]}, (3, 7, 9, 11), (3, 6, 9, 11)],
+    [{"roi_slices": [slice(s, e) for s, e in zip([0, None, None], [-1, None, None])]}, (3, 7, 9, 11), (3, 6, 9, 11)],
+    [{"roi_slices": [slice(s, e) for s, e in zip([1, None, None], [None, None, None])]}, (3, 10, 8, 6), (3, 9, 8, 6)],
+    [{"roi_slices": [slice(s, e) for s, e in zip([-1, -2, 0], [None, None, 2])]}, (3, 15, 17, 8), (3, 1, 2, 2)],
+    [{"roi_slices": [slice(s, e) for s, e in zip([None, None, None], [-2, -1, 2])]}, (3, 13, 8, 6), (3, 11, 7, 2)],
+    [{"roi_start": [-1, 0], "roi_end": [5, 5]}, (1, 5, 5), (1, 5, 5)],
+]
+
+TEST_ERRORS = [[{"roi_slices": [slice(s, e, 2) for s, e in zip([-1, -2, 0], [None, None, 2])]}]]
+
+TEST_LAZY_ERRORS = [[{"roi_start": [1, 0, 0], "roi_end": [1, 8, 8]}, (3, 3, 3, 3), (3, 0, 3, 3)]]
+
+func1 = {CenterSpatialCrop: {"roi_size": [8, 8, 6]}}
+func2 = {SpatialCrop: {"roi_center": [1, 1, 1], "roi_size": [3, 4, 3]}}
+func3 = {CenterScaleCrop: {"roi_scale": [0.6, 0.3, -1]}}
+
+TESTS_COMBINE = []
+TESTS_COMBINE.append([[func1, func2, func3], (3, 10, 10, 8)])
+TESTS_COMBINE.append([[func1, func2], (3, 8, 8, 4)])
+TESTS_COMBINE.append([[func1, func3], (3, 8, 8, 4)])
+
+
+class TestSpatialCrop(CropTest):
+    Cropper = SpatialCrop
+
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        self.crop_test(input_param, input_shape, expected_shape)
+
+    @parameterized.expand(TEST_ERRORS)
+    def test_error(self, input_param):
+        with self.assertRaises(ValueError):
+            SpatialCrop(**input_param)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+    @parameterized.expand(TEST_LAZY_ERRORS)
+    def test_lazy_error(self, input_param, input_shape, _):
+        with self.assertRaises(ValueError):
+            return 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_spatial_cropd.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
+
+from parameterized import parameterized
+
+from monai.transforms import SpatialCropd
+from tests.croppers import CropTest
+
+TESTS = [
+    [
+        {"keys": ["img"], "roi_center": [1, 1], "roi_size": [2, 2]},
+        (1, 3, 3),
+        (1, 2, 2),
+        (slice(None), slice(None, 2), slice(None, 2)),
+    ],
+    [
+        {"keys": ["img"], "roi_center": [1, 1, 1], "roi_size": [2, 2, 2]},
+        (3, 3, 3, 3),
+        (3, 2, 2, 2),
+        (slice(None), slice(None, 2), slice(None, 2), slice(None, 2)),
+    ],
+    [
+        {"keys": ["img"], "roi_start": [0, 0, 0], "roi_end": [2, 2, 2]},
+        (3, 3, 3, 3),
+        (3, 2, 2, 2),
+        (slice(None), slice(None, 2), slice(None, 2), slice(None, 2)),
+    ],
+    [
+        {"keys": ["img"], "roi_start": [0, 0], "roi_end": [2, 2]},
+        (3, 3, 3, 3),
+        (3, 2, 2, 3),
+        (slice(None), slice(None, 2), slice(None, 2), slice(None)),
+    ],
+    [
+        {"keys": ["img"], "roi_start": [0, 0, 0, 0, 0], "roi_end": [2, 2, 2, 2, 2]},
+        (3, 3, 3, 3),
+        (3, 2, 2, 2),
+        (slice(None), slice(None, 2), slice(None, 2), slice(None, 2)),
+    ],
+    [
+        {"keys": ["img"], "roi_slices": [slice(s, e) for s, e in zip([-1, -2, 0], [None, None, 2])]},
+        (3, 3, 3, 3),
+        (3, 1, 2, 2),
+        (slice(None), slice(-1, None), slice(-2, None), slice(0, 2)),
+    ],
+]
+
+
+class TestSpatialCropd(CropTest):
+    Cropper = SpatialCropd
+
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input_shape, expected_shape, same_area):
+        self.crop_test(input_param, input_shape, expected_shape, same_area)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _expected_shape, _same_area):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_spatial_pad.py

@@ -0,0 +1,57 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import BorderPad, DivisiblePad, SpatialPad
+from tests.padders import PadTest
+
+TESTS = []
+TESTS.append([{"spatial_size": [3, 4], "method": "end"}, (1, 2, 3), (1, 3, 4)])
+TESTS.append([{"spatial_size": [15, 4, -1], "method": "symmetric"}, (3, 8, 8, 4), (3, 15, 8, 4)])
+
+func1 = {SpatialPad: {"spatial_size": [15, 4, -1], "method": "symmetric"}}
+func2 = {BorderPad: {"spatial_border": 2}}
+func3 = {DivisiblePad: {"k": 5, "method": "end"}}
+
+TESTS_COMBINE = []
+TESTS_COMBINE.append([[func1, func2, func3], (3, 8, 8, 4), (3, 20, 15, 10)])
+TESTS_COMBINE.append([[func1, func2], (3, 8, 8, 4), (3, 19, 12, 8)])
+TESTS_COMBINE.append([[func2, func2], (3, 8, 8, 4), (3, 16, 16, 12)])
+
+
+class TestSpatialPad(PadTest):
+    Padder = SpatialPad
+
+    @parameterized.expand(TESTS)
+    def test_pad(self, input_param, input_shape, expected_shape):
+        self.pad_test(input_param, input_shape, expected_shape)
+
+    def test_pad_kwargs(self):
+        kwargs = {"spatial_size": [15, 8], "method": "end", "mode": "constant"}
+        unchanged_slices = [slice(None), slice(None, 8), slice(None, 4)]
+        self.pad_test_kwargs(unchanged_slices, **kwargs)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.pad_test_pending_ops(input_param, input_shape)
+
+    @parameterized.expand(TESTS_COMBINE)
+    def test_combine_ops(self, funcs, input_shape, expected_shape):
+        self.pad_test_combine_ops(funcs, input_shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_spatial_padd.py

@@ -0,0 +1,43 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import SpatialPadd
+from tests.padders import PadTest
+
+TESTS = [
+    [{"keys": ["img"], "spatial_size": [15, 8, 8], "method": "symmetric"}, (3, 8, 8, 5), (3, 15, 8, 8)],
+    [{"keys": ["img"], "spatial_size": [15, 8, 8], "method": "end"}, (3, 8, 8, 5), (3, 15, 8, 8)],
+    [{"keys": ["img"], "spatial_size": [15, 8, 8], "method": "end"}, (3, 8, 8, 5), (3, 15, 8, 8)],
+    [{"keys": ["img"], "spatial_size": [15, 8, -1], "method": "end"}, (3, 8, 5, 4), (3, 15, 8, 4)],
+]
+
+
+class TestSpatialPadd(PadTest):
+    Padder = SpatialPadd
+
+    @parameterized.expand(TESTS)
+    def test_pad(self, input_param, input_shape, expected_shape):
+        modes = ["constant", {"constant"}]
+        self.pad_test(input_param, input_shape, expected_shape, modes)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.pad_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_spatial_resample.py

@@ -0,0 +1,235 @@
+# 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
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.data.utils import to_affine_nd
+from monai.transforms import SpatialResample
+from monai.utils import optional_import
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_DEVICES, TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = []
+
+destinations_3d = [
+    torch.tensor([[1.0, 0.0, 0.0, 0.0], [0.0, -1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+    torch.tensor([[-1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+]
+expected_3d = [
+    torch.tensor([[[[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]], [[10.0, 11.0, 12.0], [7.0, 8.0, 9.0]]]]),
+    torch.tensor([[[[7.0, 8.0, 9.0], [10.0, 11.0, 12.0]], [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]),
+]
+
+for dst, expct in zip(destinations_3d, expected_3d):
+    for device in TEST_DEVICES:
+        for align in (False, True):
+            interp = ("nearest", "bilinear")
+            for interp_mode in interp:
+                for padding_mode in ("zeros", "border", "reflection"):
+                    TESTS.append(
+                        [
+                            torch.arange(12).reshape((1, 2, 2, 3)) + 1.0,  # data
+                            *device,
+                            {
+                                "dst_affine": dst,
+                                "dtype": torch.float64,
+                                "align_corners": align,
+                                "mode": interp_mode,
+                                "padding_mode": padding_mode,
+                            },
+                            expct,
+                        ]
+                    )
+if optional_import("cupy")[1] and optional_import("scipy.ndimage")[1]:
+    TESTS.append(deepcopy(TESTS[-1]))
+    TESTS[-1][2].update({"align_corners": True, "mode": 1, "padding_mode": "reflect"})  # type: ignore
+
+destinations_2d = [
+    torch.tensor([[1.0, 0.0, 0.0], [0.0, -1.0, 1.0], [0.0, 0.0, 1.0]]),  # flip the second
+    torch.tensor([[-1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]),  # flip the first
+]
+expected_2d = [torch.tensor([[[2.0, 1.0], [4.0, 3.0]]]), torch.tensor([[[3.0, 4.0], [1.0, 2.0]]])]
+
+for dst, expct in zip(destinations_2d, expected_2d):
+    for device in TEST_DEVICES:
+        for align in (False, True):
+            for interp_mode in ("nearest", "bilinear"):
+                TESTS.append(
+                    [
+                        torch.arange(4).reshape((1, 2, 2)) + 1.0,
+                        *device,
+                        {
+                            "dst_affine": dst,
+                            "dtype": torch.float32,
+                            "align_corners": align,
+                            "mode": interp_mode,
+                            "padding_mode": "zeros",
+                        },
+                        expct,
+                    ]
+                )
+
+TEST_4_5_D = []
+for device in TEST_DEVICES:
+    for dtype in (torch.float32, torch.float64):
+        # 4D
+        TEST_4_5_D.append(
+            [
+                (1, 2, 2, 3, 1),
+                (1, 1, 1, 1, 2),
+                *device,
+                dtype,
+                torch.tensor(
+                    [
+                        [[[0.5, 0.0], [0.0, 2.0], [1.5, 1.0]], [[3.5, 3.0], [3.0, 5.0], [4.5, 4.0]]],
+                        [[[6.5, 6.0], [6.0, 8.0], [7.5, 7.0]], [[9.5, 9.0], [9.0, 11.0], [10.5, 10.0]]],
+                    ]
+                ),
+            ]
+        )
+        # 5D
+        TEST_4_5_D.append(
+            [
+                (1, 2, 2, 3, 1, 1),
+                (1, 1, 1, 1, 2, 2),
+                *device,
+                dtype,
+                torch.tensor(
+                    [
+                        [
+                            [[[0.0, 0.0], [0.0, 1.0]], [[0.5, 0.0], [1.5, 1.0]], [[1.0, 2.0], [2.0, 2.0]]],
+                            [[[3.0, 3.0], [3.0, 4.0]], [[3.5, 3.0], [4.5, 4.0]], [[4.0, 5.0], [5.0, 5.0]]],
+                        ],
+                        [
+                            [[[6.0, 6.0], [6.0, 7.0]], [[6.5, 6.0], [7.5, 7.0]], [[7.0, 8.0], [8.0, 8.0]]],
+                            [[[9.0, 9.0], [9.0, 10.0]], [[9.5, 9.0], [10.5, 10.0]], [[10.0, 11.0], [11.0, 11.0]]],
+                        ],
+                    ]
+                ),
+            ]
+        )
+
+TEST_TORCH_INPUT = []
+for track_meta in (True,):
+    for t in TEST_4_5_D:
+        TEST_TORCH_INPUT.append(t + [track_meta])
+
+
+class TestSpatialResample(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_flips(self, img, device, data_param, expected_output):
+        for p in TEST_NDARRAYS_ALL:
+            img = p(img)
+            if isinstance(img, MetaTensor):
+                img.affine = torch.eye(4)
+            if hasattr(img, "to"):
+                img = img.to(device)
+            resampler = SpatialResample()
+            call_param = data_param.copy()
+            call_param["img"] = img
+            out = resampler(**call_param)
+            assert_allclose(out, expected_output, rtol=1e-2, atol=1e-2)
+            assert_allclose(to_affine_nd(len(out.shape) - 1, out.affine), call_param["dst_affine"])
+
+            test_resampler_lazy(resampler, out, init_param=None, call_param=call_param)
+
+    @parameterized.expand(TEST_4_5_D)
+    def test_4d_5d(self, new_shape, tile, device, dtype, expected_data):
+        img = np.arange(12).reshape(new_shape)
+        img = np.tile(img, tile)
+        img = MetaTensor(img).to(device)
+
+        dst = torch.tensor([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, -1.0, 1.5], [0.0, 0.0, 0.0, 1.0]])
+        dst = dst.to(dtype)
+        init_param = {"dtype": dtype, "align_corners": True}
+        call_param = {"img": img, "dst_affine": dst, "align_corners": False}
+        resampler = SpatialResample(**init_param)
+        out = resampler(**call_param)
+        assert_allclose(out, expected_data[None], rtol=1e-2, atol=1e-2)
+        assert_allclose(out.affine, dst.to(torch.float32), rtol=1e-2, atol=1e-2)
+
+        test_resampler_lazy(resampler, out, init_param, call_param)
+
+    @parameterized.expand(TEST_DEVICES)
+    def test_ill_affine(self, device):
+        img = MetaTensor(torch.arange(12).reshape(1, 2, 2, 3)).to(device)
+        ill_affine = torch.tensor([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, -1, 1.5], [0, 0, 0, 1]])
+        with self.assertRaises(ValueError):
+            img.affine = torch.eye(4)
+            dst_affine = ill_affine
+            SpatialResample()(img=img, dst_affine=dst_affine)
+        with self.assertRaises(ValueError):
+            img.affine = ill_affine
+            dst_affine = torch.eye(4)
+            SpatialResample()(img=img, dst_affine=dst_affine)
+        if not (optional_import("scipy")[1] and optional_import("cupy")[1]):
+            return
+        with self.assertRaises(ValueError):  # requires scipy
+            SpatialResample(mode=1, align_corners=True)(img=img, dst_affine=dst_affine)
+        with self.assertRaises(ValueError):
+            SpatialResample(mode=1, align_corners=False)(img=img, dst_affine=dst_affine)
+
+    @parameterized.expand(TEST_TORCH_INPUT)
+    def test_input_torch(self, new_shape, tile, device, dtype, expected_data, track_meta):
+        set_track_meta(track_meta)
+        img = np.arange(12).reshape(new_shape)
+        img = torch.as_tensor(np.tile(img, tile)).to(device)
+        dst = torch.tensor([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, -1.0, 1.5], [0.0, 0.0, 0.0, 1.0]])
+        dst = dst.to(dtype).to(device)
+        init_param = {"dtype": dtype}
+        call_param = {"img": img, "dst_affine": dst}
+        resampler = SpatialResample(**init_param)
+        out = resampler(**call_param)
+        assert_allclose(out, expected_data[None], rtol=1e-2, atol=1e-2)
+
+        test_resampler_lazy(resampler, out, init_param, call_param)
+
+        if track_meta:
+            self.assertIsInstance(out, MetaTensor)
+            assert_allclose(out.affine, dst.to(torch.float32), rtol=1e-2, atol=1e-2)
+        else:
+            self.assertIsInstance(out, torch.Tensor)
+            self.assertNotIsInstance(out, MetaTensor)
+
+    @parameterized.expand(TESTS)
+    def test_inverse(self, img, device, data_param, expected_output):
+        img = MetaTensor(img, affine=torch.eye(4)).to(device)
+        tr = SpatialResample()
+        out = tr(img=img, **data_param)
+        assert_allclose(out, expected_output, rtol=1e-2, atol=1e-2)
+        assert_allclose(to_affine_nd(len(out.shape) - 1, out.affine), data_param["dst_affine"])
+
+        # inverse
+        out = tr.inverse(out)
+        assert_allclose(img, out)
+        expected_affine = to_affine_nd(len(out.affine) - 1, torch.eye(4))
+        assert_allclose(out.affine, expected_affine)
+
+    def test_unchange(self):
+        for i, p in enumerate(TEST_NDARRAYS_ALL):
+            set_track_meta(i % 2)
+            img = p(np.arange(12).reshape(1, 3, 4))
+            result = SpatialResample()(img)
+            assert_allclose(result, img, type_test=False)
+        set_track_meta(True)
+
+
+if __name__ == "__main__":
+    unittest.main()