Merge branch 'gifti-fix3' into gifti-loadsave

Author: Ben Cipollini

nibabel/gifti/__init__.py

@@ -17,4 +17,4 @@
 """
 
 from .gifti import (GiftiMetaData, GiftiNVPairs, GiftiLabelTable, GiftiLabel,
-                    GiftiCoordSystem, data_tag, GiftiDataArray, GiftiImage)
+                    GiftiCoordSystem, GiftiDataArray, GiftiImage)

nibabel/gifti/gifti.py

@@ -12,6 +12,7 @@
 
 import numpy as np
 
+from .. import xmlutils as xml
 from ..filebasedimages import FileBasedHeader, FileBasedImage
 from ..nifti1 import data_type_codes, xform_codes, intent_codes
 from .util import (array_index_order_codes, gifti_encoding_codes,
@@ -23,7 +24,7 @@
 import base64
 
 
-class GiftiMetaData(object):
+class GiftiMetaData(xml.XmlSerializable):
     """ A list of GiftiNVPairs in stored in
     the list self.data """
     def __init__(self, nvpair=None):
@@ -46,18 +47,15 @@ def get_metadata(self):
             self.data_as_dict[ele.name] = ele.value
         return self.data_as_dict
 
-    def to_xml(self):
-        if len(self.data) == 0:
-            return b"<MetaData/>\n"
-        res = "<MetaData>\n"
+    def _to_xml_element(self):
+        metadata = xml.Element('MetaData')
         for ele in self.data:
-            nvpair = """<MD>
-\t<Name><![CDATA[%s]]></Name>
-\t<Value><![CDATA[%s]]></Value>
-</MD>\n""" % (ele.name, ele.value)
-            res = res + nvpair
-        res = res + "</MetaData>\n"
-        return res.encode('utf-8')
+            md = xml.SubElement(metadata, 'MD')
+            name = xml.SubElement(md, 'Name')
+            value = xml.SubElement(md, 'Value')
+            name.text = ele.name
+            value.text = ele.value
+        return metadata
 
     def print_summary(self):
         print(self.get_metadata())
@@ -73,7 +71,7 @@ def __init__(self, name='', value=''):
         self.value = value
 
 
-class GiftiLabelTable(object):
+class GiftiLabelTable(xml.XmlSerializable):
 
     def __init__(self):
         self.labels = []
@@ -84,31 +82,22 @@ def get_labels_as_dict(self):
             self.labels_as_dict[ele.key] = ele.label
         return self.labels_as_dict
 
-    def to_xml(self):
-        if len(self.labels) == 0:
-            return b"<LabelTable/>\n"
-        res = "<LabelTable>\n"
+    def _to_xml_element(self):
+        labeltable = xml.Element('LabelTable')
         for ele in self.labels:
-            col = ''
-            if not ele.red is None:
-                col += ' Red="%s"' % str(ele.red)
-            if not ele.green is None:
-                col += ' Green="%s"' % str(ele.green)
-            if not ele.blue is None:
-                col += ' Blue="%s"' % str(ele.blue)
-            if not ele.alpha is None:
-                col += ' Alpha="%s"' % str(ele.alpha)
-            lab = """\t<Label Key="%s"%s><![CDATA[%s]]></Label>\n""" % \
-                (str(ele.key), col, ele.label)
-            res = res + lab
-        res = res + "</LabelTable>\n"
-        return res.encode('utf-8')
+            label = xml.SubElement(labeltable, 'Label')
+            label.attrib['Key'] = str(ele.key)
+            label.text = ele.label
+            for attr in ['Red', 'Green', 'Blue', 'Alpha']:
+                if getattr(ele, attr.lower(), None) is not None:
+                    label.attrib[attr] = str(getattr(ele, attr.lower()))
+        return labeltable
 
     def print_summary(self):
         print(self.get_labels_as_dict())
 
 
-class GiftiLabel(object):
+class GiftiLabel(xml.XmlSerializable):
     key = int
     label = str
     # rgba
@@ -143,7 +132,7 @@ def _arr2txt(arr, elem_fmt):
     return '\n'.join(fmt % tuple(row) for row in arr)
 
 
-class GiftiCoordSystem(object):
+class GiftiCoordSystem(xml.XmlSerializable):
     dataspace = int
     xformspace = int
     xform = np.ndarray  # 4x4 numpy array
@@ -157,29 +146,26 @@ def __init__(self, dataspace=0, xformspace=0, xform=None):
         else:
             self.xform = xform
 
-    def to_xml(self):
-        if self.xform is None:
-            return b"<CoordinateSystemTransformMatrix/>\n"
-        res = ("""<CoordinateSystemTransformMatrix>
-\t<DataSpace><![CDATA[%s]]></DataSpace>
-\t<TransformedSpace><![CDATA[%s]]></TransformedSpace>\n"""
-               % (xform_codes.niistring[self.dataspace],
-                  xform_codes.niistring[self.xformspace]))
-        res = res + "<MatrixData>\n"
-        res += _arr2txt(self.xform, '%10.6f')
-        res = res + "</MatrixData>\n"
-        res = res + "</CoordinateSystemTransformMatrix>\n"
-        return res.encode('utf-8')
+    def _to_xml_element(self):
+        coord_xform = xml.Element('CoordinateSystemTransformMatrix')
+        if self.xform is not None:
+            dataspace = xml.SubElement(coord_xform, 'DataSpace')
+            dataspace.text = xform_codes.niistring[self.dataspace]
+            xformed_space = xml.SubElement(coord_xform, 'TransformedSpace')
+            xformed_space.text = xform_codes.niistring[self.xformspace]
+            matrix_data = xml.SubElement(coord_xform, 'MatrixData')
+            matrix_data.text = _arr2txt(self.xform, '%10.6f')
+        return coord_xform
 
     def print_summary(self):
         print('Dataspace: ', xform_codes.niistring[self.dataspace])
         print('XFormSpace: ', xform_codes.niistring[self.xformspace])
         print('Affine Transformation Matrix: \n', self.xform)
 
 
-def data_tag(dataarray, encoding, datatype, ordering):
+def _data_tag_element(dataarray, encoding, datatype, ordering):
     """ Creates the data tag depending on the required encoding,
