#include <common_lines.h>

Inheritance diagram for MultidimArray< T >:

Collaboration diagram for MultidimArray< T >:

Public Member Functions
Constructors
	MultidimArray ()

	MultidimArray (size_t Ndim, size_t Zdim, size_t Ydim, size_t Xdim, T *data)

	MultidimArray (size_t Ndim, int Zdim, int Ydim, int Xdim)

	MultidimArray (int Zdim, int Ydim, int Xdim)

	MultidimArray (int Ydim, int Xdim)

	MultidimArray (int Xdim)

	MultidimArray (const MultidimArray< T > &V)

	MultidimArray (MultidimArray< T > &&V) noexcept

	MultidimArray (const Matrix1D< T > &V)

	MultidimArray (const std::vector< T > &vector)

virtual	~MultidimArray ()

void	clear ()

Core memory operations
void	coreInit () noexcept

void	swap (MultidimArray< T > &other) noexcept

void	coreAllocate (size_t _ndim, int _zdim, int _ydim, int _xdim)

void	coreAllocate ()

void	coreAllocateReuse ()

FILE *	mmapFile (T *&_data, size_t nzyxDim) const

void	coreDeallocate () noexcept

void	alias (const MultidimArray< T > &m)

void	aliasRow (const MultidimArray< T > &m, size_t select_row)

void	aliasSlice (const MultidimArray< T > &m, size_t select_slice)

void	aliasImageInStack (const MultidimArray< T > &m, size_t select_image)

Size
void	resize (size_t Ndim, size_t Zdim, size_t Ydim, size_t Xdim, bool copy=true)

template<typename T1 >
void	resize (const MultidimArray< T1 > &v, bool copy=true)

template<typename T1 >
void	resizeNoCopy (const MultidimArray< T1 > &v)

void	checkDimensionWithDebug (int dim, const char *file, int line) const

void	selfWindow (int n0, int z0, int y0, int x0, int nF, int zF, int yF, int xF, T init_value=0)

template<class T1 >
void	window (MultidimArray< T1 > &result, int n0, int z0, int y0, int x0, int nF, int zF, int yF, int xF, T1 init_value=0) const

template<class T1 >
void	window (MultidimArray< T1 > &result, int z0, int y0, int x0, int zF, int yF, int xF, T1 init_value=0) const

void	selfWindow (int z0, int y0, int x0, int zF, int yF, int xF, T init_value=0)

template<class T1 >
void	window (MultidimArray< T1 > &result, int y0, int x0, int yF, int xF, T1 init_value=0) const

void	selfWindow (int y0, int x0, int yF, int xF, T init_value=0)

template<class T1 >
void	window (MultidimArray< T1 > &result, int x0, int xF, T1 init_value=0) const

void	selfWindow (int x0, int xF, T init_value=0)

void	patch (MultidimArray< T > patchArray, int x, int y)

Access to the pixel values
T &	operator() (const Matrix1D< double > &v) const

T &	operator() (const Matrix1D< int > &v) const

T &	operator() (size_t n, int k, int i, int j) const

T &	operator() (int k, int i, int j) const

T &	operator() (int i, int j) const

T &	operator() (int i) const

T &	operator[] (size_t i) const

void *	getArrayPointer () const

void	getImage (size_t n, MultidimArray< T > &M, size_t n2=0) const

template<typename T1 >
void	getSlice (int k, MultidimArray< T1 > &M, char axis='Z', bool reverse=false, size_t n=0) const

void	getSliceAsMatrix (size_t k, Matrix2D< T > &m) const

void	getAliasAsRowVector (Matrix1D< T > &m) const

template<typename T1 >
void	setSlice (int k, const MultidimArray< T1 > &v, size_t n=0)

template<typename T1 >
void	reslice (MultidimArray< T1 > &out, AxisView face, bool flip=false, size_t n=0) const

void	reslice (AxisView face, bool flip=false, size_t n=0)

void	getCol (size_t j, MultidimArray< T > &v) const

void	setCol (size_t j, const MultidimArray< T > &v)

void	getRow (size_t i, MultidimArray< T > &v) const

void	setRow (int i, const MultidimArray< T > &v)

void	getReal (MultidimArray< double > &realImg) const

void	getImag (MultidimArray< double > &imagImg) const

void	toPhysical (int k_log, int i_log, int j_log, int &k_phys, int &i_phys, int &j_phys) const

void	toLogical (int k_phys, int i_phys, int j_phys, int &k_log, int &i_log, int &j_log) const

void	toPhysical (int i_log, int j_log, int &i_phys, int &j_phys) const

void	toLogical (int i_phys, int j_phys, int &i_log, int &j_log) const

void	toPhysical (int i_log, int &i_phys) const

void	toLogical (int i_phys, int &i_log) const

T	interpolatedElement3D (double x, double y, double z, T outside_value=(T) 0) const

T	interpolatedElement2D (double x, double y, T outside_value=(T) 0) const

T	interpolatedElement2DOutsideZero (double x, double y) const

T	interpolatedElement1D (double x, T outside_value=(T) 0) const

T	interpolatedElementBSpline3D (double x, double y, double z, int SplineDegree=3) const

T	interpolatedElementBSpline2D (double x, double y, int SplineDegree=3) const

T	interpolatedElementBSpline2D_Degree3 (double x, double y) const

T	interpolatedElementBSpline1D (double x, int SplineDegree=3) const

Statistics functions
void	printStats (std::ostream &out=std::cout) const

T	computeMax () const

void	maxIndex (int &jmax) const

T	computeMin () const

void	minIndex (int &lmin, int &kmin, int &imin, int &jmin) const

void	minIndex (int &kmin, int &imin, int &jmin) const

void	minIndex (int &imin, int &jmin) const

void	minIndex (int &jmin) const

void	maxIndex (size_t &lmax, int &kmax, int &imax, int &jmax) const

void	computeDoubleMinMax (double &minval, double &maxval) const

void	computeDoubleMinMaxRange (double &minval, double &maxval, size_t offset, size_t size) const

double	computeAvg () const

double	computeStddev () const

void	computeStats (double &avg, double &stddev, T &minval, T &maxval) const

template<typename U >
void	computeAvgStdev (U &avg, U &stddev) const

void	computeAvgStdev_within_binary_mask (const MultidimArray< int > &mask, double &avg, double &stddev) const

void	computeMedian_within_binary_mask (const MultidimArray< int > &mask, double &median) const

void	computeStats (double &avg, double &stddev, T &min_val, T &max_val, Matrix1D< int > &corner1, Matrix1D< int > &corner2, size_t n=0)

double	computeMedian () const

void	rangeAdjust (T minF, T maxF)

void	rangeAdjust (T minF, T maxF, MultidimArray< int > &mask)

void	rangeAdjust (const MultidimArray< T > &example, const MultidimArray< int > *mask=NULL)

template<typename U >
void	statisticsAdjust (U avgF, U stddevF)

Initialization
void	initConstant (T val)

template<typename T1 >
void	initZeros (const MultidimArray< T1 > &op)

void	initZeros ()

void	initZeros (size_t Ndim, size_t Zdim, size_t Ydim, size_t Xdim)

void	initZeros (int Xdim)

void	initZeros (int Ydim, int Xdim)

void	initZeros (int Zdim, int Ydim, int Xdim)

void	initLinear (T minF, T maxF, int n=1, const String &mode="incr")

void	initRandom (double op1, double op2, RandomMode mode=RND_UNIFORM)

void	addNoise (double op1, double op2, const String &mode="uniform", double df=3.) const

Public Member Functions inherited from MultidimArrayBase
virtual	~MultidimArrayBase ()

int	getDim () const

void	setMmap (bool mmap)

void	maxIndex (ArrayCoord &pos) const

void	maxIndex (int &kmax, int &imax, int &jmax) const

void	maxIndex (int &imax, int &jmax) const

void	maxIndex (int &jmax) const

void	printShape (std::ostream &out=std::cout) const

void	setNdim (int Ndim)

void	setZdim (int Zdim)

void	setYdim (int Ydim)

void	setXdim (int Xdim)

void	setDimensions (int Xdim, int Ydim, int Zdim, size_t Ndim)

void	setDimensions (ArrayDim &newDim)

void	getDimensions (size_t &Xdim, size_t &Ydim, size_t &Zdim, size_t &Ndim) const

void	getDimensions (ArrayDim &idim) const

ArrayDim	getDimensions () const

void	getDimensions (int *size) const

size_t	getSize () const

void	resize (size_t Zdim, size_t Ydim, size_t Xdim)

void	resize (size_t Ydim, size_t Xdim)

void	resize (size_t Xdim)

void	resize (ArrayDim &adim, bool copy=true)

void	resizeNoCopy (size_t Ndim, size_t Zdim, size_t Ydim, size_t Xdim)

void	resizeNoCopy (size_t Zdim, size_t Ydim, size_t Xdim)

void	resizeNoCopy (size_t Ydim, size_t Xdim)

void	resizeNoCopy (size_t Xdim)

size_t	rowNumber () const

size_t	colNumber () const

void	copyShape (const MultidimArrayBase &m)

bool	sameShape (const MultidimArrayBase &op) const

void	setXmippOrigin ()

void	resetOrigin ()

void	moveOriginTo (int k, int i, int j)

void	moveOriginTo (int i, int j)

int	startingZ () const

int	finishingZ () const

int	startingY () const

int	finishingY () const

int	startingX () const

int	finishingX () const

bool	isCorner (const Matrix1D< double > &v) const

bool	outside (int k, int i, int j) const

bool	outside (int i, int j) const

bool	outside (int i) const

bool	outside (const Matrix1D< double > &r) const

Public Attributes
T *	data

Public Attributes inherited from MultidimArrayBase
bool	destroyData

size_t	ndim

size_t	zdim

size_t	ydim

size_t	xdim

size_t	yxdim

size_t	zyxdim

size_t	nzyxdim

int	zinit

int	yinit

int	xinit

bool	mmapOn

FILE *	mFd

size_t	nzyxdimAlloc

Friends
Scalar "by" array operations
These operations are between a scalar (of the same type as the array) and an array. The result must have been defined to be of the same type as the operand. The former content of the result array is lost after the operation. In this kind of operations the constant is operated with each element of array 2. The result has also got the same shape as the input array and its former content is lost
void	coreScalarByArray (const T &op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation)

void	scalarByArray (T op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation)

MultidimArray< T >	operator+ (T op1, const MultidimArray< T > &op2)

MultidimArray< T >	operator- (T op1, const MultidimArray< T > &op2)

MultidimArray< T >	operator* (T op1, const MultidimArray< T > &op2)

MultidimArray< T >	operator/ (T op1, const MultidimArray< T > &op2)

Array "by" array operations.
These are operations that are performed between 2 arrays of the SAME type (two integer vectors, two double matrices, ...). If they are not of the same type you can convert one of the arrays to the desired type using the function typeCast. The result must have been defined to be of the same type as the operands. In this kind of operations each element of array 1 is operated with its homologous in array 2, it is very important that both have got the same size and starting origins. The result has also got the same shape as the two operated arrays and its former content is lost.
MultidimArray< T >	operator+ (const MultidimArray< T > &op1) const

MultidimArray< T >	operator- (const MultidimArray< T > &op1) const

MultidimArray< T >	operator* (const MultidimArray< T > &op1) const

MultidimArray< T >	operator/ (const MultidimArray< T > &op1) const

void	operator+= (const MultidimArray< T > &op1)

void	operator-= (const MultidimArray< T > &op1)

void	operator*= (const MultidimArray< T > &op1)

void	operator/= (const MultidimArray< T > &op1)

double	dotProduct (const MultidimArray< T > &op1)

void	coreArrayByArray (const MultidimArray< T > &op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation)

void	selfCoreArrayByArrayMask (const MultidimArray< T > &op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation, const MultidimArray< T > *mask)

void	arrayByArray (const MultidimArray< T > &op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation)

void	selfArrayByArrayMask (const MultidimArray< T > &op1, const MultidimArray< T > &op2, MultidimArray< T > &result, char operation, const MultidimArray< T > *mask=NULL)

Array "by" scalar operations
These operations are between an array and a scalar (of the same type as the array). The result must have been defined to be of the same type as the operands. In this kind of operations each element of array 1 is operated with the given constant. The result has also got the same shape as the input array and its former content is lost
MultidimArray< T >	operator+ (T op1) const

MultidimArray< T >	operator- (T op1) const

MultidimArray< T >	operator* (T op1) const

MultidimArray< T >	operator/ (T op1) const

void	equal (T op1, MultidimArray< char > &result) const

void	operator+= (const T &op1)

void	operator-= (const T &op1)

void	operator*= (const T &op1)

void	operator/= (const T &op1)

void	coreArrayByScalar (const MultidimArray< T > &op1, const T &op2, MultidimArray< T > &result, char operation)

void	arrayByScalar (const MultidimArray< T > &op1, T op2, MultidimArray< T > &result, char operation)

Utilities
Here you have several easy functions to manage the values of the array.
T ***	adaptForNumericalRecipes3D (size_t n=0) const

void	killAdaptationForNumericalRecipes3D (T ***m) const

T **	adaptForNumericalRecipes2D (size_t n=0) const

T *	adaptForNumericalRecipes22D () const

void	loadFromNumericalRecipes2D (T **m, int Ydim, int Xdim)

void	killAdaptationForNumericalRecipes2D (T **m) const

void	killAdaptationForNumericalRecipes22D (T **m) const

T *	adaptForNumericalRecipes1D () const

void	killAdaptationForNumericalRecipes1D (T *m) const

void	centerOfMass (Matrix1D< double > &center, void *mask=NULL, size_t n=0)

void	sort (MultidimArray< T > &result) const

void	indexSort (MultidimArray< int > &indx) const

void	cumlativeDensityFunction (MultidimArray< double > &cdf)

void	threshold (const String &type, T a, T b=0, MultidimArray< int > *mask=NULL)

size_t	countThreshold (const String &type, T a, T b, MultidimArray< int > *mask=NULL)

void	substitute (T oldv, T newv, double accuracy=XMIPP_EQUAL_ACCURACY, MultidimArray< int > *mask=NULL)

void	randomSubstitute (T oldv, T avgv, T sigv, double accuracy=XMIPP_EQUAL_ACCURACY, MultidimArray< int > *mask=NULL)

void	binarize (double val=0, double accuracy=XMIPP_EQUAL_ACCURACY, MultidimArray< int > *mask=NULL)

void	binarizeRange (double valMin=0, double valMax=255, MultidimArray< int > *mask=NULL)

void	selfROUND ()

void	selfCEIL ()

void	selfFLOOR ()

void	selfABS ()

void	selfNormalizeInterval (double minPerc=0.25, double maxPerc=0.75, int Npix=1000)

void	selfSQRT ()

double	sum () const

double	sum2 () const

void	selfLog10 ()

void	selfLog ()

void	selfReverseX ()

void	selfReverseY ()

void	selfReverseZ ()

void	profile (int x0, int y0, int xF, int yF, int N, MultidimArray< double > &profile) const

void	showWithGnuPlot (const String &xlabel, const String &title)

void	edit ()

void	write (const FileName &fn) const

void	MultidimArrayMax (const MultidimArray< T > &v1, const MultidimArray< T > &v2, MultidimArray< T > &result)

void	MultidimArrayMIN (const MultidimArray< T > &v1, const MultidimArray< T > &v2, MultidimArray< T > &result)

Operators
MultidimArray< T > &	operator= (const MultidimArray< T > &op1)

MultidimArray< T > &	operator= (MultidimArray< T > &&other) noexcept

MultidimArray< T > &	operator= (const Matrix2D< T > &op1)

MultidimArray< T >	operator- () const

void	copy (Matrix2D< T > &op1) const

bool	equal (const MultidimArray< T > &op, double accuracy=XMIPP_EQUAL_ACCURACY) const

std::istream &	operator>> (std::istream &in, MultidimArray< T > &v)

Detailed Description

template<typename T>
class MultidimArray< T >

Definition at line 35 of file common_lines.h.

Constructor & Destructor Documentation

◆ MultidimArray() [1/10]

template<typename T>

MultidimArray< T >::MultidimArray ( )

inline

Empty constructor. The empty constructor creates an array with no memory associated, size=0.

Definition at line 94 of file multidim_array.h.

     {
         coreInit();
     }

◆ MultidimArray() [2/10]

template<typename T>

MultidimArray< T >::MultidimArray	(	size_t	Ndim,
		size_t	Zdim,
		size_t	Ydim,
		size_t	Xdim,
		T *	data
	)

inline

Size constructor with 4D size and already allocated data.

Definition at line 102 of file multidim_array.h.

                                                                                {
         this->coreInit();
         this->setDimensions(Xdim, Ydim, Zdim, Ndim);
         this->data = data;
         this->nzyxdimAlloc = this->nzyxdim;
         this->destroyData = false;
     }

◆ MultidimArray() [3/10]

template<typename T>

MultidimArray< T >::MultidimArray	(	size_t	Ndim,
		int	Zdim,
		int	Ydim,
		int	Xdim
	)

inline

Size constructor with 4D size. The Size constructor creates an array with memory associated, and fills it with zeros.

Definition at line 115 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(Ndim, Zdim, Ydim, Xdim);
     }

◆ MultidimArray() [4/10]

template<typename T>

MultidimArray< T >::MultidimArray	(	int	Zdim,
		int	Ydim,
		int	Xdim
	)

inline

Size constructor with 3D size. The Size constructor creates an array with memory associated, and fills it with zeros.

Definition at line 125 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(1UL, Zdim, Ydim, Xdim);
     }

◆ MultidimArray() [5/10]

template<typename T>

MultidimArray< T >::MultidimArray	(	int	Ydim,
		int	Xdim
	)

inline

Size constructor with 2D size. The Size constructor creates an array with memory associated, and fills it with zeros.

Definition at line 135 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(1UL, 1, Ydim, Xdim);
     }

◆ MultidimArray() [6/10]

template<typename T>

MultidimArray< T >::MultidimArray ( int Xdim )

inline

Size constructor with 1D size. The Size constructor creates an array with memory associated, and fills it with zeros.

Definition at line 145 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(1UL, 1, 1, Xdim);
     }

◆ MultidimArray() [7/10]

template<typename T>

MultidimArray< T >::MultidimArray ( const MultidimArray< T > & V )

inline

Copy constructor

The created volume is a perfect copy of the input array but with a different memory assignment.

MultidimArray< double > V2(V1);

Definition at line 160 of file multidim_array.h.

     {
         coreInit();
         *this = V;
     }

◆ MultidimArray() [8/10]

template<typename T>

MultidimArray< T >::MultidimArray ( MultidimArray< T > && V )

inlinenoexcept

Move constructor

The created volume is a perfect copy of the input array but with a different memory assignment.

MultidimArray< double > V2(V1);

Definition at line 175 of file multidim_array.h.

     {
         coreInit();
         swap(V);
     }

◆ MultidimArray() [9/10]

template<typename T>

MultidimArray< T >::MultidimArray ( const Matrix1D< T > & V )

inline

Copy constructor from a Matrix1D. The Size constructor creates an array with memory associated, and fills it with zeros.

Definition at line 185 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(1, 1, 1, V.size());
         for (size_t i = 0; i < V.size(); i++)
             DIRECT_A1D_ELEM(*this,i) = VEC_ELEM(V,i);
     }

◆ MultidimArray() [10/10]

template<typename T>

MultidimArray< T >::MultidimArray ( const std::vector< T > & vector )

inline

Constructor from vector 1D This will create a MultidimArray 1D the size and elements will be copied from the std::vector

Definition at line 198 of file multidim_array.h.

     {
         coreInit();
         coreAllocate(1, 1, 1, vector.size());
         for (size_t i = 0; i < vector.size(); i++)
             DIRECT_A1D_ELEM(*this,i) = vector[i];
     }

