rf: converging i/o to a base, common API - updated tests

Author: oesteban

nitransforms/io/afni.py

@@ -64,9 +64,10 @@ def from_string(cls, string):
         if '3dvolreg matrices' in lines[0]:
             lines = lines[1:]  # Drop header
 
-        parameters = np.eye(4, dtype='f4')
-        parameters[:3, :] = np.genfromtxt(
-            [lines[0].encode()], dtype=cls.dtype['parameters'])
+        parameters = np.vstack((
+            np.genfromtxt([lines[0].encode()],
+                          dtype='f8').reshape((3, 4)),
+            (0., 0., 0., 1.)))
         sa['parameters'] = parameters
         return tf
 

nitransforms/io/base.py

@@ -68,6 +68,13 @@ def to_ras(self):
         """Return a nitransforms internal RAS+ matrix."""
         raise NotImplementedError
 
+    @classmethod
+    def from_filename(cls, filename):
+        """Read the struct from a file given its path."""
+        with open(str(filename)) as f:
+            string = f.read()
+        return cls.from_string(string)
+
     @classmethod
     def from_fileobj(cls, fileobj, check=True):
         """Read the struct from a file object."""
@@ -127,6 +134,13 @@ def to_string(self):
         """Convert to a string directly writeable to file."""
         raise NotImplementedError
 
+    @classmethod
+    def from_filename(cls, filename):
+        """Read the struct from a file given its path."""
+        with open(str(filename)) as f:
+            string = f.read()
+        return cls.from_string(string)
+
     @classmethod
     def from_fileobj(cls, fileobj, check=True):
         """Read the struct from a file object."""

nitransforms/io/fsl.py

@@ -1,5 +1,4 @@
 """Read/write FSL's transforms."""
-from io import StringIO
 import numpy as np
 from nibabel.affines import voxel_sizes
 
@@ -11,16 +10,13 @@ class FSLLinearTransform(LinearParameters):
 
     def __str__(self):
         """Generate a string representation."""
-        param = self.structarr['parameters']
-        return '\t'.join(['%g' % p for p in param[:3, :].reshape(-1)])
+        lines = [' '.join(['%g' % col for col in row])
+                 for row in self.structarr['parameters']]
+        return '\n'.join(lines + [''])
 
     def to_string(self):
         """Convert to a string directly writeable to file."""
-        with StringIO() as f:
-            np.savetxt(f, self.structarr['parameters'],
-                       delimiter=' ', fmt='%g')
-            string = f.getvalue()
-        return string
+        return self.__str__()
 
     @classmethod
     def from_ras(cls, ras, moving, reference):
@@ -48,8 +44,8 @@ def from_string(cls, string):
         """Read the struct from string."""
         tf = cls()
         sa = tf.structarr
-        parameters = np.genfromtxt(string, dtype=cls.dtype['parameters'])
-        sa['parameters'] = parameters
+        sa['parameters'] = np.genfromtxt(
+            [string], dtype=cls.dtype['parameters'])
         return tf
 
 

nitransforms/io/itk.py

@@ -180,6 +180,17 @@ def from_binary(cls, byte_stream):
         """Read the struct from a matlab binary file."""
         raise TransformFileError("Please use the ITK's new .h5 format.")
 
+    @classmethod
+    def from_filename(cls, filename):
+        """Read the struct from a file given its path."""
+        if str(filename).endswith('.mat'):
+            with open(str(filename), 'b') as f:
+                return cls.from_binary(f)
+
+        with open(str(filename)) as f:
+            string = f.read()
+        return cls.from_string(string)
+
     @classmethod
     def from_fileobj(cls, fileobj, check=True):
         """Read the struct from a file object."""

nitransforms/io/lta.py

@@ -3,7 +3,7 @@
 from nibabel.volumeutils import Recoder
 from nibabel.affines import voxel_sizes
 
