GridVolumeT< T > Class Template Reference

#include <grids.h>

Public Member Functions
	GridVolumeT ()
	GridVolumeT (const GridVolumeT &_RV)
	GridVolumeT (const Grid &_grid)
GridVolumeT &	operator= (const GridVolumeT &RV)
void	assign (const GridVolumeT &RV)
	~GridVolumeT ()
void	adapt_to_grid (const Grid &_grid)
void	resize (const Matrix1D< double > &corner1, const Matrix1D< double > &corner2)
template<class T1 >
void	resize (const GridVolumeT< T1 > &GV)
void	initZeros ()
void	clear ()
Image< T > &	operator() (size_t n)
void	get_volume (size_t n, Image< T > &V)
const Image< T > &	operator() (size_t n) const
const SimpleGrid &	grid (size_t n) const
void	get_SimpleGrid (size_t n, SimpleGrid &G)
const Grid &	grid () const
void	get_Grid (Grid &G)
size_t	VolumesNo () const
GridVolumeT< T >	operator+ (T f) const
GridVolumeT< T >	operator- (T f) const
GridVolumeT< T >	operator* (T f) const
GridVolumeT< T >	operator/ (T f) const
GridVolumeT< T > friend	operator+ (T f, const GridVolumeT< T > &GV)
GridVolumeT< T > friend	operator* (T f, const GridVolumeT< T > &GV)
GridVolumeT< T >	operator+ (const GridVolumeT< T > &GV)
GridVolumeT< T >	operator- (const GridVolumeT< T > &GV)
GridVolumeT< T >	operator* (const GridVolumeT< T > &GV)
GridVolumeT< T >	operator/ (const GridVolumeT< T > &GV)
void	operator+= (const GridVolumeT< T > &GV)
void	operator-= (const GridVolumeT< T > &GV)
void	operator*= (const GridVolumeT< T > &GV)
void	operator/= (const GridVolumeT< T > &GV)
Grids I/O
The reconstructing volume is stored in the Xmipp format. Although it is not a true volume some special structure is used to store each subgrid and subvolume. a first slice contains control information about the subvolume which is behind the subvolume is stored after its control information and it can be represented by a volume viewer. The structure inside the control slice is the following: Subgrid information: (19 doubles) - basis 9 doubles - lowest 3 doubles - highest 3 doubles - relative_size 1 double - origin 3 doubles Subvolume information (6 doubles) - Zdim, Ydim, Xdim 3 doubles - Zinit, Yinit, Xinit 3 doubles With respect to the volume structure, if the volume is smaller (Ydim,Xdim) than the size assigned to the file then the data is right justified and the extra data is filled with zeros.
void	write (const FileName &fn) const
void	read (const FileName &fn, const std::string &basisName)

Detailed Description

template<class T>
class GridVolumeT< T >

Grid Volume class. The grid volumes are a special kind of volumes used in reconstructions where the volumes are understood as a 3D matrix of coefficients placed at the points defined by a Grid (BCC, FCC, ...) Remember that a complex grid like these ones are seen as lists of simpler grids. That is why this Grid Volumes are compound of a list of volumes. The first volume of the grid volume should contain the coefficients for the first grid in the list of grids, and so on.

Definition at line 41 of file grids.h.

Constructor & Destructor Documentation

GridVolumeT() [1/3]

template<class T>

GridVolumeT< T >::GridVolumeT ( )

inline

Empty constructor. The volume list is empty, and the grid is also empty

Definition at line 782 of file grids.h.

    {
        LV.clear();
        (Grid) G;
    }

GridVolumeT() [2/3]

template<class T>

GridVolumeT< T >::GridVolumeT ( const GridVolumeT< T > &  _RV )

inline

Copy constructor.

Definition at line 789 of file grids.h.

    {
        *this = _RV;
    }

GridVolumeT() [3/3]

template<class T>

GridVolumeT< T >::GridVolumeT ( const Grid &  _grid )

inline

Create using a grid as pattern and basis. Create the grid volume using this grid as pattern. This function calls adapt_to_grid , so look at there to know exactly what is performed

