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

tests/transforms/spatial/test_spatial_resampled.py

@@ -0,0 +1,124 @@
+# 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 platform
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_tensor import MetaTensor
+from monai.data.utils import to_affine_nd
+from monai.transforms.spatial.dictionary import SpatialResampled
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_DEVICES, assert_allclose
+
+ON_AARCH64 = platform.machine() == "aarch64"
+if ON_AARCH64:
+    rtol, atol = 1e-1, 1e-2
+else:
+    rtol, atol = 1e-3, 1e-4
+
+TESTS = []
+
+destinations_3d = [
+    torch.tensor([[1.0, 0.0, 0.0, 0.0], [0.0, -1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+    torch.tensor([[-1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+]
+expected_3d = [
+    torch.tensor([[[[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]], [[10.0, 11.0, 12.0], [7.0, 8.0, 9.0]]]]),
+    torch.tensor([[[[7.0, 8.0, 9.0], [10.0, 11.0, 12.0]], [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]),
+]
+
+for dst, expct in zip(destinations_3d, expected_3d):
+    for device in TEST_DEVICES:
+        for align in (True, False):
+            for dtype in (torch.float32, torch.float64):
+                interp = ("nearest", "bilinear")
+                for interp_mode in interp:
+                    for padding_mode in ("zeros", "border", "reflection"):
+                        TESTS.append(
+                            [
+                                np.arange(12).reshape((1, 2, 2, 3)) + 1.0,  # data
+                                *device,
+                                dst,
+                                {
+                                    "dst_keys": "dst_affine",
+                                    "dtype": dtype,
+                                    "align_corners": align,
+                                    "mode": interp_mode,
+                                    "padding_mode": padding_mode,
+                                },
+                                expct,
+                            ]
+                        )
+
+destinations_2d = [
+    torch.tensor([[1.0, 0.0, 0.0], [0.0, -1.0, 1.0], [0.0, 0.0, 1.0]]),  # flip the second
+    torch.tensor([[-1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]),  # flip the first
+]
+
+expected_2d = [torch.tensor([[[2.0, 1.0], [4.0, 3.0]]]), torch.tensor([[[3.0, 4.0], [1.0, 2.0]]])]
+
+for dst, expct in zip(destinations_2d, expected_2d):
+    for device in TEST_DEVICES:
+        for align in (False, True):
+            for dtype in (torch.float32, torch.float64):
+                for interp_mode in ("nearest", "bilinear"):
+                    TESTS.append(
+                        [
+                            np.arange(4).reshape((1, 2, 2)) + 1.0,  # data
+                            *device,
+                            dst,
+                            {
+                                "dst_keys": "dst_affine",
+                                "dtype": dtype,
+                                "align_corners": align,
+                                "mode": interp_mode,
+                                "padding_mode": "zeros",
+                            },
+                            expct,
+                        ]
+                    )
+
+
+class TestSpatialResample(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_flips_inverse(self, img, device, dst_affine, kwargs, expected_output):
+        img = MetaTensor(img, affine=torch.eye(4)).to(device)
+        data = {"img": img, "dst_affine": dst_affine}
+        init_param = kwargs.copy()
+        init_param["keys"] = "img"
+        call_param = {"data": data}
+        xform = SpatialResampled(**init_param)
+        output_data = xform(**call_param)
+        out = output_data["img"]
+
+        assert_allclose(out, expected_output, rtol=1e-2, atol=1e-2)
+        assert_allclose(to_affine_nd(len(out.shape) - 1, out.affine), dst_affine, rtol=1e-2, atol=1e-2)
+
+        # check lazy
+        lazy_xform = SpatialResampled(**init_param)
+        test_resampler_lazy(lazy_xform, output_data, init_param, call_param, output_key="img", rtol=rtol, atol=atol)
+
+        # check inverse
+        inverted = xform.inverse(output_data)["img"]
+        self.assertEqual(inverted.applied_operations, [])  # no further invert after inverting
+        expected_affine = to_affine_nd(len(out.affine) - 1, torch.eye(4))
+        assert_allclose(inverted.affine, expected_affine, rtol=1e-2, atol=1e-2)
+        assert_allclose(inverted, img, rtol=1e-2, atol=1e-2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_activations.py

@@ -0,0 +1,120 @@
+# 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.networks.layers.factories import Act
+from monai.transforms import Activations
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TEST_CASES = []
+for p in TEST_NDARRAYS:
+    TEST_CASES.append(
+        [
+            {"sigmoid": True, "softmax": False, "other": None},
+            p([[[0.0, 1.0], [2.0, 3.0]]]),
+            p([[[0.5000, 0.7311], [0.8808, 0.9526]]]),
+            (1, 2, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"sigmoid": False, "softmax": True, "other": None},
+            p([[[0.0, 1.0]], [[2.0, 3.0]]]),
+            p([[[0.1192, 0.1192]], [[0.8808, 0.8808]]]),
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"sigmoid": False, "softmax": True, "other": None, "unused": True, "dim": 1},
+            p([[[0.0, 1.0]], [[2.0, 3.0]]]),
+            p([[[1.0, 1.0]], [[1.0, 1.0]]]),
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"sigmoid": False, "softmax": False, "other": torch.tanh},
+            p([[[0.0, 1.0], [2.0, 3.0]]]),
+            p([[[0.0000, 0.7616], [0.9640, 0.9951]]]),
+            (1, 2, 2),
+        ]
+    )
+
+TEST_CASE_4 = [
+    "swish",
+    torch.tensor([[[-10, -8, -6, -4, -2], [0, 2, 4, 6, 8]]], dtype=torch.float32),
+    torch.tensor(
+        [[[-4.54e-04, -2.68e-03, -1.48e-02, -7.19e-02, -2.38e-01], [0.00e00, 1.76e00, 3.93e00, 5.99e00, 8.00e00]]]
+    ),
+    (1, 2, 5),
+]
+
+TEST_CASE_5 = [
+    "memswish",
+    torch.tensor([[[-10, -8, -6, -4, -2], [0, 2, 4, 6, 8]]], dtype=torch.float32),
+    torch.tensor(
+        [[[-4.54e-04, -2.68e-03, -1.48e-02, -7.19e-02, -2.38e-01], [0.00e00, 1.76e00, 3.93e00, 5.99e00, 8.00e00]]]
+    ),
+    (1, 2, 5),
+]
+
+TEST_CASE_6 = [
+    "mish",
+    torch.tensor([[[-10, -8, -6, -4, -2], [0, 2, 4, 6, 8]]], dtype=torch.float32),
+    torch.tensor(
+        [[[-4.54e-04, -2.68e-03, -1.49e-02, -7.26e-02, -2.53e-01], [0.00e00, 1.94e00, 4.00e00, 6.00e00, 8.00e00]]]
+    ),
+    (1, 2, 5),
+]
+
+TEST_CASE_7 = [
+    "geglu",
+    torch.tensor([[[-10, -8, -6, -4, -2, 0], [0, 2, 4, 6, 8, 10]]], dtype=torch.float32),
+    torch.tensor([[[1.27e-03, 3.64e-01, 0.00e00], [0.00e00, 1.60e01, 4.00e01]]]),
+    (1, 2, 3),
+]
+
+
+class TestActivations(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_value_shape(self, input_param, img, out, expected_shape):
+        result = Activations(**input_param)(img)
+
+        def _compare(ret, out, shape):
+            assert_allclose(ret, out, rtol=1e-3, type_test=False)
+            self.assertTupleEqual(ret.shape, shape)
+
+        if isinstance(result, (list, tuple)):
+            for r, e in zip(result, out):
+                _compare(r, e, expected_shape)
+        else:
+            _compare(result, out, expected_shape)
+
+    @parameterized.expand([TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7])
+    def test_monai_activations_value_shape(self, input_param, img, out, expected_shape):
+        act = Act[input_param]()
+        result = act(img)
+        assert_allclose(result, out, rtol=1e-2, atol=1e-5)
+        self.assertTupleEqual(result.shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_activationsd.py

@@ -0,0 +1,64 @@
+# 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 Activationsd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TEST_CASES = []
+for p in TEST_NDARRAYS:
+    TEST_CASES.append(
+        [
+            {"keys": ["pred", "label"], "sigmoid": False, "softmax": [True, False], "other": None, "dim": 0},
+            {"pred": p([[[0.0, 1.0]], [[2.0, 3.0]]]), "label": p([[[0.0, 1.0]], [[2.0, 3.0]]])},
+            {"pred": p([[[0.1192, 0.1192]], [[0.8808, 0.8808]]]), "label": p([[[0.0, 1.0]], [[2.0, 3.0]]])},
+            (2, 1, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"keys": ["pred", "label"], "sigmoid": False, "softmax": False, "other": [torch.tanh, None]},
+            {"pred": p([[[0.0, 1.0], [2.0, 3.0]]]), "label": p([[[0.0, 1.0], [2.0, 3.0]]])},
+            {"pred": p([[[0.0000, 0.7616], [0.9640, 0.9951]]]), "label": p([[[0.0, 1.0], [2.0, 3.0]]])},
+            (1, 2, 2),
+        ]
+    )
+
+    TEST_CASES.append(
+        [
+            {"keys": "pred", "sigmoid": False, "softmax": False, "other": torch.tanh},
+            {"pred": p([[[0.0, 1.0], [2.0, 3.0]]])},
+            {"pred": p([[[0.0000, 0.7616], [0.9640, 0.9951]]])},
+            (1, 2, 2),
+        ]
+    )
+
+
+class TestActivationsd(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_value_shape(self, input_param, test_input, output, expected_shape):
+        result = Activationsd(**input_param)(test_input)
+        assert_allclose(result["pred"], output["pred"], rtol=1e-3, type_test="tensor")
+        self.assertTupleEqual(result["pred"].shape, expected_shape)
+        if "label" in result:
+            assert_allclose(result["label"], output["label"], rtol=1e-3, type_test="tensor")
+            self.assertTupleEqual(result["label"].shape, expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_adaptors.py

@@ -0,0 +1,160 @@
+# 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 itertools
+import unittest
+
+from monai.transforms.adaptors import FunctionSignature, adaptor, apply_alias, to_kwargs
+
+
+class TestAdaptors(unittest.TestCase):
+
+    def test_function_signature(self):
+
+        def foo(image, label=None, *a, **kw):
+            pass
+
+        _ = FunctionSignature(foo)
+
+    def test_single_in_single_out(self):
+
+        def foo(image):
+            return image * 2
+
+        it = itertools.product(["image", ["image"]], [None, "image", ["image"], {"image": "image"}])
+        for i in it:
+            d = {"image": 2}
+            dres = adaptor(foo, i[0], i[1])(d)
+            self.assertEqual(dres["image"], 4)
+
+        d = {"image": 2}
+        dres = adaptor(foo, "image")(d)
+        self.assertEqual(dres["image"], 4)
+
+        d = {"image": 2}
+        dres = adaptor(foo, "image", "image")(d)
+        self.assertEqual(dres["image"], 4)
+
+        d = {"image": 2}
+        dres = adaptor(foo, "image", {"image": "image"})(d)
+        self.assertEqual(dres["image"], 4)
+
+        d = {"img": 2}
+        dres = adaptor(foo, "img", {"img": "image"})(d)
+        self.assertEqual(dres["img"], 4)
+
+        d = {"img": 2}
+        dres = adaptor(foo, ["img"], {"img": "image"})(d)
+        self.assertEqual(dres["img"], 4)
+
+    def test_multi_in_single_out(self):
+
+        def foo(image, label):
+            return image * label
+
+        it = itertools.product(["image", ["image"]], [None, ["image", "label"], {"image": "image", "label": "label"}])
+
+        for i in it:
+            d = {"image": 2, "label": 3}
+            dres = adaptor(foo, i[0], i[1])(d)
+            self.assertEqual(dres["image"], 6)
+            self.assertEqual(dres["label"], 3)
+
+        it = itertools.product(
+            ["newimage", ["newimage"]], [None, ["image", "label"], {"image": "image", "label": "label"}]
+        )
+
+        for i in it:
+            d = {"image": 2, "label": 3}
+            dres = adaptor(foo, i[0], i[1])(d)
+            self.assertEqual(dres["image"], 2)
+            self.assertEqual(dres["label"], 3)
+            self.assertEqual(dres["newimage"], 6)
+
+        it = itertools.product(["img", ["img"]], [{"img": "image", "lbl": "label"}])
+
+        for i in it:
+            d = {"img": 2, "lbl": 3}
+            dres = adaptor(foo, i[0], i[1])(d)
+            self.assertEqual(dres["img"], 6)
+            self.assertEqual(dres["lbl"], 3)
+
+    def test_default_arg_single_out(self):
+
+        def foo(a, b=2):
+            return a * b
+
+        d = {"a": 5}
+        dres = adaptor(foo, "c")(d)
+        self.assertEqual(dres["c"], 10)
+
+        d = {"b": 5}
+        with self.assertRaises(TypeError):
+            dres = adaptor(foo, "c")(d)
+
+    def test_multi_out(self):
+
+        def foo(a, b):
+            return a * b, a / b
+
+        d = {"a": 3, "b": 4}
+        dres = adaptor(foo, ["c", "d"])(d)
+        self.assertEqual(dres["c"], 12)
+        self.assertEqual(dres["d"], 3 / 4)
+
+    def test_dict_out(self):
+
+        def foo(a):
+            return {"a": a * 2}
+
+        d = {"a": 2}
+        dres = adaptor(foo, {"a": "a"})(d)
+        self.assertEqual(dres["a"], 4)
+
+        d = {"b": 2}
+        dres = adaptor(foo, {"a": "b"}, {"b": "a"})(d)
+        self.assertEqual(dres["b"], 4)
+
+
+class TestApplyAlias(unittest.TestCase):
+
+    def test_apply_alias(self):
+
+        def foo(d):
+            d["x"] *= 2
+            return d
+
+        d = {"a": 1, "b": 3}
+        result = apply_alias(foo, {"b": "x"})(d)
+        self.assertDictEqual({"a": 1, "b": 6}, result)
+
+
+class TestToKwargs(unittest.TestCase):
+
+    def test_to_kwargs(self):
+
+        def foo(**kwargs):
+            results = {k: v * 2 for k, v in kwargs.items()}
+            return results
+
+        def compose_like(fn, data):
+            data = fn(data)
+            return data
+
+        d = {"a": 1, "b": 2}
+
+        actual = compose_like(to_kwargs(foo), d)
+        self.assertDictEqual(actual, {"a": 2, "b": 4})
+
+        with self.assertRaises(TypeError):
+            actual = compose_like(foo, d)

tests/transforms/test_add_coordinate_channels.py

@@ -0,0 +1,53 @@
+# 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 AddCoordinateChannels
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS, TEST_CASES_ERROR_1, TEST_CASES_ERROR_2 = [], [], []
+for p in TEST_NDARRAYS:
+    TESTS.append([{"spatial_dims": (0, 1, 2)}, p(np.random.randint(0, 2, size=(1, 3, 3, 3))), (4, 3, 3, 3)])
+    TESTS.append([{"spatial_dims": (0,)}, p(np.random.randint(0, 2, size=(1, 3, 3, 3))), (2, 3, 3, 3)])
+    TEST_CASES_ERROR_1.append([{"spatial_dims": (2,)}, p(np.random.randint(0, 2, size=(1, 3, 3)))])
+    TEST_CASES_ERROR_2.append([{"spatial_dims": (-1, 0, 1)}, p(np.random.randint(0, 2, size=(1, 3, 3)))])
+
+
+class TestAddCoordinateChannels(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input, expected_shape):
+        result = AddCoordinateChannels(**input_param)(input)
+        self.assertEqual(type(result), type(input))
+        if isinstance(result, torch.Tensor):
+            self.assertEqual(result.device, input.device)
+        self.assertEqual(list(result.shape), list(expected_shape))
+        assert_allclose(input[0, ...], result[0, ...])
+
+    @parameterized.expand(TEST_CASES_ERROR_1)
+    def test_max_channel(self, input_param, input):
+        with self.assertRaises(ValueError):
+            AddCoordinateChannels(**input_param)(input)
+
+    @parameterized.expand(TEST_CASES_ERROR_2)
+    def test_channel_dim(self, input_param, input):
+        with self.assertRaises(ValueError):
+            AddCoordinateChannels(**input_param)(input)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_add_coordinate_channelsd.py

@@ -0,0 +1,67 @@
+# 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 AddCoordinateChannelsd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS, TEST_CASES_ERROR_1, TEST_CASES_ERROR_2 = [], [], []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"spatial_dims": (0, 1, 2), "keys": ["img"]},
+            {"img": p(np.random.randint(0, 2, size=(1, 3, 3, 3)))},
+            (4, 3, 3, 3),
+        ]
+    )
+    TESTS.append(
+        [{"spatial_dims": (0,), "keys": ["img"]}, {"img": p(np.random.randint(0, 2, size=(1, 3, 3, 3)))}, (2, 3, 3, 3)]
+    )
+
+    TEST_CASES_ERROR_1.append(
+        [{"spatial_dims": (2,), "keys": ["img"]}, {"img": p(np.random.randint(0, 2, size=(1, 3, 3)))}]
+    )
+    TEST_CASES_ERROR_2.append(
+        [{"spatial_dims": (-1, 0, 1), "keys": ["img"]}, {"img": p(np.random.randint(0, 2, size=(1, 3, 3)))}]
+    )
+
+
+class TestAddCoordinateChannels(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, input_param, input, expected_shape):
+        result = AddCoordinateChannelsd(**input_param)(input)["img"]
+        input = input["img"]
+        self.assertEqual(type(result), type(input))
+        if isinstance(result, torch.Tensor):
+            self.assertEqual(result.device, input.device)
+        self.assertEqual(result.shape, expected_shape)
+        assert_allclose(input[0, ...], result[0, ...])
+
+    @parameterized.expand(TEST_CASES_ERROR_1)
+    def test_max_channel(self, input_param, input):
+        with self.assertRaises(ValueError):
+            AddCoordinateChannelsd(**input_param)(input)
+
+    @parameterized.expand(TEST_CASES_ERROR_2)
+    def test_channel_dim(self, input_param, input):
+        with self.assertRaises(ValueError):
+            AddCoordinateChannelsd(**input_param)(input)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_add_extreme_points_channel.py

@@ -0,0 +1,80 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import AddExtremePointsChannel
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+IMG_CHANNEL = 3
+TESTS = []
+for p in TEST_NDARRAYS:
+    for q in TEST_NDARRAYS:
+        TESTS.append(
+            [
+                {
+                    "img": p(np.zeros((IMG_CHANNEL, 4, 3))),
+                    "label": q(np.array([[[0, 1, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0]]])),
+                    "sigma": 1.0,
+                    "rescale_min": 0.0,
+                    "rescale_max": 1.0,
+                },
+                p(
+                    np.array(
+                        [
+                            [0.38318458, 0.98615628, 0.85551184],
+                            [0.35422316, 0.94430935, 1.0],
+                            [0.46000731, 0.57319659, 0.46000722],
+                            [0.64577687, 0.38318464, 0.0],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+        TESTS.append(
+            [
+                {
+                    "img": p(np.zeros((IMG_CHANNEL, 4, 3))),
+                    "label": q(np.array([[[0, 1, 0], [1, 1, 1], [0, 1, 0], [0, 1, 0]]])),
+                    "sigma": 1.0,
+                    "rescale_min": 0.0,
+                    "rescale_max": 1.0,
+                },
+                p(
+                    np.array(
+                        [
+                            [0.44628328, 0.80495411, 0.44628328],
+                            [0.6779086, 1.0, 0.67790854],
+                            [0.33002687, 0.62079221, 0.33002687],
+                            [0.0, 0.31848389, 0.0],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestAddExtremePointsChannel(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, input_data, expected):
+        add_extreme_points_channel = AddExtremePointsChannel()
+        result = add_extreme_points_channel(**input_data)
+        assert_allclose(result[IMG_CHANNEL], expected, rtol=1e-4, atol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()