Improve coverage

Author: fepegar

docs/reference/transforms/ensure_shape_multiple.md

@@ -0,0 +1,5 @@
+# EnsureShapeMultiple
+
+::: torchio.EnsureShapeMultiple
+    options:
+      show_root_heading: false

tests/test_batch.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import pytest
 import torch
 
 import torchio as tio
@@ -194,3 +195,104 @@ def test_batch_copy_preserves_original(self) -> None:
         tio.Noise(std=1.0)(batch)
         # Original should be unchanged (copy=True default)
         torch.testing.assert_close(batch.data, original)
+
+
+# ── Coverage gap tests ───────────────────────────────────────────────
+
+
+class TestImagesBatchValidation:
+    def test_non_5d_raises(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        with pytest.raises(ValueError, match="5"):
+            ImagesBatch(
+                data=torch.rand(1, 10, 10),
+                affines=[tio.AffineMatrix()],
+                image_class=tio.ScalarImage,
+            )
+
+    def test_affine_count_mismatch_raises(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        with pytest.raises(ValueError, match="affines"):
+            ImagesBatch(
+                data=torch.rand(2, 1, 5, 5, 5),
+                affines=[tio.AffineMatrix()],  # only 1 for batch of 2
+                image_class=tio.ScalarImage,
+            )
+
+    def test_from_images_empty_raises(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        with pytest.raises(ValueError, match="empty"):
+            ImagesBatch.from_images([])
+
+    def test_data_setter_non_5d_raises(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        batch = ImagesBatch(
+            data=torch.rand(1, 1, 5, 5, 5),
+            affines=[tio.AffineMatrix()],
+            image_class=tio.ScalarImage,
+        )
+        with pytest.raises(ValueError, match="5"):
+            batch.data = torch.rand(1, 5, 5)
+
+    def test_device_property(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        batch = ImagesBatch(
+            data=torch.rand(1, 1, 5, 5, 5),
+            affines=[tio.AffineMatrix()],
+            image_class=tio.ScalarImage,
+        )
+        assert batch.device.type == "cpu"
+
+    def test_len(self) -> None:
+        from torchio.data.batch import ImagesBatch
+
+        batch = ImagesBatch(
+            data=torch.rand(3, 1, 5, 5, 5),
+            affines=[tio.AffineMatrix() for _ in range(3)],
+            image_class=tio.ScalarImage,
+        )
+        assert len(batch) == 3
+
+
+class TestSubjectsBatchEdgeCases:
+    def test_from_subjects_empty_raises(self) -> None:
+        from torchio.data.batch import SubjectsBatch
+
+        with pytest.raises(ValueError, match="empty"):
+            SubjectsBatch.from_subjects([])
+
+    def test_device_property(self) -> None:
+        subject = tio.Subject(t1=tio.ScalarImage(torch.rand(1, 5, 5, 5)))
+        from torchio.data.batch import SubjectsBatch
+
+        batch = SubjectsBatch.from_subjects([subject])
+        assert batch.device.type == "cpu"
+
+    def test_getattr_invalid_raises(self) -> None:
+        subject = tio.Subject(t1=tio.ScalarImage(torch.rand(1, 5, 5, 5)))
+        from torchio.data.batch import SubjectsBatch
+
+        batch = SubjectsBatch.from_subjects([subject])
+        with pytest.raises(AttributeError):
+            _ = batch.nonexistent_image
+
+    def test_len(self) -> None:
+        subject = tio.Subject(t1=tio.ScalarImage(torch.rand(1, 5, 5, 5)))
+        from torchio.data.batch import SubjectsBatch
+
+        batch = SubjectsBatch.from_subjects([subject])
+        assert len(batch) == 1
+
+    def test_repr(self) -> None:
+        subject = tio.Subject(t1=tio.ScalarImage(torch.rand(1, 5, 5, 5)))
+        from torchio.data.batch import SubjectsBatch
+
+        batch = SubjectsBatch.from_subjects([subject])
+        r = repr(batch)
+        assert "SubjectsBatch" in r
+        assert "t1" in r

tests/test_compose.py

@@ -0,0 +1,62 @@
+"""Tests for Compose transform."""
+
+from __future__ import annotations
+
+import torch
+
+import torchio as tio
+
+
+def _make_subject() -> tio.Subject:
+    return tio.Subject(
+        t1=tio.ScalarImage(torch.rand(1, 10, 10, 10)),
+        seg=tio.LabelMap(torch.zeros(1, 10, 10, 10)),
+    )
+
+
+class TestCompose:
+    def test_identity_compose(self) -> None:
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        result = tio.Compose([])(subject)
+        torch.testing.assert_close(result.t1.data, original)
+
+    def test_single_transform(self) -> None:
+        subject = _make_subject()
+        result = tio.Compose([tio.Flip(axes=(0,))])(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_multiple_transforms(self) -> None:
+        subject = _make_subject()
+        pipeline = tio.Compose(
+            [
+                tio.Flip(axes=(0,)),
+                tio.Gamma(log_gamma=0.0),
+            ]
+        )
+        result = pipeline(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_nested_compose(self) -> None:
+        subject = _make_subject()
+        inner = tio.Compose([tio.Flip(axes=(0,))], copy=False)
+        outer = tio.Compose([inner])
+        result = outer(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_copy_default(self) -> None:
+        """Compose deep-copies input by default."""
+        subject = _make_subject()
+        original_data = subject.t1.data.clone()
+        tio.Compose([tio.Gamma(log_gamma=0.5)])(subject)
+        torch.testing.assert_close(subject.t1.data, original_data)
+
+    def test_no_copy(self) -> None:
+        subject = _make_subject()
+        result = tio.Compose([tio.Gamma(log_gamma=0.0)], copy=False)(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_history_recorded(self) -> None:
+        subject = _make_subject()
+        result = tio.Compose([tio.Flip(axes=(0,))])(subject)
+        assert len(result.applied_transforms) > 0

tests/test_ensure_shape_multiple.py

@@ -204,3 +204,20 @@ def test_four_pooling_layers(self) -> None:
         result = tio.EnsureShapeMultiple(2**4)(subject)
         for s in result.t1.spatial_shape:
             assert s % 16 == 0
+
+
+# ── Coverage gap tests ───────────────────────────────────────────────
+
+
+class TestEnsureShapeMultipleValidation:
+    def test_zero_multiple_raises(self) -> None:
+        with pytest.raises(ValueError, match=">= 1"):
+            tio.EnsureShapeMultiple(target_multiple=0)
+
+    def test_wrong_tuple_length_raises(self) -> None:
+        with pytest.raises(ValueError, match="1 or 3"):
+            tio.EnsureShapeMultiple(target_multiple=(2, 4))
+
+    def test_negative_in_tuple_raises(self) -> None:
+        with pytest.raises(ValueError, match=">= 1"):
+            tio.EnsureShapeMultiple(target_multiple=(2, -1, 4))

tests/test_histogram_standardization.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 import torch
 
@@ -85,3 +87,52 @@ def test_too_few_quantiles_raises(self) -> None:
         images = self._make_images()
         with pytest.raises(ValueError, match="at least 2"):
             compute_histogram_landmarks(images, quantiles=(0.5,))
+
+
+class TestHistogramStandardizationEdgeCases:
+    def test_quantiles_out_of_range_raises(self) -> None:
+        images = [tio.ScalarImage(torch.randn(1, 5, 5, 5)) for _ in range(3)]
+        with pytest.raises(ValueError, match="\\[0, 1\\]"):
+            compute_histogram_landmarks(images, quantiles=(-0.1, 0.5, 1.1))
+
+    def test_cutoff_not_in_quantiles_raises(self) -> None:
+        images = [tio.ScalarImage(torch.randn(1, 5, 5, 5)) for _ in range(3)]
+        with pytest.raises(ValueError, match="Cutoff"):
+            compute_histogram_landmarks(
+                images, quantiles=(0.25, 0.5, 0.75), cutoff=(0.01, 0.99)
+            )
+
+    def test_load_landmarks_from_npy(self, tmp_path: Path) -> None:
+        import numpy as np
+
+        arr = np.linspace(0, 100, 13).astype(np.float32)
+        npy_path = tmp_path / "landmarks.npy"
+        np.save(npy_path, arr)
+        subject = _make_subject(with_label=False)
+        result = tio.HistogramStandardization(npy_path)(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_load_landmarks_from_pt(self, tmp_path: Path) -> None:
+        landmarks = torch.linspace(0, 100, 13)
+        pt_path = tmp_path / "landmarks.pt"
+        torch.save(landmarks, pt_path)
+        subject = _make_subject(with_label=False)
+        result = tio.HistogramStandardization(pt_path)(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_unsupported_format_raises(self, tmp_path: Path) -> None:
+        bad_path = tmp_path / "landmarks.csv"
+        bad_path.write_text("1,2,3")
+        with pytest.raises(ValueError, match="Unsupported"):
+            tio.HistogramStandardization(bad_path)
+
+    def test_pt_with_wrong_type_raises(self, tmp_path: Path) -> None:
+        pt_path = tmp_path / "landmarks.pt"
+        torch.save({"not": "a tensor"}, pt_path)
+        with pytest.raises(TypeError, match="Expected a Tensor"):
+            tio.HistogramStandardization(pt_path)
+
+    def test_load_from_path_string(self) -> None:
+        images = [tio.ScalarImage(torch.randn(1, 5, 5, 5)) for _ in range(3)]
+        landmarks = compute_histogram_landmarks(images)
+        assert landmarks.ndim == 1

tests/test_inverse.py

@@ -0,0 +1,72 @@
+"""Tests for the inverse transform module."""
+
+from __future__ import annotations
+
+import torch
+
+import torchio as tio
+
+
+def _make_subject() -> tio.Subject:
+    return tio.Subject(
+        t1=tio.ScalarImage(torch.rand(1, 10, 10, 10)),
+        seg=tio.LabelMap(torch.zeros(1, 10, 10, 10)),
+    )
+
+
+class TestApplyInverseTransform:
+    def test_flip_inverse(self) -> None:
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        transformed = tio.Flip(axes=(0,))(subject)
+        restored = transformed.apply_inverse_transform()
+        torch.testing.assert_close(restored.t1.data, original)
+
+    def test_compose_inverse(self) -> None:
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        pipeline = tio.Compose(
+            [
+                tio.Flip(axes=(0,)),
+                tio.Flip(axes=(1,)),
+            ]
+        )
+        transformed = pipeline(subject)
+        restored = transformed.apply_inverse_transform()
+        torch.testing.assert_close(restored.t1.data, original)
+
+    def test_ignore_intensity(self) -> None:
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        pipeline = tio.Compose(
+            [
+                tio.Flip(axes=(0,)),
+                tio.Noise(std=0.1),
+            ]
+        )
+        transformed = pipeline(subject)
+        restored = transformed.apply_inverse_transform(
+            ignore_intensity=True,
+        )
+        # Shape restored, flip inverted, noise skipped.
+        assert restored.t1.data.shape == original.shape
+
+    def test_get_inverse_transform(self) -> None:
+        subject = _make_subject()
+        transformed = tio.Flip(axes=(0,))(subject)
+        inverse = transformed.get_inverse_transform()
+        assert inverse is not None
+
+    def test_standalone_function(self) -> None:
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        transformed = tio.Flip(axes=(0,))(subject)
+        restored = tio.apply_inverse_transform(transformed)
+        torch.testing.assert_close(restored.t1.data, original)
+
+    def test_no_history(self) -> None:
+        """Subject with no transforms should return itself."""
+        subject = _make_subject()
+        original = subject.t1.data.clone()
+        restored = subject.apply_inverse_transform()
+        torch.testing.assert_close(restored.t1.data, original)

tests/test_one_of.py

@@ -0,0 +1,47 @@
+"""Tests for OneOf transform."""
+
+from __future__ import annotations
+
+import torch
+
+import torchio as tio
+
+
+def _make_subject() -> tio.Subject:
+    return tio.Subject(
+        t1=tio.ScalarImage(torch.rand(1, 10, 10, 10)),
+    )
+
+
+class TestOneOf:
+    def test_applies_one(self) -> None:
+        subject = _make_subject()
+        transform = tio.OneOf(
+            [
+                tio.Flip(axes=(0,)),
+                tio.Gamma(log_gamma=0.3),
+            ]
+        )
+        result = transform(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_single_transform(self) -> None:
+        subject = _make_subject()
+        result = tio.OneOf([tio.Flip(axes=(0,))])(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_with_weights(self) -> None:
+        subject = _make_subject()
+        transform = tio.OneOf(
+            {
+                tio.Flip(axes=(0,)): 1.0,
+                tio.Gamma(log_gamma=0.0): 0.0,
+            }
+        )
+        result = transform(subject)
+        assert result.t1.data.shape == subject.t1.data.shape
+
+    def test_history_recorded(self) -> None:
+        subject = _make_subject()
+        result = tio.OneOf([tio.Flip(axes=(0,))])(subject)
+        assert len(result.applied_transforms) > 0