ENH: Uber-refactor of code style, method names, etc.

Author: oesteban

nitransforms/base.py

@@ -15,13 +15,14 @@
 EQUALITY_TOL = 1e-5
 
 
-class ImageSpace(object):
+class ImageGrid(object):
     """Class to represent spaces of gridded data (images)."""
 
     __slots__ = ['_affine', '_shape', '_ndim', '_ndindex', '_coords', '_nvox',
                  '_inverse']
 
     def __init__(self, image):
+        """Create a gridded sampling reference."""
         self._affine = image.affine
         self._shape = image.shape
         self._ndim = len(image.shape)
@@ -34,26 +35,32 @@ def __init__(self, image):
 
     @property
     def affine(self):
+        """Access the indexes-to-RAS affine."""
         return self._affine
 
     @property
     def inverse(self):
+        """Access the RAS-to-indexes affine."""
         return self._inverse
 
     @property
     def shape(self):
+        """Access the space's size of each dimension."""
         return self._shape
 
     @property
     def ndim(self):
+        """Access the number of dimensions."""
         return self._ndim
 
     @property
     def nvox(self):
+        """Access the total number of voxels."""
         return self._nvox
 
     @property
     def ndindex(self):
+        """List the indexes corresponding to the space grid."""
         if self._ndindex is None:
             indexes = tuple([np.arange(s) for s in self._shape])
             self._ndindex = np.array(np.meshgrid(
@@ -62,6 +69,7 @@ def ndindex(self):
 
     @property
     def ndcoords(self):
+        """List the physical coordinates of this gridded space samples."""
         if self._coords is None:
             self._coords = np.tensordot(
                 self._affine,
@@ -70,14 +78,14 @@ def ndcoords(self):
             )[:3, ...]
         return self._coords
 
-    def map_voxels(self, coordinates):
+    def index(self, coordinates):
+        """Get the image array's indexes corresponding to coordinates."""
         coordinates = np.array(coordinates)
         ncoords = coordinates.shape[-1]
         coordinates = np.vstack((coordinates, np.ones((1, ncoords))))
 
         # Back to grid coordinates
-        return np.tensordot(np.linalg.inv(self._affine),
-                            coordinates, axes=1)[:3, ...]
+        return np.tensordot(self._inverse, coordinates, axes=1)[:3, ...]
 
     def _to_hdf5(self, group):
         group.attrs['Type'] = 'image'
@@ -86,14 +94,9 @@ def _to_hdf5(self, group):
         group.create_dataset('shape', data=self.shape)
 
     def __eq__(self, other):
-        try:
-            return (
-                np.allclose(self.affine, other.affine, rtol=EQUALITY_TOL)
-                and self.shape == other.shape
-            )
-        except AttributeError:
-            pass
-        return False
+        """Overload equals operator."""
+        return (np.allclose(self.affine, other.affine, rtol=EQUALITY_TOL) and
+                self.shape == other.shape)
 
 
 class TransformBase(object):
@@ -102,6 +105,7 @@ class TransformBase(object):
     __slots__ = ['_reference']
 
     def __init__(self):
+        """Instantiate a transform."""
         self._reference = None
 
     def __eq__(self, other):
@@ -110,25 +114,31 @@ def __eq__(self, other):
             return False
         return np.allclose(self.matrix, other.matrix, rtol=EQUALITY_TOL)
 
+    def __call__(self, x):
+        """Apply y = f(x)."""
+        return self.map(x)
+
     @property
     def reference(self):
-        '''A reference space where data will be resampled onto'''
+        """Access a reference space where data will be resampled onto."""
         if self._reference is None:
             raise ValueError('Reference space not set')
         return self._reference
 
     @reference.setter
     def reference(self, image):
-        self._reference = ImageSpace(image)
+        self._reference = ImageGrid(image)
 
     @property
     def ndim(self):
+        """Access the dimensions of the reference space."""
         return self.reference.ndim
 
     def resample(self, moving, order=3, mode='constant', cval=0.0, prefilter=True,
                  output_dtype=None):
         """
         Resample the moving image in reference space.
+
         Parameters
         ----------
         moving : `spatialimage`
@@ -150,18 +160,25 @@ def resample(self, moving, order=3, mode='constant', cval=0.0, prefilter=True,
             slightly blurred if *order > 1*, unless the input is prefiltered,
             i.e. it is the result of calling the spline filter on the original
             input.
+
         Returns
         -------
         moved_image : `spatialimage`
             The moving imaged after resampling to reference space.
+
         """
         moving_data = np.asanyarray(moving.dataobj)
         if output_dtype is None:
             output_dtype = moving_data.dtype
 
+        moving_grid = ImageGrid(moving)
+
+        def _map_indexes(ijk):
+            return moving_grid.inverse.dot(self.map(self.reference.affine.dot(ijk)))
+
         moved = ndi.geometric_transform(
             moving_data,
-            mapping=self.map_voxel,
+            mapping=_map_indexes,
             output_shape=self.reference.shape,
             output=output_dtype,
             order=order,
@@ -175,16 +192,8 @@ def resample(self, moving, order=3, mode='constant', cval=0.0, prefilter=True,
         moved_image.header.set_data_dtype(output_dtype)
         return moved_image
 
-    def map_point(self, coords):
-        """Apply y = f(x), where x is the argument `coords`."""
-        raise NotImplementedError
-
-    def map_voxel(self, index, moving=None):
-        """Apply ijk' = f_ijk((i, j, k)), equivalent to the above with indexes."""
-        raise NotImplementedError
-
-    def _to_hdf5(self, x5_root):
-        """Serialize this object into the x5 file format."""
+    def map(self, x):
+        """Apply y = f(x)."""
         raise NotImplementedError
 
     def to_filename(self, filename, fmt='X5'):
@@ -196,3 +205,7 @@ def to_filename(self, filename, fmt='X5'):
             self._to_hdf5(root)
 
         return filename
+
+    def _to_hdf5(self, x5_root):
+        """Serialize this object into the x5 file format."""
+        raise NotImplementedError

nitransforms/linear.py

@@ -178,7 +178,7 @@ def resample(self, moving, order=3, mode='constant', cval=0.0, prefilter=True,
 
         return moved_image
 
-    def map_point(self, coords, index=0, forward=True):
+    def map(self, coords, index=0, forward=True):
         """
         Apply y = f(x), where x is the argument `coords`.
 
@@ -200,10 +200,10 @@ def map_point(self, coords, index=0, forward=True):
         Examples
         --------
         >>> xfm = Affine([[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]])
-        >>> xfm.map_point((0,0,0))
+        >>> xfm((0,0,0))
         array([1, 2, 3])
 
-        >>> xfm.map_point((0,0,0), forward=False)
+        >>> xfm((0,0,0), forward=False)
         array([-1., -2., -3.])
 
         """
@@ -213,7 +213,7 @@ def map_point(self, coords, index=0, forward=True):
         affine = self._matrix[index] if forward else np.linalg.inv(self._matrix[index])
         return affine.dot(coords)[:-1]
 
-    def map_voxel(self, index, nindex=0, moving=None):
+    def _map_voxel(self, index, nindex=0, moving=None):
         """Apply ijk' = f_ijk((i, j, k)), equivalent to the above with indexes."""
         try:
             reference = self.reference

nitransforms/nonlinear.py

@@ -11,7 +11,7 @@
 from scipy import ndimage as ndi
 # from gridbspline.maths import cubic
 
-from .base import ImageSpace, TransformBase
+from .base import ImageGrid, TransformBase
 from nibabel.funcs import four_to_three
 
 # vbspl = np.vectorize(cubic)
@@ -53,7 +53,7 @@ def __init__(self, field, reference=None):
 
     def _cache_moving(self, moving):
         # Check whether input (moving) space is cached
-        moving_space = ImageSpace(moving)
+        moving_space = ImageGrid(moving)
         if self._moving_space == moving_space:
             return
 
@@ -126,14 +126,13 @@ def resample(self, moving, order=3, mode='constant', cval=0.0, prefilter=True,
         return super(DeformationFieldTransform, self).resample(
             moving, order=order, mode=mode, cval=cval, prefilter=prefilter)
 
-    def map_voxel(self, index, moving=None):
+    def _map_voxel(self, index, moving=None):
         """Apply ijk' = f_ijk((i, j, k)), equivalent to the above with indexes."""
         return tuple(self._moving[index + self.__s])
 
-    def map_coordinates(self, coordinates, order=3, mode='mirror', cval=0.0,
-                        prefilter=True):
+    def map(self, x, order=3, mode='mirror', cval=0.0, prefilter=True):
         """Apply y = f(x), where x is the argument `coords`."""
-        coordinates = np.array(coordinates)
+        coordinates = np.array(x)
         # Extract shapes and dimensions, then flatten
         ndim = coordinates.shape[-1]
         output_shape = coordinates.shape[:-1]
@@ -176,7 +175,7 @@ def __init__(self, reference, coefficients, order=3):
                 'not match the number of dimensions')
 
         self._coeffs = coefficients.get_data()
-        self._knots = ImageSpace(four_to_three(coefficients)[0])
+        self._knots = ImageGrid(four_to_three(coefficients)[0])
         self._cache_moving()
 
     def _cache_moving(self):
@@ -222,7 +221,7 @@ def _interp_transform(self, coords):
         # coords[:3] += weights.dot(np.array(coeffs, dtype=float))
         return self.reference.inverse.dot(np.hstack((coords, 1)))[:3]
 
-    def map_voxel(self, index, moving=None):
+    def _map_voxel(self, index, moving=None):
         """Apply ijk' = f_ijk((i, j, k)), equivalent to the above with indexes."""
         return tuple(self._moving[index + self.__s])
 

nitransforms/tests/test_base.py

@@ -1,13 +1,16 @@
-"""Tests of the base module"""
+"""Tests of the base module."""
 import numpy as np
+import pytest
 
-from ..base import ImageSpace
+from ..base import ImageGrid
 
 
-def test_ImageSpace(get_data):
-    im = get_data['RAS']
+@pytest.mark.parametrize('image_orientation', ['RAS', 'LAS', 'LPS', 'oblique'])
+def test_ImageGrid(get_data, image_orientation):
+    """Check the grid object."""
+    im = get_data[image_orientation]
 
-    img = ImageSpace(im)
+    img = ImageGrid(im)
     assert np.all(img.affine == np.linalg.inv(img.inverse))
 
     # nd index / coords