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

tests/transforms/test_grid_split.py

@@ -0,0 +1,88 @@
+# 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 GridSplit
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+A11 = torch.randn(3, 2, 2)
+A12 = torch.randn(3, 2, 2)
+A21 = torch.randn(3, 2, 2)
+A22 = torch.randn(3, 2, 2)
+
+A1 = torch.cat([A11, A12], 2)
+A2 = torch.cat([A21, A22], 2)
+A = torch.cat([A1, A2], 1)
+
+TEST_CASE_0 = [{"grid": (2, 2)}, A, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"grid": (2, 1)}, A, [A1, A2]]
+TEST_CASE_2 = [{"grid": (1, 2)}, A1, [A11, A12]]
+TEST_CASE_3 = [{"grid": (1, 2)}, A2, [A21, A22]]
+TEST_CASE_4 = [{"grid": (1, 1), "size": (2, 2)}, A, [A11]]
+TEST_CASE_5 = [{"grid": (1, 1), "size": 4}, A, [A]]
+TEST_CASE_6 = [{"grid": (2, 2), "size": 2}, A, [A11, A12, A21, A22]]
+TEST_CASE_7 = [{"grid": (1, 1)}, A, [A]]
+TEST_CASE_8 = [
+    {"grid": (2, 2), "size": 2},
+    torch.arange(12).reshape(1, 3, 4).to(torch.float32),
+    torch.Tensor([[[[0, 1], [4, 5]]], [[[2, 3], [6, 7]]], [[[4, 5], [8, 9]]], [[[6, 7], [10, 11]]]]).to(torch.float32),
+]
+
+TEST_SINGLE = []
+for p in TEST_NDARRAYS:
+    TEST_SINGLE.append([p, *TEST_CASE_0])
+    TEST_SINGLE.append([p, *TEST_CASE_1])
+    TEST_SINGLE.append([p, *TEST_CASE_2])
+    TEST_SINGLE.append([p, *TEST_CASE_3])
+    TEST_SINGLE.append([p, *TEST_CASE_4])
+    TEST_SINGLE.append([p, *TEST_CASE_5])
+    TEST_SINGLE.append([p, *TEST_CASE_6])
+    TEST_SINGLE.append([p, *TEST_CASE_7])
+    TEST_SINGLE.append([p, *TEST_CASE_8])
+
+TEST_CASE_MC_0 = [{"grid": (2, 2)}, [A, A], [[A11, A12, A21, A22], [A11, A12, A21, A22]]]
+TEST_CASE_MC_1 = [{"grid": (2, 1)}, [A] * 5, [[A1, A2]] * 5]
+TEST_CASE_MC_2 = [{"grid": (1, 2)}, [A1, A2], [[A11, A12], [A21, A22]]]
+
+TEST_MULTIPLE = []
+for p in TEST_NDARRAYS:
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_0])
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_1])
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_2])
+
+
+class TestGridSplit(unittest.TestCase):
+    @parameterized.expand(TEST_SINGLE)
+    def test_split_patch_single_call(self, in_type, input_parameters, image, expected):
+        input_image = in_type(image)
+        splitter = GridSplit(**input_parameters)
+        output = splitter(input_image)
+        for output_patch, expected_patch in zip(output, expected):
+            assert_allclose(output_patch, expected_patch, type_test=False)
+
+    @parameterized.expand(TEST_MULTIPLE)
+    def test_split_patch_multiple_call(self, in_type, input_parameters, img_list, expected_list):
+        splitter = GridSplit(**input_parameters)
+        for image, expected in zip(img_list, expected_list):
+            input_image = in_type(image)
+            output = splitter(input_image)
+            for output_patch, expected_patch in zip(output, expected):
+                assert_allclose(output_patch, expected_patch, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_grid_splitd.py

@@ -0,0 +1,96 @@
+# 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 GridSplitd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+A11 = torch.randn(3, 2, 2)
+A12 = torch.randn(3, 2, 2)
+A21 = torch.randn(3, 2, 2)
+A22 = torch.randn(3, 2, 2)
+
+A1 = torch.cat([A11, A12], 2)
+A2 = torch.cat([A21, A22], 2)
+A = torch.cat([A1, A2], 1)
+
+TEST_CASE_0 = [{"keys": "image", "grid": (2, 2)}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_1 = [{"keys": "image", "grid": (2, 1)}, {"image": A}, [A1, A2]]
+TEST_CASE_2 = [{"keys": "image", "grid": (1, 2)}, {"image": A1}, [A11, A12]]
+TEST_CASE_3 = [{"keys": "image", "grid": (1, 2)}, {"image": A2}, [A21, A22]]
+TEST_CASE_4 = [{"keys": "image", "grid": (1, 1), "size": {"image": (2, 2)}}, {"image": A}, [A11]]
+TEST_CASE_5 = [{"keys": "image", "grid": (1, 1), "size": {"image": 4}}, {"image": A}, [A]]
+TEST_CASE_6 = [{"keys": "image", "grid": (2, 2), "size": {"image": 2}}, {"image": A}, [A11, A12, A21, A22]]
+TEST_CASE_7 = [{"keys": "image", "grid": (1, 1)}, {"image": A}, [A]]
+TEST_CASE_8 = [
+    {"keys": "image", "grid": (2, 2), "size": {"image": 2}},
+    {"image": torch.arange(12).reshape(1, 3, 4).to(torch.float32)},
+    torch.Tensor([[[[0, 1], [4, 5]]], [[[2, 3], [6, 7]]], [[[4, 5], [8, 9]]], [[[6, 7], [10, 11]]]]).to(torch.float32),
+]
+
+TEST_SINGLE = []
+for p in TEST_NDARRAYS:
+    TEST_SINGLE.append([p, *TEST_CASE_0])
+    TEST_SINGLE.append([p, *TEST_CASE_1])
+    TEST_SINGLE.append([p, *TEST_CASE_2])
+    TEST_SINGLE.append([p, *TEST_CASE_3])
+    TEST_SINGLE.append([p, *TEST_CASE_4])
+    TEST_SINGLE.append([p, *TEST_CASE_5])
+    TEST_SINGLE.append([p, *TEST_CASE_6])
+    TEST_SINGLE.append([p, *TEST_CASE_7])
+    TEST_SINGLE.append([p, *TEST_CASE_8])
+
+TEST_CASE_MC_0 = [
+    {"keys": "image", "grid": (2, 2)},
+    [{"image": A}, {"image": A}],
+    [[A11, A12, A21, A22], [A11, A12, A21, A22]],
+]
+TEST_CASE_MC_1 = [{"keys": "image", "grid": (2, 1)}, [{"image": A}, {"image": A}, {"image": A}], [[A1, A2]] * 3]
+TEST_CASE_MC_2 = [{"keys": "image", "grid": (1, 2)}, [{"image": A1}, {"image": A2}], [[A11, A12], [A21, A22]]]
+
+TEST_MULTIPLE = []
+for p in TEST_NDARRAYS:
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_0])
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_1])
+    TEST_MULTIPLE.append([p, *TEST_CASE_MC_2])
+
+
+class TestGridSplitd(unittest.TestCase):
+    @parameterized.expand(TEST_SINGLE)
+    def test_split_patch_single_call(self, in_type, input_parameters, img_dict, expected):
+        input_dict = {}
+        for k, v in img_dict.items():
+            input_dict[k] = in_type(v)
+        splitter = GridSplitd(**input_parameters)
+        output = splitter(input_dict)
+        for output_patch, expected_patch in zip(output, expected):
+            assert_allclose(output_patch[input_parameters["keys"]], expected_patch, type_test=False)
+
+    @parameterized.expand(TEST_MULTIPLE)
+    def test_split_patch_multiple_call(self, in_type, input_parameters, img_list, expected_list):
+        splitter = GridSplitd(**input_parameters)
+        for img_dict, expected in zip(img_list, expected_list):
+            input_dict = {}
+            for k, v in img_dict.items():
+                input_dict[k] = in_type(v)
+            output = splitter(input_dict)
+            for output_patch, expected_patch in zip(output, expected):
+                assert_allclose(output_patch[input_parameters["keys"]], expected_patch, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_histogram_normalize.py

@@ -0,0 +1,59 @@
+# 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 HistogramNormalize
+from monai.utils import get_equivalent_dtype
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"num_bins": 4, "min": 1, "max": 5, "mask": np.array([1, 1, 1, 1, 1, 0])},
+            p(np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])),
+            p(np.array([1.0, 1.5, 2.5, 4.0, 5.0, 5.0])),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"num_bins": 4, "max": 4, "dtype": np.uint8},
+            p(np.array([0.0, 1.0, 2.0, 3.0, 4.0])),
+            p(np.array([0, 0, 1, 3, 4])),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"num_bins": 256, "max": 255, "dtype": np.uint8},
+            p(np.array([[[100.0, 200.0], [150.0, 250.0]]])),
+            p(np.array([[[0, 170], [70, 255]]])),
+        ]
+    )
+
+
+class TestHistogramNormalize(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = HistogramNormalize(**arguments)(image)
+        assert_allclose(result, expected_data, type_test="tensor")
+        self.assertEqual(get_equivalent_dtype(result.dtype, data_type=np.ndarray), arguments.get("dtype", np.float32))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_histogram_normalized.py

@@ -0,0 +1,59 @@
+# 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 HistogramNormalized
+from monai.utils import get_equivalent_dtype
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": "img", "num_bins": 4, "min": 1, "max": 5, "mask_key": "mask"},
+            {"img": p(np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])), "mask": p(np.array([1, 1, 1, 1, 1, 0]))},
+            p(np.array([1.0, 1.5, 2.5, 4.0, 5.0, 5.0])),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "num_bins": 4, "max": 4, "dtype": np.uint8},
+            {"img": p(np.array([0.0, 1.0, 2.0, 3.0, 4.0]))},
+            p(np.array([0, 0, 1, 3, 4])),
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": "img", "num_bins": 256, "max": 255, "dtype": np.uint8},
+            {"img": p(np.array([[[100.0, 200.0], [150.0, 250.0]]]))},
+            p(np.array([[[0, 170], [70, 255]]])),
+        ]
+    )
+
+
+class TestHistogramNormalized(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, arguments, image, expected_data):
+        result = HistogramNormalized(**arguments)(image)["img"]
+        assert_allclose(result, expected_data, type_test="tensor")
+        self.assertEqual(get_equivalent_dtype(result.dtype, data_type=np.ndarray), arguments.get("dtype", np.float32))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_image_filter.py