◆ ~MultidimArray()

template<typename T>

virtual MultidimArray< T >::~MultidimArray ( )

inlinevirtual

Destructor.

Definition at line 209 of file multidim_array.h.

     {
         coreDeallocate();
     }

Member Function Documentation

◆ adaptForNumericalRecipes1D()

template<typename T>

T* MultidimArray< T >::adaptForNumericalRecipes1D ( ) const

inline

Produce a 1D array suitable for working with Numerical Recipes

This function must be used only as a preparation for routines which need that the first physical index is 1 and not 0 as it usually is in C. In fact the vector provided for Numerical recipes is exactly this same one but with the indexes changed.

This function is not ported to Python.

Definition at line 2976 of file multidim_array.h.

     {
         return MULTIDIM_ARRAY(*this) - 1;
     }

◆ adaptForNumericalRecipes22D()

template<typename T>

T* MultidimArray< T >::adaptForNumericalRecipes22D ( ) const

inline

Produce a 1D pointer suitable for working with Numerical Recipes (2)

This function meets the same goal as the one before, however this one work with 2D arrays as a single pointer. The first element of the array is pointed by result[1*Xdim+1], and in general result[i*Xdim+j]

Definition at line 2935 of file multidim_array.h.

     {
         return MULTIDIM_ARRAY(*this) - 1 - XSIZE(*this);
     }

◆ adaptForNumericalRecipes2D()

template<typename T>

T** MultidimArray< T >::adaptForNumericalRecipes2D ( size_t n = 0 ) const

inline

Produce a 2D array suitable for working with Numerical Recipes

This function must be used only as a preparation for routines which need that the first physical index is 1 and not 0 as it usually is in C. New memory is needed to hold the new double pointer array.

Definition at line 2918 of file multidim_array.h.

     {
         T** m = NULL;
         ask_Tmatrix(m, 1, YSIZE(*this), 1, XSIZE(*this));
 
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(*this)
         m[i+1][j+1] = DIRECT_NZYX_ELEM(*this, n, 0, i, j);
 
         return m;
     }

◆ adaptForNumericalRecipes3D()

template<typename T>

T*** MultidimArray< T >::adaptForNumericalRecipes3D ( size_t n = 0 ) const

inline

Produce a 3D array suitable for working with Numerical Recipes.

This function must be used only as a preparation for routines which need that the first physical index is 1 and not 0 as it usually is in C. New memory is needed to hold the new double pointer array.

Definition at line 2894 of file multidim_array.h.

     {
         T*** m = NULL;
         ask_Tvolume(m, 1, ZSIZE(*this), 1, YSIZE(*this), 1, XSIZE(*this));
 
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(*this)
         m[k+1][i+1][j+1] = DIRECT_NZYX_ELEM(*this, n, k, i, j);
 
         return m;
     }

◆ addNoise()

template<typename T >

void MultidimArray< T >::addNoise	(	double	op1,
		double	op2,
		const String &	mode = `"uniform"`,
		double	df = `3.`
	)		const

Add noise to actual values.

This function add some noise to the actual values of the array according to a certain random distribution. You must choose two parameters for each, for the uniform distribution they mean the range where to generate the random numbers, while in the gaussian case they are the mean and the standard deviation. By default the uniform distribution is selected. The size and origin of the array are not modified. The array itself is modified.

v1.addNoise(0, 1);
// uniform distribution between 0 and 1
v1.addNoise(0, 1, "uniform");
// the same
v1.addNoise(0, 1, "gaussian");
// gaussian distribution with 0 mean and stddev=1
v1.addNoise(0, 1, "student", 3);
// t-student distribution with 0 mean and stddev=1, and 3 degrees of freedom

Definition at line 837 of file multidim_array.cpp.

 {
     T* ptr=NULL;
     size_t n;
     if (mode == "uniform")
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr += static_cast< T >(rnd_unif(op1, op2));
     else if (mode == "gaussian")
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr += static_cast< T >(rnd_gaus(op1, op2));
     else if (mode == "student")
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr += static_cast< T >(rnd_student_t(df, op1, op2));
     else
         REPORT_ERROR(ERR_VALUE_INCORRECT,
                      formatString("AddNoise: Mode not supported (%s)", mode.c_str()));
 }

◆ alias()

template<typename T>

void MultidimArray< T >::alias ( const MultidimArray< T > & m )

inline

Alias a multidimarray.

Treat the multidimarray as if it were a volume. The data is not copied into new memory, but a pointer to the multidimarray is copied. You should not make any operation on this volume such that the memory locations are changed

Definition at line 379 of file multidim_array.h.

     {
         coreDeallocate();
         copyShape(m);
         this->data=m.data;
         this->nzyxdimAlloc = this->nzyxdim;
         this->destroyData = false;
     }

◆ aliasImageInStack()

template<typename T>

void MultidimArray< T >::aliasImageInStack	(	const MultidimArray< T > &	m,
		size_t	select_image
	)

inline

Alias an image in a stack.

Treat the multidimarray as if it were a single slice. The data is not copied into new memory, but a pointer to the selected image in the multidimarray is copied. You should not make any operation on this volume such that the memory locations are changed. Select_slice starts at 0 towards Nsize.

Definition at line 436 of file multidim_array.h.

     {
         if (select_image >= NSIZE(m))
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "aliasImageInStack: Selected image cannot be higher than N size.");
         if (ZSIZE(m)!=1)
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "aliasImageInStack: This function is not meant for volumes");
 
         coreDeallocate();
         setDimensions(XSIZE(m), YSIZE(m), 1, 1);
         this->data = m.data + XSIZE(m)*YSIZE(m)*(select_image);
         this->nzyxdimAlloc = this->nzyxdim;
         this->destroyData = false;
     }

◆ aliasRow()

template<typename T>

void MultidimArray< T >::aliasRow	(	const MultidimArray< T > &	m,
		size_t	select_row
	)

inline

Alias a row in an image.

Treat the multidimarray as if it were a single slice. The data is not copied into new memory, but a pointer to the selected slice in the multidimarray is copied. You should not make any operation on this volume such that the memory locations are changed. Select_slice starts at 0 towards Zsize.

Definition at line 396 of file multidim_array.h.

     {
         if (select_row >= YSIZE(m))
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "aliasRow: Selected row cannot be higher than Y size.");
 
         coreDeallocate();
         setDimensions(XSIZE(m),1, 1, 1);
         this->data = m.data + XSIZE(m)*select_row;
         this->nzyxdimAlloc = this->nzyxdim;
         this->destroyData = false;
     }

◆ aliasSlice()

template<typename T>

void MultidimArray< T >::aliasSlice	(	const MultidimArray< T > &	m,
		size_t	select_slice
	)

inline

Alias a slice in a multidimarray.

Treat the multidimarray as if it were a single slice. The data is not copied into new memory, but a pointer to the selected slice in the multidimarray is copied. You should not make any operation on this volume such that the memory locations are changed. Select_slice starts at 0 towards Zsize.

Definition at line 416 of file multidim_array.h.

     {
         if (select_slice >= ZSIZE(m))
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "aliasSlice: Selected slice cannot be higher than Z size.");
 
         coreDeallocate();
         setDimensions(XSIZE(m), YSIZE(m), 1, 1);
         this->data = m.data + XSIZE(m)*YSIZE(m)*(select_slice);
         this->nzyxdimAlloc = this->nzyxdim;
         this->destroyData = false;
     }

◆ binarize()

template<typename T>

void MultidimArray< T >::binarize	(	double	val = `0`,
		double	accuracy = `XMIPP_EQUAL_ACCURACY`,
		MultidimArray< int > *	mask = `NULL`
	)

inline

Binarize.

This functions substitutes all values in a volume which are greater than val+accuracy by 1 and the rest are set to 0. Use threshold to get a very powerful binarization.

Definition at line 3252 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
         {
             if (*ptr <= val + accuracy)
                 *ptr = 0;
             else
                 *ptr = 1;
         }
     }

◆ binarizeRange()

template<typename T>

void MultidimArray< T >::binarizeRange	(	double	valMin = `0`,
		double	valMax = `255`,
		MultidimArray< int > *	mask = `NULL`
	)

inline

Binarize using a range

This functions substitutes all values in a volume which are in the range between valMin and valMax by 1 and the rest are set to 0.

Definition at line 3273 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
         {
             if ( (*ptr < valMax) &&  (*ptr > valMin) )
                 *ptr = 1;
             else
                 *ptr = 0;
         }
     }

◆ centerOfMass()

template<typename T>

void MultidimArray< T >::centerOfMass	(	Matrix1D< double > &	center,
		void *	mask = `NULL`,
		size_t	n = `0`
	)

inline

Computes the center of mass of the nth array

Definition at line 2992 of file multidim_array.h.

     {
         center.initZeros(3);
         double mass = 0;
         MultidimArray< int >* imask = (MultidimArray< int >*) mask;
 
         FOR_ALL_ELEMENTS_IN_ARRAY3D(*this)
         {
             if ((imask == NULL || NZYX_ELEM(*imask, n, k, i, j)) &&
                 A3D_ELEM(*this, k, i, j) > 0)
             {
                 XX(center) += j * NZYX_ELEM(*this, n, k, i, j);
                 YY(center) += i * NZYX_ELEM(*this, n, k, i, j);
                 ZZ(center) += k * NZYX_ELEM(*this, n, k, i, j);
 
                 mass += NZYX_ELEM(*this, n, k, i, j);
             }
         }
 
         if (mass != 0)
             center /= mass;
     }

◆ checkDimensionWithDebug()

template<typename T>

void MultidimArray< T >::checkDimensionWithDebug	(	int	dim,
		const char *	file,
		int	line
	)		const

inline

Definition at line 521 of file multidim_array.h.

     {
         if (getDim() != dim)
         {
             std::cerr<<" Check for dimension: "  << dim <<std::endl;
             std::cerr << "MultidimArray shape: ";
             printShape(std::cerr);
             std::cerr << std::endl;
             std::cerr << "Check called from file "<<file<<" line "<<line<<std::endl;
             exit(1);
         }
     }

◆ clear()

template<typename T>

void MultidimArray< T >::clear ( )

inlinevirtual

Clear.

Implements MultidimArrayBase.

Definition at line 216 of file multidim_array.h.

     {
         coreDeallocate();
         coreInit();
     }

◆ computeAvg()

template<typename T>

double MultidimArray< T >::computeAvg ( ) const

inlinevirtual

Average of the values in the array.

The returned value is always double, independently of the type of the array.

Implements MultidimArrayBase.

Definition at line 1739 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return 0;
 
         double sum = 0;
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         sum += static_cast< double >(*ptr);
 
         return sum / NZYXSIZE(*this);
     }

◆ computeAvgStdev()

template<typename T>

template<typename U >

void MultidimArray< T >::computeAvgStdev	(	U &	avg,
		U &	stddev
	)		const

inline

Compute statistics.

The average, standard deviation, minimum and maximum value are returned.

Definition at line 1836 of file multidim_array.h.

     {
         static_assert(
                 std::is_same<double, U>::value || std::is_same<float, U>::value,
                 "U must be a floating presiont type");
         if (NZYXSIZE(*this) <= 0)
             return;
 
         avg = 0;
         stddev = 0;
         const size_t nMax = nzyxdim;
         for (size_t n = 0; n < nMax; ++n)
         {
             U v = (U)data[n];
             avg += v;
             stddev += v * v;
         }
 
         avg /= NZYXSIZE(*this);
 
         if (NZYXSIZE(*this) > 1)
         {
             stddev = stddev / NZYXSIZE(*this) - avg * avg;
             stddev *= NZYXSIZE(*this) / (NZYXSIZE(*this) - 1);
 
             // Foreseeing numerical instabilities
             stddev = sqrt(fabs(stddev));
         }
         else
             stddev = 0;
     }

◆ computeAvgStdev_within_binary_mask()

template<typename T>

void MultidimArray< T >::computeAvgStdev_within_binary_mask	(	const MultidimArray< int > &	mask,
		double &	avg,
		double &	stddev
	)		const

inline

Compute statistics in the active area

Only the statistics for values in the overlapping between the mask and the volume for those the mask is not 0 are computed.

Definition at line 1873 of file multidim_array.h.

     {
         double sum1 = 0;
         double sum2 = 0;
         double N = 0;
 
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(*this)
         {
             if (DIRECT_MULTIDIM_ELEM(mask, n) != 0)
             {
                 ++N;
                 double aux=DIRECT_MULTIDIM_ELEM(*this, n);
                 sum1 += aux;
                 sum2 += aux*aux;
             }
         }
 
         // average and standard deviation
         avg  = sum1 / N;
         if (N > 1)
             stddev = sqrt(fabs(sum2 / N - avg * avg) * N / (N - 1));
         else
             stddev = 0;
     }

◆ computeDoubleMinMax()

template<typename T>

void MultidimArray< T >::computeDoubleMinMax	(	double &	minval,
		double &	maxval
	)		const

inline

Minimum and maximum of the values in the array.

As doubles.

Definition at line 1688 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return;
 
         T* ptr=NULL;
         size_t n;
         T Tmin=DIRECT_MULTIDIM_ELEM(*this,0);
         T Tmax=Tmin;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         {
             T val=*ptr;
             if (val < Tmin)
                 Tmin = val;
             else if (val > Tmax)
                 Tmax = val;
         }
         minval = static_cast< double >(Tmin);
         maxval = static_cast< double >(Tmax);
     }

◆ computeDoubleMinMaxRange()

template<typename T>

void MultidimArray< T >::computeDoubleMinMaxRange	(	double &	minval,
		double &	maxval,
		size_t	offset,
		size_t	size
	)		const

inlinevirtual

Minimum and maximum of the values in the array.

As doubles.

Implements MultidimArrayBase.

Definition at line 1713 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return;
 
         minval = maxval = static_cast< double >(data[offset]);
 
         T* ptr=NULL;
         T val;
         size_t n;
 
         for (n=offset,ptr=data+offset; n<size; ++n, ++ptr)
         {
             val = *ptr;
             if (val < minval)
                 minval = static_cast< double >(val);
             else if (val > maxval)
                 maxval = static_cast< double >(val);
         }
     }

◆ computeMax()

template<typename T>

T MultidimArray< T >::computeMax ( ) const

inline

Maximum of the values in the array.

The returned value is of the same type as the type of the array.

Definition at line 1537 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return static_cast< T >(0);
 
         T maxval = data[0];
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (*ptr > maxval)
             maxval = *ptr;
 
         return maxval;
     }

◆ computeMedian()

template<typename T>

double MultidimArray< T >::computeMedian ( ) const

inline

Median

Calculate the median element.

med = v1.computeMedian();

Definition at line 1951 of file multidim_array.h.

     {
         if (XSIZE(*this) == 0)
             return 0;
 
         if (XSIZE(*this) == 1)
             return DIRECT_MULTIDIM_ELEM(*this,0);
 
         // Initialise data
         MultidimArray<T> temp;
         this->sort(temp);
 
         // Get median
         if (NZYXSIZE(*this)%2==0)
             return 0.5*(DIRECT_MULTIDIM_ELEM(temp,NZYXSIZE(*this)/2-1)+
                         DIRECT_MULTIDIM_ELEM(temp,NZYXSIZE(*this)/2  ));
         else
             return DIRECT_MULTIDIM_ELEM(temp,NZYXSIZE(*this)/2);
     }

◆ computeMedian_within_binary_mask()

template<typename T >

void MultidimArray< T >::computeMedian_within_binary_mask	(	const MultidimArray< int > &	mask,
		double &	median
	)		const

Definition at line 1099 of file multidim_array.cpp.

 {
     std::vector<double> bgI;
 
     FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(*this)
     {
         if (DIRECT_MULTIDIM_ELEM(mask, n) != 0)
         {
             double aux = DIRECT_MULTIDIM_ELEM(*this, n);
             bgI.push_back(aux);
         }
     }
 
     std::sort(bgI.begin(), bgI.end());
     if (bgI.size() % 2 != 0)
         median = bgI[bgI.size() / 2];
     else
         median = (bgI[(bgI.size() - 1) / 2] + bgI[bgI.size() / 2]) / 2.0;
 }

◆ computeMin()

template<typename T>

T MultidimArray< T >::computeMin ( ) const

inline

Minimum of the values in the array.

The returned value is of the same type as the type of the array.

Definition at line 1568 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return static_cast< T >(0);
 
         T minval = data[0];
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (*ptr < minval)
             minval = *ptr;
 
         return minval;
     }

◆ computeStats() [1/2]

template<typename T>

void MultidimArray< T >::computeStats	(	double &	avg,
		double &	stddev,
		T &	minval,
		T &	maxval
	)		const

inline

Compute statistics.

The average, standard deviation, minimum and maximum value are returned.

Definition at line 1791 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return;
 
         avg = 0;
         stddev = 0;
 
         minval = maxval = data[0];
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         {
             T Tval=*ptr;
             double val=Tval;
             avg += val;
             stddev += val * val;
 
             if (Tval > maxval)
                 maxval = Tval;
             else if (Tval < minval)
                 minval = Tval;
         }
 
         avg /= NZYXSIZE(*this);
 
         if (NZYXSIZE(*this) > 1)
         {
             stddev = stddev / NZYXSIZE(*this) - avg * avg;
             stddev *= NZYXSIZE(*this) / (NZYXSIZE(*this) - 1);
 
             // Foreseeing numerical instabilities
             stddev = sqrt(static_cast< double >(ABS(stddev)));
         }
         else
             stddev = 0;
     }

◆ computeStats() [2/2]

template<typename T>

void MultidimArray< T >::computeStats	(	double &	avg,
		double &	stddev,
		T &	min_val,
		T &	max_val,
		Matrix1D< int > &	corner1,
		Matrix1D< int > &	corner2,
		size_t	n = `0`
	)

inline

Compute statistics within 2D region of 2D image.

The 2D region is specified by two corners. Note that this function only works for the 0th image in a multi-image array...

Definition at line 1906 of file multidim_array.h.

     {
         (*this).checkDimension(2);
         min_val = max_val = NZYX_ELEM((*this), n, 0, YY(corner1), XX(corner1));
 
         Matrix1D< double > r(3);
         double N = 0, sum = 0, sum2 = 0;
 
         FOR_ALL_ELEMENTS_IN_ARRAY2D_BETWEEN(corner1, corner2)
         {
             sum += (*this)(r);
             sum2 += (*this)(r) * (*this)(r);
             N++;
 
             if ((*this)(r) < min_val)
                 min_val = (*this)(r);
             else if ((*this)(r) > max_val)
                 max_val = (*this)(r);
         }
 
         if (N != 0)
         {
             avg = sum / N;
             stddev = sqrt(sum2 / N - avg * avg);
         }
         else
         {
             avg = stddev = 0;
         }
     }

◆ computeStddev()

template<typename T>

double MultidimArray< T >::computeStddev ( ) const

inline

Standard deviation of the values in the array.

Be careful that the standard deviation and NOT the variance is returned. The returned value is always double, independently of the type of the array.

Definition at line 1760 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 1)
             return 0;
 
         double avg = 0, stddev = 0;
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         {
             double val=static_cast< double >(*ptr);
             avg += val;
             stddev += val * val;
         }
 
         avg /= NZYXSIZE(*this);
         stddev = stddev / NZYXSIZE(*this) - avg * avg;
         stddev *= NZYXSIZE(*this) / (NZYXSIZE(*this) - 1);
 
         // Foreseeing numerical instabilities
         stddev = sqrt(static_cast<double>((ABS(stddev))));
 
         return stddev;
     }

◆ copy()

template<typename T>

void MultidimArray< T >::copy ( Matrix2D< T > & op1 ) const

