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

tests/metrics/test_compute_roc_auc.py

@@ -0,0 +1,155 @@
+# 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.data import decollate_batch
+from monai.metrics import ROCAUCMetric, compute_roc_auc
+from monai.transforms import Activations, AsDiscrete, Compose, ToTensor
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+TEST_CASE_1 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]], device=_device),
+    torch.tensor([[0], [1], [0], [1]], device=_device),
+    True,
+    2,
+    "macro",
+    0.75,
+]
+
+TEST_CASE_2 = [
+    torch.tensor([[0.5], [0.5], [0.2], [8.3]]),
+    torch.tensor([[0], [1], [0], [1]]),
+    False,
+    None,
+    "macro",
+    0.875,
+]
+
+TEST_CASE_3 = [torch.tensor([[0.5], [0.5], [0.2], [8.3]]), torch.tensor([0, 1, 0, 1]), False, None, "macro", 0.875]
+
+TEST_CASE_4 = [torch.tensor([0.5, 0.5, 0.2, 8.3]), torch.tensor([0, 1, 0, 1]), False, None, "macro", 0.875]
+
+TEST_CASE_5 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0], [1], [0], [1]]),
+    True,
+    2,
+    "none",
+    [0.75, 0.75],
+]
+
+TEST_CASE_6 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+    torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+    True,
+    None,
+    "weighted",
+    0.56667,
+]
+
+TEST_CASE_7 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+    torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+    True,
+    None,
+    "micro",
+    0.62,
+]
+
+TEST_CASE_8 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0], [0], [0], [0]]),
+    True,
+    2,
+    "macro",
+    float("nan"),
+]
+
+TEST_CASE_9 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[1], [1], [1], [1]]),
+    True,
+    2,
+    "macro",
+    float("nan"),
+]
+
+TEST_CASE_10 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0, 0], [1, 1], [2, 2], [3, 3]]),
+    True,
+    None,
+    "macro",
+    float("nan"),
+]
+
+
+class TestComputeROCAUC(unittest.TestCase):
+
+    @parameterized.expand(
+        [
+            TEST_CASE_1,
+            TEST_CASE_2,
+            TEST_CASE_3,
+            TEST_CASE_4,
+            TEST_CASE_5,
+            TEST_CASE_6,
+            TEST_CASE_7,
+            TEST_CASE_8,
+            TEST_CASE_9,
+            TEST_CASE_10,
+        ]
+    )
+    def test_value(self, y_pred, y, softmax, to_onehot, average, expected_value):
+        y_pred_trans = Compose([ToTensor(), Activations(softmax=softmax)])
+        y_trans = Compose([ToTensor(), AsDiscrete(to_onehot=to_onehot)])
+        y_pred = torch.stack([y_pred_trans(i) for i in decollate_batch(y_pred)], dim=0)
+        y = torch.stack([y_trans(i) for i in decollate_batch(y)], dim=0)
+        result = compute_roc_auc(y_pred=y_pred, y=y, average=average)
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_1,
+            TEST_CASE_2,
+            TEST_CASE_3,
+            TEST_CASE_4,
+            TEST_CASE_5,
+            TEST_CASE_6,
+            TEST_CASE_7,
+            TEST_CASE_8,
+            TEST_CASE_9,
+            TEST_CASE_10,
+        ]
+    )
+    def test_class_value(self, y_pred, y, softmax, to_onehot, average, expected_value):
+        y_pred_trans = Compose([ToTensor(), Activations(softmax=softmax)])
+        y_trans = Compose([ToTensor(), AsDiscrete(to_onehot=to_onehot)])
+        y_pred = [y_pred_trans(i) for i in decollate_batch(y_pred)]
+        y = [y_trans(i) for i in decollate_batch(y)]
+        metric = ROCAUCMetric(average=average)
+        metric(y_pred=y_pred, y=y)
+        result = metric.aggregate()
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+        result = metric.aggregate(average=average)  # test optional argument
+        metric.reset()
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_compute_variance.py

