Merge pull request #74 from matthew-brett/nifti-codes-cycle-fix

Nifti codes cycle fix

mrbago and I spent some time rolling the options around and this seemed the best stop-gap solution at least.

Author: matthew-brett

nibabel/analyze.py

@@ -1053,12 +1053,20 @@ def update_header(self):
         (1.0, 2.0, 3.0)
         '''
         hdr = self._header
+        # We need to update the header if the data shape has changed.  It's a
+        # bit difficult to change the data shape using the standard API, but
+        # maybe it happened
         if not self._data is None:
             hdr.set_data_shape(self._data.shape)
-        if not self._affine is None:
-            RZS = self._affine[:3, :3]
-            vox = np.sqrt(np.sum(RZS * RZS, axis=0))
-            hdr['pixdim'][1:4] = vox
+        # If the affine is not None, and it is different from the main affine in
+        # the header, update the heaader
+        if self._affine is None:
+            return
+        if np.all(self._affine == hdr.get_best_affine()):
+            return
+        RZS = self._affine[:3, :3]
+        vox = np.sqrt(np.sum(RZS * RZS, axis=0))
+        hdr['pixdim'][1:4] = vox
 
 
 load = AnalyzeImage.load

nibabel/nifti1.py

@@ -1428,14 +1428,16 @@ def update_header(self):
         super(Nifti1Pair, self).update_header()
         hdr = self._header
         hdr['magic'] = 'ni1'
-        if not self._affine is None:
-            # Set affine into sform
-            hdr.set_sform(self._affine, code='aligned')
-            # Make qform 'unknown', set voxel sizes from affine
-            hdr['qform_code'] = 0
-            RZS = self._affine[:3, :3]
-            zooms = np.sqrt(np.sum(RZS * RZS, axis=0))
-            hdr['pixdim'][1:4] = zooms
+        # If the affine is not None, and it is different from the main affine in
+        # the header, update the heaader
+        if self._affine is None:
+            return
+        if np.all(self._affine == hdr.get_best_affine()):
+            return
+        # Set affine into sform with default code
+        hdr.set_sform(self._affine, code='aligned')
+        # Make qform 'unknown'
+        hdr.set_qform(self._affine, code='unknown')
 
 
 class Nifti1Image(Nifti1Pair):

nibabel/spatialimages.py

@@ -301,7 +301,8 @@ def __init__(self, data, affine, header=None,
             # Check that affine is array-like 4,4.  Maybe this is too strict at
             # this abstract level, but so far I think all image formats we know
             # do need 4,4.
-            affine = np.asarray(affine)
+            # Copy affine to  isolate from environment
+            affine = np.array(affine, copy=True)
             if not affine.shape == (4,4):
                 raise ValueError('Affine should be shape 4,4')
         self._affine = affine

nibabel/tests/test_analyze.py

@@ -532,6 +532,37 @@ def test_affine_44(self):
         # Not OK - affine wrong shape
         assert_raises(ValueError, IC, data, np.diag([2, 3, 4]))
 
+    def test_header_updating(self):
+        # Only update on changes
+        img_klass = self.image_class
+        # With a None affine - don't overwrite zooms
+        img = img_klass(np.zeros((2,3,4)), None)
+        hdr = img.get_header()
+        hdr.set_zooms((4,5,6))
+        # Save / reload using bytes IO objects
+        for key, value in img.file_map.items():
+            value.fileobj = BytesIO()
+        img.to_file_map()
+        hdr_back = img.from_file_map(img.file_map).get_header()
+        assert_array_equal(hdr_back.get_zooms(), (4,5,6))
+        # With a real affine, update zooms
+        img = img_klass(np.zeros((2,3,4)), np.diag([2,3,4,1]), hdr)
+        hdr = img.get_header()
+        assert_array_equal(hdr.get_zooms(), (2, 3, 4))
+        # Modify affine in-place? Update on save.
+        img.get_affine()[0,0] = 9
+        for key, value in img.file_map.items():
+            value.fileobj = BytesIO()
+        img.to_file_map()
+        hdr_back = img.from_file_map(img.file_map).get_header()
+        assert_array_equal(hdr.get_zooms(), (9, 3, 4))
+        # Modify data in-place?  Update on save
+        data = img.get_data()
+        data.shape = (3, 2, 4)
+        img.to_file_map()
+        img_back = img.from_file_map(img.file_map)
+        assert_array_equal(img_back.shape, (3, 2, 4))
+
 
 def test_unsupported():
     # analyze does not support uint32

nibabel/tests/test_nifti1.py

@@ -174,11 +174,46 @@ def test_binblock_is_file(self):
 
 
 class TestNifti1Image(tana.TestAnalyzeImage):
-    # class for testing images
+    # Run analyze-flavor spatialimage tests
     image_class = Nifti1Image
 
-
-class TestNifti1Pair(tana.TestAnalyzeImage):
+    def _qform_rt(self, img):
+        # Round trip image after setting qform, sform codes
+        hdr = img.get_header()
+        hdr['qform_code'] = 3
+        hdr['sform_code'] = 4
+        # Save / reload using bytes IO objects
+        for key, value in img.file_map.items():
+            value.fileobj = BytesIO()
+        img.to_file_map()
+        return img.from_file_map(img.file_map)
+
+    def test_qform_cycle(self):
+        # Qform load save cycle
+        img_klass = self.image_class
+        # None affine
+        img = img_klass(np.zeros((2,3,4)), None)
+        hdr_back = self._qform_rt(img).get_header()
+        assert_equal(hdr_back['qform_code'], 3)
+        assert_equal(hdr_back['sform_code'], 4)
+        # Try non-None affine
+        img = img_klass(np.zeros((2,3,4)), np.eye(4))
+        hdr_back = self._qform_rt(img).get_header()
+        assert_equal(hdr_back['qform_code'], 3)
+        assert_equal(hdr_back['sform_code'], 4)
+        # Modify affine in-place - does it hold?
+        img.get_affine()[0,0] = 9
+        img.to_file_map()
+        img_back = img.from_file_map(img.file_map)
+        exp_aff = np.diag([9,1,1,1])
+        assert_array_equal(img_back.get_affine(), exp_aff)
+        hdr_back = img.get_header()
+        assert_array_equal(hdr_back.get_sform(), exp_aff)
+        assert_array_equal(hdr_back.get_qform(), exp_aff)
+
+
+class TestNifti1Pair(TestNifti1Image):
+    # Run analyze-flavor spatialimage tests
     image_class = Nifti1Pair
 
 

nibabel/tests/test_spatialimages.py

@@ -177,6 +177,23 @@ class TestSpatialImage(TestCase):
     # class for testing images
     image_class = SpatialImage
 
+    def test_isolation(self):
+        # Test image isolated from external changes to header and affine
+        img_klass = self.image_class
+        arr = np.arange(3, dtype=np.int16)
+        aff = np.eye(4)
+        img = img_klass(arr, aff)
+        assert_array_equal(img.get_affine(), aff)
+        aff[0,0] = 99
+        assert_false(np.all(img.get_affine() == aff))
+        # header, created by image creation
+        ihdr = img.get_header()
+        # Pass it back in
+        img = img_klass(arr, aff, ihdr)
+        # Check modifying header outside does not modify image
+        ihdr.set_zooms((4,))
+        assert_not_equal(img.get_header(), ihdr)
+
     def test_images(self):
         # Assumes all possible images support int16
         # See https://github.com/nipy/nibabel/issues/58

nibabel/tests/test_spm99analyze.py

@@ -105,6 +105,10 @@ class TestSpm99AnalyzeImage(test_analyze.TestAnalyzeImage):
         test_analyze.TestAnalyzeImage.test_data_hdr_cache
     ))
 
+    test_header_updating = (scipy_skip(
+        test_analyze.TestAnalyzeImage.test_header_updating
+    ))
+
     @scipy_skip
     def test_mat_read(self):
         # Test mat file reading and writing for the SPM analyze types