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

tests/transforms/test_inverse_collation.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 sys
+import unittest
+from typing import TYPE_CHECKING
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import (
+    CacheDataset,
+    DataLoader,
+    MetaTensor,
+    create_test_image_2d,
+    create_test_image_3d,
+    decollate_batch,
+    pad_list_data_collate,
+)
+from monai.transforms import (
+    Compose,
+    EnsureChannelFirstd,
+    Flipd,
+    LoadImaged,
+    RandAffined,
+    RandAxisFlipd,
+    RandFlipd,
+    RandRotate90d,
+    RandRotated,
+    RandZoomd,
+    ResizeWithPadOrCropd,
+    Rotated,
+)
+from monai.utils import optional_import, set_determinism
+from tests.test_utils import make_nifti_image
+
+if TYPE_CHECKING:
+    has_nib = True
+else:
+    _, has_nib = optional_import("nibabel")
+
+KEYS = ["image", "label"]
+
+TESTS_3D = [
+    (t.__class__.__name__ + (" pad_list_data_collate" if collate_fn else " default_collate"), t, collate_fn, 3)
+    for collate_fn in [None, pad_list_data_collate]
+    for t in [
+        Flipd(KEYS, spatial_axis=1),
+        RandFlipd(keys=KEYS, prob=0.5, spatial_axis=[1, 2]),
+        RandAxisFlipd(keys=KEYS, prob=0.5),
+        Compose([RandRotate90d(keys=KEYS, spatial_axes=(1, 2))]),
+        RandZoomd(keys=KEYS, prob=0.5, min_zoom=0.5, max_zoom=1.1, keep_size=True),
+        Rotated(keys=KEYS, angle=np.pi, dtype=np.float64),
+        RandRotated(keys=KEYS, prob=0.5, range_x=np.pi, dtype=np.float64),
+        RandAffined(
+            keys=KEYS, prob=0.5, rotate_range=np.pi, device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        ),
+    ]
+]
+
+TESTS_2D = [
+    (t.__class__.__name__ + (" pad_list_data_collate" if collate_fn else " default_collate"), t, collate_fn, 2)
+    for collate_fn in [None, pad_list_data_collate]
+    for t in [
+        Flipd(KEYS, spatial_axis=1),
+        RandFlipd(keys=KEYS, prob=0.5, spatial_axis=[1]),
+        RandAxisFlipd(keys=KEYS, prob=0.5),
+        Compose([RandRotate90d(keys=KEYS, prob=0.5, spatial_axes=(0, 1))]),
+        RandZoomd(keys=KEYS, prob=0.5, min_zoom=0.5, max_zoom=1.1, keep_size=True),
+        Rotated(keys=KEYS, angle=np.pi / 2, dtype=np.float64),
+        RandRotated(keys=KEYS, prob=0.5, range_x=np.pi, dtype=np.float64),
+        RandAffined(
+            keys=KEYS, prob=0.5, rotate_range=np.pi, device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        ),
+    ]
+]
+
+
+class TestInverseCollation(unittest.TestCase):
+    """Test collation for of random transformations with prob == 0 and 1."""
+
+    def setUp(self):
+        if not has_nib:
+            self.skipTest("nibabel required for test_inverse")
+
+        set_determinism(seed=0)
+
+        b_size = 11
+        im_fname, seg_fname = (make_nifti_image(i) for i in create_test_image_3d(101, 100, 107))
+        load_ims = Compose([LoadImaged(KEYS), EnsureChannelFirstd(KEYS, channel_dim="no_channel")])
+        self.data_3d = [load_ims({"image": im_fname, "label": seg_fname}) for _ in range(b_size)]
+
+        b_size = 8
+        im_fname, seg_fname = (make_nifti_image(i) for i in create_test_image_2d(62, 37, rad_max=10))
+        load_ims = Compose([LoadImaged(KEYS), EnsureChannelFirstd(KEYS, channel_dim="no_channel")])
+        self.data_2d = [load_ims({"image": im_fname, "label": seg_fname}) for _ in range(b_size)]
+
+        self.batch_size = 7
+
+    def tearDown(self):
+        set_determinism(seed=None)
+
+    @parameterized.expand(TESTS_2D + TESTS_3D)
+    def test_collation(self, _, transform, collate_fn, ndim):
+        """transform, collate_fn, ndim"""
+        data = self.data_3d if ndim == 3 else self.data_2d
+        if collate_fn:
+            modified_transform = transform
+        else:
+            modified_transform = Compose([transform, ResizeWithPadOrCropd(KEYS, 100)])
+
+        # num workers = 0 for mac or gpu transforms
+        num_workers = 0 if sys.platform != "linux" or torch.cuda.is_available() else 2
+
+        dataset = CacheDataset(data, transform=modified_transform, progress=False)
+        loader = DataLoader(dataset, num_workers, batch_size=self.batch_size, collate_fn=collate_fn)
+
+        for item in loader:
+            if isinstance(item, dict):
+                np.testing.assert_array_equal(item["image"].shape, item["label"].shape)
+                continue
+            d = decollate_batch(item)
+            self.assertTrue(len(d) <= self.batch_size)
+            for b in d:
+                self.assertIsInstance(b["image"], MetaTensor)
+                np.testing.assert_array_equal(
+                    b["image"].applied_operations[-1]["orig_size"], b["label"].applied_operations[-1]["orig_size"]
+                )
+                np.testing.assert_array_equal(
+                    b["image"].applied_operations[-1].get("_do_transform"),
+                    b["label"].applied_operations[-1].get("_do_transform"),
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_invert.py

@@ -0,0 +1,105 @@
+# 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 sys
+import unittest
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from monai.data import DataLoader, Dataset, MetaTensor, create_test_image_3d, decollate_batch
+from monai.transforms import (
+    CastToType,
+    Compose,
+    EnsureChannelFirst,
+    Invert,
+    Lambda,
+    LoadImage,
+    Orientation,
+    RandAffine,
+    RandAxisFlip,
+    RandFlip,
+    RandRotate,
+    RandRotate90,
+    RandZoom,
+    ResizeWithPadOrCrop,
+    Spacing,
+)
+from monai.utils import set_determinism
+from tests.test_utils import assert_allclose, make_nifti_image
+
+
+class TestInvert(unittest.TestCase):
+    def test_invert(self):
+        set_determinism(seed=0)
+        im_fname = make_nifti_image(create_test_image_3d(101, 100, 107, noise_max=100)[1])  # label image, discrete
+        data = [im_fname for _ in range(12)]
+        transform = Compose(
+            [
+                LoadImage(image_only=True),
+                EnsureChannelFirst(),
+                Orientation("RPS"),
+                Spacing(pixdim=(1.2, 1.01, 0.9), mode=1, dtype=np.float32),
+                RandFlip(prob=0.5, spatial_axis=[1, 2]),
+                RandAxisFlip(prob=0.5),
+                RandRotate90(prob=0, spatial_axes=(1, 2)),
+                RandZoom(prob=0.5, min_zoom=0.5, max_zoom=1.1, keep_size=True),
+                RandRotate(prob=0.5, range_x=np.pi, mode="bilinear", align_corners=True, dtype=np.float64),
+                RandAffine(prob=0.5, rotate_range=np.pi, mode="nearest"),
+                ResizeWithPadOrCrop(100),
+                CastToType(dtype=torch.uint8),
+            ]
+        )
+
+        # num workers = 0 for mac or gpu transforms
+        num_workers = 0 if sys.platform != "linux" or torch.cuda.is_available() else 2
+        dataset = Dataset(data, transform=transform)
+        self.assertIsInstance(transform.inverse(dataset[0]), MetaTensor)
+        loader = DataLoader(dataset, num_workers=num_workers, batch_size=1)
+        inverter = Invert(transform=transform, nearest_interp=True, device="cpu", post_func=torch.as_tensor)
+
+        for d in loader:
+            d = decollate_batch(d)
+            for item in d:
+                orig = deepcopy(item)
+                i = inverter(item)
+                self.assertTupleEqual(orig.shape[1:], (100, 100, 100))
+                # check the nearest interpolation mode
+                assert_allclose(i.to(torch.uint8).to(torch.float), i.to(torch.float))
+                self.assertTupleEqual(i.shape[1:], (101, 100, 107))
+        # check labels match
+        reverted = i.detach().cpu().numpy().astype(np.int32)
+        original = LoadImage(image_only=True)(data[-1])
+        n_good = np.sum(np.isclose(reverted, original.numpy(), atol=1e-3))
+        reverted_name = i.meta["filename_or_obj"]
+        original_name = original.meta["filename_or_obj"]
+        self.assertEqual(reverted_name, original_name)
+        print("invert diff", reverted.size - n_good)
+        self.assertTrue((reverted.size - n_good) < 300000, f"diff. {reverted.size - n_good}")
+        set_determinism(seed=None)
+
+    def test_invert_warn_pending(self):
+        # this test shouldn't raise a warning or error any more as that issue was fixed
+        # by https://github.com/Project-MONAI/MONAI/pull/6257
+        set_determinism(seed=0)
+        im_fname = make_nifti_image(create_test_image_3d(101, 100, 107, noise_max=100)[1])  # label image, discrete
+        transform = Compose(
+            [LoadImage(image_only=True), EnsureChannelFirst(), Orientation("RPS"), Lambda(func=lambda x: x)], lazy=True
+        )
+        output = transform([im_fname for _ in range(2)])
+        transform.inverse(output)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_invertd.py

@@ -0,0 +1,142 @@
+# 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 sys
+import unittest
+
+import numpy as np
+import torch
+
+from monai.data import DataLoader, Dataset, create_test_image_3d, decollate_batch
+from monai.transforms import (
+    CastToTyped,
+    Compose,
+    CopyItemsd,
+    EnsureChannelFirstd,
+    Invertd,
+    LoadImaged,
+    Orientationd,
+    RandAffined,
+    RandAxisFlipd,
+    RandFlipd,
+    RandRotate90d,
+    RandRotated,
+    RandZoomd,
+    ResizeWithPadOrCropd,
+    ScaleIntensityd,
+    Spacingd,
+)
+from monai.utils import set_determinism
+from tests.test_utils import assert_allclose, make_nifti_image
+
+KEYS = ["image", "label"]
+
+
+class TestInvertd(unittest.TestCase):
+    def test_invert(self):
+        set_determinism(seed=0)
+        im_fname, seg_fname = (make_nifti_image(i) for i in create_test_image_3d(101, 100, 107, noise_max=100))
+        transform = Compose(
+            [
+                LoadImaged(KEYS, image_only=True),
+                EnsureChannelFirstd(KEYS),
+                Orientationd(KEYS, "RPS"),
+                Spacingd(KEYS, pixdim=(1.2, 1.01, 0.9), mode=["bilinear", "nearest"], dtype=np.float32),
+                ScaleIntensityd("image", minv=1, maxv=10),
+                RandFlipd(KEYS, prob=0.5, spatial_axis=[1, 2]),
+                RandAxisFlipd(KEYS, prob=0.5),
+                RandRotate90d(KEYS, prob=0, spatial_axes=(1, 2)),
+                RandZoomd(KEYS, prob=0.5, min_zoom=0.5, max_zoom=1.1, keep_size=True),
+                RandRotated(KEYS, prob=0.5, range_x=np.pi, mode="bilinear", align_corners=True, dtype=np.float64),
+                RandAffined(KEYS, prob=0.5, rotate_range=np.pi, mode=["nearest", 0]),
+                ResizeWithPadOrCropd(KEYS, 100),
+                CastToTyped(KEYS, dtype=[torch.uint8, np.uint8]),
+                CopyItemsd("label", times=2, names=["label_inverted", "label_inverted1"]),
+                CopyItemsd("image", times=2, names=["image_inverted", "image_inverted1"]),
+            ]
+        )
+        data = [{"image": im_fname, "label": seg_fname} for _ in range(12)]
+
+        # num workers = 0 for mac or gpu transforms
+        num_workers = 0 if sys.platform != "linux" or torch.cuda.is_available() else 2
+
+        dataset = Dataset(data, transform=transform)
+        transform.inverse(dataset[0])
+        loader = DataLoader(dataset, num_workers=num_workers, batch_size=1)
+        inverter = Invertd(
+            # `image` was not copied, invert the original value directly
+            keys=["image_inverted", "label_inverted"],
+            transform=transform,
+            orig_keys=["label", "label"],
+            nearest_interp=True,
+            device=None,
+            post_func=torch.as_tensor,
+        )
+
+        inverter_1 = Invertd(
+            # `image` was not copied, invert the original value directly
+            keys=["image_inverted1", "label_inverted1"],
+            transform=transform,
+            orig_keys=["image", "image"],
+            nearest_interp=[True, False],
+            device="cpu",
+        )
+
+        expected_keys = ["image", "image_inverted", "image_inverted1", "label", "label_inverted", "label_inverted1"]
+        # execute 1 epoch
+        for d in loader:
+            d = decollate_batch(d)
+            for item in d:
+                item = inverter(item)
+                item = inverter_1(item)
+
+                self.assertListEqual(sorted(item), expected_keys)
+                self.assertTupleEqual(item["image"].shape[1:], (100, 100, 100))
+                self.assertTupleEqual(item["label"].shape[1:], (100, 100, 100))
+                # check the nearest interpolation mode
+                i = item["image_inverted"]
+                assert_allclose(i.to(torch.uint8).to(torch.float), i.to(torch.float))
+                self.assertTupleEqual(i.shape[1:], (101, 100, 107))
+                i = item["label_inverted"]
+                assert_allclose(i.to(torch.uint8).to(torch.float), i.to(torch.float))
+                self.assertTupleEqual(i.shape[1:], (101, 100, 107))
+
+                # check the case that different items use different interpolation mode to invert transforms
+                j = item["image_inverted1"]
+                # if the interpolation mode is nearest, accumulated diff should be smaller than 1
+                self.assertLess(torch.sum(j.to(torch.float) - j.to(torch.uint8).to(torch.float)).item(), 1.0)
+                self.assertTupleEqual(j.shape, (1, 101, 100, 107))
+
+                k = item["label_inverted1"]
+                # if the interpolation mode is not nearest, accumulated diff should be greater than 10000
+                self.assertGreater(torch.sum(k.to(torch.float) - k.to(torch.uint8).to(torch.float)).item(), 10000.0)
+                self.assertTupleEqual(k.shape, (1, 101, 100, 107))
+
+        # check labels match
+        reverted = item["label_inverted"].detach().cpu().numpy().astype(np.int32)
+        original = LoadImaged(KEYS, image_only=True)(data[-1])["label"]
+        n_good = np.sum(np.isclose(reverted, original, atol=1e-3))
+        reverted_name = item["label_inverted"].meta["filename_or_obj"]
+        original_name = data[-1]["label"]
+        self.assertEqual(reverted_name, original_name)
+        print("invert diff", reverted.size - n_good)
+        # 25300: 2 workers (cpu, non-macos)
+        # 1812: 0 workers (gpu or macos)
+        # 1821: windows torch 1.10.0
+        self.assertLess((reverted.size - n_good), 40000, f"diff.  {reverted.size - n_good}")
+
+        set_determinism(seed=None)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_k_space_spike_noise.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
+from copy import deepcopy
+
+import numpy as np
+import torch
+from numpy.fft import fftn, fftshift
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import KSpaceSpikeNoise
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS = []
+for shape in ((128, 64), (64, 48, 80)):
+    for p in TEST_NDARRAYS:
+        for intensity in [10, None]:
+            TESTS.append((shape, p, intensity))
+
+
+class TestKSpaceSpikeNoise(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, im_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        im, _ = create_test_image(*im_shape, rad_max=20, noise_max=0.0, num_seg_classes=5)
+        return im_type(im[None])
+
+    @parameterized.expand(TESTS)
+    def test_same_result(self, im_shape, im_type, k_intensity):
+        im = self.get_data(im_shape, im_type)
+        loc = [0, int(im.shape[1] / 2), 0] if len(im_shape) == 2 else [0, int(im.shape[1] / 2), 0, 0]
+        t = KSpaceSpikeNoise(loc, k_intensity)
+
+        out1 = t(deepcopy(im))
+        out2 = t(deepcopy(im))
+
+        if isinstance(out1, torch.Tensor):
+            out1 = out1.cpu()
+            out2 = out2.cpu()
+
+        np.testing.assert_allclose(out1, out2)
+
+    @parameterized.expand(TESTS)
+    def test_highlighted_kspace_pixel(self, im_shape, as_tensor_input, k_intensity):
+        im = self.get_data(im_shape, as_tensor_input)
+        loc = [0, int(im.shape[1] / 2), 0] if len(im_shape) == 2 else [0, int(im.shape[1] / 2), 0, 0]
+        t = KSpaceSpikeNoise(loc, k_intensity)
+        out = t(im)
+
+        if isinstance(out, torch.Tensor):
+            out = out.cpu()
+
+        if k_intensity is not None:
+            n_dims = len(im_shape)
+            out_k = fftshift(fftn(out, axes=tuple(range(-n_dims, 0))), axes=tuple(range(-n_dims, 0)))
+            log_mag = np.log(np.absolute(out_k))
+            np.testing.assert_allclose(k_intensity, log_mag[tuple(loc)], 1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_k_space_spike_noised.py

@@ -0,0 +1,98 @@
+# 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 numpy.fft import fftn, fftshift
+from parameterized import parameterized
+
+from monai.data.synthetic import create_test_image_2d, create_test_image_3d
+from monai.transforms import KSpaceSpikeNoised
+from monai.utils.misc import set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for shape in ((128, 64), (64, 48, 80)):
+    for p in TEST_NDARRAYS:
+        TESTS.append((shape, p))
+
+KEYS = ["image", "label"]
+
+
+class TestKSpaceSpikeNoised(unittest.TestCase):
+    def setUp(self):
+        set_determinism(0)
+        super().setUp()
+
+    def tearDown(self):
+        set_determinism(None)
+
+    @staticmethod
+    def get_data(im_shape, im_type):
+        create_test_image = create_test_image_2d if len(im_shape) == 2 else create_test_image_3d
+        ims = create_test_image(*im_shape, rad_max=20, noise_max=0.0, num_seg_classes=5)
+        ims = [im_type(im[None]) for im in ims]
+        return dict(zip(KEYS, ims))
+
+    @parameterized.expand(TESTS)
+    def test_same_result(self, im_shape, im_type):
+        data = self.get_data(im_shape, im_type)
+        loc = [0] + [int(im_shape[i] / 2) for i in range(len(im_shape))]
+        k_intensity = 10
+
+        t = KSpaceSpikeNoised(KEYS, loc, k_intensity)
+        out1 = t(deepcopy(data))
+        out2 = t(deepcopy(data))
+
+        for k in KEYS:
+            if isinstance(out1[k], torch.Tensor):
+                out1[k] = out1[k].cpu()
+                out2[k] = out2[k].cpu()
+            np.testing.assert_allclose(out1[k], out2[k])
+
+    @parameterized.expand(TESTS)
+    def test_highlighted_kspace_pixel(self, im_shape, im_type):
+        data = self.get_data(im_shape, im_type)
+        loc = [0] + [int(im_shape[i] / 2) for i in range(len(im_shape))]
+        k_intensity = 10
+
+        t = KSpaceSpikeNoised(KEYS, loc, k_intensity)
+        out = t(data)
+
+        for k in KEYS:
+            if isinstance(out[k], torch.Tensor):
+                out[k] = out[k].cpu()
+
+            n_dims = len(im_shape)
+            out_k = fftshift(fftn(out[k], axes=tuple(range(-n_dims, 0))), axes=tuple(range(-n_dims, 0)))
+            log_mag = np.log(np.absolute(out_k))
+            np.testing.assert_allclose(k_intensity, log_mag[tuple(loc)], 1e-1)
+
+    @parameterized.expand(TESTS)
+    def test_dict_matches(self, im_shape, im_type):
+        data = self.get_data(im_shape, im_type)
+        # use same image for both dictionary entries to check same trans is applied to them
+        data = {KEYS[0]: deepcopy(data[KEYS[0]]), KEYS[1]: deepcopy(data[KEYS[0]])}
+        loc = [0] + [int(im_shape[i] / 2) for i in range(len(im_shape))]
+        k_intensity = 10
+
+        t = KSpaceSpikeNoised(KEYS, loc, k_intensity)
+        out = t(deepcopy(data))
+        assert_allclose(out[KEYS[0]], out[KEYS[1]], type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()