ImageBase Class Reference

Image base class. More...

#include <xmipp_image_base.h>

Inheritance diagram for ImageBase:

Collaboration diagram for ImageBase:

Classes
struct	EMHead
struct	PIFDataHeader
struct	PIFMainHeader
struct	SPIDERhead
struct	TIFFDirHead

Public Member Functions
void	init ()
void	copy (const ImageBase &other)
virtual void	clear ()=0
void	clearHeader ()
virtual bool	isComplexT () const =0
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)
virtual int	readPreview (const FileName &name, size_t Xdim, size_t Ydim=0, int select_slice=CENTRAL_SLICE, size_t select_img=FIRST_IMAGE)=0
virtual void	getPreview (ImageBase *imgOut, size_t Xdim, size_t Ydim=0, int select_slice=CENTRAL_SLICE, size_t select_img=FIRST_IMAGE)=0
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)
virtual void	movePointerTo (int select_slice=ALL_SLICES, size_t select_img=ALL_IMAGES)=0
virtual DataType	myT () const =0
virtual bool	checkMmapT (DataType datatype)=0
virtual void	writePageAsDatatype (FILE *fimg, DataType datatype, size_t datasize_n)=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)
virtual size_t	getSize () const =0
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
virtual void	setDimensions (int Xdim, int Ydim, int Zdim, size_t Ndim)=0
virtual void	setDimensions (ArrayDim &aDim)
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)
virtual void	getTransformationMatrix (Matrix2D< double > &A, bool only_apply_shifts=false, const size_t n=0)=0
virtual void	sumWithFile (const FileName &fn)=0
virtual void	mirrorY ()=0
virtual void	selfApplyGeometry (int SplineDegree, bool wrap, bool only_apply_shifts)=0

Public Attributes
MultidimArrayBase *	mdaBase
std::vector< std::unique_ptr< MDRow > >	MD
MDRowVec	MDMainHeader

Protected Member Functions
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
virtual void	applyGeo (const MDRow &row, bool only_apply_shifts=false, bool wrap=xmipp_transformation::WRAP)=0
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)
virtual void	readData (FILE *fimg, size_t select_img, DataType datatype, size_t pad)=0
virtual void	readData4bit (FILE *fimg, size_t select_img, DataType datatype, size_t pad)=0
virtual void	writeData (FILE *fimg, size_t offset, DataType wDType, size_t datasize_n, CastWriteMode castMode=CW_CAST)=0
virtual void	setPage2T (size_t offset, char *page, DataType datatype, size_t pageSize)=0
virtual void	getPageFromT (size_t offset, char *page, DataType datatype, size_t pageSize)=0
virtual void	getCastConvertPageFromT (size_t offset, char *page, DataType datatype, size_t pageSize, double min0, double max0, CastWriteMode castMode=CW_CONVERT) const =0
virtual void	mmapFile ()=0
virtual void	munmapFile ()=0
void	setDatatype (DataType datatype)

Protected Attributes
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
static constexpr std::array< int, 4 >	defaultAxisOrder = {0,1,2,3}

Friends
std::ostream &	operator<< (std::ostream &o, const ImageBase &I)

Detailed Description

Image base class.

Definition at line 238 of file xmipp_image_base.h.

Constructor & Destructor Documentation

~ImageBase()

ImageBase::~ImageBase ( )

virtual

Destructor.

Definition at line 1205 of file xmipp_image_base.cpp.

{
    delete m_auxI;
}

Member Function Documentation

_read()

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

protected

Internal read image file method.

Definition at line 792 of file xmipp_image_base.cpp.

{
    // Temporary Error to find old select_img == -1
    if (select_img == (size_t) -1)
        REPORT_ERROR(ERR_DEBUG_TEST, "To select all images use ALL_IMAGES macro, or FIRST_IMAGE macro.");

    int err = 0;
    dataMode = datamode;

    // If MultidimArray pointer has been moved to a slice/image 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 Image has been previously used with mmap, then close the previous file
    if (mappedSize != 0)
        munmapFile();

    // Check whether to map the data or not
#ifdef XMIPP_MMAP

    mmapOnRead = mapData;
#endif

    const auto &ext_name = hFile->ext_name;
    fimg = hFile->fimg;
    fhed = hFile->fhed;
    tif  = hFile->tif;
    fhdf5 = hFile->fhdf5;

    size_t image_num = name.getPrefixNumber();
    filename = name;
    dataFName = hFile->fileName;

    if (image_num != ALL_IMAGES)
        select_img = image_num;

#undef DEBUG
    // #define DEBUG
#ifdef DEBUG

    std::cerr << "READ\n" <<
    "name="<<name <<std::endl;
    std::cerr << "ext= "<<ext_name <<std::endl;
    std::cerr << " now reading: "<< filename <<" dataflag= "<<dataMode
    << " select_img "  << select_img << ", image_num = " << image_num << std::endl;
#endif
#undef DEBUG

    // Defining default axis order (will be overwritten by data types that need it)
    axisOrder = defaultAxisOrder;

    //Just clear the header before reading
    MDMainHeader.clear();
    //Set the file pointer at beginning
    if (fimg != NULL)
        fseek(fimg, 0, SEEK_SET);
    if (fhed != NULL)
        fseek(fhed, 0, SEEK_SET);

    if (ext_name.contains("spi") || ext_name.contains("xmp")  ||
        ext_name.contains("stk") || ext_name.contains("vol"))
        err = readSPIDER(select_img);
    else if (isMRCStack(ext_name)) //mrc stack MUST go BEFORE plain MRC
        err = readMRC(select_img,true);
    else if (isMRCImageOrVolume(ext_name)) //mrc
        err = readMRC(select_img,false);
    else if (ext_name.contains("eer"))//EER
        err = readEER(select_img);
    else if (ext_name.contains("img") || ext_name.contains("hed"))//
        err = readIMAGIC(select_img);//imagic is always an stack
    else if (ext_name.contains("ser"))//TIA
        err = readTIA(select_img,false);
    else if (ext_name.contains("dm3"))//DM3
        err = readDM3(select_img,false);
    else if (ext_name.contains("dm4"))//DM4
        err = readDM4(select_img,false);
    else if (ext_name.contains("ems"))//EM stack
        err = readEM(select_img, true);
    else if (ext_name.contains("em"))//EM
        err = readEM(select_img);
    else if (ext_name.contains("pif"))//PIF
        err = readPIF(select_img);
    else if (ext_name.contains("inf"))//RAW with INF file
        err = readINF(select_img,false);
    else if (ext_name.contains("raw"))//RAW without INF file
        err = readRAW(select_img,false);
    else if (ext_name.contains("tif") || ext_name.contains("gain"))//TIFF
        err = readTIFF(select_img,false);
    else if (ext_name.contains("spe"))//SPE
        err = readSPE(select_img,false);
    else if (ext_name.contains("jpg"))//SPE
        err = readJPEG(select_img);
    else if (ext_name.contains("hdf") || ext_name.contains("h5"))//SPE
        err = readHDF5(select_img);
    else
        err = readSPIDER(select_img);

    // Negative errors are bad.
    return err;
}

_readBatch()

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

protected

Definition at line 894 of file xmipp_image_base.cpp.

{

    int err = 0;
    dataMode = datamode;

    // If MultidimArray pointer has been moved to a slice/image 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 Image has been previously used with mmap, then close the previous file
    if (mappedSize != 0)
        munmapFile();

    // Check whether to map the data or not
#ifdef XMIPP_MMAP

    mmapOnRead = mapData;
#endif

    const auto &ext_name = hFile->ext_name;
    fimg = hFile->fimg;
    fhed = hFile->fhed;
    tif  = hFile->tif;
    fhdf5 = hFile->fhdf5;

    filename = name;
    dataFName = hFile->fileName;


    //Just clear the header before reading
    MDMainHeader.clear();
    //Set the file pointer at beginning
    if (fimg != NULL)
        fseek(fimg, 0, SEEK_SET);
    if (fhed != NULL)
        fseek(fhed, 0, SEEK_SET);

    if (ext_name.contains("spi") || ext_name.contains("xmp")  ||
        ext_name.contains("stk") || ext_name.contains("vol")) {
        err = readSPIDER(start_img, batch_size);
    } else if (isMRCStack(ext_name)) { //mrc stack MUST go BEFORE plain MRC
        err = readMRC(start_img, batch_size, true);
    } else if (isMRCImageOrVolume(ext_name)) {//mrc
        err = readMRC(start_img, batch_size, false);
    } else {
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "Reading of a range of files is implemented only for SPIDER and MRC stack.");
    }

    // Negative errors are bad.
    return err;
}

_write()

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

protected

Internal write image file method.

Datatype info must be from filename after "%" symbol

If we are going to changes all images, then swap of the file may be changed, otherwise, original swap remains.

Definition at line 950 of file xmipp_image_base.cpp.

