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

tests/transforms/test_morphological_ops.py

@@ -0,0 +1,101 @@
+# 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.utils_morphological_ops import dilate, erode, get_morphological_filter_result_t
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS_SHAPE = []
+for p in TEST_NDARRAYS:
+    mask = torch.zeros(1, 1, 5, 5, 5)
+    filter_size = 3
+    TESTS_SHAPE.append([{"mask": p(mask), "filter_size": filter_size}, [1, 1, 5, 5, 5]])
+    mask = torch.zeros(3, 2, 5, 5, 5)
+    filter_size = 5
+    TESTS_SHAPE.append([{"mask": p(mask), "filter_size": filter_size}, [3, 2, 5, 5, 5]])
+    mask = torch.zeros(1, 1, 1, 1, 1)
+    filter_size = 5
+    TESTS_SHAPE.append([{"mask": p(mask), "filter_size": filter_size}, [1, 1, 1, 1, 1]])
+    mask = torch.zeros(1, 1, 1, 1)
+    filter_size = 5
+    TESTS_SHAPE.append([{"mask": p(mask), "filter_size": filter_size}, [1, 1, 1, 1]])
+
+TESTS_VALUE_T = []
+filter_size = 3
+mask = torch.ones(3, 2, 3, 3, 3)
+TESTS_VALUE_T.append([{"mask": mask, "filter_size": filter_size, "pad_value": 1.0}, torch.ones(3, 2, 3, 3, 3)])
+mask = torch.zeros(3, 2, 3, 3, 3)
+TESTS_VALUE_T.append([{"mask": mask, "filter_size": filter_size, "pad_value": 0.0}, torch.zeros(3, 2, 3, 3, 3)])
+mask = torch.ones(3, 2, 3, 3)
+TESTS_VALUE_T.append([{"mask": mask, "filter_size": filter_size, "pad_value": 1.0}, torch.ones(3, 2, 3, 3)])
+mask = torch.zeros(3, 2, 3, 3)
+TESTS_VALUE_T.append([{"mask": mask, "filter_size": filter_size, "pad_value": 0.0}, torch.zeros(3, 2, 3, 3)])
+
+TESTS_VALUE = []
+for p in TEST_NDARRAYS:
+    mask = torch.zeros(3, 2, 5, 5, 5)
+    filter_size = 3
+    TESTS_VALUE.append(
+        [{"mask": p(mask), "filter_size": filter_size}, p(torch.zeros(3, 2, 5, 5, 5)), p(torch.zeros(3, 2, 5, 5, 5))]
+    )
+    mask = torch.ones(1, 1, 3, 3, 3)
+    filter_size = 3
+    TESTS_VALUE.append(
+        [{"mask": p(mask), "filter_size": filter_size}, p(torch.ones(1, 1, 3, 3, 3)), p(torch.ones(1, 1, 3, 3, 3))]
+    )
+    mask = torch.ones(1, 2, 3, 3, 3)
+    filter_size = 3
+    TESTS_VALUE.append(
+        [{"mask": p(mask), "filter_size": filter_size}, p(torch.ones(1, 2, 3, 3, 3)), p(torch.ones(1, 2, 3, 3, 3))]
+    )
+    mask = torch.zeros(3, 2, 3, 3, 3)
+    mask[:, :, 1, 1, 1] = 1.0
+    filter_size = 3
+    TESTS_VALUE.append(
+        [{"mask": p(mask), "filter_size": filter_size}, p(torch.zeros(3, 2, 3, 3, 3)), p(torch.ones(3, 2, 3, 3, 3))]
+    )
+    mask = torch.zeros(3, 2, 3, 3)
+    mask[:, :, 1, 1] = 1.0
+    filter_size = 3
+    TESTS_VALUE.append(
+        [{"mask": p(mask), "filter_size": filter_size}, p(torch.zeros(3, 2, 3, 3)), p(torch.ones(3, 2, 3, 3))]
+    )
+
+
+class TestMorph(unittest.TestCase):
+    @parameterized.expand(TESTS_SHAPE)
+    def test_shape(self, input_data, expected_result):
+        result1 = erode(input_data["mask"], input_data["filter_size"])
+        assert_allclose(result1.shape, expected_result, type_test=False, device_test=False, atol=0.0)
+
+    @parameterized.expand(TESTS_VALUE_T)
+    def test_value_t(self, input_data, expected_result):
+        result1 = get_morphological_filter_result_t(
+            input_data["mask"], input_data["filter_size"], input_data["pad_value"]
+        )
+        assert_allclose(result1, expected_result, type_test=False, device_test=False, atol=0.0)
+
+    @parameterized.expand(TESTS_VALUE)
+    def test_value(self, input_data, expected_erode_result, expected_dilate_result):
+        result1 = erode(input_data["mask"], input_data["filter_size"])
+        assert_allclose(result1, expected_erode_result, type_test=True, device_test=True, atol=0.0)
+        result2 = dilate(input_data["mask"], input_data["filter_size"])
+        assert_allclose(result2, expected_dilate_result, type_test=True, device_test=True, atol=0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_nifti_endianness.py

@@ -0,0 +1,107 @@
+# 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
+from pathlib import Path
+from typing import TYPE_CHECKING
+from unittest.case import skipUnless
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data import DataLoader, Dataset, create_test_image_2d
+from monai.data.image_reader import PILReader
+from monai.transforms import LoadImage, LoadImaged
+from monai.transforms.io.array import switch_endianness
+from monai.utils.enums import PostFix
+from monai.utils.module import optional_import
+
+if TYPE_CHECKING:
+    import nibabel as nib
+    from PIL import Image as PILImage
+
+    has_nib = True
+    has_pil = True
+else:
+    nib, has_nib = optional_import("nibabel")
+    PILImage, has_pil = optional_import("PIL.Image")
+
+TESTS: list[tuple] = []
+for endianness in ["<", ">"]:
+    for use_array in [True, False]:
+        for image_only in [True, False]:
+            TESTS.append((endianness, use_array, image_only))
+
+
+class TestNiftiEndianness(unittest.TestCase):
+
+    def setUp(self):
+        self.im, _ = create_test_image_2d(100, 100)
+        self.fname = tempfile.NamedTemporaryFile(suffix=".nii.gz").name
+
+    @parameterized.expand(TESTS)
+    @skipUnless(has_nib, "Requires NiBabel")
+    def test_endianness(self, endianness, use_array, image_only):
+        hdr = nib.Nifti1Header(endianness=endianness)
+        nii = nib.Nifti1Image(self.im, np.eye(4), header=hdr)
+        nib.save(nii, self.fname)
+
+        data = [self.fname] if use_array else [{"image": self.fname}]
+        tr = LoadImage(image_only=image_only) if use_array else LoadImaged("image", image_only=image_only)
+        check_ds = Dataset(data, tr)
+        check_loader = DataLoader(check_ds, batch_size=1)
+        ret = next(iter(check_loader))
+        if isinstance(ret, dict) and PostFix.meta("image") in ret:
+            np.testing.assert_allclose(ret[PostFix.meta("image")]["spatial_shape"], [[100, 100]])
+
+    def test_switch(self):  # verify data types
+        for data in (np.zeros((2, 1)), ("test",), [24, 42], {"foo": "bar"}, True, 42):
+            output = switch_endianness(data, "<")
+            self.assertEqual(type(data), type(output))
+
+        before = np.array((20, 20), dtype=">i2")
+        expected_float = before.astype(float)
+        after = switch_endianness(before)
+        np.testing.assert_allclose(after.astype(float), expected_float)
+        self.assertEqual(after.dtype.byteorder, "<")
+
+        before = np.array((20, 20), dtype="<i2")
+        expected_float = before.astype(float)
+        after = switch_endianness(before)
+        np.testing.assert_allclose(after.astype(float), expected_float)
+
+        before = np.array(["1.12", "-9.2", "42"], dtype=np.bytes_)
+        after = switch_endianness(before)
+        np.testing.assert_array_equal(before, after)
+
+        with self.assertRaises(NotImplementedError):
+            switch_endianness(np.zeros((2, 1)), "=")
+
+        with self.assertRaises(RuntimeError):
+            switch_endianness(Path("test"), "<")
+
+    @skipUnless(has_pil, "Requires PIL")
+    def test_pil(self):
+        tempdir = tempfile.mkdtemp()
+        test_image = np.random.randint(0, 256, size=[128, 256])
+        filename = os.path.join(tempdir, "test_image.png")
+        PILImage.fromarray(test_image.astype("uint8")).save(filename)
+
+        loader = LoadImage(PILReader(converter=lambda image: image.convert("LA")))
+        _ = loader(filename)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_normalize_intensity.py

@@ -0,0 +1,143 @@
+# 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 NormalizeIntensity
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, {"nonzero": True}, np.array([0.0, 3.0, 0.0, 4.0]), np.array([0.0, -1.0, 0.0, 1.0])])
+    for q in TEST_NDARRAYS:
+        for u in TEST_NDARRAYS:
+            TESTS.append(
+                [
+                    p,
+                    {
+                        "subtrahend": q(np.array([3.5, 3.5, 3.5, 3.5])),
+                        "divisor": u(np.array([0.5, 0.5, 0.5, 0.5])),
+                        "nonzero": True,
+                    },
+                    p(np.array([0.0, 3.0, 0.0, 4.0])),
+                    p(np.array([0.0, -1.0, 0.0, 1.0])),
+                ]
+            )
+    TESTS.append([p, {"nonzero": True}, p(np.array([0.0, 0.0, 0.0, 0.0])), p(np.array([0.0, 0.0, 0.0, 0.0]))])
+    TESTS.append([p, {"nonzero": False}, p(np.array([0.0, 0.0, 0.0, 0.0])), p(np.array([0.0, 0.0, 0.0, 0.0]))])
+    TESTS.append([p, {"nonzero": False}, p(np.array([1, 1, 1, 1])), p(np.array([0.0, 0.0, 0.0, 0.0]))])
+    TESTS.append(
+        [
+            p,
+            {"nonzero": False, "channel_wise": True, "subtrahend": [1, 2, 3], "dtype": np.float32},
+            p(np.ones((3, 2, 2))),
+            p(np.array([[[0.0, 0.0], [0.0, 0.0]], [[-1.0, -1.0], [-1.0, -1.0]], [[-2.0, -2.0], [-2.0, -2.0]]])),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"nonzero": True, "channel_wise": True, "subtrahend": [1, 2, 3], "divisor": [0, 0, 2], "dtype": "float32"},
+            p(np.ones((3, 2, 2))),
+            p(np.array([[[0.0, 0.0], [0.0, 0.0]], [[-1.0, -1.0], [-1.0, -1.0]], [[-1.0, -1.0], [-1.0, -1.0]]])),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"nonzero": True, "channel_wise": False, "subtrahend": 2, "divisor": 0, "dtype": torch.float32},
+            p(np.ones((3, 2, 2))),
+            p(np.ones((3, 2, 2)) * -1.0),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"nonzero": True, "channel_wise": False, "subtrahend": np.ones((3, 2, 2)) * 0.5, "divisor": 0},
+            p(np.ones((3, 2, 2))),
+            p(np.ones((3, 2, 2)) * 0.5),
+        ]
+    )
+    TESTS.append(
+        [
+            p,
+            {"nonzero": True, "channel_wise": True, "subtrahend": np.ones((3, 2, 2)) * 0.5, "divisor": [0, 1, 0]},
+            p(np.ones((3, 2, 2))),
+            p(np.ones((3, 2, 2)) * 0.5),
+        ]
+    )
+
+
+class TestNormalizeIntensity(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_default(self, im_type):
+        im = im_type(self.imt.copy())
+        normalizer = NormalizeIntensity()
+        normalized = normalizer(im)
+        self.assertTrue(normalized.dtype in (np.float32, torch.float32))
+        expected = (self.imt - np.mean(self.imt)) / np.std(self.imt)
+        assert_allclose(normalized, expected, type_test="tensor", rtol=1e-3)
+
+    @parameterized.expand(TESTS)
+    def test_nonzero(self, in_type, input_param, input_data, expected_data):
+        normalizer = NormalizeIntensity(**input_param)
+        im = in_type(input_data)
+        normalized = normalizer(im)
+        assert_allclose(normalized, in_type(expected_data), type_test="tensor")
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, im_type):
+        normalizer = NormalizeIntensity(nonzero=True, channel_wise=True)
+        input_data = im_type(np.array([[0.0, 3.0, 0.0, 4.0], [0.0, 4.0, 0.0, 5.0]]))
+        expected = np.array([[0.0, -1.0, 0.0, 1.0], [0.0, -1.0, 0.0, 1.0]])
+        normalized = normalizer(input_data)
+        assert_allclose(normalized, im_type(expected), type_test="tensor")
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise_int(self, im_type):
+        normalizer = NormalizeIntensity(nonzero=True, channel_wise=True)
+        input_data = im_type(torch.arange(1, 25).reshape(2, 3, 4))
+        expected = np.array(
+            [
+                [
+                    [-1.593255, -1.3035723, -1.0138896, -0.7242068],
+                    [-0.4345241, -0.1448414, 0.1448414, 0.4345241],
+                    [0.7242068, 1.0138896, 1.3035723, 1.593255],
+                ],
+                [
+                    [-1.593255, -1.3035723, -1.0138896, -0.7242068],
+                    [-0.4345241, -0.1448414, 0.1448414, 0.4345241],
+                    [0.7242068, 1.0138896, 1.3035723, 1.593255],
+                ],
+            ]
+        )
+        normalized = normalizer(input_data)
+        assert_allclose(normalized, im_type(expected), type_test="tensor", rtol=1e-7, atol=1e-7)  # tolerance
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_value_errors(self, im_type):
+        input_data = im_type(np.array([[0.0, 3.0, 0.0, 4.0], [0.0, 4.0, 0.0, 5.0]]))
+        normalizer = NormalizeIntensity(nonzero=True, channel_wise=True, subtrahend=[1])
+        with self.assertRaises(ValueError):
+            normalizer(input_data)
+        normalizer = NormalizeIntensity(nonzero=True, channel_wise=True, subtrahend=[1, 2], divisor=[1])
+        with self.assertRaises(ValueError):
+            normalizer(input_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_normalize_intensityd.py

@@ -0,0 +1,81 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import NormalizeIntensityd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for q in TEST_NDARRAYS:
+        TESTS.append(
+            [
+                {"keys": ["img"], "nonzero": True},
+                {"img": p(np.array([0.0, 3.0, 0.0, 4.0]))},
+                p(np.array([0.0, -1.0, 0.0, 1.0])),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "keys": ["img"],
+                    "subtrahend": q(np.array([3.5, 3.5, 3.5, 3.5])),
+                    "divisor": q(np.array([0.5, 0.5, 0.5, 0.5])),
+                    "nonzero": True,
+                },
+                {"img": p(np.array([0.0, 3.0, 0.0, 4.0]))},
+                p(np.array([0.0, -1.0, 0.0, 1.0])),
+            ]
+        )
+        TESTS.append(
+            [
+                {"keys": ["img"], "nonzero": True},
+                {"img": p(np.array([0.0, 0.0, 0.0, 0.0]))},
+                p(np.array([0.0, 0.0, 0.0, 0.0])),
+            ]
+        )
+
+
+class TestNormalizeIntensityd(NumpyImageTestCase2D):
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_image_normalize_intensityd(self, im_type):
+        key = "img"
+        im = im_type(self.imt)
+        normalizer = NormalizeIntensityd(keys=[key])
+        normalized = normalizer({key: im})[key]
+        expected = (self.imt - np.mean(self.imt)) / np.std(self.imt)
+        assert_allclose(normalized, im_type(expected), rtol=1e-3, type_test="tensor")
+
+    @parameterized.expand(TESTS)
+    def test_nonzero(self, input_param, input_data, expected_data):
+        key = "img"
+        normalizer = NormalizeIntensityd(**input_param)
+        normalized = normalizer(input_data)[key]
+        assert_allclose(normalized, expected_data, type_test="tensor")
+
+    @parameterized.expand([[p] for p in TEST_NDARRAYS])
+    def test_channel_wise(self, im_type):
+        key = "img"
+        normalizer = NormalizeIntensityd(keys=key, nonzero=True, channel_wise=True)
+        input_data = {key: im_type(np.array([[0.0, 3.0, 0.0, 4.0], [0.0, 4.0, 0.0, 5.0]]))}
+        normalized = normalizer(input_data)[key]
+        expected = np.array([[0.0, -1.0, 0.0, 1.0], [0.0, -1.0, 0.0, 1.0]])
+        assert_allclose(normalized, im_type(expected), type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()