[ismrmrd] 04/129: Imported Upstream version 0.5.0

Ghislain Vaillant ghisvail-guest at moszumanska.debian.org
Wed Jan 14 20:00:07 UTC 2015


This is an automated email from the git hooks/post-receive script.

ghisvail-guest pushed a commit to branch master
in repository ismrmrd.

commit ea29ddd0f5ce7bf77247f3a0a228fb583a19a829
Author: Ghislain Vaillant <ghisvail at gmail.com>
Date:   Mon Mar 3 17:18:42 2014 +0000

    Imported Upstream version 0.5.0
---
 CMakeLists.txt                                     |    8 +-
 bindings/CMakeLists.txt                            |   17 +-
 bindings/java/CMakeLists.txt                       |   39 +-
 bindings/java/XMLString.java                       |   32 +-
 bindings/java/cfg.jxb                              |   10 +
 bindings/java/ismrmrd_java.i                       |   31 +
 bindings/java/{make_jar.sh => make_jar.sh.in}      |    5 +-
 bindings/python/CMakeLists.txt                     |   30 +-
 bindings/python/ismrmrd_python.i                   |  839 +++--------
 cmake/FindJava.cmake                               |  212 +++
 cmake/FindNumPy.cmake                              |  101 ++
 cmake/FindXSD.cmake                                |   72 +-
 examples/java/ismrmrd_test.java                    |   55 +-
 examples/matlab/{ => old}/ismrmrd_header2struct.m  |    0
 examples/matlab/old/simple_cartesian_recon.m       |  127 ++
 examples/matlab/{ => old}/simple_gridder.m         |    0
 examples/matlab/{ => old}/simple_spiral_recon.m    |    0
 examples/matlab/{ => old}/testsynth.m              |    0
 {matlab => examples/matlab/old}/xml2struct.m       |    0
 examples/matlab/simple_cartesian_recon.m           |   82 --
 examples/matlab/test_create_dataset.m              |  170 +++
 examples/matlab/test_recon_dataset.m               |  158 +++
 ismrmrd.h                                          | 1466 ++++++++++----------
 ismrmrd_hdf5_datatypes.h                           |    4 +
 matlab/+ismrmrd/+util/AcquisitionHeaderFromBytes.m |   47 +
 matlab/+ismrmrd/+util/AcquisitionHeaderToBytes.m   |   47 +
 matlab/+ismrmrd/+util/ImageHeaderFromBytes.m       |   32 +
 matlab/+ismrmrd/+util/ImageHeaderToBytes.m         |   32 +
 matlab/+ismrmrd/{old => +util}/hdf5_datatypes.m    |  187 +--
 matlab/+ismrmrd/+util/includejar.m                 |   15 +
 matlab/+ismrmrd/{old => +util}/isInt.m             |    0
 matlab/+ismrmrd/Acquisition.m                      |  122 ++
 matlab/+ismrmrd/AcquisitionFlags.m                 |   38 -
 matlab/+ismrmrd/AcquisitionHeader.m                |  627 ++++++---
 matlab/+ismrmrd/EncodingCounters.m                 |   94 --
 matlab/+ismrmrd/FlagBit.m                          |   32 -
 matlab/+ismrmrd/{old => }/Image.m                  |   18 +-
 matlab/+ismrmrd/ImageDataType.m                    |    9 -
 matlab/+ismrmrd/ImageFlags.m                       |   14 -
 matlab/+ismrmrd/ImageHeader.m                      |  554 +++++---
 matlab/+ismrmrd/ImageType.m                        |    9 -
 matlab/+ismrmrd/{old/file.m => IsmrmrdDataset.m}   |  200 +--
 matlab/+ismrmrd/XMLHeader.m                        |   33 -
 matlab/+ismrmrd/old/Acquisition.m                  |   49 -
 matlab/CMakeLists.txt                              |   72 +
 matlab/XMLString.java                              |   42 +
 matlab/cfg.jxb                                     |   10 +
 schema/ismrmrd.xsd                                 |  199 ++-
 48 files changed, 3421 insertions(+), 2519 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e5e7ec0..9d0de14 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,9 +36,6 @@ target_link_libraries(dummy ${XERCESC_LIBRARIES})
 # Add library ismrmrd
 add_library(ismrmrd SHARED ismrmrd_hdf5.cpp)
 
-# Process the MATLAB files
-file(GLOB MatlabMFiles ${CMAKE_SOURCE_DIR}/matlab/+ismrmrd/*.m)
-
 #The findHDF5.cmake does not work very well on Windows, let's help it out
 IF(WIN32)
 	SET(HDF5_LIB_DIR ${HDF5_INCLUDE_DIR}/../lib)
@@ -57,12 +54,13 @@ ENDIF(WIN32)
 
 INSTALL(FILES ismrmrd.h ismrmrd_hdf5.h ismrmrd_hdf5_datatypes.h ismrmrd_export.h DESTINATION include)
 INSTALL(FILES schema/ismrmrd.xsd ${XSDS_SOURCES} DESTINATION schema)
-INSTALL(FILES cmake/FindIsmrmrd.cmake cmake/FindFFTW3.cmake cmake/FindXSD.cmake cmake/FindXercesC.cmake DESTINATION cmake)
+INSTALL(FILES cmake/FindIsmrmrd.cmake cmake/FindFFTW3.cmake cmake/FindXSD.cmake
+        cmake/FindXercesC.cmake cmake/FindNumPy.cmake DESTINATION cmake)
 INSTALL(TARGETS ismrmrd DESTINATION lib)
-INSTALL(FILES ${MatlabMFiles} DESTINATION matlab/+ismrmrd)
 
 add_subdirectory(examples/c++)
 add_subdirectory(utilities)
 add_subdirectory(tests)
 add_subdirectory(doc)
+add_subdirectory(matlab)
 add_subdirectory(bindings)
diff --git a/bindings/CMakeLists.txt b/bindings/CMakeLists.txt
index 2b7cda6..4be6529 100644
--- a/bindings/CMakeLists.txt
+++ b/bindings/CMakeLists.txt
@@ -6,15 +6,26 @@ if(SWIG_FOUND)
 
     find_package(PythonLibs)
     if(PYTHONLIBS_FOUND)
-        add_subdirectory(python)
+        find_package(NumPy)
+        if(NUMPY_FOUND)
+            if (NUMPY_VERSION VERSION_LESS "1.7")
+                message("NumPy version < 1.7. Not building Python bindings")
+            else (${NUMPY_VERSION} VERSION_LESS "1.7")
+                add_subdirectory(python)
+            endif (NUMPY_VERSION VERSION_LESS "1.7")
+        else(NUMPY_FOUND)
+            message("NumPy not found. Not building Python bindings")
+        endif(NUMPY_FOUND)
     else(PYTHONLIBS_FOUND)
         message("PythonLibs not found. Not building Python bindings")
     endif(PYTHONLIBS_FOUND)
 
-    if(DEFINED JAVA_INCLUDE_DIR)
+    find_package(JNI)
+    if(JNI_FOUND)
+        message(STATUS "JAVA Include Path: ${JAVA_INCLUDE_PATH}")
         add_subdirectory(java)
     else()
-        message("JAVA_INCLUDE_DIR not defined. Not building Java bindings")
+        message("JNI not found. Not building Java bindings")
     endif()
 
 endif(SWIG_FOUND)
diff --git a/bindings/java/CMakeLists.txt b/bindings/java/CMakeLists.txt
index 86c2f23..5eb54b9 100644
--- a/bindings/java/CMakeLists.txt
+++ b/bindings/java/CMakeLists.txt
@@ -1,33 +1,44 @@
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${HDF5_INCLUDE_DIR} ${HDF5_INCLUDE_DIR}/cpp ${Boost_INCLUDE_DIR})
-include_directories(${JAVA_INCLUDE_DIR})
+include_directories(${JAVA_INCLUDE_PATH})
 if (UNIX)
-    include_directories(${JAVA_INCLUDE_DIR}/linux)
+    include_directories(${JAVA_INCLUDE_PATH}/linux)
 endif (UNIX)
 
 set(CMAKE_SWIG_FLAGS -package org.ismrm.ismrmrd)
 set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/org/ismrm/ismrmrd)
 
-set(SWIG_SOURCES ismrmrd_java.i ../../ismrmrd_hdf5.cpp)
+set(SWIG_SOURCES ismrmrd_java.i ${CMAKE_SOURCE_DIR}/ismrmrd_hdf5.cpp)
 set_source_files_properties(${SWIG_SOURCES} PROPERTIES CPLUSPLUS ON)
 swig_add_module(jismrmrd java ${SWIG_SOURCES})
 swig_link_libraries(jismrmrd ${HDF5_LIBRARIES} ${Boost_LIBRARIES})
 
-## TODO: this will NOT work on Windows
-set_source_files_properties(ismrmrd.jar PROPERTIES GENERATED true)
+#### ISMRMRD XML Header Java library ####
+configure_file(make_jar.sh.in make_jar.sh @ONLY)
+
+set(JAVADOC_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/doc")
+set(JAVA_OUTPUTS "${CMAKE_CURRENT_BINARY_DIR}/ismrmrd.jar" ${JAVADOC_OUTPUT})
+
+## TODO: not use a shell script... it breaks 'make'
 add_custom_command(
-    TARGET jismrmrd
-    POST_BUILD
+    OUTPUT ${JAVA_OUTPUTS}
+    DEPENDS jismrmrd "${CMAKE_CURRENT_BINARY_DIR}/make_jar.sh"
+    VERBATIM
+    COMMENT "Compiling java files, building jar, generating API docs"
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    COMMENT "Compiling java files and creating jar" VERBATIM
-    COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/JNILibLoader.java	
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/JNILibLoader.java
                ${CMAKE_CURRENT_BINARY_DIR}/org/ismrm/ismrmrd/
     COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/org/ismrm/ismrmrd/xmlhdr
-    COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/XMLString.java	
+    COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/XMLString.java
                ${CMAKE_CURRENT_BINARY_DIR}/org/ismrm/ismrmrd/xmlhdr/
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/make_jar.sh
-    VERBATIM
+    COMMAND sh make_jar.sh
+    COMMAND javadoc -quiet -d ${JAVADOC_OUTPUT} -subpackages org.ismrm.ismrmrd.xmlhdr
 )
+add_custom_target(ismrmrdjar ALL DEPENDS ${JAVA_OUTPUTS})
+
+install(TARGETS jismrmrd DESTINATION java)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ismrmrd.jar DESTINATION java)
 
-install(TARGETS jismrmrd DESTINATION lib)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ismrmrd.jar DESTINATION lib)
+# Note: the API documentation is only for the XML header, and is installed
+# in ${INSTALL_PREFIX}/matlab/doc
+install(DIRECTORY ${JAVADOC_OUTPUT} DESTINATION matlab)
diff --git a/bindings/java/XMLString.java b/bindings/java/XMLString.java
index d215e1d..8038712 100644
--- a/bindings/java/XMLString.java
+++ b/bindings/java/XMLString.java
@@ -1,6 +1,8 @@
 package org.ismrm.ismrmrd.xmlhdr;
 
 import javax.xml.bind.*;
+import javax.xml.namespace.QName;
+import javax.xml.transform.stream.*;
 import java.io.StringReader;
 import java.io.StringWriter;
 
@@ -8,21 +10,33 @@ import java.io.StringWriter;
 public class XMLString {
     public static IsmrmrdHeader StringToIsmrmrdHeader(String xmlstring) throws javax.xml.bind.JAXBException
     {
-        JAXBContext jc = JAXBContext.newInstance(IsmrmrdHeader.class);
-        Unmarshaller u  = jc.createUnmarshaller();
+        JAXBContext jaxbContext = JAXBContext.newInstance(IsmrmrdHeader.class);
+
+        Unmarshaller unmarshaller  = jaxbContext.createUnmarshaller();
+
         StringReader reader = new StringReader(xmlstring);
-        IsmrmrdHeader hdr = (IsmrmrdHeader) u.unmarshal(reader);
-        return hdr;
+
+        JAXBElement<IsmrmrdHeader> root = unmarshaller.unmarshal(new StreamSource(reader), IsmrmrdHeader.class);
+
+        return root.getValue();
     }
 
     public static String IsmrmrdHeaderToString(IsmrmrdHeader header) throws javax.xml.bind.JAXBException
     {
-        JAXBContext jc = JAXBContext.newInstance(IsmrmrdHeader.class);
-        Marshaller m = jc.createMarshaller();
-        m.setProperty(Marshaller.JAXB_SCHEMA_LOCATION, "http://www.ismrm.org/ISMRMRD ismrmrd.xsd");
-        m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+        JAXBContext jaxbContext = JAXBContext.newInstance(IsmrmrdHeader.class);
+
+        Marshaller marshaller = jaxbContext.createMarshaller();
+
+        marshaller.setProperty(Marshaller.JAXB_SCHEMA_LOCATION, "http://www.ismrm.org/ISMRMRD ismrmrd.xsd");
+        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+
         StringWriter writer = new StringWriter();
-        m.marshal(header, writer);
+
+        QName qname = new QName("http://www.ismrm.org/ISMRMRD", "ismrmrdHeader");
+        JAXBElement<IsmrmrdHeader> root = new JAXBElement(qname, IsmrmrdHeader.class, header);
+
+        marshaller.marshal(root, writer);
+
         return writer.toString();
     }
 }
diff --git a/bindings/java/cfg.jxb b/bindings/java/cfg.jxb
new file mode 100644
index 0000000..c7d574f
--- /dev/null
+++ b/bindings/java/cfg.jxb
@@ -0,0 +1,10 @@
+<jxb:bindings version="1.0" 
+  xmlns:jxb="http://java.sun.com/xml/ns/jaxb" 
+  xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+  xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc" 
+  jxb:extensionBindingPrefixes="xjc">
+    <jxb:bindings>
+        <jxb:globalBindings localScoping="toplevel">
+        </jxb:globalBindings>
+    </jxb:bindings>
+</jxb:bindings>
diff --git a/bindings/java/ismrmrd_java.i b/bindings/java/ismrmrd_java.i
index 6d9cd7b..a2f0019 100644
--- a/bindings/java/ismrmrd_java.i
+++ b/bindings/java/ismrmrd_java.i
@@ -58,6 +58,9 @@ typedef std::complex<double> cxdouble;
 %apply int16_t[]  {int16_t *};
 %apply uint32_t[] {uint32_t *};
 
+%ignore *::operator=;
+%ignore *::operator[];
+
 //
 // Define some extra methods for serializing and deserializing the header structures
 //
@@ -145,9 +148,37 @@ typedef std::complex<double> cxdouble;
         env->ReleaseFloatArrayElements(arr, ptr, JNI_COMMIT);
     }
 
+    jfloatArray getTraj() {
+        JNIEnv *env = JNU_GetEnv();
+        uint32_t nelem = $self->getTrajectoryDimensions()*$self->getNumberOfSamples();
+        jfloatArray arr = env->NewFloatArray(nelem);
+        if (arr != NULL) {
+            float *ptr = env->GetFloatArrayElements(arr, NULL);
+            jint i;
+            for (i = 0; i < nelem; i++) {
+                ptr[i] = $self->getTraj()[i];
+            }
+            env->ReleaseFloatArrayElements(arr, ptr, JNI_COMMIT);
+        }
+        return arr;
+    }
+
+    void setTraj(jfloatArray arr) {
+        // Get the environment
+        JNIEnv *env = JNU_GetEnv();
+        // Get the size of the input array and a pointer to it
+	jsize len  = env->GetArrayLength(arr);
+        float *ptr = env->GetFloatArrayElements(arr, NULL);
+	std::valarray<float> tmp(ptr,len);
+        // TODO: make sure that the user has set the proper size.
+	$self->setTraj(tmp);
+        env->ReleaseFloatArrayElements(arr, ptr, JNI_COMMIT);
+    }
 }
 %ignore ISMRMRD::Acquisition::getData;
 %ignore ISMRMRD::Acquisition::setData;
+%ignore ISMRMRD::Acquisition::getTraj;
+%ignore ISMRMRD::Acquisition::setTraj;
 
 //
 // The Image and NDContainerArray classes are overloaded
diff --git a/bindings/java/make_jar.sh b/bindings/java/make_jar.sh.in
old mode 100755
new mode 100644
similarity index 64%
rename from bindings/java/make_jar.sh
rename to bindings/java/make_jar.sh.in
index 0ecb4e6..fa3b1a7
--- a/bindings/java/make_jar.sh
+++ b/bindings/java/make_jar.sh.in
@@ -3,11 +3,8 @@ javac org/ismrm/ismrmrd/*.java
 
 ## The XML Header classes
 # Make a class out of the schema
-xjc -p org.ismrm.ismrmrd.xmlhdr ../../../schema/ismrmrd.xsd
+xjc -p org.ismrm.ismrmrd.xmlhdr -b @CMAKE_SOURCE_DIR@/bindings/java/cfg.jxb @CMAKE_SOURCE_DIR@/schema/ismrmrd.xsd
 javac org/ismrm/ismrmrd/xmlhdr/*.java
 
 # Build a big jar
 jar -cvf ismrmrd.jar org/ismrm/ismrmrd/*.class org/ismrm/ismrmrd/xmlhdr/*.class
-
-# Build the java docs
-javadoc -quiet -d ismrmrd.javadoc -subpackages org.ismrm.ismrmrd
diff --git a/bindings/python/CMakeLists.txt b/bindings/python/CMakeLists.txt
index 30199ea..8a86456 100644
--- a/bindings/python/CMakeLists.txt
+++ b/bindings/python/CMakeLists.txt
@@ -1,14 +1,18 @@
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
-include_directories(${PYTHON_INCLUDE_PATH} ${PYTHON_NUMPY_INCLUDE_DIR})
+include_directories(${PYTHON_INCLUDE_PATH} ${NUMPY_INCLUDE_DIRS})
 include_directories(${HDF5_INCLUDE_DIR} ${HDF5_INCLUDE_DIR}/cpp ${Boost_INCLUDE_DIR})
 
+if ( WIN32 )
+    add_definitions(-Dismrmrd_EXPORTS)
+endif ( WIN32 )
+
 set_source_files_properties(ismrmrd_python.i PROPERTIES CPLUSPLUS ON)
 
-swig_add_module(ismrmrd python ismrmrd_python.i ../../ismrmrd_hdf5.cpp)
+swig_add_module(ismrmrd python ismrmrd_python.i ${CMAKE_SOURCE_DIR}/ismrmrd_hdf5.cpp)
 swig_link_libraries(ismrmrd ${HDF5_LIBRARIES} ${Boost_LIBRARIES} ${PYTHON_LIBRARIES})
 
-install(TARGETS ${SWIG_MODULE_ismrmrd_REAL_NAME} DESTINATION lib)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ismrmrd.py DESTINATION lib)
+install(TARGETS ${SWIG_MODULE_ismrmrd_REAL_NAME} DESTINATION python)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ismrmrd.py DESTINATION python)
 
 find_program(PYXBGEN pyxbgen
     HINTS ${PYTHON_HOME} ${PYTHON_LIBRARY}/..
@@ -16,13 +20,21 @@ find_program(PYXBGEN pyxbgen
 
 if(PYXBGEN)
     set(SCHEMA "${CMAKE_SOURCE_DIR}/schema/ismrmrd.xsd")
-    set(XSD_PY "${CMAKE_CURRENT_BINARY_DIR}/ismrmrd_xsd.py")
+    set(XSD_PY_FILE "${CMAKE_CURRENT_BINARY_DIR}/ismrmrd_xsd.py")
+    set(XSD_PY_DIR "${CMAKE_CURRENT_BINARY_DIR}/raw")
+
     add_custom_command(
-        OUTPUT ${XSD_PY}
-        COMMAND ${PYXBGEN} -u "${SCHEMA}" -m ismrmrd_xsd
+        OUTPUT ${XSD_PY_FILE} ${XSD_PY_DIR}
+        COMMAND ${PYXBGEN} -r -u "${SCHEMA}" -m ismrmrd_xsd
+        COMMAND ${CMAKE_COMMAND} -E echo "import" "pyxb.utils.domutils" >> ${XSD_PY_FILE}
+        COMMAND ${CMAKE_COMMAND} -E echo "'pyxb.utils.domutils.BindingDOMSupport.SetDefaultNamespace(Namespace)'" >> ${XSD_PY_FILE}
         DEPENDS ${SCHEMA})
-    add_custom_target(pyismrmrd_xsd ALL DEPENDS ${XSD_PY})
-    install(FILES ${XSD_PY} DESTINATION lib)
+
+    add_custom_target(pyismrmrd_xsd ALL DEPENDS ${XSD_PY_FILE})
+
+    install(FILES ${XSD_PY_FILE} DESTINATION python)
+    install(DIRECTORY ${XSD_PY_DIR} DESTINATION python)
+
 else(PYXBGEN)
     message("Can't find pyxbgen executable. Not building ismrmrd_xsd.py")
 endif(PYXBGEN)
diff --git a/bindings/python/ismrmrd_python.i b/bindings/python/ismrmrd_python.i
index b1fb679..e577e81 100644
--- a/bindings/python/ismrmrd_python.i
+++ b/bindings/python/ismrmrd_python.i
@@ -1,745 +1,296 @@
 %module ismrmrd
 
 %{
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+
 #include "ismrmrd_hdf5.h"
 #include "numpy/arrayobject.h"
 
 #define SWIG_FILE_WITH_INIT
 
-/* exception helpers */
-static int swig_c_err_num = 0;
-static char swig_c_err_msg[256];
-
-const char *err_occurred()
-{
-    if (swig_c_err_num) {
-        swig_c_err_num = 0;
-        return (const char*)swig_c_err_msg;
-    }
-    return NULL;
-}
-
-void set_err(const char *msg)
-{
-    swig_c_err_num = 1;
-    strncpy(swig_c_err_msg, msg, 256);
-}
-
-// typedef for complex numbers
-typedef std::complex<float>  cxfloat;
-typedef std::complex<double> cxdouble;
-
-%}
-
-%init %{
-import_array();
-%}
-
-%include "stdint.i"
-%include "std_string.i"
-%include "std_vector.i"
-%include "carrays.i"
-
-%array_class(unsigned short, ushortArray);
-%array_class(uint16_t, ushortArray);
-%array_class(unsigned int, uintArray);
-%array_class(uint32_t, uintArray);
-%array_class(float, floatArray);
-
-%exception {
-    const char *err;
-    $action
-    if ((err = err_occurred())) {
-        PyErr_SetString(PyExc_RuntimeError, err);
-        return NULL;
-    }
-}
-
-%extend ISMRMRD::Acquisition {
-    PyObject* getData()
-    {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_FLOAT);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        //printf("# elements: %d\n", $self->getData().size());
-        //printf("data size:  %d\n", data_size);
-        //printf("total size: %d\n", raw_size);
-
-        std::valarray<float> data = $self->getData();
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_float *addr = (npy_float*)(raw + (i * data_size));
-            *addr = data[i];
-
-            /* slower method */
-            //PyObject *o = PyFloat_FromDouble((double)data[i]);
-            //PyArray_SETITEM(array, addr, o);
-            //Py_DECREF(o);
-        }
-
-        return array;
-    }
-
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISFLOAT(array)) {
-            set_err("Argument to setData is not a numpy float array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_float *addr = (npy_float*)(raw + i * data_size);
-            (*$self)[i] = (float)*addr;
-        }
-    }
-
-}
-%ignore ISMRMRD::Acquisition::getData;
-%ignore ISMRMRD::Acquisition::setData;
-
+    /* exception helpers */
+    static int swig_c_err_num = 0;
+    static char swig_c_err_msg[256];
 
-//
-// The Image class is overloaded so we need to do some renaming
-//
-%rename(Image_ushort_getData)   Image<unsigned short int>::getData;
-%rename(Image_ushort_setData)   Image<unsigned short int>::setData;
-%rename(Image_float_getData)    Image<float>::getData;
-%rename(Image_float_setData)    Image<float>::setData;
-%rename(Image_double_getData)   Image<double>::getData;
-%rename(Image_double_setData)   Image<double>::setData;
-%rename(Image_cxfloat_getData)  Image<cxfloat>::getData;
-%rename(Image_cxfloat_setData)  Image<cxfloat>::setData;
-%rename(Image_cxdouble_getData) Image<cxdouble>::getData;
-%rename(Image_cxdouble_setData) Image<cxdouble>::setData;
-
-%extend ISMRMRD::Image<unsigned short int>
-{
-    PyObject *getData()
+    const char *err_occurred()
     {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_USHORT);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        int i;
-        for (i = 0; i < $self->getNumberOfElements(); i++) {
-            npy_ushort *addr = (npy_ushort*)(raw + (i * data_size));
-            *addr = (*self)[i];
+        if (swig_c_err_num) {
+            swig_c_err_num = 0;
+            return (const char*)swig_c_err_msg;
         }
-
-        return array;
+        return NULL;
     }
 
-    void setData(PyObject *array)
+    void set_err(const char *msg)
     {
-        if (!PyArray_Check(array) || !PyArray_ISINTEGER(array)) {
-            set_err("Argument to setData is not a numpy integer array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_ushort *addr = (npy_ushort*)(raw + i * data_size);
-            (*$self)[i] = (unsigned short)*addr;
-        }
+        swig_c_err_num = 1;
+        strncpy(swig_c_err_msg, msg, 256);
     }
-}
-%ignore ISMRMRD::Image<unsigned short int>::getData;
-%ignore ISMRMRD::Image<unsigned short int>::setData;
-
-%extend ISMRMRD::Image<float>
-{
-    PyObject *getData()
-    {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_FLOAT);
 
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
+    // typedef for complex numbers
+    typedef std::complex<float>  cxfloat;
+    typedef std::complex<double> cxdouble;
 
-        int i;
-        for (i = 0; i < $self->getNumberOfElements(); i++) {
-            npy_float *addr = (npy_float*)(raw + (i * data_size));
-            *addr = (*self)[i];
-        }
-
-        return array;
-    }
-
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISFLOAT(array)) {
-            set_err("Argument to setData is not a numpy float array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_float *addr = (npy_float*)(raw + i * data_size);
-            (*$self)[i] = (float)*addr;
-        }
-    }
-}
-%ignore ISMRMRD::Image<float>::getData;
-%ignore ISMRMRD::Image<float>::setData;
 
-%extend ISMRMRD::Image<double>
-{
-    PyObject *getData()
+    template <typename T> PyObject *make_image_array(boost::shared_ptr< ISMRMRD::NDArrayContainer<T> > cont, unsigned int numpy_type)
     {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_DOUBLE);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
+        size_t all_dims = cont->dimensions_.size();
+        size_t ndim = cont->ndims();
 
-        int i;
-        for (i = 0; i < $self->getNumberOfElements(); i++) {
-            npy_double *addr = (npy_double*)(raw + (i * data_size));
-            *addr = (*self)[i];
+        npy_intp* dims = new npy_intp[ndim];
+	for (int d = 0; d < all_dims; d++){
+            int dimension = cont->dimensions_[d];
+            if (dimension > 1) {
+                dims[d] = dimension;
+            }
         }
+	PyObject *array = PyArray_New(&PyArray_Type, ndim, dims, numpy_type, NULL, NULL, 0, NPY_ARRAY_FARRAY, NULL);
+	delete[] dims;
 
         return array;
     }
 
-    void setData(PyObject *array)
+    template <typename T> PyObject* readTArray(ISMRMRD::IsmrmrdDataset *dset, const char* varname, unsigned long index, unsigned int numpy_type)
     {
-        if (!PyArray_Check(array) || !PyArray_ISFLOAT(array)) {
-            set_err("Argument to setData is not a numpy double array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
+        boost::shared_ptr< ISMRMRD::NDArrayContainer<T> > container = dset->readArray<T>(varname,index);
+        PyObject *array = make_image_array<T>(container, numpy_type);
 
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_double *addr = (npy_double*)(raw + i * data_size);
-            (*$self)[i] = (double)*addr;
-        }
-    }
-}
-%ignore ISMRMRD::Image<double>::getData;
-%ignore ISMRMRD::Image<double>::setData;
+        T *raw = (T*)PyArray_DATA((PyArrayObject*)array);
+        npy_intp raw_size = PyArray_NBYTES((PyArrayObject*)array);
 
-%extend ISMRMRD::Image<cxfloat>
-{
-    PyObject *getData()
-    {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_CFLOAT);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        int i;
-        for (i = 0; i < $self->getNumberOfElements(); i++) {
-            npy_cfloat *addr = (npy_cfloat*)(raw + (i * data_size));
-            addr->real = (*self)[i].real();
-            addr->imag = (*self)[i].imag();
-        }
+        memcpy(raw, &container->data_[0], raw_size);
 
         return array;
     }
 
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISCOMPLEX(array)) {
-            set_err("Argument to setData is not a numpy complex array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_cfloat *addr = (npy_cfloat*)(raw + i * data_size);
-            (*$self)[i] = cxfloat(addr->real, addr->imag);
-        }
-    }
-}
-%ignore ISMRMRD::Image<cxfloat>::getData;
-%ignore ISMRMRD::Image<cxfloat>::setData;
-
-%extend ISMRMRD::Image<cxdouble>
-{
-    PyObject *getData()
-    {
-        npy_intp dims[] = { $self->getData().size() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_CDOUBLE);
+%}
 
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
+// Initialize NumPy
+%init %{
+    import_array();
+%}
 
-        int i;
-        for (i = 0; i < $self->getNumberOfElements(); i++) {
-            npy_cdouble *addr = (npy_cdouble*)(raw + (i * data_size));
-            addr->real = (*self)[i].real();
-            addr->imag = (*self)[i].imag();
-        }
+%include "stdint.i"
+%include "std_string.i"
+%include "std_vector.i"
+%include "carrays.i"
 
-        return array;
-    }
+%array_class(uint16_t, ushortArray);
+%array_class(int32_t, intArray);
+%array_class(uint32_t, uintArray);
+%array_class(uint64_t, ulongArray);
+%array_class(float, floatArray);
 
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISCOMPLEX(array)) {
-            set_err("Argument to setData is not a numpy complex array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
 
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_cdouble *addr = (npy_cdouble*)(raw + i * data_size);
-            (*$self)[i] = cxdouble(addr->real, addr->imag);
-        }
+%exception {
+    const char *err;
+    $action
+    if ((err = err_occurred())) {
+        PyErr_SetString(PyExc_RuntimeError, err);
+        return NULL;
     }
 }
-%ignore ISMRMRD::Image<cxdouble>::getData;
-%ignore ISMRMRD::Image<cxdouble>::setData;
-
-
-//
-// The NDContainerArray class is overloaded so rename each template
-//
-%rename(Array_ushort_getData)   NDArrayContainer<unsigned short int>::getData;
-%rename(Array_ushort_setData)   NDArrayContainer<unsigned short int>::setData;
-%rename(Array_float_getData)    NDArrayContainer<float>::getData;
-%rename(Array_float_setData)    NDArrayContainer<float>::setData;
-%rename(Array_double_getData)   NDArrayContainer<double>::getData;
-%rename(Array_double_setData)   NDArrayContainer<double>::setData;
-%rename(Array_cxfloat_getData)  NDArrayContainer<cxfloat>::getData;
-%rename(Array_cxfloat_setData)  NDArrayContainer<cxfloat>::setData;
-%rename(Array_cxdouble_getData) NDArrayContainer<cxdouble>::getData;
-%rename(Array_cxdouble_setData) NDArrayContainer<cxdouble>::setData;
-
-%extend ISMRMRD::NDArrayContainer<unsigned short int>
-{
-    PyObject* getData()
-    {
-        npy_intp dims[] = { $self->elements() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_USHORT);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
 
-        int i;
-        for (i = 0; i < $self->elements(); i++) {
-            npy_ushort *addr = (npy_ushort*)(raw + (i * data_size));
-            (*addr) = (*self)[i];
-        }
-
-        return array;
-    }
-
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISINTEGER(array)) {
-            set_err("Argument to setData is not a numpy integer array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
+%ignore *::operator=;
+%ignore *::operator[];
+%ignore ISMRMRD::AcquisitionHeader_with_data;
+%ignore ISMRMRD::ImageHeader_with_data;
+%ignore ISMRMRD::Image;
+%ignore ISMRMRD::NDArrayContainer;
 
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_ushort *addr = (npy_ushort*)(raw + i * data_size);
-            (*$self)[i] = (unsigned short)*addr;
-        }
-    }
-}
-%ignore ISMRMRD::NDArrayContainer<unsigned short int>::getData;
-%ignore ISMRMRD::NDArrayContainer<unsigned short int>::setData;
 
-%extend ISMRMRD::NDArrayContainer<float>
-{
+%extend ISMRMRD::Acquisition {
+    /* Returns 1-D Numpy Array */
     PyObject* getData()
     {
-        npy_intp dims[] = { $self->elements() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_FLOAT);
+        npy_intp dims[] = { $self->getData().size() };
+	PyObject *array = PyArray_New(&PyArray_Type, 1, dims, NPY_FLOAT,
+                NULL, NULL, 0, NPY_ARRAY_FARRAY, NULL);
 
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
+        char *raw = PyArray_BYTES((PyArrayObject*)array);
+        int data_size = PyArray_ITEMSIZE((PyArrayObject*)array);
+        npy_intp raw_size = PyArray_NBYTES((PyArrayObject*)array);
 
-        int i;
-        for (i = 0; i < $self->elements(); i++) {
-            npy_float *addr = (npy_float*)(raw + (i * data_size));
-            (*addr) = (*self)[i];
-        }
+        std::valarray<float> data = $self->getData();
+        memcpy(raw, &data[0], dims[0] * data_size);
 
         return array;
     }
 
-    void setData(PyObject *array)
+    void setData(PyObject *in_array)
     {
-        if (!PyArray_Check(array) || !PyArray_ISFLOAT(array)) {
+        if (!PyArray_Check((PyArrayObject*)in_array) || !PyArray_ISFLOAT((PyArrayObject*)in_array)) {
             set_err("Argument to setData is not a numpy float array\n");
             return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
+        } else if (!PyArray_ISBEHAVED_RO((PyArrayObject*)in_array)) {
+            set_err("Argument to setData must be aligned\n");
             return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_float *addr = (npy_float*)(raw + i * data_size);
-            (*$self)[i] = (float)*addr;
-        }
-    }
-}
-%ignore ISMRMRD::NDArrayContainer<float>::getData;
-%ignore ISMRMRD::NDArrayContainer<float>::setData;
-
-%extend ISMRMRD::NDArrayContainer<double>
-{
-    PyObject* getData()
-    {
-        npy_intp dims[] = { $self->elements() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_DOUBLE);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        int i;
-        for (i = 0; i < $self->elements(); i++) {
-            npy_double *addr = (npy_double*)(raw + (i * data_size));
-            (*addr) = (*self)[i];
-        }
-
-        return array;
-    }
-
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISFLOAT(array)) {
-            set_err("Argument to setData is not a numpy double array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
+        } else if (!PyArray_ISONESEGMENT((PyArrayObject*)in_array)) {
+            set_err("Data is not one segment\n");
             return;
         }
 
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_double *addr = (npy_double*)(raw + i * data_size);
-            (*$self)[i] = (double)*addr;
-        }
-    }
-}
-%ignore ISMRMRD::NDArrayContainer<double>::getData;
-%ignore ISMRMRD::NDArrayContainer<double>::setData;
-
-%extend ISMRMRD::NDArrayContainer<cxfloat>
-{
-    PyObject* getData()
-    {
-        npy_intp dims[] = { $self->elements() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_CFLOAT);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        int i;
-        for (i = 0; i < $self->elements(); i++) {
-            npy_cfloat *addr = (npy_cfloat*)(raw + (i * data_size));
-            addr->real = (*self)[i].real();
-            addr->imag = (*self)[i].imag();
+        PyObject *array = NULL;
+        /* if array is C-style contiguous, make a Fortran-style contiguous copy */
+        if (PyArray_ISCONTIGUOUS((PyArrayObject*)in_array)) {
+            array = PyArray_NewCopy((PyArrayObject*)in_array, NPY_FORTRANORDER);
+        } else {
+            array = in_array;
         }
 
-        return array;
-    }
+        int ndim = PyArray_NDIM((PyArrayObject*)array);
+        int itemsize = PyArray_ITEMSIZE((PyArrayObject*)array);
+        npy_intp nbytes = PyArray_NBYTES((PyArrayObject*)array);
+        npy_intp nelements = PyArray_SIZE((PyArrayObject*)array);
+        npy_intp* dims = PyArray_DIMS((PyArrayObject*)array);
+        npy_intp* strides = PyArray_STRIDES((PyArrayObject*)array);
+        void *raw = PyArray_DATA((PyArrayObject*)array);
 
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISCOMPLEX(array)) {
-            set_err("Argument to setData is not a numpy complex array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
-
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_cfloat *addr = (npy_cfloat*)(raw + i * data_size);
-            (*$self)[i] = cxfloat(addr->real, addr->imag);
-        }
+        std::valarray<float> data(0.0, nelements);
+        memcpy(&(data[0]), raw, nbytes);
+        $self->setData(data);
     }
 }
