TEST: Add units specification to tests

Author: effigies

nibabel/analyze.py

@@ -402,7 +402,7 @@ def from_header(klass, header=None, check=True):
                                      klass))
         obj.set_data_dtype(header.get_data_dtype())
         obj.set_data_shape(header.get_data_shape())
-        obj.set_zooms(header.get_zooms())
+        obj.set_zooms(header.get_zooms(units='raw'))
         if check:
             obj.check_fix()
         return obj

nibabel/nifti1.py

@@ -785,7 +785,7 @@ def get_data_shape(self):
 
         Expanding number of dimensions gets default zooms
 
-        >>> hdr.get_zooms()
+        >>> hdr.get_zooms(units='canonical')
         (1.0, 1.0, 1.0)
 
         Notes

nibabel/tests/test_analyze.py

@@ -93,7 +93,8 @@ def test_general_init(self):
         assert_array_equal(np.diag(hdr.get_base_affine()),
                            [-1, 1, 1, 1])
         # But zooms only go with number of dimensions
-        assert_equal(hdr.get_zooms(), (1.0,))
+        assert_equal(hdr.get_zooms(units='raw'), (1.0,))
+        assert_equal(hdr.get_zooms(units='canonical'), (1.0,))
 
     def test_header_size(self):
         assert_equal(self.header_class.template_dtype.itemsize, self.sizeof_hdr)
@@ -440,7 +441,8 @@ def test_data_shape_zooms_affine(self):
             else:
                 assert_equal(hdr.get_data_shape(), (0,))
             # Default zoom - for 3D - is 1(())