Definition at line 798 of file grids.h.

    {
        adapt_to_grid(_grid);
    }

~GridVolumeT()

template<class T>

GridVolumeT< T >::~GridVolumeT ( )

inline

Destructor.

Definition at line 827 of file grids.h.

    {
        clear();
    }

Member Function Documentation

adapt_to_grid()

template<class T>

void GridVolumeT< T >::adapt_to_grid ( const Grid &  _grid )

inline

Reset current volume and use the given grid as pattern. The current grid volume is cleared. Then the given grid is taken as the grid for this grid volume. Zero-valued volumes are added to the volume list according to the number of grids inside the complex grid. The size and starting point of the volumes added are fixed by the lowest and highest fields of each SimpleGrid .

Definition at line 838 of file grids.h.

    {
        // Clear old list of volumes
        for (size_t i = 0; i < VolumesNo(); i++)
            if (LV[i]!=nullptr)
                delete LV[i];
        LV.clear();

        // Keep the incoming Grid at the same time the old grid is forgotten
        G = _grid;

        // Generate a volume for each subgrid
        int Zdim;
        int Ydim;
        int Xdim;
        Image<T> *                 Vol_aux;
        for (size_t i = 0; i < G.GridsNo(); i++)
        {
            SimpleGrid & grid = G(i);
            grid.getSize(Zdim, Ydim, Xdim);
            Vol_aux = new Image<T>;
            (*Vol_aux)().resize(Zdim, Ydim, Xdim);  // Using this function
            // after empty creation the volume
            // is zero-valued.
            STARTINGX((*Vol_aux)()) = (int) XX(grid.lowest); // This values are already
            STARTINGY((*Vol_aux)()) = (int) YY(grid.lowest); // integer although they
            STARTINGZ((*Vol_aux)()) = (int) ZZ(grid.lowest); // are stored as float
            LV.push_back(Vol_aux);
        }
    }

assign()

template<class T>

void GridVolumeT< T >::assign ( const GridVolumeT< T > &  RV )

inline

Another function for assignment.

Definition at line 821 of file grids.h.

    {
        *this = RV;
    }

clear()

template<class T>

void GridVolumeT< T >::clear ( )

inline

Clear the volume

Definition at line 943 of file grids.h.

    {
        for (size_t i = 0; i < VolumesNo(); i++)
            delete LV[i];
        LV.clear();
        G.clear();
    }

get_Grid()

template<class T>

void GridVolumeT< T >::get_Grid ( Grid &  G )

inline

Get grid.

Definition at line 997 of file grids.h.

    {
        G = grid();
    }

get_SimpleGrid()

template<class T>

void GridVolumeT< T >::get_SimpleGrid ( size_t  n, SimpleGrid &  G  )

inline

Get simple grid.

Definition at line 984 of file grids.h.

    {
        G = grid(n);
    }

get_volume()

template<class T>

void GridVolumeT< T >::get_volume ( size_t  n, Image< T > &  V  )

inline

Another function for access to one of the volumes in the list.

Definition at line 961 of file grids.h.

    {
        V = (*this)(n);
    }

grid() [1/2]

template<class T>

const SimpleGrid& GridVolumeT< T >::grid ( size_t  n ) const

inline

Constant access to a simple grid. The grid is the SimpleGrid associated to the volume which occupies position n in the volume list.

Definition at line 978 of file grids.h.

    {
        return G(n);
    }

grid() [2/2]

template<class T>

const Grid& GridVolumeT< T >::grid ( ) const

inline

Constant access to the whole grid. The grid is the whole Grid associated to the volume.

Definition at line 991 of file grids.h.

    {
        return G;
    }

initZeros()

template<class T>

void GridVolumeT< T >::initZeros ( )

inline

Set to zero with the actual size and origin.

Definition at line 936 of file grids.h.

    {
        for (size_t i = 0; i < VolumesNo(); i++)
            (*this)(i)().initZeros();
    }

operator()() [1/2]