-%ignore ISMRMRD::NDArrayContainer<cxfloat>::getData;
-%ignore ISMRMRD::NDArrayContainer<cxfloat>::setData;
-
-%extend ISMRMRD::NDArrayContainer<cxdouble>
-{
-    PyObject* getData()
-    {
-        npy_intp dims[] = { $self->elements() };
-        PyObject *array = PyArray_SimpleNew(1, dims, NPY_CDOUBLE);
-
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        npy_intp raw_size = PyArray_NBYTES(array);
-
-        int i;
-        for (i = 0; i < $self->elements(); i++) {
-            npy_cdouble *addr = (npy_cdouble*)(raw + (i * data_size));
-            addr->real = (*self)[i].real();
-            addr->imag = (*self)[i].imag();
-        }
 
-        return array;
-    }
-
-    void setData(PyObject *array)
-    {
-        if (!PyArray_Check(array) || !PyArray_ISCOMPLEX(array)) {
-            set_err("Argument to setData is not a numpy complex array\n");
-            return;
-        } 
-
-        int ndim = PyArray_NDIM(array);
-        npy_intp *dims = PyArray_DIMS(array);
-        char *raw = PyArray_BYTES(array);
-        int data_size = PyArray_ITEMSIZE(array);
-        if (ndim != 1) {
-            set_err("Argument to setData must be a 1-D array\n");
-            return;
-        }
+%ignore ISMRMRD::Acquisition::getData;
+%ignore ISMRMRD::Acquisition::setData;
 
-        int i;
-        for (i = 0; i < dims[0]; i++) {
-            npy_cdouble *addr = (npy_cdouble*)(raw + i * data_size);
-            (*$self)[i] = cxdouble(addr->real, addr->imag);
-        }
-    }
-}
-%ignore ISMRMRD::NDArrayContainer<cxdouble>::getData;
-%ignore ISMRMRD::NDArrayContainer<cxdouble>::setData;
 
-//
 // IsmrmrdDataset
