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

tests/transforms/test_save_classificationd.py

@@ -0,0 +1,109 @@
+# 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 csv
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from monai.data import CSVSaver, decollate_batch
+from monai.transforms import Compose, CopyItemsd, SaveClassificationd
+from monai.utils.enums import PostFix
+
+
+class TestSaveClassificationd(unittest.TestCase):
+
+    def test_saved_content(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            data = [
+                {
+                    "pred": torch.zeros(8),
+                    PostFix.meta("image"): {"filename_or_obj": ["testfile" + str(i) for i in range(8)]},
+                },
+                {
+                    "pred": torch.zeros(8),
+                    PostFix.meta("image"): {"filename_or_obj": ["testfile" + str(i) for i in range(8, 16)]},
+                },
+                {
+                    "pred": torch.zeros(8),
+                    PostFix.meta("image"): {"filename_or_obj": ["testfile" + str(i) for i in range(16, 24)]},
+                },
+            ]
+
+            saver = CSVSaver(
+                output_dir=Path(tempdir), filename="predictions2.csv", overwrite=False, flush=False, delimiter="\t"
+            )
+            # set up test transforms
+            post_trans = Compose(
+                [
+                    CopyItemsd(keys=PostFix.meta("image"), times=1, names=PostFix.meta("pred")),
+                    # 1st saver saves data into CSV file
+                    SaveClassificationd(
+                        keys="pred",
+                        saver=None,
+                        meta_keys=None,
+                        output_dir=Path(tempdir),
+                        filename="predictions1.csv",
+                        delimiter="\t",
+                        overwrite=True,
+                    ),
+                    # 2rd saver only saves data into the cache, manually finalize later
+                    SaveClassificationd(keys="pred", saver=saver, meta_key_postfix=PostFix.meta()),
+                ]
+            )
+            # simulate inference 2 iterations
+            d = decollate_batch(data[0])
+            for i in d:
+                post_trans(i)
+            d = decollate_batch(data[1])
+            for i in d:
+                post_trans(i)
+            # write into CSV file
+            saver.finalize()
+
+            # 3rd saver will not delete previous data due to `overwrite=False`
+            trans2 = SaveClassificationd(
+                keys="pred",
+                saver=None,
+                meta_keys=PostFix.meta("image"),  # specify meta key, so no need to copy anymore
+                output_dir=tempdir,
+                filename="predictions1.csv",
+                delimiter="\t",
+                overwrite=False,
+            )
+            d = decollate_batch(data[2])
+            for i in d:
+                trans2(i)
+
+            def _test_file(filename, count):
+                filepath = os.path.join(tempdir, filename)
+                self.assertTrue(os.path.exists(filepath))
+                with open(filepath) as f:
+                    reader = csv.reader(f, delimiter="\t")
+                    i = 0
+                    for row in reader:
+                        self.assertEqual(row[0], "testfile" + str(i))
+                        self.assertEqual(np.array(row[1:]).astype(np.float32), 0.0)
+                        i += 1
+                    self.assertEqual(i, count)
+
+            _test_file("predictions1.csv", 24)
+            _test_file("predictions2.csv", 16)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_save_image.py

@@ -0,0 +1,80 @@
+# 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 tempfile
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import SaveImage
+from monai.utils import optional_import
+
+_, has_itk = optional_import("itk", allow_namespace_pkg=True)
+
+TEST_CASE_1 = [torch.randint(0, 255, (1, 2, 3, 4)), {"filename_or_obj": "testfile0.nii.gz"}, ".nii.gz", False]
+
+TEST_CASE_2 = [torch.randint(0, 255, (1, 2, 3, 4)), None, ".nii.gz", False]
+
+TEST_CASE_3 = [torch.randint(0, 255, (1, 2, 3, 4)), {"filename_or_obj": "testfile0.nrrd"}, ".nrrd", False]
+
+TEST_CASE_4 = [
+    torch.randint(0, 255, (3, 2, 4, 5), dtype=torch.uint8),
+    {"filename_or_obj": "testfile0.dcm"},
+    ".dcm",
+    False,
+]
+
+TEST_CASE_5 = [torch.randint(0, 255, (3, 2, 4, 5), dtype=torch.uint8), ".dcm", False]
+
+
+@unittest.skipUnless(has_itk, "itk not installed")
+class TestSaveImage(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
+    def test_saved_content(self, test_data, meta_data, output_ext, resample):
+        if meta_data is not None:
+            test_data = MetaTensor(test_data, meta=meta_data)
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            trans = SaveImage(
+                output_dir=tempdir,
+                output_ext=output_ext,
+                resample=resample,
+                separate_folder=False,  # test saving into the same folder
+                output_name_formatter=lambda x, xform: dict(subject=x["filename_or_obj"] if x else "0"),
+            )
+            trans(test_data)
+
+            filepath = "testfile0" if meta_data is not None else "0"
+            self.assertTrue(os.path.exists(os.path.join(tempdir, filepath + "_trans" + output_ext)))
+
+    @parameterized.expand([TEST_CASE_5])
+    def test_saved_content_with_filename(self, test_data, output_ext, resample):
+        with tempfile.TemporaryDirectory() as tempdir:
+            trans = SaveImage(
+                output_dir=tempdir,
+                output_ext=output_ext,
+                resample=resample,
+                separate_folder=False,  # test saving into the same folder
+            )
+            filename = str(os.path.join(tempdir, "test"))
+            trans(test_data, filename=filename)
+
+            self.assertTrue(os.path.exists(filename + output_ext))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_save_imaged.py

@@ -0,0 +1,130 @@
+# 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 tempfile
+import unittest
+from pathlib import Path
+
+import torch
+from parameterized import parameterized
+
+from monai.config import PathLike
+from monai.data.folder_layout import FolderLayoutBase
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import SaveImaged
+from monai.utils import optional_import
+
+_, has_itk = optional_import("itk", allow_namespace_pkg=True)
+
+TEST_CASE_1 = [
+    {"img": MetaTensor(torch.randint(0, 255, (1, 2, 3, 4)), meta={"filename_or_obj": "testfile0.nii.gz"})},
+    ".nii.gz",
+    False,
+]
+
+TEST_CASE_2 = [
+    {
+        "img": MetaTensor(torch.randint(0, 255, (1, 2, 3, 4)), meta={"filename_or_obj": "testfile0.nii.gz"}),
+        "patch_index": 6,
+    },
+    ".nii.gz",
+    False,
+]
+
+TEST_CASE_3 = [
+    {
+        "img": MetaTensor(torch.randint(0, 255, (1, 2, 3, 4)), meta={"filename_or_obj": "testfile0.nrrd"}),
+        "patch_index": 6,
+    },
+    ".nrrd",
+    False,
+]
+
+
+@unittest.skipUnless(has_itk, "itk not installed")
+class TestSaveImaged(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_saved_content(self, test_data, output_ext, resample):
+        with tempfile.TemporaryDirectory() as tempdir:
+            trans = SaveImaged(
+                keys=["img", "pred"],
+                output_dir=tempdir,
+                output_ext=output_ext,
+                resample=resample,
+                allow_missing_keys=True,
+            )
+            trans(test_data)
+
+            patch_index = test_data["img"].meta.get("patch_index", None)
+            patch_index = f"_{patch_index}" if patch_index is not None else ""
+            filepath = os.path.join("testfile0", "testfile0" + "_trans" + patch_index + output_ext)
+            self.assertTrue(os.path.exists(os.path.join(tempdir, filepath)))
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_custom_folderlayout(self, test_data, output_ext, resample):
+
+        class TestFolderLayout(FolderLayoutBase):
+
+            def __init__(self, basepath: Path, extension: str, makedirs: bool):
+                self.basepath = basepath
+                self.ext = extension
+                self.makedirs = makedirs
+
+            def filename(self, **kwargs) -> PathLike:
+                p = self.basepath / str(kwargs["subdirectory"])
+                if not p.exists() and self.makedirs:
+                    p.mkdir()
+
+                return p / (str(kwargs["filename"]) + self.ext)
+
+        def name_formatter(metadict: dict, _) -> dict:
+            # "[filename].[ext]"
+            # quick and dirty split on .
+            base_filename = metadict["filename_or_obj"].split(".")[0]
+
+            return {"subdirectory": base_filename, "filename": "image"}
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            trans = SaveImaged(
+                keys=["img", "pred"],
+                resample=resample,
+                allow_missing_keys=True,
+                output_name_formatter=name_formatter,
+                folder_layout=TestFolderLayout(basepath=Path(tempdir), extension=output_ext, makedirs=True),
+            )
+            trans(test_data)
+
+            filepath = os.path.join("testfile0", "image" + output_ext)
+            self.assertTrue(os.path.exists(os.path.join(tempdir, filepath)))
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_includes_metadata(self, test_data, output_ext, resample):
+        with tempfile.TemporaryDirectory() as tempdir:
+            trans = SaveImaged(
+                keys=["img", "pred"],
+                output_dir=tempdir,
+                output_ext=output_ext,
+                resample=resample,
+                allow_missing_keys=True,
+                savepath_in_metadict=True,
+            )
+            trans(test_data)
+
+            self.assertTrue("saved_to" in test_data["img"].meta.keys())
+            self.assertTrue(os.path.exists(test_data["img"].meta["saved_to"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_savitzky_golay_smooth.py

@@ -0,0 +1,73 @@
+# 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 SavitzkyGolaySmooth
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+# Zero-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE = [
+    {"window_length": 3, "order": 1},
+    np.expand_dims(np.array([1.0]), 0),  # Input data: Single value
+    np.expand_dims(np.array([1 / 3]), 0),  # Expected output: With a window length of 3 and polyorder 1
+    # output should be equal to mean of 0, 1 and 0 = 1/3 (because input will be zero-padded and a linear fit performed)
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_2 = [
+    {"window_length": 3, "order": 1, "axis": 2},  # along axis 2 (second spatial dim)
+    np.expand_dims(np.ones((2, 3)), 0),
+    np.expand_dims(np.array([[2 / 3, 1.0, 2 / 3], [2 / 3, 1.0, 2 / 3]]), 0),
+    1e-5,  # absolute tolerance
+]
+
+# Replicated-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE_REP = [
+    {"window_length": 3, "order": 1, "mode": "replicate"},
+    np.expand_dims(np.array([1.0]), 0),  # Input data: Single value
+    np.expand_dims(np.array([1.0]), 0),  # Expected output: With a window length of 3 and polyorder 1
+    # output will be equal to mean of [1, 1, 1] = 1 (input will be nearest-neighbour-padded and a linear fit performed)
+    1e-5,  # absolute tolerance
+]
+
+# Sine smoothing
+
+TEST_CASE_SINE_SMOOTH = [
+    {"window_length": 3, "order": 1},
+    # Sine wave with period equal to savgol window length (windowed to reduce edge effects).
+    np.expand_dims(np.sin(2 * np.pi * 1 / 3 * np.arange(100)) * np.hanning(100), 0),
+    # Should be smoothed out to zeros
+    np.expand_dims(np.zeros(100), 0),
+    # tolerance chosen by examining output of SciPy.signal.savgol_filter() when provided the above input
+    2e-2,  # absolute tolerance
+]
+
+
+class TestSavitzkyGolaySmooth(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE, TEST_CASE_2D_AXIS_2, TEST_CASE_SINE_SMOOTH, TEST_CASE_SINGLE_VALUE_REP]
+    )
+    def test_value(self, arguments, image, expected_data, atol):
+        for p in TEST_NDARRAYS:
+            result = SavitzkyGolaySmooth(**arguments)(p(image.astype(np.float32)))
+            assert_allclose(result, p(expected_data.astype(np.float32)), rtol=1e-4, atol=atol, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_savitzky_golay_smoothd.py

@@ -0,0 +1,73 @@
+# 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 SavitzkyGolaySmoothd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+# Zero-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE = [
+    {"keys": "img", "window_length": 3, "order": 1},
+    np.expand_dims(np.array([1.0]), 0),  # Input data: Single value
+    np.expand_dims(np.array([1 / 3]), 0),  # Expected output: With a window length of 3 and polyorder 1
+    # output should be equal to mean of 0, 1 and 0 = 1/3 (because input will be zero-padded and a linear fit performed)
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_2 = [
+    {"keys": "img", "window_length": 3, "order": 1, "axis": 2},  # along axis 2 (second spatial dim)
+    np.expand_dims(np.ones((2, 3)), 0),
+    np.expand_dims(np.array([[2 / 3, 1.0, 2 / 3], [2 / 3, 1.0, 2 / 3]]), 0),
+    1e-5,  # absolute tolerance
+]
+
+# Replicated-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE_REP = [
+    {"keys": "img", "window_length": 3, "order": 1, "mode": "replicate"},
+    np.expand_dims(np.array([1.0]), 0),  # Input data: Single value
+    np.expand_dims(np.array([1.0]), 0),  # Expected output: With a window length of 3 and polyorder 1
+    # output will be equal to mean of [1, 1, 1] = 1 (input will be nearest-neighbour-padded and a linear fit performed)
+    1e-5,  # absolute tolerance
+]
+
+# Sine smoothing
+
+TEST_CASE_SINE_SMOOTH = [
+    {"keys": "img", "window_length": 3, "order": 1},
+    # Sine wave with period equal to savgol window length (windowed to reduce edge effects).
+    np.expand_dims(np.sin(2 * np.pi * 1 / 3 * np.arange(100)) * np.hanning(100), 0),
+    # Should be smoothed out to zeros
+    np.expand_dims(np.zeros(100), 0),
+    # tolerance chosen by examining output of SciPy.signal.savgol_filter() when provided the above input
+    2e-2,  # absolute tolerance
+]
+
+
+class TestSavitzkyGolaySmoothd(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE, TEST_CASE_2D_AXIS_2, TEST_CASE_SINE_SMOOTH, TEST_CASE_SINGLE_VALUE_REP]
+    )
+    def test_value(self, arguments, image, expected_data, atol):
+        for p in TEST_NDARRAYS:
+            result = SavitzkyGolaySmoothd(**arguments)({"img": p(image.astype(np.float32))})["img"]
+            assert_allclose(result, p(expected_data.astype(np.float32)), rtol=1e-4, atol=atol, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_scale_intensity.py

@@ -0,0 +1,76 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ScaleIntensity
+from monai.transforms.utils import rescale_array
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestScaleIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_range_scale(self, p):
+        scaler = ScaleIntensity(minv=1.0, maxv=2.0)
+        im = p(self.imt)
+        result = scaler(im)
+        mina = self.imt.min()
+        maxa = self.imt.max()
+        norm = (self.imt - mina) / (maxa - mina)
+        expected = p((norm * (2.0 - 1.0)) + 1.0)
+        assert_allclose(result, expected, type_test="tensor", rtol=1e-7, atol=0)
+
+    def test_factor_scale(self):
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensity(minv=None, maxv=None, factor=0.1)
+            result = scaler(p(self.imt))
+            expected = p((self.imt * (1 + 0.1)).astype(np.float32))
+            assert_allclose(result, p(expected), type_test="tensor", rtol=1e-7, atol=0)
+
+    def test_max_none(self):
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensity(minv=0.0, maxv=None, factor=0.1)
+            result = scaler(p(self.imt))
+            expected = rescale_array(p(self.imt), minv=0.0, maxv=None)
+            assert_allclose(result, expected, type_test="tensor", rtol=1e-3, atol=1e-3)
+
+    def test_int(self):
+        """integers should be handled by converting them to floats first."""
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensity(minv=1.0, maxv=2.0)
+            result = scaler(p(self.imt.astype(int)))
+            _imt = self.imt.astype(int).astype(np.float32)
+            mina = _imt.min()
+            maxa = _imt.max()
+            norm = (_imt - mina) / (maxa - mina)
+            expected = p((norm * (2.0 - 1.0)) + 1.0)
+            assert_allclose(result, expected, type_test="tensor", rtol=1e-7, atol=0)
+
+    def test_channel_wise(self):
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensity(minv=1.0, maxv=2.0, channel_wise=True)
+            data = p(np.tile(self.imt, (3, 1, 1, 1)))
+            result = scaler(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[i], expected, type_test="tensor", rtol=1e-7, atol=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_scale_intensity_fixed_mean.py

@@ -0,0 +1,94 @@
+# 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 ScaleIntensityFixedMean
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestScaleIntensityFixedMean(NumpyImageTestCase2D):
+    def test_factor_scale(self):
+        for p in TEST_NDARRAYS:
+            scaler = ScaleIntensityFixedMean(factor=0.1, fixed_mean=False)
+            result = scaler(p(self.imt))
+            expected = p((self.imt * (1 + 0.1)).astype(np.float32))
+            assert_allclose(result, p(expected), type_test="tensor", rtol=1e-7, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_preserve_range(self, p):
+        for channel_wise in [False, True]:
+            factor = 0.9
+            scaler = ScaleIntensityFixedMean(
+                factor=factor, preserve_range=True, channel_wise=channel_wise, fixed_mean=False
+            )
+            im = p(self.imt)
+            result = scaler(im)
+
+            if False:  # channel_wise:
+                out = []
+                for d in im:
+                    clip_min = d.min()
+                    clip_max = d.max()
+                    d = (1 + factor) * d
+                    d[d < clip_min] = clip_min
+                    d[d > clip_max] = clip_max
+                    out.append(d)
+                expected = p(out)
+            else:
+                clip_min = im.min()
+                clip_max = im.max()
+                im = (1 + factor) * im
+                im[im < clip_min] = clip_min
+                im[im > clip_max] = clip_max
+                expected = im
+            assert_allclose(result, expected, type_test="tensor", atol=1e-7)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_fixed_mean(self, p):
+        for channel_wise in [False, True]:
+            factor = 0.9
+            scaler = ScaleIntensityFixedMean(factor=factor, fixed_mean=True, channel_wise=channel_wise)
+            im = p(self.imt)
+            result = scaler(im)
+            mn = im.mean()
+            im = im - mn
+            expected = (1 + factor) * im
+            expected = expected + mn
+            assert_allclose(result, expected, type_test="tensor", atol=1e-7)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_fixed_mean_preserve_range(self, p):
+        for channel_wise in [False, True]:
+            factor = 0.9
+            scaler = ScaleIntensityFixedMean(
+                factor=factor, preserve_range=True, fixed_mean=True, channel_wise=channel_wise
+            )
+            im = p(self.imt)
+            clip_min = im.min()
+            clip_max = im.max()
+            result = scaler(im)
+            mn = im.mean()
+            im = im - mn
+            expected = (1 + factor) * im
+            expected = expected + mn
+            expected[expected < clip_min] = clip_min
+            expected[expected > clip_max] = clip_max
+            assert_allclose(result, expected, type_test="tensor", atol=1e-7)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_scale_intensity_range.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 unittest
+
+import numpy as np
+
+from monai.transforms import ScaleIntensityRange
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class IntensityScaleIntensityRange(NumpyImageTestCase2D):
+    def test_image_scale_intensity_range(self):
+        scaler = ScaleIntensityRange(a_min=20, a_max=108, b_min=50, b_max=80, dtype=np.uint8)
+        for p in TEST_NDARRAYS:
+            scaled = scaler(p(self.imt))
+            self.assertTrue(scaled.dtype, np.uint8)
+            expected = (((self.imt - 20) / 88) * 30 + 50).astype(np.uint8)
+            assert_allclose(scaled, p(expected), type_test="tensor")
+
+    def test_image_scale_intensity_range_none_clip(self):
+        scaler = ScaleIntensityRange(a_min=20, a_max=108, b_min=None, b_max=80, clip=True, dtype=np.uint8)
+        for p in TEST_NDARRAYS:
+            scaled = scaler(p(self.imt))
+            self.assertTrue(scaled.dtype, np.uint8)
+            expected = (np.clip((self.imt - 20) / 88, None, 80)).astype(np.uint8)
+            assert_allclose(scaled, p(expected), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()