[med-svn] [ismrmrd] 01/04: Imported Upstream version 1.2.3
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Tue Mar 10 17:04:17 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository ismrmrd.
commit 766b60a3e32f4c91ac28d40e8947381546ea47cf
Author: Ghislain Antony Vaillant <ghisvail at gmail.com>
Date: Tue Mar 10 11:40:31 2015 +0000
Imported Upstream version 1.2.3
---
CMakeLists.txt | 2 +-
bindings/python/.gitignore | 6 -
bindings/python/MANIFEST.in | 3 -
bindings/python/Makefile | 14 -
bindings/python/README | 1 -
bindings/python/cismrmrd.pxd | 256 --------
bindings/python/demo.py | 11 -
bindings/python/ismrmrd.pyx | 874 ---------------------------
bindings/python/setup.py | 62 --
cmake/ismrmrd_cpack.cmake | 5 +
doc/source/index.rst | 1 +
examples/c/main.c | 2 +
examples/python/ismrmrd_recon_dataset.py | 141 +++--
include/ismrmrd/ismrmrd.h | 44 +-
libsrc/dataset.c | 235 ++++---
libsrc/ismrmrd.c | 26 +-
libsrc/ismrmrd.cpp | 96 ++-
libsrc/xml.cpp | 6 +-
utilities/CMakeLists.txt | 2 +-
utilities/generate_cartesian_shepp_logan.cpp | 6 +-
20 files changed, 342 insertions(+), 1451 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 91e8b9f..a8c27f2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,7 +51,7 @@ endif (WIN32)
#in the utility libraries, that don't affect the data format itself.
set(ISMRMRD_VERSION_MAJOR 1)
set(ISMRMRD_VERSION_MINOR 2)
-set(ISMRMRD_VERSION_PATCH 1)
+set(ISMRMRD_VERSION_PATCH 3)
set(ISMRMRD_XML_SCHEMA_SHA1 "99a63f4e8cf08ffc268f5ee8b8c8b2a1edf69412")
diff --git a/bindings/python/.gitignore b/bindings/python/.gitignore
deleted file mode 100644
index 3c8fb3c..0000000
--- a/bindings/python/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-ismrmrd.c
-*.so
-*.h5
-MANIFEST
-build/
-dist/
diff --git a/bindings/python/MANIFEST.in b/bindings/python/MANIFEST.in
deleted file mode 100644
index 2d19b01..0000000
--- a/bindings/python/MANIFEST.in
+++ /dev/null
@@ -1,3 +0,0 @@
-cismrmrd.pxd
-ismrmrd.pyx
-setup.py
diff --git a/bindings/python/Makefile b/bindings/python/Makefile
deleted file mode 100644
index d88609c..0000000
--- a/bindings/python/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-ISMRMRD_HOME ?= /usr/local
-
-CPPFLAGS = -I$(ISMRMRD_HOME)/include
-LDFLAGS = -L$(ISMRMRD_HOME)/lib
-
-ismrmrd.so: ismrmrd.pyx cismrmrd.pxd setup.py
- python setup.py build_ext -i
-
-install: ismrmrd.so
- install -d $(ISMRMRD_HOME)/python
- install $< $(ISMRMRD_HOME)/python/
-
-clean:
- rm ismrmrd.c ismrmrd.so
diff --git a/bindings/python/README b/bindings/python/README
deleted file mode 100644
index 8e39585..0000000
--- a/bindings/python/README
+++ /dev/null
@@ -1 +0,0 @@
-Python bindings to ISMRMRD
diff --git a/bindings/python/cismrmrd.pxd b/bindings/python/cismrmrd.pxd
deleted file mode 100644
index cec67a7..0000000
--- a/bindings/python/cismrmrd.pxd
+++ /dev/null
@@ -1,256 +0,0 @@
-from libc.stdint cimport uint16_t, uint32_t, uint64_t, int32_t
-
-cdef extern from "ismrmrd/version.h":
- cdef enum:
- ISMRMRD_VERSION_MAJOR = 1
- ISMRMRD_VERSION_MINOR = 1
- ISMRMRD_VERSION_PATCH = 0
- ISMRMRD_XMLHDR_VERSION = 1
-
-cdef extern from "ismrmrd/ismrmrd.h":
- cdef enum:
- ISMRMRD_USER_INTS = 8
- ISMRMRD_USER_FLOATS = 8
- ISMRMRD_PHYS_STAMPS = 3
- ISMRMRD_CHANNEL_MASKS = 16
- ISMRMRD_NDARRAY_MAXDIM = 7
- ISMRMRD_POSITION_LENGTH = 3
- ISMRMRD_DIRECTION_LENGTH = 3
-
- ctypedef enum ISMRMRD_ErrorCodes:
- ISMRMRD_BEGINERROR
- ISMRMRD_NOERROR
- ISMRMRD_MEMORYERROR
- ISMRMRD_FILEERROR
- ISMRMRD_TYPEERROR
- ISMRMRD_RUNTIMEERROR
- ISMRMRD_HDF5ERROR
- ISMRMRD_ENDERROR
-
- cdef bint ismrmrd_pop_error(char**, int*, char**, int*, char**)
- char* ismrmrd_strerror(int)
-
- ctypedef struct ISMRMRD_EncodingCounters:
- uint16_t kspace_encode_step_1 # e.g. phase encoding line number
- uint16_t kspace_encode_step_2 # e.g. partition encodning number
- uint16_t average # e.g. signal average number
- uint16_t slice # e.g. imaging slice number
- uint16_t contrast # e.g. echo number in multi-echo
- uint16_t phase # e.g. cardiac phase number
- uint16_t repetition # e.g. dynamic number for dynamic scanning
- uint16_t set # e.g. flow encodning set
- uint16_t segment # e.g. segment number for segmented acquisition
- uint16_t user[ISMRMRD_USER_INTS] # Free user parameters
-
- cdef enum ISMRMRD_AcquisitionFlags:
- ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP1
- ISMRMRD_ACQ_LAST_IN_ENCODE_STEP1
- ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP2
- ISMRMRD_ACQ_LAST_IN_ENCODE_STEP2
- ISMRMRD_ACQ_FIRST_IN_AVERAGE
- ISMRMRD_ACQ_LAST_IN_AVERAGE
- ISMRMRD_ACQ_FIRST_IN_SLICE
- ISMRMRD_ACQ_LAST_IN_SLICE
- ISMRMRD_ACQ_FIRST_IN_CONTRAST
- ISMRMRD_ACQ_LAST_IN_CONTRAST
- ISMRMRD_ACQ_FIRST_IN_PHASE
- ISMRMRD_ACQ_LAST_IN_PHASE
- ISMRMRD_ACQ_FIRST_IN_REPETITION
- ISMRMRD_ACQ_LAST_IN_REPETITION
- ISMRMRD_ACQ_FIRST_IN_SET
- ISMRMRD_ACQ_LAST_IN_SET
- ISMRMRD_ACQ_FIRST_IN_SEGMENT
- ISMRMRD_ACQ_LAST_IN_SEGMENT
- ISMRMRD_ACQ_IS_NOISE_MEASUREMENT
- ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION
- ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING
- ISMRMRD_ACQ_IS_REVERSE
- ISMRMRD_ACQ_IS_NAVIGATION_DATA
- ISMRMRD_ACQ_IS_PHASECORR_DATA
- ISMRMRD_ACQ_LAST_IN_MEASUREMENT
- ISMRMRD_ACQ_IS_HPFEEDBACK_DATA
- ISMRMRD_ACQ_IS_DUMMYSCAN_DATA
- ISMRMRD_ACQ_IS_RTFEEDBACK_DATA
- ISMRMRD_ACQ_IS_SURFACECOILCORRECTIONSCAN_DATA
- ISMRMRD_ACQ_USER1
- ISMRMRD_ACQ_USER2
- ISMRMRD_ACQ_USER3
- ISMRMRD_ACQ_USER4
- ISMRMRD_ACQ_USER5
- ISMRMRD_ACQ_USER6
- ISMRMRD_ACQ_USER7
- ISMRMRD_ACQ_USER8
-
- ctypedef struct ISMRMRD_AcquisitionHeader:
- uint16_t version # First unsigned int indicates the version
- uint64_t flags # bit field with flags
- uint32_t measurement_uid # Unique ID for the measurement
- uint32_t scan_counter # Current acquisition number in the measurement
- uint32_t acquisition_time_stamp # Acquisition clock
- uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS] # Physiology time stamps, e.g. ecg, breating, etc.
- uint16_t number_of_samples # Number of samples acquired
- uint16_t available_channels # Available coils
- uint16_t active_channels # Active coils on current acquisiton
- uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS] # Mask to indicate which channels are active. Support for 1024 channels
- uint16_t discard_pre # Samples to be discarded at the beginning of acquisition
- uint16_t discard_post # Samples to be discarded at the end of acquisition
- uint16_t center_sample # Sample at the center of k-space
- uint16_t encoding_space_ref # Reference to an encoding space, typically only one per acquisition
- uint16_t trajectory_dimensions # Indicates the dimensionality of the trajectory vector (0 means no trajectory)
- float sample_time_us # Time between samples in micro seconds, sampling BW
- float position[ISMRMRD_POSITION_LENGTH] # Three-dimensional spatial offsets from isocenter
- float read_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the readout/frequency encoding
- float phase_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the phase
- float slice_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the slice direction
- float patient_table_position[ISMRMRD_POSITION_LENGTH] # Patient table off-center
- ISMRMRD_EncodingCounters idx # Encoding loop counters, see above
- int32_t user_int[ISMRMRD_USER_INTS] # Free user parameters
- float user_float[ISMRMRD_USER_FLOATS] # Free user parameters
-
- ctypedef struct ISMRMRD_Acquisition:
- ISMRMRD_AcquisitionHeader head
- float *traj
- float complex *data
-
- cdef int ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr)
- cdef ISMRMRD_Acquisition * ismrmrd_create_acquisition()
- cdef int ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq)
- cdef int ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq)
- cdef int ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq)
- cdef int ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource)
- cdef int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq)
- cdef size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq)
- cdef size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq)
-
-
- cdef enum ISMRMRD_ImageDataTypes:
- ISMRMRD_USHORT = 1 # corresponds to uint16_t
- ISMRMRD_SHORT # corresponds to int16_t
- ISMRMRD_UINT # corresponds to uint32_t
- ISMRMRD_INT # corresponds to int32_t
- ISMRMRD_FLOAT # corresponds to float
- ISMRMRD_DOUBLE # corresponds to double
- ISMRMRD_CXFLOAT # corresponds to complex float
- ISMRMRD_CXDOUBLE # corresponds to complex double
-
- cdef size_t ismrmrd_sizeof_data_type(int data_type)
-
- cdef enum ISMRMRD_ImageTypes:
- ISMRMRD_IMTYPE_MAGNITUDE = 1
- ISMRMRD_IMTYPE_PHASE
- ISMRMRD_IMTYPE_REAL
- ISMRMRD_IMTYPE_IMAG
- ISMRMRD_IMTYPE_COMPLEX
-
- # IMAGE FLAGS
- cdef enum ISMRMRD_ImageFlags:
- ISMRMRD_IMAGE_IS_NAVIGATION_DATA = 1 # used to be 23?
- ISMRMRD_IMAGE_USER1 = 57
- ISMRMRD_IMAGE_USER2 = 58
- ISMRMRD_IMAGE_USER3 = 59
- ISMRMRD_IMAGE_USER4 = 60
- ISMRMRD_IMAGE_USER5 = 61
- ISMRMRD_IMAGE_USER6 = 62
- ISMRMRD_IMAGE_USER7 = 63
- ISMRMRD_IMAGE_USER8 = 64
-
- ctypedef struct ISMRMRD_ImageHeader:
- uint16_t version # First unsigned int indicates the version
- uint16_t data_type # e.g. unsigned short, float, complex float, etc.
- uint64_t flags # bit field with flags
- uint32_t measurement_uid # Unique ID for the measurement
- uint16_t matrix_size[3] # Pixels in the 3 spatial dimensions
- float field_of_view[3] # Size (in mm) of the 3 spatial dimensions
- uint16_t channels # Number of receive channels
- float position[ISMRMRD_POSITION_LENGTH] # Three-dimensional spatial offsets from isocenter
- float read_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the readout/frequency encoding
- float phase_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the phase
- float slice_dir[ISMRMRD_DIRECTION_LENGTH] # Directional cosines of the slice direction
- float patient_table_position[ISMRMRD_POSITION_LENGTH] # Patient table off-center
- uint16_t average # e.g. signal average number
- uint16_t slice # e.g. imaging slice number
- uint16_t contrast # e.g. echo number in multi-echo
- uint16_t phase # e.g. cardiac phase number
- uint16_t repetition # e.g. dynamic number for dynamic scanning
- uint16_t set # e.g. flow encodning set
- uint32_t acquisition_time_stamp # Acquisition clock
- uint32_t physiology_time_stamp[ISMRMRD_PHYS_STAMPS] # Physiology time stamps, e.g. ecg, breating, etc.
- uint16_t image_type # e.g. magnitude, phase, complex, real, imag, etc.
- uint16_t image_index # e.g. image number in series of images
- uint16_t image_series_index # e.g. series number
- int32_t user_int[ISMRMRD_USER_INTS] # Free user parameters
- float user_float[ISMRMRD_USER_FLOATS] # Free user parameters
- uint32_t attribute_string_len # Length of attributes string
-
- ctypedef struct ISMRMRD_Image:
- ISMRMRD_ImageHeader head
- char *attribute_string
- void *data
-
- cdef int ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr)
- cdef ISMRMRD_Image * ismrmrd_create_image()
- cdef int ismrmrd_free_image(ISMRMRD_Image *im)
- cdef int ismrmrd_init_image(ISMRMRD_Image *im)
- cdef int ismrmrd_cleanup_image(ISMRMRD_Image *im)
- cdef int ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource)
- cdef int ismrmrd_make_consistent_image(ISMRMRD_Image *im)
- cdef size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im)
- cdef size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im)
-
-
- ctypedef struct ISMRMRD_NDArray:
- uint16_t version # First unsigned int indicates the version
- uint16_t data_type # e.g. unsigned short, float, complex float, etc.
- uint16_t ndim # Number of dimensions
- uint16_t dims[ISMRMRD_NDARRAY_MAXDIM] # Dimensions
- void *data # Pointer to data
-
- cdef ISMRMRD_NDArray * ismrmrd_create_ndarray()
- cdef int ismrmrd_free_ndarray(ISMRMRD_NDArray *arr)
- cdef int ismrmrd_init_ndarray(ISMRMRD_NDArray *arr)
- cdef int ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr)
- cdef int ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource)
- cdef int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr)
- cdef size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr)
-
-
- cdef bint ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val)
- cdef int ismrmrd_set_flag(uint64_t *flags, const uint64_t val)
- cdef int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val)
- cdef int ismrmrd_clear_all_flags(uint64_t *flags)
-
- cdef int ismrmrd_sign_of_directions(float read_dir[3],
- float phase_dir[3], float slice_dir[3])
- cdef void ismrmrd_directions_to_quaternion(float read_dir[3],
- float phase_dir[3], float slice_dir[3], float quat[4])
- cdef void ismrmrd_quaternion_to_directions(float quat[4],
- float read_dir[3], float phase_dir[3], float slice_dir[3])
-
-cdef extern from "ismrmrd/dataset.h":
- ctypedef struct ISMRMRD_Dataset:
- char *filename
- char *groupname
- int fileid
-
- cdef int ismrmrd_init_dataset(ISMRMRD_Dataset*, const char*, const char*)
- cdef int ismrmrd_open_dataset(ISMRMRD_Dataset*, const bint)
- cdef int ismrmrd_close_dataset(ISMRMRD_Dataset*)
- cdef char *ismrmrd_read_header(const ISMRMRD_Dataset *)
- cdef int ismrmrd_write_header(ISMRMRD_Dataset *, const char *)
- cdef uint32_t ismrmrd_get_number_of_acquisitions(const ISMRMRD_Dataset*)
- cdef int ismrmrd_append_acquisition(ISMRMRD_Dataset *,
- const ISMRMRD_Acquisition *)
- cdef int ismrmrd_read_acquisition(const ISMRMRD_Dataset *, uint32_t,
- ISMRMRD_Acquisition *)
- cdef uint32_t ismrmrd_get_number_of_images(const ISMRMRD_Dataset *,
- const char *)
- cdef int ismrmrd_append_image(ISMRMRD_Dataset *, const char *,
- const ISMRMRD_Image *)
- cdef int ismrmrd_read_image(const ISMRMRD_Dataset *, const char *,
- const uint32_t, ISMRMRD_Image *)
- cdef uint32_t ismrmrd_get_number_of_arrays(const ISMRMRD_Dataset *,
- const char *)
- cdef int ismrmrd_append_array(ISMRMRD_Dataset *dset, const char *,
- const ISMRMRD_NDArray *)
- cdef int ismrmrd_read_array(const ISMRMRD_Dataset *, const char *,
- const uint32_t, ISMRMRD_NDArray *)
diff --git a/bindings/python/demo.py b/bindings/python/demo.py
deleted file mode 100644
index 8ce439b..0000000
--- a/bindings/python/demo.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import ismrmrd
-
-acq = ismrmrd.Acquisition()
-acq.head.version = 42
-print(acq.head.version)
-
-img = ismrmrd.Image()
-
-f = ismrmrd.Dataset('./testdata.h5', '/dataset', True)
-print f.filename
-# xml = f.readHeader()
diff --git a/bindings/python/ismrmrd.pyx b/bindings/python/ismrmrd.pyx
deleted file mode 100644
index aae774a..0000000
--- a/bindings/python/ismrmrd.pyx
+++ /dev/null
@@ -1,874 +0,0 @@
-cimport cismrmrd
-from libc.stdlib cimport calloc, free
-from libc.string cimport memcpy
-
-# required for PyArray* functions and dtypes
-import numpy
-cimport numpy
-numpy.import_array()
-
-# conversion table between ISMRMRD and Numpy dtypes
-cdef dict ismrmrd_to_numpy_typenums_dict = {
- cismrmrd.ISMRMRD_USHORT: numpy.NPY_UINT16,
- cismrmrd.ISMRMRD_SHORT: numpy.NPY_INT16,
- cismrmrd.ISMRMRD_UINT: numpy.NPY_UINT32,
- cismrmrd.ISMRMRD_INT: numpy.NPY_INT32,
- cismrmrd.ISMRMRD_FLOAT: numpy.NPY_FLOAT32,
- cismrmrd.ISMRMRD_DOUBLE: numpy.NPY_FLOAT64,
- cismrmrd.ISMRMRD_CXFLOAT: numpy.NPY_COMPLEX64,
- cismrmrd.ISMRMRD_CXDOUBLE: numpy.NPY_COMPLEX128,
-}
-
-cdef dict numpy_dtype_to_ismrmrd_typenum = {
- numpy.uint16: cismrmrd.ISMRMRD_USHORT,
- numpy.int16: cismrmrd.ISMRMRD_SHORT,
- numpy.uint32: cismrmrd.ISMRMRD_UINT,
- numpy.int32: cismrmrd.ISMRMRD_INT,
- numpy.float32: cismrmrd.ISMRMRD_FLOAT,
- numpy.float64: cismrmrd.ISMRMRD_DOUBLE,
- numpy.complex64: cismrmrd.ISMRMRD_CXFLOAT,
- numpy.complex128: cismrmrd.ISMRMRD_CXDOUBLE,
-}
-
-cdef dict ismrmrd_typenum_to_numpy_dtype = {
- cismrmrd.ISMRMRD_USHORT: numpy.uint16,
- cismrmrd.ISMRMRD_SHORT: numpy.int16,
- cismrmrd.ISMRMRD_UINT: numpy.uint32,
- cismrmrd.ISMRMRD_INT: numpy.int32,
- cismrmrd.ISMRMRD_FLOAT: numpy.float32,
- cismrmrd.ISMRMRD_DOUBLE: numpy.float64,
- cismrmrd.ISMRMRD_CXFLOAT: numpy.complex64,
- cismrmrd.ISMRMRD_CXDOUBLE: numpy.complex128,
-}
-
-# Expose ISMRMRD constants to python
-VERSION_MAJOR = cismrmrd.ISMRMRD_VERSION_MAJOR
-VERSION_MINOR = cismrmrd.ISMRMRD_VERSION_MINOR
-VERSION_PATCH = cismrmrd.ISMRMRD_VERSION_PATCH
-XMLHDR_VERSION = cismrmrd.ISMRMRD_XMLHDR_VERSION
-
-USER_INTS = cismrmrd.ISMRMRD_USER_INTS
-USER_FLOATS = cismrmrd.ISMRMRD_USER_FLOATS
-PHYS_STAMPS = cismrmrd.ISMRMRD_PHYS_STAMPS
-CHANNEL_MASKS = cismrmrd.ISMRMRD_CHANNEL_MASKS
-NDARRAY_MAXDIM = cismrmrd.ISMRMRD_NDARRAY_MAXDIM
-POSITION_LENGTH = cismrmrd.ISMRMRD_POSITION_LENGTH
-DIRECTION_LENGTH = cismrmrd.ISMRMRD_DIRECTION_LENGTH
-
-# Error codes
-BEGINERROR = cismrmrd.ISMRMRD_BEGINERROR
-NOERROR = cismrmrd.ISMRMRD_NOERROR
-MEMORYERROR = cismrmrd.ISMRMRD_MEMORYERROR
-FILEERROR = cismrmrd.ISMRMRD_FILEERROR
-TYPEERROR = cismrmrd.ISMRMRD_TYPEERROR
-RUNTIMEERROR = cismrmrd.ISMRMRD_RUNTIMEERROR
-HDF5ERROR = cismrmrd.ISMRMRD_HDF5ERROR
-ENDERROR = cismrmrd.ISMRMRD_ENDERROR
-
-# Data types
-USHORT = cismrmrd.ISMRMRD_USHORT
-SHORT = cismrmrd.ISMRMRD_SHORT
-UINT = cismrmrd.ISMRMRD_UINT
-INT = cismrmrd.ISMRMRD_INT
-FLOAT = cismrmrd.ISMRMRD_FLOAT
-DOUBLE = cismrmrd.ISMRMRD_DOUBLE
-CXFLOAT = cismrmrd.ISMRMRD_CXFLOAT
-CXDOUBLE = cismrmrd.ISMRMRD_CXDOUBLE
-
-# Image types
-IMTYPE_MAGNITUDE = cismrmrd.ISMRMRD_IMTYPE_MAGNITUDE
-IMTYPE_PHASE = cismrmrd.ISMRMRD_IMTYPE_PHASE
-IMTYPE_REAL = cismrmrd.ISMRMRD_IMTYPE_REAL
-IMTYPE_IMAG = cismrmrd.ISMRMRD_IMTYPE_IMAG
-IMTYPE_COMPLEX = cismrmrd.ISMRMRD_IMTYPE_COMPLEX
-
-# Acquisition flags
-# TODO: encapsulate that to a class and let set_flag / clear_flag be the
-# only interface
-ACQ_FIRST_IN_ENCODE_STEP1 = cismrmrd.ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP1
-ACQ_LAST_IN_ENCODE_STEP1 = cismrmrd.ISMRMRD_ACQ_LAST_IN_ENCODE_STEP1
-ACQ_FIRST_IN_ENCODE_STEP2 = cismrmrd.ISMRMRD_ACQ_FIRST_IN_ENCODE_STEP2
-ACQ_LAST_IN_ENCODE_STEP2 = cismrmrd.ISMRMRD_ACQ_LAST_IN_ENCODE_STEP2
-ACQ_FIRST_IN_AVERAGE = cismrmrd.ISMRMRD_ACQ_FIRST_IN_AVERAGE
-ACQ_LAST_IN_AVERAGE = cismrmrd.ISMRMRD_ACQ_LAST_IN_AVERAGE
-ACQ_FIRST_IN_SLICE = cismrmrd.ISMRMRD_ACQ_FIRST_IN_SLICE
-ACQ_LAST_IN_SLICE = cismrmrd.ISMRMRD_ACQ_LAST_IN_SLICE
-ACQ_FIRST_IN_CONTRAST = cismrmrd.ISMRMRD_ACQ_FIRST_IN_CONTRAST
-ACQ_LAST_IN_CONTRAST = cismrmrd.ISMRMRD_ACQ_LAST_IN_CONTRAST
-ACQ_FIRST_IN_PHASE = cismrmrd.ISMRMRD_ACQ_FIRST_IN_PHASE
-ACQ_LAST_IN_PHASE = cismrmrd.ISMRMRD_ACQ_LAST_IN_PHASE
-ACQ_FIRST_IN_REPETITION = cismrmrd.ISMRMRD_ACQ_FIRST_IN_REPETITION
-ACQ_LAST_IN_REPETITION = cismrmrd.ISMRMRD_ACQ_LAST_IN_REPETITION
-ACQ_FIRST_IN_SET = cismrmrd.ISMRMRD_ACQ_FIRST_IN_SET
-ACQ_LAST_IN_SET = cismrmrd.ISMRMRD_ACQ_LAST_IN_SET
-ACQ_FIRST_IN_SEGMENT = cismrmrd.ISMRMRD_ACQ_FIRST_IN_SEGMENT
-ACQ_LAST_IN_SEGMENT = cismrmrd.ISMRMRD_ACQ_LAST_IN_SEGMENT
-ACQ_IS_NOISE_MEASUREMENT = cismrmrd.ISMRMRD_ACQ_IS_NOISE_MEASUREMENT
-ACQ_IS_PARALLEL_CALIBRATION = cismrmrd.ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION
-ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING = cismrmrd.ISMRMRD_ACQ_IS_PARALLEL_CALIBRATION_AND_IMAGING
-ACQ_IS_REVERSE = cismrmrd.ISMRMRD_ACQ_IS_REVERSE
-ACQ_IS_NAVIGATION_DATA = cismrmrd.ISMRMRD_ACQ_IS_NAVIGATION_DATA
-ACQ_IS_PHASECORR_DATA = cismrmrd.ISMRMRD_ACQ_IS_PHASECORR_DATA
-ACQ_LAST_IN_MEASUREMENT = cismrmrd.ISMRMRD_ACQ_LAST_IN_MEASUREMENT
-ACQ_IS_HPFEEDBACK_DATA = cismrmrd.ISMRMRD_ACQ_IS_HPFEEDBACK_DATA
-ACQ_IS_DUMMYSCAN_DATA = cismrmrd.ISMRMRD_ACQ_IS_DUMMYSCAN_DATA
-ACQ_IS_RTFEEDBACK_DATA = cismrmrd.ISMRMRD_ACQ_IS_RTFEEDBACK_DATA
-ACQ_IS_SURFACECOILCORRECTIONSCAN_DATA = cismrmrd.ISMRMRD_ACQ_IS_SURFACECOILCORRECTIONSCAN_DATA
-ACQ_USER1 = cismrmrd.ISMRMRD_ACQ_USER1
-ACQ_USER2 = cismrmrd.ISMRMRD_ACQ_USER2
-ACQ_USER3 = cismrmrd.ISMRMRD_ACQ_USER3
-ACQ_USER4 = cismrmrd.ISMRMRD_ACQ_USER4
-ACQ_USER5 = cismrmrd.ISMRMRD_ACQ_USER5
-ACQ_USER6 = cismrmrd.ISMRMRD_ACQ_USER6
-ACQ_USER7 = cismrmrd.ISMRMRD_ACQ_USER7
-ACQ_USER8 = cismrmrd.ISMRMRD_ACQ_USER8
-
-# Image flags
-IMAGE_IS_NAVIGATION_DATA = cismrmrd.ISMRMRD_IMAGE_IS_NAVIGATION_DATA
-IMAGE_USER1 = cismrmrd.ISMRMRD_IMAGE_USER1
-IMAGE_USER2 = cismrmrd.ISMRMRD_IMAGE_USER2
-IMAGE_USER3 = cismrmrd.ISMRMRD_IMAGE_USER3
-IMAGE_USER4 = cismrmrd.ISMRMRD_IMAGE_USER4
-IMAGE_USER5 = cismrmrd.ISMRMRD_IMAGE_USER5
-IMAGE_USER6 = cismrmrd.ISMRMRD_IMAGE_USER6
-IMAGE_USER7 = cismrmrd.ISMRMRD_IMAGE_USER7
-IMAGE_USER8 = cismrmrd.ISMRMRD_IMAGE_USER8
-
-
-cdef bytes build_exception_string():
- cdef char *pfile = NULL
- cdef char *pfunc = NULL
- cdef char *pmsg = NULL
- cdef int line=0, code=0
- cdef bytes err_string
- if(cismrmrd.ismrmrd_pop_error(&pfile, &line, &pfunc, &code, &pmsg)):
- err_string = "ISMRMRD {0} in {1} ({2}:{3})".format(
- <bytes> cismrmrd.ismrmrd_strerror(code),
- <bytes> pfunc,
- <bytes> pfile,
- line,
- <bytes> pmsg,
- )
- return err_string
-
-
-def sizeof_data_type(tp):
- return cismrmrd.ismrmrd_sizeof_data_type(tp)
-
-def encoding_counters_from_bytes(buff):
- e = EncodingCounters()
- e._from_bytes(buff)
- return e
-
-def acquisition_header_from_bytes(buff):
- a = AcquisitionHeader()
- a._from_bytes(buff)
- return a
-
-def image_header_from_bytes(buff):
- i = ImageHeader()
- i._from_bytes(buff)
- return i
-
-
-cdef class EncodingCounters:
-
- cdef cismrmrd.ISMRMRD_EncodingCounters *thisptr
-
- def __cinit__(self, other = None):
- self.thisptr = <cismrmrd.ISMRMRD_EncodingCounters*>calloc(1, sizeof(cismrmrd.ISMRMRD_EncodingCounters))
-
- def __dealloc__(self):
- free(self.thisptr)
-
- def __copy__(self):
- cdef EncodingCounters acopy = EncodingCounters()
- acopy.copy_from(self.thisptr)
- return acopy
-
- cdef copy_from(self, cismrmrd.ISMRMRD_EncodingCounters *ptr):
- memcpy(self.thisptr, ptr, sizeof(cismrmrd.ISMRMRD_EncodingCounters))
-
- cdef copy_to(self, cismrmrd.ISMRMRD_EncodingCounters *ptr):
- memcpy(ptr, self.thisptr, sizeof(cismrmrd.ISMRMRD_EncodingCounters))
-
- @staticmethod
- def _size_in_bytes():
- return sizeof(cismrmrd.ISMRMRD_EncodingCounters)
-
- def _from_bytes(self, s):
- memcpy(self.thisptr, <char *>s, self._size_in_bytes())
-
- def to_bytes(self):
- c_string = <char *>(self.thisptr)
- return c_string[:self._size_in_bytes()]
-
- property kspace_encode_step_1:
- def __get__(self): return self.thisptr.kspace_encode_step_1
- def __set__(self, val): self.thisptr.kspace_encode_step_1 = val
-
- property kspace_encode_step_2:
- def __get__(self): return self.thisptr.kspace_encode_step_2
- def __set__(self, val): self.thisptr.kspace_encode_step_2 = val
-
- property average:
- def __get__(self): return self.thisptr.average
- def __set__(self, val): self.thisptr.average = val
-
- property slice:
- def __get__(self): return self.thisptr.slice
- def __set__(self, val): self.thisptr.slice = val
-
- property contrast:
- def __get__(self): return self.thisptr.contrast
- def __set__(self, val): self.thisptr.contrast = val
-
- property phase:
- def __get__(self): return self.thisptr.phase
- def __set__(self, val): self.thisptr.phase = val
-
- property repetition:
- def __get__(self): return self.thisptr.repetition
- def __set__(self, val): self.thisptr.repetition = val
-
- property set:
- def __get__(self): return self.thisptr.set
- def __set__(self, val): self.thisptr.set = val
-
- property segment:
- def __get__(self): return self.thisptr.segment
- def __set__(self, val): self.thisptr.segment = val
-
- property user:
- def __get__(self):
- l = [0 for i in range(cismrmrd.ISMRMRD_USER_INTS)]
- for i in range(cismrmrd.ISMRMRD_USER_INTS):
- l[i] = self.thisptr.user[i]
- return l
- def __set__(self, vals):
- for i in range(cismrmrd.ISMRMRD_USER_INTS):
- self.thisptr.user[i] = vals[i]
-
-
-cdef class AcquisitionHeader:
-
- cdef cismrmrd.ISMRMRD_AcquisitionHeader *thisptr
-
- def __cinit__(self):
- self.thisptr = <cismrmrd.ISMRMRD_AcquisitionHeader*>calloc(1, sizeof(cismrmrd.ISMRMRD_AcquisitionHeader))
- errno = cismrmrd.ismrmrd_init_acquisition_header(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- def __dealloc__(self):
- free(self.thisptr)
-
- def __copy__(self):
- cdef AcquisitionHeader acopy = AcquisitionHeader()
- acopy.copy_from(self.thisptr)
- return acopy
-
- cdef copy_from(self, cismrmrd.ISMRMRD_AcquisitionHeader *ptr):
- memcpy(self.thisptr, ptr, sizeof(cismrmrd.ISMRMRD_AcquisitionHeader))
-
- cdef copy_to(self, cismrmrd.ISMRMRD_AcquisitionHeader *ptr):
- memcpy(ptr, self.thisptr, sizeof(cismrmrd.ISMRMRD_AcquisitionHeader))
-
- @staticmethod
- def _size_in_bytes():
- return sizeof(cismrmrd.ISMRMRD_AcquisitionHeader)
-
- def _from_bytes(self, s):
- memcpy(self.thisptr, <char *>s, self._size_in_bytes())
-
- def to_bytes(self):
- c_string = <char *>(self.thisptr)
- return c_string[:self._size_in_bytes()]
-
- property version:
- def __get__(self): return self.thisptr.version
- def __set__(self, val): self.thisptr.version = val
-
- property flags:
- def __get__(self): return self.thisptr.flags
- def __set__(self, val): self.thisptr.flags = val
-
- property measurement_uid:
- def __get__(self): return self.thisptr.measurement_uid
- def __set__(self, val): self.thisptr.measurement_uid = val
-
- property scan_counter:
- def __get__(self): return self.thisptr.scan_counter
- def __set__(self, val): self.thisptr.scan_counter = val
-
- property acquisition_time_stamp:
- def __get__(self): return self.thisptr.acquisition_time_stamp
- def __set__(self, val): self.thisptr.acquisition_time_stamp = val
-
- property physiology_time_stamp:
- def __get__(self):
- return [self.thisptr.physiology_time_stamp[i] for i in
- range(cismrmrd.ISMRMRD_PHYS_STAMPS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_PHYS_STAMPS):
- self.thisptr.physiology_time_stamp[i] = val[i]
-
- property number_of_samples:
- def __get__(self): return self.thisptr.number_of_samples
- def __set__(self, val): self.thisptr.number_of_samples = val
-
- property available_channels:
- def __get__(self): return self.thisptr.available_channels
- def __set__(self, val): self.thisptr.available_channels = val
-
- property active_channels:
- def __get__(self): return self.thisptr.active_channels
- def __set__(self, val): self.thisptr.active_channels = val
-
- property channel_mask:
- def __get__(self):
- return [self.thisptr.channel_mask[i] for i in
- range(cismrmrd.ISMRMRD_CHANNEL_MASKS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_CHANNEL_MASKS):
- self.thisptr.channel_mask[i] = val[i]
-
- property discard_pre:
- def __get__(self): return self.thisptr.discard_pre
- def __set__(self, val): self.thisptr.discard_pre = val
-
- property discard_post:
- def __get__(self): return self.thisptr.discard_post
- def __set__(self, val): self.thisptr.discard_post = val
-
- property center_sample:
- def __get__(self): return self.thisptr.center_sample
- def __set__(self, val): self.thisptr.center_sample = val
-
- property encoding_space_ref:
- def __get__(self): return self.thisptr.encoding_space_ref
- def __set__(self, val): self.thisptr.encoding_space_ref = val
-
- property trajectory_dimensions:
- def __get__(self): return self.thisptr.trajectory_dimensions
- def __set__(self, val): self.thisptr.trajectory_dimensions = val
-
- property sample_time_us:
- def __get__(self): return self.thisptr.sample_time_us
- def __set__(self, val): self.thisptr.sample_time_us = val
-
- property position:
- def __get__(self):
- return [self.thisptr.position[i] for i in
- range(cismrmrd.ISMRMRD_POSITION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_POSITION_LENGTH):
- self.thisptr.position[i] = val[i]
-
- property read_dir:
- def __get__(self):
- return [self.thisptr.read_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.read_dir[i] = val[i]
-
- property phase_dir:
- def __get__(self):
- return [self.thisptr.phase_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.phase_dir[i] = val[i]
-
- property slice_dir:
- def __get__(self):
- return [self.thisptr.slice_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.slice_dir[i] = val[i]
-
- property patient_table_position:
- def __get__(self):
- return [self.thisptr.patient_table_position[i] for i in
- range(cismrmrd.ISMRMRD_POSITION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_POSITION_LENGTH):
- self.thisptr.patient_table_position[i] = val[i]
-
- property idx:
- def __get__(self):
- cdef EncodingCounters idx = EncodingCounters()
- idx.copy_from(&self.thisptr.idx)
- return idx
- def __set__(self, EncodingCounters val):
- val.copy_to(&self.thisptr.idx)
-
- property user_int:
- def __get__(self):
- return [self.thisptr.user_int[i] for i in
- range(cismrmrd.ISMRMRD_USER_INTS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_USER_INTS):
- self.thisptr.user_int[i] = val[i]
-
- property user_float:
- def __get__(self):
- return [self.thisptr.user_float[i] for i in
- range(cismrmrd.ISMRMRD_USER_FLOATS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_USER_FLOATS):
- self.thisptr.user_float[i] = val[i]
-
-
-cdef class Acquisition:
-
- cdef cismrmrd.ISMRMRD_Acquisition *thisptr
-
- def __cinit__(self, AcquisitionHeader head=None):
- self.thisptr = <cismrmrd.ISMRMRD_Acquisition*>calloc(1, sizeof(cismrmrd.ISMRMRD_Acquisition))
- errno = cismrmrd.ismrmrd_init_acquisition(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- if head is not None:
- self.head = head
-
- def __dealloc__(self):
- errno = cismrmrd.ismrmrd_cleanup_acquisition(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- free(self.thisptr)
-
- def __copy__(self):
- cdef Acquisition acopy = Acquisition()
- errno = cismrmrd.ismrmrd_copy_acquisition(acopy.thisptr, self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return acopy
-
- property head:
- def __get__(self):
- cdef AcquisitionHeader head = AcquisitionHeader()
- head.copy_from(&self.thisptr.head)
- return head
- def __set__(self, AcquisitionHeader head):
- head.copy_to(&self.thisptr.head)
- errno = cismrmrd.ismrmrd_make_consistent_acquisition(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- property data:
- def __get__(self):
- cdef numpy.npy_intp shape_data[2]
- shape_data[0] = self.head.active_channels
- shape_data[1] = self.head.number_of_samples
- # careful here, thisptr is a R-W view
- return numpy.PyArray_SimpleNewFromData(2, shape_data,
- numpy.NPY_COMPLEX64, <void *>(self.thisptr.data))
- def __set__(self, val):
- self.data.ravel()[:] = numpy.asarray(val).ravel()[:]
-
- property traj:
- def __get__(self):
- cdef numpy.npy_intp shape_traj[2]
- shape_traj[0] = self.head.number_of_samples
- shape_traj[1] = self.head.trajectory_dimensions
- # careful here, thisptr is a R-W view
- # if traj ptr is empty, then will return an empty array
- # which is arguably better than returning a NoneType.
- return numpy.PyArray_SimpleNewFromData(2, shape_traj,
- numpy.NPY_FLOAT32, <void *>(self.thisptr.traj))
- def __set__(self, val):
- self.data.ravel()[:] = numpy.asarray(val).ravel()[:]
-
-
-cdef class ImageHeader:
-
- cdef cismrmrd.ISMRMRD_ImageHeader *thisptr
-
- def __cinit__(self):
- self.thisptr = <cismrmrd.ISMRMRD_ImageHeader*>calloc(1, sizeof(cismrmrd.ISMRMRD_ImageHeader))
- errno = cismrmrd.ismrmrd_init_image_header(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- def __dealloc__(self):
- free(self.thisptr)
-
- def __copy__(self):
- cdef ImageHeader acopy = ImageHeader()
- acopy.copy_from(self.thisptr)
- return acopy
-
- cdef copy_from(self, cismrmrd.ISMRMRD_ImageHeader *ptr):
- memcpy(self.thisptr, ptr, sizeof(cismrmrd.ISMRMRD_ImageHeader))
-
- cdef copy_to(self, cismrmrd.ISMRMRD_ImageHeader *ptr):
- memcpy(ptr, self.thisptr, sizeof(cismrmrd.ISMRMRD_ImageHeader))
-
- @staticmethod
- def _size_in_bytes():
- return sizeof(cismrmrd.ISMRMRD_ImageHeader)
-
- def _from_bytes(self, s):
- memcpy(self.thisptr, <char *>s, self._size_in_bytes())
-
- def to_bytes(self):
- c_string = <char *>(self.thisptr)
- return c_string[:self._size_in_bytes()]
-
- property version:
- def __get__(self): return self.thisptr.version
- def __set__(self, val): self.thisptr.version = val
-
- property data_type:
- def __get__(self): return self.thisptr.data_type
- def __set__(self, val): self.thisptr.data_type = val
-
- property flags:
- def __get__(self): return self.thisptr.flags
- def __set__(self, val): self.thisptr.flags = val
-
- property measurement_uid:
- def __get__(self): return self.thisptr.measurement_uid
- def __set__(self, val): self.thisptr.measurement_uid = val
-
- property matrix_size:
- def __get__(self):
- return [self.thisptr.matrix_size[i] for i in range(3)]
- def __set__(self, val):
- for i in range(3):
- self.thisptr.matrix_size[i] = val[i]
-
- property field_of_view:
- def __get__(self):
- return [self.thisptr.field_of_view[i] for i in range(3)]
- def __set__(self, val):
- for i in range(3):
- self.thisptr.field_of_view[i] = val[i]
-
- property channels:
- def __get__(self): return self.thisptr.channels
- def __set__(self, val): self.thisptr.channels = val
-
- property position:
- def __get__(self):
- return [self.thisptr.position[i] for i in
- range(cismrmrd.ISMRMRD_POSITION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_POSITION_LENGTH):
- self.thisptr.position[i] = val[i]
-
- property read_dir:
- def __get__(self):
- return [self.thisptr.read_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.read_dir[i] = val[i]
-
- property phase_dir:
- def __get__(self):
- return [self.thisptr.phase_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.phase_dir[i] = val[i]
-
- property slice_dir:
- def __get__(self):
- return [self.thisptr.slice_dir[i] for i in
- range(cismrmrd.ISMRMRD_DIRECTION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_DIRECTION_LENGTH):
- self.thisptr.slice_dir[i] = val[i]
-
- property patient_table_position:
- def __get__(self):
- return [self.thisptr.patient_table_position[i] for i in
- range(cismrmrd.ISMRMRD_POSITION_LENGTH)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_POSITION_LENGTH):
- self.thisptr.patient_table_position[i] = val[i]
-
- property average:
- def __get__(self): return self.thisptr.average
- def __set__(self, val): self.thisptr.average = val
-
- property slice:
- def __get__(self): return self.thisptr.slice
- def __set__(self, val): self.thisptr.slice = val
-
- property contrast:
- def __get__(self): return self.thisptr.contrast
- def __set__(self, val): self.thisptr.contrast = val
-
- property phase:
- def __get__(self): return self.thisptr.phase
- def __set__(self, val): self.thisptr.phase = val
-
- property repetition:
- def __get__(self): return self.thisptr.repetition
- def __set__(self, val): self.thisptr.repetition = val
-
- property set:
- def __get__(self): return self.thisptr.set
- def __set__(self, val): self.thisptr.set = val
-
- property acquisition_time_stamp:
- def __get__(self): return self.thisptr.acquisition_time_stamp
- def __set__(self, val): self.thisptr.acquisition_time_stamp = val
-
- property physiology_time_stamp:
- def __get__(self):
- return [self.thisptr.physiology_time_stamp[i] for i in
- range(cismrmrd.ISMRMRD_PHYS_STAMPS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_PHYS_STAMPS):
- self.thisptr.physiology_time_stamp[i] = val[i]
-
- property image_type:
- def __get__(self): return self.thisptr.image_type
- def __set__(self, val): self.thisptr.image_type = val
-
- property image_index:
- def __get__(self): return self.thisptr.image_index
- def __set__(self, val): self.thisptr.image_index = val
-
- property image_series_index:
- def __get__(self): return self.thisptr.image_series_index
- def __set__(self, val): self.thisptr.image_series_index = val
-
- property user_int:
- def __get__(self):
- return [self.thisptr.user_int[i] for i in
- range(cismrmrd.ISMRMRD_USER_INTS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_USER_INTS):
- self.thisptr.user_int[i] = val[i]
-
- property user_float:
- def __get__(self):
- return [self.thisptr.user_float[i] for i in
- range(cismrmrd.ISMRMRD_USER_FLOATS)]
- def __set__(self, val):
- for i in range(cismrmrd.ISMRMRD_USER_FLOATS):
- self.thisptr.user_int[i] = val[i]
-
- property attribute_string_len:
- def __get__(self): return self.thisptr.attribute_string_len
- def __set__(self, val): self.thisptr.attribute_string_len = val
-
-
-cdef class Image:
-
- cdef cismrmrd.ISMRMRD_Image *thisptr
-
- def __cinit__(self, ImageHeader head=None):
- self.thisptr = <cismrmrd.ISMRMRD_Image*>calloc(1, sizeof(cismrmrd.ISMRMRD_Image))
- errno = cismrmrd.ismrmrd_init_image(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- if head is not None:
- self.head = head
-
- def __dealloc__(self):
- errno = cismrmrd.ismrmrd_cleanup_image(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- free(self.thisptr)
-
- def __copy__(self):
- cdef Image acopy = Image()
- errno = cismrmrd.ismrmrd_copy_image(acopy.thisptr, self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return acopy
-
- property head:
- def __get__(self):
- cdef ImageHeader head = ImageHeader()
- head.copy_from(&self.thisptr.head)
- return head
- def __set__(self, ImageHeader head):
- head.copy_to(&self.thisptr.head)
- errno = cismrmrd.ismrmrd_make_consistent_image(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- property attribute_string:
- def __get__(self): return self.thisptr.attribute_string
-
- property data:
- def __get__(self):
- cdef numpy.npy_intp shape_data[3]
- for idim in range(3):
- shape_data[idim] = self.head.matrix_size[idim]
- cdef int typenum = ismrmrd_to_numpy_typenums_dict[self.head.data_type]
- return numpy.PyArray_SimpleNewFromData(3, shape_data,
- typenum, <void *>(self.thisptr.data))
- def __set__(self, val):
- self.data.ravel()[:] = numpy.asarray(val).ravel()[:]
-
-
-cdef class NDArray:
-
- cdef cismrmrd.ISMRMRD_NDArray *thisptr
-
- def __cinit__(self, shape=None, dtype=None):
- self.thisptr = <cismrmrd.ISMRMRD_NDArray*>calloc(1, sizeof(cismrmrd.ISMRMRD_NDArray))
- errno = cismrmrd.ismrmrd_init_ndarray(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- # default dtype is numpy.dtype(None), normally float64
- self.dtype = dtype
- # shape remain optional
- if shape is not None:
- self.shape = shape
-
- def __dealloc__(self):
- errno = cismrmrd.ismrmrd_cleanup_ndarray(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- free(self.thisptr)
-
- def __copy__(self):
- cdef NDArray acopy = NDArray()
- errno = cismrmrd.ismrmrd_copy_ndarray(acopy.thisptr, self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return acopy
-
- property version:
- def __get__(self): return self.thisptr.version
-
- property dtype:
- def __get__(self):
- return numpy.dtype(ismrmrd_typenum_to_numpy_dtype[self.thisptr.data_type])
- def __set__(self, val):
- numpy_dtype = numpy.dtype(val)
- self.thisptr.data_type = numpy_dtype_to_ismrmrd_typenum[numpy_dtype.type]
- errno = cismrmrd.ismrmrd_make_consistent_ndarray(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- property ndim:
- def __get__(self): return self.thisptr.ndim
- def __set__(self, val): self.thisptr.ndim = val
-
- property shape:
- def __get__(self):
- return [self.thisptr.dims[i] for i in range(self.ndim)]
- def __set__(self, val):
- self.ndim = len(val)
- for idim in range(self.ndim):
- self.thisptr.dims[idim] = val[idim]
- errno = cismrmrd.ismrmrd_make_consistent_ndarray(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- property data:
- def __get__(self):
- cdef numpy.npy_intp shape_data[cismrmrd.ISMRMRD_NDARRAY_MAXDIM]
- for idim in range(self.ndim):
- shape_data[idim] = self.shape[idim]
- cdef int typenum = ismrmrd_to_numpy_typenums_dict[self.thisptr.data_type]
- return numpy.PyArray_SimpleNewFromData(self.ndim, shape_data,
- typenum, <void *>(self.thisptr.data))
- def __set__(self, val):
- self.data.ravel()[:] = numpy.asarray(val).ravel()[:]
-
-
-cdef class Dataset:
-
- cdef cismrmrd.ISMRMRD_Dataset *thisptr
- cdef bint is_open
-
- def __cinit__(self, const char *filename, const char *groupname, create_if_needed=True):
- self.thisptr = <cismrmrd.ISMRMRD_Dataset*>calloc(1, sizeof(cismrmrd.ISMRMRD_Dataset))
- errno = cismrmrd.ismrmrd_init_dataset(self.thisptr, filename, groupname)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- self.open(create_if_needed)
-
- def __dealloc__(self):
- self.close()
- free(self.thisptr)
-
- def open(self, create_if_needed=True):
- if not self.is_open:
- errno = cismrmrd.ismrmrd_open_dataset(self.thisptr, create_if_needed)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- self.is_open = True
-
- def close(self):
- if self.is_open:
- errno = cismrmrd.ismrmrd_close_dataset(self.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- self.is_open = False
-
- property filename:
- def __get__(self): return self.thisptr.filename
-
- property groupname:
- def __get__(self): return self.thisptr.groupname
-
- property fileid:
- def __get__(self): return self.thisptr.fileid
-
- def write_header(self, xmlstring):
- errno = cismrmrd.ismrmrd_write_header(self.thisptr, xmlstring)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- def read_header(self):
- return cismrmrd.ismrmrd_read_header(self.thisptr)
-
- def append_acquisition(self, Acquisition acq):
- errno = cismrmrd.ismrmrd_append_acquisition(self.thisptr, acq.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- def read_acquisition(self, index):
- cdef Acquisition acq = Acquisition()
- errno = cismrmrd.ismrmrd_read_acquisition(self.thisptr, index, acq.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return acq
-
- @property
- def number_of_acquisitions(self):
- return cismrmrd.ismrmrd_get_number_of_acquisitions(self.thisptr)
-
- def append_image(self, varname, Image img):
- errno = cismrmrd.ismrmrd_append_image(self.thisptr, varname, img.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
-
- def read_image(self, varname, index):
- cdef Image img = Image()
- errno = cismrmrd.ismrmrd_read_image(self.thisptr, varname, index, img.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return img
-
- def number_of_images(self, varname):
- return cismrmrd.ismrmrd_get_number_of_images(self.thisptr, varname)
-
- def append_array(self, varname, NDArray arr):
- errno = cismrmrd.ismrmrd_append_array(self.thisptr, varname, arr.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string().decode('UTF-8'))
-
- def read_array(self, varname, index):
- cdef NDArray arr = NDArray()
- errno = cismrmrd.ismrmrd_read_array(self.thisptr, varname, index, arr.thisptr)
- if errno != cismrmrd.ISMRMRD_NOERROR:
- raise RuntimeError(build_exception_string())
- return arr
-
- def number_of_arrays(self, varname):
- return cismrmrd.ismrmrd_get_number_of_arrays(self.thisptr, varname)
diff --git a/bindings/python/setup.py b/bindings/python/setup.py
deleted file mode 100644
index dcf482d..0000000
--- a/bindings/python/setup.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import os
-from distutils.core import setup
-from distutils.command.build import build
-from distutils.command.build_py import build_py
-from distutils.extension import Extension
-from Cython.Distutils import build_ext
-import numpy
-
-ismrmrd_home = os.environ.get('ISMRMRD_HOME', '')
-schema_file = os.path.join(ismrmrd_home,'share','ismrmrd','schema','ismrmrd.xsd')
-
-class my_build(build):
- def run(self):
- self.run_command("build_ext")
- self.run_command("build_py")
- build.run(self)
-
-class my_build_py(build_py):
- def run(self):
- print "Hello"
- # honor the --dry-run flag
- if not self.dry_run:
- os.system('pyxbgen -u '+schema_file+' -m ismrmrd_xsd --binding-root="'+self.build_lib+'"')
-
- # distutils uses old-style classes, so no super()
- build_py.run(self)
-
-ext = Extension(
- "ismrmrd",
- ["cismrmrd.pxd", "ismrmrd.pyx"],
- include_dirs=[os.path.join(ismrmrd_home, 'include'),
- '/usr/local/include', '/usr/include',
- numpy.get_include()],
- library_dirs=[os.path.join(ismrmrd_home, 'lib'),
- '/usr/local/lib', '/usr/lib'],
- libraries=["ismrmrd"],
- extra_link_args=[],
-)
-
-setup(
- name='ismrmrd',
- version='1.2.1',
- author='ISMRMRD Developers',
- author_email='ismrmrd at googlegroups.com',
- description='Python bindings to ISMRMRD',
- license='Public Domain',
- keywords='ismrmrd',
- url='https://ismrmrd.github.io',
- packages=[],
- classifiers=[
- 'Development Status :: 5 - Production/Stable',
- 'Intended Audience :: Science/Research',
- 'License :: Public Domain',
- 'Operating System :: OS Independent',
- 'Programming Language :: Cython',
- 'Topic :: Scientific/Engineering :: Medical Science Apps.'
- ],
- requires=['Cython', 'numpy', 'PyXB'],
-
- ext_modules=[ext],
- cmdclass={'build_ext':build_ext,'build_py':my_build_py,'build':my_build}
-)
diff --git a/cmake/ismrmrd_cpack.cmake b/cmake/ismrmrd_cpack.cmake
index 05ef69d..eee956c 100644
--- a/cmake/ismrmrd_cpack.cmake
+++ b/cmake/ismrmrd_cpack.cmake
@@ -31,3 +31,8 @@ set(DEBIAN_PACKAGE_DEPENDS "libhdf5-7, libfftw3-3, libboost-program-options-dev"
# where the package metadata are
set(ISMRMRD_CPACK_CFG_FILE "${PROJECT_BINARY_DIR}/cpack_options.cmake")
+
+# Where the package to be installed
+#set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CMAKE_INSTALL_PREFIX})
+set(CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
+message("CPACK_PACKAGING_INSTALL_PREFIX: " ${CPACK_PACKAGING_INSTALL_PREFIX})
diff --git a/doc/source/index.rst b/doc/source/index.rst
index 4fa1fb8..a0e7c73 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -97,6 +97,7 @@ Mac OSX Installation
There are numerous different package management systems for Mac. In this example, we have used Homebrew (http://brew.sh/). First install the dependencies::
+ brew tap homebrew/science
brew install wget hdf5 boost cmake doxygen fftw
Then download and compile:
diff --git a/examples/c/main.c b/examples/c/main.c
index 06cf191..6bb5d07 100644
--- a/examples/c/main.c
+++ b/examples/c/main.c
@@ -156,6 +156,7 @@ int main(void)
numim = ismrmrd_get_number_of_images(&dataset2, "testimages");
printf("Number of images stored = %d\n", numim);
+ ismrmrd_init_image(&im2);
ismrmrd_read_image(&dataset2, "testimages", 1, &im2);
printf("Image 1 attribute string = %s\n", im2.attribute_string);
printf("Image 1 at position 10 has value = %f\n", ((float*)im2.data)[10]);
@@ -175,6 +176,7 @@ int main(void)
printf("Number of arrays stored = %d\n", ismrmrd_get_number_of_arrays(&dataset2, "testarray"));
/* Read it back in */
+ ismrmrd_init_ndarray(&arr2);
ismrmrd_read_array(&dataset2, "testarray", 0, &arr2);
printf("Array 2 at position 10 has value = %f\n", ((float*)arr2.data)[10]);
diff --git a/examples/python/ismrmrd_recon_dataset.py b/examples/python/ismrmrd_recon_dataset.py
index 124ecfa..a0ccd49 100644
--- a/examples/python/ismrmrd_recon_dataset.py
+++ b/examples/python/ismrmrd_recon_dataset.py
@@ -12,9 +12,9 @@ filename = 'testdata.h5'
if not os.path.isfile(filename):
print("%s is not a valid file" % filename)
raise SystemExit
-dset = ismrmrd.IsmrmrdDataset(filename, 'dataset', create_if_needed=False)
+dset = ismrmrd.Dataset(filename, 'dataset', create_if_needed=False)
-header = ismrmrd_xsd.CreateFromDocument(dset.readHeader())
+header = ismrmrd_xsd.CreateFromDocument(dset.read_header())
enc = header.encoding[0]
# Matrix size
@@ -34,65 +34,72 @@ rFOVy = enc.reconSpace.fieldOfView_mm.y
rFOVz = enc.reconSpace.fieldOfView_mm.z
# Number of Slices, Reps, Contrasts, etc.
-nslices = enc.encodingLimits.slice.maximum + 1
ncoils = header.acquisitionSystemInformation.receiverChannels
-nreps = enc.encodingLimits.repetition.maximum + 1
-ncontrasts = enc.encodingLimits.contrast.maximum + 1
-
-# TODO: Ignore noise scans
-for acqnum in range(dset.getNumberOfAcquisitions()):
- acq = dset.readAcquisition(acqnum)
- if acq.getHead().flags & ismrmrd.ACQ_IS_NOISE_MEASUREMENT:
- print("Found noise measurement @ %d" % acqnum)
-
-all_data = np.zeros((eNx, eNy, eNz, ncoils, nslices, ncontrasts, nreps), dtype=np.complex64)
-for acqnum in range(dset.getNumberOfAcquisitions()):
- acq = dset.readAcquisition(acqnum)
- head = acq.getHead()
- rep = head.idx.repetition
- contrast = head.idx.contrast
- slice = head.idx.slice
- y = head.idx.kspace_encode_step_1
- z = head.idx.kspace_encode_step_2
- floatdata = acq.getData()
- data = np.array([complex(elem[0], elem[1]) for elem in zip(floatdata[::2], floatdata[1::2])])
- data = data.reshape((eNx, ncoils))
- all_data[:, y, z, :, slice, contrast, rep] = data
-
-fig = plt.figure()
-h, w = nreps * ncontrasts, eNz * nslices
-i = 0
-for rep in range(nreps):
- for contrast in range(ncontrasts):
- for slice in range(nslices):
- for z in range(eNz):
- K = all_data[:,:,z,:,slice, contrast, rep]
- comb = np.sqrt(np.sum(np.abs(K) ** 2, 2))
- a = fig.add_subplot(h, w, i)
- plt.imshow(comb)
- i += 1
-fig.set_size_inches(16, 16)
+if enc.encodingLimits.slice != None:
+ nslices = enc.encodingLimits.slice.maximum + 1
+else:
+ nslices = 1
+
+if enc.encodingLimits.repetition != None:
+ nreps = enc.encodingLimits.repetition.maximum + 1
+else:
+ nreps = 1
+
+if enc.encodingLimits.contrast != None:
+ ncontrasts = enc.encodingLimits.contrast.maximum + 1
+else:
+ ncontrasts = 1
+
+
+all_data = np.zeros((nreps, ncontrasts, nslices, ncoils, eNz, eNy, eNx), dtype=np.complex64)
+for acqnum in range(dset.number_of_acquisitions):
+ acq = dset.read_acquisition(acqnum)
+
+ # TODO: Currently ignoring noise scans
+ if acq.head.flags & ismrmrd.ACQ_IS_NOISE_MEASUREMENT:
+ continue
+
+ rep = acq.head.idx.repetition
+ contrast = acq.head.idx.contrast
+ slice = acq.head.idx.slice
+ y = acq.head.idx.kspace_encode_step_1
+ z = acq.head.idx.kspace_encode_step_2
+ all_data[rep, contrast, slice, :, z, y, :] = acq.data
+
+#fig = plt.figure()
+#h, w = nreps * ncontrasts, eNz * nslices
+#i = 0
+#for rep in range(nreps):
+# for contrast in range(ncontrasts):
+# for slice in range(nslices):
+# for z in range(eNz):
+# K = all_data[rep,contrast,slice,:,z,:,:]
+# comb = np.sqrt(np.squeeze(np.sum(np.abs(K) ** 2, 2)))
+# a = fig.add_subplot(h, w, i)
+# plt.imshow(comb)
+# i += 1
+#fig.set_size_inches(16, 16)
images = []
for rep in range(nreps):
for contrast in range(ncontrasts):
for slice in range(nslices):
- K = all_data[:,:,:,:,slice, contrast, rep]
- K = fftshift(ifft(fftshift(K, axes=0), axis=0), axes=0)
+ K = all_data[rep,contrast,slice,:,:,:,:]
+ K = fftshift(ifft(fftshift(K, axes=3), axis=3), axes=3)
# chop if needed
if eNx != rNx:
i0 = (eNx - rNx) / 2
i1 = (eNx - rNx) / 2 + rNx
- im = K[i0:i1,:,:,:]
+ im = K[:,:,:,i0:i1]
else:
im = K
- im = fftshift(ifft(fftshift(im, axes=1), axis=1), axes=1)
- if np.size(im, 2) > 1:
- im = fftshift(ifft(fftshift(im, axes=2), axis=2), axes=2)
+ im = fftshift(ifft(fftshift(im, axes=2), axis=2), axes=2)
+ if np.size(im, 1) > 1:
+ im = fftshift(ifft(fftshift(im, axes=1), axis=1), axes=1)
- im = np.squeeze(np.sqrt(np.sum(np.abs(im) ** 2, 3)))
+ im = np.squeeze(np.sqrt(np.sum(np.abs(im) ** 2, 0)))
images.append(im)
l = len(images)
@@ -102,24 +109,24 @@ for n, im in enumerate(images):
plt.imshow(im)
fig.set_size_inches(16, 4)
-# grab the first acquisition for extra info
-acqh = dset.readAcquisition(0).getHead()
-
-for n, img in enumerate(images):
- hdr = ismrmrd.ImageHeader()
- hdr.acquisition_time_stamp = acqh.acquisition_time_stamp
- hdr.flags = 0
- hdr.measurement_uid = acqh.measurement_uid
- hdr.phase_dir = acqh.phase_dir
- hdr.physiology_time_stamp = acqh.physiology_time_stamp
- hdr.position = acqh.position
- hdr.read_dir = acqh.read_dir
- hdr.slice_dir = acqh.slice_dir
- hdr.channels = 1
- hdr.image_data_type = ismrmrd.DATA_FLOAT
- hdr.image_type = ismrmrd.TYPE_MAGNITUDE
- hdr.image_index = n
- hdr.slice = n
-
- dset.appendImageHeader(hdr, "image_%d.hdr" % n)
- dset.appendArray(img, "image_%d.img" % n)
+## # grab the first acquisition for extra info
+## acqh = dset.read_acquisition(0).head
+
+## for n, img in enumerate(images):
+## hdr = ismrmrd.ImageHeader()
+## hdr.acquisition_time_stamp = acqh.acquisition_time_stamp
+## hdr.flags = 0
+## hdr.measurement_uid = acqh.measurement_uid
+## hdr.phase_dir = acqh.phase_dir
+## hdr.physiology_time_stamp = acqh.physiology_time_stamp
+## hdr.position = acqh.position
+## hdr.read_dir = acqh.read_dir
+## hdr.slice_dir = acqh.slice_dir
+## hdr.channels = 1
+## hdr.image_data_type = ismrmrd.DATA_FLOAT
+## hdr.image_type = ismrmrd.TYPE_MAGNITUDE
+## hdr.image_index = n
+## hdr.slice = n
+
+## dset.appendImageHeader(hdr, "image_%d.hdr" % n)
+## dset.appendArray(img, "image_%d.img" % n)
diff --git a/include/ismrmrd/ismrmrd.h b/include/ismrmrd/ismrmrd.h
index 04f07d8..24bfeab 100644
--- a/include/ismrmrd/ismrmrd.h
+++ b/include/ismrmrd/ismrmrd.h
@@ -22,12 +22,14 @@
/* Language and cross platform section for defining types */
/* integers */
#ifdef _MSC_VER /* MS compiler */
+#ifndef HAS_INT_TYPE
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
+#endif
#else /* non MS C or C++ compiler */
#include <stdint.h>
#include <stddef.h> /* for size_t */
@@ -367,6 +369,7 @@ EXPORTISMRMRD size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr);
*/
EXPORTISMRMRD bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val);
EXPORTISMRMRD int ismrmrd_set_flag(uint64_t *flags, const uint64_t val);
+EXPORTISMRMRD int ismrmrd_set_flags(uint64_t *flags, const uint64_t val);
EXPORTISMRMRD int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val);
EXPORTISMRMRD int ismrmrd_clear_all_flags(uint64_t *flags);
/** @} */
@@ -522,19 +525,20 @@ public:
// Sizes
void resize(uint16_t num_samples, uint16_t active_channels=1, uint16_t trajectory_dimensions=0);
- const size_t getNumberOfDataElements();
- const size_t getNumberOfTrajElements();
- const size_t getDataSize();
- const size_t getTrajSize();
+ size_t getNumberOfDataElements() const;
+ size_t getNumberOfTrajElements() const;
+ size_t getDataSize() const;
+ size_t getTrajSize() const;
// Header, data and trajectory accessors
- const AcquisitionHeader &getHead();
- void setHead(const AcquisitionHeader other);
+ const AcquisitionHeader &getHead() const;
+ void setHead(const AcquisitionHeader &other);
/**
* Returns a pointer to the data
*/
- const complex_float_t * const getDataPtr() const ;
+ const complex_float_t * getDataPtr() const;
+ complex_float_t * getDataPtr();
/**
* Returns a reference to the data
@@ -559,7 +563,8 @@ public:
/**
* Returns a pointer to the trajectory
*/
- const float * const getTrajPtr() const;
+ const float * getTrajPtr() const;
+ float * getTrajPtr();
/**
* Returns a reference to the trajectory
@@ -587,6 +592,10 @@ public:
void clearFlag(const uint64_t val);
void clearAllFlags();
+ bool isFlagSet(const FlagBit &val) { return isFlagSet(val.bitmask_); }
+ void setFlag(const FlagBit &val) { setFlag(val.bitmask_); }
+ void clearFlag(const FlagBit &val) { clearFlag(val.bitmask_); }
+
// Channel mask methods
bool isChannelActive(uint16_t channel_id);
void setChannelActive(uint16_t channel_id);
@@ -742,15 +751,17 @@ public:
// Header
ImageHeader & getHead();
+ const ImageHeader & getHead() const;
void setHead(const ImageHeader& head);
// Attribute string
void getAttributeString(std::string &atrr) const;
- void setAttributeString(const std::string attr);
- const size_t getAttributeStringLength();
+ void setAttributeString(const std::string &attr);
+ size_t getAttributeStringLength() const;
// Data
- T * const getDataPtr() const;
+ T * getDataPtr();
+ const T * getDataPtr() const;
/** Returns the number of elements in the image data **/
size_t getNumberOfDataElements() const;
/** Returns the size of the image data in bytes **/
@@ -781,14 +792,15 @@ public:
NDArray<T> & operator= (const NDArray<T> &other);
// Accessors and mutators
- const uint16_t getVersion();
- const ISMRMRD_DataTypes getDataType();
- const uint16_t getNDim();
+ uint16_t getVersion() const;
+ ISMRMRD_DataTypes getDataType() const;
+ uint16_t getNDim() const;
const size_t (&getDims())[ISMRMRD_NDARRAY_MAXDIM];
- const size_t getDataSize();
+ size_t getDataSize() const;
void resize(const std::vector<size_t> dimvec);
- const size_t getNumberOfElements();
+ size_t getNumberOfElements() const;
T * getDataPtr();
+ const T * getDataPtr() const;
/** Returns iterator to the beginning of the array **/
T * begin();
diff --git a/libsrc/dataset.c b/libsrc/dataset.c
index 8b6321b..b1ee935 100644
--- a/libsrc/dataset.c
+++ b/libsrc/dataset.c
@@ -596,6 +596,11 @@ static int append_element(const ISMRMRD_Dataset * dset, const char * path,
h5status = H5Sget_simple_extent_dims(dataspace, hdfdims, maxdims);
for (n = 0; n<ndim; n++) {
if (dims[n] != hdfdims[n+1]) {
+ free(hdfdims);
+ free(ext_dims);
+ free(offset);
+ free(maxdims);
+ free(chunk_dims);
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Dimensions are incorrect.");
}
}
@@ -627,11 +632,21 @@ static int append_element(const ISMRMRD_Dataset * dset, const char * path,
/* create */
dataset = H5Dcreate2(dset->fileid, path, datatype, dataspace, H5P_DEFAULT, props, H5P_DEFAULT);
if (dataset < 0) {
+ free(hdfdims);
+ free(ext_dims);
+ free(offset);
+ free(maxdims);
+ free(chunk_dims);
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to create dataset");
}
h5status = H5Pclose(props);
if (h5status < 0) {
+ free(hdfdims);
+ free(ext_dims);
+ free(offset);
+ free(maxdims);
+ free(chunk_dims);
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close property list");
}
@@ -656,7 +671,7 @@ static int append_element(const ISMRMRD_Dataset * dset, const char * path,
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to write dataset");
}
-
+
/* Clean up */
h5status = H5Sclose(dataspace);
if (h5status < 0) {
@@ -683,14 +698,14 @@ static int append_element(const ISMRMRD_Dataset * dset, const char * path,
}
static int get_array_properties(const ISMRMRD_Dataset *dset, const char *path,
- uint16_t *ndim, size_t dims[ISMRMRD_NDARRAY_MAXDIM],
- uint16_t *data_type)
+ uint16_t *ndim, size_t dims[ISMRMRD_NDARRAY_MAXDIM],
+ uint16_t *data_type)
{
hid_t dataset, filespace, hdf5type;
hsize_t *hdfdims = NULL;
herr_t h5status = 0;
int rank, n;
-
+
if (NULL == dset) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
}
@@ -715,14 +730,14 @@ static int get_array_properties(const ISMRMRD_Dataset *dset, const char *path,
/* get the dimensions */
hdfdims = (hsize_t *)malloc(rank * sizeof(*hdfdims));
h5status = H5Sget_simple_extent_dims(filespace, hdfdims, NULL);
-
+
/* set the return values - permute dimensions */
*data_type = get_ndarray_data_type(hdf5type);
*ndim = rank;
for (n=0; n<rank; n++) {
dims[n] = hdfdims[rank-n-1];
}
-
+
/* clean up */
h5status = H5Tclose(hdf5type);
if (h5status < 0) {
@@ -743,15 +758,17 @@ static int get_array_properties(const ISMRMRD_Dataset *dset, const char *path,
return ISMRMRD_NOERROR;
}
-
+
int read_element(const ISMRMRD_Dataset *dset, const char *path, void *elem,
- const hid_t datatype, const uint32_t index)
+ const hid_t datatype, const uint32_t index)
{
hid_t dataset, filespace, memspace;
hsize_t *hdfdims = NULL, *offset = NULL, *count = NULL;
herr_t h5status = 0;
int rank = 0;
int n;
+ int ret_code = ISMRMRD_NOERROR;
+
if (NULL == dset) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
@@ -777,7 +794,8 @@ int read_element(const ISMRMRD_Dataset *dset, const char *path, void *elem,
h5status = H5Sget_simple_extent_dims(filespace, hdfdims, NULL);
if (index >= hdfdims[0]) {
- return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Index out of range.");
+ ret_code = ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Index out of range.");
+ goto cleanup;
}
offset[0] = index;
@@ -786,35 +804,43 @@ int read_element(const ISMRMRD_Dataset *dset, const char *path, void *elem,
offset[n] = 0;
count[n] = hdfdims[n];
}
-
+
h5status = H5Sselect_hyperslab(filespace, H5S_SELECT_SET, offset, NULL, count, NULL);
/* create space for one */
memspace = H5Screate_simple(rank, count, NULL);
-
+
h5status = H5Dread(dataset, datatype, memspace, filespace, H5P_DEFAULT, elem);
if (h5status < 0) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to read from dataset.");
+ ret_code = ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to read from dataset.");
+ goto cleanup;
}
h5status = H5Sclose(filespace);
if (h5status < 0) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close filespace.");
+ ret_code = ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close filespace.");
+ goto cleanup;
}
h5status = H5Sclose(memspace);
if (h5status < 0) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close memspace.");
+ ret_code = ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close memspace.");
+ goto cleanup;
}
h5status = H5Dclose(dataset);
if (h5status < 0) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close dataset.");
+ ret_code = ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close dataset.");
+ goto cleanup;
}
- return ISMRMRD_NOERROR;
+cleanup:
+ free(count);
+ free(offset);
+ free(hdfdims);
+ return ret_code;
}
/********************/
@@ -835,7 +861,7 @@ int ismrmrd_init_dataset(ISMRMRD_Dataset *dset, const char *filename,
return ISMRMRD_PUSH_ERR(ISMRMRD_MEMORYERROR, "Failed to malloc dataset groupname");
}
strcpy(dset->filename, filename);
-
+
dset->groupname = (char *) malloc(strlen(groupname) + 1);
if (dset->groupname == NULL) {
return ISMRMRD_PUSH_ERR(ISMRMRD_MEMORYERROR, "Failed to malloc dataset groupname");
@@ -883,7 +909,7 @@ int ismrmrd_open_dataset(ISMRMRD_Dataset *dset, const bool create_if_needed) {
/* Open the existing dataset */
/* ensure that /groupname exists */
create_link(dset, dset->groupname);
-
+
return ISMRMRD_NOERROR;
}
@@ -895,6 +921,16 @@ int ismrmrd_close_dataset(ISMRMRD_Dataset *dset) {
return false;
}
+ if (dset->filename != NULL) {
+ free(dset->filename);
+ dset->filename = NULL;
+ }
+
+ if (dset->groupname != NULL) {
+ free(dset->groupname);
+ dset->groupname = NULL;
+ }
+
/* Check for a valid fileid before trying to close the file */
if (dset->fileid > 0) {
h5status = H5Fclose (dset->fileid);
@@ -904,7 +940,7 @@ int ismrmrd_close_dataset(ISMRMRD_Dataset *dset) {
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close dataset.");
}
}
-
+
return ISMRMRD_NOERROR;
}
@@ -925,17 +961,18 @@ int ismrmrd_write_header(const ISMRMRD_Dataset *dset, const char *xmlstring) {
/* The path to the xml header */
path = make_path(dset, "xml");
-
+
/* Delete the old header if it exists */
h5status = delete_var(dset, "xml");
-
+
/* Create a new dataset for the xmlstring */
/* i.e. create the memory type, data space, and data set */
dataspace = H5Screate_simple(1, dims, NULL);
datatype = get_hdf5type_xmlheader();
props = H5Pcreate (H5P_DATASET_CREATE);
dataset = H5Dcreate2(dset->fileid, path, datatype, dataspace, H5P_DEFAULT, props, H5P_DEFAULT);
-
+ free(path);
+
/* Write it out */
/* We have to wrap the xmlstring in an array */
buff[0] = (void *) xmlstring; /* safe to get rid of const the type */
@@ -944,7 +981,7 @@ int ismrmrd_write_header(const ISMRMRD_Dataset *dset, const char *xmlstring) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to write xml string to dataset");
}
-
+
/* Clean up */
h5status = H5Pclose(props);
if (h5status < 0) {
@@ -973,8 +1010,9 @@ int ismrmrd_write_header(const ISMRMRD_Dataset *dset, const char *xmlstring) {
char * ismrmrd_read_header(const ISMRMRD_Dataset *dset) {
hid_t dataset, datatype;
herr_t h5status;
- char * xmlstring, *path;
-
+ char* xmlstring = NULL;
+ char* path = NULL;
+
if (dset==NULL) {
ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Pointer should not be NULL.");
return NULL;
@@ -982,57 +1020,61 @@ char * ismrmrd_read_header(const ISMRMRD_Dataset *dset) {
/* The path to the xml header */
path = make_path(dset, "xml");
-
- if (link_exists(dset, path)) {
- void *buff[1] = { NULL };
- dataset = H5Dopen2(dset->fileid, path, H5P_DEFAULT);
- datatype = get_hdf5type_xmlheader();
- /* Read it into a 1D buffer*/
- h5status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff);
- if (h5status < 0 || buff[0] == NULL) {
- H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to read header.");
- free(path);
- return NULL;
- }
-
- /* Unpack */
- xmlstring = (char *) malloc(strlen(buff[0])+1);
- if (xmlstring == NULL) {
- ISMRMRD_PUSH_ERR(ISMRMRD_MEMORYERROR, "Failed to malloc xmlstring");
- } else {
- memcpy(xmlstring, buff[0], strlen(buff[0])+1);
- }
-
- /* Clean up */
- h5status = H5Tclose(datatype);
- if (h5status < 0) {
- H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close XML header HDF5 datatype.");
- return NULL;
- }
- h5status = H5Dclose(dataset);
- if (h5status < 0) {
- H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
- ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close XML header HDF5 dataset.");
- return NULL;
- }
- free(path);
- return xmlstring;
- }
- else {
+ if (!link_exists(dset, path)) {
/* No XML String found */
ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "No XML Header found.");
- free(path);
- return NULL;
+ goto cleanup_path;
}
+
+ void *buff[1] = { NULL };
+ dataset = H5Dopen2(dset->fileid, path, H5P_DEFAULT);
+ datatype = get_hdf5type_xmlheader();
+ /* Read it into a 1D buffer*/
+ h5status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff);
+ if (h5status < 0 || buff[0] == NULL) {
+ H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
+ ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to read header.");
+ goto cleanup_path;
+ }
+
+ /* Unpack */
+ xmlstring = (char *) malloc(strlen(buff[0])+1);
+ if (NULL == xmlstring) {
+ ISMRMRD_PUSH_ERR(ISMRMRD_MEMORYERROR, "Failed to malloc xmlstring");
+ goto cleanup_path;
+ } else {
+ memcpy(xmlstring, buff[0], strlen(buff[0])+1);
+ }
+
+ /* Clean up */
+ h5status = H5Tclose(datatype);
+ if (h5status < 0) {
+ H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
+ ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close XML header HDF5 datatype.");
+ goto cleanup_xmlstring;
+ }
+ h5status = H5Dclose(dataset);
+ if (h5status < 0) {
+ H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
+ ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to close XML header HDF5 dataset.");
+ goto cleanup_xmlstring;
+ }
+
+ goto cleanup_path;
+
+cleanup_xmlstring:
+ free(xmlstring);
+ xmlstring = NULL;
+cleanup_path:
+ free(path);
+ return xmlstring;
}
uint32_t ismrmrd_get_number_of_acquisitions(const ISMRMRD_Dataset *dset) {
char *path;
uint32_t numacq;
-
+
if (dset==NULL) {
ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Pointer should not be NULL.");
return 0;
@@ -1049,27 +1091,27 @@ int ismrmrd_append_acquisition(const ISMRMRD_Dataset *dset, const ISMRMRD_Acquis
char *path;
hid_t datatype;
HDF5_Acquisition hdf5acq[1];
-
+
if (dset==NULL) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
}
if (acq==NULL) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Acquisition pointer should not be NULL.");
}
-
+
/* The path to the acqusition data */
path = make_path(dset, "data");
-
+
/* The acquisition datatype */
datatype = get_hdf5type_acquisition();
-
+
/* Create the HDF5 version of the acquisition */
hdf5acq[0].head = acq->head;
hdf5acq[0].traj.len = acq->head.number_of_samples * acq->head.trajectory_dimensions;
hdf5acq[0].traj.p = acq->traj;
hdf5acq[0].data.len = 2 * acq->head.number_of_samples * acq->head.active_channels;
hdf5acq[0].data.p = acq->data;
-
+
/* Write it */
status = append_element(dset, path, hdf5acq, datatype, 0, NULL);
if (status != ISMRMRD_NOERROR) {
@@ -1084,7 +1126,7 @@ int ismrmrd_append_acquisition(const ISMRMRD_Dataset *dset, const ISMRMRD_Acquis
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close datatype.");
}
-
+
return ISMRMRD_NOERROR;
}
@@ -1148,7 +1190,7 @@ int ismrmrd_append_image(const ISMRMRD_Dataset *dset, const char *varname, const
path = make_path(dset, varname);
/* Make sure the path exists */
create_link(dset, path);
-
+
/* Handle the header */
headerpath = append_to_path(dset, path, "header");
datatype = get_hdf5type_imageheader();
@@ -1158,7 +1200,7 @@ int ismrmrd_append_image(const ISMRMRD_Dataset *dset, const char *varname, const
}
status = H5Tclose(datatype);
free(headerpath);
-
+
/* Handle the attribute string */
attrpath = append_to_path(dset, path, "attributes");
datatype = get_hdf5type_image_attribute_string();
@@ -1168,7 +1210,7 @@ int ismrmrd_append_image(const ISMRMRD_Dataset *dset, const char *varname, const
}
status = H5Tclose(datatype);
free(attrpath);
-
+
/* Handle the data */
datapath = append_to_path(dset, path, "data");
datatype = get_hdf5type_ndarray(im->head.data_type);
@@ -1183,14 +1225,14 @@ int ismrmrd_append_image(const ISMRMRD_Dataset *dset, const char *varname, const
}
status = H5Tclose(datatype);
free(datapath);
-
+
/* Final cleanup */
if (status < 0) {
H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, walk_hdf5_errors, NULL);
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close datatype.");
}
free(path);
-
+
return ISMRMRD_NOERROR;
}
@@ -1198,7 +1240,7 @@ uint32_t ismrmrd_get_number_of_images(const ISMRMRD_Dataset *dset, const char *v
{
char *path, *headerpath;
uint32_t numimages;
-
+
if (dset==NULL) {
ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
return 0;
@@ -1220,7 +1262,7 @@ uint32_t ismrmrd_get_number_of_images(const ISMRMRD_Dataset *dset, const char *v
int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
- const uint32_t index, ISMRMRD_Image *im) {
+ const uint32_t index, ISMRMRD_Image *im) {
int status;
hid_t datatype;
@@ -1238,15 +1280,15 @@ int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
}
numims = ismrmrd_get_number_of_images(dset, varname);
-
+
if (index > numims) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Index requested exceeds number of images in the dataset.");
}
-
+
/* The group for this set of images */
/* /groupname/varname */
path = make_path(dset, varname);
-
+
/* Handle the header */
headerpath = append_to_path(dset, path, "header");
datatype = get_hdf5type_imageheader();
@@ -1259,7 +1301,7 @@ int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
/* Allocate the memory for the attribute string and the data */
ismrmrd_make_consistent_image(im);
-
+
/* Handle the attribute string */
attrpath = append_to_path(dset, path, "attributes");
datatype = get_hdf5type_image_attribute_string();
@@ -1269,7 +1311,7 @@ int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
}
free(attrpath);
H5Tclose(datatype);
-
+
/* Handle the data */
datapath = append_to_path(dset, path, "data");
datatype = get_hdf5type_ndarray(im->head.data_type);
@@ -1278,7 +1320,7 @@ int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to read image data.");
}
free(datapath);
-
+
/* Final cleanup */
status = H5Tclose(datatype);
if (status < 0) {
@@ -1286,7 +1328,7 @@ int ismrmrd_read_image(const ISMRMRD_Dataset *dset, const char *varname,
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close datatype.");
}
free(path);
-
+
return ISMRMRD_NOERROR;
}
@@ -1307,11 +1349,11 @@ int ismrmrd_append_array(const ISMRMRD_Dataset *dset, const char *varname, const
if (arr==NULL) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Array pointer should not be NULL.");
}
-
+
/* The group for this set */
/* /groupname/varname */
path = make_path(dset, varname);
-
+
/* Handle the data */
datatype = get_hdf5type_ndarray(arr->data_type);
ndim = arr->ndim;
@@ -1322,9 +1364,10 @@ int ismrmrd_append_array(const ISMRMRD_Dataset *dset, const char *varname, const
}
status = append_element(dset, path, arr->data, datatype, ndim, dims);
if (status != ISMRMRD_NOERROR) {
+ free(dims);
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to append array.");
}
-
+
/* Final cleanup */
free(dims);
status = H5Tclose(datatype);
@@ -1333,14 +1376,14 @@ int ismrmrd_append_array(const ISMRMRD_Dataset *dset, const char *varname, const
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close datatype.");
}
free(path);
-
+
return ISMRMRD_NOERROR;
}
uint32_t ismrmrd_get_number_of_arrays(const ISMRMRD_Dataset *dset, const char *varname) {
char *path;
uint32_t numarrays;
-
+
if (dset==NULL) {
ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
return 0;
@@ -1359,11 +1402,11 @@ uint32_t ismrmrd_get_number_of_arrays(const ISMRMRD_Dataset *dset, const char *v
}
int ismrmrd_read_array(const ISMRMRD_Dataset *dset, const char *varname,
- const uint32_t index, ISMRMRD_NDArray *arr) {
+ const uint32_t index, ISMRMRD_NDArray *arr) {
int status;
hid_t datatype;
char *path;
-
+
if (dset==NULL) {
return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Dataset pointer should not be NULL.");
}
@@ -1390,7 +1433,7 @@ int ismrmrd_read_array(const ISMRMRD_Dataset *dset, const char *varname,
if (status != ISMRMRD_NOERROR) {
return ISMRMRD_PUSH_ERR(ISMRMRD_FILEERROR, "Failed to append array.");
}
-
+
/* Final cleanup */
status = H5Tclose(datatype);
if (status < 0) {
@@ -1398,7 +1441,7 @@ int ismrmrd_read_array(const ISMRMRD_Dataset *dset, const char *varname,
return ISMRMRD_PUSH_ERR(ISMRMRD_HDF5ERROR, "Failed to close datatype.");
}
free(path);
-
+
return ISMRMRD_NOERROR;
}
diff --git a/libsrc/ismrmrd.c b/libsrc/ismrmrd.c
index b917496..3d687d4 100644
--- a/libsrc/ismrmrd.c
+++ b/libsrc/ismrmrd.c
@@ -426,7 +426,7 @@ size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr) {
}
for (n = 0; n < arr->ndim; n++) {
- num_data *= arr->dims[n];
+ num_data *= (int) (arr->dims[n]);
}
data_size = num_data * ismrmrd_sizeof_data_type(arr->data_type);
@@ -485,6 +485,14 @@ int ismrmrd_set_flag(uint64_t *flags, const uint64_t val) {
return ISMRMRD_NOERROR;
}
+int ismrmrd_set_flags(uint64_t *flags, const uint64_t val) {
+ if (flags==NULL) {
+ return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Pointer should not be NULL.");
+ }
+ *flags = val;
+ return ISMRMRD_NOERROR;
+}
+
int ismrmrd_clear_flag(uint64_t *flags, const uint64_t val) {
uint64_t bitmask;
if (flags==NULL) {
@@ -507,7 +515,7 @@ bool ismrmrd_is_channel_on(const uint64_t channel_mask[ISMRMRD_CHANNEL_MASKS], c
uint64_t bitmask;
size_t offset;
if (channel_mask==NULL) {
- ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Pointer to channel_mask should not be NULL.");
+ return ISMRMRD_PUSH_ERR(ISMRMRD_RUNTIMEERROR, "Pointer to channel_mask should not be NULL.");
}
bitmask = 1 << (chan % 64);
offset = chan / 64;
@@ -585,13 +593,13 @@ void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3],
/* Compute quaternion parameters */
/* http://www.cs.princeton.edu/~gewang/projects/darth/stuff/quat_faq.html#Q55 */
- trace = 1.0l + r11 + r22 + r33;
- if (trace > 0.00001l) { /* simplest case */
+ trace = 1.0 + r11 + r22 + r33;
+ if (trace > 0.00001) { /* simplest case */
s = sqrt(trace) * 2;
a = (r32 - r23) / s;
b = (r13 - r31) / s;
c = (r21 - r12) / s;
- d = 0.25l * s;
+ d = 0.25 * s;
} else {
/* trickier case...
* determine which major diagonal element has
@@ -602,7 +610,7 @@ void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3],
/* if r11 is the greatest */
if (xd > 1.0) {
s = 2.0 * sqrt(xd);
- a = 0.25l * s;
+ a = 0.25 * s;
b = (r21 + r12) / s;
c = (r31 + r13) / s;
d = (r32 - r23) / s;
@@ -611,7 +619,7 @@ void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3],
else if (yd > 1.0) {
s = 2.0 * sqrt(yd);
a = (r21 + r12) / s;
- b = 0.25l * s;
+ b = 0.25 * s;
c = (r32 + r23) / s;
d = (r13 - r31) / s;
}
@@ -620,11 +628,11 @@ void ismrmrd_directions_to_quaternion(float read_dir[3], float phase_dir[3],
s = 2.0 * sqrt(zd);
a = (r13 + r31) / s;
b = (r23 + r32) / s;
- c = 0.25l * s;
+ c = 0.25 * s;
d = (r21 - r12) / s;
}
- if (a < 0.0l) {
+ if (a < 0.0) {
b = -b;
c = -c;
d = -d;
diff --git a/libsrc/ismrmrd.cpp b/libsrc/ismrmrd.cpp
index aa63aed..baa6dd1 100644
--- a/libsrc/ismrmrd.cpp
+++ b/libsrc/ismrmrd.cpp
@@ -3,6 +3,7 @@
#include <sstream>
#include <stdexcept>
+#include <iostream>
#include "ismrmrd/ismrmrd.h"
namespace ISMRMRD {
@@ -201,33 +202,33 @@ float (&Acquisition::user_float()) [ISMRMRD_USER_FLOATS] {
}
// Sizes
-const size_t Acquisition::getNumberOfDataElements() {
+size_t Acquisition::getNumberOfDataElements() const {
size_t num = acq.head.number_of_samples * acq.head.active_channels;
return num;
}
-const size_t Acquisition::getDataSize() {
+size_t Acquisition::getDataSize() const {
size_t num = acq.head.number_of_samples * acq.head.active_channels;
return num*sizeof(complex_float_t);
}
-const size_t Acquisition::getNumberOfTrajElements() {
+size_t Acquisition::getNumberOfTrajElements() const {
size_t num = acq.head.number_of_samples * acq.head.trajectory_dimensions;
return num;
}
-const size_t Acquisition::getTrajSize() {
+size_t Acquisition::getTrajSize() const {
size_t num = acq.head.number_of_samples * acq.head.trajectory_dimensions;
return num*sizeof(float);
}
// Data and Trajectory accessors
-const AcquisitionHeader & Acquisition::getHead() {
+const AcquisitionHeader & Acquisition::getHead() const {
// This returns a reference
- return *static_cast<AcquisitionHeader *>(&acq.head);
+ return *static_cast<const AcquisitionHeader *>(&acq.head);
}
-void Acquisition::setHead(const AcquisitionHeader other) {
+void Acquisition::setHead(const AcquisitionHeader &other) {
memcpy(&acq.head, &other, sizeof(AcquisitionHeader));
if (ismrmrd_make_consistent_acquisition(&acq) != ISMRMRD_NOERROR) {
throw std::runtime_error(build_exception_string());
@@ -243,7 +244,11 @@ void Acquisition::resize(uint16_t num_samples, uint16_t active_channels, uint16_
}
}
-const complex_float_t * const Acquisition::getDataPtr() const {
+const complex_float_t * Acquisition::getDataPtr() const {
+ return acq.data;
+}
+
+complex_float_t * Acquisition::getDataPtr() {
return acq.data;
}
@@ -256,7 +261,11 @@ complex_float_t & Acquisition::data(uint16_t sample, uint16_t channel){
return acq.data[index];
}
-const float * const Acquisition::getTrajPtr() const {
+const float * Acquisition::getTrajPtr() const {
+ return acq.traj;
+}
+
+float * Acquisition::getTrajPtr() {
return acq.traj;
}
@@ -355,7 +364,7 @@ template <typename T> Image<T>::Image(uint16_t matrix_size_x,
if (ismrmrd_init_image(&im) != ISMRMRD_NOERROR) {
throw std::runtime_error(build_exception_string());
}
- im.head.data_type = get_data_type<T>();
+ im.head.data_type = static_cast<uint16_t>(get_data_type<T>());
resize(matrix_size_x, matrix_size_y, matrix_size_z, channels);
}
@@ -879,6 +888,10 @@ template <typename T> void Image<T>::setFlag(const uint64_t val) {
ismrmrd_set_flag(&(im.head.flags), val);
}
+template <typename T> void Image<T>::setFlags(const uint64_t val) {
+ ismrmrd_set_flags(&(im.head.flags), val);
+}
+
template <typename T> void Image<T>::clearFlag(const uint64_t val) {
ismrmrd_clear_flag(&(im.head.flags), val);
}
@@ -893,6 +906,11 @@ template <typename T> ImageHeader &Image<T>::getHead() {
return *static_cast<ImageHeader *>(&im.head);
}
+template <typename T> const ImageHeader &Image<T>::getHead() const {
+ // This returns a reference
+ return *static_cast<const ImageHeader *>(&im.head);
+}
+
template <typename T> void Image<T>::setHead(const ImageHeader &other) {
if (other.data_type != im.head.data_type) {
throw std::runtime_error("Cannot assign a header of a different data type.");
@@ -907,34 +925,48 @@ template <typename T> void Image<T>::setHead(const ImageHeader &other) {
// Attribute string
template <typename T> void Image<T>::getAttributeString(std::string &attr) const
{
- attr = std::string(im.attribute_string);
+ if (im.attribute_string)
+ attr.assign(im.attribute_string);
+ else
+ attr.assign("");
}
-template <typename T> void Image<T>::setAttributeString(const std::string attr)
+template <typename T> void Image<T>::setAttributeString(const std::string &attr)
{
- im.head.attribute_string_len = attr.length();
- im.attribute_string = (char *)realloc(im.attribute_string, attr.length()+1);
- // TODO error check?
- strcpy(im.attribute_string, attr.c_str());
+ size_t length = attr.length();
+ im.head.attribute_string_len = static_cast<uint32_t>(length);
+
+ // Add null terminating character
+ length++;
+
+ im.attribute_string = (char *)realloc(im.attribute_string, length);
+ if (NULL==im.attribute_string) {
+ throw std::runtime_error(build_exception_string());
+ }
+ strncpy(im.attribute_string, attr.c_str(), length);
}
-template <typename T> const size_t Image<T>::getAttributeStringLength()
+template <typename T> size_t Image<T>::getAttributeStringLength() const
{
return im.head.attribute_string_len;
}
// Data
-template <typename T> T * const Image<T>::getDataPtr() const {
+template <typename T> T * Image<T>::getDataPtr() {
return static_cast<T*>(im.data);
}
+template <typename T> const T * Image<T>::getDataPtr() const {
+ return static_cast<const T*>(im.data);
+}
+
template <typename T> size_t Image<T>::getNumberOfDataElements() const {
size_t num = 1;
num *= im.head.matrix_size[0];
num *= im.head.matrix_size[1];
num *= im.head.matrix_size[2];
num *= im.head.channels;
- return ismrmrd_size_of_image_data(&im);
+ return num;
}
template <typename T> size_t Image<T>::getDataSize() const {
@@ -965,7 +997,7 @@ template <typename T> NDArray<T>::NDArray()
if (ismrmrd_init_ndarray(&arr) != ISMRMRD_NOERROR) {
throw std::runtime_error(build_exception_string());
}
- arr.data_type = get_data_type<T>();
+ arr.data_type = static_cast<uint16_t>(get_data_type<T>());
}
template <typename T> NDArray<T>::NDArray(const std::vector<size_t> dimvec)
@@ -973,7 +1005,7 @@ template <typename T> NDArray<T>::NDArray(const std::vector<size_t> dimvec)
if (ismrmrd_init_ndarray(&arr) != ISMRMRD_NOERROR) {
throw std::runtime_error(build_exception_string());
}
- arr.data_type = get_data_type<T>();
+ arr.data_type = static_cast<uint16_t>(get_data_type<T>());
resize(dimvec);
}
@@ -1015,15 +1047,15 @@ template <typename T> NDArray<T> & NDArray<T>::operator= (const NDArray<T> &othe
return *this;
}
-template <typename T> const uint16_t NDArray<T>::getVersion() {
+template <typename T> uint16_t NDArray<T>::getVersion() const {
return arr.version;
};
-template <typename T> const ISMRMRD_DataTypes NDArray<T>::getDataType() {
+template <typename T> ISMRMRD_DataTypes NDArray<T>::getDataType() const {
return static_cast<ISMRMRD_DataTypes>( arr.data_type );
}
-template <typename T> const uint16_t NDArray<T>::getNDim() {
+template <typename T> uint16_t NDArray<T>::getNDim() const {
return arr.ndim;
};
@@ -1035,7 +1067,7 @@ template <typename T> void NDArray<T>::resize(const std::vector<size_t> dimvec)
if (dimvec.size() > ISMRMRD_NDARRAY_MAXDIM) {
throw std::runtime_error("Input vector dimvec is too long.");
}
- arr.ndim = dimvec.size();
+ arr.ndim = static_cast<uint16_t>(dimvec.size());
for (int n=0; n<arr.ndim; n++) {
arr.dims[n] = dimvec[n];
}
@@ -1048,14 +1080,22 @@ template <typename T> T * NDArray<T>::getDataPtr() {
return static_cast<T*>(arr.data);
}
-template <typename T> const size_t NDArray<T>::getDataSize() {
+template <typename T> const T * NDArray<T>::getDataPtr() const {
+ return static_cast<T*>(arr.data);
+}
+
+template <typename T> size_t NDArray<T>::getDataSize() const {
return ismrmrd_size_of_ndarray_data(&arr);
}
-template <typename T> const size_t NDArray<T>::getNumberOfElements() {
+template <typename T> size_t NDArray<T>::getNumberOfElements() const {
size_t num = 1;
for (int n = 0; n < arr.ndim; n++) {
- num *= arr.dims[n];
+ size_t v = arr.dims[n];
+ // This is necessary to prevent bad GCC loop optimization!
+ if (v > 0) {
+ num *= v;
+ }
}
return num;
}
diff --git a/libsrc/xml.cpp b/libsrc/xml.cpp
index 0bab44e..5e6a3d7 100644
--- a/libsrc/xml.cpp
+++ b/libsrc/xml.cpp
@@ -528,10 +528,10 @@ namespace ISMRMRD
a = root.append_attribute("xsi:schemaLocation");
a.set_value("http://www.ismrm.org/ISMRMRD ismrmrd.xsd");
- a = root.append_attribute("version");
- a.set_value(ISMRMRD_XMLHDR_VERSION);
-
if (h.version) {
+ if (*h.version != ISMRMRD_XMLHDR_VERSION) {
+ throw std::runtime_error("XML header version does not match library schema version.");
+ }
append_optional_node(root,"version",h.version);
}
diff --git a/utilities/CMakeLists.txt b/utilities/CMakeLists.txt
index f385a37..2257dec 100644
--- a/utilities/CMakeLists.txt
+++ b/utilities/CMakeLists.txt
@@ -20,7 +20,7 @@ if (NOT WIN32)
install(TARGETS ismrmrd_test_xml DESTINATION bin)
endif(NOT WIN32)
-find_package(Boost COMPONENTS program_options)
+find_package(Boost 1.43 COMPONENTS program_options)
find_package(FFTW3 COMPONENTS single)
if(FFTW3_FOUND AND Boost_FOUND)
diff --git a/utilities/generate_cartesian_shepp_logan.cpp b/utilities/generate_cartesian_shepp_logan.cpp
index 0199e0e..c5028f1 100644
--- a/utilities/generate_cartesian_shepp_logan.cpp
+++ b/utilities/generate_cartesian_shepp_logan.cpp
@@ -39,8 +39,8 @@ int main(int argc, char** argv)
float noise_level;
std::string outfile;
std::string dataset;
- bool store_coordinates;
- bool noise_calibration;
+ bool store_coordinates = false;
+ bool noise_calibration = false;
po::options_description desc("Allowed options");
desc.add_options()
@@ -181,7 +181,7 @@ int main(int argc, char** argv)
e.reconSpace.fieldOfView_mm.z = 6;
e.trajectory = "cartesian";
e.encodingLimits.kspace_encoding_step_1 = Limit(0, matrix_size-1,(matrix_size>>1));
- e.encodingLimits.repetition = Limit(0, repetitions*acc_factor,0);
+ e.encodingLimits.repetition = Limit(0, repetitions*acc_factor - 1,0);
//e.g. parallel imaging
if (acc_factor > 1) {
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/ismrmrd.git
More information about the debian-med-commit
mailing list