-//
-%rename(readImage_ushort)   readImage<unsigned short int>;
-%rename(readImage_float)    readImage<float>;
-%rename(readImage_double)   readImage<double>;
-%rename(readImage_cxfloat)  readImage<cxfloat>;
-%rename(readImage_cxdouble) readImage<cxdouble>;
-
-%rename(readArray_ushort)   readArray<unsigned short int>;
-%rename(readArray_float)    readArray<float>;
-%rename(readArray_double)   readArray<double>;
-%rename(readArray_cxfloat)  readArray<cxfloat>;
-%rename(readArray_cxdouble) readArray<cxdouble>;
 
 %extend ISMRMRD::IsmrmrdDataset {
+
+    // XML
     std::string readHeader() {
         boost::shared_ptr<std::string> hdr = $self->readHeader();
         return *(hdr.get()); 
     }
 
+    // Acquisition
     ISMRMRD::Acquisition* readAcquisition(unsigned long index = 0) {
         ISMRMRD::Acquisition* acq = new ISMRMRD::Acquisition(*$self->readAcquisition(index).get());
         return acq;
     }
 
+    // Image Header
     ISMRMRD::ImageHeader* readImageHeader(const char* varname, unsigned long index = 0) {
         ISMRMRD::ImageHeader* imghdr = new ISMRMRD::ImageHeader(*$self->readImageHeader(varname,index).get());
         return imghdr;
     }
 
-    // Image
-    ISMRMRD::Image<float>* readImage<float>(const char* varname, unsigned long index = 0) {
-        ISMRMRD::Image<float>* img = new ISMRMRD::Image<float>(*$self->readImage<float>(varname,index).get());
-        return img;
-    }
-
-    ISMRMRD::Image<double>* readImage<double>(const char* varname, unsigned long index = 0) {
-        ISMRMRD::Image<double>* img = new ISMRMRD::Image<double>(*$self->readImage<double>(varname,index).get());
-        return img;
-    }
-
-    ISMRMRD::Image<unsigned short int>* readImage<unsigned short>(const char* varname, unsigned long index = 0) {
-        ISMRMRD::Image<unsigned short>* img = new ISMRMRD::Image<unsigned short>(*$self->readImage<unsigned short>(varname,index).get());
-        return img;
-    }
-
-    ISMRMRD::Image<cxfloat>* readImage<cxfloat>(const char* varname, unsigned long index = 0) {
-        ISMRMRD::Image< cxfloat >* img = new ISMRMRD::Image< cxfloat >(*$self->readImage< cxfloat >(varname,index).get());
-        return img;
-    }
-
-    ISMRMRD::Image<cxdouble>* readImage<cxdouble>(const char* varname, unsigned long index = 0) {
-        ISMRMRD::Image<cxdouble>* img = new ISMRMRD::Image<cxdouble>(*$self->readImage<cxdouble>(varname,index).get());
-        return img;
-    }
-
-    // NDArray
-    ISMRMRD::NDArrayContainer<float>* readArray<float>(const char* varname, unsigned long index = 0) {
-        boost::shared_ptr< ISMRMRD::NDArrayContainer<float> > tmp = $self->readArray<float>(varname,index);
-        ISMRMRD::NDArrayContainer<float>* img = new ISMRMRD::NDArrayContainer<float>(tmp->dimensions_, tmp->data_);
-        return img;
-    }
-
-    ISMRMRD::NDArrayContainer<double>* readArray<double>(const char* varname, unsigned long index = 0) {
-        boost::shared_ptr< ISMRMRD::NDArrayContainer<double> > tmp = $self->readArray<double>(varname,index);
-        ISMRMRD::NDArrayContainer<double>* img = new ISMRMRD::NDArrayContainer<double>(tmp->dimensions_, tmp->data_);
-        return img;
-    }
-
-    ISMRMRD::NDArrayContainer<unsigned short>* readArray<unsigned short>(const char* varname, unsigned long index = 0) {
-        boost::shared_ptr< ISMRMRD::NDArrayContainer<unsigned short> > tmp = $self->readArray<unsigned short>(varname,index);
-        ISMRMRD::NDArrayContainer<unsigned short>* img = new ISMRMRD::NDArrayContainer<unsigned short>(tmp->dimensions_, tmp->data_);
-        return img;
-    }
+    // Image Data
+    PyObject* readArray(ISMRMRD::ImageHeader *hdr, const char* varname, unsigned long index = 0)
+    {
+        PyObject *array = NULL;
+        if (!hdr) {
+            return NULL;
+        }
 
-    ISMRMRD::NDArrayContainer< cxfloat >* readArray< cxfloat >(const char* varname, unsigned long index = 0) {
-        boost::shared_ptr< ISMRMRD::NDArrayContainer<cxfloat> >  tmp = $self->readArray< cxfloat >(varname,index);
-        ISMRMRD::NDArrayContainer<cxfloat>* img = new ISMRMRD::NDArrayContainer< cxfloat >(tmp->dimensions_, tmp->data_);
-        return img;
+        switch (hdr->image_data_type) {
+        case ISMRMRD::DATA_UNSIGNED_SHORT: {
+            return readTArray<unsigned short>($self, varname, index, NPY_USHORT);
+            break;
+        }
+        case ISMRMRD::DATA_FLOAT: {
+            return readTArray<float>($self, varname, index, NPY_FLOAT);
+            break;
+        }
+        case ISMRMRD::DATA_DOUBLE: {
+            return readTArray<double>($self, varname, index, NPY_DOUBLE);
+            break;
+        }
+        case ISMRMRD::DATA_COMPLEX_FLOAT: {
+            return readTArray<cxfloat>($self, varname, index, NPY_CFLOAT);
+            break;
+        }
+        case ISMRMRD::DATA_COMPLEX_DOUBLE: {
+            return readTArray<cxdouble>($self, varname, index, NPY_CDOUBLE);
+            break;
+        }
+        default:
+            array = NULL;
+        }
+        return array;
     }
 
-    ISMRMRD::NDArrayContainer<cxdouble>* readArray<cxdouble>(const char* varname, unsigned long index = 0) {
-        boost::shared_ptr< ISMRMRD::NDArrayContainer<cxdouble> > tmp = $self->readArray<cxdouble>(varname,index);
-        ISMRMRD::NDArrayContainer<cxdouble>* img = new ISMRMRD::NDArrayContainer<cxdouble>(tmp->dimensions_, tmp->data_);
-        return img;
+    int appendArray(PyObject *in_array, const char* varname)
+    {
+        if (!PyArray_Check((PyArrayObject*)in_array)) {
+            set_err("array arg to appendArray is not a numpy array\n");
+            return -1;
+        } else if (!PyArray_ISBEHAVED_RO((PyArrayObject*)in_array)) {
+            set_err("array arg to appendArray must be aligned and in machine byte-order\n");
+            return -1;
+        }
+
+        PyObject *array = NULL;
+        /* if in_array is C-style contiguous, make it a Fortran-style contiguous copy */
+        if (PyArray_ISCONTIGUOUS((PyArrayObject*)in_array)) {
+            array = PyArray_NewCopy((PyArrayObject*)in_array, NPY_FORTRANORDER);
+        } else {
+            array = in_array;
+        }
+
+        int ndim = PyArray_NDIM((PyArrayObject*)array);
+        npy_intp* dims = PyArray_DIMS((PyArrayObject*)array);
+
+        std::vector<unsigned int> dimensions;
+        for (int d = 0; d < ndim; d++) {
+            dimensions.push_back(dims[d]);
+        }
+
+        int ret = 0;
+        switch (PyArray_TYPE((PyArrayObject*)array)) {
+            case NPY_USHORT: {
+                npy_ushort *raw = (npy_ushort*)PyArray_DATA((PyArrayObject*)array);
+                ret = $self->appendArray(dimensions, raw, varname);
+                break;
+            }
+            case NPY_FLOAT: {
+                npy_float *raw = (npy_float*)PyArray_DATA((PyArrayObject*)array);
+                ret = $self->appendArray(dimensions, raw, varname);
+                break;
+            }
+            case NPY_DOUBLE: {
+                npy_double *raw = (npy_double*)PyArray_DATA((PyArrayObject*)array);
+                ret = $self->appendArray(dimensions, raw, varname);
+                break;
+            }
+            case NPY_CFLOAT: {
+                npy_cfloat *raw = (npy_cfloat*)PyArray_DATA((PyArrayObject*)array);
+                ret = $self->appendArray(dimensions, (std::complex<float>*)raw, varname);
+                break;
+            }
+            case NPY_CDOUBLE: {
+                npy_cdouble *raw = (npy_cdouble*)PyArray_DATA((PyArrayObject*)array);
+                ret = $self->appendArray(dimensions, (std::complex<float>*)raw, varname);
+                break;
+            }
+            default:
+                set_err("Invalid array dtype\n");
+                return -1;
+        }
+        return ret;
     }
 
 }
+
 %ignore readHeader;
 %ignore readAcquisition;
 %ignore readImageHeader;
 %ignore readImage;
 %ignore readArray;
+%ignore appendImage;
+%ignore appendArray;
 
-//
-// The header files to process
-//
+// Process the main ISMRMRD header
 %include "ismrmrd.h"
 
-// These defines are needed for the HDF5 stuff to work
+// These definitions are needed for the HDF5 stuff to work
 %define EXPORTISMRMRD %enddef
-namespace H5 {
-   
-}
+namespace H5 { }
 
+// Process the HDF5 ISMRMD headers
 %include "ismrmrd_hdf5.h"
 %include "ismrmrd_hdf5_datatypes.h"
-
-// Instantiate some of the overloaded objects and methods
-namespace ISMRMRD {
-    // The Image and ArrayContainer types
-    %template(Image_ushort)   Image<unsigned short int>;
-    %template(Image_float)    Image<float>;
-    %template(Image_double)   Image<double>;
-    %template(Image_cxfloat)  Image<cxfloat>;
-    %template(Image_cxdouble) Image<cxdouble>;
-
-    %template(Array_ushort)   NDArrayContainer<unsigned short int>;
-    %template(Array_float)    NDArrayContainer<float>;
-    %template(Array_double)   NDArrayContainer<double>;
-    %template(Array_cxfloat)  NDArrayContainer<cxfloat>;
-    %template(Array_cxdouble) NDArrayContainer<cxdouble>;
-
-    // The Image and ArrayContainer Append methods
-    %template(appendImage_ushort)   IsmrmrdDataset::appendImage<unsigned short int>;
-    %template(appendImage_float)    IsmrmrdDataset::appendImage<float>;
-    %template(appendImage_double)   IsmrmrdDataset::appendImage<double>;
-    %template(appendImage_cxfloat)  IsmrmrdDataset::appendImage<cxfloat>;
-    %template(appendImage_cxdouble) IsmrmrdDataset::appendImage<cxdouble>;
-
-    %template(appendArray_ushort)   IsmrmrdDataset::appendArray<unsigned short int>;
-    %template(appendArray_float)    IsmrmrdDataset::appendArray<float>;
-    %template(appendArray_double)   IsmrmrdDataset::appendArray<double>;
-    %template(appendArray_cxfloat)  IsmrmrdDataset::appendArray<cxfloat>;
-    %template(appendArray_cxdouble) IsmrmrdDataset::appendArray<cxdouble>;
-
-}
diff --git a/cmake/FindJava.cmake b/cmake/FindJava.cmake
new file mode 100644
index 0000000..4d6f888
--- /dev/null
+++ b/cmake/FindJava.cmake
@@ -0,0 +1,212 @@
+# - Find Java
+# This module finds if Java is installed and determines where the
+# include files and libraries are. This code sets the following
+# variables:
+#
+#  Java_JAVA_EXECUTABLE    = the full path to the Java runtime
+#  Java_JAVAC_EXECUTABLE   = the full path to the Java compiler
+#  Java_JAVAH_EXECUTABLE   = the full path to the Java header generator
+#  Java_JAVADOC_EXECUTABLE = the full path to the Java documention generator
+#  Java_XJC_EXECUTABLE     = the full path to the Java JAXB generator
+#  Java_JAR_EXECUTABLE     = the full path to the Java archiver
+#  Java_VERSION_STRING     = Version of the package found (java version), eg. 1.6.0_12
+#  Java_VERSION_MAJOR      = The major version of the package found.
+#  Java_VERSION_MINOR      = The minor version of the package found.
+#  Java_VERSION_PATCH      = The patch version of the package found.
+#  Java_VERSION_TWEAK      = The tweak version of the package found (after '_')
+#  Java_VERSION            = This is set to: $major.$minor.$patch(.$tweak)
+#
+# The minimum required version of Java can be specified using the
+# standard CMake syntax, e.g. find_package(Java 1.5)
+#
+# NOTE: ${Java_VERSION} and ${Java_VERSION_STRING} are not guaranteed to be
+# identical. For example some java version may return:
+# Java_VERSION_STRING = 1.5.0_17
+# and
+# Java_VERSION        = 1.5.0.17
+#
+# another example is the Java OEM, with:
+# Java_VERSION_STRING = 1.6.0-oem
+# and
+# Java_VERSION        = 1.6.0
+#
+# For these components the following variables are set:
+#
+#  Java_FOUND                    - TRUE if all components are found.
+#  Java_INCLUDE_DIRS             - Full paths to all include dirs.
+#  Java_LIBRARIES                - Full paths to all libraries.
+#  Java_<component>_FOUND        - TRUE if <component> is found.
+#
+# Example Usages:
+#  find_package(Java)
+#  find_package(Java COMPONENTS Runtime)
+#  find_package(Java COMPONENTS Development)
+#
+
+#=============================================================================
+# Copyright 2002-2009 Kitware, Inc.
+# Copyright 2009-2011 Mathieu Malaterre <mathieu.malaterre at gmail.com>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# The HINTS option should only be used for values computed from the system.
+set(_JAVA_HINTS
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\2.0;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.9;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.8;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.7;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.6;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.5;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.4;JavaHome]/bin"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.3;JavaHome]/bin"
+  $ENV{JAVA_HOME}/bin
+  )
+# Hard-coded guesses should still go in PATHS. This ensures that the user
+# environment can always override hard guesses.
+set(_JAVA_PATHS
+  /usr/lib/java/bin
+  /usr/share/java/bin
+  /usr/local/java/bin
+  /usr/local/java/share/bin
+  /usr/java/j2sdk1.4.2_04
+  /usr/lib/j2sdk1.4-sun/bin
+  /usr/java/j2sdk1.4.2_09/bin
+  /usr/lib/j2sdk1.5-sun/bin
+  /opt/sun-jdk-1.5.0.04/bin
+  )
+find_program(Java_JAVA_EXECUTABLE
+  NAMES java
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+if(Java_JAVA_EXECUTABLE)
+    execute_process(COMMAND ${Java_JAVA_EXECUTABLE} -version
+      RESULT_VARIABLE res
+      OUTPUT_VARIABLE var
+      ERROR_VARIABLE var # sun-java output to stderr
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_STRIP_TRAILING_WHITESPACE)
+    if( res )
+      if(${Java_FIND_REQUIRED})
+        message( FATAL_ERROR "Error executing java -version" )
+      else()
+        message( STATUS "Warning, could not run java --version")
+      endif()
+    else()
+      # extract major/minor version and patch level from "java -version" output
+      # Tested on linux using
+      # 1. Sun / Sun OEM
+      # 2. OpenJDK 1.6
+      # 3. GCJ 1.5
+      # 4. Kaffe 1.4.2
+      if(var MATCHES "java version \"[0-9]+\\.[0-9]+\\.[0-9_.]+.*\".*")
+        # This is most likely Sun / OpenJDK, or maybe GCJ-java compat layer
+        string( REGEX REPLACE ".* version \"([0-9]+\\.[0-9]+\\.[0-9_.]+.*)\".*"
+                "\\1" Java_VERSION_STRING "${var}" )
+      elseif(var MATCHES "java full version \"kaffe-[0-9]+\\.[0-9]+\\.[0-9_]+\".*")
+        # Kaffe style
+        string( REGEX REPLACE "java full version \"kaffe-([0-9]+\\.[0-9]+\\.[0-9_]+).*"
+                "\\1" Java_VERSION_STRING "${var}" )
+      else()
+        if(NOT Java_FIND_QUIETLY)
+          message(WARNING "regex not supported: ${var}. Please report")
+        endif()
+      endif()
+      string( REGEX REPLACE "([0-9]+).*" "\\1" Java_VERSION_MAJOR "${Java_VERSION_STRING}" )
+      string( REGEX REPLACE "[0-9]+\\.([0-9]+).*" "\\1" Java_VERSION_MINOR "${Java_VERSION_STRING}" )
+      string( REGEX REPLACE "[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" Java_VERSION_PATCH "${Java_VERSION_STRING}" )
+      # warning tweak version can be empty:
+      string( REGEX REPLACE "[0-9]+\\.[0-9]+\\.[0-9]+[_\\.]?([0-9]*).*$" "\\1" Java_VERSION_TWEAK "${Java_VERSION_STRING}" )
+      if( Java_VERSION_TWEAK STREQUAL "" ) # check case where tweak is not defined
+        set(Java_VERSION ${Java_VERSION_MAJOR}.${Java_VERSION_MINOR}.${Java_VERSION_PATCH})
+      else()
+        set(Java_VERSION ${Java_VERSION_MAJOR}.${Java_VERSION_MINOR}.${Java_VERSION_PATCH}.${Java_VERSION_TWEAK})
+      endif()
+    endif()
+
+endif()
+
+
+find_program(Java_JAR_EXECUTABLE
+  NAMES jar
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+find_program(Java_JAVAC_EXECUTABLE
+  NAMES javac
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+find_program(Java_XJC_EXECUTABLE
+  NAMES xjc
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+find_program(Java_JAVAH_EXECUTABLE
+  NAMES javah
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+find_program(Java_JAVADOC_EXECUTABLE
+  NAMES javadoc
+  HINTS ${_JAVA_HINTS}
+  PATHS ${_JAVA_PATHS}
+)
+
+include(FindPackageHandleStandardArgs)
+if(Java_FIND_COMPONENTS)
+  foreach(component ${Java_FIND_COMPONENTS})
+    # User just want to execute some Java byte-compiled
+    if(component STREQUAL "Runtime")
+      find_package_handle_standard_args(Java
+        REQUIRED_VARS Java_JAVA_EXECUTABLE
+        VERSION_VAR Java_VERSION
+        )
+    elseif(component STREQUAL "Development")
+      find_package_handle_standard_args(Java
+        REQUIRED_VARS Java_JAVA_EXECUTABLE Java_JAR_EXECUTABLE Java_JAVAC_EXECUTABLE
+                      Java_XJC_EXECUTABLE Java_JAVAH_EXECUTABLE Java_JAVADOC_EXECUTABLE
+        VERSION_VAR Java_VERSION
+        )
+    else()
+      message(FATAL_ERROR "Comp: ${component} is not handled")
+    endif()
+    set(Java_${component}_FOUND TRUE)
+  endforeach()
+else()
+  # Check for everything
+  find_package_handle_standard_args(Java
+    REQUIRED_VARS Java_JAVA_EXECUTABLE Java_JAR_EXECUTABLE Java_JAVAC_EXECUTABLE
+                  Java_XJC_EXECUTABLE Java_JAVAH_EXECUTABLE Java_JAVADOC_EXECUTABLE
+    VERSION_VAR Java_VERSION
+    )
+endif()
+
+
+mark_as_advanced(
+  Java_JAVA_EXECUTABLE
+  Java_JAR_EXECUTABLE
+  Java_JAVAC_EXECUTABLE
+  Java_XJC_EXECUTABLE
+  Java_JAVAH_EXECUTABLE
+  Java_JAVADOC_EXECUTABLE
+  )
+
+# LEGACY
+set(JAVA_RUNTIME ${Java_JAVA_EXECUTABLE})
+set(JAVA_ARCHIVE ${Java_JAR_EXECUTABLE})
+set(JAVA_COMPILE ${Java_JAVAC_EXECUTABLE})
+
diff --git a/cmake/FindNumPy.cmake b/cmake/FindNumPy.cmake
new file mode 100644
index 0000000..6feeb73
--- /dev/null
+++ b/cmake/FindNumPy.cmake
@@ -0,0 +1,101 @@
+# - Find the NumPy libraries
+# This module finds if NumPy is installed, and sets the following variables
+# indicating where it is.
+#
+# TODO: Update to provide the libraries and paths for linking npymath lib.
+#
+#  NUMPY_FOUND               - was NumPy found
+#  NUMPY_VERSION             - the version of NumPy found as a string
+#  NUMPY_VERSION_MAJOR       - the major version number of NumPy
+#  NUMPY_VERSION_MINOR       - the minor version number of NumPy
+#  NUMPY_VERSION_PATCH       - the patch version number of NumPy
+#  NUMPY_VERSION_DECIMAL     - e.g. version 1.6.1 is 10601
+#  NUMPY_INCLUDE_DIRS        - path to the NumPy include files
+
+#============================================================================
+# Copyright 2012 Continuum Analytics, Inc.
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+#============================================================================
+
+# Finding NumPy involves calling the Python interpreter
+if(NumPy_FIND_REQUIRED)
+    find_package(PythonInterp REQUIRED)
+else()
+    find_package(PythonInterp)
+endif()
+
+if(NOT PYTHONINTERP_FOUND)
+    set(NUMPY_FOUND FALSE)
+    return()
+endif()
+
+execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
+    "import numpy as n; print(n.__version__); print(n.get_include());"
+    RESULT_VARIABLE _NUMPY_SEARCH_SUCCESS
+    OUTPUT_VARIABLE _NUMPY_VALUES_OUTPUT
+    ERROR_VARIABLE _NUMPY_ERROR_VALUE
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+if(NOT _NUMPY_SEARCH_SUCCESS MATCHES 0)
+    if(NumPy_FIND_REQUIRED)
+        message(FATAL_ERROR
+            "NumPy import failure:\n${_NUMPY_ERROR_VALUE}")
+    endif()
+    set(NUMPY_FOUND FALSE)
+    return()
+endif()
+
+# Convert the process output into a list
+string(REGEX REPLACE ";" "\\\\;" _NUMPY_VALUES ${_NUMPY_VALUES_OUTPUT})
+string(REGEX REPLACE "\n" ";" _NUMPY_VALUES ${_NUMPY_VALUES})
+list(GET _NUMPY_VALUES 0 NUMPY_VERSION)
+list(GET _NUMPY_VALUES 1 NUMPY_INCLUDE_DIRS)
+
+string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" _VER_CHECK "${NUMPY_VERSION}")
+if("${_VER_CHECK}" STREQUAL "")
+    # The output from Python was unexpected. Raise an error always
+    # here, because we found NumPy, but it appears to be corrupted somehow.
+    message(FATAL_ERROR
+        "Requested version and include path from NumPy, got instead:\n${_NUMPY_VALUES_OUTPUT}\n")
+    return()
+endif()
+
+# Make sure all directory separators are '/'
+string(REGEX REPLACE "\\\\" "/" NUMPY_INCLUDE_DIRS ${NUMPY_INCLUDE_DIRS})
+
+# Get the major and minor version numbers
+string(REGEX REPLACE "\\." ";" _NUMPY_VERSION_LIST ${NUMPY_VERSION})
+list(GET _NUMPY_VERSION_LIST 0 NUMPY_VERSION_MAJOR)
+list(GET _NUMPY_VERSION_LIST 1 NUMPY_VERSION_MINOR)
+list(GET _NUMPY_VERSION_LIST 2 NUMPY_VERSION_PATCH)
+string(REGEX MATCH "[0-9]*" NUMPY_VERSION_PATCH ${NUMPY_VERSION_PATCH})
+math(EXPR NUMPY_VERSION_DECIMAL
+    "(${NUMPY_VERSION_MAJOR} * 10000) + (${NUMPY_VERSION_MINOR} * 100) + ${NUMPY_VERSION_PATCH}")
+
+find_package_message(NUMPY
+    "Found NumPy: version \"${NUMPY_VERSION}\" ${NUMPY_INCLUDE_DIRS}"
+    "${NUMPY_INCLUDE_DIRS}${NUMPY_VERSION}")
+
+set(NUMPY_FOUND TRUE)
+
diff --git a/cmake/FindXSD.cmake b/cmake/FindXSD.cmake
index ed83d61..59a8834 100644
--- a/cmake/FindXSD.cmake
+++ b/cmake/FindXSD.cmake
@@ -1,57 +1,26 @@
-# - Find CodeSource Xsd
-# This module can be used to find Xsd and it's include path
+# - Find CodeSynthesis XSD
+# This module can be used to find XSD and it's include path
 # Variables:
-#	XSD_EXECUTABLE
-#	XSD_INCLUDE_DIR
-#	XSD_FOUND
+#	XSD_FOUND - System has XSD
+#	XSD_EXECUTABLE - XSD binary executable
+#	XSD_INCLUDE_DIR - XSD include directory
+#
+# Functions:
+#       WRAP_XSD - Generates C++ bindings in the given output directory for a given schema file
 
-SET(XSD_FOUND FALSE)
+if(NOT DEFINED XSD_DIR AND DEFINED ENV{XSD_DIR})
+    set(XSD_DIR $ENV{XSD_DIR})
+endif(NOT DEFINED XSD_DIR AND DEFINED ENV{XSD_DIR})
 
-if(WIN32)
-	SET(__XSD_NAME xsd.exe)
-else(WIN32)
-	SET(__XSD_NAME xsdcxx xsd)
-endif(WIN32)
+find_program(XSD_EXECUTABLE NAMES xsd xsdcxx xsd.exe
+    PATHS ${XSD_DIR} /usr /usr/local
+    PATH_SUFFIXES bin
+)
 
-if(XSD_INCLUDE_DIR)
-	#in cache already
-	SET(XSD_FOUND TRUE)
-else(XSD_INCLUDE_DIR)
-	IF (WIN32) 
-	find_program(XSD_EXECUTABLE NAMES "bin/${__XSD_NAME}" "${__XSD_NAME}"
-	     PATHS
-		 ${XSD_DIR}
-		 ${XSD_DIR}/bin
-	)
-	ELSE(WIN32)
-	find_file(XSD_EXECUTABLE NAMES ${__XSD_NAME}
-	     PATHS
-	         /usr/local/bin
-		 /usr/bin
-		 ${XSD_DIR}
-		 ${XSD_DIR}/bin
-	)
-	ENDIF(WIN32)
-
-	if(XSD_EXECUTABLE)
-		SET(XSD_FOUND TRUE)
-	else(XSD_EXECUTABLE)
-		SET(XSD_EXECUTABLE "xsd-NOTFOUND" CACHE FILE "xsd executable path")
-	endif(XSD_EXECUTABLE)
-
-	find_path(XSD_INCLUDE_DIR NAMES xsd 
-	    PATHS
-		${XSD_DIR}/include
-		/usr/include
-		/usr/local/include
-	)
-
-	if(XSD_INCLUDE_DIR)
-		SET(XSD_FOUND TRUE)
-	else(XSD_INCLUDE_DIR)
-		SET(XSD_INCLUDE_DIR "xsd-include-NOTFOUND" CACHE PATH "xsd include path")
-	endif(XSD_INCLUDE_DIR)
-endif(XSD_INCLUDE_DIR)
+find_path(XSD_INCLUDE_DIR NAMES xsd/cxx/pre.hxx
+    PATHS ${XSD_DIR} /usr /usr/local
+    PATH_SUFFIXES include
+)
 
 FUNCTION(XSD_EXTRACT_OPTIONS _xsd_files _xsd_options)
 	foreach(current_arg ${ARGN})
@@ -94,3 +63,6 @@ FUNCTION(WRAP_XSD XSD_SRCS XSD_INCLUDES OUT_PATH)
 	SET(${XSD_SRCS} ${_XSD_SRCS} PARENT_SCOPE)
 ENDFUNCTION(WRAP_XSD)
 
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(XSD DEFAULT_MSG XSD_INCLUDE_DIR XSD_EXECUTABLE)
+mark_as_advanced(XSD_INCLUDE_DIR XSD_EXECUTABLE)
diff --git a/examples/java/ismrmrd_test.java b/examples/java/ismrmrd_test.java
index 07177ac..85b9fb7 100644
--- a/examples/java/ismrmrd_test.java
+++ b/examples/java/ismrmrd_test.java
@@ -5,42 +5,51 @@ public class ismrmrd_test {
 
     public static void main(String argv[]) {
         // Load the ISMRMRD JNI library
-	try {
-	    JNILibLoader.load();
-	}
-	catch (java.net.URISyntaxException e) {
-	    System.err.println("JNI Library failed to load: " + e.getMessage());
+        try {
+            JNILibLoader.load();
+        }
+        catch (java.net.URISyntaxException e) {
+            System.err.println("JNI Library failed to load: " + e.getMessage());
             System.exit(1);
-	}
-	
-	String filename = "";
-	if (argv.length == 1) {
-	    filename = argv[0];
-	}
-	else {
-	    System.err.println("Give me a filename.");
+        }
+
+        String filename = "";
+        if (argv.length == 1) {
+            filename = argv[0];
+        }
+        else {
+            System.err.println("Give me a filename.");
             System.exit(1);
-	}
-     
+        }
+
         IsmrmrdDataset f = new IsmrmrdDataset(filename, "/dataset");
         String xmlstring = f.readHeader();
-        System.out.println("The XML Header");
+
         System.out.println(xmlstring);
 
-	IsmrmrdHeader hdr = new IsmrmrdHeader();;
-	try {
-	    hdr = XMLString.StringToIsmrmrdHeader(xmlstring);
-	}
-	catch (javax.xml.bind.JAXBException e){
-	    System.err.println("XML Header could not be parsed." + e.getMessage());
+        IsmrmrdHeader hdr = new IsmrmrdHeader();
+        try {
+            hdr = XMLString.StringToIsmrmrdHeader(xmlstring);
+        } catch (javax.xml.bind.JAXBException e) {
+            System.err.format("XML Header could not be parsed.%n%s", e.getMessage());
             System.exit(1);
-	}
+        }
+
         long freq = hdr.getExperimentalConditions().getH1ResonanceFrequencyHz();
         System.out.format("%n%n The resonance frequency is %d.%n", freq);
 
         long nacq = f.getNumberOfAcquisitions();
         System.out.format("%n%n The number of Acquisitions is %d.%n", nacq);
 
+        String xmlcopy = "";
+        try {
+            xmlcopy = XMLString.IsmrmrdHeaderToString(hdr);
+        } catch (javax.xml.bind.JAXBException e) {
+            System.err.format("XML Header could not be generated.%n%s", e.getMessage());
+            System.exit(1);
+        }
+
+        System.out.println(xmlcopy);
     }
 
 }
diff --git a/examples/matlab/ismrmrd_header2struct.m b/examples/matlab/old/ismrmrd_header2struct.m
similarity index 100%
rename from examples/matlab/ismrmrd_header2struct.m
rename to examples/matlab/old/ismrmrd_header2struct.m
diff --git a/examples/matlab/old/simple_cartesian_recon.m b/examples/matlab/old/simple_cartesian_recon.m
new file mode 100644
index 0000000..08913f7
--- /dev/null
+++ b/examples/matlab/old/simple_cartesian_recon.m
@@ -0,0 +1,127 @@
+function [images] = simple_cartesian_recon(ismrmrdfile, dataset)
+%
+%   [images] = simple_cartesian_recon(ismrmrdfile, dataset)
+%
+%   Simple example of how to reconstruct a 2D/3D cartesian dataset stored
+%   in ISMRMRD dataformat. Reconstruction handles partial fourier,
+%   oversampling, etc. 
+%
+%   Michael S. Hansen (michael.hansen at nih.gov), 2012
+%   Souheil J. Inati  (souheil.inati at nih.gov),  2013
+%
+%   Usage notes:
+%     ismrmrdfile: string, required.
+%     dataset:     string, optional, default='dataset'
+%
+
+switch nargin
+    case 1
+        dset = 'dataset';
+    case 2
+        dset = dataset;
+    otherwise
+        error('Wrong number of input arguments.')
+end
+
+% Open the dataset
+f = ismrmrd.IsmrmrdDataset(ismrmrdfile, dset);
+
+% Is this a cartesian acquisition
+traj = f.xmlhdr.getEncoding.get(0).getTrajectory();
+if (~traj.equals(traj.CARTESIAN))
+   error('This is not a cartesian dataset'); 
+end
+
+% Get the matrix sizes and the number of slices and channels
+matrix_size = [f.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getX, ...
+               f.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getY, ...
+               f.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getZ];
+
+recon_size = [f.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getX, ...
+              f.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getY, ...
+              f.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getZ];
+
+if ~isempty(f.xmlhdr.getEncoding.get(0).getEncodingLimits.getSlice)
+    slices = f.xmlhdr.getEncoding.get(0).getEncodingLimits.getSlice;
+else
+    slices = 1;
+end
+
+channels = f.xmlhdr.getAcquisitionSystemInformation.getReceiverChannels.doubleValue;
+
+
+% Get the encoding centers
+center_line = f.xmlhdr.getEncoding.get(0).getEncodingLimits.getKspaceEncodingStep1.getCenter;
+if (matrix_size(3) > 1)
+    % 3D
+    center_partition = f.xmlhdr.getEncoding.get(0).getEncodingLimits.getKspaceEncodingStep2.getCenter;
+else
+    % 2D
+    center_partition = 0;
+end
+
+% Allocate a buffer for storing 1 repetition's worth of data
+buffer = zeros([matrix_size(1),matrix_size(2),matrix_size(3),slices,channels],'single');
+
+% Initalize the output
+images = [];
+
+% read all the acquisitions
+acq = f.readAcquisition();
+
+% Loop over all the acquisitions
+counter = 0;
+for p = 1:acq.getNumber()
+    
+    % ignore the noise scans
+    if acq.head.flagIsSet(acq.head.FLAGS.ACQ_IS_NOISE_MEASUREMENT,p)
+        continue
+    end
+
+    % stuff the data in the buffer
+    line_number      = int32(acq.head.idx.kspace_encode_step_1(p)) - center_line + matrix_size(2)/2 + 1;
+    if matrix_size(3) > 1
+        partition_number = int32(acq.head.idx.kspace_encode_step_2(p)) - center_partition + matrix_size(3)/2 + 1;
+    else
+        partition_number = 1;
+    end
+    slice_number     = acq.head.idx.slice(p) + 1;
+    buffer(:,line_number,partition_number,slice_number,:) = acq.data{p};
+    
+    % Is this the last in slice? We should make an image
+    if acq.head.flagIsSet(acq.head.FLAGS.ACQ_LAST_IN_SLICE,p)
+        counter = counter + 1;
+        fprintf('Reconstructing image %d\n', counter); 
+        fprintf('   slice: %d\n', slice_number); 
+        fprintf('   rep:   %d\n', acq.head.idx.repetition(p)+1); 
+
+        % FFT
+        img = fftshift(ifft(ifftshift(buffer(:,:,:,slice_number,:)),[],1)) ./ sqrt(size(buffer,1));
+        img = fftshift(ifft(ifftshift(img),[],2)) ./ sqrt(size(img,2));
+        if (matrix_size(3) > 1), 
+            img = fftshift(ifft(ifftshift(img),[],3)) ./ sqrt(size(img,3));
+        end
+
+        % Handle over-sampling
+        if matrix_size(3) > 1
+            img = img((1:recon_size(1)) + (matrix_size(1)-recon_size(1))/2, ...
+                      (1:recon_size(2)) + (matrix_size(2)-recon_size(2))/2, ...
+                      (1:recon_size(3)) + (matrix_size(3)-recon_size(3))/2, :);
+        else
+            img = img((1:recon_size(1)) + (matrix_size(1)-recon_size(1))/2, ...
+                      (1:recon_size(2)) + (matrix_size(2)-recon_size(2))/2, ...
+                      1, :);
+        end
+
+        % RMS coil combination
+        img = sqrt(sum(abs(img).^2,4));
+        
+        % Append to the output buffer
+        images(:,:,:,counter) = img;
+    end
+
+end
+fprintf('done\n'); 
+
+% Display the middle slice image
+% imagesc(images(:,:,bitshift(size(images,3),-1)+1, 1));colormap(gray);axis image;
diff --git a/examples/matlab/simple_gridder.m b/examples/matlab/old/simple_gridder.m
similarity index 100%
rename from examples/matlab/simple_gridder.m
rename to examples/matlab/old/simple_gridder.m
diff --git a/examples/matlab/simple_spiral_recon.m b/examples/matlab/old/simple_spiral_recon.m
similarity index 100%
rename from examples/matlab/simple_spiral_recon.m
rename to examples/matlab/old/simple_spiral_recon.m
diff --git a/examples/matlab/testsynth.m b/examples/matlab/old/testsynth.m
similarity index 100%
rename from examples/matlab/testsynth.m
rename to examples/matlab/old/testsynth.m
diff --git a/matlab/xml2struct.m b/examples/matlab/old/xml2struct.m
similarity index 100%
rename from matlab/xml2struct.m
rename to examples/matlab/old/xml2struct.m
diff --git a/examples/matlab/simple_cartesian_recon.m b/examples/matlab/simple_cartesian_recon.m
deleted file mode 100644
index 9e9daec..0000000
--- a/examples/matlab/simple_cartesian_recon.m
+++ /dev/null
@@ -1,82 +0,0 @@
-function [images] = simple_cartesian_recon(ismrmrdfile)
-%
-%   [images] = simple_cartesian_recon(ismrmrdfile)
-%
-%   Simple example of how to reconstruct a 2D/3D cartesian dataset stored
-%   in ISMRMRD dataformat. Reconstruction handles partial fourier,
-%   oversampling, etc. 
-%
-%   Michael S. Hansen (michael.hansen at nih.gov), 2012
-%
-
-
-%read the header
-header = ismrmrd_header2struct(h5read(ismrmrdfile,'/dataset/xml'));
-
-
-%Is this a cartesian acquisition
-if (~strcmp(header.ismrmrdHeader.encoding.trajectory.Text,'cartesian')),
-   error('This is not a cartesian dataset'); 
-end
-
-%if (str2num(header.ismrmrdHeader.encoding.encodedSpace.matrixSize.z.Text) <= 1),
-%    error('This is not a 3D dataset'); 
-%end
-    
-%Let's get the matrix size
-matrix_size = [str2num(header.ismrmrdHeader.encoding.encodedSpace.matrixSize.x.Text), ...
-               str2num(header.ismrmrdHeader.encoding.encodedSpace.matrixSize.y.Text), ...
-               str2num(header.ismrmrdHeader.encoding.encodedSpace.matrixSize.z.Text)];
-
-           
-recon_size = [str2num(header.ismrmrdHeader.encoding.reconSpace.matrixSize.x.Text), ...
-              str2num(header.ismrmrdHeader.encoding.reconSpace.matrixSize.y.Text), ...
-              str2num(header.ismrmrdHeader.encoding.reconSpace.matrixSize.z.Text)];
-
-
-%Let's load the data
-raw_data = h5read(ismrmrdfile,'/dataset/data');
-
-channels = max(raw_data.head.active_channels);
-samples = max(raw_data.head.number_of_samples);
-center_line = str2num(header.ismrmrdHeader.encoding.encodingLimits.kspace_encoding_step_1.center.Text);
-center_partition = str2num(header.ismrmrdHeader.encoding.encodingLimits.kspace_encoding_step_2.center.Text);
-
-if (samples ~= matrix_size(1)),
-    error('Mismatch between number of samples and matrix size');
-end
-
-buffer = zeros(matrix_size(1),matrix_size(2),matrix_size(3),channels);           
-counter = 0;
-for p=1:length(raw_data.head.flags),
-   if (bitget(uint64(raw_data.head.flags(p)),19)), %if this is noise, we will skip it
-      continue; 
-   end
-   line_number      = (int32(raw_data.head.idx.kspace_encode_step_1(p))-center_line)+bitshift(matrix_size(2),-1);  
-   partition_number = (int32(raw_data.head.idx.kspace_encode_step_2(p))-center_partition)+bitshift(matrix_size(3),-1);  
-   buffer(:,line_number+1,partition_number+1,:) = reshape(complex(raw_data.data{p}(1:2:end), raw_data.data{p}(2:2:end)), samples, 1, 1, channels);
-   
-   if (bitget(uint64(raw_data.head.flags(p)),8)), %Is this the last in slice? We should make an image
-      fprintf('Reconstructing image %d....', counter+1); 
-
-      img = fftshift(ifft(ifftshift(buffer),[],1)) ./ sqrt(size(buffer,1));
-      img = fftshift(ifft(ifftshift(img),[],2)) ./ sqrt(size(img,2));
-      if (matrix_size(3) > 1), 
-          img = fftshift(ifft(ifftshift(img),[],3)) ./ sqrt(size(img,3));
-      end
-      
-      img = img((1:recon_size(1))+bitshift(matrix_size(1)-recon_size(1),-1), ...
-                (1:recon_size(2))+bitshift(matrix_size(2)-recon_size(2),-1), ...
-                (1:recon_size(3))+bitshift(matrix_size(3)-recon_size(3),-1), :);
-      
-      images(:,:,:,counter+1) = sqrt(sum(abs(img).^2,4)); %RMS coil combination
-      counter = counter + 1;
-      fprintf('done\n'); 
-      buffer = zeros(matrix_size(1),matrix_size(2),matrix_size(3), channels);           
-   end  
-end
-
-%Let's just show the middle slice image
-imagesc(images(:,:,bitshift(size(images,3),-1)+1, 1));colormap(gray);axis image;
-
-
diff --git a/examples/matlab/test_create_dataset.m b/examples/matlab/test_create_dataset.m
new file mode 100644
index 0000000..a9c17f8
--- /dev/null
+++ b/examples/matlab/test_create_dataset.m
@@ -0,0 +1,170 @@
+%% Generating a simple ISMRMRD data set
+
+% This is an example of how to construct a datset from synthetic data
+% simulating a fully sampled acquisition on a cartesian grid.
+% data from 4 coils from a single slice object that looks like a square
+
+% File Name
+filename = 'testdata.h5';
+
+% Create an empty ismrmrd dataset
+if exist(filename,'file')
+    error(['File ' filename ' already exists.  Please remove first'])
+end
+dset = ismrmrd.IsmrmrdDataset(filename);
+
+% Synthesize the object
+nX = 256;
+nY = 256;
+rho = zeros(nX,nY);
+indxstart = floor(nX/4)+1;
+indxend   = floor(3*nX/4);
+indystart = floor(nY/4)+1;
+indyend   = floor(3*nY/4);
+rho(indxstart:indxend,indystart:indyend) = 1;
+
+% Synthesize some coil sensitivities
+[X,Y] = ndgrid((0:nX-1)/nX/2.0 - 0.5, (0:nY-1)/nY/2.0 - 0.5);
+C = zeros(nX,nY,4);
+C(:,:,1) = exp(-((X-.5).^2 + (Y).^2)    + 1i*(X-.5));
+C(:,:,2) = exp(-((X+.5).^2 + (Y).^2)    - 1i*(X+.5));
+C(:,:,3) = exp(-((X).^2    + (Y-.5).^2) + 1i*(Y-.5));
+C(:,:,4) = exp(-((X).^2    + (Y+.5).^2) - 1i*(Y+.5));
+nCoils = size(C,3);
+
+% Synthesize the k-space data
+nReps = 5;
+noiselevel = 0.05;
+K = zeros(nX, nY, nCoils, nReps);
+for rep = 1:nReps
+    for coil = 1:nCoils
+        noise = noiselevel * (randn(nX,nY)+1j*randn(nX,nY));
+        K(:,:,coil,rep) = fftshift(fft2(fftshift( C(:,:,coil).*rho + noise)));
+    end
+end
+
+% It is very slow to append one acquisition at a time, so we're going
+% to append a block of acquisitions at a time.
+% In this case, we'll do it one repetition at a time to show off this
+% feature.  Each block has nY aquisitions
+acqblock = ismrmrd.Acquisition(nY);
+
+% Set the header elements that don't change
+acqblock.head.version(:) = 1.0;
+acqblock.head.number_of_samples(:) = nX;
+acqblock.head.center_sample(:) = floor(nX/2);
+acqblock.head.active_channels(:) = nCoils;
+acqblock.head.read_dir  = repmat(single([1 0 0]'),[1 nY]);
+acqblock.head.phase_dir = repmat(single([0 1 0]'),[1 nY]);
+acqblock.head.slice_dir = repmat(single([0 0 1]'),[1 nY]);
+
+% Loop over the acquisitions, set the header, set the data and append
+for rep = 1:nReps
+    for acqno = 1:nY
+        
+        % Set the header elements that change from acquisition to the next
+        % c-style counting
+        acqblock.head.scan_counter(acqno) = (rep-1)*nY + acqno-1;
+        acqblock.head.idx.kspace_encode_step_1(acqno) = acqno-1; 
+        acqblock.head.idx.repetition(acqno) = rep - 1;
+        
+        % Set the flags
+        acqblock.head.flagClearAll(acqno);
+        if acqno == 1
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_FIRST_IN_ENCODE_STEP1, acqno);
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_FIRST_IN_SLICE, acqno);
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_FIRST_IN_REPETITION, acqno);
+        elseif acqno==size(K,2)
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_LAST_IN_ENCODE_STEP1, acqno);
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_LAST_IN_SLICE, acqno);
+            acqblock.head.flagSet(acqblock.head.FLAGS.ACQ_LAST_IN_REPETITION, acqno);
+        end
+        
+        % fill the data
+        acqblock.data{acqno} = squeeze(K(:,acqno,:,rep));
+    end
+
+    % Append the acquisition block
+    dset.appendAcquisition(acqblock);
+        
+end % rep loop
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%% Fill the xml header %
+%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% Experimental Conditions
+expcond = org.ismrm.ismrmrd.ExperimentalConditionsType;
+expcond.setH1ResonanceFrequencyHz(128000000); % 3T
+dset.xmlhdr.setExperimentalConditions(expcond);
+
+%% Acquisition System Information
+acqsysinfo = org.ismrm.ismrmrd.AcquisitionSystemInformationType;
+acqsysinfo.setReceiverChannels(java.lang.Integer(nCoils));
+dset.xmlhdr.setAcquisitionSystemInformation(acqsysinfo);
+
+%% The Encoding
+encoding = org.ismrm.ismrmrd.Encoding;
+encoding.setTrajectory(org.ismrm.ismrmrd.TrajectoryType.CARTESIAN);
+
+% Encoded Space
+fov = org.ismrm.ismrmrd.FieldOfViewMm;
+fov.setX(256);
+fov.setX(256);
+fov.setZ(5);
+matrix = org.ismrm.ismrmrd.MatrixSize;
+matrix.setX(size(K,1));
+matrix.setY(size(K,2));
+matrix.setZ(1);
+encodedspace = org.ismrm.ismrmrd.EncodingSpaceType;
+encodedspace.setMatrixSize(matrix);
+encodedspace.setFieldOfViewMm(fov);
+encoding.setEncodedSpace(encodedspace);
+
+% Recon Space
+% (same as encoding space)
+encoding.setReconSpace(encodedspace);
+
+% Encoding Limits
+% Be careful!!! All of the XML Header stuff is  JAVA so it is
+% being done with objects.  Make sure that you
+% create one object per thing you care about
+encodinglimits = org.ismrm.ismrmrd.EncodingLimitsType;
+
+limitsa = org.ismrm.ismrmrd.LimitType;
+limitsa.setMinimum(0);
+limitsa.setCenter(floor(size(K,1)/2)); 
+limitsa.setMaximum(size(K,1)-1); 
+encodinglimits.setKspaceEncodingStep0(limitsa);
+
+limitsb = org.ismrm.ismrmrd.LimitType;
+limitsb.setMinimum(0);
+limitsb.setCenter(floor(size(K,2)/2)); 
+limitsb.setMaximum(size(K,2)-1); 
+encodinglimits.setKspaceEncodingStep1(limitsb);
+
+limitsc = org.ismrm.ismrmrd.LimitType;
+limitsc.setMinimum(0);
+limitsc.setCenter(floor(nReps/2)); 
+limitsc.setMaximum(nReps-1);
+encodinglimits.setRepetition(limitsc);
+
+% All the rest are zero and we can use the same one for all of them
+limits = org.ismrm.ismrmrd.LimitType;
+limits.setMinimum(0);
+limits.setCenter(0); 
+limits.setMaximum(0);
+encodinglimits.setAverage(limits);
+encodinglimits.setContrast(limits);
+encodinglimits.setKspaceEncodingStep2(limits);
+encodinglimits.setPhase(limits);
+encodinglimits.setSegment(limits);
+encodinglimits.setSet(limits);
+encodinglimits.setSlice(limits);
+% Stuff
+encoding.setEncodingLimits(encodinglimits);
+dset.xmlhdr.getEncoding.add(encoding);
+
+%% Write the dataset
+dset.close();
diff --git a/examples/matlab/test_recon_dataset.m b/examples/matlab/test_recon_dataset.m
new file mode 100644
index 0000000..3cb0a16
--- /dev/null
+++ b/examples/matlab/test_recon_dataset.m
@@ -0,0 +1,158 @@
+%% Working with an existing ISMRMRD data set
+
+% This is a simple example of how to reconstruct images from data
+% acquired on a fully sampled cartesian grid
+%
+% Capabilities:
+%   2D/3D
+%   multiple slices/slabs
+%   multiple contrasts, repetitions
+%   
+% Limitations:
+%   only works with a single encoded space
+%   fully sampled k-space (no partial fourier or undersampling)
+%   doesn't handle averages, phases, segments and sets
+%   ignores noise scans (no pre-whitening)
+% 
+
+% We first create a data set using the example program like this:
+%   ismrmrd_generate_cartesian_shepp_logan -r 5 -C -o shepp-logan.h5
+% This will produce the file shepp-logan.h5 containing an ISMRMRD
+% dataset sampled evenly on the k-space grid -128:0.5:127.5 x -128:127
+% (i.e. oversampled by a factor of 2 in the readout direction)
+% with 8 coils, 5 repetitions and a noise level of 0.5
+% with a noise calibration scan at the beginning
+%
+%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
+% Loading an existing file %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
+filename = 'shepp-logan.h5';
+if exist(filename, 'file')
+    dset = ismrmrd.IsmrmrdDataset(filename, 'dataset');
+else
+    error(['File ' filename ' does not exist.  Please generate it.'])
+end
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Read some fields from the XML header %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% We need to check if optional fields exists before trying to read them
+% Some functions return java.lang.Integer type and we convert to double
+
+%% Encoding and reconstruction information
+% Matrix size
+enc_Nx = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getX;
+enc_Ny = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getY;
+enc_Nz = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getMatrixSize.getZ;
+rec_Nx = dset.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getX;
+rec_Ny = dset.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getY;
+rec_Nz = dset.xmlhdr.getEncoding.get(0).getReconSpace.getMatrixSize.getZ;
+
+% Field of View
+enc_FOVx = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getFieldOfViewMm.getX;
+enc_FOVy = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getFieldOfViewMm.getY;
+enc_FOVz = dset.xmlhdr.getEncoding.get(0).getEncodedSpace.getFieldOfViewMm.getZ;
+rec_FOVx = dset.xmlhdr.getEncoding.get(0).getReconSpace.getFieldOfViewMm.getX;
+rec_FOVy = dset.xmlhdr.getEncoding.get(0).getReconSpace.getFieldOfViewMm.getY;
+rec_FOVz = dset.xmlhdr.getEncoding.get(0).getReconSpace.getFieldOfViewMm.getZ;
+
+% Number of slices
+if isempty(dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getSlice)
+    nSlices = 1;
+else
+    nSlices = dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getSlice.getMaximum;
+end
+
+% Number of coils, in the system information
+nCoils = double(dset.xmlhdr.getAcquisitionSystemInformation.getReceiverChannels);
+
+% Repetitions, contrasts etc.
+if isempty(dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getRepetition)
+    nReps = 1;
+else
+    nReps = double(dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getRepetition.getMaximum);
+end
+
+if isempty(dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getContrast)
+    nContrasts = 1;
+else
+    nContrasts = double(dset.xmlhdr.getEncoding.get(0).getEncodingLimits.getContrast.getMaximum);
+end
+
+% TODO add the other possibilites
+
+%% Read all the data
+% Reading can be done one acquisition (or chunk) at a time, 
+% but this is much faster for data sets that fit into RAM.
+D = dset.readAcquisition();
+
+% Note: can select a single acquisition or header from the block, e.g.
+% acq = D.select(5);
+% hdr = D.head.select(5);
+% or you can work with them all together
+
+%% Ignore noise scans
+% TODO add a pre-whitening example
+% Find the first non-noise scan
+% This is how to check if a flag is set in the acquisition header
+isNoise = D.head.flagIsSet(D.head.FLAGS.ACQ_IS_NOISE_MEASUREMENT);
+firstScan = find(isNoise==0,1,'first');
+if firstScan > 1
+    noise = D.select(1:firstScan-1);
+else
+    noise = [];
+end
+meas  = D.select(firstScan:D.getNumber);
+clear D;
+
+%% Reconstruct images
+% Since the entire file is in memory we can use random access
+% Loop over repetitions, contrasts, slices
+reconImages = {};
+nimages = 0;
+for rep = 1:nReps
+    for contrast = 1:nContrasts
+        for slice = 1:nSlices
+            % Initialize the K-space storage array
+            K = zeros(enc_Nx, enc_Ny, enc_Nz, nCoils);
+            % Select the appropriate measurements from the data
+            acqs = find(  (meas.head.idx.contrast==(contrast-1)) ...
+                        & (meas.head.idx.repetition==(rep-1)) ...
+                        & (meas.head.idx.slice==(slice-1)));
+            for p = 1:length(acqs)
+                ky = meas.head.idx.kspace_encode_step_1(acqs(p)) + 1;
+                kz = meas.head.idx.kspace_encode_step_2(acqs(p)) + 1;
+                K(:,ky,kz,:) = meas.data{acqs(p)};
+            end
+            % Reconstruct in x
+            K = fftshift(ifft(fftshift(K,1),[],1),1);
+            % Chop if needed
+            if (enc_Nx == rec_Nx)
+                im = K;
+            else
+                ind1 = floor((enc_Nx - rec_Nx)/2)+1;
+                ind2 = floor((enc_Nx - rec_Nx)/2)+rec_Nx;
+                im = K(ind1:ind2,:,:,:);
+            end
+            % Reconstruct in y then z
+            im = fftshift(ifft(fftshift(im,2),[],2),2);
+            if size(im,3)>1
+                im = fftshift(ifft(fftshift(im,3),[],3),3);
+            end
+            
+            % Combine SOS across coils
+            im = sqrt(sum(abs(im).^2,4));
+            
+            % Append
+            nimages = nimages + 1;
+            reconImages{nimages} = im;
+        end
+    end
+end
+
+%% Display the first image
+figure
+colormap gray
+imagesc(reconImages{1}); axis image; axis off; colorbar;
diff --git a/ismrmrd.h b/ismrmrd.h
index 66cd880..9b3d031 100644
--- a/ismrmrd.h
+++ b/ismrmrd.h
@@ -46,7 +46,7 @@ typedef unsigned __int64 uint64_t;
 #define ISMRMRD_DIRECTION_LENGTH  3
 #define ISMRMRD_USER_INTS         8
 #define ISMRMRD_USER_FLOATS       8
-#define ISMRMRD_PHYS_STAMPS       8
+#define ISMRMRD_PHYS_STAMPS       8  //TODO: This should be changed to 3 (Major impact)
 #define ISMRMRD_CHANNEL_MASKS     16
 
 #ifdef __cplusplus
@@ -60,8 +60,8 @@ public:
    : bitmask_(0)
     {
       if (b > 0) {
-	bitmask_ = 1;
-	bitmask_ = (bitmask_ << (b-1));
+    bitmask_ = 1;
+    bitmask_ = (bitmask_ << (b-1));
       }
     }
   
@@ -76,40 +76,46 @@ public:
 
 /** ACQUISITION FLAGS */
 enum AcquisitionFlags {
-	/* Looping indicators */
-        ACQ_FIRST_IN_ENCODE_STEP1                        	= 1,
-	ACQ_LAST_IN_ENCODE_STEP1    				= 2,
-	ACQ_FIRST_IN_ENCODE_STEP2   				= 3,
-	ACQ_LAST_IN_ENCODE_STEP2    				= 4,
-	ACQ_FIRST_IN_AVERAGE        				= 5,
-	ACQ_LAST_IN_AVERAGE         				= 6,
-	ACQ_FIRST_IN_SLICE          				= 7,
-	ACQ_LAST_IN_SLICE           				= 8,
-	ACQ_FIRST_IN_CONTRAST       				= 9,
-	ACQ_LAST_IN_CONTRAST        				= 10,
-	ACQ_FIRST_IN_PHASE          				= 11,
-	ACQ_LAST_IN_PHASE           				= 12,
-	ACQ_FIRST_IN_REPETITION     				= 13,
-	ACQ_LAST_IN_REPETITION      				= 14,
-	ACQ_FIRST_IN_SET            				= 15,
-	ACQ_LAST_IN_SET             				= 16,
-	ACQ_FIRST_IN_SEGMENT        				= 17,
-	ACQ_LAST_IN_SEGMENT         				= 18,
-
-	ACQ_IS_NOISE_MEASUREMENT                  	        = 19,
-	ACQ_IS_PARALLEL_CALIBRATION             	= 20,
-	ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING 	= 21,
-	ACQ_IS_REVERSE              				= 22,
-	ACQ_IS_NAVIGATION_DATA      				= 23,
-
-	ACQ_USER1                   				= 57,
-	ACQ_USER2                   				= 58,
-	ACQ_USER3                   				= 59,
-	ACQ_USER4                   				= 60,
-	ACQ_USER5                   				= 61,
-	ACQ_USER6                   				= 62,
-	ACQ_USER7                   				= 63,
-	ACQ_USER8                   				= 64
+    /* Looping indicators */
+    ACQ_FIRST_IN_ENCODE_STEP1                   = 1,
+    ACQ_LAST_IN_ENCODE_STEP1                    = 2,
+    ACQ_FIRST_IN_ENCODE_STEP2                   = 3,
+    ACQ_LAST_IN_ENCODE_STEP2                    = 4,
+    ACQ_FIRST_IN_AVERAGE                        = 5,
+    ACQ_LAST_IN_AVERAGE                         = 6,
+    ACQ_FIRST_IN_SLICE                          = 7,
+    ACQ_LAST_IN_SLICE                           = 8,
+    ACQ_FIRST_IN_CONTRAST                       = 9,
+    ACQ_LAST_IN_CONTRAST                        = 10,
+    ACQ_FIRST_IN_PHASE                          = 11,
+    ACQ_LAST_IN_PHASE                           = 12,
+    ACQ_FIRST_IN_REPETITION                     = 13,
+    ACQ_LAST_IN_REPETITION                      = 14,
+    ACQ_FIRST_IN_SET                            = 15,
+    ACQ_LAST_IN_SET                             = 16,
+    ACQ_FIRST_IN_SEGMENT                        = 17,
+    ACQ_LAST_IN_SEGMENT                         = 18,
+
+    ACQ_LAST_IN_MEASUREMENT                     = 25,
+
+    ACQ_IS_NOISE_MEASUREMENT                    = 19,
+    ACQ_IS_PARALLEL_CALIBRATION                 = 20,
+    ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING     = 21,
+    ACQ_IS_REVERSE                              = 22,
+    ACQ_IS_NAVIGATION_DATA                      = 23,
+    ACQ_IS_PHASECORR_DATA                       = 24,
+    ACQ_IS_RTFEEDBACK_DATA                      = 25,
+    ACQ_IS_HPFEEDBACK_DATA                      = 26,
+    ACQ_IS_DUMMYSCAN_DATA                       = 27,
+
+    ACQ_USER1                                   = 57,
+    ACQ_USER2                                   = 58,
+    ACQ_USER3                                   = 59,
+    ACQ_USER4                                   = 60,
+    ACQ_USER5                                   = 61,
+    ACQ_USER6                                   = 62,
+    ACQ_USER7                                   = 63,
+    ACQ_USER8                                   = 64
 };
 
 /**
@@ -117,16 +123,16 @@ enum AcquisitionFlags {
 
  */
 typedef struct EncodingCounters {
-	uint16_t kspace_encode_step_1;     /**< e.g. phase encoding line number */
-	uint16_t kspace_encode_step_2;     /**< e.g. partition encodning number */
-	uint16_t average;                  /**< e.g. signal average number */
-	uint16_t slice;                    /**< e.g. imaging slice number */
-	uint16_t contrast;                 /**< e.g. echo number in multi-echo */
-	uint16_t phase;                    /**< e.g. cardiac phase number */
-	uint16_t repetition;               /**< e.g. dynamic number for dynamic scanning */
-	uint16_t set;                      /**< e.g. flow encodning set */
-	uint16_t segment;                  /**< e.g. segment number for segmented acquisition */
-	uint16_t user[ISMRMRD_USER_INTS];  /**< Free user parameters */
+    uint16_t kspace_encode_step_1;     /**< e.g. phase encoding line number */
+    uint16_t kspace_encode_step_2;     /**< e.g. partition encodning number */
+    uint16_t average;                  /**< e.g. signal average number */
+    uint16_t slice;                    /**< e.g. imaging slice number */
+    uint16_t contrast;                 /**< e.g. echo number in multi-echo */
+    uint16_t phase;                    /**< e.g. cardiac phase number */
+    uint16_t repetition;               /**< e.g. dynamic number for dynamic scanning */
+    uint16_t set;                      /**< e.g. flow encodning set */
+    uint16_t segment;                  /**< e.g. segment number for segmented acquisition */
+    uint16_t user[ISMRMRD_USER_INTS];  /**< Free user parameters */
 } EncodingCounters;
 
 /**
@@ -134,62 +140,62 @@ typedef struct EncodingCounters {
  */
 typedef struct AcquisitionHeader
 {
-	uint16_t           version;                                          /**< First unsigned int indicates the version */
-	uint64_t           flags;                                            /**< bit field with flags */
-	uint32_t           measurement_uid;                                  /**< Unique ID for the measurement */
-	uint32_t           scan_counter;                                     /**< Current acquisition number in the measurement */
-	uint32_t           acquisition_time_stamp;                           /**< Acquisition clock */
-	uint32_t           physiology_time_stamp[ISMRMRD_PHYS_STAMPS];       /**< Physiology time stamps, e.g. ecg, breating, etc. */
-	uint16_t           number_of_samples;                                /**< Number of samples acquired */
-	uint16_t           available_channels;                               /**< Available coils */
-	uint16_t           active_channels;                                  /**< Active coils on current acquisiton */
-	uint64_t           channel_mask[ISMRMRD_CHANNEL_MASKS];              /**< Mask to indicate which channels are active. Support for 1024 channels */
-	uint16_t           discard_pre;                                      /**< Samples to be discarded at the beginning of acquisition */
-	uint16_t           discard_post;                                     /**< Samples to be discarded at the end of acquisition */
-	uint16_t           center_sample;                                    /**< Sample at the center of k-space */
-	uint16_t           encoding_space_ref;                               /**< Reference to an encoding space, typically only one per acquisition */
-	uint16_t           trajectory_dimensions;                            /**< Indicates the dimensionality of the trajectory vector (0 means no trajectory) */
-	float              sample_time_us;                                   /**< Time between samples in micro seconds, sampling BW */
-	float              position[ISMRMRD_POSITION_LENGTH];                /**< Three-dimensional spatial offsets from isocenter */
-	float              read_dir[ISMRMRD_DIRECTION_LENGTH];               /**< Directional cosines of the readout/frequency encoding */
-	float              phase_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the phase */
-	float              slice_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the slice direction */
-	float              patient_table_position[ISMRMRD_POSITION_LENGTH];  /**< Patient table off-center */
-	EncodingCounters   idx;                                              /**< Encoding loop counters, see above */
-	int32_t            user_int[ISMRMRD_USER_INTS];                      /**< Free user parameters */
-	float              user_float[ISMRMRD_USER_FLOATS];                  /**< Free user parameters */
+    uint16_t           version;                                          /**< First unsigned int indicates the version */
+    uint64_t           flags;                                            /**< bit field with flags */
+    uint32_t           measurement_uid;                                  /**< Unique ID for the measurement */
+    uint32_t           scan_counter;                                     /**< Current acquisition number in the measurement */
+    uint32_t           acquisition_time_stamp;                           /**< Acquisition clock */
+    uint32_t           physiology_time_stamp[ISMRMRD_PHYS_STAMPS];       /**< Physiology time stamps, e.g. ecg, breating, etc. */
+    uint16_t           number_of_samples;                                /**< Number of samples acquired */
+    uint16_t           available_channels;                               /**< Available coils */
+    uint16_t           active_channels;                                  /**< Active coils on current acquisiton */
+    uint64_t           channel_mask[ISMRMRD_CHANNEL_MASKS];              /**< Mask to indicate which channels are active. Support for 1024 channels */
+    uint16_t           discard_pre;                                      /**< Samples to be discarded at the beginning of acquisition */
+    uint16_t           discard_post;                                     /**< Samples to be discarded at the end of acquisition */
+    uint16_t           center_sample;                                    /**< Sample at the center of k-space */
+    uint16_t           encoding_space_ref;                               /**< Reference to an encoding space, typically only one per acquisition */
+    uint16_t           trajectory_dimensions;                            /**< Indicates the dimensionality of the trajectory vector (0 means no trajectory) */
+    float              sample_time_us;                                   /**< Time between samples in micro seconds, sampling BW */
+    float              position[ISMRMRD_POSITION_LENGTH];                /**< Three-dimensional spatial offsets from isocenter */
+    float              read_dir[ISMRMRD_DIRECTION_LENGTH];               /**< Directional cosines of the readout/frequency encoding */
+    float              phase_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the phase */
+    float              slice_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the slice direction */
+    float              patient_table_position[ISMRMRD_POSITION_LENGTH];  /**< Patient table off-center */
+    EncodingCounters   idx;                                              /**< Encoding loop counters, see above */
+    int32_t            user_int[ISMRMRD_USER_INTS];                      /**< Free user parameters */
+    float              user_float[ISMRMRD_USER_FLOATS];                  /**< Free user parameters */
 } AcquisitionHeader;
 
 enum ImageDataType
 {
-	DATA_FLOAT = 1,
-	DATA_DOUBLE,
-	DATA_COMPLEX_FLOAT,
-	DATA_COMPLEX_DOUBLE,
-	DATA_UNSIGNED_SHORT
+    DATA_FLOAT = 1,
+    DATA_DOUBLE,
+    DATA_COMPLEX_FLOAT,
+    DATA_COMPLEX_DOUBLE,
+    DATA_UNSIGNED_SHORT
 };
 
 enum ImageType
 {
-	TYPE_MAGNITUDE = 1,
-	TYPE_PHASE,
-	TYPE_REAL,
-	TYPE_IMAG,
-	TYPE_COMPLEX
+    TYPE_MAGNITUDE = 1,
+    TYPE_PHASE,
+    TYPE_REAL,
+    TYPE_IMAG,
+    TYPE_COMPLEX
 };
 
 /** IMAGE FLAGS */
 enum ImageFlags {
-	IMAGE_IS_NAVIGATION_DATA      				= 23,
-
-	IMAGE_USER1                   				= 57,
-	IMAGE_USER2                   				= 58,
-	IMAGE_USER3                   				= 59,
-	IMAGE_USER4                   				= 60,
-	IMAGE_USER5                   				= 61,
-	IMAGE_USER6                   				= 62,
-	IMAGE_USER7                   				= 63,
-	IMAGE_USER8                   				= 64
+    IMAGE_IS_NAVIGATION_DATA                      = 23,
+
+    IMAGE_USER1                                   = 57,
+    IMAGE_USER2                                   = 58,
+    IMAGE_USER3                                   = 59,
+    IMAGE_USER4                                   = 60,
+    IMAGE_USER5                                   = 61,
+    IMAGE_USER6                                   = 62,
+    IMAGE_USER7                                   = 63,
+    IMAGE_USER8                                   = 64
 };
 
 /**
@@ -197,31 +203,31 @@ enum ImageFlags {
  */
 typedef struct ImageHeader
 {
-	uint16_t            version;                                         /**< First unsigned int indicates the version */
-	uint64_t            flags;                                           /**< bit field with flags */
-	uint32_t            measurement_uid;                                 /**< Unique ID for the measurement  */
-	uint16_t            matrix_size[3];                                  /**< Pixels in the 3 spatial dimensions */
-	float               field_of_view[3];                                /**< Size (in mm) of the 3 spatial dimensions */
-	uint16_t            channels;                                        /**< Number of receive channels */
-	float               position[ISMRMRD_POSITION_LENGTH];               /**< Three-dimensional spatial offsets from isocenter */
-	float               read_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the readout/frequency encoding */
-	float               phase_dir[ISMRMRD_DIRECTION_LENGTH];             /**< Directional cosines of the phase */
-	float               slice_dir[ISMRMRD_DIRECTION_LENGTH];             /**< Directional cosines of the slice direction */
-	float               patient_table_position[ISMRMRD_POSITION_LENGTH]; /**< Patient table off-center */
-	uint16_t            average;                                         /**< e.g. signal average number */
-	uint16_t            slice;                                           /**< e.g. imaging slice number */
-	uint16_t            contrast;                                        /**< e.g. echo number in multi-echo */
-	uint16_t            phase;                                           /**< e.g. cardiac phase number */
-	uint16_t            repetition;                                      /**< e.g. dynamic number for dynamic scanning */
-	uint16_t            set;                                             /**< e.g. flow encodning set */
-	uint32_t            acquisition_time_stamp;                          /**< Acquisition clock */
-	uint32_t            physiology_time_stamp[ISMRMRD_PHYS_STAMPS];      /**< Physiology time stamps, e.g. ecg, breating, etc. */
-	uint16_t            image_data_type;                                 /**< e.g. unsigned short, float, complex float, etc. */
-	uint16_t            image_type;                                      /**< e.g. magnitude, phase, complex, real, imag, etc. */
-	uint16_t            image_index;					                 /**< e.g. image number in series of images  */
-	uint16_t            image_series_index;                              /**< e.g. series number */
-	int32_t             user_int[ISMRMRD_USER_INTS];                     /**< Free user parameters */
-	float               user_float[ISMRMRD_USER_FLOATS];                 /**< Free user parameters */
+    uint16_t            version;                                         /**< First unsigned int indicates the version */
+    uint64_t            flags;                                           /**< bit field with flags */
+    uint32_t            measurement_uid;                                 /**< Unique ID for the measurement  */
+    uint16_t            matrix_size[3];                                  /**< Pixels in the 3 spatial dimensions */
+    float               field_of_view[3];                                /**< Size (in mm) of the 3 spatial dimensions */
+    uint16_t            channels;                                        /**< Number of receive channels */
+    float               position[ISMRMRD_POSITION_LENGTH];               /**< Three-dimensional spatial offsets from isocenter */
+    float               read_dir[ISMRMRD_DIRECTION_LENGTH];              /**< Directional cosines of the readout/frequency encoding */
+    float               phase_dir[ISMRMRD_DIRECTION_LENGTH];             /**< Directional cosines of the phase */
+    float               slice_dir[ISMRMRD_DIRECTION_LENGTH];             /**< Directional cosines of the slice direction */
+    float               patient_table_position[ISMRMRD_POSITION_LENGTH]; /**< Patient table off-center */
+    uint16_t            average;                                         /**< e.g. signal average number */
+    uint16_t            slice;                                           /**< e.g. imaging slice number */
+    uint16_t            contrast;                                        /**< e.g. echo number in multi-echo */
+    uint16_t            phase;                                           /**< e.g. cardiac phase number */
+    uint16_t            repetition;                                      /**< e.g. dynamic number for dynamic scanning */
+    uint16_t            set;                                             /**< e.g. flow encodning set */
+    uint32_t            acquisition_time_stamp;                          /**< Acquisition clock */
+    uint32_t            physiology_time_stamp[ISMRMRD_PHYS_STAMPS];      /**< Physiology time stamps, e.g. ecg, breating, etc. */
+    uint16_t            image_data_type;                                 /**< e.g. unsigned short, float, complex float, etc. */
+    uint16_t            image_type;                                      /**< e.g. magnitude, phase, complex, real, imag, etc. */
+    uint16_t            image_index;                                     /**< e.g. image number in series of images  */
+    uint16_t            image_series_index;                              /**< e.g. series number */
+    int32_t             user_int[ISMRMRD_USER_INTS];                     /**< Free user parameters */
+    float               user_float[ISMRMRD_USER_FLOATS];                 /**< Free user parameters */
 } ImageHeader;
 
 #ifdef __cplusplus
@@ -231,50 +237,50 @@ typedef struct ImageHeader
 template <typename T> class NDArrayContainer {
 
 public:
-	NDArrayContainer() {}
+    NDArrayContainer() {}
 
     /**
      * @brief Construct with dimensions and data
      */
-	NDArrayContainer(const std::vector<unsigned int>& dimensions) {
-		dimensions_ = dimensions;
-		data_.resize(elements());
-	}
+    NDArrayContainer(const std::vector<unsigned int>& dimensions) {
+        dimensions_ = dimensions;
+        data_.resize(elements());
+    }
 
     /**
      * @brief Construct with dimensions and data
      */
-	NDArrayContainer(const std::vector<unsigned int>& dimensions, const T* d) {
-		dimensions_ = dimensions;
-		data_.resize(elements());
-		memcpy(&data_[0],d,sizeof(T)*elements());
-	}
+    NDArrayContainer(const std::vector<unsigned int>& dimensions, const T* d) {
+        dimensions_ = dimensions;
+        data_.resize(elements());
+        memcpy(&data_[0],d,sizeof(T)*elements());
+    }
 
     /**
      * @brief Construct with dimensions and preset value
      */
-	NDArrayContainer(const std::vector<unsigned int>& dimensions, const std::valarray<T>& t) {
-		dimensions_ = dimensions;
-		data_.resize(elements());
-		data_ = t;
-	}
-
-	virtual ~NDArrayContainer() {}
-
-	std::vector<unsigned int> dimensions_; /**< Array with dimensions of the array. First dimension is fastest moving in the array */
-	std::valarray<T> data_;               /**< The data itself. A vector is used here for easy memory management                  */
-
-	size_t elements() const {
-		if (dimensions_.size() == 0) {
-			return 0;
-		}
-		size_t elements = 1;
-		std::vector<unsigned int>::const_iterator it = dimensions_.begin();
-		while (it != dimensions_.end()) {
-			elements *= *(it++);
-		}
-		return elements;
-	}
+    NDArrayContainer(const std::vector<unsigned int>& dimensions, const std::valarray<T>& t) {
+        dimensions_ = dimensions;
+        data_.resize(elements());
+        data_ = t;
+    }
+
+    virtual ~NDArrayContainer() {}
+
+    std::vector<unsigned int> dimensions_; /**< Array with dimensions of the array. First dimension is fastest moving in the array */
+    std::valarray<T> data_;               /**< The data itself. A vector is used here for easy memory management                  */
+
+    size_t elements() const {
+        if (dimensions_.size() == 0) {
+            return 0;
+        }
+        size_t elements = 1;
+        std::vector<unsigned int>::const_iterator it = dimensions_.begin();
+        while (it != dimensions_.end()) {
+            elements *= *(it++);
+        }
+        return elements;
+    }
 
     T& operator[] (const size_t& p) {
         return data_[p];
@@ -292,16 +298,16 @@ public:
         data_.resize(s,t);
     }
 
-	bool is_consistent() const {
-		return (elements() == data_.size());
-	}
+    bool is_consistent() const {
+        return (elements() == data_.size());
+    }
 
-	size_t ndims() const {
-		size_t i = 1, n_dimensions = 1;
-		for (; i < dimensions_.size(); i++)
-			n_dimensions += (size_t) (dimensions_[i] > 1);
-		return n_dimensions;
-	}
+    size_t ndims() const {
+        size_t i = 1, n_dimensions = 1;
+        for (; i < dimensions_.size(); i++)
+            n_dimensions += (size_t) (dimensions_[i] > 1);
+        return n_dimensions;
+    }
 
 };
 
@@ -312,227 +318,227 @@ template <typename T>
 class Image {
 
 public:
-	Image(unsigned int matrix_size_x = 0,
-		  unsigned int matrix_size_y = 1,
-		  unsigned int matrix_size_z = 1,
-		  unsigned int channels      = 1)
+    Image(unsigned int matrix_size_x = 0,
+          unsigned int matrix_size_y = 1,
+          unsigned int matrix_size_z = 1,
+          unsigned int channels      = 1)
     {
-		memset(&head_,0,sizeof(ImageHeader));
-		head_.version = ISMRMRD_VERSION;
+        memset(&head_,0,sizeof(ImageHeader));
+        head_.version = ISMRMRD_VERSION;
         head_.matrix_size[0] = matrix_size_x;
         head_.matrix_size[1] = matrix_size_y;
         head_.matrix_size[2] = matrix_size_z;
         head_.channels       = channels;
         setSpecificDataType();
         makeConsistent();
-	}
+    }
 
 
     Image(const Image& a) {   // copy constructor
-		if (this != &a) {
+        if (this != &a) {
             head_ = a.head_;
             this->data_ = a.data_;
             makeConsistent();
-		}
-	}
+        }
+    }
 
-	Image& operator=(const Image& a) {
-		if (this != &a) {
+    Image& operator=(const Image& a) {
+        if (this != &a) {
             head_ = a.head_;
             this->data_ = a.data_;
             makeConsistent();
-		}
-		return *this;
-	}
+        }
+        return *this;
+    }
 
-	~Image() {}
+    ~Image() {}
 
-	bool isFlagSet(FlagBit& f) const {
-		return f.isSet(head_.flags);
-	}
+    bool isFlagSet(FlagBit& f) const {
+        return f.isSet(head_.flags);
+    }
 
-	void setFlag(FlagBit& f) {
-		head_.flags |= f.bitmask_;
-	}
+    void setFlag(FlagBit& f) {
+        head_.flags |= f.bitmask_;
+    }
 
-	size_t getNumberOfElements() const {
-		return head_.matrix_size[0]*
+    size_t getNumberOfElements() const {
+        return head_.matrix_size[0]*
             head_.matrix_size[1]*
             head_.matrix_size[2]*
             head_.channels;
-	}
+    }
+
+
+    uint32_t getAcquisitionTimeStamp() const {
+        return head_.acquisition_time_stamp;
+    }
+
+    void setAcquisitionTimeStamp(uint32_t acquisitionTimeStamp) {
+        head_.acquisition_time_stamp = acquisitionTimeStamp;
+    }
+
+    uint16_t getAverage() const {
+        return head_.average;
+    }
+
+    void setAverage(uint16_t average) {
+        this->head_.average = average;
+    }
+
+    uint16_t getChannels() const {
+        return head_.channels;
+    }
+
+    void setChannels(uint16_t channels) {
+        this->head_.channels = channels;
+    }
+
+    uint16_t getContrast() const {
+        return head_.contrast;
+    }
+
+    void setContrast(uint16_t contrast) {
+        this->head_.contrast = contrast;
+    }
+
+    float getFieldOfViewX() const {
+        return head_.field_of_view[0];
+    }
+
+    void setFieldOfViewX(float f) {
+        head_.field_of_view[0] = f;
+    }
+
+    float getFieldOfViewY() const {
+        return head_.field_of_view[1];
+    }
+
+    void setFieldOfViewY(float f) {
+        head_.field_of_view[1] = f;
+    }
+
+    float getFieldOfViewZ() const {
+        return head_.field_of_view[2];
+    }
+
+    void setFieldOfViewZ(float f) {
+        head_.field_of_view[2] = f;
+    }
+
+    uint64_t getFlags() const {
+        return head_.flags;
+    }
+
+    void setFlags(uint64_t flags) {
+        this->head_.flags = flags;
+    }
+
+    uint16_t getImageDataType() const {
+        return head_.image_data_type;
+    }
+
+    void setImageDataType(uint16_t imageDataType) {
+        head_.image_data_type = imageDataType;
+    }
+
+    uint16_t getImageIndex() const {
+        return head_.image_index;
+    }
+
+    void setImageIndex(uint16_t imageIndex) {
+        head_.image_index = imageIndex;
+    }
+
+    uint16_t getImageSeriesIndex() const {
+        return head_.image_series_index;
+    }
+
+    void setImageSeriesIndex(uint16_t imageSeriesIndex) {
+        head_.image_series_index = imageSeriesIndex;
+    }
+
+    uint16_t getImageType() const {
+        return head_.image_type;
+    }
+
+    void setImageType(uint16_t imageType) {
+        head_.image_type = imageType;
+    }
 
+    uint16_t getMatrixSizeX() const {
+        return head_.matrix_size[0];
+    }
 
-	uint32_t getAcquisitionTimeStamp() const {
-		return head_.acquisition_time_stamp;
-	}
+    void setMatrixSizeX(uint16_t s) {
+        head_.matrix_size[0] = s;
+        makeConsistent();
+    }
 
-	void setAcquisitionTimeStamp(uint32_t acquisitionTimeStamp) {
-		head_.acquisition_time_stamp = acquisitionTimeStamp;
-	}
+    uint16_t getMatrixSizeY() const {
+        return head_.matrix_size[1];
+    }
 
-	uint16_t getAverage() const {
-		return head_.average;
-	}
+    void setMatrixSizeY(uint16_t s) {
+        head_.matrix_size[1] = s;
+        makeConsistent();
+    }
 
-	void setAverage(uint16_t average) {
-		this->head_.average = average;
-	}
+    uint16_t getMatrixSizeZ() const {
+        return head_.matrix_size[2];
+    }
 
-	uint16_t getChannels() const {
-		return head_.channels;
-	}
+    void setMatrixSizeZ(uint16_t s) {
+        head_.matrix_size[2] = s;
+        makeConsistent();
+    }
 
-	void setChannels(uint16_t channels) {
-		this->head_.channels = channels;
-	}
 
-	uint16_t getContrast() const {
-		return head_.contrast;
-	}
+    uint32_t getMeasurementUid() const {
+        return head_.measurement_uid;
+    }
 
-	void setContrast(uint16_t contrast) {
-		this->head_.contrast = contrast;
-	}
+    void setMeasurementUid(uint32_t measurementUid) {
+        head_.measurement_uid = measurementUid;
+    }
 
-	float getFieldOfViewX() const {
-		return head_.field_of_view[0];
-	}
+    const float getPatientTablePosition(unsigned int axis) const {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            return head_.patient_table_position[axis];
+        }
+        return 0;
+    }
 
-	void setFieldOfViewX(float f) {
-		head_.field_of_view[0] = f;
-	}
+    void setPatientTablePosition(unsigned int axis, float value) {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            head_.patient_table_position[axis] = value;
+        }
+    }
 
-	float getFieldOfViewY() const {
-		return head_.field_of_view[1];
-	}
+    const uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const {
+        if (stamp_id < ISMRMRD_PHYS_STAMPS) {
+            return head_.physiology_time_stamp[stamp_id];
+        }
+        return 0;
+    }
 
-	void setFieldOfViewY(float f) {
-		head_.field_of_view[1] = f;
-	}
+    void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value){
+        if (stamp_id < ISMRMRD_PHYS_STAMPS) {
+            head_.physiology_time_stamp[stamp_id] = value;
+        }
+    }
 
-	float getFieldOfViewZ() const {
-		return head_.field_of_view[2];
-	}
+    const float getPosition(unsigned int axis) const {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            return head_.position[axis];
+        }
+        return 0;
+    }
 
-	void setFieldOfViewZ(float f) {
-		head_.field_of_view[2] = f;
-	}
-
-	uint64_t getFlags() const {
-		return head_.flags;
-	}
-
-	void setFlags(uint64_t flags) {
-		this->head_.flags = flags;
-	}
-
-	uint16_t getImageDataType() const {
-		return head_.image_data_type;
-	}
-
-	void setImageDataType(uint16_t imageDataType) {
-		head_.image_data_type = imageDataType;
-	}
-
-	uint16_t getImageIndex() const {
-		return head_.image_index;
-	}
-
-	void setImageIndex(uint16_t imageIndex) {
-		head_.image_index = imageIndex;
-	}
-
-	uint16_t getImageSeriesIndex() const {
-		return head_.image_series_index;
-	}
-
-	void setImageSeriesIndex(uint16_t imageSeriesIndex) {
-		head_.image_series_index = imageSeriesIndex;
-	}
-
-	uint16_t getImageType() const {
-		return head_.image_type;
-	}
-
-	void setImageType(uint16_t imageType) {
-		head_.image_type = imageType;
-	}
-
-	uint16_t getMatrixSizeX() const {
-		return head_.matrix_size[0];
-	}
-
-	void setMatrixSizeX(uint16_t s) {
-		head_.matrix_size[0] = s;
-		makeConsistent();
-	}
-
-	uint16_t getMatrixSizeY() const {
-		return head_.matrix_size[1];
-	}
-
-	void setMatrixSizeY(uint16_t s) {
-		head_.matrix_size[1] = s;
-		makeConsistent();
-	}
-
-	uint16_t getMatrixSizeZ() const {
-		return head_.matrix_size[2];
-	}
-
-	void setMatrixSizeZ(uint16_t s) {
-		head_.matrix_size[2] = s;
-		makeConsistent();
-	}
-
-
-	uint32_t getMeasurementUid() const {
-		return head_.measurement_uid;
-	}
-
-	void setMeasurementUid(uint32_t measurementUid) {
-		head_.measurement_uid = measurementUid;
-	}
-
-	const float getPatientTablePosition(unsigned int axis) const {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			return head_.patient_table_position[axis];
-		}
-		return 0;
-	}
-
-	void setPatientTablePosition(unsigned int axis, float value) {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			head_.patient_table_position[axis] = value;
-		}
-	}
-
-	const uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const {
-		if (stamp_id < ISMRMRD_PHYS_STAMPS) {
-			return head_.physiology_time_stamp[stamp_id];
-		}
-		return 0;
-	}
-
-	void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value){
-		if (stamp_id < ISMRMRD_PHYS_STAMPS) {
-			head_.physiology_time_stamp[stamp_id] = value;
-		}
-	}
-
-	const float getPosition(unsigned int axis) const {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			return head_.position[axis];
-		}
-		return 0;
-	}
-
-	void setPosition(unsigned int axis, float value){
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			head_.position[axis] = value;
-		}
-	}
+    void setPosition(unsigned int axis, float value){
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            head_.position[axis] = value;
+        }
+    }
 
         const float getReadDirection(unsigned int index) const {
                 if (index < ISMRMRD_DIRECTION_LENGTH) {
@@ -573,89 +579,89 @@ public:
                 }
         }
 