{
    // Temporary Error to find old select_img == -1
    if (select_img == (size_t) -1)
        REPORT_ERROR(ERR_DEBUG_TEST, "To select all images use ALL_IMAGES macro, or FIRST_IMAGE macro.");

    int err = 0;

    // if image is mapped to file then close the file and clear
    if (mmapOnWrite && mappedSize > 0)
    {
        munmapFile();
        return;
    }

    filename = name;
    dataFName = hFile->fileName;
    _exists = hFile->exist;
    fimg = hFile->fimg;
    fhed = hFile->fhed;
    tif  = hFile->tif;

    FileName ext_name = hFile->ext_name;

    size_t aux;
    FileName filNamePlusExt;
    name.decompose(aux, filNamePlusExt);

    if (select_img == ALL_IMAGES)
        select_img = aux;

    size_t found = filNamePlusExt.find_first_of("%");
    String imParam = "";
    if (found!=String::npos)
    {
        imParam =  filNamePlusExt.substr(found+1).c_str();
        filNamePlusExt = filNamePlusExt.substr(0, found) ;
    }

    // #define DEBUG
#ifdef DEBUG

    std::cerr << "write" <<std::endl;
    std::cerr<<"extension for write= "<<ext_name<<std::endl;
    std::cerr<<"filename= "<<filename<<std::endl;
    std::cerr<<"mode= "<<mode<<std::endl;
    std::cerr<<"isStack= "<<isStack<<std::endl;
    std::cerr<<"select_img= "<<select_img<<std::endl;
    std::cerr << "exists=" << _exists << std::endl;
#endif
#undef DEBUG
    // Check that image is not empty
    if (getSize() < 1)
        REPORT_ERROR(ERR_MULTIDIM_EMPTY,(String)"write Image ERROR: image "+name+" is empty!");

    replaceNsize = 0;//reset replaceNsize in case image is reused
    if(isStack && select_img == ALL_IMAGES && mode == WRITE_REPLACE)
        REPORT_ERROR(ERR_VALUE_INCORRECT,"Please specify object to be replaced");
    else if (_exists && (mode == WRITE_REPLACE || mode == WRITE_APPEND))
    {
        // CHECK FOR INCONSISTENCIES BETWEEN data.xdim and x, etc???
        size_t Xdim, Ydim, Zdim, _Xdim, _Ydim, _Zdim, Ndim, _Ndim;
        Xdim = Ydim = Zdim = _Xdim = _Ydim = _Zdim = Ndim = _Ndim = 0;
        if (nullptr == m_auxI) {
            m_auxI = new Image<char>();
        }
        m_auxI->_read(filNamePlusExt, hFile, HEADER, ALL_IMAGES);

        this->getDimensions(Xdim, Ydim, Zdim, Ndim);
        m_auxI->getDimensions(_Xdim, _Ydim, _Zdim, _Ndim);

        if(m_auxI->getSize()>1)
        {
            replaceNsize = _Ndim;

            if (select_img > ALL_IMAGES || Ndim < replaceNsize)
                swapWrite = m_auxI->swap;

            if(Xdim != _Xdim ||
               Ydim != _Ydim ||
               Zdim != _Zdim)
            {
                REPORT_ERROR(ERR_MULTIDIM_SIZE,formatString(
                                 "ImageBase::Write: images source and target have different sizes:\n"
                                 "Image source to be written (x,y,z,n) = %d %d %d %lu\n"
                                 "Image file target %s (x,y,z,n) = %d %d %d %lu",
                                 Xdim,Ydim,Zdim,Ndim,dataFName.c_str(),_Xdim,_Ydim,_Zdim,_Ndim));
            }
        }
    }
    else if(!_exists && mode == WRITE_APPEND)
    {
        ;
    }
    else if (mode == WRITE_READONLY)//If new file we are in the WRITE_OVERWRITE mode
    {
        REPORT_ERROR(ERR_ARG_INCORRECT, formatString("File %s  opened in read-only mode. Cannot write.", name.c_str()));
    }

    /*
     * SELECT FORMAT
     */
    //Set the file pointer at beginning
    if (fimg != NULL)
        fseek(fimg, 0, SEEK_SET);
    if (fhed != NULL)
        fseek(fhed, 0, SEEK_SET);

    if(ext_name.contains("spi") || ext_name.contains("xmp") ||
       ext_name.contains("vol"))
        err = writeSPIDER(select_img,isStack,mode);
    else if (ext_name.contains("stk"))
        err = writeSPIDER(select_img,true,mode);
    else if (isMRCStack(ext_name) || isMRCImageOrVolume(ext_name))
        writeMRC(select_img,isStack,mode,imParam,castMode);
    else if (ext_name.contains("img") || ext_name.contains("hed"))
        writeIMAGIC(select_img,mode,imParam,castMode);
    else if (ext_name.contains("dm3"))
        writeDM3(select_img,false,mode);
    else if (ext_name.contains("dm4"))
        writeDM4(select_img,false,mode);
    else if (ext_name.contains("em"))
        writeEM(select_img,false,mode);
    else if (ext_name.contains("pif"))
        writePIF(select_img,false,mode);
    else if (ext_name.contains("ser"))
        writeTIA(select_img,false,mode);
    else if (ext_name.contains("raw") || ext_name.contains("inf"))
        writeINF(select_img,false,mode,imParam,castMode);
    else if (ext_name.contains("tif"))
        writeTIFF(select_img,isStack,mode,imParam,castMode);
    else if (ext_name.contains("spe"))
        writeSPE(select_img,isStack,mode);
    else if (ext_name.contains("jpg"))
        writeJPEG(select_img, false, WRITE_OVERWRITE, "", CW_ADJUST);
    else if (ext_name.contains("hdf5") || ext_name.contains("h5"))
        writeHDF5(select_img);
    else
        err = writeSPIDER(select_img,isStack,mode);

    if ( err < 0 )
    {
        std::cerr << " Filename = " << filename << " Extension= " << ext_name << std::endl;
        REPORT_ERROR(ERR_IO_NOWRITE, "Error writing file");
    }

    /* If initially the file did not existed, once the first image is written,
     * then the file exists
     */
    if (!_exists)
        hFile->exist = _exists = true;
}

applyGeo() [1/2]

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

Apply geometry in referring metadata to the image

Definition at line 246 of file xmipp_image_base.cpp.

{
    std::unique_ptr<const MDRow> row(md.getRow(objId));
    applyGeo(*row, params.only_apply_shifts, params.wrap);
}

applyGeo() [2/2]

virtual void ImageBase::applyGeo ( const MDRow &  row, bool  only_apply_shifts = false, bool  wrap = xmipp_transformation::WRAP  )

protectedpure virtual

Internal apply geometrical transformations

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

checkMmapT()

virtual bool ImageBase::checkMmapT ( DataType  datatype )

pure virtual

Check file Datatype is same as T type to use mmap.

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

clear()

virtual void ImageBase::clear ( )

pure virtual

Clear. Initialize everything to 0

Implemented in ImageOver, Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

clearHeader()

void ImageBase::clearHeader

(

)

Clear the header of the image

Definition at line 109 of file xmipp_image_base.cpp.

{
    MDMainHeader.clear();
    MD.clear();
    //Just to ensure there is an empty MDRow
    MD.push_back(std::unique_ptr<MDRow>(new MDRowVec(MDMainHeader)));
}

closeFile()

void ImageBase::closeFile ( ImageFHandler *  hFile = NULL ) const

protected

Close file function. Close the image file according to its name and file handler.

Definition at line 707 of file xmipp_image_base.cpp.

{
    FileName ext_name, fileName;
    FILE* fimg, *fhed;
    TIFF* tif;
    hid_t fhdf5;

    if (hFile != NULL)
    {
        fileName = hFile->fileName;
        ext_name = hFile->ext_name;
        fimg = hFile->fimg;
        fhed = hFile->fhed;
        tif  = hFile->tif;
        fhdf5 = hFile->fhdf5;
    }
    else
    {
        fileName = filename;
        ext_name = filename.getFileFormat();
        fimg = this->fimg;
        fhed = this->fhed;
        tif  = this->tif;
        fhdf5 = this->fhdf5;

    }

    if (ext_name.contains("tif"))
    {
        TIFFClose(tif);
        /* Since when creating a TIFF file without adding an image the file is 8 bytes
         * and this same file returns an error when trying to open again, we are going
         * to suppose that under 8 bytes this is empty.
        */
        if (fileName.getFileSize() < 9)
            filename.deleteFile();
    }
    else if (ext_name.contains("hdf") || ext_name.contains("h5"))
    {
        H5Fclose(fhdf5);
        if (fclose(fimg) != 0 )
            REPORT_ERROR(ERR_IO_NOCLOSED,(String)"Can not close image file "+ filename);
    }
    else
    {
        if (fclose(fimg) != 0 )
            REPORT_ERROR(ERR_IO_NOCLOSED,(String)"Can not close image file "+ filename);

        if (fhed != NULL &&  fclose(fhed) != 0 )
            REPORT_ERROR(ERR_IO_NOCLOSED,(String)"Can not close header file of "
                         + filename);
    }
    delete hFile;
}

copy()

void ImageBase::copy

(

const ImageBase &

other

)

Copy. Copy ImageBase from other image

Definition at line 70 of file xmipp_image_base.cpp.

                                           {
    MDMainHeader = other.MDMainHeader;
    MD.clear();
    MD.reserve(other.MD.size());
    if ((other.MD.size() > 0) && (dynamic_cast<MDRowVec*>(other.MD[0].get()) != nullptr)) {
        for (const std::unique_ptr<MDRow>& rowPtr : other.MD) {
            const MDRow& row = *rowPtr;
            MD.emplace_back(std::unique_ptr<MDRow>(new MDRowVec(dynamic_cast<const MDRowVec&>(row))));
        }
    }
    if ((other.MD.size() > 0) && (dynamic_cast<MDRowSql*>(other.MD[0].get()) != nullptr)) {
        for (const std::unique_ptr<MDRow>& rowPtr : other.MD) {
            const MDRow& row = *rowPtr;
            MD.emplace_back(std::unique_ptr<MDRow>(new MDRowSql(dynamic_cast<const MDRowSql&>(row))));
        }
    }

    filename = other.filename;
    tempFilename = other.tempFilename;
    dataFName = other.dataFName;
    fimg = other.fimg;
    fhed = other.fhed;
    tif = other.tif;
    hFile = other.hFile;
    aDimFile = other.aDimFile;
    offset = other.offset;
    swap = other.swap;
    swapWrite = other.swapWrite;
    transform = other.transform;
    replaceNsize = other.replaceNsize;
    _exists = other._exists;
    mmapOnRead = other.mmapOnRead;
    mmapOnWrite = other.mmapOnWrite;
    mFd = other.mFd;
    mappedSize = other.mappedSize;
    mappedOffset = other.mappedOffset;
    virtualOffset = other.virtualOffset;
}

datatype()

DataType ImageBase::datatype

(

)

const

Get datatype info from MDMainHeader.

In theory, it must be the image file data type.

std::cout << "datatype= " << datatype() << std::endl;

Data type

std::cout << "datatype= " << dataType() << std::endl;

Definition at line 483 of file xmipp_image_base.cpp.

{
    int dummy;
    MDMainHeader.getValue(MDL_DATATYPE, dummy);
    return (DataType)dummy;
}

flip()

bool ImageBase::flip

(

const size_t

n = 0

)

const

Get Flip

std::cout << "flip= " << flip() << std::endl;

Definition at line 470 of file xmipp_image_base.cpp.

{
    bool dummy = false;
    MD[n]->getValue(MDL_FLIP, dummy);
    return dummy;
}

getCastConvertPageFromT()

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

protectedpure virtual

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

getDimensions() [1/3]

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

