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

tests/transforms/test_affined.py

@@ -0,0 +1,190 @@
+# 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
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import Affined
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, test_local_inversion
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(-1, 0), device=device),
+                {"img": p(np.arange(9).reshape((1, 3, 3)))},
+                p(np.arange(9).reshape(1, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(-1, 0), device=device, dtype=None),
+                {"img": p(np.arange(9, dtype=float).reshape((1, 3, 3)))},
+                p(np.arange(9).reshape(1, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2)))},
+                p(np.arange(4).reshape(1, 2, 2)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(4, 4), device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2)))},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 2.0, 3.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", rotate_params=[np.pi / 2], padding_mode="zeros", spatial_size=(4, 4), device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2)))},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 3.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    keys="img",
+                    affine=p(torch.tensor([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])),
+                    padding_mode="zeros",
+                    spatial_size=(4, 4),
+                    device=device,
+                ),
+                {"img": p(np.arange(4).reshape((1, 2, 2)))},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 3.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(-1, 0, 0), device=device),
+                {"img": p(np.arange(27).reshape((1, 3, 3, 3)))},
+                p(np.arange(27).reshape(1, 3, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(-1, 0, 0), device=device, align_corners=False),
+                {"img": p(np.arange(27).reshape((1, 3, 3, 3)))},
+                p(np.arange(27).reshape(1, 3, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(keys="img", padding_mode="zeros", spatial_size=(4, 4, 4), device=device),
+                {"img": p(np.arange(8).reshape((1, 2, 2, 2)))},
+                p(
+                    np.array(
+                        [
+                            [
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 1.0, 0.0],
+                                    [0.0, 2.0, 3.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 4.0, 5.0, 0.0],
+                                    [0.0, 6.0, 7.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    keys="img", rotate_params=[np.pi / 2], padding_mode="zeros", spatial_size=(4, 4, 4), device=device
+                ),
+                {"img": p(np.arange(8).reshape((1, 2, 2, 2)))},
+                p(
+                    np.array(
+                        [
+                            [
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 2.0, 0.0, 0.0],
+                                    [0.0, 3.0, 1.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 6.0, 4.0, 0.0],
+                                    [0.0, 7.0, 5.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestAffined(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_affine(self, input_param, input_data, expected_val):
+        input_copy = deepcopy(input_data)
+        g = Affined(**input_param)
+        result = g(input_data)
+        test_local_inversion(g, result, input_copy, dict_key="img")
+        assert_allclose(result["img"], expected_val, rtol=1e-4, atol=1e-4, type_test="tensor")
+
+        # test lazy
+        lazy_input_param = input_param.copy()
+        for align_corners in [True, False]:
+            lazy_input_param["align_corners"] = align_corners
+            resampler = Affined(**lazy_input_param)
+            call_param = {"data": input_data}
+            non_lazy_result = resampler(**call_param)
+            test_resampler_lazy(resampler, non_lazy_result, lazy_input_param, call_param, output_key="img")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_as_channel_last.py

@@ -0,0 +1,38 @@
+# 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 AsChannelLast
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, {"channel_dim": 0}, (2, 3, 4, 1)])
+    TESTS.append([p, {"channel_dim": 1}, (1, 3, 4, 2)])
+    TESTS.append([p, {"channel_dim": 3}, (1, 2, 3, 4)])
+
+
+class TestAsChannelLast(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, in_type, input_param, expected_shape):
+        test_data = in_type(np.random.randint(0, 2, size=[1, 2, 3, 4]))
+        result = AsChannelLast(**input_param)(test_data)
+        self.assertTupleEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_as_channel_lastd.py

@@ -0,0 +1,44 @@
+# 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 AsChannelLastd
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, {"keys": ["image", "label", "extra"], "channel_dim": 0}, (2, 3, 4, 1)])
+    TESTS.append([p, {"keys": ["image", "label", "extra"], "channel_dim": 1}, (1, 3, 4, 2)])
+    TESTS.append([p, {"keys": ["image", "label", "extra"], "channel_dim": 3}, (1, 2, 3, 4)])
+
+
+class TestAsChannelLastd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, in_type, input_param, expected_shape):
+        test_data = {
+            "image": in_type(np.random.randint(0, 2, size=[1, 2, 3, 4])),
+            "label": in_type(np.random.randint(0, 2, size=[1, 2, 3, 4])),
+            "extra": in_type(np.random.randint(0, 2, size=[1, 2, 3, 4])),
+        }
+        result = AsChannelLastd(**input_param)(test_data)
+        self.assertTupleEqual(result["image"].shape, expected_shape)
+        self.assertTupleEqual(result["label"].shape, expected_shape)
+        self.assertTupleEqual(result["extra"].shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_as_discrete.py

@@ -0,0 +1,81 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import AsDiscrete
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TEST_CASES = []
+for p in TEST_NDARRAYS:
+    TEST_CASES.append(
+        [
+            {"argmax": True, "to_onehot": None, "threshold": 0.5},
+            p([[[0.0, 1.0]], [[2.0, 3.0]]]),
+            p([[[1.0, 1.0]]]),
+            (1, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"argmax": True, "to_onehot": 2, "threshold": 0.5, "dim": 0},
+            p([[[0.0, 1.0]], [[2.0, 3.0]]]),
+            p([[[0.0, 0.0]], [[1.0, 1.0]]]),
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"argmax": False, "to_onehot": None, "threshold": 0.6},
+            p([[[0.0, 1.0], [2.0, 3.0]]]),
+            p([[[0.0, 1.0], [1.0, 1.0]]]),
+            (1, 2, 2),
+        ]
+    )
+
+    # test threshold = 0.0
+    TEST_CASES.append(
+        [
+            {"argmax": False, "to_onehot": None, "threshold": 0.0},
+            p([[[0.0, -1.0], [-2.0, 3.0]]]),
+            p([[[1.0, 0.0], [0.0, 1.0]]]),
+            (1, 2, 2),
+        ]
+    )
+
+    TEST_CASES.append([{"argmax": False, "to_onehot": 3}, p(1), p([0.0, 1.0, 0.0]), (3,)])
+
+    TEST_CASES.append(
+        [{"rounding": "torchrounding"}, p([[[0.123, 1.345], [2.567, 3.789]]]), p([[[0.0, 1.0], [3.0, 4.0]]]), (1, 2, 2)]
+    )
+
+
+class TestAsDiscrete(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_value_shape(self, input_param, img, out, expected_shape):
+        result = AsDiscrete(**input_param)(img)
+        assert_allclose(result, out, rtol=1e-3, type_test="tensor")
+        self.assertTupleEqual(result.shape, expected_shape)
+
+    def test_additional(self):
+        for p in TEST_NDARRAYS:
+            out = AsDiscrete(argmax=True, dim=1, keepdim=False)(p([[[0.0, 1.0]], [[2.0, 3.0]]]))
+            assert_allclose(out, p([[0.0, 0.0], [0.0, 0.0]]), type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_as_discreted.py

@@ -0,0 +1,82 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import AsDiscreted
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TEST_CASES = []
+for p in TEST_NDARRAYS:
+    TEST_CASES.append(
+        [
+            {"keys": ["pred", "label"], "argmax": [True, False], "to_onehot": 2, "threshold": 0.5},
+            {"pred": p([[[0.0, 1.0]], [[2.0, 3.0]]]), "label": p([[[0, 1]]])},
+            {"pred": p([[[0.0, 0.0]], [[1.0, 1.0]]]), "label": p([[[1.0, 0.0]], [[0.0, 1.0]]])},
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"keys": ["pred", "label"], "argmax": False, "to_onehot": None, "threshold": [0.6, None]},
+            {"pred": p([[[0.0, 1.0], [2.0, 3.0]]]), "label": p([[[0, 1], [1, 1]]])},
+            {"pred": p([[[0.0, 1.0], [1.0, 1.0]]]), "label": p([[[0.0, 1.0], [1.0, 1.0]]])},
+            (1, 2, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"keys": ["pred"], "argmax": True, "to_onehot": 2, "threshold": 0.5, "dim": 0, "keepdim": True},
+            {"pred": p([[[0.0, 1.0]], [[2.0, 3.0]]])},
+            {"pred": p([[[0.0, 0.0]], [[1.0, 1.0]]])},
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"keys": "pred", "rounding": "torchrounding"},
+            {"pred": p([[[0.123, 1.345], [2.567, 3.789]]])},
+            {"pred": p([[[0.0, 1.0], [3.0, 4.0]]])},
+            (1, 2, 2),
+        ]
+    )
+
+    # test threshold = 0.0
+    TEST_CASES.append(
+        [
+            {"keys": ["pred", "label"], "argmax": False, "to_onehot": None, "threshold": [0.0, None]},
+            {"pred": p([[[0.0, -1.0], [-2.0, 3.0]]]), "label": p([[[0, 1], [1, 1]]])},
+            {"pred": p([[[1.0, 0.0], [0.0, 1.0]]]), "label": p([[[0.0, 1.0], [1.0, 1.0]]])},
+            (1, 2, 2),
+        ]
+    )
+
+
+class TestAsDiscreted(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_value_shape(self, input_param, test_input, output, expected_shape):
+        result = AsDiscreted(**input_param)(test_input)
+        assert_allclose(result["pred"], output["pred"], rtol=1e-3, type_test="tensor")
+        self.assertTupleEqual(result["pred"].shape, expected_shape)
+        if "label" in result:
+            assert_allclose(result["label"], output["label"], rtol=1e-3, type_test="tensor")
+            self.assertTupleEqual(result["label"].shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_border_pad.py

@@ -0,0 +1,49 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import BorderPad
+from monai.utils.enums import NumpyPadMode, PytorchPadMode
+from tests.padders import PadTest
+
+TESTS = [
+    [{"spatial_border": 2}, (3, 8, 8, 4), (3, 12, 12, 8)],
+    [{"spatial_border": [1, 2, 3]}, (3, 8, 8, 4), (3, 10, 12, 10)],
+    [{"spatial_border": [1, 2, 3, 4, 5, 6]}, (3, 8, 8, 4), (3, 11, 15, 15)],
+    [{"spatial_border": [1, 2, 3, 4, 5, 6]}, (3, 8, 8, 4), (3, 11, 15, 15)],
+]
+
+
+class TestBorderPad(PadTest):
+    Padder = BorderPad
+
+    @parameterized.expand(TESTS)
+    def test_pad(self, input_param, input_shape, expected_shape):
+        modes = ["constant", NumpyPadMode.CONSTANT, PytorchPadMode.CONSTANT]
+        self.pad_test(input_param, input_shape, expected_shape, modes)
+
+    def test_pad_kwargs(self):
+        kwargs = {"spatial_border": 2, "mode": "constant"}
+        unchanged_slices = [slice(None), slice(2, -2), slice(2, -2)]
+        self.pad_test_kwargs(unchanged_slices, **kwargs)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.pad_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_border_padd.py

@@ -0,0 +1,45 @@
+# 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 parameterized import parameterized
+
+from monai.transforms import BorderPadd
+from monai.utils.enums import NumpyPadMode, PytorchPadMode
+from tests.padders import PadTest
+
+TESTS = [
+    [{"keys": "img", "spatial_border": 2}, (3, 8, 8, 4), (3, 12, 12, 8)],
+    [{"keys": "img", "spatial_border": [1, 2, 3]}, (3, 8, 8, 4), (3, 10, 12, 10)],
+    [{"keys": "img", "spatial_border": [1, 2, 3, 4, 5, 6]}, (3, 8, 8, 4), (3, 11, 15, 15)],
+    [{"keys": "img", "spatial_border": 2}, (3, 8, 8, 4), (3, 12, 12, 8)],
+    [{"keys": "img", "spatial_border": 2}, (3, 8, 8, 4), (3, 12, 12, 8)],
+]
+
+
+class TestBorderPadd(PadTest):
+    Padder = BorderPadd
+
+    @parameterized.expand(TESTS)
+    def test_pad(self, input_param, input_shape, expected_shape):
+        modes = ["constant", NumpyPadMode.CONSTANT, PytorchPadMode.CONSTANT, "edge", NumpyPadMode.EDGE]
+        self.pad_test(input_param, input_shape, expected_shape, modes)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, input_param, input_shape, _):
+        self.pad_test_pending_ops(input_param, input_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_bounding_rect.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
+
+import monai
+from monai.transforms import BoundingRect
+from tests.test_utils import TEST_NDARRAYS
+
+TEST_CASE_1 = [(2, 3), [[0, 0], [1, 2]]]
+
+TEST_CASE_2 = [(1, 8, 10), [[0, 7, 1, 9]]]
+
+TEST_CASE_3 = [(2, 16, 20, 18), [[0, 16, 0, 20, 0, 18], [0, 16, 0, 20, 0, 18]]]
+
+
+class TestBoundingRect(unittest.TestCase):
+    def setUp(self):
+        monai.utils.set_determinism(1)
+
+    def tearDown(self):
+        monai.utils.set_determinism(None)
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_shape(self, input_shape, expected):
+        test_data = np.random.randint(0, 8, size=input_shape)
+        test_data = test_data == 7
+        for p in TEST_NDARRAYS:
+            result = BoundingRect()(p(test_data))
+            np.testing.assert_allclose(result, expected)
+
+    def test_select_fn(self):
+        test_data = np.random.randint(0, 8, size=(2, 3))
+        test_data = test_data == 7
+        for p in TEST_NDARRAYS:
+            bbox = BoundingRect(select_fn=lambda x: x < 1)(p(test_data))
+            np.testing.assert_allclose(bbox, [[0, 3], [0, 3]])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_bounding_rectd.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 parameterized import parameterized
+
+import monai
+from monai.transforms import BoundingRectD
+from tests.test_utils import TEST_NDARRAYS
+
+TEST_CASE_1 = [(2, 3), [[0, 0], [1, 2]]]
+
+TEST_CASE_2 = [(1, 8, 10), [[0, 7, 1, 9]]]
+
+TEST_CASE_3 = [(2, 16, 20, 18), [[0, 16, 0, 20, 0, 18], [0, 16, 0, 20, 0, 18]]]
+
+
+class TestBoundingRectD(unittest.TestCase):
+    def setUp(self):
+        monai.utils.set_determinism(1)
+
+    def tearDown(self):
+        monai.utils.set_determinism(None)
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_shape(self, input_shape, expected):
+        test_data = np.random.randint(0, 8, size=input_shape)
+        test_data = test_data == 7
+        for p in TEST_NDARRAYS:
+            result = BoundingRectD("image")({"image": p(test_data)})
+            np.testing.assert_allclose(result["image_bbox"], expected)
+
+            result = BoundingRectD("image", "cc")({"image": p(test_data)})
+            np.testing.assert_allclose(result["image_cc"], expected)
+
+            with self.assertRaises(KeyError):
+                BoundingRectD("image", "cc")({"image": p(test_data), "image_cc": None})
+
+
+if __name__ == "__main__":
+    unittest.main()