[ismrmrd] 05/281: Started implementation of HDF5 tools
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Wed Jan 14 20:00:48 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to annotated tag ismrmrd0.5
in repository ismrmrd.
commit 3f78d477ba9538f343aac7411b0dff9cafe23683
Author: Michael S. Hansen <michael.hansen at nih.gov>
Date: Mon Jul 30 11:20:23 2012 -0400
Started implementation of HDF5 tools
---
CMakeLists.txt | 17 +-
cmake/FindIsmrmrd.cmake | 17 +-
ismrmrd.h | 8 +-
ismrmrd_hdf5.cpp | 73 ++++++-
ismrmrd_hdf5.h | 48 ++++-
ismrmrd_hdf5_datatypes.h | 481 +++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 616 insertions(+), 28 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 55d4cdc..9262257 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,6 +5,8 @@ list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
find_package(XSD REQUIRED)
find_package(XercesC REQUIRED)
+find_package(Boost REQUIRED)
+find_package(HDF5 1.8 COMPONENTS C CXX HL REQUIRED)
#Process the XSD files
SET(XSDS schema/ismrmrd.xsd)
@@ -12,10 +14,15 @@ SET(XSD_ARGS cxx-tree --generate-serialization)
WRAP_XSD(XSDS_SOURCES XSD_INCLUDES ${CMAKE_CURRENT_BINARY_DIR}/schema ${XSDS} OPTIONS ${XSD_ARGS})
-INCLUDE_DIRECTORIES(${XSD_INCLUDES})
-add_executable(ismrmrd main.cpp ${XSDS_SOURCES})
-target_link_libraries(ismrmrd ${XERCESC_LIBRARIES})
+INCLUDE_DIRECTORIES(${XSD_INCLUDES} ${XERCESC_INCLUDE_DIR} ${Boost_INCLUDE_DIR} ${HDF5_INCLUDES})
+add_executable(ismrmrd_test main.cpp ${XSDS_SOURCES})
+target_link_libraries(ismrmrd_test ${XERCESC_LIBRARIES})
-INSTALL(FILES ismrmrd.h DESTINATION include)
+add_library(ismrmrd SHARED ismrmrd_hdf5.cpp)
+target_link_libraries(ismrmrd ${HDF5_LIBRARIES})
+
+INSTALL(FILES ismrmrd.h ismrmrd_hdf5.h ismrmrd_hdf5_datatypes.h ismrmrd_export.h DESTINATION include)
INSTALL(FILES schema/ismrmrd.xsd DESTINATION schema)
-INSTALL(FILES cmake/FindIsmrmrd.cmake DESTINATION cmake)
\ No newline at end of file
+INSTALL(FILES cmake/FindIsmrmrd.cmake DESTINATION cmake)
+INSTALL(TARGETS ismrmrd DESTINATION lib)
+INSTALL(TARGETS ismrmrd_test DESTINATION bin)
\ No newline at end of file
diff --git a/cmake/FindIsmrmrd.cmake b/cmake/FindIsmrmrd.cmake
index 2e26b9d..7120f31 100644
--- a/cmake/FindIsmrmrd.cmake
+++ b/cmake/FindIsmrmrd.cmake
@@ -1,13 +1,18 @@
# - Find ISMRMRRD
# ISMRMRD_FOUND - True if ISMRMRD found.
# ISMRMRD_INCLUDE_DIR - where to find ismrmrd.h, etc.
+# ISMRMRD_LIBRARIES - libismrmrd.so, etc.
-FIND_PATH( ISMRMRD_INCLUDE_DIR "ismrmrd.h"
- PATH_SUFFIXES "ismrmrd" )
+MESSAGE("GADGETRON_HOME: $ENV{GADGETRON_HOME}")
+
+FIND_PATH( ISMRMRD_INCLUDE_DIR ismrmrd.h
+$ENV{GADGETRON_HOME}/include /usr/local/include)
+
+FIND_LIBRARY( ISMRMRD_LIBRARIES
+ NAMES "ismrmrd"
+ PATHS $ENV{GADGETRON_HOME}/lib /usr/local/lib)
-# handle the QUIETLY and REQUIRED arguments and set TINYXML_FOUND to TRUE if
-# all listed variables are TRUE
INCLUDE( "FindPackageHandleStandardArgs" )
-FIND_PACKAGE_HANDLE_STANDARD_ARGS( "Ismrmrd" DEFAULT_MSG ISMRMRD_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS( "Ismrmrd" DEFAULT_MSG ISMRMRD_INCLUDE_DIR ISMRMRD_LIBRARIES)
-MARK_AS_ADVANCED( ISMRMRD_INCLUDE_DIR)
\ No newline at end of file
+MARK_AS_ADVANCED( ISMRMRD_INCLUDE_DIR ISMRMRD_LIBRARIES)
\ No newline at end of file
diff --git a/ismrmrd.h b/ismrmrd.h
index 2c5592a..4d06a69 100644
--- a/ismrmrd.h
+++ b/ismrmrd.h
@@ -6,7 +6,7 @@
/* Brian Hargreaves (bah at stanford.edu) */
/* Sebastian Kozerke (kozerke at biomed.ee.ethz.ch) */
-#prama once
+#pragma once
#ifndef ISMRMRD_H
#define ISMRMRD_H
@@ -80,9 +80,9 @@ namespace ISMRMRD
float sample_time_us; //Time between samples in micro seconds, sampling BW
float position[3]; //Three-dimensional spatial offsets from isocenter
float quarternion[4]; //Angulation of acquisition
- float patient_table_position[3]; //Patient table off-center
+ float patient_table_position[3]; //Patient table off-center
EncodingCounters idx; //Encoding loop counters, see above
- uint32_t user_int[8]; //Free user parameters
+ int32_t user_int[8]; //Free user parameters
float user_float[8]; //Free user parameters
};
@@ -94,7 +94,7 @@ namespace ISMRMRD
: traj_(0)
, data_(0)
{
- memset(head_,0,sizeof(AcquisitionHeader));
+ memset(&head_,0,sizeof(AcquisitionHeader));
head_.version = ISMRMRD_VERSION;
}
diff --git a/ismrmrd_hdf5.cpp b/ismrmrd_hdf5.cpp
index a88ab25..e0fc8d6 100644
--- a/ismrmrd_hdf5.cpp
+++ b/ismrmrd_hdf5.cpp
@@ -1,25 +1,76 @@
#include "ismrmrd_hdf5.h"
+#include "ismrmrd_hdf5_datatypes.h"
-#include <H5Cpp.h>
-
-#ifndef H5_NO_NAMESPACE
-using namespace H5;
-#endif
+#include <iostream>
#include <boost/algorithm/string.hpp>
namespace ISMRMRD
{
- struct H5Acquisition
+int IsmrmrdDataset::openHDF5File()
+{
+
+ std::cout << "Opening dataset..." << std::endl;
+ if (file_exists_) {
+ try {
+ if (!H5File::isHdf5(filename_.c_str())) {
+ std::cerr << "File \"" << filename_ << "\" is not an HDF file file" << std::endl;
+ return -1;
+ }
+ file_ = boost::shared_ptr<H5File>(new H5File(filename_, H5F_ACC_RDWR));
+ } catch (...) {
+ std::cerr << "Failed to open HDF5 file." << std::endl;
+ return -1;
+ }
+ file_open_ = true;
+ } else if (create_file_if_needed_){
+ try {
+ file_ = boost::shared_ptr<H5File>(new H5File(filename_, H5F_ACC_TRUNC));
+ } catch (...) {
+ std::cerr << "Failed to create and open HDF5 file." << std::endl;
+ return -1;
+ }
+ file_open_ = true;
+ }
+
+ return 0;
+}
+
+
+
+
+ int H5AppendAcquisition(const Acquisition& a, const char* filename, const char* varname)
{
- AcquisitionHeader head;
- hvl_t traj;
- hvl_t data;
- };
+ /*
+
+ H5Acquisition tmp;
+ tmp.head = a.head_;
+ tmp.traj.len = a.head_.trajectory_dimensions*a.head_.number_of_samples;
+ tmp.traj.p = (void*) a.traj_;
+ tmp.data.len = a.head_.number_of_samples*a.head_.active_channels*2;
+ tmp.data.p = (void*) a.data_;
+
+ boost::shared_ptr<DataType> structdatatype = getHDF5CompositeType<STRUCT>();
+ boost::shared_ptr<DataType> vdatatype = getHDF5Type<DATATYPE>();
+ vdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (vdatatype->getId())));
+
+ CompType* ct = new CompType(sizeof(local_hdf5_append_struct<STRUCT>));
+ ct->insertMember( "h", HOFFSET(local_hdf5_append_struct<STRUCT>,h), *structdatatype);
+ ct->insertMember( "d", HOFFSET(local_hdf5_append_struct<STRUCT>,d), *vdatatype);
+
+ boost::shared_ptr<DataType> datatype(ct);
+
+
+ return hdf5_append_struct(&tmp, datatype, filename, varname);
+ */
+ return 0;
+}
+
+ /*
template <class T> boost::shared_ptr<CompType> getHDF5CompositeType();
template <class T> boost::shared_ptr<DataType> getHDF5ArrayType(int LENGTH);
@@ -115,4 +166,6 @@ template <> boost::shared_ptr<CompType> getHDF5CompositeType<GadgetMessageAcquis
return hdf5_append_struct(&tmp, datatype, filename, varname);
}
+*/
+
} //End of ISMRMRD namespace
diff --git a/ismrmrd_hdf5.h b/ismrmrd_hdf5.h
index a06cef2..c6be388 100644
--- a/ismrmrd_hdf5.h
+++ b/ismrmrd_hdf5.h
@@ -1,18 +1,60 @@
-#prama once
+#pragma once
#ifndef ISMRMRD_HDF5_H
#define ISMRMRD_HDF5_H
#include "ismrmrd_export.h"
#include "ismrmrd.h"
+#include <fstream>
#include <boost/shared_ptr.hpp>
+#include <H5Cpp.h>
+
+#ifndef H5_NO_NAMESPACE
+using namespace H5;
+#endif
+
+
namespace ISMRMRD
{
- EXPORTISMRMRD int H5AppendAcquisition(Acquisition* a, const char* filename, const char* varname);
- EXPORTISMRMRD boost::shared_ptr<Acquisition> H5ReadAcquisition(const char* filename, const char* varname, unsigned long index = 0);
+class EXPORTISMRMRD IsmrmrdDataset
+{
+public:
+ IsmrmrdDataset(const char* filename, const char* groupname, bool create_file_if_needed = true)
+ : filename_(filename)
+ , groupname_(groupname)
+ , file_open_(false)
+ , create_file_if_needed_(create_file_if_needed)
+ {
+ std::ifstream ifile(filename_.c_str());
+ file_exists_ = ifile;
+
+ if (openHDF5File() < 0) {
+ std::cerr << "Error opening HDF file" << std::endl;
+ }
+ }
+
+ bool fileExists() {
+ return file_exists_;
+ }
+
+protected:
+ int openHDF5File();
+
+ std::string filename_;
+ std::string groupname_;
+ bool file_open_;
+ bool file_exists_;
+ bool create_file_if_needed_;
+
+ boost::shared_ptr<H5File> file_;
+
+};
+
+EXPORTISMRMRD int H5AppendAcquisition(Acquisition* a, const char* filename, const char* varname);
+EXPORTISMRMRD boost::shared_ptr<Acquisition> H5ReadAcquisition(const char* filename, const char* varname, unsigned long index = 0);
diff --git a/ismrmrd_hdf5_datatypes.h b/ismrmrd_hdf5_datatypes.h
new file mode 100644
index 0000000..2b8be4f
--- /dev/null
+++ b/ismrmrd_hdf5_datatypes.h
@@ -0,0 +1,481 @@
+#pragma once
+#ifndef ISMRMRD_HDF5_DATATYPES_H_
+#define ISMRMRD_HDF5_DATATYPES_H_
+
+#include "ismrmrd.h"
+
+#include <H5Cpp.h>
+#include <boost/shared_ptr.hpp>
+
+
+#include <vector>
+
+#ifndef H5_NO_NAMESPACE
+ using namespace H5;
+#endif
+
+namespace ISMRMRD
+{
+
+template <typename T> boost::shared_ptr<DataType> getIsmrmrdHDF5Type();
+
+template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<EncodingCounters>()
+{
+
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(EncodingCounters)));
+
+ ret->insertMember( "kspace_encode_step_1", HOFFSET(EncodingCounters, kspace_encode_step_1), PredType::NATIVE_UINT16);
+ ret->insertMember( "kspace_encode_step_2", HOFFSET(EncodingCounters, kspace_encode_step_2), PredType::NATIVE_UINT16);
+ ret->insertMember( "average", HOFFSET(EncodingCounters, average), PredType::NATIVE_UINT16);
+ ret->insertMember( "slice", HOFFSET(EncodingCounters, slice), PredType::NATIVE_UINT16);
+ ret->insertMember( "contrast", HOFFSET(EncodingCounters, contrast), PredType::NATIVE_UINT16);
+ ret->insertMember( "phase", HOFFSET(EncodingCounters, phase), PredType::NATIVE_UINT16);
+ ret->insertMember( "repetition", HOFFSET(EncodingCounters, repetition), PredType::NATIVE_UINT16);
+ ret->insertMember( "set", HOFFSET(EncodingCounters, set), PredType::NATIVE_UINT16);
+ ret->insertMember( "segment", HOFFSET(EncodingCounters, segment), PredType::NATIVE_UINT16);
+
+ std::vector<hsize_t> dims(1,8);
+ boost::shared_ptr<DataType> array_type(new ArrayType(PredType::NATIVE_UINT16, 1, &dims[0]));
+ ret->insertMember( "user", HOFFSET(EncodingCounters, user), *array_type);
+
+ return ret;
+};
+
+template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<AcquisitionHeader>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(AcquisitionHeader)));
+ ret->insertMember( "version", HOFFSET(AcquisitionHeader, version), PredType::NATIVE_UINT16);
+ ret->insertMember( "flags", HOFFSET(AcquisitionHeader, flags), PredType::NATIVE_UINT64);
+ ret->insertMember( "measurement_uid", HOFFSET(AcquisitionHeader, measurement_uid), PredType::NATIVE_UINT32);
+ ret->insertMember( "scan_counter", HOFFSET(AcquisitionHeader, scan_counter), PredType::NATIVE_UINT32);
+ ret->insertMember( "acquisition_time_stamp", HOFFSET(AcquisitionHeader, acquisition_time_stamp), PredType::NATIVE_UINT32);
+
+ 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);
+
+ ret->insertMember( "number_of_samples", HOFFSET(AcquisitionHeader, number_of_samples), PredType::NATIVE_UINT16);
+ ret->insertMember( "available_channels", HOFFSET(AcquisitionHeader, available_channels), PredType::NATIVE_UINT16);
+ ret->insertMember( "active_channels", HOFFSET(AcquisitionHeader, active_channels), PredType::NATIVE_UINT16);
+
+ dims[0] = 16;
+ boost::shared_ptr<DataType> mask_array_type(new ArrayType(PredType::NATIVE_UINT64, 1, &dims[0]));
+ ret->insertMember( "channel_mask", HOFFSET(AcquisitionHeader, channel_mask), *mask_array_type);
+ ret->insertMember( "discard_pre", HOFFSET(AcquisitionHeader, discard_pre), PredType::NATIVE_UINT16);
+ ret->insertMember( "discard_post", HOFFSET(AcquisitionHeader, discard_post), PredType::NATIVE_UINT16);
+ ret->insertMember( "center_sample", HOFFSET(AcquisitionHeader, center_sample), PredType::NATIVE_UINT16);
+ ret->insertMember( "encoding_space_ref", HOFFSET(AcquisitionHeader, encoding_space_ref), PredType::NATIVE_UINT16);
+ ret->insertMember( "trajectory_dimensions", HOFFSET(AcquisitionHeader, trajectory_dimensions), PredType::NATIVE_UINT16);
+ ret->insertMember( "sample_time_us", HOFFSET(AcquisitionHeader, sample_time_us), PredType::NATIVE_FLOAT);
+
+ dims[0] = 3;
+ boost::shared_ptr<DataType> position_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
+ ret->insertMember( "position", HOFFSET(AcquisitionHeader, position), *position_array_type);
+
+ dims[0] = 4;
+ boost::shared_ptr<DataType> quaterion_array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
+ ret->insertMember( "quarternion", HOFFSET(AcquisitionHeader, quarternion), *quaterion_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(AcquisitionHeader, patient_table_position), *table_array_type);
+
+ boost::shared_ptr<DataType> ec_type = getIsmrmrdHDF5Type<EncodingCounters>();
+ ret->insertMember( "idx", HOFFSET(AcquisitionHeader, idx), *ec_type);
+
+ dims[0] = 8;
+ boost::shared_ptr<DataType> user_int_array_type(new ArrayType(PredType::NATIVE_INT32, 1, &dims[0]));
+ ret->insertMember( "user_int", HOFFSET(AcquisitionHeader, 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(AcquisitionHeader, user_float), *user_float_array_type);
+
+ return ret;
+
+}
+
+struct AcquisitionHeader_with_data
+{
+ AcquisitionHeader head;
+ hvl_t traj;
+ hvl_t data;
+};
+
+struct complex_t
+{
+ float real;
+ float imag;
+};
+
+template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<complex_t>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(complex_t)));
+ ret->insertMember( "real", HOFFSET(complex_t,real), PredType::NATIVE_FLOAT);
+ ret->insertMember( "imag", HOFFSET(complex_t,imag), PredType::NATIVE_FLOAT);
+ return ret;
+}
+
+template <> boost::shared_ptr<DataType> getIsmrmrdHDF5Type<AcquisitionHeader_with_data>()
+{
+ 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), *cxvdatatype);
+ ret->insertMember( "data", HOFFSET(AcquisitionHeader_with_data,data), *cxvdatatype);
+ return ret;
+}
+
+
+/*
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<mdhCutOff>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(mdhCutOff)));
+
+ ret->insertMember( "ushPre", HOFFSET(mdhCutOff,ushPre), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushPost", HOFFSET(mdhCutOff,ushPost), PredType::NATIVE_UINT16);
+
+ return ret;
+};
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<mdhSlicePosVec>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(mdhSlicePosVec)));
+
+ ret->insertMember( "flSag", HOFFSET(mdhSlicePosVec,flSag), PredType::NATIVE_FLOAT);
+ ret->insertMember( "flCor", HOFFSET(mdhSlicePosVec,flCor), PredType::NATIVE_FLOAT);
+ ret->insertMember( "flTra", HOFFSET(mdhSlicePosVec,flTra), PredType::NATIVE_FLOAT);
+
+ return ret;
+};
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<mdhSliceData>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(mdhSliceData)));
+
+ std::vector<hsize_t> dims(1,4);
+ boost::shared_ptr<DataType> array_type(new ArrayType(PredType::NATIVE_FLOAT, 1, &dims[0]));
+ boost::shared_ptr<DataType> slicepos_type = getSiemensHDF5Type<mdhSlicePosVec>();
+
+ ret->insertMember( "sSlicePosVec", HOFFSET(mdhSliceData,sSlicePosVec), *slicepos_type);
+ ret->insertMember( "aflQuaternion", HOFFSET(mdhSliceData,aflQuaternion), *array_type);
+ return ret;
+};
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sMDH>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sMDH)));
+
+ std::vector<hsize_t> dims(1,2);
+ boost::shared_ptr<DataType> array_type_eval(new ArrayType(PredType::NATIVE_UINT, 1, &dims[0]));
+
+ dims[0] = 4;
+ boost::shared_ptr<DataType> array_type_icepara(new ArrayType(PredType::NATIVE_USHORT, 1, &dims[0]));
+ boost::shared_ptr<DataType> array_type_freepara(new ArrayType(PredType::NATIVE_USHORT, 1, &dims[0]));
+
+ boost::shared_ptr<DataType> lc_type = getSiemensHDF5Type<mdhLC>();
+ boost::shared_ptr<DataType> cutoff_type = getSiemensHDF5Type<mdhCutOff>();
+
+ boost::shared_ptr<DataType> slicedata_type = getSiemensHDF5Type<mdhSliceData>();
+
+ ret->insertMember( "ulFlagsAndDMALength", HOFFSET(sMDH,ulFlagsAndDMALength), PredType::NATIVE_UINT32);
+ ret->insertMember( "lMeasUID", HOFFSET(sMDH,lMeasUID), PredType::NATIVE_INT32);
+ ret->insertMember( "ulScanCounter", HOFFSET(sMDH,ulScanCounter), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulTimeStamp", HOFFSET(sMDH,ulTimeStamp), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulPMUTimeStamp", HOFFSET(sMDH,ulPMUTimeStamp), PredType::NATIVE_UINT32);
+ ret->insertMember( "aulEvalInfoMask", HOFFSET(sMDH,aulEvalInfoMask), *array_type_eval);
+ ret->insertMember( "ushSamplesInScan", HOFFSET(sMDH,ushSamplesInScan), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushUsedChannels", HOFFSET(sMDH,ushUsedChannels), PredType::NATIVE_UINT16);
+ ret->insertMember( "sLC", HOFFSET(sMDH,sLC), *lc_type);
+ ret->insertMember( "sCutOff", HOFFSET(sMDH,sCutOff), *cutoff_type);
+ ret->insertMember( "ushKSpaceCentreColumn", HOFFSET(sMDH,ushKSpaceCentreColumn), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushCoilSelect", HOFFSET(sMDH,ushCoilSelect), PredType::NATIVE_UINT16);
+ ret->insertMember( "fReadOutOffcentre", HOFFSET(sMDH,fReadOutOffcentre), PredType::NATIVE_FLOAT);
+ ret->insertMember( "ulTimeSinceLastRF", HOFFSET(sMDH,ulTimeSinceLastRF), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushKSpaceCentreLineNo", HOFFSET(sMDH,ushKSpaceCentreLineNo), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushKSpaceCentrePartitionNo", HOFFSET(sMDH,ushKSpaceCentrePartitionNo), PredType::NATIVE_UINT16);
+ ret->insertMember( "aushIceProgramPara", HOFFSET(sMDH,aushIceProgramPara), *array_type_icepara);
+ ret->insertMember( "aushFreePara", HOFFSET(sMDH,aushFreePara), *array_type_freepara);
+ ret->insertMember( "sSliceData", HOFFSET(sMDH,sSliceData), *slicedata_type);
+ ret->insertMember( "ushChannelId", HOFFSET(sMDH,ushChannelId), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushPTABPosNeg", HOFFSET(sMDH,ushPTABPosNeg), PredType::NATIVE_UINT16);
+
+ return ret;
+}
+
+struct MDH_with_data
+{
+ sMDH mdh;
+ hvl_t data;
+};
+
+struct complex_t
+{
+ float real;
+ float imag;
+};
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<complex_t>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(complex_t)));
+ ret->insertMember( "real", HOFFSET(complex_t,real), PredType::NATIVE_FLOAT);
+ ret->insertMember( "imag", HOFFSET(complex_t,imag), PredType::NATIVE_FLOAT);
+ return ret;
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<MDH_with_data>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(MDH_with_data)));
+
+ boost::shared_ptr<DataType> mdh_type = getSiemensHDF5Type<sMDH>();
+ boost::shared_ptr<DataType> vdatatype = getSiemensHDF5Type<complex_t>();
+ vdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (vdatatype->getId())));
+
+ ret->insertMember( "mdh", HOFFSET(MDH_with_data,mdh), *mdh_type);
+ ret->insertMember( "data", HOFFSET(MDH_with_data,data), *vdatatype);
+
+ return ret;
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sScanHeader>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sScanHeader)));
+
+ std::vector<hsize_t> dims(1,2);
+ boost::shared_ptr<DataType> array_type_eval(new ArrayType(PredType::NATIVE_UINT, 1, &dims[0]));
+
+ dims[0] = 24;
+ boost::shared_ptr<DataType> array_type_icepara(new ArrayType(PredType::NATIVE_USHORT, 1, &dims[0]));
+ dims[0] = 4;
+ boost::shared_ptr<DataType> array_type_reserved(new ArrayType(PredType::NATIVE_USHORT, 1, &dims[0]));
+
+ boost::shared_ptr<DataType> lc_type = getSiemensHDF5Type<mdhLC>();
+ boost::shared_ptr<DataType> cutoff_type = getSiemensHDF5Type<mdhCutOff>();
+
+ boost::shared_ptr<DataType> slicedata_type = getSiemensHDF5Type<mdhSliceData>();
+
+ ret->insertMember( "ulFlagsAndDMALength", HOFFSET(sScanHeader,ulFlagsAndDMALength), PredType::NATIVE_UINT32);
+ ret->insertMember( "lMeasUID", HOFFSET(sScanHeader,lMeasUID), PredType::NATIVE_INT32);
+ ret->insertMember( "ulScanCounter", HOFFSET(sScanHeader,ulScanCounter), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulTimeStamp", HOFFSET(sScanHeader,ulTimeStamp), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulPMUTimeStamp", HOFFSET(sScanHeader,ulPMUTimeStamp), PredType::NATIVE_UINT32);
+ ret->insertMember( "ushSystemType", HOFFSET(sScanHeader,ushSystemType), PredType::NATIVE_UINT16);
+ ret->insertMember( "ulPTABPosDelay", HOFFSET(sScanHeader,ulPTABPosDelay), PredType::NATIVE_UINT16);
+ ret->insertMember( "lPTABPosX", HOFFSET(sScanHeader,lPTABPosX), PredType::NATIVE_INT32);
+ ret->insertMember( "lPTABPosY", HOFFSET(sScanHeader,lPTABPosY), PredType::NATIVE_INT32);
+ ret->insertMember( "lPTABPosZ", HOFFSET(sScanHeader,lPTABPosZ), PredType::NATIVE_INT32);
+ ret->insertMember( "ulReserved1", HOFFSET(sScanHeader,ulReserved1), PredType::NATIVE_UINT32);
+ ret->insertMember( "aulEvalInfoMask", HOFFSET(sScanHeader,aulEvalInfoMask), *array_type_eval);
+ ret->insertMember( "ushSamplesInScan", HOFFSET(sScanHeader,ushSamplesInScan), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushUsedChannels", HOFFSET(sScanHeader,ushUsedChannels), PredType::NATIVE_UINT16);
+ ret->insertMember( "sLC", HOFFSET(sScanHeader,sLC), *lc_type);
+ ret->insertMember( "sCutOff", HOFFSET(sScanHeader,sCutOff), *cutoff_type);
+ ret->insertMember( "ushKSpaceCentreColumn", HOFFSET(sScanHeader,ushKSpaceCentreColumn), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushCoilSelect", HOFFSET(sScanHeader,ushCoilSelect), PredType::NATIVE_UINT16);
+ ret->insertMember( "fReadOutOffcentre", HOFFSET(sScanHeader,fReadOutOffcentre), PredType::NATIVE_FLOAT);
+ ret->insertMember( "ulTimeSinceLastRF", HOFFSET(sScanHeader,ulTimeSinceLastRF), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushKSpaceCentreLineNo", HOFFSET(sScanHeader,ushKSpaceCentreLineNo), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushKSpaceCentrePartitionNo", HOFFSET(sScanHeader,ushKSpaceCentrePartitionNo), PredType::NATIVE_UINT16);
+ ret->insertMember( "sSliceData", HOFFSET(sScanHeader,sSliceData), *slicedata_type);
+ ret->insertMember( "aushIceProgramPara", HOFFSET(sScanHeader,aushIceProgramPara), *array_type_icepara);
+ ret->insertMember( "aushReservedPara", HOFFSET(sScanHeader,aushReservedPara), *array_type_reserved);
+ ret->insertMember( "ushApplicationCounter", HOFFSET(sScanHeader,ushApplicationCounter), PredType::NATIVE_UINT16);
+ ret->insertMember( "ushApplicationMask", HOFFSET(sScanHeader,ushApplicationMask), PredType::NATIVE_UINT16);
+ ret->insertMember( "ulCRC", HOFFSET(sScanHeader,ulCRC), PredType::NATIVE_UINT32);
+
+ return ret;
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sChannelHeader>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sChannelHeader)));
+
+ ret->insertMember( "ulTypeAndChannelLength", HOFFSET(sChannelHeader,ulTypeAndChannelLength), PredType::NATIVE_UINT32);
+ ret->insertMember( "lMeasUID", HOFFSET(sChannelHeader,lMeasUID), PredType::NATIVE_INT32);
+ ret->insertMember( "ulScanCounter", HOFFSET(sChannelHeader,ulScanCounter), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulReserved1", HOFFSET(sChannelHeader,ulReserved1), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulSequenceTime", HOFFSET(sChannelHeader,ulSequenceTime), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulUnused2", HOFFSET(sChannelHeader,ulUnused2), PredType::NATIVE_UINT32);
+ ret->insertMember( "ulChannelId", HOFFSET(sChannelHeader,ulChannelId), PredType::NATIVE_UINT16);
+ ret->insertMember( "ulUnused3", HOFFSET(sChannelHeader,ulUnused3), PredType::NATIVE_UINT16);
+ ret->insertMember( "ulCRC", HOFFSET(sChannelHeader,ulCRC), PredType::NATIVE_UINT32);
+
+ return ret;
+}
+
+struct sChannelHeader_with_data
+{
+ sChannelHeader channelHeader;
+ hvl_t data;
+};
+
+void ClearsChannelHeader_with_data(sChannelHeader_with_data* b)
+{
+ if (b->data.len) {
+ if (b->data.p) {
+ complex_t* ptr = reinterpret_cast<complex_t*>(b->data.p);
+ delete [] ptr;
+ }
+ b->data.p = 0;
+ b->data.len = 0;
+ }
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sChannelHeader_with_data>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sChannelHeader_with_data)));
+
+ boost::shared_ptr<DataType> channelheader_type = getSiemensHDF5Type<sChannelHeader>();
+ boost::shared_ptr<DataType> vdatatype = getSiemensHDF5Type<complex_t>();
+ vdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (vdatatype->getId())));
+ ret->insertMember( "channelHeader", HOFFSET(sChannelHeader_with_data, channelHeader), *channelheader_type);
+ ret->insertMember( "data", HOFFSET(sChannelHeader_with_data,data), *vdatatype);
+ return ret;
+}
+
+struct sScanHeader_with_data
+{
+ sScanHeader scanHeader;
+ hvl_t data;
+};
+
+struct sScanHeader_with_syncdata
+{
+ sScanHeader scanHeader;
+ uint32_t last_scan_counter;
+ hvl_t syncdata;
+};
+
+void ClearsScanHeader_with_data(sScanHeader_with_data* c)
+{
+ if (c->data.len) {
+ if (c->data.p) {
+ for (unsigned int i = 0; i < c->data.len; i++) {
+ sChannelHeader_with_data* ptr = reinterpret_cast<sChannelHeader_with_data*>(c->data.p);
+ ClearsChannelHeader_with_data(ptr+i);
+ }
+ }
+ c->data.p = 0;
+ c->data.len = 0;
+ }
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sScanHeader_with_data>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sScanHeader_with_data)));
+
+ boost::shared_ptr<DataType> scanheader_type = getSiemensHDF5Type<sScanHeader>();
+ boost::shared_ptr<DataType> vdatatype = getSiemensHDF5Type<sChannelHeader_with_data>();
+ vdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (vdatatype->getId())));
+ ret->insertMember( "scanHeader", HOFFSET(sScanHeader_with_data, scanHeader), *scanheader_type);
+ ret->insertMember( "data", HOFFSET(sScanHeader_with_data,data), *vdatatype);
+ return ret;
+}
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<sScanHeader_with_syncdata>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(sScanHeader_with_syncdata)));
+
+ boost::shared_ptr<DataType> scanheader_type = getSiemensHDF5Type<sScanHeader>();
+ boost::shared_ptr<DataType> vdatatype = boost::shared_ptr<DataType>(new DataType(PredType::NATIVE_CHAR));
+ vdatatype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create (vdatatype->getId())));
+ ret->insertMember( "scanHeader", HOFFSET(sScanHeader_with_syncdata, scanHeader), *scanheader_type);
+ ret->insertMember( "last_scan_counter", HOFFSET(sScanHeader_with_syncdata, last_scan_counter), PredType::NATIVE_UINT32);
+ ret->insertMember( "syncdata", HOFFSET(sScanHeader_with_syncdata,syncdata), *vdatatype);
+ return ret;
+}
+
+struct MeasurementHeaderBuffer
+{
+ hvl_t bufName_;
+ uint32_t bufLen_;
+ hvl_t buf_;
+};
+
+void ClearMeasurementHeaderBuffer(MeasurementHeaderBuffer* b)
+{
+ if (b->bufName_.len) {
+ if (b->bufName_.p) {
+ char* ptr = reinterpret_cast<char*>(b->bufName_.p);
+ delete [] ptr;
+ }
+ b->bufName_.p = 0;
+ b->bufName_.len = 0;
+ }
+
+ if (b->buf_.len) {
+ if (b->buf_.p) {
+ char* ptr = reinterpret_cast<char*>(b->buf_.p);
+ delete [] ptr;
+ }
+ b->buf_.len = 0;
+ b->buf_.p = 0;
+ }
+}
+
+struct MeasurementHeader
+{
+
+public:
+ uint32_t dma_length;
+ uint32_t nr_buffers;
+ hvl_t buffers;
+
+};
+
+void ClearMeasurementHeader(MeasurementHeader* h)
+{
+ if (h->buffers.len) {
+ if (h->buffers.p) {
+ MeasurementHeaderBuffer* ptr = reinterpret_cast<MeasurementHeaderBuffer*>(h->buffers.p);
+ for (unsigned int i = 0; i < h->buffers.len; i++) {
+ ClearMeasurementHeaderBuffer(ptr+i);
+ }
+ }
+ h->buffers.p = 0;
+ h->buffers.len = 0;
+ }
+}
+
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<MeasurementHeaderBuffer>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(MeasurementHeaderBuffer)));
+
+ boost::shared_ptr<DataType> buf_type(new DataType(PredType::NATIVE_CHAR));
+ buf_type = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create ( buf_type->getId())));
+
+ ret->insertMember( "bufName_", HOFFSET(MeasurementHeaderBuffer, bufName_), *buf_type);
+ ret->insertMember( "bufLen_", HOFFSET(MeasurementHeaderBuffer,bufLen_), PredType::NATIVE_UINT32);
+ ret->insertMember( "buf_", HOFFSET(MeasurementHeaderBuffer, buf_), *buf_type);
+
+ return ret;
+}
+
+
+
+template <> boost::shared_ptr<DataType> getSiemensHDF5Type<MeasurementHeader>()
+{
+ boost::shared_ptr<CompType> ret = boost::shared_ptr<CompType>(new CompType(sizeof(MeasurementHeader)));
+
+ boost::shared_ptr<DataType> vtype = getSiemensHDF5Type<MeasurementHeaderBuffer>();
+ vtype = boost::shared_ptr<DataType>(new DataType(H5Tvlen_create ( vtype->getId())));
+
+ ret->insertMember( "dma_length", HOFFSET(MeasurementHeader,dma_length), PredType::NATIVE_UINT32);
+ ret->insertMember( "nr_buffers", HOFFSET(MeasurementHeader,nr_buffers), PredType::NATIVE_UINT32);
+ ret->insertMember( "buffers", HOFFSET(MeasurementHeader, buffers), *vtype);
+
+ return ret;
+}
+*/
+
+}
+
+#endif /* ISMRMRD_HDF5_DATATYPES_H_ */
--
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