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

tests/transforms/test_rand_deform_grid.py

@@ -0,0 +1,138 @@
+# 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 RandDeformGrid
+from tests.test_utils import assert_allclose
+
+TEST_CASES = [
+    [
+        dict(spacing=(1, 2), magnitude_range=(1.0, 2.0), device=None),
+        {"spatial_size": (3, 3)},
+        np.array(
+            [
+                [
+                    [-3.45774551, -0.6608006, -1.62002671, -4.02259806, -2.77692349],
+                    [1.21748926, -4.25845712, -1.57592837, 0.69985342, -2.16382767],
+                    [-0.91158377, -0.12717178, 2.00258405, -0.85789449, -0.59616292],
+                    [0.41676882, 3.96204313, 3.93633727, 2.34820726, 1.51855713],
+                    [2.99011186, 4.00170105, 0.74339613, 3.57886072, 0.31633439],
+                ],
+                [
+                    [-4.85634965, -0.78197195, -1.91838077, 1.81192079, 2.84286669],
+                    [-4.34323645, -5.75784424, -2.37875058, 1.06023016, 5.24536301],
+                    [-4.23315172, -1.99617861, 0.92412057, 0.81899041, 4.38084451],
+                    [-5.08141703, -4.31985211, -0.52488611, 2.77048576, 4.45464513],
+                    [-4.01588556, 1.21238156, 0.55444352, 3.31421131, 7.00529793],
+                ],
+                [
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                ],
+            ]
+        ),
+    ],
+    [
+        dict(spacing=(1, 2, 2), magnitude_range=(1.0, 3.0), device=None),
+        {"spatial_size": (1, 2, 2)},
+        np.array(
+            [
+                [
+                    [
+                        [-2.81748977, 0.66968869, -0.52625642, -3.52173734],
+                        [-1.96865364, 1.76472402, -5.06258324, -1.71805669],
+                        [1.11934537, -2.45103851, -2.13654555, -1.15855539],
+                        [1.49678424, -2.06960677, -1.74328475, -1.7271617],
+                    ],
+                    [
+                        [3.69301983, 3.66097025, 1.68091953, 0.6465273],
+                        [1.23445289, 2.49568333, -1.56671014, 1.96849393],
+                        [-2.09916271, -1.06768069, 1.51861453, -2.39180117],
+                        [-0.23449363, -1.44269211, -0.42794076, -4.68520972],
+                    ],
+                    [
+                        [-1.96578162, -0.17168741, 2.55269525, 0.70931081],
+                        [1.00476444, 2.15217619, -0.47246061, 1.4748298],
+                        [-0.34829048, -1.89234811, 0.34558185, 1.9606272],
+                        [1.56684302, 0.98019418, 5.00513708, 1.69126978],
+                    ],
+                ],
+                [
+                    [
+                        [-1.36146598, 0.7469491, -5.16647064, -4.73906938],
+                        [1.91920577, -2.33606298, -0.95030633, 0.7901769],
+                        [2.49116076, 3.93791246, 3.50390686, 2.79030531],
+                        [1.70638302, 4.33070564, 3.52613304, 0.77965554],
+                    ],
+                    [
+                        [-0.62725323, -1.64857887, -2.92384357, -3.39022706],
+                        [-3.00611521, -0.66597021, -0.21577072, -2.39146379],
+                        [2.94568388, -0.83686357, -2.55435186, 2.74064119],
+                        [2.3247117, 2.78900974, 1.59788581, 0.31140512],
+                    ],
+                    [
+                        [-0.89856598, -4.15325814, -0.21934502, -1.64845891],
+                        [-1.52694693, -2.81794479, -2.22623861, -3.0299247],
+                        [4.49410486, 1.27529645, 2.92559679, -1.12171559],
+                        [3.30307684, 4.97189727, 2.43914751, 4.7262225],
+                    ],
+                ],
+                [
+                    [
+                        [-4.81571068, -3.28263239, 1.635167, 2.36520831],
+                        [-1.92511521, -4.311247, 2.19242556, 7.34990574],
+                        [-3.04122716, -0.94284154, 1.30058968, -0.11719455],
+                        [-2.28657395, -3.68766906, 0.28400757, 5.08072864],
+                    ],
+                    [
+                        [-4.2308508, -0.16084264, 2.69545963, 3.4666492],
+                        [-5.29514976, -1.55660775, 4.28031473, -0.39019547],
+                        [-3.4617024, -1.92430221, 1.20214712, 4.25261228],
+                        [-0.30683774, -1.4524049, 2.35996724, 3.83663135],
+                    ],
+                    [
+                        [-2.20587965, -1.94408353, -0.66964855, 1.15838178],
+                        [-4.26637632, -0.46145396, 2.27393031, 3.5415298],
+                        [-3.91902371, 2.02343374, 3.54278271, 2.40735681],
+                        [-4.3785335, -0.78200288, 3.12162619, 3.55709275],
+                    ],
+                ],
+                [
+                    [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]],
+                    [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]],
+                    [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]],
+                ],
+            ]
+        ),
+    ],
+]
+
+
+class TestRandDeformGrid(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_rand_deform_grid(self, input_param, input_data, expected_val):
+        g = RandDeformGrid(**input_param)
+        g.set_random_state(123)
+        result = g(**input_data)
+        assert_allclose(result, expected_val, type_test=False, rtol=1e-3, atol=1e-3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_elastic_2d.py

@@ -0,0 +1,127 @@
+# 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 import Rand2DElastic
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, is_tf32_env
+
+_rtol = 5e-3 if is_tf32_env() else 1e-4
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                {"spacing": (0.3, 0.3), "magnitude_range": (1.0, 2.0), "prob": 0.0, "device": device},
+                {"img": p(torch.ones((3, 3, 3))), "spatial_size": (2, 2)},
+                p(np.ones((3, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                {"spacing": (0.3, 0.3), "magnitude_range": (1.0, 2.0), "prob": 0.0, "device": device},
+                {"img": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(np.arange(27).reshape((3, 3, 3))),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (1.0, 2.0),
+                    "prob": 0.9,
+                    "device": device,
+                    "padding_mode": "zeros",
+                },
+                {"img": p(torch.ones((3, 3, 3))), "spatial_size": (2, 2), "mode": "bilinear"},
+                p(
+                    np.array(
+                        [
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "spacing": (1.0, 1.0),
+                    "magnitude_range": (1.0, 1.0),
+                    "scale_range": [1.2, 2.2],
+                    "prob": 0.9,
+                    "padding_mode": "border",
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(
+                    torch.tensor(
+                        [
+                            [[3.0793, 2.6141], [4.0568, 5.9978]],
+                            [[12.0793, 11.6141], [13.0568, 14.9978]],
+                            [[21.0793, 20.6141], [22.0568, 23.9978]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (0.1, 0.2),
+                    "translate_range": [-0.01, 0.01],
+                    "scale_range": [0.01, 0.02],
+                    "prob": 0.9,
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(
+                    np.array(
+                        [
+                            [[1.3584113, 1.9251312], [5.626623, 6.642721]],
+                            [[10.358411, 10.925131], [14.626623, 15.642721]],
+                            [[19.358412, 19.92513], [23.626623, 24.642721]],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestRand2DElastic(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_2d_elastic(self, input_param, input_data, expected_val):
+        g = Rand2DElastic(**input_param)
+        set_track_meta(False)
+        result = g(**input_data)
+        self.assertNotIsInstance(result, MetaTensor)
+        self.assertIsInstance(result, torch.Tensor)
+        set_track_meta(True)
+        g.set_random_state(123)
+        result = g(**input_data)
+        assert_allclose(result, expected_val, type_test=False, rtol=_rtol, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_elastic_3d.py

@@ -0,0 +1,104 @@
+# 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 import Rand3DElastic
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                {
+                    "magnitude_range": (0.3, 2.3),
+                    "sigma_range": (1.0, 20.0),
+                    "prob": 0.0,
+                    "device": device,
+                    "spatial_size": -1,
+                },
+                {"img": p(torch.arange(72).reshape((2, 3, 3, 4)))},
+                p(np.arange(72).reshape((2, 3, 3, 4))),
+            ]
+        )
+        TESTS.append(
+            [
+                {"magnitude_range": (0.3, 2.3), "sigma_range": (1.0, 20.0), "prob": 0.0, "device": device},
+                {"img": p(torch.ones((2, 3, 3, 3))), "spatial_size": (2, 2, 2)},
+                p(np.ones((2, 2, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                {"magnitude_range": (0.3, 0.3), "sigma_range": (1.0, 2.0), "prob": 0.9, "device": device},
+                {"img": p(torch.arange(27).reshape((1, 3, 3, 3))), "spatial_size": (2, 2, 2)},
+                p(
+                    np.array(
+                        [
+                            [
+                                [[6.4939356, 7.50289], [9.518351, 10.522849]],
+                                [[15.512375, 16.523542], [18.531467, 19.53646]],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "magnitude_range": (0.3, 0.3),
+                    "sigma_range": (1.0, 2.0),
+                    "prob": 0.9,
+                    "rotate_range": [1, 1, 1],
+                    "device": device,
+                    "spatial_size": (2, 2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((1, 3, 3, 3))), "mode": "bilinear"},
+                p(
+                    np.array(
+                        [
+                            [
+                                [[5.0069294, 9.463932], [9.287769, 13.739735]],
+                                [[12.319424, 16.777205], [16.594296, 21.045748]],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestRand3DElastic(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_3d_elastic(self, input_param, input_data, expected_val):
+        g = Rand3DElastic(**input_param)
+        set_track_meta(False)
+        g.set_random_state(123)
+        result = g(**input_data)
+        self.assertNotIsInstance(result, MetaTensor)
+        self.assertIsInstance(result, torch.Tensor)
+        set_track_meta(True)
+        g.set_random_state(123)
+        result = g(**input_data)
+        assert_allclose(result, expected_val, type_test=False, rtol=1e-1, atol=1e-1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_elasticd_2d.py

@@ -0,0 +1,177 @@
+# 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 import Rand2DElasticd
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, is_tf32_env
+
+_rtol = 5e-3 if is_tf32_env() else 1e-4
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (1.0, 2.0),
+                    "prob": 0.0,
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.ones((3, 3, 3))), "seg": p(torch.ones((3, 3, 3)))},
+                p(np.ones((3, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (0.3, 0.3),
+                    "prob": 0.0,
+                    "device": device,
+                    "spatial_size": -1,
+                },
+                {"img": p(torch.arange(4).reshape((1, 2, 2))), "seg": p(torch.arange(4).reshape((1, 2, 2)))},
+                p(np.arange(4).reshape((1, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (1.0, 2.0),
+                    "prob": 0.9,
+                    "padding_mode": "zeros",
+                    "device": device,
+                    "spatial_size": (2, 2),
+                    "mode": "bilinear",
+                },
+                {"img": p(torch.ones((3, 3, 3))), "seg": p(torch.ones((3, 3, 3)))},
+                p(
+                    np.array(
+                        [
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                            [[0.45531988, 0.0], [0.0, 0.71558857]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "spacing": (1.0, 1.0),
+                    "magnitude_range": (1.0, 1.0),
+                    "scale_range": [1.2, 2.2],
+                    "prob": 0.9,
+                    "padding_mode": "border",
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((3, 3, 3))), "seg": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(
+                    torch.tensor(
+                        [
+                            [[3.0793, 2.6141], [4.0568, 5.9978]],
+                            [[12.0793, 11.6141], [13.0568, 14.9978]],
+                            [[21.0793, 20.6141], [22.0568, 23.9978]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (0.1, 0.2),
+                    "translate_range": [-0.01, 0.01],
+                    "scale_range": [0.01, 0.02],
+                    "prob": 0.9,
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((3, 3, 3))), "seg": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(
+                    np.array(
+                        [
+                            [[1.3584113, 1.9251312], [5.626623, 6.642721]],
+                            [[10.358411, 10.925131], [14.626623, 15.642721]],
+                            [[19.358412, 19.92513], [23.626623, 24.642721]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ("img", "seg"),
+                    "mode": ("bilinear", "nearest"),
+                    "spacing": (0.3, 0.3),
+                    "magnitude_range": (0.1, 0.2),
+                    "translate_range": [-0.01, 0.01],
+                    "scale_range": [0.01, 0.02],
+                    "prob": 0.9,
+                    "device": device,
+                    "spatial_size": (2, 2),
+                },
+                {"img": p(torch.arange(27).reshape((3, 3, 3))), "seg": p(torch.arange(27).reshape((3, 3, 3)))},
+                {
+                    "img": p(
+                        torch.tensor(
+                            [
+                                [[1.3584, 1.9251], [5.6266, 6.6427]],
+                                [[10.3584, 10.9251], [14.6266, 15.6427]],
+                                [[19.3584, 19.9251], [23.6266, 24.6427]],
+                            ]
+                        )
+                    ),
+                    "seg": p(
+                        torch.tensor(
+                            [[[0.0, 2.0], [6.0, 8.0]], [[9.0, 11.0], [15.0, 17.0]], [[18.0, 20.0], [24.0, 26.0]]]
+                        )
+                    ),
+                },
+            ]
+        )
+
+
+class TestRand2DElasticd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_2d_elasticd(self, input_param, input_data, expected_val):
+        g = Rand2DElasticd(**input_param)
+        if input_param.get("device", None) is None and isinstance(input_data["img"], torch.Tensor):
+            input_data["img"].to("cuda:0" if torch.cuda.is_available() else "cpu")
+        g.set_random_state(123)
+        res = g(input_data)
+        for key in res:
+            result = res[key]
+            expected = expected_val[key] if isinstance(expected_val, dict) else expected_val
+            assert_allclose(result, expected, rtol=_rtol, atol=5e-3, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()