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

tests/transforms/test_rand_histogram_shift.py

@@ -0,0 +1,92 @@
+# 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 RandHistogramShift
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"num_control_points": 5, "prob": 0.0},
+            {"img": p(np.arange(8).reshape((1, 2, 2, 2)))},
+            np.arange(8).reshape((1, 2, 2, 2)),
+        ]
+    )
+    TESTS.append(
+        [
+            {"num_control_points": 5, "prob": 0.9},
+            {"img": p(np.arange(8).reshape((1, 2, 2, 2)).astype(np.float32))},
+            np.array([[[[0.0, 0.57227867], [1.1391707, 1.68990281]], [[2.75833219, 4.34445884], [5.70913743, 7.0]]]]),
+        ]
+    )
+    TESTS.append(
+        [
+            {"num_control_points": (5, 20), "prob": 0.9},
+            {"img": p(np.arange(8).reshape((1, 2, 2, 2)).astype(np.float32))},
+            np.array([[[[0.0, 1.17472492], [2.21553091, 2.88292011]], [[3.98407301, 5.01302123], [6.09275004, 7.0]]]]),
+        ]
+    )
+
+WARN_TESTS = []
+for p in TEST_NDARRAYS:
+    WARN_TESTS.append(
+        [
+            {"num_control_points": 5, "prob": 1.0},
+            {"img": p(np.zeros(8).reshape((1, 2, 2, 2)))},
+            np.zeros(8).reshape((1, 2, 2, 2)),
+        ]
+    )
+
+
+class TestRandHistogramShift(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_histogram_shift(self, input_param, input_data, expected_val):
+        g = RandHistogramShift(**input_param)
+        g.set_random_state(123)
+        result = g(**input_data)
+        assert_allclose(result, expected_val, rtol=1e-4, atol=1e-4, type_test="tensor")
+
+    def test_interp(self):
+        tr = RandHistogramShift()
+        for array_type in (torch.tensor, np.array):
+            x = array_type([0.0, 4.0, 6.0, 10.0])
+            y = array_type([1.0, -1.0, 3.0, 5.0])
+
+            yi = tr.interp(array_type([0, 2, 4, 8, 10]), x, y)
+            self.assertEqual(yi.shape, (5,))
+            assert_allclose(yi, array_type([1.0, 0.0, -1.0, 4.0, 5.0]))
+
+            yi = tr.interp(array_type([-1, 11, 10.001, -0.001]), x, y)
+            self.assertEqual(yi.shape, (4,))
+            assert_allclose(yi, array_type([1.0, 5.0, 5.0, 1.0]))
+
+            yi = tr.interp(array_type([[-2, 11], [1, 3], [8, 10]]), x, y)
+            self.assertEqual(yi.shape, (3, 2))
+            assert_allclose(yi, array_type([[1.0, 5.0], [0.5, -0.5], [4.0, 5.0]]))
+
+    @parameterized.expand(WARN_TESTS)
+    def test_warn(self, input_param, input_data, expected_val):
+        with self.assertWarns(Warning):
+            result = RandHistogramShift(**input_param)(**input_data)
+            assert_allclose(result, expected_val, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_k_space_spike_noise.py

@@ -0,0 +1,92 @@
+# 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 copy import deepcopy
+
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import KSpaceSpikeNoise, RandKSpaceSpikeNoise
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for shape in ((128, 64), (64, 48, 80)):
+    for p in TEST_NDARRAYS:
+        for channel_wise in (True, False):
+            TESTS.append((shape, p, channel_wise))
+
+
+class TestRandKSpaceSpikeNoise(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, im_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        im = create_test_image(*im_shape, rad_max=20, noise_max=0.0, num_seg_classes=5)[0][None]
+        return im_type(im)
+
+    @parameterized.expand(TESTS)
+    def test_0_prob(self, im_shape, im_type, channel_wise):
+        im = self.get_data(im_shape, im_type)
+        intensity_range = [14, 15]
+        t = RandKSpaceSpikeNoise(0.0, intensity_range, channel_wise)
+        out = t(im)
+        assert_allclose(out, im, type_test="tensor")
+
+    @parameterized.expand(TESTS)
+    def test_1_prob(self, im_shape, im_type, channel_wise):
+        im = self.get_data(im_shape, im_type)
+        intensity_range = [14, 14]
+        t = RandKSpaceSpikeNoise(1.0, intensity_range, channel_wise)
+        out = t(im)
+        base_t = KSpaceSpikeNoise(t.sampled_locs, [14])
+        out = out - base_t(im)
+        assert_allclose(out, im * 0, type_test="tensor")
+
+    @parameterized.expand(TESTS)
+    def test_same_result(self, im_shape, im_type, channel_wise):
+        im = self.get_data(im_shape, im_type)
+        intensity_range = [14, 15]
+        t = RandKSpaceSpikeNoise(0.0, intensity_range, channel_wise)
+        t.set_random_state(42)
+        out1 = t(deepcopy(im))
+        t.set_random_state(42)
+        out2 = t(deepcopy(im))
+        assert_allclose(out1, out2, type_test="tensor")
+
+    @parameterized.expand(TESTS)
+    def test_intensity(self, im_shape, im_type, channel_wise):
+        im = self.get_data(im_shape, im_type)
+        intensity_range = [14, 14.1]
+        t = RandKSpaceSpikeNoise(1.0, intensity_range, channel_wise)
+        _ = t(deepcopy(im))
+        self.assertGreaterEqual(t.sampled_k_intensity[0], 14)
+        self.assertLessEqual(t.sampled_k_intensity[0], 14.1)
+
+    @parameterized.expand(TESTS)
+    def test_default_intensity(self, im_shape, im_type, channel_wise):
+        im = self.get_data(im_shape, im_type)
+        t = RandKSpaceSpikeNoise(1.0, intensity_range=None, channel_wise=channel_wise)
+        out = t(deepcopy(im))
+        self.assertEqual(out.shape, im.shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_k_space_spike_noised.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
+from copy import deepcopy
+
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import RandKSpaceSpikeNoised
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for shape in ((128, 64), (64, 48, 80)):
+    for p in TEST_NDARRAYS:
+        TESTS.append((shape, p))
+
+KEYS = ["image", "label"]
+
+
+class TestKSpaceSpikeNoised(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, im_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        ims = create_test_image(*im_shape, rad_max=20, noise_max=0.0, num_seg_classes=5)
+        ims = [im_type(im[None]) for im in ims]
+        return dict(zip(KEYS, ims))
+
+    @parameterized.expand(TESTS)
+    def test_same_result(self, im_shape, im_type):
+        data = self.get_data(im_shape, im_type)
+
+        t = RandKSpaceSpikeNoised(KEYS, prob=1.0, intensity_range=(13, 15), channel_wise=True)
+        t.set_random_state(42)
+        out1 = t(deepcopy(data))
+
+        t.set_random_state(42)
+        out2 = t(deepcopy(data))
+
+        for k in KEYS:
+            assert_allclose(out1[k], out2[k], atol=1e-10, type_test="tensor")
+
+    @parameterized.expand(TESTS)
+    def test_0_prob(self, im_shape, im_type):
+        data = self.get_data(im_shape, im_type)
+
+        t1 = RandKSpaceSpikeNoised(KEYS, prob=0.0, intensity_range=(13, 15), channel_wise=True)
+        t2 = RandKSpaceSpikeNoised(KEYS, prob=0.0, intensity_range=(13, 15), channel_wise=True)
+        out1 = t1(data)
+        out2 = t2(data)
+
+        for k in KEYS:
+            assert_allclose(out1[k], data[k], type_test="tensor")
+            assert_allclose(out2[k], data[k], type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_rician_noise.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 unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import RandRicianNoise
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(("test_zero_mean", p, 0, 0.1))
+    TESTS.append(("test_non_zero_mean", p, 1, 0.5))
+
+
+class TestRandRicianNoise(NumpyImageTestCase2D):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, _, in_type, mean, std):
+        seed = 0
+        rician_fn = RandRicianNoise(prob=1.0, mean=mean, std=std)
+        rician_fn.set_random_state(seed)
+        im = in_type(self.imt)
+        noised = rician_fn(im)
+        if isinstance(im, torch.Tensor):
+            self.assertEqual(im.dtype, noised.dtype)
+        np.random.seed(seed)
+        np.random.random()
+        _std = np.random.uniform(0, std)
+        expected = np.sqrt(
+            (self.imt + np.random.normal(mean, _std, size=self.imt.shape)) ** 2
+            + np.random.normal(mean, _std, size=self.imt.shape) ** 2
+        )
+        if isinstance(noised, torch.Tensor):
+            noised = noised.cpu()
+        np.testing.assert_allclose(expected, noised, atol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_rician_noised.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 unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import RandRicianNoised
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(["test_zero_mean", p, ["img1", "img2"], 0, 0.1])
+    TESTS.append(["test_non_zero_mean", p, ["img1", "img2"], 1, 0.5])
+
+seed = 0
+
+
+class TestRandRicianNoisedNumpy(NumpyImageTestCase2D):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, _, in_type, keys, mean, std):
+        rician_fn = RandRicianNoised(keys=keys, prob=1.0, mean=mean, std=std, dtype=np.float64)
+        rician_fn.set_random_state(seed)
+        noised = rician_fn({k: in_type(self.imt) for k in keys})
+        np.random.seed(seed)
+        for k in keys:
+            # simulate the `randomize` function of transform
+            np.random.random()
+            _std = np.random.uniform(0, std)
+            expected = np.sqrt(
+                (self.imt + np.random.normal(mean, _std, size=self.imt.shape)) ** 2
+                + np.random.normal(mean, _std, size=self.imt.shape) ** 2
+            )
+            if isinstance(noised[k], torch.Tensor):
+                noised[k] = noised[k].cpu()
+            np.testing.assert_allclose(expected, noised[k], atol=1e-5, rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_rotate.py

@@ -0,0 +1,166 @@
+# 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.data import MetaTensor, set_track_meta
+from monai.transforms import RandRotate
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import (
+    TEST_NDARRAYS_ALL,
+    NumpyImageTestCase2D,
+    NumpyImageTestCase3D,
+    assert_allclose,
+    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 / 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,
+            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, (-np.pi / 4, 0), 0, 0, False, "nearest", "zeros", False, (1, 64, 61, 87)))
+
+
+class TestRandRotate2D(NumpyImageTestCase2D):
+    @parameterized.expand(TEST_CASES_2D)
+    def test_correct_results(self, im_type, degrees, keep_size, mode, padding_mode, align_corners):
+        init_param = {
+            "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 = RandRotate(**init_param)
+        rotate_fn.set_random_state(243)
+        call_param = {"img": im_type(self.imt[0])}
+        rotated = rotate_fn(**call_param)
+
+        # test lazy
+        test_resampler_lazy(rotate_fn, rotated, init_param=init_param, call_param=call_param, seed=243)
+        rotate_fn.lazy = False
+
+        _order = 0 if mode == "nearest" else 1
+        if mode == "border":
+            _mode = "nearest"
+        elif mode == "reflection":
+            _mode = "reflect"
+        else:
+            _mode = "constant"
+        angle = rotate_fn.x
+        expected = scipy.ndimage.rotate(
+            self.imt[0, 0], -np.rad2deg(angle), (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False
+        )
+        expected = np.stack(expected).astype(np.float32)
+        rotated = rotated.cpu() if isinstance(rotated, torch.Tensor) else rotated
+        good = np.sum(np.isclose(expected, rotated[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 TestRandRotate3D(NumpyImageTestCase3D):
+    @parameterized.expand(TEST_CASES_3D)
+    def test_correct_results(self, im_type, x, y, z, keep_size, mode, padding_mode, align_corners, expected):
+        init_param = {
+            "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 = RandRotate(**init_param)
+        rotate_fn.set_random_state(243)
+        im = im_type(self.imt[0])
+        call_param = {"img": im}
+        rotated = rotate_fn(**call_param)
+
+        # test lazy
+        test_resampler_lazy(rotate_fn, rotated, init_param=init_param, call_param=call_param, seed=243)
+        rotate_fn.lazy = False
+
+        assert_allclose(rotated.shape, expected, rtol=1e-7, atol=0)
+        test_local_inversion(rotate_fn, rotated, im)
+
+        set_track_meta(False)
+        rotated = rotate_fn(im)
+        self.assertNotIsInstance(rotated, MetaTensor)
+        self.assertIsInstance(rotated, torch.Tensor)
+        set_track_meta(True)
+
+
+class TestRandRotateDtype(NumpyImageTestCase2D):
+    @parameterized.expand(TEST_CASES_2D)
+    def test_correct_results(self, im_type, degrees, keep_size, mode, padding_mode, align_corners):
+        rotate_fn = RandRotate(
+            range_x=1.0,
+            prob=0.5,
+            keep_size=keep_size,
+            mode=mode,
+            padding_mode=padding_mode,
+            align_corners=align_corners,
+            dtype=np.float64,
+        )
+        im = im_type(self.imt[0])
+        rotated = rotate_fn(im)
+        self.assertEqual(rotated.dtype, torch.float32)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_rotate90.py

@@ -0,0 +1,100 @@
+# 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 RandRotate90
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, assert_allclose, test_local_inversion
+
+
+class TestRandRotate90(NumpyImageTestCase2D):
+    def test_default(self):
+        rotate = RandRotate90()
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(123)
+            im = p(self.imt[0])
+            call_param = {"img": im}
+            rotated = rotate(**call_param)
+            test_local_inversion(rotate, rotated, im)
+            expected = [np.rot90(channel, 0, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=123)
+            rotate.lazy = False
+
+    def test_k(self):
+        init_param = {"max_k": 2}
+        rotate = RandRotate90(**init_param)
+        for p in TEST_NDARRAYS_ALL:
+            im = p(self.imt[0])
+            set_track_meta(False)
+            rotated = rotate(im)
+            self.assertNotIsInstance(rotated, MetaTensor)
+            self.assertIsInstance(rotated, torch.Tensor)
+
+            set_track_meta(True)
+            rotate.set_random_state(123)
+            call_param = {"img": im}
+            rotated = rotate(**call_param)
+            test_local_inversion(rotate, rotated, im)
+            expected = [np.rot90(channel, 0, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
+
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=123)
+            rotate.lazy = False
+
+    def test_spatial_axes(self):
+        rotate = RandRotate90(spatial_axes=(0, 1), prob=1.0)
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(1234)
+            im = p(self.imt[0])
+            call_param = {"img": im}
+            rotated = rotate(**call_param)
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=1234)
+            rotate.lazy = False
+
+            self.assertEqual(len(rotated.applied_operations), 1)
+            expected = [np.rot90(channel, rotate._rand_k, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
+            test_local_inversion(rotate, rotated, im)
+
+    def test_prob_k_spatial_axes(self):
+        rotate = RandRotate90(prob=1.0, max_k=2, spatial_axes=(0, 1))
+        for p in TEST_NDARRAYS_ALL:
+            rotate.set_random_state(234)
+            im = p(self.imt[0])
+            call_param = {"img": im}
+            rotated = rotate(**call_param)
+            # test lazy
+            test_resampler_lazy(rotate, rotated, call_param=call_param, seed=234)
+            rotate.lazy = False
+
+            test_local_inversion(rotate, rotated, im)
+            expected = [np.rot90(channel, 1, (0, 1)) for channel in self.imt[0]]
+            expected = np.stack(expected)
+            assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()