Definition at line 56 of file multidim_array.cpp.

 {
     op1.resizeNoCopy(YSIZE(*this), XSIZE(*this));
     memcpy(MATRIX2D_ARRAY(op1), MULTIDIM_ARRAY(*this), MULTIDIM_SIZE(*this)*sizeof(T));
 }

◆ coreAllocate() [1/2]

template<typename T>

void MultidimArray< T >::coreAllocate	(	size_t	_ndim,
		int	_zdim,
		int	_ydim,
		int	_xdim
	)

inline

Core allocate with dimensions.

Definition at line 262 of file multidim_array.h.

     {
         if (_ndim <= 0 || _zdim <= 0 || _ydim<=0 || _xdim<=0)
         {
             clear();
             return;
         }
         if(data!=NULL)
             REPORT_ERROR(ERR_MEM_NOTDEALLOC, "do not allocate space for an image if you have not deallocate it first");
 
         ndim=_ndim;
         zdim=_zdim;
         ydim=_ydim;
         xdim=_xdim;
         yxdim=(size_t)ydim*xdim;
         zyxdim=yxdim*zdim;
         nzyxdim=zyxdim*ndim;
 
         coreAllocate();
     }

◆ coreAllocate() [2/2]

template<typename T>

void MultidimArray< T >::coreAllocate ( )

inline

Core allocate without dimensions.

It is supposed the dimensions are set previously with setXdim(x), setYdim(y) setZdim(z), setNdim(n) or with setDimensions(Xdim, Ydim, Zdim, Ndim);

Definition at line 289 of file multidim_array.h.

     {
         if(data!=NULL)
             REPORT_ERROR(ERR_MEM_NOTDEALLOC, "do not allocate space for an image if you have not deallocate it first");
 
         if (mmapOn)
             mFd = mmapFile(data, nzyxdim);
         else
         {
             try
             {
                 data = new T [nzyxdim];
                 if (data == NULL)
                 {
                     setMmap(true);
                     mFd = mmapFile(data, nzyxdim);
                 }
             }
             catch (std::bad_alloc &)
             {
                 setMmap(true);
                 mFd = mmapFile(data, nzyxdim);
             }
         }
         memset(data,0,nzyxdim*sizeof(T));
         nzyxdimAlloc = nzyxdim;
     }

◆ coreAllocateReuse()

template<typename T>

void MultidimArray< T >::coreAllocateReuse ( )

inlinevirtual

Core allocate without dimensions.

It is supposed the dimensions are set previously with setXdim(x), setYdim(y) setZdim(z), setNdim(n) or with setDimensions(Xdim, Ydim, Zdim, Ndim);

Implements MultidimArrayBase.

Definition at line 323 of file multidim_array.h.

     {
         if(data != NULL && nzyxdim <= nzyxdimAlloc)
             return;
         else if (nzyxdim > nzyxdimAlloc)
             coreDeallocate();
 
         if (mmapOn)
             mFd = mmapFile(data, nzyxdim);
         else
         {
             data = new T [nzyxdim];
             if (data == NULL)
                 REPORT_ERROR(ERR_MEM_NOTENOUGH, "Allocate: No space left");
         }
         memset(data,0,nzyxdim*sizeof(T));
         nzyxdimAlloc = nzyxdim;
     }

◆ coreDeallocate()

template<typename T>

void MultidimArray< T >::coreDeallocate ( )

inlinevirtualnoexcept

Core deallocate. Free all data.

Implements MultidimArrayBase.

Definition at line 349 of file multidim_array.h.

     {
         if (data != NULL && destroyData)
         {
             if (mmapOn)
             {
 #ifdef XMIPP_MMAP
                 munmap(data,nzyxdimAlloc*sizeof(T));
                 fclose(mFd);
 #else
 
                 REPORT_ERROR(ERR_MMAP,"Mapping not supported in Windows");
 #endif
 
             }
             else
                 delete[] data;
         }
         data = NULL;
         destroyData = true;
         nzyxdimAlloc = 0;
     }

◆ coreInit()

template<typename T>

void MultidimArray< T >::coreInit ( )

inlinenoexcept

Core init. Initialize everything to 0

Definition at line 229 of file multidim_array.h.

     {
         xdim = yxdim = zyxdim = nzyxdim = 0;
         ydim = zdim = ndim = 0;
         zinit = yinit = xinit = 0;
         data = NULL;
         nzyxdimAlloc = 0;
         destroyData = true;
         mmapOn = false;
         mFd = NULL;
     }

◆ countThreshold()

template<typename T>

size_t MultidimArray< T >::countThreshold	(	const String &	type,
		T	a,
		T	b,
		MultidimArray< int > *	mask = `NULL`
	)

inline

Count with threshold.

This function returns the number of elements meeting the threshold condition.

Definition at line 3160 of file multidim_array.h.

     {
         int mode;
 
         if (type == "abs_above")
             mode = 1;
         else if (type == "abs_below")
             mode = 2;
         else if (type == "above")
             mode = 3;
         else if (type == "below")
             mode = 4;
         else if (type == "range")
             mode = 5;
         else
             REPORT_ERROR(ERR_VALUE_INCORRECT,
                          formatString("CountThreshold: mode not supported (%s)", type.c_str()));
 
         size_t ret = 0;
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
         {
             switch (mode)
             {
             case 1:
                 if (ABS(*ptr) > a)
                     ret++;
                 break;
             case 2:
                 if (ABS(*ptr) < a)
                     ret++;
                 break;
             case 3:
                 if (*ptr > a)
                     ret++;
                 break;
             case 4:
                 if (*ptr < a)
                     ret++;
                 break;
             case 5:
                 if (*ptr >= a && *ptr <= b)
                     ret++;
                 break;
             }
         }
         return ret;
     }

◆ cumlativeDensityFunction()

template<typename T>

void MultidimArray< T >::cumlativeDensityFunction ( MultidimArray< double > & cdf )

inline

Cumulative Density Function. For each entry in the array, give what is the probability of having a value smaller or equal than this entry.

Definition at line 3042 of file multidim_array.h.

     {
         MultidimArray<int> indx;
         indexSort(indx);
         cdf.resizeNoCopy(*this);
         double iSize=1.0/XSIZE(indx);
         FOR_ALL_ELEMENTS_IN_ARRAY1D(indx)
         {
             int ii=A1D_ELEM(indx,i)-1;
             A1D_ELEM(cdf,ii)=(i+1)*iSize;
         }
     }

◆ dotProduct()

template<typename T>

double MultidimArray< T >::dotProduct ( const MultidimArray< T > & op1 )

inline

Dot product

Definition at line 2405 of file multidim_array.h.

     {
         if (!sameShape(op1))
             REPORT_ERROR(ERR_MULTIDIM_SIZE,"The two arrays for dot product are not of the same shape");
         double dot=0;
         size_t n;
         T* ptrOp1=NULL;
         T* ptrOp2=NULL;
         const size_t unroll=4;
         size_t nmax=unroll*(MULTIDIM_SIZE(*this)/unroll);
         for (n=0, ptrOp1=data,ptrOp2=op1.data;
              n<nmax; n+=unroll, ptrOp1+=unroll, ptrOp2+=unroll)
         {
             dot += *ptrOp1 * *ptrOp2;
             dot += *(ptrOp1+1) * *(ptrOp2+1);
             dot += *(ptrOp1+2) * *(ptrOp2+2);
             dot += *(ptrOp1+3) * *(ptrOp2+3);
         }
         for (n=nmax, ptrOp1=data+nmax, ptrOp2=op1.data+nmax;
              n<MULTIDIM_SIZE(*this); ++n, ++ptrOp1, ++ptrOp2)
             dot += *ptrOp1 * *ptrOp2;
         return dot;
     }

◆ edit()

template<typename T >

void MultidimArray< T >::edit ( )

Edit with xmipp_editor.

This function generates a random filename starting with PPP and edits it with xmipp_editor. After closing the editor the file is removed.

Definition at line 956 of file multidim_array.cpp.

 {
     FileName nam;
     nam.initRandom(15);
 
     nam = formatString("PPP%s.txt", nam.c_str());
     write(nam);
 
     if (0 != system(formatString("xmipp_edit -i %s -remove &", nam.c_str()).c_str())) {
         REPORT_ERROR(ERR_IO, "Cannot open xmipp_edit");
     }
 }

◆ equal() [1/2]

template<typename T>

void MultidimArray< T >::equal	(	T	op1,
		MultidimArray< char > &	result
	)		const

inline

v3 = (v1 == k).

Definition at line 2545 of file multidim_array.h.

     {
         result.resizeNoCopy(*this);
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(result)
         DIRECT_MULTIDIM_ELEM(result,n) = DIRECT_MULTIDIM_ELEM(*this,n) == op1;
     }

◆ equal() [2/2]

template<typename T>

bool MultidimArray< T >::equal	(	const MultidimArray< T > &	op,
		double	accuracy = `XMIPP_EQUAL_ACCURACY`
	)		const

inline

Equality.

Returns true if this object has got the same shape (origin and size) than the argument and the same values (within accuracy).

Definition at line 3721 of file multidim_array.h.

     {
         if (!sameShape(op) || data==NULL || op.data == NULL)
             return false;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(*this)
         {
             if (fabs(DIRECT_MULTIDIM_ELEM(*this,n) -
                      DIRECT_MULTIDIM_ELEM(op,n)) > accuracy)
                 return false;
         }
         return true;
     }

◆ getAliasAsRowVector()

template<typename T>

void MultidimArray< T >::getAliasAsRowVector ( Matrix1D< T > & m ) const

inline

Return the data aliased as a row vector in a Matrix1D

Definition at line 1014 of file multidim_array.h.

     {
         m.vdim = NZYXSIZE(*this);
         m.destroyData = false;
         m.row = true;
         m.vdata = data;
     }

◆ getArrayPointer()

template<typename T>

void* MultidimArray< T >::getArrayPointer ( ) const

inlinevirtual

Return the void pointer to the internal data array

Implements MultidimArrayBase.

Definition at line 864 of file multidim_array.h.

     {
         return (void*) data;
 
     }

◆ getCol()

template<typename T>

void MultidimArray< T >::getCol	(	size_t	j,
		MultidimArray< T > &	v
	)		const

inline

Get Column

This function returns a column vector corresponding to the chosen column.

std::vector< double > v;

m.getCol(-1, v);

Definition at line 1126 of file multidim_array.h.

     {
         if (xdim == 0 || ydim == 0)
         {
             v.clear();
             return;
         }
 
         if (j >= xdim)
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,"getCol: Matrix subscript (j) greater than matrix dimension");
 
         v.resizeNoCopy(ydim);
         for (size_t i = 0; i < ydim; i++)
             DIRECT_A1D_ELEM(v,i) = DIRECT_A2D_ELEM(*this,i, j);
     }

◆ getImag()

template<typename T>

void MultidimArray< T >::getImag ( MultidimArray< double > & imagImg ) const

inline

Definition at line 1221 of file multidim_array.h.

     {
         REPORT_ERROR(ERR_TYPE_INCORRECT, "MultidimArray: Non complex datatype.");
     }

◆ getImage()

template<typename T>

void MultidimArray< T >::getImage	(	size_t	n,
		MultidimArray< T > &	M,
		size_t	n2 = `0`
	)		const

inline

Copy an image from a stack to another

Copy image image n from this MDA to image n2 in MDA M.

V.getImage(0, m, 3);

Definition at line 877 of file multidim_array.h.

     {
         if (XSIZE(*this) == 0)
         {
             M.clear();
             return;
         }
 
         if (n > NSIZE(*this))
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS," Multidimarray getImage: n larger than NSIZE");
 
         if (ZSIZE(*this) != ZSIZE(M) || YSIZE(*this) != YSIZE(M) || XSIZE(*this) != XSIZE(M))
         {
             if (n2 == 0)
                 M.resizeNoCopy(*this);
             else
                 REPORT_ERROR(ERR_MULTIDIM_SIZE, "MultidimArray::getImage: Target dimensions do not match source dimensions.");
         }
 
         if (n2 > NSIZE(M))
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS," Multidimarray getImage: n larger than MultidimArray target NSIZE");
 
 
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(M)
         DIRECT_NZYX_ELEM(M, n2, k, i, j) = DIRECT_NZYX_ELEM(*this, n, k, i, j);
 
         STARTINGX(M) = STARTINGX(*this);
         STARTINGY(M) = STARTINGY(*this);
         STARTINGZ(M) = STARTINGZ(*this);
     }

◆ getReal()

template<typename T>

void MultidimArray< T >::getReal ( MultidimArray< double > & realImg ) const

inline

Definition at line 1216 of file multidim_array.h.

     {
         REPORT_ERROR(ERR_TYPE_INCORRECT, "MultidimArray: Non complex datatype.");
     }

◆ getRow()

template<typename T>

void MultidimArray< T >::getRow	(	size_t	i,
		MultidimArray< T > &	v
	)		const

inline

Get row

This function returns a row vector corresponding to the chosen row inside the nth 2D matrix, the numbering of the rows is also logical not physical.

std::vector< double > v;

m.getRow(-2, v);

Definition at line 1178 of file multidim_array.h.

     {
         if (xdim == 0 || ydim == 0)
         {
             v.clear();
             return;
         }
 
         if (i >= ydim)
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "getRow: Matrix subscript (i) greater than matrix dimension");
 
         v.resizeNoCopy(xdim);
         memcpy(&A1D_ELEM(v,0),&A2D_ELEM(*this,i,0),xdim*sizeof(T));
     }

◆ getSlice()

template<typename T>

template<typename T1 >

void MultidimArray< T >::getSlice	(	int	k,
		MultidimArray< T1 > &	M,
		char	axis = `'Z'`,
		bool	reverse = `false`,
		size_t	n = `0`
	)		const

inline

2D Slice access for reading.

This function returns a slice (a 2D matrix) corresponding to the chosen slice inside the nth 3D matrix, the numbering of the slices is also logical not physical. This function differs from the previous one in that this one cuts and assign in a single step instead of in two steps, as in the previous example.

V.slice(0, m);

Definition at line 921 of file multidim_array.h.

     {
         if (XSIZE(*this) == 0)
         {
             M.clear();
             return;
         }
 
         T* ptr=NULL;
         switch (axis)
         {
         case 'Z':
             if (k < STARTINGZ(*this) || k > FINISHINGZ(*this))
                 REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,
                              "Slice: Multidim subscript (k) out of range");
 
             M.resize(1, 1, YSIZE(*this), XSIZE(*this),false);
             k = k - STARTINGZ(*this);
 
             if (reverse)
             {
                 int zEnd = ZSIZE(*this) - 1;
                 FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(M)
                 DIRECT_A2D_ELEM(M, i, j) = (T1) DIRECT_NZYX_ELEM(*this, n, k,  zEnd-i, j);
             }
             else
             {
                 ptr=&(DIRECT_NZYX_ELEM(*this, n, k, 0, 0));
                 FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(M)
                 DIRECT_MULTIDIM_ELEM(M, n) = (T1) *(ptr++);
             }
 
             STARTINGX(M) = STARTINGX(*this);
             STARTINGY(M) = STARTINGY(*this);
             break;
         case 'Y':
             if (k < STARTINGY(*this) || k > FINISHINGY(*this))
                 REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,
                              "Slice: Multidim subscript (i) out of range");
 
             k = k - STARTINGY(*this);
             M.resizeNoCopy(ZSIZE(*this), XSIZE(*this));
 
             if (reverse)
             {
                 int zEnd = ZSIZE(*this) - 1;
                 FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(M)
                 DIRECT_A2D_ELEM(M, i, j) = (T1) DIRECT_NZYX_ELEM(*this, n, zEnd-i, k, j);
             }
             else
             {
                 FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(M)
                 DIRECT_A2D_ELEM(M, i, j) = (T1) DIRECT_NZYX_ELEM(*this, n, i, k, j);
             }
 
             STARTINGX(M) = STARTINGX(*this);
             STARTINGY(M) = STARTINGZ(*this);
             break;
         case 'X':
             if (k < STARTINGX(*this) || k > FINISHINGX(*this))
                 REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,
                              "Slice: Multidim subscript (j) out of range");
 
             k = k - STARTINGX(*this);
             M.resizeNoCopy(YSIZE(*this), ZSIZE(*this));
 
             if (reverse)
             {
                 int zEnd = ZSIZE(*this) - 1;
                 FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(M)
                 DIRECT_A2D_ELEM(M, i, j) = (T1) DIRECT_NZYX_ELEM(*this, n, zEnd-j, i, k);
             }
             else
             {
                 FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(M)
                 DIRECT_A2D_ELEM(M, i, j) = (T1) DIRECT_NZYX_ELEM(*this, n, j, i, k);
             }
 
             STARTINGX(M) = STARTINGY(*this);
             STARTINGY(M) = STARTINGZ(*this);
             break;
         default:
             REPORT_ERROR(ERR_VALUE_INCORRECT,
                          formatString("Slice: not supported axis %c", axis));
         }
     }

◆ getSliceAsMatrix()

template<typename T>

void MultidimArray< T >::getSliceAsMatrix	(	size_t	k,
		Matrix2D< T > &	m
	)		const

Get Z slice as matrix

Definition at line 38 of file multidim_array.cpp.

 {
 //    there's wrong bracket somewhere, and I don't want to think about it now
 //    m.resizeNoCopy(YSIZE(*this),XSIZE(*this));
 //    memcpy(&MAT_ELEM(m,0,0),&A3D_ELEM(*this,k,0,0),YSIZE(*this),XSIZE(*this)*sizeof(double));
     REPORT_ERROR(ERR_NOT_IMPLEMENTED,"Please contact developers");
 }

◆ indexSort()

template<typename T >

void MultidimArray< T >::indexSort ( MultidimArray< int > & indx ) const

Gives a vector with the indexes for a sorted vector

This function returns the indexes of a sorted vector. The input vector is not modified at all. For instance, if the input vector is [3 2 -1 0] the result of this function would be [3 4 2 1] meaning that the lowest value is at index 3, then comes the element at index 4, ... Note that indexes start at 1.

v2 = v1.indexSort();

Definition at line 882 of file multidim_array.cpp.

 {
     checkDimension(1);
 
     MultidimArray< double > temp;
     indx.clear();
 
     if (xdim == 0)
         return;
 
     if (xdim == 1)
     {
         indx.resizeNoCopy(1);
         DIRECT_A1D_ELEM(indx,0) = 1;
         return;
     }
 
     // Initialise data
     indx.resizeNoCopy(xdim);
     typeCast(*this, temp);
 
     // Sort indexes
     double* temp_array = temp.adaptForNumericalRecipes1D();
     int* indx_array = indx.adaptForNumericalRecipes1D();
     indexx(XSIZE(*this), temp_array, indx_array);
 }

◆ initConstant()

template<typename T>

void MultidimArray< T >::initConstant ( T val )

inline

Same value in all components.

The constant must be of a type compatible with the array type, ie, you cannot assign a double to an integer array without a casting. It is not an error if the array is empty, then nothing is done.

v.initConstant(3.14);

Definition at line 2705 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = val;
     }

◆ initLinear()

template<typename T>

void MultidimArray< T >::initLinear	(	T	minF,
		T	maxF,
		int	n = `1`,
		const String &	mode = `"incr"`
	)

inline

Linear initialization (only for 1D)

The 1D vector is filled with values increasing/decreasing linearly within a range or at given steps.

Increment functionality: The default increment is 1, the initial point is incremented by this value until the upper limit is reached. This is the default working mode for the function.

v1.initLinear(1, 3); // v1=[1 2 3]
v1.initLinear(1.5, 3.1); // v1=[1.5 2.5]
v1.initLinear(0, 10, 3); // v1=[0 3 6 9]
v1.initLinear(0, 10, 3, "incr"); // v1=[0 3 6 9]

Step functionality: The given range is divided in as many points as indicated (in the example 6 points).

