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

tests/transforms/test_flatten_sub_keysd.py

@@ -0,0 +1,64 @@
+# 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.transforms import FlattenSubKeysd
+
+A = torch.randn(2, 2)
+B = torch.randn(3, 3)
+C = torch.randn(1, 3)
+I = torch.randn(2, 3)
+D1 = {"a": A, "b": B}
+D2 = {"a": A, "b": B, "c": C}
+
+TEST_CASE_0 = [{"keys": "pred"}, {"image": I, "pred": D1}, {"a": A, "b": B, "image": I}]
+TEST_CASE_1 = [{"keys": "pred"}, {"image": I, "pred": D2}, {"a": A, "b": B, "c": C, "image": I}]
+TEST_CASE_2 = [{"keys": "pred", "sub_keys": ["a", "b"]}, {"image": I, "pred": D1}, {"a": A, "b": B, "image": I}]
+TEST_CASE_3 = [{"keys": "pred", "sub_keys": ["a", "b"]}, {"image": I, "pred": D2}, {"a": A, "b": B, "image": I}]
+TEST_CASE_4 = [
+    {"keys": "pred", "sub_keys": ["a", "b"], "delete_keys": False},
+    {"image": I, "pred": D1},
+    {"a": A, "b": B, "image": I, "pred": D1},
+]
+TEST_CASE_5 = [
+    {"keys": "pred", "sub_keys": ["a", "b"], "prefix": "new"},
+    {"image": I, "pred": D2},
+    {"new_a": A, "new_b": B, "image": I},
+]
+TEST_CASE_ERROR_1 = [  # error for duplicate key
+    {"keys": "pred", "sub_keys": ["a", "b"]},
+    {"image": I, "pred": D2, "a": None},
+]
+
+
+class TestFlattenSubKeysd(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_dict(self, params, input_data, expected):
+        result = FlattenSubKeysd(**params)(input_data)
+        self.assertSetEqual(set(result.keys()), set(expected.keys()))
+        for k in expected:
+            self.assertEqual(id(result[k]), id(expected[k]))
+
+    @parameterized.expand([TEST_CASE_ERROR_1])
+    def test_error(self, params, input_data):
+        with self.assertRaises(ValueError):
+            FlattenSubKeysd(**params)(input_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_flip.py

@@ -0,0 +1,83 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import Flip
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import (
+    TEST_DEVICES,
+    TEST_NDARRAYS_ALL,
+    NumpyImageTestCase2D,
+    assert_allclose,
+    test_local_inversion,
+)
+
+INVALID_CASES = [("wrong_axis", ["s", 1], TypeError), ("not_numbers", "s", TypeError)]
+
+VALID_CASES = [("no_axis", None), ("one_axis", 1), ("many_axis", [0, 1]), ("negative_axis", [0, -1])]
+
+TORCH_CASES = []
+for track_meta in (False, True):
+    for device in TEST_DEVICES:
+        TORCH_CASES.append([[0, 1], torch.zeros((1, 3, 2)), track_meta, *device])
+
+
+class TestFlip(NumpyImageTestCase2D):
+    @parameterized.expand(INVALID_CASES)
+    def test_invalid_inputs(self, _, spatial_axis, raises):
+        with self.assertRaises(raises):
+            flip = Flip(spatial_axis)
+            flip(self.imt[0])
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, _, spatial_axis):
+        for p in TEST_NDARRAYS_ALL:
+            im = p(self.imt[0])
+            init_param = {"spatial_axis": spatial_axis}
+            flip = Flip(**init_param)
+            expected = [np.flip(channel, spatial_axis) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            call_param = {"img": im}
+            result = flip(**call_param)
+            test_resampler_lazy(flip, result, init_param, call_param)
+            assert_allclose(result, p(expected), type_test="tensor")
+            test_local_inversion(flip, result, im)
+
+    @parameterized.expand(TORCH_CASES)
+    def test_torch(self, spatial_axis, img: torch.Tensor, track_meta: bool, device):
+        set_track_meta(track_meta)
+        img = img.to(device)
+        init_param = {"spatial_axis": spatial_axis}
+        xform = Flip(**init_param)
+        call_param = {"img": img}
+        res = xform(**call_param)  # type: ignore[arg-type]
+        self.assertEqual(img.shape, res.shape)
+        if track_meta:
+            test_resampler_lazy(xform, res, init_param, call_param)
+            self.assertIsInstance(res, MetaTensor)
+        else:
+            self.assertNotIsInstance(res, MetaTensor)
+            self.assertIsInstance(res, torch.Tensor)
+            with self.assertRaisesRegex(ValueError, "MetaTensor"):
+                xform.inverse(res)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_flipd.py

@@ -0,0 +1,90 @@
+# 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 import config
+from monai.data.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import Flipd
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import (
+    TEST_DEVICES,
+    TEST_NDARRAYS_ALL,
+    NumpyImageTestCase2D,
+    assert_allclose,
+    test_local_inversion,
+)
+
+INVALID_CASES = [("wrong_axis", ["s", 1], TypeError), ("not_numbers", "s", TypeError)]
+
+VALID_CASES = [("no_axis", None), ("one_axis", 1), ("many_axis", [0, 1])]
+
+TORCH_CASES = []
+for track_meta in (False, True):
+    for device in TEST_DEVICES:
+        TORCH_CASES.append([[0, 1], torch.zeros((1, 3, 2)), track_meta, *device])
+
+
+class TestFlipd(NumpyImageTestCase2D):
+    @parameterized.expand(INVALID_CASES)
+    def test_invalid_cases(self, _, spatial_axis, raises):
+        with self.assertRaises(raises):
+            flip = Flipd(keys="img", spatial_axis=spatial_axis)
+            flip({"img": self.imt[0]})
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, _, spatial_axis):
+        for p in TEST_NDARRAYS_ALL:
+            init_param = {"keys": "img", "spatial_axis": spatial_axis}
+            flip = Flipd(**init_param)
+            expected = [np.flip(channel, spatial_axis) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            im = p(self.imt[0])
+            call_param = {"data": {"img": im}}
+            result = flip(**call_param)
+            test_resampler_lazy(flip, result, init_param, call_param, output_key="img")
+            assert_allclose(result["img"], p(expected), type_test="tensor")
+            test_local_inversion(flip, {"img": result["img"]}, {"img": im}, "img")
+
+    @parameterized.expand(TORCH_CASES)
+    def test_torch(self, spatial_axis, img: torch.Tensor, track_meta: bool, device):
+        set_track_meta(track_meta)
+        img = img.to(device)
+        init_param = {"keys": "image", "spatial_axis": spatial_axis}
+        xform = Flipd(**init_param)
+        call_param = {"data": {"image": img}}
+        res = xform(**call_param)  # type: ignore
+        self.assertEqual(img.shape, res["image"].shape)
+        if track_meta:
+            test_resampler_lazy(xform, res, init_param, call_param, output_key="image")
+            self.assertIsInstance(res["image"], MetaTensor)
+        else:
+            self.assertNotIsInstance(res["image"], MetaTensor)
+            self.assertIsInstance(res["image"], torch.Tensor)
+            with self.assertRaisesRegex(ValueError, "MetaTensor"):
+                xform.inverse(res)
+
+    @unittest.skipIf(not config.USE_META_DICT, "not using meta dict")
+    def test_meta_dict(self):
+        xform = Flipd("image", [0, 1])
+        res = xform({"image": torch.zeros(1, 3, 4)})
+        self.assertEqual(res["image"].applied_operations, res["image_transforms"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_fourier.py

@@ -0,0 +1,70 @@
+# 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.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import Fourier
+from monai.utils.misc import set_determinism
+from tests.test_utils import SkipIfBeforePyTorchVersion, SkipIfNoModule
+
+TEST_CASES = [((128, 64),), ((64, 48, 80),)]
+
+
+@SkipIfBeforePyTorchVersion((1, 8))
+@SkipIfNoModule("torch.fft")
+class TestFourier(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(img_shape):
+        create_test_image = create_test_image_2d if len(img_shape) == 2 else create_test_image_3d
+        im = create_test_image(*img_shape, num_objs=4, rad_max=20, noise_max=0.0, num_seg_classes=5)[0][None]
+        return torch.Tensor(im)
+
+    @parameterized.expand(TEST_CASES)
+    def test_forward(self, img_shape):
+        n_dims = len(img_shape[1:])
+        x = self.get_data(img_shape)
+        t = Fourier()
+        out = t.shift_fourier(x, n_dims)
+
+        expect = torch.fft.fftshift(torch.fft.fftn(x, dim=tuple(range(-n_dims, 0))), dim=tuple(range(-n_dims, 0)))
+
+        np.testing.assert_allclose(out, expect)
+
+    @parameterized.expand(TEST_CASES)
+    def test_backward(self, img_shape):
+        n_dims = len(img_shape[1:])
+        x = self.get_data(img_shape)
+        t = Fourier()
+        out = t.inv_shift_fourier(x, n_dims)
+
+        expect = torch.fft.ifftn(
+            torch.fft.ifftshift(x, dim=tuple(range(-n_dims, 0))), dim=tuple(range(-n_dims, 0))
+        ).real
+
+        np.testing.assert_allclose(out, expect)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gaussian_sharpen.py

@@ -0,0 +1,92 @@
+# 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 GaussianSharpen
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [4.1081963, 3.4950666, 4.1081963],
+                        [3.7239995, 2.8491793, 3.7239995],
+                        [4.569839, 3.9529324, 4.569839],
+                    ],
+                    [[10.616725, 9.081067, 10.616725], [9.309998, 7.12295, 9.309998], [11.078365, 9.538931, 11.078365]],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"sigma1": 1.0, "sigma2": 0.75, "alpha": 20},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [4.513644, 4.869134, 4.513644],
+                        [8.467242, 9.4004135, 8.467242],
+                        [10.416813, 12.0653515, 10.416813],
+                    ],
+                    [
+                        [15.711488, 17.569994, 15.711488],
+                        [21.16811, 23.501041, 21.16811],
+                        [21.614658, 24.766209, 21.614658],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"sigma1": (0.5, 1.0), "sigma2": (0.5, 0.75), "alpha": 20},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [3.3324685, 3.335536, 3.3324673],
+                        [7.7666636, 8.16056, 7.7666636],
+                        [12.662973, 14.317837, 12.6629715],
+                    ],
+                    [
+                        [15.329051, 16.57557, 15.329051],
+                        [19.41665, 20.40139, 19.416655],
+                        [24.659554, 27.557873, 24.659554],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+
+class TestGaussianSharpen(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = GaussianSharpen(**arguments)(image)
+        assert_allclose(result, expected_data, atol=0, rtol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gaussian_sharpend.py

@@ -0,0 +1,92 @@
+# 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 GaussianSharpend
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": "img"},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [4.1081963, 3.4950666, 4.1081963],
+                        [3.7239995, 2.8491793, 3.7239995],
+                        [4.569839, 3.9529324, 4.569839],
+                    ],
+                    [[10.616725, 9.081067, 10.616725], [9.309998, 7.12295, 9.309998], [11.078365, 9.538931, 11.078365]],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "sigma1": 1.0, "sigma2": 0.75, "alpha": 20},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [4.513644, 4.869134, 4.513644],
+                        [8.467242, 9.4004135, 8.467242],
+                        [10.416813, 12.0653515, 10.416813],
+                    ],
+                    [
+                        [15.711488, 17.569994, 15.711488],
+                        [21.16811, 23.501041, 21.16811],
+                        [21.614658, 24.766209, 21.614658],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "sigma1": (0.5, 1.0), "sigma2": (0.5, 0.75), "alpha": 20},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [3.3324685, 3.335536, 3.3324673],
+                        [7.7666636, 8.16056, 7.7666636],
+                        [12.662973, 14.317837, 12.6629715],
+                    ],
+                    [
+                        [15.329051, 16.57557, 15.329051],
+                        [19.41665, 20.40139, 19.416655],
+                        [24.659554, 27.557873, 24.659554],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+
+class TestGaussianSharpend(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = GaussianSharpend(**arguments)(image)
+        assert_allclose(result["img"], expected_data, rtol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gaussian_smooth.py

@@ -0,0 +1,96 @@
+# 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 GaussianSmooth
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"sigma": 1.5},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [0.59167546, 0.69312394, 0.59167546],
+                        [0.7956997, 0.93213004, 0.7956997],
+                        [0.7668002, 0.8982755, 0.7668002],
+                    ],
+                    [
+                        [1.6105323, 1.8866735, 1.6105323],
+                        [1.9892492, 2.3303251, 1.9892492],
+                        [1.7856569, 2.091825, 1.7856569],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"sigma": 0.5},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [0.8424794, 0.99864554, 0.8424794],
+                        [1.678146, 1.9892154, 1.678146],
+                        [1.9889624, 2.3576462, 1.9889624],
+                    ],
+                    [
+                        [2.966061, 3.5158648, 2.966061],
+                        [4.1953645, 4.973038, 4.1953645],
+                        [4.112544, 4.8748655, 4.1125436],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"sigma": [1.5, 0.5]},
+            p([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]),
+            p(
+                [
+                    [
+                        [0.8542037, 1.0125432, 0.8542037],
+                        [1.1487541, 1.3616928, 1.1487541],
+                        [1.1070318, 1.3122368, 1.1070318],
+                    ],
+                    [
+                        [2.3251305, 2.756128, 2.3251305],
+                        [2.8718853, 3.4042323, 2.8718853],
+                        [2.5779586, 3.0558217, 2.5779586],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+
+class TestGaussianSmooth(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = GaussianSmooth(**arguments)(image)
+        assert_allclose(result, expected_data, atol=1e-4, rtol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_gaussian_smoothd.py

@@ -0,0 +1,96 @@
+# 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 GaussianSmoothd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": "img", "sigma": 1.5},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [0.59167546, 0.69312394, 0.59167546],
+                        [0.7956997, 0.93213004, 0.7956997],
+                        [0.7668002, 0.8982755, 0.7668002],
+                    ],
+                    [
+                        [1.6105323, 1.8866735, 1.6105323],
+                        [1.9892492, 2.3303251, 1.9892492],
+                        [1.7856569, 2.091825, 1.7856569],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "sigma": 0.5},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [0.8424794, 0.99864554, 0.8424794],
+                        [1.678146, 1.9892154, 1.678146],
+                        [1.9889624, 2.3576462, 1.9889624],
+                    ],
+                    [
+                        [2.966061, 3.5158648, 2.966061],
+                        [4.1953645, 4.973038, 4.1953645],
+                        [4.112544, 4.8748655, 4.1125436],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "sigma": [1.5, 0.5]},
+            {"img": p(np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]))},
+            np.array(
+                [
+                    [
+                        [0.8542037, 1.0125432, 0.8542037],
+                        [1.1487541, 1.3616928, 1.1487541],
+                        [1.1070318, 1.3122368, 1.1070318],
+                    ],
+                    [
+                        [2.3251305, 2.756128, 2.3251305],
+                        [2.8718853, 3.4042323, 2.8718853],
+                        [2.5779586, 3.0558217, 2.5779586],
+                    ],
+                ]
+            ),
+        ]
+    )
+
+
+class TestGaussianSmoothd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = GaussianSmoothd(**arguments)(image)
+        assert_allclose(result["img"], expected_data, rtol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()