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

tests/transforms/test_data_stats.py

@@ -0,0 +1,221 @@
+# 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 logging
+import os
+import sys
+import tempfile
+import unittest
+from io import StringIO
+from unittest.mock import patch
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import DataStats
+
+TEST_CASE_1 = [
+    {
+        "prefix": "test data",
+        "data_type": False,
+        "data_shape": False,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:",
+]
+
+TEST_CASE_2 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": False,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'>",
+]
+
+TEST_CASE_3 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)",
+]
+
+TEST_CASE_4 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\nValue range: (0, 2)",
+]
+
+TEST_CASE_5 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\nValue range: (0, 2)\nValue: [[0 1]\n [1 2]]",
+]
+
+TEST_CASE_6 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": np.mean,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    (
+        "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\n"
+        "Value range: (0, 2)\nValue: [[0 1]\n [1 2]]\nAdditional info: 1.0"
+    ),
+]
+
+TEST_CASE_7 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": lambda x: torch.mean(x.float()),
+        "name": "DataStats",
+    },
+    torch.tensor([[0, 1], [1, 2]]).to("cuda" if torch.cuda.is_available() else "cpu"),
+    (
+        "test data statistics:\nType: <class 'torch.Tensor'>\nShape: torch.Size([2, 2])\nValue range: (0, 2)\n"
+        "Value: tensor([[0, 1],\n        [1, 2]])\nAdditional info: 1.0"
+    ),
+]
+
+TEST_CASE_8 = [
+    {
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": np.mean,
+        "name": "DataStats",
+    },
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'> int64\nShape: (2, 2)\nValue range: (0, 2)\n"
+    "Value: [[0 1]\n [1 2]]\nAdditional info: 1.0\n",
+]
+
+TEST_CASE_9 = [
+    np.array([[0, 1], [1, 2]]),
+    "test data statistics:\nType: <class 'numpy.ndarray'> int64\nShape: (2, 2)\nValue range: (0, 2)\n"
+    "Value: [[0 1]\n [1 2]]\n"
+    "Meta info: '(input is not a MetaTensor)'\n"
+    "Additional info: 1.0\n",
+]
+
+TEST_CASE_10 = [
+    MetaTensor(
+        torch.tensor([[0, 1], [1, 2]]),
+        affine=torch.as_tensor([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 1]], dtype=torch.float64),
+        meta={"some": "info"},
+    ),
+    "test data statistics:\nType: <class 'monai.data.meta_tensor.MetaTensor'> torch.int64\n"
+    "Shape: torch.Size([2, 2])\nValue range: (0, 2)\n"
+    "Value: tensor([[0, 1],\n        [1, 2]])\n"
+    "Meta info: {'some': 'info', affine: tensor([[2., 0., 0., 0.],\n"
+    "        [0., 2., 0., 0.],\n"
+    "        [0., 0., 2., 0.],\n"
+    "        [0., 0., 0., 1.]], dtype=torch.float64), space: RAS}\n"
+    "Additional info: 1.0\n",
+]
+
+
+class TestDataStats(unittest.TestCase):
+
+    @parameterized.expand(
+        [TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7, TEST_CASE_8]
+    )
+    def test_value(self, input_param, input_data, expected_print):
+        transform = DataStats(**input_param)
+        _ = transform(input_data)
+
+    @parameterized.expand([TEST_CASE_9, TEST_CASE_10])
+    def test_file(self, input_data, expected_print):
+        with tempfile.TemporaryDirectory() as tempdir:
+            filename = os.path.join(tempdir, "test_data_stats.log")
+            handler = logging.FileHandler(filename, mode="w")
+            handler.setLevel(logging.INFO)
+            name = "DataStats"
+            logger = logging.getLogger(name)
+            logger.addHandler(handler)
+            input_param = {
+                "prefix": "test data",
+                "data_type": True,
+                "data_shape": True,
+                "value_range": True,
+                "data_value": True,
+                "meta_info": True,
+                "additional_info": np.mean,
+                "name": name,
+            }
+            transform = DataStats(**input_param)
+            _ = transform(input_data)
+            for h in logger.handlers[:]:
+                h.close()
+                logger.removeHandler(h)
+            with open(filename) as f:
+                content = f.read()
+            if sys.platform != "win32":
+                self.assertEqual(content, expected_print)
+
+    def test_multiple_data_stats(self):
+        with patch("sys.stdout", new=StringIO()) as out:
+            input_data = np.array([[0, 1], [1, 2]])
+            transform = DataStats()
+            _ = DataStats()
+            _ = transform(input_data)
+            print(out.getvalue().strip())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_data_statsd.py

