Merge branch 'ppc-fixes-rebased' into main-master

* ppc-fixes-rebased: (22 commits)
  RF - correct name of timeseries option and add misspelled alias
  BF - encode string data as utf-8 on save, matching specified encoding
  BF+TEST - set data array datatype correctly
  RF - move datatype def and intents back to nifti1 to reduce duplication
  RF - added ability for make_dt_codes to include niistring field, with tests
  RF - increase use of Recoder; clean whitespace; use class in classmethod
  RF - klass used in classmethod (in case of inheritance); replace mutable default arg
  BF - use InTemporaryDirectory for gifti round trip test
  RF - refactoring gifti code etc use, cleaning whitespace for PEP8
  Removed debug messages again. Test pass on Mac
  BF - Correct save endianness
  BF - Update endianness while reading
  BF - Update write logic
  Possible fix
  Print
  Print
  Test
  Add more test message
  BF - Add print statements
  BF - First byteswap fix
  ...

Author: matthew-brett

nibabel/gifti/gifti.py

@@ -42,7 +42,7 @@ def write(image, filename):
         A GiftiImage instance to store 
     filename : string
         Filename to store the Gifti file to
-
+       
     Returns
     -------
     None
@@ -72,7 +72,10 @@ def write(image, filename):
         Time Series
     .topo.gii
         Topology