v1.initLinear(0, 10, 6, "steps"); // v1=[0 2 4 6 8 10]

Definition at line 2797 of file multidim_array.h.

     {
         double slope;
         int steps;
 
         if (mode == "incr")
         {
             steps = 1 + (int) FLOOR((double) ABS((maxF - minF)) / ((double) n));
             slope = n * SGN(maxF - minF);
         }
         else if (mode == "steps")
         {
             steps = n;
             slope = (maxF - minF) / (steps - 1);
         }
         else
             REPORT_ERROR(ERR_VALUE_INCORRECT, "Init_linear: Mode not supported (" + mode +
                          ")");
 
         if (steps == 0)
             clear();
         else
         {
             resizeNoCopy(steps);
             for (int i = 0; i < steps; i++)
                 A1D_ELEM(*this, i) = (T)((double) minF + slope * i);
         }
     }

◆ initRandom()

template<typename T >

template void MultidimArray< T >::initRandom	(	double	op1,
		double	op2,
		RandomMode	mode = `RND_UNIFORM`
	)

Initialize with random values.

This function allows you to initialize the array with a set of random values picked from a uniform random distribution or a gaussian one. You must choose two parameters for each, for the uniform distribution they mean the range where to generate the random numbers, while in the gaussian case they are the mean and the standard deviation. By default the uniform distribution is selected. The size and origin of the array are not modified.

v.initRandom(0, 1);
// uniform distribution between 0 and 1
v.initRandom(0, 1, "uniform");
// the same
v.initRandom(0, 1, "gaussian");
// gaussian distribution with 0 mean and stddev=1

Definition at line 821 of file multidim_array.cpp.

 {
     T* ptr=NULL;
     size_t n;
     if (mode == RND_UNIFORM)
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(rnd_unif(op1, op2));
     else if (mode == RND_GAUSSIAN)
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(rnd_gaus(op1, op2));
     else
         REPORT_ERROR(ERR_VALUE_INCORRECT,
                      formatString("InitRandom: Mode not supported"));
 }

◆ initZeros() [1/6]

template<typename T>

template<typename T1 >

void MultidimArray< T >::initZeros ( const MultidimArray< T1 > & op )

inline

Initialize to zeros following a pattern.

All values are set to 0, and the origin and size of the pattern are adopted.

v2.initZeros(v1);

Definition at line 2723 of file multidim_array.h.

     {
         if (data == NULL || !sameShape(op))
             resizeNoCopy(op);
         memset(data,0,nzyxdim*sizeof(T));
     }

◆ initZeros() [2/6]

template<typename T>

void MultidimArray< T >::initZeros ( )

inline

Initialize to zeros with current size.

All values are set to 0. The current size and origin are kept. It is not an error if the array is empty, then nothing is done.

v.initZeros();

Definition at line 2739 of file multidim_array.h.

     {
         memset(data,0,nzyxdim*sizeof(T));
     }

◆ initZeros() [3/6]

template<typename T>

void MultidimArray< T >::initZeros	(	size_t	Ndim,
		size_t	Zdim,
		size_t	Ydim,
		size_t	Xdim
	)

inline

Initialize to zeros with a given size.

Definition at line 2746 of file multidim_array.h.

     {
         if (xdim!=Xdim || ydim!=Ydim || zdim!=Zdim || ndim!=Ndim)
             resize(Ndim, Zdim,Ydim,Xdim,false);
         memset(data,0,nzyxdim*sizeof(T));
     }

◆ initZeros() [4/6]

template<typename T>

void MultidimArray< T >::initZeros ( int Xdim )

inline

Initialize to zeros with a given size.

Definition at line 2755 of file multidim_array.h.

     {
         initZeros(1, 1, 1, Xdim);
     }

◆ initZeros() [5/6]

template<typename T>

void MultidimArray< T >::initZeros	(	int	Ydim,
		int	Xdim
	)

inline

Initialize to zeros with a given size.

Definition at line 2762 of file multidim_array.h.

     {
         initZeros(1, 1, Ydim, Xdim);
     }

◆ initZeros() [6/6]

template<typename T>

void MultidimArray< T >::initZeros	(	int	Zdim,
		int	Ydim,
		int	Xdim
	)

inline

Initialize to zeros with a given size.

Definition at line 2769 of file multidim_array.h.

     {
         initZeros(1, Zdim, Ydim, Xdim);
     }

◆ interpolatedElement1D()

template<typename T>

T MultidimArray< T >::interpolatedElement1D	(	double	x,
		T	outside_value = `(T) 0`
	)		const

inline

Interpolates the value of the nth 1D matrix M at the point (x)

Bilinear interpolation. (x) is in logical coordinates.

Definition at line 1425 of file multidim_array.h.

     {
         int x0 = floor(x);
         double fx = x - x0;
         int x1 = x0 + 1;
 
         int j0=STARTINGX(*this);
         int jF=FINISHINGX(*this);
 
 #define ASSIGNVAL1D(d,j) \
      if ((j) < j0 || (j) > jF) \
       d=outside_value;\
         else \
          d=A1D_ELEM(*this, j);
 
         double d0, d1;
         ASSIGNVAL1D(d0,x0);
         ASSIGNVAL1D(d1,x1);
 
         return (T) LIN_INTERP(fx, d0, d1);
     }

◆ interpolatedElement2D()

template<typename T>

T MultidimArray< T >::interpolatedElement2D	(	double	x,
		double	y,
		T	outside_value = `(T) 0`
	)		const

inline

Interpolates the value of the nth 2D matrix M at the point (x,y)

Bilinear interpolation. (x,y) are in logical coordinates.

Definition at line 1355 of file multidim_array.h.

     {
         int x0 = floor(x);
         double fx = x - x0;
         int x1 = x0 + 1;
         int y0 = floor(y);
         double fy = y - y0;
         int y1 = y0 + 1;
 
         int i0=STARTINGY(*this);
         int j0=STARTINGX(*this);
         int iF=FINISHINGY(*this);
         int jF=FINISHINGX(*this);
 
 #define ASSIGNVAL2D(d,i,j) \
      if ((j) < j0 || (j) > jF || (i) < i0 || (i) > iF) \
       d=outside_value;\
         else \
          d=A2D_ELEM(*this, i, j);
 
         double d00, d10, d11, d01;
         ASSIGNVAL2D(d00,y0,x0);
         ASSIGNVAL2D(d01,y0,x1);
         ASSIGNVAL2D(d10,y1,x0);
         ASSIGNVAL2D(d11,y1,x1);
 
         double d0 = LIN_INTERP(fx, d00, d01);
         double d1 = LIN_INTERP(fx, d10, d11);
         return (T) LIN_INTERP(fy, d0, d1);
     }

◆ interpolatedElement2DOutsideZero()

template<typename T>

T MultidimArray< T >::interpolatedElement2DOutsideZero	(	double	x,
		double	y
	)		const

inline

Non-divergent version of interpolatedElement2D

works only for outside_value = 0 does not break vectorization

Definition at line 1391 of file multidim_array.h.

     {
         int x0 = floor(x);
         double fx = x - x0;
         int x1 = x0 + 1;
         int y0 = floor(y);
         double fy = y - y0;
         int y1 = y0 + 1;
 
         int i0=STARTINGY(*this);
         int j0=STARTINGX(*this);
         int iF=FINISHINGY(*this);
         int jF=FINISHINGX(*this);
 
         int b;
 #define ASSIGNVAL2DNODIV(d,i,j) \
         b = ((j) < j0 || (j) > jF || (i) < i0 || (i) > iF); \
         b ? d=0 : d=A2D_ELEM(*this, i, j);
 
         double d00, d10, d11, d01;
         ASSIGNVAL2DNODIV(d00,y0,x0);
         ASSIGNVAL2DNODIV(d01,y0,x1);
         ASSIGNVAL2DNODIV(d10,y1,x0);
         ASSIGNVAL2DNODIV(d11,y1,x1);
 
         double d0 = LIN_INTERP(fx, d00, d01);
         double d1 = LIN_INTERP(fx, d10, d11);
         return (T) LIN_INTERP(fy, d0, d1);
     }

◆ interpolatedElement3D()

template<typename T>

T MultidimArray< T >::interpolatedElement3D	(	double	x,
		double	y,
		double	z,
		T	outside_value = `(T) 0`
	)		const

inline

Interpolates the value of the nth 3D matrix M at the point (x,y,z).

(x,y,z) are in logical coordinates.

Definition at line 1317 of file multidim_array.h.

     {
         int x0 = FLOOR(x);
         double fx = x - x0;
         int x1 = x0 + 1;
 
         int y0 = FLOOR(y);
         double fy = y - y0;
         int y1 = y0 + 1;
 
         int z0 = FLOOR(z);
         double fz = z - z0;
         int z1 = z0 + 1;
 
         double doutside_value=outside_value;
         double d000 = (OUTSIDE3D(z0, y0, x0)) ? doutside_value : A3D_ELEM(*this, z0, y0, x0);
         double d001 = (OUTSIDE3D(z0, y0, x1)) ? doutside_value : A3D_ELEM(*this, z0, y0, x1);
         double d010 = (OUTSIDE3D(z0, y1, x0)) ? doutside_value : A3D_ELEM(*this, z0, y1, x0);
         double d011 = (OUTSIDE3D(z0, y1, x1)) ? doutside_value : A3D_ELEM(*this, z0, y1, x1);
         double d100 = (OUTSIDE3D(z1, y0, x0)) ? doutside_value : A3D_ELEM(*this, z1, y0, x0);
         double d101 = (OUTSIDE3D(z1, y0, x1)) ? doutside_value : A3D_ELEM(*this, z1, y0, x1);
         double d110 = (OUTSIDE3D(z1, y1, x0)) ? doutside_value : A3D_ELEM(*this, z1, y1, x0);
         double d111 = (OUTSIDE3D(z1, y1, x1)) ? doutside_value : A3D_ELEM(*this, z1, y1, x1);
 
         double dx00 = LIN_INTERP(fx, d000, d001);
         double dx01 = LIN_INTERP(fx, d100, d101);
         double dx10 = LIN_INTERP(fx, d010, d011);
         double dx11 = LIN_INTERP(fx, d110, d111);
         double dxy0 = LIN_INTERP(fy, dx00, dx10);
         double dxy1 = LIN_INTERP(fy, dx01, dx11);
 
         return (T) LIN_INTERP(fz, dxy0, dxy1);
     }

◆ interpolatedElementBSpline1D()

template<typename T >

T MultidimArray< T >::interpolatedElementBSpline1D	(	double	x,
		int	SplineDegree = `3`
	)		const

Interpolates the value of the nth 1D vector M at the point (x) knowing that this vector is a set of B-spline coefficients

(x) is in logical coordinates

To interpolate using splines you must first produce the Bspline coefficients. An example to interpolate a vector at (0.5) using splines would be:

MultidimArray< double > Bspline_coeffs;
myVector.produceSplineCoefficients(Bspline_coeffs, 3);
interpolated_value = Bspline_coeffs.interpolatedElementBSpline(0.5,3);

Definition at line 760 of file multidim_array.cpp.

 {
     int SplineDegree_1 = SplineDegree - 1;
 
     // Logical to physical
     x -= STARTINGX(*this);
 
     int l1 = (int)ceil(x - SplineDegree_1);
     int l2 = l1 + SplineDegree;
     int Xdim=(int)XSIZE(*this);
     double sum = 0.0;
     for (int l = l1; l <= l2; l++)
     {
         double xminusl = x - (double) l;
         int equivalent_l=l;
         if      (l<0)
             equivalent_l=-l-1;
         else if (l>=Xdim)
             equivalent_l=2*Xdim-l-1;
         double Coeff = (double) DIRECT_A1D_ELEM(*this, equivalent_l);
         double aux;
         switch (SplineDegree)
         {
         case 2:
             sum += Coeff * Bspline02(xminusl);
             break;
 
         case 3:
             BSPLINE03(aux,xminusl);
             sum += Coeff * aux;
             break;
 
         case 4:
             sum += Coeff * Bspline04(xminusl);
             break;
 
         case 5:
             sum += Coeff * Bspline05(xminusl);
             break;
 
         case 6:
             sum += Coeff * Bspline06(xminusl);
             break;
 
         case 7:
             sum += Coeff * Bspline07(xminusl);
             break;
 
         case 8:
             sum += Coeff * Bspline08(xminusl);
             break;
 
         case 9:
             sum += Coeff * Bspline09(xminusl);
             break;
         }
     }
     return (T) sum;
 }

◆ interpolatedElementBSpline2D()

template<typename T >

T MultidimArray< T >::interpolatedElementBSpline2D	(	double	x,
		double	y,
		int	SplineDegree = `3`
	)		const

Interpolates the value of the nth 2D matrix M at the point (x,y) knowing that this image is a set of B-spline coefficients

(x,y) are in logical coordinates

To interpolate using splines you must first produce the Bspline coefficients. An example to interpolate an image at (0.5,0.5) using splines would be:

MultidimArray< double > Bspline_coeffs;
myImage.produceSplineCoefficients(Bspline_coeffs, 3);
interpolated_value = Bspline_coeffs.interpolatedElementBSpline(0.5,
0.5,3);

Definition at line 570 of file multidim_array.cpp.

 {
     int SplineDegree_1 = SplineDegree - 1;
 
     // Logical to physical
     y -= STARTINGY(*this);
     x -= STARTINGX(*this);
 
     int l1 = (int)ceil(x - SplineDegree_1);
     int l2 = l1 + SplineDegree;
     int m1 = (int)ceil(y - SplineDegree_1);
     int m2 = m1 + SplineDegree;
 
     double columns = 0.0;
     double aux;
     int Ydim=(int)YSIZE(*this);
     int Xdim=(int)XSIZE(*this);
     for (int m = m1; m <= m2; m++)
     {
         int equivalent_m=m;
         if      (m<0)
             equivalent_m=-m-1;
         else if (m>=Ydim)
             equivalent_m=2*Ydim-m-1;
         double rows = 0.0;
         for (int l = l1; l <= l2; l++)
         {
             double xminusl = x - (double) l;
             int equivalent_l=l;
             if      (l<0)
                 equivalent_l=-l-1;
             else if (l>=Xdim)
                 equivalent_l=2*Xdim-l-1;
             double Coeff = DIRECT_A2D_ELEM(*this, equivalent_m,equivalent_l);
             switch (SplineDegree)
             {
             case 2:
                 rows += Coeff * Bspline02(xminusl);
                 break;
 
             case 3:
                 BSPLINE03(aux,xminusl);
                 rows += Coeff * aux;
                 break;
 
             case 4:
                 rows += Coeff * Bspline04(xminusl);
                 break;
 
             case 5:
                 rows += Coeff * Bspline05(xminusl);
                 break;
 
             case 6:
                 rows += Coeff * Bspline06(xminusl);
                 break;
 
             case 7:
                 rows += Coeff * Bspline07(xminusl);
                 break;
 
             case 8:
                 rows += Coeff * Bspline08(xminusl);
                 break;
 
             case 9:
                 rows += Coeff * Bspline09(xminusl);
                 break;
             }
         }
 
         double yminusm = y - (double) m;
         switch (SplineDegree)
         {
         case 2:
             columns += rows * Bspline02(yminusm);
             break;
 
         case 3:
             BSPLINE03(aux,yminusm);
             columns += rows * aux;
             break;
 
         case 4:
             columns += rows * Bspline04(yminusm);
             break;
 
         case 5:
             columns += rows * Bspline05(yminusm);
             break;
 
         case 6:
             columns += rows * Bspline06(yminusm);
             break;
 
         case 7:
             columns += rows * Bspline07(yminusm);
             break;
 
         case 8:
             columns += rows * Bspline08(yminusm);
             break;
 
         case 9:
             columns += rows * Bspline09(yminusm);
             break;
         }
     }
     return (T) columns;
 }

◆ interpolatedElementBSpline2D_Degree3()

template<typename T >

T MultidimArray< T >::interpolatedElementBSpline2D_Degree3	(	double	x,
		double	y
	)		const

Definition at line 682 of file multidim_array.cpp.

 {
     bool    firstTime=true;         // Inner loop first time execution flag.
     double  *ref;
 
     // Logical to physical
     y -= STARTINGY(*this);
     x -= STARTINGX(*this);
 
     int l1 = (int)ceil(x - 2);
     int l2 = l1 + 3;
     int m1 = (int)ceil(y - 2);
     int m2 = m1 + 3;
 
     double columns = 0.0;
     double aux;
     int Ydim=(int)YSIZE(*this);
     int Xdim=(int)XSIZE(*this);
 
     int     equivalent_l_Array[LOOKUP_TABLE_LEN]; // = new int [l2 - l1 + 1];
     double  aux_Array[LOOKUP_TABLE_LEN];// = new double [l2 - l1 + 1];
 
     for (int m = m1; m <= m2; m++)
     {
         int equivalent_m=m;
         if      (m<0)
             equivalent_m=-m-1;
         else if (m>=Ydim)
             equivalent_m=2*Ydim-m-1;
         double rows = 0.0;
         int index=0;
         ref = &DIRECT_A2D_ELEM(*this, equivalent_m,0);
         for (int l = l1; l <= l2; l++)
         {
             int equivalent_l;
             // Check if it is first time executing inner loop.
             if (firstTime)
             {
                 double xminusl = x - (double) l;
                 equivalent_l=l;
                 if (l<0)
                 {
                     equivalent_l=-l-1;
                 }
                 else if (l>=Xdim)
                 {
                     equivalent_l=2*Xdim-l-1;
                 }
 
                 equivalent_l_Array[index] = equivalent_l;
                 BSPLINE03(aux,xminusl);
                 aux_Array[index] = aux;
                 index++;
             }
             else
             {
                 equivalent_l = equivalent_l_Array[index];
                 aux = aux_Array[index];
                 index++;
             }
 
             //double Coeff = DIRECT_A2D_ELEM(*this, equivalent_m,equivalent_l);
             double Coeff = ref[equivalent_l];
             rows += Coeff * aux;
         }
 
         // Set first time inner flag is executed to false.
         firstTime = false;
 
         double yminusm = y - (double) m;
         BSPLINE03(aux,yminusm);
         columns += rows * aux;
     }
 
     return (T) columns;
 }

◆ interpolatedElementBSpline3D()

template<typename T >

T MultidimArray< T >::interpolatedElementBSpline3D	(	double	x,
		double	y,
		double	z,
		int	SplineDegree = `3`
	)		const

Interpolates the value of the nth 3D matrix M at the point (x,y,z) knowing that this image is a set of B-spline coefficients.

(x,y,z) are in logical coordinates.

