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

tests/transforms/compose/test_some_of.py

@@ -0,0 +1,258 @@
+# 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
+
+import monai.transforms.intensity.array as ia
+import monai.transforms.spatial.array as sa
+import monai.transforms.spatial.dictionary as sd
+from monai.data import MetaTensor
+from monai.transforms import TraceableTransform, Transform
+from monai.transforms.compose import Compose, SomeOf
+from monai.utils import set_determinism
+from monai.utils.enums import TraceKeys
+from tests.integration.test_one_of import NonInv
+from tests.transforms.test_random_order import InvC, InvD
+
+
+class A(Transform):
+
+    def __call__(self, x):
+        return 2 * x
+
+
+class B(Transform):
+
+    def __call__(self, x):
+        return 3 * x
+
+
+class C(Transform):
+
+    def __call__(self, x):
+        return 5 * x
+
+
+class D(Transform):
+
+    def __call__(self, x):
+        return 7 * x
+
+
+KEYS = ["x", "y"]
+TEST_COMPOUND = [
+    (SomeOf((A(), B(), C()), num_transforms=3), 2 * 3 * 5),
+    (Compose((SomeOf((A(), B(), C()), num_transforms=3), D())), 2 * 3 * 5 * 7),
+    (SomeOf((A(), B(), C(), Compose(D())), num_transforms=4), 2 * 3 * 5 * 7),
+    (SomeOf(()), 1),
+    (SomeOf(None), 1),
+]
+
+# Modified from RandomOrder
+TEST_INVERSES = [
+    (SomeOf((InvC(KEYS), InvD(KEYS))), True, True),
+    (Compose((SomeOf((InvC(KEYS), InvD(KEYS))), SomeOf((InvD(KEYS), InvC(KEYS))))), True, False),
+    (SomeOf((SomeOf((InvC(KEYS), InvD(KEYS))), SomeOf((InvD(KEYS), InvC(KEYS))))), True, False),
+    (SomeOf((Compose((InvC(KEYS), InvD(KEYS))), Compose((InvD(KEYS), InvC(KEYS))))), True, False),
+    (SomeOf((NonInv(KEYS), NonInv(KEYS))), False, False),
+    (SomeOf(()), False, False),
+]
+
+
+class TestSomeOf(unittest.TestCase):
+
+    def setUp(self):
+        set_determinism(seed=0)
+
+    def tearDown(self):
+        set_determinism(None)
+
+    def update_transform_count(self, counts, output):
+        op_count = 0
+
+        if output % 2 == 0:
+            counts[0] += 1
+            op_count += 1
+        if output % 3 == 0:
+            counts[1] += 1
+            op_count += 1
+        if output % 5 == 0:
+            counts[2] += 1
+            op_count += 1
+
+        return op_count
+
+    def test_fixed(self):
+        iterations = 10000
+        num_transforms = 3
+        transform_counts = 3 * [0]
+        subset_size_counts = 4 * [0]
+
+        s = SomeOf((A(), B(), C()), num_transforms=num_transforms)
+
+        for _ in range(iterations):
+            output = s(1)
+            subset_size = self.update_transform_count(transform_counts, output)
+            subset_size_counts[subset_size] += 1
+
+        for i in range(3):
+            self.assertEqual(transform_counts[i], iterations)
+
+        for i in range(3):
+            self.assertEqual(subset_size_counts[i], 0)
+
+        self.assertEqual(subset_size_counts[3], iterations)
+
+    def test_unfixed(self):
+        iterations = 10000
+        num_transforms = (0, 3)
+        transform_counts = 3 * [0]
+        subset_size_counts = 4 * [0]
+
+        s = SomeOf((A(), B(), C()), num_transforms=num_transforms)
+
+        for _ in range(iterations):
+            output = s(1)
+            subset_size = self.update_transform_count(transform_counts, output)
+            subset_size_counts[subset_size] += 1
+
+        for i in range(3):
+            self.assertAlmostEqual(transform_counts[i] / iterations, 0.5, delta=0.01)
+
+        for i in range(4):
+            self.assertAlmostEqual(subset_size_counts[i] / iterations, 0.25, delta=0.01)
+
+    def test_non_dict_metatensor(self):
+        data = MetaTensor(1)
+        s = SomeOf([A()], num_transforms=1)
+        out = s(data)
+        self.assertEqual(out, 2)
+        inv = s.inverse(out)  # A() is not invertible, nothing happens
+        self.assertEqual(inv, 2)
+
+    @parameterized.expand(TEST_COMPOUND)
+    def test_compound_pipeline(self, transform, expected_value):
+        output = transform(1)
+        self.assertEqual(output, expected_value)
+
+    # Modified from RandomOrder
+    @parameterized.expand(TEST_INVERSES)
+    def test_inverse(self, transform, invertible, use_metatensor):
+        data = {k: (i + 1) * 10.0 if not use_metatensor else MetaTensor((i + 1) * 10.0) for i, k in enumerate(KEYS)}
+        fwd_data1 = transform(data)
+        # test call twice won't affect inverse
+        fwd_data2 = transform(data)
+
+        if invertible:
+            for k in KEYS:
+                t = (
+                    fwd_data1[TraceableTransform.trace_key(k)][-1]
+                    if not use_metatensor
+                    else fwd_data1[k].applied_operations[-1]
+                )
+                # make sure the SomeOf applied_order was stored
+                self.assertEqual(t[TraceKeys.CLASS_NAME], SomeOf.__name__)
+
+        # call the inverse
+        fwd_inv_data1 = transform.inverse(fwd_data1)
+        fwd_inv_data2 = transform.inverse(fwd_data2)
+
+        fwd_data = [fwd_data1, fwd_data2]
+        fwd_inv_data = [fwd_inv_data1, fwd_inv_data2]
+        for i, _fwd_inv_data in enumerate(fwd_inv_data):
+            if invertible:
+                for k in KEYS:
+                    # check transform was removed
+                    if not use_metatensor:
+                        self.assertTrue(
+                            len(_fwd_inv_data[TraceableTransform.trace_key(k)])
+                            < len(fwd_data[i][TraceableTransform.trace_key(k)])
+                        )
+                    # check data is same as original (and different from forward)
+                    self.assertEqual(_fwd_inv_data[k], data[k])
+                    self.assertNotEqual(_fwd_inv_data[k], fwd_data[i][k])
+            else:
+                # if not invertible, should not change the data
+                self.assertDictEqual(fwd_data[i], _fwd_inv_data)
+
+    def test_bad_inverse_data(self):
+        tr = SomeOf((A(), B(), C()), num_transforms=1, weights=(1, 2, 1))
+        self.assertRaises(RuntimeError, tr.inverse, [])
+
+    def test_normalize_weights(self):
+        tr = SomeOf((A(), B(), C()), num_transforms=1, weights=(1, 2, 1))
+        self.assertTupleEqual(tr.weights, (0.25, 0.5, 0.25))
+
+        tr = SomeOf((), num_transforms=1, weights=(1, 2, 1))
+        self.assertIsNone(tr.weights)
+
+    def test_no_weights_arg(self):
+        tr = SomeOf((A(), B(), C(), D()), num_transforms=1)
+        self.assertIsNone(tr.weights)
+
+    def test_bad_weights(self):
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=1, weights=(1, 2))
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=1, weights=(0, 0, 0))
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=1, weights=(-1, 1, 1))
+
+    def test_bad_num_transforms(self):
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=(-1, 2))
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms="str")
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=(1, 2, 3))
+        self.assertRaises(ValueError, SomeOf, (A(), B(), C()), num_transforms=("a", 1))
+
+
+TEST_SOMEOF_EXTENDED_TEST_CASES = [
+    [None, tuple()],
+    [None, (sa.Rotate(np.pi / 8),)],
+    [None, (sa.Flip(0), sa.Flip(1), sa.Rotate90(1), sa.Zoom(0.8), ia.NormalizeIntensity())],
+    [("a",), (sd.Rotated(("a",), np.pi / 8),)],
+]
+
+
+class TestSomeOfAPITests(unittest.TestCase):
+
+    @staticmethod
+    def data_from_keys(keys):
+        if keys is None:
+            data = torch.unsqueeze(torch.tensor(np.arange(12 * 16).reshape(12, 16)), dim=0)
+        else:
+            data = {}
+            for i_k, k in enumerate(keys):
+                data[k] = torch.unsqueeze(torch.tensor(np.arange(12 * 16)).reshape(12, 16) + i_k * 192, dim=0)
+        return data
+
+    @parameterized.expand(TEST_SOMEOF_EXTENDED_TEST_CASES)
+    def test_execute_change_start_end(self, keys, pipeline):
+        data = self.data_from_keys(keys)
+
+        c = SomeOf(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+
+        c = SomeOf(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/croppad/__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/croppad/test_rand_weighted_crop.py

@@ -0,0 +1,224 @@
+# 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.parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.croppad.array import RandWeightedCrop
+from monai.transforms.lazy.functional import apply_pending
+from tests.croppers import CropTest
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, NumpyImageTestCase3D, assert_allclose
+
+
+def get_data(ndim):
+    im_gen = NumpyImageTestCase2D() if ndim == 2 else NumpyImageTestCase3D()
+    im_gen.setUp()
+    return im_gen.imt[0], im_gen.seg1[0], im_gen.segn[0]
+
+
+IMT_2D, SEG1_2D, SEGN_2D = get_data(ndim=2)
+IMT_3D, SEG1_3D, SEGN_3D = get_data(ndim=3)
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for q in TEST_NDARRAYS_ALL:
+        im = SEG1_2D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = 1.1
+        weight[0, 40, 31] = 1
+        weight[0, 80, 21] = 1
+        TESTS.append(
+            [
+                "small roi 2d",
+                dict(spatial_size=(10, 12), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 10, 12),
+                [[80, 21], [30, 17], [40, 31]],
+            ]
+        )
+        im = IMT_2D
+        TESTS.append(
+            [
+                "default roi 2d",
+                dict(spatial_size=(10, -1), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 10, 64),
+                [[14, 32], [105, 32], [20, 32]],
+            ]
+        )
+        im = SEGN_2D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = 1.1
+        weight[0, 10, 1] = 1
+        TESTS.append(
+            [
+                "large roi 2d",
+                dict(spatial_size=(10000, 400), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 128, 64),
+                [[64, 32], [64, 32], [64, 32]],
+            ]
+        )
+        im = IMT_2D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = np.inf
+        weight[0, 10, 1] = -np.inf
+        weight[0, 10, 20] = -np.nan
+        TESTS.append(
+            [
+                "bad w 2d",
+                dict(spatial_size=(20, 40), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 20, 40),
+                [[63, 37], [31, 43], [66, 20]],
+            ]
+        )
+        im = SEG1_2D
+        weight_map = np.zeros_like(im, dtype=np.int32)
+        weight_map[0, 30, 20] = 3
+        weight_map[0, 45, 44] = 1
+        weight_map[0, 60, 50] = 2
+        TESTS.append(
+            [
+                "int w 2d",
+                dict(spatial_size=(10, 12), num_samples=3),
+                p(im),
+                q(weight_map),
+                (1, 10, 12),
+                [[60, 50], [30, 20], [45, 44]],
+            ]
+        )
+        im = SEG1_3D
+        weight = np.zeros_like(im)
+        weight[0, 5, 30, 17] = 1.1
+        weight[0, 8, 40, 31] = 1
+        weight[0, 11, 23, 21] = 1
+        TESTS.append(
+            [
+                "small roi 3d",
+                dict(spatial_size=(8, 10, 12), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 8, 10, 12),
+                [[11, 23, 21], [5, 30, 17], [8, 40, 31]],
+            ]
+        )
+        im = IMT_3D
+        weight = np.zeros_like(im)
+        weight[0, 7, 17] = 1.1
+        weight[0, 13, 31] = 1.1
+        weight[0, 24, 21] = 1
+        TESTS.append(
+            [
+                "default roi 3d",
+                dict(spatial_size=(10, -1, -1), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 10, 48, 80),
+                [[14, 24, 40], [41, 24, 40], [20, 24, 40]],
+            ]
+        )
+        im = SEGN_3D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17, 20] = 1.1
+        weight[0, 10, 1, 17] = 1
+        TESTS.append(
+            [
+                "large roi 3d",
+                dict(spatial_size=(10000, 400, 80), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 64, 48, 80),
+                [[32, 24, 40], [32, 24, 40], [32, 24, 40]],
+            ]
+        )
+        im = IMT_3D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = np.inf
+        weight[0, 10, 1] = -np.inf
+        weight[0, 10, 20] = -np.nan
+        TESTS.append(
+            [
+                "bad w 3d",
+                dict(spatial_size=(64, 48, 80), num_samples=3),
+                p(im),
+                q(weight),
+                (1, 64, 48, 80),
+                [[32, 24, 40], [32, 24, 40], [32, 24, 40]],
+            ]
+        )
+        im = SEG1_3D
+        weight_map = np.zeros_like(im, dtype=np.int32)
+        weight_map[0, 6, 22, 19] = 4
+        weight_map[0, 8, 40, 31] = 2
+        weight_map[0, 13, 20, 24] = 3
+        TESTS.append(
+            [
+                "int w 3d",
+                dict(spatial_size=(8, 10, 12), num_samples=3),
+                p(im),
+                q(weight_map),
+                (1, 8, 10, 12),
+                [[13, 20, 24], [6, 22, 19], [8, 40, 31]],
+            ]
+        )
+
+
+class TestRandWeightedCrop(CropTest):
+    Cropper = RandWeightedCrop
+
+    @parameterized.expand(TESTS)
+    def test_rand_weighted_crop(self, _, input_params, img, weight, expected_shape, expected_vals):
+        crop = RandWeightedCrop(**input_params)
+        crop.set_random_state(10)
+        result = crop(img, weight)
+        self.assertTrue(len(result) == input_params["num_samples"])
+        assert_allclose(result[0].shape, expected_shape)
+        for c, e in zip(crop.centers, expected_vals):
+            assert_allclose(c, e, type_test=False)
+        # if desired ROI is larger than image, check image is unchanged
+        if all(s >= i for i, s in zip(img.shape[1:], input_params["spatial_size"])):
+            for res in result:
+                assert_allclose(res, img, type_test="tensor")
+                self.assertEqual(len(res.applied_operations), 1)
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, _, input_param, img, weight, expected_shape, expected_vals):
+        crop = RandWeightedCrop(**input_param)
+        # non-lazy
+        crop.set_random_state(10)
+        expected = crop(img, weight)
+        self.assertIsInstance(expected[0], MetaTensor)
+        # lazy
+        crop.set_random_state(10)
+        crop.lazy = True
+        pending_result = crop(img, weight)
+        for i, _pending_result in enumerate(pending_result):
+            self.assertIsInstance(_pending_result, MetaTensor)
+            assert_allclose(_pending_result.peek_pending_affine(), expected[i].affine)
+            assert_allclose(_pending_result.peek_pending_shape(), expected[i].shape[1:])
+            # only support nearest
+            result = apply_pending(_pending_result, overrides={"mode": "nearest", "align_corners": False})[0]
+            # compare
+            assert_allclose(result, expected[i], rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/croppad/test_rand_weighted_cropd.py

@@ -0,0 +1,182 @@
+# 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.data.meta_tensor import MetaTensor
+from monai.transforms.croppad.dictionary import RandWeightedCropd
+from monai.transforms.lazy.functional import apply_pending
+from tests.test_utils import TEST_NDARRAYS_ALL, NumpyImageTestCase2D, NumpyImageTestCase3D, assert_allclose
+
+
+def get_data(ndim):
+    im_gen = NumpyImageTestCase2D() if ndim == 2 else NumpyImageTestCase3D()
+    im_gen.setUp()
+    return im_gen.imt[0], im_gen.seg1[0], im_gen.segn[0]
+
+
+IMT_2D, SEG1_2D, SEGN_2D = get_data(ndim=2)
+IMT_3D, SEG1_3D, SEGN_3D = get_data(ndim=3)
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for q in TEST_NDARRAYS_ALL:
+        im = IMT_2D
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = 1.1
+        weight[0, 40, 31] = 1
+        weight[0, 80, 21] = 1
+        TESTS.append(
+            [
+                "small roi 2d",
+                dict(keys="img", w_key="w", spatial_size=(10, 12), num_samples=3),
+                {"img": p(im), "w": q(weight)},
+                (1, 10, 12),
+                [[80, 21], [30, 17], [40, 31]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = 1.1
+        weight[0, 40, 31] = 1
+        weight[0, 80, 21] = 1
+        TESTS.append(
+            [
+                "default roi 2d",
+                dict(keys="img", w_key="w", spatial_size=(10, -1), num_samples=3),
+                {"img": p(im), "w": q(weight), "others": np.nan},
+                (1, 10, 64),
+                [[14, 32], [105, 32], [20, 32]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = 1.1
+        weight[0, 10, 1] = 1
+        TESTS.append(
+            [
+                "large roi 2d",
+                dict(keys=("img", "seg"), w_key="weight", spatial_size=(10000, 400), num_samples=3),
+                {"img": p(im), "seg": p(SEGN_2D), "weight": q(weight)},
+                (1, 128, 64),
+                [[64, 32], [64, 32], [64, 32]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = np.inf
+        weight[0, 10, 1] = -np.inf
+        weight[0, 10, 20] = -np.nan
+        TESTS.append(
+            [
+                "bad w roi 2d",
+                dict(keys=("img", "seg"), w_key="w", spatial_size=(20, 40), num_samples=3),
+                {"img": p(im), "seg": p(SEGN_2D), "w": q(weight)},
+                (1, 20, 40),
+                [[63, 37], [31, 43], [66, 20]],
+            ]
+        )
+
+        im = IMT_3D
+        weight = np.zeros_like(im)
+        weight[0, 5, 30, 17] = 1.1
+        weight[0, 8, 40, 31] = 1
+        weight[0, 11, 23, 21] = 1
+        TESTS.append(
+            [
+                "small roi 3d",
+                dict(keys="img", w_key="w", spatial_size=(8, 10, 12), num_samples=3),
+                {"img": p(im), "w": q(weight)},
+                (1, 8, 10, 12),
+                [[11, 23, 21], [5, 30, 17], [8, 40, 31]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 5, 30, 17] = 1.1
+        weight[0, 8, 40, 31] = 1
+        weight[0, 11, 23, 21] = 1
+        TESTS.append(
+            [
+                "default roi 3d",
+                dict(keys=("img", "seg"), w_key="w", spatial_size=(10, -1, -1), num_samples=3),
+                {"img": p(im), "seg": p(SEGN_3D), "w": q(weight)},
+                (1, 10, 64, 80),
+                [[14, 32, 40], [41, 32, 40], [20, 32, 40]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 30, 17, 20] = 1.1
+        weight[0, 10, 1, 17] = 1
+        TESTS.append(
+            [
+                "large roi 3d",
+                dict(keys="img", w_key="w", spatial_size=(10000, 400, 80), num_samples=3),
+                {"img": p(im), "w": q(weight)},
+                (1, 48, 64, 80),
+                [[24, 32, 40], [24, 32, 40], [24, 32, 40]],
+            ]
+        )
+
+        weight = np.zeros_like(im)
+        weight[0, 30, 17] = np.inf
+        weight[0, 10, 1] = -np.inf
+        weight[0, 10, 20] = -np.nan
+        TESTS.append(
+            [
+                "bad w roi 3d",
+                dict(keys=("img", "seg"), w_key="w", spatial_size=(48, 64, 80), num_samples=3),
+                {"img": p(im), "seg": p(SEGN_3D), "w": q(weight)},
+                (1, 48, 64, 80),
+                [[24, 32, 40], [24, 32, 40], [24, 32, 40]],
+            ]
+        )
+
+
+class TestRandWeightedCrop(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_weighted_cropd(self, _, init_params, input_data, expected_shape, expected_centers):
+        crop = RandWeightedCropd(**init_params)
+        crop.set_random_state(10)
+        result = crop(input_data)
+        self.assertEqual(len(result), init_params["num_samples"])
+        _len = len(tuple(input_data.keys()))
+        self.assertTupleEqual(tuple(result[0].keys())[:_len], tuple(input_data.keys()))
+
+    @parameterized.expand(TESTS)
+    def test_pending_ops(self, _, input_param, input_data, expected_shape, expected_centers):
+        crop = RandWeightedCropd(**input_param)
+        # non-lazy
+        crop.set_random_state(10)
+        expected = crop(input_data)
+        self.assertIsInstance(expected[0]["img"], MetaTensor)
+        # lazy
+        crop.set_random_state(10)
+        crop.lazy = True
+        pending_result = crop(input_data)
+        for i, _pending_result in enumerate(pending_result):
+            self.assertIsInstance(_pending_result["img"], MetaTensor)
+            assert_allclose(_pending_result["img"].peek_pending_affine(), expected[i]["img"].affine)
+            assert_allclose(_pending_result["img"].peek_pending_shape(), expected[i]["img"].shape[1:])
+            # only support nearest
+            result = apply_pending(_pending_result["img"], overrides={"mode": "nearest", "align_corners": False})[0]
+            # compare
+            assert_allclose(result, expected[i]["img"], rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/functional/__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.