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

tests/transforms/test_signal_rand_drop.py

@@ -0,0 +1,50 @@
+# 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 os
+import unittest
+from pathlib import Path
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import SignalRandDrop
+from monai.utils.type_conversion import convert_to_tensor
+
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [([0.0, 1.0],), ([0.01, 0.1],)]
+
+
+class TestSignalRandDropNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandDrop(boundaries), SignalRandDrop)
+        sig = np.load(TEST_SIGNAL)
+        droped = SignalRandDrop(boundaries)
+        dropedsignal = droped(sig)
+        self.assertEqual(dropedsignal.shape[1], sig.shape[1])
+
+
+class TestSignalRandDropTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandDrop(boundaries), SignalRandDrop)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        droped = SignalRandDrop(boundaries)
+        dropedsignal = droped(sig)
+        self.assertEqual(dropedsignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_scale.py

@@ -0,0 +1,52 @@
+# 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 os
+import unittest
+from pathlib import Path
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import SignalRandScale
+from monai.utils.type_conversion import convert_to_tensor
+
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [([-1.0, 1.0],), ([0.01, 0.1],)]
+
+
+class TestSignalRandScaleNumpy(unittest.TestCase):
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandScale(boundaries), SignalRandScale)
+        sig = np.load(TEST_SIGNAL)
+        scaled = SignalRandScale(boundaries)
+        scaledsignal = scaled(sig)
+        self.assertEqual(scaledsignal.shape[1], sig.shape[1])
+
+
+class TestSignalRandScaleTorch(unittest.TestCase):
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandScale(boundaries), SignalRandScale)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        scaled = SignalRandScale(boundaries)
+        scaledsignal = scaled(sig)
+        self.assertEqual(scaledsignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_shift.py

@@ -0,0 +1,55 @@
+# 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 os
+import unittest
+from pathlib import Path
+from unittest import skipUnless
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.signal.array import SignalRandShift
+from monai.utils import optional_import
+from monai.utils.type_conversion import convert_to_tensor
+
+_, has_scipy = optional_import("scipy")
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [("wrap", 0.0, [-1.0, 1.0])]
+
+
+@skipUnless(has_scipy, "scipy required")
+class TestSignalRandShiftNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, mode, filling, boundaries):
+        self.assertIsInstance(SignalRandShift(mode, filling, boundaries), SignalRandShift)
+        sig = np.load(TEST_SIGNAL)
+        shifted = SignalRandShift(mode, filling, boundaries)
+        shiftedsignal = shifted(sig)
+        self.assertEqual(shiftedsignal.shape[1], sig.shape[1])
+
+
+@skipUnless(has_scipy, "scipy required")
+class TestSignalRandShiftTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, mode, filling, boundaries):
+        self.assertIsInstance(SignalRandShift(mode, filling, boundaries), SignalRandShift)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        shifted = SignalRandShift(mode, filling, boundaries)
+        shiftedsignal = shifted(sig)
+        self.assertEqual(shiftedsignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_remove_frequency.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 os
+import unittest
+from pathlib import Path
+from unittest import skipUnless
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import SignalRemoveFrequency
+from monai.utils import optional_import
+from monai.utils.type_conversion import convert_to_tensor
+
+_, has_scipy = optional_import("scipy")
+_, has_torchaudio = optional_import("torchaudio")
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [(60, 1, 500)]
+
+
+@skipUnless(has_scipy and has_torchaudio, "scipy and torchaudio are required")
+class TestSignalRemoveFrequencyNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, frequency, quality_factor, sampling_freq):
+        self.assertIsInstance(SignalRemoveFrequency(frequency, quality_factor, sampling_freq), SignalRemoveFrequency)
+        sig = np.load(TEST_SIGNAL)
+        t = sig.shape[1] / sampling_freq
+        composite_sig = sig + np.sin(2 * np.pi * frequency * t)
+        freqremove = SignalRemoveFrequency(frequency, quality_factor, sampling_freq)
+        freqremovesignal = freqremove(composite_sig)
+        y = np.fft.fft(composite_sig) / composite_sig.shape[1]
+        y = y[: composite_sig.shape[1] // 2]
+        y2 = np.fft.fft(freqremovesignal) / freqremovesignal.shape[1]
+        y2 = y2[: freqremovesignal.shape[1] // 2]
+        self.assertEqual(composite_sig.shape[1], sig.shape[1])
+        self.assertAlmostEqual(y.all(), y2.all())
+
+
+@skipUnless(has_scipy and has_torchaudio, "scipy and torchaudio are required")
+class TestSignalRemoveFrequencyTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, frequency, quality_factor, sampling_freq):
+        self.assertIsInstance(SignalRemoveFrequency(frequency, quality_factor, sampling_freq), SignalRemoveFrequency)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        t = sig.shape[1] / sampling_freq
+        composite_sig = convert_to_tensor(sig + np.sin(2 * np.pi * frequency * t))
+        freqremove = SignalRemoveFrequency(frequency, quality_factor, sampling_freq)
+        freqremovesignal = freqremove(composite_sig)
+        y = torch.fft.fft(composite_sig) / composite_sig.shape[1]
+        y = y[: composite_sig.shape[1] // 2]
+        y2 = torch.fft.fft(freqremovesignal) / freqremovesignal.shape[1]
+        y2 = y2[: freqremovesignal.shape[1] // 2]
+        self.assertEqual(composite_sig.shape[1], sig.shape[1])
+        self.assertAlmostEqual(y.all(), y2.all())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_smooth_field.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
+from itertools import product
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.networks.utils import meshgrid_xy
+from monai.transforms import RandSmoothDeformd, RandSmoothFieldAdjustContrastd, RandSmoothFieldAdjustIntensityd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose, is_tf32_env
+
+_rtol = 5e-3 if is_tf32_env() else 1e-4
+
+x, y = meshgrid_xy(torch.linspace(-1, 2, 11), torch.linspace(-2.1, 1.2, 8))
+pattern2d = x.pow(2).add_(y.pow(2)).sqrt_()
+
+x, y, z = meshgrid_xy(torch.linspace(-1, 2, 11), torch.linspace(-2.1, 1.2, 8), torch.linspace(-0.1, 10.2, 6))
+pattern3d = x.pow(2).add_(y.pow(2)).add_(z.pow(2)).sqrt_()
+
+INPUT_SHAPES = ((1, 8, 8), (1, 12, 7), (2, 8, 8), (2, 13, 8), (1, 8, 8, 8), (3, 7, 4, 5))
+
+TESTS_CONTRAST = []
+TESTS_INTENSITY = []
+TESTS_DEFORM = []
+
+KEY = "test"
+
+for arr_type, shape in product(TEST_NDARRAYS, INPUT_SHAPES):
+    in_arr = arr_type(np.ones(shape, np.float32))
+    exp_arr = arr_type(np.ones(shape, np.float32))
+    rand_size = (4,) * (len(shape) - 1)
+
+    device = torch.device("cpu")
+
+    if isinstance(in_arr, torch.Tensor) and in_arr.get_device() >= 0:
+        device = torch.device(in_arr.get_device())
+
+    TESTS_CONTRAST.append(
+        (
+            {"keys": (KEY,), "spatial_size": shape[1:], "rand_size": rand_size, "prob": 1.0, "device": device},
+            {KEY: in_arr},
+            {KEY: exp_arr},
+        )
+    )
+
+    TESTS_INTENSITY.append(
+        (
+            {
+                "keys": (KEY,),
+                "spatial_size": shape[1:],
+                "rand_size": rand_size,
+                "prob": 1.0,
+                "device": device,
+                "gamma": (0.9, 1),
+            },
+            {KEY: in_arr},
+            {KEY: exp_arr},
+        )
+    )
+
+    TESTS_DEFORM.append(
+        (
+            {
+                "keys": (KEY,),
+                "spatial_size": shape[1:],
+                "rand_size": rand_size,
+                "prob": 1.0,
+                "device": device,
+                "def_range": 0.1,
+            },
+            {KEY: in_arr},
+            {KEY: exp_arr},
+        )
+    )
+
+
+class TestSmoothField(unittest.TestCase):
+    @parameterized.expand(TESTS_CONTRAST)
+    def test_rand_smooth_field_adjust_contrastd(self, input_param, input_data, expected_val):
+        g = RandSmoothFieldAdjustContrastd(**input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    def test_rand_smooth_field_adjust_contrastd_pad(self):
+        input_param, input_data, expected_val = TESTS_CONTRAST[0]
+
+        g = RandSmoothFieldAdjustContrastd(pad=1, **input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    @parameterized.expand(TESTS_INTENSITY)
+    def test_rand_smooth_field_adjust_intensityd(self, input_param, input_data, expected_val):
+        g = RandSmoothFieldAdjustIntensityd(**input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    def test_rand_smooth_field_adjust_intensityd_pad(self):
+        input_param, input_data, expected_val = TESTS_INTENSITY[0]
+
+        g = RandSmoothFieldAdjustIntensityd(pad=1, **input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    @parameterized.expand(TESTS_DEFORM)
+    def test_rand_smooth_deformd(self, input_param, input_data, expected_val):
+        g = RandSmoothDeformd(**input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    def test_rand_smooth_nodeformd(self):
+        """Test input is very close to output when deformation is very low, verifies there's no transposition."""
+
+        for label, im in zip(("2D", "3D"), (pattern2d, pattern3d)):
+            with self.subTest(f"Testing {label} case with shape {im.shape}"):
+                rsize = (3,) * len(im.shape)
+                g = RandSmoothDeformd(
+                    keys=(KEY,), spatial_size=im.shape, rand_size=rsize, prob=1.0, device=device, def_range=1e-20
+                )
+                g.set_random_state(123)
+
+                expected_val = {KEY: im[None]}
+
+                res = g(expected_val)
+                for key, result in res.items():
+                    expected = expected_val[key]
+
+                    self.assertSequenceEqual(tuple(result.shape), tuple(expected.shape))
+
+                    assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+    def test_rand_smooth_deformd_pad(self):
+        input_param, input_data, expected_val = TESTS_DEFORM[0]
+
+        g = RandSmoothDeformd(pad=1, **input_param)
+        g.set_random_state(123)
+
+        res = g(input_data)
+        for key, result in res.items():
+            expected = expected_val[key]
+            assert_allclose(result, expected, rtol=_rtol, atol=1e-1, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_sobel_gradient.py

@@ -0,0 +1,189 @@
+# 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 SobelGradients
+from tests.test_utils import assert_allclose
+
+IMAGE = torch.zeros(1, 16, 16, dtype=torch.float32)
+IMAGE[0, 8, :] = 1
+
+# Output with reflect padding
+OUTPUT_3x3 = torch.zeros(2, 16, 16, dtype=torch.float32)
+OUTPUT_3x3[0, 7, :] = 0.5
+OUTPUT_3x3[0, 9, :] = -0.5
+
+# Output with zero padding
+OUTPUT_3x3_ZERO_PAD = OUTPUT_3x3.clone()
+OUTPUT_3x3_ZERO_PAD[1, 7, 0] = OUTPUT_3x3_ZERO_PAD[1, 9, 0] = 0.125
+OUTPUT_3x3_ZERO_PAD[1, 8, 0] = 0.25
+OUTPUT_3x3_ZERO_PAD[1, 7, -1] = OUTPUT_3x3_ZERO_PAD[1, 9, -1] = -0.125
+OUTPUT_3x3_ZERO_PAD[1, 8, -1] = -0.25
+OUTPUT_3x3_ZERO_PAD[0, 7, 0] = OUTPUT_3x3_ZERO_PAD[0, 7, -1] = 3.0 / 8.0
+OUTPUT_3x3_ZERO_PAD[0, 9, 0] = OUTPUT_3x3_ZERO_PAD[0, 9, -1] = -3.0 / 8.0
+
+TEST_CASE_0 = [IMAGE, {"kernel_size": 3, "dtype": torch.float32}, OUTPUT_3x3]
+TEST_CASE_1 = [IMAGE, {"kernel_size": 3, "dtype": torch.float64}, OUTPUT_3x3]
+TEST_CASE_2 = [IMAGE, {"kernel_size": 3, "spatial_axes": 0, "dtype": torch.float64}, OUTPUT_3x3[0:1]]
+TEST_CASE_3 = [IMAGE, {"kernel_size": 3, "spatial_axes": 1, "dtype": torch.float64}, OUTPUT_3x3[1:2]]
+TEST_CASE_4 = [IMAGE, {"kernel_size": 3, "spatial_axes": [1], "dtype": torch.float64}, OUTPUT_3x3[1:2]]
+TEST_CASE_5 = [
+    IMAGE,
+    {"kernel_size": 3, "spatial_axes": [0, 1], "normalize_kernels": True, "dtype": torch.float64},
+    OUTPUT_3x3,
+]
+TEST_CASE_6 = [
+    IMAGE,
+    {"kernel_size": 3, "spatial_axes": (0, 1), "padding_mode": "reflect", "dtype": torch.float64},
+    OUTPUT_3x3,
+]
+TEST_CASE_7 = [
+    IMAGE,
+    {"kernel_size": 3, "spatial_axes": (0, 1), "padding_mode": "zeros", "dtype": torch.float64},
+    OUTPUT_3x3_ZERO_PAD,
+]
+TEST_CASE_8 = [  # Non-normalized kernels
+    IMAGE,
+    {"kernel_size": 3, "normalize_kernels": False, "dtype": torch.float32},
+    OUTPUT_3x3 * 8.0,
+]
+TEST_CASE_9 = [  # Normalized gradients and normalized kernels
+    IMAGE,
+    {
+        "kernel_size": 3,
+        "normalize_kernels": True,
+        "normalize_gradients": True,
+        "spatial_axes": (0, 1),
+        "dtype": torch.float64,
+    },
+    torch.cat([OUTPUT_3x3[0:1] + 0.5, OUTPUT_3x3[1:2]]),
+]
+TEST_CASE_10 = [  # Normalized gradients but non-normalized kernels
+    IMAGE,
+    {
+        "kernel_size": 3,
+        "normalize_kernels": False,
+        "normalize_gradients": True,
+        "spatial_axes": (0, 1),
+        "dtype": torch.float64,
+    },
+    torch.cat([OUTPUT_3x3[0:1] + 0.5, OUTPUT_3x3[1:2]]),
+]
+
+TEST_CASE_KERNEL_0 = [
+    {"kernel_size": 3, "dtype": torch.float64},
+    (torch.tensor([-0.5, 0.0, 0.5], dtype=torch.float64), torch.tensor([0.25, 0.5, 0.25], dtype=torch.float64)),
+]
+TEST_CASE_KERNEL_1 = [
+    {"kernel_size": 5, "dtype": torch.float64},
+    (
+        torch.tensor([-0.1250, -0.2500, 0.0000, 0.2500, 0.1250], dtype=torch.float64),
+        torch.tensor([0.0625, 0.2500, 0.3750, 0.2500, 0.0625], dtype=torch.float64),
+    ),
+]
+TEST_CASE_KERNEL_2 = [
+    {"kernel_size": 7, "dtype": torch.float64},
+    (
+        torch.tensor([-0.03125, -0.125, -0.15625, 0.0, 0.15625, 0.125, 0.03125], dtype=torch.float64),
+        torch.tensor([0.015625, 0.09375, 0.234375, 0.3125, 0.234375, 0.09375, 0.015625], dtype=torch.float64),
+    ),
+]
+TEST_CASE_KERNEL_NON_NORMALIZED_0 = [
+    {"kernel_size": 3, "normalize_kernels": False, "dtype": torch.float64},
+    (torch.tensor([-1.0, 0.0, 1.0], dtype=torch.float64), torch.tensor([1.0, 2.0, 1.0], dtype=torch.float64)),
+]
+TEST_CASE_KERNEL_NON_NORMALIZED_1 = [
+    {"kernel_size": 5, "normalize_kernels": False, "dtype": torch.float64},
+    (
+        torch.tensor([-1.0, -2.0, 0.0, 2.0, 1.0], dtype=torch.float64),
+        torch.tensor([1.0, 4.0, 6.0, 4.0, 1.0], dtype=torch.float64),
+    ),
+]
+TEST_CASE_KERNEL_NON_NORMALIZED_2 = [
+    {"kernel_size": 7, "normalize_kernels": False, "dtype": torch.float64},
+    (
+        torch.tensor([-1.0, -4.0, -5.0, 0.0, 5.0, 4.0, 1.0], dtype=torch.float64),
+        torch.tensor([1.0, 6.0, 15.0, 20.0, 15.0, 6.0, 1.0], dtype=torch.float64),
+    ),
+]
+
+TEST_CASE_ERROR_0 = [IMAGE, {"kernel_size": 1}]  # kernel size less than 3
+TEST_CASE_ERROR_1 = [IMAGE, {"kernel_size": 4}]  # even kernel size
+TEST_CASE_ERROR_2 = [IMAGE, {"spatial_axes": "horizontal"}]  # wrong type direction
+TEST_CASE_ERROR_3 = [IMAGE, {"spatial_axes": 3}]  # wrong direction
+TEST_CASE_ERROR_4 = [IMAGE, {"spatial_axes": [3]}]  # wrong direction in a list
+TEST_CASE_ERROR_5 = [IMAGE, {"spatial_axes": [0, 4]}]  # correct and wrong direction in a list
+
+
+class SobelGradientTests(unittest.TestCase):
+    backend = None
+
+    @parameterized.expand(
+        [
+            TEST_CASE_0,
+            TEST_CASE_1,
+            TEST_CASE_2,
+            TEST_CASE_3,
+            TEST_CASE_4,
+            TEST_CASE_5,
+            TEST_CASE_6,
+            TEST_CASE_7,
+            TEST_CASE_8,
+            TEST_CASE_9,
+            TEST_CASE_10,
+        ]
+    )
+    def test_sobel_gradients(self, image, arguments, expected_grad):
+        sobel = SobelGradients(**arguments)
+        grad = sobel(image)
+        assert_allclose(grad, expected_grad)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_KERNEL_0,
+            TEST_CASE_KERNEL_1,
+            TEST_CASE_KERNEL_2,
+            TEST_CASE_KERNEL_NON_NORMALIZED_0,
+            TEST_CASE_KERNEL_NON_NORMALIZED_1,
+            TEST_CASE_KERNEL_NON_NORMALIZED_2,
+        ]
+    )
+    def test_sobel_kernels(self, arguments, expected_kernels):
+        sobel = SobelGradients(**arguments)
+        self.assertEqual(sobel.kernel_diff.dtype, expected_kernels[0].dtype)
+        self.assertEqual(sobel.kernel_smooth.dtype, expected_kernels[0].dtype)
+        assert_allclose(sobel.kernel_diff, expected_kernels[0])
+        assert_allclose(sobel.kernel_smooth, expected_kernels[1])
+
+    @parameterized.expand(
+        [
+            TEST_CASE_ERROR_0,
+            TEST_CASE_ERROR_1,
+            TEST_CASE_ERROR_2,
+            TEST_CASE_ERROR_3,
+            TEST_CASE_ERROR_4,
+            TEST_CASE_ERROR_5,
+        ]
+    )
+    def test_sobel_gradients_error(self, image, arguments):
+        with self.assertRaises(ValueError):
+            sobel = SobelGradients(**arguments)
+            sobel(image)
+
+
+if __name__ == "__main__":
+    unittest.main()