Definition at line 424 of file multidim_array.cpp.

 {
     int SplineDegree_1 = SplineDegree - 1;
 
     // Logical to physical
     z -= STARTINGZ(*this);
     y -= STARTINGY(*this);
     x -= STARTINGX(*this);
 
     int l1 = (int)ceil(x - SplineDegree_1);
     int l2 = l1 + SplineDegree;
 
     int m1 = (int)ceil(y - SplineDegree_1);
     int m2 = m1 + SplineDegree;
 
     int n1 = (int)ceil(z - SplineDegree_1);
     int n2 = n1 + SplineDegree;
 
     double zyxsum = 0.0;
     double aux;
     int Xdim=(int)XSIZE(*this);
     int Ydim=(int)YSIZE(*this);
     int Zdim=(int)ZSIZE(*this);
     for (int nn = n1; nn <= n2; nn++)
     {
         int equivalent_nn=nn;
         if      (nn<0)
             equivalent_nn=-nn-1;
         else if (nn>=Zdim)
             equivalent_nn=2*Zdim-nn-1;
         double yxsum = 0.0;
         for (int m = m1; m <= m2; m++)
         {
             int equivalent_m=m;
             if      (m<0)
                 equivalent_m=-m-1;
             else if (m>=Ydim)
                 equivalent_m=2*Ydim-m-1;
             double xsum = 0.0;
             for (int l = l1; l <= l2; l++)
             {
                 double xminusl = x - (double) l;
                 int equivalent_l=l;
                 if      (l<0)
                     equivalent_l=-l-1;
                 else if (l>=Xdim)
                     equivalent_l=2*Xdim-l-1;
                 double Coeff = (double) DIRECT_A3D_ELEM(*this,
                                                         equivalent_nn,equivalent_m,equivalent_l);
                 switch (SplineDegree)
                 {
                 case 2:
                     xsum += Coeff * Bspline02(xminusl);
                     break;
                 case 3:
                     BSPLINE03(aux,xminusl);
                     xsum += Coeff * aux;
                     break;
                 case 4:
                     xsum += Coeff * Bspline04(xminusl);
                     break;
                 case 5:
                     xsum += Coeff * Bspline05(xminusl);
                     break;
                 case 6:
                     xsum += Coeff * Bspline06(xminusl);
                     break;
                 case 7:
                     xsum += Coeff * Bspline07(xminusl);
                     break;
                 case 8:
                     xsum += Coeff * Bspline08(xminusl);
                     break;
                 case 9:
                     xsum += Coeff * Bspline09(xminusl);
                     break;
                 }
             }
 
             double yminusm = y - (double) m;
             switch (SplineDegree)
             {
             case 2:
                 yxsum += xsum * Bspline02(yminusm);
                 break;
             case 3:
                 BSPLINE03(aux,yminusm);
                 yxsum += xsum * aux;
                 break;
             case 4:
                 yxsum += xsum * Bspline04(yminusm);
                 break;
             case 5:
                 yxsum += xsum * Bspline05(yminusm);
                 break;
             case 6:
                 yxsum += xsum * Bspline06(yminusm);
                 break;
             case 7:
                 yxsum += xsum * Bspline07(yminusm);
                 break;
             case 8:
                 yxsum += xsum * Bspline08(yminusm);
                 break;
             case 9:
                 yxsum += xsum * Bspline09(yminusm);
                 break;
             }
         }
 
         double zminusn = z - (double) nn;
         switch (SplineDegree)
         {
         case 2:
             zyxsum += yxsum * Bspline02(zminusn);
             break;
         case 3:
             BSPLINE03(aux,zminusn);
             zyxsum += yxsum * aux;
             break;
         case 4:
             zyxsum += yxsum * Bspline04(zminusn);
             break;
         case 5:
             zyxsum += yxsum * Bspline05(zminusn);
             break;
         case 6:
             zyxsum += yxsum * Bspline06(zminusn);
             break;
         case 7:
             zyxsum += yxsum * Bspline07(zminusn);
             break;
         case 8:
             zyxsum += yxsum * Bspline08(zminusn);
             break;
         case 9:
             zyxsum += yxsum * Bspline09(zminusn);
             break;
         }
     }
 
     return (T) zyxsum;
 }

◆ killAdaptationForNumericalRecipes1D()

template<typename T>

void MultidimArray< T >::killAdaptationForNumericalRecipes1D ( T * m ) const

inline

Kill a 1D array produced for Numerical Recipes.

Nothing needs to be done in fact.

This function is not ported to Python.

Definition at line 2987 of file multidim_array.h.

2988 {}

◆ killAdaptationForNumericalRecipes22D()

template<typename T>

void MultidimArray< T >::killAdaptationForNumericalRecipes22D ( T ** m ) const

inline

Kill a 2D array produced for numerical recipes, 2.

Nothing needs to be done.

Definition at line 2964 of file multidim_array.h.

2965 {}

◆ killAdaptationForNumericalRecipes2D()

template<typename T>

void MultidimArray< T >::killAdaptationForNumericalRecipes2D ( T ** m ) const

inline

Kill a 2D array produced for numerical recipes

The allocated memory is freed.

Definition at line 2955 of file multidim_array.h.

     {
         free_Tmatrix(m, 1, YSIZE(*this), 1, XSIZE(*this));
     }

◆ killAdaptationForNumericalRecipes3D()

template<typename T>

void MultidimArray< T >::killAdaptationForNumericalRecipes3D ( T *** m ) const

inline

Kill a 3D array produced for numerical recipes.

Definition at line 2907 of file multidim_array.h.

     {
         free_Tvolume(m, 1, ZSIZE(*this), 1, YSIZE(*this), 1, XSIZE(*this));
     }

◆ loadFromNumericalRecipes2D()

template<typename T>

void MultidimArray< T >::loadFromNumericalRecipes2D	(	T **	m,
		int	Ydim,
		int	Xdim
	)

inline

Load 2D array from numerical recipes result.

Definition at line 2942 of file multidim_array.h.

     {
         resizeNoCopy(Ydim, Xdim);
 
         for (int i = 1; i <= Ydim; i++)
             for (int j = 1; j <= Xdim; j++)
                 DIRECT_A2D_ELEM(*this,i - 1, j - 1) = m[i][j];
     }

◆ maxIndex() [1/2]

template<typename T>

void MultidimArray< T >::maxIndex ( int & jmax ) const

inline

1D Indices for the maximum element.

This function just calls to the 4D function

Definition at line 1557 of file multidim_array.h.

     {
         size_t zeroLong=0;
         int zeroInt=0;
         maxIndex(zeroLong,zeroInt,zeroInt,jmax);
     }

◆ maxIndex() [2/2]

template<typename T>

void MultidimArray< T >::maxIndex	(	size_t &	lmax,
		int &	kmax,
		int &	imax,
		int &	jmax
	)		const

inlinevirtual

4D Indices for the maximum element.

This function returns the index of the maximum element of an array. array(l,k,i,j). Returns -1 if the array is empty

Implements MultidimArrayBase.

Definition at line 1654 of file multidim_array.h.

     {
         if (XSIZE(*this) == 0)
         {
             lmax = kmax = imax = jmax = -1;
             return;
         }
 
         kmax = STARTINGZ(*this);
         imax = STARTINGY(*this);
         jmax = STARTINGX(*this);
         lmax = 0;
         size_t n=0;
         T maxval = DIRECT_MULTIDIM_ELEM(*this, n);
 
         FOR_ALL_NZYX_ELEMENTS_IN_MULTIDIMARRAY(*this)
         {
             T val=DIRECT_MULTIDIM_ELEM(*this, n);
             if (val > maxval)
             {
                 maxval = val;
                 lmax = l;
                 kmax = k;
                 imax = i;
                 jmax = j;
             }
             ++n;
         }
     }

◆ minIndex() [1/4]

template<typename T>

void MultidimArray< T >::minIndex	(	int &	lmin,
		int &	kmin,
		int &	imin,
		int &	jmin
	)		const

inline

4D Indices for the minimum element.

This function returns the index of the minimum element of an array. array(l,k,i,j). Returns -1 if the array is empty

Definition at line 1589 of file multidim_array.h.

     {
         if (XSIZE(*this) == 0)
         {
             lmin = kmin = imin = jmin = -1;
             return;
         }
 
         kmin = STARTINGZ(*this);
         imin = STARTINGY(*this);
         jmin = STARTINGX(*this);
         lmin = 0;
         size_t n=0;
         T minval = DIRECT_MULTIDIM_ELEM(*this, n);
 
         FOR_ALL_NZYX_ELEMENTS_IN_MULTIDIMARRAY(*this)
         {
             T val=DIRECT_MULTIDIM_ELEM(*this,n);
             if (val > minval)
             {
                 minval = val;
                 lmin = l;
                 kmin = k;
                 imin = i;
                 jmin = j;
             }
             ++n;
         }
     }

◆ minIndex() [2/4]

template<typename T>

void MultidimArray< T >::minIndex	(	int &	kmin,
		int &	imin,
		int &	jmin
	)		const

inline

3D Indices for the minimum element.

This function just calls to the 4D function

Definition at line 1623 of file multidim_array.h.

     {
         int zeroInt=0;
         minIndex(zeroInt,kmin,imin,jmin);
     }

◆ minIndex() [3/4]

template<typename T>

void MultidimArray< T >::minIndex	(	int &	imin,
		int &	jmin
	)		const

inline

2D Indices for the minimum element.

This function just calls to the 4D function

Definition at line 1633 of file multidim_array.h.

     {
         int zeroInt=0;
         minIndex(zeroInt,zeroInt,imin,jmin);
     }

◆ minIndex() [4/4]

template<typename T>

void MultidimArray< T >::minIndex ( int & jmin ) const

inline

1D Indices for the minimum element.

This function just calls to the 4D function

Definition at line 1643 of file multidim_array.h.

     {
         int zeroInt=0;
         minIndex(zeroInt,zeroInt,zeroInt,jmin);
     }

◆ mmapFile()

template<typename T>

template FILE * MultidimArray< T >::mmapFile	(	T *&	_data,
		size_t	nzyxDim
	)		const

Definition at line 859 of file multidim_array.cpp.

 {
 #ifdef XMIPP_MMAP
     FILE* fMap = tmpfile();
     int Fd = fileno(fMap);
 
     if ((lseek(Fd, nzyxDim*sizeof(T)-1, SEEK_SET) == -1) || (::write(Fd,"",1) == -1))
     {
         fclose(fMap);
         REPORT_ERROR(ERR_IO_NOWRITE,"MultidimArray::resize: Error 'stretching' the map file.");
     }
     if ( (_data = (T*) mmap(0,nzyxDim*sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, Fd, 0)) == (void*) MAP_FAILED )
         REPORT_ERROR(ERR_MMAP_NOTADDR,formatString("MultidimArray::resize: mmap failed. Error %s", strerror(errno)));
 
     return fMap;
 #else
 
     REPORT_ERROR(ERR_MMAP,"Mapping not supported in Windows");
 #endif
 
 }

◆ operator()() [1/6]

template<typename T>

T& MultidimArray< T >::operator() ( const Matrix1D< double > & v ) const

inline

Volume element access via double vector.

Returns the value of a matrix logical position, but this time the element position is determined by a R3 vector. The elements can be used either by value or by reference. An exception is thrown if the index is outside the logical range. Pay attention in the following example that we are accessing the same element as in the previous function but, now we have to give first the X position because we are building first a vector of the form (x,y,z).

V(vectorR3(1, -2, 0)) = 1;

val = V(vectorR3(1, -2, 0));

Definition at line 755 of file multidim_array.h.

     {
         switch (VEC_XSIZE(v))
         {
         case 1:
             return A1D_ELEM((*this), ROUND(XX(v)));
         case 2:
             return A2D_ELEM((*this), ROUND(YY(v)), ROUND(XX(v)));
         case 3:
             return A3D_ELEM((*this), ROUND(ZZ(v)), ROUND(YY(v)), ROUND(XX(v)));
         default:
             REPORT_ERROR(ERR_ARG_INCORRECT,"Cannot handle indexes with dimension larger than 3");
         }
     }

◆ operator()() [2/6]

template<typename T>

T& MultidimArray< T >::operator() ( const Matrix1D< int > & v ) const

inline

Volume element access via integer vector.

Definition at line 772 of file multidim_array.h.

     {
         switch (VEC_XSIZE(v))
         {
         case 1:
             return A1D_ELEM((*this), XX(v));
         case 2:
             return A2D_ELEM((*this), YY(v), XX(v));
         case 3:
             return A3D_ELEM((*this), ZZ(v), YY(v), XX(v));
         default:
             REPORT_ERROR(ERR_ARG_INCORRECT,"Cannot handle indexes with dimension larger than 3");
         }
     }

◆ operator()() [3/6]

template<typename T>

T& MultidimArray< T >::operator()	(	size_t	n,
		int	k,
		int	i,
		int	j
	)		const

inline

4D element access via index.

Returns the value of a matrix logical position. In our example we could access from v(0, 0,-2,-1) to v(0, 1,2,1). The elements can be used either by value or by reference. An exception is thrown if the index is outside the logical range. Be careful that the argument order is (Z,Y,X).

V(0, 0, -2, 1) = 1;

val = V(0, 0, -2, 1);

Definition at line 799 of file multidim_array.h.

     {
         return NZYX_ELEM(*this, n, k, i, j);
     }

◆ operator()() [4/6]

template<typename T>

T& MultidimArray< T >::operator()	(	int	k,
		int	i,
		int	j
	)		const

inline

3D element access via index.

Returns the value of a matrix logical position. In our example we could access from v(0,-2,-1) to v(1,2,1). The elements can be used either by value or by reference. An exception is thrown if the index is outside the logical range. Be careful that the argument order is (Z,Y,X).

V(0, -2, 1) = 1;

val = V(0, -2, 1);

Definition at line 816 of file multidim_array.h.

     {
         return A3D_ELEM(*this, k, i, j);
     }

◆ operator()() [5/6]

template<typename T>

T& MultidimArray< T >::operator()	(	int	i,
		int	j
	)		const

inline

Matrix element access via index

Returns the value of a matrix logical position. In our example we could access from v(-2,-1) to v(2,1). The elements can be used either by value or by reference. An exception is thrown if the index is outside the logical range. The first argument is the Y position and the second the X position.

m(-2, 1) = 1;

val = m(-2, 1);

Definition at line 834 of file multidim_array.h.

     {
         return A2D_ELEM(*this, i, j);
     }

◆ operator()() [6/6]

template<typename T>

T& MultidimArray< T >::operator() ( int i ) const

inline

Vector element access

Returns the value of a vector logical position. In our example we could access from v(-2) to v(2). The elements can be used either by value or by reference. An exception is thrown if the index is outside the logical range.

v(-2) = 1;

val = v(-2);

Definition at line 851 of file multidim_array.h.

     {
         return A1D_ELEM(*this, i);
     }

◆ operator*() [1/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator* ( const MultidimArray< T > & op1 ) const

inline

v3 = v1 * v2.

Definition at line 2360 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByArray(*this, op1, tmp, '*');
         return tmp;
     }

◆ operator*() [2/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator* ( T op1 ) const

inline

v3 = v1 * k.

Definition at line 2526 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByScalar(*this, op1, tmp, '*');
         return tmp;
     }

◆ operator*=() [1/2]

template<typename T>

void MultidimArray< T >::operator*= ( const MultidimArray< T > & op1 )

inline

v3 *= v2.

Definition at line 2392 of file multidim_array.h.

     {
         arrayByArray(*this, op1, *this, '*');
     }

◆ operator*=() [2/2]

template<typename T>

void MultidimArray< T >::operator*= ( const T & op1 )

inline

v3 *= k.

This function is not ported to Python.

Definition at line 2574 of file multidim_array.h.

     {
         arrayByScalar(*this, op1, *this, '*');
     }

◆ operator+() [1/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator+ ( const MultidimArray< T > & op1 ) const

inline

v3 = v1 + v2.

Definition at line 2342 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByArray(*this, op1, tmp, '+');
         return tmp;
     }

◆ operator+() [2/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator+ ( T op1 ) const

inline

v3 = v1 + k.

Definition at line 2508 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByScalar(*this, op1, tmp, '+');
         return tmp;
     }

◆ operator+=() [1/2]

template<typename T>

void MultidimArray< T >::operator+= ( const MultidimArray< T > & op1 )

inline

v3 += v2.

Definition at line 2378 of file multidim_array.h.

     {
         arrayByArray(*this, op1, *this, '+');
     }

◆ operator+=() [2/2]

template<typename T>

void MultidimArray< T >::operator+= ( const T & op1 )

inline

v3 += k.

This function is not ported to Python.

Definition at line 2556 of file multidim_array.h.

     {
         arrayByScalar(*this, op1, *this, '+');
     }

◆ operator-() [1/3]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator- ( const MultidimArray< T > & op1 ) const

inline

v3 = v1 - v2.

Definition at line 2351 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByArray(*this, op1, tmp, '-');
         return tmp;
     }

◆ operator-() [2/3]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator- ( T op1 ) const

inline

v3 = v1 - k.

Definition at line 2517 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByScalar(*this, op1, tmp, '-');
         return tmp;
     }

◆ operator-() [3/3]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator- ( void ) const

inline

Unary minus.

It is used to build arithmetic expressions. You can make a minus of anything as long as it is correct semantically.

v1 = -v2;

v1 = -v2.transpose();

Definition at line 3684 of file multidim_array.h.

     {
         MultidimArray<T> tmp(*this);
         T* ptr;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(tmp,n,ptr)
         *ptr = -(*ptr);
         return tmp;
     }

◆ operator-=() [1/2]

template<typename T>

void MultidimArray< T >::operator-= ( const MultidimArray< T > & op1 )

inline

v3 -= v2.

Definition at line 2385 of file multidim_array.h.

     {
         arrayByArray(*this, op1, *this, '-');
     }

◆ operator-=() [2/2]

template<typename T>

void MultidimArray< T >::operator-= ( const T & op1 )

inline

v3 -= k.

This function is not ported to Python.

Definition at line 2565 of file multidim_array.h.

     {
         arrayByScalar(*this, op1, *this, '-');
     }

◆ operator/() [1/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator/ ( const MultidimArray< T > & op1 ) const

inline

v3 = v1 / v2.

Definition at line 2369 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByArray(*this, op1, tmp, '/');
         return tmp;
     }

◆ operator/() [2/2]

template<typename T>

MultidimArray<T> MultidimArray< T >::operator/ ( T op1 ) const

inline

v3 = v1 / k.

Definition at line 2535 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         arrayByScalar(*this, op1, tmp, '/');
         return tmp;
     }

◆ operator/=() [1/2]

template<typename T>

void MultidimArray< T >::operator/= ( const MultidimArray< T > & op1 )

inline

v3 /= v2.

Definition at line 2399 of file multidim_array.h.

     {
         arrayByArray(*this, op1, *this, '/');
     }

◆ operator/=() [2/2]

template<typename T>

void MultidimArray< T >::operator/= ( const T & op1 )

inline

v3 /= k.

This function is not ported to Python.

Definition at line 2583 of file multidim_array.h.

     {
         arrayByScalar(*this, op1, *this, '/');
     }

◆ operator=() [1/3]

template<typename T>

MultidimArray<T>& MultidimArray< T >::operator= ( const MultidimArray< T > & op1 )

inline

Assignment.

You can build as complex assignment expressions as you like. Multiple assignment is allowed.

v1 = v2 + v3;

v1 = v2 = v3;

This function is ported to Python as assign.

Definition at line 3628 of file multidim_array.h.

     {
         if (&op1 != this)
         {
             if (data == NULL || !sameShape(op1))
                 resizeNoCopy(op1);
             memcpy(data,op1.data,MULTIDIM_SIZE(op1)*sizeof(T));
         }
         return *this;
     }

◆ operator=() [2/3]

template<typename T>

MultidimArray<T>& MultidimArray< T >::operator= ( MultidimArray< T > && other )

inlinenoexcept

Move assignment.

You can build as complex assignment expressions as you like. Multiple assignment is allowed.

v1 = v2 + v3;

v1 = v2 = v3;

Definition at line 3649 of file multidim_array.h.

     {
         if (&other != this)
         {
             coreDeallocate();
             coreInit();
             swap(other);
         }
         return *this;
     }

◆ operator=() [3/3]

template<typename T>

MultidimArray< T > & MultidimArray< T >::operator= ( const Matrix2D< T > & op1 )

Assignment.

You can build as complex assignment expressions as you like. Multiple assignment is allowed.

v1 = v2 + v3;

v1 = v2 = v3;

This function is ported to Python as assign.

Definition at line 47 of file multidim_array.cpp.

 {
     resizeNoCopy(MAT_YSIZE(op1), MAT_XSIZE(op1));
     memcpy(data,MATRIX2D_ARRAY(op1), MAT_SIZE(op1)*sizeof(T));
 
     return *this;
 }

◆ operator[]()

template<typename T>

T& MultidimArray< T >::operator[] ( size_t i ) const