+        
+    The Gifti file is stored in endian convention of the current machine.
     """
-    f = open(filename, 'w')
-    f.write(image.to_xml())
+    f = open(filename, 'wb')
+    # Our giftis are always utf-8 encoded - see GiftiImage.to_xml
+    f.write(image.to_xml().encode('utf-8'))
     f.close()

nibabel/gifti/giftiio.py

@@ -8,15 +8,16 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 
 import base64
+import sys
 import zlib
 from StringIO import StringIO
 from xml.parsers.expat import ParserCreate, ExpatError
 
 import numpy as np
 
+from ..nifti1 import data_type_codes, xform_codes, intent_codes
 from . import gifti as gi
-from .util import (data_type_codes, xform_codes, intent_codes,
-                   array_index_order_codes, gifti_encoding_codes,
+from .util import (array_index_order_codes, gifti_encoding_codes,
                    gifti_endian_codes)
 
 
@@ -25,32 +26,24 @@
 
 def read_data_block(encoding, endian, ordering, datatype, shape, data):
     """ Tries to unzip, decode, parse the funny string data """
-    if ordering == 1:
-        ord = 'C'
-    elif ordering == 2:
-        ord = 'F'
-    else:
-        ord = 'C'
-
-    if encoding == 1:
+    ord = array_index_order_codes.npcode[ordering]
+    enclabel = gifti_encoding_codes.label[encoding]
+    if enclabel == 'ASCII':
         # GIFTI_ENCODING_ASCII
         c = StringIO(data)
         da = np.loadtxt(c)
         da = da.astype(data_type_codes.type[datatype])
+        # independent of the endianness
         return da
-
-    elif encoding == 2:
+    elif enclabel == 'B64BIN':
         # GIFTI_ENCODING_B64BIN
         dec = base64.decodestring(data.encode('ascii'))
         dt = data_type_codes.type[datatype]
         sh = tuple(shape)
         newarr = np.fromstring(dec, dtype = dt)
-        if len(newarr.shape) == len(sh):
-            return newarr
-        else:
-            return newarr.reshape(sh, order = ord)
-
-    elif encoding == 3:
+        if len(newarr.shape) != len(sh):
+            newarr = newarr.reshape(sh, order = ord)
+    elif enclabel == 'B64GZ':
         # GIFTI_ENCODING_B64GZ
         # convert to bytes array for python 3.2
         # http://diveintopython3.org/strings.html#byte-arrays
@@ -59,16 +52,20 @@ def read_data_block(encoding, endian, ordering, datatype, shape, data):
         dt = data_type_codes.type[datatype]
         sh = tuple(shape)
         newarr = np.fromstring(zdec, dtype = dt)
-        if len(newarr.shape) == len(sh):
-            return newarr
-        else:
-            return newarr.reshape(sh, order = ord)
-
-    elif encoding == 4:
+        if len(newarr.shape) != len(sh):
+            newarr = newarr.reshape(sh, order = ord)
+    elif enclabel == 'External':
         # GIFTI_ENCODING_EXTBIN
         raise NotImplementedError("In what format are the external files?")
     else:
         return 0
+    # check if we need to byteswap
+    required_byteorder = gifti_endian_codes.byteorder[endian]
+    if (required_byteorder in ('big', 'little') and
+        required_byteorder != sys.byteorder):
+        newarr = newarr.byteswap()
+    return newarr
+
 
 class Outputter(object):
 
@@ -95,11 +92,10 @@ def initialize(self):
         # where to write CDATA:
         self.write_to = None
         self.img = None
-    
+
     def StartElementHandler(self, name, attrs):
         if DEBUG_PRINT:
             print 'Start element:\n\t', repr(name), attrs
-        
         if name == 'GIFTI':
             # create gifti image
             self.img = gi.GiftiImage()
@@ -110,7 +106,6 @@ def StartElementHandler(self, name, attrs):
                 self.count_da = False
 
             self.fsm_state.append('GIFTI')
-
         elif name == 'MetaData':
             self.fsm_state.append('MetaData')
 
@@ -120,28 +115,22 @@ def StartElementHandler(self, name, attrs):
             else:
                 # otherwise, create darray.meta
                 self.meta_da = gi.GiftiMetaData()
-                
-
         elif name == 'MD':
             self.nvpair = gi.GiftiNVPairs()
             self.fsm_state.append('MD')
-
         elif name == 'Name':
             if self.nvpair == None:
                 raise ExpatError
             else:
                 self.write_to = 'Name'
-
         elif name == 'Value':
             if self.nvpair == None:
                 raise ExpatError
             else:
                 self.write_to = 'Value'
-
         elif name == 'LabelTable':
             self.lata = gi.GiftiLabelTable()
             self.fsm_state.append('LabelTable')
-
         elif name == 'Label':
             self.label = gi.GiftiLabel()
             if "Index" in attrs:
@@ -154,9 +143,7 @@ def StartElementHandler(self, name, attrs):
                 self.label.blue = float(attrs["Blue"])
             if "Alpha" in attrs:
                 self.label.alpha = float(attrs["Alpha"])
-            
             self.write_to = 'Label'
-
         elif name == 'DataArray':
             self.da = gi.GiftiDataArray()
             if "Intent" in attrs:
@@ -171,7 +158,6 @@ def StartElementHandler(self, name, attrs):
                 di = "Dim%s" % str(i)
                 if di in attrs:
                     self.da.dims.append(int(attrs[di]))
-
             # dimensionality has to correspond to the number of DimX given
             assert len(self.da.dims) == self.da.num_dim
             if "Encoding" in attrs:
@@ -182,49 +168,39 @@ def StartElementHandler(self, name, attrs):
                 self.da.ext_fname = attrs["ExternalFileName"]
             if "ExternalFileOffset" in attrs:
                 self.da.ext_offset = attrs["ExternalFileOffset"]
-            
             self.img.darrays.append(self.da)
             self.fsm_state.append('DataArray')
-
         elif name == 'CoordinateSystemTransformMatrix':
             self.coordsys = gi.GiftiCoordSystem()
             self.img.darrays[-1].coordsys = self.coordsys
             self.fsm_state.append('CoordinateSystemTransformMatrix')
-
         elif name == 'DataSpace':
             if self.coordsys == None:
                 raise ExpatError
             else:
                 self.write_to = 'DataSpace'
-
         elif name == 'TransformedSpace':
             if self.coordsys == None:
                 raise ExpatError
             else:
                 self.write_to = 'TransformedSpace'
-
         elif name == 'MatrixData':
             if self.coordsys == None:
                 raise ExpatError
             else:
                 self.write_to = 'MatrixData'
-
         elif name == 'Data':
             self.write_to = 'Data'
 
-
     def EndElementHandler(self, name):
         if DEBUG_PRINT:
             print 'End element:\n\t', repr(name)
-
         if name == 'GIFTI':
             # remove last element of the list
             self.fsm_state.pop()
             # assert len(self.fsm_state) == 0
-
         elif name == 'MetaData':
             self.fsm_state.pop()
-            
             if len(self.fsm_state) == 1:
                 # only Gifti there, so this was a closing global
                 # metadata tag
@@ -233,26 +209,19 @@ def EndElementHandler(self, name):
             else:
                 self.img.darrays[-1].meta = self.meta_da
                 self.meta_da = None
-                
         elif name == 'MD':
             self.fsm_state.pop()
-
             if not self.meta_global is None and self.meta_da == None:
                 self.meta_global.data.append(self.nvpair)
-            
             elif not self.meta_da is None and self.meta_global == None:
                 self.meta_da.data.append(self.nvpair)
-                
             # remove reference
             self.nvpair = None
-
         elif name == 'LabelTable':
             self.fsm_state.pop()
-
             # add labeltable
             self.img.labeltable = self.lata
             self.lata = None
-
         elif name == 'DataArray':
             if self.count_da:
                 self.img.numDA += 1
@@ -277,9 +246,7 @@ def EndElementHandler(self, name):
             self.label = None
             self.write_to = None
 
-
     def CharacterDataHandler(self, data):
-
         if self.write_to == 'Name':
             data = data.strip()
             self.nvpair.name = data
@@ -302,30 +269,41 @@ def CharacterDataHandler(self, data):
             da_tmp.data = read_data_block(da_tmp.encoding, da_tmp.endian, \
                                           da_tmp.ind_ord, da_tmp.datatype, \
                                           da_tmp.dims, data)
+            # update the endianness according to the
+            # current machine setting
+            self.endian = gifti_endian_codes.code[sys.byteorder]
         elif self.write_to == 'Label':
             self.label.label = data.strip()
 
 
 def parse_gifti_file(fname, buffer_size = 35000000):
-
+    """ Parse gifti file named `fname`, return image
+
+    Parameters
+    ----------
+    fname : str
+        filename of gifti file
+    buffer_size: int, optional
+        size of read buffer.
+
+    Returns
+    -------
+    img : gifti image
+    """
     datasource = open(fname,'rb')
-    
     parser = ParserCreate()
     parser.buffer_text = True
     parser.buffer_size = buffer_size
-    HANDLER_NAMES = [
-    'StartElementHandler', 'EndElementHandler',
-    'CharacterDataHandler',
-    ]
+    HANDLER_NAMES = ['StartElementHandler',
+                     'EndElementHandler',
+                     'CharacterDataHandler']
     out = Outputter()
     for name in HANDLER_NAMES:
         setattr(parser, name, getattr(out, name))
-
     try:
         parser.ParseFile(datasource)
     except ExpatError:
         print 'An expat error occured while parsing the  Gifti file.'
-
     # update filename
     out.img.filename = fname
     return out.img

nibabel/gifti/parse_gifti_fast.py

@@ -3,15 +3,17 @@
 
 import numpy as np
 
-from ..gifti import GiftiImage
+from ...nifti1 import data_type_codes, intent_codes
+
+from ..gifti import GiftiImage, GiftiDataArray
 
 from numpy.testing import (assert_array_almost_equal,
                            assert_array_equal)
 
 from nose.tools import assert_true, assert_equal, assert_raises
 
 
-def test_gifti_data():
+def test_gifti_image():
     # Check that we're not modifying the default empty list in the default
     # arguments.
     gi = GiftiImage()
@@ -22,3 +24,15 @@ def test_gifti_data():
     gi = GiftiImage()
     assert_equal(gi.darrays, [])
 
+
+def test_dataarray():
+    for dt_code in data_type_codes.value_set():
+        data_type = data_type_codes.type[dt_code]
+        if data_type is np.void: # not supported
+            continue
+        arr = np.zeros((10,3), dtype=data_type)
+        da = GiftiDataArray.from_array(arr, 'triangle')
+        assert_equal(da.datatype, data_type_codes[arr.dtype])
+        bs_arr = arr.byteswap().newbyteorder()
+        da = GiftiDataArray.from_array(bs_arr, 'triangle')
+        assert_equal(da.datatype, data_type_codes[arr.dtype])