[ismrmrd] 02/177: Completed C style type creation
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Wed Jan 14 20:01:55 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to annotated tag v1.1.0.beta.1
in repository ismrmrd.
commit 71e4c4ab111e8805cf77dc9123d8458ccae13572
Author: Michael S. Hansen <michael.hansen at nih.gov>
Date: Mon Jul 14 10:33:18 2014 -0400
Completed C style type creation
---
ismrmrd_hdf5.cpp | 9 +-
ismrmrd_hdf5.h | 48 ++++
ismrmrd_hdf5_datatypes.h | 329 +++++++++++++++++++++++++++
utilities/generate_cartesian_shepp_logan.cpp | 2 +-
4 files changed, 383 insertions(+), 5 deletions(-)
diff --git a/ismrmrd_hdf5.cpp b/ismrmrd_hdf5.cpp
index 80a819f..03c5fca 100644
--- a/ismrmrd_hdf5.cpp
+++ b/ismrmrd_hdf5.cpp
@@ -11,7 +11,7 @@ namespace ISMRMRD
int IsmrmrdDataset::openHDF5File()
{
-
+ std::cout << "Opening file" << std::endl;
if (file_exists_) {
try {
if (!H5File::isHdf5(filename_.c_str())) {
@@ -228,10 +228,11 @@ template EXPORTISMRMRD int IsmrmrdDataset::appendArray(NDArrayContainer< ImageHe
template <typename T> boost::shared_ptr< NDArrayContainer<T> > IsmrmrdDataset::readArray(const char* varname, unsigned long int index)
{
- boost::shared_ptr< NDArrayContainer<T> > ret(new NDArrayContainer<T>());
- boost::shared_ptr<DataType> datatype = getIsmrmrdHDF5Type<T>();
+ boost::shared_ptr< NDArrayContainer<T> > ret(new NDArrayContainer<T>());
+ boost::shared_ptr<DataType> datatype = getIsmrmrdHDF5Type<T>();
+
+ std::string data_path = groupname_ + std::string("/") + std::string(varname);
- std::string data_path = groupname_ + std::string("/") + std::string(varname);
try {
diff --git a/ismrmrd_hdf5.h b/ismrmrd_hdf5.h
index bb976db..ea98339 100644
--- a/ismrmrd_hdf5.h
+++ b/ismrmrd_hdf5.h
@@ -6,6 +6,10 @@
#include "ismrmrd.h"
#include <fstream>
+#include <typeinfo>
+#include <map>
+#include <string>
+
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
@@ -85,6 +89,47 @@ public:
xml_header_path_ = groupname_ + std::string("/xml");
data_path_ = groupname_ + std::string("/data");
+
+ hid_t t;
+
+ t = this->type_container_.get_type<float>();
+ std::cout << "Type for float: " << t << std::endl;
+
+ t = this->type_container_.get_type<double>();
+ std::cout << "Type for double: " << t << std::endl;
+
+ t = this->type_container_.get_type< std::complex<float> >();
+ std::cout << "Type for complex float: " << t << std::endl;
+
+ t = this->type_container_.get_type< std::complex<double> >();
+ std::cout << "Type for complex double: " << t << std::endl;
+
+ t = this->type_container_.get_type< EncodingCounters >();
+ std::cout << "Type for EncodingCounters: " << t << std::endl;
+
+ t = this->type_container_.get_type< AcquisitionHeader >();
+ std::cout << "Type for AcquisitionHeader: " << t << std::endl;
+
+ t = this->type_container_.get_type< AcquisitionHeader_with_data >();
+ std::cout << "Type for AcquisitionHeader_with_data: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader >();
+ std::cout << "Type for ImageHeader: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader_with_data<float> >();
+ std::cout << "Type for ImageHeader_with_data<float>: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader_with_data<double> >();
+ std::cout << "Type for ImageHeader_with_data<double>: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader_with_data<unsigned short> >();
+ std::cout << "Type for ImageHeader_with_data<unsigned short>: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader_with_data<ccomplex_t> >();
+ std::cout << "Type for ImageHeader_with_data<ccomplex_t>: " << t << std::endl;
+
+ t = this->type_container_.get_type< ImageHeader_with_data<cdouble_complex_t> >();
+ std::cout << "Type for ImageHeader_with_data<cdouble_complex_t>: " << t << std::endl;
}
/**
@@ -198,6 +243,7 @@ protected:
return file_exists_;
}
+
std::string filename_;
std::string groupname_;
std::string xml_header_path_;
@@ -210,6 +256,8 @@ protected:
boost::shared_ptr<H5File> file_;
boost::shared_ptr<DataSet> dataset_;
+
+ IsmrmrdHDF5TypeContainer type_container_;
};
/**
diff --git a/ismrmrd_hdf5_datatypes.h b/ismrmrd_hdf5_datatypes.h
index 27e4528..675656a 100644
--- a/ismrmrd_hdf5_datatypes.h
+++ b/ismrmrd_hdf5_datatypes.h
@@ -19,6 +19,335 @@
namespace ISMRMRD
{
+ /* HDF5 C Interface (begin) */
+
+ class IsmrmrdHDF5TypeContainer {
+
+ public:
+
+ ~IsmrmrdHDF5TypeContainer() {
+ std::map<const std::type_info*, hid_t>::iterator it = hdf5_type_map_.begin();
+ while (it != hdf5_type_map_.end()) {
+ H5Tclose(it->second);
+ it++;
+ }
+ it = hdf5_vlen_type_map_.begin();
+ while (it != hdf5_vlen_type_map_.end()) {
+ H5Tclose(it->second);
+ it++;
+ }
+
+ }
+
+ template <typename T> hid_t get_type() {
+ std::map<const std::type_info*, hid_t>::iterator it = hdf5_type_map_.find(&typeid(T));
+ if (it != hdf5_type_map_.end()) {
+ return it->second;
+ } else {
+ hid_t t = this->getIsmrmrdHDF5Type<T>();
+ hdf5_type_map_[&typeid(T)] = t;
+ return t;
+ }
+ }
+
+ template <typename T, int N> hid_t get_array_type() {
+ std::map<const std::type_info*, hid_t>::iterator it = hdf5_type_map_.find(&typeid( T[N] ));
+ if (it != hdf5_type_map_.end()) {
+ return it->second;
+ } else {
+ hid_t t = this->getIsmrmrdHDF5ArrayType<T,N>();
+ hdf5_type_map_[&typeid(T[N])] = t;
+ return t;
+ }
+ }
+
+ template <typename T> hid_t get_vlen_type() {
+ std::map<const std::type_info*, hid_t>::iterator it = hdf5_vlen_type_map_.find(&typeid(T));
+ if (it != hdf5_vlen_type_map_.end()) {
+ return it->second;
+ } else {
+ hid_t t = this->getIsmrmrdHDF5VLenType<T>();
+ hdf5_vlen_type_map_[&typeid(T)] = t;
+ return t;
+ }
+ }
+
+
+ protected:
+ struct compare_typeinfo {
+ bool operator ()(const std::type_info* a, const std::type_info* b) const {
+ return a->before(*b);
+ }
+ };
+
+ std::map<const std::type_info*, hid_t, compare_typeinfo> hdf5_type_map_;
+ std::map<const std::type_info*, hid_t, compare_typeinfo> hdf5_vlen_type_map_;
+ template <typename T> hid_t getIsmrmrdHDF5Type();
+ template <typename T, int N> hid_t getIsmrmrdHDF5ArrayType();
+ template <typename T> hid_t getIsmrmrdHDF5VLenType();
+
+ }; //class IsmrmrdHDF5TypeContainer
+
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<float>() {
+ return H5Tcopy(H5T_NATIVE_FLOAT);
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<double>() {
+ return H5Tcopy(H5T_NATIVE_DOUBLE);
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<char>() {
+ return H5Tcopy(H5T_NATIVE_CHAR);;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<unsigned short>() {
+ return H5Tcopy(H5T_NATIVE_USHORT);;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type< std::complex<float> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(std::complex<float>));
+ H5Tinsert(t, "real", 0, H5T_NATIVE_FLOAT);
+ H5Tinsert(t, "imag", sizeof(float), H5T_NATIVE_FLOAT);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type< std::complex<double> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(std::complex<double>));
+ H5Tinsert(t, "real", 0, H5T_NATIVE_DOUBLE);
+ H5Tinsert(t, "imag", sizeof(double), H5T_NATIVE_DOUBLE);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< uint16_t, 3 >() {
+ std::vector<hsize_t> dims(1,3);
+ hid_t t = H5Tarray_create(H5T_NATIVE_UINT16, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< uint16_t, ISMRMRD_USER_INTS >() {
+ std::vector<hsize_t> dims(1,ISMRMRD_USER_INTS);
+ hid_t t = H5Tarray_create(H5T_NATIVE_UINT16, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< uint32_t, 3 >() { //TODO: The 3 should be replace with ISMRMRD_PHYS_TIME_STAMPS when that is corrected
+ std::vector<hsize_t> dims(1,3);//TODO: Replace when header is updated
+ hid_t t = H5Tarray_create(H5T_NATIVE_UINT32, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< int32_t, ISMRMRD_USER_INTS >() {
+ std::vector<hsize_t> dims(1,ISMRMRD_USER_INTS);
+ hid_t t = H5Tarray_create(H5T_NATIVE_INT32, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< uint64_t, ISMRMRD_CHANNEL_MASKS >() {
+ std::vector<hsize_t> dims(1,ISMRMRD_CHANNEL_MASKS);
+ hid_t t = H5Tarray_create(H5T_NATIVE_UINT64, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< float, ISMRMRD_POSITION_LENGTH >() {
+ std::vector<hsize_t> dims(1,ISMRMRD_POSITION_LENGTH);
+ hid_t t = H5Tarray_create(H5T_NATIVE_FLOAT, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5ArrayType< float, ISMRMRD_USER_FLOATS >() {
+ std::vector<hsize_t> dims(1,ISMRMRD_USER_FLOATS);
+ hid_t t = H5Tarray_create(H5T_NATIVE_FLOAT, 1, &dims[0], NULL);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<EncodingCounters>() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(EncodingCounters));
+ H5Tinsert(t, "kspace_encode_step_1", HOFFSET(EncodingCounters, kspace_encode_step_1), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "kspace_encode_step_2", HOFFSET(EncodingCounters, kspace_encode_step_2), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "average", HOFFSET(EncodingCounters, average), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "slice", HOFFSET(EncodingCounters, slice), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "contrast", HOFFSET(EncodingCounters, contrast), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "phase", HOFFSET(EncodingCounters, phase), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "repetition", HOFFSET(EncodingCounters, repetition), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "set", HOFFSET(EncodingCounters, set), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "segment", HOFFSET(EncodingCounters, segment), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "user", HOFFSET(EncodingCounters, user), get_array_type< uint16_t, ISMRMRD_USER_INTS >());
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<AcquisitionHeader>() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(AcquisitionHeader));
+ H5Tinsert(t,"version", HOFFSET(AcquisitionHeader, version), H5T_NATIVE_UINT16);
+ H5Tinsert(t,"flags", HOFFSET(AcquisitionHeader, flags), H5T_NATIVE_UINT64);
+ H5Tinsert(t, "measurement_uid", HOFFSET(AcquisitionHeader, measurement_uid), H5T_NATIVE_UINT32);
+ H5Tinsert(t, "scan_counter", HOFFSET(AcquisitionHeader, scan_counter), H5T_NATIVE_UINT32);
+ H5Tinsert(t, "acquisition_time_stamp", HOFFSET(AcquisitionHeader, acquisition_time_stamp), H5T_NATIVE_UINT32);
+ H5Tinsert(t, "physiology_time_stamp", HOFFSET(AcquisitionHeader, physiology_time_stamp), get_array_type<uint32_t,3>()); //TODO: should be get_array_type<uint32_t,ISMRMRD_PHYS_STAMPS>()
+ H5Tinsert(t, "number_of_samples", HOFFSET(AcquisitionHeader, number_of_samples), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "available_channels", HOFFSET(AcquisitionHeader, available_channels), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "active_channels", HOFFSET(AcquisitionHeader, active_channels), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "channel_mask", HOFFSET(AcquisitionHeader, channel_mask), get_array_type<uint64_t,ISMRMRD_CHANNEL_MASKS>());
+ H5Tinsert(t, "discard_pre", HOFFSET(AcquisitionHeader, discard_pre), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "discard_post", HOFFSET(AcquisitionHeader, discard_post), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "center_sample", HOFFSET(AcquisitionHeader, center_sample), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "encoding_space_ref", HOFFSET(AcquisitionHeader, encoding_space_ref), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "trajectory_dimensions", HOFFSET(AcquisitionHeader, trajectory_dimensions), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "sample_time_us", HOFFSET(AcquisitionHeader, sample_time_us), H5T_NATIVE_FLOAT);
+ H5Tinsert(t, "position", HOFFSET(AcquisitionHeader, position), get_array_type<float,ISMRMRD_POSITION_LENGTH>());
+ H5Tinsert(t, "read_dir", HOFFSET(AcquisitionHeader, read_dir), get_array_type<float,ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "phase_dir", HOFFSET(AcquisitionHeader, phase_dir), get_array_type<float,ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "slice_dir", HOFFSET(AcquisitionHeader, slice_dir), get_array_type<float,ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "patient_table_position", HOFFSET(AcquisitionHeader, patient_table_position), get_array_type<float,ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "idx", HOFFSET(AcquisitionHeader, idx), get_type<EncodingCounters>());
+ H5Tinsert(t, "user_int", HOFFSET(AcquisitionHeader, user_int), get_array_type<int32_t,ISMRMRD_USER_INTS>());
+ H5Tinsert(t, "user_float", HOFFSET(AcquisitionHeader, user_float), get_array_type<float,ISMRMRD_USER_FLOATS>());
+ return t;
+ }
+
+ struct ccomplex_t
+ {
+ float real;
+ float imag;
+ };
+
+ struct cdouble_complex_t
+ {
+ double real;
+ double imag;
+ };
+
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type< ccomplex_t >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ccomplex_t));
+ H5Tinsert(t, "real", HOFFSET(ccomplex_t, real), H5T_NATIVE_FLOAT);
+ H5Tinsert(t, "imag", HOFFSET(ccomplex_t, imag), H5T_NATIVE_FLOAT);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type< cdouble_complex_t >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(cdouble_complex_t));
+ H5Tinsert(t, "real", HOFFSET(cdouble_complex_t, real), H5T_NATIVE_FLOAT);
+ H5Tinsert(t, "imag", HOFFSET(cdouble_complex_t, imag), H5T_NATIVE_FLOAT);
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5VLenType< float >() {
+ return H5Tvlen_create(H5T_NATIVE_FLOAT);
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5VLenType< double >() {
+ return H5Tvlen_create(H5T_NATIVE_DOUBLE);
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5VLenType< ccomplex_t >() {
+ return H5Tvlen_create(get_type<ccomplex_t>());
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5VLenType< cdouble_complex_t >() {
+ return H5Tvlen_create(get_type<cdouble_complex_t>());
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5VLenType< uint16_t >() {
+ return H5Tvlen_create(H5T_NATIVE_UINT16);
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<AcquisitionHeader_with_data>() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(AcquisitionHeader_with_data));
+ H5Tinsert(t, "head", HOFFSET(AcquisitionHeader_with_data,head), get_type<AcquisitionHeader>());
+ H5Tinsert(t, "traj", HOFFSET(AcquisitionHeader_with_data,traj), get_vlen_type<float>());
+ H5Tinsert(t, "data", HOFFSET(AcquisitionHeader_with_data,data), get_vlen_type< ccomplex_t>());
+ return t;
+ }
+
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader>() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader));
+
+ H5Tinsert(t, "version", HOFFSET(ImageHeader, version), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "flags", HOFFSET(ImageHeader, flags), H5T_NATIVE_UINT64);
+ H5Tinsert(t, "measurement_uid", HOFFSET(ImageHeader, measurement_uid), H5T_NATIVE_UINT32);
+ H5Tinsert(t, "matrix_size", HOFFSET(ImageHeader, matrix_size), get_array_type<uint16_t,3>());
+ H5Tinsert(t, "field_of_view", HOFFSET(ImageHeader, field_of_view), get_array_type<float, ISMRMRD_POSITION_LENGTH>());
+ H5Tinsert(t, "channels", HOFFSET(ImageHeader, channels), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "position", HOFFSET(ImageHeader, position), get_array_type<float, ISMRMRD_POSITION_LENGTH>());
+ H5Tinsert(t, "read_dir", HOFFSET(ImageHeader, read_dir), get_array_type<float, ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "phase_dir", HOFFSET(ImageHeader, phase_dir), get_array_type<float, ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "slice_dir", HOFFSET(ImageHeader, slice_dir), get_array_type<float, ISMRMRD_DIRECTION_LENGTH>());
+ H5Tinsert(t, "patient_table_position", HOFFSET(ImageHeader, patient_table_position), get_array_type<float, ISMRMRD_POSITION_LENGTH>());
+ H5Tinsert(t, "average", HOFFSET(ImageHeader, average), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "slice", HOFFSET(ImageHeader, slice), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "contrast", HOFFSET(ImageHeader, contrast), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "phase", HOFFSET(ImageHeader, phase), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "repetition", HOFFSET(ImageHeader, repetition), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "set", HOFFSET(ImageHeader, set), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "acquisition_time_stamp", HOFFSET(ImageHeader, acquisition_time_stamp), H5T_NATIVE_UINT32);
+ H5Tinsert(t, "physiology_time_stamp", HOFFSET(ImageHeader, physiology_time_stamp), get_array_type<uint32_t, 3>()); //TODO: get_array_type<uint32_t, ISMRMRD_PHYS_STAMPS>()
+ H5Tinsert(t, "image_data_type", HOFFSET(ImageHeader, image_data_type), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "image_type", HOFFSET(ImageHeader, image_type), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "image_index", HOFFSET(ImageHeader, image_index), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "image_series_index", HOFFSET(ImageHeader, image_series_index), H5T_NATIVE_UINT16);
+ H5Tinsert(t, "user_int", HOFFSET(ImageHeader, user_int), get_array_type<int32_t, ISMRMRD_USER_INTS>());
+ H5Tinsert(t, "user_float", HOFFSET(ImageHeader, user_float), get_array_type<float, ISMRMRD_USER_FLOATS>());
+ return t;
+}
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader_with_data<float> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader_with_data<float>));
+ H5Tinsert(t, "head", HOFFSET(ImageHeader_with_data<float>,head), get_type<ImageHeader>());
+ H5Tinsert(t, "data", HOFFSET(ImageHeader_with_data<float>,data), get_vlen_type<float>());
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader_with_data<double> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader_with_data<double>));
+ H5Tinsert(t, "head", HOFFSET(ImageHeader_with_data<double>,head), get_type<ImageHeader>());
+ H5Tinsert(t, "data", HOFFSET(ImageHeader_with_data<double>,data), get_vlen_type<double>());
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader_with_data<unsigned short> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader_with_data<unsigned short>));
+ H5Tinsert(t, "head", HOFFSET(ImageHeader_with_data<unsigned short>,head), get_type<ImageHeader>());
+ H5Tinsert(t, "data", HOFFSET(ImageHeader_with_data<unsigned short>,data), get_vlen_type<unsigned short>());
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader_with_data<ccomplex_t> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader_with_data<ccomplex_t>));
+ H5Tinsert(t, "head", HOFFSET(ImageHeader_with_data<ccomplex_t>,head), get_type<ImageHeader>());
+ H5Tinsert(t, "data", HOFFSET(ImageHeader_with_data<ccomplex_t>,data), get_vlen_type<ccomplex_t>());
+ return t;
+ }
+
+ template <> inline hid_t IsmrmrdHDF5TypeContainer::getIsmrmrdHDF5Type<ImageHeader_with_data<cdouble_complex_t> >() {
+ hid_t t = H5Tcreate(H5T_COMPOUND, sizeof(ImageHeader_with_data<cdouble_complex_t>));
+ H5Tinsert(t, "head", HOFFSET(ImageHeader_with_data<cdouble_complex_t>,head), get_type<ImageHeader>());
+ H5Tinsert(t, "data", HOFFSET(ImageHeader_with_data<cdouble_complex_t>,data), get_vlen_type<cdouble_complex_t>());
+ return t;
+ }
+
+/*
+
+template <> inline boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data< std::complex<float> > >()
+{
+ return getIsmrmrdHDF5Type<ImageHeader_with_data<complex_t> >();
+}
+
+template <> inline boost::shared_ptr<DataType> getIsmrmrdHDF5Type<ImageHeader_with_data< std::complex<double> > >()
+{
+ return getIsmrmrdHDF5Type<ImageHeader_with_data<double_complex_t> >();
+}
+
+template <> inline boost::shared_ptr<DataType> getIsmrmrdHDF5Type<std::string>()
+{
+ boost::shared_ptr<DataType> ret(new StrType(0, H5T_VARIABLE));
+ return ret;
+}
+
+*/
+
+ /* HDF5 C Interface (end) */
template <typename T> boost::shared_ptr<DataType> getIsmrmrdHDF5Type();
diff --git a/utilities/generate_cartesian_shepp_logan.cpp b/utilities/generate_cartesian_shepp_logan.cpp
index 93988cc..9bf70e0 100644
--- a/utilities/generate_cartesian_shepp_logan.cpp
+++ b/utilities/generate_cartesian_shepp_logan.cpp
@@ -62,7 +62,7 @@ int main(int argc, char** argv)
return 1;
}
- std::cout << "Generating Cartesian Shepp Logan Phantom" << std::endl;
+ std::cout << "Generating Cartesian Shepp Logan Phantom!!!" << std::endl;
std::cout << "Acceleration: " << acc_factor << std::endl;
boost::shared_ptr<NDArrayContainer<std::complex<float> > > phantom = shepp_logan_phantom(matrix_size);
--
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