@@ -0,0 +1,147 @@
+# 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.metrics import VarianceMetric, compute_variance
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# keep background, 1D Case
+TEST_CASE_1 = [  # y_pred (3, 1, 3), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0]]], device=_device),
+        "include_background": True,
+        "spatial_map": False,
+    },
+    [[0.0]],
+]
+
+# keep background, 2D Case
+TEST_CASE_2 = [  # y_pred (1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "include_background": True,
+        "spatial_map": False,
+    },
+    [[0.0]],
+]
+
+# keep background, 3D Case
+TEST_CASE_3 = [  # y_pred (1, 1, 1, 2, 2), expected out (0.0)
+    {
+        "y_pred": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "include_background": True,
+        "spatial_map": False,
+    },
+    [[0.0]],
+]
+
+# remove background, 1D Case
+TEST_CASE_4 = [  # y_pred (3, 1, 3), expected out (0.0)
+    {
+        "y_pred": torch.tensor(
+            [
+                [[1.0, 2.0, 3.0], [1.0, 1.0, 1.0]],
+                [[4.0, 5.0, 6.0], [1.0, 1.0, 1.0]],
+                [[7.0, 8.0, 9.0], [1.0, 1.0, 1.0]],
+            ],
+            device=_device,
+        ),
+        "include_background": False,
+        "spatial_map": False,
+    },
+    [[0.0]],
+]
+
+# Spatial Map Test Case for 2D Case
+TEST_CASE_5 = [  # y_pred (1, 1, 2, 2), expected out all (0.0) map of 2x2
+    {
+        "y_pred": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]]]], device=_device),
+        "include_background": True,
+        "spatial_map": True,
+    },
+    [[0.0, 0.0], [0.0, 0.0]],
+]
+
+# Spatial Map Test Case for 3D Case
+TEST_CASE_6 = [  # y_pred (1, 1, 2, 2, 2), expected out all (0.0) map of 2x2x2
+    {
+        "y_pred": torch.tensor([[[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]], device=_device),
+        "include_background": True,
+        "spatial_map": True,
+    },
+    [[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]],
+]
+
+# Threshold test for a 1D Case
+TEST_CASE_7 = [  # y_pred (3, 1, 3), expected out (0.0)
+    {
+        "y_pred": torch.tensor(
+            [
+                [[1.0, 2.0, 3.0], [1.0, 1.0, 0.0]],
+                [[4.0, 5.0, 6.0], [1.0, 1.0, 1.0]],
+                [[7.0, 8.0, 9.0], [1.0, 1.0, 0.0]],
+                [[1.0, 2.0, 3.0], [1.0, 1.0, 1.0]],
+            ],
+            device=_device,
+        ),
+        "include_background": False,
+        "spatial_map": False,
+        "threshold": 0.001,
+    },
+    [[0.083167]],
+]
+
+
+class TestComputeVariance(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
+    def test_value(self, input_data, expected_value):
+        result = compute_variance(**input_data)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+        np.testing.assert_equal(result.device, input_data["y_pred"].device)
+
+    @parameterized.expand([TEST_CASE_5, TEST_CASE_6])
+    def test_spatial_case(self, input_data, expected_value):
+        result = compute_variance(**input_data)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_7])
+    def test_threshold_case(self, input_data, expected_value):
+        result = compute_variance(**input_data)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
+    def test_value_class(self, input_data, expected_value):
+        vals = {}
+        vals["y_pred"] = input_data.pop("y_pred")
+        comp_var = VarianceMetric(**input_data)
+        result = comp_var(**vals)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+    @parameterized.expand([TEST_CASE_5, TEST_CASE_6])
+    def test_spatial_case_class(self, input_data, expected_value):
+        vals = {}
+        vals["y_pred"] = input_data.pop("y_pred")
+        comp_var = VarianceMetric(**input_data)
+        result = comp_var(**vals)
+        np.testing.assert_allclose(result.cpu().numpy(), expected_value, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_cumulative.py

@@ -0,0 +1,63 @@
+# 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 monai.metrics import Cumulative
+from tests.test_utils import assert_allclose
+
+
+class TestCumulative(unittest.TestCase):
+    def test_single(self):
+        c = Cumulative()
+        c.extend([2, 3])
+        c.append(1)
+        assert_allclose(c.get_buffer(), torch.tensor([2, 3, 1]))
+
+    def test_multi(self):
+        c = Cumulative()
+        c.extend([2, 3], [4, 6])
+        c.append(1)
+        assert_allclose(c.get_buffer()[0], torch.tensor([2, 3, 1]))
+        assert_allclose(c.get_buffer()[1], torch.tensor([4, 6]))
+
+        c.reset()
+        c.append()
+        c.extend()
+        self.assertEqual(c.get_buffer(), [])
+        c.get_buffer().append(1)
+        self.assertEqual(c.get_buffer(), [])  # no in-place update for the buffer
+
+        c.reset()
+
+    def test_ill(self):
+        c = Cumulative()
+        with self.assertRaises(TypeError):
+            c.extend(None)
+        with self.assertRaises(TypeError):
+            c.extend([])
+        with self.assertRaises(TypeError):
+            c.extend(1)
+        with self.assertRaises(TypeError):
+            c.append([])
+            c.append([1, 2])
+            c.get_buffer()
+        with self.assertRaises(TypeError):
+            c.append(None)
+            c.get_buffer()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_cumulative_average.py

@@ -0,0 +1,74 @@
+# 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.metrics import CumulativeAverage
+
+TEST_CASE_1 = []
+TEST_CASE_1.append([{"vals": [1, 2, 3], "avg": 2}])
+TEST_CASE_1.append([{"vals": [[1, 1, 1], [2, 2, 2], [3, 6, 9]], "avg": [2, 3, 4]}])
+
+TEST_CASE_1.append([{"vals": [2, 4, 6], "counts": [2, 1, 2], "avg": 4}])
+TEST_CASE_1.append(
+    [{"vals": [[3, 2, 1], [2, 3, 2], [0, 0, 9]], "counts": [[4, 4, 4], [4, 4, 4], [2, 2, 2]], "avg": [2, 2, 3]}]
+)
+
+TEST_CASE_1.append([{"vals": [1, 2, float("nan")], "avg": 1.5}])
+
+
+class TestAverageMeter(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASE_1)
+    def test_value_all(self, data):
+        # test orig
+        self.run_test(data)
+
+        # test in numpy
+        data["vals"] = np.array(data["vals"])
+        data["avg"] = np.array(data["avg"])
+        self.run_test(data)
+
+        # test as Tensors
+        data["vals"] = torch.tensor(data["vals"])
+        data["avg"] = torch.tensor(data["avg"], dtype=torch.float)
+        self.run_test(data)
+
+        if torch.cuda.is_available():
+            data["vals"] = data["vals"].cuda()
+            self.run_test(data)
+
+    def run_test(self, data):
+        vals = data["vals"]
+        avg = data["avg"]
+
+        counts = data.get("counts", None)
+        if counts is not None and not isinstance(counts, list) and isinstance(vals, list):
+            counts = [counts] * len(vals)
+
+        avg_meter = CumulativeAverage()
+        for i in range(len(vals)):
+            if counts is not None:
+                avg_meter.append(vals[i], counts[i])
+            else:
+                avg_meter.append(vals[i])
+
+        np.testing.assert_equal(avg_meter.aggregate(), avg)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_cumulative_average_dist.py

@@ -0,0 +1,48 @@
+# 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
+import torch.distributed as dist
+
+from monai.metrics import CumulativeAverage
+from tests.test_utils import DistCall, DistTestCase, SkipIfBeforePyTorchVersion
+
+
+@SkipIfBeforePyTorchVersion((1, 8))
+class DistributedCumulativeAverage(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_value(self):
+        rank = dist.get_rank()
+        nprocs = dist.get_world_size()
+        is_cuda = dist.get_backend() == dist.Backend.NCCL
+        if is_cuda:
+            torch.cuda.set_device(rank)
+
+        device = torch.device(rank) if is_cuda else torch.device("cpu")
+
+        avg_meter = CumulativeAverage()  # each process rank has it's own AverageMeter
+        n_iter = 10
+        for i in range(n_iter):
+            val = torch.as_tensor(rank + i, device=device)
+            avg_meter.append(val=val)
+
+        avg_val = avg_meter.aggregate()  # average across all processes
+        expected_val = sum(sum(list(range(rank_i, rank_i + n_iter))) for rank_i in range(nprocs)) / (n_iter * nprocs)
+        np.testing.assert_equal(avg_val, expected_val)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/metrics/test_hausdorff_distance.py

@@ -0,0 +1,209 @@
+# 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 itertools import product
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.metrics import HausdorffDistanceMetric
+
+_devices = ["cpu"]
+if torch.cuda.is_available():
+    _devices.append("cuda")
+
+
+def create_spherical_seg_3d(
+    radius: float = 20.0,
+    centre: tuple[int, int, int] = (49, 49, 49),
+    im_shape: tuple[int, int, int] = (99, 99, 99),
+    im_spacing: tuple[float, float, float] = (1.0, 1.0, 1.0),
+) -> np.ndarray:
+    """
+    Return a 3D image with a sphere inside. Voxel values will be
+    1 inside the sphere, and 0 elsewhere.
+
+    Args:
+        radius: radius of sphere (in terms of number of voxels, can be partial)
+        centre: location of sphere centre.
+        im_shape: shape of image to create.
+        im_spacing: spacing of image to create.
+
+    See also:
+        :py:meth:`~create_test_image_3d`
+    """
+    # Create image
+    image = np.zeros(im_shape, dtype=np.int32)
+    spy, spx, spz = np.ogrid[: im_shape[0], : im_shape[1], : im_shape[2]]
+    spy = spy.astype(float) * im_spacing[0]
+    spx = spx.astype(float) * im_spacing[1]
+    spz = spz.astype(float) * im_spacing[2]
+
+    spy -= centre[0]
+    spx -= centre[1]
+    spz -= centre[2]
+
+    circle = (spx * spx + spy * spy + spz * spz) <= radius * radius
+
+    image[circle] = 1
+    image[~circle] = 0
+    return image
+
+
+test_spacing = (0.85, 1.2, 0.9)
+TEST_CASES = [
+    [[create_spherical_seg_3d(), create_spherical_seg_3d(), None, 1], [0, 0, 0, 0, 0, 0]],
+    [
+        [
+            create_spherical_seg_3d(radius=20, centre=(20, 20, 20)),
+            create_spherical_seg_3d(radius=20, centre=(19, 19, 19)),
+            None,
+        ],
+        [1.7320508075688772, 1.7320508075688772, 1, 1, 3, 3],
+    ],
+    [
+        [
+            create_spherical_seg_3d(radius=33, centre=(19, 33, 22)),
+            create_spherical_seg_3d(radius=33, centre=(20, 33, 22)),
+            None,
+        ],
+        [1, 1, 1, 1, 1, 1],
+    ],
+    [
+        [
+            create_spherical_seg_3d(radius=20, centre=(20, 33, 22)),
+            create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),
+            None,
+        ],
+        [20.09975124224178, 20.223748416156685, 15, 20, 24, 35],
+    ],
+    [
+        [
+            # pred does not have foreground (but gt has), the metric should be inf
+            np.zeros([99, 99, 99]),
+            create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),
+            None,
+        ],
+        [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf],
+    ],
+    [
+        [
+            # gt does not have foreground (but pred has), the metric should be inf
+            create_spherical_seg_3d(),
+            np.zeros([99, 99, 99]),
+            None,
+        ],
+        [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf],
+    ],
+    [
+        [
+            create_spherical_seg_3d(radius=20, centre=(20, 33, 22)),
+            create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),
+            None,
+            95,
+        ],
+        [19.924858845171276, 20.09975124224178, 14, 18, 22, 33],
+    ],
+    [
+        [
+            create_spherical_seg_3d(radius=20, centre=(20, 20, 20), im_spacing=test_spacing),
+            create_spherical_seg_3d(radius=20, centre=(19, 19, 19), im_spacing=test_spacing),
+            test_spacing,
+        ],
+        [2.0808651447296143, 2.2671568, 2, 2, 3, 4],
+    ],
+    [
+        [
+            create_spherical_seg_3d(radius=15, centre=(20, 33, 22), im_spacing=test_spacing),
+            create_spherical_seg_3d(radius=30, centre=(20, 33, 22), im_spacing=test_spacing),
+            test_spacing,
+        ],
+        [15.439640998840332, 15.62594, 11, 17, 20, 28],
+    ],
+]
+
+TEST_CASES_NANS = [
+    [
+        [
+            # both pred and gt do not have foreground, spacing is None, metric and not_nans should be 0
+            np.zeros([99, 99, 99]),
+            np.zeros([99, 99, 99]),
+            None,
+        ]
+    ],
+    [
+        [
+            # both pred and gt do not have foreground, metric and not_nans should be 0
+            np.zeros([99, 99, 99]),
+            np.zeros([99, 99, 99]),
+            test_spacing,
+        ]
+    ],
+]
+
+TEST_CASES_EXPANDED = []
+for test_case in TEST_CASES:
+    test_output: list[float | int]
+    test_input, test_output = test_case  # type: ignore
+    for _device in _devices:
+        for i, (metric, directed) in enumerate(product(["euclidean", "chessboard", "taxicab"], [True, False])):
+            TEST_CASES_EXPANDED.append((_device, metric, directed, test_input, test_output[i]))
+
+
+def _describe_test_case(test_func, test_number, params):
+    _device, metric, directed, test_input, test_output = params.args
+    return f"device: {_device} metric: {metric} directed:{directed} expected: {test_output}"
+
+
+class TestHausdorffDistance(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_EXPANDED, doc_func=_describe_test_case)
+    def test_value(self, device, metric, directed, input_data, expected_value):
+        percentile = None
+        if len(input_data) == 4:
+            [seg_1, seg_2, spacing, percentile] = input_data
+        else:
+            [seg_1, seg_2, spacing] = input_data
+
+        seg_1 = torch.tensor(seg_1, device=device)
+        seg_2 = torch.tensor(seg_2, device=device)
+        hd_metric = HausdorffDistanceMetric(
+            include_background=False, distance_metric=metric, percentile=percentile, directed=directed
+        )
+        # shape of seg_1, seg_2 are: HWD, converts to BNHWD
+        batch, n_class = 2, 3
+        batch_seg_1 = seg_1.unsqueeze(0).unsqueeze(0).repeat([batch, n_class, 1, 1, 1])
+        batch_seg_2 = seg_2.unsqueeze(0).unsqueeze(0).repeat([batch, n_class, 1, 1, 1])
+        hd_metric(batch_seg_1, batch_seg_2, spacing=spacing)
+        result: torch.Tensor = hd_metric.aggregate(reduction="mean")  # type: ignore
+        np.testing.assert_allclose(expected_value, result.cpu(), rtol=1e-6)
+        np.testing.assert_equal(result.device, seg_1.device)
+
+    @parameterized.expand(TEST_CASES_NANS)
+    def test_nans(self, input_data):
+        [seg_1, seg_2, spacing] = input_data
+        seg_1 = torch.tensor(seg_1)
+        seg_2 = torch.tensor(seg_2)
+        hd_metric = HausdorffDistanceMetric(include_background=False, get_not_nans=True)
+        batch_seg_1 = seg_1.unsqueeze(0).unsqueeze(0)
+        batch_seg_2 = seg_2.unsqueeze(0).unsqueeze(0)
+        hd_metric(batch_seg_1, batch_seg_2, spacing=spacing)
+        result, not_nans = hd_metric.aggregate()
+        np.testing.assert_allclose(0, result, rtol=1e-7)
+        np.testing.assert_allclose(0, not_nans, rtol=1e-7)
+
+
+if __name__ == "__main__":
+    unittest.main()