Get dimensions of the multidimArray inside image. TODO: This method must be changed to return the size of the image read from file, i.e. aDimFile, and where this is used should be used the imageBase::mda->getDimensions instead.

Definition at line 544 of file xmipp_image_base.cpp.

{
    Xdim = XSIZE(*mdaBase);
    Ydim = YSIZE(*mdaBase);
    Zdim = ZSIZE(*mdaBase);
    Ndim = NSIZE(*mdaBase);
}

getDimensions() [2/3]

void ImageBase::getDimensions ( ArrayDim &  aDim )

inline

Get Image dimensions

Definition at line 513 of file xmipp_image_base.h.

    {
        aDim = aDimFile;
    }

getDimensions() [3/3]

ArrayDim ImageBase::getDimensions ( )

inline

Definition at line 517 of file xmipp_image_base.h.

    {
        return aDimFile;
    }

getEulerAngles()

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

Get Euler angles from image header

Definition at line 519 of file xmipp_image_base.cpp.

{
    MD[n]->getValue(MDL_ANGLE_ROT, rot);
    MD[n]->getValue(MDL_ANGLE_TILT, tilt);
    MD[n]->getValue(MDL_ANGLE_PSI, psi);
}

getGeometry()

MDRow& ImageBase::getGeometry ( const size_t  n = 0 )

inline

Return geometry row

Definition at line 551 of file xmipp_image_base.h.

    {
        return *MD[n];
    }

getInfo() [1/2]

void ImageBase::getInfo

(

ImageInfo &

imgInfo

)

const

Get basic information from already read image file

Get Image dimensions

Definition at line 554 of file xmipp_image_base.cpp.

{
    imgInfo.filename = filename;
    imgInfo.offset = offset;
    imgInfo.datatype = datatype();
    imgInfo.swap = getSwap() > 0;
    imgInfo.adim = aDimFile ;
}

getInfo() [2/2]

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

Get basic information from image file

Definition at line 563 of file xmipp_image_base.cpp.

{
    read(name, HEADER);
    getInfo(imgInfo);
}

getOffsetAndSwap()

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

inline

Get Image offset and swap

Definition at line 536 of file xmipp_image_base.h.

    {
        _offset = offset;
        _swap = swap;
    }

getPageFromT()

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

protectedpure virtual

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

getPreview()

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

pure 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.

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

getScale()

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

inline

Get scale from image header

Definition at line 756 of file xmipp_image_base.h.

    {
        MD[n]->getValue(MDL_SCALE, scale);
    }

getShifts()

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

Get origin offsets from image header

Definition at line 537 of file xmipp_image_base.cpp.

{
    MD[n]->getValue(MDL_SHIFT_X, xoff);
    MD[n]->getValue(MDL_SHIFT_Y, yoff);
    MD[n]->getValue(MDL_SHIFT_Z, zoff);
}

getSize()

virtual size_t ImageBase::getSize ( ) const

pure virtual

Get whole number of pixels

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

getSwap()

int ImageBase::getSwap ( ) const

inline

Get Image swap

Definition at line 544 of file xmipp_image_base.h.

    {
        return swap;
    }

getTransformationMatrix()

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

pure virtual

Get geometric transformation matrix from 2D-image header

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

individualContainsLabel()

bool ImageBase::individualContainsLabel ( MDLabel  label ) const

inline

Definition at line 562 of file xmipp_image_base.h.

    {
        return (!MD.empty() && MD[0]->containsLabel(label));
    }

init()

void ImageBase::init

(

void

)

Init. Initialize everything to 0

Definition at line 50 of file xmipp_image_base.cpp.

{
    clearHeader();

    filename = tempFilename = dataFName = "";
    fimg = fhed = NULL;
    hFile = NULL;
    tif = NULL;
    dataMode = DATA;
    transform = isComplexT() ? Standard : NoTransform;
    filename.clear();
    offset = 0;
    swap = swapWrite = 0;
    replaceNsize = 0;
    _exists = mmapOnRead = mmapOnWrite = false;
    mFd        = 0;
    mappedSize = mappedOffset = virtualOffset = 0;
    m_auxI = nullptr;
}

initGeometry()

void ImageBase::initGeometry

(

const size_t

n = 0

)

Init geometry transformation with defaults values

Definition at line 39 of file xmipp_image_base.cpp.

{
    MDL::emptifyHeader(*MD[n]);
}

isComplex()

bool ImageBase::isComplex ( ) const

inline

Check whether image is complex based on transform

Definition at line 294 of file xmipp_image_base.h.

    {
        return !(transform==NoTransform);
    }

isComplexImage()

bool ImageBase::isComplexImage ( const FileName &  name )

inline

Is this file a complex image

Check whether a fourier-space (complex) image can be read

Definition at line 327 of file xmipp_image_base.h.

    {
        return (isImage(name) && isComplex());
    }

isComplexT()

virtual bool ImageBase::isComplexT ( ) const

pure virtual

Check whether image is complex based on T

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

isImage()

bool ImageBase::isImage

(

const FileName &

name

)

Is this file an image

Check whether a real-space image can be read

Definition at line 1107 of file xmipp_image_base.cpp.

{
    try
    {
        return !read(name, HEADER);
    }
    catch (XmippError &xe)
    {
        return false;
    }
}

isMapped()

bool ImageBase::isMapped ( )

inline

Check if image is mapped on file

Definition at line 309 of file xmipp_image_base.h.

    {
        return (mmapOnRead || mmapOnWrite);
    }

isRealImage()

bool ImageBase::isRealImage ( const FileName &  name )

inline

Is this file a real-valued image

Check whether a real-space image can be read

Definition at line 318 of file xmipp_image_base.h.

    {
        return (isImage(name) && !isComplex());
    }

mainContainsLabel()

bool ImageBase::mainContainsLabel ( MDLabel  label ) const

inline

Definition at line 568 of file xmipp_image_base.h.

    {
        return MDMainHeader.containsLabel(label);
    }

mapFile2Write()

void ImageBase::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
	)

Create a mapped image file

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. The image object must be cleared prior to use this method.

New mapped file

If XMIPP_MMAP is not defined this function is supposed to create the empty file only

Definition at line 202 of file xmipp_image_base.cpp.

{
#ifdef XMIPP_MMAP
    mmapOnWrite = true;
#endif

    setDimensions(Xdim, Ydim, Zdim, 1); // Images with Ndim >1 cannot be mapped to image file
    MD.resize(1);
    filename = _filename;
    FileName fnToOpen;
    if (createTempFile)
    {
        tempFilename.initUniqueName("temp_XXXXXX");
        fnToOpen = tempFilename + ":" + _filename.getExtension();
    }
    else
        fnToOpen=_filename;

    /* If the filename is in stack or an image is selected, we will suppose
     * you want to write this, even if you have not set the flags to.
     */
    if ( (filename.isInStack() || select_img > ALL_IMAGES) && mode == WRITE_OVERWRITE)
    {
        isStack = true;
        mode = WRITE_REPLACE;
    }

    hFile = openFile(fnToOpen, mode);
    _write(filename, hFile, select_img, isStack, mode);
    closeFile(hFile);
}

mirrorY()

virtual void ImageBase::mirrorY ( )

pure virtual

flip multidim array around X axis

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

mmapFile()

virtual void ImageBase::mmapFile ( )

protectedpure virtual

Mmap the Image class to an image file.

movePointerTo()

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

pure virtual

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.

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

munmapFile()

virtual void ImageBase::munmapFile ( )

protectedpure virtual

Munmap the image file.

myT()

virtual DataType ImageBase::myT ( ) const

pure virtual

name()

const FileName& ImageBase::name ( ) const

inline

Get file name

std::cout << "Image name = " << I.name() << std::endl;

Definition at line 500 of file xmipp_image_base.h.

    {
        return filename;
    }

openFile()

ImageFHandler * ImageBase::openFile ( const FileName &  name, int  mode = WRITE_READONLY  ) const

protected

---

Open file function Open the image file and returns its file hander.

Definition at line 572 of file xmipp_image_base.cpp.

{
    if (name.empty())
        REPORT_ERROR(ERR_PARAM_INCORRECT, "ImageBase::openFile Cannot open an empty Filename.");

    ImageFHandler* hFile = new ImageFHandler;
    FileName fileName, headName = "";
    FileName ext_name = name.getFileFormat();

    // Remove image number and block name
    fileName = name.removeAllPrefixes();

    fileName = fileName.removeFileFormat();

    size_t found = fileName.find_first_of("%");
    if (found!=String::npos)
        fileName = fileName.substr(0, found) ;

     bool exist = fileName.exists();
     bool sizeZero = true;

     if (exist)
         sizeZero = fileName.getFileSize() <= 0;
    hFile->exist = exist && !sizeZero;
    hFile->mode = mode;

    String wmChar;

    switch (mode)
    {
    case WRITE_READONLY:
        if (!exist)
          REPORT_ERROR(ERR_IO_NOTEXIST, formatString("Cannot access file '%s'. It doesn't exist", name.c_str()));
        else if (sizeZero)
          REPORT_ERROR(ERR_IO_SIZE, formatString("Cannot read zero size file '%s'.", name.c_str()));

        wmChar = "r";
        break;
    case WRITE_OVERWRITE:
        wmChar = "w";
        break;
    case WRITE_APPEND:
    case WRITE_REPLACE:
        wmChar = (hFile->exist) ? "r+" : "w+";
        break;

    }

    if (ext_name.contains("tif"))
    {
        TIFFSetWarningHandler(NULL); // Switch off warning messages
        if ((hFile->tif = TIFFOpen(fileName.c_str(), wmChar.c_str())) == NULL)
            REPORT_ERROR(ERR_IO_NOTOPEN,"rwTIFF: There is a problem opening the TIFF file.");
        hFile->fimg = NULL;
        hFile->fhed = NULL;
    }
    else if (ext_name.contains("hdf") || ext_name.contains("h5"))
    {
        if ((hFile->fhdf5 = H5Fopen(fileName.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT)) == -1 )
            REPORT_ERROR(ERR_IO_NOTOPEN,"ImageBase::openFile: There is a problem opening the HDF5 file.");
        //        hFile->fimg = NULL;

        if ( (hFile->fimg = fopen(fileName.c_str(), wmChar.c_str())) == NULL )
        {
            if (errno == EACCES)
                REPORT_ERROR(ERR_IO_NOPERM,formatString("Image::openFile: permission denied when opening %s",fileName.c_str()));
            else
                REPORT_ERROR(ERR_IO_NOTOPEN,formatString("Image::openFile cannot open: %s", fileName.c_str()));
        }

        hFile->fhed = NULL;
        hFile->tif = NULL;
    }
    else
    {
        hFile->tif = NULL;

        if (ext_name.contains("img") || ext_name.contains("hed"))
        {
            fileName = fileName.withoutExtension();
            headName = fileName.addExtension("hed");
            fileName = fileName.addExtension("img");
        }
        else if (ext_name.contains("raw"))
        {
            if (mode != WRITE_READONLY || fileName.addExtension("inf").exists() )
            {
                headName = fileName.addExtension("inf");
                ext_name = "inf";
            }
            else
                ext_name = "raw";
        }
        else if (ext_name.contains("inf"))
        {
            headName = fileName;
            fileName = fileName.withoutExtension();
            ext_name = "inf";
        }

        // Open image file
        if ( (hFile->fimg = fopen(fileName.c_str(), wmChar.c_str())) == NULL )
        {
            if (errno == EACCES)
                REPORT_ERROR(ERR_IO_NOPERM,formatString("Image::openFile: permission denied when opening %s",fileName.c_str()));
            else
                REPORT_ERROR(ERR_IO_NOTOPEN,formatString("Image::openFile cannot open: %s", fileName.c_str()));
        }


        if (headName != "")
        {
            if ((hFile->fhed = fopen(headName.c_str(), wmChar.c_str()))  == NULL )
            {
                if (errno == EACCES)
                    REPORT_ERROR(ERR_IO_NOPERM,formatString("Image::openFile: permission denied when opening %s",headName.c_str()));
                else
                    REPORT_ERROR(ERR_IO_NOTOPEN,formatString("Image::openFile cannot open: %s",headName.c_str()));
            }

        }
        else
            hFile->fhed = NULL;

    }
    hFile->fileName = fileName;
    hFile->headName = headName;
    hFile->ext_name = ext_name;

    return hFile;
}