template<class T>

Image<T>& GridVolumeT< T >::operator() ( size_t  n )

inline

Access to one of the volumes in the list. The first volume is the number 0.

Definition at line 953 of file grids.h.

    {
        if (n>LV.size())
            REPORT_ERROR(ERR_VALUE_INCORRECT, "The Grid Volume hasn't got so many Simple Volumes");
        return *(LV[n]);
    }

operator()() [2/2]

template<class T>

const Image<T>& GridVolumeT< T >::operator() ( size_t  n ) const

inline

Constant access to a volume in the list. The first volume is the number 0.

Definition at line 968 of file grids.h.

    {
        if (n>LV.size())
            REPORT_ERROR(ERR_VALUE_INCORRECT, "The Grid Volume hasn't got so many Simple Volumes");
        return *(LV[n]);
    }

operator*() [1/3]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator* ( T  f ) const

inline

Multiply by a constant. The constant is multiplied with all simple volumes. \Ex: V2=V1*6;

Definition at line 1035 of file grids.h.

    {
        GRIDVOLUME_BY_SCALAR('*');
    }

operator*() [2/3]

template<class T>

GridVolumeT<T> friend GridVolumeT< T >::operator* ( T  f, const GridVolumeT< T > &  GV  )

inline

Multiply by a constant. The constant is multiplied with all simple volumes. \Ex: V2=6*V1;

Definition at line 1059 of file grids.h.

    {
        return GV*f;
    }

operator*() [3/3]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator* ( const GridVolumeT< T > &  GV )

inline

Multiply by another volume. The two volumes must be equally the same in shape (size, origin, number of simple volumes, ...) if they aren't an exception is thrown. \Ex: V3=V1*V2;

Definition at line 1113 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOL('*');
    }

operator*=()

template<class T>

void GridVolumeT< T >::operator*= ( const GridVolumeT< T > &  GV )

inline

Multiply by another volume.

Definition at line 1155 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOLASSIG('*');
    }

operator+() [1/3]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator+ ( T  f ) const

inline

Sum a constant. The constant is added to all simple volumes. \Ex: V2=V1+6;

Definition at line 1019 of file grids.h.

    {
        GRIDVOLUME_BY_SCALAR('+');
    }

operator+() [2/3]

template<class T>

GridVolumeT<T> friend GridVolumeT< T >::operator+ ( T  f, const GridVolumeT< T > &  GV  )

inline

Sum a constant. The constant is added to all simple volumes. \Ex: V2=6+V1;

Definition at line 1051 of file grids.h.

    {
        return GV + f;
    }

operator+() [3/3]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator+ ( const GridVolumeT< T > &  GV )

inline

Sum another volume. The two volumes must be equally the same in shape (size, origin, number of simple volumes, ...) if they aren't an exception is thrown. \Ex: V3=V1+V2;

Definition at line 1093 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOL('+');
    }

operator+=()

template<class T>

void GridVolumeT< T >::operator+= ( const GridVolumeT< T > &  GV )

inline

Sum another volume.

Definition at line 1143 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOLASSIG('+');
    }

operator-() [1/2]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator- ( T  f ) const

inline

Subtract a constant. The constant is subtracted from all simple volumes. \Ex: V2=V1-6;

Definition at line 1027 of file grids.h.

    {
        GRIDVOLUME_BY_SCALAR('-');
    }

operator-() [2/2]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator- ( const GridVolumeT< T > &  GV )

inline

Subtract another volume. The two volumes must be equally the same in shape (size, origin, number of simple volumes, ...) if they aren't an exception is thrown. \Ex: V3=V1-V2;

Definition at line 1103 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOL('-');
    }

operator-=()

template<class T>

void GridVolumeT< T >::operator-= ( const GridVolumeT< T > &  GV )

inline

Subtract another volume.

Definition at line 1149 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOLASSIG('-');
    }

operator/() [1/2]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator/ ( T  f ) const

inline

Divide by a constant. The constant divides all simple volumes. \Ex: V2=V1/6;

