RF: change to mapped_voxels as vox2out_vox input

Also refactor tests to be a little less repetive.

Author: matthew-brett

nibabel/spaces.py

@@ -12,6 +12,12 @@
 
 A voxel space can be expressed by a shape implying an array, where the axes are
 the axes of the array.
+
+A mapped voxel space (mapped voxels) is either:
+
+* an image, with attributes ``shape`` (the voxel space) and ``affine`` (the
+  mapping), or
+* a length 2 sequence with the same information (shape, affine).
 """
 
 from itertools import product
@@ -21,12 +27,11 @@
 from .affines import apply_affine
 
 
-def vox2out_vox(in_shape, in_affine, voxel_sizes=None):
-    """ output-aligned shape, affine for input voxels implied by `in_shape`
-
-    The input (voxel) space is given by `in_shape`
+def vox2out_vox(mapped_voxels, voxel_sizes=None):
+    """ output-aligned shape, affine for input implied by `mapped_voxels`
 
-    The mapping between input space and output space is `in_affine`
+    The input (voxel) space, and the affine mapping to output space, are given
+    in `mapped_voxels`.
 
     The output space is implied by the affine, we don't need to know what that
     is, we just return something with the same (implied) output space.
@@ -39,10 +44,11 @@ def vox2out_vox(in_shape, in_affine, voxel_sizes=None):
 
     Parameters
     ----------
-    in_shape : sequence
-        shape of implied input image voxel block. Up to length 3.
-    in_affine : (4, 4) array-like
-        affine mapping voxel coordinates in `in_shape` to output coordinates.
+    mapped_voxels : object or length 2 sequence
+        If object, has attributes ``shape`` giving input voxel shape, and
+        ``affine`` giving mapping of input voxels to output space. If length 2
+        sequence, elements are (shape, affine) with same meaning as above. The
+        affine is a (4, 4) array-like.
     voxel_sizes : None or sequence
         Gives the diagonal entries of `output_affine` (except the trailing 1
         for the homogenous coordinates) (``output_affine == np.diag(voxel_sizes
@@ -53,14 +59,18 @@ def vox2out_vox(in_shape, in_affine, voxel_sizes=None):
     output_shape : sequence
         Shape of output image that has voxel axes aligned to original image
         output space axes, and encloses all the voxel data from the original
-        image implied by `in_shape`.
+        image implied by input shape.
     output_affine : (4, 4) array
         Affine of output image that has voxel axes aligned to the output axes
-        implied by `in_affine`. Top-left 3 x 3 part of affine is diagonal with
+        implied by input affine. Top-left 3 x 3 part of affine is diagonal with
         all positive entries.  The entries come from `voxel_sizes` if
         specified, or are all 1.  If the image is < 3D, then the missing
         dimensions will have a 1 in the matching diagonal.
     """
+    try:
+        in_shape, in_affine = mapped_voxels.shape, mapped_voxels.affine
+    except AttributeError:
+        in_shape, in_affine = mapped_voxels
     n_axes = len(in_shape)
     if n_axes > 3:
         raise ValueError('This function can only deal with 3D images')

nibabel/tests/test_spaces.py

@@ -5,7 +5,8 @@
 import numpy.linalg as npl
 
 from ..spaces import vox2out_vox, slice2volume
-from ..affines import apply_affine
+from ..affines import apply_affine, from_matvec
+from ..nifti1 import Nifti1Image
 from ..eulerangles import euler2mat
 
 
@@ -36,71 +37,65 @@ def assert_all_in(in_shape, in_affine, out_shape, out_affine):
 
 def test_vox2out_vox():
     # Test world space bounding box
-    shape, aff = vox2out_vox((2, 3, 4), np.eye(4))
+    # Test basic case, identity, no voxel sizes passed
+    shape, aff = vox2out_vox(((2, 3, 4), np.eye(4)))
     assert_array_equal(shape, (2, 3, 4))
-    assert_true(isinstance(shape, tuple))
-    assert_true(isinstance(shape[0], int))
     assert_array_equal(aff, np.eye(4))
