tst: ramping up coverage

Author: oesteban

nitransforms/base.py

@@ -108,7 +108,7 @@ def __init__(self, image):
             self._ndim = 3
 
         self._npoints = getattr(image, 'npoints',
-                                np.prod(image.shape))
+                                np.prod(self._shape))
         self._ndindex = None
         self._coords = None
         self._inverse = getattr(image, 'inverse',
@@ -173,9 +173,11 @@ class TransformBase(object):
 
     __slots__ = ['_reference']
 
-    def __init__(self):
+    def __init__(self, reference=None):
         """Instantiate a transform."""
         self._reference = None
+        if reference:
+            self.reference = reference
 
     def __call__(self, x, inverse=False):
         """Apply y = f(x)."""

nitransforms/io/fsl.py

@@ -1,6 +1,7 @@
 """Read/write FSL's transforms."""
 import os
 import numpy as np
+from pathlib import Path
 from nibabel.affines import voxel_sizes
 
 from .base import BaseLinearTransformList, LinearParameters, TransformFileError
@@ -63,13 +64,11 @@ class FSLLinearTransformArray(BaseLinearTransformList):
 
     def to_filename(self, filename):
         """Store this transform to a file with the appropriate format."""
-        if len(self.xforms) == 1:
-            self.xforms[0].to_filename(filename)
-            return
-
+        output_dir = Path(filename).parent
+        output_dir.mkdir(exist_ok=True, parents=True)
         for i, xfm in enumerate(self.xforms):
-            with open('%s.%03d' % (filename, i), 'w') as f:
-                f.write(xfm.to_string())
+            (output_dir / '.'.join((str(filename), '%03d' % i))).write_text(
+                xfm.to_string())
 
     def to_ras(self, moving=None, reference=None):
         """Return a nitransforms' internal RAS matrix."""

nitransforms/linear.py

@@ -55,19 +55,16 @@ def __init__(self, matrix=None, reference=None):
                [0, 0, 0, 1]])
 
         """
-        super().__init__()
-        if matrix is None:
-            matrix = np.eye(4)
-
-        self._matrix = np.array(matrix)
-        if self._matrix.ndim != 2:
-            raise TypeError('Affine should be 2D.')
-
-        if self._matrix.shape[0] != self._matrix.shape[1]:
-            raise TypeError('Matrix is not square.')
+        super().__init__(reference=reference)
+        self._matrix = np.eye(4)
 
-        if reference:
-            self.reference = reference
+        if matrix is not None:
+            matrix = np.array(matrix)
+            if matrix.ndim != 2:
+                raise TypeError('Affine should be 2D.')
+            elif matrix.shape[0] != matrix.shape[1]:
+                raise TypeError('Matrix is not square.')
+            self._matrix = matrix
 
     def __eq__(self, other):
         """
@@ -162,7 +159,7 @@ def to_filename(self, filename, fmt='X5', moving=None):
             # xform info
             lt = io.LinearTransform()
             lt['sigma'] = 1.
-            lt['m_L'] = [self.matrix]
+            lt['m_L'] = self.matrix
             # Just for reference, nitransforms does not write VOX2VOX
             lt['src'] = io.VolumeGeometry.from_image(moving)
             lt['dst'] = io.VolumeGeometry.from_image(self.reference)
@@ -299,7 +296,7 @@ def map(self, x, inverse=False):
 
     def to_filename(self, filename, fmt='X5', moving=None):
         """Store the transform in BIDS-Transforms HDF5 file format (.x5)."""
-        if fmt.lower() in ['itk', 'ants', 'elastix']:
+        if fmt.lower() in ('itk', 'ants', 'elastix'):
             itkobj = io.itk.ITKLinearTransformArray.from_ras(self.matrix)
             itkobj.to_filename(filename)
             return filename
@@ -323,18 +320,19 @@ def to_filename(self, filename, fmt='X5', moving=None):
             fslobj.to_filename(filename)
             return filename
 
-        if fmt.lower() == 'fs':
+        if fmt.lower() in ('fs', 'lta'):
             # xform info
-            lt = io.LinearTransform()
-            lt['sigma'] = 1.
-            lt['m_L'] = self.matrix
-            # Just for reference, nitransforms does not write VOX2VOX
-            lt['src'] = io.VolumeGeometry.from_image(moving)
-            lt['dst'] = io.VolumeGeometry.from_image(self.reference)
             # to make LTA file format
             lta = io.LinearTransformArray()
             lta['type'] = 1  # RAS2RAS
-            lta['xforms'].append(lt)
+            for m in self.matrix:
+                lt = io.LinearTransform()
+                lt['sigma'] = 1.
+                lt['m_L'] = m
+                # Just for reference, nitransforms does not write VOX2VOX
+                lt['src'] = io.VolumeGeometry.from_image(moving)
+                lt['dst'] = io.VolumeGeometry.from_image(self.reference)
+                lta['xforms'].append(lt)
 
             with open(filename, 'w') as f:
                 f.write(lta.to_string())

nitransforms/tests/test_base.py

@@ -11,13 +11,22 @@ def test_SpatialReference(data_path):
     """Ensure the reference factory is working properly."""
     obj1 = data_path / 'someones_anatomy.nii.gz'
     obj2 = data_path / 'sub-200148_hemi-R_pial.surf.gii'