psi()

double ImageBase::psi

(

const size_t

n = 0

)

const

Get Psi angle

std::cout << "Third Euler angle " << I.psi() << std::endl;

Definition at line 391 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_ANGLE_PSI, dummy);
    return dummy;
}

read()

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

General read function you can read a single image from a single image file or a single image file from an stack, in the second case the select slide may come in the image name or in the select_img parameter file name takes precedence over select_img If ALL_IMAGES is given the whole object is read.

Parameter mapData allows to access to image mapped to disk instead of loaded into memory. In case the mapped image is intended to be modified the parameter mode must be WRITE_REPLACE.

This function cannot apply geometrical transformations.

General read function

Definition at line 119 of file xmipp_image_base.cpp.

{
    if (!mapData)
        mode = WRITE_READONLY; //TODO: Check if openfile other than readonly is necessary

    hFile = openFile(name, mode);
    int err = _read(name, hFile, datamode, select_img, mapData);
    closeFile(hFile);
    return err;
}

readApplyGeo() [1/3]

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

General read function you can read a single image from a single image file or a single image file from an stack, in the second case the select slide may come in the image name or in the select_img parameter file name takes precedence over select_img If -1 is given the whole object is read

This function can apply geometrical transformations, but cannot map the image in disk

Definition at line 264 of file xmipp_image_base.cpp.

{
    ImageFHandler* hFile = openFile(name);
    int err = _read(name, hFile, params.datamode, params.select_img);
    applyGeo(row, params.only_apply_shifts, params.wrap);
    closeFile(hFile);
    return err;
}

readApplyGeo() [2/3]

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

Read an image from metadata, filename is provided

Definition at line 275 of file xmipp_image_base.cpp.

{
    std::unique_ptr<const MDRow> row(md.getRow(objId));
    READ_AND_RETURN();
}

readApplyGeo() [3/3]

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

Read an image from metadata, filename is taken from MDL_IMAGE

Definition at line 283 of file xmipp_image_base.cpp.

{
    std::unique_ptr<const MDRow> row(md.getRow(objId));
    FileName name;
    row->getValue(MDL_IMAGE, name);
    READ_AND_RETURN();
}

readBatch()

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

Reads batch_size images from a single image file starting from image with index start_img. If batch_size == ALL_IMAGES, then all images starting from start_img to last image are read.

Definition at line 131 of file xmipp_image_base.cpp.

{
    if (!mapData) {
        mode = WRITE_READONLY;
    }

    hFile = openFile(name, mode);
    int err = _readBatch(name, hFile, start_img, batch_size, datamode, mapData);
    closeFile(hFile);
    return err;
}

readData()

virtual void ImageBase::readData ( FILE *  fimg, size_t  select_img, DataType  datatype, size_t  pad  )

protectedpure virtual

Read the raw data

readData4bit()

virtual void ImageBase::readData4bit ( FILE *  fimg, size_t  select_img, DataType  datatype, size_t  pad  )

protectedpure virtual

Read the raw data in MRC 4bit mode

readEER()

int ImageBase::readEER ( size_t  select_img )

protected

Definition at line 569 of file rwEER.cpp.

                                        {
    int upsampling = 1;
    StringVector info;
    DataType datatype;
    size_t found = filename.find_first_of("#");
    FileName infolist = filename.substr(found + 1);
    filename = filename.substr(0, found);
    infolist.toLowercase();
    splitString(infolist, ",", info, false);

    if (info.size() < 3)
            REPORT_ERROR(ERR_ARG_MISSING, (String) "Cannot open file " + filename +
                                        ". Not enough header arguments.");

    const int fractioning = std::atoi(info[0].c_str());
    if (fractioning < 1)
    {
        REPORT_ERROR(ERR_PARAM_INCORRECT, "Incorrect fractioning value (must be greater than zero)");
    }
    if (select_img > fractioning) {
        REPORT_ERROR(ERR_PARAM_INCORRECT, (String) "Incorrect frame number selected (" + std::to_string(select_img) + "). Number of frames is " + std::to_string(fractioning) + ".");
    }

    int _xDim,_yDim,_zDim;
    size_t _nDim;
    if (info[1] == "4K")
    {
        _xDim = _yDim = 4096;
    } 
    else if (info[1] == "8K")
    {
        _xDim = _yDim = 8192;
    }
    else {
        REPORT_ERROR(ERR_PARAM_INCORRECT, "Incorrect output size. Valid sizes are: 4K, 8K.");
    }

    _zDim = _nDim = 1;
    setDimensions(_xDim, _yDim, _zDim, _nDim);
    mdaBase->coreAllocateReuse();

  if(info[2] == "uint8")
        datatype = DT_UChar;
    else if (info[2] == "uint16")
        datatype = DT_UShort;
    else
        REPORT_ERROR(ERR_PARAM_INCORRECT, "Incorrect output data type. Valid types are: uint8, uint16.");
    
    MDMainHeader.setValue(MDL_SAMPLINGRATE_X,(double) -1);
    MDMainHeader.setValue(MDL_SAMPLINGRATE_Y,(double) -1);
    MDMainHeader.setValue(MDL_DATATYPE,(int)datatype);

    MD.clear();
    MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));

    if( dataMode < DATA )
        return 0;

    EERRenderer renderer;
    renderer.read(hFile->fileName, upsampling);

    MultidimArray<int> buffer(_yDim, _xDim);
    const auto step = renderer.getNFrames() / fractioning;
    const auto first = (select_img-1)*step;
    const auto last = first + step - 1;
    renderer.renderFrames(first, last, buffer);
    setPage2T(
        0UL, reinterpret_cast<char*>(MULTIDIM_ARRAY(buffer)),
        DT_Int,
        MULTIDIM_SIZE(buffer)
    );

    return 0;
}

readEM()

int ImageBase::readEM ( size_t  select_img, bool  isStack = false  )

protected

Read image from EM file format

Parameters

select_img

Index number of selected image

Returns

Definition at line 33 of file rwEM.cpp.

{
    // EM File formats does not support stacks
    if (select_img > FIRST_IMAGE & !isStack)
        REPORT_ERROR(ERR_ARG_INCORRECT, "readEM: EM file format does not support stacks.");

    EMHead header;

    if ( fread( &header, EMHEADERSIZE, 1, fimg ) != 1 )
        REPORT_ERROR(ERR_IO_NOREAD, formatString("rwEM: cannot read EM main header from file %s"
                     ". Error message: %s", filename.c_str() ,strerror(errno)));

    // endian: If machine is SGI, OS-9 or MAC: Big Endian, otherwise Litle Endian
    // Check Machine endianess
    bool isLE = IsLittleEndian();

    if (header.machine == 0 || header.machine == 3 || header.machine == 5)
        swap = isLE;
    else if (header.machine == 1 || header.machine == 2 || header.machine == 4 || header.machine == 6)
        swap = !isLE;
    else
        REPORT_ERROR(ERR_IMG_UNKNOWN, "rwEM: Unknown source machine to determine Endianness");

    if (swap)
        swapPage((char *) &header, EMHEADERSIZE - 256, DT_UInt); // EMHEADERSIZE - 256 is to exclude userdata from swapping

    // Setting image dimensions

    ArrayDim aDim;
    if (isStack)
    {
        if ( select_img > header.zdim )
            REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, formatString("readEM: %s Image number %lu exceeds stack size %lu", this->filename.c_str(), select_img, header.zdim));

        aDim.ndim = (select_img > ALL_IMAGES)? 1 : header.zdim;
        aDim.zdim = 1;
    }
    else
    {
        aDim.ndim = 1;
        aDim.zdim = header.zdim;
    }

    aDim.xdim = header.xdim;
    aDim.ydim= header.ydim;

    replaceNsize = aDim.ndim;
    setDimensions(aDim);


    DataType datatype;
    switch (header.datatype)
    {
    case 1:
        datatype = DT_SChar;
        break;
    case 2:
        datatype = DT_Short;
        break;
    case 4:
        datatype = DT_Int;
        break;
    case 3:
    case 5:
        datatype = DT_Float;
        break;
    case 8:
        datatype = DT_CFloat;
        break;
    case 9:
        datatype = DT_CDouble;
        break;
    default:
        REPORT_ERROR(ERR_ARG_INCORRECT, formatString("readEM: Unknown datatype value: %c", header.datatype));
        break;
    }
    MDMainHeader.setValue(MDL_DATATYPE,(int)datatype);

    offset = EMHEADERSIZE;

    // If only header is read: return
    if (dataMode==HEADER || (dataMode == _HEADER_ALL && aDim.ndim > 1)) // Stop reading if not necessary
        return 0;

    size_t   imgStart = IMG_INDEX(select_img);
    size_t   imgEnd = (select_img != ALL_IMAGES) ? imgStart + 1 : aDim.ndim;

    MD.clear();
    for (size_t i = 0; i < imgEnd-imgStart; i++)
        MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));

    /* As MRC does not support stacks, we use the geometry stored in the header
    for any image when we simulate the file is a stack.*/
    if (dataMode == _HEADER_ALL || dataMode == _DATA_ALL)
    {
        for ( size_t i = 0; i < imgEnd - imgStart; ++i )
        {
            MD[i]->setValue(MDL_SHIFT_X, 0.);
            MD[i]->setValue(MDL_SHIFT_Y, 0.);
            MD[i]->setValue(MDL_SHIFT_Z, 0.);
            MD[i]->setValue(MDL_ORIGIN_X, 0.);
            MD[i]->setValue(MDL_ORIGIN_Y, 0.);
            MD[i]->setValue(MDL_ORIGIN_Z, 0.);
        }
    }

    if ( dataMode < DATA )   // Don't read the individual header and the data if not necessary
        return 0;

    readData(fimg, select_img, datatype, 0);

    return(0);
}

