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

tests/transforms/test_utils_pytorch_numpy_unification.py

@@ -0,0 +1,90 @@
+# 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.utils_pytorch_numpy_unification import max, min, mode, percentile
+from monai.utils import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose, skip_if_quick
+
+TEST_MODE = []
+for p in TEST_NDARRAYS:
+    TEST_MODE.append([p(np.array([1, 2, 3, 4, 4, 5])), p(4), False])
+    TEST_MODE.append([p(np.array([3.1, 4.1, 4.1, 5.1])), p(4.1), False])
+    TEST_MODE.append([p(np.array([3.1, 4.1, 4.1, 5.1])), p(4), True])
+
+TEST_MIN_MAX = []
+for p in TEST_NDARRAYS:
+    TEST_MIN_MAX.append([p(np.array([1, 2, 3, 4, 4, 5])), {}, min, p(1)])
+    TEST_MIN_MAX.append([p(np.array([[3.1, 4.1, 4.1, 5.1], [3, 5, 4.1, 5]])), {"dim": 1}, min, p([3.1, 3])])
+    TEST_MIN_MAX.append([p(np.array([1, 2, 3, 4, 4, 5])), {}, max, p(5)])
+    TEST_MIN_MAX.append([p(np.array([[3.1, 4.1, 4.1, 5.1], [3, 5, 4.1, 5]])), {"dim": 1}, max, p([5.1, 5])])
+
+
+class TestPytorchNumpyUnification(unittest.TestCase):
+    def setUp(self) -> None:
+        set_determinism(0)
+
+    def test_percentile(self):
+        for size in (1, 100):
+            q = np.random.randint(0, 100, size=size)
+            results = []
+            for idx, p in enumerate(TEST_NDARRAYS):
+                dtype = [np.float32, float][idx % 2]
+                arr = p(np.arange(100 * 101).reshape(1, 100, 101).astype(dtype))
+                results.append(percentile(arr, q))
+                assert_allclose(results[0], results[-1], type_test=False, atol=1e-4, rtol=1e-4)
+
+    @skip_if_quick
+    def test_many_elements_quantile(self):  # pytorch#64947
+        for p in TEST_NDARRAYS:
+            for elements in (1000, 17_000_000):
+                for t in [*TEST_NDARRAYS, list]:
+                    x = p(np.random.randn(elements))
+                    q = percentile(x, t([10, 50]))
+                    if isinstance(x, torch.Tensor):
+                        self.assertIsInstance(q, torch.Tensor)
+                    assert_allclose(q.shape, [2], type_test=False)
+
+    def test_fails(self):
+        for p in TEST_NDARRAYS:
+            for q in (-1, 101):
+                arr = p(np.arange(100 * 101).reshape(1, 100, 101).astype(np.float32))
+                with self.assertRaises(ValueError):
+                    percentile(arr, q)
+
+    def test_dim(self):
+        q = np.random.randint(0, 100, size=50)
+        results = []
+        for p in TEST_NDARRAYS:
+            arr = p(np.arange(6).reshape(1, 2, 3).astype(np.float32))
+            results.append(percentile(arr, q, dim=1))
+            assert_allclose(results[0], results[-1], type_test=False, atol=1e-4)
+
+    @parameterized.expand(TEST_MODE)
+    def test_mode(self, array, expected, to_long):
+        res = mode(array, to_long=to_long)
+        assert_allclose(res, expected)
+
+    @parameterized.expand(TEST_MIN_MAX)
+    def test_min_max(self, array, input_params, func, expected):
+        res = func(array, **input_params)
+        assert_allclose(res, expected, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_vote_ensemble.py

@@ -0,0 +1,84 @@
+# 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 torch
+from parameterized import parameterized
+
+from monai.transforms import VoteEnsemble
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    # shape: [2, 1, 1]
+    TESTS.append(
+        [
+            {"num_classes": None},
+            [p(torch.tensor([[[1]], [[0]]])), p(torch.tensor([[[1]], [[0]]])), p(torch.tensor([[[0]], [[1]]]))],
+            p(torch.tensor([[[1.0]], [[0.0]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1, 1]
+    TESTS.append(
+        [
+            {"num_classes": None},
+            p(
+                torch.stack(
+                    [torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[0]], [[1]]]])]
+                )
+            ),
+            p(torch.tensor([[[[1.0]], [[0.0]]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1]
+    TESTS.append(
+        [
+            {"num_classes": 3},
+            [p(torch.tensor([[[0], [2]]])), p(torch.tensor([[[0], [2]]])), p(torch.tensor([[[1], [1]]]))],
+            p(torch.tensor([[[0], [2]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1]
+    TESTS.append(
+        [
+            {"num_classes": 5},
+            [p(torch.tensor([[[0], [2]]])), p(torch.tensor([[[0], [2]]])), p(torch.tensor([[[1], [1]]]))],
+            p(torch.tensor([[[0], [2]]])),
+        ]
+    )
+
+    # shape: [1]
+    TESTS.append(
+        [{"num_classes": 3}, [p(torch.tensor([2])), p(torch.tensor([2])), p(torch.tensor([1]))], p(torch.tensor([2]))]
+    )
+
+    # shape: 1
+    TESTS.append([{"num_classes": 3}, [p(torch.tensor(2)), p(torch.tensor(2)), p(torch.tensor(1))], p(torch.tensor(2))])
+
+
+class TestVoteEnsemble(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input_param, img, expected_value):
+        result = VoteEnsemble(**input_param)(img)
+        if isinstance(img, torch.Tensor):
+            self.assertIsInstance(result, torch.Tensor)
+            self.assertEqual(result.device, img.device)
+        assert_allclose(result, expected_value)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_vote_ensembled.py

@@ -0,0 +1,107 @@
+# 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 torch
+from parameterized import parameterized
+
+from monai.transforms import VoteEnsembled
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    # shape: [1, 2, 1, 1]
+    TESTS.append(
+        [
+            {"keys": ["pred0", "pred1", "pred2"], "output_key": "output", "num_classes": None},
+            {
+                "pred0": p(torch.tensor([[[[1]], [[0]]]])),
+                "pred1": p(torch.tensor([[[[1]], [[0]]]])),
+                "pred2": p(torch.tensor([[[[0]], [[1]]]])),
+            },
+            p(torch.tensor([[[[1.0]], [[0.0]]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1, 1]
+    TESTS.append(
+        [
+            {"keys": "output", "output_key": "output", "num_classes": None},
+            {
+                "output": p(
+                    torch.stack(
+                        [torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[0]], [[1]]]])]
+                    )
+                )
+            },
+            p(torch.tensor([[[[1.0]], [[0.0]]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1]
+    TESTS.append(
+        [
+            {"keys": ["pred0", "pred1", "pred2"], "output_key": "output", "num_classes": 3},
+            {
+                "pred0": p(torch.tensor([[[0], [2]]])),
+                "pred1": p(torch.tensor([[[0], [2]]])),
+                "pred2": p(torch.tensor([[[1], [1]]])),
+            },
+            p(torch.tensor([[[0], [2]]])),
+        ]
+    )
+
+    # shape: [1, 2, 1]
+    TESTS.append(
+        [
+            {"keys": ["pred0", "pred1", "pred2"], "output_key": "output", "num_classes": 5},
+            {
+                "pred0": p(torch.tensor([[[0], [2]]])),
+                "pred1": p(torch.tensor([[[0], [2]]])),
+                "pred2": p(torch.tensor([[[1], [1]]])),
+            },
+            p(torch.tensor([[[0], [2]]])),
+        ]
+    )
+
+    # shape: [1]
+    TESTS.append(
+        [
+            {"keys": ["pred0", "pred1", "pred2"], "output_key": "output", "num_classes": 3},
+            {"pred0": p(torch.tensor([2])), "pred1": p(torch.tensor([2])), "pred2": p(torch.tensor([1]))},
+            p(torch.tensor([2])),
+        ]
+    )
+
+
+class TestVoteEnsembled(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input_param, img, expected_value):
+        result = VoteEnsembled(**input_param)(img)
+        assert_allclose(result["output"], expected_value)
+
+    def test_cuda_value(self):
+        img = torch.stack(
+            [torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[1]], [[0]]]]), torch.tensor([[[[0]], [[1]]]])]
+        )
+        expected_value = torch.tensor([[[[1.0]], [[0.0]]]])
+        if torch.cuda.is_available():
+            img = img.to(torch.device("cuda:0"))
+            expected_value = expected_value.to(torch.device("cuda:0"))
+        result = VoteEnsembled(keys="output", num_classes=None)({"output": img})
+        assert_allclose(result["output"], expected_value)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_with_allow_missing_keys.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 monai.transforms import Compose, SpatialPad, SpatialPadd, allow_missing_keys_mode
+
+
+class TestWithAllowMissingKeysMode(unittest.TestCase):
+
+    def setUp(self):
+        self.data = {"image": np.arange(16, dtype=float).reshape(1, 4, 4)}
+
+    def test_map_transform(self):
+        for amk in [True, False]:
+            t = SpatialPadd(["image", "label"], 10, allow_missing_keys=amk)
+            with allow_missing_keys_mode(t):
+                # check state is True
+                self.assertTrue(t.allow_missing_keys)
+                # and that transform works even though key is missing
+                _ = t(self.data)
+            # check it has returned to original state
+            self.assertEqual(t.allow_missing_keys, amk)
+            if not amk:
+                # should fail because amks==False and key is missing
+                with self.assertRaises(KeyError):
+                    _ = t(self.data)
+
+    def test_compose(self):
+        amks = [True, False, True]
+        t = Compose([SpatialPadd(["image", "label"], 10, allow_missing_keys=amk) for amk in amks])
+        with allow_missing_keys_mode(t):
+            # check states are all True
+            for _t in t.transforms:
+                self.assertTrue(_t.allow_missing_keys)
+            # and that transform works even though key is missing
+            _ = t(self.data)
+        # check they've returned to original state
+        for _t, amk in zip(t.transforms, amks):
+            self.assertEqual(_t.allow_missing_keys, amk)
+        # should fail because not all amks==True and key is missing
+        with self.assertRaises((KeyError, RuntimeError)):
+            _ = t(self.data)
+
+    def test_array_transform(self):
+        for t in [SpatialPad(10), Compose([SpatialPad(10)])]:
+            with self.assertRaises(TypeError):
+                with allow_missing_keys_mode(t):
+                    pass
+
+    def test_multiple(self):
+        orig_states = [True, False]
+        ts = [SpatialPadd(["image", "label"], 10, allow_missing_keys=i) for i in orig_states]
+        with allow_missing_keys_mode(ts):
+            for t in ts:
+                self.assertTrue(t.allow_missing_keys)
+                # and that transform works even though key is missing
+                _ = t(self.data)
+        for t, o_s in zip(ts, orig_states):
+            self.assertEqual(t.allow_missing_keys, o_s)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_zoom.py

@@ -0,0 +1,120 @@
+# 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 scipy.ndimage import zoom as zoom_scipy
+
+from monai.data import MetaTensor, set_track_meta
+from monai.transforms import Zoom
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import (
+    DEFAULT_TEST_AFFINE,
+    TEST_NDARRAYS_ALL,
+    NumpyImageTestCase2D,
+    assert_allclose,
+    test_local_inversion,
+)
+
+VALID_CASES = [
+    (1.5, "nearest", True),
+    (1.5, "nearest", False),
+    (0.8, "bilinear"),
+    (0.8, 1),
+    (0.8, "area"),
+    (1.5, "nearest", False, True),
+    (0.8, "area", False, True),
+]
+
+INVALID_CASES = [((None, None), "bilinear", TypeError), ((0.9, 0.9), "s", ValueError)]
+
+
+class TestZoom(NumpyImageTestCase2D):
+    @parameterized.expand(VALID_CASES)
+    def test_pending_ops(self, zoom, mode, align_corners=False, keep_size=False):
+        im = MetaTensor(self.imt[0], meta={"a": "b", "affine": DEFAULT_TEST_AFFINE})
+        zoom_fn = Zoom(
+            zoom=zoom, mode="bilinear", keep_size=keep_size, dtype=torch.float64, align_corners=align_corners
+        )
+        # non-lazy
+        expected = zoom_fn(im)
+        self.assertIsInstance(expected, MetaTensor)
+        # lazy
+        zoom_fn.lazy = True
+        pending_result = zoom_fn(im)
+        self.assertIsInstance(pending_result, MetaTensor)
+        assert_allclose(pending_result.peek_pending_affine(), expected.affine)
+        assert_allclose(pending_result.peek_pending_shape(), expected.shape[1:])
+        overrides = {"mode": "bilinear", "dtype": np.float64, "align_corners": align_corners}
+        result = apply_pending(pending_result, overrides=overrides)[0]
+        # compare
+        match_ratio = np.sum(np.isclose(result, expected)) / np.prod(result.shape)
+        self.assertGreater(match_ratio, 0.95)
+
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, zoom, mode, *_):
+        for p in TEST_NDARRAYS_ALL:
+            zoom_fn = Zoom(zoom=zoom, mode=mode, keep_size=False)
+            im = p(self.imt[0])
+            zoomed = zoom_fn(im)
+            test_local_inversion(zoom_fn, zoomed, im)
+            _order = 0
+            if mode == 1 or mode.endswith("linear"):
+                _order = 1
+            expected = []
+            for channel in self.imt[0]:
+                expected.append(zoom_scipy(channel, zoom=zoom, mode="nearest", order=_order, prefilter=False))
+            expected = np.stack(expected).astype(np.float32)
+            assert_allclose(zoomed, p(expected), atol=1.0, type_test=False)
+
+    def test_keep_size(self):
+        for p in TEST_NDARRAYS_ALL:
+            zoom_fn = Zoom(zoom=[0.6, 0.6], keep_size=True, align_corners=True)
+            im = p(self.imt[0])
+            zoomed = zoom_fn(im, mode="bilinear")
+            assert_allclose(zoomed.shape, self.imt.shape[1:], type_test=False)
+            test_local_inversion(zoom_fn, zoomed, im)
+
+            zoom_fn = Zoom(zoom=[1.3, 1.3], keep_size=True)
+            im = p(self.imt[0])
+            zoomed = zoom_fn(im)
+            assert_allclose(zoomed.shape, self.imt.shape[1:], type_test=False)
+            test_local_inversion(zoom_fn, zoomed, p(self.imt[0]))
+
+            set_track_meta(False)
+            rotated = zoom_fn(im)
+            self.assertNotIsInstance(rotated, MetaTensor)
+            np.testing.assert_allclose(zoomed.shape, self.imt.shape[1:])
+            set_track_meta(True)
+
+    @parameterized.expand(INVALID_CASES)
+    def test_invalid_inputs(self, zoom, mode, raises):
+        for p in TEST_NDARRAYS_ALL:
+            with self.assertRaises(raises):
+                zoom_fn = Zoom(zoom=zoom, mode=mode)
+                zoom_fn(p(self.imt[0]))
+
+    def test_padding_mode(self):
+        for p in TEST_NDARRAYS_ALL:
+            zoom_fn = Zoom(zoom=0.5, mode="nearest", padding_mode="constant", keep_size=True)
+            test_data = p([[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]])
+            zoomed = zoom_fn(test_data)
+            expected = p([[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])
+            assert_allclose(zoomed, expected, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_zoomd.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
+import torch
+from parameterized import parameterized
+from scipy.ndimage import zoom as zoom_scipy
+
+from monai.config import USE_COMPILED
+from monai.transforms import Zoomd
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, assert_allclose, test_local_inversion
+
+VALID_CASES = [
+    (1.5, "nearest", False),
+    (0.3, "bilinear", False, True),
+    (0.8, "bilinear", False, False),
+    (1.3, "bilinear", False),
+]
+
+INVALID_CASES = [("no_zoom", None, "bilinear", TypeError), ("invalid_order", 0.9, "s", ValueError)]
+
+
+class TestZoomd(NumpyImageTestCase2D):
+    @parameterized.expand(VALID_CASES)
+    def test_correct_results(self, zoom, mode, keep_size, align_corners=None):
+        key = "img"
+        init_param = {
+            "keys": key,
+            "zoom": zoom,
+            "mode": mode,
+            "keep_size": keep_size,
+            "dtype": torch.float64,
+            "align_corners": align_corners,
+        }
+        zoom_fn = Zoomd(**init_param)
+        for p in TEST_NDARRAYS_ALL:
+            im = p(self.imt[0])
+            call_param = {"data": {key: im}}
+            zoomed = zoom_fn(**call_param)
+
+            # test lazy
+            # TODO: temporarily skip "nearest" test
+            if mode == "bilinear":
+                test_resampler_lazy(
+                    zoom_fn, zoomed, init_param, call_param, output_key=key, atol=1e-4 if USE_COMPILED else 1e-6
+                )
+                zoom_fn.lazy = False
+
+            test_local_inversion(zoom_fn, zoomed, {key: im}, key)
+            _order = 0
+            if mode.endswith("linear"):
+                _order = 1
+            expected = [
+                zoom_scipy(channel, zoom=zoom, mode="nearest", order=_order, prefilter=False) for channel in self.imt[0]
+            ]
+
+            expected = np.stack(expected).astype(np.float32)
+            assert_allclose(zoomed[key], p(expected), atol=1.0, type_test=False)
+
+    def test_keep_size(self):
+        key = "img"
+        zoom_fn = Zoomd(key, zoom=0.6, keep_size=True, padding_mode="constant", constant_values=2)
+        for p in TEST_NDARRAYS_ALL:
+            zoomed = zoom_fn({key: p(self.imt[0])})
+            np.testing.assert_array_equal(zoomed[key].shape, self.imt.shape[1:])
+
+            zoom_fn = Zoomd(key, zoom=1.3, keep_size=True)
+            zoomed = zoom_fn({key: self.imt[0]})
+            self.assertTrue(np.array_equal(zoomed[key].shape, self.imt.shape[1:]))
+
+    @parameterized.expand(INVALID_CASES)
+    def test_invalid_inputs(self, _, zoom, mode, raises):
+        key = "img"
+        for p in TEST_NDARRAYS_ALL:
+            with self.assertRaises(raises):
+                zoom_fn = Zoomd(key, zoom=zoom, mode=mode)
+                zoom_fn({key: p(self.imt[0])})
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/transform/__init__.py

@@ -0,0 +1,10 @@
+# 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.

tests/transforms/transform/test_randomizable.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
+
+from monai.transforms.transform import Randomizable
+
+
+class RandTest(Randomizable):
+
+    def randomize(self, data=None):
+        pass
+
+
+class TestRandomizable(unittest.TestCase):
+
+    def test_default(self):
+        inst = RandTest()
+        r1 = inst.R.rand()
+        self.assertTrue(isinstance(inst.R, np.random.RandomState))
+        inst.set_random_state()
+        r2 = inst.R.rand()
+        self.assertNotAlmostEqual(r1, r2)
+
+    def test_seed(self):
+        inst = RandTest()
+        inst.set_random_state(seed=123)
+        self.assertAlmostEqual(inst.R.rand(), 0.69646918)
+        inst.set_random_state(123)
+        self.assertAlmostEqual(inst.R.rand(), 0.69646918)
+
+    def test_state(self):
+        inst = RandTest()
+        inst_r = np.random.RandomState(123)
+        inst.set_random_state(state=inst_r)
+        self.assertAlmostEqual(inst.R.rand(), 0.69646918)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/transform/test_randomizable_transform_type.py

@@ -0,0 +1,37 @@
+# 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.transform import RandomizableTrait, RandomizableTransform
+
+
+class InheritsInterface(RandomizableTrait):
+    pass
+
+
+class InheritsImplementation(RandomizableTransform):
+
+    def __call__(self, data):
+        return data
+
+
+class TestRandomizableTransformType(unittest.TestCase):
+
+    def test_is_randomizable_transform_type(self):
+        inst = InheritsInterface()
+        self.assertIsInstance(inst, RandomizableTrait)
+
+    def test_set_random_state_randomizable_transform(self):
+        inst = InheritsImplementation()
+        inst.set_random_state(0)

tests/transforms/utility/__init__.py

@@ -0,0 +1,10 @@
+# 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.