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

tests/transforms/test_generate_label_classes_crop_centers.py

@@ -0,0 +1,71 @@
+# 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
+
+from parameterized import parameterized
+
+from monai.transforms import generate_label_classes_crop_centers
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TEST_CASE_1 = [
+    {
+        "spatial_size": [2, 2, 2],
+        "num_samples": 2,
+        "ratios": [1, 2],
+        "label_spatial_shape": [3, 3, 3],
+        "indices": [[3, 12, 21], [1, 9, 18]],
+    },
+    tuple,
+    2,
+    3,
+]
+
+TEST_CASE_2 = [
+    {
+        "spatial_size": [2, 2, 2],
+        "num_samples": 1,
+        "ratios": None,
+        "label_spatial_shape": [3, 3, 3],
+        "indices": [[3, 12, 21], [1, 9, 18]],
+    },
+    tuple,
+    1,
+    3,
+]
+
+
+class TestGenerateLabelClassesCropCenters(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_type_shape(self, input_data, expected_type, expected_count, expected_shape):
+        results = []
+        for p in TEST_NDARRAYS + (None,):
+            input_data = deepcopy(input_data)
+            if p is not None:
+                input_data["indices"] = p(input_data["indices"])
+            set_determinism(0)
+            result = generate_label_classes_crop_centers(**input_data)
+            self.assertIsInstance(result, expected_type)
+            self.assertEqual(len(result), expected_count)
+            self.assertEqual(len(result[0]), expected_shape)
+            # check for consistency between numpy, torch and torch.cuda
+            results.append(result)
+            if len(results) > 1:
+                for x, y in zip(result[0], result[-1]):
+                    assert_allclose(x, y, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_generate_pos_neg_label_crop_centers.py

@@ -0,0 +1,76 @@
+# 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
+
+from parameterized import parameterized
+
+from monai.transforms import generate_pos_neg_label_crop_centers
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = [
+    [
+        {
+            "spatial_size": [2, 2, 2],
+            "num_samples": 2,
+            "pos_ratio": 1.0,
+            "label_spatial_shape": [3, 3, 3],
+            "fg_indices": [1, 9, 18],
+            "bg_indices": [3, 12, 21],
+        },
+        tuple,
+        2,
+        3,
+    ],
+    [
+        {
+            "spatial_size": [2, 2, 2],
+            "num_samples": 2,
+            "pos_ratio": 0.0,
+            "label_spatial_shape": [3, 3, 3],
+            "fg_indices": [],
+            "bg_indices": [3, 12, 21],
+        },
+        tuple,
+        2,
+        3,
+    ],
+]
+
+
+class TestGeneratePosNegLabelCropCenters(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_type_shape(self, input_data, expected_type, expected_count, expected_shape):
+        results = []
+        for p in TEST_NDARRAYS + (None,):
+            input_data = deepcopy(input_data)
+            if p is not None:
+                for k in ["fg_indices", "bg_indices"]:
+                    input_data[k] = p(input_data[k])
+            set_determinism(0)
+            result = generate_pos_neg_label_crop_centers(**input_data)
+            self.assertIsInstance(result, expected_type)
+            self.assertEqual(len(result), expected_count)
+            self.assertEqual(len(result[0]), expected_shape)
+            # check for consistency between numpy, torch and torch.cuda
+            results.append(result)
+            if len(results) > 1:
+                # compare every crop center
+                for x, y in zip(results[0], results[-1]):
+                    assert_allclose(x, y, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_generate_spatial_bounding_box.py

@@ -0,0 +1,114 @@
+# 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 generate_spatial_bounding_box
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    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]]])
+                ),
+                "select_fn": lambda x: x > 0,
+                "channel_indices": None,
+                "margin": 0,
+            },
+            ([1, 1], [4, 4]),
+        ]
+    )
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    np.array([[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 3, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]])
+                ),
+                "select_fn": lambda x: x > 1,
+                "channel_indices": None,
+                "margin": 0,
+            },
+            ([2, 2], [3, 3]),
+        ]
+    )
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    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]]])
+                ),
+                "select_fn": lambda x: x > 0,
+                "channel_indices": 0,
+                "margin": 0,
+            },
+            ([1, 1], [4, 4]),
+        ]
+    )
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    np.array([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]])
+                ),
+                "select_fn": lambda x: x > 0,
+                "channel_indices": None,
+                "margin": 1,
+            },
+            ([0, 0], [4, 5]),
+        ]
+    )
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    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]]])
+                ),
+                "select_fn": lambda x: x > 0,
+                "channel_indices": None,
+                "margin": [2, 1],
+                "allow_smaller": False,
+            },
+            ([-1, 0], [6, 5]),
+        ]
+    )
+    TESTS.append(
+        [
+            {
+                "img": p(
+                    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]]])
+                ),
+                "select_fn": lambda x: x > 0,
+                "channel_indices": None,
+                "margin": [2, 1],
+                "allow_smaller": True,
+            },
+            ([0, 0], [5, 5]),
+        ]
+    )
+
+
+class TestGenerateSpatialBoundingBox(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input_data, expected_box):
+        result = generate_spatial_bounding_box(**input_data)
+        self.assertTupleEqual(result, expected_box)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_get_extreme_points.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
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import get_extreme_points
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {
+                "img": p(np.array([[0, 1, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0]])),
+                "rand_state": np.random,
+                "background": 0,
+                "pert": 0.0,
+            },
+            [(0, 1), (3, 0), (3, 0), (1, 2)],
+        ]
+    )
+
+    TESTS.append(
+        [
+            {
+                "img": p(np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0], [0, 1, 0]])),
+                "rand_state": np.random,
+                "background": 0,
+                "pert": 0.0,
+            },
+            [(0, 1), (3, 1), (1, 0), (1, 2)],
+        ]
+    )
+
+
+class TestGetExtremePoints(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_type_shape(self, input_data, expected):
+        result = get_extreme_points(**input_data)
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gibbs_noise.py

@@ -0,0 +1,75 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from copy import deepcopy
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import GibbsNoise
+from monai.utils.misc import set_determinism
+from monai.utils.module import optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+_, has_torch_fft = optional_import("torch.fft", name="fftshift")
+
+TEST_CASES = []
+for shape in ((128, 64), (64, 48, 80)):
+    for input_type in TEST_NDARRAYS if has_torch_fft else [np.array]:
+        TEST_CASES.append((shape, input_type))
+
+
+class TestGibbsNoise(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, input_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        im = create_test_image(*im_shape, num_objs=4, rad_max=20, noise_max=0.0, num_seg_classes=5)[0][None]
+        return input_type(im)
+
+    @parameterized.expand(TEST_CASES)
+    def test_same_result(self, im_shape, input_type):
+        im = self.get_data(im_shape, input_type)
+        alpha = 0.8
+        t = GibbsNoise(alpha)
+        out1 = t(deepcopy(im))
+        out2 = t(deepcopy(im))
+        assert_allclose(out1, out2, rtol=1e-7, atol=0, type_test="tensor")
+
+    @parameterized.expand(TEST_CASES)
+    def test_identity(self, im_shape, input_type):
+        im = self.get_data(im_shape, input_type)
+        alpha = 0.0
+        t = GibbsNoise(alpha)
+        out = t(deepcopy(im))
+        assert_allclose(out, im, atol=1e-2, rtol=1e-7, type_test="tensor")
+
+    @parameterized.expand(TEST_CASES)
+    def test_alpha_1(self, im_shape, input_type):
+        im = self.get_data(im_shape, input_type)
+        alpha = 1.0
+        t = GibbsNoise(alpha)
+        out = t(deepcopy(im))
+        assert_allclose(out, 0 * im, rtol=1e-7, atol=0, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gibbs_noised.py

@@ -0,0 +1,88 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from copy import deepcopy
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import GibbsNoised
+from monai.utils.misc import set_determinism
+from monai.utils.module import optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+_, has_torch_fft = optional_import("torch.fft", name="fftshift")
+
+TEST_CASES = []
+for shape in ((128, 64), (64, 48, 80)):
+    for input_type in TEST_NDARRAYS if has_torch_fft else [np.array]:
+        TEST_CASES.append((shape, input_type))
+KEYS = ["im", "label"]
+
+
+class TestGibbsNoised(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, input_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        ims = create_test_image(*im_shape, rad_max=20, noise_max=0.0, num_seg_classes=5)
+        return {k: input_type(deepcopy(v)) for k, v in zip(KEYS, ims)}
+
+    @parameterized.expand(TEST_CASES)
+    def test_same_result(self, im_shape, input_type):
+        data = self.get_data(im_shape, input_type)
+        alpha = 0.8
+        t = GibbsNoised(KEYS, alpha)
+        out1 = t(deepcopy(data))
+        out2 = t(deepcopy(data))
+        for k in KEYS:
+            assert_allclose(out1[k], out2[k], rtol=1e-7, atol=0, type_test="tensor")
+
+    @parameterized.expand(TEST_CASES)
+    def test_identity(self, im_shape, input_type):
+        data = self.get_data(im_shape, input_type)
+        alpha = 0.0
+        t = GibbsNoised(KEYS, alpha)
+        out = t(deepcopy(data))
+        for k in KEYS:
+            assert_allclose(out[k], data[k], atol=1e-2, type_test="tensor")
+
+    @parameterized.expand(TEST_CASES)
+    def test_alpha_1(self, im_shape, input_type):
+        data = self.get_data(im_shape, input_type)
+        alpha = 1.0
+        t = GibbsNoised(KEYS, alpha)
+        out = t(deepcopy(data))
+        for k in KEYS:
+            assert_allclose(out[k], 0.0 * data[k], atol=1e-2, type_test="tensor")
+
+    @parameterized.expand(TEST_CASES)
+    def test_dict_matches(self, im_shape, input_type):
+        data = self.get_data(im_shape, input_type)
+        data = {KEYS[0]: deepcopy(data[KEYS[0]]), KEYS[1]: deepcopy(data[KEYS[0]])}
+        alpha = 1.0
+        t = GibbsNoised(KEYS, alpha)
+        out = t(deepcopy(data))
+        assert_allclose(out[KEYS[0]], out[KEYS[1]], rtol=1e-7, atol=0, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_grid_distortion.py

@@ -0,0 +1,113 @@
+# 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 GridDistortion
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    TESTS.append(
+        [
+            dict(num_cells=3, distort_steps=[(1.5,) * 4] * 2, mode="nearest", padding_mode="zeros"),
+            p(np.indices([6, 6]).astype(np.float32)),
+            p(
+                np.array(
+                    [
+                        [
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [3.0, 3.0, 3.0, 0.0, 0.0, 0.0],
+                            [3.0, 3.0, 3.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                        ],
+                        [
+                            [0.0, 3.0, 3.0, 0.0, 0.0, 0.0],
+                            [0.0, 3.0, 3.0, 0.0, 0.0, 0.0],
+                            [0.0, 3.0, 3.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                        ],
+                    ]
+                ).astype(np.float32)
+            ),
+        ]
+    )
+    num_cells = (2, 2)
+    distort_steps = [(1.5,) * (1 + num_cells[0]), (1.0,) * (1 + num_cells[1])]
+    TESTS.append(
+        [
+            dict(num_cells=num_cells, distort_steps=distort_steps, mode="bilinear", padding_mode="reflection"),
+            p(np.indices([6, 6]).astype(np.float32)),
+            p(
+                np.array(
+                    [
+                        [
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [2.25, 2.25, 2.25, 2.25, 2.25, 2.25],
+                            [4.5, 4.5, 4.5, 4.5, 4.5, 4.5],
+                            [4.5, 4.5, 4.5, 4.5, 4.5, 4.5],
+                            [4.2500, 4.2500, 4.2500, 4.2500, 4.2500, 4.2500],
+                            [2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
+                        ],
+                        [
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                            [0.0, 1.5, 3.0, 3.0, 4.5, 5.0],
+                        ],
+                    ]
+                ).astype(np.float32)
+            ),
+        ]
+    )
+    TESTS.append(
+        [
+            dict(num_cells=2, distort_steps=[(1.26,) * 3] * 3, mode="nearest", padding_mode="zeros"),
+            p(np.indices([3, 3, 3])[:1].astype(np.float32)),
+            p(
+                np.array(
+                    [
+                        [
+                            [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                            [[1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+                            [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                        ]
+                    ]
+                ).astype(np.float32)
+            ),
+        ]
+    )
+
+
+class TestGridDistortion(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_grid_distortion(self, input_param, input_data, expected_val):
+        g = GridDistortion(**input_param)
+        result = g(input_data)
+        if input_param["padding_mode"] != "reflection":
+            assert_allclose(result, expected_val, type_test=False, rtol=1e-4, atol=1e-4)
+        else:
+            assert_allclose(result.shape, expected_val.shape, type_test=False, rtol=1e-4, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_grid_distortiond.py

@@ -0,0 +1,87 @@
+# 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 GridDistortiond
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TESTS = []
+num_cells = (2, 2)
+distort_steps = [(1.5,) * (1 + n_c) for n_c in num_cells]
+for p in TEST_NDARRAYS_ALL:
+    img = np.indices([6, 6]).astype(np.float32)
+    TESTS.append(
+        [
+            dict(
+                keys=["img", "mask"],
+                num_cells=num_cells,
+                distort_steps=distort_steps,
+                mode=["bilinear", "nearest"],
+                padding_mode=["reflection", "zeros"],
+            ),
+            {"img": p(img), "mask": p(np.ones_like(img[:1]))},
+            p(
+                np.array(
+                    [
+                        [
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [2.25, 2.25, 2.25, 2.25, 2.25, 2.25],
+                            [4.5, 4.5, 4.5, 4.5, 4.5, 4.5],
+                            [4.5, 4.5, 4.5, 4.5, 4.5, 4.5],
+                            [4.2500, 4.2500, 4.2500, 4.2500, 4.2500, 4.2500],
+                            [2.0000, 2.0000, 2.0000, 2.0000, 2.0000, 2.0000],
+                        ],
+                        [
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                            [0.0000, 2.2500, 4.5000, 4.5000, 4.2500, 2.0000],
+                        ],
+                    ]
+                ).astype(np.float32)
+            ),
+            p(
+                np.array(
+                    [
+                        [
+                            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+                            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+                            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+                            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                        ]
+                    ]
+                ).astype(np.float32)
+            ),
+        ]
+    )
+
+
+class TestGridDistortiond(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_grid_distortiond(self, input_param, input_data, expected_val_img, expected_val_mask):
+        g = GridDistortiond(**input_param)
+        result = g(input_data)
+        assert_allclose(result["mask"], expected_val_mask, type_test=False, rtol=1e-4, atol=1e-4)
+        assert_allclose(result["img"].shape, expected_val_img.shape, type_test=False, rtol=1e-4, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()