-    assert_all_in((2, 3, 4), np.eye(4), shape, aff)
-    shape, aff = vox2out_vox((2, 3, 4), np.diag([-1, 1, 1, 1]))
-    assert_array_equal(shape, (2, 3, 4))
-    assert_array_equal(aff, [[1, 0, 0, -1], # axis reversed -> -ve offset
-                             [0, 1, 0, 0],
-                             [0, 0, 1, 0],
-                             [0, 0, 0, 1]])
-    assert_all_in((2, 3, 4), np.diag([-1, 1, 1, 1]), shape, aff)
-    # zooms for affine > 1 -> larger grid with default 1mm output voxels
-    shape, aff = vox2out_vox((2, 3, 4), np.diag([4, 5, 6, 1]))
-    assert_array_equal(shape, (5, 11, 19))
-    assert_array_equal(aff, np.eye(4))
-    assert_all_in((2, 3, 4), np.diag([4, 5, 6, 1]), shape, aff)
-    # set output voxels to be same size as input. back to original shape
-    shape, aff = vox2out_vox((2, 3, 4), np.diag([4, 5, 6, 1]), (4, 5, 6))
-    assert_array_equal(shape, (2, 3, 4))
-    assert_array_equal(aff, np.diag([4, 5, 6, 1]))
-    assert_all_in((2, 3, 4), np.diag([4, 5, 6, 1]), shape, aff)
-    # zero point preserved
-    in_aff = [[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]]
-    shape, aff = vox2out_vox((2, 3, 4), in_aff)
-    assert_array_equal(shape, (2, 3, 4))
-    assert_array_equal(aff, in_aff)
-    assert_all_in((2, 3, 4), in_aff, shape, aff)
-    in_aff = [[1, 0, 0, -1], [0, 1, 0, -2], [0, 0, 1, -3], [0, 0, 0, 1]]
-    shape, aff = vox2out_vox((2, 3, 4), in_aff)
-    assert_array_equal(shape, (2, 3, 4))
-    assert_array_equal(aff, in_aff)
-    assert_all_in((2, 3, 4), in_aff, shape, aff)
-    # rotation around third axis
-    in_aff = np.eye(4)
-    in_aff[:3, :3] = euler2mat(np.pi / 4)
-    shape, aff = vox2out_vox((2, 3, 4), in_aff)
-    # x diff, y diff now 3 cos pi / 4 == 2.12, ceil to 3, add 1
-    assert_array_equal(shape, (4, 4, 4))
-    # most negative x now 2 cos pi / 4
-    assert_almost_equal(aff, [[1, 0, 0, -2 * np.cos(np.pi / 4)],
-                              [0, 1, 0, 0],
-                              [0, 0, 1, 0],
-                              [0, 0, 0, 1]])
-    assert_all_in((2, 3, 4), in_aff, shape, aff)
+    # Some affines as input to the tests
+    trans_123 = [[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]]
+    trans_m123 = [[1, 0, 0, -1], [0, 1, 0, -2], [0, 0, 1, -3], [0, 0, 0, 1]]
+    rot_3 = from_matvec(euler2mat(np.pi / 4), [0, 0, 0])
+    for in_shape, in_aff, vox, out_shape, out_aff in (
+        # Identity
+        ((2, 3, 4), np.eye(4), None, (2, 3, 4), np.eye(4)),
+        # Flip first axis
+        ((2, 3, 4), np.diag([-1, 1, 1, 1]), None,
+         (2, 3, 4), [[1, 0, 0, -1], # axis reversed -> -ve offset
+                     [0, 1, 0, 0],
+                     [0, 0, 1, 0],
+                     [0, 0, 0, 1]]),
+        # zooms for affine > 1 -> larger grid with default 1mm output voxels
+        ((2, 3, 4), np.diag([4, 5, 6, 1]), None,
+         (5, 11, 19), np.eye(4)),
+        # set output voxels to be same size as input. back to original shape
+        ((2, 3, 4), np.diag([4, 5, 6, 1]), (4, 5, 6),
+         (2, 3, 4), np.diag([4, 5, 6, 1])),
+        # Translation preserved in output
+        ((2, 3, 4), trans_123, None,
+         (2, 3, 4), trans_123),
+        ((2, 3, 4), trans_m123, None,
+         (2, 3, 4), trans_m123),
+        # rotation around 3rd axis
+        ((2, 3, 4), rot_3, None,
+         # x diff, y diff now 3 cos pi / 4 == 2.12, ceil to 3, add 1
+         # most negative x now 2 cos pi / 4
+         (4, 4, 4), [[1, 0, 0, -2 * np.cos(np.pi / 4)],
+                     [0, 1, 0, 0],
+                     [0, 0, 1, 0],
+                     [0, 0, 0, 1]]),
+        # Less than 3 axes
+        ((2, 3), np.eye(4), None,
+         (2, 3),  np.eye(4)),
+        ((2,), np.eye(4), None,
+         (2,),  np.eye(4)),
+        # Number of voxel sizes matches length
+        ((2, 3), np.diag([4, 5, 6, 1]), (4, 5),
+         (2, 3), np.diag([4, 5, 1, 1])),
+    ):
+        img = Nifti1Image(np.ones(in_shape), in_aff)
+        for input in ((in_shape, in_aff), img):
+            shape, aff = vox2out_vox(input, vox)
+            assert_all_in(in_shape, in_aff, shape, aff)
+            assert_equal(shape, out_shape)
+            assert_almost_equal(aff, out_aff)
+            assert_true(isinstance(shape, tuple))
+            assert_true(isinstance(shape[0], int))
     # Enforce number of axes
-    assert_raises(ValueError, vox2out_vox, (2, 3, 4, 5), np.eye(4))
-    assert_raises(ValueError, vox2out_vox, (2, 3, 4, 5, 6), np.eye(4))
-    # Less than 3 is OK
-    shape, aff = vox2out_vox((2, 3), np.eye(4))
-    assert_array_equal(shape, (2, 3))
-    assert_array_equal(aff, np.eye(4))
-    assert_all_in((2, 3), np.eye(4), shape, aff)
-    shape, aff = vox2out_vox((2,), np.eye(4))
-    assert_array_equal(shape, (2,))
-    assert_array_equal(aff, np.eye(4))
-    assert_all_in((2,), np.eye(4), shape, aff)
-    # Number of voxel sizes matches length
-    shape, aff = vox2out_vox((2, 3), np.diag([4, 5, 6, 1]), (4, 5))
-    assert_array_equal(shape, (2, 3))
-    assert_array_equal(aff, np.diag([4, 5, 1, 1]))
+    assert_raises(ValueError, vox2out_vox, ((2, 3, 4, 5), np.eye(4)))
+    assert_raises(ValueError, vox2out_vox, ((2, 3, 4, 5, 6), np.eye(4)))
     # Voxel sizes must be positive
-    assert_raises(ValueError, vox2out_vox, (2, 3, 4), np.eye(4), [-1, 1, 1])
-    assert_raises(ValueError, vox2out_vox, (2, 3, 4), np.eye(4), [1, 0, 1])
+    assert_raises(ValueError, vox2out_vox, ((2, 3, 4), np.eye(4), [-1, 1, 1]))
+    assert_raises(ValueError, vox2out_vox, ((2, 3, 4), np.eye(4), [1, 0, 1]))
 
 
 def test_slice2volume():