xmipp_image_generic.h

Go to the documentation of this file.

/***************************************************************************
 * Authors:     Joaquin Oton (joton@cnb.csic.es)
 *
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef CORE_IMAGE_GENERIC_H_
#define CORE_IMAGE_GENERIC_H_

#include "xmipp_image_base.h"
#include "multidim_array_generic.h"

// @addtogroup Images

#define CHECK_IMG(op)\
 if (image == NULL) \
  REPORT_ERROR(ERR_IMG_UNKNOWN, "ImageGeneric: Image not initialized.");\
 else\
 {\
  op\
 }

class ImageGeneric
{

public:
    ImageBase* image;
    DataType datatype;
    MultidimArrayGeneric * data;

protected:

    bool    swap; // To store the swap mode of the image when the datatype is read.

public:

    ImageGeneric()
    {
        init();
    }
    ImageGeneric(DataType _datatype);

    ImageGeneric(const FileName &filename);

    ImageGeneric(const ImageGeneric &img);

    ~ImageGeneric();

    void init();

    void clear();

    void copy(const ImageGeneric &img);

    void clearHeader()
    {
        image->clearHeader();
    }

    void initGeometry(const size_t n = 0);
    MDRow& getGeometry(const size_t n = 0)
    {
        return *(image->MD[n]);
    }

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

    size_t getSize() const
    {
        return NZYXSIZE(*(data->im));
    }

    void getEulerAngles(double &rot, double &tilt, double &psi,
                        size_t n = 0)
    {
        image->getEulerAngles(rot, tilt, psi, n);
    }

    double tilt(const size_t n = 0) const
    {
        return image->tilt(n);
    }

    void resize(int Xdim, int Ydim, int Zdim, size_t Ndim, bool copy=true)
    {
        image->setDimensions(Xdim, Ydim, Zdim, Ndim);
        data->resize(Ndim, Zdim, Ydim, Xdim, copy);
    }

    void setDatatype(DataType _datatype);

    void setDatatype(const FileName &name, ImageInfo &imgInf);
    void setDatatype(const FileName &name);

    void setDataMode(DataMode mode)
    {
        image->setDataMode(mode);
    }

    DataType getDatatype()const
    {
        return datatype;
    }

    void getInfo(ImageInfo &imgInfo) const;

    int getDatatypeDepth()const
    {
        switch (datatype)
        {
        case DT_Float:
        case DT_UInt:
            return 32;
        case DT_Int:
            return 31;
        case DT_Short:
            return 15;
        case DT_UShort:
        case DT_HalfFloat:
            return 16;
        case DT_SChar:
            return 7;
        case DT_UHalfByte:
        case DT_UChar:
            return 8;
        default:
            REPORT_ERROR(ERR_TYPE_INCORRECT,"Do not know how to handle this type at this point");
        }
    }

    inline bool isMapped()
    {
        return image->isMapped();
    }

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

    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);
    /* Euler mirror Y ---------------------------------------------------------- */
    void mirrorY(void);

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

    /* Initially try to read normally, but if there is a memory allocation problem, then
     * try to read from the mapped file.*/
    int readOrReadMapped(const FileName &name, size_t select_img = ALL_IMAGES, int mode = WRITE_READONLY);

    /* Read 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.
    */
    int readPreview(const FileName &name, size_t Xdim, size_t Ydim = 0, int select_slice = CENTRAL_SLICE, size_t select_img = FIRST_IMAGE);

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

    void getPreview(ImageGeneric &imgOut, int Xdim, int Ydim = -1, int select_slice = CENTRAL_SLICE, size_t select_img = FIRST_IMAGE);

    /* Read an image with a lower resolution as a preview image.
    * Resizing is done in fourier space
    * If Zdim parameter is not passed, then all slices are rescaled.
    * If Ydim is not passed, then Ydim is rescaled same factor as Xdim.
    */
    int readPreviewFourier(const FileName &name, size_t Xdim, size_t Ydim = 0, int select_slice = CENTRAL_SLICE, size_t select_img = FIRST_IMAGE);

    /* Using xvsmooth */
    int readPreviewSmooth(const FileName &name, size_t Xdim, size_t Ydim = 0, int select_slice = CENTRAL_SLICE, size_t select_img = FIRST_IMAGE);


    inline 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)
    {
        image->write(name,select_img,isStack,mode,castMode,_swapWrite);
    }

    /* Create an empty image file of format given by filename and map it to memory.
     */
    void mapFile2Write(int Xdim, int Ydim, int Zdim, const FileName &_filename,
                       bool createTempFile=false, size_t select_img = APPEND_IMAGE,
                       bool isStack=false, int mode=WRITE_OVERWRITE, int _swapWrite = 0);

    void movePointerTo(int select_slice = ALL_SLICES, size_t select_img = ALL_IMAGES)
    {
        image->movePointerTo(select_slice, select_img);
    }


    /* MultidimArrayGeneric data access
     */
    inline MultidimArrayGeneric& operator()()
    {
        return *data;
    }

    inline const MultidimArrayGeneric& operator()() const
    {
        return *data;
    }

    ImageGeneric& operator=(const ImageGeneric &img);

    bool operator==(const ImageGeneric &i1) const;

    void convert2Datatype(DataType datatype, CastWriteMode castMode=CW_CONVERT);

    /* Reslice a volume aligning any X or Y direction with Z axis.
     */
    void reslice(AxisView view);
    /* The resliced volume is returned in out
    */
    void reslice(AxisView view, ImageGeneric &out);

    bool equal(const ImageGeneric &i1, double accuracy=XMIPP_EQUAL_ACCURACY) const
    {
        return data->equal(MULTIDIM_ARRAY_GENERIC(i1),accuracy);
    }
    inline double getPixel(unsigned long n, int k, int i, int j) const
    {
        double ret;
#define GETVALUE(type) ret = NZYX_ELEM(*(MultidimArray<type>*)data->im,n,k,i,j);
        SWITCHDATATYPE(datatype,GETVALUE)
#undef GETVALUE
        return ret;
    }

    inline double getPixel(int i, int j) const
    {
        double ret;
#define GETVALUE(type) ret = (double) A2D_ELEM(*(MultidimArray<type>*)data->im,i,j);
        SWITCHDATATYPE(datatype,GETVALUE)
#undef GETVALUE
        return ret;
    }

    inline void setPixel(unsigned long n, int k, int i, int j, double value) const
    {
#define SETVALUE(type) NZYX_ELEM(*(MultidimArray<type>*)data->im,n,k,i,j) = (type) value;
        SWITCHDATATYPE(datatype,SETVALUE)
#undef SETVALUE

    }

    inline void setPixel(int i, int j, double value) const
    {

#define SETVALUE(type) A2D_ELEM(*(MultidimArray<type>*)data->im,i,j) = (type) value;
        CHECK_IMG(SWITCHDATATYPE(datatype,SETVALUE))
#undef SETVALUE

    }

    inline void initConstant(double value) const
    {
#define INITCONS(type) (*(MultidimArray<type>*)(data->im)).initConstant((type) value);
        CHECK_IMG(SWITCHDATATYPE(datatype,INITCONS))
#undef INITCONS

    }

    inline void initRandom(double op1, double op2, RandomMode mode = RND_UNIFORM) const
    {
#define INITRND(type) (*(MultidimArray<type>*)(data->im)).initRandom(op1, op2, mode);
        CHECK_IMG(SWITCHDATATYPE(datatype,INITRND))
#undef INITRND

    }

    void print() const;

    void toString(String &s) const;

    friend std::ostream& operator<<(std::ostream& o, const ImageGeneric& I)
    {
        o << I.image;
        return o;
    }

    void add(const ImageGeneric &img);

    void subtract(const ImageGeneric &img);

    void multiply(const double value);

    void multiply(const ImageGeneric &img);

    void divide(const ImageGeneric &img);

    void divide(const double value);

}
;




void createEmptyFile(const FileName &_filename, int Xdim, int Ydim, int Zdim = 1,
                     size_t select_img = APPEND_IMAGE, bool isStack = false,
                     int mode = WRITE_OVERWRITE, int _swapWrite = 0, const MDRowVec *md = nullptr);

#endif /* IMAGE_GENERIC_H_ */