RF: Move slicing machinery to SpatialFirstSlicer class

Author: effigies

nibabel/spatialimages.py

@@ -322,24 +322,95 @@ class ImageDataError(Exception):
     pass
 
 
-class SpatialImage(DataobjImage):
-    ''' Template class for volumetric (3D/4D) images '''
-    header_class = SpatialHeader
+class SpatialFirstSlicer(object):
+    ''' Slicing interface that returns a new image with an updated affine
+
+    Checks that an image's first three axes are spatial
+    '''
+    def __init__(self, img):
+        from .imageclasses import spatial_axes_first
+        if not spatial_axes_first(img):
+            raise ValueError("Cannot predict position of spatial axes for "
+                             "Image type " + img.__class__.__name__)
+        self.img = img
+
+    def __getitem__(self, slicer):
+        try:
+            slicer = self.check_slicing(slicer)
+        except ValueError as err:
+            raise IndexError(*err.args)
+        dataobj = self.img.dataobj[slicer]
+        affine = self.slice_affine(slicer)
+        return self.img.__class__(dataobj.copy(), affine, self.img.header)
+
+    def check_slicing(self, slicer, return_spatial=False):
+        ''' Canonicalize slicers and check for scalar indices in spatial dims
+
+        Parameters
+        ----------
+        slicer : object
+            something that can be used to slice an array as in
+            ``arr[sliceobj]``
+        return_spatial : bool
+            return only slices along spatial dimensions (x, y, z)
 
-    class Slicer(object):
-        ''' Slicing interface that returns a new image with an updated affine
+        Returns
+        -------
+        slicer : object
+            Validated slicer object that will slice image's `dataobj`
+            without collapsing spatial dimensions
         '''
-        def __init__(self, img):
-            self.img = img
+        slicer = canonical_slicers(slicer, self.img.shape)
+        spatial_slices = slicer[:3]
+        for subslicer in spatial_slices:
+            if subslicer is None:
+                raise IndexError("New axis not permitted in spatial dimensions")
+            elif isinstance(subslicer, int):
+                raise IndexError("Scalar indices disallowed in spatial dimensions; "
+                                 "Use `[x]` or `x:x+1`.")
+        return spatial_slices if return_spatial else slicer
 
-        def __getitem__(self, slicer):
-            try:
-                slicer = self.img._check_slicing(slicer)
-            except ValueError as err:
-                raise IndexError(*err.args)
-            dataobj = self.img.dataobj[slicer]
-            affine = self.img._slice_affine(slicer)
-            return self.img.__class__(dataobj.copy(), affine, self.img.header)
+    def slice_affine(self, slicer):
+        """ Retrieve affine for current image, if sliced by a given index
+
+        Applies scaling if down-sampling is applied, and adjusts the intercept
+        to account for any cropping.
+
+        Parameters
+        ----------
+        slicer : object
+            something that can be used to slice an array as in
+            ``arr[sliceobj]``
+
+        Returns
+        -------
+        affine : (4,4) ndarray
+            Affine with updated scale and intercept
+        """
+        slicer = self.check_slicing(slicer, return_spatial=True)
+
+        # Transform:
+        # sx  0  0 tx
+        #  0 sy  0 ty
+        #  0  0 sz tz
+        #  0  0  0  1
+        transform = np.eye(4, dtype=int)
+
+        for i, subslicer in enumerate(slicer):
+            if isinstance(subslicer, slice):
+                if subslicer.step == 0:
+                    raise ValueError("slice step cannot be 0")
+                transform[i, i] = subslicer.step if subslicer.step is not None else 1
+                transform[i, 3] = subslicer.start or 0
+            # If slicer is None, nothing to do
+
+        return self.img.affine.dot(transform)
+
+
+class SpatialImage(DataobjImage):
+    ''' Template class for volumetric (3D/4D) images '''
+    header_class = SpatialHeader
+    ImageSlicer = SpatialFirstSlicer
 
     def __init__(self, dataobj, affine, header=None,
                  extra=None, file_map=None):
@@ -477,69 +548,6 @@ def from_image(klass, img):
                      klass.header_class.from_header(img.header),
                      extra=img.extra.copy())
 
-    def _check_slicing(self, slicer, return_spatial=False):
-        ''' Canonicalize slicers and check for scalar indices in spatial dims
-
-        Parameters
-        ----------
-        slicer : object
-            something that can be used to slice an array as in
-            ``arr[sliceobj]``
-        return_spatial : bool
-            return only slices along spatial dimensions (x, y, z)
-
-        Returns
-        -------
-        slicer : object
-            Validated slicer object that will slice image's `dataobj`
-            without collapsing spatial dimensions
-        '''
-        slicer = canonical_slicers(slicer, self.shape)
-        spatial_slices = slicer[:3]
-        for subslicer in spatial_slices:
-            if subslicer is None:
-                raise IndexError("New axis not permitted in spatial dimensions")
-            elif isinstance(subslicer, int):
-                raise IndexError("Scalar indices disallowed in spatial dimensions; "
-                                 "Use `[x]` or `x:x+1`.")
-        return spatial_slices if return_spatial else slicer
-
-    def _slice_affine(self, slicer):
-        """ Retrieve affine for current image, if sliced by a given index
-
-        Applies scaling if down-sampling is applied, and adjusts the intercept
-        to account for any cropping.
-
-        Parameters
-        ----------
-        slicer : object
-            something that can be used to slice an array as in
-            ``arr[sliceobj]``
-
-        Returns
-        -------
-        affine : (4,4) ndarray
-            Affine with updated scale and intercept
-        """
-        slicer = self._check_slicing(slicer, return_spatial=True)
-
-        # Transform:
-        # sx  0  0 tx
-        #  0 sy  0 ty
-        #  0  0 sz tz
-        #  0  0  0  1
-        transform = np.eye(4, dtype=int)
-
-        for i, subslicer in enumerate(slicer):
-            if isinstance(subslicer, slice):
-                if subslicer.step == 0:
-                    raise ValueError("slice step cannot be 0")
-                transform[i, i] = subslicer.step if subslicer.step is not None else 1
-                transform[i, 3] = subslicer.start or 0
-            # If slicer is None, nothing to do
-
-        return self.affine.dot(transform)
-
     @property
     def slicer(self):
         """ Slicer object that returns cropped and subsampled images
@@ -558,11 +566,7 @@ def slicer(self):
 
         .. _aliasing: https://en.wikipedia.org/wiki/Aliasing
         """
-        from .imageclasses import spatial_axes_first
-        if not spatial_axes_first(self):
-            raise ValueError("Cannot predict position of spatial axes for "
-                             "Image type " + self.__class__.__name__)
-        return self.Slicer(self)
+        return self.ImageSlicer(self)
 
 
     def __getitem__(self, idx):