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
12// clang-format off
13
20#pragma once
21#ifndef ISMRMRD_H
22#define ISMRMRD_H
23
24/* Language and cross platform section for defining types */
25/* integers */
26#include <stdint.h>
27#include <stddef.h> /* for size_t */
28
29#if __cplusplus > 199711L
30#include <type_traits>
31#endif
32
33/* Unaligned */
34#ifdef _MSC_VER
35#define ISMRMRD_UNALIGNED __unaligned
36#else
37#define ISMRMRD_UNALIGNED
38#endif
39
40/* Complex numbers */
41#ifdef __cplusplus
42#include <complex>
43typedef std::complex<float> complex_float_t;
44typedef std::complex<double> complex_double_t;
45#else
46#ifdef _MSC_VER /* MS C compiler */
47typedef struct complex_float_t{
48 float real;
49 float imag;
50}complex_float_t;
51typedef struct complex_double_t{
52 double real;
53 double imag;
54}complex_double_t;
55#else /* C99 compiler */
56#include <complex.h>
57typedef float complex complex_float_t;
58typedef double complex complex_double_t;
59#endif /* _MSC_VER */
60#endif /* __cplusplus */
61
62/* Booleans - part of C++ */
63#ifndef __cplusplus
64#if defined (_MSC_VER) && (_MSC_VER < 1800) /* old MS C compiler */
65typedef int bool;
66#define false 0
67#define true 1
68#else /* C99 compiler */
69#include <stdbool.h>
70#endif /* _MSC_VER */
71#endif /* __cplusplus */
72
73/* Vectors */
74#ifdef __cplusplus
75#include <vector>
76#endif /* __cplusplus */
77
78/* Exports needed for MS C++ */
79#include "ismrmrd/export.h"
80
81#pragma pack(push, 2) /* Use 2 byte alignment */
82
83#ifdef __cplusplus
84namespace ISMRMRD {
85extern "C" {
86#endif
87
92 ISMRMRD_USER_INTS = 8,
93 ISMRMRD_USER_FLOATS = 8,
94 ISMRMRD_PHYS_STAMPS = 3,
95 ISMRMRD_CHANNEL_MASKS = 16,
96 ISMRMRD_NDARRAY_MAXDIM = 7,
97 ISMRMRD_POSITION_LENGTH = 3,
98 ISMRMRD_DIRECTION_LENGTH = 3
99};
100
101
106 ISMRMRD_BEGINERROR=-1,
107 ISMRMRD_NOERROR,
108 ISMRMRD_MEMORYERROR,
109 ISMRMRD_FILEERROR,
110 ISMRMRD_TYPEERROR,
111 ISMRMRD_RUNTIMEERROR,
112 ISMRMRD_HDF5ERROR,
113 ISMRMRD_ENDERROR
114};
115
129
131EXPORTISMRMRD size_t ismrmrd_sizeof_data_type(int data_type);
132
137 ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP1 = 1,
138 ISMRMRD_ACQ_LAST_IN_ENCODE_STEP1 = 2,
139 ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP2 = 3,
140 ISMRMRD_ACQ_LAST_IN_ENCODE_STEP2 = 4,
141 ISMRMRD_ACQ_FIRST_IN_AVERAGE = 5,
142 ISMRMRD_ACQ_LAST_IN_AVERAGE = 6,
143 ISMRMRD_ACQ_FIRST_IN_SLICE = 7,
144 ISMRMRD_ACQ_LAST_IN_SLICE = 8,
145 ISMRMRD_ACQ_FIRST_IN_CONTRAST = 9,
146 ISMRMRD_ACQ_LAST_IN_CONTRAST = 10,
147 ISMRMRD_ACQ_FIRST_IN_PHASE = 11,
148 ISMRMRD_ACQ_LAST_IN_PHASE = 12,
149 ISMRMRD_ACQ_FIRST_IN_REPETITION = 13,
150 ISMRMRD_ACQ_LAST_IN_REPETITION = 14,
151 ISMRMRD_ACQ_FIRST_IN_SET = 15,
152 ISMRMRD_ACQ_LAST_IN_SET = 16,
153 ISMRMRD_ACQ_FIRST_IN_SEGMENT = 17,
154 ISMRMRD_ACQ_LAST_IN_SEGMENT = 18,
155 ISMRMRD_ACQ_IS_NOISE_MEASUREMENT = 19,
156 ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION = 20,
157 ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING = 21,
158 ISMRMRD_ACQ_IS_REVERSE = 22,
159 ISMRMRD_ACQ_IS_NAVIGATION_DATA = 23,
160 ISMRMRD_ACQ_IS_PHASECORR_DATA = 24,
161 ISMRMRD_ACQ_LAST_IN_MEASUREMENT = 25,
162 ISMRMRD_ACQ_IS_HPFEEDBACK_DATA = 26,
163 ISMRMRD_ACQ_IS_DUMMYSCAN_DATA = 27,
164 ISMRMRD_ACQ_IS_RTFEEDBACK_DATA = 28,
165 ISMRMRD_ACQ_IS_SURFACECOILCORRECTIONSCAN_DATA = 29,
166 ISMRMRD_ACQ_IS_PHASE_STABILIZATION_REFERENCE = 30,
167 ISMRMRD_ACQ_IS_PHASE_STABILIZATION = 31,
168
169
170 ISMRMRD_ACQ_COMPRESSION1 = 53,
171 ISMRMRD_ACQ_COMPRESSION2 = 54,
172 ISMRMRD_ACQ_COMPRESSION3 = 55,
173 ISMRMRD_ACQ_COMPRESSION4 = 56,
174 ISMRMRD_ACQ_USER1 = 57,
175 ISMRMRD_ACQ_USER2 = 58,
176 ISMRMRD_ACQ_USER3 = 59,
177 ISMRMRD_ACQ_USER4 = 60,
178 ISMRMRD_ACQ_USER5 = 61,
179 ISMRMRD_ACQ_USER6 = 62,
180 ISMRMRD_ACQ_USER7 = 63,
181 ISMRMRD_ACQ_USER8 = 64
182};
183
188 ISMRMRD_IMTYPE_MAGNITUDE = 1,
189 ISMRMRD_IMTYPE_PHASE = 2,
190 ISMRMRD_IMTYPE_REAL = 3,
191 ISMRMRD_IMTYPE_IMAG = 4,
192 ISMRMRD_IMTYPE_COMPLEX = 5
193};
194
199 ISMRMRD_IMAGE_IS_NAVIGATION_DATA = 1,
200 ISMRMRD_IMAGE_FIRST_IN_AVERAGE = 5,
201 ISMRMRD_IMAGE_LAST_IN_AVERAGE = 6,
202 ISMRMRD_IMAGE_FIRST_IN_SLICE = 7,
203 ISMRMRD_IMAGE_LAST_IN_SLICE = 8,
204 ISMRMRD_IMAGE_FIRST_IN_CONTRAST = 9,
205 ISMRMRD_IMAGE_LAST_IN_CONTRAST = 10,
206 ISMRMRD_IMAGE_FIRST_IN_PHASE = 11,
207 ISMRMRD_IMAGE_LAST_IN_PHASE = 12,
208 ISMRMRD_IMAGE_FIRST_IN_REPETITION = 13,
209 ISMRMRD_IMAGE_LAST_IN_REPETITION = 14,
210 ISMRMRD_IMAGE_FIRST_IN_SET = 15,
211 ISMRMRD_IMAGE_LAST_IN_SET = 16,
212 ISMRMRD_IMAGE_USER1 = 57,
213 ISMRMRD_IMAGE_USER2 = 58,
214 ISMRMRD_IMAGE_USER3 = 59,
215 ISMRMRD_IMAGE_USER4 = 60,
216 ISMRMRD_IMAGE_USER5 = 61,
217 ISMRMRD_IMAGE_USER6 = 62,
218 ISMRMRD_IMAGE_USER7 = 63,
219 ISMRMRD_IMAGE_USER8 = 64
220};
221
228 uint16_t average;
229 uint16_t slice;
230 uint16_t contrast;
231 uint16_t phase;
232 uint16_t repetition;
233 uint16_t set;
234 uint16_t segment;
235 uint16_t user[ISMRMRD_USER_INTS];
236} ISMRMRD_EncodingCounters;
237
238#if __cplusplus > 199711L // Static assert requires C++11
239// Check standard layout
240static_assert(std::is_standard_layout<ISMRMRD_EncodingCounters>::value, "ISMRMRD_EncodingCounters is not a standard layout type");
241// Check for size and offset of EncodingCounters struct members
242static_assert(sizeof(ISMRMRD_EncodingCounters) == 34, "ISMRMRD_EncodingCounters is not the expected size");
243static_assert(offsetof(ISMRMRD_EncodingCounters, kspace_encode_step_1) == 0, "kspace_encode_step_1 is not at the expected offset");
244static_assert(offsetof(ISMRMRD_EncodingCounters, kspace_encode_step_2) == 2, "kspace_encode_step_2 is not at the expected offset");
245static_assert(offsetof(ISMRMRD_EncodingCounters, average) == 4, "average is not at the expected offset");
246static_assert(offsetof(ISMRMRD_EncodingCounters, slice) == 6, "slice is not at the expected offset");
247static_assert(offsetof(ISMRMRD_EncodingCounters, contrast) == 8, "contrast is not at the expected offset");
248static_assert(offsetof(ISMRMRD_EncodingCounters, phase) == 10, "phase is not at the expected offset");
249static_assert(offsetof(ISMRMRD_EncodingCounters, repetition) == 12, "repetition is not at the expected offset");
250static_assert(offsetof(ISMRMRD_EncodingCounters, set) == 14, "set is not at the expected offset");
251static_assert(offsetof(ISMRMRD_EncodingCounters, segment) == 16, "segment is not at the expected offset");
252static_assert(offsetof(ISMRMRD_EncodingCounters, user) == 18, "user is not at the expected offset");
253#endif
254
259 uint16_t version;
260 uint64_t flags;
262 uint32_t scan_counter;
264 uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
268 uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS];
269 uint16_t discard_pre;
270 uint16_t discard_post;
271 uint16_t center_sample;
275 float position[3];
276 float read_dir[3];
277 float phase_dir[3];
278 float slice_dir[3];
281 int32_t user_int[ISMRMRD_USER_INTS];
282 float user_float[ISMRMRD_USER_FLOATS];
283} ISMRMRD_AcquisitionHeader;
284
285#if __cplusplus > 199711L // Static assert requires C++11
286// Check standard layout
287static_assert(std::is_standard_layout<ISMRMRD_AcquisitionHeader>::value, "ISMRMRD_AcquisitionHeader is not a standard layout type");
288// Check for size and offset of AcquisitionHeader struct members
289static_assert(sizeof(ISMRMRD_AcquisitionHeader) == 340, "ISMRMRD_AcquisitionHeader is not the expected size");
290static_assert(offsetof(ISMRMRD_AcquisitionHeader, version) == 0, "version is not at the expected offset");
291static_assert(offsetof(ISMRMRD_AcquisitionHeader, flags) == 2, "flags is not at the expected offset");
292static_assert(offsetof(ISMRMRD_AcquisitionHeader, measurement_uid) == 10, "measurement_uid is not at the expected offset");
293static_assert(offsetof(ISMRMRD_AcquisitionHeader, scan_counter) == 14, "scan_counter is not at the expected offset");
294static_assert(offsetof(ISMRMRD_AcquisitionHeader, acquisition_time_stamp) == 18, "acquisition_time_stamp is not at the expected offset");
295static_assert(offsetof(ISMRMRD_AcquisitionHeader, physiology_time_stamp) == 22, "physiology_time_stamp is not at the expected offset");
296static_assert(offsetof(ISMRMRD_AcquisitionHeader, number_of_samples) == 34, "number_of_samples is not at the expected offset");
297static_assert(offsetof(ISMRMRD_AcquisitionHeader, available_channels) == 36, "available_channels is not at the expected offset");
298static_assert(offsetof(ISMRMRD_AcquisitionHeader, active_channels) == 38, "active_channels is not at the expected offset");
299static_assert(offsetof(ISMRMRD_AcquisitionHeader, channel_mask) == 40, "channel_mask is not at the expected offset");
300static_assert(offsetof(ISMRMRD_AcquisitionHeader, discard_pre) == 168, "discard_pre is not at the expected offset");
301static_assert(offsetof(ISMRMRD_AcquisitionHeader, discard_post) == 170, "discard_post is not at the expected offset");
302static_assert(offsetof(ISMRMRD_AcquisitionHeader, center_sample) == 172, "center_sample is not at the expected offset");
303static_assert(offsetof(ISMRMRD_AcquisitionHeader, encoding_space_ref) == 174, "encoding_space_ref is not at the expected offset");
304static_assert(offsetof(ISMRMRD_AcquisitionHeader, trajectory_dimensions) == 176, "trajectory_dimensions is not at the expected offset");
305static_assert(offsetof(ISMRMRD_AcquisitionHeader, sample_time_us) == 178, "sample_time_us is not at the expected offset");
306static_assert(offsetof(ISMRMRD_AcquisitionHeader, position) == 182, "position is not at the expected offset");
307static_assert(offsetof(ISMRMRD_AcquisitionHeader, read_dir) == 194, "read_dir is not at the expected offset");
308static_assert(offsetof(ISMRMRD_AcquisitionHeader, phase_dir) == 206, "phase_dir is not at the expected offset");
309static_assert(offsetof(ISMRMRD_AcquisitionHeader, slice_dir) == 218, "slice_dir is not at the expected offset");
310static_assert(offsetof(ISMRMRD_AcquisitionHeader, patient_table_position) == 230, "patient_table_position is not at the expected offset");
311static_assert(offsetof(ISMRMRD_AcquisitionHeader, idx) == 242, "idx is not at the expected offset");
312static_assert(offsetof(ISMRMRD_AcquisitionHeader, user_int) == 276, "user_int is not at the expected offset");
313static_assert(offsetof(ISMRMRD_AcquisitionHeader, user_float) == 308, "user_float is not at the expected offset");
314#endif
315
321EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr);
322
324typedef struct ISMRMRD_Acquisition {
326 float *traj;
327 complex_float_t *data;
328} ISMRMRD_Acquisition;
329
333EXPORTISMRMRD ISMRMRD_Acquisition * ismrmrd_create_acquisition();
334EXPORTISMRMRD int ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq);
335EXPORTISMRMRD int ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq);
336EXPORTISMRMRD int ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq);
337EXPORTISMRMRD int ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource);
338EXPORTISMRMRD int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq);
339EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq);
340EXPORTISMRMRD size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq);
343/**********/
344/* Images */
345/**********/
346
350typedef struct ISMRMRD_ImageHeader {
351 uint16_t version;
352 uint16_t data_type;
353 uint64_t flags;
355 uint16_t matrix_size[3];
356 float field_of_view[3];
357 uint16_t channels;
358 float position[3];
359 float read_dir[3];
360 float phase_dir[3];
361 float slice_dir[3];
363 uint16_t average;
364 uint16_t slice;
365 uint16_t contrast;
366 uint16_t phase;
367 uint16_t repetition;
368 uint16_t set;
370 uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS];
371 uint16_t image_type;
372 uint16_t image_index;
374 int32_t user_int[ISMRMRD_USER_INTS];
375 float user_float[ISMRMRD_USER_FLOATS];
377} ISMRMRD_ImageHeader;
378
379#if __cplusplus > 199711L // Static assert requires C++11
380// Check standard layout
381static_assert(std::is_standard_layout<ISMRMRD_ImageHeader>::value, "ISMRMRD_ImageHeader is not a standard layout type");
382// Check size and offsets of ISMRMRD_ImageHeader
383static_assert(sizeof(ISMRMRD_ImageHeader) == 198, "ISMRMRD_ImageHeader is not the expected size");
384static_assert(offsetof(ISMRMRD_ImageHeader, version) == 0, "version is not at the expected offset");
385static_assert(offsetof(ISMRMRD_ImageHeader, data_type) == 2, "data_type is not at the expected offset");
386static_assert(offsetof(ISMRMRD_ImageHeader, flags) == 4, "flags is not at the expected offset");
387static_assert(offsetof(ISMRMRD_ImageHeader, measurement_uid) == 12, "measurement_uid is not at the expected offset");
388static_assert(offsetof(ISMRMRD_ImageHeader, matrix_size) == 16, "matrix_size is not at the expected offset");
389static_assert(offsetof(ISMRMRD_ImageHeader, field_of_view) == 22, "field_of_view is not at the expected offset");
390static_assert(offsetof(ISMRMRD_ImageHeader, channels) == 34, "channels is not at the expected offset");
391static_assert(offsetof(ISMRMRD_ImageHeader, position) == 36, "position is not at the expected offset");
392static_assert(offsetof(ISMRMRD_ImageHeader, read_dir) == 48, "read_dir is not at the expected offset");
393static_assert(offsetof(ISMRMRD_ImageHeader, phase_dir) == 60, "phase_dir is not at the expected offset");
394static_assert(offsetof(ISMRMRD_ImageHeader, slice_dir) == 72, "slice_dir is not at the expected offset");
395static_assert(offsetof(ISMRMRD_ImageHeader, patient_table_position) == 84, "patient_table_position is not at the expected offset");
396static_assert(offsetof(ISMRMRD_ImageHeader, average) == 96, "average is not at the expected offset");
397static_assert(offsetof(ISMRMRD_ImageHeader, slice) == 98, "slice is not at the expected offset");
398static_assert(offsetof(ISMRMRD_ImageHeader, contrast) == 100, "contrast is not at the expected offset");
399static_assert(offsetof(ISMRMRD_ImageHeader, phase) == 102, "phase is not at the expected offset");
400static_assert(offsetof(ISMRMRD_ImageHeader, repetition) == 104, "repetition is not at the expected offset");
401static_assert(offsetof(ISMRMRD_ImageHeader, set) == 106, "set is not at the expected offset");
402static_assert(offsetof(ISMRMRD_ImageHeader, acquisition_time_stamp) == 108, "acquisition_time_stamp is not at the expected offset");
403static_assert(offsetof(ISMRMRD_ImageHeader, physiology_time_stamp) == 112, "physiology_time_stamp is not at the expected offset");
404static_assert(offsetof(ISMRMRD_ImageHeader, image_type) == 124, "image_type is not at the expected offset");
405static_assert(offsetof(ISMRMRD_ImageHeader, image_index) == 126, "image_index is not at the expected offset");
406static_assert(offsetof(ISMRMRD_ImageHeader, image_series_index) == 128, "image_series_index is not at the expected offset");
407static_assert(offsetof(ISMRMRD_ImageHeader, user_int) == 130, "user_int is not at the expected offset");
408static_assert(offsetof(ISMRMRD_ImageHeader, user_float) == 162, "user_float is not at the expected offset");
409static_assert(offsetof(ISMRMRD_ImageHeader, attribute_string_len) == 194, "attribute_string_len is not at the expected offset");
410#endif
411
413EXPORTISMRMRD int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr);
414
419typedef struct ISMRMRD_Image {
421 char *attribute_string;
422 void *data;
423} ISMRMRD_Image;
424
425
429EXPORTISMRMRD ISMRMRD_Image * ismrmrd_create_image();
430EXPORTISMRMRD int ismrmrd_free_image(ISMRMRD_Image *im);
431EXPORTISMRMRD int ismrmrd_init_image(ISMRMRD_Image *im);
432EXPORTISMRMRD int ismrmrd_cleanup_image(ISMRMRD_Image *im);
433EXPORTISMRMRD int ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource);
434EXPORTISMRMRD int ismrmrd_make_consistent_image(ISMRMRD_Image *im);
435EXPORTISMRMRD size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im);
436EXPORTISMRMRD size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im);
439/************/
440/* NDArrays */
441/************/
442
446typedef struct ISMRMRD_NDArray {
447 uint16_t version;
448 uint16_t data_type;
449 uint16_t ndim;
450 size_t dims[ISMRMRD_NDARRAY_MAXDIM];
451 void *data;
452} ISMRMRD_NDArray;
453
457EXPORTISMRMRD ISMRMRD_NDArray * ismrmrd_create_ndarray();
458EXPORTISMRMRD int ismrmrd_free_ndarray(ISMRMRD_NDArray *arr);
459EXPORTISMRMRD int ismrmrd_init_ndarray(ISMRMRD_NDArray *arr);
460EXPORTISMRMRD int ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr);
461EXPORTISMRMRD int ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource);
462EXPORTISMRMRD int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr);
463EXPORTISMRMRD size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr);
466/*********/
467/* Flags */
468/*********/
472EXPORTISMRMRD bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val);
473EXPORTISMRMRD int ismrmrd_set_flag(ISMRMRD_UNALIGNED uint64_t *flags, const uint64_t val);
474EXPORTISMRMRD int ismrmrd_set_flags(ISMRMRD_UNALIGNED uint64_t *flags, const uint64_t val);
475EXPORTISMRMRD int ismrmrd_clear_flag(ISMRMRD_UNALIGNED uint64_t *flags, const uint64_t val);
476EXPORTISMRMRD int ismrmrd_clear_all_flags(ISMRMRD_UNALIGNED uint64_t *flags);
479/*****************/
480/* Channel Masks */
481/*****************/
485EXPORTISMRMRD bool ismrmrd_is_channel_on(const uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
486EXPORTISMRMRD int ismrmrd_set_channel_on(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
487EXPORTISMRMRD int ismrmrd_set_channel_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], const uint16_t chan);
488EXPORTISMRMRD int ismrmrd_set_all_channels_off(uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]);
491/******************/
492/* Error Handling */
493/******************/
497typedef void (*ismrmrd_error_handler_t)(const char *file, int line,
498 const char *function, int code, const char *msg);
499#define ISMRMRD_PUSH_ERR(code, msg) ismrmrd_push_error(__FILE__, __LINE__, \
500 __func__, (code), (msg))
501int ismrmrd_push_error(const char *file, const int line, const char *func,
502 const int code, const char *msg);
504EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t);
506EXPORTISMRMRD const char *ismrmrd_strerror(int code);
511bool ismrmrd_pop_error(char **file, int *line, char **func,
512 int *code, char **msg);
513
514/*****************************/
515/* Rotations and Quaternions */
516/*****************************/
521EXPORTISMRMRD int ismrmrd_sign_of_directions(float const read_dir[3], float const phase_dir[3], float const slice_dir[3]);
522
524EXPORTISMRMRD void ismrmrd_directions_to_quaternion(float const read_dir[3], float const phase_dir[3], float const slice_dir[3], float quat[4]);
525
527EXPORTISMRMRD void ismrmrd_quaternion_to_directions(float const quat[4], float read_dir[3], float phase_dir[3], float slice_dir[3]);
530#pragma pack(pop) /* Restore old alignment */
531
532#ifdef __cplusplus
533} // extern "C"
534
536
538std::string build_exception_string(void);
539
542
543
549bool operator==(const EncodingCounters& ec1, const EncodingCounters& ec2);
550
552template <typename T> EXPORTISMRMRD ISMRMRD_DataTypes get_data_type();
553
555class EXPORTISMRMRD FlagBit
556{
557public:
558 FlagBit(unsigned short b)
559 : bitmask_(0)
560 {
561 if (b > 0) {
562 bitmask_ = 1;
563 bitmask_ = (bitmask_ << (b-1));
564 }
565 }
566
567 bool isSet(const uint64_t& m) const {
568 return ((m & bitmask_)>0);
569 }
570
571 uint64_t bitmask_;
572
573};
574
576class EXPORTISMRMRD AcquisitionHeader: public ISMRMRD_AcquisitionHeader {
577public:
578 // Constructors
580
581
582 bool operator==(const AcquisitionHeader& acq) const;
583
584 // Flag methods
585 bool isFlagSet(const ISMRMRD_AcquisitionFlags val) const;
586 void setFlag(const ISMRMRD_AcquisitionFlags val);
587 void clearFlag(const ISMRMRD_AcquisitionFlags val);
588 void clearAllFlags();
589
590 // Channel mask methods
591 bool isChannelActive(uint16_t channel_id) const;
592 void setChannelActive(uint16_t channel_id);
593 void setChannelNotActive(uint16_t channel_id);
594 void setAllChannelsNotActive();
595
596};
597
598#if __cplusplus > 199711L // Static assert and is_standard_layout requires C++11
599static_assert(sizeof(AcquisitionHeader) == sizeof(ISMRMRD_AcquisitionHeader), "AcquisitionHeader size mismatch");
600static_assert(std::is_standard_layout<AcquisitionHeader>::value, "AcquisitionHeader is not a standard layout type");
601#endif
602
604class EXPORTISMRMRD Acquisition {
605 friend class Dataset;
606public:
607 // Constructors, assignment, destructor
608 Acquisition();
609 Acquisition(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
610 Acquisition(const Acquisition &other);
611 Acquisition & operator= (const Acquisition &other);
612 ~Acquisition();
613
614 // Accessors and mutators
615 uint16_t version() const;
616 uint64_t flags() const;
617 uint32_t &measurement_uid();
618 uint32_t &scan_counter();
619 uint32_t &acquisition_time_stamp();
620 uint32_t (&physiology_time_stamp())[ISMRMRD_PHYS_STAMPS];
621 const uint16_t &number_of_samples();
622 uint16_t &available_channels();
623 const uint16_t &active_channels();
624 const uint64_t (&channel_mask())[ISMRMRD_CHANNEL_MASKS];
625 uint16_t &discard_pre();
626 uint16_t &discard_post();
627 uint16_t &center_sample();
628 uint16_t &encoding_space_ref();
629 const uint16_t &trajectory_dimensions();
630 float &sample_time_us();
631 float (&position())[3];
632 float (&read_dir())[3];
633 float (&phase_dir())[3];
634 float (&slice_dir())[3];
635 float (&patient_table_position())[3];
637 int32_t (&user_int())[ISMRMRD_USER_INTS];
638 float (&user_float())[ISMRMRD_USER_FLOATS];
639
640
641 uint32_t measurement_uid() const;
642 uint32_t scan_counter() const;
643 uint32_t acquisition_time_stamp() const;
644 const uint32_t (&physiology_time_stamp() const )[ISMRMRD_PHYS_STAMPS];
645 uint16_t number_of_samples() const;
646 uint16_t available_channels() const;
647 uint16_t active_channels() const;
648 const uint64_t (&channel_mask() const)[ISMRMRD_CHANNEL_MASKS];
649 uint16_t discard_pre() const;
650 uint16_t discard_post() const;
651 uint16_t center_sample() const;
652 uint16_t encoding_space_ref() const;
653 uint16_t trajectory_dimensions() const;
654 float sample_time_us() const;
655 const float (&position() const)[3];
656 const float (&read_dir() const)[3];
657 const float (&phase_dir() const)[3];
658 const float (&slice_dir() const)[3];
659 const float (&patient_table_position() const)[3];
660 const ISMRMRD_EncodingCounters &idx() const;
661 const int32_t (&user_int() const)[ISMRMRD_USER_INTS];
662 const float (&user_float() const)[ISMRMRD_USER_FLOATS];
663
664 // Sizes
665 void resize(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
666 size_t getNumberOfDataElements() const;
667 size_t getNumberOfTrajElements() const;
668 size_t getDataSize() const;
669 size_t getTrajSize() const;
670
671 // Header, data and trajectory accessors
672 const AcquisitionHeader &getHead() const;
673 void setHead(const AcquisitionHeader &other);
674
678 const complex_float_t * getDataPtr() const;
679 complex_float_t * getDataPtr();
680
684 complex_float_t & data(uint16_t sample, uint16_t channel);
685
689 void setData(complex_float_t * data);
690
694 complex_float_t * data_begin();
695 const complex_float_t * data_begin() const;
696
700 complex_float_t * data_end();
701 const complex_float_t * data_end() const;
702
706 const float * getTrajPtr() const;
707 float * getTrajPtr();
708
712 float & traj(uint16_t dimension, uint16_t sample);
713
717 void setTraj(float * traj);
718
722 float * traj_begin();
723 const float * traj_begin() const;
724
728 float * traj_end();
729 const float * traj_end() const;
730
731 // Flag methods
732 bool isFlagSet(const uint64_t val) const;
733 void setFlag(const uint64_t val);
734 void clearFlag(const uint64_t val);
735 void clearAllFlags();
736
737 bool isFlagSet(const FlagBit &val) const { return isFlagSet(val.bitmask_); }
738 void setFlag(const FlagBit &val) { setFlag(val.bitmask_); }
739 void clearFlag(const FlagBit &val) { clearFlag(val.bitmask_); }
740
741 // Channel mask methods
742 bool isChannelActive(uint16_t channel_id) const;
743 void setChannelActive(uint16_t channel_id);
744 void setChannelNotActive(uint16_t channel_id);
745 void setAllChannelsNotActive();
746
747protected:
749};
750
752class EXPORTISMRMRD ImageHeader: public ISMRMRD_ImageHeader {
753public:
754 // Constructor
755 ImageHeader();
756
757 // Flag methods
758 bool isFlagSet(const uint64_t val) const;
759 void setFlag(const uint64_t val);
760 void clearFlag(const uint64_t val);
761 void clearAllFlags();
762
763};
764
765#if __cplusplus > 199711L // Static assert and is_standard_layout requires C++11
766static_assert(sizeof(ImageHeader) == sizeof(ISMRMRD_ImageHeader), "ImageHeader size mismatch");
767static_assert(std::is_standard_layout<ImageHeader>::value, "ImageHeader is not a standard layout type");
768#endif
769
771template <typename T> class EXPORTISMRMRD Image {
772 friend class Dataset;
773public:
774 // Constructors
775 Image(uint16_t matrix_size_x = 0, uint16_t matrix_size_y = 1,
776 uint16_t matrix_size_z = 1, uint16_t channels = 1);
777 Image(const Image &other);
778 Image & operator= (const Image &other);
779 ~Image();
780
781 // Image dimensions
782 void resize(uint16_t matrix_size_x, uint16_t matrix_size_y, uint16_t matrix_size_z, uint16_t channels);
783 uint16_t getMatrixSizeX() const;
784 void setMatrixSizeX(uint16_t matrix_size_x);
785 uint16_t getMatrixSizeY() const;
786 void setMatrixSizeY(uint16_t matrix_size_y);
787 uint16_t getMatrixSizeZ() const;
788 void setMatrixSizeZ(uint16_t matrix_size_z);
789 uint16_t getNumberOfChannels() const;
790 void setNumberOfChannels(uint16_t channels);
791
792 // Field of view
793 void setFieldOfView(float fov_x, float fov_y, float fov_z);
794 float getFieldOfViewX() const;
795 void setFieldOfViewX(float f);
796 float getFieldOfViewY() const;
797 void setFieldOfViewY(float f);
798 float getFieldOfViewZ() const;
799 void setFieldOfViewZ(float f);
800
801 // Positions and orientations
802 void setPosition(float x, float y, float z);
803 float getPositionX() const;
804 void setPositionX(float x);
805 float getPositionY() const;
806 void setPositionY(float y);
807 float getPositionZ() const;
808 void setPositionZ(float z);
809
810 void setReadDirection(float x, float y, float z);
811 float getReadDirectionX() const;
812 void setReadDirectionX(float x);
813 float getReadDirectionY() const;
814 void setReadDirectionY(float y);
815 float getReadDirectionZ() const;
816 void setReadDirectionZ(float z);
817
818 void setPhaseDirection(float x, float y, float z);
819 float getPhaseDirectionX() const;
820 void setPhaseDirectionX(float x);
821 float getPhaseDirectionY() const;
822 void setPhaseDirectionY(float y);
823 float getPhaseDirectionZ() const;
824 void setPhaseDirectionZ(float z);
825
826 void setSliceDirection(float x, float y, float z);
827 float getSliceDirectionX() const;
828 void setSliceDirectionX(float x);
829 float getSliceDirectionY() const;
830 void setSliceDirectionY(float y);
831 float getSliceDirectionZ() const;
832 void setSliceDirectionZ(float z);
833
834 void setPatientTablePosition(float x, float y, float z);
835 float getPatientTablePositionX() const;
836 void setPatientTablePositionX(float x);
837 float getPatientTablePositionY() const;
838 void setPatientTablePositionY(float y);
839 float getPatientTablePositionZ() const;
840 void setPatientTablePositionZ(float z);
841
842
843 // Attributes
844 uint16_t getVersion() const;
845 ISMRMRD_DataTypes getDataType() const;
846
847 // Counters and labels
848 uint32_t getMeasurementUid() const;
849 void setMeasurementUid(uint32_t measurement_uid);
850
851 uint16_t getAverage() const;
852 void setAverage(uint16_t average);
853
854 uint16_t getSlice() const;
855 void setSlice(uint16_t slice);
856
857 uint16_t getContrast() const;
858 void setContrast(uint16_t contrast);
859
860 uint16_t getPhase() const;
861 void setPhase(uint16_t phase);
862
863 uint16_t getRepetition() const;
864 void setRepetition(uint16_t repetition);
865
866 uint16_t getSet() const;
867 void setSet(uint16_t set);
868
869 uint32_t getAcquisitionTimeStamp() const;
870 void setAcquisitionTimeStamp(uint32_t acquisition_time_stamp);
871
872 uint32_t getPhysiologyTimeStamp(unsigned int stamp_id) const;
873 void setPhysiologyTimeStamp(unsigned int stamp_id, uint32_t value);
874
875 uint16_t getImageType() const;
876 void setImageType(uint16_t image_type);
877
878 uint16_t getImageIndex() const;
879 void setImageIndex(uint16_t image_index);
880
881 uint16_t getImageSeriesIndex() const;
882 void setImageSeriesIndex(uint16_t image_series_index);
883
884 // User parameters
885 float getUserFloat(unsigned int index) const;
886 void setUserFloat(unsigned int index, float value);
887
888 int32_t getUserInt(unsigned int index) const;
889 void setUserInt(unsigned int index, int32_t value);
890
891 // Flags
892 uint64_t getFlags() const;
893 void setFlags(const uint64_t flags);
894 bool isFlagSet(const uint64_t val) const;
895 void setFlag(const uint64_t val);
896 void clearFlag(const uint64_t val);
897 void clearAllFlags();
898
899 // Header
900 ImageHeader & getHead();
901 const ImageHeader & getHead() const;
902 void setHead(const ImageHeader& head);
903
904 // Attribute string
905 void getAttributeString(std::string &attr) const;
906 const char *getAttributeString() const;
907 void setAttributeString(const std::string &attr);
908 void setAttributeString(const char *attr);
909 size_t getAttributeStringLength() const;
910
911 // Data
912 T * getDataPtr();
913 const T * getDataPtr() const;
915 size_t getNumberOfDataElements() const;
917 size_t getDataSize() const;
918
920 T* begin();
921
923 T* end();
924
926 T & operator () (uint16_t x, uint16_t y=0, uint16_t z=0 , uint16_t channel =0);
927
928protected:
929 ISMRMRD_Image im;
930};
931
933template <typename T> class EXPORTISMRMRD NDArray {
934 friend class Dataset;
935public:
936 // Constructors, destructor and copy
937 NDArray();
938 NDArray(const std::vector<size_t> dimvec);
939 NDArray(const NDArray<T> &other);
940 ~NDArray();
941 NDArray<T> & operator= (const NDArray<T> &other);
942
943 // Accessors and mutators
944 uint16_t getVersion() const;
945 ISMRMRD_DataTypes getDataType() const;
946 uint16_t getNDim() const;
947 const size_t (&getDims())[ISMRMRD_NDARRAY_MAXDIM];
948 size_t getDataSize() const;
949 void resize(const std::vector<size_t> dimvec);
950 size_t getNumberOfElements() const;
951 T * getDataPtr();
952 const T * getDataPtr() const;
953
955 T * begin();
956
958 T* end();
959
961 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);
962
963protected:
964 ISMRMRD_NDArray arr;
965};
966
967
970} // namespace ISMRMRD
971
972#endif
973
974#endif /* ISMRMRD_H */
Header for MR Acquisition type.
Definition ismrmrd.h:576
MR Acquisition type.
Definition ismrmrd.h:604
Definition dataset.h:162
Convenience class for flags.
Definition ismrmrd.h:556
Header for MR Image type.
Definition ismrmrd.h:752
MR Image type.
Definition ismrmrd.h:771
N-Dimensional array type.
Definition ismrmrd.h:933
EXPORTISMRMRD void ismrmrd_set_error_handler(ismrmrd_error_handler_t)
Definition ismrmrd.c:750
EXPORTISMRMRD int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr)
Definition ismrmrd.c:42
EXPORTISMRMRD const char * ismrmrd_strerror(int code)
Definition ismrmrd.c:754
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:594
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:668
int ismrmrd_push_error(const char *file, const int line, const char *func, const int code, const char *msg)
Definition ismrmrd.c:689
EXPORTISMRMRD int ismrmrd_sign_of_directions(float const read_dir[3], float const phase_dir[3], float const slice_dir[3])
Definition ismrmrd.c:578
EXPORTISMRMRD ISMRMRD_DataTypes get_data_type()
Allowed data types for Images and NDArrays.
ISMRMRD_ImageFlags
Definition ismrmrd.h:198
ISMRMRD_ErrorCodes
Definition ismrmrd.h:105
std::string build_exception_string(void)
ISMRMRD C++ Interface.
Definition ismrmrd.cpp:1340
ISMRMRD_AcquisitionFlags
Definition ismrmrd.h:136
ISMRMRD_Constants
Definition ismrmrd.h:91
ISMRMRD_DataTypes
Definition ismrmrd.h:119
@ ISMRMRD_INT
Definition ismrmrd.h:123
@ ISMRMRD_DOUBLE
Definition ismrmrd.h:125
@ ISMRMRD_CXDOUBLE
Definition ismrmrd.h:127
@ ISMRMRD_UINT
Definition ismrmrd.h:122
@ ISMRMRD_CXFLOAT
Definition ismrmrd.h:126
@ ISMRMRD_FLOAT
Definition ismrmrd.h:124
@ ISMRMRD_USHORT
Definition ismrmrd.h:120
@ ISMRMRD_SHORT
Definition ismrmrd.h:121
ISMRMRD_ImageTypes
Definition ismrmrd.h:187
Definition ismrmrd.h:258
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition ismrmrd.h:264
float phase_dir[3]
Definition ismrmrd.h:277
uint32_t measurement_uid
Definition ismrmrd.h:261
ISMRMRD_EncodingCounters idx
Definition ismrmrd.h:280
uint32_t acquisition_time_stamp
Definition ismrmrd.h:263
uint64_t flags
Definition ismrmrd.h:260
int32_t user_int[ISMRMRD_USER_INTS]
Definition ismrmrd.h:281
uint16_t encoding_space_ref
Definition ismrmrd.h:272
uint16_t trajectory_dimensions
Definition ismrmrd.h:273
uint16_t available_channels
Definition ismrmrd.h:266
float slice_dir[3]
Definition ismrmrd.h:278
float position[3]
Definition ismrmrd.h:275
float user_float[ISMRMRD_USER_FLOATS]
Definition ismrmrd.h:282
uint16_t discard_post
Definition ismrmrd.h:270
uint16_t center_sample
Definition ismrmrd.h:271
float patient_table_position[3]
Definition ismrmrd.h:279
uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS]
Definition ismrmrd.h:268
float read_dir[3]
Definition ismrmrd.h:276
uint32_t scan_counter
Definition ismrmrd.h:262
uint16_t number_of_samples
Definition ismrmrd.h:265
float sample_time_us
Definition ismrmrd.h:274
uint16_t version
Definition ismrmrd.h:259
uint16_t discard_pre
Definition ismrmrd.h:269
uint16_t active_channels
Definition ismrmrd.h:267
Definition ismrmrd.h:324
ISMRMRD_AcquisitionHeader head
Definition ismrmrd.h:325
Definition ismrmrd.h:225
uint16_t average
Definition ismrmrd.h:228
uint16_t repetition
Definition ismrmrd.h:232
uint16_t segment
Definition ismrmrd.h:234
uint16_t kspace_encode_step_1
Definition ismrmrd.h:226
uint16_t kspace_encode_step_2
Definition ismrmrd.h:227
uint16_t phase
Definition ismrmrd.h:231
uint16_t user[ISMRMRD_USER_INTS]
Definition ismrmrd.h:235
uint16_t set
Definition ismrmrd.h:233
uint16_t contrast
Definition ismrmrd.h:230
uint16_t slice
Definition ismrmrd.h:229
Definition ismrmrd.h:350
uint16_t data_type
Definition ismrmrd.h:352
uint16_t set
Definition ismrmrd.h:368
int32_t user_int[ISMRMRD_USER_INTS]
Definition ismrmrd.h:374
uint16_t phase
Definition ismrmrd.h:366
uint16_t slice
Definition ismrmrd.h:364
uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS]
Definition ismrmrd.h:370
uint16_t image_type
Definition ismrmrd.h:371
uint16_t version
Definition ismrmrd.h:351
uint16_t matrix_size[3]
Definition ismrmrd.h:355
uint16_t image_index
Definition ismrmrd.h:372
float patient_table_position[3]
Definition ismrmrd.h:362
uint16_t channels
Definition ismrmrd.h:357
float phase_dir[3]
Definition ismrmrd.h:360
uint16_t repetition
Definition ismrmrd.h:367
float position[3]
Definition ismrmrd.h:358
float read_dir[3]
Definition ismrmrd.h:359
uint32_t acquisition_time_stamp
Definition ismrmrd.h:369
float field_of_view[3]
Definition ismrmrd.h:356
float user_float[ISMRMRD_USER_FLOATS]
Definition ismrmrd.h:375
uint64_t flags
Definition ismrmrd.h:353
uint16_t image_series_index
Definition ismrmrd.h:373
uint32_t attribute_string_len
Definition ismrmrd.h:376
float slice_dir[3]
Definition ismrmrd.h:361
uint16_t contrast
Definition ismrmrd.h:365
uint32_t measurement_uid
Definition ismrmrd.h:354
uint16_t average
Definition ismrmrd.h:363
Definition ismrmrd.h:419
Definition ismrmrd.h:446
size_t dims[ISMRMRD_NDARRAY_MAXDIM]
Definition ismrmrd.h:450
uint16_t version
Definition ismrmrd.h:447
void * data
Definition ismrmrd.h:451
uint16_t ndim
Definition ismrmrd.h:449
uint16_t data_type
Definition ismrmrd.h:448