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

tests/transforms/test_scale_intensity_ranged.py

@@ -0,0 +1,40 @@
+# 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 monai.transforms import ScaleIntensityRanged
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class IntensityScaleIntensityRanged(NumpyImageTestCase2D):
+    def test_image_scale_intensity_ranged(self):
+        key = "img"
+        scaler = ScaleIntensityRanged(keys=key, a_min=20, a_max=108, b_min=50, b_max=80)
+        for p in TEST_NDARRAYS:
+            scaled = scaler({key: p(self.imt)})
+            expected = (self.imt - 20) / 88
+            expected = expected * 30 + 50
+            assert_allclose(scaled[key], p(expected), type_test="tensor")
+
+    def test_image_scale_intensity_ranged_none(self):
+        key = "img"
+        scaler = ScaleIntensityRanged(keys=key, a_min=20, a_max=108, b_min=None, b_max=None)
+        for p in TEST_NDARRAYS:
+            scaled = scaler({key: p(self.imt)})
+            expected = (self.imt - 20) / 88
+            assert_allclose(scaled[key], p(expected), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_scale_intensityd.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 monai.transforms import ScaleIntensityd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestScaleIntensityd(NumpyImageTestCase2D):
+    def test_range_scale(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensityd(keys=[key], minv=1.0, maxv=2.0)
+            result = scaler({key: p(self.imt)})
+            mina = np.min(self.imt)
+            maxa = np.max(self.imt)
+            norm = (self.imt - mina) / (maxa - mina)
+            expected = (norm * (2.0 - 1.0)) + 1.0
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+    def test_factor_scale(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensityd(keys=[key], minv=None, maxv=None, factor=0.1)
+            result = scaler({key: p(self.imt)})
+            expected = (self.imt * (1 + 0.1)).astype(np.float32)
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+    def test_channel_wise(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensityd(keys=[key], minv=1.0, maxv=2.0, channel_wise=True)
+            data = p(self.imt)
+            result = scaler({key: data})
+            mina = self.imt.min()
+            maxa = self.imt.max()
+            for i, c in enumerate(data):
+                norm = (c - mina) / (maxa - mina)
+                expected = p((norm * (2.0 - 1.0)) + 1.0)
+                assert_allclose(result[key][i], expected, type_test="tensor", rtol=1e-7, atol=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_select_itemsd.py

@@ -0,0 +1,41 @@
+# 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 SelectItemsd
+
+TEST_CASE_1 = [{"keys": [str(i) for i in range(30)]}, 30]
+
+
+class TestSelectItemsd(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1])
+    def test_memory(self, input_param, expected_key_size):
+        input_data = {}
+        for i in range(50):
+            input_data[str(i)] = [time.time()] * 100000
+        result = SelectItemsd(**input_param)(input_data)
+        self.assertEqual(len(result.keys()), expected_key_size)
+        self.assertSetEqual(set(result.keys()), set(input_param["keys"]))
+        self.assertGreaterEqual(
+            sys.getsizeof(input_data) * float(expected_key_size) / len(input_data), sys.getsizeof(result)
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_shift_intensity.py

@@ -0,0 +1,31 @@
+# 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 monai.transforms import ShiftIntensity
+from tests.test_utils import NumpyImageTestCase2D
+
+
+class TestShiftIntensity(NumpyImageTestCase2D):
+    def test_value(self):
+        shifter = ShiftIntensity(offset=1.0)
+        result = shifter(self.imt)
+        expected = self.imt + 1.0
+        np.testing.assert_allclose(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_shift_intensityd.py

@@ -0,0 +1,44 @@
+# 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 monai.transforms import IntensityStatsd, ShiftIntensityd
+from monai.utils.enums import PostFix
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestShiftIntensityd(NumpyImageTestCase2D):
+    def test_value(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            shifter = ShiftIntensityd(keys=[key], offset=1.0)
+            result = shifter({key: p(self.imt)})
+            expected = self.imt + 1.0
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+    def test_factor(self):
+        key = "img"
+        stats = IntensityStatsd(keys=key, ops="max", key_prefix="orig")
+        shifter = ShiftIntensityd(keys=[key], offset=1.0, factor_key=["orig_max"])
+        data = {key: self.imt, PostFix.meta(key): {"affine": None}}
+
+        result = shifter(stats(data))
+        expected = self.imt + 1.0 * np.nanmax(self.imt)
+        np.testing.assert_allclose(result[key], expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_continuouswavelet.py

@@ -0,0 +1,44 @@
+# 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 import SignalContinuousWavelet
+from monai.utils import optional_import
+
+_, has_pywt = optional_import("pywt")
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [("mexh", 150, 500)]
+EXPECTED_RESULTS = [(6, 150, 2000)]
+
+
+@skipUnless(has_pywt, "pywt required")
+class TestSignalContinousWavelet(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, type, length, frequency):
+        self.assertIsInstance(SignalContinuousWavelet(type, length, frequency), SignalContinuousWavelet)
+        sig = np.load(TEST_SIGNAL)
+        cwt = SignalContinuousWavelet(type, length, frequency)
+        cwtsignal = cwt(sig)
+        self.assertEqual(cwtsignal.shape, EXPECTED_RESULTS[0])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_fillempty.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
+import torch
+
+from monai.transforms import SignalFillEmpty
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+
+
+@SkipIfBeforePyTorchVersion((1, 9))
+class TestSignalFillEmptyNumpy(unittest.TestCase):
+    def test_correct_parameters_multi_channels(self):
+        self.assertIsInstance(SignalFillEmpty(replacement=0.0), SignalFillEmpty)
+        sig = np.load(TEST_SIGNAL)
+        sig[:, 123] = np.nan
+        fillempty = SignalFillEmpty(replacement=0.0)
+        fillemptysignal = fillempty(sig)
+        self.assertTrue(not np.isnan(fillemptysignal).any())
+
+
+@SkipIfBeforePyTorchVersion((1, 9))
+class TestSignalFillEmptyTorch(unittest.TestCase):
+    def test_correct_parameters_multi_channels(self):
+        self.assertIsInstance(SignalFillEmpty(replacement=0.0), SignalFillEmpty)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        sig[:, 123] = convert_to_tensor(np.nan)
+        fillempty = SignalFillEmpty(replacement=0.0)
+        fillemptysignal = fillempty(sig)
+        self.assertTrue(not torch.isnan(fillemptysignal).any())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_fillemptyd.py

@@ -0,0 +1,60 @@
+# 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
+import torch
+
+from monai.transforms import SignalFillEmptyd
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+
+
+@SkipIfBeforePyTorchVersion((1, 9))
+class TestSignalFillEmptyNumpy(unittest.TestCase):
+    def test_correct_parameters_multi_channels(self):
+        self.assertIsInstance(SignalFillEmptyd(replacement=0.0), SignalFillEmptyd)
+        sig = np.load(TEST_SIGNAL)
+        sig[:, 123] = np.nan
+        data = {}
+        data["signal"] = sig
+        fillempty = SignalFillEmptyd(keys=("signal",), replacement=0.0)
+        data_ = fillempty(data)
+
+        self.assertTrue(np.isnan(sig).any())
+        self.assertTrue(not np.isnan(data_["signal"]).any())
+
+
+@SkipIfBeforePyTorchVersion((1, 9))
+class TestSignalFillEmptyTorch(unittest.TestCase):
+    def test_correct_parameters_multi_channels(self):
+        self.assertIsInstance(SignalFillEmptyd(replacement=0.0), SignalFillEmptyd)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        sig[:, 123] = convert_to_tensor(np.nan)
+        data = {}
+        data["signal"] = sig
+        fillempty = SignalFillEmptyd(keys=("signal",), replacement=0.0)
+        data_ = fillempty(data)
+
+        self.assertTrue(np.isnan(sig).any())
+        self.assertTrue(not torch.isnan(data_["signal"]).any())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_add_gaussiannoise.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 SignalRandAddGaussianNoise
+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, 0.02],)]
+
+
+class TestSignalRandAddGaussianNoiseNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandAddGaussianNoise(boundaries), SignalRandAddGaussianNoise)
+        sig = np.load(TEST_SIGNAL)
+        gaussian = SignalRandAddGaussianNoise(boundaries)
+        gaussiansignal = gaussian(sig)
+        self.assertEqual(gaussiansignal.shape[1], sig.shape[1])
+
+
+class TestSignalRandAddGaussianNoiseTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries):
+        self.assertIsInstance(SignalRandAddGaussianNoise(boundaries), SignalRandAddGaussianNoise)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        gaussian = SignalRandAddGaussianNoise(boundaries)
+        gaussiansignal = gaussian(sig)
+        self.assertEqual(gaussiansignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_add_sine.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 SignalRandAddSine
+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.0, 0.5]), ([0.0, 1.0], [0.01, 0.1])]
+
+
+class TestSignalRandAddSineNumpy(unittest.TestCase):
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, freqs):
+        self.assertIsInstance(SignalRandAddSine(boundaries, freqs), SignalRandAddSine)
+        sig = np.load(TEST_SIGNAL)
+        sine = SignalRandAddSine(boundaries, freqs)
+        sinesignal = sine(sig)
+        self.assertEqual(sinesignal.shape[1], sig.shape[1])
+
+
+class TestSignalRandAddSineTorch(unittest.TestCase):
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, freqs):
+        self.assertIsInstance(SignalRandAddSine(boundaries, freqs), SignalRandAddSine)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        sine = SignalRandAddSine(boundaries, freqs)
+        sinesignal = sine(sig)
+        self.assertEqual(sinesignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_add_sine_partial.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 SignalRandAddSinePartial
+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.1, 0.6], [0.0, 0.4])]
+
+
+class TestSignalRandAddSinePartialNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies, fraction):
+        self.assertIsInstance(SignalRandAddSinePartial(boundaries, frequencies, fraction), SignalRandAddSinePartial)
+        sig = np.load(TEST_SIGNAL)
+        partialsine = SignalRandAddSinePartial(boundaries, frequencies, fraction)
+        partialsinesignal = partialsine(sig)
+        self.assertEqual(partialsinesignal.shape[1], sig.shape[1])
+
+
+class TestSignalRandAddSinePartialTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies, fraction):
+        self.assertIsInstance(SignalRandAddSinePartial(boundaries, frequencies, fraction), SignalRandAddSinePartial)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        partialsine = SignalRandAddSinePartial(boundaries, frequencies, fraction)
+        partialsinesignal = partialsine(sig)
+        self.assertEqual(partialsinesignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_add_squarepulse.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 os
+import unittest
+from pathlib import Path
+from unittest import skipUnless
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import SignalRandAddSquarePulse
+from monai.utils import optional_import
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+_, has_scipy = optional_import("scipy")
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [([0.0, 1.0], [0.001, 0.2])]
+
+
+@skipUnless(has_scipy, "scipy required")
+@SkipIfBeforePyTorchVersion((1, 10, 1))
+class TestSignalRandAddSquarePulseNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies):
+        self.assertIsInstance(SignalRandAddSquarePulse(boundaries, frequencies), SignalRandAddSquarePulse)
+        sig = np.load(TEST_SIGNAL)
+        squared = SignalRandAddSquarePulse(boundaries, frequencies)
+        squaredsignal = squared(sig)
+        self.assertEqual(squaredsignal.shape[1], sig.shape[1])
+
+
+@skipUnless(has_scipy, "scipy required")
+@SkipIfBeforePyTorchVersion((1, 10, 1))
+class TestSignalRandAddSquarePulseTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies):
+        self.assertIsInstance(SignalRandAddSquarePulse(boundaries, frequencies), SignalRandAddSquarePulse)
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        squared = SignalRandAddSquarePulse(boundaries, frequencies)
+        squaredsignal = squared(sig)
+        self.assertEqual(squaredsignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_signal_rand_add_squarepulse_partial.py

@@ -0,0 +1,62 @@
+# 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 import SignalRandAddSquarePulsePartial
+from monai.utils import optional_import
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+_, has_scipy = optional_import("scipy")
+TESTS_PATH = Path(__file__).parents[1]
+TEST_SIGNAL = os.path.join(TESTS_PATH, "testing_data", "signal.npy")
+VALID_CASES = [([0.0, 1.0], [0.001, 0.2], [0.0, 0.4])]
+
+
+@skipUnless(has_scipy, "scipy required")
+@SkipIfBeforePyTorchVersion((1, 10, 1))
+class TestSignalRandAddSquarePulsePartialNumpy(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies, fraction):
+        self.assertIsInstance(
+            SignalRandAddSquarePulsePartial(boundaries, frequencies, fraction), SignalRandAddSquarePulsePartial
+        )
+        sig = np.load(TEST_SIGNAL)
+        partialsquare = SignalRandAddSquarePulsePartial(boundaries, frequencies, fraction)
+        partialsquaresignal = partialsquare(sig)
+        self.assertEqual(partialsquaresignal.shape[1], sig.shape[1])
+
+
+@skipUnless(has_scipy, "scipy required")
+@SkipIfBeforePyTorchVersion((1, 10, 1))
+class TestSignalRandAddSquarePulsePartialTorch(unittest.TestCase):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_parameters_multi_channels(self, boundaries, frequencies, fraction):
+        self.assertIsInstance(
+            SignalRandAddSquarePulsePartial(boundaries, frequencies, fraction), SignalRandAddSquarePulsePartial
+        )
+        sig = convert_to_tensor(np.load(TEST_SIGNAL))
+        partialsquare = SignalRandAddSquarePulsePartial(boundaries, frequencies, fraction)
+        partialsquaresignal = partialsquare(sig)
+        self.assertEqual(partialsquaresignal.shape[1], sig.shape[1])
+
+
+if __name__ == "__main__":
+    unittest.main()