#include <image_operate.h>

Inheritance diagram for Image< T >:

Collaboration diagram for Image< T >:

Public Member Functions
	Image ()

	Image (int Xdim, int Ydim, int Zdim, int Ndim, const FileName &_filename)

	Image (int Xdim, int Ydim, int Zdim=1, int Ndim=1, bool _mmapOn=false)

	Image (const Image< T > &im)

	Image (const MultidimArray< T > &im)

virtual	~Image ()

void	clear ()

void	clearData ()

bool	isComplexT () const

void	getInverseAxisOrder (const std::array< int, 4 > &order, std::array< int, 4 > &result)

void	transposeAxisSizes (const std::array< size_t, 4 > &sizes, const std::array< int, 4 > &order, std::array< size_t, 4 > &result)

void	transposeInPlace (MultidimArray< T > &multidimArray, const std::array< int, 4 > &order)

void	castPage2T (char page, T ptrDest, DataType datatype, size_t pageSize)

void	castPage2Datatype (T srcPtr, char page, DataType datatype, size_t pageSize) const

void	castConvertPage2Datatype (T srcPtr, char page, DataType datatype, size_t pageSize, double min0, double max0, CastWriteMode castMode=CW_CONVERT) const

void	setPage2T (size_t offset, char *page, DataType datatype, size_t pageSize)

void	getPageFromT (size_t offset, char *page, DataType datatype, size_t pageSize)

void	getCastConvertPageFromT (size_t offset, char *page, DataType datatype, size_t pageSize, double min0, double max0, CastWriteMode castMode=CW_CONVERT) const

bool	checkMmapT (DataType datatype) override

void	mirrorY (void)

void	mirrorX (void)

void	selfApplyGeometry (int SplineDegree, bool wrap=xmipp_transformation::WRAP, bool only_apply_shifts=false)

int	readPreview (const FileName &name, size_t Xdim, size_t Ydim=0, int select_slice=CENTRAL_SLICE, size_t select_img=FIRST_IMAGE)

void	getPreview (ImageBase *imgBOut, size_t Xdim, size_t Ydim=0, int select_slice=CENTRAL_SLICE, size_t select_img=FIRST_IMAGE)

void	movePointerTo (int select_slice=ALL_SLICES, size_t select_img=ALL_IMAGES)

void	writePageAsDatatype (FILE *fimg, DataType datatype, size_t datasize_n)

Image< T > &	operator= (const Image< T > &op1)

MultidimArray< T > &	operator() ()

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

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

bool	operator== (const Image< T > &i1) const

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

size_t	getSize () const

void	getTransformationMatrix (Matrix2D< double > &A, bool only_apply_shifts=false, const size_t n=0)

void	sumWithFile (const FileName &fn)

template<>
void	castPage2T (char page, std::complex< double > ptrDest, DataType datatype, size_t pageSize)

template<>
void	castPage2Datatype (std::complex< double > srcPtr, char page, DataType datatype, size_t pageSize) const

template<>
void	castConvertPage2Datatype (std::complex< double > srcPtr, char page, DataType datatype, size_t pageSize, double min0, double max0, CastWriteMode castMode) const

template<>
void	castPage2T (char page, std::complex< double > ptrDest, DataType datatype, size_t pageSize)

template<>
void	castPage2Datatype (std::complex< double > srcPtr, char page, DataType datatype, size_t pageSize) const

template<>
void	castConvertPage2Datatype (std::complex< double > srcPtr, char page, DataType datatype, size_t pageSize, double min0, double max0, CastWriteMode castMode) const

Public Member Functions inherited from ImageBase
void	init ()

void	copy (const ImageBase &other)

void	clearHeader ()

bool	isComplex () const

virtual	~ImageBase ()

bool	isImage (const FileName &name)

bool	isMapped ()

bool	isRealImage (const FileName &name)

bool	isComplexImage (const FileName &name)

void	rename (const FileName &name)

void	mapFile2Write (size_t Xdim, size_t Ydim, size_t Zdim, const FileName &_filename, bool createTempFile=false, size_t select_img=APPEND_IMAGE, bool isStack=false, int mode=WRITE_OVERWRITE)

int	read (const FileName &name, DataMode datamode=DATA, size_t select_img=ALL_IMAGES, bool mapData=false, int mode=WRITE_READONLY)

int	readBatch (const FileName &name, size_t start_img, size_t batch_size, DataMode datamode=DATA, bool mapData=false, int mode=WRITE_READONLY)

int	readRange (const FileName &name, size_t start_img, size_t end_img, DataMode datamode=DATA, bool mapData=false, int mode=WRITE_READONLY)

int	readApplyGeo (const FileName &name, const MDRow &row, const ApplyGeoParams &params=DefaultApplyGeoParams)

int	readApplyGeo (const FileName &name, const MetaData &md, size_t objId, const ApplyGeoParams &params=DefaultApplyGeoParams)

int	readApplyGeo (const MetaData &md, size_t objId, const ApplyGeoParams &params=DefaultApplyGeoParams)

void	applyGeo (const MetaData &md, size_t objId, const ApplyGeoParams &params=DefaultApplyGeoParams)

void	setGeo (const MDRow &row, size_t n=0)

int	readMapped (const FileName &name, size_t select_img=ALL_IMAGES, int mode=WRITE_READONLY)

int	readOrReadMapped (const FileName &name, size_t select_img=ALL_IMAGES, int mode=WRITE_READONLY)

int	readOrReadPreview (const FileName &name, size_t Xdim, size_t Ydim, int select_slice=CENTRAL_SLICE, size_t select_img=FIRST_IMAGE, bool mapData=false)

void	write (const FileName &name="", size_t select_img=ALL_IMAGES, bool isStack=false, int mode=WRITE_OVERWRITE, CastWriteMode castMode=CW_CAST, int _swapWrite=0)

void	swapPage (char *page, size_t pageNrElements, DataType datatype, int swap=1)

void	swapOnWrite ()

const FileName &	name () const

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

void	getDimensions (ArrayDim &aDim)

ArrayDim	getDimensions ()

void	getInfo (ImageInfo &imgInfo) const

void	getInfo (const FileName &name, ImageInfo &imgInfo)

void	getOffsetAndSwap (size_t &_offset, int &_swap) const

int	getSwap () const

MDRow &	getGeometry (const size_t n=0)

void	initGeometry (const size_t n=0)

bool	individualContainsLabel (MDLabel label) const

bool	mainContainsLabel (MDLabel label) const

double	rot (const size_t n=0) const

double	tilt (const size_t n=0) const

double	psi (const size_t n=0) const

double	Xoff (const size_t n=0) const

double	Yoff (const size_t n=0) const

double	Zoff (const size_t n=0) const

double	weight (const size_t n=0) const

double	scale (const size_t n=0) const

bool	flip (const size_t n=0) const

DataType	datatype () const

double	samplingRateX () const

void	setADimFile (ArrayDim aDim)

void	setName (const FileName &_filename)

void	setDataMode (DataMode mode)

