Refactor as_closest_canonical into transpose function

As per Matthew's comments, place the logic which re-orients
the data into a function in SpatialImage and override this
in Nifti1Pair with a version which updates dim_info.

Also add new test cases using AnalyzeImage so that we
cover both possibilities.

Signed-off-by: Mark Hymers <[email protected]>

Author: markhymers

nibabel/funcs.py

@@ -221,22 +221,9 @@ def as_closest_canonical(img, enforce_diag=False):
     # check if we are going to end up with something diagonal
     if enforce_diag and not _aff_is_diag(aff):
         raise OrientationError('Transformed affine is not diagonal')
-    # we need to transform the data
-    arr = img.get_data()
-    t_arr = apply_orientation(arr, ornt)
-    # Also apply the transform to the dim_info fields
-    new_hdr = img.header.copy()
-    new_dim = list(new_hdr.get_dim_info())
-    for idx, value in enumerate(new_dim):
-        # For each value, leave as None if it was that way,
-        # otherwise check where we have mapped it to
-        if value is None:
-            continue
-        new_dim[idx] = np.where(ornt[:, 0] == idx)[0]
-    new_hdr.set_dim_info(*new_dim)
-
-    return img.__class__(t_arr, out_aff, new_hdr)
 
+    # Get the image class to transform the data for us
+    return img.transpose(ornt, out_aff)
 
 def _aff_is_diag(aff):
     ''' Utility function returning True if affine is nearly diagonal '''

nibabel/nifti1.py

@@ -27,6 +27,7 @@
 from .spm99analyze import SpmAnalyzeHeader
 from .casting import have_binary128
 from .pydicom_compat import have_dicom, pydicom as pdcm
+from .orientations import apply_orientation
 
 # nifti1 flat header definition for Analyze-like first 348 bytes
 # first number in comments indicates offset in file header in bytes
@@ -1969,6 +1970,26 @@ def set_sform(self, affine, code=None, **kwargs):
             else:
                 self._affine[:] = self._header.get_best_affine()
 
+    def transpose(self, ornt, new_aff):
+        # Override the default SpatialImage method so that we update dim_info
+        t_arr = apply_orientation(self.get_data(), ornt)
+
+        # Also apply the transform to the dim_info fields
+        new_hdr = self.header.copy()
+        new_dim = list(new_hdr.get_dim_info())
+        for idx, value in enumerate(new_dim):
+            # For each value, leave as None if it was that way,
+            # otherwise check where we have mapped it to
+            if value is None:
+                continue
+            new_dim[idx] = np.where(ornt[:, 0] == idx)[0]
+
+        new_hdr.set_dim_info(*new_dim)
+
+        return self.__class__(t_arr, new_aff, new_hdr)
+
+
+
 
 class Nifti1Image(Nifti1Pair):
     """ Class for single file NIfTI1 format image

nibabel/spatialimages.py

@@ -141,6 +141,7 @@
 from .viewers import OrthoSlicer3D
 from .volumeutils import shape_zoom_affine
 from .deprecated import deprecate_with_version
+from .orientations import apply_orientation
 
 
 class HeaderDataError(Exception):
@@ -483,3 +484,28 @@ def orthoview(self):
         """
         return OrthoSlicer3D(self.dataobj, self.affine,
                              title=self.get_filename())
+
+
+    def transpose(self, ornt, new_aff):
+        """Apply an orientation change and return a new image
+
+        Parameters
+        ----------
+        ornt : (n,2) orientation array
+           orientation transform. ``ornt[N,1]` is flip of axis N of the
+           array implied by `shape`, where 1 means no flip and -1 means
+           flip.  For example, if ``N==0`` and ``ornt[0,1] == -1``, and
+           there's an array ``arr`` of shape `shape`, the flip would
+           correspond to the effect of ``np.flipud(arr)``.  ``ornt[:,0]`` is
+           the transpose that needs to be done to the implied array, as in
+           ``arr.transpose(ornt[:,0])``
+
+        Notes
+        -----
+        Subclasses should override this if they have additional requirements
+        when re-orienting an image.
+        """
+
+        t_arr = apply_orientation(self.get_data(), ornt)
+
+        return self.__class__(t_arr, new_aff, self.header)

nibabel/tests/test_funcs.py

@@ -12,6 +12,7 @@
 import numpy as np
 
 from ..funcs import concat_images, as_closest_canonical, OrientationError
+from ..analyze import AnalyzeImage
 from ..nifti1 import Nifti1Image
 from ..loadsave import save
 
@@ -128,8 +129,24 @@ def test_concat():
 
 
 def test_closest_canonical():
-    arr = np.arange(24).reshape((2, 3, 4, 1))
-    # no funky stuff, returns same thing
+    # Use 32-bit data so that the AnalyzeImage class doesn't complain
+    arr = np.arange(24).reshape((2, 3, 4, 1)).astype(np.int32)
+
+    # Test with an AnalyzeImage first
+    img = AnalyzeImage(arr, np.eye(4))
+    xyz_img = as_closest_canonical(img)
+    assert_true(img is xyz_img)
+
+    # And a case where the Analyze image has to be flipped
+    img = AnalyzeImage(arr, np.diag([-1, 1, 1, 1]))
+    xyz_img = as_closest_canonical(img)
+    assert_false(img is xyz_img)
+    out_arr = xyz_img.get_data()
+    assert_array_equal(out_arr, np.flipud(arr))
+
+    # Now onto the NIFTI cases (where dim_info also has to be updated)
+
+    # No funky stuff, returns same thing
     img = Nifti1Image(arr, np.eye(4))
     # set freq/phase/slice dim so that we can check that we
     # re-order them properly