-    returns as bytes"""
+    returns as XML element"""
     import zlib
     ord = array_index_order_codes.npcode[ordering]
     enclabel = gifti_encoding_codes.label[encoding]
@@ -194,10 +180,13 @@ def data_tag(dataarray, encoding, datatype, ordering):
         raise NotImplementedError("In what format are the external files?")
     else:
         da = ''
-    return ("<Data>" + da + "</Data>\n").encode('utf-8')
 
+    data = xml.Element('Data')
+    data.text = da
+    return data
 
-class GiftiDataArray(object):
+
+class GiftiDataArray(xml.XmlSerializable):
 
     # These are for documentation only; we don't use these class variables
     intent = int
@@ -278,51 +267,35 @@ def from_array(klass,
         cda.meta = GiftiMetaData.from_dict(meta)
         return cda
 
-    def to_xml(self):
+    def _to_xml_element(self):
         # fix endianness to machine endianness
         self.endian = gifti_endian_codes.code[sys.byteorder]
-        result = ""
-        result += self.to_xml_open().decode('utf-8')
-        # write metadata
-        if not self.meta is None:
-            result += self.meta.to_xml().decode('utf-8')
-        # write coord sys
-        if not self.coordsys is None:
-            result += self.coordsys.to_xml().decode('utf-8')
+
+        data_array = xml.Element('DataArray', attrib={
+            'Intent': intent_codes.niistring[self.intent],
+            'DataType': data_type_codes.niistring[self.datatype],
+            'ArrayIndexingOrder': array_index_order_codes.label[self.ind_ord],
+            'Dimensionality': str(self.num_dim),
+            'Encoding': gifti_encoding_codes.specs[self.encoding],
+            'Endian': gifti_endian_codes.specs[self.endian],
+            'ExternalFileName': self.ext_fname,
+            'ExternalFileOffset': self.ext_offset})
+        for di, dn in enumerate(self.dims):
+            data_array.attrib['Dim%d' % di] = str(dn)
+
+        if self.meta is not None:
+            data_array.append(self.meta._to_xml_element())
+        if self.coordsys is not None:
+            data_array.append(self.coordsys._to_xml_element())
         # write data array depending on the encoding
         dt_kind = data_type_codes.dtype[self.datatype].kind
-        result += data_tag(self.data,
-                           gifti_encoding_codes.specs[self.encoding],
-                           KIND2FMT[dt_kind],
-                           self.ind_ord).decode('utf-8')
-        result = result + self.to_xml_close().decode('utf-8')
-        return result.encode('utf-8')
-
-    def to_xml_open(self):
-        out = """<DataArray Intent="%s"
-\tDataType="%s"
-\tArrayIndexingOrder="%s"
-\tDimensionality="%s"
-%s\tEncoding="%s"
-\tEndian="%s"
-\tExternalFileName="%s"
-\tExternalFileOffset="%s">\n"""
-        di = ""
-        for i, n in enumerate(self.dims):
-            di = di + '\tDim%s=\"%s\"\n' % (str(i), str(n))
-        return (out % (intent_codes.niistring[self.intent],
-                      data_type_codes.niistring[self.datatype],
-                      array_index_order_codes.label[self.ind_ord],
-                      str(self.num_dim),
-                      str(di),
-                      gifti_encoding_codes.specs[self.encoding],
-                      gifti_endian_codes.specs[self.endian],
-                      self.ext_fname,
-                      self.ext_offset,
-                      )).encode('utf-8')
-
-    def to_xml_close(self):
-        return b"</DataArray>\n"
+        data_array.append(
+            _data_tag_element(self.data,
+                              gifti_encoding_codes.specs[self.encoding],
+                              KIND2FMT[dt_kind],
+                              self.ind_ord))
+
+        return data_array
 
     def print_summary(self):
         print('Intent: ', intent_codes.niistring[self.intent])
@@ -348,15 +321,14 @@ def get_metadata(self):
 class GiftiHeader(FileBasedHeader):
     pass
 
-
-class GiftiImage(FileBasedImage):
+class GiftiImage(FileBasedImage, xml.XmlSerializable):
     valid_exts = ('.gii',)
     files_types = (('image', '.gii'),)
 
     def __init__(self, header=None, extra=None, file_map=None, meta=None,
                  labeltable=None, darrays=None, version="1.0"):
-        super(GiftiImage, self).__init__(header=header, extra=extra,
-                                         file_map=file_map)
+        FileBasedImage.__init__(self, header=header, extra=extra,
+                                file_map=file_map)
 
         if darrays is None:
             darrays = []
@@ -466,20 +438,24 @@ def print_summary(self):
             print(da.print_summary())
         print('----end----')
 
-    def to_xml(self):
+
+    def _to_xml_element(self):
+        GIFTI = xml.Element('GIFTI', attrib={
+            'Version': self.version,
+            'NumberOfDataArrays': str(self.numDA)})
+        if self.meta is not None:
+            GIFTI.append(self.meta._to_xml_element())
+        if self.labeltable is not None:
+            GIFTI.append(self.labeltable._to_xml_element())
+        for dar in self.darrays:
+            GIFTI.append(dar._to_xml_element())
+        return GIFTI
+
+    def to_xml(self, enc='utf-8'):
         """ Return XML corresponding to image content """
-        res = """<?xml version="1.0" encoding="UTF-8"?>
+        return b"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE GIFTI SYSTEM "http://www.nitrc.org/frs/download.php/115/gifti.dtd">
-<GIFTI Version="%s"  NumberOfDataArrays="%s">\n""" % (self.version,
-                                                      str(self.numDA))
-        if not self.meta is None:
-            res += self.meta.to_xml().decode('utf-8')
-        if not self.labeltable is None:
-            res += self.labeltable.to_xml().decode('utf-8')
-        for dar in self.darrays:
-            res += dar.to_xml().decode('utf-8')
-        res += "</GIFTI>"
-        return res.encode('utf-8')
+""" + xml.XmlSerializable.to_xml(self, enc)
 
     @classmethod
     def from_file_map(klass, file_map):

nibabel/xmlutils.py

@@ -0,0 +1,25 @@
+# emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+#
+#   See COPYING file distributed along with the NiBabel package for the
+#   copyright and license terms.
+#
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+"""
+Thin layer around xml.etree.ElementTree, to abstract nibabel xml support.
+"""
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+
+class XmlSerializable(object):
+    """ Basic interface for serializing an object to xml"""
+
+    def _to_xml_element(self):
+        """ Output should be a xml.etree.ElementTree.Element"""
+        raise NotImplementedError()
+
+    def to_xml(self, enc='utf-8'):
+        """ Output should be an xml string with the given encoding.
+        (default: utf-8)"""
+        return tostring(self._to_xml_element(), enc)