void	setEulerAngles (double rot, double tilt, double psi, const size_t n=0)

void	getEulerAngles (double &rot, double &tilt, double &psi, const size_t n=0) const

void	setRot (double rot, const size_t n=0)

void	setTilt (double tilt, const size_t n=0)

void	setPsi (double psi, const size_t n=0)

void	setShifts (double xoff, double yoff, double zoff=0., const size_t n=0)

void	getShifts (double &xoff, double &yoff, double &zoff, const size_t n=0) const

void	setXoff (double xoff, const size_t n=0)

void	setYoff (double yoff, const size_t n=0)

void	setZoff (double zoff, const size_t n=0)

void	setScale (double scale, const size_t n=0)

void	getScale (double &scale, const size_t n=0)

void	setFlip (bool flip, const size_t n=0)

void	setWeight (double weight, const size_t n=0)

Public Attributes
MultidimArray< T >	data

Public Attributes inherited from ImageBase
MultidimArrayBase *	mdaBase

std::vector< std::unique_ptr< MDRow > >	MD

MDRowVec	MDMainHeader

Protected Member Functions
void	applyGeo (const MDRow &row, bool only_apply_shifts=false, bool wrap=xmipp_transformation::WRAP) override

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

Protected Member Functions inherited from ImageBase
int	readDM3 (size_t img_select, bool isStack=false)