Definition at line 1043 of file grids.h.

    {
        GRIDVOLUME_BY_SCALAR('/');
    }

operator/() [2/2]

template<class T>

GridVolumeT<T> GridVolumeT< T >::operator/ ( const GridVolumeT< T > &  GV )

inline

Divide by another volume. The two volumes must be equally the same in shape (size, origin, number of simple volumes, ...) if they aren't an exception is thrown. \Ex: V3=V1/V2;

Definition at line 1123 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOL('/');
    }

operator/=()

template<class T>

void GridVolumeT< T >::operator/= ( const GridVolumeT< T > &  GV )

inline

Divide by another volume.

Definition at line 1161 of file grids.h.

    {
        GRIDVOL_BY_GRIDVOLASSIG('/');
    }

operator=()

template<class T>

GridVolumeT& GridVolumeT< T >::operator= ( const GridVolumeT< T > &  RV )

inline

Assignment.

Definition at line 804 of file grids.h.

    {
        if (this != &RV)
        {
            clear();
            G = RV.G;
            for (size_t i = 0; i < RV.VolumesNo(); i++)
            {
                auto  *V = new Image<T>;
                *V = RV(i);
                LV.push_back(V);
            }
        }
        return *this;
    }

read()

template<class T>

void GridVolumeT< T >::read ( const FileName &  fn, const std::string &  basisName  )

inline

Read grid volume. The volume is read from a Xmipp volume with a special structure at several slices.

