Grids

Collaboration diagram for Grids:

Classes
class	SimpleGrid
class	Grid
class	GridVolumeT< T >

Typedefs
typedef GridVolumeT< double >	GridVolume

Functions
template<class T >
std::ostream &	operator<< (std::ostream &o, const GridVolumeT< T > &GV)

UsefulGrids Some useful grids
These are already-built grids to make your task easier. You can find here Simple Cubic (CC), Face-Centered (FCC) and Body-Centered Cubic (BCC) grids. Most of them are supposed to have its origin in the middle of the two defining corners. The defining corners (corner1 and corner2) are directly related with lowest and highest indexes inside the grid respectively. The difference is that the corners are given ALWAYS in the universal coordinate system while the lowest and highest are vectors in the grid coordinate system
SimpleGrid	Create_CC_grid (double relative_size, const Matrix1D< double > &corner1, const Matrix1D< double > &corner2, const Matrix1D< double > &origin)
Grid	Create_CC_grid (double relative_size, const Matrix1D< double > &corner1, const Matrix1D< double > &corner2)
Grid	Create_CC_grid (double relative_size, int Zdim, int Ydim, int Xdim)
Grid	Create_BCC_grid (double relative_size, const Matrix1D< double > &corner1, const Matrix1D< double > &corner2)
Grid	Create_FCC_grid (double relative_size, const Matrix1D< double > &corner1, const Matrix1D< double > &corner2)
SimpleGrid	Create_grid_within_sphere (double relative_size, const Matrix1D< double > &origin, const Matrix1D< double > &X, const Matrix1D< double > &Y, const Matrix1D< double > &Z, double R2)
Grid	Create_CC_grid (double relative_size, double R)
Grid	Create_BCC_grid (double relative_size, double R)
Grid	Create_FCC_grid (double relative_size, double R)
#define	CC   0
	CC identifier. More...
#define	FCC   1
	FCC identifier. More...
#define	BCC   2
	BCC identifier. More...

Detailed Description

The grids are one of the most basic things in the reconstruction process, since the reconstructed volumes are expressed as a linear combination of a volume basis function weighted and shifted to all positions defined by the grid. Grids in Xmipp may be as complex as you liked, a complex grid is supposed to be a superposition of simpler grids. Simple grids maintain information about the simple grids themselves (orientation, spacing, ...) while complex ones are only collections of simple grids. Usual grids as BCC (Body Centered Cubic) or FCC (Face Centered Cubic), can be expressed as the superposition of two CC (Cubic) grids.

It is important to notice that the existence of this class makes the reconstruction algorithms independent from the underlying grid, incrementing the reusability of the code.

Macro Definition Documentation

BCC

#define BCC   2

BCC identifier.

Definition at line 589 of file grids.h.

CC

#define CC   0

CC identifier.

Definition at line 585 of file grids.h.

FCC

#define FCC   1

FCC identifier.

Definition at line 587 of file grids.h.

Typedef Documentation

GridVolume

typedef GridVolumeT<double> GridVolume

Definition at line 1496 of file grids.h.

Function Documentation

Create_BCC_grid() [1/2]

Grid Create_BCC_grid	(	double	relative_size,
		const Matrix1D< double > &	corner1,
		const Matrix1D< double > &	corner2
	)

Create a BCC grid as a Complex grid (two corners). This function constructs two CC Simple grids with the following parameters

Grid(0) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          ROUNDnD((corner1+corner2)/2)

Grid(1) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          ROUNDnD((corner1+corner2)/2)+relative_size/2*vectorR3(1,1,1)

As you see the BCC grid is the superposition of 2 CC grids one shifted with the other by (0.5,0.5,0.5) units in the grid coordinate system.

Definition at line 251 of file grids.cpp.

{
    Grid             result;
    SimpleGrid       aux_grid;
    Matrix1D<double> origin = (corner1 + corner2) / 2;
    origin.selfROUND();

    //Even Slice
    //    0 1 2 3 4 5 6 7 8 9 10 11 12 (Col)
    //  0 A   A   A   A   A   A     A
    //  1
    //  2 A   A   A   A   A   A     A
    //  3
    //  4 A   A   A   A   A   A     A
    //  5
    //  6 A   A   A   A   A   A     A
    //  7
    //  8 A   A   A   A   A   A     A
    //  9
    // 10 A   A   A   A   A   A     A
    // 11
    // 12 A   A   A   A   A   A     A
    //(Row)
    //
    //Odd Slice
    //    0 1 2 3 4 5 6 7 8 9 10 11 12 (Col)
    //  0
    //  1   B   B   B   B   B    B
    //  2
    //  3   B   B   B   B   B    B
    //  4
    //  5   B   B   B   B   B    B
    //  6
    //  7   B   B   B   B   B    B
    //  8
    //  9   B   B   B   B   B    B
    // 10
    // 11   B   B   B   B   B    B
    // 12
    //(Row)

    // Grid A
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, origin);
    result.add_grid(aux_grid);

    // Grid B
    origin = origin + relative_size / 2 * vectorR3(1., 1., 1.);
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, origin);
    result.add_grid(aux_grid);

    return result;
}