readJPEG()

int ImageBase::readJPEG ( size_t  select_img )

protected

Definition at line 34 of file rwJPEG.cpp.

{
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);

    jpeg_stdio_src(&cinfo, fimg);
    jpeg_read_header(&cinfo, TRUE);

    MDMainHeader.setValue(MDL_MIN,0.);
    MDMainHeader.setValue(MDL_MAX,0.);
    MDMainHeader.setValue(MDL_AVG,0.);
    MDMainHeader.setValue(MDL_STDDEV,0.);
    MDMainHeader.setValue(MDL_SAMPLINGRATE_X,1.);
    MDMainHeader.setValue(MDL_SAMPLINGRATE_Y,1.);
    MDMainHeader.setValue(MDL_SAMPLINGRATE_Z,1.);
    MDMainHeader.setValue(MDL_DATATYPE,(int) DT_UChar);

    ArrayDim aDim;
    aDim.xdim = cinfo.image_width;
    aDim.ydim = cinfo.image_height;
    aDim.zdim = 1;
    aDim.ndim = 1;

    setDimensions(aDim);

    replaceNsize = aDim.ndim;

    //Read header only
    if (dataMode == HEADER || (dataMode == _HEADER_ALL )) // Stop reading if not necessary
    {
        jpeg_destroy_decompress(&cinfo);
        return 0;
    }

    /* As we cannot mmap a TIFF File, when this option is passed we are going to mmap
     * the multidimarray of Image
     */

    if (mmapOnRead)
    {
        mmapOnRead = false;
        if (aDim.nzyxdim*gettypesize(DT_UChar) > tiff_map_min_size)
            mdaBase->setMmap(true);
    }

    // Allocate memory for image data (Assume xdim, ydim, zdim and ndim are already set
    //if memory already allocated use it (no resize allowed)
    mdaBase->coreAllocateReuse();

    MD.clear();
    for (size_t i = 0; i < aDim.ndim; i++)
        MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));

    /* Start decompression jpeg here */
    jpeg_start_decompress( &cinfo );

    /* allocate memory to hold the uncompressed image */
    char * buffer = new char [aDim.xdim];
    /* now actually read the jpeg into the raw buffer */
    JSAMPROW row_pointer[1];
    row_pointer[0] = new unsigned char [aDim.xdim*cinfo.num_components];
    /* read one scan line at a time */
    while( cinfo.output_scanline < cinfo.image_height )
    {
        jpeg_read_scanlines( &cinfo, row_pointer, 1 );
        for(size_t i=0; i<cinfo.image_width;i++)
            buffer[i] = row_pointer[0][i*cinfo.num_components];
        setPage2T((cinfo.output_scanline - 1)*cinfo.image_width, buffer, DT_UChar, aDim.xdim);
    }
    /* wrap up decompression, destroy objects, free pointers and close open files */
    jpeg_finish_decompress( &cinfo );
    jpeg_destroy_decompress( &cinfo );
    delete[] row_pointer[0];

    return 0;
}

readMapped()

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

Definition at line 156 of file xmipp_image_base.cpp.

{
    read(name, HEADER);
    bool swap = this->swap > 0;
    return read(name, DATA, select_img, !swap, mode);
}

readMRC()

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

protected

Definition at line 132 of file rwMRC.cpp.

{

#undef DEBUG
    //#define DEBUG
#ifdef DEBUG
    printf("DEBUG readMRC: Reading MRC file\n");
#endif

    std::unique_ptr< MRChead > header( new MRChead() );

    int errCode = 0;

    if ( fread( header.get(), MRCSIZE, 1, fimg ) < 1 )
        return(-2);

    // Determine byte order and swap bytes if from little-endian machine
    if ( (swap = (( abs( header->mode ) > SWAPTRIG ) || ( abs(header->nz) > SWAPTRIG ))) )
    {
#ifdef DEBUG
        fprintf(stderr, "Warning: Swapping header byte order for 4-byte types\n");
#endif

        swapPage((char *) header.get(), MRCSIZE - 800, DT_Float); // MRCSIZE - 800 is to exclude labels from swapping
    }

    // Convert VAX floating point types if necessary
    // if ( header->amin > header->amax )
    //    REPORT_ERROR(ERR_IMG_NOREAD,"readMRC: amin > max: VAX floating point conversion unsupported");

    size_t _xDim,_yDim,_zDim,_nDim;
    size_t _nDimSet;

    _xDim = header->nx;
    _yDim = header->ny;
    _zDim = header->nz;

    // Reading and storing axis order
    axisOrder[0] = 0;
    axisOrder[1] = 4 - header->maps;
    axisOrder[2] = 4 - header->mapr;
    axisOrder[3] = 4 - header->mapc;

    bool isVolStk = (header->ispg > 400);

    /* isStack is already true if file uses our customized "mrcs" extension. In this case
     * we ignore the stack behavior in header. If format is forced through ":" flag suffix,
     * then we also ignore the stack behavior in header */
    if ( !isStack && (isVolStk || !filename.contains(":")))
        isStack = ((header->ispg == 0 || isVolStk ) && (header->nsymbt == 0));

    // std::cout << "isStack = " << isStack << std::endl;

    if(isStack)
    {
        if (isVolStk)
        {
            _nDim = _zDim / header->mz;
            _zDim = header->mz;
        }
        else
        {
            _nDim = _zDim;// When isStack slices in Z are supposed to be a stack of images
            _zDim = 1;
        }

        if (batch_size == ALL_IMAGES) {
            _nDimSet = _nDim - start_img + 1;
        } else {
        _nDimSet = std::min( start_img + batch_size - 1, _nDim ) - start_img + 1;
        }


        if ( start_img > _nDim )
            REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, formatString("readMRC: %s Image number %lu exceeds stack size %lu", this->filename.c_str(), start_img, _nDim));

    }
    else // If the reading is not like a stack, then the select_img is not taken into account and must be selected the only image
    {
        start_img = 1;
        _nDim = 1;
        _nDimSet = 1;
    }

    DataType datatype;
    switch ( header->mode )
    {
    case 0:
        datatype = DT_UChar;
        break;
    case 1:
        datatype = DT_Short;
        break;
    case 2:
        datatype = DT_Float;
        break;
    case 3:
        datatype = DT_CShort;
        break;
    case 4:
        datatype = DT_CFloat;
        break;
    case 6:
        datatype = DT_UShort;
        break;
    case 12:
        datatype = DT_HalfFloat;
        break;
    case 101:
        datatype = DT_UHalfByte;
        break;

    default:
        datatype = DT_Unknown;
        errCode = -1;
        break;
    }

    replaceNsize = _nDim;
    setDimensions(_xDim, _yDim, _zDim, _nDimSet);


    offset = MRCSIZE + header->nsymbt;
    size_t datasize_n;
    datasize_n = _xDim*_yDim*_zDim;

    // If mode is any of the fourier transforms (3,4)
    if ( header->mode > 2 && header->mode < 5 )
    {
        transform = CentHerm;
        fseek(fimg, 0, SEEK_END);
        if ( ftell(fimg) > offset + 0.8*datasize_n*gettypesize(datatype) )
            _xDim = (2 * (_xDim - 1));
        if ( header->mx%2 == 1 )
            _xDim += 1;     // Quick fix for odd x-size maps
        setDimensions(_xDim, _yDim, _zDim, _nDim);
    }

    MDMainHeader.setValue(MDL_MIN,(double)header->amin);
    MDMainHeader.setValue(MDL_MAX,(double)header->amax);
    MDMainHeader.setValue(MDL_AVG,(double)header->amean);
    MDMainHeader.setValue(MDL_STDDEV,(double)header->arms);
    MDMainHeader.setValue(MDL_DATATYPE,(int)datatype);

    double sampling;
    MDMainHeader.getValueOrDefault(MDL_SAMPLINGRATE_X, sampling, 1.0);
    if ( header->mx && header->a!=0 && sampling == 1.0)//ux
        MDMainHeader.setValue(MDL_SAMPLINGRATE_X,(double)header->a/header->mx);
    MDMainHeader.getValueOrDefault(MDL_SAMPLINGRATE_Y, sampling, 1.0);
    if ( header->my && header->b!=0 && sampling == 1.0)//yx
        MDMainHeader.setValue(MDL_SAMPLINGRATE_Y,(double)header->b/header->my);
    MDMainHeader.getValueOrDefault(MDL_SAMPLINGRATE_Z, sampling, 1.0);
    if ( header->mz && header->c!=0 && sampling == 1.0)//zx
        MDMainHeader.setValue(MDL_SAMPLINGRATE_Z,(double)header->c/header->mz);

    if (dataMode==HEADER || (dataMode == _HEADER_ALL && _nDim > 1)) // Stop reading if not necessary
    {
        readData(NULL, 0, DT_Unknown, 0); // To consider axis ordering. Will not read actual data
        return errCode;
    }

    const size_t   imgStart = IMG_INDEX(start_img);
    const size_t   imgEnd = start_img + _nDimSet - 1;

    MD.clear();
    for (size_t i = 0; i < imgEnd-imgStart; i++)
        MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));

    /* As MRC does not support stacks, we use the geometry stored in the header
    for any image when we simulate the file is a stack.*/
    if (dataMode == _HEADER_ALL || dataMode == _DATA_ALL)
    {
        double aux;
        for ( size_t i = 0; i < imgEnd - imgStart; ++i )
        {
            MD[i]->setValue(MDL_SHIFT_X, (double) -header->nxStart);
            MD[i]->setValue(MDL_SHIFT_Y, (double) -header->nyStart);
            MD[i]->setValue(MDL_SHIFT_Z, (double) -header->nzStart);

            // We include auto detection of MRC2000 or CCP4 style origin based on http://situs.biomachina.org/fmap.pdf
            if (header->xOrigin != 0)
                MD[i]->setValue(MDL_ORIGIN_X, (double)-header->xOrigin);
            else if (header->nxStart != 0 && MDMainHeader.getValue(MDL_SAMPLINGRATE_X,aux))
                MD[i]->setValue(MDL_ORIGIN_X, -header->nxStart/aux);

            if (header->yOrigin !=0)
                MD[i]->setValue(MDL_ORIGIN_Y, (double)-header->yOrigin);
            else if(header->nyStart !=0 && MDMainHeader.getValue(MDL_SAMPLINGRATE_Y,aux))
                MD[i]->setValue(MDL_ORIGIN_Y, -header->nyStart/aux);

            if (header->zOrigin != 0)
                MD[i]->setValue(MDL_ORIGIN_Z, (double)-header->zOrigin);
            else if(header->nzStart !=0 && MDMainHeader.getValue(MDL_SAMPLINGRATE_Z,aux))
                MD[i]->setValue(MDL_ORIGIN_Z, -header->nzStart/aux);
        }
    }

    if ( dataMode < DATA )   // Don't read the individual header and the data if not necessary
    {
        readData(NULL, 0, DT_Unknown, 0); // To consider axis ordering. Will not read actual data
        return errCode;
    }

    // Lets read the data

    // 4-bits mode: Here is the magic to expand the compressed images
    if (datatype == DT_UHalfByte){
        readData4bit(fimg, start_img, datatype, 0);
    }
    else{
        readData(fimg, start_img, datatype, 0);
    }

    return errCode;
}

