ISMRMRD
ISMRM Raw Data Format
Loading...
Searching...
No Matches
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
26typedef __int16 int16_t;
27typedef unsigned __int16 uint16_t;
28typedef __int32 int32_t;
29typedef unsigned __int32 uint32_t;
30typedef __int64 int64_t;
31typedef 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>
41typedef std::complex<float> complex_float_t;
42typedef std::complex<double> complex_double_t;
43#else
44#ifdef _MSC_VER /* MS C compiler */
45typedef struct complex_float_t{
46 float real;
47 float imag;
48}complex_float_t;
49typedef struct complex_double_t{
50 double real;
51 double imag;
52}complex_double_t;
53#else /* C99 compiler */
54#include <complex.h>
55typedef float complex complex_float_t;
56typedef 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 */
63typedef 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
82namespace ISMRMRD {
83extern "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
127
129EXPORTISMRMRD 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
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;
231 uint32_t scan_counter;
233 uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
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
259EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr);
260
262typedef struct ISMRMRD_Acquisition {
264 float *traj;
265 complex_float_t *data;
266} ISMRMRD_Acquisition;
267
271EXPORTISMRMRD ISMRMRD_Acquisition * ismrmrd_create_acquisition();
272EXPORTISMRMRD int ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq);
273EXPORTISMRMRD int ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq);
274EXPORTISMRMRD int ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq);
275EXPORTISMRMRD int ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource);
276EXPORTISMRMRD int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq);
277EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq);
278EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq);
281/**********/
282/* Images */
283/**********/
284
288typedef struct ISMRMRD_ImageHeader {
289 uint16_t version;
290 uint16_t data_type;
291 uint64_t flags;
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
318EXPORTISMRMRD int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr);
319
324typedef struct ISMRMRD_Image {
326 char *attribute_string;
327 void *data;
328} ISMRMRD_Image;
329
330
334EXPORTISMRMRD ISMRMRD_Image * ismrmrd_create_image();
335EXPORTISMRMRD int ismrmrd_free_image(ISMRMRD_Image *im);
336EXPORTISMRMRD int ismrmrd_init_image(ISMRMRD_Image *im);
337EXPORTISMRMRD int ismrmrd_cleanup_image(ISMRMRD_Image *im);
338EXPORTISMRMRD int ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource);
339EXPORTISMRMRD int ismrmrd_make_consistent_image(ISMRMRD_Image *im);
340EXPORTISMRMRD size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im);
341EXPORTISMRMRD size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im);
344/************/
345/* NDArrays */
346/************/
347
351typedef 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
362EXPORTISMRMRD ISMRMRD_NDArray * ismrmrd_create_ndarray();
363EXPORTISMRMRD int ismrmrd_free_ndarray(ISMRMRD_NDArray *arr);
364EXPORTISMRMRD int ismrmrd_init_ndarray(ISMRMRD_NDArray *arr);
365EXPORTISMRMRD int ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr);
366EXPORTISMRMRD int ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource);
367EXPORTISMRMRD int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr);
368EXPORTISMRMRD size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr);
371/*********/
372/* Flags */
373/*********/
377EXPORTISMRMRD bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val);
378EXPORTISMRMRD int ismrmrd_set_flag(uint64_t *flags, const uint64_t val);
379EXPORTISMRMRD int ismrmrd_set_flags(uint64_t *flags, const uint64_t val);
380EXPORTISMRMRD int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val);
381EXPORTISMRMRD int ismrmrd_clear_all_flags(uint64_t *flags);
384/*****************/
385/* Channel Masks */
386/*****************/
390EXPORTISMRMRD bool ismrmrd_is_channel_on(const uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
391EXPORTISMRMRD int ismrmrd_set_channel_on(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
392EXPORTISMRMRD int ismrmrd_set_channel_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
393EXPORTISMRMRD int ismrmrd_set_all_channels_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]);
396/******************/
397/* Error Handling */
398/******************/
402typedef 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))
406int ismrmrd_push_error(const char *file, const int line, const char *func,
407 const int code, const char *msg);
409EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t);
411EXPORTISMRMRD char *ismrmrd_strerror(int code);
416bool ismrmrd_pop_error(char **file, int *line, char **func,
417 int *code, char **msg);
418
419/*****************************/
420/* Rotations and Quaternions */
421/*****************************/
426EXPORTISMRMRD int ismrmrd_sign_of_directions(float const read_dir[3], float const phase_dir[3], float const slice_dir[3]);
427
429EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float const read_dir[3], float const phase_dir[3], float const slice_dir[3], float quat[4]);
430
432EXPORTISMRMRD 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
443std::string build_exception_string(void);
444
447
448
454bool operator==(const EncodingCounters& ec1, const EncodingCounters& ec2);
455
457template <typename T> EXPORTISMRMRD ISMRMRD_DataTypes get_data_type();
458
460class EXPORTISMRMRD FlagBit
461{
462public:
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
481class EXPORTISMRMRD AcquisitionHeader: public ISMRMRD_AcquisitionHeader {
482public:
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
504class EXPORTISMRMRD Acquisition {
505 friend class Dataset;
506public:
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
619protected:
621};
622
624class EXPORTISMRMRD ImageHeader: public ISMRMRD_ImageHeader {
625public:
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
638template <typename T> class EXPORTISMRMRD Image {
639 friend class Dataset;
640public:
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
795protected:
796 ISMRMRD_Image im;
797};
798
800template <typename T> class EXPORTISMRMRD NDArray {
801 friend class Dataset;
802public:
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
830protected:
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
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