Definition at line 1330 of file grids.h.

    {
        Image<T>       V;
        Image<T>       * sV;
        SimpleGrid     sG;
        size_t         sli = 0;

        float temp_float;
        size_t floatsize;
        const std::type_info &typeinfoT = typeid(T); // We need to know what kind
        // of variable is T
        const std::type_info &typeinfoD = typeid(double);
        const std::type_info &typeinfoI = typeid(int);

        floatsize = (size_t) sizeof(float);
        // We use a trick to save the grid information in the volume
        // If the following if is true the trick can not be used
        if ((typeid(T) == typeid(int)) && (sizeof(float) != sizeof(int)))
            REPORT_ERROR(ERR_TYPE_INCORRECT,"Error: GridVolume is integer and (sizeof(float)!= sizeof(int)");

        // Allocate memory ......................................................
        sG.basis.resize(3, 3);
        sG.lowest.resize(3);
        sG.highest.resize(3);
        sG.origin.resize(3);

        // Read Reconstructing volume from file .................................
        V.read(fn);
        if (basisName=="voxels")
        {
            V().setXmippOrigin();
            sV=new Image<double>;
            *sV=V;
            LV.push_back(sV);
            G=Create_CC_grid(1.0,ZSIZE(V()),YSIZE(V()),XSIZE(V()));
        }
        else
        {
#define UNPACK_DOUBLE(v,cast) \
            {jj=pos%VOLMATRIX(V).xdim; ii=pos/VOLMATRIX(V).xdim; pos++; \
            (v)=(cast)VOLVOXEL(V,sli,ii,jj);}
#define UNPACK_INT(v,cast) \
            {jj=pos%VOLMATRIX(V).xdim; ii=pos/VOLMATRIX(V).xdim; pos++; \
            memcpy( &temp_float, &(VOLVOXEL(V,sli,ii,jj)),floatsize);\
            (v)=(cast)temp_float;}

            while (sli < ZSIZE(V()))
            {
                int pos;                // Position inside the control slice
                int ii;                 // Position inside the control slice
                int jj;                 // Position inside the control slice
                size_t k;               // Auxiliary counters
                size_t i;               // Auxiliary counters
                size_t j;               // Auxiliary counters
                size_t Zdim;
                size_t Ydim;
                size_t Xdim;
                int Zinit;
                int Yinit;
                int Xinit;

                // Read Grid data ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
                pos = 0;
                if (typeinfoT == typeinfoD)
                {
                    for (i = 0; i < 3; i++)
                        for (j = 0; j < 3; j++)
                            UNPACK_DOUBLE((sG.basis)(i, j), double);
                    for (i = 0; i < 3; i++)
                        UNPACK_DOUBLE((sG.lowest)(i), int);
                    for (i = 0; i < 3; i++)
                        UNPACK_DOUBLE((sG.highest)(i), int);
                    UNPACK_DOUBLE(sG.relative_size, double);
                    for (i = 0; i < 3; i++)
                        UNPACK_DOUBLE((sG.origin)(i), double);
                    UNPACK_DOUBLE(sG.R2, double);
                }
                else if (typeinfoT == typeinfoI)
                {
                    // We use a trick to save the grid information in the volume
                    // If the following if is true the trick can not be used
                    if (sizeof(float) != sizeof(int))
                        REPORT_ERROR(ERR_TYPE_INCORRECT,
                                     "GridVolume is integer and (sizeof(float)!= sizeof(int)");

                    for (i = 0; i < 3; i++)
                        for (j = 0; j < 3; j++)
                            UNPACK_INT((sG.basis)(i, j), double);
                    for (i = 0; i < 3; i++)
                        UNPACK_INT((sG.lowest)(i), int);
                    for (i = 0; i < 3; i++)
                        UNPACK_INT((sG.highest)(i), int);
                    UNPACK_INT(sG.relative_size, double);
                    for (i = 0; i < 3; i++)
                        UNPACK_INT((sG.origin)(i), double);
                    UNPACK_INT(sG.R2, double);
                }
                sG.inv_basis = sG.basis.inv();

                // Store Grid in the list of the grid volume
                G.add_grid(sG);

                // Read Volume Control Information ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
                if (typeinfoT == typeinfoD)
                {
                    UNPACK_DOUBLE(Zdim, int);
                    UNPACK_DOUBLE(Ydim, int);
                    UNPACK_DOUBLE(Xdim, int);
                    UNPACK_DOUBLE(Zinit, int);
                    UNPACK_DOUBLE(Yinit, int);
                    UNPACK_DOUBLE(Xinit, int);
                }
                else if (typeinfoT == typeinfoI)
                {
                    UNPACK_INT(Zdim, int);
                    UNPACK_INT(Ydim, int);
                    UNPACK_INT(Xdim, int);
                    UNPACK_INT(Zinit, int);
                    UNPACK_INT(Yinit, int);
                    UNPACK_INT(Xinit, int);
                }

                // Set volume size and origin
                sV = new Image<T>;
                VOLMATRIX(*sV).initZeros(Zdim, Ydim, Xdim);
                STARTINGZ(VOLMATRIX(*sV)) = Zinit;
                STARTINGY(VOLMATRIX(*sV)) = Yinit;
                STARTINGX(VOLMATRIX(*sV)) = Xinit;
#ifdef DEBUG

                std::cout << "The read grid is \n" << sG;
                std::cout << "Volume dimensions: " << Zdim << " x " << Ydim << " x "
                << Xdim << std::endl;
                std::cout << "Volume init: " << Zinit << " x " << Yinit << " x "
                << Xinit << std::endl;
#endif

                sli++;

                // Read volume ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
                for (k = 0; k < ZSIZE(VOLMATRIX(*sV)); k++)
                {
                    for (i = 0; i < YSIZE(VOLMATRIX(*sV)); i++)
                        for (j = 0; j < XSIZE(VOLMATRIX(*sV)); j++)
                        {
#ifdef DEBUG
                            std::cout << "Reading from file position (" << sli << "," << i
                            << "," << j << ") to subvolume position ("
                            << k << "," << i << "," << j << ")\n";
#endif

                            DIRECT_VOLVOXEL(*sV, k, i, j) = DIRECT_VOLVOXEL(V, sli, i, j);
                        }
                    sli++;
                }

                // Store volume in the list
                LV.push_back(sV);
            }
#undef UNPACK_DOUBLE
#undef UNPACK_INT
        }
    }

resize() [1/2]

template<class T>

void GridVolumeT< T >::resize ( const Matrix1D< double > &  corner1, const Matrix1D< double > &  corner2  )