readOrReadMapped()

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

Definition at line 163 of file xmipp_image_base.cpp.

{
    try
    {
        return read(name, DATA, select_img, false, mode);
    }
    catch (XmippError &xe)
    {
        if (xe.__errno == ERR_MEM_NOTENOUGH)
        {
            reportWarning("ImageBase::readOrReadMapped: Not enough memory to allocate. \n"
                          " Proceeding to map image from file.");
            return readMapped(name, select_img, mode);
        }
        else
            throw xe;
    }
}

readOrReadPreview()

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

This function allows to read the original image or a preview of it also allowing to select either a specific image from the stack or a slice from a volume.

In the case of reading images in its real dimensions it is also possible to image map from file.

Definition at line 182 of file xmipp_image_base.cpp.

{
    read(name, HEADER);
    size_t imXdim, imYdim, imZdim, imNdim;
    getDimensions(imXdim, imYdim, imZdim, imNdim);

    if (imXdim != Xdim || imYdim != Ydim)
        return readPreview(name, Xdim, Ydim, select_slice, select_img);
    else
    {
        int ret = read(name, DATA, select_img, mapData);
        if (select_slice != ALL_SLICES)
            movePointerTo(select_slice);
        return ret;
    }

}

readPIF()

int ImageBase::readPIF ( size_t  select_img )

protected

Read image from PIF file format

Parameters

select_img

Index number of selected image

Returns

Definition at line 33 of file rwPIF.cpp.

{
    PIFMainHeader  mainHeader;
    if ( fread( &mainHeader, PIFHEADERSIZE, 1, fimg ) != 1 )
        REPORT_ERROR(ERR_IO_NOREAD, formatString("rwPIF: cannot read Spider main header from file %s"
                     ". Error message: %s", filename.c_str() ,strerror(errno)));

    // Check Machine endianness
    bool isLE = IsLittleEndian();

    // Determine byte order and swap bytes if from different-endian machine
    swap = (isLE == mainHeader.endianNess);

    if (swap)
        swapPage((char *) &mainHeader, PIFHEADERSIZE, DT_Int);


    DataType datatype;
    switch (mainHeader.mode)
    {
    case 0:
        datatype = DT_SChar;
        break;
    case 1:
    case 7: // Actually it's floatint*2, but it isn't moved to float
        datatype = DT_Short;
        break;
    case 2:
    case 46: // This case is not documented, but I think this is floatInt*4
        datatype = DT_Int; // We aren't moving to float actually
        break;
    case 3:
    case 8: // Actually it's complex floatint*2, but it isn't moved to float
        datatype = DT_CShort;
        break;
    case 4:
        datatype = DT_CInt; // We aren't moving to float actually
        break;
    case 9:
        datatype = DT_Float;
        break;
    case 10:
        datatype = DT_CFloat;
        break;
    case 97:
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "readPIF: Reading from colormap datatype file not implemented.\n"
                     "If you're interested in this feature, please contact us at xmipp@cnb.csic.es \n"
                     "and send us an example image file to help implementing.");
        break;
    default:
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, formatString("readPIF: Reading from datatype code %d file not implemented.\n"
                     "If you're interested in this feature, please contact us at xmipp@cnb.csic.es \n"
                     "and send us an example image file to help implementing.", mainHeader.mode));
        break;
    }
    MDMainHeader.setValue(MDL_DATATYPE,(int)datatype);


    // Check selected image
    if (select_img > (size_t)mainHeader.numImages)
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, formatString("readPIF (%s): Image number %lu exceeds stack size %lu" ,filename.c_str(),select_img, mainHeader.numImages));

    // Setting image dimensions
    ArrayDim aDim;

    aDim.ndim = (select_img == ALL_IMAGES)? mainHeader.numImages : 1;
    aDim.zdim = mainHeader.nz;
    aDim.ydim = mainHeader.ny;
    aDim.xdim = mainHeader.nx;

    replaceNsize = aDim.ndim;

    setDimensions(aDim);


    size_t imgStart = IMG_INDEX(select_img);
    size_t datatypeSize = gettypesize(datatype);
    offset = PIFHEADERSIZE*2;// + (aDimFile.zyxdim*datatypeSize + PIFHEADERSIZE)*imgStart;

    if (dataMode == HEADER || (dataMode == _HEADER_ALL && aDim.ndim > 1)) // Stop reading if not necessary
        return 0;

    size_t   imgEnd = (select_img != ALL_IMAGES) ? imgStart + 1 : aDim.ndim;

    size_t imageSize = PIFHEADERSIZE + aDimFile.zyxdim*datatypeSize;
    size_t pad       = PIFHEADERSIZE;
    size_t headerOffset  = PIFHEADERSIZE;

    MD.clear();
    for (size_t i = 0; i < imgEnd-imgStart; i++)
        MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));

    PIFDataHeader dataHeader;

    for (size_t n = 0, i = imgStart; i < imgEnd; ++i, ++n )
    {
        if (fseek( fimg, headerOffset + i*imageSize, SEEK_SET ) != 0)//fseek return 0 on success
            REPORT_ERROR(ERR_IO, formatString("rwPIF: error seeking %lu to read image %lu", headerOffset, i));

        if ( fread( &dataHeader, PIFHEADERSIZE, 1, fimg ) != 1 )
            REPORT_ERROR(ERR_IO_NOREAD, formatString("rwPIF: cannot read PIF image %lu header", i));

        if ( swap )
            swapPage((char *) &dataHeader, PIFHEADERSIZE, DT_Int);

        if (dataMode == _HEADER_ALL || dataMode == _DATA_ALL)
        {
            MD[n]->setValue(MDL_ORIGIN_X, (double)dataHeader.nxstart);
            MD[n]->setValue(MDL_ORIGIN_Y, (double)dataHeader.nystart);
            MD[n]->setValue(MDL_ORIGIN_Z, (double)dataHeader.nzstart);
            MD[n]->setValue(MDL_ANGLE_ROT, (double)dataHeader.alpha);
            MD[n]->setValue(MDL_ANGLE_TILT, (double)dataHeader.beta);
            MD[n]->setValue(MDL_ANGLE_PSI, (double)dataHeader.gamma);
            MD[n]->setValue(MDL_SAMPLINGRATE_X, (double)dataHeader.xlength/aDim.xdim);
            MD[n]->setValue(MDL_SAMPLINGRATE_Y, (double)dataHeader.ylength/aDim.ydim);
            MD[n]->setValue(MDL_SAMPLINGRATE_Z, (double)dataHeader.zlength/aDim.zdim);
        }
    }

    if (dataMode < DATA)   // Don't read  data if not necessary but read the header
        return 0;

    //offset should point to the begin of the data
    readData(fimg, select_img, datatype, pad );

    return(0);
}

readPreview()

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

pure virtual

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

readRange()

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

Reads range of images form a single image file starting from image with index start_img and ending with image with index end_img inclusive.

Definition at line 144 of file xmipp_image_base.cpp.

{
    if (end_img < start_img) {
        REPORT_ERROR(ERR_ARG_DEPENDENCE, formatString("readRange: end_img %lu is smaller than start_img %lu\n", end_img, start_img));
    }

    readBatch(name, start_img, end_img - start_img + 1, datamode, mapData, mode);
    return true;
}

rename()

void ImageBase::rename ( const FileName &  name )

inline

Rename the image

Definition at line 333 of file xmipp_image_base.h.

    {
        filename = name;
    }

rot()

double ImageBase::rot

(

const size_t

n = 0

)

const

Get Rot angle

std::cout << "First Euler angle " << I.rot() << std::endl;

Definition at line 365 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_ANGLE_ROT, dummy);
    return dummy;
}

samplingRateX()

double ImageBase::samplingRateX

(

)

const

Sampling RateX

std::cout << "sampling= " << samplingRateX() << std::endl;

