ISMRMRD
ISMRM Raw Data Format
ismrmrd.h
Go to the documentation of this file.
1 /* ISMRMRD MR Raw Data Strutures */
2 /* DRAFT */
3 /* Authors: */
4 /* Michael S. Hansen (michael.hansen@nih.gov) */
5 /* Brian Hargreaves (bah@stanford.edu) */
6 /* Sebastian Kozerke (kozerke@biomed.ee.ethz.ch) */
7 /* Kaveh Vahedipour (k.vahedipour@fz-juelich.de) */
8 /* Hui Xue (hui.xue@nih.gov) */
9 /* Souheil Inati (souheil.inati@nih.gov) */
10 /* Joseph Naegele (joseph.naegele@nih.gov) */
11 
18 #pragma once
19 #ifndef ISMRMRD_H
20 #define ISMRMRD_H
21 
22 /* Language and cross platform section for defining types */
23 /* integers */
24 #ifdef _MSC_VER /* MS compiler */
25 typedef __int16 int16_t;
26 typedef unsigned __int16 uint16_t;
27 typedef __int32 int32_t;
28 typedef unsigned __int32 uint32_t;
29 typedef __int64 int64_t;
30 typedef unsigned __int64 uint64_t;
31 #else /* non MS C or C++ compiler */
32 #include <stdint.h>
33 #include <stddef.h> /* for size_t */
34 #endif /* _MSC_VER */
35 
36 /* Complex numbers */
37 #ifdef __cplusplus
38 #include <complex>
39 typedef std::complex<float> complex_float_t;
40 typedef std::complex<double> complex_double_t;
41 #else
42 #ifdef _MSC_VER /* MS C compiler */
43 typedef struct complex_float_t{
44  float real;
45  float imag;
46 }complex_float_t;
47 typedef struct complex_double_t{
48  double real;
49  double imag;
50 }complex_double_t;
51 #else /* C99 compiler */
52 #include <complex.h>
53 typedef float complex complex_float_t;
54 typedef double complex complex_double_t;
55 #endif /* _MSC_VER */
56 #endif /* __cplusplus */
57 
58 /* Booleans - part of C++ */
59 #ifndef __cplusplus
60 #ifdef _MSC_VER /* MS C compiler */
61 typedef int bool;
62 #define false 0
63 #define true 1
64 #else /* C99 compiler */
65 #include <stdbool.h>
66 #endif /* _MSC_VER */
67 #endif /* __cplusplus */
68 
69 /* Vectors */
70 #ifdef __cplusplus
71 #include <vector>
72 #endif /* __cplusplus */
73 
74 /* Exports needed for MS C++ */
75 #include "ismrmrd/export.h"
76 
77 #pragma pack(push, 2) /* Use 2 byte alignment */
78 
79 #ifdef __cplusplus
80 namespace ISMRMRD {
81 extern "C" {
82 #endif
83 
88  ISMRMRD_USER_INTS = 8,
89  ISMRMRD_USER_FLOATS = 8,
90  ISMRMRD_PHYS_STAMPS = 3,
91  ISMRMRD_CHANNEL_MASKS = 16,
92  ISMRMRD_NDARRAY_MAXDIM = 7,
93  ISMRMRD_POSITION_LENGTH = 3,
94  ISMRMRD_DIRECTION_LENGTH = 3
95 };
96 
97 
102  ISMRMRD_BEGINERROR=-1,
103  ISMRMRD_NOERROR,
104  ISMRMRD_MEMORYERROR,
105  ISMRMRD_FILEERROR,
106  ISMRMRD_TYPEERROR,
107  ISMRMRD_RUNTIMEERROR,
108  ISMRMRD_HDF5ERROR,
109  ISMRMRD_ENDERROR
110 };
111 
124 };
125 
127 size_t ismrmrd_sizeof_data_type(int data_type);
128 
133  ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP1 = 1,
134  ISMRMRD_ACQ_LAST_IN_ENCODE_STEP1 = 2,
135  ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP2 = 3,
136  ISMRMRD_ACQ_LAST_IN_ENCODE_STEP2 = 4,
137  ISMRMRD_ACQ_FIRST_IN_AVERAGE = 5,
138  ISMRMRD_ACQ_LAST_IN_AVERAGE = 6,
139  ISMRMRD_ACQ_FIRST_IN_SLICE = 7,
140  ISMRMRD_ACQ_LAST_IN_SLICE = 8,
141  ISMRMRD_ACQ_FIRST_IN_CONTRAST = 9,
142  ISMRMRD_ACQ_LAST_IN_CONTRAST = 10,
143  ISMRMRD_ACQ_FIRST_IN_PHASE = 11,
144  ISMRMRD_ACQ_LAST_IN_PHASE = 12,
145  ISMRMRD_ACQ_FIRST_IN_REPETITION = 13,
146  ISMRMRD_ACQ_LAST_IN_REPETITION = 14,
147  ISMRMRD_ACQ_FIRST_IN_SET = 15,
148  ISMRMRD_ACQ_LAST_IN_SET = 16,
149  ISMRMRD_ACQ_FIRST_IN_SEGMENT = 17,
150  ISMRMRD_ACQ_LAST_IN_SEGMENT = 18,
151  ISMRMRD_ACQ_IS_NOISE_MEASUREMENT = 19,
152  ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION = 20,
153  ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING = 21,
154  ISMRMRD_ACQ_IS_REVERSE = 22,
155  ISMRMRD_ACQ_IS_NAVIGATION_DATA = 23,
156  ISMRMRD_ACQ_IS_PHASECORR_DATA = 24,
157  ISMRMRD_ACQ_LAST_IN_MEASUREMENT = 25,
158  ISMRMRD_ACQ_IS_HPFEEDBACK_DATA = 26,
159  ISMRMRD_ACQ_IS_DUMMYSCAN_DATA = 27,
160  ISMRMRD_ACQ_IS_RTFEEDBACK_DATA = 28,
161  ISMRMRD_ACQ_IS_SURFACECOILCORRECTIONSCAN_DATA = 29,
162 
163  ISMRMRD_ACQ_USER1 = 57,
164  ISMRMRD_ACQ_USER2 = 58,
165  ISMRMRD_ACQ_USER3 = 59,
166  ISMRMRD_ACQ_USER4 = 60,
167  ISMRMRD_ACQ_USER5 = 61,
168  ISMRMRD_ACQ_USER6 = 62,
169  ISMRMRD_ACQ_USER7 = 63,
170  ISMRMRD_ACQ_USER8 = 64
171 };
172 
177  ISMRMRD_IMTYPE_MAGNITUDE = 1,
178  ISMRMRD_IMTYPE_PHASE = 2,
179  ISMRMRD_IMTYPE_REAL = 3,
180  ISMRMRD_IMTYPE_IMAG = 4,
181  ISMRMRD_IMTYPE_COMPLEX = 5
182 };
183 
188  ISMRMRD_IMAGE_IS_NAVIGATION_DATA = 1,
189  ISMRMRD_IMAGE_USER1 = 57,
190  ISMRMRD_IMAGE_USER2 = 58,
191  ISMRMRD_IMAGE_USER3 = 59,
192  ISMRMRD_IMAGE_USER4 = 60,
193  ISMRMRD_IMAGE_USER5 = 61,
194  ISMRMRD_IMAGE_USER6 = 62,
195  ISMRMRD_IMAGE_USER7 = 63,
196  ISMRMRD_IMAGE_USER8 = 64
197 };
198 
202 typedef struct ISMRMRD_EncodingCounters {
205  uint16_t average;
206  uint16_t slice;
207  uint16_t contrast;
208  uint16_t phase;
209  uint16_t repetition;
210  uint16_t set;
211  uint16_t segment;
212  uint16_t user[ISMRMRD_USER_INTS];
214 
219  uint16_t version;
220  uint64_t flags;
221  uint32_t measurement_uid;
222  uint32_t scan_counter;
224  uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
225  uint16_t number_of_samples;
227  uint16_t active_channels;
228  uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS];
229  uint16_t discard_pre;
230  uint16_t discard_post;
231  uint16_t center_sample;
235  float position[3];
236  float read_dir[3];
237  float phase_dir[3];
238  float slice_dir[3];
241  int32_t user_int[ISMRMRD_USER_INTS];
242  float user_float[ISMRMRD_USER_FLOATS];
244 
251 
253 typedef struct ISMRMRD_Acquisition {
255  float *traj;
256  complex_float_t *data;
258 
262 EXPORTISMRMRD ISMRMRD_Acquisition * ismrmrd_create_acquisition();
263 EXPORTISMRMRD int ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq);
264 EXPORTISMRMRD int ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq);
265 EXPORTISMRMRD int ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq);
266 EXPORTISMRMRD int ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource);
267 EXPORTISMRMRD int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq);
268 EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq);
269 EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq);
272 /**********/
273 /* Images */
274 /**********/
275 
279 typedef struct ISMRMRD_ImageHeader {
280  uint16_t version;
281  uint16_t data_type;
282  uint64_t flags;
283  uint32_t measurement_uid;
284  uint16_t matrix_size[3];
285  float field_of_view[3];
286  uint16_t channels;
287  float position[3];
288  float read_dir[3];
289  float phase_dir[3];
290  float slice_dir[3];
292  uint16_t average;
293  uint16_t slice;
294  uint16_t contrast;
295  uint16_t phase;
296  uint16_t repetition;
297  uint16_t set;
299  uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
300  uint16_t image_type;
301  uint16_t image_index;
303  int32_t user_int[ISMRMRD_USER_INTS];
304  float user_float[ISMRMRD_USER_FLOATS];
307 
309 EXPORTISMRMRD int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr);
310 
315 typedef struct ISMRMRD_Image {
316  ISMRMRD_ImageHeader head;
317  char *attribute_string;
318  void *data;
319 } ISMRMRD_Image;
320 
321 
325 EXPORTISMRMRD ISMRMRD_Image * ismrmrd_create_image();
326 EXPORTISMRMRD int ismrmrd_free_image(ISMRMRD_Image *im);
327 EXPORTISMRMRD int ismrmrd_init_image(ISMRMRD_Image *im);
328 EXPORTISMRMRD int ismrmrd_cleanup_image(ISMRMRD_Image *im);
329 EXPORTISMRMRD int ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource);
330 EXPORTISMRMRD int ismrmrd_make_consistent_image(ISMRMRD_Image *im);
331 EXPORTISMRMRD size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im);
332 EXPORTISMRMRD size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im);
335 /************/
336 /* NDArrays */
337 /************/
338 
342 typedef struct ISMRMRD_NDArray {
343  uint16_t version;
344  uint16_t data_type;
345  uint16_t ndim;
346  size_t dims[ISMRMRD_NDARRAY_MAXDIM];
347  void *data;
349 
353 EXPORTISMRMRD ISMRMRD_NDArray * ismrmrd_create_ndarray();
354 EXPORTISMRMRD int ismrmrd_free_ndarray(ISMRMRD_NDArray *arr);
355 EXPORTISMRMRD int ismrmrd_init_ndarray(ISMRMRD_NDArray *arr);
356 EXPORTISMRMRD int ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr);
357 EXPORTISMRMRD int ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource);
358 EXPORTISMRMRD int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr);
359 EXPORTISMRMRD size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr);
362 /*********/
363 /* Flags */
364 /*********/
368 EXPORTISMRMRD bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val);
369 EXPORTISMRMRD int ismrmrd_set_flag(uint64_t *flags, const uint64_t val);
370 EXPORTISMRMRD int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val);
371 EXPORTISMRMRD int ismrmrd_clear_all_flags(uint64_t *flags);
374 /*****************/
375 /* Channel Masks */
376 /*****************/
380 EXPORTISMRMRD bool ismrmrd_is_channel_on(const uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
381 EXPORTISMRMRD int ismrmrd_set_channel_on(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
382 EXPORTISMRMRD int ismrmrd_set_channel_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
383 EXPORTISMRMRD int ismrmrd_set_all_channels_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]);
386 /******************/
387 /* Error Handling */
388 /******************/
392 typedef void (*ismrmrd_error_handler_t)(const char *file, int line,
393  const char *function, int code, const char *msg);
394 #define ISMRMRD_PUSH_ERR(code, msg) ismrmrd_push_error(__FILE__, __LINE__, \
395  __func__, (code), (msg))
396 int ismrmrd_push_error(const char *file, const int line, const char *func,
397  const int code, const char *msg);
399 EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t);
401 EXPORTISMRMRD char *ismrmrd_strerror(int code);
406 bool ismrmrd_pop_error(char **file, int *line, char **func,
407  int *code, char **msg);
408 
409 /*****************************/
410 /* Rotations and Quaternions */
411 /*****************************/
416 EXPORTISMRMRD int ismrmrd_sign_of_directions(float read_dir[3], float phase_dir[3], float slice_dir[3]);
417 
419 EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3], float slice_dir[3], float quat[4]);
420 
422 EXPORTISMRMRD void ismrmrd_quaternion_to_directions(float quat[4], float read_dir[3], float phase_dir[3], float slice_dir[3]);
425 #pragma pack(pop) /* Restore old alignment */
426 
427 #ifdef __cplusplus
428 } // extern "C"
429 
431 
433 std::string build_exception_string(void);
434 
437 
442 template <typename T> EXPORTISMRMRD ISMRMRD_DataTypes get_data_type();
444 
446 class EXPORTISMRMRD FlagBit
447 {
448 public:
449  FlagBit(unsigned short b)
450  : bitmask_(0)
451  {
452  if (b > 0) {
453  bitmask_ = 1;
454  bitmask_ = (bitmask_ << (b-1));
455  }
456  }
457 
458  bool isSet(const uint64_t& m) const {
459  return ((m & bitmask_)>0);
460  }
461 
462  uint64_t bitmask_;
463 
464 };
465 
467 class EXPORTISMRMRD AcquisitionHeader: public ISMRMRD_AcquisitionHeader {
468 public:
469  // Constructors
471 
472  // Flag methods
473  bool isFlagSet(const ISMRMRD_AcquisitionFlags val);
474  void setFlag(const ISMRMRD_AcquisitionFlags val);
475  void clearFlag(const ISMRMRD_AcquisitionFlags val);
476  void clearAllFlags();
477 
478  // Channel mask methods
479  bool isChannelActive(uint16_t channel_id);
480  void setChannelActive(uint16_t channel_id);
481  void setChannelNotActive(uint16_t channel_id);
482  void setAllChannelsNotActive();
483 
484 };
485 
487 class EXPORTISMRMRD Acquisition {
488  friend class Dataset;
489 public:
490  // Constructors, assignment, destructor
491  Acquisition();
492  Acquisition(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
493  Acquisition(const Acquisition &other);
494  Acquisition & operator= (const Acquisition &other);
495  ~Acquisition();
496 
497  // Accessors and mutators
498  const uint16_t &version();
499  const uint64_t &flags();
500  uint32_t &measurement_uid();
501  uint32_t &scan_counter();
502  uint32_t &acquisition_time_stamp();
503  uint32_t (&physiology_time_stamp())[ISMRMRD_PHYS_STAMPS];
504  const uint16_t &number_of_samples();
505  uint16_t &available_channels();
506  const uint16_t &active_channels();
507  const uint64_t (&channel_mask())[ISMRMRD_CHANNEL_MASKS];
508  uint16_t &discard_pre();
509  uint16_t &discard_post();
510  uint16_t &center_sample();
511  uint16_t &encoding_space_ref();
512  const uint16_t &trajectory_dimensions();
513  float &sample_time_us();
514  float (&position())[3];
515  float (&read_dir())[3];
516  float (&phase_dir())[3];
517  float (&slice_dir())[3];
518  float (&patient_table_position())[3];
520  int32_t (&user_int())[ISMRMRD_USER_INTS];
521  float (&user_float())[ISMRMRD_USER_FLOATS];
522 
523  // Sizes
524  void resize(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
525  const size_t getNumberOfDataElements();
526  const size_t getNumberOfTrajElements();
527  const size_t getDataSize();
528  const size_t getTrajSize();
529 
530  // Header, data and trajectory accessors
531  const AcquisitionHeader &getHead();
532  void setHead(const AcquisitionHeader other);
533 
537  const complex_float_t * const getDataPtr() const ;
538 
542  complex_float_t & data(uint16_t sample, uint16_t channel);
543 
547  void setData(complex_float_t * data);
548 
552  complex_float_t * data_begin() const;
553 
557  complex_float_t * data_end() const;
558 
562  const float * const getTrajPtr() const;
563 
567  float & traj(uint16_t dimension, uint16_t sample);
568 
572  void setTraj(float * traj);
573 
577  float * traj_begin() const;
578 
582  float * traj_end() const;
583 
584  // Flag methods
585  bool isFlagSet(const uint64_t val);
586  void setFlag(const uint64_t val);
587  void clearFlag(const uint64_t val);
588  void clearAllFlags();
589 
590  // Channel mask methods
591  bool isChannelActive(uint16_t channel_id);
592  void setChannelActive(uint16_t channel_id);
593  void setChannelNotActive(uint16_t channel_id);
594  void setAllChannelsNotActive();
595 
596 protected:
598 };
599 
601 class EXPORTISMRMRD ImageHeader: public ISMRMRD_ImageHeader {
602 public:
603  // Constructor
604  ImageHeader();
605 
606  // Flag methods
607  bool isFlagSet(const uint64_t val);
608  void setFlag(const uint64_t val);
609  void clearFlag(const uint64_t val);
610  void clearAllFlags();
611 
612 };
613 
615 template <typename T> class EXPORTISMRMRD Image {
616  friend class Dataset;
617 public:
618  // Constructors
619  Image(uint16_t matrix_size_x = 0, uint16_t matrix_size_y = 1,
620  uint16_t matrix_size_z = 1, uint16_t channels = 1);
621  Image(const Image &other);
622  Image & operator= (const Image &other);
623  ~Image();
624 
625  // Image dimensions
626  void resize(uint16_t matrix_size_x, uint16_t matrix_size_y, uint16_t matrix_size_z, uint16_t channels);
627  uint16_t getMatrixSizeX() const;
628  void setMatrixSizeX(uint16_t matrix_size_x);
629  uint16_t getMatrixSizeY() const;
630  void setMatrixSizeY(uint16_t matrix_size_y);
631  uint16_t getMatrixSizeZ() const;
632  void setMatrixSizeZ(uint16_t matrix_size_z);
633  uint16_t getNumberOfChannels() const;
634  void setNumberOfChannels(uint16_t channels);
635 
636  // Field of view
637  void setFieldOfView(float fov_x, float fov_y, float fov_z);
638  float getFieldOfViewX() const;
639  void setFieldOfViewX(float f);
640  float getFieldOfViewY() const;
641  void setFieldOfViewY(float f);
642  float getFieldOfViewZ() const;
643  void setFieldOfViewZ(float f);
644 
645  // Positions and orientations
646  void setPosition(float x, float y, float z);
647  float getPositionX() const;
648  void setPositionX(float x);
649  float getPositionY() const;
650  void setPositionY(float y);
651  float getPositionZ() const;
652  void setPositionZ(float z);
653 
654  void setReadDirection(float x, float y, float z);
655  float getReadDirectionX() const;
656  void setReadDirectionX(float x);
657  float getReadDirectionY() const;
658  void setReadDirectionY(float y);
659  float getReadDirectionZ() const;
660  void setReadDirectionZ(float z);
661 
662  void setPhaseDirection(float x, float y, float z);
663  float getPhaseDirectionX() const;
664  void setPhaseDirectionX(float x);
665  float getPhaseDirectionY() const;
666  void setPhaseDirectionY(float y);
667  float getPhaseDirectionZ() const;
668  void setPhaseDirectionZ(float z);
669 
670  void setSliceDirection(float x, float y, float z);
671  float getSliceDirectionX() const;
672  void setSliceDirectionX(float x);
673  float getSliceDirectionY() const;
674  void setSliceDirectionY(float y);
675  float getSliceDirectionZ() const;
676  void setSliceDirectionZ(float z);
677 
678  void setPatientTablePosition(float x, float y, float z);
679  float getPatientTablePositionX() const;
680  void setPatientTablePositionX(float x);
681  float getPatientTablePositionY() const;
682  void setPatientTablePositionY(float y);
683  float getPatientTablePositionZ() const;
684  void setPatientTablePositionZ(float z);
685 
686 
687  // Attributes
688  uint16_t getVersion() const;
689  ISMRMRD_DataTypes getDataType() const;
690 
691  // Counters and labels
692  uint32_t getMeasurementUid() const;
693  void setMeasurementUid(uint32_t measurement_uid);
694 
695  uint16_t getAverage() const;
696  void setAverage(uint16_t average);
697 
698  uint16_t getSlice() const;
699  void setSlice(uint16_t slice);
700 
701  uint16_t getContrast() const;
702  void setContrast(uint16_t contrast);
703 
704  uint16_t getPhase() const;
705  void setPhase(uint16_t phase);
706 
707  uint16_t getRepetition() const;
708  void setRepetition(uint16_t repetition);
709 
710  uint16_t getSet() const;
711  void setSet(uint16_t set);
712 
713  uint32_t getAcquisitionTimeStamp() const;
714  void setAcquisitionTimeStamp(uint32_t acquisition_time_stamp);
715 
716  uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const;
717  void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value);
718 
719  uint16_t getImageType() const;
720  void setImageType(uint16_t image_type);
721 
722  uint16_t getImageIndex() const;
723  void setImageIndex(uint16_t image_index);
724 
725  uint16_t getImageSeriesIndex() const;
726  void setImageSeriesIndex(uint16_t image_series_index);
727 
728  // User parameters
729  float getUserFloat(unsigned int index) const;
730  void setUserFloat(unsigned int index, float value);
731 
732  int32_t getUserInt(unsigned int index) const;
733  void setUserInt(unsigned int index, int32_t value);
734 
735  // Flags
736  uint64_t getFlags() const;
737  void setFlags(const uint64_t flags);
738  bool isFlagSet(const uint64_t val) const;
739  void setFlag(const uint64_t val);
740  void clearFlag(const uint64_t val);
741  void clearAllFlags();
742 
743  // Header
744  ImageHeader & getHead();
745  void setHead(const ImageHeader& head);
746 
747  // Attribute string
748  void getAttributeString(std::string &atrr) const;
749  void setAttributeString(const std::string attr);
750  const size_t getAttributeStringLength();
751 
752  // Data
753  T * const getDataPtr() const;
755  size_t getNumberOfDataElements() const;
757  size_t getDataSize() const;
758 
760  T* begin();
761 
763  T* end();
764 
766  T & operator () (uint16_t x, uint16_t y=0, uint16_t z=0 , uint16_t channel =0);
767 
768 protected:
769  ISMRMRD_Image im;
770 };
771 
773 template <typename T> class EXPORTISMRMRD NDArray {
774  friend class Dataset;
775 public:
776  // Constructors, destructor and copy
777  NDArray();
778  NDArray(const std::vector<size_t> dimvec);
779  NDArray(const NDArray<T> &other);
780  ~NDArray();
781  NDArray<T> & operator= (const NDArray<T> &other);
782 
783  // Accessors and mutators
784  const uint16_t getVersion();
785  const ISMRMRD_DataTypes getDataType();
786  const uint16_t getNDim();
787  const size_t (&getDims())[ISMRMRD_NDARRAY_MAXDIM];
788  const size_t getDataSize();
789  void resize(const std::vector<size_t> dimvec);
790  const size_t getNumberOfElements();
791  T * getDataPtr();
792 
794  T * begin();
795 
797  T* end();
798 
800  T & operator () (uint16_t x, uint16_t y=0, uint16_t z=0, uint16_t w=0, uint16_t n=0, uint16_t m=0, uint16_t l=0);
801 
802 protected:
803  ISMRMRD_NDArray arr;
804 };
805 
806 
809 } // namespace ISMRMRD
810 
811 #endif
812 
813 #endif /* ISMRMRD_H */
uint16_t average
Definition: ismrmrd.h:205
uint16_t discard_pre
Definition: ismrmrd.h:229
uint16_t discard_post
Definition: ismrmrd.h:230
float position[3]
Definition: ismrmrd.h:287
uint16_t version
Definition: ismrmrd.h:219
uint32_t scan_counter
Definition: ismrmrd.h:222
struct ISMRMRD::ISMRMRD_NDArray ISMRMRD_NDArray
uint16_t data_type
Definition: ismrmrd.h:344
float user_float[ISMRMRD_USER_FLOATS]
Definition: ismrmrd.h:304
ISMRMRD_Constants
Definition: ismrmrd.h:87
float position[3]
Definition: ismrmrd.h:235
uint16_t channels
Definition: ismrmrd.h:286
struct ISMRMRD::ISMRMRD_Acquisition ISMRMRD_Acquisition
uint16_t phase
Definition: ismrmrd.h:295
uint16_t version
Definition: ismrmrd.h:343
ISMRMRD_AcquisitionFlags
Definition: ismrmrd.h:132
int32_t user_int[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:303
uint16_t set
Definition: ismrmrd.h:297
uint16_t image_series_index
Definition: ismrmrd.h:302
uint32_t acquisition_time_stamp
Definition: ismrmrd.h:223
uint16_t segment
Definition: ismrmrd.h:211
int ismrmrd_push_error(const char *file, const int line, const char *func, const int code, const char *msg)
Definition: ismrmrd.c:663
uint16_t data_type
Definition: ismrmrd.h:281
uint16_t phase
Definition: ismrmrd.h:208
uint16_t kspace_encode_step_1
Definition: ismrmrd.h:203
EXPORTISMRMRD void ismrmrd_quaternion_to_directions(float quat[4], float read_dir[3], float phase_dir[3], float slice_dir[3])
Definition: ismrmrd.c:642
uint16_t slice
Definition: ismrmrd.h:293
Definition: ismrmrd.h:123
Definition: ismrmrd.h:119
uint16_t active_channels
Definition: ismrmrd.h:227
uint16_t slice
Definition: ismrmrd.h:206
uint16_t contrast
Definition: ismrmrd.h:294
MR Acquisition type.
Definition: ismrmrd.h:487
uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]
Definition: ismrmrd.h:228
Definition: ismrmrd.h:279
ISMRMRD_AcquisitionHeader head
Definition: ismrmrd.h:254
uint16_t center_sample
Definition: ismrmrd.h:231
uint16_t available_channels
Definition: ismrmrd.h:226
uint16_t user[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:212
float patient_table_position[3]
Definition: ismrmrd.h:239
bool ismrmrd_pop_error(char **file, int *line, char **func, int *code, char **msg)
Definition: ismrmrd.c:692
struct ISMRMRD::ISMRMRD_EncodingCounters ISMRMRD_EncodingCounters
ISMRMRD_ImageFlags
Definition: ismrmrd.h:187
ISMRMRD_ImageTypes
Definition: ismrmrd.h:176
Definition: ismrmrd.h:118
uint32_t attribute_string_len
Definition: ismrmrd.h:305
int32_t user_int[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:241
float slice_dir[3]
Definition: ismrmrd.h:238
float field_of_view[3]
Definition: ismrmrd.h:285
uint16_t average
Definition: ismrmrd.h:292
EXPORTISMRMRD int ismrmrd_sign_of_directions(float read_dir[3], float phase_dir[3], float slice_dir[3])
Definition: ismrmrd.c:552
struct ISMRMRD::ISMRMRD_Image ISMRMRD_Image
uint16_t contrast
Definition: ismrmrd.h:207
Definition: ismrmrd.h:122
uint32_t acquisition_time_stamp
Definition: ismrmrd.h:298
float phase_dir[3]
Definition: ismrmrd.h:289
uint16_t ndim
Definition: ismrmrd.h:345
std::string build_exception_string(void)
ISMRMRD C++ Interface.
Definition: ismrmrd.cpp:1147
struct ISMRMRD::ISMRMRD_ImageHeader ISMRMRD_ImageHeader
float phase_dir[3]
Definition: ismrmrd.h:237
ISMRMRD_ErrorCodes
Definition: ismrmrd.h:101
float user_float[ISMRMRD_USER_FLOATS]
Definition: ismrmrd.h:242
uint16_t repetition
Definition: ismrmrd.h:209
float sample_time_us
Definition: ismrmrd.h:234
Header for MR Image type.
Definition: ismrmrd.h:601
Definition: ismrmrd.h:218
N-Dimensional array type.
Definition: ismrmrd.h:773
uint16_t trajectory_dimensions
Definition: ismrmrd.h:233
ISMRMRD_EncodingCounters EncodingCounters
Some typedefs to beautify the namespace.
Definition: ismrmrd.h:436
ISMRMRD_EncodingCounters idx
Definition: ismrmrd.h:240
uint16_t repetition
Definition: ismrmrd.h:296
Definition: dataset.h:143
Definition: ismrmrd.h:253
uint16_t matrix_size[3]
Definition: ismrmrd.h:284
void * data
Definition: ismrmrd.h:347
uint16_t image_index
Definition: ismrmrd.h:301
EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3], float slice_dir[3], float quat[4])
Definition: ismrmrd.c:568
uint16_t set
Definition: ismrmrd.h:210
uint16_t version
Definition: ismrmrd.h:280
EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr)
Definition: ismrmrd.c:41
struct ISMRMRD::ISMRMRD_AcquisitionHeader ISMRMRD_AcquisitionHeader
Definition: ismrmrd.h:120
Definition: dataset.h:15
Definition: ismrmrd.h:202
Definition: ismrmrd.h:121
uint16_t encoding_space_ref
Definition: ismrmrd.h:232
Definition: ismrmrd.h:116
EXPORTISMRMRD char * ismrmrd_strerror(int code)
Definition: ismrmrd.c:728
uint16_t number_of_samples
Definition: ismrmrd.h:225
uint16_t image_type
Definition: ismrmrd.h:300
size_t dims[ISMRMRD_NDARRAY_MAXDIM]
Definition: ismrmrd.h:346
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition: ismrmrd.h:224
uint32_t measurement_uid
Definition: ismrmrd.h:221
Definition: ismrmrd.h:342
EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t)
Definition: ismrmrd.c:724
float patient_table_position[3]
Definition: ismrmrd.h:291
float read_dir[3]
Definition: ismrmrd.h:236
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition: ismrmrd.h:299
float read_dir[3]
Definition: ismrmrd.h:288
MR Image type.
Definition: ismrmrd.h:615
Header for MR Acquisition type.
Definition: ismrmrd.h:467
uint64_t flags
Definition: ismrmrd.h:220
uint64_t flags
Definition: ismrmrd.h:282
Convenience class for flags.
Definition: ismrmrd.h:446
float slice_dir[3]
Definition: ismrmrd.h:290
size_t ismrmrd_sizeof_data_type(int data_type)
Definition: ismrmrd.c:437
Definition: ismrmrd.h:315
ISMRMRD_DataTypes
Definition: ismrmrd.h:115
Definition: ismrmrd.h:117
EXPORTISMRMRD int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr)
Definition: ismrmrd.c:183
uint16_t kspace_encode_step_2
Definition: ismrmrd.h:204
EXPORTISMRMRD ISMRMRD_DataTypes get_data_type()
Allowed data types for Images and NDArrays.
uint32_t measurement_uid
Definition: ismrmrd.h:283