-	uint16_t getPhase() const {
-		return head_.phase;
-	}
-
-	void setPhase(uint16_t phase) {
-		this->head_.phase = phase;
-	}
-
-
-	uint16_t getRepetition() const {
-		return head_.repetition;
-	}
-
-	void setRepetition(uint16_t repetition) {
-		this->head_.repetition = repetition;
-	}
-
-	uint16_t getSet() const {
-		return head_.set;
-	}
-
-	void setSet(uint16_t set) {
-		this->head_.set = set;
-	}
-
-	uint16_t getSlice() const {
-		return head_.slice;
-	}
-
-	void setSlice(uint16_t slice) {
-		this->head_.slice = slice;
-	}
-
-	const float getUserFloat(unsigned int index) const {
-		if (index < ISMRMRD_USER_FLOATS) {
-			return head_.user_float[index];
-		}
-		return 0.0f;
-	}
-
-	void setUserFloat(unsigned int index, float value) {
-		if (index < ISMRMRD_USER_FLOATS) {
-			head_.user_float[index] = value;
-		}
-	}
-
-	const int32_t getUserInt(unsigned int index) const {
-		if (index < ISMRMRD_USER_INTS) {
-			return head_.user_int[index];
-		}
-		return 0;
-	}
-
-	void setUserInt(unsigned int index, int32_t value) {
-		if (index < ISMRMRD_USER_INTS) {
-			head_.user_int[index] = value;
-		}
-	}
-
-	uint16_t getVersion() const {
-		return head_.version;
-	}
-
-	void setVersion(uint16_t version) {
-		this->head_.version = version;
-	}
-
-	const std::valarray<T>& getData() const {
-		return data_;
-	}
-
-	void setData(const std::valarray<T>& data) {
-		data_ = data;
-	}
-
-	const ImageHeader& getHead() const {
-		return head_;
-	}
-
-	void setHead(const ImageHeader& head) {
-		head_ = head;
-		makeConsistent();
-	}
+    uint16_t getPhase() const {
+        return head_.phase;
+    }
+
+    void setPhase(uint16_t phase) {
+        this->head_.phase = phase;
+    }
+
+
+    uint16_t getRepetition() const {
+        return head_.repetition;
+    }
+
+    void setRepetition(uint16_t repetition) {
+        this->head_.repetition = repetition;
+    }
+
+    uint16_t getSet() const {
+        return head_.set;
+    }
+
+    void setSet(uint16_t set) {
+        this->head_.set = set;
+    }
+
+    uint16_t getSlice() const {
+        return head_.slice;
+    }
+
+    void setSlice(uint16_t slice) {
+        this->head_.slice = slice;
+    }
+
+    const float getUserFloat(unsigned int index) const {
+        if (index < ISMRMRD_USER_FLOATS) {
+            return head_.user_float[index];
+        }
+        return 0.0f;
+    }
+
+    void setUserFloat(unsigned int index, float value) {
+        if (index < ISMRMRD_USER_FLOATS) {
+            head_.user_float[index] = value;
+        }
+    }
+
+    const int32_t getUserInt(unsigned int index) const {
+        if (index < ISMRMRD_USER_INTS) {
+            return head_.user_int[index];
+        }
+        return 0;
+    }
+
+    void setUserInt(unsigned int index, int32_t value) {
+        if (index < ISMRMRD_USER_INTS) {
+            head_.user_int[index] = value;
+        }
+    }
+
+    uint16_t getVersion() const {
+        return head_.version;
+    }
+
+    void setVersion(uint16_t version) {
+        this->head_.version = version;
+    }
+
+    const std::valarray<T>& getData() const {
+        return data_;
+    }
+
+    void setData(const std::valarray<T>& data) {
+        data_ = data;
+    }
+
+    const ImageHeader& getHead() const {
+        return head_;
+    }
+
+    void setHead(const ImageHeader& head) {
+        head_ = head;
+        makeConsistent();
+    }
 
     T& operator[] (const size_t& p) {
         return data_[p];
@@ -667,36 +673,36 @@ public:
 
 
 protected:
-	ImageHeader head_;     /**< ImageHeader as defined above */
-	std::valarray<T> data_;
-	void makeConsistent() {
-		if (getNumberOfElements() != data_.size()) {
-			data_.resize(getNumberOfElements());
-		}
-	}
+    ImageHeader head_;     /**< ImageHeader as defined above */
+    std::valarray<T> data_;
+    void makeConsistent() {
+        if (getNumberOfElements() != data_.size()) {
+            data_.resize(getNumberOfElements());
+        }
+    }
 
-	void setSpecificDataType();
+    void setSpecificDataType();
 
 };
 
 template <> inline void Image<float>::setSpecificDataType() {
-	head_.image_data_type = DATA_FLOAT;
+    head_.image_data_type = DATA_FLOAT;
 }
 
 template <> inline void Image<double>::setSpecificDataType() {
-	head_.image_data_type = DATA_DOUBLE;
+    head_.image_data_type = DATA_DOUBLE;
 }
 
 template <> inline void Image< std::complex<float> >::setSpecificDataType() {
-	head_.image_data_type = DATA_COMPLEX_FLOAT;
+    head_.image_data_type = DATA_COMPLEX_FLOAT;
 }
 
 template <> inline void Image< std::complex<double> >::setSpecificDataType() {
-	head_.image_data_type = DATA_COMPLEX_DOUBLE;
+    head_.image_data_type = DATA_COMPLEX_DOUBLE;
 }
 
 template <> inline void Image< unsigned short >::setSpecificDataType() {
-	head_.image_data_type = DATA_UNSIGNED_SHORT;
+    head_.image_data_type = DATA_UNSIGNED_SHORT;
 }
 
 
@@ -717,207 +723,207 @@ template <> inline void Image< unsigned short >::setSpecificDataType() {
 class Acquisition {
 
 public:
-	Acquisition()
+    Acquisition()
         : traj_(), data_() {
-		memset(&head_,0,sizeof(AcquisitionHeader));
-		head_.version = ISMRMRD_VERSION;
-	}
-
-	~Acquisition() {}
-
-	Acquisition (const Acquisition& a) {   // copy constructor
-		if (this != &a) {
-			head_ = a.head_;
-			data_.resize(a.data_.size());
-			memcpy(&data_[0],&a.data_[0],sizeof(float)*a.data_.size());
-			traj_.resize(a.traj_.size());
-			memcpy(&traj_[0],&a.traj_[0],sizeof(float)*a.traj_.size());
-		}
-	}
-
-	Acquisition& operator=(const Acquisition& a) {
-		if (this != &a) {
+        memset(&head_,0,sizeof(AcquisitionHeader));
+        head_.version = ISMRMRD_VERSION;
+    }
+
+    ~Acquisition() {}
+
+    Acquisition (const Acquisition& a) {   // copy constructor
+        if (this != &a) {
+            head_ = a.head_;
+            data_.resize(a.data_.size());
+            memcpy(&data_[0],&a.data_[0],sizeof(float)*a.data_.size());
+            traj_.resize(a.traj_.size());
+            memcpy(&traj_[0],&a.traj_[0],sizeof(float)*a.traj_.size());
+        }
+    }
+
+    Acquisition& operator=(const Acquisition& a) {
+        if (this != &a) {
             head_ = a.head_;
-			data_.resize(a.data_.size());
-			memcpy(&data_[0],&a.data_[0],sizeof(float)*a.data_.size());
-			traj_.resize(a.traj_.size());
-			memcpy(&traj_[0],&a.traj_[0],sizeof(float)*a.traj_.size());
-		}
-		return *this;
-	}
-
-	const AcquisitionHeader& getHead() {
-		return head_;
-	}
-
-	void setHead(const AcquisitionHeader& h) {
-		head_ = h;
-		makeConsistent();
-	}
-
-	bool isFlagSet(const FlagBit& f) const {
-		return f.isSet(head_.flags);
-	}
-
-	void setFlag(const FlagBit& f) {
-		head_.flags |= f.bitmask_;
-	}
-
-	uint32_t getAcquisitionTimeStamp() const {
-		return head_.acquisition_time_stamp;
-	}
-
-	void setAcquisitionTimeStamp(uint32_t acquisitionTimeStamp) {
-		head_.acquisition_time_stamp = acquisitionTimeStamp;
-	}
-
-	uint16_t getActiveChannels() const {
-		return head_.active_channels;
-	}
-
-	void setActiveChannels(uint16_t activeChannels) {
-		head_.active_channels = activeChannels;
-		makeConsistent();
-	}
-
-	uint16_t getAvailableChannels() const {
-		return head_.available_channels;
-	}
-
-	void setAvailableChannels(uint16_t availableChannels) {
-		head_.available_channels = availableChannels;
-	}
-
-	uint16_t getCenterSample() const {
-		return head_.center_sample;
-	}
-
-	void setCenterSample(uint16_t centerSample) {
-		head_.center_sample = centerSample;
-	}
-
-	bool isChannelActive(unsigned int channel_id) {
-		if (channel_id < 64*ISMRMRD_CHANNEL_MASKS) {
-			unsigned int mask_idx = channel_id>>6;
-			unsigned int mask_bit = channel_id-mask_idx*64;
-			return ((head_.channel_mask[mask_idx] & ( (uint64_t)1 << mask_bit)) > 0);
-		}
-		return false;
-	}
-
-	void setChannelActive(unsigned int channel_id) {
-		if (channel_id < 64*ISMRMRD_CHANNEL_MASKS) {
-			unsigned int mask_idx = channel_id>>6;
-			unsigned int mask_bit = channel_id-mask_idx*64;
-			head_.channel_mask[mask_idx] |= ( (uint64_t)1 << mask_bit);
-		}
-	}
-
-	unsigned int getActiveChannelBits() {
-		unsigned int bits = 0;
-		for (unsigned int i = 0; i < ISMRMRD_CHANNEL_MASKS*64; i++) {
-			if (isChannelActive(i)) {
-				bits++;
-			}
-		}
-		return bits;
-	}
-
-	uint16_t getDiscardPost() const {
-		return head_.discard_post;
-	}
-
-	void setDiscardPost(uint16_t discardPost) {
-		head_.discard_post = discardPost;
-	}
-
-	uint16_t getDiscardPre() const {
-		return head_.discard_pre;
-	}
-
-	void setDiscardPre(uint16_t discardPre) {
-		head_.discard_pre = discardPre;
-	}
-
-	uint16_t getEncodingSpaceRef() const {
-		return head_.encoding_space_ref;
-	}
-
-	void setEncodingSpaceRef(uint16_t encodingSpaceRef) {
-		head_.encoding_space_ref = encodingSpaceRef;
-	}
-
-	uint64_t getFlags() const {
-		return head_.flags;
-	}
-
-	void setFlags(uint64_t flags) {
-		this->head_.flags = flags;
-	}
-
-	EncodingCounters& getIdx() {
-		return head_.idx;
-	}
-
-	void setIdx(const EncodingCounters& idx) {
-		this->head_.idx = idx;
-	}
-
-	uint32_t getMeasurementUid() const {
-		return head_.measurement_uid;
-	}
-
-	void setMeasurementUid(uint32_t measurementUid) {
-		head_.measurement_uid = measurementUid;
-	}
-
-	uint16_t getNumberOfSamples() const {
-		return head_.number_of_samples;
-	}
-
-	void setNumberOfSamples(uint16_t numberOfSamples) {
-		head_.number_of_samples = numberOfSamples;
-		makeConsistent();
-	}
-
-	const float getPatientTablePosition(unsigned int axis) const {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			return head_.patient_table_position[axis];
-		}
-		return 0;
-	}
-
-	void setPatientTablePosition(unsigned int axis, float value) {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			head_.patient_table_position[axis] = value;
-		}
-	}
-
-	const uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const {
-		if (stamp_id < ISMRMRD_PHYS_STAMPS) {
-			return head_.physiology_time_stamp[stamp_id];
-		}
-		return 0;
-	}
-
-	void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value){
-		if (stamp_id < ISMRMRD_PHYS_STAMPS) {
-			head_.physiology_time_stamp[stamp_id] = value;
-		}
-	}
-
-	const float getPosition(unsigned int axis) const {
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			return head_.position[axis];
-		}
-		return 0;
-	}
-
-	void setPosition(unsigned int axis, float value){
-		if (axis < ISMRMRD_POSITION_LENGTH) {
-			head_.position[axis] = value;
-		}
-	}
+            data_.resize(a.data_.size());
+            memcpy(&data_[0],&a.data_[0],sizeof(float)*a.data_.size());
+            traj_.resize(a.traj_.size());
+            memcpy(&traj_[0],&a.traj_[0],sizeof(float)*a.traj_.size());
+        }
+        return *this;
+    }
+
+    const AcquisitionHeader& getHead() {
+        return head_;
+    }
+
+    void setHead(const AcquisitionHeader& h) {
+        head_ = h;
+        makeConsistent();
+    }
+
+    bool isFlagSet(const FlagBit& f) const {
+        return f.isSet(head_.flags);
+    }
+
+    void setFlag(const FlagBit& f) {
+        head_.flags |= f.bitmask_;
+    }
+
+    uint32_t getAcquisitionTimeStamp() const {
+        return head_.acquisition_time_stamp;
+    }
+
+    void setAcquisitionTimeStamp(uint32_t acquisitionTimeStamp) {
+        head_.acquisition_time_stamp = acquisitionTimeStamp;
+    }
+
+    uint16_t getActiveChannels() const {
+        return head_.active_channels;
+    }
+
+    void setActiveChannels(uint16_t activeChannels) {
+        head_.active_channels = activeChannels;
+        makeConsistent();
+    }
+
+    uint16_t getAvailableChannels() const {
+        return head_.available_channels;
+    }
+
+    void setAvailableChannels(uint16_t availableChannels) {
+        head_.available_channels = availableChannels;
+    }
+
+    uint16_t getCenterSample() const {
+        return head_.center_sample;
+    }
+
+    void setCenterSample(uint16_t centerSample) {
+        head_.center_sample = centerSample;
+    }
+
+    bool isChannelActive(unsigned int channel_id) {
+        if (channel_id < 64*ISMRMRD_CHANNEL_MASKS) {
+            unsigned int mask_idx = channel_id>>6;
+            unsigned int mask_bit = channel_id-mask_idx*64;
+            return ((head_.channel_mask[mask_idx] & ( (uint64_t)1 << mask_bit)) > 0);
+        }
+        return false;
+    }
+
+    void setChannelActive(unsigned int channel_id) {
+        if (channel_id < 64*ISMRMRD_CHANNEL_MASKS) {
+            unsigned int mask_idx = channel_id>>6;
+            unsigned int mask_bit = channel_id-mask_idx*64;
+            head_.channel_mask[mask_idx] |= ( (uint64_t)1 << mask_bit);
+        }
+    }
+
+    unsigned int getActiveChannelBits() {
+        unsigned int bits = 0;
+        for (unsigned int i = 0; i < ISMRMRD_CHANNEL_MASKS*64; i++) {
+            if (isChannelActive(i)) {
+                bits++;
+            }
+        }
+        return bits;
+    }
+
+    uint16_t getDiscardPost() const {
+        return head_.discard_post;
+    }
+
+    void setDiscardPost(uint16_t discardPost) {
+        head_.discard_post = discardPost;
+    }
+
+    uint16_t getDiscardPre() const {
+        return head_.discard_pre;
+    }
+
+    void setDiscardPre(uint16_t discardPre) {
+        head_.discard_pre = discardPre;
+    }
+
+    uint16_t getEncodingSpaceRef() const {
+        return head_.encoding_space_ref;
+    }
+
+    void setEncodingSpaceRef(uint16_t encodingSpaceRef) {
+        head_.encoding_space_ref = encodingSpaceRef;
+    }
+
+    uint64_t getFlags() const {
+        return head_.flags;
+    }
+
+    void setFlags(uint64_t flags) {
+        this->head_.flags = flags;
+    }
+
+    EncodingCounters& getIdx() {
+        return head_.idx;
+    }
+
+    void setIdx(const EncodingCounters& idx) {
+        this->head_.idx = idx;
+    }
+
+    uint32_t getMeasurementUid() const {
+        return head_.measurement_uid;
+    }
+
+    void setMeasurementUid(uint32_t measurementUid) {
+        head_.measurement_uid = measurementUid;
+    }
+
+    uint16_t getNumberOfSamples() const {
+        return head_.number_of_samples;
+    }
+
+    void setNumberOfSamples(uint16_t numberOfSamples) {
+        head_.number_of_samples = numberOfSamples;
+        makeConsistent();
+    }
+
+    const float getPatientTablePosition(unsigned int axis) const {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            return head_.patient_table_position[axis];
+        }
+        return 0;
+    }
+
+    void setPatientTablePosition(unsigned int axis, float value) {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            head_.patient_table_position[axis] = value;
+        }
+    }
+
+    const uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const {
+        if (stamp_id < ISMRMRD_PHYS_STAMPS) {
+            return head_.physiology_time_stamp[stamp_id];
+        }
+        return 0;
+    }
+
+    void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value){
+        if (stamp_id < ISMRMRD_PHYS_STAMPS) {
+            head_.physiology_time_stamp[stamp_id] = value;
+        }
+    }
+
+    const float getPosition(unsigned int axis) const {
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            return head_.position[axis];
+        }
+        return 0;
+    }
+
+    void setPosition(unsigned int axis, float value){
+        if (axis < ISMRMRD_POSITION_LENGTH) {
+            head_.position[axis] = value;
+        }
+    }
 
         const float getReadDirection(unsigned int index) const {
                 if (index < ISMRMRD_DIRECTION_LENGTH) {
@@ -958,80 +964,80 @@ public:
                 }
         }
 
