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

tests/transforms/test_distance_transform_edt.py

@@ -0,0 +1,202 @@
+# 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.transforms import DistanceTransformEDT, DistanceTransformEDTd
+from tests.test_utils import HAS_CUPY, assert_allclose, optional_import, skip_if_no_cuda
+
+momorphology, has_cucim = optional_import("cucim.core.operations.morphology")
+ndimage, has_ndimage = optional_import("scipy.ndimage")
+cp, _ = optional_import("cupy")
+
+TEST_CASES = [
+    [
+        np.array(
+            ([[0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 0]],), dtype=np.float32
+        ),
+        np.array(
+            [
+                [
+                    [0.0, 1.0, 1.4142, 2.2361, 3.0],
+                    [0.0, 0.0, 1.0, 2.0, 2.0],
+                    [0.0, 1.0, 1.4142, 1.4142, 1.0],
+                    [0.0, 1.0, 1.4142, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ]
+            ]
+        ),
+    ],
+    [  # Example 4D input to test channel-wise CuPy
+        np.array(
+            [[[[0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 0]]]], dtype=np.float32
+        ),
+        np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 1.4142, 2.2361, 3.0],
+                        [0.0, 0.0, 1.0, 2.0, 2.0],
+                        [0.0, 1.0, 1.4142, 1.4142, 1.0],
+                        [0.0, 1.0, 1.4142, 1.0, 0.0],
+                        [0.0, 1.0, 1.0, 0.0, 0.0],
+                    ]
+                ]
+            ]
+        ),
+    ],
+    [
+        np.array(
+            [
+                [
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+                [
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+                [
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 1.0, 1.0, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        np.array(
+            [
+                [
+                    [0.0, 1.0, 1.4142135, 2.236068, 3.0],
+                    [0.0, 0.0, 1.0, 2.0, 2.0],
+                    [0.0, 1.0, 1.4142135, 1.4142135, 1.0],
+                    [0.0, 1.0, 1.4142135, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+                [
+                    [0.0, 1.0, 1.4142135, 2.236068, 3.0],
+                    [0.0, 0.0, 1.0, 2.0, 2.0],
+                    [0.0, 1.0, 1.4142135, 1.4142135, 1.0],
+                    [0.0, 1.0, 1.4142135, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+                [
+                    [0.0, 1.0, 1.4142135, 2.236068, 3.0],
+                    [0.0, 0.0, 1.0, 2.0, 2.0],
+                    [0.0, 1.0, 1.4142135, 1.4142135, 1.0],
+                    [0.0, 1.0, 1.4142135, 1.0, 0.0],
+                    [0.0, 1.0, 1.0, 0.0, 0.0],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+    ],
+]
+
+SAMPLING_TEST_CASES = [
+    [
+        2,
+        np.array(
+            ([[0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 0]],), dtype=np.float32
+        ),
+        np.array(
+            [
+                [
+                    [0.0, 2.0, 2.828427, 4.472136, 6.0],
+                    [0.0, 0.0, 2.0, 4.0, 4.0],
+                    [0.0, 2.0, 2.828427, 2.828427, 2.0],
+                    [0.0, 2.0, 2.828427, 2.0, 0.0],
+                    [0.0, 2.0, 2.0, 0.0, 0.0],
+                ]
+            ]
+        ),
+    ]
+]
+
+RAISES_TEST_CASES = (
+    [  # Example 4D input. Should raise under CuPy
+        np.array(
+            [[[[[0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 0]]]]],
+            dtype=np.float32,
+        )
+    ],
+)
+
+
+class TestDistanceTransformEDT(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_scipy_transform(self, input, expected_output):
+        transform = DistanceTransformEDT()
+        output = transform(input)
+        assert_allclose(output, expected_output, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @parameterized.expand(TEST_CASES)
+    def test_scipy_transformd(self, input, expected_output):
+        transform = DistanceTransformEDTd(keys=("to_transform",))
+        data = {"to_transform": input}
+        data_ = transform(data)
+        output = data_["to_transform"]
+        assert_allclose(output, expected_output, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @parameterized.expand(SAMPLING_TEST_CASES)
+    def test_scipy_sampling(self, sampling, input, expected_output):
+        transform = DistanceTransformEDT(sampling=sampling)
+        output = transform(input)
+        assert_allclose(output, expected_output, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @parameterized.expand(TEST_CASES)
+    @skip_if_no_cuda
+    @unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+    @unittest.skipUnless(momorphology, "cuCIM transforms are required.")
+    def test_cucim_transform(self, input, expected_output):
+        input_ = torch.tensor(input, device="cuda")
+        transform = DistanceTransformEDT()
+        output = transform(input_)
+        assert_allclose(cp.asnumpy(output), cp.asnumpy(expected_output), atol=1e-4, rtol=1e-4, type_test=False)
+
+    @parameterized.expand(SAMPLING_TEST_CASES)
+    @skip_if_no_cuda
+    @unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+    @unittest.skipUnless(momorphology, "cuCIM transforms are required.")
+    def test_cucim_sampling(self, sampling, input, expected_output):
+        input_ = torch.tensor(input, device="cuda")
+        transform = DistanceTransformEDT(sampling=sampling)
+        output = transform(input_)
+        assert_allclose(cp.asnumpy(output), cp.asnumpy(expected_output), atol=1e-4, rtol=1e-4, type_test=False)
+
+    @parameterized.expand(RAISES_TEST_CASES)
+    @skip_if_no_cuda
+    @unittest.skipUnless(HAS_CUPY, "CuPy is required.")
+    @unittest.skipUnless(momorphology, "cuCIM transforms are required.")
+    def test_cucim_raises(self, raises):
+        """Currently images of shape a certain shape are supported. This test checks for the according error message"""
+        input_ = torch.tensor(raises, device="cuda")
+        transform = DistanceTransformEDT()
+        with self.assertRaises(RuntimeError):
+            transform(input_)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_divisible_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 DivisiblePad
+from monai.utils.enums import NumpyPadMode, PytorchPadMode
+from tests.padders import PadTest
+
+TESTS = []
+
+# pad first dim to be divisible by 7, the second unchanged.
+TESTS.append([{"k": (7, -1)}, (3, 8, 7), (3, 14, 7)])
+# pad all dimensions to be divisible by 5
+TESTS.append([{"k": 5, "method": "end"}, (3, 10, 5, 17), (3, 10, 5, 20)])
+
+
+class TestDivisiblePad(PadTest):
+    Padder = DivisiblePad
+
+    @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 = {"k": 5, "method": "end"}
+        unchanged_slices = [slice(None), slice(None, 8), slice(None, 4)]
+        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_divisible_padd.py

@@ -0,0 +1,42 @@
+# 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 DivisiblePadd
+from monai.utils.enums import NumpyPadMode, PytorchPadMode
+from tests.padders import PadTest
+
+TESTS = [
+    [{"keys": "img", "k": [4, 3, 2]}, (3, 8, 8, 4), (3, 8, 9, 4)],
+    [{"keys": "img", "k": 7, "method": "end"}, (3, 8, 7), (3, 14, 7)],
+]
+
+
+class TestDivisiblePadd(PadTest):
+    Padder = DivisiblePadd
+
+    @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_ensure_channel_first.py

@@ -0,0 +1,113 @@
+# 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 os
+import tempfile
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+from parameterized import parameterized
+from PIL import Image
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import EnsureChannelFirst, LoadImage
+from monai.utils import optional_import
+
+itk, has_itk = optional_import("itk", allow_namespace_pkg=True)
+ITKReader, _ = optional_import("monai.data", name="ITKReader", as_type="decorator")
+
+TEST_CASE_1 = [{}, ["test_image.nii.gz"], None]
+
+TEST_CASE_2 = [{}, ["test_image.nii.gz"], -1]
+
+TEST_CASE_3 = [{}, ["test_image.nii.gz", "test_image2.nii.gz", "test_image3.nii.gz"], None]
+
+TEST_CASE_4 = [{"reader": ITKReader() if has_itk else "itkreader"}, ["test_image.nii.gz"], None]
+
+TEST_CASE_5 = [{"reader": ITKReader() if has_itk else "itkreader"}, ["test_image.nii.gz"], -1]
+
+TEST_CASE_6 = [
+    {"reader": ITKReader() if has_itk else "itkreader"},
+    ["test_image.nii.gz", "test_image2.nii.gz", "test_image3.nii.gz"],
+    None,
+]
+
+
+class TestEnsureChannelFirst(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6])
+    @unittest.skipUnless(has_itk, "itk not installed")
+    def test_load_nifti(self, input_param, filenames, original_channel_dim):
+        # if original_channel_dim is None
+        test_image = np.random.rand(8, 8, 8)
+
+        if original_channel_dim == -1:
+            test_image = np.random.rand(8, 8, 8, 1)
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            for i, name in enumerate(filenames):
+                filenames[i] = os.path.join(tempdir, name)
+                nib.save(nib.Nifti1Image(test_image, np.eye(4)), filenames[i])
+
+            result = LoadImage(image_only=True, **input_param)(filenames)
+            result = EnsureChannelFirst()(result)
+            self.assertEqual(result.shape[0], len(filenames))
+
+    @unittest.skipUnless(has_itk, "itk not installed")
+    def test_itk_dicom_series_reader(self):
+        filenames = "tests/testing_data/CT_DICOM"
+        itk.ProcessObject.SetGlobalWarningDisplay(False)
+        result = LoadImage(image_only=True, reader=ITKReader(pixel_type=itk.UC))(filenames)
+        result = EnsureChannelFirst()(result)
+        self.assertEqual(result.shape[0], 1)
+
+    def test_load_png(self):
+        spatial_size = (6, 6, 3)
+        test_image = np.random.randint(0, 6, size=spatial_size)
+        with tempfile.TemporaryDirectory() as tempdir:
+            filename = os.path.join(tempdir, "test_image.png")
+            Image.fromarray(test_image.astype("uint8")).save(filename)
+            result = LoadImage(image_only=True)(filename)
+            result = EnsureChannelFirst()(result)
+            self.assertEqual(result.shape[0], 3)
+            result = EnsureChannelFirst(channel_dim=-1)(result)
+            self.assertEqual(result.shape, (6, 3, 6))
+
+    def test_check(self):
+        im = torch.zeros(1, 2, 3)
+        im_nodim = MetaTensor(im, meta={"original_channel_dim": None})
+
+        with self.assertRaises(ValueError):  # not MetaTensor
+            EnsureChannelFirst(channel_dim=None)(im)
+        with self.assertRaises(ValueError):  # no meta
+            EnsureChannelFirst(channel_dim=None)(MetaTensor(im))
+        with self.assertRaises(ValueError):  # no meta channel
+            EnsureChannelFirst()(im_nodim)
+
+        with self.assertWarns(Warning):
+            EnsureChannelFirst(strict_check=False, channel_dim=None)(im)
+
+        with self.assertWarns(Warning):
+            EnsureChannelFirst(strict_check=False, channel_dim=None)(im_nodim)
+
+    def test_default_channel_first(self):
+        im = torch.rand(4, 4)
+        result = EnsureChannelFirst(channel_dim="no_channel")(im)
+
+        self.assertEqual(result.shape, (1, 4, 4))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_ensure_channel_firstd.py

@@ -0,0 +1,85 @@
+# 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 os
+import tempfile
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+from parameterized import parameterized
+from PIL import Image
+
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import EnsureChannelFirstd, LoadImaged
+
+TEST_CASE_1 = [{"keys": "img"}, ["test_image.nii.gz"], None]
+
+TEST_CASE_2 = [{"keys": "img"}, ["test_image.nii.gz"], -1]
+
+TEST_CASE_3 = [{"keys": "img"}, ["test_image.nii.gz", "test_image2.nii.gz", "test_image3.nii.gz"], None]
+
+
+class TestEnsureChannelFirstd(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_load_nifti(self, input_param, filenames, original_channel_dim):
+        # if original_channel_dim is None:
+        test_image = np.random.rand(8, 8, 8)
+
+        if original_channel_dim == -1:
+            test_image = np.random.rand(8, 8, 8, 1)
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            for i, name in enumerate(filenames):
+                filenames[i] = os.path.join(tempdir, name)
+                nib.save(nib.Nifti1Image(test_image, np.eye(4)), filenames[i])
+            result = LoadImaged(**input_param)({"img": filenames})
+            result = EnsureChannelFirstd(**input_param)(result)
+            self.assertEqual(result["img"].shape[0], len(filenames))
+
+    def test_load_png(self):
+        spatial_size = (6, 6, 3)
+        test_image = np.random.randint(0, 256, size=spatial_size)
+        with tempfile.TemporaryDirectory() as tempdir:
+            filename = os.path.join(tempdir, "test_image.png")
+            Image.fromarray(test_image.astype("uint8")).save(filename)
+            result = LoadImaged(keys="img")({"img": filename})
+            result = EnsureChannelFirstd(keys="img")(result)
+            self.assertEqual(result["img"].shape[0], 3)
+
+    def test_exceptions(self):
+        im = torch.zeros((1, 2, 3))
+        im_nodim = MetaTensor(im, meta={"original_channel_dim": None})
+
+        with self.assertRaises(ValueError):  # no meta
+            EnsureChannelFirstd("img", channel_dim=None)({"img": im})
+        with self.assertRaises(ValueError):  # no meta channel
+            EnsureChannelFirstd("img", channel_dim=None)({"img": im_nodim})
+
+        with self.assertWarns(Warning):
+            EnsureChannelFirstd("img", strict_check=False, channel_dim=None)({"img": im})
+
+        with self.assertWarns(Warning):
+            EnsureChannelFirstd("img", strict_check=False, channel_dim=None)({"img": im_nodim})
+
+    def test_default_channel_first(self):
+        im = torch.rand(4, 4)
+        result = EnsureChannelFirstd("img", channel_dim="no_channel")({"img": im})
+
+        self.assertEqual(result["img"].shape, (1, 4, 4))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_ensure_type.py

@@ -0,0 +1,94 @@
+# 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.data import MetaTensor
+from monai.transforms import EnsureType
+from tests.test_utils import assert_allclose
+
+
+class TestEnsureType(unittest.TestCase):
+    def test_array_input(self):
+        test_datas = [np.array([[1, 2], [3, 4]]), torch.as_tensor([[1, 2], [3, 4]])]
+        if torch.cuda.is_available():
+            test_datas.append(test_datas[-1].cuda())
+        for test_data in test_datas:
+            for dtype in ("tensor", "NUMPY"):
+                result = EnsureType(dtype, dtype=np.float32 if dtype == "NUMPY" else None, device="cpu")(test_data)
+                if dtype == "NUMPY":
+                    self.assertTrue(result.dtype == np.float32)
+                self.assertTrue(isinstance(result, torch.Tensor if dtype == "tensor" else np.ndarray))
+                assert_allclose(result, test_data, type_test=False)
+                self.assertTupleEqual(result.shape, (2, 2))
+
+    def test_single_input(self):
+        test_datas = [5, 5.0, False, np.asarray(5), torch.tensor(5)]
+        if torch.cuda.is_available():
+            test_datas.append(test_datas[-1].cuda())
+        for test_data in test_datas:
+            for dtype in ("tensor", "numpy"):
+                result = EnsureType(data_type=dtype, device="cpu")(test_data)
+                self.assertTrue(isinstance(result, torch.Tensor if dtype == "tensor" else np.ndarray))
+                if isinstance(test_data, bool):
+                    self.assertFalse(result)
+                else:
+                    assert_allclose(result, test_data, type_test=False)
+                self.assertEqual(result.ndim, 0)
+
+    def test_string(self):
+        for dtype in ("tensor", "numpy"):
+            # string input
+            result = EnsureType(data_type=dtype)("test_string")
+            self.assertTrue(isinstance(result, str))
+            self.assertEqual(result, "test_string")
+            # numpy array of string
+            result = EnsureType(data_type=dtype)(np.array(["test_string0", "test_string1"]))
+            self.assertTrue(isinstance(result, np.ndarray))
+            self.assertEqual(result[1], "test_string1")
+
+    def test_list_tuple(self):
+        for dtype in ("tensor", "numpy"):
+            result = EnsureType(data_type=dtype, wrap_sequence=False, track_meta=True)([[1, 2], [3, 4]])
+            self.assertTrue(isinstance(result, list))
+            self.assertTrue(isinstance(result[0][1], MetaTensor if dtype == "tensor" else np.ndarray))
+            assert_allclose(result[1][0], torch.as_tensor(3), type_test=False)
+            # tuple of numpy arrays
+            result = EnsureType(data_type=dtype, wrap_sequence=False)((np.array([1, 2]), np.array([3, 4])))
+            self.assertTrue(isinstance(result, tuple))
+            self.assertTrue(isinstance(result[0], torch.Tensor if dtype == "tensor" else np.ndarray))
+            assert_allclose(result[1], torch.as_tensor([3, 4]), type_test=False)
+
+    def test_dict(self):
+        # simulate complicated input data
+        test_data = {
+            "img": np.array([1.0, 2.0], dtype=np.float32),
+            "meta": {"dims": 3, "size": np.array([1, 2, 3]), "path": "temp/test"},
+            "extra": None,
+        }
+        for dtype in ("tensor", "numpy"):
+            result = EnsureType(data_type=dtype, track_meta=False)(test_data)
+            self.assertTrue(isinstance(result, dict))
+            self.assertTrue(isinstance(result["img"], torch.Tensor if dtype == "tensor" else np.ndarray))
+            assert_allclose(result["img"], torch.as_tensor([1.0, 2.0]), type_test=False)
+            self.assertTrue(isinstance(result["meta"]["size"], torch.Tensor if dtype == "tensor" else np.ndarray))
+            assert_allclose(result["meta"]["size"], torch.as_tensor([1, 2, 3]), type_test=False)
+            self.assertEqual(result["meta"]["path"], "temp/test")
+            self.assertEqual(result["extra"], None)
+
+
+if __name__ == "__main__":
+    unittest.main()