Create_BCC_grid() [2/2]

Grid Create_BCC_grid	(	double	relative_size,
		double	R
	)

Create a BCC grid such that a sphere of radius R and centered at the origin is inside.

origin=(0,0,0);
x=(0.5,0.5,-0.5);
y=(0.5,-0.5,0.5);
z=(-0.5,0.5,0.5);

Definition at line 446 of file grids.cpp.

{
    Grid            result;
    SimpleGrid      aux_grid;

    Matrix1D<double> origin(3);
    origin.initZeros();
    Matrix1D<double> x(3);
    Matrix1D<double> y(3);
    Matrix1D<double> z(3);
    VECTOR_R3(x, 0.5, 0.5, -0.5);
    VECTOR_R3(y, 0.5, -0.5, 0.5);
    VECTOR_R3(z, -0.5, 0.5, 0.5);
    aux_grid = Create_grid_within_sphere(relative_size, origin, x, y, z, R * R);
    result.add_grid(aux_grid);
    return result;
}

Create_CC_grid() [1/4]

SimpleGrid Create_CC_grid	(	double	relative_size,
		const Matrix1D< double > &	corner1,
		const Matrix1D< double > &	corner2,
		const Matrix1D< double > &	origin
	)

Create a CC grid as a Simple grid. The parameters of the CC grid are:

axes:            (1,0,0),(0,1,0),(0,0,1)
lowest:          FLOORnD(grid.universe2grid(corner1))
highest:         CEILnD (grid.universe2grid(corner2))
relative_size:   specified
origin:          specified

where the specified means that it has been specified as a parameter of the function. The resulting grid is ready to work. There are two roundings for the lowest and highest indexes, they are such that corner1 and corner2 are guaranteed to be inside the Cubic grid. It might be that due to the relative size you are including more points in the universal grid that needed. Look at the following example, imagine that you have a relative size of 2.75 and that you want a cubic grid between (-1,-1,-1) and (1,1,1) (in the universal coord. system), with origin at (0,0,0); then the smallest cubic grid that includes the corners is also defined between (-1,-1,-1) and (1,1,1) in the grid system, but in the universal system these points corresponds to (-2.75,-2.75,-2.75) and (2.75,2.75,2.75). You see that you are including points (specifically, (-2,-2,-2), (-2,-2,-1), ...) that you didn't intend at the beginning, but remember that with this relative size, the resulting CC grid is the smallest one which includes the given corners.

Definition at line 196 of file grids.cpp.

{
    SimpleGrid    grid;

    // The vectors of the grid are the default ones of (1,0,0), (0,1,0),
    // and (0,0,1), and its inverse matrix is already computed
    grid.relative_size = relative_size;
    grid.origin        = origin;

    // Compute the lowest and highest indexes inside the grid
    grid.universe2grid(corner1, grid.lowest);
    grid.lowest.selfFLOOR();
    grid.universe2grid(corner2, grid.highest);
    grid.highest.selfCEIL();

    grid.R2 = -1;
    return grid;
}

Create_CC_grid() [2/4]

Grid Create_CC_grid	(	double	relative_size,
		const Matrix1D< double > &	corner1,
		const Matrix1D< double > &	corner2
	)

Create a CC grid as a Complex grid (two corners). This function makes a call to the previous one with

corner1:         specified
corner2:         specified
relative_size:   specified
origin:          ROUNDnD((corner1+corner2)/2)

That is to say, the origin of the grid is at its center, lowest and highest indexes are nearly symmetrical (lowest=-highest). The possible asymetries come from the ROUNDnD in the origin calculation.

Definition at line 217 of file grids.cpp.

{
    Grid            result;
    SimpleGrid      aux_grid;

    Matrix1D<double> origin = (corner1 + corner2) / 2;
    FOR_ALL_ELEMENTS_IN_MATRIX1D(origin)
        if (ABS(ROUND(origin(i))-origin(i))<0.45)
            origin(i)=ROUND(origin(i));
        else
            origin(i)=CEIL(origin(i));
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, origin);
    result.add_grid(aux_grid);
    return result;
}

Create_CC_grid() [3/4]

Grid Create_CC_grid	(	double	relative_size,
		int	Zdim,
		int	Ydim,
		int	Xdim
	)