@@ -0,0 +1,249 @@
+# 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 logging
+import os
+import sys
+import tempfile
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import DataStatsd
+
+TEST_CASE_1 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": False,
+        "data_shape": False,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:",
+]
+
+TEST_CASE_2 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": False,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'>",
+]
+
+TEST_CASE_3 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": False,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)",
+]
+
+TEST_CASE_4 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": False,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\nValue range: (0, 2)",
+]
+
+TEST_CASE_5 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": None,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\nValue range: (0, 2)\nValue: [[0 1]\n [1 2]]",
+]
+
+TEST_CASE_6 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": np.mean,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    (
+        "test data statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\n"
+        "Value range: (0, 2)\nValue: [[0 1]\n [1 2]]\nAdditional info: 1.0"
+    ),
+]
+
+TEST_CASE_7 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_type": True,
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "additional_info": lambda x: torch.mean(x.float()),
+        "name": "DataStats",
+    },
+    {"img": torch.tensor([[0, 1], [1, 2]]).to("cuda" if torch.cuda.is_available() else "cpu")},
+    (
+        "test data statistics:\nType: <class 'torch.Tensor'>\nShape: torch.Size([2, 2])\nValue range: (0, 2)\n"
+        "Value: tensor([[0, 1],\n        [1, 2]])\nAdditional info: 1.0"
+    ),
+]
+
+TEST_CASE_8 = [
+    {
+        "keys": ("img", "affine"),
+        "prefix": ("image", "affine"),
+        "data_type": True,
+        "data_shape": True,
+        "value_range": (True, False),
+        "data_value": (False, True),
+        "additional_info": (np.mean, None),
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]]), "affine": np.eye(2, 2)},
+    "affine statistics:\nType: <class 'numpy.ndarray'>\nShape: (2, 2)\nValue: [[1. 0.]\n [0. 1.]]",
+]
+
+TEST_CASE_9 = [
+    {
+        "keys": "img",
+        "prefix": "test data",
+        "data_shape": True,
+        "value_range": True,
+        "data_value": True,
+        "meta_info": False,
+        "additional_info": np.mean,
+        "name": "DataStats",
+    },
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'> int64\nShape: (2, 2)\nValue range: (0, 2)\n"
+    "Value: [[0 1]\n [1 2]]\nAdditional info: 1.0\n",
+]
+
+TEST_CASE_10 = [
+    {"img": np.array([[0, 1], [1, 2]])},
+    "test data statistics:\nType: <class 'numpy.ndarray'> int64\nShape: (2, 2)\nValue range: (0, 2)\n"
+    "Value: [[0 1]\n [1 2]]\n"
+    "Meta info: '(input is not a MetaTensor)'\n"
+    "Additional info: 1.0\n",
+]
+
+TEST_CASE_11 = [
+    {
+        "img": (
+            MetaTensor(
+                torch.tensor([[0, 1], [1, 2]]),
+                affine=torch.as_tensor([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 1]], dtype=torch.float64),
+                meta={"some": "info"},
+            )
+        )
+    },
+    "test data statistics:\nType: <class 'monai.data.meta_tensor.MetaTensor'> torch.int64\n"
+    "Shape: torch.Size([2, 2])\nValue range: (0, 2)\n"
+    "Value: tensor([[0, 1],\n        [1, 2]])\n"
+    "Meta info: {'some': 'info', affine: tensor([[2., 0., 0., 0.],\n"
+    "        [0., 2., 0., 0.],\n"
+    "        [0., 0., 2., 0.],\n"
+    "        [0., 0., 0., 1.]], dtype=torch.float64), space: RAS}\n"
+    "Additional info: 1.0\n",
+]
+
+
+class TestDataStatsd(unittest.TestCase):
+
+    @parameterized.expand(
+        [
+            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,
+        ]
+    )
+    def test_value(self, input_param, input_data, expected_print):
+        transform = DataStatsd(**input_param)
+        _ = transform(input_data)
+
+    @parameterized.expand([TEST_CASE_10, TEST_CASE_11])
+    def test_file(self, input_data, expected_print):
+        with tempfile.TemporaryDirectory() as tempdir:
+            filename = os.path.join(tempdir, "test_stats.log")
+            handler = logging.FileHandler(filename, mode="w")
+            handler.setLevel(logging.INFO)
+            name = "DataStats"
+            logger = logging.getLogger(name)
+            logger.addHandler(handler)
+            input_param = {
+                "keys": "img",
+                "prefix": "test data",
+                "data_shape": True,
+                "value_range": True,
+                "data_value": True,
+                "meta_info": True,
+                "additional_info": np.mean,
+                "name": name,
+            }
+            transform = DataStatsd(**input_param)
+            _ = transform(input_data)
+            for h in logger.handlers[:]:
+                h.close()
+                logger.removeHandler(h)
+            del handler
+            with open(filename) as f:
+                content = f.read()
+            if sys.platform != "win32":
+                self.assertEqual(content, expected_print)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_delete_itemsd.py

