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 #if defined (_MSC_VER) && (_MSC_VER < 1800) /* old 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 
125  ISMRMRD_CXDOUBLE = 8
126 };
127 
129 EXPORTISMRMRD 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  ISMRMRD_ACQ_IS_PHASE_STABILIZATION_REFERENCE = 30,
165  ISMRMRD_ACQ_IS_PHASE_STABILIZATION = 31,
166 
167 
168  ISMRMRD_ACQ_COMPRESSION1 = 53,
169  ISMRMRD_ACQ_COMPRESSION2 = 54,
170  ISMRMRD_ACQ_COMPRESSION3 = 55,
171  ISMRMRD_ACQ_COMPRESSION4 = 56,
172  ISMRMRD_ACQ_USER1 = 57,
173  ISMRMRD_ACQ_USER2 = 58,
174  ISMRMRD_ACQ_USER3 = 59,
175  ISMRMRD_ACQ_USER4 = 60,
176  ISMRMRD_ACQ_USER5 = 61,
177  ISMRMRD_ACQ_USER6 = 62,
178  ISMRMRD_ACQ_USER7 = 63,
179  ISMRMRD_ACQ_USER8 = 64
180 };
181 
186  ISMRMRD_IMTYPE_MAGNITUDE = 1,
187  ISMRMRD_IMTYPE_PHASE = 2,
188  ISMRMRD_IMTYPE_REAL = 3,
189  ISMRMRD_IMTYPE_IMAG = 4,
190  ISMRMRD_IMTYPE_COMPLEX = 5
191 };
192 
197  ISMRMRD_IMAGE_IS_NAVIGATION_DATA = 1,
198  ISMRMRD_IMAGE_USER1 = 57,
199  ISMRMRD_IMAGE_USER2 = 58,
200  ISMRMRD_IMAGE_USER3 = 59,
201  ISMRMRD_IMAGE_USER4 = 60,
202  ISMRMRD_IMAGE_USER5 = 61,
203  ISMRMRD_IMAGE_USER6 = 62,
204  ISMRMRD_IMAGE_USER7 = 63,
205  ISMRMRD_IMAGE_USER8 = 64
206 };
207 
211 typedef struct ISMRMRD_EncodingCounters {
214  uint16_t average;
215  uint16_t slice;
216  uint16_t contrast;
217  uint16_t phase;
218  uint16_t repetition;
219  uint16_t set;
220  uint16_t segment;
221  uint16_t user[ISMRMRD_USER_INTS];
222 } ISMRMRD_EncodingCounters;
223 
228  uint16_t version;
229  uint64_t flags;
230  uint32_t measurement_uid;
231  uint32_t scan_counter;
233  uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
234  uint16_t number_of_samples;
236  uint16_t active_channels;
237  uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS];
238  uint16_t discard_pre;
239  uint16_t discard_post;
240  uint16_t center_sample;
244  float position[3];
245  float read_dir[3];
246  float phase_dir[3];
247  float slice_dir[3];
250  int32_t user_int[ISMRMRD_USER_INTS];
251  float user_float[ISMRMRD_USER_FLOATS];
252 } ISMRMRD_AcquisitionHeader;
253 
259 EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr);
260 
262 typedef struct ISMRMRD_Acquisition {
264  float *traj;
265  complex_float_t *data;
266 } ISMRMRD_Acquisition;
267 
271 EXPORTISMRMRD ISMRMRD_Acquisition * ismrmrd_create_acquisition();
272 EXPORTISMRMRD int ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq);
273 EXPORTISMRMRD int ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq);
274 EXPORTISMRMRD int ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq);
275 EXPORTISMRMRD int ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource);
276 EXPORTISMRMRD int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq);
277 EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq);
278 EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq);
281 /**********/
282 /* Images */
283 /**********/
284 
288 typedef struct ISMRMRD_ImageHeader {
289  uint16_t version;
290  uint16_t data_type;
291  uint64_t flags;
292  uint32_t measurement_uid;
293  uint16_t matrix_size[3];
294  float field_of_view[3];
295  uint16_t channels;
296  float position[3];
297  float read_dir[3];
298  float phase_dir[3];
299  float slice_dir[3];
301  uint16_t average;
302  uint16_t slice;
303  uint16_t contrast;
304  uint16_t phase;
305  uint16_t repetition;
306  uint16_t set;
308  uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
309  uint16_t image_type;
310  uint16_t image_index;
312  int32_t user_int[ISMRMRD_USER_INTS];
313  float user_float[ISMRMRD_USER_FLOATS];
315 } ISMRMRD_ImageHeader;
316 
318 EXPORTISMRMRD int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr);
319 
324 typedef struct ISMRMRD_Image {
325  ISMRMRD_ImageHeader head;
326  char *attribute_string;
327  void *data;
329 
330 
334 EXPORTISMRMRD ISMRMRD_Image * ismrmrd_create_image();
335 EXPORTISMRMRD int ismrmrd_free_image(ISMRMRD_Image *im);
336 EXPORTISMRMRD int ismrmrd_init_image(ISMRMRD_Image *im);
337 EXPORTISMRMRD int ismrmrd_cleanup_image(ISMRMRD_Image *im);
338 EXPORTISMRMRD int ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource);
339 EXPORTISMRMRD int ismrmrd_make_consistent_image(ISMRMRD_Image *im);
340 EXPORTISMRMRD size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im);
341 EXPORTISMRMRD size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im);
344 /************/
345 /* NDArrays */
346 /************/
347 
351 typedef struct ISMRMRD_NDArray {
352  uint16_t version;
353  uint16_t data_type;
354  uint16_t ndim;
355  size_t dims[ISMRMRD_NDARRAY_MAXDIM];
356  void *data;
357 } ISMRMRD_NDArray;
358 
362 EXPORTISMRMRD ISMRMRD_NDArray * ismrmrd_create_ndarray();
363 EXPORTISMRMRD int ismrmrd_free_ndarray(ISMRMRD_NDArray *arr);
364 EXPORTISMRMRD int ismrmrd_init_ndarray(ISMRMRD_NDArray *arr);
365 EXPORTISMRMRD int ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr);
366 EXPORTISMRMRD int ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource);
367 EXPORTISMRMRD int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr);
368 EXPORTISMRMRD size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr);
371 /*********/
372 /* Flags */
373 /*********/
377 EXPORTISMRMRD bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val);
378 EXPORTISMRMRD int ismrmrd_set_flag(uint64_t *flags, const uint64_t val);
379 EXPORTISMRMRD int ismrmrd_set_flags(uint64_t *flags, const uint64_t val);
380 EXPORTISMRMRD int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val);
381 EXPORTISMRMRD int ismrmrd_clear_all_flags(uint64_t *flags);
384 /*****************/
385 /* Channel Masks */
386 /*****************/
390 EXPORTISMRMRD bool ismrmrd_is_channel_on(const uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
391 EXPORTISMRMRD int ismrmrd_set_channel_on(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
392 EXPORTISMRMRD int ismrmrd_set_channel_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
393 EXPORTISMRMRD int ismrmrd_set_all_channels_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]);
396 /******************/
397 /* Error Handling */
398 /******************/
402 typedef void (*ismrmrd_error_handler_t)(const char *file, int line,
403  const char *function, int code, const char *msg);
404 #define ISMRMRD_PUSH_ERR(code, msg) ismrmrd_push_error(__FILE__, __LINE__, \
405  __func__, (code), (msg))
406 int ismrmrd_push_error(const char *file, const int line, const char *func,
407  const int code, const char *msg);
409 EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t);
411 EXPORTISMRMRD char *ismrmrd_strerror(int code);
416 bool ismrmrd_pop_error(char **file, int *line, char **func,
417  int *code, char **msg);
418 
419 /*****************************/
420 /* Rotations and Quaternions */
421 /*****************************/
426 EXPORTISMRMRD int ismrmrd_sign_of_directions(float const read_dir[3], float const phase_dir[3], float const slice_dir[3]);
427 
429 EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float const read_dir[3], float const phase_dir[3], float const slice_dir[3], float quat[4]);
430 
432 EXPORTISMRMRD void ismrmrd_quaternion_to_directions(float const quat[4], float read_dir[3], float phase_dir[3], float slice_dir[3]);
435 #pragma pack(pop) /* Restore old alignment */
436 
437 #ifdef __cplusplus
438 } // extern "C"
439 
441 
443 std::string build_exception_string(void);
444 
447 
448 
454 bool operator==(const EncodingCounters& ec1, const EncodingCounters& ec2);
455 
457 template <typename T> EXPORTISMRMRD ISMRMRD_DataTypes get_data_type();
458 
460 class EXPORTISMRMRD FlagBit
461 {
462 public:
463  FlagBit(unsigned short b)
464  : bitmask_(0)
465  {
466  if (b > 0) {
467  bitmask_ = 1;
468  bitmask_ = (bitmask_ << (b-1));
469  }
470  }
471 
472  bool isSet(const uint64_t& m) const {
473  return ((m & bitmask_)>0);
474  }
475 
476  uint64_t bitmask_;
477 
478 };
479 
481 class EXPORTISMRMRD AcquisitionHeader: public ISMRMRD_AcquisitionHeader {
482 public:
483  // Constructors
485 
486 
487  bool operator==(const AcquisitionHeader& acq) const;
488 
489  // Flag methods
490  bool isFlagSet(const ISMRMRD_AcquisitionFlags val) const;
491  void setFlag(const ISMRMRD_AcquisitionFlags val);
492  void clearFlag(const ISMRMRD_AcquisitionFlags val);
493  void clearAllFlags();
494 
495  // Channel mask methods
496  bool isChannelActive(uint16_t channel_id) const;
497  void setChannelActive(uint16_t channel_id);
498  void setChannelNotActive(uint16_t channel_id);
499  void setAllChannelsNotActive();
500 
501 };
502 
504 class EXPORTISMRMRD Acquisition {
505  friend class Dataset;
506 public:
507  // Constructors, assignment, destructor
508  Acquisition();
509  Acquisition(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
510  Acquisition(const Acquisition &other);
511  Acquisition & operator= (const Acquisition &other);
512  ~Acquisition();
513 
514  // Accessors and mutators
515  const uint16_t &version();
516  const uint64_t &flags();
517  uint32_t &measurement_uid();
518  uint32_t &scan_counter();
519  uint32_t &acquisition_time_stamp();
520  uint32_t (&physiology_time_stamp())[ISMRMRD_PHYS_STAMPS];
521  const uint16_t &number_of_samples();
522  uint16_t &available_channels();
523  const uint16_t &active_channels();
524  const uint64_t (&channel_mask())[ISMRMRD_CHANNEL_MASKS];
525  uint16_t &discard_pre();
526  uint16_t &discard_post();
527  uint16_t &center_sample();
528  uint16_t &encoding_space_ref();
529  const uint16_t &trajectory_dimensions();
530  float &sample_time_us();
531  float (&position())[3];
532  float (&read_dir())[3];
533  float (&phase_dir())[3];
534  float (&slice_dir())[3];
535  float (&patient_table_position())[3];
537  int32_t (&user_int())[ISMRMRD_USER_INTS];
538  float (&user_float())[ISMRMRD_USER_FLOATS];
539 
540  // Sizes
541  void resize(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
542  size_t getNumberOfDataElements() const;
543  size_t getNumberOfTrajElements() const;
544  size_t getDataSize() const;
545  size_t getTrajSize() const;
546 
547  // Header, data and trajectory accessors
548  const AcquisitionHeader &getHead() const;
549  void setHead(const AcquisitionHeader &other);
550 
554  const complex_float_t * getDataPtr() const;
555  complex_float_t * getDataPtr();
556 
560  complex_float_t & data(uint16_t sample, uint16_t channel);
561 
565  void setData(complex_float_t * data);
566 
570  complex_float_t * data_begin() const;
571 
575  complex_float_t * data_end() const;
576 
580  const float * getTrajPtr() const;
581  float * getTrajPtr();
582 
586  float & traj(uint16_t dimension, uint16_t sample);
587 
591  void setTraj(float * traj);
592 
596  float * traj_begin() const;
597 
601  float * traj_end() const;
602 
603  // Flag methods
604  bool isFlagSet(const uint64_t val);
605  void setFlag(const uint64_t val);
606  void clearFlag(const uint64_t val);
607  void clearAllFlags();
608 
609  bool isFlagSet(const FlagBit &val) { return isFlagSet(val.bitmask_); }
610  void setFlag(const FlagBit &val) { setFlag(val.bitmask_); }
611  void clearFlag(const FlagBit &val) { clearFlag(val.bitmask_); }
612 
613  // Channel mask methods
614  bool isChannelActive(uint16_t channel_id);
615  void setChannelActive(uint16_t channel_id);
616  void setChannelNotActive(uint16_t channel_id);
617  void setAllChannelsNotActive();
618 
619 protected:
621 };
622 
624 class EXPORTISMRMRD ImageHeader: public ISMRMRD_ImageHeader {
625 public:
626  // Constructor
627  ImageHeader();
628 
629  // Flag methods
630  bool isFlagSet(const uint64_t val);
631  void setFlag(const uint64_t val);
632  void clearFlag(const uint64_t val);
633  void clearAllFlags();
634 
635 };
636 
638 template <typename T> class EXPORTISMRMRD Image {
639  friend class Dataset;
640 public:
641  // Constructors
642  Image(uint16_t matrix_size_x = 0, uint16_t matrix_size_y = 1,
643  uint16_t matrix_size_z = 1, uint16_t channels = 1);
644  Image(const Image &other);
645  Image & operator= (const Image &other);
646  ~Image();
647 
648  // Image dimensions
649  void resize(uint16_t matrix_size_x, uint16_t matrix_size_y, uint16_t matrix_size_z, uint16_t channels);
650  uint16_t getMatrixSizeX() const;
651  void setMatrixSizeX(uint16_t matrix_size_x);
652  uint16_t getMatrixSizeY() const;
653  void setMatrixSizeY(uint16_t matrix_size_y);
654  uint16_t getMatrixSizeZ() const;
655  void setMatrixSizeZ(uint16_t matrix_size_z);
656  uint16_t getNumberOfChannels() const;
657  void setNumberOfChannels(uint16_t channels);
658 
659  // Field of view
660  void setFieldOfView(float fov_x, float fov_y, float fov_z);
661  float getFieldOfViewX() const;
662  void setFieldOfViewX(float f);
663  float getFieldOfViewY() const;
664  void setFieldOfViewY(float f);
665  float getFieldOfViewZ() const;
666  void setFieldOfViewZ(float f);
667 
668  // Positions and orientations
669  void setPosition(float x, float y, float z);
670  float getPositionX() const;
671  void setPositionX(float x);
672  float getPositionY() const;
673  void setPositionY(float y);
674  float getPositionZ() const;
675  void setPositionZ(float z);
676 
677  void setReadDirection(float x, float y, float z);
678  float getReadDirectionX() const;
679  void setReadDirectionX(float x);
680  float getReadDirectionY() const;
681  void setReadDirectionY(float y);
682  float getReadDirectionZ() const;
683  void setReadDirectionZ(float z);
684 
685  void setPhaseDirection(float x, float y, float z);
686  float getPhaseDirectionX() const;
687  void setPhaseDirectionX(float x);
688  float getPhaseDirectionY() const;
689  void setPhaseDirectionY(float y);
690  float getPhaseDirectionZ() const;
691  void setPhaseDirectionZ(float z);
692 
693  void setSliceDirection(float x, float y, float z);
694  float getSliceDirectionX() const;
695  void setSliceDirectionX(float x);
696  float getSliceDirectionY() const;
697  void setSliceDirectionY(float y);
698  float getSliceDirectionZ() const;
699  void setSliceDirectionZ(float z);
700 
701  void setPatientTablePosition(float x, float y, float z);
702  float getPatientTablePositionX() const;
703  void setPatientTablePositionX(float x);
704  float getPatientTablePositionY() const;
705  void setPatientTablePositionY(float y);
706  float getPatientTablePositionZ() const;
707  void setPatientTablePositionZ(float z);
708 
709 
710  // Attributes
711  uint16_t getVersion() const;
712  ISMRMRD_DataTypes getDataType() const;
713 
714  // Counters and labels
715  uint32_t getMeasurementUid() const;
716  void setMeasurementUid(uint32_t measurement_uid);
717 
718  uint16_t getAverage() const;
719  void setAverage(uint16_t average);
720 
721  uint16_t getSlice() const;
722  void setSlice(uint16_t slice);
723 
724  uint16_t getContrast() const;
725  void setContrast(uint16_t contrast);
726 
727  uint16_t getPhase() const;
728  void setPhase(uint16_t phase);
729 
730  uint16_t getRepetition() const;
731  void setRepetition(uint16_t repetition);
732 
733  uint16_t getSet() const;
734  void setSet(uint16_t set);
735 
736  uint32_t getAcquisitionTimeStamp() const;
737  void setAcquisitionTimeStamp(uint32_t acquisition_time_stamp);
738 
739  uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const;
740  void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value);
741 
742  uint16_t getImageType() const;
743  void setImageType(uint16_t image_type);
744 
745  uint16_t getImageIndex() const;
746  void setImageIndex(uint16_t image_index);
747 
748  uint16_t getImageSeriesIndex() const;
749  void setImageSeriesIndex(uint16_t image_series_index);
750 
751  // User parameters
752  float getUserFloat(unsigned int index) const;
753  void setUserFloat(unsigned int index, float value);
754 
755  int32_t getUserInt(unsigned int index) const;
756  void setUserInt(unsigned int index, int32_t value);
757 
758  // Flags
759  uint64_t getFlags() const;
760  void setFlags(const uint64_t flags);
761  bool isFlagSet(const uint64_t val) const;
762  void setFlag(const uint64_t val);
763  void clearFlag(const uint64_t val);
764  void clearAllFlags();
765 
766  // Header
767  ImageHeader & getHead();
768  const ImageHeader & getHead() const;
769  void setHead(const ImageHeader& head);
770 
771  // Attribute string
772  void getAttributeString(std::string &attr) const;
773  const char *getAttributeString() const;
774  void setAttributeString(const std::string &attr);
775  void setAttributeString(const char *attr);
776  size_t getAttributeStringLength() const;
777 
778  // Data
779  T * getDataPtr();
780  const T * getDataPtr() const;
782  size_t getNumberOfDataElements() const;
784  size_t getDataSize() const;
785 
787  T* begin();
788 
790  T* end();
791 
793  T & operator () (uint16_t x, uint16_t y=0, uint16_t z=0 , uint16_t channel =0);
794 
795 protected:
796  ISMRMRD_Image im;
797 };
798 
800 template <typename T> class EXPORTISMRMRD NDArray {
801  friend class Dataset;
802 public:
803  // Constructors, destructor and copy
804  NDArray();
805  NDArray(const std::vector<size_t> dimvec);
806  NDArray(const NDArray<T> &other);
807  ~NDArray();
808  NDArray<T> & operator= (const NDArray<T> &other);
809 
810  // Accessors and mutators
811  uint16_t getVersion() const;
812  ISMRMRD_DataTypes getDataType() const;
813  uint16_t getNDim() const;
814  const size_t (&getDims())[ISMRMRD_NDARRAY_MAXDIM];
815  size_t getDataSize() const;
816  void resize(const std::vector<size_t> dimvec);
817  size_t getNumberOfElements() const;
818  T * getDataPtr();
819  const T * getDataPtr() const;
820 
822  T * begin();
823 
825  T* end();
826 
828  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);
829 
830 protected:
831  ISMRMRD_NDArray arr;
832 };
833 
834 
837 } // namespace ISMRMRD
838 
839 #endif
840 
841 #endif /* ISMRMRD_H */
Header for MR Acquisition type.
Definition: ismrmrd.h:481
MR Acquisition type.
Definition: ismrmrd.h:504
Definition: dataset.h:161
Convenience class for flags.
Definition: ismrmrd.h:461
Header for MR Image type.
Definition: ismrmrd.h:624
MR Image type.
Definition: ismrmrd.h:638
N-Dimensional array type.
Definition: ismrmrd.h:800
EXPORTISMRMRD char * ismrmrd_strerror(int code)
Definition: ismrmrd.c:749
EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t)
Definition: ismrmrd.c:745
EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr)
Definition: ismrmrd.c:42
EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float const read_dir[3], float const phase_dir[3], float const slice_dir[3], float quat[4])
Definition: ismrmrd.c:589
EXPORTISMRMRD void ismrmrd_quaternion_to_directions(float const quat[4], float read_dir[3], float phase_dir[3], float slice_dir[3])
Definition: ismrmrd.c:663
int ismrmrd_push_error(const char *file, const int line, const char *func, const int code, const char *msg)
Definition: ismrmrd.c:684
EXPORTISMRMRD int ismrmrd_sign_of_directions(float const read_dir[3], float const phase_dir[3], float const slice_dir[3])
Definition: ismrmrd.c:573
struct ISMRMRD::ISMRMRD_Image ISMRMRD_Image
EXPORTISMRMRD ISMRMRD_DataTypes get_data_type()
Allowed data types for Images and NDArrays.
ISMRMRD_ImageFlags
Definition: ismrmrd.h:196
ISMRMRD_ErrorCodes
Definition: ismrmrd.h:103
std::string build_exception_string(void)
ISMRMRD C++ Interface.
Definition: ismrmrd.cpp:1240
ISMRMRD_AcquisitionFlags
Definition: ismrmrd.h:134
ISMRMRD_Constants
Definition: ismrmrd.h:89
ISMRMRD_DataTypes
Definition: ismrmrd.h:117
@ ISMRMRD_INT
Definition: ismrmrd.h:121
@ ISMRMRD_DOUBLE
Definition: ismrmrd.h:123
@ ISMRMRD_CXDOUBLE
Definition: ismrmrd.h:125
@ ISMRMRD_UINT
Definition: ismrmrd.h:120
@ ISMRMRD_CXFLOAT
Definition: ismrmrd.h:124
@ ISMRMRD_FLOAT
Definition: ismrmrd.h:122
@ ISMRMRD_USHORT
Definition: ismrmrd.h:118
@ ISMRMRD_SHORT
Definition: ismrmrd.h:119
ISMRMRD_ImageTypes
Definition: ismrmrd.h:185
Definition: ismrmrd.h:227
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition: ismrmrd.h:233
float phase_dir[3]
Definition: ismrmrd.h:246
uint32_t measurement_uid
Definition: ismrmrd.h:230
ISMRMRD_EncodingCounters idx
Definition: ismrmrd.h:249
uint32_t acquisition_time_stamp
Definition: ismrmrd.h:232
uint64_t flags
Definition: ismrmrd.h:229
int32_t user_int[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:250
uint16_t encoding_space_ref
Definition: ismrmrd.h:241
uint16_t trajectory_dimensions
Definition: ismrmrd.h:242
uint16_t available_channels
Definition: ismrmrd.h:235
float slice_dir[3]
Definition: ismrmrd.h:247
float position[3]
Definition: ismrmrd.h:244
float user_float[ISMRMRD_USER_FLOATS]
Definition: ismrmrd.h:251
uint16_t discard_post
Definition: ismrmrd.h:239
uint16_t center_sample
Definition: ismrmrd.h:240
float patient_table_position[3]
Definition: ismrmrd.h:248
uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]
Definition: ismrmrd.h:237
float read_dir[3]
Definition: ismrmrd.h:245
uint32_t scan_counter
Definition: ismrmrd.h:231
uint16_t number_of_samples
Definition: ismrmrd.h:234
float sample_time_us
Definition: ismrmrd.h:243
uint16_t version
Definition: ismrmrd.h:228
uint16_t discard_pre
Definition: ismrmrd.h:238
uint16_t active_channels
Definition: ismrmrd.h:236
Definition: ismrmrd.h:262
ISMRMRD_AcquisitionHeader head
Definition: ismrmrd.h:263
Definition: ismrmrd.h:211
uint16_t average
Definition: ismrmrd.h:214
uint16_t repetition
Definition: ismrmrd.h:218
uint16_t segment
Definition: ismrmrd.h:220
uint16_t kspace_encode_step_1
Definition: ismrmrd.h:212
uint16_t kspace_encode_step_2
Definition: ismrmrd.h:213
uint16_t phase
Definition: ismrmrd.h:217
uint16_t user[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:221
uint16_t set
Definition: ismrmrd.h:219
uint16_t contrast
Definition: ismrmrd.h:216
uint16_t slice
Definition: ismrmrd.h:215
Definition: ismrmrd.h:288
uint16_t data_type
Definition: ismrmrd.h:290
uint16_t set
Definition: ismrmrd.h:306
int32_t user_int[ISMRMRD_USER_INTS]
Definition: ismrmrd.h:312
uint16_t phase
Definition: ismrmrd.h:304
uint16_t slice
Definition: ismrmrd.h:302
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition: ismrmrd.h:308
uint16_t image_type
Definition: ismrmrd.h:309
uint16_t version
Definition: ismrmrd.h:289
uint16_t matrix_size[3]
Definition: ismrmrd.h:293
uint16_t image_index
Definition: ismrmrd.h:310
float patient_table_position[3]
Definition: ismrmrd.h:300
uint16_t channels
Definition: ismrmrd.h:295
float phase_dir[3]
Definition: ismrmrd.h:298
uint16_t repetition
Definition: ismrmrd.h:305
float position[3]
Definition: ismrmrd.h:296
float read_dir[3]
Definition: ismrmrd.h:297
uint32_t acquisition_time_stamp
Definition: ismrmrd.h:307
float field_of_view[3]
Definition: ismrmrd.h:294
float user_float[ISMRMRD_USER_FLOATS]
Definition: ismrmrd.h:313
uint64_t flags
Definition: ismrmrd.h:291
uint16_t image_series_index
Definition: ismrmrd.h:311
uint32_t attribute_string_len
Definition: ismrmrd.h:314
float slice_dir[3]
Definition: ismrmrd.h:299
uint16_t contrast
Definition: ismrmrd.h:303
uint32_t measurement_uid
Definition: ismrmrd.h:292
uint16_t average
Definition: ismrmrd.h:301
Definition: ismrmrd.h:324
Definition: ismrmrd.h:351
size_t dims[ISMRMRD_NDARRAY_MAXDIM]
Definition: ismrmrd.h:355
uint16_t version
Definition: ismrmrd.h:352
void * data
Definition: ismrmrd.h:356
uint16_t ndim
Definition: ismrmrd.h:354
uint16_t data_type
Definition: ismrmrd.h:353