-	float getSampleTimeUs() const {
-		return head_.sample_time_us;
-	}
-
-	void setSampleTimeUs(float sampleTimeUs) {
-		head_.sample_time_us = sampleTimeUs;
-	}
-
-	uint32_t getScanCounter() const {
-		return head_.scan_counter;
-	}
-
-	void setScanCounter(uint32_t scanCounter) {
-		head_.scan_counter = scanCounter;
-	}
-
-	uint16_t getTrajectoryDimensions() const {
-		return head_.trajectory_dimensions;
-	}
-
-	void setTrajectoryDimensions(uint16_t trajectoryDimensions) {
-		head_.trajectory_dimensions = trajectoryDimensions;
-		makeConsistent();
-	}
-
-	const float getUserFloat(unsigned int index) const {
-		if (index < ISMRMRD_USER_FLOATS) {
-			return head_.user_float[index];
-		}
-		return 0.0f;
-	}
-
-	void setUserFloat(unsigned int index, float value) {
-		if (index < ISMRMRD_USER_FLOATS) {
-			head_.user_float[index] = value;
-		}
-	}
-
-	const int32_t getUserInt(unsigned int index) const {
-		if (index < ISMRMRD_USER_INTS) {
-			return head_.user_int[index];
-		}
-		return 0;
-	}
-
-	void setUserInt(unsigned int index, int32_t value) {
-		if (index < ISMRMRD_USER_INTS) {
-			head_.user_int[index] = value;
-		}
-	}
-
-	uint16_t getVersion() const {
-		return head_.version;
-	}
-
-	void setVersion(uint16_t version) {
-		this->head_.version = version;
-	}
-
-	const std::valarray<float>& getData() const {
-		return data_;
-	}
-
-	void setData(const std::valarray<float>& data) {
-		data_ = data;
-	}
-
-	const std::valarray<float>& getTraj() const {
-		return traj_;
-	}
-
-	void setTraj(const std::valarray<float>& traj) {
-		traj_ = traj;
-	}
+    float getSampleTimeUs() const {
+        return head_.sample_time_us;
+    }
+
+    void setSampleTimeUs(float sampleTimeUs) {
+        head_.sample_time_us = sampleTimeUs;
+    }
+
+    uint32_t getScanCounter() const {
+        return head_.scan_counter;
+    }
+
+    void setScanCounter(uint32_t scanCounter) {
+        head_.scan_counter = scanCounter;
+    }
+
+    uint16_t getTrajectoryDimensions() const {
+        return head_.trajectory_dimensions;
+    }
+
+    void setTrajectoryDimensions(uint16_t trajectoryDimensions) {
+        head_.trajectory_dimensions = trajectoryDimensions;
+        makeConsistent();
+    }
+
+    const float getUserFloat(unsigned int index) const {
+        if (index < ISMRMRD_USER_FLOATS) {
+            return head_.user_float[index];
+        }
+        return 0.0f;
+    }
+
+    void setUserFloat(unsigned int index, float value) {
+        if (index < ISMRMRD_USER_FLOATS) {
+            head_.user_float[index] = value;
+        }
+    }
+
+    const int32_t getUserInt(unsigned int index) const {
+        if (index < ISMRMRD_USER_INTS) {
+            return head_.user_int[index];
+        }
+        return 0;
+    }
+
+    void setUserInt(unsigned int index, int32_t value) {
+        if (index < ISMRMRD_USER_INTS) {
+            head_.user_int[index] = value;
+        }
+    }
+
+    uint16_t getVersion() const {
+        return head_.version;
+    }
+
+    void setVersion(uint16_t version) {
+        this->head_.version = version;
+    }
+
+    const std::valarray<float>& getData() const {
+        return data_;
+    }
+
+    void setData(const std::valarray<float>& data) {
+        data_ = data;
+    }
+
+    const std::valarray<float>& getTraj() const {
+        return traj_;
+    }
+
+    void setTraj(const std::valarray<float>& traj) {
+        traj_ = traj;
+    }
 
     float& operator[] (const size_t& p) {
         return data_[p];
@@ -1042,28 +1048,28 @@ public:
     }
 
 protected:
-	size_t calcTrajLength() {
-		return head_.trajectory_dimensions*head_.number_of_samples;
-	}
-
-	size_t calcDataLength() {
-		return head_.active_channels*head_.number_of_samples*2;
-	}
-
-
-	void makeConsistent() {
-		if (head_.active_channels > head_.available_channels) {
-			head_.available_channels = head_.active_channels;
-		}
-		if (calcTrajLength() != traj_.size()) {
-			traj_.resize(calcTrajLength());
-		}
-		if (calcDataLength() != data_.size()) {
-			data_.resize(calcDataLength());
-		}
-	}
-
-	AcquisitionHeader head_; /**< Header, see above */
+    size_t calcTrajLength() {
+        return head_.trajectory_dimensions*head_.number_of_samples;
+    }
+
+    size_t calcDataLength() {
+        return head_.active_channels*head_.number_of_samples*2;
+    }
+
+
+    void makeConsistent() {
+        if (head_.active_channels > head_.available_channels) {
+            head_.available_channels = head_.active_channels;
+        }
+        if (calcTrajLength() != traj_.size()) {
+            traj_.resize(calcTrajLength());
+        }
+        if (calcDataLength() != data_.size()) {
+            data_.resize(calcDataLength());
+        }
+    }
+
+    AcquisitionHeader head_; /**< Header, see above */
     std::valarray<float> traj_;
     std::valarray<float> data_;
 
diff --git a/ismrmrd_hdf5_datatypes.h b/ismrmrd_hdf5_datatypes.h
index 016897b..ea6e75f 100644
--- a/ismrmrd_hdf5_datatypes.h
+++ b/ismrmrd_hdf5_datatypes.h
@@ -96,6 +96,8 @@ template <> inline boost::shared_ptr<DataType> getIsmrmrdHDF5Type<AcquisitionHea
 	ret->insertMember( "scan_counter", 				HOFFSET(AcquisitionHeader, scan_counter), 			PredType::NATIVE_UINT32);
 	ret->insertMember( "acquisition_time_stamp", 	HOFFSET(AcquisitionHeader, acquisition_time_stamp), PredType::NATIVE_UINT32);
 
+        // TODO: change ISMRMRD_PHYS_STAMPS to 3 (Major change)
+        // we should use the size defines and not hard coded numbers.
 	std::vector<hsize_t> dims(1,3);
 	boost::shared_ptr<DataType> array_type(new ArrayType(PredType::NATIVE_UINT32, 1, &dims[0]));
 	ret->insertMember( "physiology_time_stamp", HOFFSET(AcquisitionHeader, physiology_time_stamp), 		*array_type);
@@ -244,6 +246,8 @@ template <> inline boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader>()
 	ret->insertMember( "set",   					HOFFSET(ImageHeader, set), 						PredType::NATIVE_UINT16);
 	ret->insertMember( "acquisition_time_stamp", 	HOFFSET(ImageHeader, acquisition_time_stamp),   PredType::NATIVE_UINT32);
 
+        // TODO: ISMRMRD_PHYS_STAMPS should be 3 (Major change)
+        // we should use the size defines and not hard coded numbers.
 	dims[0] = 3;
 	boost::shared_ptr<DataType> array_type(new ArrayType(PredType::NATIVE_UINT32, 1, &dims[0]));
 	ret->insertMember( "physiology_time_stamp", HOFFSET(ImageHeader, physiology_time_stamp), 		*array_type);
diff --git a/matlab/+ismrmrd/+util/AcquisitionHeaderFromBytes.m b/matlab/+ismrmrd/+util/AcquisitionHeaderFromBytes.m
new file mode 100644
index 0000000..70352a8
--- /dev/null
+++ b/matlab/+ismrmrd/+util/AcquisitionHeaderFromBytes.m
@@ -0,0 +1,47 @@
+function hdr = AcquisitionHeaderFromBytes(bytes)
+% Construct an ISMRMRD Acquisition Header structure from a byte array.
+
+hdr = struct( ...
+    'version',                typecast(bytes(  1:  2), 'uint16'), ... % First unsigned int indicates the version %
+    'flags',                  typecast(bytes(  3: 10), 'uint64'), ... % bit field with flags %
+    'measurement_uid',        typecast(bytes( 11: 10), 'uint32'), ... % Unique ID for the measurement %
+    'scan_counter',           typecast(bytes( 15: 14), 'uint32'), ... % Current acquisition number in the measurement %
+    'acquisition_time_stamp', typecast(bytes( 19: 18), 'uint32'), ... % Acquisition clock %
+    'physiology_time_stamp',  typecast(bytes( 23: 30), 'uint32'), ... % Physiology time stamps, e.g. ecg, breating, etc. %
+                                                                  ... %   TODO: the C header has a bug.  3 is correct
+    'number_of_samples',      typecast(bytes( 55: 56), 'uint16'), ... % Number of samples acquired %
+    'available_channels',     typecast(bytes( 57: 58), 'uint16'), ... % Available coils %
+    'active_channels',        typecast(bytes( 59: 60), 'uint16'), ... % Active coils on current acquisiton %
+    'channel_mask',           typecast(bytes( 61:188), 'uint64'), ... % Mask to indicate which channels are active. Support for 1024 channels %
+    'discard_pre',            typecast(bytes(189:190), 'uint16'), ... % Samples to be discarded at the beginning of acquisition %
+    'discard_post',           typecast(bytes(191:192), 'uint16'), ... % Samples to be discarded at the end of acquisition %
+    'center_sample',          typecast(bytes(193:194), 'uint16'), ... % Sample at the center of k-space %
+    'encoding_space_ref',     typecast(bytes(195:196), 'uint16'), ... % Reference to an encoding space, typically only one per acquisition %
+    'trajectory_dimensions',  typecast(bytes(197:198), 'uint16'), ... % Indicates the dimensionality of the trajectory vector (0 means no trajectory) %
+    'sample_time_us',         typecast(bytes(199:202), 'single'), ... % Time between samples in micro seconds, sampling BW %
+    'position',               typecast(bytes(203:214), 'single'), ... % Three-dimensional spatial offsets from isocenter %
+    'read_dir',               typecast(bytes(215:226), 'single'), ... % Directional cosines of the readout/frequency encoding %
+    'phase_dir',              typecast(bytes(227:238), 'single'), ... % Directional cosines of the phase encoding %
+    'slice_dir',              typecast(bytes(239:250), 'single'), ... % Directional cosines of the slice %
+    'patient_table_position', typecast(bytes(251:262), 'single'), ... % Patient table off-center %
+    'idx',                    struct(),                           ... % Encoding counters %
+    'user_int',               typecast(bytes(297:328), 'int32'),  ... % Free user parameters %
+    'user_float',             typecast(bytes(329:360), 'single')  ... % Free user parameters %
+    );
+
+    
+% Encoding Counters
+hdr.idx = struct( ...
+    'kspace_encode_step_1',   typecast(bytes(263:264), 'uint16'), ... % phase encoding line number %
+    'kspace_encode_step_2',   typecast(bytes(265:266), 'uint16'), ... % partition encodning number %
+    'average',                typecast(bytes(263:268), 'uint16'), ... % signal average number %
+    'slice',                  typecast(bytes(265:270), 'uint16'), ... % imaging slice number %
+    'contrast',               typecast(bytes(267:272), 'uint16'), ... % echo number in multi-echo %
+    'phase',                  typecast(bytes(269:274), 'uint16'), ... % cardiac phase number %
+    'repetition',             typecast(bytes(271:276), 'uint16'), ... % dynamic number for dynamic scanning %
+    'set',                    typecast(bytes(273:278), 'uint16'), ... % flow encoding set %
+    'segment',                typecast(bytes(275:280), 'uint16'), ... % segment number for segmented acquisition %
+    'user',                   typecast(bytes(281:296), 'uint16')  ... % Free user parameters %
+    );
+
+end
diff --git a/matlab/+ismrmrd/+util/AcquisitionHeaderToBytes.m b/matlab/+ismrmrd/+util/AcquisitionHeaderToBytes.m
new file mode 100644
index 0000000..f0f4292
--- /dev/null
+++ b/matlab/+ismrmrd/+util/AcquisitionHeaderToBytes.m
@@ -0,0 +1,47 @@
+function bytes = AcquisitionHeaderToBytes(hdr)
+% Convert to an ISMRMRD AcquisitionHeader struct to a byte array.
+
+    % TODO: physiology_time_stamp should be 3.
+    %bytes = zeros(340,1,'int8');
+    bytes = zeros(360,1,'int8');
+    off = 1;
+    bytes(off:off+1)   = typecast(hdr.version               ,'int8'); off=off+2;
+    bytes(off:off+7)   = typecast(hdr.flags                 ,'int8'); off=off+8;
+    bytes(off:off+3)   = typecast(hdr.measurement_uid       ,'int8'); off=off+4;
+    bytes(off:off+3)   = typecast(hdr.scan_counter          ,'int8'); off=off+4;
+    bytes(off:off+3)   = typecast(hdr.acquisition_time_stamp,'int8'); off=off+4;
+    
+    % TODO: physiology_time_stamp should be 3.
+    % but the C struct has a bug, so convert to padding.
+    bytes(off:off+11)  = typecast(hdr.physiology_time_stamp ,'int8'); off=off+12;
+    off = off+20; % Discard 5*uint32;
+
+    bytes(off:off+1)   = typecast(hdr.number_of_samples     ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.available_channels    ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.active_channels       ,'int8'); off=off+2;
+    bytes(off:off+127) = typecast(hdr.channel_mask          ,'int8'); off=off+128;
+    bytes(off:off+1)   = typecast(hdr.discard_pre           ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.discard_post          ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.center_sample         ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.encoding_space_ref    ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.trajectory_dimensions ,'int8'); off=off+2;
+    bytes(off:off+3)   = typecast(hdr.sample_time_us        ,'int8'); off=off+4;
+    bytes(off:off+11)  = typecast(hdr.position              ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.read_dir              ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.phase_dir             ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.slice_dir             ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.patient_table_position,'int8'); off=off+12;
+    bytes(off:off+1)   = typecast(hdr.idx.kspace_encode_step_1,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.kspace_encode_step_2,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.average           ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.slice             ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.contrast          ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.phase             ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.repetition        ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.set               ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.idx.segment           ,'int8'); off=off+2;
+    bytes(off:off+15)  = typecast(hdr.idx.user              ,'int8'); off=off+16;
+    bytes(off:off+31)  = typecast(hdr.user_int              ,'int8'); off=off+32;
+    bytes(off:off+31)  = typecast(hdr.user_float            ,'int8');
+
+end
diff --git a/matlab/+ismrmrd/+util/ImageHeaderFromBytes.m b/matlab/+ismrmrd/+util/ImageHeaderFromBytes.m
new file mode 100644
index 0000000..c5bde23
--- /dev/null
+++ b/matlab/+ismrmrd/+util/ImageHeaderFromBytes.m
@@ -0,0 +1,32 @@
+function hdr = ImageHeaderFromBytes(bytes)
+% Construct an ISMRMRD Image Header structure from a byte array.
+
+    off = 1;
+    hdr = struct();
+    hdr.version                = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.flags                  = typecast(bytes(off:off+7),  'uint64'); off=off+8;
+    hdr.measurement_uid        = typecast(bytes(off:off+3),  'uint32'); off=off+4;
+    hdr.matrix_size            = typecast(bytes(off:off+5),  'uint16'); off=off+6;
+    hdr.field_of_view          = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.channels               = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.position               = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.read_dir               = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.phase_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.slice_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.patient_table_position = typecast(bytes(off:off+11), 'single'); off=off+12;
+    hdr.average                = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.slice                  = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.contrast               = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.phase                  = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.repetition             = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.set                    = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.acquisition_time_stamp = typecast(bytes(off:off+3),  'uint32'); off=off+4;
+    hdr.physiology_time_stamp  = typecast(bytes(off:off+31), 'uint32'); off=off+32;
+    hdr.image_data_type        = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.image_type             = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.image_index            = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.image_series_index     = typecast(bytes(off:off+1),  'uint16'); off=off+2;
+    hdr.user_int               = typecast(bytes(off:off+31), 'uint32'); off=off+32;
+    hdr.user_float             = typecast(bytes(off:off+31), 'single');
+
+end
\ No newline at end of file
diff --git a/matlab/+ismrmrd/+util/ImageHeaderToBytes.m b/matlab/+ismrmrd/+util/ImageHeaderToBytes.m
new file mode 100644
index 0000000..54f2452
--- /dev/null
+++ b/matlab/+ismrmrd/+util/ImageHeaderToBytes.m
@@ -0,0 +1,32 @@
+function bytes = ImageHeaderToBytes(hdr)
+% Convert to an ISMRMRD ImageHeader struct to a byte array.
+
+    bytes = zeros(214,1,'int8');
+    off = 1;
+    bytes(off:off+1)   = typecast(hdr.version               ,'int8'); off=off+2;
+    bytes(off:off+7)   = typecast(hdr.flags                 ,'int8'); off=off+8;
+    bytes(off:off+3)   = typecast(hdr.measurement_uid       ,'int8'); off=off+4;
+    bytes(off:off+5)   = typecast(hdr.matrix_size           ,'int8'); off=off+6;
+    bytes(off:off+11)  = typecast(hdr.field_of_view         ,'int8'); off=off+12;
+    bytes(off:off+1)   = typecast(hdr.channels              ,'int8'); off=off+2;
+    bytes(off:off+11)  = typecast(hdr.position              ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.read_dir              ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.phase_dir             ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.slice_dir             ,'int8'); off=off+12;
+    bytes(off:off+11)  = typecast(hdr.patient_table_position,'int8'); off=off+12;
+    bytes(off:off+1)   = typecast(hdr.average               ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.slice                 ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.contrast              ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.phase                 ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.repetition            ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.set                   ,'int8'); off=off+2;
+    bytes(off:off+3)   = typecast(hdr.acquisition_time_stamp,'int8'); off=off+4;
+    bytes(off:off+31)  = typecast(hdr.physiology_time_stamp ,'int8'); off=off+32;
+    bytes(off:off+1)   = typecast(hdr.image_data_type       ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.image_type            ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.image_index           ,'int8'); off=off+2;
+    bytes(off:off+1)   = typecast(hdr.image_series_index    ,'int8'); off=off+2;
+    bytes(off:off+31)  = typecast(hdr.user_int              ,'int8'); off=off+32;
+    bytes(off:off+31)  = typecast(hdr.user_float            ,'int8');
+
+end
diff --git a/matlab/+ismrmrd/old/hdf5_datatypes.m b/matlab/+ismrmrd/+util/hdf5_datatypes.m
similarity index 90%
rename from matlab/+ismrmrd/old/hdf5_datatypes.m
rename to matlab/+ismrmrd/+util/hdf5_datatypes.m
index 6954366..14788d7 100644
--- a/matlab/+ismrmrd/old/hdf5_datatypes.m
+++ b/matlab/+ismrmrd/+util/hdf5_datatypes.m
@@ -1,83 +1,112 @@
 classdef hdf5_datatypes
+% This convenience class defines the HDF5 types used in the
+% ISMRMRD HDF5 file
+    properties
+        T_float;
+        T_double;
+        T_char;
+        T_complexfloat;
+        T_complexdouble;
+        T_ushort;
+        T_EncodingCounters;
+        T_AcquisitionHeader;
+        T_Acquisition;
+    end
     
-    methods (Static)
+    methods
+        
+        function obj = hdf5_datatypes()
+            obj.T_float = ismrmrd.util.hdf5_datatypes.getType_float();
+            obj.T_double = ismrmrd.util.hdf5_datatypes.getType_double();
+            obj.T_char = ismrmrd.util.hdf5_datatypes.getType_char();
+            obj.T_complexfloat = ismrmrd.util.hdf5_datatypes.getType_complexfloat();
+            obj.T_complexdouble = ismrmrd.util.hdf5_datatypes.getType_complexdouble();
+            obj.T_ushort = ismrmrd.util.hdf5_datatypes.getType_ushort();
+            obj.T_EncodingCounters = ismrmrd.util.hdf5_datatypes.getType_EncodingCounters();
+            obj.T_AcquisitionHeader = ismrmrd.util.hdf5_datatypes.getType_AcquisitionHeader();
+            obj.T_Acquisition = ismrmrd.util.hdf5_datatypes.getType_Acquisition();
+        end
         
+    end
+   
+    methods (Static)
+
         function b = getType_float()
             b = H5T.copy('H5T_NATIVE_FLOAT');
         end
-        
+
         function b = getType_double()
             b = H5T.copy('H5T_NATIVE_DOUBLE');
         end
-        
+
         function b = getType_char()
             b = H5T.copy('H5T_NATIVE_CHAR');
         end
-        
+
         function b = getType_complexfloat()
             typesize = 2*H5T.get_size('H5T_NATIVE_FLOAT');
             b = H5T.create ('H5T_COMPOUND', typesize);
             H5T.insert (b, 'real', 0, 'H5T_NATIVE_FLOAT');
             H5T.insert (b, 'imag', H5T.get_size('H5T_NATIVE_FLOAT'), 'H5T_NATIVE_FLOAT');
         end
-        
+
         function b = getType_complexdouble()
             b = H5T.create ('H5T_COMPOUND', ...
                              2*H5T.get_size('H5T_NATIVE_DOUBLE'));
             H5T.insert (b, 'real', 0, 'H5T_NATIVE_DOUBLE');
             H5T.insert (b, 'imag', H5T.get_size('H5T_NATIVE_DOUBLE'), 'H5T_NATIVE_DOUBLE');
         end
-        
+
         function b = getType_ushort()
             b = H5T.copy('H5T_NATIVE_USHORT');
         end
-        
+
         function b = getType_EncodingCounters()
-            
+
             typesize = 17*H5T.get_size('H5T_NATIVE_UINT16');
             b = H5T.create ('H5T_COMPOUND', typesize);
-            
+
             offset = 0;
             H5T.insert(b, 'kspace_encode_step_1', offset, 'H5T_NATIVE_UINT16');
-            
+
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            H5T.insert(b, 'kspace_encode_step_2', offset, 'H5T_NATIVE_UINT16');            
+            H5T.insert(b, 'kspace_encode_step_2', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'average', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'slice', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'contrast', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'phase', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'repetition', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'set', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'segment', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'user', offset, H5T.array_create('H5T_NATIVE_UINT16',[8]));
-            
+
         end
- 
+
         function b = getType_AcquisitionHeader()
-            
+
             typesize = 0;
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % version
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT64'); % flag
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT32'); % measurement_uid
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT32'); % scan_counter
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT32'); % acquisition_time_stamp
-            typesize = typesize + 3*H5T.get_size('H5T_NATIVE_UINT32'); % pysio_time_stampe(3)
+            typesize = typesize + 3*H5T.get_size('H5T_NATIVE_UINT32'); % physio_time_stamps
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % number_of_samples
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % available_channels
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % active_channels
@@ -87,37 +116,37 @@ classdef hdf5_datatypes
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % center_sample
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % encoding_space_ref
             typesize = typesize + H5T.get_size('H5T_NATIVE_UINT16'); % trajectory_dimension
-            typesize = typesize + H5T.get_size('H5T_NATIVE_FLOAT');  % sample_time_us 
+            typesize = typesize + H5T.get_size('H5T_NATIVE_FLOAT');  % sample_time_us
             typesize = typesize + 3*H5T.get_size('H5T_NATIVE_FLOAT'); % position
             typesize = typesize + 3*H5T.get_size('H5T_NATIVE_FLOAT'); % read_dir
             typesize = typesize + 3*H5T.get_size('H5T_NATIVE_FLOAT'); % phase_dir
             typesize = typesize + 3*H5T.get_size('H5T_NATIVE_FLOAT'); % slice_dir
             typesize = typesize + 3*H5T.get_size('H5T_NATIVE_FLOAT'); % patient_table_position
-            typesize = typesize + H5T.get_size(ismrmrd.hdf5_datatypes.getType_EncodingCounters()); % idx
+            typesize = typesize + H5T.get_size(ismrmrd.util.hdf5_datatypes.getType_EncodingCounters()); % idx
             typesize = typesize + 8*H5T.get_size('H5T_NATIVE_INT32'); % user_int
             typesize = typesize + 8*H5T.get_size('H5T_NATIVE_FLOAT'); % user_float
-            
+
             b = H5T.create ('H5T_COMPOUND', typesize);
-            
+
             offset = 0;
-            H5T.insert(b, 'version', offset, 'H5T_NATIVE_UINT16'); 
+            H5T.insert(b, 'version', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
 
             H5T.insert(b, 'flags', offset, 'H5T_NATIVE_UINT64');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT64');
-            
+
             H5T.insert(b, 'measurement_uid', offset, 'H5T_NATIVE_UINT32');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT32');
-            
+
             H5T.insert(b, 'scan_counter', offset, 'H5T_NATIVE_UINT32');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT32');
-            
+
             H5T.insert(b, 'acquisition_time_stamp', offset, 'H5T_NATIVE_UINT32');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT32');
-            
+
             H5T.insert(b, 'physiology_time_stamp', offset, H5T.array_create('H5T_NATIVE_UINT32',[3]));
             offset = offset + 3*H5T.get_size('H5T_NATIVE_UINT32');
-            
+
             H5T.insert(b, 'number_of_samples', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
 
@@ -126,10 +155,10 @@ classdef hdf5_datatypes
 
             H5T.insert(b, 'active_channels', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'channel_mask', offset, H5T.array_create('H5T_NATIVE_UINT64',[16]));
             offset = offset + 16*H5T.get_size('H5T_NATIVE_UINT64');
-            
+
             H5T.insert(b, 'discard_pre', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
 
@@ -141,10 +170,10 @@ classdef hdf5_datatypes
 
             H5T.insert(b, 'encoding_space_ref', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'trajectory_dimensions', offset, 'H5T_NATIVE_UINT16');
             offset = offset + H5T.get_size('H5T_NATIVE_UINT16');
-            
+
             H5T.insert(b, 'sample_time_us', offset, 'H5T_NATIVE_FLOAT');
             offset = offset + H5T.get_size('H5T_NATIVE_FLOAT');
 
@@ -159,13 +188,13 @@ classdef hdf5_datatypes
 
             H5T.insert(b, 'slice_dir', offset, H5T.array_create('H5T_NATIVE_FLOAT',[3]));
             offset = offset + 3*H5T.get_size('H5T_NATIVE_FLOAT');
-            
+
             H5T.insert(b, 'patient_table_position', offset, H5T.array_create('H5T_NATIVE_FLOAT',[3]));
             offset = offset + 3*H5T.get_size('H5T_NATIVE_FLOAT');
-            
-            H5T.insert(b, 'idx', offset, ismrmrd.hdf5_datatypes.getType_EncodingCounters);
-            offset = offset + H5T.get_size(ismrmrd.hdf5_datatypes.getType_EncodingCounters);
-            
+
+            H5T.insert(b, 'idx', offset, ismrmrd.util.hdf5_datatypes.getType_EncodingCounters);
+            offset = offset + H5T.get_size(ismrmrd.util.hdf5_datatypes.getType_EncodingCounters);
+
             H5T.insert(b, 'user_int', offset, H5T.array_create('H5T_NATIVE_INT32',[8]));
             offset = offset + 8*H5T.get_size('H5T_NATIVE_INT32');
 
@@ -175,13 +204,13 @@ classdef hdf5_datatypes
         end
 
         function b = getType_Acquisition()
-            
-            head = H5T.copy(ismrmrd.hdf5_datatypes.getType_AcquisitionHeader);
-            traj = H5T.vlen_create(ismrmrd.hdf5_datatypes.getType_float());
-            data = H5T.vlen_create(ismrmrd.hdf5_datatypes.getType_float());
-            
+
+            head = H5T.copy(ismrmrd.util.hdf5_datatypes.getType_AcquisitionHeader());
+            traj = H5T.vlen_create(ismrmrd.util.hdf5_datatypes.getType_float());
+            data = H5T.vlen_create(ismrmrd.util.hdf5_datatypes.getType_float());
+
             typesize = H5T.get_size(head) + H5T.get_size(traj) + H5T.get_size(data);
-            
+
             b = H5T.create ('H5T_COMPOUND', typesize);
 
             offset = 0;
@@ -190,51 +219,51 @@ classdef hdf5_datatypes
             H5T.insert(b, 'traj', offset, traj);
             offset = offset + H5T.get_size(traj);
             H5T.insert(b, 'data', offset, data);
-            
+
         end
     end % Methods (Static)
-    
+
 end
 
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(AcquisitionHeader_with_data)));
-% 
+%
 % 	boost::shared_ptr<DataType>  head_type = getIsmrmrdHDF5Type<AcquisitionHeader>();
 % 	boost::shared_ptr<DataType> cxvdatatype = getIsmrmrdHDF5Type<complex_t>();
 % 	cxvdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (cxvdatatype->getId())));
 % 	boost::shared_ptr<DataType> realvdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (PredType::NATIVE_FLOAT.getId())));
-% 
+%
 % 	ret->insertMember( "head",  HOFFSET(AcquisitionHeader_with_data,head),   	*head_type);
 % 	ret->insertMember( "traj", HOFFSET(AcquisitionHeader_with_data,traj),  		*realvdatatype);
 % 	ret->insertMember( "data", HOFFSET(AcquisitionHeader_with_data,data),  		*cxvdatatype);
 
 
 
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader>()
 % {
-% 
+%
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader)));
-% 
+%
 % 	ret->insertMember( "version", 					HOFFSET(ImageHeader, version), 					PredType::NATIVE_UINT16);
 % 	ret->insertMember( "flags", 					HOFFSET(ImageHeader, flags), 				   	PredType::NATIVE_UINT64);
 % 	ret->insertMember( "measurement_uid", 			HOFFSET(ImageHeader, measurement_uid), 		    PredType::NATIVE_UINT32);
-% 
+%
 % 	std::vector<hsize_t> dims(1,0);
-% 
+%
 % 	dims[0] = 3;
 % 	boost::shared_ptr<DataType> mat_size_array_type(new ArrayType(PredType::NATIVE_UINT16, 1, &dims[0]));
 % 	ret->insertMember( "matrix_size", 				HOFFSET(ImageHeader, matrix_size), 		*mat_size_array_type);
-% 
+%
 % 	dims[0] = 3;
 % 	boost::shared_ptr<DataType> fov_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 % 	ret->insertMember( "field_of_view", 			HOFFSET(ImageHeader, field_of_view), 		*fov_array_type);
-% 
+%
 % 	ret->insertMember( "channels", 					HOFFSET(ImageHeader, channels), 					PredType::NATIVE_UINT16);
-% 
+%
 % 	dims[0] = 3;
 % 	boost::shared_ptr<DataType> position_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 % 	ret->insertMember( "position", 					HOFFSET(ImageHeader, position), 				*position_array_type);
-% 
+%
 %	dims[0] = 3;
 %	boost::shared_ptr<DataType> phase_dir_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 %	ret->insertMember( "phase_dir", 				HOFFSET(ImageHeader, phase_dir), 			*phase_dir_array_type);
@@ -246,12 +275,12 @@ end
 %	dims[0] = 3;
 %	boost::shared_ptr<DataType> table_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 %	ret->insertMember( "patient_table_position", 	HOFFSET(ImageHeader, patient_table_position), *table_array_type);
-% 
+%
 % 	dims[0] = 3;
 % 	boost::shared_ptr<DataType> table_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 % 	ret->insertMember( "patient_table_position", 	HOFFSET(ImageHeader, patient_table_position), *table_array_type);
-% 
-% 
+%
+%
 % 	ret->insertMember( "average", 					HOFFSET(ImageHeader, average), 					PredType::NATIVE_UINT16);
 % 	ret->insertMember( "slice", 					HOFFSET(ImageHeader, slice), 					PredType::NATIVE_UINT16);
 % 	ret->insertMember( "contrast", 					HOFFSET(ImageHeader, contrast), 				PredType::NATIVE_UINT16);
@@ -259,28 +288,28 @@ end
 % 	ret->insertMember( "repetition", 				HOFFSET(ImageHeader, repetition), 				PredType::NATIVE_UINT16);
 % 	ret->insertMember( "set",   					HOFFSET(ImageHeader, set), 						PredType::NATIVE_UINT16);
 % 	ret->insertMember( "acquisition_time_stamp", 	HOFFSET(ImageHeader, acquisition_time_stamp),   PredType::NATIVE_UINT32);
-% 
+%
 % 	dims[0] = 3;
 % 	boost::shared_ptr<DataType> array_type(new ArrayType(PredType::NATIVE_UINT32, 1, &dims[0]));
 % 	ret->insertMember( "physiology_time_stamp", HOFFSET(ImageHeader, physiology_time_stamp), 		*array_type);
-% 
+%
 % 	ret->insertMember( "image_data_type",   		HOFFSET(ImageHeader, image_data_type),			PredType::NATIVE_UINT16);
 % 	ret->insertMember( "image_type",   				HOFFSET(ImageHeader, image_type),				PredType::NATIVE_UINT16);
 % 	ret->insertMember( "image_index",   			HOFFSET(ImageHeader, image_index),				PredType::NATIVE_UINT16);
 % 	ret->insertMember( "image_series_index",		HOFFSET(ImageHeader, image_series_index),		PredType::NATIVE_UINT16);
-% 
+%
 % 	dims[0] = 8;
 % 	boost::shared_ptr<DataType> user_int_array_type(new ArrayType(PredType::NATIVE_INT32, 1, &dims[0]));
 % 	ret->insertMember( "user_int", 				HOFFSET(ImageHeader, user_int), *user_int_array_type);
-% 
+%
 % 	dims[0] = 8;
 % 	boost::shared_ptr<DataType> user_float_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
 % 	ret->insertMember( "user_float", 				HOFFSET(ImageHeader, user_float), *user_float_array_type);
-% 
+%
 % 	return ret;
 % }
-% 
-% 
+%
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data<float> >()
 % {
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader_with_data<float>)));
@@ -291,7 +320,7 @@ end
 % 	ret->insertMember( "data", HOFFSET(ImageHeader_with_data<float>,data),  	*vdatatype);
 % 	return ret;
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data<double> >()
 % {
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader_with_data<double>)));
@@ -302,7 +331,7 @@ end
 % 	ret->insertMember( "data", HOFFSET(ImageHeader_with_data<double>,data),  	*vdatatype);
 % 	return ret;
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data<unsigned short> >()
 % {
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader_with_data<unsigned short>)));
@@ -313,7 +342,7 @@ end
 % 	ret->insertMember( "data", HOFFSET(ImageHeader_with_data<unsigned short>,data),  	*vdatatype);
 % 	return ret;
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data<complex_t> >()
 % {
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader_with_data<complex_t>)));
@@ -324,7 +353,7 @@ end
 % 	ret->insertMember( "data", HOFFSET(ImageHeader_with_data<complex_t>,data),  	*vdatatype);
 % 	return ret;
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data<double_complex_t> >()
 % {
 % 	boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(ImageHeader_with_data<double_complex_t>)));
@@ -335,16 +364,16 @@ end
 % 	ret->insertMember( "data", HOFFSET(ImageHeader_with_data<double_complex_t>,data),  	*vdatatype);
 % 	return ret;
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data< std::complex<float> > >()
 % {
 % 	return getIsmrmrdHDF5Type<ImageHeader_with_data<complex_t> >();
 % }
-% 
+%
 % template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data< std::complex<double> > >()
 % {
 % 	return getIsmrmrdHDF5Type<ImageHeader_with_data<double_complex_t> >();
 % }
-% 
+%
 % }