+    obj3 = data_path / 'func.nii.gz'
 
     assert isinstance(SpatialReference.factory(obj1), ImageGrid)
     assert isinstance(SpatialReference.factory(str(obj1)), ImageGrid)
     assert isinstance(SpatialReference.factory(nb.load(str(obj1))), ImageGrid)
     assert isinstance(SpatialReference.factory(obj2), SampledSpatialData)
     assert isinstance(SpatialReference.factory(str(obj2)), SampledSpatialData)
     assert isinstance(SpatialReference.factory(nb.load(str(obj2))), SampledSpatialData)
+    assert isinstance(SpatialReference.factory(obj3), ImageGrid)
+    assert isinstance(SpatialReference.factory(str(obj3)), ImageGrid)
+    assert isinstance(SpatialReference.factory(nb.load(str(obj3))), ImageGrid)
+
+    func_ref = SpatialReference.factory(obj3)
+    assert func_ref.ndim == 3
+    assert func_ref.shape == (96, 96, 56)
+    assert func_ref.npoints == np.prod(func_ref.shape)
 
 
 @pytest.mark.parametrize('image_orientation', ['RAS', 'LAS', 'LPS', 'oblique'])

nitransforms/tests/test_linear.py

@@ -31,28 +31,58 @@
 }
 
 
-def test_linear_typeerrors(data_path):
+@pytest.mark.parametrize('matrix', [
+    [0.0],
+    np.ones((3, 3, 3)),
+    np.ones((3, 4)),
+])
+def test_linear_typeerrors1(matrix):
     """Exercise errors in Affine creation."""
     with pytest.raises(TypeError):
-        ntl.Affine([0.0])
+        ntl.Affine(matrix)
 
-    with pytest.raises(TypeError):
-        ntl.Affine(np.arange((3, 3, 3)))
-
-    with pytest.raises(TypeError):
-        ntl.Affine(np.arange((3, 4)))
 
+def test_linear_typeerrors2(data_path):
+    """Exercise errors in Affine creation."""
     with pytest.raises(TypeError):
         ntl.Affine.from_filename(data_path / 'itktflist.tfm', fmt='itk')
 
 
-def test_loadsave(tmp_path, data_path):
+def test_loadsave_itk(tmp_path, data_path):
     """Test idempotency."""
+    ref_file = data_path / 'someones_anatomy.nii.gz'
     xfm = ntl.load(data_path / 'itktflist2.tfm', fmt='itk')
-    xfm.to_filename(tmp_path / 'writtenout.tfm', fmt='itk')
+    assert isinstance(xfm, ntl.LinearTransformsMapping)
+    xfm.reference = ref_file
+    xfm.to_filename(tmp_path / 'transform-mapping.tfm', fmt='itk')
 
     assert (data_path / 'itktflist2.tfm').read_text() \
-        == (tmp_path / 'writtenout.tfm').read_text()
+        == (tmp_path / 'transform-mapping.tfm').read_text()
+
+    single_xfm = ntl.load(data_path / 'affine-LAS.itk.tfm', fmt='itk')
+    assert isinstance(single_xfm, ntl.Affine)
+    assert single_xfm == ntl.Affine.from_filename(
+        data_path / 'affine-LAS.itk.tfm', fmt='itk')
+
+
+@pytest.mark.xfail(reason="Not fully implemented")
+@pytest.mark.parametrize('fmt', ['itk', 'fsl', 'afni', 'lta'])
+def test_loadsave(tmp_path, data_path, fmt):
+    """Test idempotency."""
+    ref_file = data_path / 'someones_anatomy.nii.gz'
+    xfm = ntl.load(data_path / 'itktflist2.tfm', fmt='itk')
+    xfm.reference = ref_file
+
+    fname = tmp_path / '.'.join(('transform-mapping', fmt))
+    xfm.to_filename(fname, fmt=fmt)
+    xfm == ntl.load(fname, fmt=fmt, reference=ref_file)
+
+    ref_file = data_path / 'someones_anatomy.nii.gz'
+    xfm = ntl.load(data_path / 'affine-LAS.itk.tfm', fmt='itk')
+    xfm.reference = ref_file
+    fname = tmp_path / '.'.join(('single-transform', fmt))
+    xfm.to_filename(fname, fmt=fmt)
+    xfm == ntl.load(fname, fmt=fmt, reference=ref_file)
 
 
 @pytest.mark.xfail(reason="Not fully implemented")
@@ -146,3 +176,21 @@ def test_concatenation(data_path):
     x = [(0., 0., 0.), (1., 1., 1.), (-1., -1., -1.)]
     assert np.all((aff + ntl.Affine())(x) == x)
     assert np.all((aff + ntl.Affine())(x, inverse=True) == x)
+
+
+def test_LinearTransformsMapping_apply(tmp_path, data_path):
+    """Apply transform mappings."""
+    hmc = ntl.load(data_path / 'hmc-itk.tfm', fmt='itk',
+                   reference=data_path / 'sbref.nii.gz')
+    assert isinstance(hmc, ntl.LinearTransformsMapping)
+
+    # Test-case: realing functional data on to sbref
+    nii = hmc.apply(data_path / 'func.nii.gz', order=1)
+    assert nii.dataobj.shape[-1] == len(hmc)
+
+    # Test-case: write out a fieldmap moved with head
+    hmcinv = ntl.LinearTransformsMapping(
+        np.linalg.inv(hmc.matrix),
+        reference=data_path / 'func.nii.gz')
+    nii = hmcinv.apply(data_path / 'fmap.nii.gz', order=1)
+    assert nii.dataobj.shape[-1] == len(hmc)