@@ -0,0 +1,58 @@
+# 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 sys
+import time
+import unittest
+
+from parameterized import parameterized
+
+from monai.transforms import DeleteItemsd
+from monai.utils.enums import PostFix
+
+TEST_CASE_1 = [{"keys": [str(i) for i in range(30)]}, 20]
+
+TEST_CASE_2 = [{"keys": ["image/" + str(i) for i in range(30)], "sep": "/"}, 20]
+
+TEST_CASE_3 = [{"keys": "meta_dict%0008\\|[0-9]", "sep": "%", "use_re": True}]
+
+
+class TestDeleteItemsd(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_memory(self, input_param, expected_key_size):
+        input_data = {"image": {}} if "sep" in input_param else {}
+        for i in range(50):
+            if "sep" in input_param:
+                input_data["image"][str(i)] = [time.time()] * 100000
+            else:
+                input_data[str(i)] = [time.time()] * 100000
+        result = DeleteItemsd(**input_param)(input_data)
+        if "sep" in input_param:
+            self.assertEqual(len(result["image"].keys()), expected_key_size)
+        else:
+            self.assertEqual(len(result.keys()), expected_key_size)
+        self.assertGreaterEqual(
+            sys.getsizeof(input_data) * float(expected_key_size) / len(input_data), sys.getsizeof(result)
+        )
+
+    @parameterized.expand([TEST_CASE_3])
+    def test_re(self, input_param):
+        input_data = {"image": [1, 2, 3], PostFix.meta(): {"0008|0005": 1, "0008|1050": 2, "0008test": 3}}
+        result = DeleteItemsd(**input_param)(input_data)
+        self.assertEqual(result[PostFix.meta()]["0008test"], 3)
+        self.assertEqual(len(result[PostFix.meta()]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_detect_envelope.py

@@ -0,0 +1,159 @@
+# 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 DetectEnvelope
+from monai.utils import OptionalImportError
+from tests.test_utils import TEST_NDARRAYS, SkipIfModule, SkipIfNoModule, assert_allclose
+
+n_samples = 500
+hann_windowed_sine = np.sin(2 * np.pi * 10 * np.linspace(0, 1, n_samples)) * np.hanning(n_samples)
+
+# SINGLE-CHANNEL VALUE TESTS
+# using np.expand_dims() to add length 1 channel dimension at dimension 0
+
+TEST_CASE_1D_SINE = [
+    {},  # args (empty, so use default)
+    np.expand_dims(hann_windowed_sine, 0),  # Input data: Hann windowed sine wave
+    np.expand_dims(np.hanning(n_samples), 0),  # Expected output: the Hann window
+    1e-4,  # absolute tolerance
+]
+
+TEST_CASE_2D_SINE = [
+    {},  # args (empty, so use default (i.e. process along first spatial dimension, axis=1)
+    # Create 10 identical windowed sine waves as a 2D numpy array
+    np.expand_dims(np.stack([hann_windowed_sine] * 10, axis=1), 0),
+    # Expected output: Set of 10 identical Hann windows
+    np.expand_dims(np.stack([np.hanning(n_samples)] * 10, axis=1), 0),
+    1e-4,  # absolute tolerance
+]
+
+TEST_CASE_3D_SINE = [
+    {},  # args (empty, so use default (i.e. process along first spatial dimension, axis=1)
+    # Create 100 identical windowed sine waves as a (n_samples x 10 x 10) 3D numpy array
+    np.expand_dims(np.stack([np.stack([hann_windowed_sine] * 10, axis=1)] * 10, axis=2), 0),
+    # Expected output: Set of 100 identical Hann windows in (n_samples x 10 x 10) 3D numpy array
+    np.expand_dims(np.stack([np.stack([np.hanning(n_samples)] * 10, axis=1)] * 10, axis=2), 0),
+    1e-4,  # absolute tolerance
+]
+
+TEST_CASE_2D_SINE_AXIS_1 = [
+    {"axis": 2},  # set axis argument to 1
+    # Create 10 identical windowed sine waves as a 2D numpy array
+    np.expand_dims(np.stack([hann_windowed_sine] * 10, axis=1), 0),
+    # Expected output: absolute value of each sample of the waveform, repeated (i.e. flat envelopes)
+    np.expand_dims(np.abs(np.repeat(hann_windowed_sine, 10).reshape((n_samples, 10))), 0),
+    1e-4,  # absolute tolerance
+]
+
+TEST_CASE_1D_SINE_PADDING_N = [
+    {"n": 512},  # args (empty, so use default)
+    np.expand_dims(hann_windowed_sine, 0),  # Input data: Hann windowed sine wave
+    np.expand_dims(np.concatenate([np.hanning(500), np.zeros(12)]), 0),  # Expected output: the Hann window
+    1e-3,  # absolute tolerance
+]
+
+# MULTI-CHANNEL VALUE TEST
+
+TEST_CASE_2_CHAN_3D_SINE = [
+    {},  # args (empty, so use default (i.e. process along first spatial dimension, axis=1)
+    # Create 100 identical windowed sine waves as a (n_samples x 10 x 10) 3D numpy array, twice (2 channels)
+    torch.as_tensor(np.stack([np.stack([np.stack([hann_windowed_sine] * 10, axis=1)] * 10, axis=2)] * 2, axis=0)),
+    # Expected output: Set of 100 identical Hann windows in (n_samples x 10 x 10) 3D numpy array, twice (2 channels)
+    torch.as_tensor(np.stack([np.stack([np.stack([np.hanning(n_samples)] * 10, axis=1)] * 10, axis=2)] * 2, axis=0)),
+    1e-4,  # absolute tolerance
+]
+
+# EXCEPTION TESTS
+
+TEST_CASE_INVALID_AXIS_1 = [
+    {"axis": 3},  # set axis argument to 3 when only 3 dimensions (1 channel + 2 spatial)
+    np.expand_dims(np.stack([hann_windowed_sine] * 10, axis=1), 0),  # Create 2D dataset
+    "__call__",  # method expected to raise exception
+]
+
+TEST_CASE_INVALID_AXIS_2 = [
+    {"axis": -1},  # set axis argument negative
+    np.expand_dims(np.stack([hann_windowed_sine] * 10, axis=1), 0),  # Create 2D dataset
+    "__init__",  # method expected to raise exception
+]
+
+TEST_CASE_INVALID_N = [
+    {"n": 0},  # set FFT length to zero
+    np.expand_dims(np.stack([hann_windowed_sine] * 10, axis=1), 0),  # Create 2D dataset
+    "__call__",  # method expected to raise exception
+]
+
+TEST_CASE_INVALID_DTYPE = [
+    {},
+    np.expand_dims(np.array(hann_windowed_sine, dtype=complex), 0),  # complex numbers are invalid
+    "__call__",  # method expected to raise exception
+]
+
+TEST_CASE_INVALID_IMG_LEN = [
+    {},
+    np.expand_dims(np.array([]), 0),  # empty array is invalid
+    "__call__",  # method expected to raise exception
+]
+
+TEST_CASE_INVALID_OBJ = [{}, "a string", "__call__"]  # method expected to raise exception
+
+
+@SkipIfNoModule("torch.fft")
+class TestDetectEnvelope(unittest.TestCase):
+    @parameterized.expand(
+        [
+            TEST_CASE_1D_SINE,
+            TEST_CASE_2D_SINE,
+            TEST_CASE_3D_SINE,
+            TEST_CASE_2D_SINE_AXIS_1,
+            TEST_CASE_1D_SINE_PADDING_N,
+            TEST_CASE_2_CHAN_3D_SINE,
+        ]
+    )
+    def test_value(self, arguments, image, expected_data, atol):
+        for p in TEST_NDARRAYS:
+            result = DetectEnvelope(**arguments)(p(image))
+            assert_allclose(result, p(expected_data), atol=atol, type_test="tensor")
+
+    @parameterized.expand(
+        [
+            TEST_CASE_INVALID_AXIS_1,
+            TEST_CASE_INVALID_AXIS_2,
+            TEST_CASE_INVALID_N,
+            TEST_CASE_INVALID_DTYPE,
+            TEST_CASE_INVALID_IMG_LEN,
+        ]
+    )
+    def test_value_error(self, arguments, image, method):
+        if method == "__init__":
+            self.assertRaises(ValueError, DetectEnvelope, **arguments)
+        elif method == "__call__":
+            self.assertRaises(ValueError, DetectEnvelope(**arguments), image)
+        else:
+            self.fail("Expected raising method invalid. Should be __init__ or __call__.")
+
+
+@SkipIfModule("torch.fft")
+class TestHilbertTransformNoFFTMod(unittest.TestCase):
+    def test_no_fft_module_error(self):
+        self.assertRaises(OptionalImportError, DetectEnvelope(), np.random.rand(1, 10))
+
+
+if __name__ == "__main__":
+    unittest.main()