Definition at line 500 of file xmipp_image_base.cpp.

{
    double dummy = 1.;
    MDMainHeader.getValue(MDL_SAMPLINGRATE_X, dummy);
    return dummy;
}

scale()

double ImageBase::scale

(

const size_t

n = 0

)

const

Get Scale factor

std::cout << "scale= " << I.scale() << std::endl;

Definition at line 456 of file xmipp_image_base.cpp.

{
    double dummy = 1;
    MD[n]->getValue(MDL_SCALE, dummy);
    return dummy;
}

selfApplyGeometry()

virtual void ImageBase::selfApplyGeometry ( int  SplineDegree, bool  wrap, bool  only_apply_shifts  )

pure virtual

Internal apply geometrical transformations

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

setADimFile()

void ImageBase::setADimFile ( ArrayDim  aDim )

inline

Set the information of the original image dimensions

Definition at line 670 of file xmipp_image_base.h.

    {
        aDimFile = aDim;
    }

setDataMode()

void ImageBase::setDataMode ( DataMode  mode )

inline

Set the read/write dataMode of the object

Definition at line 683 of file xmipp_image_base.h.

    {
        dataMode = mode;
    }

setDatatype()

void ImageBase::setDatatype ( DataType  datatype )

protected

Set datatype info in MDMainHeader

Definition at line 490 of file xmipp_image_base.cpp.

{
    MDMainHeader.setValue(MDL_DATATYPE, (int) datatype);
}

setDimensions() [1/2]

virtual void ImageBase::setDimensions ( int  Xdim, int  Ydim, int  Zdim, size_t  Ndim  )

pure virtual

Set image dimensions

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

setDimensions() [2/2]

void ImageBase::setDimensions ( ArrayDim &  aDim )

virtual

Definition at line 44 of file xmipp_image_base.cpp.

{
    mdaBase->setDimensions(aDim);
    aDimFile = aDim;
}

setEulerAngles()

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

Set Euler angles in image header

Definition at line 509 of file xmipp_image_base.cpp.

{
    MD[n]->setValue(MDL_ANGLE_ROT, rot);
    MD[n]->setValue(MDL_ANGLE_TILT, tilt);
    MD[n]->setValue(MDL_ANGLE_PSI, psi);
}

setFlip()

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

inline

Set flip in image header

Definition at line 763 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_FLIP, flip);
    }

setGeo()

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

Set geo. Copy the input geometry row into the image metadata row n.

Definition at line 252 of file xmipp_image_base.cpp.

{
    if (n < MD.size()) {
        if (dynamic_cast<const MDRowVec*>(&row) != nullptr)
            MD[n] = std::unique_ptr<MDRow>(new MDRowVec(dynamic_cast<const MDRowVec&>(row)));
        if (dynamic_cast<const MDRowSql*>(&row) != nullptr)
            MD[n] = std::unique_ptr<MDRow>(new MDRowSql(dynamic_cast<const MDRowSql&>(row)));
    } else {
        REPORT_ERROR(ERR_MD_OBJECTNUMBER, "Trying to set a value outside the current metadata size");
    }
}

setName()

void ImageBase::setName ( const FileName &  _filename )

inline

Set file name

Definition at line 676 of file xmipp_image_base.h.

    {
        filename = _filename;
    }

setPage2T()

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

protectedpure virtual

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

setPsi()

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

inline

Set Rotation angle to image

Definition at line 711 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_ANGLE_PSI, psi);
    }

setRot()

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

inline

Set Rotation angle to image

Definition at line 699 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_ANGLE_ROT, rot);
    }

setScale()

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

inline

Set scale in image header

Definition at line 749 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_SCALE, scale);
    }

setShifts()

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

Set origin offsets in image header

Definition at line 529 of file xmipp_image_base.cpp.

{
    MD[n]->setValue(MDL_SHIFT_X, xoff);
    MD[n]->setValue(MDL_SHIFT_Y, yoff);
    MD[n]->setValue(MDL_SHIFT_Z, zoff);
}

setTilt()

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

inline

Set Tilt angle to image

Definition at line 705 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_ANGLE_TILT, tilt);
    }

setWeight()

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

inline

Set Weight in image header

Definition at line 770 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_WEIGHT, weight);
    }

setXoff()

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

inline

Set X offset in image header

Definition at line 728 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_SHIFT_X, xoff);
    }

setYoff()

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

inline

Set Y offset in image header

Definition at line 735 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_SHIFT_Y, yoff);
    }

setZoff()

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

inline

Set Z offset in image header

Definition at line 742 of file xmipp_image_base.h.

    {
        MD[n]->setValue(MDL_SHIFT_Z, zoff);
    }

sumWithFile()

virtual void ImageBase::sumWithFile ( const FileName &  fn )

pure virtual

Sum this object with other file and keep in this object

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

swapOnWrite()

void ImageBase::swapOnWrite ( )

inline

Definition at line 489 of file xmipp_image_base.h.

    {
        swapWrite = true;
    }

swapPage()

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

Swap an entire page input pointer char *

Definition at line 331 of file xmipp_image_base.cpp.

{
    size_t datatypesize = gettypesize(datatype);
#ifdef DEBUG

    std::cerr<<"DEBUG swapPage: Swapping image data with swap= "
    << swap<<" datatypesize= "<<datatypesize
    << " pageNrElements " << pageNrElements
    << " datatype " << datatype
    <<std::endl;
    ;
#endif

    // Swap bytes if required
    if ( swap == 1 )
    {
        if ( datatype >= DT_CShort )
            datatypesize /= 2;
        for ( size_t i = 0; i < pageNrElements; i += datatypesize )
            swapbytes(page+i, datatypesize);
    }
    else if ( swap > 1 )
    {
        for (size_t i=0; i<pageNrElements; i+=swap )
            swapbytes(page+i, swap);
    }
}

tilt()

double ImageBase::tilt

(

const size_t

n = 0

)

const

Get Tilt angle

std::cout << "Second Euler angle " << I.tilt() << std::endl;

Definition at line 378 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_ANGLE_TILT, dummy);
    return dummy;
}

weight()

double ImageBase::weight

(

const size_t

n = 0

)

const

Get Weight

std::cout << "weight= " << I.weight() << std::endl;

Definition at line 443 of file xmipp_image_base.cpp.

{
    double dummy = 1;
    MD[n]->getValue(MDL_WEIGHT, dummy);
    return dummy;
}

write()

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

General write function select_img= which slice should I replace overwrite = 0, append slice overwrite = 1 overwrite slice

Definition at line 292 of file xmipp_image_base.cpp.

{
    const FileName &fname = (name.empty()) ? filename : name;

    if (mmapOnWrite && mappedSize > 0)
    {
        bool hasTempFile = !tempFilename.empty();
        if (hasTempFile && fname.isInStack())
            mmapOnWrite = !(mmapOnRead = true); // We change mmap mode from write to read to allow writing the image into a stack.
        else
        {
            if (_swapWrite > 0)
                REPORT_ERROR(ERR_ARG_INCORRECT, "Cannot swap endianness on writing if file is already mapped.");
            munmapFile();
            if (hasTempFile && std::rename(tempFilename.c_str(), fname.c_str()) != 0)
                REPORT_ERROR(ERR_IO, formatString("Error renaming file '%s' to '%s'.", tempFilename.c_str(), fname.c_str()));
            return;
        }
    }
    // Swap the endianness of the image file when writing
    swapWrite = _swapWrite;

    /* If the filename is in stack we will suppose you want to write this,
     * even if you have not set the flags to.
     */
    if ( fname.isInStack() && mode == WRITE_OVERWRITE)
    {
        isStack = true;
        mode = WRITE_REPLACE;
    }
    //    else if (!isStack && mode != WRITE_OVERWRITE)
    //        mode = WRITE_OVERWRITE;

    hFile = openFile(fname, mode);
    _write(fname, hFile, select_img, isStack, mode, castMode);
    closeFile(hFile);
}

writeData()

virtual void ImageBase::writeData ( FILE *  fimg, size_t  offset, DataType  wDType, size_t  datasize_n, CastWriteMode  castMode = CW_CAST  )

protectedpure virtual

Write the raw date after a data type casting.

writeEM()

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

protected

Write image to EM file format

Parameters

select_img	Number of selected image to write
isStack	Force to write as stack if possible
mode	Write file type: overwrite, replace, append....

Returns

Definition at line 148 of file rwEM.cpp.

{
    REPORT_ERROR(ERR_IO_NOWRITE, "ERROR: writeEM is not implemented.");
    return(-1);
}

writeJPEG()

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

protected

Definition at line 130 of file rwJPEG.cpp.

{
    if (isComplexT())
    {
        REPORT_ERROR(ERR_TYPE_INCORRECT,"rwJPEG: Complex images are not supported by JPEG format.");
        return 0;
    }

    ArrayDim aDim;
    mdaBase->getDimensions(aDim);

    // Volumes are not supported
    if (aDim.zdim > 1)
        REPORT_ERROR(ERR_MULTIDIM_DIM, "rwJPEG: volumes are not supported.");

    //Selection of output datatype
    DataType myTypeID = myT();

    if (mmapOnWrite)
    {
        /* As we cannot mmap a JPEG File, when this option is passed we are going to mmap
         * the multidimarray of Image
         */
        mmapOnWrite = false;
        dataMode = DATA;
        MDMainHeader.setValue(MDL_DATATYPE,(int) myTypeID);

        if (aDim.nzyxdim*gettypesize(myTypeID) > tiff_map_min_size)
            mdaBase->setMmap(true);

        // Allocate memory for image data (Assume xdim, ydim, zdim and ndim are already set
        //if memory already allocated use it (no resize allowed)

        mdaBase->coreAllocateReuse();

        return 0;
    }

    jpeg_compress_struct cinfo;
    jpeg_error_mgr jerr;

    //    struct jpeg_destination_mgr dmgr;
    //
    //    /* create our in-memory output buffer to hold the jpeg */
    //    JOCTET * out_buffer   = new JOCTET[aDim.xdim * aDim.ydim];
    //
    //    /* here is the magic */
    //    dmgr.init_destination    = init_buffer;
    //    dmgr.empty_output_buffer = empty_buffer;
    //    dmgr.term_destination    = term_buffer;
    //    dmgr.next_output_byte    = out_buffer;
    //    dmgr.free_in_buffer      = aDim.xdim * aDim.ydim;

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);

    jpeg_stdio_dest(&cinfo, fimg);

    /* Set JPEG image properties */
    cinfo.image_width = aDim.xdim;      /* image width and height, in pixels */
    cinfo.image_height = aDim.ydim;
    cinfo.input_components = 1;     /* # of color components per pixel */
    cinfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */

    jpeg_set_defaults(&cinfo);

    jpeg_start_compress(&cinfo, TRUE);

    JSAMPROW row_pointer[1];        /* pointer to a single row */
    row_pointer[0] = new unsigned char [aDim.xdim];
    char * buffer = (char*) row_pointer[0];
    double min0, max0;
    mdaBase->computeDoubleMinMaxRange(min0, max0, 0, aDim.xdim*aDim.ydim);


    while (cinfo.next_scanline < cinfo.image_height)
    {
        getCastConvertPageFromT((cinfo.next_scanline)*cinfo.image_width, buffer,
                                DT_UChar, cinfo.image_width, min0, max0, castMode);

        jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    delete[] row_pointer[0];

    //    fwrite(out_buffer, cinfo.dest->next_output_byte - out_buffer,1 ,fimg);

    return(0);
}

