Grid Class Reference

#include <grids.h>

Public Member Functions
void	add_grid (const SimpleGrid &SG)
const SimpleGrid &	operator() (size_t n) const
SimpleGrid &	operator() (size_t n)
void	get_SimpleGrid (int n, SimpleGrid &G) const
size_t	GridsNo () const
void	assign (const Grid &G)
void	clear ()
void	voxel_corners (Matrix1D< double > &Gcorner1, Matrix1D< double > &Gcorner2, const Matrix2D< double > *V=nullptr) const

Friends
std::ostream &	operator<< (std::ostream &o, const Grid &grid)

Detailed Description

Complex Grids. Grid is the structure where "true" grids like (BCC, FCC, CC, ...) are stored. A complex grid is nothing else than a list of Simple Grids, and this is so because a complex grid is supposed to be the superposition of several simple grids, each one with all the information that a SimpleGrid has got. When projecting the volume or whatever what you must do is to project each simple grid, or apply the function you want to each simple grid. For instance, here you have a function to show a complex grid

std::ostream& operator << (std::ostream& o, Grid &grid) {
   o << "Complex Grid -------------------------------------\n";
   for (int i=0; i<grid.GridsNo(); i++) o << grid(i);
   return o;
}

Initially the complex grid is empty, and you must fill it adding new simple grids to it with the function Grid::add_grid . The simple grids must be prepared to work before entering into the complex one.

Definition at line 479 of file grids.h.

Member Function Documentation

add_grid()

void Grid::add_grid ( const SimpleGrid &  SG )

inline

Add a grid to the set. The complex grid is a list of simple grids, use this function to add a simple grid to the complex one, remember that before using this function the simple grid must have been prepared to work (see SimpleGrid::prepare_grid ). See class documentation for an example of use.

Definition at line 491 of file grids.h.

    {
        LG.push_back(SG);
    }

assign()

void Grid::assign ( const Grid &  G )

inline

Another function for assignment.

Definition at line 553 of file grids.h.

    {
        *this = G;
    }

clear()

void Grid::clear ( )

inline

Clear.

Definition at line 559 of file grids.h.

    {
        LG.clear();
    }

get_SimpleGrid()

void Grid::get_SimpleGrid ( int  n, SimpleGrid &  G  ) const

inline

Another function for get a "pointer" to a simple grid.

Definition at line 527 of file grids.h.

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

GridsNo()

size_t Grid::GridsNo ( ) const

inline

Number of simple grids inside. This function returns the number of simple grids inside the complex grid. \ Ex: std::cout << "In BCC there are " << BCC.GridsNo() << " grids\n";

Definition at line 536 of file grids.h.

    {
        return LG.size();
    }

operator()() [1/2]

const SimpleGrid& Grid::operator() ( size_t  n ) const

inline

Get a constant "pointer" to a simple grid. The complex grid is built upon the STL vectors, using this function you can access (constant access, you cannot modify the simple grid) any of the simple grids inside the list. Remember that the first grid is the number 0. An exception is thrown if you try to access a simple grid beyond the number of actual simple grids inside the complex one. \ Ex: std::cout << "The first grid in the BCC grid is " << BCC(0);

Definition at line 504 of file grids.h.

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

operator()() [2/2]

SimpleGrid& Grid::operator() ( size_t  n )

inline

Get a "pointer" to a simple grid. The complex grid is built upon the STL vectors, using this function you can access any of the simple grids inside the list. Remember that the first grid is the number 0. An exception is thrown if you try to access a simple grid beyond the number of actual simple grids inside the complex one. \ Ex: BCC(0).origin=vectorR3(1,1,1);

Definition at line 519 of file grids.h.

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

voxel_corners()

void Grid::voxel_corners	(	Matrix1D< double > &	Gcorner1,
		Matrix1D< double > &	Gcorner2,
		const Matrix2D< double > *	V = nullptr
	)		const