-from .base import StringBasedStruct, TransformFileError
+from .base import BaseLinearTransformList, StringBasedStruct, TransformFileError
 
 
 transform_codes = Recoder((
@@ -16,6 +16,8 @@
 
 
 class VolumeGeometry(StringBasedStruct):
+    """Data structure for regularly gridded images."""
+
     template_dtype = np.dtype([
         ('valid', 'i4'),              # Valid values: 0, 1
         ('volume', 'i4', (3, 1)),     # width, height, depth
@@ -28,6 +30,7 @@ class VolumeGeometry(StringBasedStruct):
     dtype = template_dtype
 
     def as_affine(self):
+        """Return the internal affine of this regular grid."""
         affine = np.eye(4)
         sa = self.structarr
         A = np.hstack((sa['xras'], sa['yras'], sa['zras'])) * sa['voxelsize']
@@ -36,7 +39,8 @@ def as_affine(self):
         affine[:3, [3]] = b
         return affine
 
-    def to_string(self):
+    def __str__(self):
+        """Format the structure as a text file."""
         sa = self.structarr
         lines = [
             'valid = {}  # volume info {:s}valid'.format(
@@ -52,8 +56,13 @@ def to_string(self):
         ]
         return '\n'.join(lines)
 
+    def to_string(self):
+        """Format the structure as a text file."""
+        return self.__str__()
+
     @classmethod
     def from_image(klass, img):
+        """Create struct from an image."""
         volgeom = klass()
         sa = volgeom.structarr
         sa['valid'] = 1
@@ -75,6 +84,7 @@ def from_image(klass, img):
 
     @classmethod
     def from_string(klass, string):
+        """Create a volume structure off of text."""
         volgeom = klass()
         sa = volgeom.structarr
         lines = string.splitlines()
@@ -83,15 +93,21 @@ def from_string(klass, string):
             label, valstring = lines.pop(0).split(' =')
             assert label.strip() == key
 
-            val = np.genfromtxt([valstring.encode()],
-                                dtype=klass.dtype[key])
-            sa[key] = val.reshape(sa[key].shape) if val.size else ''
-
+            val = ''
+            if valstring.strip():
+                parsed = np.genfromtxt([valstring.encode()], autostrip=True,
+                                       dtype=klass.dtype[key])
+                if parsed.size:
+                    val = parsed.reshape(sa[key].shape)
+            sa[key] = val
         return volgeom
 
 
 class LinearTransform(StringBasedStruct):
+    """Represents a single LTA's transform structure."""
+
     template_dtype = np.dtype([
+        ('type', 'i4'),
         ('mean', 'f4', (3, 1)),  # x0, y0, z0
         ('sigma', 'f4'),
         ('m_L', 'f8', (4, 4)),
@@ -103,12 +119,53 @@ class LinearTransform(StringBasedStruct):
     dtype = template_dtype
 
     def __getitem__(self, idx):
+        """Implement dictionary access."""
         val = super(LinearTransform, self).__getitem__(idx)
         if idx in ('src', 'dst'):
             val = VolumeGeometry(val)
         return val
 
+    def set_type(self, new_type):
+        """
+        Convert the internal transformation matrix to a different type inplace.
+
+        Parameters
+        ----------
+        new_type : str, int
+            Tranformation type
+
+        """
+        sa = self.structarr
+        src = VolumeGeometry(sa['src'])
+        dst = VolumeGeometry(sa['dst'])
+        current = sa['type']
+        if isinstance(new_type, str):
+            new_type = transform_codes.code[new_type]
+
+        if current == new_type:
+            return
+
+        # VOX2VOX -> RAS2RAS
+        if (current, new_type) == (0, 1):
+            M = dst.as_affine().dot(sa['m_L'].dot(np.linalg.inv(src.as_affine())))
+            sa['m_L'] = M
+            sa['type'] = new_type
+            return
+
+        raise NotImplementedError(
+            "Converting {0} to {1} is not yet available".format(
+                transform_codes.label[current],
+                transform_codes.label[new_type]
+            )
+        )
+
+    def to_ras(self):
+        """Return a nitransforms internal RAS+ matrix."""
+        self.set_type(1)
+        return self.structarr['m_L']
+
     def to_string(self):
+        """Convert this transform to text."""
         sa = self.structarr
         lines = [
             'mean      = {:6.4f} {:6.4f} {:6.4f}'.format(
@@ -120,14 +177,15 @@ def to_string(self):
             ('{:18.15e} ' * 4).format(*sa['m_L'][2]),
             ('{:18.15e} ' * 4).format(*sa['m_L'][3]),
             'src volume info',
-            self['src'].to_string(),
+            '%s' % self['src'],
             'dst volume info',
-            self['dst'].to_string(),
+            '%s' % self['dst'],
         ]
         return '\n'.join(lines)
 
     @classmethod
     def from_string(klass, string):
+        """Read a transform from text."""
         lt = klass()
         sa = lt.structarr
         lines = string.splitlines()
@@ -151,31 +209,32 @@ def from_string(klass, string):
         return lt
 
 
-class LinearTransformArray(StringBasedStruct):
+class LinearTransformArray(BaseLinearTransformList):
+    """A list of linear transforms generated by FreeSurfer."""
+
     template_dtype = np.dtype([
         ('type', 'i4'),
         ('nxforms', 'i4'),
         ('subject', 'U1024'),
         ('fscale', 'f4')])
     dtype = template_dtype
-    _xforms = None
-
-    def __init__(self,
-                 binaryblock=None,
-                 endianness=None,
-                 check=True):
-        super(LinearTransformArray, self).__init__(binaryblock, endianness, check)
-        self._xforms = [LinearTransform()
-                        for _ in range(self.structarr['nxforms'])]
+    _inner_type = LinearTransform
 
     def __getitem__(self, idx):
+        """Allow dictionary access to the transforms."""
         if idx == 'xforms':
             return self._xforms
         if idx == 'nxforms':
             return len(self._xforms)
-        return super(LinearTransformArray, self).__getitem__(idx)
+        return self.structarr[idx]
+
+    def to_ras(self, moving=None, reference=None):
+        """Set type to RAS2RAS and return the new matrix."""
+        self.structarr['type'] = 1
+        return [xfm.to_ras() for xfm in self.xforms]
 
     def to_string(self):
+        """Convert this LTA into text format."""
         code = int(self['type'])
         header = [
             'type      = {} # {}'.format(code, transform_codes.label[code]),
@@ -188,6 +247,7 @@ def to_string(self):
 
     @classmethod
     def from_string(klass, string):
+        """Read this LTA from a text string."""
         lta = klass()
         sa = lta.structarr
         lines = [l.strip() for l in string.splitlines()
@@ -203,7 +263,8 @@ def from_string(klass, string):
             sa[key] = val.reshape(sa[key].shape) if val.size else ''
         for _ in range(sa['nxforms']):
             lta._xforms.append(
-                LinearTransform.from_string('\n'.join(lines[:25])))
+                klass._inner_type.from_string('\n'.join(lines[:25])))
+            lta._xforms[-1].structarr['type'] = sa['type']
             lines = lines[25:]
         if lines:
             for key in ('subject', 'fscale'):
@@ -223,37 +284,3 @@ def from_string(klass, string):
 
         assert len(lta._xforms) == sa['nxforms']
         return lta
-
-    @classmethod
-    def from_fileobj(klass, fileobj, check=True):
-        return klass.from_string(fileobj.read())
-
-    def set_type(self, target):
-        """
-        Convert the internal transformation matrix to a different type inplace
-
-        Parameters
-        ----------
-        target : str, int
-            Tranformation type
-        """
-        assert self['nxforms'] == 1, "Cannot convert multiple transformations"
-        xform = self['xforms'][0]
-        src = xform['src']
-        dst = xform['dst']
-        current = self['type']
-        if isinstance(target, str):
-            target = transform_codes.code[target]
-
-        # VOX2VOX -> RAS2RAS
-        if current == 0 and target == 1:
-            M = dst.as_affine().dot(xform['m_L'].dot(np.linalg.inv(src.as_affine())))
-        else:
-            raise NotImplementedError(
-                "Converting {0} to {1} is not yet available".format(
-                    transform_codes.label[current],
-                    transform_codes.label[target]
-                )
-            )
-        xform['m_L'] = M
-        self['type'] = target

nitransforms/linear.py

@@ -174,30 +174,20 @@ def to_filename(self, filename, fmt='X5', moving=None):
 
         raise NotImplementedError
 
+    @classmethod
+    def from_filename(cls, filename, fmt='X5',
+                      reference=None, moving=None):
+        """Create an affine from a transform file."""
+        if fmt.lower() in ('itk', 'ants', 'elastix'):
+            _factory = io.itk.ITKLinearTransformArray
+        elif fmt.lower() in ('lta', 'fs'):
+            _factory = io.LinearTransformArray
+        else:
+            raise NotImplementedError
 
-def load(filename, fmt='X5', reference=None):
-    """Load a linear transform."""
-    if fmt.lower() in ('itk', 'ants', 'elastix'):
-        with open(filename) as itkfile:
-            itkxfm = io.itk.ITKLinearTransformArray.from_fileobj(
-                itkfile)
-        matrix = itkxfm.to_ras()
-    # elif fmt.lower() == 'afni':
-    #     parameters = LPS.dot(self.matrix.dot(LPS))
-    #     parameters = parameters[:3, :].reshape(-1).tolist()
-    elif fmt.lower() == 'fs':
-        with open(filename) as ltafile:
-            lta = io.LinearTransformArray.from_fileobj(ltafile)
-        if lta['nxforms'] > 1:
-            raise NotImplementedError("Multiple transforms are not yet supported.")
-        if lta['type'] != 1:
-            # To make transforms generalize across use-cases, LTA transforms
-            # are converted to RAS-to-RAS.
-            lta.set_type(1)
-        matrix = lta['xforms'][0]['m_L']
-    elif fmt.lower() in ('x5', 'bids'):
-        raise NotImplementedError
-    else:
-        raise NotImplementedError
+        struct = _factory.from_filename(filename)
+        matrix = struct.to_ras(reference=reference, moving=moving)
+
+        return cls(matrix, reference=reference)
 
-    return Affine(matrix, reference=reference)
+load = Affine.from_filename