inline

Resize. The grid volume is resized such that the space delimited by the two given corners is covered. Overlapping grid points are retained while non-overlapping ones are set to 0.

Definition at line 873 of file grids.h.

    {
        Image<T> *         Vol_aux;
        std::vector<Image<T> * > LV_aux;

        for (size_t n = 0; n < G.GridsNo(); n++)
        {
            SimpleGrid &grid = G(n);

            // Resize grid
            grid.universe2grid(corner1, grid.lowest);
            grid.lowest.selfFLOOR();
            grid.universe2grid(corner2, grid.highest);
            grid.highest.selfCEIL();

            // Resize auxiliary volume
            int Zdim;
            int Ydim;
            int Xdim;
            grid.getSize(Zdim, Ydim, Xdim);
            Vol_aux = new Image<T>;
            (*Vol_aux)().resize(Zdim, Ydim, Xdim);
            STARTINGX((*Vol_aux)()) = (int) XX(grid.lowest); // This values are already
            STARTINGY((*Vol_aux)()) = (int) YY(grid.lowest); // integer although they
            STARTINGZ((*Vol_aux)()) = (int) ZZ(grid.lowest); // are stored as float

            // Copy values in common
            Image<T> * origin = LV[n];
            SPEED_UP_tempsInt;
            FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(VOLMATRIX(*Vol_aux), VOLMATRIX(*origin))
            {
                VOLVOXEL(*Vol_aux, k, i, j) = VOLVOXEL(*origin, k, i, j);
            }

            // Extract old volume and push new one
            delete LV[n];
            LV_aux.push_back(Vol_aux);
        }
        LV = LV_aux;
    }

resize() [2/2]

template<class T>

template<class T1 >

void GridVolumeT< T >::resize ( const GridVolumeT< T1 > &  GV )

inline

Resize after a pattern. The volume is of the same shape, the grids are copied, and the volume coeeficients are set to 0.

Definition at line 919 of file grids.h.

    {
        clear();
        for (size_t n = 0; n < GV.VolumesNo(); n++)
        {
            SimpleGrid grid;
            grid = GV.grid(n);
            G.add_grid(grid);

            Image<T> *Vol_aux;
            Vol_aux = new Image<T>;
            (*Vol_aux)().resize(GV(n)());
            LV.push_back(Vol_aux);
        }
    }

VolumesNo()

template<class T>

size_t GridVolumeT< T >::VolumesNo ( ) const

inline

Number of volumes inside structure.

Definition at line 1003 of file grids.h.

    {
        return LV.size();
    }

write()

template<class T>

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

inline

Write grid volume. The Filename is compulsory, an exception is thrown if the volume is too small to hold the control information of each layer.