-% 
+%
diff --git a/matlab/+ismrmrd/+util/includejar.m b/matlab/+ismrmrd/+util/includejar.m
new file mode 100644
index 0000000..dcaa62e
--- /dev/null
+++ b/matlab/+ismrmrd/+util/includejar.m
@@ -0,0 +1,15 @@
+function includejar()
+% Set the javaclasspath to be able to load the xml header bits
+
+    % Path to the jar file
+    fpath = mfilename('fullpath');
+    [pathstr, name, ext] = fileparts(fpath);
+    jar = fullfile(pathstr, 'ismrmrd-matlab.jar');
+    
+    % Only add if it's not already on our path
+    jpath = javaclasspath('-all');
+    if ~any(strcmp(jar,jpath))
+        javaaddpath(jar);
+    end
+
+end
diff --git a/matlab/+ismrmrd/old/isInt.m b/matlab/+ismrmrd/+util/isInt.m
similarity index 100%
rename from matlab/+ismrmrd/old/isInt.m
rename to matlab/+ismrmrd/+util/isInt.m
diff --git a/matlab/+ismrmrd/Acquisition.m b/matlab/+ismrmrd/Acquisition.m
new file mode 100644
index 0000000..9dd441d
--- /dev/null
+++ b/matlab/+ismrmrd/Acquisition.m
@@ -0,0 +1,122 @@
+classdef Acquisition < handle
+
+    properties
+        head = [];
+        traj = {};
+        data = {};
+    end
+
+    methods
+
+        function obj = Acquisition(arg1, traj, data)
+            switch nargin
+                case 0
+                    % No argument constructor
+                    % initialize to a single acquisition
+                    extend(obj,1);
+                    
+                case 1
+                    % One argument constructor
+                    if ismrmrd.util.isInt(arg1)
+                        % First argument is a number
+                        M = arg1;
+                        extend(obj,M);
+                    else                        
+                        % First argument is a header (hopefully)
+                        M = length(arg1.version);
+                        obj.head = ismrmrd.AcquisitionHeader(arg1);
+                        obj.traj{M} = [];
+                        obj.data{M} = [];
+                    end
+                    
+                case 3
+                    % Three argument constructor
+                    obj.head = ismrmrd.AcquisitionHeader(arg1);
+                    M = length(arg1.version);
+                    if isempty(traj)
+                        obj.traj{M} = [];
+                    else
+                        obj.traj = traj;
+                    end
+                    if isempty(data)
+                        obj.data{M} = [];
+                    else
+                        if isreal(data{1})
+                            dataFromFloat(obj,data);
+                        else
+                            obj.data = data;
+                        end
+                    end
+                    
+            otherwise
+                    error('ismrmrd.Acquistion constructor, wrong number of arguments.');
+            end
+        end
+        
+        function nacq = getNumber(obj)
+            nacq = obj.head.getNumber();
+        end
+        
+        function acq = select(obj, range)
+            % Return a copy of a range of acquisitions
+            
+            % create an empty acquisition
+            acq = ismrmrd.Acquisition();
+            % Fill the header
+            acq.head = obj.head.select(range);
+            % Fill the trajectory and the data
+            for p = 1:length(range)
+                acq.traj{p} = obj.traj{range(p)};
+                acq.data{p} = obj.data{range(p)};
+            end    
+        end
+        
+        function append(obj, head, traj, data)
+            Nstart = obj.getNumber + 1;
+            Nend   = obj.getNumber + length(head.version);
+            Nrange = Nstart:Nend;
+            obj.head.append(head);
+            if isempty(traj) > 0
+                obj.traj{Nrange} = traj;
+            end
+            if isempty(data) > 0
+                obj.data{Nrange} = data;
+            end
+            
+        end
+        
+        function extend(obj,N)
+            % Extend with blank head and empty traj and data.
+            M = N+obj.getNumber();
+            obj.head.extend(N);
+            obj.traj{M} = [];
+            obj.data{M} = []; 
+        end
+        
+        function dataFromFloat(obj,v)
+            if (isempty(obj.head) || (length(v) ~= length(obj.head.version)))
+                error('Mismatch between size of head and data.  Please set head first.');
+            end
+            obj.data = cell(1,length(v));
+            for p = 1:length(v)
+                dims = [obj.head.number_of_samples(p), ...
+                        obj.head.active_channels(p)];
+                buff = v{p};
+                obj.data{p} = reshape(buff(1:2:end) + 1j*buff(2:2:end), dims);
+            end
+        end
+
+        function v = dataToFloat(obj)
+            v = cell(1,length(obj.data));
+            for p = 1:length(obj.data)
+                dim = size(obj.data{p});
+                buff = zeros([2*prod(dim),1],'single');
+                buff(1:2:end) = real(reshape(obj.data{p},prod(dim),1));
+                buff(2:2:end) = imag(reshape(obj.data{p},prod(dim),1));
+                v{p} = buff;
+            end
+        end
+        
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/+ismrmrd/AcquisitionFlags.m b/matlab/+ismrmrd/AcquisitionFlags.m
deleted file mode 100644
index f8ea364..0000000
--- a/matlab/+ismrmrd/AcquisitionFlags.m
+++ /dev/null
@@ -1,38 +0,0 @@
-classdef AcquisitionFlags
-    properties(Constant)
-        % Looping indicators %
-        ACQ_FIRST_IN_ENCODE_STEP1                	= 1,
-        ACQ_LAST_IN_ENCODE_STEP1    				= 2,
-        ACQ_FIRST_IN_ENCODE_STEP2   				= 3,
-        ACQ_LAST_IN_ENCODE_STEP2    				= 4,
-        ACQ_FIRST_IN_AVERAGE        				= 5,
-        ACQ_LAST_IN_AVERAGE         				= 6,
-        ACQ_FIRST_IN_SLICE          				= 7,
-        ACQ_LAST_IN_SLICE           				= 8,
-        ACQ_FIRST_IN_CONTRAST       				= 9,
-        ACQ_LAST_IN_CONTRAST        				= 10,
-        ACQ_FIRST_IN_PHASE          				= 11,
-        ACQ_LAST_IN_PHASE           				= 12,
-        ACQ_FIRST_IN_REPETITION     				= 13,
-        ACQ_LAST_IN_REPETITION      				= 14,
-        ACQ_FIRST_IN_SET            				= 15,
-        ACQ_LAST_IN_SET             				= 16,
-        ACQ_FIRST_IN_SEGMENT        				= 17,
-        ACQ_LAST_IN_SEGMENT         				= 18,
-
-        ACQ_IS_NOISE_MEASUREMENT                	= 19,
-        ACQ_IS_PARALLEL_CALIBRATION             	= 20,
-        ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING 	= 21,
-        ACQ_IS_REVERSE              				= 22,
-        ACQ_IS_NAVIGATION_DATA      				= 23,
-
-        ACQ_USER1                   				= 57,
-        ACQ_USER2                   				= 58,
-        ACQ_USER3                   				= 59,
-        ACQ_USER4                   				= 60,
-        ACQ_USER5                   				= 61,
-        ACQ_USER6                   				= 62,
-        ACQ_USER7                   				= 63,
-        ACQ_USER8                   				= 64
-    end
-end
\ No newline at end of file
diff --git a/matlab/+ismrmrd/AcquisitionHeader.m b/matlab/+ismrmrd/AcquisitionHeader.m
index 1fbb742..cd4e3db 100644
--- a/matlab/+ismrmrd/AcquisitionHeader.m
+++ b/matlab/+ismrmrd/AcquisitionHeader.m
@@ -1,237 +1,468 @@
-classdef AcquisitionHeader
+classdef AcquisitionHeader < handle
     
     properties
-        version = uint16(0);                           % First unsigned int indicates the version %
-        flags = uint64(0);                             % bit field with flags %
-        measurement_uid = uint32(0);                   % Unique ID for the measurement %
-        scan_counter = uint32(0);                      % Current acquisition number in the measurement %
-        acquisition_time_stamp = uint32(0);            % Acquisition clock %
-        physiology_time_stamp = zeros(8,1,'uint32');   % Physiology time stamps, e.g. ecg, breating, etc. %
-        number_of_samples = uint16(0);                 % Number of samples acquired %
-        available_channels = uint16(0);                % Available coils %
-        active_channels = uint16(0);                   % Active coils on current acquisiton %
-        channel_mask = zeros(16,1,'uint64');           % Mask to indicate which channels are active. Support for 1024 channels %
-        discard_pre = uint16(0);                       % Samples to be discarded at the beginning of acquisition %
-        discard_post = uint16(0);                      % Samples to be discarded at the end of acquisition %
-        center_sample = uint16(0);                     % Sample at the center of k-space %
-        encoding_space_ref = uint16(0);                % Reference to an encoding space, typically only one per acquisition %
-        trajectory_dimensions = uint16(0);             % Indicates the dimensionality of the trajectory vector (0 means no trajectory) %
-        sample_time_us = single(0);                    % Time between samples in micro seconds, sampling BW %
-        position = zeros(3,1,'single');                % Three-dimensional spatial offsets from isocenter %
-        read_dir = zeros(3,1,'single');                % Directional cosines of the readout/frequency encoding %
-        phase_dir = zeros(3,1,'single');               % Directional cosines of the phase encoding %
-        slice_dir = zeros(3,1,'single');               % Directional cosines of the slice %
-        patient_table_position = zeros(3,1, 'single'); % Patient table off-center %
-        idx = ismrmrd.EncodingCounters;                % Encoding loop counters, see above %
-        user_int = zeros(8,1,'int32');                 % Free user parameters %
-        user_float = zeros(8,1,'single');              % Free user parameters %
+        
+        version = uint16([]);                          % First unsigned int indicates the version %
+        flags = uint64([]);                            % bit field with flags %
+        measurement_uid = uint32([]);                  % Unique ID for the measurement %
+        scan_counter = uint32([]);                     % Current acquisition number in the measurement %
+        acquisition_time_stamp = uint32([]);           % Acquisition clock %
+        physiology_time_stamp = uint32([]);            % Physiology time stamps, e.g. ecg, breating, etc. %
+        number_of_samples = uint16([]);                % Number of samples acquired %
+        available_channels = uint16([]);               % Available coils %
+        active_channels = uint16([]);                  % Active coils on current acquisiton %
+        channel_mask = uint64([]);                     % Mask to indicate which channels are active. Support for 1024 channels %
+        discard_pre = uint16([]);                      % Samples to be discarded at the beginning of acquisition %
+        discard_post = uint16([]);                     % Samples to be discarded at the end of acquisition %
+        center_sample = uint16([]);                    % Sample at the center of k-space %
+        encoding_space_ref = uint16([]);               % Reference to an encoding space, typically only one per acquisition %
+        trajectory_dimensions = uint16([]);            % Indicates the dimensionality of the trajectory vector (0 means no trajectory) %
+        sample_time_us = single([]);                   % Time between samples in micro seconds, sampling BW %
+        position = single([]);                         % Three-dimensional spatial offsets from isocenter %
+        read_dir = single([]);                         % Directional cosines of the readout/frequency encoding %
+        phase_dir = single([]);                        % Directional cosines of the phase encoding %
+        slice_dir = single([]);                        % Directional cosines of the slice %
+        patient_table_position = single([]);           % Patient table off-center %
+        idx = struct(  ...                             % Encoding loop counters, see above %
+            'kspace_encode_step_1', uint16([]), ...   
+            'kspace_encode_step_2', uint16([]), ...
+            'average', uint16([]), ...
+            'slice', uint16([]), ...
+            'contrast', uint16([]), ...
+            'phase', uint16([]), ...
+            'repetition', uint16([]), ...
+            'set', uint16([]), ...
+            'segment', uint16([]), ...
+            'user', uint16([]));
+        user_int = int32([]);                 % Free user parameters %
+        user_float = single([]);              % Free user parameters %
+        
+    end
+    
+    properties(Constant)
+        FLAGS = struct( ...
+            'ACQ_FIRST_IN_ENCODE_STEP1',                1, ...
+            'ACQ_LAST_IN_ENCODE_STEP1',                 2, ...
+            'ACQ_FIRST_IN_ENCODE_STEP2',                3, ...
+            'ACQ_LAST_IN_ENCODE_STEP2',                 4, ...
+            'ACQ_FIRST_IN_AVERAGE',                     5, ...
+            'ACQ_LAST_IN_AVERAGE',                      6, ...
+            'ACQ_FIRST_IN_SLICE',                       7, ...
+            'ACQ_LAST_IN_SLICE',                        8, ...
+            'ACQ_FIRST_IN_CONTRAST',                    9, ...
+            'ACQ_LAST_IN_CONTRAST',                    10, ...
+            'ACQ_FIRST_IN_PHASE',                      11, ...
+            'ACQ_LAST_IN_PHASE',                       12, ...
+            'ACQ_FIRST_IN_REPETITION',                 13, ...
+            'ACQ_LAST_IN_REPETITION',                  14, ...
+            'ACQ_FIRST_IN_SET',                        15, ...
+            'ACQ_LAST_IN_SET',                         16, ...
+            'ACQ_FIRST_IN_SEGMENT',                    17, ...
+            'ACQ_LAST_IN_SEGMENT',                     18, ...
+            'ACQ_IS_NOISE_MEASUREMENT',                19, ...
+            'ACQ_IS_PARALLEL_CALIBRATION',             20, ...
+            'ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING', 21, ...
+            'ACQ_IS_REVERSE',                          22, ...
+            'ACQ_IS_NAVIGATION_DATA',                  23, ...
+            'ACQ_USER1',                               57, ...
+            'ACQ_USER2',                               58, ...
+            'ACQ_USER3',                               59, ...
+            'ACQ_USER4',                               60, ...
+            'ACQ_USER5',                               61, ...
+            'ACQ_USER6',                               62, ...
+            'ACQ_USER7',                               63, ...
+            'ACQ_USER8',                               64);
     end
     
     methods
         
-        % Constructor
-        function obj = AcquisitionHeader(bytes)
-            if (nargin == 1)
-                off = 1;
-                obj.version                = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.flags                  = typecast(bytes(off:off+7),  'uint64'); off=off+8;
-                obj.measurement_uid        = typecast(bytes(off:off+3),  'uint32'); off=off+4;
-                obj.scan_counter           = typecast(bytes(off:off+3),  'uint32'); off=off+4;
-                obj.acquisition_time_stamp = typecast(bytes(off:off+3),  'uint32'); off=off+4;
-                obj.physiology_time_stamp  = typecast(bytes(off:off+31), 'uint32'); off=off+32;
-                obj.number_of_samples      = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.available_channels     = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.active_channels        = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.channel_mask           = typecast(bytes(off:off+127),'uint64'); off=off+128;
-                obj.discard_pre            = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.discard_post           = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.center_sample          = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.encoding_space_ref     = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.trajectory_dimensions  = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.sample_time_us         = typecast(bytes(off:off+3),  'single'); off=off+4;
-                obj.position               = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.read_dir               = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.phase_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.slice_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.patient_table_position = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.idx              = ismrmrd.EncodingCounters(bytes(off:off+33)); off=off+34;
-                obj.user_int               = typecast(bytes(off:off+31), 'uint32'); off=off+32;
-                obj.user_float             = typecast(bytes(off:off+31), 'single');
+        function obj = AcquisitionHeader(arg)
+            switch nargin
+                case 0
+                    % No argument constructor
+                    % initialize to a single acquisition header
+                    extend(obj,1);
+                    
+                case 1
+                    % One argument constructor
+                    if isstruct(arg)
+                        % plain struct
+                        fromStruct(obj,arg);
+                    elseif (length(arg)==1 && ismrmrd.util.isInt(arg)) == 1
+                        % number
+                        extend(obj,arg);
+                    elseif isa(arg,'int8')
+                        % Byte array
+                        fromBytes(obj,arg);
+                    else
+                        % Unknown type
+                        error('Unknown argument type.')
+                    end
+                    
+                otherwise
+                    error('Wrong number of arguments.')
+                    
             end
         end
         
-        % Convert to Bytes
-        function bytes = toBytes(obj)
-            bytes = zeros(360,1,'int8');
-            off = 1;
-            bytes(off:off+1)   = typecast(obj.version               ,'int8'); off=off+2;
-            bytes(off:off+7)   = typecast(obj.flags                 ,'int8'); off=off+8;
-            bytes(off:off+3)   = typecast(obj.measurement_uid       ,'int8'); off=off+4;
-            bytes(off:off+3)   = typecast(obj.scan_counter          ,'int8'); off=off+4;
-            bytes(off:off+3)   = typecast(obj.acquisition_time_stamp,'int8'); off=off+4;
-            bytes(off:off+31)  = typecast(obj.physiology_time_stamp ,'int8'); off=off+32;
-            bytes(off:off+1)   = typecast(obj.number_of_samples     ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.available_channels    ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.active_channels       ,'int8'); off=off+2;
-            bytes(off:off+127) = typecast(obj.channel_mask          ,'int8'); off=off+128;
-            bytes(off:off+1)   = typecast(obj.discard_pre           ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.discard_post          ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.center_sample         ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.encoding_space_ref    ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.trajectory_dimensions ,'int8'); off=off+2;
-            bytes(off:off+3)   = typecast(obj.sample_time_us        ,'int8'); off=off+4;
-            bytes(off:off+11)  = typecast(obj.position              ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.read_dir              ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.phase_dir             ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.slice_dir             ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.patient_table_position,'int8'); off=off+12;
-            bytes(off:off+33)  = obj.idx.toBytes();                           off=off+34;
-            bytes(off:off+31)  = typecast(obj.user_int              ,'int8'); off=off+32;
-            bytes(off:off+31)  = typecast(obj.user_float            ,'int8');
+        function nacq = getNumber(obj)
+            nacq = length(obj.version);
         end
+
+        function hdr = select(obj, range)
+            % Return a copy of a range of acquisition headers
+            
+            % create an empty acquisition header
+            M = length(range);
+            hdr = ismrmrd.AcquisitionHeader(M);
+            
+            % Fill
+            hdr.version = obj.version(range);
+            hdr.flags = obj.flags(range);
+            hdr.measurement_uid = obj.measurement_uid(range);
+            hdr.scan_counter = obj.scan_counter(range);
+            hdr.acquisition_time_stamp = obj.acquisition_time_stamp(range);
+            hdr.physiology_time_stamp = obj.physiology_time_stamp(:,range);
+            hdr.number_of_samples = obj.number_of_samples(range);
+            hdr.available_channels = obj.available_channels(range);
+            hdr.active_channels = obj.active_channels(range);
+            hdr.channel_mask = obj.channel_mask(:,range);
+            hdr.discard_pre = obj.discard_pre(range);
+            hdr.discard_post = obj.discard_post(range);
+            hdr.center_sample = obj.center_sample(range);
+            hdr.encoding_space_ref = obj.encoding_space_ref(range);
+            hdr.trajectory_dimensions = obj.trajectory_dimensions(range);
+            hdr.sample_time_us = obj.sample_time_us(range);
+            hdr.position = obj.position(:,range);
+            hdr.read_dir = obj.read_dir(:,range);
+            hdr.phase_dir = obj.phase_dir(:,range);
+            hdr.slice_dir = obj.slice_dir(:,range);
+            hdr.patient_table_position = obj.patient_table_position(:,range);
+            hdr.idx.kspace_encode_step_1 = obj.idx.kspace_encode_step_1(range);
+            hdr.idx.kspace_encode_step_2 = obj.idx.kspace_encode_step_2(range);
+            hdr.idx.average = obj.idx.average(range);
+            hdr.idx.slice = obj.idx.slice(range);
+            hdr.idx.contrast = obj.idx.contrast(range);
+            hdr.idx.phase = obj.idx.phase(range);
+            hdr.idx.repetition = obj.idx.repetition(range);
+            hdr.idx.set = obj.idx.set(range);
+            hdr.idx.segment = obj.idx.segment(range);
+            hdr.idx.user = obj.idx.user(:,range);
+            hdr.user_int = obj.user_int(:,range);
+            hdr.user_float = obj.user_float(:,range);
+            
+        end        
         
-        % The flag methods
-        function val = isFlagSet(obj,flagstring)
-            flagbit = ismrmrd.FlagBit(getfield(ismrmrd.AcquisitionFlags,flagstring));
-            val = flagbit.isSet(obj.flags);
+        function extend(obj,N)
+            % Extend with blank header
+            range = obj.getNumber + (1:N);
+            obj.version(1,range)                  = zeros(1,N,'uint16');
+            obj.flags(1,range)                    = zeros(1,N,'uint64');
+            obj.measurement_uid(1,range)          = zeros(1,N,'uint32');
+            obj.scan_counter(1,range)             = zeros(1,N,'uint32');
+            obj.acquisition_time_stamp(1,range)   = zeros(1,N,'uint32');
+            obj.physiology_time_stamp(1:3,range)  = zeros(3,N,'uint32');
+            obj.number_of_samples(1,range)        = zeros(1,N,'uint16');
+            obj.available_channels(1,range)       = zeros(1,N,'uint16');
+            obj.active_channels(1,range)          = zeros(1,N,'uint16');
+            obj.channel_mask(1:16,range)          = zeros(16,N,'uint64');
+            obj.discard_pre(1,range)              = zeros(1,N,'uint16');
+            obj.discard_post(1,range)             = zeros(1,N,'uint16');
+            obj.center_sample(1,range)            = zeros(1,N,'uint16');
+            obj.encoding_space_ref(1,range)       = zeros(1,N,'uint16');
+            obj.trajectory_dimensions(1,range)    = zeros(1,N,'uint16');
+            obj.sample_time_us(1,range)           = zeros(1,N,'uint16');
+            obj.position(1:3,range)               = zeros(3,N,'single');
+            obj.read_dir(1:3,range)               = zeros(3,N,'single');
+            obj.phase_dir(1:3,range)              = zeros(3,N,'single');
+            obj.slice_dir(1:3,range)              = zeros(3,N,'single');
+            obj.patient_table_position(1:3,range) = zeros(3,N,'single');
+            obj.idx.kspace_encode_step_1(1,range) = zeros(1,N,'uint16');
+            obj.idx.kspace_encode_step_2(1,range) = zeros(1,N,'uint16');
+            obj.idx.average(1,range)              = zeros(1,N,'uint16');
+            obj.idx.slice(1,range)                = zeros(1,N,'uint16');
+            obj.idx.contrast(1,range)             = zeros(1,N,'uint16');
+            obj.idx.phase(1,range)                = zeros(1,N,'uint16');
+            obj.idx.repetition(1,range)           = zeros(1,N,'uint16');
+            obj.idx.set(1,range)                  = zeros(1,N,'uint16');
+            obj.idx.segment(1,range)              = zeros(1,N,'uint16');
+            obj.idx.user(1:8,range)               = zeros(8,N,'uint16');
+            obj.user_int(1:8,range)               = zeros(8,N,'int32');
+            obj.user_float(1:8,range)             = zeros(8,N,'single');
         end
         
-        function obj = setFlag(obj,flagstring)
-            flagbit = ismrmrd.FlagBit(getfield(ismrmrd.AcquisitionFlags,flagstring));
-            obj.flags = bitor(obj.flags, flagbit.bitmask);
+        function append(obj, head)
+            Nstart = obj.getNumber + 1;
+            Nend   = obj.getNumber + length(head.version);
+            Nrange = Nstart:Nend;
+            obj.version(Nrange) = hdr.version;
+            obj.flags(Nrange) = hdr.flags;
+            obj.measurement_uid(Nrange) = hdr.measurement_uid;
+            obj.scan_counter(Nrange) = hdr.scan_counter;
+            obj.acquisition_time_stamp(Nrange) = hdr.acquisition_time_stamp;
+            obj.physiology_time_stamp(:,Nrange) = hdr.physiology_time_stamp;
+            obj.number_of_samples(Nrange) = hdr.number_of_samples;
+            obj.available_channels(Nrange) = hdr.available_channels;
+            obj.active_channels(Nrange) = hdr.active_channels;
+            obj.channel_mask(:,Nrange) = hdr.channel_mask;
+            obj.discard_pre(Nrange) = hdr.discard_pre;
+            obj.discard_post(Nrange) = hdr.discard_post;
+            obj.center_sample(Nrange) = hdr.center_sample;
+            obj.encoding_space_ref(Nrange) = hdr.encoding_space_ref;
+            obj.trajectory_dimensions(Nrange) = hdr.trajectory_dimensions;
+            obj.sample_time_us(Nrange) = hdr.sample_time_us;
+            obj.position(:,Nrange) = hdr.position;
+            obj.read_dir(:,Nrange) = hdr.read_dir;
+            obj.phase_dir(:,Nrange) = hdr.phase_dir;
+            obj.slice_dir(:,Nrange) = hdr.slice_dir;
+            obj.patient_table_position(:,Nrange) = hdr.patient_table_position;
+            obj.idx.kspace_encode_step_1(Nrange) = hdr.idx.kspace_encode_step_1;
+            obj.idx.kspace_encode_step_2(Nrange) = hdr.idx.kspace_encode_step_2;
+            obj.idx.average(Nrange) = hdr.idx.average;
+            obj.idx.slice(Nrange) = hdr.idx.slice;
+            obj.idx.contrast(Nrange) = hdr.idx.contrast;
+            obj.idx.phase(Nrange) = hdr.idx.phase;
+            obj.idx.repetition(Nrange) = hdr.idx.repetition;
+            obj.idx.set(Nrange) = hdr.idx.set;
+            obj.idx.segment(Nrange) = hdr.idx.segment;
+            obj.idx.user(:,Nrange) = hdr.idx.user;
+            obj.user_int(:,Nrange) = hdr.user_int;
+            obj.user_float(:,Nrange) = hdr.user_float;            
         end
-        
-        % Set methods
-        function obj = set.version(obj,v)
-            obj.version = uint16(v);
+
+        function fromStruct(obj, hdr)
+            %warning! no error checking
+            obj.version = hdr.version;
+            obj.flags = hdr.flags;
+            obj.measurement_uid = hdr.measurement_uid;
+            obj.scan_counter = hdr.scan_counter;
+            obj.acquisition_time_stamp = hdr.acquisition_time_stamp;
+            obj.physiology_time_stamp = hdr.physiology_time_stamp;
+            obj.number_of_samples = hdr.number_of_samples;
+            obj.available_channels = hdr.available_channels;
+            obj.active_channels = hdr.active_channels;
+            obj.channel_mask = hdr.channel_mask;
+            obj.discard_pre = hdr.discard_pre;
+            obj.discard_post = hdr.discard_post;
+            obj.center_sample = hdr.center_sample;
+            obj.encoding_space_ref = hdr.encoding_space_ref;
+            obj.trajectory_dimensions = hdr.trajectory_dimensions;
+            obj.sample_time_us = hdr.sample_time_us;
+            obj.position = hdr.position;
+            obj.read_dir = hdr.read_dir;
+            obj.phase_dir = hdr.phase_dir;
+            obj.slice_dir = hdr.slice_dir;
+            obj.patient_table_position = hdr.patient_table_position;
+            obj.idx.kspace_encode_step_1 = hdr.idx.kspace_encode_step_1;
+            obj.idx.kspace_encode_step_2 = hdr.idx.kspace_encode_step_2;
+            obj.idx.average = hdr.idx.average;
+            obj.idx.slice = hdr.idx.slice;
+            obj.idx.contrast = hdr.idx.contrast;
+            obj.idx.phase = hdr.idx.phase;
+            obj.idx.repetition = hdr.idx.repetition;
+            obj.idx.set = hdr.idx.set;
+            obj.idx.segment = hdr.idx.segment;
+            obj.idx.user = hdr.idx.user;
+            obj.user_int = hdr.user_int;
+            obj.user_float = hdr.user_float;            
         end
-        
-        function obj = set.flags(obj,v)
-            obj.flags = uint64(v);
-        end
-        
-        function obj = set.measurement_uid(obj,v)
-            obj.measurement_uid = uint32(v);
+
+        function hdr = toStruct(obj)
+            %warning! no error checking
+            hdr = struct();
+            hdr.version = obj.version;
+            hdr.flags = obj.flags;
+            hdr.measurement_uid = obj.measurement_uid;
+            hdr.scan_counter = obj.scan_counter;
+            hdr.acquisition_time_stamp = obj.acquisition_time_stamp;
+            hdr.physiology_time_stamp = obj.physiology_time_stamp;
+            hdr.number_of_samples = obj.number_of_samples;
+            hdr.available_channels = obj.available_channels;
+            hdr.active_channels = obj.active_channels;
+            hdr.channel_mask = obj.channel_mask;
+            hdr.discard_pre = obj.discard_pre;
+            hdr.discard_post = obj.discard_post;
+            hdr.center_sample = obj.center_sample;
+            hdr.encoding_space_ref = obj.encoding_space_ref;
+            hdr.trajectory_dimensions = obj.trajectory_dimensions;
+            hdr.sample_time_us = obj.sample_time_us;
+            hdr.position = obj.position;
+            hdr.read_dir = obj.read_dir;
+            hdr.phase_dir = obj.phase_dir;
+            hdr.slice_dir = obj.slice_dir;
+            hdr.patient_table_position = obj.patient_table_position;
+            hdr.idx.kspace_encode_step_1 = obj.idx.kspace_encode_step_1;
+            hdr.idx.kspace_encode_step_2 = obj.idx.kspace_encode_step_2;
+            hdr.idx.average = obj.idx.average;
+            hdr.idx.slice = obj.idx.slice;
+            hdr.idx.contrast = obj.idx.contrast;
+            hdr.idx.phase = obj.idx.phase;
+            hdr.idx.repetition = obj.idx.repetition;
+            hdr.idx.set = obj.idx.set;
+            hdr.idx.segment = obj.idx.segment;
+            hdr.idx.user = obj.idx.user;
+            hdr.user_int = obj.user_int;
+            hdr.user_float = obj.user_float;            
         end
         
