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

tests/transforms/test_clip_intensity_percentiles.py

@@ -0,0 +1,196 @@
+# 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.transforms import ClipIntensityPercentiles
+from monai.transforms.utils import soft_clip
+from monai.transforms.utils_pytorch_numpy_unification import clip, percentile
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, NumpyImageTestCase3D, assert_allclose
+
+
+def test_hard_clip_func(im, lower, upper):
+    im_t = convert_to_tensor(im)
+    if lower is None:
+        upper = percentile(im_t, upper)
+    elif upper is None:
+        lower = percentile(im_t, lower)
+    else:
+        lower, upper = percentile(im_t, (lower, upper))
+    return clip(im_t, lower, upper)
+
+
+def test_soft_clip_func(im, lower, upper):
+    im_t = convert_to_tensor(im)
+    if lower is None:
+        upper = percentile(im_t, upper)
+    elif upper is None:
+        lower = percentile(im_t, lower)
+    else:
+        lower, upper = percentile(im_t, (lower, upper))
+    return soft_clip(im_t, minv=lower, maxv=upper, sharpness_factor=1.0, dtype=torch.float32)
+
+
+class TestClipIntensityPercentiles2D(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_two_sided(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=95, lower=5)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 5, 95)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_high(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=95, lower=None)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 0, 95)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_low(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=None, lower=5)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 5, 100)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_two_sided(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=95, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, 5, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_high(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=95, lower=None, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, None, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_low(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=None, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, 5, None)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        clipper = ClipIntensityPercentiles(upper=95, lower=5, channel_wise=True)
+        im = p(self.imt)
+        result = clipper(im)
+        im_t = convert_to_tensor(self.imt)
+        for i, c in enumerate(im_t):
+            lower, upper = percentile(c, (5, 95))
+            expected = clip(c, lower, upper)
+            assert_allclose(result[i], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    def test_ill_sharpness_factor(self):
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentiles(upper=95, lower=5, sharpness_factor=0.0)
+
+    def test_ill_lower_percentile(self):
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentiles(upper=None, lower=-1)
+
+    def test_ill_upper_percentile(self):
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentiles(upper=101, lower=None)
+
+    def test_ill_percentiles(self):
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentiles(upper=95, lower=96)
+
+    def test_ill_both_none(self):
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentiles(upper=None, lower=None)
+
+
+class TestClipIntensityPercentiles3D(NumpyImageTestCase3D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_two_sided(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=95, lower=5)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 5, 95)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_high(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=95, lower=None)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 0, 95)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_low(self, p):
+        hard_clipper = ClipIntensityPercentiles(upper=None, lower=5)
+        im = p(self.imt)
+        result = hard_clipper(im)
+        expected = test_hard_clip_func(im, 5, 100)
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_two_sided(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=95, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, 5, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_high(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=95, lower=None, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, None, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_low(self, p):
+        soft_clipper = ClipIntensityPercentiles(upper=None, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper(im)
+        expected = test_soft_clip_func(im, 5, None)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        clipper = ClipIntensityPercentiles(upper=95, lower=5, channel_wise=True)
+        im = p(self.imt)
+        result = clipper(im)
+        im_t = convert_to_tensor(self.imt)
+        for i, c in enumerate(im_t):
+            lower, upper = percentile(c, (5, 95))
+            expected = clip(c, lower, upper)
+            assert_allclose(result[i], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_clip_intensity_percentilesd.py

@@ -0,0 +1,193 @@
+# 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 ClipIntensityPercentilesd
+from monai.transforms.utils_pytorch_numpy_unification import clip, percentile
+from monai.utils.type_conversion import convert_to_tensor
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, NumpyImageTestCase3D, assert_allclose
+from tests.transforms.test_clip_intensity_percentiles import test_hard_clip_func, test_soft_clip_func
+
+
+class TestClipIntensityPercentilesd2D(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_two_sided(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 5, 95)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_high(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=None)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 0, 95)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_low(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=None, lower=5)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 5, 100)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_two_sided(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, 5, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_high(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=None, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, None, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_low(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=None, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, 5, None)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        key = "img"
+        clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5, channel_wise=True)
+        im = p(self.imt)
+        result = clipper({key: im})
+        im_t = convert_to_tensor(self.imt)
+        for i, c in enumerate(im_t):
+            lower, upper = percentile(c, (5, 95))
+            expected = clip(c, lower, upper)
+            assert_allclose(result[key][i], p(expected), type_test="tensor", rtol=1e-3, atol=0)
+
+    def test_ill_sharpness_factor(self):
+        key = "img"
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentilesd(keys=[key], upper=95, lower=5, sharpness_factor=0.0)
+
+    def test_ill_lower_percentile(self):
+        key = "img"
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentilesd(keys=[key], upper=None, lower=-1)
+
+    def test_ill_upper_percentile(self):
+        key = "img"
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentilesd(keys=[key], upper=101, lower=None)
+
+    def test_ill_percentiles(self):
+        key = "img"
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentilesd(keys=[key], upper=95, lower=96)
+
+    def test_ill_both_none(self):
+        key = "img"
+        with self.assertRaises(ValueError):
+            ClipIntensityPercentilesd(keys=[key], upper=None, lower=None)
+
+
+class TestClipIntensityPercentilesd3D(NumpyImageTestCase3D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_two_sided(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 5, 95)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_high(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=None)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 0, 95)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_hard_clipping_one_sided_low(self, p):
+        key = "img"
+        hard_clipper = ClipIntensityPercentilesd(keys=[key], upper=None, lower=5)
+        im = p(self.imt)
+        result = hard_clipper({key: im})
+        expected = test_hard_clip_func(im, 5, 100)
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_two_sided(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, 5, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_high(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=None, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, None, 95)
+        # the rtol is set to 1e-4 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_soft_clipping_one_sided_low(self, p):
+        key = "img"
+        soft_clipper = ClipIntensityPercentilesd(keys=[key], upper=None, lower=5, sharpness_factor=1.0)
+        im = p(self.imt)
+        result = soft_clipper({key: im})
+        expected = test_soft_clip_func(im, 5, None)
+        # the rtol is set to 1e-6 because the logaddexp function used in softplus is not stable accross torch and numpy
+        assert_allclose(result[key], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, p):
+        key = "img"
+        clipper = ClipIntensityPercentilesd(keys=[key], upper=95, lower=5, channel_wise=True)
+        im = p(self.imt)
+        result = clipper({key: im})
+        im_t = convert_to_tensor(im)
+        for i, c in enumerate(im_t):
+            lower, upper = percentile(c, (5, 95))
+            expected = clip(c, lower, upper)
+            assert_allclose(result[key][i], p(expected), type_test="tensor", rtol=1e-4, atol=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_compose_get_number_conversions.py

@@ -0,0 +1,127 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from copy import deepcopy
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import Compose
+from monai.transforms.compose import OneOf
+from monai.transforms.transform import Transform
+from monai.transforms.utils import get_number_image_type_conversions
+from monai.utils import convert_to_numpy, convert_to_tensor
+
+NP_ARR = np.ones((10, 10, 10))
+PT_ARR = torch.as_tensor(NP_ARR)
+KEY = "IMAGE"
+
+
+def _apply(x, fn):
+    if isinstance(x, dict):
+        d = deepcopy(x)
+        d[KEY] = fn(d[KEY])
+        return d
+    return fn(x)
+
+
+class Load(Transform):
+
+    def __init__(self, as_tensor):
+        self.fn = lambda _: PT_ARR if as_tensor else NP_ARR
+
+    def __call__(self, x):
+        return _apply(x, self.fn)
+
+
+class N(Transform):
+
+    def __call__(self, x):
+        return _apply(x, convert_to_numpy)
+
+
+class T(Transform):
+
+    def __call__(self, x):
+        return _apply(x, convert_to_tensor)
+
+
+class NT(Transform):
+
+    def __call__(self, x):
+        return _apply(x, lambda x: x)
+
+
+class TCPU(Transform):
+
+    def __call__(self, x):
+        return _apply(x, lambda x: convert_to_tensor(x).cpu())
+
+
+class TGPU(Transform):
+
+    def __call__(self, x):
+        return _apply(x, lambda x: convert_to_tensor(x).cuda())
+
+
+TESTS: list[tuple] = []
+for is_dict in (False, True):
+    # same type depends on input
+    TESTS.append(((N(), N()), is_dict, NP_ARR, 0))
+    TESTS.append(((N(), N()), is_dict, PT_ARR, 1))
+    TESTS.append(((T(), T()), is_dict, NP_ARR, 1))
+    TESTS.append(((T(), T()), is_dict, PT_ARR, 0))
+
+    # loading depends on loader's output type and following transform
+    TESTS.append(((Load(as_tensor=False), N()), is_dict, "fname.nii", 0))
+    TESTS.append(((Load(as_tensor=True), N()), is_dict, "fname.nii", 1))
+    TESTS.append(((Load(as_tensor=False), T()), is_dict, "fname.nii", 1))
+    TESTS.append(((Load(as_tensor=True), T()), is_dict, "fname.nii", 0))
+    TESTS.append(((Load(as_tensor=True), NT()), is_dict, "fname.nii", 0))
+    TESTS.append(((Load(as_tensor=True), NT()), is_dict, "fname.nii", 0))
+
+    # no changes for ambivalent transforms
+    TESTS.append(((NT(), NT()), is_dict, NP_ARR, 0))
+    TESTS.append(((NT(), NT()), is_dict, PT_ARR, 0))
+
+    # multiple conversions
+    TESTS.append(((N(), T(), N()), is_dict, PT_ARR, 3))
+    TESTS.append(((N(), NT(), T(), T(), NT(), NT(), N()), is_dict, PT_ARR, 3))
+
+    # shouldn't matter that there are nested composes
+    TESTS.append(((N(), NT(), T(), Compose([T(), NT(), NT(), N()])), is_dict, PT_ARR, 3))
+
+    # changing device also counts
+    if torch.cuda.is_available():
+        TESTS.append(((TCPU(), TGPU(), TCPU()), is_dict, PT_ARR, 2))
+
+
+class TestComposeNumConversions(unittest.TestCase):
+
+    @parameterized.expand(TESTS)
+    def test_get_number_of_conversions(self, transforms, is_dict, input, expected):
+        input = input if not is_dict else {KEY: input, "Other": NP_ARR}
+        tr = Compose(transforms)
+        n = get_number_image_type_conversions(tr, input, key=KEY if is_dict else None)
+        self.assertEqual(n, expected)
+
+    def test_raises(self):
+        tr = Compose([N(), OneOf([T(), T()])])
+        with self.assertRaises(RuntimeError):
+            get_number_image_type_conversions(tr, NP_ARR)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_concat_itemsd.py

@@ -0,0 +1,82 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+
+from monai.data import MetaTensor
+from monai.transforms import ConcatItemsd
+from tests.test_utils import assert_allclose
+
+
+class TestConcatItemsd(unittest.TestCase):
+    def test_tensor_values(self):
+        device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu:0")
+        input_data = {
+            "img1": torch.tensor([[0, 1], [1, 2]], device=device),
+            "img2": torch.tensor([[0, 1], [1, 2]], device=device),
+        }
+        result = ConcatItemsd(keys=["img1", "img2"], name="cat_img")(input_data)
+        self.assertIn("cat_img", result)
+        result["cat_img"] += 1
+        assert_allclose(result["img1"], torch.tensor([[0, 1], [1, 2]], device=device))
+        assert_allclose(result["cat_img"], torch.tensor([[1, 2], [2, 3], [1, 2], [2, 3]], device=device))
+
+    def test_metatensor_values(self):
+        device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu:0")
+        input_data = {
+            "img1": MetaTensor([[0, 1], [1, 2]], device=device),
+            "img2": MetaTensor([[0, 1], [1, 2]], device=device),
+        }
+        result = ConcatItemsd(keys=["img1", "img2"], name="cat_img")(input_data)
+        self.assertIn("cat_img", result)
+        self.assertIsInstance(result["cat_img"], MetaTensor)
+        self.assertEqual(result["img1"].meta, result["cat_img"].meta)
+        result["cat_img"] += 1
+        assert_allclose(result["img1"], torch.tensor([[0, 1], [1, 2]], device=device))
+        assert_allclose(result["cat_img"], torch.tensor([[1, 2], [2, 3], [1, 2], [2, 3]], device=device))
+
+    def test_numpy_values(self):
+        input_data = {"img1": np.array([[0, 1], [1, 2]]), "img2": np.array([[0, 1], [1, 2]])}
+        result = ConcatItemsd(keys=["img1", "img2"], name="cat_img")(input_data)
+        self.assertIn("cat_img", result)
+        result["cat_img"] += 1
+        np.testing.assert_allclose(result["img1"], np.array([[0, 1], [1, 2]]))
+        np.testing.assert_allclose(result["cat_img"], np.array([[1, 2], [2, 3], [1, 2], [2, 3]]))
+
+    def test_single_numpy(self):
+        input_data = {"img": np.array([[0, 1], [1, 2]])}
+        result = ConcatItemsd(keys="img", name="cat_img")(input_data)
+        result["cat_img"] += 1
+        np.testing.assert_allclose(result["img"], np.array([[0, 1], [1, 2]]))
+        np.testing.assert_allclose(result["cat_img"], np.array([[1, 2], [2, 3]]))
+
+    def test_single_tensor(self):
+        input_data = {"img": torch.tensor([[0, 1], [1, 2]])}
+        result = ConcatItemsd(keys="img", name="cat_img")(input_data)
+        result["cat_img"] += 1
+        assert_allclose(result["img"], torch.tensor([[0, 1], [1, 2]]))
+        assert_allclose(result["cat_img"], torch.tensor([[1, 2], [2, 3]]))
+
+    def test_single_metatensor(self):
+        input_data = {"img": MetaTensor([[0, 1], [1, 2]])}
+        result = ConcatItemsd(keys="img", name="cat_img")(input_data)
+        result["cat_img"] += 1
+        assert_allclose(result["img"], torch.tensor([[0, 1], [1, 2]]))
+        assert_allclose(result["cat_img"], torch.tensor([[1, 2], [2, 3]]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_convert_to_multi_channel.py

@@ -0,0 +1,59 @@
+# 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.transforms import ConvertToMultiChannelBasedOnBratsClasses
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.extend(
+        [
+            [
+                p([[0, 1, 2], [1, 2, 4], [0, 1, 4]]),
+                p(
+                    [
+                        [[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]],
+                    ]
+                ),
+            ],
+            [
+                p([[[[0, 1], [1, 2]], [[2, 4], [4, 4]]]]),
+                p(
+                    [
+                        [[[0, 1], [1, 0]], [[0, 1], [1, 1]]],
+                        [[[0, 1], [1, 1]], [[1, 1], [1, 1]]],
+                        [[[0, 0], [0, 0]], [[0, 1], [1, 1]]],
+                    ]
+                ),
+            ],
+        ]
+    )
+
+
+class TestConvertToMultiChannel(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_type_shape(self, data, expected_result):
+        result = ConvertToMultiChannelBasedOnBratsClasses()(data)
+        assert_allclose(result, expected_result)
+        self.assertTrue(result.dtype in (bool, torch.bool))
+
+
+if __name__ == "__main__":
+    unittest.main()