-            assert_equal(hdr.get_zooms(), (1,) * L)
+            assert_equal(hdr.get_zooms(units='raw'), (1,) * L)
+            assert_equal(hdr.get_zooms(units='canonical'), (1,) * L)
             # errors if zooms do not match shape
             if len(shape):
                 assert_raises(HeaderDataError,
@@ -462,11 +464,14 @@ def test_data_shape_zooms_affine(self):
         hdr = self.header_class()
         hdr.set_data_shape((1, 2, 3))
         hdr.set_zooms((4, 5, 6))
-        assert_array_equal(hdr.get_zooms(), (4, 5, 6))
+        assert_array_equal(hdr.get_zooms(units='raw'), (4, 5, 6))
+        assert_array_equal(hdr.get_zooms(units='canonical'), (4, 5, 6))
         hdr.set_data_shape((1, 2))
-        assert_array_equal(hdr.get_zooms(), (4, 5))
+        assert_array_equal(hdr.get_zooms(units='raw'), (4, 5))
+        assert_array_equal(hdr.get_zooms(units='canonical'), (4, 5))
         hdr.set_data_shape((1, 2, 3))
-        assert_array_equal(hdr.get_zooms(), (4, 5, 1))
+        assert_array_equal(hdr.get_zooms(units='raw'), (4, 5, 1))
+        assert_array_equal(hdr.get_zooms(units='canonical'), (4, 5, 1))
         # Setting zooms changes affine
         assert_array_equal(np.diag(hdr.get_base_affine()),
                            [-4, 5, 1, 1])
@@ -536,12 +541,13 @@ def get_data_dtype(self): return np.dtype('i2')
 
             def get_data_shape(self): return (5, 4, 3)
 
-            def get_zooms(self): return (10.0, 9.0, 8.0)
+            def get_zooms(self, units=None, raise_unknown=None): return (10.0, 9.0, 8.0)
         converted = klass.from_header(C())
         assert_true(isinstance(converted, klass))
         assert_equal(converted.get_data_dtype(), np.dtype('i2'))
         assert_equal(converted.get_data_shape(), (5, 4, 3))
-        assert_equal(converted.get_zooms(), (10.0, 9.0, 8.0))
+        assert_equal(converted.get_zooms(units='raw'), (10.0, 9.0, 8.0))
+        assert_equal(converted.get_zooms(units='canonical'), (10.0, 9.0, 8.0))
 
     def test_base_affine(self):
         klass = self.header_class
@@ -641,7 +647,7 @@ def get_data_shape(self):
 
         class H4(H3):
 
-            def get_zooms(self):
+            def get_zooms(self, units=None, raise_unknown=None):
                 return 4., 5., 6.
         exp_hdr = klass()
         exp_hdr.set_data_dtype(np.dtype('u1'))

nibabel/tests/test_nifti1.py

@@ -852,11 +852,11 @@ def test_set_qform(self):
         img.set_qform(new_affine, 1, update_affine=False)
         assert_array_almost_equal(img.affine, aff_affine)
         # Clear qform using None, zooms unchanged
-        assert_array_almost_equal(hdr.get_zooms(), [1.1, 1.1, 1.1])
+        assert_array_almost_equal(hdr.get_zooms(units='raw'), [1.1, 1.1, 1.1])
         img.set_qform(None)
         qaff, code = img.get_qform(coded=True)
         assert_equal((qaff, code), (None, 0))
-        assert_array_almost_equal(hdr.get_zooms(), [1.1, 1.1, 1.1])
+        assert_array_almost_equal(hdr.get_zooms(units='raw'), [1.1, 1.1, 1.1])
         # Best affine similarly
         assert_array_almost_equal(img.affine, hdr.get_best_affine())
         # If sform is not set, qform should update affine
@@ -911,9 +911,9 @@ def test_set_sform(self):
         assert_array_almost_equal(img.affine, aff_affine)
         # zooms do not get updated when qform is 0
         assert_array_almost_equal(img.get_qform(), orig_aff)
-        assert_array_almost_equal(hdr.get_zooms(), [2.2, 3.3, 4.3])
+        assert_array_almost_equal(hdr.get_zooms(units='raw'), [2.2, 3.3, 4.3])
         img.set_qform(None)
-        assert_array_almost_equal(hdr.get_zooms(), [2.2, 3.3, 4.3])
+        assert_array_almost_equal(hdr.get_zooms(units='raw'), [2.2, 3.3, 4.3])
         # Set sform using new_affine when qform is set
         img.set_qform(qform_affine, 1)
         img.set_sform(new_affine, 1)
@@ -922,7 +922,7 @@ def test_set_sform(self):
         assert_array_almost_equal(saff, new_affine)
         assert_array_almost_equal(img.affine, new_affine)
         # zooms follow qform
-        assert_array_almost_equal(hdr.get_zooms(), [1.2, 1.2, 1.2])
+        assert_array_almost_equal(hdr.get_zooms(units='raw'), [1.2, 1.2, 1.2])
         # Clear sform using None, best_affine should fall back on qform
         img.set_sform(None)
         assert_equal(hdr['sform_code'], 0)
@@ -1010,15 +1010,15 @@ def test_load_pixdims(self):
         # Check qform, sform, pixdims are the same
         assert_array_equal(img_hdr.get_qform(), qaff)
         assert_array_equal(img_hdr.get_sform(), saff)
-        assert_array_equal(img_hdr.get_zooms(), [2, 3, 4])
+        assert_array_equal(img_hdr.get_zooms(units='raw'), [2, 3, 4])
         # Save to stringio
         re_simg = bytesio_round_trip(simg)
         assert_array_equal(re_simg.get_data(), arr)
         # Check qform, sform, pixdims are the same
         rimg_hdr = re_simg.header
         assert_array_equal(rimg_hdr.get_qform(), qaff)
         assert_array_equal(rimg_hdr.get_sform(), saff)
-        assert_array_equal(rimg_hdr.get_zooms(), [2, 3, 4])
+        assert_array_equal(rimg_hdr.get_zooms(units='raw'), [2, 3, 4])
 
     def test_affines_init(self):
         # Test we are doing vaguely spec-related qform things.  The 'spec' here
@@ -1032,20 +1032,20 @@ def test_affines_init(self):
         hdr = img.header
         assert_equal(hdr['qform_code'], 0)
         assert_equal(hdr['sform_code'], 2)
-        assert_array_equal(hdr.get_zooms(), [2, 3, 4])
+        assert_array_equal(hdr.get_zooms(units='raw'), [2, 3, 4])
         # This is also true for affines with header passed
         qaff = np.diag([3, 4, 5, 1])
         saff = np.diag([6, 7, 8, 1])
         hdr.set_qform(qaff, code='scanner')
         hdr.set_sform(saff, code='talairach')
-        assert_array_equal(hdr.get_zooms(), [3, 4, 5])
+        assert_array_equal(hdr.get_zooms(units='raw'), [3, 4, 5])
         img = IC(arr, aff, hdr)
         new_hdr = img.header
         # Again affine is sort of anonymous space
         assert_equal(new_hdr['qform_code'], 0)
         assert_equal(new_hdr['sform_code'], 2)
         assert_array_equal(new_hdr.get_sform(), aff)
-        assert_array_equal(new_hdr.get_zooms(), [2, 3, 4])
+        assert_array_equal(new_hdr.get_zooms(units='raw'), [2, 3, 4])
         # But if no affine passed, codes and matrices stay the same
         img = IC(arr, None, hdr)
         new_hdr = img.header
@@ -1054,7 +1054,7 @@ def test_affines_init(self):
         assert_equal(new_hdr['sform_code'], 3)  # Still talairach
         assert_array_equal(new_hdr.get_sform(), saff)
         # Pixdims as in the original header
-        assert_array_equal(new_hdr.get_zooms(), [3, 4, 5])
+        assert_array_equal(new_hdr.get_zooms(units='raw'), [3, 4, 5])
 
     def test_read_no_extensions(self):
         IC = self.image_class