RNifti
Fast R and C++ Access to NIfTI Images
|
1 #ifndef _NIFTI_IMAGE_H_
2 #define _NIFTI_IMAGE_H_
12 #define MAYBE_SHARED(x) (NAMED(x) > 1)
17 #define R_NegInf -INFINITY
44 typedef std::complex<float> complex64_t;
45 typedef std::complex<double> complex128_t;
57 unsigned char bytes[4];
83 virtual size_t size ()
const {
return 0; }
84 virtual bool hasNaN ()
const {
return false; }
85 virtual complex128_t getComplex (
void *ptr)
const {
return complex128_t(0.0, 0.0); }
86 virtual double getDouble (
void *ptr)
const {
return 0.0; }
87 virtual int getInt (
void *ptr)
const {
return 0; }
89 virtual void setComplex (
void *ptr,
const complex128_t value)
const {}
90 virtual void setDouble (
void *ptr,
const double value)
const {}
91 virtual void setInt (
void *ptr,
const int value)
const {}
92 virtual void setRgb (
void *ptr,
const rgba32_t value)
const {}
93 virtual void minmax (
void *ptr,
const size_t length,
double *min,
double *max)
const { *min = 0.0; *max = 0.0; }
99 template <
typename Type,
bool alpha = false>
102 size_t size ()
const {
return (
sizeof(Type)); }
103 bool hasNaN ()
const {
return std::numeric_limits<Type>::has_quiet_NaN; }
104 complex128_t getComplex (
void *ptr)
const {
return complex128_t(
static_cast<double>(*
static_cast<Type*
>(ptr)), 0.0); }
105 double getDouble (
void *ptr)
const {
return static_cast<double>(*
static_cast<Type*
>(ptr)); }
106 int getInt (
void *ptr)
const {
return static_cast<int>(*
static_cast<Type*
>(ptr)); }
107 void setComplex (
void *ptr,
const complex128_t value)
const
109 *(
static_cast<Type*
>(ptr)) = Type(value.real());
110 *(
static_cast<Type*
>(ptr) + 1) = Type(0);
112 void setDouble (
void *ptr,
const double value)
const { *(
static_cast<Type*
>(ptr)) = Type(value); }
113 void setInt (
void *ptr,
const int value)
const { *(
static_cast<Type*
>(ptr)) = Type(value); }
114 void minmax (
void *ptr,
const size_t length,
double *min,
double *max)
const;
117 template <
typename ElementType>
120 size_t size ()
const {
return (
sizeof(ElementType) * 2); }
121 bool hasNaN ()
const {
return std::numeric_limits<ElementType>::has_quiet_NaN; }
122 std::complex<ElementType> getNative (
void *ptr)
const
124 const ElementType real = *
static_cast<ElementType*
>(ptr);
125 const ElementType imag = *(
static_cast<ElementType*
>(ptr) + 1);
126 return std::complex<ElementType>(real, imag);
128 void setNative (
void *ptr,
const std::complex<ElementType> native)
const
130 *(
static_cast<ElementType*
>(ptr)) = native.real();
131 *(
static_cast<ElementType*
>(ptr) + 1) = native.imag();
133 complex128_t getComplex (
void *ptr)
const {
return complex128_t(getNative(ptr)); }
134 double getDouble (
void *ptr)
const {
return static_cast<double>(getNative(ptr).real()); }
135 int getInt (
void *ptr)
const {
return static_cast<int>(getNative(ptr).real()); }
136 void setComplex (
void *ptr,
const complex128_t value)
const { setNative(ptr, std::complex<ElementType>(value)); }
137 void setDouble (
void *ptr,
const double value)
const { setNative(ptr, std::complex<ElementType>(value, 0.0)); }
138 void setInt (
void *ptr,
const int value)
const { setNative(ptr, std::complex<ElementType>(
static_cast<ElementType
>(value), 0.0)); }
139 void minmax (
void *ptr,
const size_t length,
double *min,
double *max)
const;
142 template <
bool alpha>
145 size_t size ()
const {
return alpha ? 4 : 3; }
146 int getInt (
void *ptr)
const {
return getRgb(ptr).value.packed; }
150 unsigned char *source =
static_cast<unsigned char *
>(ptr);
151 std::copy(source, source + (alpha ? 4 : 3), value.value.bytes);
154 void setInt (
void *ptr,
const int value)
const
157 native.value.packed = value;
160 void setRgb (
void *ptr,
const rgba32_t value)
const
162 unsigned char *target =
static_cast<unsigned char *
>(ptr);
163 std::copy(value.value.bytes, value.value.bytes + (alpha ? 4 : 3), target);
165 void minmax (
void *ptr,
const size_t length,
double *min,
double *max)
const { *min = 0.0; *max = 255.0; }
196 throw std::runtime_error(
"Unsupported data type (" + std::string(nifti_datatype_string(
_datatype)) +
")");
227 else if (alloc && data == NULL)
249 double dataMin, dataMax, typeMin, typeMax;
250 data.
minmax(&dataMin, &dataMax);
251 handler->minmax(NULL, 0, &typeMin, &typeMax);
254 if (dataMin < typeMin || dataMax > typeMax)
256 slope = (dataMax - dataMin) / (typeMax - typeMin);
282 this->ptr = (ptr == NULL ? parent.
dataPtr : ptr);
292 template <
typename SourceType>
305 template <
typename TargetType>
306 operator TargetType()
const
310 else if (std::numeric_limits<TargetType>::is_integer)
311 return TargetType(parent.
handler->getInt(ptr));
313 return TargetType(parent.
handler->getDouble(ptr));
316 template <
typename ElementType>
317 operator std::complex<ElementType>()
const
322 return std::complex<ElementType>(parent.
handler->getComplex(ptr));
329 operator Rcomplex()
const
331 const complex128_t value = parent.
handler->getComplex(ptr);
332 Rcomplex rValue = { value.real(), value.imag() };
344 return parent.
handler->getRgb(ptr);
351 class Iterator :
public std::iterator<std::random_access_iterator_tag, Element>
369 this->ptr = (ptr == NULL ? parent.
dataPtr : ptr);
370 this->step = (step == 0 ? parent.
handler->size() : step);
378 : parent(other.parent), ptr(other.ptr), step(other.step) {}
380 Iterator & operator++ () { ptr =
static_cast<char*
>(ptr) + step;
return *
this; }
381 Iterator operator++ (
int) {
Iterator copy(*
this); ptr =
static_cast<char*
>(ptr) + step;
return copy; }
382 Iterator operator+ (ptrdiff_t n)
const
384 void *newptr =
static_cast<char*
>(ptr) + (n * step);
385 return Iterator(parent, newptr, step);
387 Iterator & operator-- () { ptr =
static_cast<char*
>(ptr) - step;
return *
this; }
388 Iterator operator-- (
int) {
Iterator copy(*
this); ptr =
static_cast<char*
>(ptr) - step;
return copy; }
389 Iterator operator- (ptrdiff_t n)
const
391 void *newptr =
static_cast<char*
>(ptr) - (n * step);
392 return Iterator(parent, newptr, step);
395 ptrdiff_t operator- (
const Iterator &other)
const
397 const ptrdiff_t difference =
static_cast<char*
>(ptr) -
static_cast<char*
>(other.ptr);
398 return difference / step;
401 bool operator== (
const Iterator &other)
const {
return (ptr==other.ptr && step==other.step); }
402 bool operator!= (
const Iterator &other)
const {
return (ptr!=other.ptr || step!=other.step); }
403 bool operator> (
const Iterator &other)
const {
return (ptr > other.ptr); }
404 bool operator< (
const Iterator &other)
const {
return (ptr < other.ptr); }
406 const Element operator* ()
const {
return Element(parent, ptr); }
407 Element operator* () {
return Element(parent, ptr); }
408 const Element operator[] (
const size_t i)
const {
return Element(parent,
static_cast<char*
>(ptr) + (i * step)); }
409 Element operator[] (
const size_t i) {
return Element(parent,
static_cast<char*
>(ptr) + (i * step)); }
439 init(NULL, 0, DT_NONE, 0.0, 0.0,
false);
441 init(image->data, image->nvox, image->datatype,
static_cast<double>(image->scl_slope),
static_cast<double>(image->scl_inter),
false);
460 std::copy(source.
begin(), source.
end(), this->begin());
470 template <
class InputIterator>
473 const size_t length =
static_cast<size_t>(std::distance(from, to));
475 std::copy(from, to, this->
begin());
600 void minmax (
double *min,
double *max)
const
616 inline bool NiftiImageData::ConcreteTypeHandler<int>::hasNaN ()
const {
return true; }
624 template <
typename ElementType,
int Length>
628 ElementType elements[Length];
636 std::fill(elements, elements + Length, value);
644 std::copy(source, source + Length, this->elements);
653 for (
int i=0; i<Length; i++)
654 result.elements[i] = -elements[i];
658 const ElementType & operator[] (
const size_t i)
const {
return elements[i]; }
660 ElementType & operator[] (
const size_t i) {
return elements[i]; }
670 template <
class NiftiType,
typename ElementType,
int Order>
710 std::copy(source, source + Order*Order, this->elements);
718 const ElementType *castSource = (
const ElementType *) *source.m;
719 std::copy(castSource, castSource + Order*Order, this->elements);
728 Rcpp::NumericMatrix matrix(source);
729 if (matrix.cols() != Order && matrix.rows() != Order)
730 throw std::runtime_error(
"Matrix does not have the expected dimensions");
731 for (
int i=0; i<Order; i++)
733 for (
int j=0; j<Order; j++)
734 elements[j + i*Order] = matrix(i,j);
743 operator const NiftiType ()
const {
return niftiCopy(); }
766 const ElementType *
end ()
const {
return elements + Order*Order; }
779 for (
int i=0; i<Order; i++)
809 operator SEXP ()
const
811 Rcpp::NumericMatrix result(Order, Order);
812 for (
int i=0; i<Order; i++)
814 for (
int j=0; j<Order; j++)
815 result(i,j) =
elements[j + i*Order];
824 #include "RNifti/NiftiImage_matrix.h"
836 #if RNIFTI_NIFTILIB_VERSION == 1
838 typedef float pixdim_t;
839 typedef float scale_t;
840 #elif RNIFTI_NIFTILIB_VERSION == 2
841 typedef int64_t dim_t;
842 typedef double pixdim_t;
843 typedef double scale_t;
867 throw std::runtime_error(
"Blocks must be along the last dimension in the image");
880 if (source->datatype !=
image->datatype)
881 throw std::runtime_error(
"New data does not have the same datatype as the target block");
882 if (source->scl_slope !=
image->scl_slope || source->scl_inter !=
image->scl_inter)
883 throw std::runtime_error(
"New data does not have the same scale parameters as the target block");
885 size_t blockSize = 1;
889 if (blockSize != source->nvox)
890 throw std::runtime_error(
"New data does not have the same size as the target block");
892 blockSize *=
image->nbyper;
907 size_t blockSize = 1;
921 template <
typename TargetType>
922 std::vector<TargetType>
getData (
const bool useSlope =
true)
const;
934 #if RNIFTI_NIFTILIB_VERSION == 1
935 typedef float Element;
940 #elif RNIFTI_NIFTILIB_VERSION == 2
941 typedef double Element;
963 : forward(NULL), inverse(NULL),
qparams(NULL),
mat() {}
969 : forward(NULL), inverse(NULL),
qparams(NULL),
mat(source) {}
974 Xform (
const Matrix::NativeType &source)
975 : forward(NULL), inverse(NULL),
qparams(NULL),
mat(source) {}
982 : forward(*source.m), inverse(NULL),
qparams(NULL),
mat(source) {}
988 Xform (Matrix::NativeType &source, Matrix::NativeType &inverse, Element *
qparams = NULL)
996 : forward(NULL), inverse(NULL),
qparams(NULL),
mat(Matrix(source)) {}
1003 operator const Matrix::NativeType ()
const {
return mat; }
1009 operator Matrix::NativeType () {
return mat; }
1086 if (sexpType == INTSXP || sexpType == LGLSXP)
1088 else if (sexpType == REALSXP)
1090 else if (sexpType == CPLXSXP)
1091 return DT_COMPLEX128;
1093 throw std::runtime_error(
"Array elements must be numeric");
1138 void copy (
const nifti_image *source);
1224 Rc_printf(
"Creating NiftiImage (v%d) with pointer %p (from NiftiImage)\n", RNIFTI_NIFTILIB_VERSION, this->image);
1237 Rc_printf(
"Creating NiftiImage (v%d) with pointer %p (from Block)\n", RNIFTI_NIFTILIB_VERSION, this->image);
1255 Rc_printf(
"Creating NiftiImage (v%d) with pointer %p (from pointer)\n", RNIFTI_NIFTILIB_VERSION, this->image);
1279 NiftiImage (
const std::string &path,
const bool readData =
true);
1287 NiftiImage (
const std::string &path,
const std::vector<dim_t> &volumes);
1300 NiftiImage (
const SEXP
object,
const bool readData =
true,
const bool readOnly =
false);
1312 operator const nifti_image* ()
const {
return image; }
1317 operator nifti_image* () {
return image; }
1337 Rc_printf(
"Creating NiftiImage (v%d), with pointer %p (from NiftiImage)\n", RNIFTI_NIFTILIB_VERSION, this->image);
1351 Rc_printf(
"Creating NiftiImage (v%d) with pointer %p (from Block)\n", RNIFTI_NIFTILIB_VERSION, this->image);
1408 std::vector<dim_t>
dim ()
const
1411 return std::vector<dim_t>();
1423 return std::vector<pixdim_t>();
1425 return std::vector<pixdim_t>(
image->pixdim+1,
image->pixdim+
image->ndim+1);
1436 int ndim =
image->ndim;
1437 while (
image->dim[ndim] < 2)
1465 template <
typename TargetType>
1466 std::vector<TargetType>
getData (
const bool useSlope =
true)
const;
1494 template <
typename SourceType>
1512 #if RNIFTI_NIFTILIB_VERSION == 1
1513 nifti_image_unload(
image);
1514 #elif RNIFTI_NIFTILIB_VERSION == 2
1515 nifti2_image_unload(
image);
1652 switch (
image->datatype)
1654 case DT_NONE:
return 0;
1655 case DT_RGB24:
return 3;
1656 case DT_RGBA32:
return 4;
1676 std::pair<std::string,std::string>
toFile (
const std::string fileName,
const int datatype = DT_NONE,
const int filetype = -1)
const;
1686 std::pair<std::string,std::string>
toFile (
const std::string fileName,
const std::string &datatype,
const int filetype = -1)
const;
1716 #include "RNifti/NiftiImage_impl.h"
const Xform sform() const
Access the sform matrix.
Definition: NiftiImage.h:1581
MatrixType operator*(const MatrixType &other) const
Matrix-matrix multiplication (infix shorthand)
Definition: NiftiImage.h:792
NiftiImage(const std::string &path, const std::vector< dim_t > &volumes)
Initialise using a path string and sequence of required volumes.
NiftiImage & rescale(const std::vector< pixdim_t > &scales)
Rescale the image, changing its image dimensions and pixel dimensions.
void release()
Release the currently wrapped pointer, if it is not NULL, decrementing the reference count and releas...
bool isScaled() const
Determine whether the object uses data scaling.
Definition: NiftiImage.h:528
Inner class referring to a subset of an image.
Definition: NiftiImage.h:851
NiftiImage(const Block &source)
Initialise from a block, copying in the data.
Definition: NiftiImage.h:1232
std::pair< std::string, std::string > toFile(const std::string fileName, const std::string &datatype, const int filetype=-1) const
Write the image to a NIfTI-1 file.
ElementType colnorm() const
Maximum column norm, as implemented in niftilib (Order 3 only)
std::vector< dim_t > dim() const
Return the dimensions of the image.
Definition: NiftiImage.h:1408
bool isComplex() const
Determine whether the datatype is complex.
Definition: NiftiImage.h:534
NiftiImageData & operator=(const NiftiImageData &source)
Copy assignment operator.
Definition: NiftiImage.h:493
Xform(Matrix::NativeType &source, Matrix::NativeType &inverse, Element *qparams=NULL)
Initialise from forward and backward matrices, and optionally quaternion parameters.
Definition: NiftiImage.h:988
nifti_image * image
The wrapped nifti_image pointer.
Definition: NiftiImage.h:1107
SquareMatrix(const ElementType *source)
Initialise from a C-style array of the appropriate type and length.
Definition: NiftiImage.h:708
Iterator type for NiftiImageData, with Element as its value type.
Definition: NiftiImage.h:352
const ElementType & operator()(const int i, const int j) const
Indexing operator.
Definition: NiftiImage.h:798
SquareMatrix(SEXP source)
Initialise from an R object representing a numeric matrix.
Definition: NiftiImage.h:726
Xform qform()
Access the qform matrix.
Definition: NiftiImage.h:1575
Block block(const int i)
Extract a block from the image.
Definition: NiftiImage.h:1611
const Block volume(const int i) const
Extract a volume block from a 4D image.
Definition: NiftiImage.h:1632
Xform(const Matrix::NativeType &source)
Initialise from a constant NIfTI mat44 or dmat44.
Definition: NiftiImage.h:974
NiftiImage & dropData()
Drop the data from the image, retaining only the metadata.
Definition: NiftiImage.h:1510
int * refCount
A reference counter, shared with other objects wrapping the same pointer.
Definition: NiftiImage.h:1108
Submatrix rotation() const
Obtain the 3x3 rotation matrix from the xform matrix, with scale and skew components removed.
std::string orientation() const
Obtain the approximate orientation of the image's coordinate frame, as a three-character string consi...
Element(const NiftiImageData &parent, void *ptr=NULL)
Primary constructor.
Definition: NiftiImage.h:279
NiftiImage & operator=(const NiftiImage &source)
Copy assignment operator, which copies from its argument.
Definition: NiftiImage.h:1333
NiftiImage(const std::string &path, const bool readData=true)
Initialise using a path string.
NiftiImage(const NiftiImage &source, const bool copy=true)
Copy constructor.
Definition: NiftiImage.h:1216
NiftiImage & changeDatatype(const int datatype, const bool useSlope=false)
Change the datatype of the image, casting the pixel data if present.
NiftiImageData(void *data, const size_t length, const int datatype, const double slope=1.0, const double intercept=0.0)
Primary constructor.
Definition: NiftiImage.h:427
Vector3 spacing() const
Obtain the pixel spacing of the image in each spatial dimension.
void updatePixdim(const std::vector< pixdim_t > &pixdim)
Modify the pixel dimensions, and potentially the xform matrices to match.
Abstract inner class defining the type-specific functions required in concrete subclasses.
Definition: NiftiImage.h:81
const Iterator end() const
Obtain a constant iterator corresponding to the end of the blob.
Definition: NiftiImage.h:571
Vector< ElementType, Length > operator-() const
Unary negation operator, which reverses the signs of all elements.
Definition: NiftiImage.h:650
Thin wrapper around a C-style nifti_image struct that allows C++-style destruction.
Definition: NiftiImage.h:834
Vector3 offset() const
Obtain the translation component of the xform matrix.
Simple RGB(A) type encapsulating an 8-bit colour value with optional opacity, which can also be set o...
Definition: NiftiImage.h:54
NiftiImageData(InputIterator from, InputIterator to, const int datatype)
Iterator-based constructor.
Definition: NiftiImage.h:471
bool isFloatingPoint() const
Determine whether the datatype is floating point.
Definition: NiftiImage.h:541
VectorType multiply(const VectorType &vec) const
Matrix-vector multiplication.
size_t size() const
Return the number of elements in the data.
Definition: NiftiImage.h:509
MatrixType polar() const
Polar decomposition, as implemented in niftilib (Order 3 only)
bool isNull() const
Determine whether or not the wrapped pointer is NULL.
Definition: NiftiImage.h:1369
void copy(const nifti_image *source)
Copy the contents of a nifti_image to create a new image, acquiring the new pointer.
void setPixunits(const std::vector< std::string > &pixunits)
Modify the pixel dimension units.
SquareMatrix(const NiftiType &source)
Initialise from the appropriate niftilib type.
Definition: NiftiImage.h:716
NiftiImage & replaceData(const std::vector< SourceType > &data, const int datatype=DT_NONE)
Replace the pixel data in the image with the contents of a vector.
size_t length() const
Return the number of elements in the data.
Definition: NiftiImage.h:508
double slope
The slope term used to scale data values.
Definition: NiftiImage.h:73
Block slice(const int i)
Extract a slice block from a 3D image.
Definition: NiftiImage.h:1625
Rcpp::RObject toPointer(const std::string label) const
Create an internal image to pass back to R.
const Element operator[](const size_t i) const
Indexing operator, returning a constant element.
Definition: NiftiImage.h:584
static MatrixType eye()
Construct an identity matrix of the appropriate size.
Definition: NiftiImage.h:776
void acquire(const NiftiImage &source)
Acquire the same pointer as another NiftiImage, incrementing the shared reference count.
Definition: NiftiImage.h:1122
NiftiImageData(const NiftiImageData &source, const int datatype=DT_NONE)
Copy constructor with optional type conversion.
Definition: NiftiImage.h:451
bool isShared() const
Determine whether the wrapped pointer is shared with another NiftiImage.
Definition: NiftiImage.h:1375
double intercept
The intercept term used to scale data values.
Definition: NiftiImage.h:74
dim_t nBlocks() const
Return the number of blocks in the image.
Definition: NiftiImage.h:1593
const Matrix & matrix() const
Access the xform matrix as an immutable SquareMatrix object.
Definition: NiftiImage.h:1032
Iterator end()
Obtain a mutable iterator corresponding to the end of the blob.
Definition: NiftiImage.h:577
Rcpp::RObject toArrayOrPointer(const bool internal, const std::string label) const
A conditional method that calls either toArray or toPointer.
std::pair< std::string, std::string > toFile(const std::string fileName, const int datatype=DT_NONE, const int filetype=-1) const
Write the image to a NIfTI-1 file.
NiftiImage & reorient(const std::string &orientation)
Reorient the image by permuting dimensions and potentially reversing some.
ElementType rownorm() const
Maximum row norm, as implemented in niftilib (Order 3 only)
Xform(const Matrix &source)
Initialise from a 4x4 SquareMatrix.
Definition: NiftiImage.h:968
std::vector< TargetType > getData(const bool useSlope=true) const
Extract a vector of data from the image, casting it to any required element type.
Inner class representing a single element in the data blob.
Definition: NiftiImage.h:267
Submatrix submatrix() const
Obtain the upper left 3x3 submatrix from the xform matrix.
Element handedness() const
Returns the qfac value, which should be 1 where the xform matrix represents a right-handed coordinate...
NiftiImage & update(const Rcpp::RObject &object)
Update the image from an R array.
Vector4 quaternion() const
Obtain the quaternion representation of the xform's rotation component.
const NiftiImageData data() const
Obtain the pixel data within the image.
Definition: NiftiImage.h:1448
NiftiImage & reorient(const int i, const int j, const int k)
Reorient the image by permuting dimensions and potentially reversing some.
size_t _length
The number of data elements in the blob.
Definition: NiftiImage.h:203
bool isRgb() const
Determine whether the datatype corresponds to an RGB type.
Definition: NiftiImage.h:553
MatrixType inverse() const
Matrix inverse.
NiftiType NativeType
The niftilib structure type corresponding to this matrix.
Definition: NiftiImage.h:693
NiftiImage(nifti_image *const image, const bool copy=false)
Initialise using an existing nifti_image pointer.
Definition: NiftiImage.h:1247
SquareMatrix< NiftiType, ElementType, Order > MatrixType
Type alias for the current specialisation.
Definition: NiftiImage.h:694
Wrapper class encapsulating a NIfTI data blob, with responsibility for handling data scaling and poly...
Definition: NiftiImage.h:71
Rcpp::RObject toArray() const
Create an R array from the image.
NiftiImageData data() const
Obtain the data within the block.
Definition: NiftiImage.h:901
const Block block(const int i) const
Extract a block from the image.
Definition: NiftiImage.h:1602
A simple object-oriented wrapper around a fixed-length array.
Definition: NiftiImage.h:626
bool isInteger() const
Determine whether the datatype is an integer type.
Definition: NiftiImage.h:547
NiftiType * niftiPointer() const
Obtain a pointer to a NIfTI-style mat44 or dmat44 encapsulating the same data as this object.
Definition: NiftiImage.h:680
SquareMatrix(const ElementType value=0.0)
Initialise with a fixed element value, defaulting to zero.
Definition: NiftiImage.h:700
NiftiImage & setPersistence(const bool persistent)
Mark the image as persistent, so that it can be passed back to R.
Definition: NiftiImage.h:1363
NiftiImage & replaceData(const NiftiImageData &data)
Replace the pixel data in the image with the contents of a NiftiImageData object.
Block volume(const int i)
Extract a volume block from a 4D image.
Definition: NiftiImage.h:1639
NiftiImageData unscaled() const
Return a similar object to the callee, but with the slope and intercept values reset.
Definition: NiftiImage.h:559
virtual ~NiftiImage()
Destructor which decrements the reference counter, and releases the wrapped pointer if the counter dr...
Definition: NiftiImage.h:1307
Vector(const ElementType value=0.0)
Initialise with a fixed element value, defaulting to zero.
Definition: NiftiImage.h:634
NiftiImage & changeDatatype(const std::string &datatype, const bool useSlope=false)
Change the datatype of the image, casting the pixel data if present.
Element * qparams
Pointers to linked C-style arrays.
Definition: NiftiImage.h:949
NiftiImageData & disown()
Disown the data blob, removing responsibility for freeing it upon destruction.
Definition: NiftiImage.h:565
bool isDataScaled() const
Determine whether nontrivial scale and slope parameters are set.
Definition: NiftiImage.h:1390
Matrix mat
The full xform matrix underpinning this object.
Definition: NiftiImage.h:950
void acquire(nifti_image *const image)
Acquire the specified pointer to a nifti_image struct, taking (possibly shared) responsibility for fr...
Iterator begin()
Obtain a mutable iterator corresponding to the start of the blob.
Definition: NiftiImage.h:574
const Xform xform(const bool preferQuaternion=true) const
Obtain an xform matrix, indicating the orientation of the image.
Concrete inner class template defining behaviour specific to individual data types.
Definition: NiftiImage.h:101
const dim_t index
The location along dimension.
Definition: NiftiImage.h:854
TypeHandler * createHandler()
Create a concrete type handler appropriate to the datatype code stored with the data.
Definition: NiftiImage.h:173
Definition: NiftiImage.h:55
static int fileVersion(const std::string &path)
Get the NIfTI format version used by the file at the specified path.
Xform()
Default constructor.
Definition: NiftiImage.h:962
std::vector< TargetType > getData(const bool useSlope=true) const
Extract a vector of data from a block, casting it to any required element type.
NiftiImage()
Default constructor.
Definition: NiftiImage.h:1207
const nifti_image * operator->() const
Allows a NiftiImage object to be treated as a pointer to a const nifti_image.
Definition: NiftiImage.h:1322
void replace(const Matrix &source)
Replace the current matrix with a new one.
void * dataPtr
Opaque pointer to the underlying data blob.
Definition: NiftiImage.h:200
int datatype() const
Return stored datatype code.
Definition: NiftiImage.h:507
Xform & operator=(const Xform &source)
Copy assignment operator, taking an Xform and replacing linked data.
Definition: NiftiImage.h:1014
Block & operator=(const NiftiImage &source)
Copy assignment operator, which allows a block in one image to be replaced with the contents of anoth...
Definition: NiftiImage.h:878
TypeHandler * handler
Type handler, which is created to match the datatype.
Definition: NiftiImage.h:202
size_t nVoxels() const
Return the number of voxels in the image.
Definition: NiftiImage.h:1666
MatrixType multiply(const MatrixType &other) const
Matrix-matrix multiplication.
size_t totalBytes() const
Return the total size of the data blob, in bytes.
Definition: NiftiImage.h:515
Vector< ElementType, Order > VectorType
Type of vectors for which this matrix is a linear operator.
Definition: NiftiImage.h:695
void calibrateFrom(const NiftiImageData &data)
Update the slope and intercept to cover the range of another data object.
Definition: NiftiImage.h:242
void initFromMriImage(const Rcpp::RObject &object, const bool copyData=true)
Initialise the object from a reference object of class "MriImage".
ElementType elements[Order *Order]
The underlying raw data elements, stored row-major for consistency with niftilib.
Definition: NiftiImage.h:674
size_t bytesPerPixel() const
Return the number of bytes used per element, or zero if the datatype is undefined or the blob is NULL...
Definition: NiftiImage.h:512
void init(void *data, const size_t length, const int datatype, const double slope, const double intercept, const bool alloc=true)
Initialiser method, used by constructors.
Definition: NiftiImage.h:216
Inner class representing an xform matrix, which indicates the orientation and other spatial propertie...
Definition: NiftiImage.h:932
ElementType * end()
Return a pointer/iterator to the end of the data.
Definition: NiftiImage.h:771
bool owner
An indicator of whether this object is responsible for cleaning up the data.
Definition: NiftiImage.h:204
Class representing a numeric square matrix of a fixed order.
Definition: NiftiImage.h:672
const NiftiImage & image
The parent image.
Definition: NiftiImage.h:852
Xform(SEXP source)
Initialise from an R numeric matrix object.
Definition: NiftiImage.h:995
NiftiImageData(nifti_image *image)
Convenience constructor for a nifti_image.
Definition: NiftiImage.h:436
void * blob() const
Return an opaque pointer to the blob.
Definition: NiftiImage.h:506
NiftiImage(const std::vector< dim_t > &dim, const std::string &datatype)
Initialise from basic metadata, allocating and zeroing pixel data.
std::vector< pixdim_t > pixdim() const
Return the dimensions of the pixels or voxels in the image.
Definition: NiftiImage.h:1420
void minmax(double *min, double *max) const
Calculate the minimum and maximum values in the blob, as doubles.
Definition: NiftiImage.h:600
ElementType determ() const
Matrix determinant, as implemented in niftilib (Order 3 only)
Xform(Matrix::NativeType &source)
Initialise from a NIfTI mat44 or dmat44.
Definition: NiftiImage.h:981
int nDims() const
Return the number of dimensions in the image.
Definition: NiftiImage.h:1396
ElementType * begin()
Return a pointer/iterator to the beginning of the data.
Definition: NiftiImage.h:761
Iterator(const Iterator &other)
Copy constructor.
Definition: NiftiImage.h:377
NiftiImage(const SEXP object, const bool readData=true, const bool readOnly=false)
Initialise from an R object, retrieving an existing image from an external pointer attribute if avail...
Iterator(const NiftiImageData &parent, void *ptr=NULL, const size_t step=0)
Primary constructor.
Definition: NiftiImage.h:366
NiftiImage & drop()
Drop unitary dimensions.
Definition: NiftiImage.h:1434
void initFromNiftiS4(const Rcpp::RObject &object, const bool copyData=true)
Initialise the object from an S4 object of class "nifti".
Xform sform()
Access the sform matrix.
Definition: NiftiImage.h:1587
void initFromArray(const Rcpp::RObject &object, const bool copyData=true)
Initialise the object from an R array.
void initFromList(const Rcpp::RObject &object)
Initialise the object from an R list with named elements, which can only contain metadata.
NiftiImageData data()
Obtain the pixel data within the image.
Definition: NiftiImage.h:1454
int nChannels() const
Return the number of colour channels used by the image.
Definition: NiftiImage.h:1646
const ElementType * begin() const
Return a pointer/iterator to the beginning of the data.
Definition: NiftiImage.h:755
void copy(const NiftiImage &source)
Copy the contents of another NiftiImage to create a new image, acquiring a new pointer.
const Xform qform() const
Access the qform matrix.
Definition: NiftiImage.h:1569
const int dimension
The dimension along which the block applies (which should be the last)
Definition: NiftiImage.h:853
Block(const NiftiImage &image, const int dimension, const dim_t index)
Standard constructor for this class.
Definition: NiftiImage.h:863
const Block slice(const int i) const
Extract a slice block from a 3D image.
Definition: NiftiImage.h:1618
bool isPersistent() const
Determine whether or not the image is marked as persistent.
Definition: NiftiImage.h:1383
Element & operator=(const SourceType &value)
Copy assignment operator.
virtual ~NiftiImageData()
Destructor which frees the type handler, and the data blob if it is owned by this object.
Definition: NiftiImage.h:481
bool isEmpty() const
Determine whether or not the object is empty.
Definition: NiftiImage.h:521
const Iterator begin() const
Obtain a constant iterator corresponding to the start of the blob.
Definition: NiftiImage.h:568
NiftiImageData()
Default constructor, creating an empty data object.
Definition: NiftiImage.h:415
NiftiType niftiCopy() const
Copy the data elements into a new NIfTI-style mat44 or dmat44.
Definition: NiftiImage.h:685
const ElementType * end() const
Return a pointer/iterator to the end of the data.
Definition: NiftiImage.h:766
void initFromDims(const std::vector< dim_t > &dim, const int datatype)
Initialise an empty object from basic metadata.
void copy(const Block &source)
Copy the contents of a Block to create a new image, acquiring a new pointer.
NiftiImage(const std::vector< dim_t > &dim, const int datatype)
Initialise from basic metadata, allocating and zeroing pixel data.
int _datatype
Datatype code indicating the actual type of the elements.
Definition: NiftiImage.h:201
static int sexpTypeToNiftiType(const int sexpType)
Convert between R SEXP object type and nifti_image datatype codes.
Definition: NiftiImage.h:1084
Vector(const ElementType *source)
Initialise from a C-style array of the appropriate type and length.
Definition: NiftiImage.h:642