writePageAsDatatype()

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

pure virtual

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.

Implemented in Image< T >, Image< double >, Image< float >, Image< int >, Image< unsigned int >, Image< short int >, Image< unsigned char >, Image< char >, and Image< unsigned short int >.

writePIF()

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

protected

Write image to PIF file format

Parameters

select_img	Number of selected image to write
isStack	Force to write as stack if possible
mode	Write file type: overwrite, replace, append....

Returns

Definition at line 161 of file rwPIF.cpp.

{
    REPORT_ERROR(ERR_IO_NOWRITE, "ERROR: writePIF is not implemented.");
    return(-1);
}

Xoff()

double ImageBase::Xoff

(

const size_t

n = 0

)

const

Get Xoff

std::cout << "Origin offset in X " << I.Xoff() << std::endl;

Definition at line 404 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_SHIFT_X, dummy);
    return dummy;
}

Yoff()

double ImageBase::Yoff

(

const size_t

n = 0

)

const

Get Yoff

std::cout << "Origin offset in Y " << I.Yoff() << std::endl;

Definition at line 417 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_SHIFT_Y, dummy);
    return dummy;
}

Zoff()

double ImageBase::Zoff

(

const size_t

n = 0

)

const

Get Zoff

std::cout << "Origin offset in Z " << I.Zoff() << std::endl;

Definition at line 430 of file xmipp_image_base.cpp.

{
    double dummy = 0;
    MD[n]->getValue(MDL_SHIFT_Z, dummy);
    return dummy;
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  o, const ImageBase &  I  )

friend

Show ImageBase

Show image properties

Definition at line 1121 of file xmipp_image_base.cpp.

{
    o << std::endl;
    DataType * fileDT = NULL;
    if (!I.filename.empty())
    {
        o << "--- File information ---" << std::endl;
        o << "Filename       : " << I.filename << std::endl;
        o << "Endianess      : ";
        if (I.swap^IsLittleEndian())
            o << "Little"  << std::endl;
        else
            o << "Big" << std::endl;

        o << "Reversed       : ";
        if (I.swap)
            o << "True"  << std::endl;
        else
            o << "False" << std::endl;
        fileDT = new DataType;
        *fileDT = I.datatype();
        o << "Data type      : " << datatype2StrLong(*fileDT) << std::endl;
        o << "Data offset    : " << I.offset << std::endl;
    }

    o << "--- Image information ---" << std::endl;

    DataType myDT = I.myT();
    if ((fileDT == NULL || myDT != *fileDT) && I.dataMode >= DATA )
        o << "Memory datatype: " << datatype2StrLong(I.myT()) << std::endl;
    o << "Image type     : ";
    if (I.isComplex())
        o << "Fourier-space image" << std::endl;
    else
        o << "Real-space image" << std::endl;

    delete fileDT;

    size_t xdim, ydim, zdim, ndim;
    I.getDimensions(xdim, ydim, zdim, ndim);
    o << "Dimensions     : " << ndim << " x " << zdim << " x " << ydim << " x " << xdim;
    o << "  ((N)Objects x (Z)Slices x (Y)Rows x (X)Columns)" << std::endl;

    double sampling;
    I.MDMainHeader.getValueOrDefault(MDL_SAMPLINGRATE_X, sampling, 0);
    if (sampling > 0)
    {
        o << "Sampling rate  : " << std::endl;
        o << "                 X-rate (Angstrom/pixel) = " << sampling << std::endl;
        I.MDMainHeader.getValue(MDL_SAMPLINGRATE_Y, sampling);
        o << "                 Y-rate (Angstrom/pixel) = " << sampling << std::endl;
        I.MDMainHeader.getValue(MDL_SAMPLINGRATE_Z, sampling);
        o << "                 Z-rate (Angstrom/pixel) = " << sampling << std::endl;
    }

    std::stringstream oGeo;

    if (I.individualContainsLabel(MDL_ANGLE_ROT))
    {
        oGeo << "Euler angles   : " << std::endl;
        oGeo << "                 Phi   (rotation around Z axis)                  = " << I.rot() << std::endl;
        oGeo << "                 Theta (tilt, second rotation around new Y axis) = " << I.tilt() << std::endl;
        oGeo << "                 Psi   (third rotation around new Z axis)        = " << I.psi() << std::endl;
    }
    if (I.individualContainsLabel(MDL_SHIFT_X))
    {
        oGeo << "Origin Offsets : " << std::endl;
        oGeo << "                 Xoff  (origin offset in X-direction) = " << I.Xoff() << std::endl;
        oGeo << "                 Yoff  (origin offset in Y-direction) = " << I.Yoff() << std::endl;
        oGeo << "                 Zoff  (origin offset in Z-direction) = " << I.Zoff() << std::endl;
    }
    if (I.individualContainsLabel(MDL_SCALE))
        oGeo << "Scale          : " <<I.scale() << std::endl;
    if (I.individualContainsLabel(MDL_WEIGHT))
        oGeo << "Weight         : " << I.weight() << std::endl;
    if (I.individualContainsLabel(MDL_FLIP))
        oGeo << "Flip           : " << I.flip() << std::endl;

    if (!oGeo.str().empty())
        o << "--- Geometry ---" << std::endl << oGeo.str();

    return o;
}

Member Data Documentation

_exists

bool ImageBase::_exists

protected

Definition at line 263 of file xmipp_image_base.h.

aDimFile

ArrayDim ImageBase::aDimFile

protected

Definition at line 255 of file xmipp_image_base.h.

axisOrder

std::array<int,4> ImageBase::axisOrder

protected

Definition at line 260 of file xmipp_image_base.h.

dataFName

FileName ImageBase::dataFName

protected

Definition at line 249 of file xmipp_image_base.h.

dataMode

DataMode ImageBase::dataMode

protected

Definition at line 256 of file xmipp_image_base.h.

defaultAxisOrder

constexpr std::array<int,4> ImageBase::defaultAxisOrder = {0,1,2,3}

staticprotected

Definition at line 271 of file xmipp_image_base.h.

fhdf5

hid_t ImageBase::fhdf5

protected

Definition at line 253 of file xmipp_image_base.h.

fhed

FILE* ImageBase::fhed

protected

Definition at line 251 of file xmipp_image_base.h.

filename

FileName ImageBase::filename

protected

Definition at line 247 of file xmipp_image_base.h.

fimg

FILE* ImageBase::fimg

protected

Definition at line 250 of file xmipp_image_base.h.

hFile

ImageFHandler* ImageBase::hFile

protected

Definition at line 254 of file xmipp_image_base.h.

mappedOffset

size_t ImageBase::mappedOffset

protected

Definition at line 268 of file xmipp_image_base.h.

mappedSize

size_t ImageBase::mappedSize

protected

Definition at line 267 of file xmipp_image_base.h.

MD

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

Definition at line 242 of file xmipp_image_base.h.

mdaBase

MultidimArrayBase* ImageBase::mdaBase

Definition at line 241 of file xmipp_image_base.h.

MDMainHeader

MDRowVec ImageBase::MDMainHeader

Definition at line 244 of file xmipp_image_base.h.

mFd

int ImageBase::mFd

protected

Definition at line 266 of file xmipp_image_base.h.

mmapOnRead

bool ImageBase::mmapOnRead

protected

Definition at line 264 of file xmipp_image_base.h.

mmapOnWrite

bool ImageBase::mmapOnWrite

protected

Definition at line 265 of file xmipp_image_base.h.

offset

size_t ImageBase::offset

protected

Definition at line 257 of file xmipp_image_base.h.

replaceNsize

size_t ImageBase::replaceNsize

protected

Definition at line 262 of file xmipp_image_base.h.

swap

int ImageBase::swap

protected

Definition at line 258 of file xmipp_image_base.h.

swapWrite

int ImageBase::swapWrite

protected

Definition at line 259 of file xmipp_image_base.h.

tempFilename

FileName ImageBase::tempFilename

protected

Definition at line 248 of file xmipp_image_base.h.

tif

TIFF* ImageBase::tif

protected

Definition at line 252 of file xmipp_image_base.h.

transform

TransformType ImageBase::transform

protected

Definition at line 261 of file xmipp_image_base.h.

virtualOffset

size_t ImageBase::virtualOffset

protected

Definition at line 269 of file xmipp_image_base.h.

---

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

• xmippCore/core/xmipp_image_base.h
• xmippCore/core/rwDM3.cpp
• xmippCore/core/rwDM4.cpp
• xmippCore/core/rwEER.cpp
• xmippCore/core/rwEM.cpp
• xmippCore/core/rwHDF5.cpp
• xmippCore/core/rwIMAGIC.cpp
• xmippCore/core/rwINF.cpp
• xmippCore/core/rwJPEG.cpp
• xmippCore/core/rwMRC.cpp
• xmippCore/core/rwPIF.cpp
• xmippCore/core/rwRAW.cpp
• xmippCore/core/rwSPE.cpp
• xmippCore/core/rwSPIDER.cpp
• xmippCore/core/rwTIA.cpp
• xmippCore/core/rwTIFF.cpp
• xmippCore/core/xmipp_image_base.cpp