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

tests/transforms/utility/test_apply_transform_to_points.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
+
+import torch
+from parameterized import parameterized
+
+from monai.data import MetaTensor
+from monai.transforms.utility.array import ApplyTransformToPoints
+from monai.utils import set_determinism
+
+set_determinism(seed=0)
+
+DATA_2D = torch.rand(1, 64, 64)
+DATA_3D = torch.rand(1, 64, 64, 64)
+POINT_2D_WORLD = torch.tensor([[[2, 2], [2, 4], [4, 6]]])
+POINT_2D_IMAGE = torch.tensor([[[1, 1], [1, 2], [2, 3]]])
+POINT_2D_IMAGE_RAS = torch.tensor([[[-1, -1], [-1, -2], [-2, -3]]])
+POINT_3D_WORLD = torch.tensor([[[2, 4, 6], [8, 10, 12]], [[14, 16, 18], [20, 22, 24]]])
+POINT_3D_IMAGE = torch.tensor([[[-8, 8, 6], [-2, 14, 12]], [[4, 20, 18], [10, 26, 24]]])
+POINT_3D_IMAGE_RAS = torch.tensor([[[-12, 0, 6], [-18, -6, 12]], [[-24, -12, 18], [-30, -18, 24]]])
+AFFINE_1 = torch.tensor([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+AFFINE_2 = torch.tensor([[1, 0, 0, 10], [0, 1, 0, -4], [0, 0, 1, 0], [0, 0, 0, 1]])
+
+TEST_CASES = [
+    [MetaTensor(DATA_2D, affine=AFFINE_1), POINT_2D_WORLD, None, True, False, POINT_2D_IMAGE],
+    [None, MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), None, False, False, POINT_2D_WORLD],
+    [None, MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), AFFINE_1, False, False, POINT_2D_WORLD],
+    [MetaTensor(DATA_2D, affine=AFFINE_1), POINT_2D_WORLD, None, True, True, POINT_2D_IMAGE_RAS],
+    [MetaTensor(DATA_3D, affine=AFFINE_2), POINT_3D_WORLD, None, True, False, POINT_3D_IMAGE],
+    [
+        MetaTensor(DATA_3D, affine=AFFINE_2),
+        MetaTensor(POINT_3D_IMAGE, affine=AFFINE_2),
+        None,
+        False,
+        False,
+        POINT_3D_WORLD,
+    ],
+    [MetaTensor(DATA_3D, affine=AFFINE_2), POINT_3D_WORLD, None, True, True, POINT_3D_IMAGE_RAS],
+]
+
+TEST_CASES_WRONG = [
+    [POINT_2D_WORLD, True, None],
+    [POINT_2D_WORLD.unsqueeze(0), False, None],
+    [POINT_3D_WORLD[..., 0:1], False, None],
+    [POINT_3D_WORLD, False, torch.tensor([[[1, 0, 0, 10], [0, 1, 0, -4], [0, 0, 1, 0], [0, 0, 0, 1]]])],
+]
+
+
+class TestCoordinateTransform(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_transform_coordinates(self, image, points, affine, invert_affine, affine_lps_to_ras, expected_output):
+        transform = ApplyTransformToPoints(
+            dtype=torch.int64, affine=affine, invert_affine=invert_affine, affine_lps_to_ras=affine_lps_to_ras
+        )
+        affine = image.affine if image is not None else None
+        output = transform(points, affine)
+        self.assertTrue(torch.allclose(output, expected_output))
+        invert_out = transform.inverse(output)
+        self.assertTrue(torch.allclose(invert_out, points))
+
+    @parameterized.expand(TEST_CASES_WRONG)
+    def test_wrong_input(self, input, invert_affine, affine):
+        transform = ApplyTransformToPoints(dtype=torch.int64, invert_affine=invert_affine)
+        with self.assertRaises(ValueError):
+            transform(input, affine)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_apply_transform_to_pointsd.py

@@ -0,0 +1,185 @@
+# 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.data import MetaTensor
+from monai.transforms.utility.dictionary import ApplyTransformToPointsd
+from monai.utils import set_determinism
+
+set_determinism(seed=0)
+
+DATA_2D = torch.rand(1, 64, 64)
+DATA_3D = torch.rand(1, 64, 64, 64)
+POINT_2D_WORLD = torch.tensor([[[2, 2], [2, 4], [4, 6]]])
+POINT_2D_IMAGE = torch.tensor([[[1, 1], [1, 2], [2, 3]]])
+POINT_2D_IMAGE_RAS = torch.tensor([[[-1, -1], [-1, -2], [-2, -3]]])
+POINT_3D_WORLD = torch.tensor([[[2, 4, 6], [8, 10, 12]], [[14, 16, 18], [20, 22, 24]]])
+POINT_3D_IMAGE = torch.tensor([[[-8, 8, 6], [-2, 14, 12]], [[4, 20, 18], [10, 26, 24]]])
+POINT_3D_IMAGE_RAS = torch.tensor([[[-12, 0, 6], [-18, -6, 12]], [[-24, -12, 18], [-30, -18, 24]]])
+AFFINE_1 = torch.tensor([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+AFFINE_2 = torch.tensor([[1, 0, 0, 10], [0, 1, 0, -4], [0, 0, 1, 0], [0, 0, 0, 1]])
+
+TEST_CASES = [
+    [MetaTensor(DATA_2D, affine=AFFINE_1), POINT_2D_WORLD, None, True, False, POINT_2D_IMAGE],  # use image affine
+    [None, MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), None, False, False, POINT_2D_WORLD],  # use point affine
+    [None, MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), AFFINE_1, False, False, POINT_2D_WORLD],  # use input affine
+    [None, POINT_2D_WORLD, AFFINE_1, True, False, POINT_2D_IMAGE],  # use input affine
+    [
+        MetaTensor(DATA_2D, affine=AFFINE_1),
+        POINT_2D_WORLD,
+        None,
+        True,
+        True,
+        POINT_2D_IMAGE_RAS,
+    ],  # test affine_lps_to_ras
+    [MetaTensor(DATA_3D, affine=AFFINE_2), POINT_3D_WORLD, None, True, False, POINT_3D_IMAGE],
+    ["affine", POINT_3D_WORLD, None, True, False, POINT_3D_IMAGE],  # use refer_data itself
+    [
+        MetaTensor(DATA_3D, affine=AFFINE_2),
+        MetaTensor(POINT_3D_IMAGE, affine=AFFINE_2),
+        None,
+        False,
+        False,
+        POINT_3D_WORLD,
+    ],
+    [MetaTensor(DATA_3D, affine=AFFINE_2), POINT_3D_WORLD, None, True, True, POINT_3D_IMAGE_RAS],
+    [MetaTensor(DATA_3D, affine=AFFINE_2), POINT_3D_WORLD, None, True, True, POINT_3D_IMAGE_RAS],
+]
+TEST_CASES_SEQUENCE = [
+    [
+        (MetaTensor(DATA_2D, affine=AFFINE_1), MetaTensor(DATA_3D, affine=AFFINE_2)),
+        [POINT_2D_WORLD, POINT_3D_WORLD],
+        None,
+        True,
+        False,
+        ["image_1", "image_2"],
+        [POINT_2D_IMAGE, POINT_3D_IMAGE],
+    ],  # use image affine
+    [
+        (MetaTensor(DATA_2D, affine=AFFINE_1), MetaTensor(DATA_3D, affine=AFFINE_2)),
+        [POINT_2D_WORLD, POINT_3D_WORLD],
+        None,
+        True,
+        True,
+        ["image_1", "image_2"],
+        [POINT_2D_IMAGE_RAS, POINT_3D_IMAGE_RAS],
+    ],  # test affine_lps_to_ras
+    [
+        (None, None),
+        [MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), MetaTensor(POINT_3D_IMAGE, affine=AFFINE_2)],
+        None,
+        False,
+        False,
+        None,
+        [POINT_2D_WORLD, POINT_3D_WORLD],
+    ],  # use point affine
+    [
+        (None, None),
+        [POINT_2D_WORLD, POINT_2D_WORLD],
+        AFFINE_1,
+        True,
+        False,
+        None,
+        [POINT_2D_IMAGE, POINT_2D_IMAGE],
+    ],  # use input affine
+    [
+        (MetaTensor(DATA_2D, affine=AFFINE_1), MetaTensor(DATA_3D, affine=AFFINE_2)),
+        [MetaTensor(POINT_2D_IMAGE, affine=AFFINE_1), MetaTensor(POINT_3D_IMAGE, affine=AFFINE_2)],
+        None,
+        False,
+        False,
+        ["image_1", "image_2"],
+        [POINT_2D_WORLD, POINT_3D_WORLD],
+    ],
+]
+
+TEST_CASES_WRONG = [
+    [POINT_2D_WORLD, True, None, None],
+    [POINT_2D_WORLD.unsqueeze(0), False, None, None],
+    [POINT_3D_WORLD[..., 0:1], False, None, None],
+    [POINT_3D_WORLD, False, torch.tensor([[[1, 0, 0, 10], [0, 1, 0, -4], [0, 0, 1, 0], [0, 0, 0, 1]]]), None],
+    [POINT_3D_WORLD, False, None, "image"],
+    [POINT_3D_WORLD, False, None, []],
+]
+
+
+class TestCoordinateTransform(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_transform_coordinates(self, image, points, affine, invert_affine, affine_lps_to_ras, expected_output):
+        data = {
+            "image": image,
+            "point": points,
+            "affine": torch.tensor([[1, 0, 0, 10], [0, 1, 0, -4], [0, 0, 1, 0], [0, 0, 0, 1]]),
+        }
+        refer_keys = "image" if (image is not None and image != "affine") else image
+        transform = ApplyTransformToPointsd(
+            keys="point",
+            refer_keys=refer_keys,
+            dtype=torch.int64,
+            affine=affine,
+            invert_affine=invert_affine,
+            affine_lps_to_ras=affine_lps_to_ras,
+        )
+        output = transform(data)
+
+        self.assertTrue(torch.allclose(output["point"], expected_output))
+        invert_out = transform.inverse(output)
+        self.assertTrue(torch.allclose(invert_out["point"], points))
+
+    @parameterized.expand(TEST_CASES_SEQUENCE)
+    def test_transform_coordinates_sequences(
+        self, image, points, affine, invert_affine, affine_lps_to_ras, refer_keys, expected_output
+    ):
+        data = {"image_1": image[0], "image_2": image[1], "point_1": points[0], "point_2": points[1]}
+        keys = ["point_1", "point_2"]
+        transform = ApplyTransformToPointsd(
+            keys=keys,
+            refer_keys=refer_keys,
+            dtype=torch.int64,
+            affine=affine,
+            invert_affine=invert_affine,
+            affine_lps_to_ras=affine_lps_to_ras,
+        )
+        output = transform(data)
+
+        self.assertTrue(torch.allclose(output["point_1"], expected_output[0]))
+        self.assertTrue(torch.allclose(output["point_2"], expected_output[1]))
+        invert_out = transform.inverse(output)
+        self.assertTrue(torch.allclose(invert_out["point_1"], points[0]))
+
+    @parameterized.expand(TEST_CASES_WRONG)
+    def test_wrong_input(self, input, invert_affine, affine, refer_keys):
+        if refer_keys == []:
+            with self.assertRaises(ValueError):
+                ApplyTransformToPointsd(
+                    keys="point", dtype=torch.int64, invert_affine=invert_affine, affine=affine, refer_keys=refer_keys
+                )
+        else:
+            transform = ApplyTransformToPointsd(
+                keys="point", dtype=torch.int64, invert_affine=invert_affine, affine=affine, refer_keys=refer_keys
+            )
+            data = {"point": input}
+            if refer_keys == "image":
+                with self.assertRaises(KeyError):
+                    transform(data)
+            else:
+                with self.assertRaises(ValueError):
+                    transform(data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_identity.py

@@ -0,0 +1,29 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+from monai.transforms.utility.array import Identity
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestIdentity(NumpyImageTestCase2D):
+    def test_identity(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            identity = Identity()
+            assert_allclose(img, identity(img))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_identityd.py

@@ -0,0 +1,30 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+from monai.transforms.utility.dictionary import Identityd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestIdentityd(NumpyImageTestCase2D):
+    def test_identityd(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            data = {"img": img}
+            identity = Identityd(keys=data.keys())
+            assert_allclose(img, identity(data)["img"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_lambda.py

@@ -0,0 +1,71 @@
+# 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 numpy import ndarray
+from torch import Tensor
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.utility.array import Lambda
+from monai.utils.type_conversion import convert_to_numpy, convert_to_tensor
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestLambda(NumpyImageTestCase2D):
+    def test_lambda_identity(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+
+            def identity_func(x):
+                return x
+
+            lambd = Lambda(func=identity_func)
+            assert_allclose(identity_func(img), lambd(img), type_test=False)
+
+    def test_lambda_slicing(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+
+            def slice_func(x):
+                return x[:, :, :6, ::2]
+
+            lambd = Lambda(func=slice_func)
+            out = lambd(img)
+            assert_allclose(slice_func(img), out, type_test=False)
+            self.assertIsInstance(out, MetaTensor)
+            self.assertEqual(len(out.applied_operations), 1)
+            out = lambd.inverse(out)
+            self.assertEqual(len(out.applied_operations), 0)
+
+    def test_lambda_track_meta_false(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+
+            def to_numpy(x):
+                return convert_to_numpy(x)
+
+            lambd = Lambda(func=to_numpy, track_meta=False)
+            out = lambd(img)
+            self.assertIsInstance(out, ndarray)
+
+            def to_tensor(x):
+                return convert_to_tensor(x)
+
+            lambd = Lambda(func=to_tensor, track_meta=False)
+            out = lambd(img)
+            self.assertIsInstance(out, Tensor)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_lambdad.py

@@ -0,0 +1,83 @@
+# 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 numpy import ndarray
+from torch import Tensor
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.utility.dictionary import Lambdad
+from monai.utils.type_conversion import convert_to_numpy, convert_to_tensor
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestLambdad(NumpyImageTestCase2D):
+    def test_lambdad_identity(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            data = {"img": img, "prop": 1.0, "label": 1.0}
+
+            def noise_func(x):
+                return x + 1.0
+
+            expected = {"img": noise_func(data["img"]), "prop": 1.0, "new_label": 2.0}
+            ret = Lambdad(keys=["img", "prop", "label"], func=noise_func, overwrite=[True, False, "new_label"])(data)
+            assert_allclose(expected["img"], ret["img"], type_test=False)
+            assert_allclose(expected["prop"], ret["prop"], type_test=False)
+            assert_allclose(expected["new_label"], ret["new_label"], type_test=False)
+
+    def test_lambdad_slicing(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            data = {"img": img}
+
+            def slice_func(x):
+                return x[:, :, :6, ::2]
+
+            lambd = Lambdad(keys=data.keys(), func=slice_func)
+            expected = {}
+            expected = slice_func(data["img"])
+            out = lambd(data)
+            out_img = out["img"]
+            assert_allclose(expected, out_img, type_test=False)
+            self.assertIsInstance(out_img, MetaTensor)
+            self.assertEqual(len(out_img.applied_operations), 1)
+            inv_img = lambd.inverse(out)["img"]
+            self.assertIsInstance(inv_img, MetaTensor)
+            self.assertEqual(len(inv_img.applied_operations), 0)
+
+    def test_lambdad_track_meta_false(self):
+        for p in TEST_NDARRAYS:
+            img = p(self.imt)
+            data = {"img": img}
+
+            def to_numpy(x):
+                return convert_to_numpy(x)
+
+            lambd = Lambdad(keys=data.keys(), func=to_numpy, track_meta=False)
+            out = lambd(data)
+            out_img = out["img"]
+            self.assertIsInstance(out_img, ndarray)
+
+            def to_tensor(x):
+                return convert_to_tensor(x)
+
+            lambd = Lambdad(keys=data.keys(), func=to_tensor, track_meta=False)
+            out = lambd(data)
+            out_img = out["img"]
+            self.assertIsInstance(out_img, Tensor)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_rand_lambda.py

@@ -0,0 +1,87 @@
+# 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
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.transform import Randomizable
+from monai.transforms.utility.array import RandLambda
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+
+class RandTest(Randomizable):
+    """
+    randomisable transform for testing.
+    """
+
+    def randomize(self, data=None):
+        self._a = self.R.random()
+
+    def __call__(self, data):
+        self.randomize()
+        return deepcopy(data) + self._a
+
+
+class TestRandLambda(unittest.TestCase):
+    def check(self, tr: RandLambda, img, img_orig_type, out, expected=None):
+        # input shouldn't change
+        self.assertIsInstance(img, img_orig_type)
+        if isinstance(img, MetaTensor):
+            self.assertEqual(len(img.applied_operations), 0)
+        # output data matches expected
+        assert_allclose(expected, out, type_test=False)
+        # output type is MetaTensor with 1 appended operation
+        self.assertIsInstance(out, MetaTensor)
+        self.assertEqual(len(out.applied_operations), 1)
+
+        # inverse
+        inv = tr.inverse(out)
+        # after inverse, input image remains unchanged
+        self.assertIsInstance(img, img_orig_type)
+        if isinstance(img, MetaTensor):
+            self.assertEqual(len(img.applied_operations), 0)
+        # after inverse, output is MetaTensor with 0 applied operations
+        self.assertIsInstance(inv, MetaTensor)
+        self.assertEqual(len(inv.applied_operations), 0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_rand_lambdad_identity(self, t):
+        img = t(np.zeros((10, 10)))
+        img_t = type(img)
+
+        test_func = RandTest()
+        test_func.set_random_state(seed=134)
+        expected = test_func(img)
+        test_func.set_random_state(seed=134)
+
+        # default prob
+        tr = RandLambda(func=test_func)
+        ret = tr(img)
+        self.check(tr, img, img_t, ret, expected)
+
+        tr = RandLambda(func=test_func, prob=0.0)
+        ret = tr(img)
+        self.check(tr, img, img_t, ret, expected=img)
+
+        trans = RandLambda(func=test_func, prob=0.5)
+        trans.set_random_state(seed=123)
+        ret = trans(img)
+        self.check(trans, img, img_t, ret, expected=img)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_rand_lambdad.py

@@ -0,0 +1,77 @@
+# 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
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.transform import Randomizable
+from monai.transforms.utility.dictionary import RandLambdad
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+
+class RandTest(Randomizable):
+    """
+    randomisable transform for testing.
+    """
+
+    def randomize(self, data=None):
+        self._a = self.R.random()
+
+    def __call__(self, data):
+        self.randomize()
+        return data + self._a
+
+
+class TestRandLambdad(unittest.TestCase):
+    def check(self, tr: RandLambdad, input: dict, out: dict, expected: dict):
+        if isinstance(input["img"], MetaTensor):
+            self.assertEqual(len(input["img"].applied_operations), 0)
+        self.assertIsInstance(out["img"], MetaTensor)
+        self.assertEqual(len(out["img"].applied_operations), 1)
+        assert_allclose(expected["img"], out["img"], type_test=False)
+        assert_allclose(expected["prop"], out["prop"], type_test=False)
+        inv = tr.inverse(out)
+        self.assertIsInstance(inv["img"], MetaTensor)
+        self.assertEqual(len(inv["img"].applied_operations), 0)  # type: ignore
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_rand_lambdad_identity(self, t):
+        img = t(np.zeros((10, 10)))
+        data = {"img": img, "prop": 1.0}
+
+        test_func = RandTest()
+        test_func.set_random_state(seed=134)
+        expected = {"img": test_func(data["img"]), "prop": 1.0}
+        test_func.set_random_state(seed=134)
+
+        # default prob
+        tr = RandLambdad(keys=["img", "prop"], func=test_func, overwrite=[True, False])
+        ret = tr(deepcopy(data))
+        self.check(tr, data, ret, expected)
+
+        tr = RandLambdad(keys=["img", "prop"], func=test_func, prob=0.0)
+        ret = tr(deepcopy(data))
+        self.check(tr, data, ret, expected=data)
+
+        trans = RandLambdad(keys=["img", "prop"], func=test_func, prob=0.5)
+        trans.set_random_state(seed=123)
+        ret = trans(deepcopy(data))
+        self.check(trans, data, ret, expected=data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/utility/test_simulatedelay.py

@@ -0,0 +1,36 @@
+# 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 time
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.utility.array import SimulateDelay
+from tests.test_utils import NumpyImageTestCase2D
+
+
+class TestSimulateDelay(NumpyImageTestCase2D):
+    @parameterized.expand([(0.45,), (1,)])
+    def test_value(self, delay_test_time: float):
+        resize = SimulateDelay(delay_time=delay_test_time)
+        start: float = time.time()
+        _ = resize(self.imt[0])
+        stop: float = time.time()
+        measured_approximate: float = stop - start
+        np.testing.assert_allclose(delay_test_time, measured_approximate, rtol=0.5)
+
+
+if __name__ == "__main__":
+    unittest.main()