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