inline

Definition at line 856 of file multidim_array.h.

      {
          return data[i];
      }

◆ patch()

template<typename T>

void MultidimArray< T >::patch	(	MultidimArray< T >	patchArray,
		int	x,
		int	y
	)

inline

Make a patch with the input array in the given positions

Definition at line 727 of file multidim_array.h.

     {
         int n = XSIZE(patchArray)*sizeof(T);
 
         for (size_t i=0; i < YSIZE(patchArray); ++i)
             memcpy(&dAij(*this, y+i, x), &dAij(patchArray, i, 0), n);
     }

◆ printStats()

template<typename T>

void MultidimArray< T >::printStats ( std::ostream & out = std::cout ) const

inline

Print statistics in current line.

No end of line character is written after this print out.

a.computeStats();
std::cout << "Statistics of variable a ";
a.printStats();
std::cout << std::endl;

Definition at line 1507 of file multidim_array.h.

     {
         T minval, maxval;
         double avgval, devval;
 
         computeStats(avgval, devval, minval, maxval);
 
         out.setf(std::ios::showpoint);
         int old_prec = out.precision(7);
 
         out << " min= ";
         out.width(9);
         out << minval;
         out << " max= ";
         out.width(9);
         out << maxval;
         out << " avg= ";
         out.width(9);
         out << avgval;
         out << " dev= ";
         out.width(9);
         out << devval;
 
         out.precision(old_prec);
     }

◆ profile()

template<typename T>

void MultidimArray< T >::profile	(	int	x0,
		int	y0,
		int	xF,
		int	yF,
		int	N,
		MultidimArray< double > &	profile
	)		const

inline

Extracts the 1D profile between two points in a 2D array

Given two logical indexes, this function returns samples of the line that joins them. This is done by bilinear interpolation. The number of samples in the line is N.

Definition at line 3576 of file multidim_array.h.

     {
         checkDimension(2);
         profile.initZeros(N);
         double tx_step = (double)(xF - x0) / (N - 1);
         double ty_step = (double)(yF - y0) / (N - 1);
         double tx = x0, ty = y0;
 
         for (int i = 0; i < N; i++)
         {
             profile(i) = interpolatedElement2D(tx, ty);
             tx += tx_step;
             ty += ty_step;
         }
     }

◆ randomSubstitute()

template<typename T>

void MultidimArray< T >::randomSubstitute	(	T	oldv,
		T	avgv,
		T	sigv,
		double	accuracy = `XMIPP_EQUAL_ACCURACY`,
		MultidimArray< int > *	mask = `NULL`
	)

Substitute a given value by a sample from a Gaussian distribution.

Substitute a given value by a sample from a Gaussian distribution. The accuracy is used to say if the value in the array is equal to the old value. Set it to 0 for perfect accuracy.

Definition at line 1120 of file multidim_array.cpp.

 {
     T* ptr=NULL;
     size_t n;
     FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
     if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
         if (ABS(*ptr - oldv) <= accuracy)
             *ptr = rnd_gaus(avgv, sigv);
 }

◆ rangeAdjust() [1/3]

template<typename T>

void MultidimArray< T >::rangeAdjust	(	T	minF,
		T	maxF
	)

inline

Adjust the range of the array to a given one.

A linear operation is performed on the values of the array such that after it, the values of the array are comprissed between the two values set. The actual array is modified itself

v.rangeAdjust(0, 1);

// The array is now ranging from 0 to 1

Definition at line 1982 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return;
 
         double min0=0., max0=0.;
         computeDoubleMinMax(min0, max0);
 
         // If max0==min0, it means that the vector is a constant one, so the
         // only possible transformation is to a fixed minF
         double slope;
         if (max0 != min0)
             slope = static_cast< double >(maxF - minF) /
                     static_cast< double >(max0 - min0);
         else
             slope = 0;
 
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = minF + static_cast< T >(slope *
                                        static_cast< double >(*ptr - min0));
     }

◆ rangeAdjust() [2/3]

template<typename T>

void MultidimArray< T >::rangeAdjust	(	T	minF,
		T	maxF,
		MultidimArray< int > &	mask
	)

inline

Adjust the range of the array to a given one within a mask.

A linear operation is performed on the values of the array such that after it, the values of the array are comprissed between the two values set. The actual array is modified itself. The linear transformation is computed within the mask, but it is applied everywhere.

v.rangeAdjust(0, 1, mask);

// The array is now ranging from 0 to 1

Definition at line 2019 of file multidim_array.h.

     {
         if (MULTIDIM_SIZE(*this) <= 0)
             return;
 
         double min0=0., max0=0.;
         bool first=true;
         T* ptr=NULL;
         size_t n;
         int * ptrMask=MULTIDIM_ARRAY(mask);
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         {
             if (*ptrMask)
             {
                 T val= *ptr;
                 if (first)
                 {
                     min0=max0=(double)val;
                     first=false;
                 }
                 else
                 {
                     min0=XMIPP_MIN(min0,val);
                     max0=XMIPP_MAX(max0,val);
                 }
             }
             ptrMask++;
         }
 
         // If max0==min0, it means that the vector is a constant one, so the
         // only possible transformation is to a fixed minF
         double slope;
         if (max0 != min0)
             slope = static_cast< double >(maxF - minF) /
                     static_cast< double >(max0 - min0);
         else
             slope = 0;
 
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = minF + static_cast< T >(slope *
                                        static_cast< double >(*ptr - min0));
     }

◆ rangeAdjust() [3/3]

template<typename T>

void MultidimArray< T >::rangeAdjust	(	const MultidimArray< T > &	example,
		const MultidimArray< int > *	mask = `NULL`
	)

inline

Adjust the range of the array to the range of another array in a least squares sense.

A linear operation is performed on the values of the array such that after it, the values of the self array are as similar as possible (L2 sense) to the values of the array shown as sample

Definition at line 2073 of file multidim_array.h.

     {
         if (NZYXSIZE(*this) <= 0)
             return;
 
         double avgExample=0., stddevExample=0., avgThis, stddevThis;
         if (mask!=NULL)
         {
             example.computeAvgStdev_within_binary_mask(*mask,avgExample,stddevExample);
             computeAvgStdev_within_binary_mask(*mask,avgThis,stddevThis);
         }
         else
         {
             computeAvgStdev(avgThis,stddevThis);
             example.computeAvgStdev(avgExample,stddevExample);
         }
 
         // y=a+bx
         double b=stddevThis>0? stddevExample/stddevThis:0;
         double a=avgExample-avgThis*b;
 
         size_t n;
         T *ptr=NULL;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(a+b * static_cast< double > (*ptr));
     }

◆ resize() [1/2]

template<typename T >

void MultidimArray< T >::resize	(	size_t	Ndim,
		size_t	Zdim,
		size_t	Ydim,
		size_t	Xdim,
		bool	copy = `true`
	)

virtual

Resize to a given size

This function resize the actual array to the given size. The origin is not modified. If the actual array is larger than the pattern then the values outside the new size are lost, if it is smaller then 0's are added. An exception is thrown if there is no memory.

V1.resize(3, 3, 2);

Implements MultidimArrayBase.

Definition at line 983 of file multidim_array.cpp.

 {
     if (Ndim*Zdim*Ydim*Xdim == nzyxdimAlloc && data != NULL)
     {
         ndim = Ndim;
         xdim = Xdim;
         ydim = Ydim;
         zdim = Zdim;
         yxdim = Ydim * Xdim;
         zyxdim = Zdim * yxdim;
         nzyxdim = Ndim * zyxdim;
         return;
     }
     else if (!destroyData)
         REPORT_ERROR(ERR_MULTIDIM_SIZE, "Cannot resize array when accessing through alias.");
 
     if (Xdim <= 0 || Ydim <= 0 || Zdim <= 0 || Ndim <= 0)
     {
         clear();
         return;
     }
 
     // data can be NULL while xdim etc are set to non-zero values
     // (This can happen for reading of images...)
     // In that case, initialize data to zeros.
     if (NZYXSIZE(*this) > 0 && data == NULL)
     {
         ndim = Ndim;
         xdim = Xdim;
         ydim = Ydim;
         zdim = Zdim;
         yxdim = Ydim * Xdim;
         zyxdim = Zdim * yxdim;
         nzyxdim = Ndim * zyxdim;
 
         coreAllocate();
         return;
     }
 
     // Ask for memory
     size_t YXdim=(size_t)Ydim*Xdim;
     size_t ZYXdim=YXdim*Zdim;
     size_t NZYXdim=ZYXdim*Ndim;
     FILE*  new_mFd=NULL;
 
     T * new_data=NULL;
 
     try
     {
         if (mmapOn)
             new_mFd = mmapFile(new_data, NZYXdim);
         else
             new_data = new T [NZYXdim];
 
         memset(new_data,0,NZYXdim*sizeof(T));
     }
     catch (std::bad_alloc &)
     {
         if (!mmapOn)
         {
             setMmap(true);
             resize(Ndim, Zdim, Ydim, Xdim, copy);
             return;
         }
         else
         {
             std::ostringstream sstream;
             sstream << "Allocate: No space left to allocate ";
             sstream << (NZYXdim * sizeof(T)/1024/1024/1024) ;
             sstream << "Gb." ;
             REPORT_ERROR(ERR_MEM_NOTENOUGH, sstream.str());
         }
     }
     // Copy needed elements, fill with 0 if necessary
     if (copy)
     {
         const auto nCopy = std::min(Ndim, NSIZE(*this));
         const auto zCopy = std::min(Zdim, ZSIZE(*this));
         const auto yCopy = std::min(Ydim, YSIZE(*this));
         const auto xCopy = std::min(Xdim, XSIZE(*this));
         const auto xCopyBytes = xCopy*sizeof(T);
 
         for (size_t l = 0; l < nCopy; ++l) 
             for (size_t k = 0; k < zCopy; ++k) 
                 for (size_t i = 0; i < yCopy; ++i) 
                     memcpy(
                         new_data + l*ZYXdim + k*YXdim + i*Xdim,
                         data + l*zyxdim + k*yxdim + i*xdim,
                         xCopyBytes
                     );
     }
 
     // deallocate old array
     coreDeallocate();
 
     // assign *this vector to the newly created
     data = new_data;
     ndim = Ndim;
     xdim = Xdim;
     ydim = Ydim;
     zdim = Zdim;
     yxdim = Ydim * Xdim;
     zyxdim = Zdim * yxdim;
     nzyxdim = Ndim * zyxdim;
     mFd = new_mFd;
     nzyxdimAlloc = nzyxdim;
 }

◆ resize() [2/2]

template<typename T>

template<typename T1 >

void MultidimArray< T >::resize	(	const MultidimArray< T1 > &	v,
		bool	copy = `true`
	)

inline

Resize according to a pattern.

This function resize the actual array to the same size and origin as the input pattern. If the actual array is larger than the pattern then the trailing values are lost, if it is smaller then 0's are added at the end

v2.resize(v1);

// v2 has got now the same structure as v1

Definition at line 490 of file multidim_array.h.

     {
         if (NSIZE(*this) != NSIZE(v) || XSIZE(*this) != XSIZE(v) ||
             YSIZE(*this) != YSIZE(v) || ZSIZE(*this) != ZSIZE(v) || data==NULL)
             resize(NSIZE(v), ZSIZE(v), YSIZE(v), XSIZE(v), copy);
 
         STARTINGX(*this) = STARTINGX(v);
         STARTINGY(*this) = STARTINGY(v);
         STARTINGZ(*this) = STARTINGZ(v);
     }

◆ resizeNoCopy()

template<typename T>

template<typename T1 >

void MultidimArray< T >::resizeNoCopy ( const MultidimArray< T1 > & v )

inline

Resize according to a pattern with no copy.

Definition at line 504 of file multidim_array.h.

     {
         if (NSIZE(*this) != NSIZE(v) || XSIZE(*this) != XSIZE(v) ||
             YSIZE(*this) != YSIZE(v) || ZSIZE(*this) != ZSIZE(v) || data==NULL)
             resize(NSIZE(v), ZSIZE(v), YSIZE(v), XSIZE(v), false);
 
         STARTINGX(*this) = STARTINGX(v);
         STARTINGY(*this) = STARTINGY(v);
         STARTINGZ(*this) = STARTINGZ(v);
     }

◆ reslice() [1/2]

template<typename T>

template<typename T1 >

void MultidimArray< T >::reslice	(	MultidimArray< T1 > &	out,
		AxisView	face,
		bool	flip = `false`,
		size_t	n = `0`
	)		const

inline

Reslice the volume aliging any X or Y direction with Z axis

Parameters

face	Select the face to become the new Z direction
out	The resliced volume is returned
flip	Invert the positions of Z planes, keeping the X-Y orientation
n	Select the number of image in case of stacks

Definition at line 1062 of file multidim_array.h.

     {
         ArrayDim aDim, aDimOut;
         getDimensions(aDim);
 
         char axis='Z';
         bool reverse=false;
 
         aDimOut = aDim;
 
         if (face == VIEW_Y_NEG || face == VIEW_Y_POS)
         {
             axis = 'Y';
             aDimOut.ydim = aDim.zdim;
             aDimOut.zdim = aDim.ydim;
             reverse = (face == VIEW_Y_NEG);
         }
         else if (face == VIEW_X_NEG || face == VIEW_X_POS)
         {
             axis = 'X';
             aDimOut.xdim = aDim.zdim;
             aDimOut.zdim = aDim.xdim;
             reverse = (face == VIEW_X_NEG);
         }
 
         flip = flip^reverse;
 
         out.resize(aDimOut, false);
 
         MultidimArray<T1> imTemp;
 
         int index;
 
         for (size_t k = 0; k < aDimOut.zdim; k++)
         {
             imTemp.aliasSlice(out, k);
             index = k + (aDimOut.zdim - 1 - 2*k) * (int)flip;
             this->getSlice(index, imTemp, axis, !reverse);
         }
     }

◆ reslice() [2/2]

template<typename T>

void MultidimArray< T >::reslice	(	AxisView	face,
		bool	flip = `false`,
		size_t	n = `0`
	)

inline

Reslice the current volume

Parameters

face	Select the face to become the new Z direction
flip	Invert the positions of Z planes, keeping the X-Y orientation
n	Select the number of image in case of stacks

Definition at line 1109 of file multidim_array.h.

     {
         MultidimArray<T> mTemp;
         reslice(mTemp, face, flip, n);
         *this = mTemp;
     }

◆ selfABS()

template<typename T>

void MultidimArray< T >::selfABS ( )

inline

ABS

Applies an ABS (absolute value) to each array element.

Definition at line 3330 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = ABS(*ptr);
     }

◆ selfCEIL()

template<typename T>

void MultidimArray< T >::selfCEIL ( )

inline

CEILING

Applies a CEILING (look for the nearest larger integer) to each array element.

Definition at line 3305 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = CEIL(*ptr);
     }

◆ selfFLOOR()

template<typename T>

void MultidimArray< T >::selfFLOOR ( )

inline

FLOOR

Applies a FLOOR (look for the nearest larger integer) to each array element.

Definition at line 3318 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = FLOOR(*ptr);
     }

◆ selfLog()

template<typename T>

void MultidimArray< T >::selfLog ( )

inline

Log.

Each component of the result is the log of the original components.

Definition at line 3464 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(log(static_cast< double >(*ptr)));
     }

◆ selfLog10()

template<typename T>

void MultidimArray< T >::selfLog10 ( )

inline

Log10.

Each component of the result is the log10 of the original components.

Definition at line 3452 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(log10(static_cast< double >(*ptr)));
     }

◆ selfNormalizeInterval()

template<typename T >

void MultidimArray< T >::selfNormalizeInterval	(	double	minPerc = `0.25`,
		double	maxPerc = `0.75`,
		int	Npix = `1000`
	)

Normalize the percentil interval values between -1 to 1 the normalization is done over a Npix number of pixels chosen at random

v_sorted(minPerc) = -1 v_sorted(maxPerc) = 1

Definition at line 910 of file multidim_array.cpp.

 {
     std::vector<double> randValues; // Vector with random chosen values
 
     for(int i=0; i<Npix; i++)
     {
         size_t indx = (size_t)rnd_unif(0, MULTIDIM_SIZE(*this));
         randValues.push_back(DIRECT_MULTIDIM_ELEM(*this,indx));
     }
     std::sort(randValues.begin(),randValues.end());
 
     double m = randValues[(size_t)(minPerc*Npix)];
     double M = randValues[(size_t)(maxPerc*Npix)];
 
     T* ptr=NULL;
     size_t n;
     FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
     *ptr = 2/(M-m)*(*ptr-m)-1;
 }

◆ selfReverseX()

template<typename T>

void MultidimArray< T >::selfReverseX ( )

inlinevirtual

Reverse matrix values over X axis, keep in this object.

Maybe better with an example:

Odd case

slice 0
[01 02 03          [07 08 09
 04 05 06           04 05 06
 07 08 09]          01 02 03]
----->
slice 1
[11 12 13          [17 18 19
 14 15 16           14 15 16
 17 18 19]          11 12 13]

Even case

slice 0
[01 02 03 04         [01 04 03 02
 05 06 06 07          05 07 06 06
 08 09 10 11          08 11 10 09
 12 13 14 15]         12 15 14 13]

Implements MultidimArrayBase.

Definition at line 3501 of file multidim_array.h.

     {
         size_t xsize=XSIZE(*this);
         size_t halfSizeX = (xsize-2)/2;
         size_t xsize_1=xsize-1;
         for (size_t k = 0; k < ZSIZE(*this); k++)
             for (size_t i = 0; i < YSIZE(*this); i++)
                 for (size_t j = 0; j <=halfSizeX; j++)
                 {
                     T aux;
                     T& d1=DIRECT_ZYX_ELEM(*this, k, i, j);
                     T& d2=DIRECT_ZYX_ELEM(*this, k, i, xsize_1 - j);
                     SWAP(d1,d2,aux);
                 }
         STARTINGX(*this) = -FINISHINGX(*this);
     }

◆ selfReverseY()

template<typename T>

void MultidimArray< T >::selfReverseY ( )

inlinevirtual

Reverse matrix values over Y axis, keep in this object.

Maybe better with an example:

slice 0
[01 02 03          [07 08 09
 04 05 06           04 05 06
 07 08 09]          01 02 03]

Implements MultidimArrayBase.

Definition at line 3531 of file multidim_array.h.

     {
         size_t ysize=YSIZE(*this);
         size_t halfSizeY = (ysize-2)/2;
         size_t ysize_1=ysize-1;
         for (size_t k = 0; k < ZSIZE(*this); k++)
             for (size_t i = 0; i <= halfSizeY; i++)
                 for (size_t j = 0; j < XSIZE(*this); j++)
                 {
                     T aux;
                     T& d1=DIRECT_ZYX_ELEM(*this, k, i, j);
                     T& d2=DIRECT_ZYX_ELEM(*this, k, ysize_1 - i, j);
                     SWAP(d1,d2,aux);
                 }
         STARTINGY(*this) = -FINISHINGY(*this);
     }

◆ selfReverseZ()

template<typename T>

void MultidimArray< T >::selfReverseZ ( )

inlinevirtual

Reverse matrix values over Z axis, keep result in this object.

Implements MultidimArrayBase.

Definition at line 3553 of file multidim_array.h.

     {
         size_t zsize=ZSIZE(*this);
         size_t halfSizeZ = (zsize-2)/2;
         size_t zsize_1=zsize-1;
         for (size_t k = 0; k <= halfSizeZ; k++)
             for (size_t i = 0; i <YSIZE(*this); i++)
                 for (size_t j = 0; j < XSIZE(*this); j++)
                 {
                     T aux;
                     T& d1=DIRECT_ZYX_ELEM(*this, k, i, j);
                     T& d2=DIRECT_ZYX_ELEM(*this, zsize_1- k, i, j);
                     SWAP(d1,d2,aux);
                 }
         STARTINGZ(*this) = -FINISHINGZ(*this);
     }

