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

tests/transforms/test_convert_to_multi_channeld.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
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import ConvertToMultiChannelBasedOnBratsClassesd
+
+TEST_CASE = [
+    {"keys": "label"},
+    {"label": np.array([[0, 1, 2], [1, 2, 4], [0, 1, 4]])},
+    np.array([[[0, 1, 0], [1, 0, 1], [0, 1, 1]], [[0, 1, 1], [1, 1, 1], [0, 1, 1]], [[0, 0, 0], [0, 0, 1], [0, 0, 1]]]),
+]
+
+
+class TestConvertToMultiChanneld(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE])
+    def test_type_shape(self, keys, data, expected_result):
+        result = ConvertToMultiChannelBasedOnBratsClassesd(**keys)(data)
+        np.testing.assert_equal(result["label"], expected_result)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_copy_itemsd.py

@@ -0,0 +1,86 @@
+# 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.networks import eval_mode
+from monai.transforms import CopyItemsd
+from monai.utils import ensure_tuple
+from tests.test_utils import assert_allclose
+
+TEST_CASE_1 = ["img", 1, "img_1"]
+
+TEST_CASE_2 = [["img", "seg"], 1, ["img_1", "seg_1"]]
+
+TEST_CASE_3 = ["img", 2, ["img_1", "img_2"]]
+
+TEST_CASE_4 = [["img", "seg"], 2, ["img_1", "seg_1", "img_2", "seg_2"]]
+
+
+class TestCopyItemsd(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
+    def test_numpy_values(self, keys, times, names):
+        input_data = {"img": np.array([[0, 1], [1, 2]]), "seg": np.array([[3, 4], [4, 5]])}
+        result = CopyItemsd(keys=keys, times=times, names=names)(input_data)
+        for name in ensure_tuple(names):
+            self.assertTrue(name in result)
+        result["img_1"] += 1
+        np.testing.assert_allclose(result["img_1"], np.array([[1, 2], [2, 3]]))
+        np.testing.assert_allclose(result["img"], np.array([[0, 1], [1, 2]]))
+
+    def test_default_names(self):
+        input_data = {"img": np.array([[0, 1], [1, 2]]), "seg": np.array([[3, 4], [4, 5]])}
+        result = CopyItemsd(keys=["img", "seg"], times=2, names=None)(input_data)
+        for name in ["img_0", "seg_0", "img_1", "seg_1"]:
+            self.assertTrue(name in result)
+
+    def test_tensor_values(self):
+        device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu:0")
+        input_data = {
+            "img": torch.tensor([[0, 1], [1, 2]], device=device),
+            "seg": torch.tensor([[0, 1], [1, 2]], device=device),
+        }
+        # test default `times=1`
+        result = CopyItemsd(keys="img", names="img_1")(input_data)
+        self.assertTrue("img_1" in result)
+        result["img_1"] += 1
+        assert_allclose(result["img"], torch.tensor([[0, 1], [1, 2]], device=device))
+        assert_allclose(result["img_1"], torch.tensor([[1, 2], [2, 3]], device=device))
+
+    def test_array_values(self):
+        input_data = {"img": [[0, 1], [1, 2]], "seg": [[0, 1], [1, 2]]}
+        result = CopyItemsd(keys="img", times=1, names="img_1")(input_data)
+        self.assertTrue("img_1" in result)
+        result["img_1"][0][0] += 1
+        np.testing.assert_allclose(result["img"], [[0, 1], [1, 2]])
+        np.testing.assert_allclose(result["img_1"], [[1, 1], [1, 2]])
+
+    def test_graph_tensor_values(self):
+        device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu:0")
+        net = torch.nn.PReLU().to(device)
+        with eval_mode(net):
+            pred = net(torch.tensor([[0.0, 1.0], [1.0, 2.0]], device=device))
+        input_data = {"pred": pred, "seg": torch.tensor([[0.0, 1.0], [1.0, 2.0]], device=device)}
+        result = CopyItemsd(keys="pred", times=1, names="pred_1")(input_data)
+        self.assertTrue("pred_1" in result)
+        result["pred_1"] += 1.0
+        assert_allclose(result["pred"], torch.tensor([[0.0, 1.0], [1.0, 2.0]], device=device))
+        assert_allclose(result["pred_1"], torch.tensor([[1.0, 2.0], [2.0, 3.0]], device=device))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_create_grid_and_affine.py

@@ -0,0 +1,274 @@
+# 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.transforms import (
+    create_control_grid,
+    create_grid,
+    create_rotate,
+    create_scale,
+    create_shear,
+    create_translate,
+)
+from tests.test_utils import assert_allclose, is_tf32_env
+
+
+class TestCreateGrid(unittest.TestCase):
+    def test_create_grid(self):
+        with self.assertRaisesRegex(TypeError, ""):
+            create_grid(None)
+        with self.assertRaisesRegex(TypeError, ""):
+            create_grid((1, 1), spacing=2.0)
+        with self.assertRaisesRegex(TypeError, ""):
+            create_grid((1, 1), spacing=2.0)
+
+        test_assert(create_grid, ((1, 1),), np.array([[[0.0]], [[0.0]], [[1.0]]]))
+
+        test_assert(create_grid, ((1, 1), None, False), np.array([[[0.0]], [[0.0]]]))
+
+        test_assert(create_grid, ((1, 1), (1.2, 1.3)), np.array([[[0.0]], [[0.0]], [[1.0]]]))
+
+        test_assert(create_grid, ((1, 1, 1), (1.2, 1.3, 1.0)), np.array([[[[0.0]]], [[[0.0]]], [[[0.0]]], [[[1.0]]]]))
+
+        test_assert(create_grid, ((1, 1, 1), (1.2, 1.3, 1.0), False), np.array([[[[0.0]]], [[[0.0]]], [[[0.0]]]]))
+
+        g = create_grid((1, 1, 1), spacing=(1.2, 1.3, 1.0), dtype=np.int32)
+        np.testing.assert_equal(g.dtype, np.int32)
+
+        g = create_grid((1, 1, 1), spacing=(1.2, 1.3, 1.0), dtype=torch.float64, backend="torch")
+        np.testing.assert_equal(g.dtype, torch.float64)
+
+        test_assert(
+            create_grid,
+            ((2, 2, 2),),
+            np.array(
+                [
+                    [[[-0.5, -0.5], [-0.5, -0.5]], [[0.5, 0.5], [0.5, 0.5]]],
+                    [[[-0.5, -0.5], [0.5, 0.5]], [[-0.5, -0.5], [0.5, 0.5]]],
+                    [[[-0.5, 0.5], [-0.5, 0.5]], [[-0.5, 0.5], [-0.5, 0.5]]],
+                    [[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]],
+                ]
+            ),
+        )
+
+        test_assert(
+            create_grid,
+            ((2, 2, 2), (1.2, 1.3, 1.0)),
+            np.array(
+                [
+                    [[[-0.6, -0.6], [-0.6, -0.6]], [[0.6, 0.6], [0.6, 0.6]]],
+                    [[[-0.65, -0.65], [0.65, 0.65]], [[-0.65, -0.65], [0.65, 0.65]]],
+                    [[[-0.5, 0.5], [-0.5, 0.5]], [[-0.5, 0.5], [-0.5, 0.5]]],
+                    [[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]],
+                ]
+            ),
+        )
+
+    def test_create_control_grid(self):
+        with self.assertRaisesRegex(TypeError, ""):
+            create_control_grid(None, None)
+        with self.assertRaisesRegex(TypeError, ""):
+            create_control_grid((1, 1), 2.0)
+
+        test_assert(
+            create_control_grid,
+            ((1.0, 1.0), (1.0, 1.0)),
+            np.array(
+                [
+                    [[-1.0, -1.0, -1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                    [[-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0]],
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ),
+        )
+
+        test_assert(
+            create_control_grid,
+            ((1.0, 1.0), (2.0, 2.0)),
+            np.array(
+                [
+                    [[-2.0, -2.0, -2.0], [0.0, 0.0, 0.0], [2.0, 2.0, 2.0]],
+                    [[-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0]],
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ),
+        )
+
+        test_assert(
+            create_control_grid,
+            ((2.0, 2.0), (1.0, 1.0)),
+            np.array(
+                [
+                    [[-1.5, -1.5, -1.5, -1.5], [-0.5, -0.5, -0.5, -0.5], [0.5, 0.5, 0.5, 0.5], [1.5, 1.5, 1.5, 1.5]],
+                    [[-1.5, -0.5, 0.5, 1.5], [-1.5, -0.5, 0.5, 1.5], [-1.5, -0.5, 0.5, 1.5], [-1.5, -0.5, 0.5, 1.5]],
+                    [[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]],
+                ]
+            ),
+        )
+
+        test_assert(
+            create_control_grid,
+            ((2.0, 2.0), (2.0, 2.0)),
+            np.array(
+                [
+                    [[-3.0, -3.0, -3.0, -3.0], [-1.0, -1.0, -1.0, -1.0], [1.0, 1.0, 1.0, 1.0], [3.0, 3.0, 3.0, 3.0]],
+                    [[-3.0, -1.0, 1.0, 3.0], [-3.0, -1.0, 1.0, 3.0], [-3.0, -1.0, 1.0, 3.0], [-3.0, -1.0, 1.0, 3.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, 1.0]],
+                ]
+            ),
+        )
+
+        test_assert(
+            create_control_grid,
+            ((1.0, 1.0, 1.0), (2.0, 2.0, 2.0), False),
+            np.array(
+                [
+                    [
+                        [[-2.0, -2.0, -2.0], [-2.0, -2.0, -2.0], [-2.0, -2.0, -2.0]],
+                        [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                        [[2.0, 2.0, 2.0], [2.0, 2.0, 2.0], [2.0, 2.0, 2.0]],
+                    ],
+                    [
+                        [[-2.0, -2.0, -2.0], [0.0, 0.0, 0.0], [2.0, 2.0, 2.0]],
+                        [[-2.0, -2.0, -2.0], [0.0, 0.0, 0.0], [2.0, 2.0, 2.0]],
+                        [[-2.0, -2.0, -2.0], [0.0, 0.0, 0.0], [2.0, 2.0, 2.0]],
+                    ],
+                    [
+                        [[-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0]],
+                        [[-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0]],
+                        [[-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0], [-2.0, 0.0, 2.0]],
+                    ],
+                ]
+            ),
+        )
+
+
+def test_assert(func, params, expected):
+    gpu_test = ("torch_gpu",) if torch.cuda.is_available() else ()
+    for b in ("torch", "numpy") + gpu_test:
+        if b == "torch_gpu":
+            m = func(*params, device="cuda:0", backend="torch")
+        else:
+            m = func(*params, backend=b)
+        assert_allclose(m, expected, type_test=False, rtol=1e-2 if is_tf32_env() else 1e-5, atol=1e-5)
+
+
+class TestCreateAffine(unittest.TestCase):
+    def test_create_rotate(self):
+        with self.assertRaisesRegex(TypeError, ""):
+            create_rotate(2, None)
+
+        with self.assertRaisesRegex(ValueError, ""):
+            create_rotate(5, 1)
+
+        test_assert(
+            create_rotate,
+            (2, 1.1),
+            np.array([[0.45359612, -0.89120736, 0.0], [0.89120736, 0.45359612, 0.0], [0.0, 0.0, 1.0]]),
+        )
+        test_assert(
+            create_rotate,
+            (3, 1.1),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.45359612, -0.89120736, 0.0],
+                    [0.0, 0.89120736, 0.45359612, 0.0],
+                    [0.0, 0.0, 0.0, 1.0],
+                ]
+            ),
+        )
+        test_assert(
+            create_rotate,
+            (3, (1.1, 1)),
+            np.array(
+                [
+                    [0.54030231, 0.0, 0.84147098, 0.0],
+                    [0.74992513, 0.45359612, -0.48152139, 0.0],
+                    [-0.38168798, 0.89120736, 0.24507903, 0.0],
+                    [0.0, 0.0, 0.0, 1.0],
+                ]
+            ),
+        )
+        test_assert(
+            create_rotate,
+            (3, (1, 1, 1.1)),
+            np.array(
+                [
+                    [0.24507903, -0.48152139, 0.84147098, 0.0],
+                    [0.80270075, -0.38596121, -0.45464871, 0.0],
+                    [0.54369824, 0.78687425, 0.29192658, 0.0],
+                    [0.0, 0.0, 0.0, 1.0],
+                ]
+            ),
+        )
+        test_assert(
+            create_rotate,
+            (3, (0, 0, np.pi / 2)),
+            np.array([[0.0, -1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+
+    def test_create_shear(self):
+        test_assert(create_shear, (2, 1.0), np.array([[1.0, 1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
+        test_assert(create_shear, (2, (2.0, 3.0)), np.array([[1.0, 2.0, 0.0], [3.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
+        test_assert(
+            create_shear,
+            (3, 1.0),
+            np.array([[1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+
+    def test_create_scale(self):
+        test_assert(create_scale, (2, 2), np.array([[2.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
+        test_assert(create_scale, (2, [2, 2, 2]), np.array([[2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 1.0]]))
+        test_assert(
+            create_scale,
+            (3, [1.5, 2.4]),
+            np.array([[1.5, 0.0, 0.0, 0.0], [0.0, 2.4, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+        test_assert(
+            create_scale,
+            (3, 1.5),
+            np.array([[1.5, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+        test_assert(
+            create_scale,
+            (3, [1, 2, 3, 4, 5]),
+            np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 0.0, 3.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+
+    def test_create_translate(self):
+        test_assert(create_translate, (2, 2), np.array([[1.0, 0.0, 2.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
+        test_assert(create_translate, (2, [2, 2, 2]), np.array([[1.0, 0.0, 2.0], [0.0, 1.0, 2.0], [0.0, 0.0, 1.0]]))
+        test_assert(
+            create_translate,
+            (3, [1.5, 2.4]),
+            np.array([[1.0, 0.0, 0.0, 1.5], [0.0, 1.0, 0.0, 2.4], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+        test_assert(
+            create_translate,
+            (3, 1.5),
+            np.array([[1.0, 0.0, 0.0, 1.5], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+        test_assert(
+            create_translate,
+            (3, [1, 2, 3, 4, 5]),
+            np.array([[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 2.0], [0.0, 0.0, 1.0, 3.0], [0.0, 0.0, 0.0, 1.0]]),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_crop_foreground.py

@@ -0,0 +1,164 @@
+# 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.config import USE_COMPILED
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import CropForeground
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose
+
+TEST_COORDS, TESTS, TEST_LAZY_ERROR = [], [], []
+
+for p in TEST_NDARRAYS_ALL:
+    TEST_COORDS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": 0},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+            p([[[1, 2, 1], [2, 3, 2], [1, 2, 1]]]),
+            True,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 1, "channel_indices": None, "margin": 0},
+            p([[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 3, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]]),
+            p([[[3]]]),
+            False,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": 0, "margin": 0},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+            p([[[1, 2, 1], [2, 3, 2], [1, 2, 1]]]),
+            True,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": 1},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]),
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0]]]),
+            True,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": [2, 1], "allow_smaller": True},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]),
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]),
+            True,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": [2, 1], "allow_smaller": False},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]),
+            p([[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]),
+            True,
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": 0, "k_divisible": 4},
+            p([[[0, 0, 0, 0, 0], [0, 1, 2, 1, 0], [0, 2, 3, 2, 0], [0, 1, 2, 1, 0], [0, 0, 0, 0, 0]]]),
+            p([[[1, 2, 1, 0], [2, 3, 2, 0], [1, 2, 1, 0], [0, 0, 0, 0]]]),
+            True,
+        ]
+    )
+
+    TEST_LAZY_ERROR.append(
+        [
+            {"select_fn": lambda x: x > 0, "channel_indices": None, "margin": 0, "k_divisible": 10},
+            p([[[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]]]),
+            p(np.zeros((1, 0, 0), dtype=np.int64)),
+            True,
+        ]
+    )
+
+
+class TestCropForeground(unittest.TestCase):
+    @parameterized.expand(TEST_COORDS + TESTS)
+    def test_value(self, arguments, image, expected_data, _):
+        cropper = CropForeground(**arguments)
+        result = cropper(image)
+        assert_allclose(result, expected_data, type_test=False)
+        self.assertIsInstance(result, MetaTensor)
+        self.assertEqual(len(result.applied_operations), 1)
+        inv = cropper.inverse(result)
+        self.assertIsInstance(inv, MetaTensor)
+        self.assertEqual(inv.applied_operations, [])
+        self.assertTupleEqual(inv.shape, image.shape)
+
+    @parameterized.expand(TEST_COORDS)
+    def test_return_coords(self, arguments, image, _expected_data, _align_corners):
+        arguments["return_coords"] = True
+        _, start_coord, end_coord = CropForeground(**arguments)(image)
+        arguments["return_coords"] = False
+        np.testing.assert_allclose(start_coord, np.asarray([1, 1]))
+        np.testing.assert_allclose(end_coord, np.asarray([4, 4]))
+
+    @parameterized.expand(TEST_COORDS + TESTS)
+    def test_pending_ops(self, input_param, image, _expected_data, align_corners):
+        crop_fn = CropForeground(**input_param)
+        # non-lazy
+        expected = crop_fn(image)
+        self.assertIsInstance(expected, MetaTensor)
+        # lazy
+        crop_fn.lazy = True
+        pending_result = crop_fn(image)
+        self.assertIsInstance(pending_result, MetaTensor)
+        assert_allclose(pending_result.peek_pending_affine(), expected.affine)
+        assert_allclose(pending_result.peek_pending_shape(), expected.shape[1:])
+        # only support nearest
+        overrides = {"mode": "nearest", "align_corners": align_corners}
+        result = apply_pending(pending_result, overrides=overrides)[0]
+        # compare
+        assert_allclose(result, expected, rtol=1e-5)
+
+    @parameterized.expand(TEST_LAZY_ERROR)
+    @unittest.skipIf(USE_COMPILED, "skip errors whe use compiled")
+    def test_lazy_error(self, input_param, image, _expected_data, align_corners):
+        with self.assertRaises(ValueError):
+            crop_fn = CropForeground(**input_param)
+            # lazy
+            crop_fn.lazy = True
+            pending_result = crop_fn(image)
+            overrides = {"mode": "nearest", "align_corners": align_corners}
+            return apply_pending(pending_result, overrides=overrides)[0]
+
+    @parameterized.expand(TEST_COORDS + TESTS)
+    def test_inverse_pending_ops(self, input_param, image, _expected_data, align_corners):
+        crop_fn = CropForeground(**input_param)
+        crop_fn.lazy = True
+        pending_result = crop_fn(image)
+        self.assertIsInstance(pending_result, MetaTensor)
+        result = apply_pending(pending_result, overrides={"mode": "nearest", "align_corners": align_corners})[0]
+        inverted = crop_fn.inverse(result)
+        self.assertEqual(image.shape, inverted.shape)
+        self.assertTrue((not inverted.applied_operations) and (not inverted.pending_operations))
+
+
+if __name__ == "__main__":
+    unittest.main()