Minimum size for a voxel volume if it is to hold the whole grid. The returned vectors Gcorner1 and Gcorner2 enclose this grid. You can supply a deformation matrix (see blobs2voxels )

Definition at line 120 of file grids.cpp.

{
    Matrix1D<double> SGcorner1(3);     // Subgrid corners
    Matrix1D<double> SGcorner2(3);     // Subgrid corners
    SPEED_UP_temps012;

    // Look for the lowest and highest volume coordinate
    Gcorner1.resize(3);  // lowest and highest coord.
    Gcorner2.resize(3);
    for (size_t n = 0; n < GridsNo(); n++)
    {
        // Find box for this grid
        bool first;
        first = true;
        for (auto k = (int)ZZ(LG[n].lowest); k <= ZZ(LG[n].highest); k++)
            for (auto i = (int)YY(LG[n].lowest); i <= YY(LG[n].highest); i++)
                for (auto j = (int)XX(LG[n].lowest); j <= XX(LG[n].highest); j++)
                {
                    Matrix1D<double> grid_index(3);
                    Matrix1D<double> univ_position(3);
                    VECTOR_R3(grid_index, j, i, k);
                    LG[n].grid2universe(grid_index, univ_position);
                    if (V != nullptr)
                    {
                        M3x3_BY_V3x1(univ_position, *V, univ_position);
                    }
                    if (!LG[n].is_interesting(univ_position)) continue;
                    if (!first)
                    {
                        XX(SGcorner1) = XMIPP_MIN(XX(SGcorner1), XX(univ_position));
                        YY(SGcorner1) = XMIPP_MIN(YY(SGcorner1), YY(univ_position));
                        ZZ(SGcorner1) = XMIPP_MIN(ZZ(SGcorner1), ZZ(univ_position));

                        XX(SGcorner2) = XMIPP_MAX(XX(SGcorner2), XX(univ_position));
                        YY(SGcorner2) = XMIPP_MAX(YY(SGcorner2), YY(univ_position));
                        ZZ(SGcorner2) = XMIPP_MAX(ZZ(SGcorner2), ZZ(univ_position));
                    }
                    else
                    {
                        SGcorner2 = SGcorner1 = univ_position;
                        first = false;
                    }
                }

        // Compare with the rest of the grids
        if (n != 0)
        {
            XX(Gcorner1) = XMIPP_MIN(XX(Gcorner1), XX(SGcorner1));
            YY(Gcorner1) = XMIPP_MIN(YY(Gcorner1), YY(SGcorner1));
            ZZ(Gcorner1) = XMIPP_MIN(ZZ(Gcorner1), ZZ(SGcorner1));

            XX(Gcorner2) = XMIPP_MAX(XX(Gcorner2), XX(SGcorner2));
            YY(Gcorner2) = XMIPP_MAX(YY(Gcorner2), YY(SGcorner2));
            ZZ(Gcorner2) = XMIPP_MAX(ZZ(Gcorner2), ZZ(SGcorner2));
        }
        else
        {
            Gcorner1 = SGcorner1;
            Gcorner2 = SGcorner2;
        }

#ifdef DEBUG
        std::cout << LG[n];
        std::cout << "SGcorner1 " << SGcorner1.transpose() << std::endl;
        std::cout << "SGcorner2 " << SGcorner2.transpose() << std::endl;
        std::cout << "Gcorner1  " << Gcorner1.transpose() << std::endl;
        std::cout << "Gcorner2  " << Gcorner2.transpose() << std::endl;
#endif
    }
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  o, const Grid &  grid  )

friend

Show a complex grid. Show all simple grids inside the complex one. \ Ex: std::cout << BCC;

Definition at line 544 of file grids.h.

    {
        o << "Complex Grid -------------------------------------\n";
        for (size_t i = 0; i < grid.GridsNo(); i++)
            o << grid(i);
        return o;
    }

---

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

• xmipp/libraries/data/grids.h
• xmipp/libraries/data/grids.cpp