◆ selfROUND()

template<typename T>

void MultidimArray< T >::selfROUND ( )

inline

ROUND

Applies a ROUND (look for the nearest integer) to each array element.

Definition at line 3292 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = ROUND(*ptr);
     }

◆ selfSQRT()

template<typename T>

void MultidimArray< T >::selfSQRT ( )

inline

Sqrt.

Each component of the result is the square root of the original component.

Definition at line 3389 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         *ptr = static_cast< T >(sqrt(static_cast< double >(*ptr)));
     }

◆ selfWindow() [1/4]

template<typename T>

void MultidimArray< T >::selfWindow	(	int	n0,
		int	z0,
		int	y0,
		int	x0,
		int	nF,
		int	zF,
		int	yF,
		int	xF,
		T	init_value = `0`
	)

inline

Generic selfWindow routine (dim independent)

This function will call to 3D,2D or 1D specific selfWindow routines

Definition at line 538 of file multidim_array.h.

     {
         if (this->ndim >1)
             REPORT_ERROR(ERR_MULTIDIM_DIM,"stack windowing not implemented");
         if (this->zdim >1)
         {//call 3Dwindow
             selfWindow( z0,  y0,  x0,
                         zF,  yF,  xF,
                         init_value);
         }
         else if (this->ydim >1)
         {//call 2Dwindow
             selfWindow( y0,  x0,
                         yF,  xF,
                         init_value);
 
         }
         else if (this->xdim >1)
         {//call 1Dwindow
             selfWindow( x0, xF, init_value);
         }
     }

◆ selfWindow() [2/4]

template<typename T>

void MultidimArray< T >::selfWindow	(	int	z0,
		int	y0,
		int	x0,
		int	zF,
		int	yF,
		int	xF,
		T	init_value = `0`
	)

inline

3D Self window

Definition at line 633 of file multidim_array.h.

     {
         if (z0 == STARTINGZ(*this) && zF == FINISHINGZ(*this) &&
             y0 == STARTINGY(*this) && yF == FINISHINGY(*this) &&
             x0 == STARTINGX(*this) && xF == FINISHINGX(*this))
             return;
 
         MultidimArray<T> result;
         window(result,z0,y0,x0,zF,yF,xF,init_value);
         *this=result;
     }

◆ selfWindow() [3/4]

template<typename T>

void MultidimArray< T >::selfWindow	(	int	y0,
		int	x0,
		int	yF,
		int	xF,
		T	init_value = `0`
	)

inline

2D Self window

Definition at line 682 of file multidim_array.h.

     {
         MultidimArray<T> result;
         window(result,y0,x0,yF,xF,init_value);
         *this=result;
     }

◆ selfWindow() [4/4]

template<typename T>

void MultidimArray< T >::selfWindow	(	int	x0,
		int	xF,
		T	init_value = `0`
	)

inline

1D Self window

Definition at line 718 of file multidim_array.h.

     {
         MultidimArray<T> result;
         window(result,x0,xF,init_value);
         *this=result;
     }

◆ setCol()

template<typename T>

void MultidimArray< T >::setCol	(	size_t	j,
		const MultidimArray< T > &	v
	)

inline

Set Column

This function sets a column vector corresponding to the chosen column inside matrix.

m.setCol(0, (m.row(1)).transpose()); // Copies row 1 in column 0

Definition at line 1151 of file multidim_array.h.

     {
         if (xdim == 0 || ydim == 0)
             REPORT_ERROR(ERR_MULTIDIM_EMPTY, "setCol: Target matrix is empty");
 
         if (j>= xdim)
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "setCol: Matrix subscript (j) out of range");
 
         if (v.xdim != ydim)
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          "setCol: Vector dimension different from matrix one");
 
         for (size_t i = 0; i < ydim; i++)
             DIRECT_A2D_ELEM(*this,i, j) = DIRECT_A1D_ELEM(v,i);
     }

◆ setRow()

template<typename T>

void MultidimArray< T >::setRow	(	int	i,
		const MultidimArray< T > &	v
	)

inline

Set Row

This function sets a row vector corresponding to the chosen row in the 2D Matrix

m.setRow(-2, m.row(1)); // Copies row 1 in row -2

Definition at line 1201 of file multidim_array.h.

     {
         if (xdim == 0 || ydim == 0)
             REPORT_ERROR(ERR_MULTIDIM_EMPTY, "setRow: Target matrix is empty");
 
         if (i < 0 || i >= ydim)
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "setRow: Matrix subscript (i) out of range");
 
         if (v.xdim != xdim)
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          "setRow: Vector dimension different from matrix one");
 
         memcpy(&A2D_ELEM(*this,i,0),&A1D_ELEM(v,0),xdim*sizeof(T));
     }

◆ setSlice()

template<typename T>

template<typename T1 >

void MultidimArray< T >::setSlice	(	int	k,
		const MultidimArray< T1 > &	v,
		size_t	n = `0`
	)

inline

Slice access for writing.

This function sets a 2D matrix corresponding to the chosen slice inside the nth volume, the numbering of the slices is also logical not physical.

// Copies slice 0 in slice 1

V.setSlice(1, (V.slice(0)));

Definition at line 1033 of file multidim_array.h.

     {
         if (xdim == 0)
             return;
 
         if (k < STARTINGZ(*this) || k > FINISHINGZ(*this))
             REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,formatString(
                              "setSlice: MultidimArray subscript (k=%d) out of range [%d, %d]",
                              k,STARTINGZ(*this),FINISHINGZ(*this)));
 
         if (v.rowNumber() != YSIZE(*this) || v.colNumber() != XSIZE(*this))
             REPORT_ERROR(ERR_MULTIDIM_DIM,
                          "setSlice: MultidimArray dimensions different from the matrix ones");
 
         k-=STARTINGZ(*this);
         T *ptr=&(DIRECT_NZYX_ELEM(*this, n, k, 0, 0));
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(v)
         *(ptr++) = (T) DIRECT_MULTIDIM_ELEM(v, n);
     }

◆ showWithGnuPlot()

template<typename T >

void MultidimArray< T >::showWithGnuPlot	(	const String &	xlabel,
		const String &	title
	)

Show using gnuplot

This function uses gnuplot to plot this vector. You must supply the xlabel, ylabel, and title.

Definition at line 931 of file multidim_array.cpp.

 {
     checkDimension(1);
 
     FileName fn_tmp;
     fn_tmp.initRandom(10);
     const char * fnStr = fn_tmp.c_str();
     MultidimArray<T>::write(formatString("PPP%s.txt", fnStr));
 
     std::ofstream fh_gplot;
     fh_gplot.open(formatString("PPP%s.gpl", fnStr).c_str());
     if (!fh_gplot)
         REPORT_ERROR(ERR_IO_NOTOPEN,
                      formatString("vector::showWithGnuPlot: Cannot open PPP%s.gpl for output", fnStr));
     fh_gplot << "set xlabel \"" + xlabel + "\"\n";
     fh_gplot << "plot \"PPP" + fn_tmp + ".txt\" title \"" + title +
     "\" w l\n";
     fh_gplot << "pause 300 \"\"\n";
     fh_gplot.close();
     if (0 != system(formatString("(gnuplot PPP%s.gpl; rm PPP%s.txt PPP%s.gpl) &", fnStr, fnStr, fnStr).c_str()) ) {
         REPORT_ERROR(ERR_IO, "Cannot open gnuplot");
     }
 }

◆ sort()

template<typename T>

void MultidimArray< T >::sort ( MultidimArray< T > & result ) const

Sort vector elements

Sort in ascending order the vector elements. You can use the "reverse" function to sort in descending order.

v2 = v1.sort();

Definition at line 1092 of file multidim_array.cpp.

 {
     result = *this;
     std::sort(result.data, result.data + result.nzyxdim);
 }

◆ statisticsAdjust()

template<typename T>

template<typename U >

void MultidimArray< T >::statisticsAdjust	(	U	avgF,
		U	stddevF
	)

inline

Adjust the average and stddev of the array to given values.

A linear operation is performed on the values of the array such that after it, the average and standard deviation of the array are the two values set. The actual array is modified itself

v.statisticsAdjust(0,1);

// The array has got now 0 mean and stddev=1

Definition at line 2114 of file multidim_array.h.

     {
         static_assert(
                 std::is_same<double, U>::value || std::is_same<float, U>::value,
                 "U must be a floating presiont type");
         U avg0 = 0;
         U stddev0 = 0;
 
         if (NZYXSIZE(*this) == 0)
             return;
 
         computeAvgStdev(avg0, stddev0);
 
         U a = (stddev0 != 0) ? (stddevF / stddev0) : 0;
         U b = avgF - a * avg0;
 
         T* ptr=&DIRECT_MULTIDIM_ELEM(*this,0);
         size_t nmax=(nzyxdim/4)*4;
         for (size_t n=0; n<nmax; n+=4, ptr+=4)
         {
             *(ptr  )= static_cast< T >(a * (*(ptr  )) + b);
             *(ptr+1)= static_cast< T >(a * (*(ptr+1)) + b);
             *(ptr+2)= static_cast< T >(a * (*(ptr+2)) + b);
             *(ptr+3)= static_cast< T >(a * (*(ptr+3)) + b);
         }
         for (size_t n=nmax; n<nzyxdim; ++n, ptr+=1)
             *(ptr  )= static_cast< T >(a * (*(ptr  )) + b);
     }

◆ substitute()

template<typename T>

void MultidimArray< T >::substitute	(	T	oldv,
		T	newv,
		double	accuracy = `XMIPP_EQUAL_ACCURACY`,
		MultidimArray< int > *	mask = `NULL`
	)

inline

Substitute a value by another.

Substitute an old value by a new one. The accuracy is used to say if the value in the array is equal to the old value. Set it to 0 for perfect accuracy.

Definition at line 3221 of file multidim_array.h.

     {
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
             if (ABS(*ptr - oldv) <= accuracy)
                 *ptr = newv;
     }

◆ sum()

template<typename T>

double MultidimArray< T >::sum ( ) const

inline

Sum of matrix values.

This function returns the sum of all internal values.

double sum = m.sum();

Definition at line 3405 of file multidim_array.h.

     {
         double sum = 0;
         T* ptr=NULL;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         sum += *ptr;
         return sum;
     }

◆ sum2()

template<typename T>

double MultidimArray< T >::sum2 ( ) const

inline

Sum of squared vector values.

This function returns the sum of all internal values to the second power.

double sum2 = m.sum2();

Definition at line 3424 of file multidim_array.h.

     {
         double sum = 0;
 
         // Unroll the loop
         const size_t unroll=4;
         size_t nmax=(NZYXSIZE(*this)/unroll)*unroll;
         T* ptr = MULTIDIM_ARRAY(*this);
         for (size_t n=0; n<nmax; n+=unroll, ptr+=unroll)
         {
             sum+= (*ptr)*(*ptr);
             T* ptr1=ptr+1;
             sum+= (*ptr1)*(*ptr1);
             T* ptr2=ptr+2;
             sum+= (*ptr2)*(*ptr2);
             T* ptr3=ptr+3;
             sum+= (*ptr3)*(*ptr3);
         }
         // Do the remaining elements
         for (size_t n=nmax; n<NZYXSIZE(*this); ++n, ++ptr)
             sum+=(*ptr)*(*ptr);
         return sum;
     }

◆ swap()

template<typename T>

void MultidimArray< T >::swap ( MultidimArray< T > & other )

inlinenoexcept

Definition at line 241 of file multidim_array.h.

     {
         std::swap(xdim, other.xdim);
         std::swap(ydim, other.ydim);
         std::swap(zdim, other.zdim);
         std::swap(ndim, other.ndim);
         std::swap(yxdim, other.yxdim);
         std::swap(zyxdim, other.zyxdim);
         std::swap(nzyxdim, other.nzyxdim);
         std::swap(xinit, other.xinit);
         std::swap(yinit, other.yinit);
         std::swap(zinit, other.zinit);
         std::swap(data, other.data);
         std::swap(nzyxdimAlloc, other.nzyxdimAlloc);
         std::swap(destroyData, other.destroyData);
         std::swap(mmapOn, other.mmapOn);
         std::swap(mFd, other.mFd);
     }

◆ threshold()

template<typename T>

void MultidimArray< T >::threshold	(	const String &	type,
		T	a,
		T	b = `0`,
		MultidimArray< int > *	mask = `NULL`
	)

inline

Several thresholding.

Apply a threshold to the array, the object is modified itself. There are several kinds of thresholding and you must specify it, the values given in the fuction have different meanings according to the threshold applied.

abs_above: if |x|>a => x=b abs_below: if |x|<a => x=b above: if x >a => x=b below: if x <a => x=b range: if x <a => x=a and if x>b => x=b soft: if abs(x)<a => x=0 else x=sgn(x)*(abs(x)-a)

v.threshold("abs_above", 10, 10);
// any value whose absolute value is above 10 will be substituted by
// -10 (if it is negative) or 10 (if it is positive)
v.threshold("abs_below", 0.1, 0);
// any value whose absolute value is below 0.1 will be substituted by
// -0 (if it is negative) or 0 (if it is positive)
v.threshold("above", 10, 10);
// any value above 10 will be substituted by 10
v.threshold("below", -10, -10);
// any value below -10 will be substituted by -10
v.threshold("range", 0, 1);
// v is "saturated" by values 0 and 1, any value outside this range
// will be substituted by its nearest border

Definition at line 3089 of file multidim_array.h.

     {
         int mode;
 
         if (type == "abs_above")
             mode = 1;
         else if (type == "abs_below")
             mode = 2;
         else if (type == "above")
             mode = 3;
         else if (type == "below")
             mode = 4;
         else if (type == "range")
             mode = 5;
         else if (type == "soft")
             mode = 6;
         else
             REPORT_ERROR(ERR_VALUE_INCORRECT,
                          formatString("Threshold: mode not supported (%s)", type.c_str() ));
 
         T* ptr=NULL;
         size_t n;
         T ma=-a;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(*this,n,ptr)
         {
             if (mask == NULL || DIRECT_MULTIDIM_ELEM(*mask,n) > 0 )
             {
                 switch (mode)
                 {
                 case 1:
                     if (ABS(*ptr) > a)
                         *ptr = SGN(*ptr) * b;
                     break;
                 case 2:
                     if (ABS(*ptr) < a)
                         *ptr = SGN(*ptr) * b;
                     break;
                 case 3:
                     if (*ptr > a)
                         *ptr = b;
                     break;
                 case 4:
                     if (*ptr < a)
                         *ptr = b;
                     break;
                 case 5:
                     if (*ptr < a)
                         *ptr = a;
                     else if (*ptr > b)
                         *ptr = b;
                     break;
                 case 6:
                     if (*ptr<ma)
                         *ptr+=a;
                     else if (*ptr>a)
                         *ptr-=a;
                     else
                         *ptr=0;
                 }
             }
         }
     }

◆ toLogical() [1/3]

template<typename T>

void MultidimArray< T >::toLogical	(	int	k_phys,
		int	i_phys,
		int	j_phys,
		int &	k_log,
		int &	i_log,
		int &	j_log
	)		const

inline

3D Physical to logical index translation.

This function returns the logical position of a physical one.

m.toLogical(i_phys, j_phys, i_log, j_log);

Definition at line 1251 of file multidim_array.h.

     {
         k_log = k_phys + STARTINGZ(*this);
         i_log = i_phys + STARTINGY(*this);
         j_log = j_phys + STARTINGX(*this);
     }

◆ toLogical() [2/3]

template<typename T>

void MultidimArray< T >::toLogical	(	int	i_phys,
		int	j_phys,
		int &	i_log,
		int &	j_log
	)		const

inline

2D Physical to logical index translation

This function returns the logical position of a physical one.

m.toLogical(i_phys, j_phys, i_log, j_log);

Definition at line 1281 of file multidim_array.h.

     {
         i_log = i_phys + STARTINGY(*this);
         j_log = j_phys + STARTINGX(*this);
     }

◆ toLogical() [3/3]

template<typename T>

void MultidimArray< T >::toLogical	(	int	i_phys,
		int &	i_log
	)		const

inline

1D Physical to logical index translation.

This function returns the logical position of a physical one.

v.toLogical(i_phys, i_log);

Definition at line 1308 of file multidim_array.h.

     {
         i_log = i_phys + STARTINGX(*this);
     }

◆ toPhysical() [1/3]

template<typename T>

void MultidimArray< T >::toPhysical	(	int	k_log,
		int	i_log,
		int	j_log,
		int &	k_phys,
		int &	i_phys,
		int &	j_phys
	)		const

inline

3D Logical to physical index translation.

This function returns the physical position of a logical one.

m.toPhysical(k_log, i_log, j_log, k_phys, i_phys, j_phys);

Definition at line 1235 of file multidim_array.h.

     {
         k_phys = k_log - STARTINGZ(*this);
         i_phys = i_log - STARTINGY(*this);
         j_phys = j_log - STARTINGX(*this);
     }

◆ toPhysical() [2/3]

template<typename T>

void MultidimArray< T >::toPhysical	(	int	i_log,
		int	j_log,
		int &	i_phys,
		int &	j_phys
	)		const

inline

2D Logical to physical index translation

This function returns the physical position of a logical one.

m.toPhysical(i_log, j_log, i_phys, j_phys);

Definition at line 1267 of file multidim_array.h.

     {
         i_phys = i_log - STARTINGY(*this);
         j_phys = j_log - STARTINGX(*this);
     }

◆ toPhysical() [3/3]

template<typename T>

void MultidimArray< T >::toPhysical	(	int	i_log,
		int &	i_phys
	)		const

inline

1D Logical to physical index translation

This function returns the physical position of a logical one.

v.toPhysical(i_log, i_phys);

Definition at line 1295 of file multidim_array.h.

     {
         i_phys = i_log - STARTINGX(*this);
     }

◆ window() [1/4]

template<typename T>

template<class T1 >

void MultidimArray< T >::window	(	MultidimArray< T1 > &	result,
		int	n0,
		int	z0,
		int	y0,
		int	x0,
		int	nF,
		int	zF,
		int	yF,
		int	xF,
		T1	init_value = `0`
	)		const

inline

Definition at line 564 of file multidim_array.h.

     {
         if (this->ndim >1)
             REPORT_ERROR(ERR_MULTIDIM_DIM,"stack windowing not implemented");
         if (this->zdim >1)
         {//call 3Dwindow
             window(result, z0,  y0,  x0,
                    zF,  yF,  xF,
                    init_value);
         }
         else if (this->ydim >1)
         {//call 2Dwindow
             window(result, y0,  x0,
                    yF,  xF,
                    init_value);
         }
         else if (this->xdim >1)
         {//call 1Dwindow
             window(result, x0, xF, init_value);
         }
     }

◆ window() [2/4]

template<typename T>

template<class T1 >

void MultidimArray< T >::window	(	MultidimArray< T1 > &	result,
		int	z0,
		int	y0,
		int	x0,
		int	zF,
		int	yF,
		int	xF,
		T1	init_value = `0`
	)		const

inline

Put a 3D selfWindow to the nth volume

The volume is windowed within the two positions given to this function. Indexes always refer to logical indexes. If a position is outside the actual matrix range then the matrix is padded init_value until the new position is reached. In the following example suppose that m1 is the following and that the origin is (-1,-1,-1).

slice 0
[01 02 03          [
 04 05 06           04 05 06 0
 07 08 09]          07 08 09 0]
----->
slice 1
[11 12 13          [
 14 15 16           14 15 16 0
 17 18 19]          17 18 19 0]

V1.selfWindow(0, 0, -1, 1, 1, 2);

