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

tests/transforms/test_rand_rotate90d.py

@@ -0,0 +1,112 @@
+# 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 monai.data import MetaTensor, set_track_meta
+from monai.transforms import RandRotate90d
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, assert_allclose, test_local_inversion
+
+
+class TestRandRotate90d(NumpyImageTestCase2D):
+    def test_default(self):
+        key = "test"
+        rotate = RandRotate90d(keys=key)
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(1323)
+            im = {key: p(self.imt[0])}
+            call_param = {"data": im}
+            rotated = rotate(**call_param)
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=1323, output_key=key)
+            rotate.lazy = False
+
+            test_local_inversion(rotate, rotated, im, key)
+            expected = [np.rot90(channel, 0, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated[key], p(expected), type_test="tensor")
+
+            set_track_meta(False)
+            rotated = rotate(im)[key]
+            self.assertNotIsInstance(rotated, MetaTensor)
+            self.assertIsInstance(rotated, torch.Tensor)
+            set_track_meta(True)
+
+    def test_k(self):
+        key = "test"
+        rotate = RandRotate90d(keys=key, max_k=2)
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(234)
+            im = {key: p(self.imt[0])}
+            call_param = {"data": im}
+            rotated = rotate(**call_param)
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=234, output_key=key)
+            rotate.lazy = False
+
+            test_local_inversion(rotate, rotated, im, key)
+            expected = [np.rot90(channel, 0, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated[key], p(expected), type_test="tensor")
+
+    def test_spatial_axes(self):
+        key = "test"
+        rotate = RandRotate90d(keys=key, spatial_axes=(0, 1))
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(234)
+            im = {key: p(self.imt[0])}
+            call_param = {"data": im}
+            rotated = rotate(**call_param)
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=234, output_key=key)
+            rotate.lazy = False
+
+            test_local_inversion(rotate, rotated, im, key)
+            expected = [np.rot90(channel, 0, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated[key], p(expected), type_test="tensor")
+
+    def test_prob_k_spatial_axes(self):
+        key = "test"
+        rotate = RandRotate90d(keys=key, prob=1.0, max_k=2, spatial_axes=(0, 1))
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(234)
+            im = {key: p(self.imt[0])}
+            call_param = {"data": im}
+            rotated = rotate(**call_param)
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=234, output_key=key)
+            rotate.lazy = False
+
+            expected = [np.rot90(channel, 1, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated[key], p(expected), type_test="tensor")
+            test_local_inversion(rotate, rotated, im, key)
+
+    def test_no_key(self):
+        key = "unknown"
+        rotate = RandRotate90d(keys=key, prob=1.0, max_k=2, spatial_axes=(0, 1))
+        with self.assertRaisesRegex(KeyError, ""):
+            rotate({"test": self.imt[0]})
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_rotated.py

@@ -0,0 +1,187 @@
+# 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 scipy.ndimage
+import torch
+from parameterized import parameterized
+
+from monai.config import USE_COMPILED
+from monai.transforms import RandRotated
+from monai.utils import GridSampleMode, GridSamplePadMode
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, NumpyImageTestCase3D, test_local_inversion
+
+TEST_CASES_2D: list[tuple] = []
+for p in TEST_NDARRAYS_ALL:
+    TEST_CASES_2D.append((p, np.pi / 2, True, "bilinear", "border", False))
+    TEST_CASES_2D.append((p, np.pi / 4, True, "nearest", "border", False))
+    TEST_CASES_2D.append((p, np.pi, False, "nearest", "zeros", True))
+    if not USE_COMPILED:
+        TEST_CASES_2D.append((p, (-np.pi / 4, 0), False, "nearest", "zeros", True))
+
+TEST_CASES_3D: list[tuple] = []
+for p in TEST_NDARRAYS_ALL:
+    TEST_CASES_3D.append(
+        (p, np.pi / 2, -np.pi / 6, (0.0, np.pi), False, "bilinear", "border", False, (1, 81, 110, 112))
+    )
+    TEST_CASES_3D.append(
+        (
+            p,
+            np.pi / 2,
+            -np.pi / 6,
+            (0.0, np.pi),
+            False,
+            GridSampleMode.NEAREST,
+            GridSamplePadMode.BORDER,
+            False,
+            (1, 81, 110, 112),
+        )
+    )
+    TEST_CASES_3D.append(
+        (
+            p,
+            np.pi / 4,
+            (-np.pi / 9, np.pi / 4.5),
+            (np.pi / 9, np.pi / 6),
+            False,
+            "nearest",
+            "border",
+            True,
+            (1, 97, 100, 97),
+        )
+    )
+    TEST_CASES_3D.append(
+        (
+            p,
+            np.pi / 4,
+            (-np.pi / 9, np.pi / 4.5),
+            (np.pi / 9, np.pi / 6),
+            False,
+            GridSampleMode.NEAREST,
+            GridSamplePadMode.BORDER,
+            True,
+            (1, 97, 100, 97),
+        )
+    )
+    TEST_CASES_3D.append(
+        (
+            p,
+            0.0,
+            (2 * np.pi, 2.06 * np.pi),
+            (-np.pi / 180, np.pi / 180),
+            True,
+            "nearest",
+            "zeros",
+            True,
+            (1, 64, 48, 80),
+        )
+    )
+    TEST_CASES_3D.append(
+        (
+            p,
+            0.0,
+            (2 * np.pi, 2.06 * np.pi),
+            (-np.pi / 180, np.pi / 180),
+            True,
+            GridSampleMode.NEAREST,
+            GridSamplePadMode.ZEROS,
+            True,
+            (1, 64, 48, 80),
+        )
+    )
+    TEST_CASES_3D.append((p, (-np.pi / 4, 0), 0, 0, False, "nearest", "zeros", False, (1, 64, 61, 87)))
+    TEST_CASES_3D.append(
+        (p, (-np.pi / 4, 0), 0, 0, False, GridSampleMode.NEAREST, GridSamplePadMode.ZEROS, False, (1, 64, 61, 87))
+    )
+
+
+class TestRandRotated2D(NumpyImageTestCase2D):
+    @parameterized.expand(TEST_CASES_2D)
+    def test_correct_results(self, im_type, degrees, keep_size, mode, padding_mode, align_corners):
+        init_param = {
+            "keys": "img",
+            "range_x": degrees,
+            "prob": 1.0,
+            "keep_size": keep_size,
+            "mode": mode,
+            "padding_mode": padding_mode,
+            "align_corners": align_corners,
+            "dtype": np.float64,
+        }
+        rotate_fn = RandRotated(**init_param)
+        im = im_type(self.imt[0])
+        rotate_fn.set_random_state(243)
+        call_param = {"data": {"img": im, "seg": im_type(self.segn[0])}}
+        rotated = rotate_fn(**call_param)
+
+        # test lazy
+        test_resampler_lazy(
+            rotate_fn, rotated, init_param=init_param, call_param=call_param, seed=243, output_key="img"
+        )
+
+        _order = 0 if mode == "nearest" else 1
+        if padding_mode == "border":
+            _mode = "nearest"
+        elif padding_mode == "reflection":
+            _mode = "reflect"
+        else:
+            _mode = "constant"
+        angle = rotate_fn.rand_rotate.x
+        expected = scipy.ndimage.rotate(
+            self.imt[0, 0], -np.rad2deg(angle), (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False
+        )
+        test_local_inversion(rotate_fn, rotated, {"img": im}, "img")
+        for k, v in rotated.items():
+            rotated[k] = v.cpu() if isinstance(v, torch.Tensor) else v
+        expected = np.stack(expected).astype(np.float32)
+        good = np.sum(np.isclose(expected, rotated["img"][0], atol=1e-3))
+        self.assertLessEqual(np.abs(good - expected.size), 40, "diff at most 40 pixels")
+
+
+@unittest.skipIf(USE_COMPILED, "unit tests not for compiled version.")
+class TestRandRotated3D(NumpyImageTestCase3D):
+    @parameterized.expand(TEST_CASES_3D)
+    def test_correct_shapes(self, im_type, x, y, z, keep_size, mode, padding_mode, align_corners, expected):
+        init_param = {
+            "keys": ("img", "seg"),
+            "range_x": x,
+            "range_y": y,
+            "range_z": z,
+            "prob": 1.0,
+            "keep_size": keep_size,
+            "mode": mode,
+            "padding_mode": padding_mode,
+            "align_corners": align_corners,
+            "dtype": np.float64,
+        }
+        rotate_fn = RandRotated(**init_param)
+        rotate_fn.set_random_state(243)
+        call_param = {"data": {"img": im_type(self.imt[0]), "seg": im_type(self.segn[0])}}
+        rotated = rotate_fn(**call_param)
+
+        # test lazy
+        test_resampler_lazy(
+            rotate_fn, rotated, init_param=init_param, call_param=call_param, seed=243, output_key="img"
+        )
+        np.testing.assert_allclose(rotated["img"].shape, expected)
+
+        rotate_fn.prob = 0.0
+        rotated = rotate_fn({"img": im_type(self.imt[0]), "seg": im_type(self.segn[0])})
+        self.assertEqual(rotated["seg"].dtype, torch.float32)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_crop.py

@@ -0,0 +1,78 @@
+# 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 RandScaleCrop
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_SHAPES = [
+    [{"roi_scale": [1.0, 1.0, -1.0], "random_center": True}, (3, 3, 3, 4), (3, 3, 3, 4)],
+    [{"roi_scale": [1.0, 1.0, 1.0], "random_center": False}, (3, 3, 3, 3), (3, 3, 3, 3)],
+]
+
+TEST_VALUES = [
+    [
+        {"roi_scale": [0.6, 0.6], "random_center": False},
+        np.array([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+    ]
+]
+
+TEST_RANDOM_SHAPES = [
+    [
+        {"roi_scale": [0.75, 0.6, 0.5], "max_roi_scale": [1.0, -1.0, 0.6], "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 3, 4, 3),
+    ],
+    [{"roi_scale": 0.6, "max_roi_scale": 0.8, "random_center": True, "random_size": True}, (1, 4, 5, 6), (1, 3, 4, 4)],
+    [{"roi_scale": 0.2, "max_roi_scale": 0.8, "random_center": True, "random_size": True}, (1, 4, 5, 6), (1, 3, 2, 4)],
+]
+
+
+class TestRandScaleCrop(CropTest):
+    Cropper = RandScaleCrop
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        self.crop_test(input_param, input_shape, expected_shape)
+
+    @parameterized.expand(TEST_VALUES)
+    def test_value(self, input_param, input_data):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = RandScaleCrop(**input_param)
+                result = cropper(im_type(input_data))
+                roi = [(2 - i // 2, 2 + i - i // 2) for i in cropper._size]
+                assert_allclose(result, input_data[:, roi[0][0] : roi[0][1], roi[1][0] : roi[1][1]], type_test="tensor")
+
+    @parameterized.expand(TEST_RANDOM_SHAPES)
+    def test_random_shape(self, input_param, input_shape, expected_shape):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = RandScaleCrop(**input_param)
+                cropper.set_random_state(seed=123)
+                input_data = im_type(np.random.randint(0, 2, input_shape))
+                result = cropper(input_data)
+                self.assertTupleEqual(result.shape, expected_shape)
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_cropd.py

@@ -0,0 +1,98 @@
+# 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 RandScaleCropd
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_SHAPES = [
+    [{"keys": "img", "roi_scale": [1.0, 1.0, -1.0], "random_center": True}, (3, 3, 3, 4), (3, 3, 3, 4)],
+    [
+        # test `allow_missing_keys` with key "label"
+        {"keys": ["label", "img"], "roi_scale": [1.0, 1.0, 1.0], "random_center": False, "allow_missing_keys": True},
+        (3, 3, 3, 3),
+        (3, 3, 3, 3),
+    ],
+]
+
+TEST_VALUES = [
+    [
+        {"keys": "img", "roi_scale": [0.6, 0.6], "random_center": False},
+        np.array([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+    ]
+]
+
+TEST_RANDOM_SHAPES = [
+    [
+        {
+            "keys": "img",
+            "roi_scale": [0.75, 0.6, 0.5],
+            "max_roi_scale": [1.0, -1.0, 0.6],
+            "random_center": True,
+            "random_size": True,
+        },
+        (1, 4, 5, 6),
+        (1, 3, 4, 3),
+    ],
+    [
+        {"keys": "img", "roi_scale": 0.6, "max_roi_scale": 0.8, "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 3, 4, 4),
+    ],
+    [
+        {"keys": "img", "roi_scale": 0.2, "max_roi_scale": 0.8, "random_center": True, "random_size": True},
+        (1, 4, 5, 6),
+        (1, 3, 2, 4),
+    ],
+]
+
+
+class TestRandScaleCropd(CropTest):
+    Cropper = RandScaleCropd
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        self.crop_test(input_param, input_shape, expected_shape)
+
+    @parameterized.expand(TEST_VALUES)
+    def test_value(self, input_param, input_im):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = self.Cropper(**input_param)
+                input_data = {"img": im_type(input_im)}
+                result = cropper(input_data)["img"]
+                roi = [(2 - i // 2, 2 + i - i // 2) for i in cropper.cropper._size]
+                assert_allclose(result, input_im[:, roi[0][0] : roi[0][1], roi[1][0] : roi[1][1]], type_test="tensor")
+
+    @parameterized.expand(TEST_RANDOM_SHAPES)
+    def test_random_shape(self, input_param, input_shape, expected_shape):
+        for im_type in TEST_NDARRAYS_ALL:
+            with self.subTest(im_type=im_type):
+                cropper = self.Cropper(**input_param)
+                cropper.set_random_state(seed=123)
+                input_data = {"img": im_type(np.random.randint(0, 2, input_shape))}
+                result = cropper(input_data)["img"]
+                self.assertTupleEqual(result.shape, expected_shape)
+
+    @parameterized.expand(TEST_SHAPES)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.crop_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_intensity.py

@@ -0,0 +1,54 @@
+# 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 RandScaleIntensity
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandScaleIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_value(self, p):
+        scaler = RandScaleIntensity(factors=0.5, prob=1.0)
+        scaler.set_random_state(seed=0)
+        im = p(self.imt)
+        result = scaler(im)
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        expected = p((self.imt * (1 + np.random.uniform(low=-0.5, high=0.5))).astype(np.float32))
+        assert_allclose(result, p(expected), rtol=1e-7, atol=0, type_test="tensor")
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        scaler = RandScaleIntensity(factors=0.5, channel_wise=True, prob=1.0)
+        scaler.set_random_state(seed=0)
+        im = p(self.imt)
+        result = scaler(im)
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        channel_num = self.imt.shape[0]
+        factor = [np.random.uniform(low=-0.5, high=0.5) for _ in range(channel_num)]
+        expected = p(
+            np.stack([np.asarray((self.imt[i]) * (1 + factor[i])) for i in range(channel_num)]).astype(np.float32)
+        )
+        assert_allclose(result, expected, atol=0, rtol=1e-5, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_intensity_fixed_mean.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 parameterized import parameterized
+
+from monai.transforms import RandScaleIntensityFixedMean
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandScaleIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_value(self, p):
+        scaler = RandScaleIntensityFixedMean(prob=1.0, factors=0.5)
+        scaler.set_random_state(seed=0)
+        im = p(self.imt)
+        result = scaler(im)
+        np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
+        mn = im.mean()
+        im = im - mn
+        expected = (1 + np.random.uniform(low=-0.5, high=0.5)) * im
+        expected = expected + mn
+        assert_allclose(result, expected, type_test="tensor", atol=1e-7)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_intensity_fixed_meand.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 RandScaleIntensityFixedMeand
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandScaleIntensityFixedMeand(NumpyImageTestCase2D):
+    def test_value(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = RandScaleIntensityFixedMeand(keys=[key], factors=0.5, prob=1.0)
+            scaler.set_random_state(seed=0)
+            result = scaler({key: p(self.imt)})
+            np.random.seed(0)
+            # simulate the randomize function of transform
+            np.random.random()
+            im = self.imt
+            mn = im.mean()
+            im = im - mn
+            expected = (1 + np.random.uniform(low=-0.5, high=0.5)) * im
+            expected = expected + mn
+            assert_allclose(result[key], p(expected), type_test="tensor", atol=1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_scale_intensityd.py

@@ -0,0 +1,53 @@
+# 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 RandScaleIntensityd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestRandScaleIntensityd(NumpyImageTestCase2D):
+    def test_value(self):
+        key = "img"
+        for p in TEST_NDARRAYS:
+            scaler = RandScaleIntensityd(keys=[key], factors=0.5, prob=1.0)
+            scaler.set_random_state(seed=0)
+            result = scaler({key: p(self.imt)})
+            np.random.seed(0)
+            # simulate the randomize function of transform
+            np.random.random()
+            expected = (self.imt * (1 + np.random.uniform(low=-0.5, high=0.5))).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 = RandScaleIntensityd(keys=[key], factors=0.5, prob=1.0, channel_wise=True)
+            scaler.set_random_state(seed=0)
+            result = scaler({key: p(self.imt)})
+            np.random.seed(0)
+            # simulate the randomize function of transform
+            np.random.random()
+            channel_num = self.imt.shape[0]
+            factor = [np.random.uniform(low=-0.5, high=0.5) for _ in range(channel_num)]
+            expected = p(
+                np.stack([np.asarray((self.imt[i]) * (1 + factor[i])) for i in range(channel_num)]).astype(np.float32)
+            )
+            assert_allclose(result[key], p(expected), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()