Create a CC grid as a Complex grid (size). This function makes a call to the previous one with

corner1:         -origin
corner2:         vectorR3(Xdim,Ydim,Zdim)-origin-1
relative_size:   specified
origin:          vectorR3((int)(Xdim/2.0),(int)(Ydim/2.0),(int)(Zdim/2.0))

That is to say, the origin of the grid is at its center, corner1 and corner2 are chosen such that from corner1 to corner2 (both included) there are exactly (Xdim,Ydim,Zdim) samples in the universal grid. The resulting volume is symmetrical (corner1=-corner2) if the sizes are odd in all directions, and is not if the sizes are even.

Definition at line 234 of file grids.cpp.

{
    Grid            result;
    SimpleGrid      aux_grid;

    Matrix1D<double> origin =
        vectorR3((double)FLOOR(Xdim / 2.0), (double)FLOOR(Ydim / 2.0),
                  (double)FLOOR(Zdim / 2.0));
    aux_grid = Create_CC_grid(relative_size, -origin,
                              vectorR3((double)Xdim, (double)Ydim, (double)Zdim) - origin - 1,
                              vectorR3(0.0,0.0,0.0));
    result.add_grid(aux_grid);

    return result;
}

Create_CC_grid() [4/4]

Grid Create_CC_grid	(	double	relative_size,
		double	R
	)

Create a CC grid such that a sphere of radius R and centered at the origin is inside.

origin=(0,0,0);
x=(1,0,0);
y=(0,1,0);
z=(0,0,1);

Definition at line 427 of file grids.cpp.

{
    Grid            result;
    SimpleGrid      aux_grid;

    Matrix1D<double> origin(3);
    origin.initZeros();
    Matrix1D<double> x(3);
    Matrix1D<double> y(3);
    Matrix1D<double> z(3);
    VECTOR_R3(x, 1, 0, 0);
    VECTOR_R3(y, 0, 1, 0);
    VECTOR_R3(z, 0, 0, 1);
    aux_grid = Create_grid_within_sphere(relative_size, origin, x, y, z, R * R);
    result.add_grid(aux_grid);
    return result;
}

Create_FCC_grid() [1/2]

Grid Create_FCC_grid	(	double	relative_size,
		const Matrix1D< double > &	corner1,
		const Matrix1D< double > &	corner2
	)

Create a FCC grid as a Complex grid (two corners). This function constructs four CC Simple grids with the following parameters

origin:          ROUNDnD((corner1+corner2)/2)

Grid(0) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          origin

Grid(1) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          origin+relative_size/2*vectorR3(0,1,1)

Grid(2) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          origin+relative_size/2*vectorR3(1,0,1)

Grid(3) -------------------------------------
corner1:         specified
corner2:         specified
relative_size:   specified
origin:          origin+relative_size/2*vectorR3(1,1,0)

Definition at line 306 of file grids.cpp.

{

    Grid             result;
    SimpleGrid       aux_grid;
    Matrix1D<double> aux_origin;
    Matrix1D<double> cornerb;
    Matrix1D<double> origin = (corner1 + corner2) / 2;
    origin.selfROUND();

    //Even Slice
    //    0 1 2 3 4 5 6 7 8 9 10 11 12 (Col)
    //  0 A   A   A   A   A   A     A
    //  1   B   B   B   B   B    B
    //  2 A   A   A   A   A   A     A
    //  3   B   B   B   B   B    B
    //  4 A   A   A   A   A   A     A
    //  5   B   B   B   B   B    B
    //  6 A   A   A   A   A   A     A
    //  7   B   B   B   B   B    B
    //  8 A   A   A   A   A   A     A
    //  9   B   B   B   B   B    B
    // 10 A   A   A   A   A   A     A
    // 11   B   B   B   B   B    B
    // 12 A   A   A   A   A   A     A
    //(Row)
    //
    //Odd Slice
    //    0 1 2 3 4 5 6 7 8 9 10 11 12 (Col)
    //  0   C   C   C   C   C    C
    //  1 D   D   D   D   D   D     D
    //  2   C   C   C   C   C    C
    //  3 D   D   D   D   D   D     D
    //  4   C   C   C   C   C    C
    //  5 D   D   D   D   D   D     D
    //  6   C   C   C   C   C    C
    //  7 D   D   D   D   D   D     D
    //  8   C   C   C   C   C    C
    //  9 D   D   D   D   D   D     D
    // 10   C   C   C   C   C    C
    // 11 D   D   D   D   D   D     D
    // 12   C   C   C   C   C    C
    //(Row)

    // Grid A
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, origin);
    result.add_grid(aux_grid);
    // Grid D
    aux_origin = origin + relative_size / 2 * vectorR3(0., 1., 1.);
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, aux_origin);
    result.add_grid(aux_grid);
    // Grid C
    aux_origin = origin + relative_size / 2 * vectorR3(1., 0., 1.);
    aux_grid = Create_CC_grid(relative_size, corner1, corner2, aux_origin);
    result.add_grid(aux_grid);
    // Grid B
    cornerb = corner2;
    cornerb(0) = cornerb(0) - 1;
    cornerb(1) = cornerb(1) - 1;
    aux_origin = origin + relative_size / 2 * vectorR3(1., 1., 0.);
    aux_grid = Create_CC_grid(relative_size, corner1, cornerb, aux_origin);
    result.add_grid(aux_grid);

    return result;
}