int	writeDM3 (size_t img_select, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readDM4 (size_t img_select, bool isStack=false)

int	writeDM4 (size_t img_select, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readIMAGIC (size_t img_select)

int	writeIMAGIC (size_t img_select=ALL_IMAGES, int mode=WRITE_OVERWRITE, const String &bitDepth="", CastWriteMode castMode=CW_CAST)

int	readMRC (size_t select_img, bool isStack=false)

int	readMRC (size_t start_img, size_t batch_size, bool isStack=false)

int	writeMRC (size_t select_img, bool isStack=false, int mode=WRITE_OVERWRITE, const String &bitDepth="", CastWriteMode castMode=CW_CAST)

int	readINF (size_t img_select, bool isStack=false)

int	writeINF (size_t img_select, bool isStack=false, int mode=WRITE_OVERWRITE, String bitDepth="", CastWriteMode castMode=CW_CAST)

DataType	datatypeRAW (String strDT)

int	readRAW (size_t select_img, bool isStack=false)

int	readSPIDER (size_t select_img)

int	readSPIDER (size_t start_img, size_t batch_size)

int	writeSPIDER (size_t select_img=ALL_IMAGES, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readSPE (size_t select_img, bool isStack=false)

int	writeSPE (size_t select_img, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readTIA (int img_select, bool isStack=false)

int	writeTIA (int img_select, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readJPEG (size_t select_img)

int	writeJPEG (size_t select_img, bool isStack=false, int mode=WRITE_OVERWRITE, String bitDepth="", CastWriteMode castMode=CW_CONVERT)

void	castTiffTile2T (size_t offset, char *tif_buf, unsigned int x, unsigned int y, unsigned int imageWidth, unsigned int imageLength, unsigned int tileWidth, unsigned int tileLength, unsigned short samplesPerPixel, DataType datatype)

void	castTiffLine2T (size_t offset, char *tif_buf, unsigned int y, unsigned int imageWidth, unsigned int imageLength, unsigned short samplesPerPixel, DataType datatype)

DataType	datatypeTIFF (TIFFDirHead dHead)

int	readTIFF (size_t select_img, bool isStack=false)

int	writeTIFF (size_t select_img, bool isStack=false, int mode=WRITE_OVERWRITE, String bitDepth="", CastWriteMode castMode=CW_CAST)

int	readEM (size_t select_img, bool isStack=false)

int	writeEM (size_t select_img=ALL_IMAGES, bool isStack=false, int mode=WRITE_OVERWRITE)

int	readPIF (size_t select_img)

int	writePIF (size_t select_img=ALL_IMAGES, bool isStack=false, int mode=WRITE_OVERWRITE)

DataType	datatypeH5 (hid_t dataset)

hid_t	H5Datatype (DataType datatype)

int	readHDF5 (size_t select_img)

int	writeHDF5 (size_t select_img, bool isStack=false, int mode=WRITE_OVERWRITE, String bitDepth="", CastWriteMode castMode=CW_CAST)

int	readEER (size_t select_img)

ImageFHandler *	openFile (const FileName &name, int mode=WRITE_READONLY) const
	More...

void	closeFile (ImageFHandler *hFile=NULL) const

int	_read (const FileName &name, ImageFHandler *hFile, DataMode datamode=DATA, size_t select_img=ALL_IMAGES, bool mapData=false)

int	_readBatch (const FileName &name, ImageFHandler *hFile, size_t start_img, size_t batch_size, DataMode datamode=DATA, bool mapData=false)

void	_write (const FileName &name, ImageFHandler *hFile, size_t select_img=ALL_IMAGES, bool isStack=false, int mode=WRITE_OVERWRITE, CastWriteMode castMode=CW_CAST)

void	setDatatype (DataType datatype)

Friends
class	ImageCollection

template<typename TT >
class	Image

Additional Inherited Members
Protected Attributes inherited from ImageBase
FileName	filename

FileName	tempFilename

FileName	dataFName

FILE *	fimg

FILE *	fhed

TIFF *	tif

hid_t	fhdf5

ImageFHandler *	hFile

ArrayDim	aDimFile

DataMode	dataMode

size_t	offset

int	swap

int	swapWrite

std::array< int, 4 >	axisOrder

TransformType	transform

size_t	replaceNsize

bool	_exists

bool	mmapOnRead

bool	mmapOnWrite

int	mFd

size_t	mappedSize

size_t	mappedOffset

size_t	virtualOffset

Static Protected Attributes inherited from ImageBase
static constexpr std::array< int, 4 >	defaultAxisOrder = {0,1,2,3}

Detailed Description

template<typename T>
class Image< T >

Template class for images. The image class is the general image handling class.

Definition at line 36 of file image_operate.h.

Constructor & Destructor Documentation

◆ Image() [1/5]

template<typename T>

Image< T >::Image ( )

inline

Empty constructor

An empty image is created.

Image<double> I;

Definition at line 66 of file xmipp_image.h.

     {
         mdaBase = (MultidimArrayBase*) &data;
         init();
     }

◆ Image() [2/5]

template<typename T>

Image< T >::Image	(	int	Xdim,
		int	Ydim,
		int	Zdim,
		int	Ndim,
		const FileName &	_filename
	)

inline

Constructor with size and filename

An image file, which name and format are given by filename, is created with the given size. Then the image is mapped to this file.

Image I(64,64,1,1,"image.spi");

Definition at line 81 of file xmipp_image.h.

     {
         mdaBase = (MultidimArrayBase*) &data;
         init();
         mmapOnWrite = true;
         data.setDimensions(Xdim, Ydim, Zdim, Ndim);
         MD.resize(Ndim);
         filename = _filename;
         ImageFHandler *hFile = openFile(_filename, WRITE_OVERWRITE);
         _write(_filename, hFile, ALL_IMAGES, false, WRITE_OVERWRITE);
         closeFile(hFile);
     }

◆ Image() [3/5]

template<typename T>

Image< T >::Image	(	int	Xdim,
		int	Ydim,
		int	Zdim = `1`,
		int	Ndim = `1`,
		bool	_mmapOn = `false`
	)

inline

Constructor with size

A blank image (0.0 filled) is created with the given size. Pay attention to the dimension order: Y and then X. If _mmapOn is True then image is allocated in a temporary file.

Image I(64,64);

Definition at line 104 of file xmipp_image.h.

     {
         mdaBase = (MultidimArrayBase*) &data;
         init();
         data.setMmap(_mmapOn);
         data.coreAllocate(Ndim, Zdim, Ydim, Xdim);
         MD.resize(Ndim);
     }

◆ Image() [4/5]

template<typename T>

Image< T >::Image ( const Image< T > & im )

inline

Definition at line 113 of file xmipp_image.h.

     {
         mdaBase = (MultidimArrayBase*) &data;
         init();
         *this = im;
     }

◆ Image() [5/5]

template<typename T>

Image< T >::Image ( const MultidimArray< T > & im )

inline

Constructor with MultidimArray alias

An image is created directly with its multidimarray aliased to im. This function is useful when debugging and you want to save multidimarrays.

Definition at line 125 of file xmipp_image.h.

     {
         mdaBase = (MultidimArrayBase*) &data;
         init();
         data.alias(im);
     }

◆ ~Image()

template<typename T>

virtual Image< T >::~Image ( )

inlinevirtual

Destructor.

Definition at line 135 of file xmipp_image.h.

     {
         clearData();
     }

Member Function Documentation

◆ applyGeo()

template<typename T >

void Image< T >::applyGeo	(	const MDRow &	row,
		bool	only_apply_shifts = `false`,
		bool	wrap = `xmipp_transformation::WRAP`
	)

overrideprotectedvirtual

Specific read functions for different file formatsApply geometry in referring metadata to the image

Implements ImageBase.

Definition at line 327 of file xmipp_image.cpp.

                                                                            {
     //This implementation does not handle stacks,
     //read in a block
     if (data.ndim != 1)
         REPORT_ERROR(ERR_MULTIDIM_SIZE,
                      "Geometric transformation cannot be applied to stacks!!!");
 
     if (MD.size() == 0)
         MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));
     MDRow &rowAux = *MD[0];
 
     if (!row.containsLabel(MDL_TRANSFORM_MATRIX))
     {
         double aux;
         //origins
         if (row.getValue(MDL_ORIGIN_X, aux))
             rowAux.setValue(MDL_ORIGIN_X, aux);
         if (row.getValue(MDL_ORIGIN_Y, aux))
             rowAux.setValue(MDL_ORIGIN_Y, aux);
         if (row.getValue(MDL_ORIGIN_Z, aux))
             rowAux.setValue(MDL_ORIGIN_Z, aux);
         //shifts
         if (row.getValue(MDL_SHIFT_X, aux))
             rowAux.setValue(MDL_SHIFT_X, aux);
         if (row.getValue(MDL_SHIFT_Y, aux))
             rowAux.setValue(MDL_SHIFT_Y, aux);
         if (row.getValue(MDL_SHIFT_Z, aux))
             rowAux.setValue(MDL_SHIFT_Z, aux);
         //rotations
         if (row.getValue(MDL_ANGLE_ROT, aux))
             rowAux.setValue(MDL_ANGLE_ROT, aux);
         if (row.getValue(MDL_ANGLE_TILT, aux))
             rowAux.setValue(MDL_ANGLE_TILT, aux);
         if (row.getValue(MDL_ANGLE_PSI, aux))
             rowAux.setValue(MDL_ANGLE_PSI, aux);
         //scale
         if (row.getValue(MDL_SCALE, aux))
             rowAux.setValue(MDL_SCALE, aux);
         //weight
         if (row.getValue(MDL_WEIGHT, aux))
             rowAux.setValue(MDL_WEIGHT, aux);
         bool auxBool;
         if (row.getValue(MDL_FLIP, auxBool))
             rowAux.setValue(MDL_FLIP, auxBool);
     }
 
     //apply geo has not been defined for volumes
     //and only make sense when reading data
     if (data.getDim() < 3 && dataMode >= DATA)
     {
         Matrix2D<double> A;
         if (!row.containsLabel(MDL_TRANSFORM_MATRIX))
             getTransformationMatrix(A, only_apply_shifts);
         else
         {
             String matrixStr;
             row.getValue(MDL_TRANSFORM_MATRIX, matrixStr);
             string2TransformationMatrix(matrixStr, A, 3);
         }
 
         if (!A.isIdentity())
         {
             MultidimArray<T> tmp = MULTIDIM_ARRAY(*this);
             applyGeometry(xmipp_transformation::BSPLINE3, MULTIDIM_ARRAY(*this), tmp, A, xmipp_transformation::IS_NOT_INV,
                           wrap);
         }
     }
 }

◆ castConvertPage2Datatype() [1/3]

template<>

void Image< std::complex< double > >::castConvertPage2Datatype	(	std::complex< double > *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize,
		double	min0,
		double	max0,
		CastWriteMode	castMode
	)		const

Definition at line 227 of file xmipp_image.cpp.

 {
 
     switch (datatype)
     {
     case DT_CFloat:
         {
             std::complex<float> * ptr = (std::complex<float> *) page;
             for(size_t i=0; i<pageSize;i++)
                 ptr[i] = (std::complex<float>)srcPtr[i];
         }
         break;
     default:
         REPORT_ERROR(ERR_TYPE_INCORRECT,formatString("ERROR: cannot cast&convert type number %d to complex<double>",datatype));
         break;
     }
 }

◆ castConvertPage2Datatype() [2/3]

template<typename T>

void Image< T >::castConvertPage2Datatype	(	T *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize,
		double	min0,
		double	max0,
		CastWriteMode	castMode = `CW_CONVERT`
	)		const

inline

Definition at line 544 of file xmipp_image.h.

     {
 
         double minF, maxF;
         double slope;
         size_t n;
         DataType myTypeId = myT();
 
         switch (datatype)
         {
             case DT_UHalfByte:
             case DT_UChar:
             {
                 if (castMode == CW_CONVERT && myTypeId == DT_SChar)
                 {
                     slope = 1;
                     min0 -= CHAR_MIN;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = 0;
                     maxF = UCHAR_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
                 unsigned char * ptr = (unsigned char *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<unsigned char>(minF
                                                         + (slope * static_cast<double>(srcPtr[n] - min0)));
 
                 break;
             }
             case DT_SChar:
             {
                 if (castMode == CW_CONVERT && myTypeId == DT_UChar)
                 {
                     slope = 1;
                     min0 += CHAR_MIN;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = CHAR_MIN;
                     maxF = CHAR_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
                 char * ptr = (char *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<char>(minF
                                                + (slope * static_cast<double>(srcPtr[n] - min0)));
 
                 break;
             }
             case DT_UShort:
             {
                 if (castMode == CW_CONVERT
                     && (myTypeId == DT_SChar || myTypeId == DT_Short))
                 {
                     slope = 1;
                     min0 -= SHRT_MIN;
                 }
                 else if (castMode == CW_CONVERT && (myTypeId == DT_UChar))
                 {
                     slope = 1;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = 0;
                     maxF = USHRT_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
 
                 unsigned short * ptr = (unsigned short *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<unsigned short>(minF
                                                          + (slope * static_cast<double>(srcPtr[n] - min0)));
 
                 break;
             }
             case DT_Short:
             {
                 if (castMode == CW_CONVERT
                     && (myTypeId == DT_UChar || myTypeId == DT_UShort))
                 {
                     slope = 1;
                     min0 += SHRT_MIN;
                 }
                 else if (castMode == CW_CONVERT && (myTypeId == DT_SChar))
                 {
                     slope = 1;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = SHRT_MIN;
                     maxF = SHRT_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
                 short * ptr = (short *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<short>(minF
                                                 + (slope * static_cast<double>(srcPtr[n] - min0)));
 
                 break;
             }
             case DT_UInt:
             {
                 if (castMode == CW_CONVERT
                     && (myTypeId == DT_SChar || myTypeId == DT_Short
                         || myTypeId == DT_Int))
                 {
                     slope = 1;
                     min0 -= INT_MIN;
                 }
                 else if (castMode == CW_CONVERT
                          && (myTypeId == DT_UShort || myTypeId == DT_UChar))
                 {
                     slope = 1;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = 0;
                     maxF = UINT_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
                 unsigned int * ptr = (unsigned int *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<unsigned int>(minF
                                                        + (slope * static_cast<double>(srcPtr[n] - min0)));
                 break;
             }
             case DT_Int:
             {
                 if (castMode == CW_CONVERT
                     && (myTypeId == DT_UChar || myTypeId == DT_UShort
                         || myTypeId == DT_UInt))
                 {
                     slope = 1;
                     min0 += INT_MIN;
                 }
                 else if (castMode == CW_CONVERT
                          && (myTypeId == DT_Short || myTypeId == DT_SChar))
                 {
                     slope = 1;
                 }
                 else if (castMode == CW_CAST)
                 {
                     minF  = 0;
                     min0  = 0;
                     slope = 1;
                 }
                 else
                 {
                     minF = INT_MIN;
                     maxF = INT_MAX;
                     if (max0 != min0)
                         slope = static_cast<double>(maxF - minF)
                                 / static_cast<double>(max0 - min0);
                     else
                         slope = 0;
                 }
                 int * ptr = (int *) page;
 
                 for (n = 0; n < pageSize; n++)
                     ptr[n] = static_cast<int>(minF
                                               + (slope * static_cast<double>(srcPtr[n] - min0)));
                 break;
             }
             default:
                 castPage2Datatype(srcPtr, page, datatype, pageSize);
         }
 
     }

◆ castConvertPage2Datatype() [3/3]

template<>

void Image< std::complex< double > >::castConvertPage2Datatype	(	std::complex< double > *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize,
		double	min0,
		double	max0,
		CastWriteMode	castMode
	)		const

◆ castPage2Datatype() [1/3]

template<>

void Image< std::complex< double > >::castPage2Datatype	(	std::complex< double > *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize
	)		const

Definition at line 181 of file xmipp_image.cpp.

 {
     switch (datatype)
     {
     case DT_CShort:
         {
             short  * ptr = (short *) page;
             double * srcPtrd = (double *)srcPtr;
             for(size_t i=0; i<pageSize;i++)
             {
                 *ptr=(short) *srcPtrd; ptr++; srcPtrd++;
                 *ptr=(short) *srcPtrd; ptr++; srcPtrd++;
             }
         }
         break;
     case DT_CInt:
         {
                         int  * ptr = (int *) page;
                         double * srcPtrd = (double *)srcPtr;
             for(size_t i=0; i<pageSize;i++)
                         {
                             *ptr=(int) *srcPtrd; ptr++; srcPtrd++;
                             *ptr=(int) *srcPtrd; ptr++; srcPtrd++;
                         }
         }
         break;
     case DT_CFloat:
         {
             std::complex<float> * ptr = (std::complex<float> *) page;
             for(size_t i=0; i<pageSize;i++)
                 ptr[i] = (std::complex<float>)srcPtr[i];
         }
         break;
     case DT_CDouble:
         memcpy(page, srcPtr, pageSize*sizeof(std::complex<double>));
         break;
     default:
         REPORT_ERROR(ERR_TYPE_INCORRECT,formatString("ERROR: cannot cast type number %d to complex<double>",datatype));
         break;
     }
 }

◆ castPage2Datatype() [2/3]

template<typename T>

void Image< T >::castPage2Datatype	(	T *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize
	)		const

inline

Cast page from T to datatype input pointer char *

Definition at line 426 of file xmipp_image.h.

     {
         switch (datatype)
         {
             case DT_Float:
             {
                 if (typeid(T) == typeid(float))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (float *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (float) srcPtr[i];
                 }
                 break;
             }
             case DT_Double:
             {
                 if (typeid(T) == typeid(double))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (double *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (double) srcPtr[i];
                 }
                 break;
             }
             case DT_UShort:
             {
                 if (typeid(T) == typeid(unsigned short))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (unsigned short *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (unsigned short) srcPtr[i];
                 }
                 break;
             }
             case DT_Short:
             {
                 if (typeid(T) == typeid(short))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (short *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (short) srcPtr[i];
                 }
                 break;
             }
             case DT_UHalfByte:
             case DT_UChar:
             {
                 if (typeid(T) == typeid(unsigned char))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (unsigned char *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (unsigned char) srcPtr[i];
                 }
                 break;
             }
             case DT_SChar:
             {
                 if (typeid(T) == typeid(char))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (char *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (char) srcPtr[i];
                 }
                 break;
             }
             case DT_HalfFloat:
             {
                 if (typeid(T) == typeid(half_float::half))
                 {
                     memcpy(page, srcPtr, pageSize * sizeof(T));
                 }
                 else
                 {
                     auto* ptr = (half_float::half *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         *ptr = (half_float::half) srcPtr[i];
                 }
                 break;
             }
             default:
             {
                 std::cerr << "outputDatatype = " << datatype << std::endl;
                 REPORT_ERROR(ERR_TYPE_INCORRECT,
                              " ERROR: cannot cast T to outputDatatype");
             }
         }
     }

◆ castPage2Datatype() [3/3]

template<>

void Image< std::complex< double > >::castPage2Datatype	(	std::complex< double > *	srcPtr,
		char *	page,
		DataType	datatype,
		size_t	pageSize
	)		const

◆ castPage2T() [1/3]

template<>

void Image< std::complex< double > >::castPage2T	(	char *	page,
		std::complex< double > *	ptrDest,
		DataType	datatype,
		size_t	pageSize
	)

Definition at line 141 of file xmipp_image.cpp.

 {
 
     switch (datatype)
     {
     case DT_CShort:
         {
             std::complex<short> * ptr = (std::complex<short> *) page;
             for(size_t i=0; i<pageSize;i++)
                 ptrDest[i]= std::complex<double> (real(ptr[i]),imag(ptr[i]));
         }
         break;
     case DT_CInt:
         {
             std::complex<int> * ptr = (std::complex<int> *) page;
             for(size_t i=0; i<pageSize;i++)
             ptrDest[i]= std::complex<double> (real(ptr[i]),imag(ptr[i]));
         }
         break;
     case DT_CFloat:
         {
             std::complex<float> * ptr = (std::complex<float> *) page;
             for(size_t i=0; i<pageSize;i++)
                 ptrDest[i]= std::complex<double> (real(ptr[i]),imag(ptr[i]));
         }
         break;
     case DT_CDouble:
             memcpy(ptrDest, page, pageSize*sizeof(std::complex<double>));
         break;
     default:
         std::cerr<<"Datatype= "<<datatype<<std::endl;
         REPORT_ERROR(ERR_TYPE_INCORRECT," ERROR: cannot cast datatype to std::complex<double>");
         break;
     }
 }

◆ castPage2T() [2/3]

template<typename T>

void Image< T >::castPage2T	(	char *	page,
		T *	ptrDest,
		DataType	datatype,
		size_t	pageSize
	)

inline

Cast a page of data from type dataType to type Tdest input pointer char *

Definition at line 268 of file xmipp_image.h.

     {
         switch (datatype)
         {
             case DT_Unknown:
                 REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR: datatype is Unknown_Type");
             case DT_UHalfByte:
             case DT_UChar:
             {
                 if (typeid(T) == typeid(unsigned char))
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 else
                 {
                     const auto* ptr = (unsigned char *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_SChar:
             {
                 if (typeid(T) == typeid(signed char))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (signed char *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_UShort:
             {
                 if (typeid(T) == typeid(unsigned short))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (unsigned short *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_Short:
             {
                 if (typeid(T) == typeid(short))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (short *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_UInt:
             {
                 if (typeid(T) == typeid(unsigned int))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (unsigned int *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_Int:
             {
                 if (typeid(T) == typeid(int))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (int *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_Long:
             {
                 if (typeid(T) == typeid(long))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (long *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_Float:
             {
                 if (typeid(T) == typeid(float))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (float *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_Double:
             {
                 if (typeid(T) == typeid(double))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (double *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             case DT_HalfFloat:
             {
                 if (typeid(T) == typeid(half_float::half))
                 {
                     memcpy(ptrDest, page, pageSize * sizeof(T));
                 }
                 else
                 {
                     const auto* ptr = (half_float::half *) page;
                     for (size_t i = 0; i < pageSize; ++i, ++ptr)
                         ptrDest[i] = (T) *ptr;
                 }
                 break;
             }
             default:
             {
                 std::cerr << "Datatype= " << datatype << std::endl;
                 REPORT_ERROR(ERR_TYPE_INCORRECT, " ERROR: cannot cast datatype to T");
             }
         }
 
     }

◆ castPage2T() [3/3]

template<>

void Image< std::complex< double > >::castPage2T	(	char *	page,
		std::complex< double > *	ptrDest,
		DataType	datatype,
		size_t	pageSize
	)

◆ checkMmapT()

template<typename T>

bool Image< T >::checkMmapT ( DataType datatype )

inlineoverridevirtual

Check if file Datatype is the same as the declared image object (T type) to use mmap.

Implements ImageBase.

Definition at line 797 of file xmipp_image.h.

     {
 
         switch (datatype)
         {
             case DT_Unknown:
                 REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR: datatype is Unknown_Type");
             case DT_UHalfByte:
                 return 0;
             case DT_UChar:
                 return typeid(T) == typeid(unsigned char);
             case DT_SChar:
                 return typeid(T) == typeid(char);
             case DT_UShort:
                 return typeid(T) == typeid(unsigned short);
             case DT_Short:
                 return typeid(T) == typeid(short);
             case DT_UInt:
                 return typeid(T) == typeid(unsigned int);
             case DT_Int:
                 return typeid(T) == typeid(int);
             case DT_Long:
                 return typeid(T) == typeid(long);
             case DT_Float:
                 return typeid(T) == typeid(float);
             case DT_Double:
                 return typeid(T) == typeid(double);
             case DT_HalfFloat:
                 return typeid(T) == typeid(half_float::half);
             default:
             {
                 std::cerr << "Datatype= " << datatype << std::endl;
                 REPORT_ERROR(ERR_TYPE_INCORRECT, " ERROR: cannot cast datatype to T");
             }
         }
     }

◆ clear()

template<typename T>

void Image< T >::clear ( )

inlinevirtual

Clear. Initialize everything to 0

Implements ImageBase.

Definition at line 144 of file xmipp_image.h.

     {
         clearData();
         init();
     }

◆ clearData()

template<typename T>

void Image< T >::clearData ( )

inline

Clear the data pointer either mapped or not. Initially fix the pointer position in case of tricking a lower number of slices and starting in a slice different from zero.

Definition at line 156 of file xmipp_image.h.

     {
         // If MultidimArray pointer has been moved to a slice different from zero, then reset it.
         // This check must be done prior to mappedSize check, since mappedSlice is a trick over data pointer
         if (virtualOffset != 0)
             movePointerTo(ALL_SLICES);
         if (mmapOnRead || mmapOnWrite)
             munmapFile();
 
         else
             data.clear();
 
     }

◆ getCastConvertPageFromT()

template<typename T>

void Image< T >::getCastConvertPageFromT	(	size_t	offset,
		char *	page,
		DataType	datatype,
		size_t	pageSize,
		double	min0,
		double	max0,
		CastWriteMode	castMode = `CW_CONVERT`
	)		const

inlinevirtual

Implements ImageBase.

Definition at line 786 of file xmipp_image.h.

     {
         castConvertPage2Datatype(MULTIDIM_ARRAY(data) + offset, page, datatype,
                                  pageSize, min0, max0, castMode);
     }

◆ getInverseAxisOrder()

template<typename T>

void Image< T >::getInverseAxisOrder	(	const std::array< int, 4 > &	order,
		std::array< int, 4 > &	result
	)

inline

Obtain the inverse axis mapping

Definition at line 184 of file xmipp_image.h.

     {
         for (size_t i = 0; i < result.size(); ++i)
         {
             size_t j = 0;
             while(j < order.size() && order[j] != i) ++j; // Find inverse mapping
             if (j >= order.size())
                 REPORT_ERROR(ERR_LOGIC_ERROR, "Invalid axis mapping");
             
             result[i] = j;
         }
     }

◆ getPageFromT()

template<typename T>

void Image< T >::getPageFromT	(	size_t	offset,
		char *	page,
		DataType	datatype,
		size_t	pageSize
	)

inlinevirtual

Implements ImageBase.

Definition at line 779 of file xmipp_image.h.

     {
         castPage2Datatype(MULTIDIM_ARRAY(data) + offset, page, datatype,
                           pageSize);
     }

◆ getPreview()

template<typename T >

void Image< T >::getPreview	(	ImageBase *	imgBOut,
		size_t	Xdim,
		size_t	Ydim = `0`,
		int	select_slice = `CENTRAL_SLICE`,
		size_t	select_img = `FIRST_IMAGE`
	)

virtual

Returns an image with a lower resolution as a preview image. If Zdim parameter is not passed, then all slices are rescaled. If Ydim is not passed, then Ydim is rescaled same factor as Xdim.

Implements ImageBase.

Definition at line 276 of file xmipp_image.cpp.

 {
     // Zdim is used to choose the slices: -1 = CENTRAL_SLICE, 0 = ALL_SLICES, else This Slice
 
     size_t Zdim;
     ArrayDim imAdim;
     MULTIDIM_ARRAY(*this).getDimensions(imAdim);
     MULTIDIM_ARRAY(*this).setXmippOrigin();
 
     double scale;
 
     // If only Xdim is passed, it is the higher allowable size, for any dimension
     if (Ydim == 0 && imAdim.xdim < imAdim.ydim)
     {
         Ydim = Xdim;
         scale = ((double) Ydim) / ((double) imAdim.ydim);
         Xdim = (int) (scale * imAdim.xdim);
     }
     else
     {
         scale = ((double) Xdim) / ((double) imAdim.xdim);
         if (Ydim == 0)
             Ydim = (int) (scale * imAdim.ydim);
     }
 
     Image<T> &imgOut = *((Image<T>*) imgBOut);
 
     int mode = (scale <= 1) ? xmipp_transformation::NEAREST : xmipp_transformation::LINEAR; // If scale factor is higher than 1, LINEAR mode is used to avoid artifacts
 
     if (select_slice > ALL_SLICES) // In this case a specific slice number has been chosen (Not central slice)
     {
         movePointerTo(select_slice, select_img);
         scaleToSize(mode, IMGMATRIX(imgOut), IMGMATRIX(*this), Xdim, Ydim);
     }
     else // Otherwise, All slices or Central slice is selected
     {
         movePointerTo(ALL_SLICES, select_img);
         Zdim = (select_slice == ALL_SLICES) ? imAdim.zdim : 1;
         scaleToSize(mode, IMGMATRIX(imgOut), IMGMATRIX(*this), Xdim, Ydim,
                     Zdim);
     }
 
     movePointerTo();
     IMGMATRIX(*this).resetOrigin();
 
     // We set the actual dimesions of th MDA to the imageOut as if it were read from file.
     imgOut.setADimFile(IMGMATRIX(imgOut).getDimensions());
 }

◆ getSize()

template<typename T>

size_t Image< T >::getSize ( ) const

inlinevirtual

Get Image dimensions

Implements ImageBase.

Definition at line 1091 of file xmipp_image.h.

     {
         return NZYXSIZE(data);
     }

◆ getTransformationMatrix()

template<typename T >

void Image< T >::getTransformationMatrix	(	Matrix2D< double > &	A,
		bool	only_apply_shifts = `false`,
		const size_t	n = `0`
	)

virtual

Get geometric transformation matrix from 2D-image header

Implements ImageBase.

Definition at line 266 of file xmipp_image.cpp.

 {
     // This has only been implemented for 2D images...
     MULTIDIM_ARRAY(*this).checkDimension(2);
     A.resizeNoCopy(3, 3);
     geo2TransformationMatrix(*MD[n], A, only_apply_shifts);
 }

◆ isComplexT()

template<typename T>

bool Image< T >::isComplexT ( ) const

inlinevirtual

Check whether image is complex based on T

Implements ImageBase.

Definition at line 173 of file xmipp_image.h.

     {
         return (typeid(T) == typeid(std::complex<double>)
                 || typeid(T) == typeid(std::complex<float>));
     }

◆ mirrorX()

template<typename T>

void Image< T >::mirrorX ( void )

inline

flip image around Y axis

Definition at line 865 of file xmipp_image.h.

     {
         T aux(0);
         size_t Z, Y, X, N, X2;
 
         X = XSIZE(data);
         Y = YSIZE(data);
         Z = ZSIZE(data);
         N = NSIZE(data);
         X2 = X / 2;
         X--;
         for (size_t l = 0; l < N; ++l)
             for (size_t k = 0; k < Z; ++k)
                 for (size_t i = 0; i < Y; ++i)
                     for (size_t j = 0; j < X2; ++j)
                     {
                         aux = DIRECT_NZYX_ELEM(data, l, k, i, j);
                         DIRECT_NZYX_ELEM(data, l, k, i, j) = DIRECT_NZYX_ELEM(data, l, k,
                                                                               i, X - j);
                         DIRECT_NZYX_ELEM(data, l, k, i, X - j) = aux;
                     }
     }

◆ mirrorY()

template<typename T>

void Image< T >::mirrorY ( void )

inlinevirtual

flip image around X axis

Implements ImageBase.

Definition at line 838 of file xmipp_image.h.

     {
         T aux(0);
         size_t Z, Y, X, N, Y2;
 
         X = XSIZE(data);
         Y = YSIZE(data);
         Z = ZSIZE(data);
         N = NSIZE(data);
         Y2 = Y / 2;
         Y--;
         for (size_t l = 0; l < N; ++l)
             for (size_t k = 0; k < Z; ++k)
                 for (size_t i = 0; i < Y2; ++i)
                     for (size_t j = 0; j < X; ++j)
                     {
                         aux = DIRECT_NZYX_ELEM(data, l, k, i, j);
                         DIRECT_NZYX_ELEM(data, l, k, i, j) = DIRECT_NZYX_ELEM(data, l, k,
                                                                               Y - i, j);
                         DIRECT_NZYX_ELEM(data, l, k, Y-i, j) = aux;
                     }
     }

◆ movePointerTo()

template<typename T>

void Image< T >::movePointerTo	(	int	select_slice = `ALL_SLICES`,
		size_t	select_img = `ALL_IMAGES`
	)

inlinevirtual

It changes the behavior of the internal multidimarray so it points to a specific slice/image from a stack, volume or stack of volumes. No information is deallocated from memory, so it is also possible to repoint to the whole stack,volume... (passing select_slice = ALL_SLICES and selec_img = ALL_IMAGES).

The options for select_slice are:

a slice number,
CENTRAL_SLICE, to automatically select the central slice of the volume,
ALL_SLICES, to recover the whole volume.

The options for selec_img are:

a image number of the stack,
ALL_IMAGES, to recover the whole stack.

If a specific slice number is selected, then a specific image from the stack must be also selected. Otherwise, FIRST_IMAGE is proposed.

If Image Object is read using readPreview method, movePointerTo only works when rescaling the image in X-Y plane only, but all slices must be read.

Implements ImageBase.

Definition at line 931 of file xmipp_image.h.

     {
         if (MULTIDIM_ARRAY(VOLMATRIX(*this)) == NULL)
             REPORT_ERROR(ERR_MULTIDIM_EMPTY,
                          "Image::movePointerTo: Image is empty");
         if (select_slice > (int) aDimFile.zdim)
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          formatString(
                                  "movePointerTo: Selected slice %4d cannot be higher than Z size %4d.",
                                  select_slice, aDimFile.zdim));
         else if (select_img > aDimFile.ndim)
             REPORT_ERROR(ERR_MULTIDIM_SIZE,
                          formatString(
                                  "movePointerTo: Selected image %4d cannot be higher than N size %4d.",
                                  select_img, aDimFile.ndim));
 
         ArrayDim newDim;
         VOLMATRIX(*this).getDimensions(newDim);
 
         /* Restore the real dimensions from the MDA, as it may be
          * X-Y dimensioned different from file (readPreview). */
         newDim.zdim = aDimFile.zdim;
         newDim.ndim = aDimFile.ndim;
 
         int phys_slice;
 
         switch (select_slice)
         {
             case CENTRAL_SLICE:
                 phys_slice = aDimFile.zdim / 2;
                 newDim.zdim = 1;
                 break;
             case ALL_SLICES:
                 phys_slice = 0;
                 break;
             default:
                 phys_slice = select_slice - 1;
                 newDim.zdim = 1;
                 break;
         }
 
         /* If we select a single slice, we are forced to chose also an image.
          * as at this moment we cannot select the same slice from different images at a time.
          */
         if (select_slice > 0 && select_img == ALL_IMAGES)
             select_img = FIRST_IMAGE;
         if (select_img > ALL_IMAGES)
             newDim.ndim = 1;
 
         VOLMATRIX(*this).setDimensions(newDim);
 
         size_t newVirtualOffset = YXSIZE(VOLMATRIX(*this))
                                   * (aDimFile.zdim * IMG_INDEX(select_img) + phys_slice);
         MULTIDIM_ARRAY(VOLMATRIX(*this)) += (newVirtualOffset - virtualOffset);
         virtualOffset = newVirtualOffset;
     }

◆ operator()() [1/4]

template<typename T>

MultidimArray<T>& Image< T >::operator() ( )

inline

Data access

This operator can be used to access the data multidimarray. In this way we could resize an image just by resizing its associated matrix or we could add two images by adding their matrices.

I().resize(128, 128);

I2() = I1() + I2();

Definition at line 1025 of file xmipp_image.h.

     {
         return data;
     }

◆ operator()() [2/4]

template<typename T>

const MultidimArray<T>& Image< T >::operator() ( ) const

inline

Definition at line 1030 of file xmipp_image.h.

     {
         return data;
     }

◆ operator()() [3/4]

template<typename T>

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

inline

Pixel access

This operator is used to access a pixel within a 2D image. This is a logical access, so you could access to negative positions if the image has been defined so (see the general explanation for the class).

std::cout << "Grey level of pixel (-3,-3) of the image = " << I(-3, -3)
<< std::endl;
I(-3, -3) = I(-3, -2);

Definition at line 1049 of file xmipp_image.h.

     {
         return A2D_ELEM(data, i, j);
     }

◆ operator()() [4/4]

template<typename T>

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

inline

Voxel access

This operator is used to access a voxel within a 3D image. This is a logical access, so you could access to negative positions if the image has been defined so (see the general explanation for the class).

std::cout << "Grey level of pixel (-3,-3, 1) of the volume = " << I(-3, -3, 1)
<< std::endl;
I(-3, -3, 1) = I(-3, -2, 0);

Definition at line 1076 of file xmipp_image.h.

     {
         return A3D_ELEM(data, k, i, j);
     }

◆ operator=()

template<typename T>

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

inline

Copy the MDA and the fields related to the (possible) original file

Definition at line 1006 of file xmipp_image.h.

     {
         this->copy(op1);
         data = op1.data;
         return *this;
     }

◆ operator==()

template<typename T>

bool Image< T >::operator== ( const Image< T > & i1 ) const

inline

equal operator

Definition at line 1057 of file xmipp_image.h.

     {
         return (this->data == i1.data);
     }

◆ readPreview()

template<typename T >

int Image< T >::readPreview	(	const FileName &	name,
		size_t	Xdim,
		size_t	Ydim = `0`,
		int	select_slice = `CENTRAL_SLICE`,
		size_t	select_img = `FIRST_IMAGE`
	)

virtual

Implements ImageBase.

Definition at line 38 of file xmipp_image.cpp.

 {
     // Zdim is used to choose the slices: -1 = CENTRAL_SLICE, 0 = ALL_SLICES, else This Slice
 
     ImageGeneric im;
     size_t imXdim, imYdim, imZdim, Zdim;
     int err;
     err = im.readMapped(name, select_img);
     im.getDimensions(imXdim, imYdim, imZdim);
     ImageInfo imgInfo;
     im.getInfo(imgInfo);
 
     //Set information from image file
     setName(name);
     setDatatype(imgInfo.datatype);
     aDimFile = imgInfo.adim;
 
     im().setXmippOrigin();
 
     double scale;
 
     // If only Xdim is passed, it is the higher allowable size, for any dimension
     if (Ydim == 0 && imXdim < imYdim)
     {
         Ydim = Xdim;
         scale = ((double) Ydim) / ((double) imYdim);
         Xdim = (int) (scale * imXdim);
     }
     else
     {
         scale = ((double) Xdim) / ((double) imXdim);
         if (Ydim == 0)
             Ydim = (int) (scale * imYdim);
     }
 
     int mode = (scale <= 1) ? xmipp_transformation::NEAREST : xmipp_transformation::LINEAR; // If scale factor is higher than 1, LINEAR mode is used to avoid artifacts
 
     if (select_slice > ALL_SLICES) // In this case a specific slice number has been chosen (Not central slice)
     {
         MultidimArrayGeneric array(im(), select_slice - 1);
         array.setXmippOrigin();
 
         scaleToSize(mode, IMGMATRIX(*this), array, Xdim, Ydim);
     }
     else // Otherwise, All slices or Central slice is selected
     {
         Zdim = (select_slice == ALL_SLICES) ? imZdim : 1;
         scaleToSize(mode, IMGMATRIX(*this), im(), Xdim, Ydim, Zdim);
     }
 
     IMGMATRIX(*this).resetOrigin();
     return err;
 }

◆ selfApplyGeometry()

template<typename T >

void Image< T >::selfApplyGeometry	(	int	SplineDegree,
		bool	wrap = `xmipp_transformation::WRAP`,
		bool	only_apply_shifts = `false`
	)

virtual

Internal apply geometrical transformations

Implements ImageBase.

Definition at line 247 of file xmipp_image.cpp.

 {
     //apply geo has not been defined for volumes
     //and only make sense when reading data
     if (data.getDim() < 3 && dataMode >= DATA)
     {
         Matrix2D<double> A;
         getTransformationMatrix(A, only_apply_shifts);
         if (!A.isIdentity())
         {
             MultidimArray<T> tmp = MULTIDIM_ARRAY(*this);
             applyGeometry(SplineDegree, MULTIDIM_ARRAY(*this), tmp, A, xmipp_transformation::IS_NOT_INV,
                           wrap);
         }
     }
 }

◆ setDimensions()

template<typename T>

void Image< T >::setDimensions	(	int	Xdim,
		int	Ydim,
		int	Zdim,
		size_t	Ndim
	)

inlineprotectedvirtual

Set the image dimensions

Implements ImageBase.

Definition at line 1127 of file xmipp_image.h.

     {
         data.setDimensions(Xdim, Ydim, Zdim, Ndim);
         data.getDimensions(aDimFile);
     }

◆ setPage2T()

template<typename T>

void Image< T >::setPage2T	(	size_t	offset,
		char *	page,
		DataType	datatype,
		size_t	pageSize
	)

inlinevirtual

Implements ImageBase.

Definition at line 773 of file xmipp_image.h.

     {
         castPage2T(page, MULTIDIM_ARRAY(data) + offset, datatype, pageSize);
     }

◆ sumWithFile()

template<typename T>

void Image< T >::sumWithFile ( const FileName & fn )

inlinevirtual

Sum this object with other file and keep in this object

Implements ImageBase.

Definition at line 1105 of file xmipp_image.h.

     {
         Image<T> aux;
         aux.read(fn, DATA, ALL_IMAGES, true);
         (*this)() += aux();
     }

◆ transposeAxisSizes()

template<typename T>

void Image< T >::transposeAxisSizes	(	const std::array< size_t, 4 > &	sizes,
		const std::array< int, 4 > &	order,
		std::array< size_t, 4 > &	result
	)

inline

Trasposes the given size array according to inverseOrder

Definition at line 202 of file xmipp_image.h.

     {
         std::array<int, 4> inverseOrder;
         getInverseAxisOrder(order, inverseOrder);
 
         result = {
             sizes[inverseOrder[0]],
             sizes[inverseOrder[1]],
             sizes[inverseOrder[2]],
             sizes[inverseOrder[3]]
         };
     }

◆ transposeInPlace()

template<typename T>

void Image< T >::transposeInPlace	(	MultidimArray< T > &	multidimArray,
		const std::array< int, 4 > &	order
	)

inline

Trasposes the given MultidimArray with the given order

Definition at line 221 of file xmipp_image.h.

    {
         std::array<int, 4> inverseOrder;
         getInverseAxisOrder(order, inverseOrder);
 
         // Creating new multidim array of the same size than the original
         const std::array<size_t,4> sizes = {
             NSIZE(multidimArray),
             ZSIZE(multidimArray),
             YSIZE(multidimArray),
             XSIZE(multidimArray)
         };
 
         MultidimArray<T> result(
             sizes[inverseOrder[0]],
             sizes[inverseOrder[1]],
             sizes[inverseOrder[2]],
             sizes[inverseOrder[3]]
         );
 
         // Performing transposition in a loop for every dimension
         for (size_t n = 0; n < NSIZE(multidimArray); n++) {
             for (size_t z = 0; z < ZSIZE(multidimArray); z++) {
                 for (size_t y = 0; y < YSIZE(multidimArray); y++) {
                     for (size_t x = 0; x < XSIZE(multidimArray); x++) {
                         // Defining array to access with the axis orders
                         const std::array<size_t,4> indices = {n, z, y, x};
                         const auto l = indices[inverseOrder[0]];
                         const auto k = indices[inverseOrder[1]];
                         const auto i = indices[inverseOrder[2]];
                         const auto j = indices[inverseOrder[3]];
 
                         // Transposing element
                         DIRECT_NZYX_ELEM(result, l, k, i, j) = DIRECT_NZYX_ELEM(multidimArray, n, z, y, x);
                     }
                 }
             }
         }
 
         // Remapping pointers from original multidim array to transposed one
         multidimArray = std::move(result);
    }

◆ writePageAsDatatype()

template<typename T>

void Image< T >::writePageAsDatatype	(	FILE *	fimg,
		DataType	datatype,
		size_t	datasize_n
	)

inlinevirtual

Write an entire page as datatype

A page of datasize_n elements T is cast to datatype and written to fimg The memory for the casted page is allocated and freed internally.

Implements ImageBase.

Definition at line 994 of file xmipp_image.h.

     {
         size_t datasize = datasize_n * gettypesize(datatype);
         char * fdata = (char *) askMemory(datasize);
         castPage2Datatype(MULTIDIM_ARRAY(data), fdata, datatype, datasize_n);
         fwrite(fdata, datasize, 1, fimg);
         freeMemory(fdata, datasize);
     }

Friends And Related Function Documentation

◆ Image

template<typename T>

template<typename TT >

friend class Image

friend

Definition at line 1550 of file xmipp_image.h.

◆ ImageCollection

template<typename T>

friend class ImageCollection

friend

Definition at line 1548 of file xmipp_image.h.

Member Data Documentation

◆ data

template<typename T>

MultidimArray<T> Image< T >::data

Definition at line 55 of file xmipp_image.h.

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

xmipp/libraries/data/image_operate.h
xmippCore/core/xmipp_image.h
xmippCore/core/xmipp_image.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

template<typename T> class Image< T >

Constructor & Destructor Documentation

◆ Image() [1/5]

◆ Image() [2/5]

◆ Image() [3/5]

◆ Image() [4/5]

◆ Image() [5/5]

◆ ~Image()

Member Function Documentation

◆ applyGeo()

◆ castConvertPage2Datatype() [1/3]

◆ castConvertPage2Datatype() [2/3]

◆ castConvertPage2Datatype() [3/3]

◆ castPage2Datatype() [1/3]

◆ castPage2Datatype() [2/3]

◆ castPage2Datatype() [3/3]

◆ castPage2T() [1/3]

◆ castPage2T() [2/3]

◆ castPage2T() [3/3]

◆ checkMmapT()

◆ clear()

◆ clearData()

◆ getCastConvertPageFromT()

◆ getInverseAxisOrder()

◆ getPageFromT()

◆ getPreview()

◆ getSize()

◆ getTransformationMatrix()

◆ isComplexT()

◆ mirrorX()

◆ mirrorY()

◆ movePointerTo()

◆ operator()() [1/4]

◆ operator()() [2/4]

◆ operator()() [3/4]

◆ operator()() [4/4]

◆ operator=()

◆ operator==()

◆ readPreview()

◆ selfApplyGeometry()

◆ setDimensions()

◆ setPage2T()

◆ sumWithFile()

◆ transposeAxisSizes()

◆ transposeInPlace()

◆ writePageAsDatatype()

Friends And Related Function Documentation

◆ Image

◆ ImageCollection

Member Data Documentation

◆ data

template<typename T>
class Image< T >