-        function obj = set.scan_counter(obj,v)
-            obj.scan_counter = uint32(v);
-        end
-        
-        function obj = set.acquisition_time_stamp(obj,v)
-            obj.acquisition_time_stamp = uint32(v);
-        end
-        
-        function obj = set.physiology_time_stamp(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.physiology_time_stamp must have 8 elements')
-            end
-            obj.physiology_time_stamp = uint32(v);
-        end
-        
-        function obj = set.number_of_samples(obj,v)
-            obj.number_of_samples = uint16(v);
-        end
-        
-        function obj = set.available_channels(obj,v)
-            obj.available_channels = uint16(v);
-        end
-        
-        function obj = set.active_channels(obj,v)
-            obj.active_channels = uint16(v);
-        end
-        
-        function obj = set.channel_mask(obj,v)
-            if (length(v)~=16)
-                error('AcquisitionHeader.channel_mask must have 16 elements')
+        function fromBytes(obj, bytearray)
+
+            % TODO: physiology_time_stamp should be 3. So size will change
+            % from 360 to 340;
+            if size(bytearray,1) ~= 360
+                error('Wrong number of bytes for AcquisitionHeader.')
             end
-            obj.channel_mask = uint64(v);
-        end
-        
-        function obj = set.discard_pre(obj,v)
-            obj.discard_pre = uint16(v);
+            N = size(bytearray,2);
+            for p = 1:N
+                obj.version(p) =                  typecast(bytearray(  1:  2,p), 'uint16'); ... % First unsigned int indicates the version %
+                obj.flags(p) =                    typecast(bytearray(  3: 10,p), 'uint64'); ... % bit field with flags %
+                obj.measurement_uid(p) =          typecast(bytearray( 11: 14,p), 'uint32'); ... % Unique ID for the measurement %
+                obj.scan_counter(p) =             typecast(bytearray( 15: 18,p), 'uint32'); ... % Current acquisition number in the measurement %
+                obj.acquisition_time_stamp(p) =   typecast(bytearray( 19: 22,p), 'uint32'); ... % Acquisition clock %
+                obj.physiology_time_stamp(:,p) =  typecast(bytearray( 23: 30,p), 'uint32'); ... % Physiology time stamps, e.g. ecg, breating, etc. %
+                                                                                            ... %   TODO: the C header has a bug.  3 is correct
+                obj.number_of_samples(p) =        typecast(bytearray( 55: 56,p), 'uint16'); ... % Number of samples acquired %
+                obj.available_channels(p) =       typecast(bytearray( 57: 58,p), 'uint16'); ... % Available coils %
+                obj.active_channels(p) =          typecast(bytearray( 59: 60,p), 'uint16'); ... % Active coils on current acquisiton %
+                obj.channel_mask(:,p) =           typecast(bytearray( 61:188,p), 'uint64'); ... % Mask to indicate which channels are active. Support for 1024 channels %
+                obj.discard_pre(p) =              typecast(bytearray(189:190,p), 'uint16'); ... % Samples to be discarded at the beginning of acquisition %
+                obj.discard_post(p) =             typecast(bytearray(191:192,p), 'uint16'); ... % Samples to be discarded at the end of acquisition %
+                obj.center_sample(p) =            typecast(bytearray(193:194,p), 'uint16'); ... % Sample at the center of k-space %
+                obj.encoding_space_ref(p) =       typecast(bytearray(195:196,p), 'uint16'); ... % Reference to an encoding space, typically only one per acquisition %
+                obj.trajectory_dimensions(p) =    typecast(bytearray(197:198,p), 'uint16'); ... % Indicates the dimensionality of the trajectory vector (0 means no trajectory) %
+                obj.sample_time_us(p) =           typecast(bytearray(199:202,p), 'single'); ... % Time between samples in micro seconds, sampling BW %
+                obj.position(:,p) =               typecast(bytearray(203:214,p), 'single'); ... % Three-dimensional spatial offsets from isocenter %
+                obj.read_dir(:,p) =               typecast(bytearray(215:226,p), 'single'); ... % Directional cosines of the readout/frequency encoding %
+                obj.phase_dir(:,p) =              typecast(bytearray(227:238,p), 'single'); ... % Directional cosines of the phase encoding %
+                obj.slice_dir(:,p) =              typecast(bytearray(239:250,p), 'single'); ... % Directional cosines of the slice %
+                obj.patient_table_position(:,p) = typecast(bytearray(251:262,p), 'single'); ... % Patient table off-center %
+                obj.idx.kspace_encode_step_1(p) = typecast(bytearray(263:264,p), 'uint16'); ... % phase encoding line number %
+                obj.idx.kspace_encode_step_2(p) = typecast(bytearray(265:266,p), 'uint16'); ... % partition encodning number %
+                obj.idx.average(p) =              typecast(bytearray(267:268,p), 'uint16'); ... % signal average number %
+                obj.idx.slice(p) =                typecast(bytearray(269:270,p), 'uint16'); ... % imaging slice number %
+                obj.idx.contrast(p) =             typecast(bytearray(271:272,p), 'uint16'); ... % echo number in multi-echo %
+                obj.idx.phase(p) =                typecast(bytearray(273:274,p), 'uint16'); ... % cardiac phase number %
+                obj.idx.repetition(p) =           typecast(bytearray(275:276,p), 'uint16'); ... % dynamic number for dynamic scanning %
+                obj.idx.set(p) =                  typecast(bytearray(277:278,p), 'uint16'); ... % flow encoding set %
+                obj.idx.segment(p) =              typecast(bytearray(279:280,p), 'uint16'); ... % segment number for segmented acquisition %
+                obj.idx.user(:,p) =               typecast(bytearray(281:296,p), 'uint16'); ... % Free user parameters %
+                obj.user_int(:,p) =               typecast(bytearray(297:328,p), 'int32');  ... % Free user parameters %
+                obj.user_float(:,p) =             typecast(bytearray(329:360,p), 'single'); ... % Free user parameters %
+            end              
         end
         
-        function obj = set.discard_post(obj,v)
-            obj.discard_post = uint16(v);
-        end
-        
-        function obj = set.center_sample(obj,v)
-            obj.center_sample = uint16(v);
-        end
-        
-        function obj = set.encoding_space_ref(obj,v)
-            obj.encoding_space_ref = uint16(v);
-        end
-        
-        function obj = set.trajectory_dimensions(obj,v)
-            obj.trajectory_dimensions = uint16(v);
-        end
-        
-        function obj = set.sample_time_us(obj,v)
-            obj.sample_time_us = single(v);
-        end
-        
-        function obj = set.position(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.position must have 3 elements')
+        function bytes = toBytes(obj)
+            % Convert to an ISMRMRD AcquisitionHeader struct to a byte array.
+
+            N = obj.getNumber;
+            
+            % TODO: physiology_time_stamp should be 3.
+            %bytes = zeros(340,N,'int8');
+            bytes = zeros(360,N,'int8');
+            for p = 1:N
+                off = 1;
+                bytes(off:off+1,p)   = typecast(obj.version(p)               ,'int8'); off=off+2;
+                bytes(off:off+7,p)   = typecast(obj.flags(p)                 ,'int8'); off=off+8;
+                bytes(off:off+3,p)   = typecast(obj.measurement_uid(p)       ,'int8'); off=off+4;
+                bytes(off:off+3,p)   = typecast(obj.scan_counter(p)          ,'int8'); off=off+4;
+                bytes(off:off+3,p)   = typecast(obj.acquisition_time_stamp(p),'int8'); off=off+4;
+
+                % TODO: physiology_time_stamp should be 3.
+                % but the C struct has a bug, so convert to padding.
+                bytes(off:off+11,p)  = typecast(obj.physiology_time_stamp(:,p) ,'int8'); off=off+12;
+                off = off+20; % Discard 5*uint32;
+
+                bytes(off:off+1,p)   = typecast(obj.number_of_samples(p)     ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.available_channels(p)    ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.active_channels(p)       ,'int8'); off=off+2;
+                bytes(off:off+127,p) = typecast(obj.channel_mask(:,p)        ,'int8'); off=off+128;
+                bytes(off:off+1,p)   = typecast(obj.discard_pre(p)           ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.discard_post(p)          ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.center_sample(p)         ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.encoding_space_ref(p)    ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.trajectory_dimensions(p) ,'int8'); off=off+2;
+                bytes(off:off+3,p)   = typecast(obj.sample_time_us(p)        ,'int8'); off=off+4;
+                bytes(off:off+11,p)  = typecast(obj.position(:,p)            ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.read_dir(:,p)            ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.phase_dir(:,p)           ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.slice_dir(:,p)           ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.patient_table_position(:,p),'int8'); off=off+12;
+                bytes(off:off+1,p)   = typecast(obj.idx.kspace_encode_step_1(p),'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.kspace_encode_step_2(p),'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.average(p)           ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.slice(p)             ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.contrast(p)          ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.phase(p)             ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.repetition(p)        ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.set(p)               ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.idx.segment(p)           ,'int8'); off=off+2;
+                bytes(off:off+15,p)  = typecast(obj.idx.user(:,p)            ,'int8'); off=off+16;
+                bytes(off:off+31,p)  = typecast(obj.user_int(:,p)            ,'int8'); off=off+32;
+                bytes(off:off+31,p)  = typecast(obj.user_float(:,p)          ,'int8');
             end
-            obj.position = single(v);
         end
         
-        function obj = set.read_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.read_dir must have 3 elements')
+        function ret = flagIsSet(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.read_dir = single(v);
-        end
-        
-        function obj = set.phase_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.phase_dir must have 3 elements')
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
+            else
+                error('Flag is of the wrong type.'); 
             end
-            obj.phase_dir = single(v);
-        end
-        
-        function obj = set.slice_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.slice_dir must have 3 elements')
+            bitmask = bitshift(uint64(1),(b-1));
+            ret = zeros(size(range));
+            for p = 1:length(range)
+                ret(p) = (bitand(obj.flags(range(p)), bitmask)>0);
             end
-            obj.slice_dir = single(v);
         end
         
-        function obj = set.patient_table_position(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.patient_table_position must have 3 elements')
+        function flagSet(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.patient_table_position = single(v);
-        end
-        
-        function obj = set.idx(obj,v)
-            if isa(v,'ismrmrd.EncodingCounters')
-                obj.idx = v;
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
             else
-                % not of the correct type, hope it's a struct
-                % and try to copy one element at a time
-                u = fieldnames(obj.idx);
-                for p = 1:length(u)
-                    obj.idx = setfield(obj.idx,u{p},getfield(v,u{p}));
+                error('Flag is of the wrong type.'); 
+            end
+            bitmask = bitshift(uint64(1),(b-1));
+
+            alreadyset = obj.flagIsSet(flag,range);
+            for p = 1:length(range)
+                if ~alreadyset(p)
+                    obj.flags(range(p)) = obj.flags(range(p)) + bitmask;
                 end
             end
         end
         
-        function obj = set.user_int(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.user_int must have 8 elements')
+        function flagClear(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.user_int = int32(v);
-        end
-        
-        function obj = set.user_float(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.user_float must have 8 elements')
+            
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
+            else
+                error('Flag is of the wrong type.'); 
+            end
+            bitmask = bitshift(uint64(1),(b-1));
+            
+            alreadyset = obj.flagIsSet(flag,range);
+            for p = 1:length(range)
+                if alreadyset(p)
+                    obj.flags(range(p)) = obj.flags(range(p)) - bitmask;
+                end
             end
-            obj.user_float = single(v);
+                
+            
         end
         
     end
diff --git a/matlab/+ismrmrd/EncodingCounters.m b/matlab/+ismrmrd/EncodingCounters.m
deleted file mode 100644
index 7f818b5..0000000
--- a/matlab/+ismrmrd/EncodingCounters.m
+++ /dev/null
@@ -1,94 +0,0 @@
-classdef EncodingCounters
-    
-    properties
-        kspace_encode_step_1 = uint16(0); % e.g. phase encoding line number %
-        kspace_encode_step_2 = uint16(0); % e.g. partition encodning number %
-        average              = uint16(0); % e.g. signal average number %
-        slice                = uint16(0); % e.g. imaging slice number %
-        contrast             = uint16(0); % e.g. echo number in multi-echo %
-        phase                = uint16(0); % e.g. cardiac phase number %
-        repetition           = uint16(0); % e.g. dynamic number for dynamic scanning %
-        set                  = uint16(0); % e.g. flow encodning set %
-        segment              = uint16(0); % e.g. segment number for segmented acquisition %
-        user                 = zeros(1,8,'uint16'); % Free user parameters %
-    end
-    
-    methods
-
-        % Constructor
-        function obj = EncodingCounters(bytes)
-            if (nargin == 1)
-                obj.kspace_encode_step_1 = typecast(bytes( 1: 2),'uint16');
-                obj.kspace_encode_step_2 = typecast(bytes( 3: 4),'uint16');
-                obj.average              = typecast(bytes( 5: 6),'uint16');
-                obj.slice                = typecast(bytes( 7: 8),'uint16');
-                obj.contrast             = typecast(bytes( 9:10),'uint16');
-                obj.phase                = typecast(bytes(11:12),'uint16');
-                obj.repetition           = typecast(bytes(13:14),'uint16');
-                obj.set                  = typecast(bytes(15:16),'uint16');
-                obj.segment              = typecast(bytes(17:18),'uint16');
-                obj.user                 = typecast(bytes(19:34),'uint16');
-            end
-        end
-
-        function bytes = toBytes(obj)
-            bytes = zeros(34,1,'int8');
-            bytes( 1: 2) = typecast(obj.kspace_encode_step_1,'int8');
-            bytes( 3: 4) = typecast(obj.kspace_encode_step_2,'int8');
-            bytes( 5: 6) = typecast(obj.average             ,'int8');
-            bytes( 7: 8) = typecast(obj.slice               ,'int8');
-            bytes( 9:10) = typecast(obj.contrast            ,'int8');
-            bytes(11:12) = typecast(obj.phase               ,'int8');
-            bytes(13:14) = typecast(obj.repetition          ,'int8');
-            bytes(15:16) = typecast(obj.set                 ,'int8');
-            bytes(17:18) = typecast(obj.segment             ,'int8');
-            bytes(19:34) = typecast(obj.user                ,'int8');
-        end
-        
-        % Set methods
-        function obj = set.kspace_encode_step_1(obj,v)
-            obj.kspace_encode_step_1 = uint16(v);
-        end
-        
-        function obj = set.kspace_encode_step_2(obj,v)
-            obj.kspace_encode_step_2 = uint16(v);
-        end
-        
-        function obj = set.average(obj,v)
-            obj.average = uint16(v);
-        end
-        
-        function obj = set.slice(obj,v)
-            obj.slice = uint16(v);
-        end
-        
-        function obj = set.contrast(obj,v)
-            obj.contrast = uint16(v);
-        end
-        
-        function obj = set.phase(obj,v)
-            obj.phase = uint16(v);
-        end
-        
-        function obj = set.repetition(obj,v)
-            obj.repetition = uint16(v);
-        end
-        
-        function obj = set.set(obj,v)
-            obj.set = uint16(v);
-        end
-        
-        function obj = set.segment(obj,v)
-            obj.segment = uint16(v);
-        end
-        
-        function obj = set.user(obj,v)
-            if (length(v)~=8)
-                error('EncodingCounters.user must have 8 elements')
-            end
-            obj.user = uint16(v);
-        end
-        
-    end
-   
-end % EncodingCounters
diff --git a/matlab/+ismrmrd/FlagBit.m b/matlab/+ismrmrd/FlagBit.m
deleted file mode 100644
index 6008c16..0000000
--- a/matlab/+ismrmrd/FlagBit.m
+++ /dev/null
@@ -1,32 +0,0 @@
-classdef FlagBit
-    
-    properties
-        bitmask = uint64(0);
-    end
-    
-    methods
-        function obj = FlagBit(b)
-            if ~(b>0)
-                error('b must be positive');
-            else
-                obj.bitmask = bitshift(uint16(1),(b-1));
-            end
-        end % FlagBit
-    end
-    
-    methods
-        
-        function obj = set.bitmask(obj,b)
-            obj.bitmask = uint64(b);
-        end % bitmask set function
-        
-        function b = isSet(obj,m)
-            if (bitand(obj.bitmask, uint64(m))>0)
-                b = true;
-            else
-                b = false;
-            end
-        end % isSet
-    end
-    
-end % classdef
\ No newline at end of file
diff --git a/matlab/+ismrmrd/old/Image.m b/matlab/+ismrmrd/Image.m
similarity index 84%
rename from matlab/+ismrmrd/old/Image.m
rename to matlab/+ismrmrd/Image.m
index fe591b8..2f75783 100644
--- a/matlab/+ismrmrd/old/Image.m
+++ b/matlab/+ismrmrd/Image.m
@@ -1,6 +1,6 @@
 % Image
 classdef Image
-    
+
     % Properties
     properties
 
@@ -8,28 +8,28 @@ classdef Image
         data_ = [];
 
     end % Properties
-    
+
     % Methods
     methods
 
         function obj = set.head_(obj,v)
             obj.head_ = v;
         end
-        
+
         function obj = set.data_(obj,v)
             obj.data_ = single(complex(v));
         end
-        
+
         function b = isFlagSet(obj,flag)
             bitflag = ismrmrd.FlagBit(flag);
             b = bitflag.isSet(obj.head_.flag);
         end
-        
+
         function obj = setFlag(obj,flag)
-            bitflag = ismrmrd.FlagBit(flag);            
+            bitflag = ismrmrd.FlagBit(flag);
             obj.head_.flag = bitor(obj.head_.flag, bitflag.bitmask_);
         end
-        
+
     end % Methods
-    
-end
\ No newline at end of file
+
+end
diff --git a/matlab/+ismrmrd/ImageDataType.m b/matlab/+ismrmrd/ImageDataType.m
deleted file mode 100644
index e231a58..0000000
--- a/matlab/+ismrmrd/ImageDataType.m
+++ /dev/null
@@ -1,9 +0,0 @@
-classdef ImageDataType
-    properties(Constant)
-        DATA_FLOAT = 1,
-        DATA_DOUBLE = 2,
-        DATA_COMPLEX_FLOAT = 3,
-        DATA_COMPLEX_DOUBLE = 4,
-        DATA_UNSIGNED_SHORT = 5
-    end
-end
diff --git a/matlab/+ismrmrd/ImageFlags.m b/matlab/+ismrmrd/ImageFlags.m
deleted file mode 100644
index fda74b5..0000000
--- a/matlab/+ismrmrd/ImageFlags.m
+++ /dev/null
@@ -1,14 +0,0 @@
-% IMAGE FLAGS %
-classdef ImageFlags
-    properties(Constant)
-        IMAGE_IS_NAVIGATION_DATA      				= 23,
-        IMAGE_USER1                   				= 57,
-        IMAGE_USER2                   				= 58,
-        IMAGE_USER3                   				= 59,
-        IMAGE_USER4                   				= 60,
-        IMAGE_USER5                   				= 61,
-        IMAGE_USER6                   				= 62,
-        IMAGE_USER7                   				= 63,
-        IMAGE_USER8                   				= 64
-    end
-end
\ No newline at end of file
diff --git a/matlab/+ismrmrd/ImageHeader.m b/matlab/+ismrmrd/ImageHeader.m
index 6503b0f..9c0940b 100644
--- a/matlab/+ismrmrd/ImageHeader.m
+++ b/matlab/+ismrmrd/ImageHeader.m
@@ -1,236 +1,396 @@
-classdef ImageHeader
+classdef ImageHeader < handle
     
     properties
-        version = uint16(0);                          % First unsigned int indicates the version %
-        flags = uint64(0);                            % bit field with flags %
-        measurement_uid = uint32(0);                  % Unique ID for the measurement %
-        matrix_size = zeros(3,1,'uint16');            % Pixels in the 3 spatial dimensions
-        field_of_view = zeros(3,1,'single');          % Size (in mm) of the 3 spatial dimensions %
-        channels = uint16(0);                         % Number of receive channels %
-        position = zeros(3,1,'single');               % Three-dimensional spatial offsets from isocenter %
-        read_dir = zeros(3,1,'single');               % Directional cosines of the readout/frequency encoding %
-        phase_dir = zeros(3,1,'single');              % Directional cosines of the phase encoding %
-        slice_dir = zeros(3,1,'single');              % Directional cosines of the slice %
-        patient_table_position = zeros(3,1,'single'); % Patient table off-center %
-        average = uint16(0);                          % e.g. signal average number %
-        slice = uint16(0);                            % e.g. imaging slice number %
-        contrast = uint16(0);                         % e.g. echo number in multi-echo %
-        phase = uint16(0);                            % e.g. cardiac phase number %
-        repetition = uint16(0);                       % e.g. dynamic number for dynamic scanning %
-        set = uint16(0);                              % e.g. flow encodning set %
-        acquisition_time_stamp = uint32(0);           % Acquisition clock %
-        physiology_time_stamp = zeros(8,1,'uint32');  % Physiology time stamps, e.g. ecg, breating, etc. %
-        image_data_type = uint16(0);                  % e.g. unsigned short, float, complex float, etc. %
-        image_type = uint16(0);                       % e.g. magnitude, phase, complex, real, imag, etc. %
-        image_index = uint16(0);					  % e.g. image number in series of images  %
-        image_series_index = uint16(0);               % e.g. series number %
-        user_int = zeros(8,1,'int32');                % Free user parameters %
-        user_float = zeros(8,1,'single');             % Free user parameters %
+        
+        version = uint16([]);                % First unsigned int indicates the version %
+        flags = uint64([]);                  % bit field with flags %
+        measurement_uid = uint32([]);        % Unique ID for the measurement %
+        matrix_size = uint16([]);            % Pixels in the 3 spatial dimensions
+        field_of_view = single([]);          % Size (in mm) of the 3 spatial dimensions %
+        channels = uint16([]);               % Number of receive channels %
+        position = single([]);               % Three-dimensional spatial offsets from isocenter %
+        read_dir = single([]);               % Directional cosines of the readout/frequency encoding %
+        phase_dir = single([]);              % Directional cosines of the phase encoding %
+        slice_dir = single([]);              % Directional cosines of the slice %
+        patient_table_position = single([]); % Patient table off-center %
+        average = uint16([]);                % e.g. signal average number %
+        slice = uint16([]);                  % e.g. imaging slice number %
+        contrast = uint16([]);               % e.g. echo number in multi-echo %
+        phase = uint16([]);                  % e.g. cardiac phase number %
+        repetition = uint16([]);             % e.g. dynamic number for dynamic scanning %
+        set = uint16([]);                    % e.g. flow encodning set %
+        acquisition_time_stamp = uint32([]); % Acquisition clock %
+        physiology_time_stamp = uint32([]);  % Physiology time stamps, e.g. ecg, breating, etc. %
+        image_data_type = uint16([]);        % e.g. unsigned short, float, complex float, etc. %
+        image_type = uint16([]);             % e.g. magnitude, phase, complex, real, imag, etc. %
+        image_index = uint16([]);			 % e.g. image number in series of images  %
+        image_series_index = uint16([]);     % e.g. series number %
+        user_int = int32([]);                % Free user parameters %
+        user_float = single([]);             % Free user parameters %
+        
+    end
+
+    properties(Constant)
+        FLAGS = struct( ...
+            'IMAGE_IS_NAVIGATION_DATA', 23, ...
+            'IMAGE_USER1',              57, ...
+            'IMAGE_USER2',              58, ...
+            'IMAGE_USER3',              59, ...
+            'IMAGE_USER4',              60, ...
+            'IMAGE_USER5',              61, ...
+            'IMAGE_USER6',              62, ...
+            'IMAGE_USER7',              63, ...
+            'IMAGE_USER8',              64);
+        
+        DATA_TYPE = struct( ...
+            'FLOAT',          uint16(1), ...
+            'DOUBLE',         uint16(2), ...
+            'COMPLEX_FLOAT',  uint16(3), ...
+            'COMPLEX_DOUBLE', uint16(4), ...
+            'UNSIGNED_SHORT', uint16(5));
+        
+        IMAGE_TYPE = struct( ...
+            'TYPE_MAGNITUDE', uint16(1), ...
+            'TYPE_PHASE',     uint16(2), ...
+            'TYPE_REAL',      uint16(3), ...
+            'TYPE_IMAG',      uint16(4), ...
+            'TYPE_COMPLEX',   uint16(5));
+
     end
     
     methods
         
-        % Constructor
-        function obj = ImageHeader(bytes)
-            if (nargin == 1)
-                off = 1;
-                obj.version                = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.flags                  = typecast(bytes(off:off+7),  'uint64'); off=off+8;
-                obj.measurement_uid        = typecast(bytes(off:off+3),  'uint32'); off=off+4;
-                obj.matrix_size            = typecast(bytes(off:off+5),  'uint16'); off=off+6;
-                obj.field_of_view          = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.channels               = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.position               = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.read_dir               = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.phase_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.slice_dir              = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.patient_table_position = typecast(bytes(off:off+11), 'single'); off=off+12;
-                obj.average                = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.slice                  = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.contrast               = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.phase                  = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.repetition             = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.set                    = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.acquisition_time_stamp = typecast(bytes(off:off+3),  'uint32'); off=off+4;
-                obj.physiology_time_stamp  = typecast(bytes(off:off+31), 'uint32'); off=off+32;
-                obj.image_data_type        = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.image_type             = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.image_index            = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.image_series_index     = typecast(bytes(off:off+1),  'uint16'); off=off+2;
-                obj.user_int               = typecast(bytes(off:off+31), 'uint32'); off=off+32;
-                obj.user_float             = typecast(bytes(off:off+31), 'single');
+        function obj = ImageHeader(arg)
+            switch nargin
+                case 0
+                    % No argument constructor
+                    % initialize to a single image header
+                    extend(obj,1);
+                    
+                case 1
+                    % One argument constructor
+                    if isstruct(arg)
+                        % plain struct
+                        fromStruct(obj,arg);
+                    elseif (length(arg)==1 && ismrmrd.util.isInt(arg)) == 1
+                        % number
+                        extend(obj,arg);
+                    elseif isa(arg,'int8')
+                        % Byte array
+                        fromBytes(obj,arg);
+                    else
+                        % Unknown type
+                        error('Unknown argument type.')
+                    end
+                    
+                otherwise
+                    error('Wrong number of arguments.')
+                    
             end
         end
         
-        function bytes = toBytes(obj)
-            bytes = zeros(214,1,'int8');
-            off = 1;
-            bytes(off:off+1)   = typecast(obj.version               ,'int8'); off=off+2;
-            bytes(off:off+7)   = typecast(obj.flags                 ,'int8'); off=off+8;
-            bytes(off:off+3)   = typecast(obj.measurement_uid       ,'int8'); off=off+4;
-            bytes(off:off+5)   = typecast(obj.matrix_size           ,'int8'); off=off+6;
-            bytes(off:off+11)  = typecast(obj.field_of_view         ,'int8'); off=off+12;
-            bytes(off:off+1)   = typecast(obj.channels              ,'int8'); off=off+2;
-            bytes(off:off+11)  = typecast(obj.position              ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.read_dir              ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.phase_dir             ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.slice_dir             ,'int8'); off=off+12;
-            bytes(off:off+11)  = typecast(obj.patient_table_position,'int8'); off=off+12;
-            bytes(off:off+1)   = typecast(obj.average               ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.slice                 ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.contrast              ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.phase                 ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.repetition            ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.set                   ,'int8'); off=off+2;
-            bytes(off:off+3)   = typecast(obj.acquisition_time_stamp,'int8'); off=off+4;
-            bytes(off:off+31)  = typecast(obj.physiology_time_stamp ,'int8'); off=off+32;
-            bytes(off:off+1)   = typecast(obj.image_data_type       ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.image_type            ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.image_index           ,'int8'); off=off+2;
-            bytes(off:off+1)   = typecast(obj.image_series_index    ,'int8'); off=off+2;
-            bytes(off:off+31)  = typecast(obj.user_int              ,'int8'); off=off+32;
-            bytes(off:off+31)  = typecast(obj.user_float            ,'int8');
+        function nacq = getNumber(obj)
+            nacq = length(obj.version);
         end
         
-        % The flag methods
-        function val = isFlagSet(obj,flagstring)
-            flagbit = ismrmrd.FlagBit(getfield(ismrmrd.ImageFlags,flagstring));
-            val = flagbit.isSet(obj.flags);
-        end
+        function hdr = select(obj, range)
+            % Return a copy of a range of image headers
+            
+            % create an empty image header
+            M = length(range);
+            hdr = ismrmrd.ImageHeader(M);
+            
+            % Fill
+            hdr.version = obj.version(range);
+            hdr.flags = obj.flags(range);
+            hdr.measurement_uid = obj.measurement_uid(range);
+            hdr.matrix_size = obj.matrix_size(:,range);
+            hdr.field_of_view = obj.field_of_view(:,range);
+            hdr.channels = obj.channels(:,range);
+            hdr.position = obj.position(:,range);
+            hdr.read_dir = obj.read_dir(:,range);
+            hdr.phase_dir = obj.phase_dir(:,range);
+            hdr.slice_dir = obj.slice_dir(:,range);
+            hdr.patient_table_position = obj.patient_table_position(:,range);
+            hdr.average = obj.average(range);
+            hdr.slice = obj.slice(range);
+            hdr.contrast = obj.contrast(range);
+            hdr.phase = obj.phase(range);
+            hdr.repetition = obj.repetition(range);
+            hdr.set = obj.set(range);
+            hdr.acquisition_time_stamp = obj.acquisition_time_stamp(range);
+            hdr.physiology_time_stamp = obj.physiology_time_stamp(:,range);
+            hdr.image_data_type = obj.image_data_type(range);
+            hdr.image_type = obj.image_type(range);
+            hdr.image_index = obj.image_index(range);
+            hdr.image_series_index = obj.image_series_index(range);
+            hdr.user_int = obj.user_int(:,range);
+            hdr.user_float = obj.user_float(:,range);
+
+        end        
         
-        function obj = setFlag(obj,flagstring)
-            flagbit = ismrmrd.FlagBit(getfield(ismrmrd.ImageFlags,flagstring));
-            obj.flags = bitor(obj.flags, flagbit.bitmask);
+        function extend(obj,N)
+            % Extend with blank header
+
+            range = obj.getNumber + (1:N);            
+            obj.version(1,range)                  = zeros(1,N,'uint16');
+            obj.flags(1,range)                    = zeros(1,N,'uint64');
+            obj.measurement_uid(1,range)          = zeros(1,N,'uint32');
+            obj.matrix_size(1:3,range)            = zeros(3,N,'uint16');
+            obj.field_of_view(1:3,range)          = zeros(3,N,'single');
+            obj.channels(1,range)                 = zeros(1,N,'uint16');
+            obj.position(1:3,range)               = zeros(3,N,'single');
+            obj.read_dir(1:3,range)               = zeros(3,N,'single');
+            obj.phase_dir(1:3,range)              = zeros(3,N,'single');
+            obj.slice_dir(1:3,range)              = zeros(3,N,'single');
+            obj.patient_table_position(1:3,range) = zeros(3,N,'single');
+            obj.average(1,range)                  = zeros(1,N,'uint16');
+            obj.slice(1,range)                    = zeros(1,N,'uint16');
+            obj.contrast(1,range)                 = zeros(1,N,'uint16');
+            obj.phase(1,range)                    = zeros(1,N,'uint16');
+            obj.repetition(1,range)               = zeros(1,N,'uint16');
+            obj.set(1,range)                      = zeros(1,N,'uint16');
+            obj.acquisition_time_stamp(1,range)   = zeros(1,N,'uint32');
+            obj.physiology_time_stamp(1:3,range)  = zeros(3,N,'uint32');
+            obj.image_data_type(1,range)          = zeros(1,N,'uint16');
+            obj.image_type(1,range)               = zeros(1,N,'uint16');
+            obj.image_index(1,range)              = zeros(1,N,'uint16');
+            obj.image_series_index(1,range)       = zeros(1,N,'uint16');
+            obj.user_int(1:8,range)               = zeros(8,N,'int32');
+            obj.user_float(1:8,range)             = zeros(8,N,'single');
         end
         
-        % Set methods
-        function obj = set.version(obj,v)
-            obj.version = uint16(v);
+        function append(obj, head)
+            Nstart = obj.getNumber + 1;
+            Nend   = obj.getNumber + length(head.version);
+            Nrange = Nstart:Nend;
+            obj.version(Nrange) = hdr.version;
+            obj.flags(Nrange) = hdr.flags;
+            obj.measurement_uid(Nrange) = hdr.measurement_uid;
+            obj.matrix_size(:,Nrange) = hdr.matrix_size;
+            obj.field_of_view(:,Nrange) = hdr.field_of_view;
+            obj.channels(Nrange) = hdr.channels;
+            obj.position(:,Nrange) = hdr.position;
+            obj.read_dir(:,Nrange) = hdr.read_dir;
+            obj.phase_dir(:,Nrange) = hdr.phase_dir;
+            obj.slice_dir(:,Nrange) = hdr.slice_dir;
+            obj.patient_table_position(:,Nrange) = hdr.patient_table_position;
+            obj.average(Nrange) = hdr.average;
+            obj.slice(Nrange) = hdr.slice;
+            obj.contrast(Nrange) = hdr.contrast;
+            obj.phase(Nrange) = hdr.phase;
+            obj.repetition(Nrange) = hdr.repetition;
+            obj.set(Nrange) = hdr.set;
+            obj.acquisition_time_stamp(Nrange) = hdr.acquisition_time_stamp;
+            obj.physiology_time_stamp(:,Nrange) = hdr.physiology_time_stamp;
+            obj.image_data_type(Nrange) = hdr.image_data_type;
+            obj.image_type(Nrange) = hdr.image_type;
+            obj.image_index(Nrange) = hdr.image_index;
+            obj.image_series_index(Nrange) = hdr.image_series_index;
+            obj.user_int(:,Nrange) = hdr.user_int;
+            obj.user_float(:,Nrange) = hdr.user_float;            
+            
         end
-        
-        function obj = set.flags(obj,v)
-            obj.flags = uint64(v);
+
+        function fromStruct(obj, hdr)
+            %warning! no error checking
+            obj.version = hdr.version;
+            obj.flags = hdr.flags;
+            obj.measurement_uid = hdr.measurement_uid;
+            obj.matrix_size = hdr.matrix_size;
+            obj.field_of_view = hdr.field_of_view;
+            obj.channels = hdr.channels;
+            obj.position = hdr.position;
+            obj.read_dir = hdr.read_dir;
+            obj.phase_dir = hdr.phase_dir;
+            obj.slice_dir = hdr.slice_dir;
+            obj.patient_table_position = hdr.patient_table_position;
+            obj.average = hdr.average;
+            obj.slice = hdr.slice;
+            obj.contrast = hdr.contrast;
+            obj.phase = hdr.phase;
+            obj.repetition = hdr.repetition;
+            obj.set = hdr.set;
+            obj.acquisition_time_stamp = hdr.acquisition_time_stamp;
+            obj.physiology_time_stamp = hdr.physiology_time_stamp;
+            obj.image_data_type = hdr.image_data_type;
+            obj.image_type = hdr.image_type;
+            obj.image_index = hdr.image_index;
+            obj.image_series_index = hdr.image_series_index;
+            obj.user_int = hdr.user_int;
+            obj.user_float = hdr.user_float;
         end
-        
-        function obj = set.measurement_uid(obj,v)
-            obj.measurement_uid = uint32(v);
+
+        function hdr = toStruct(obj)
+            %warning! no error checking
+            hdr = struct();
+            hdr.version = obj.version;
+            hdr.flags = obj.flags;
+            hdr.measurement_uid = obj.measurement_uid;
+            hdr.matrix_size = obj.matrix_size;
+            hdr.field_of_view = obj.field_of_view;
+            hdr.channels = obj.channels;
+            hdr.position = obj.position;
+            hdr.read_dir = obj.read_dir;
+            hdr.phase_dir = obj.phase_dir;
+            hdr.slice_dir = obj.slice_dir;
+            hdr.patient_table_position = obj.patient_table_position;
+            hdr.average = obj.average;
+            hdr.slice = obj.slice;
+            hdr.contrast = obj.contrast;
+            hdr.phase = obj.phase;
+            hdr.repetition = obj.repetition;
+            hdr.set = obj.set;
+            hdr.acquisition_time_stamp = obj.acquisition_time_stamp;
+            hdr.physiology_time_stamp = obj.physiology_time_stamp;
+            hdr.image_data_type = obj.image_data_type;
+            hdr.image_type = obj.image_type;
+            hdr.image_index = obj.image_index;
+            hdr.image_series_index = obj.image_series_index;
+            hdr.user_int = obj.user_int;
+            hdr.user_float = obj.user_float;            
         end
         
-        function obj = set.matrix_size(obj,v)
-            if (length(v)~=3)
-                error('ImageHeader.matrix_size must have 3 elements')
+        function fromBytes(obj, bytearray)
+
+            % TODO: physiology_time_stamp should be 3. So size will change
+            % from 214 to 194;
+            if size(bytearray,1) ~= 214
+                error('Wrong number of bytes for AcquisitionHeader.')
             end
-            obj.matrix_size = uint16(v);
+            N = size(bytearray,2);
+            for p = 1:N
+                obj.version(p)                  = typecast(bytes(1:2,p),     'uint16');
+                obj.flags(p)                    = typecast(bytes(3:10,p),    'uint64');
+                obj.measurement_uid(p)          = typecast(bytes(11:14,p),   'uint32');
+                obj.matrix_size(:,p)            = typecast(bytes(15:20,p),   'uint16');
+                obj.field_of_view(:,p)          = typecast(bytes(21:32,p),   'single');
+                obj.channels(p)                 = typecast(bytes(33:34,p),   'uint16');
+                obj.position(:,p)               = typecast(bytes(35:46,p),   'single');
+                obj.read_dir(:,p)               = typecast(bytes(47:58,p),   'single');
+                obj.phase_dir(:,p)              = typecast(bytes(59:70,p),   'single');
+                obj.slice_dir(:,p)              = typecast(bytes(71:82,p),   'single');
+                obj.patient_table_position(:,p) = typecast(bytes(83:94,p),   'single');
+                obj.average(p)                  = typecast(bytes(95:96,p),   'uint16');
+                obj.slice(p)                    = typecast(bytes(97:98,p),   'uint16');
+                obj.contrast(p)                 = typecast(bytes(99:100,p),  'uint16');
+                obj.phase(p)                    = typecast(bytes(101:102,p), 'uint16');
+                obj.repetition(p)               = typecast(bytes(103:104,p), 'uint16');
+                obj.set(p)                      = typecast(bytes(105:106,p), 'uint16');
+                obj.acquisition_time_stamp(p)   = typecast(bytes(107:110,p), 'uint32');
+                obj.physiology_time_stamp(:,p)  = typecast(bytes(111:122,p), 'uint32');
+                                    ... %   TODO: the C header has a bug.  3 is correct                
+                obj.image_data_type(p)          = typecast(bytes(143:144,p), 'uint16');
+                obj.image_type(p)               = typecast(bytes(145:146,p), 'uint16');
+                obj.image_index(p)              = typecast(bytes(147:148,p), 'uint16');
+                obj.image_series_index(p)       = typecast(bytes(149:150,p), 'uint16');
+                obj.user_int(:,p)               = typecast(bytes(151:182,p), 'uint32');
+                obj.user_float(:,p)             = typecast(bytes(183:214,p), 'single');
+            end              
         end
         
-        function obj = set.field_of_view(obj,v)
-            if (length(v)~=3)
-                error('ImageHeader.field_of_view must have 3 elements')
+        function bytes = toBytes(obj)
+            % Convert to an ISMRMRD AcquisitionHeader struct to a byte array.
+
+            N = obj.getNumber;
+            
+            % TODO: physiology_time_stamp should be 3.
+            %bytes = zeros(194,N,'int8');
+            bytes = zeros(214,N,'int8');
+            for p = 1:N
+                off = 1;
+                bytes(off:off+1,p)   = typecast(obj.version(p)                 ,'int8'); off=off+2;
+                bytes(off:off+7,p)   = typecast(obj.flags(p)                   ,'int8'); off=off+8;
+                bytes(off:off+3,p)   = typecast(obj.measurement_uid(p)         ,'int8'); off=off+4;
+                bytes(off:off+5,p)   = typecast(obj.matrix_size(:,p)           ,'int8'); off=off+6;
+                bytes(off:off+11,p)  = typecast(obj.field_of_view(:,p)         ,'int8'); off=off+12;
+                bytes(off:off+1,p)   = typecast(obj.channels(p)                ,'int8'); off=off+2;
+                bytes(off:off+11,p)  = typecast(obj.position(:,p)              ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.read_dir(:,p)              ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.phase_dir(:,p)             ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.slice_dir(:,p)             ,'int8'); off=off+12;
+                bytes(off:off+11,p)  = typecast(obj.patient_table_position(:,p),'int8'); off=off+12;
+                bytes(off:off+1,p)   = typecast(obj.average(p)                 ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.slice(p)                   ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.contrast(p)                ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.phase(p)                   ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.repetition(p)              ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.set(p)                     ,'int8'); off=off+2;
+                bytes(off:off+3,p)   = typecast(obj.acquisition_time_stamp(p)  ,'int8'); off=off+4;
+                % TODO: physiology_time_stamp should be 3.
+                % but the C struct has a bug, so convert to padding.
+                bytes(off:off+11,p)  = typecast(obj.physiology_time_stamp(:,p) ,'int8'); off=off+12;
+                off = off+20; % Discard 5*uint32;
+                bytes(off:off+1,p)   = typecast(obj.image_data_type(p)         ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.image_type(p)              ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.image_index(p)             ,'int8'); off=off+2;
+                bytes(off:off+1,p)   = typecast(obj.image_series_index(p)      ,'int8'); off=off+2;
+                bytes(off:off+31,p)  = typecast(obj.user_int(:,p)              ,'int8'); off=off+32;
+                bytes(off:off+31,p)  = typecast(obj.user_float(:,p)            ,'int8');
             end
-            obj.field_of_view = single(v);
         end
         
-        function obj = set.channels(obj,v)
-            obj.channels = uint16(v);
-        end
-        
-        function obj = set.position(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.position must have 3 elements')
+        function ret = flagIsSet(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.position = single(v);
-        end
-        
-        function obj = set.read_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.read_dir must have 3 elements')
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
+            else
+                error('Flag is of the wrong type.'); 
             end
-            obj.read_dir = single(v);
-        end
-        
-        function obj = set.phase_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.phase_dir must have 3 elements')
+            bitmask = bitshift(uint64(1),(b-1));
+            ret = zeros(size(range));
+            for p = 1:length(range)
+                ret(p) = (bitand(obj.flags(range(p)), bitmask)>0);
             end
-            obj.phase_dir = single(v);
         end
         
-        function obj = set.slice_dir(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.slice_dir must have 3 elements')
+        function flagSet(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.slice_dir = single(v);
-        end
-        
-        function obj = set.patient_table_position(obj,v)
-            if (length(v)~=3)
-                error('AcquisitionHeader.patient_table_position must have 3 elements')
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
+            else
+                error('Flag is of the wrong type.'); 
             end
-            obj.patient_table_position = single(v);
-        end
-        
-        function obj = set.average(obj,v)
-            obj.average = uint16(v);
-        end
-        
-        function obj = set.slice(obj,v)
-            obj.slice = uint16(v);
-        end
-        
-        function obj = set.contrast(obj,v)
-            obj.contrast = uint16(v);
-        end
-        
-        function obj = set.phase(obj,v)
-            obj.phase = uint16(v);
-        end
-        
-        function obj = set.repetition(obj,v)
-            obj.repetition = uint16(v);
-        end
-        
-        function obj = set.set(obj,v)
-            obj.set = uint16(v);
-        end
-        
-        function obj = set.acquisition_time_stamp(obj,v)
-            obj.acquisition_time_stamp = uint32(v);
-        end
-        
-        function obj = set.physiology_time_stamp(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.physiology_time_stamp must have 8 elements')
+            bitmask = bitshift(uint64(1),(b-1));
+
+            alreadyset = obj.flagIsSet(flag,range);
+            for p = 1:length(range)
+                if ~alreadyset(p)
+                    obj.flags(range(p)) = obj.flags(range(p)) + bitmask;
+                end
             end
-            obj.physiology_time_stamp = uint32(v);
-        end
-        
-        function obj = set.image_data_type(obj,v)
-            obj.image_data_type = uint16(v);
         end
         
-        function obj = set.image_type(obj,v)
-            obj.image_type = uint16(v);
-        end
-        
-        function obj = set.image_index(obj,v)
-            obj.image_index = uint16(v);
-        end
-        function obj = set.image_series_index(obj,v)
-            obj.image_series_index = uint16(v);
-        end
-        
-        function obj = set.user_int(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.user_int must have 8 elements')
+        function flagClear(obj, flag, range)
+            if nargin < 3
+                range = 1:obj.getNumber;
             end
-            obj.user_int = int32(v);
-        end
-        
-        function obj = set.user_float(obj,v)
-            if (length(v)~=8)
-                error('AcquisitionHeader.user_float must have 8 elements')
+            
+            if isa(flag, 'char')
+                b = obj.FLAGS.(flag);
+            elseif (flag>0)
+                b = uint64(flag);
+            else
+                error('Flag is of the wrong type.'); 
+            end
+            bitmask = bitshift(uint64(1),(b-1));
+            
+            alreadyset = obj.flagIsSet(flag,range);
+            for p = 1:length(range)
+                if alreadyset(p)
+                    obj.flags(range(p)) = obj.flags(range(p)) - bitmask;
+                end
             end
-            obj.user_float = single(v);
+                
+            
         end
         
     end
diff --git a/matlab/+ismrmrd/ImageType.m b/matlab/+ismrmrd/ImageType.m
deleted file mode 100644
index 7e1cd59..0000000
--- a/matlab/+ismrmrd/ImageType.m
+++ /dev/null
@@ -1,9 +0,0 @@
-classdef ImageType
-    properties(Constant)
-        TYPE_MAGNITUDE = 1,
-        TYPE_PHASE = 2,
-        TYPE_REAL = 3,
-        TYPE_IMAG = 4,
-        TYPE_COMPLEX = 5
-    end
-end
diff --git a/matlab/+ismrmrd/old/file.m b/matlab/+ismrmrd/IsmrmrdDataset.m
similarity index 64%
rename from matlab/+ismrmrd/old/file.m
rename to matlab/+ismrmrd/IsmrmrdDataset.m
index ff71db1..d38fbae 100644
--- a/matlab/+ismrmrd/old/file.m
+++ b/matlab/+ismrmrd/IsmrmrdDataset.m
@@ -1,5 +1,4 @@
-% File
-classdef file
+classdef IsmrmrdDataset
 
     properties
         fid = -1;
@@ -7,12 +6,18 @@ classdef file
         datapath = '';
         xmlpath = '';
         xmlhdr = [];
+        htypes = [];
     end
-    
+
     methods
-        
-        function obj = file(filename,groupname)
-            
+
+        function obj = IsmrmrdDataset(filename,groupname)
+            % add the ismrmrd jar to the javaclasspath
+            ismrmrd.util.includejar();
+
+            % Set the hdf types
+            obj.htypes = ismrmrd.util.hdf5_datatypes;
+                      
             % If the file exists, open it for read/write
             % otherwise, create it
             if exist(filename,'file')
@@ -22,10 +27,10 @@ classdef file
                 obj.fid = H5F.create(filename,'H5F_ACC_TRUNC',fcpl,'H5P_DEFAULT');
                 H5P.close(fcpl);
             end
-            
+
             % Set the filename
             obj.filename = filename;
-            
+
             % Set the group name
             %   default is dataset
             if nargin == 1
@@ -35,34 +40,39 @@ classdef file
             grouppath = ['/' groupname];
             obj.xmlpath   = ['/' groupname '/xml'];
             obj.datapath  = ['/' groupname '/data'];
-            
+
             % Check if the group exists
             lapl_id=H5P.create('H5P_LINK_ACCESS');
             if (H5L.exists(obj.fid,grouppath,lapl_id) == 0)
-                % group does not exist, create it and set a default header
+                % group does not exist, create it
                 group_id = H5G.create(obj.fid, grouppath, 0);
                 H5G.close(group_id);
                 % create a default xml header object
-                obj.xmlhdr = ismrmrd.XMLHeader();
+                %obj.xmlhdr = ismrmrd.XMLHeader();
+                obj.xmlhdr = org.ismrm.ismrmrd.IsmrmrdHeader();
             else
                 % group exists, read the xml header
-                % and create a new convert it to an xml header object
-                obj.xmlhdr = ismrmrd.XMLHeader().stringToHeader(obj.readxml());
+                %obj.xmlhdr = ismrmrd.XMLHeader().stringToHeader(obj.readxml());
+                obj.xmlhdr = org.ismrm.ismrmrd.XMLString.StringToIsmrmrdHeader(obj.readxml());
             end
             H5P.close(lapl_id);
-        
+
         end
-        
+
         function obj = close(obj)
             % synchronize the xml header
-            xmlstring = ismrmrd.XMLHeader.headerToString(obj.xmlhdr);
-            obj.writexml(xmlstring);
+            obj.writexml(obj.xmlstring());
             % close the file
             H5F.close(obj.fid);
         end
+
+        function xmlstring = xmlstring(obj)
+            % convert xmlhdr to a string
+            %xmlstring = ismrmrd.XMLHeader.headerToString(obj.xmlhdr);
+            xmlstring = org.ismrm.ismrmrd.XMLString.IsmrmrdHeaderToString(obj.xmlhdr);
+        end
         
         function xmlstring = readxml(obj)
-            
             % Check if the XML header exists
             % TODO: set it's value to the default
             lapl_id=H5P.create('H5P_LINK_ACCESS');
@@ -73,13 +83,13 @@ classdef file
 
             % Open
             xml_id = H5D.open(obj.fid, obj.xmlpath);
-            
+
             % Get the type
             xml_dtype = H5D.get_type(xml_id);
-            
+
             % Read the data
             hdr = H5D.read(xml_id, xml_dtype, 'H5S_ALL', 'H5S_ALL', 'H5P_DEFAULT');
-            
+
             % Output depends on whether or not the stored string was variale length
             if (H5T.is_variable_str(xml_dtype))
                 xmlstring = hdr{1};
@@ -89,17 +99,19 @@ classdef file
 
             % Close the XML
             H5T.close(xml_dtype);
-            H5D.close (xml_id); 
+            H5D.close (xml_id);
         end
-        
+
         function writexml(obj,xmlstring)
             % No validation is performed.  You're on your own.
+            % make sure it's a char
+            xmlstring = char(xmlstring);
             
             % TODO: add error checking on the write and return a status
             % TODO: if the matlab variable length string bug is resolved
             % then we should change this logic to just modify the length
             % and overwrite.
-            
+
             % Check if the XML header exists
             %   if it does not exist, create it
             %   if it exists, modify the size appropriately
@@ -109,7 +121,7 @@ classdef file
                 H5L.delete(obj.fid, obj.xmlpath,'H5P_DEFAULT');
             end
             H5P.close(lapl_id);
-            
+
             % Set variable length string type
             xml_dtype = H5T.copy('H5T_C_S1');
             % Matlab is having trouble writing variable length strings
@@ -121,18 +133,22 @@ classdef file
             xml_id = H5D.create (obj.fid, obj.xmlpath, xml_dtype, ....
                                  xml_space_id, 'H5P_DEFAULT');
             H5S.close(xml_space_id);
-            
+
             % Write the data
             H5D.write(xml_id, xml_dtype, ...
                       'H5S_ALL', 'H5S_ALL', 'H5P_DEFAULT', xmlstring);
-            
+
             % Close the XML
             H5D.close(xml_id);
-            
         end
-        
+
         function nacq = getNumberOfAcquisitions(obj)
-            
+
+            % Check if the Data exists
+            lapl_id=H5P.create('H5P_LINK_ACCESS');
+            if (H5L.exists(obj.fid, obj.datapath, lapl_id) == 0)
+                error([obj.datapath ' does not exist in the HDF5 dataset.']);
+            end
             dset = H5D.open(obj.fid, obj.datapath);
             space = H5D.get_space(dset);
             H5S.get_simple_extent_dims(space);
@@ -143,64 +159,86 @@ classdef file
 
         end
 
-        function acq = readAcquisition(obj, nacq)
+        function block = readAcquisition(obj, start, stop)
+            if nargin == 1
+                % Read all the acquisitions
+                start = 1;
+                stop = -1;
+            elseif nargin == 2
+                % Read a single acquisition
+                stop = start;
+            end
+
+            % Check if the Data exists
+            lapl=H5P.create('H5P_LINK_ACCESS');
+            if (H5L.exists(obj.fid, obj.datapath, lapl) == 0)
+                error([obj.datapath ' does not exist in the HDF5 dataset.']);
+            end
 
             % Open the data
-            dset_id = H5D.open(obj.fid, obj.datapath);
+            dset = H5D.open(obj.fid, obj.datapath);
 
             % Open the data space
-            file_space_id = H5D.get_space(dset_id);
+            space = H5D.get_space(dset);
+            
+            % Get the size
+            H5S.get_simple_extent_dims(space);
+            [~,dims,~] = H5S.get_simple_extent_dims(space);
+            nacq = dims(1);
 
-            % Initialize the return object
-            acq = ismrmrd.Acquisition;
-        
             % Create a mem_space for reading
-            dims = [1 1];
-            mem_space_id = H5S.create_simple(2,dims,[]);
-
-            % Read the desired acquisition
-            offset = [nacq-1 0];
-            H5S.select_hyperslab(file_space_id,'H5S_SELECT_SET',offset,[1 1],[1 1],[1 1]);
-            d = H5D.read(dset_id, ismrmrd.hdf5_datatypes.getType_Acquisition, ...
-                            mem_space_id, file_space_id, 'H5P_DEFAULT');
-
-            % Set the structure bits
-            acq.head = d.head(1);
-            acq.traj = d.traj{1};
-            t = d.data{1};
-            acq.data = t(1:2:end) + 1j*t(2:2:end);
-            
+            if (stop >= start)
+                offset = [start-1 0];
+                dims = [stop-start+1 1];
+                mem_space = H5S.create_simple(2,dims,[]);
+            else
+                offset = [0 0];
+                dims = [nacq 1];
+                mem_space = H5S.create_simple(2,dims,[]);
+            end
+
+            % Read the desired acquisitions            
+            H5S.select_hyperslab(space,'H5S_SELECT_SET',offset,[1 1],[1 1],dims);
+            d = H5D.read(dset, obj.htypes.T_Acquisition, ...
+                         mem_space, space, 'H5P_DEFAULT');
+                     
+            % Pack'em
+            block = ismrmrd.Acquisition(d.head, d.traj, d.data);
+
             % Clean up
-            H5S.close(mem_space_id);
-            H5S.close(file_space_id);
-            H5D.close(dset_id);
+            H5S.close(mem_space);
+            H5S.close(space);
+            H5D.close(dset);
         end
-                
+
         function appendAcquisition(obj, acq)
             % Append an acquisition
-            
+
             % TODO: Check the type of the input
             
+            % The number of acquisitions that we are going to append
+            N = acq.getNumber();
+            
             % Check if the Data exists
             %   if it does not exist, create it
-            %   if it does exist increase it's size by one
+            %   if it does exist increase it's size
             lapl_id=H5P.create('H5P_LINK_ACCESS');
             if (H5L.exists(obj.fid, obj.datapath, lapl_id) == 0)
                 % Data does not exist
                 %   create with rank 2, unlimited, and set the chunk size
-                dims    = [1 1];
+                dims    = [N 1];
                 maxdims = [H5ML.get_constant_value('H5S_UNLIMITED') 1];
                 file_space_id = H5S.create_simple(2, dims, maxdims);
-                
+
                 dcpl = H5P.create('H5P_DATASET_CREATE');
                 chunk = [1 1];
                 H5P.set_chunk (dcpl, chunk);
                 data_id = H5D.create(obj.fid, obj.datapath, ...
-                                     ismrmrd.hdf5_datatypes.getType_Acquisition, ...
+                                     obj.htypes.T_Acquisition, ...
                                      file_space_id, dcpl);
                 H5P.close(dcpl);
                 H5S.close(file_space_id);
-                
+
             else
                 % Open the data
                 data_id = H5D.open(obj.fid, obj.datapath);
@@ -208,41 +246,35 @@ classdef file
                 % Open the data space
                 file_space_id = H5D.get_space(data_id);
 
-                % Get the size, increment by one
+                % Get the size, increment by N
                 H5S.get_simple_extent_dims(file_space_id);
                 [~,dims,~] = H5S.get_simple_extent_dims(file_space_id);
-                dims = [dims(1)+1, 1];
+                dims = [dims(1)+N, 1];
                 H5D.set_extent (data_id, dims);
                 H5S.close(file_space_id);
 
             end
             H5P.close(lapl_id);
-            
-            % Get the file space (room for one more acq)
+
+            % Get the file space
             file_space_id = H5D.get_space(data_id);
             [~,dims,~] = H5S.get_simple_extent_dims(file_space_id);
-            
-            % Select the last block
-            offset = [dims(1)-1 0];
-            H5S.select_hyperslab(file_space_id,'H5S_SELECT_SET',offset,[],[],[]);
-            
+
+            % Select the last N block
+            offset = [dims(1)-N 0];
+            H5S.select_hyperslab(file_space_id,'H5S_SELECT_SET',offset,[1 1],[1 1],[N 1]);
+
             % Mem space
-            mem_space_id = H5S.create_simple(2,[1 1],[]);
+            mem_space_id = H5S.create_simple(2,[N 1],[]);
 
             % Pack the acquisition into the correct struct for writing
-            swarn = warning('query','MATLAB:structOnObject');
-            warning('off', 'MATLAB:structOnObject')
-            d.head(1) = struct(acq.head);
-            d.head(1).idx = struct(acq.head.idx);
-            warning(swarn.state, 'MATLAB:structOnObject')            
-            d.traj{1} = acq.traj;
-            t = zeros(2*length(acq.data),1,'single');
-            t(1:2:end) = real(acq.data);
-            t(2:2:end) = imag(acq.data);
-            d.data{1} = t;
+            d = struct();
+            d.head = acq.head.toStruct();
+            d.traj = acq.traj;
+            d.data = acq.dataToFloat();
             
             % Write
-            H5D.write(data_id, ismrmrd.hdf5_datatypes.getType_Acquisition(), ...
+            H5D.write(data_id, obj.htypes.T_Acquisition, ...
                       mem_space_id, file_space_id, 'H5P_DEFAULT', d);
 
             % Clean up
@@ -250,7 +282,7 @@ classdef file
             H5S.close(file_space_id);
             H5D.close(data_id);
         end
-        
+
     end
-    
+
 end
diff --git a/matlab/+ismrmrd/XMLHeader.m b/matlab/+ismrmrd/XMLHeader.m
deleted file mode 100644
index eca3ebc..0000000
--- a/matlab/+ismrmrd/XMLHeader.m
+++ /dev/null
@@ -1,33 +0,0 @@
-classdef XMLHeader
-
-    methods
-
-        function obj = XMLHeader(xmlstr)
-
-            obj.factory = org.ismrm.ismrmrd.xmlhdr.ObjectFactory(); 
-        end
-
-        function hdr = fromString(obj,xmlstring)
-            import javax.xml.bind.*
-            jc = JAXBContext.newInstance('org.ismrm.ismrmrd.xmlhdr', obj.factory.getClass().getClassLoader());
-            u  = jc.createUnmarshaller();
-            jstr = java.lang.String(xmlstring);
-            hdr = u.unmarshal(java.io.ByteArrayInputStream(jstr.getBytes()));
-
-        end
-
-        function xmlstring = toString(obj)
-            import javax.xml.bind.*
-            jc = JAXBContext.newInstance('org.ismrm.ismrmrd.xmlhdr', obj.factory.getClass().getClassLoader());
-            m  = jc.createMarshaller();
-            m.setProperty(Marshaller.JAXB_SCHEMA_LOCATION, 'http://www.ismrm.org/ISMRMD ismrmrd.xsd');
-
-            strbuff = java.io.StringWriter();
-            m.marshal(hdr, strbuff);
-            xmlstring = strbuff.toString();
-
-        end
-
-    end
-
-end
diff --git a/matlab/+ismrmrd/old/Acquisition.m b/matlab/+ismrmrd/old/Acquisition.m
deleted file mode 100644
index e9e4fe3..0000000
--- a/matlab/+ismrmrd/old/Acquisition.m
+++ /dev/null
@@ -1,49 +0,0 @@
-% Acquisition
-classdef Acquisition
-    
-    % Properties
-    properties
-
-        head = ismrmrd.AcquisitionHeader;
-        traj = single([]);
-        data = single([]);
-
-    end % Properties
-    
-    % Methods
-    methods
-        
-        function obj = set.head(obj,v)
-            if isa(v,'ismrmrd.AcquisitionHeader')
-                obj.head = v;
-            else
-                % not of the correct type, hope it's a struct 
-                % and try to copy one element at a time
-                u = fieldnames(obj.head);
-                for p = 1:length(u)
-                    obj.head = setfield(obj.head,u{p},getfield(v,u{p}));
-                end
-            end
-        end
-        
-        function obj = set.traj(obj,v)
-            obj.traj = single(v);
-        end
-        
-        function obj = set.data(obj,v)
-            obj.data = single(v);        
-        end
-
-        function b = isFlagSet(obj,flag)
-            bitflag = ismrmrd.FlagBit(flag);
-            b = bitflag.isSet(obj.head.flag);
-        end
-        
-        function obj = setFlag(obj,flag)
-            bitflag = ismrmrd.FlagBit(flag);            
-            obj.head.flag = bitor(obj.head.flag, bitflag.bitmask);
-        end
-        
-    end % Methods
-    
-end
\ No newline at end of file
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
new file mode 100644
index 0000000..2b92ab0
--- /dev/null
+++ b/matlab/CMakeLists.txt
@@ -0,0 +1,72 @@
+find_package(Java)
+
+if (NOT JAVA_FOUND)
+    message(STATUS "Java (xjc) Not Found - Not generating XML bindings")
+else (NOT JAVA_FOUND)
+
+    set(ISMRMRD_SCHEMA ${CMAKE_SOURCE_DIR}/schema/ismrmrd.xsd)
+    set(ISMRMRD_JAR "${CMAKE_CURRENT_BINARY_DIR}/ismrmrd-matlab.jar")
+    set(ISMRMRD_PACKAGE "org/ismrm/ismrmrd")
+    set(ISMRMRD_PACKAGE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${ISMRMRD_PACKAGE}")
+
+    set(XML_STRING "XMLString")
+    set(XML_STRING_JAVA "XMLString.java")
+
+    set(XJC_CONFIG "cfg.jxb")
+    file (COPY ${XJC_CONFIG} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+    file (MAKE_DIRECTORY ${ISMRMRD_PACKAGE_PATH})
+    file (COPY ${XML_STRING_JAVA} DESTINATION ${ISMRMRD_PACKAGE_PATH})
+
+    foreach (class
+        ${XML_STRING}
+        AccelerationFactorType
+        ExperimentalConditionsType
+        MeasurementInformationType
+        TrajectoryDescriptionType
+        AcquisitionSystemInformationType
+        FieldOfViewMm
+        ObjectFactory
+        TrajectoryType
+        CalibrationModeType
+        InterleavingDimensionType
+        ParallelImagingType
+        UserParameterBase64Type
+        DicomParametersType
+        IsmrmrdHeader
+        ReferencedImageSequence
+        UserParameterDoubleType
+        Encoding
+        LimitType
+        SequenceParametersType
+        UserParameterLongType
+        EncodingLimitsType
+        MRImageModule
+        StudyInformationType
+        UserParameters
+        EncodingSpaceType
+        MatrixSize
+        SubjectInformationType
+        package-info
+    )
+        list (APPEND ISMRMRD_XJC_SOURCES "${ISMRMRD_PACKAGE}/${class}.java")
+        list (APPEND ISMRMRD_XJC_CLASSES "${ISMRMRD_PACKAGE}/${class}.class")
+    endforeach()
+
+    add_custom_command(
+        OUTPUT ${ISMRMRD_JAR}
+        COMMAND ${Java_XJC_EXECUTABLE} -quiet -b ${XJC_CONFIG} ${ISMRMRD_SCHEMA}
+        COMMAND ${Java_JAVAC_EXECUTABLE} ${ISMRMRD_XJC_SOURCES}
+        COMMAND ${Java_JAR_EXECUTABLE} cf ${ISMRMRD_JAR} ${ISMRMRD_XJC_CLASSES}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating ISMRMRD XML bindings..." VERBATIM
+        DEPENDS ${ISMRMRD_SCHEMA} ${XML_STRING_JAVA}
+    )
+
+    # make a fake target called 'xxx.jar' that will be built
+    # when you type make and depends on the file 'xxx.jar'
+    add_custom_target(ismrmrd-matlab-jar ALL DEPENDS ${ISMRMRD_JAR})
+endif(NOT JAVA_FOUND)
+
+INSTALL(DIRECTORY +ismrmrd DESTINATION matlab)
+INSTALL(FILES ${ISMRMRD_JAR} DESTINATION matlab/+ismrmrd/+util)
diff --git a/matlab/XMLString.java b/matlab/XMLString.java
new file mode 100644
index 0000000..39127ca
--- /dev/null
+++ b/matlab/XMLString.java
@@ -0,0 +1,42 @@
+package org.ismrm.ismrmrd;
+
+import javax.xml.bind.*;
+import javax.xml.namespace.QName;
+import javax.xml.transform.stream.*;
+import java.io.StringReader;
+import java.io.StringWriter;
+
+
+public class XMLString {
+    public static IsmrmrdHeader StringToIsmrmrdHeader(String xmlstring) throws javax.xml.bind.JAXBException
+    {
+        JAXBContext jaxbContext = JAXBContext.newInstance(IsmrmrdHeader.class);
+
+        Unmarshaller unmarshaller  = jaxbContext.createUnmarshaller();
+
+        StringReader reader = new StringReader(xmlstring);
+
+        JAXBElement<IsmrmrdHeader> root = unmarshaller.unmarshal(new StreamSource(reader), IsmrmrdHeader.class);
+
+        return root.getValue();
+    }
+
+    public static String IsmrmrdHeaderToString(IsmrmrdHeader header) throws javax.xml.bind.JAXBException
+    {
+        JAXBContext jaxbContext = JAXBContext.newInstance(IsmrmrdHeader.class);
+
+        Marshaller marshaller = jaxbContext.createMarshaller();
+
+        marshaller.setProperty(Marshaller.JAXB_SCHEMA_LOCATION, "http://www.ismrm.org/ISMRMRD ismrmrd.xsd");
+        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+
+        StringWriter writer = new StringWriter();
+
+        QName qname = new QName("http://www.ismrm.org/ISMRMRD", "ismrmrdHeader");
+        JAXBElement<IsmrmrdHeader> root = new JAXBElement(qname, IsmrmrdHeader.class, header);
+
+        marshaller.marshal(root, writer);
+
+        return writer.toString();
+    }
+}
diff --git a/matlab/cfg.jxb b/matlab/cfg.jxb
new file mode 100644
index 0000000..696f66d
--- /dev/null
+++ b/matlab/cfg.jxb
@@ -0,0 +1,10 @@
+<jxb:bindings version="1.0"
+  xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
+  jxb:extensionBindingPrefixes="xjc">
+    <jxb:bindings>
+        <jxb:globalBindings localScoping="toplevel">
+        </jxb:globalBindings>
+    </jxb:bindings>
+</jxb:bindings>
diff --git a/schema/ismrmrd.xsd b/schema/ismrmrd.xsd
index c020eec..4be1512 100644
--- a/schema/ismrmrd.xsd
+++ b/schema/ismrmrd.xsd
@@ -1,40 +1,22 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <xs:schema xmlns="http://www.ismrm.org/ISMRMRD" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" targetNamespace="http://www.ismrm.org/ISMRMRD">
 
-  <xs:element name="ismrmrdHeader">
-    <xs:complexType>
+    <xs:element name="ismrmrdHeader" type="ismrmrdHeader"/>
+
+    <xs:complexType name="ismrmrdHeader">
       <xs:sequence>
 	<xs:element maxOccurs="1" minOccurs="0" name="subjectInformation" type="subjectInformationType"/>
 	<xs:element maxOccurs="1" minOccurs="0" name="studyInformation" type="studyInformationType"/>
 	<xs:element maxOccurs="1" minOccurs="0" name="measurementInformation" type="measurementInformationType"/>
 	<xs:element maxOccurs="1" minOccurs="0" name="acquisitionSystemInformation" type="acquisitionSystemInformationType"/>
 	<xs:element maxOccurs="1" minOccurs="1" name="experimentalConditions" type="experimentalConditionsType"/>
-	<xs:element maxOccurs="unbounded" minOccurs="1" name="encoding">
-	  <xs:complexType>
-	    <xs:all>
-	      <xs:element maxOccurs="1" minOccurs="1" name="encodedSpace" type="encodingSpaceType"/>
-	      <xs:element maxOccurs="1" minOccurs="1" name="reconSpace" type="encodingSpaceType"/>
-	      <xs:element maxOccurs="1" minOccurs="1" name="encodingLimits" type="encodingLimitsType"/>
-	      <xs:element maxOccurs="1" minOccurs="1" name="trajectory" type="trajectoryType"/>
-	      <xs:element maxOccurs="1" minOccurs="0" name="trajectoryDescription" type="trajectoryDescriptionType"/>
-	    </xs:all>
-	  </xs:complexType>
-	</xs:element>
+        <xs:element maxOccurs="unbounded" minOccurs="1" name="encoding" type="encoding"/>
 	<xs:element maxOccurs="1" minOccurs="0" name="parallelImaging" type="parallelImagingType"/>
 	<xs:element maxOccurs="1" minOccurs="0" name="sequenceParameters" type="sequenceParametersType"/>
         <xs:element maxOccurs="1" minOccurs="0" name="dicomParameters" type="dicomParametersType"/>
-	<xs:element maxOccurs="1" minOccurs="0" name="userParameters">
-	  <xs:complexType>
-	    <xs:sequence>
-	      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterLong" type="userParameterLongType"/>
-	      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterDouble" type="userParameterDoubleType"/>
-	      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterBase64" type="userParameterBase64Type"/>
-	    </xs:sequence>
-	  </xs:complexType>
-	</xs:element>
+        <xs:element maxOccurs="1" minOccurs="0" name="userParameters" type="userParameters"/>
       </xs:sequence>
     </xs:complexType>
-  </xs:element>
 
   <xs:complexType name="subjectInformationType">
     <xs:all>
@@ -63,9 +45,27 @@
     </xs:all>
   </xs:complexType>
 
-  <xs:complexType name="experimentalConditionsType">
+  <xs:complexType name="measurementInformationType">
     <xs:all>
-      <xs:element name="H1resonanceFrequency_Hz" type="xs:long"/>
+      <xs:element minOccurs="1" name="seriesDate" type="xs:date"/>
+      <xs:element minOccurs="1" name="seriesTime" type="xs:time"/>
+      <xs:element minOccurs="1" name="patientPosition">
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:enumeration value="HFP"/>
+            <xs:enumeration value="HFS"/>
+            <xs:enumeration value="HFDR"/>
+            <xs:enumeration value="HFDL"/>
+            <xs:enumeration value="FFP"/>
+            <xs:enumeration value="FFS"/>
+            <xs:enumeration value="FFDR"/>
+            <xs:enumeration value="FFDL"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element minOccurs="0" name="initialSeriesNumber" type="xs:long"/>
+      <xs:element minOccurs="0" name="protocolName" type="xs:string"/>
+      <xs:element minOccurs="0" name="seriesDescription" type="xs:string"/>
     </xs:all>
   </xs:complexType>
 
@@ -81,29 +81,45 @@
     </xs:all>
   </xs:complexType>
 
+  <xs:complexType name="experimentalConditionsType">
+    <xs:all>
+      <xs:element name="H1resonanceFrequency_Hz" type="xs:long"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="encoding">
+    <xs:all>
+      <xs:element maxOccurs="1" minOccurs="1" name="encodedSpace" type="encodingSpaceType"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="reconSpace" type="encodingSpaceType"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="encodingLimits" type="encodingLimitsType"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="trajectory" type="trajectoryType"/>
+      <xs:element maxOccurs="1" minOccurs="0" name="trajectoryDescription" type="trajectoryDescriptionType"/>
+    </xs:all>
+  </xs:complexType>
+
   <xs:complexType name="encodingSpaceType">
     <xs:all>
-      <xs:element name="matrixSize">
-	<xs:complexType>
-	  <xs:sequence>
-	    <xs:element default="1" maxOccurs="1" minOccurs="1" name="x" type="xs:unsignedShort"/>
-	    <xs:element default="1" maxOccurs="1" minOccurs="1" name="y" type="xs:unsignedShort"/>
-	    <xs:element default="1" maxOccurs="1" minOccurs="1" name="z" type="xs:unsignedShort"/>
-	  </xs:sequence>
-	</xs:complexType>
-      </xs:element>
-      <xs:element name="fieldOfView_mm">
-	<xs:complexType>
-	  <xs:sequence>
-	    <xs:element maxOccurs="1" minOccurs="1" name="x" type="xs:float"/>
-	    <xs:element maxOccurs="1" minOccurs="1" name="y" type="xs:float"/>
-	    <xs:element maxOccurs="1" minOccurs="1" name="z" type="xs:float"/>
-	  </xs:sequence>
-	</xs:complexType>
-      </xs:element>
+      <xs:element maxOccurs="1" minOccurs="1" name="matrixSize" type="matrixSize"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="fieldOfView_mm" type="fieldOfView_mm"/>
     </xs:all>
   </xs:complexType>
 
+  <xs:complexType name="matrixSize">
+    <xs:sequence>
+      <xs:element default="1" maxOccurs="1" minOccurs="1" name="x" type="xs:unsignedShort"/>
+      <xs:element default="1" maxOccurs="1" minOccurs="1" name="y" type="xs:unsignedShort"/>
+      <xs:element default="1" maxOccurs="1" minOccurs="1" name="z" type="xs:unsignedShort"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="fieldOfView_mm">
+    <xs:sequence>
+      <xs:element maxOccurs="1" minOccurs="1" name="x" type="xs:float"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="y" type="xs:float"/>
+      <xs:element maxOccurs="1" minOccurs="1" name="z" type="xs:float"/>
+    </xs:sequence>
+  </xs:complexType>
+
   <xs:complexType name="limitType">
     <xs:all>
       <xs:element default="0" name="minimum" type="xs:unsignedShort"/>
@@ -148,11 +164,11 @@
   </xs:complexType>
 
   <xs:complexType name="sequenceParametersType">
-  	<xs:sequence>
-  		<xs:element minOccurs="1" maxOccurs="unbounded" type="xs:float" name="TR"/>
-  		<xs:element minOccurs="1" maxOccurs="unbounded" type="xs:float" name="TE"/>
-  		<xs:element minOccurs="0" maxOccurs="unbounded" type="xs:float" name="TI"/>
-  	</xs:sequence>
+    <xs:sequence>
+      <xs:element minOccurs="1" maxOccurs="unbounded" type="xs:float" name="TR"/>
+      <xs:element minOccurs="1" maxOccurs="unbounded" type="xs:float" name="TE"/>
+      <xs:element minOccurs="0" maxOccurs="unbounded" type="xs:float" name="TI"/>
+    </xs:sequence>
   </xs:complexType>
 
   <xs:complexType name="userParameterLongType">
@@ -176,68 +192,49 @@
     </xs:all>
   </xs:complexType>
 
-  <xs:complexType name="measurementInformationType">
+  <xs:complexType name="dicomParametersType">
     <xs:all>
-      <xs:element minOccurs="1" name="seriesDate" type="xs:date"/>
-      <xs:element minOccurs="1" name="seriesTime" type="xs:time"/>
-      <xs:element minOccurs="1" name="patientPosition">
+      <xs:element minOccurs="1" name="studyInstanceUID" type="xs:string"/>
+      <xs:element minOccurs="0" name="seriesInstanceUIDRoot" type="xs:string"/>
+      <xs:element minOccurs="0" name="frameOfReferenceUID" type="xs:string"/>
+      <xs:element minOccurs="0" name="referencedImageSequence" type="referencedImageSequence"/>
+      <xs:element minOccurs="0" name="MRImageModule" type="MRImageModule"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="referencedImageSequence">
+    <xs:sequence>
+      <xs:element minOccurs="0" maxOccurs="unbounded" name="referencedSOPInstanceUID" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+      
+  <xs:complexType name="MRImageModule">
+    <xs:all>
+      <xs:element minOccurs="0" name="imageType" type="xs:string"/>
+      <xs:element minOccurs="0" name="scanningSequence" type="xs:string"/>
+      <xs:element minOccurs="0" name="sequenceVariant" type="xs:string"/>
+      <xs:element minOccurs="0" name="scanOptions" type="xs:string"/>
+      <xs:element minOccurs="0" name="mrAcquisitionType" type="xs:string"/>
+      <xs:element minOccurs="0" name="echoTrainLength" type="xs:long"/>
+      <xs:element minOccurs="0" name="triggerTime" type="xs:float"/>
+      <xs:element minOccurs="0" name="flipAngle_deg" type="xs:long"/>
+      <xs:element minOccurs="0" name="freqEncodingDirection">
         <xs:simpleType>
           <xs:restriction base="xs:string">
-            <xs:enumeration value="HFP"/>
-            <xs:enumeration value="HFS"/>
-            <xs:enumeration value="HFDR"/>
-            <xs:enumeration value="HFDL"/>
-            <xs:enumeration value="FFP"/>
-            <xs:enumeration value="FFS"/>
-            <xs:enumeration value="FFDR"/>
-            <xs:enumeration value="FFDL"/>
+            <xs:enumeration value="ROW"/>
+            <xs:enumeration value="COL"/>
           </xs:restriction>
         </xs:simpleType>
       </xs:element>
-      <xs:element minOccurs="0" name="initialSeriesNumber" type="xs:long"/>
-      <xs:element minOccurs="0" name="protocolName" type="xs:string"/>
-      <xs:element minOccurs="0" name="seriesDescription" type="xs:string"/>
     </xs:all>
   </xs:complexType>
 
-  <xs:complexType name="dicomParametersType">
-    <xs:all>
-      <xs:element minOccurs="1" name="studyInstanceUID" type="xs:string"/>
-      <xs:element minOccurs="0" name="seriesInstanceUIDRoot" type="xs:string"/>
-      <xs:element minOccurs="0" name="frameOfReferenceUID" type="xs:string"/>
-
-      <xs:element minOccurs="0" name="referencedImageSequence">
-        <xs:complexType>
-          <xs:sequence>
-            <xs:element minOccurs="0" maxOccurs="unbounded" name="referencedSOPInstanceUID" type="xs:string"/>
-          </xs:sequence>
-        </xs:complexType>
-      </xs:element>
-
-      <xs:element minOccurs="0" name="MRImageModule">
-        <xs:complexType>
-          <xs:all>
-            <xs:element minOccurs="0" name="imageType" type="xs:string"/>
-            <xs:element minOccurs="0" name="scanningSequence" type="xs:string"/>
-            <xs:element minOccurs="0" name="sequenceVariant" type="xs:string"/>
-            <xs:element minOccurs="0" name="scanOptions" type="xs:string"/>
-            <xs:element minOccurs="0" name="mrAcquisitionType" type="xs:string"/>
-            <xs:element minOccurs="0" name="echoTrainLength" type="xs:long"/>
-            <xs:element minOccurs="0" name="triggerTime" type="xs:float"/>
-            <xs:element minOccurs="0" name="flipAngle_deg" type="xs:long"/>
-            <xs:element minOccurs="0" name="freqEncodingDirection">
-              <xs:simpleType>
-                <xs:restriction base="xs:string">
-                  <xs:enumeration value="ROW"/>
-                  <xs:enumeration value="COL"/>
-                </xs:restriction>
-              </xs:simpleType>
-            </xs:element>
-          </xs:all>
-        </xs:complexType>
-      </xs:element>
-
-    </xs:all>
+  <xs:complexType name="userParameters">
+    <xs:sequence>
+      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterLong" type="userParameterLongType"/>
+      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterDouble" type="userParameterDoubleType"/>
+      <xs:element maxOccurs="unbounded" minOccurs="0" name="userParameterBase64" type="userParameterBase64Type"/>
+    </xs:sequence>
   </xs:complexType>
 
   <xs:complexType name="accelerationFactorType">

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/ismrmrd.git



More information about the debian-science-commits mailing list