Definition at line 1196 of file grids.h.

    {
        Image<T>    V;
        float temp_float;
        size_t floatsize;
        const std::type_info &typeinfoT = typeid(T); // We need to know what kind
        // of variable is T
        const std::type_info &typeinfoD = typeid(double);
        const std::type_info &typeinfoI = typeid(int);

        floatsize = (size_t) sizeof(float);

        if (VolumesNo() == 0)
            return;

        // Create the writing volume ............................................
        size_t Zdim = 0;
        size_t Ydim = 0;
        size_t Xdim = 0;
        for (size_t v = 0; v < VolumesNo(); v++)
        {
            const Image<T> & this_vol = (*this)(v);
            Zdim += ZSIZE(this_vol());
            Ydim = XMIPP_MAX(Ydim, YSIZE(this_vol()));
            Xdim = XMIPP_MAX(Xdim, XSIZE(this_vol()));
        }

        // Check if there is enough space for the control slice
        if (Xdim*Ydim < 25)
            Ydim = (int) CEIL(25.0f / Xdim);

        // A slice is added for control information for each subvolume
        VOLMATRIX(V).initZeros(Zdim + VolumesNo(), Ydim, Xdim);

        // Write Grid volume ....................................................
#define PACK_DOUBLE(v) \
{jj=pos%Xdim; ii=pos/Xdim; pos++; VOLVOXEL(V,sli,ii,jj)=(T)(v);}
#define PACK_INT(v) \
    {jj=pos%Xdim; ii=pos/Xdim; pos++; \
        temp_float = (float) (v); \
        memcpy( &(VOLVOXEL(V,sli,ii,jj)) , &temp_float, floatsize); \
    }

        int sli = 0;
        for (size_t v = 0; v < VolumesNo(); v++)
        {
            int pos;                // Position inside the control slice
            int ii;                 // Position inside the control slice
            int jj;                 // Position inside the control slice
            size_t k;               // Auxiliar counters
            size_t i;               // Auxiliar counters
            size_t j;               // Auxiliar counters

            // Choose grid and volume
            const SimpleGrid & this_grid = grid(v);
            const Image<T> & this_vol = (*this)(v);

            // Store Grid data ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
            pos = 0;

            if (typeinfoT == typeinfoD)
            {
                for (i = 0; i < 3; i++)
                    for (j = 0; j < 3; j++)
                        PACK_DOUBLE((this_grid.basis)(i, j));
                for (i = 0; i < 3; i++)
                    PACK_DOUBLE((this_grid.lowest)(i));
                for (i = 0; i < 3; i++)
                    PACK_DOUBLE((this_grid.highest)(i));
                PACK_DOUBLE(this_grid.relative_size);
                for (i = 0; i < 3; i++)
                    PACK_DOUBLE((this_grid.origin)(i));
                PACK_DOUBLE(this_grid.R2);

                // Store volume control ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
                PACK_DOUBLE(ZSIZE(this_vol()));
                PACK_DOUBLE(YSIZE(this_vol()));
                PACK_DOUBLE(XSIZE(this_vol()));
                PACK_DOUBLE(STARTINGZ(this_vol()));
                PACK_DOUBLE(STARTINGY(this_vol()));
                PACK_DOUBLE(STARTINGX(this_vol()));
            }
            else if (typeinfoT == typeinfoI)
            {
                // We use a trick to save the grid information in the volume
                // If the following if is true the trick can not be used
                if (sizeof(float) != sizeof(int))
                    REPORT_ERROR(ERR_TYPE_INCORRECT,
                                 "GridVolume is integer and (sizeof(float)!= sizeof(int)");

                for (i = 0; i < 3; i++)
                    for (j = 0; j < 3; j++)
                        PACK_INT((this_grid.basis)(i, j));
                for (i = 0; i < 3; i++)
                    PACK_INT((this_grid.lowest)(i));
                for (i = 0; i < 3; i++)
                    PACK_INT((this_grid.highest)(i));
                PACK_INT(this_grid.relative_size);
                for (i = 0; i < 3; i++)
                    PACK_INT((this_grid.origin)(i));
                PACK_INT(this_grid.R2);

                // Store volume control ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
                PACK_INT(ZSIZE(this_vol()));
                PACK_INT(YSIZE(this_vol()));
                PACK_INT(XSIZE(this_vol()));
                PACK_INT(STARTINGZ(this_vol()));
                PACK_INT(STARTINGY(this_vol()));
                PACK_INT(STARTINGX(this_vol()));
            }
            else
                REPORT_ERROR(ERR_TYPE_INCORRECT, "GridVolume must be double or int\n");

            sli++;

            // Write the whole volume ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
            for (k = 0; k < ZSIZE(VOLMATRIX(this_vol)); k++)
            {
                for (i = 0; i < YSIZE(VOLMATRIX(this_vol)); i++)
                    for (j = 0; j < XSIZE(VOLMATRIX(this_vol)); j++)
                        DIRECT_VOLVOXEL(V, sli, i, j) = DIRECT_VOLVOXEL(this_vol, k, i, j);
                sli++;
            }
        }
#undef PACK_DOUBLE
#undef PACK_INT

        // Effectively write the volume .........................................
        V.write(fn);
    }

---

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

• xmipp/libraries/data/grids.h