Definition at line 615 of file multidim_array.h.

     {
         result.resizeNoCopy(zF - z0 + 1, yF - y0 + 1, xF - x0 + 1);
         STARTINGZ(result) = z0;
         STARTINGY(result) = y0;
         STARTINGX(result) = x0;
 
         FOR_ALL_ELEMENTS_IN_ARRAY3D(result)
         if ((k >= STARTINGZ(*this) && k <= FINISHINGZ(*this)) &&
             (i >= STARTINGY(*this) && i <= FINISHINGY(*this)) &&
             (j >= STARTINGX(*this) && j <= FINISHINGX(*this)))
             A3D_ELEM(result, k, i, j) = (T1) A3D_ELEM(*this, k, i, j);
         else
             A3D_ELEM(result, k, i, j) = init_value;
     }

◆ window() [3/4]

template<typename T>

template<class T1 >

void MultidimArray< T >::window	(	MultidimArray< T1 > &	result,
		int	y0,
		int	x0,
		int	yF,
		int	xF,
		T1	init_value = `0`
	)		const

inline

Put a 2D selfWindow to the nth matrix

The matrix is windowed within the two positions given to this function. Indexes always refer to logical indexes. If a position is outside the actual matrix range then the matrix is padded with init_value until the new position is reached. In the following examples suppose that m1 is the following and that the origin is (-1,-1).

     [1 2 3               [1 2 3 0
m1 =  4 5 6    --->  m1 =  4 5 6 0
      7 8 9]               7 8 9 0]

m1.selfWindow(-1, -1, 1, 2);

Definition at line 666 of file multidim_array.h.

     {
         result.resizeNoCopy(yF - y0 + 1, xF - x0 + 1);
         STARTINGY(result) = y0;
         STARTINGX(result) = x0;
 
         FOR_ALL_ELEMENTS_IN_ARRAY2D(result)
         if (j >= STARTINGX(*this) && j <= FINISHINGX(*this) &&
             i >= STARTINGY(*this) && i <= FINISHINGY(*this))
             A2D_ELEM(result, i, j) = A2D_ELEM(*this, i, j);
         else
             A2D_ELEM(result, i, j) = init_value;
     }

◆ window() [4/4]

template<typename T>

template<class T1 >

void MultidimArray< T >::window	(	MultidimArray< T1 > &	result,
		int	x0,
		int	xF,
		T1	init_value = `0`
	)		const

inline

Put a 1D selfWindow to the nth vector

The vector is windowed within the two indexes given to this function. Indexes always refer to logical indexes. If an index is outside the actual vector range then the vector is padded winit_value. In the following examples suppose that v1=[-2 -1 0 1 2] and that the origin is -2.

v1.selfWindow(-1, 2); // v1=[-1 0 1 2]; v1.startingX() == -1
v1.selfWindow(-3, 1); // v1=[0 -2 -1 0 1]; v1.startingX() == -3

Definition at line 705 of file multidim_array.h.

     {
         result.resizeNoCopy(xF - x0 + 1);
         STARTINGX(result) = x0;
 
         FOR_ALL_ELEMENTS_IN_ARRAY1D(result)
         if (i >= STARTINGX(*this) && i <= FINISHINGX(*this))
             A1D_ELEM(result, i) = A1D_ELEM(*this, i);
         else
             A1D_ELEM(result, i) = init_value;
     }

◆ write()

template<typename T >

void MultidimArray< T >::write ( const FileName & fn ) const

Write to an ASCII file.

Definition at line 970 of file multidim_array.cpp.

 {
     std::ofstream out;
     out.open(fn.c_str(), std::ios::out);
     if (!out)
         REPORT_ERROR(ERR_IO_NOTOPEN,
                      formatString("MultidimArray::write: File %s cannot be opened for output", fn.c_str()));
 
     out << *this;
     out.close();
 }

Friends And Related Function Documentation

◆ arrayByArray

template<typename T>

void arrayByArray	(	const MultidimArray< T > &	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Array by array

This function must take two vectors of the same size, and operate element by element according to the operation required. This is the function which really implements the operations. Simple calls to it perform much faster than calls to the corresponding operators. Although it is supposed to be a hidden function not useable by normal programmers.

Definition at line 2310 of file multidim_array.h.

     {
         if (!op1.sameShape(op2))
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          formatString("Array_by_array: different shapes (%c)", operation));
         if (result.data == NULL || !result.sameShape(op1))
             result.resizeNoCopy(op1);
         coreArrayByArray(op1, op2, result, operation);
     }

◆ arrayByScalar

template<typename T>

void arrayByScalar	(	const MultidimArray< T > &	op1,
		T	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Array by scalar.

This function must take one vector and a constant, and operate element by element according to the operation required. This is the function which really implements the operations. Simple calls to it perform much faster than calls to the corresponding operators. Although it is supposed to be a hidden function not useable by normal programmers.

This function is not ported to Python.

Definition at line 2496 of file multidim_array.h.

     {
         if (result.data == NULL || !result.sameShape(op1))
             result.resizeNoCopy(op1);
         coreArrayByScalar(op1, op2, result, operation);
     }

◆ coreArrayByArray

template<typename T>

void coreArrayByArray	(	const MultidimArray< T > &	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Core array by array operation.

It assumes that the result is already resized.

Definition at line 2163 of file multidim_array.h.

     {
         T* ptrResult=NULL;
         T* ptrOp1=NULL;
         T* ptrOp2=NULL;
         size_t n;
         // Loop unrolling
         const size_t unroll=4;
         size_t nmax=unroll*(op1.nzyxdim/unroll);
         switch (operation)
         {
         case '+':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data;
                  n<nmax; n+=unroll, ptrResult+=unroll, ptrOp1+=unroll, ptrOp2+=unroll)
             {
                 *ptrResult = *ptrOp1 + *ptrOp2;
                 *(ptrResult+1) = *(ptrOp1+1) + *(ptrOp2+1);
                 *(ptrResult+2) = *(ptrOp1+2) + *(ptrOp2+2);
                 *(ptrResult+3) = *(ptrOp1+3) + *(ptrOp2+3);
             }
             for (n=nmax, ptrResult=result.data+nmax, ptrOp1=op1.data+nmax, ptrOp2=op2.data+nmax;
                  n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1, ++ptrOp2)
                 *ptrResult = *ptrOp1 + *ptrOp2;
             break;
         case '-':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data;
                      n<nmax; n+=unroll, ptrResult+=unroll, ptrOp1+=unroll, ptrOp2+=unroll)
                 {
                     *ptrResult = *ptrOp1 - *ptrOp2;
                     *(ptrResult+1) = *(ptrOp1+1) - *(ptrOp2+1);
                     *(ptrResult+2) = *(ptrOp1+2) - *(ptrOp2+2);
                     *(ptrResult+3) = *(ptrOp1+3) - *(ptrOp2+3);
                 }
             for (n=nmax, ptrResult=result.data+nmax, ptrOp1=op1.data+nmax, ptrOp2=op2.data+nmax;
                  n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1, ++ptrOp2)
                 *ptrResult = *ptrOp1 - *ptrOp2;
             break;
         case '*':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data;
                      n<nmax; n+=unroll, ptrResult+=unroll, ptrOp1+=unroll, ptrOp2+=unroll)
                 {
                     *ptrResult = *ptrOp1 * *ptrOp2;
                     *(ptrResult+1) = *(ptrOp1+1) * *(ptrOp2+1);
                     *(ptrResult+2) = *(ptrOp1+2) * *(ptrOp2+2);
                     *(ptrResult+3) = *(ptrOp1+3) * *(ptrOp2+3);
                 }
             for (n=nmax, ptrResult=result.data+nmax, ptrOp1=op1.data+nmax, ptrOp2=op2.data+nmax;
                  n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1, ++ptrOp2)
                 *ptrResult = *ptrOp1 * *ptrOp2;
             break;
         case '/':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data;
                      n<nmax; n+=unroll, ptrResult+=unroll, ptrOp1+=unroll, ptrOp2+=unroll)
                 {
                     *ptrResult = *ptrOp1 / *ptrOp2;
                     *(ptrResult+1) = *(ptrOp1+1) / *(ptrOp2+1);
                     *(ptrResult+2) = *(ptrOp1+2) / *(ptrOp2+2);
                     *(ptrResult+3) = *(ptrOp1+3) / *(ptrOp2+3);
                 }
             for (n=nmax, ptrResult=result.data+nmax, ptrOp1=op1.data+nmax, ptrOp2=op2.data+nmax;
                  n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1, ++ptrOp2)
                 *ptrResult = *ptrOp1 / *ptrOp2;
             break;
         }
     }

◆ coreArrayByScalar

template<typename T>

void coreArrayByScalar	(	const MultidimArray< T > &	op1,
		const T &	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Core array by scalar operation.

It assumes that the result is already resized.

This function is not ported to Python.

Definition at line 2448 of file multidim_array.h.

     {
         T* ptrResult=NULL;
         T* ptrOp1=NULL;
         size_t n;
         switch (operation)
         {
         case '+':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data;
                  n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1)
                 *ptrResult = *ptrOp1 + op2;
             break;
         case '-':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data;
                      n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1)
                     *ptrResult = *ptrOp1 - op2;
             break;
         case '*':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data;
                      n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1)
                     *ptrResult = *ptrOp1 * op2;
             break;
         case '/':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data;
                      n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1)
                     *ptrResult = *ptrOp1 / op2;
             break;
         case '=':
                 for (n=0, ptrResult=result.data, ptrOp1=op1.data;
                      n<op1.zyxdim; ++n, ++ptrResult, ++ptrOp1)
                     *ptrResult = *ptrOp1 == op2;
             break;
         }
     }

◆ coreScalarByArray

template<typename T>

void coreScalarByArray	(	const T &	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Core array by scalar operation.

It assumes that the result is already resized.

This function is not ported to Python.

Definition at line 2608 of file multidim_array.h.

     {
         T* ptrResult=NULL;
         T* ptrOp2=NULL;
         size_t n;
         for (n=0, ptrResult=result.data, ptrOp2=op2.data;
              n<op2.zyxdim; ++n, ++ptrResult, ++ptrOp2)
             switch (operation)
             {
             case '+':
                 *ptrResult = op1 + *ptrOp2;
                 break;
             case '-':
                 *ptrResult = op1 - *ptrOp2;
                 break;
             case '*':
                 *ptrResult = op1 * *ptrOp2;
                 break;
             case '/':
                 *ptrResult = op1 / *ptrOp2;
                 break;
             }
     }

◆ MultidimArrayMax

template<typename T>

void MultidimArrayMax	(	const MultidimArray< T > &	v1,
		const MultidimArray< T > &	v2,
		MultidimArray< T > &	result
	)

friend

MAX

Each component of the result is the maximum of the correspoing components of the two input arrays. They must have the same shape, if not an exception is thrown

Definition at line 3352 of file multidim_array.h.

     {
         if (!v1.sameShape(v2))
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "MAX: arrays of different shape");
 
         result.resizeNoCopy(v1);
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(result)
         DIRECT_MULTIDIM_ELEM(result,n) = XMIPP_MAX(
                                              DIRECT_MULTIDIM_ELEM(v1,n),
                                              DIRECT_MULTIDIM_ELEM(v2,n));
     }

◆ MultidimArrayMIN

template<typename T>

void MultidimArrayMIN	(	const MultidimArray< T > &	v1,
		const MultidimArray< T > &	v2,
		MultidimArray< T > &	result
	)

friend

MIN

Each component of the result is the minimum of the correspoing components of the two input arrays. They must have the same shape, if not an exception is thrown

Definition at line 3371 of file multidim_array.h.

     {
         if (!v1.sameShape(v2))
             REPORT_ERROR(ERR_MULTIDIM_SIZE, "MIN: arrays of different shape");
 
         result.resizeNoCopy(v1);
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(result)
         DIRECT_MULTIDIM_ELEM(result,n) = XMIPP_MIN(
                                              DIRECT_MULTIDIM_ELEM(v1,n),
                                              DIRECT_MULTIDIM_ELEM(v2,n));
     }

◆ operator*

template<typename T>

MultidimArray<T> operator*	(	T	op1,
		const MultidimArray< T > &	op2
	)

friend

v3 = k * v2.

Definition at line 2675 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         scalarByArray(op1, op2, tmp, '*');
         return tmp;
     }

◆ operator+

template<typename T>

MultidimArray<T> operator+	(	T	op1,
		const MultidimArray< T > &	op2
	)

friend

v3 = k + v2.

Definition at line 2657 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         scalarByArray(op1, op2, tmp, '+');
         return tmp;
     }

◆ operator-

template<typename T>

MultidimArray<T> operator-	(	T	op1,
		const MultidimArray< T > &	op2
	)

friend

v3 = k - v2.

Definition at line 2666 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         scalarByArray(op1, op2, tmp, '-');
         return tmp;
     }

◆ operator/

template<typename T>

MultidimArray<T> operator/	(	T	op1,
		const MultidimArray< T > &	op2
	)

friend

v3 = k / v2

Definition at line 2684 of file multidim_array.h.

     {
         MultidimArray<T> tmp;
         scalarByArray(op1, op2, tmp, '/');
         return tmp;
     }

◆ operator>>

template<typename T>

std::istream& operator>>	(	std::istream &	in,
		MultidimArray< T > &	v
	)

friend

Input from input stream.

Actual size of the array is used to know how many values must be read.

v.<3);

std::cin >> v;

This function is not ported to Python.

Definition at line 3705 of file multidim_array.h.

     {
         T* ptr;
         size_t n;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(v,n,ptr)
         in >> *ptr;
         return in;
     }

◆ scalarByArray

template<typename T>

void scalarByArray	(	T	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation
	)

friend

Scalar by array.

This function must take one scalar and a vector, and operate element by element according to the operation required. This is the function which really implements the operations. Simple calls to it perform much faster than calls to the corresponding operators. Although it is supposed to be a hidden function not useable by normal programmers.

This function is not ported to Python.

Definition at line 2645 of file multidim_array.h.

     {
         if (result.data == NULL || !result.sameShape(op2))
             result.resizeNoCopy(op2);
         coreScalarByArray(op1, op2, result, operation);
     }

◆ selfArrayByArrayMask

template<typename T>

void selfArrayByArrayMask	(	const MultidimArray< T > &	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation,
		const MultidimArray< T > *	mask = `NULL`
	)

friend

Self Array by array

Similar to array by array. requires 4 vectors the pixel result(i) is calculated as result(i) += op1(i), if the mask is different from zero result(i) += op2(i) * mask(i)

Definition at line 2329 of file multidim_array.h.

     {
         if (!op1.sameShape(op2) || !result.sameShape(op1))
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          formatString("Array_by_array: different shapes (%c)", operation));
         selfCoreArrayByArrayMask(op1, op2, result, operation, mask);
     }

◆ selfCoreArrayByArrayMask

template<typename T>

void selfCoreArrayByArrayMask	(	const MultidimArray< T > &	op1,
		const MultidimArray< T > &	op2,
		MultidimArray< T > &	result,
		char	operation,
		const MultidimArray< T > *	mask
	)

friend

Core array by array operation.

It assumes that the result is already resized.

Definition at line 2235 of file multidim_array.h.

     {
         T* ptrResult=NULL;
         T* ptrOp1=NULL;
         T* ptrOp2=NULL;
         T* ptrMask=NULL;
         T zero;
         zero = T(0);
         size_t n;
         switch (operation)
         {
         case '+':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data,
                  ptrMask=mask->data;
                  n<op1.nzyxdim; n++, ptrResult++,
                  ptrOp1++, ptrOp2++, ptrMask++)
             {
                 if ((*ptrMask)==zero)
                     *ptrResult += (*ptrOp1);
                 else
                     *ptrResult += (*ptrOp2);//(*ptrOp2) * (*ptrMask);
             }
             break;
         case '-':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data,
                  ptrMask=mask->data;
                  n<op1.nzyxdim; n++, ptrResult++,
                  ptrOp1++, ptrOp2++, ptrMask++)
             {
                 if ((*ptrMask)==zero)
                     *ptrResult -= (*ptrOp1);
                 else
                     *ptrResult -= (*ptrOp2) * (*ptrMask);
             }
             break;
             //NOTE: not clear if this should be the default case for * and / operators
         case '*':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data,
                  ptrMask=mask->data;
                  n<op1.nzyxdim; n++, ptrResult++,
                  ptrOp1++, ptrOp2++, ptrMask++)
             {
                 if ((*ptrMask)==zero)
                     *ptrResult *= (*ptrOp1);
                 else
                     *ptrResult *= (*ptrOp2) * (*ptrMask);
             }
             break;
         case '/':
             for (n=0, ptrResult=result.data, ptrOp1=op1.data,ptrOp2=op2.data,
                  ptrMask=mask->data;
                  n<op1.nzyxdim; n++, ptrResult++,
                  ptrOp1++, ptrOp2++, ptrMask++)
             {
                 if ((*ptrMask)==zero)
                     *ptrResult /= (*ptrOp1);
                 else
                     *ptrResult /= (*ptrOp2) * (*ptrMask);
             }
             break;
         }
     }

Member Data Documentation

◆ data

template<typename T>

T* MultidimArray< T >::data

Definition at line 84 of file multidim_array.h.

The documentation for this class was generated from the following files:

xmipp/legacy/libraries/reconstruction/common_lines.h
xmippCore/core/multidim_array.h
xmippCore/core/multidim_array.cpp

Public Member Functions

Public Attributes

Friends

Array "by" array operations.

Array "by" scalar operations

Utilities

Operators

Detailed Description

template<typename T> class MultidimArray< T >

Constructor & Destructor Documentation

◆ MultidimArray() [1/10]

◆ MultidimArray() [2/10]

◆ MultidimArray() [3/10]

◆ MultidimArray() [4/10]

◆ MultidimArray() [5/10]

◆ MultidimArray() [6/10]

◆ MultidimArray() [7/10]

◆ MultidimArray() [8/10]

◆ MultidimArray() [9/10]

◆ MultidimArray() [10/10]

◆ ~MultidimArray()

Member Function Documentation

◆ adaptForNumericalRecipes1D()

◆ adaptForNumericalRecipes22D()

◆ adaptForNumericalRecipes2D()

◆ adaptForNumericalRecipes3D()

◆ addNoise()

◆ alias()

◆ aliasImageInStack()

◆ aliasRow()

◆ aliasSlice()

◆ binarize()

◆ binarizeRange()

◆ centerOfMass()

◆ checkDimensionWithDebug()

◆ clear()

◆ computeAvg()

◆ computeAvgStdev()

◆ computeAvgStdev_within_binary_mask()

◆ computeDoubleMinMax()

◆ computeDoubleMinMaxRange()

◆ computeMax()

◆ computeMedian()

◆ computeMedian_within_binary_mask()

◆ computeMin()

◆ computeStats() [1/2]

◆ computeStats() [2/2]

◆ computeStddev()

◆ copy()

◆ coreAllocate() [1/2]

◆ coreAllocate() [2/2]

◆ coreAllocateReuse()

◆ coreDeallocate()

◆ coreInit()

◆ countThreshold()

◆ cumlativeDensityFunction()

◆ dotProduct()

◆ edit()

◆ equal() [1/2]

◆ equal() [2/2]

◆ getAliasAsRowVector()

◆ getArrayPointer()

◆ getCol()

◆ getImag()

◆ getImage()

◆ getReal()

◆ getRow()

◆ getSlice()

◆ getSliceAsMatrix()

◆ indexSort()

◆ initConstant()

◆ initLinear()

◆ initRandom()

◆ initZeros() [1/6]

◆ initZeros() [2/6]

◆ initZeros() [3/6]

◆ initZeros() [4/6]

◆ initZeros() [5/6]

◆ initZeros() [6/6]

◆ interpolatedElement1D()

template<typename T>
class MultidimArray< T >