Create_FCC_grid() [2/2]

Grid Create_FCC_grid	(	double	relative_size,
		double	R
	)

Create a FCC grid such that a sphere of radius R and centered at the origin is inside.

origin=(0,0,0);
x=(0.5,0.5,0);
y=(0.5,0,0.5);
z=(0,0.5,0.5);

Definition at line 465 of file grids.cpp.

{
    Grid            result;
    SimpleGrid      aux_grid;

    Matrix1D<double> origin(3);
    origin.initZeros();
    Matrix1D<double> x(3);
    Matrix1D<double> y(3);
    Matrix1D<double> z(3);
    VECTOR_R3(x, 0.5, 0.5, 0);
    VECTOR_R3(y, 0.5, 0, 0.5);
    VECTOR_R3(z, 0, 0.5, 0.5);
    aux_grid = Create_grid_within_sphere(relative_size, origin, x, y, z, R * R);
    result.add_grid(aux_grid);
    return result;
}

Create_grid_within_sphere()

SimpleGrid Create_grid_within_sphere	(	double	relative_size,
		const Matrix1D< double > &	origin,
		const Matrix1D< double > &	X,
		const Matrix1D< double > &	Y,
		const Matrix1D< double > &	Z,
		double	R2
	)

Create a simple grid fitting the given sphere. Not all index combinations are within the sphere, so attention must be paid whether a certain point is within it or not.

The formula for the grid limits are computed as

XX(highest)=CEIL((R/relative_size)/X.module());
XX(lowest)=-XX(highest);

Definition at line 376 of file grids.cpp.

{
    SimpleGrid    grid;
    double R = sqrt(R2);

    grid.set_X(X);
    grid.set_Y(Y);
    grid.set_Z(Z);
    grid.relative_size = relative_size;
    grid.origin        = origin;
    grid.R2 = R2;
    grid.lowest.initZeros(3);
    grid.highest.initZeros(3);
    grid.prepare_grid();

    // Find grid limits
    int iR = CEIL(R);
    Matrix1D<double> univ_position(3);
    Matrix1D<double> grid_position(3);
    for (int k = -iR; k <= iR; k++)
        for (int i = -iR; i <= iR; i++)
            for (int j = -iR; j <= iR; j++)
            {
                VECTOR_R3(univ_position, j, i, k);
                if (univ_position.module() > R) continue;
                grid.universe2grid(univ_position, grid_position);
                XX(grid.lowest) = XMIPP_MIN(XX(grid.lowest), FLOOR(XX(grid_position)));
                YY(grid.lowest) = XMIPP_MIN(YY(grid.lowest), FLOOR(YY(grid_position)));
                ZZ(grid.lowest) = XMIPP_MIN(ZZ(grid.lowest), FLOOR(ZZ(grid_position)));
                XX(grid.highest) = XMIPP_MAX(XX(grid.highest), CEIL(XX(grid_position)));
                YY(grid.highest) = XMIPP_MAX(YY(grid.highest), CEIL(YY(grid_position)));
                ZZ(grid.highest) = XMIPP_MAX(ZZ(grid.highest), CEIL(ZZ(grid_position)));
            }

#ifdef DEBUG
    std::cout << "Sphere radius = " << R << std::endl
    << "relative size = " << relative_size << std::endl
    << "X module      = " << X.module() << std::endl
    << "Y module      = " << Y.module() << std::endl
    << "Z module      = " << Z.module() << std::endl
    << grid
    ;
#endif
    return grid;
}

operator<<()

template<class T >

std::ostream & operator<<	(	std::ostream &	o,
		const GridVolumeT< T > &	GV
	)

Show a grid.

Definition at line 1501 of file grids.h.

{
    o << "Grid Volume -----------\n";
    o << GV.G;
    o << "Number of volumes= " << GV.VolumesNo() << std::endl;
    for (int i = 0; i < GV.VolumesNo(); i++)
    {
        o << "Volume " << i << "------------" << std::endl;
        o << GV(i)();
    }
    return o;
}