@@ -0,0 +1,259 @@
+# 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.data.meta_tensor import MetaTensor
+from monai.networks.layers.simplelayers import GaussianFilter
+from monai.transforms import ImageFilter, ImageFilterd, RandImageFilter, RandImageFilterd
+
+EXPECTED_FILTERS = {
+    "mean": torch.tensor([[1, 1, 1], [1, 1, 1], [1, 1, 1]]).float(),
+    "laplace": torch.tensor([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]).float(),
+    "elliptical": torch.tensor([[0, 1, 0], [1, 1, 1], [0, 1, 0]]).float(),
+    "sharpen": torch.tensor([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]).float(),
+}
+
+SUPPORTED_FILTERS = ["mean", "laplace", "elliptical", "sobel", "sharpen", "median", "gauss", "savitzky_golay"]
+SAMPLE_IMAGE_2D = torch.randn(1, 10, 10)
+SAMPLE_IMAGE_3D = torch.randn(1, 10, 10, 10)
+SAMPLE_DICT = {"image_2d": SAMPLE_IMAGE_2D, "image_3d": SAMPLE_IMAGE_3D}
+
+# Sobel filter uses reflect pad as default which is not implemented for 3d in torch 1.8.1 or 1.9.1
+ADDITIONAL_ARGUMENTS = {"order": 1, "sigma": 1, "padding_mode": "zeros"}
+
+
+class TestModule(torch.nn.Module):
+    __test__ = False  # indicate to pytest that this class is not intended for collection
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return x + 1
+
+
+class TestNotAModuleOrTransform:
+    pass
+
+
+class TestImageFilter(unittest.TestCase):
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_init_from_string(self, filter_name):
+        "Test init from string"
+        _ = ImageFilter(filter_name, 3, **ADDITIONAL_ARGUMENTS)
+
+    def test_init_raises(self):
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter("mean")
+            self.assertTrue("`filter_size` must be specified when specifying filters by string." in str(context.output))
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter("mean")
+            self.assertTrue("`filter_size` should be a single uneven integer." in str(context.output))
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter("gauss", 3)
+            self.assertTrue("`filter='gauss', requires the additonal keyword argument `sigma`" in str(context.output))
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter("savitzky_golay", 3)
+            self.assertTrue(
+                "`filter='savitzky_golay', requires the additonal keyword argument `order`" in str(context.output)
+            )
+
+    def test_init_from_array(self):
+        "Test init with custom filter and assert wrong filter shape throws an error"
+        _ = ImageFilter(torch.ones(3, 3))
+        _ = ImageFilter(torch.ones(3, 3, 3))
+        _ = ImageFilter(np.ones((3, 3)))
+        _ = ImageFilter(np.ones((3, 3, 3)))
+
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter(torch.ones(3, 3, 3, 3))
+            self.assertTrue("Only 1D, 2D, and 3D filters are supported." in str(context.output))
+
+    def test_init_from_module(self):
+        filter = ImageFilter(TestModule())
+        out = filter(torch.zeros(1, 3, 3, 3))
+        torch.testing.assert_allclose(torch.ones(1, 3, 3, 3), out)
+
+    def test_init_from_transform(self):
+        _ = ImageFilter(GaussianFilter(3, sigma=2))
+
+    def test_init_from_wrong_type_fails(self):
+        with self.assertRaises(Exception) as context:
+            _ = ImageFilter(TestNotAModuleOrTransform())
+            self.assertTrue("<class 'type'> is not supported." in str(context.output))
+
+    @parameterized.expand(EXPECTED_FILTERS.keys())
+    def test_2d_filter_correctness(self, filter_name):
+        "Test correctness of filters (2d only)"
+        tfm = ImageFilter(filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        filter = tfm._get_filter_from_string(filter_name, size=3, ndim=2).filter.squeeze()
+        torch.testing.assert_allclose(filter, EXPECTED_FILTERS[filter_name])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d(self, filter_name):
+        "Text function `__call__` for 2d images"
+        filter = ImageFilter(filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_2D)
+        self.assertEqual(out_tensor.shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d(self, filter_name):
+        "Text function `__call__` for 3d images"
+        filter = ImageFilter(filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_3D)
+        self.assertEqual(out_tensor.shape[1:], SAMPLE_IMAGE_3D.shape[1:])
+
+    def test_pass_applied_operations(self):
+        "Test that applied operations are passed through"
+        applied_operations = ["op1", "op2"]
+        image = MetaTensor(SAMPLE_IMAGE_2D, applied_operations=applied_operations)
+        filter = ImageFilter(SUPPORTED_FILTERS[0], 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(image)
+        self.assertEqual(out_tensor.applied_operations, applied_operations)
+
+    def test_pass_empty_metadata_dict(self):
+        "Test that applied operations are passed through"
+        image = MetaTensor(SAMPLE_IMAGE_2D, meta={})
+        filter = ImageFilter(SUPPORTED_FILTERS[0], 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(image)
+        self.assertTrue(isinstance(out_tensor, MetaTensor))
+
+    def test_gaussian_filter_without_filter_size(self):
+        "Test Gaussian filter without specifying filter_size"
+        filter = ImageFilter("gauss", sigma=2)
+        out_tensor = filter(SAMPLE_IMAGE_2D)
+        self.assertEqual(out_tensor.shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+
+class TestImageFilterDict(unittest.TestCase):
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_init_from_string_dict(self, filter_name):
+        "Test init from string and assert an error is thrown if no size is passed"
+        _ = ImageFilterd("image", filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        with self.assertRaises(Exception) as _:
+            _ = ImageFilterd(self.image_key, filter_name)
+
+    def test_init_from_array_dict(self):
+        "Test init with custom filter and assert wrong filter shape throws an error"
+        _ = ImageFilterd("image", torch.ones(3, 3))
+        with self.assertRaises(Exception) as _:
+            _ = ImageFilterd(self.image_key, torch.ones(3, 3, 3, 3))
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d(self, filter_name):
+        "Text function `__call__` for 2d images"
+        filter = ImageFilterd("image_2d", filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        self.assertEqual(out_tensor["image_2d"].shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d(self, filter_name):
+        "Text function `__call__` for 3d images"
+        filter = ImageFilterd("image_3d", filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        self.assertEqual(out_tensor["image_3d"].shape[1:], SAMPLE_IMAGE_3D.shape[1:])
+
+
+class TestRandImageFilter(unittest.TestCase):
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_init_from_string(self, filter_name):
+        "Test init from string and assert an error is thrown if no size is passed"
+        _ = RandImageFilter(filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        with self.assertRaises(Exception) as _:
+            _ = RandImageFilter(filter_name)
+
+    def test_init_from_array(self):
+        "Test init with custom filter and assert wrong filter shape throws an error"
+        _ = RandImageFilter(torch.ones(3, 3))
+        with self.assertRaises(Exception) as _:
+            _ = RandImageFilter(torch.ones(3, 3, 3, 3))
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d_prob_1(self, filter_name):
+        "Text function `__call__` for 2d images"
+        filter = RandImageFilter(filter_name, 3, 1, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_2D)
+        self.assertEqual(out_tensor.shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d_prob_1(self, filter_name):
+        "Text function `__call__` for 3d images"
+        filter = RandImageFilter(filter_name, 3, 1, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_3D)
+        self.assertEqual(out_tensor.shape[1:], SAMPLE_IMAGE_3D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d_prob_0(self, filter_name):
+        "Text function `__call__` for 2d images"
+        filter = RandImageFilter(filter_name, 3, 0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_2D)
+        torch.testing.assert_allclose(out_tensor, SAMPLE_IMAGE_2D)
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d_prob_0(self, filter_name):
+        "Text function `__call__` for 3d images"
+        filter = RandImageFilter(filter_name, 3, 0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_IMAGE_3D)
+        torch.testing.assert_allclose(out_tensor, SAMPLE_IMAGE_3D)
+
+
+class TestRandImageFilterDict(unittest.TestCase):
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_init_from_string_dict(self, filter_name):
+        "Test init from string and assert an error is thrown if no size is passed"
+        _ = RandImageFilterd("image", filter_name, 3, **ADDITIONAL_ARGUMENTS)
+        with self.assertRaises(Exception) as _:
+            _ = RandImageFilterd("image", filter_name)
+
+    def test_init_from_array_dict(self):
+        "Test init with custom filter and assert wrong filter shape throws an error"
+        _ = RandImageFilterd("image", torch.ones(3, 3))
+        with self.assertRaises(Exception) as _:
+            _ = RandImageFilterd("image", torch.ones(3, 3, 3, 3))
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d_prob_1(self, filter_name):
+        filter = RandImageFilterd("image_2d", filter_name, 3, 1.0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        self.assertEqual(out_tensor["image_2d"].shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d_prob_1(self, filter_name):
+        filter = RandImageFilterd("image_3d", filter_name, 3, 1.0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        self.assertEqual(out_tensor["image_3d"].shape[1:], SAMPLE_IMAGE_3D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_2d_prob_0(self, filter_name):
+        filter = RandImageFilterd("image_2d", filter_name, 3, 0.0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        torch.testing.assert_allclose(out_tensor["image_2d"].shape[1:], SAMPLE_IMAGE_2D.shape[1:])
+
+    @parameterized.expand(SUPPORTED_FILTERS)
+    def test_call_3d_prob_0(self, filter_name):
+        filter = RandImageFilterd("image_3d", filter_name, 3, 0.0, **ADDITIONAL_ARGUMENTS)
+        out_tensor = filter(SAMPLE_DICT)
+        torch.testing.assert_allclose(out_tensor["image_3d"].shape[1:], SAMPLE_IMAGE_3D.shape[1:])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_intensity_stats.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 IntensityStats
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.extend(
+        [
+            [
+                {"ops": ["max", "mean"], "key_prefix": "orig"},
+                p([[[0.0, 1.0], [2.0, 3.0]]]),
+                {"affine": None},
+                {"orig_max": 3.0, "orig_mean": 1.5},
+            ],
+            [{"ops": "std", "key_prefix": "orig"}, p([[[0.0, 1.0], [2.0, 3.0]]]), None, {"orig_std": 1.118034}],
+            [
+                {"ops": [np.mean, "max", np.min], "key_prefix": "orig"},
+                p([[[0.0, 1.0], [2.0, 3.0]]]),
+                None,
+                {"orig_custom_0": 1.5, "orig_max": 3.0, "orig_custom_1": 0.0},
+            ],
+            [
+                {"ops": ["max", "mean"], "key_prefix": "orig", "channel_wise": True},
+                p([[[0.0, 1.0], [2.0, 3.0]], [[4.0, 5.0], [6.0, 7.0]]]),
+                {"affine": None},
+                {"orig_max": [3.0, 7.0], "orig_mean": [1.5, 5.5]},
+            ],
+            [
+                {"ops": ["max", "mean"], "key_prefix": "orig"},
+                p([[[0.0, 1.0], [2.0, 3.0]]]),
+                {"affine": None},
+                {"orig_max": 3.0, "orig_mean": 1.5},
+            ],
+        ]
+    )
+
+
+class TestIntensityStats(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input_param, img, meta_dict, expected):
+        _, meta_dict = IntensityStats(**input_param)(img, meta_dict)
+        for k, v in expected.items():
+            self.assertTrue(k in meta_dict)
+            np.testing.assert_allclose(v, meta_dict[k], atol=1e-3)
+
+    def test_mask(self):
+        for p in TEST_NDARRAYS:
+            img = p([[[0.0, 1.0], [2.0, 3.0]]])
+            mask = np.array([[[1, 0], [1, 0]]], dtype=bool)
+            img, meta_dict = IntensityStats(ops=["max", "mean"], key_prefix="orig")(img, mask=mask)
+            np.testing.assert_allclose(meta_dict["orig_max"], 2.0, atol=1e-3)
+            np.testing.assert_allclose(meta_dict["orig_mean"], 1.0, atol=1e-3)
+
+
+if __name__ == "__main__":
+    unittest.main()