ProgClassifyCL3D Class Reference

#include <mpi_classify_CLTomo.h>

Inheritance diagram for ProgClassifyCL3D:

Collaboration diagram for ProgClassifyCL3D:

Public Member Functions
	ProgClassifyCL3D (int argc, char **argv)
	MPI constructor. More...
	ProgClassifyCL3D (const ProgClassifyCL3D &)=delete
	ProgClassifyCL3D (const ProgClassifyCL3D &&)=delete
	~ProgClassifyCL3D ()
	Destructor. More...
ProgClassifyCL3D &	operator= (const ProgClassifyCL3D &)=delete
ProgClassifyCL3D &	operator= (const ProgClassifyCL3D &&)=delete
void	readParams ()
	Read. More...
void	show () const
	Show. More...
void	defineParams ()
	Usage. More...
void	produceSideInfo ()
	Produce side info. More...
void	run ()
	Run. More...
Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)
const char *	getParam (const char *param, const char *subparam, int arg=0)
int	getIntParam (const char *param, int arg=0)
int	getIntParam (const char *param, const char *subparam, int arg=0)
double	getDoubleParam (const char *param, int arg=0)
double	getDoubleParam (const char *param, const char *subparam, int arg=0)
float	getFloatParam (const char *param, int arg=0)
float	getFloatParam (const char *param, const char *subparam, int arg=0)
void	getListParam (const char *param, StringVector &list)
int	getCountParam (const char *param)
bool	checkParam (const char *param)
bool	existsParam (const char *param)
void	addParamsLine (const String &line)
void	addParamsLine (const char *line)
ParamDef *	getParamDef (const char *param) const
virtual void	quit (int exit_code=0) const
virtual int	tryRun ()
void	initProgress (size_t total, size_t stepBin=60)
void	setProgress (size_t value=0)
void	endProgress ()
void	processDefaultComment (const char *param, const char *left)
void	setDefaultComment (const char *param, const char *comment)
virtual void	initComments ()
void	setProgramName (const char *name)
void	addUsageLine (const char *line, bool verbatim=false)
void	clearUsage ()
void	addExampleLine (const char *example, bool verbatim=true)
void	addSeeAlsoLine (const char *seeAlso)
void	addKeywords (const char *keywords)
const char *	name () const
virtual void	usage (int verb=0) const
virtual void	usage (const String &param, int verb=2)
int	version () const
virtual void	read (int argc, const char **argv, bool reportErrors=true)
virtual void	read (int argc, char **argv, bool reportErrors=true)
void	read (const String &argumentsLine)
	XmippProgram ()
	XmippProgram (int argc, const char **argv)
virtual	~XmippProgram ()

Public Attributes
FileName	fnSel
	Input selfile with the images to quantify. More...
FileName	fnCodes0
	Input selfile with initial codes. More...
FileName	fnOut
	Output rootname. More...
FileName	fnSym
	Symmetry file or code. More...
int	Niter
	Number of iterations. More...
int	Ncodes0
	Initial number of code vectors. More...
int	Ncodes
	Final number of code vectors. More...
int	Nneighbours
	Number of neighbours. More...
double	PminSize
	Minimum size of a node. More...
double	maxFreq
	Maximum frequency for the alignment. More...
double	sparsity
	Sparsity factor (0<f<1; 1=drop all coefficients, 0=do not drop any coefficient) More...
double	DWTsparsity
	DWT Sparsity factor (0<f<1; 1=drop all coefficients, 0=do not drop any coefficient) More...
bool	classifyAllImages
	Clasify all images. More...
bool	randomizeStartingOrientation
	Use this option to avoid aligning at the beginning all the missing wedges. More...
double	maxShiftZ
	Maximum shift Z. More...
double	maxShiftY
	Maximum shift Y. More...
double	maxShiftX
	Maximum shift X. More...
double	maxRot
	Maximum rot. More...
double	maxTilt
	Maximum tilt. More...
double	maxPsi
	Maximum psi. More...
Mask	mask
	Mask. More...
bool	dontAlign
	Don't align. More...
bool	generateAlignedVolumes
	Generate aligned subvolumes. More...
SymList	SL
MetaDataDb	SF
std::vector< size_t >	objId
CL3D	vq
MpiNode *	node
GaussianInterpolator	gaussianInterpolator
size_t	Zdim
size_t	Ydim
size_t	Xdim
PyObject *	frmFunc
	Pointer to the Python FRM alignment function. More...
PyObject *	wedgeClass
	Pointer to the Python GeneralWedge class. More...
double	maxShift
	Max shift. More...
MultidimArray< unsigned char >	maxFreqMask
	MaxFreq mask. More...
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug

Additional Inherited Members
Protected Member Functions inherited from XmippProgram
void	defineCommons ()
Protected Attributes inherited from XmippProgram
int	errorCode
ProgramDef *	progDef
	Program definition and arguments parser. More...
std::map< String, CommentList >	defaultComments
int	argc
	Original command line arguments. More...
const char **	argv

Detailed Description

CL3D parameters.

Definition at line 220 of file mpi_classify_CLTomo.h.

Constructor & Destructor Documentation

ProgClassifyCL3D() [1/3]

ProgClassifyCL3D::ProgClassifyCL3D	(	int	argc,
		char **	argv
	)

MPI constructor.

Definition at line 1300 of file mpi_classify_CLTomo_prog.cpp.

{
    node = new MpiNode(argc, argv);
    if (!node->isMaster())
        verbose = 0;
    mask.allowed_data_types=INT_MASK;
}

ProgClassifyCL3D() [2/3]

ProgClassifyCL3D::ProgClassifyCL3D ( const ProgClassifyCL3D &  )

delete

ProgClassifyCL3D() [3/3]

ProgClassifyCL3D::ProgClassifyCL3D ( const ProgClassifyCL3D &&  )

delete

~ProgClassifyCL3D()

ProgClassifyCL3D::~ProgClassifyCL3D

(

)

Destructor.

Definition at line 1309 of file mpi_classify_CLTomo_prog.cpp.

{
    delete node;
}

Member Function Documentation

defineParams()

void ProgClassifyCL3D::defineParams ( )

virtual

Usage.

Reimplemented from XmippProgram.

Definition at line 1377 of file mpi_classify_CLTomo_prog.cpp.

{
    addUsageLine("Divide a selfile of volumes into the desired number of classes. ");
    addUsageLine("+Vector quantization with correntropy and a probabilistic criterion is used for creating the subdivisions.");
    addUsageLine("+Correlation and the standard maximum correlation criterion can also be used and normally produce good results.");
    addUsageLine("+Correntropy and the probabilistic clustering criterion are recommended for images with very low SNR or cases in which the correlation have clear difficulties to converge.");
    addUsageLine("+");
    addUsageLine("+The algorithm is fully described in [[http://www.ncbi.nlm.nih.gov/pubmed/20362059][this article]].");
    addUsageLine("+");
    addUsageLine("+An interesting convergence criterion is the number of images changing classes between iterations. If a low percentage of the image change class, then the clustering is rather stable and clear.");
    addUsageLine("+If many images change class, it is likely that there is not enough SNR to determine so many classes. It is recommended to reduce the number of classes");
    addParamsLine("    -i <selfile>             : Selfile with the input images");
    addParamsLine("   [--oroot <root=class>]    : Output rootname, by default, class");
    addParamsLine("   [--iter <N=20>]           : Number of iterations");
    addParamsLine("   [--nref0 <N=2>]           : Initial number of code vectors");
    addParamsLine("or  --ref0 <selfile=\"\">    : Selfile with initial code vectors");
    addParamsLine("   [--nref <N=16>]           : Final number of code vectors");
    addParamsLine("   [--neigh+ <N=4>]          : Number of neighbour code vectors");
    addParamsLine("                             : Set -1 for all");
    addParamsLine("   [--minsize+ <N=20>]       : Percentage minimum node size");
    addParamsLine("   [--sparsity+ <f=0.975>]   : Percentage of Fourier coefficients to drop");
    addParamsLine("   [--DWTsparsity+ <f=0.99>] : Percentage of wavelet coefficients to drop");
    addParamsLine("   [--maxShiftX <d=10>]      : Maximum allowed shift in X");
    addParamsLine("   [--maxShiftY <d=10>]      : Maximum allowed shift in Y");
    addParamsLine("   [--maxShiftZ <d=10>]      : Maximum allowed shift in Z");
    addParamsLine("   [--maxRot <d=360>]        : Maximum allowed rotational angle in absolute value");
    addParamsLine("   [--maxTilt <d=360>]       : Maximum allowed tilt angle in absolute value");
    addParamsLine("   [--maxPsi <d=360>]        : Maximum allowed in-plane angle in absolute value");
    addParamsLine("   [--classifyAllImages]     : By default, some images may not be classified. Use this option to classify them all.");
    addParamsLine("   [--sym <s=c1>]            : Symmetry of the classes to be reconstructed");
    addParamsLine("   [--maxFreq <w=0.2>]       : Maximum frequency to be reconstructed");
    addParamsLine("   [--randomizeStartingOrientation] : Use this option to avoid aligning all missing wedges");
    addParamsLine("   [--dontAlign]             : Do not align volumes, only classify");
    addParamsLine("   [--generateAlignedVolumes]: Generate aligned subvolumes at the end");
    Mask::defineParams(this,INT_MASK,NULL,NULL,true);
    addExampleLine("The MPI program as to be called through a python wrapper that encapsulates some path setting",false);
    addExampleLine(" ",false);
    addExampleLine("Call the program as xmipp_classify_CLTomo [numberOfMPIProcessors] [arguments as above]",false);
    addExampleLine("xmipp_classify_CLTomo 8 -i images.stk --nref 256 --oroot class --iter 10");
}

operator=() [1/2]

ProgClassifyCL3D& ProgClassifyCL3D::operator= ( const ProgClassifyCL3D &  )

delete

operator=() [2/2]

ProgClassifyCL3D& ProgClassifyCL3D::operator= ( const ProgClassifyCL3D &&  )

delete

produceSideInfo()

void ProgClassifyCL3D::produceSideInfo

(

)

Produce side info.

Definition at line 1418 of file mpi_classify_CLTomo_prog.cpp.

{
    gaussianInterpolator.initialize(6, 60000, false);

    // Get image dimensions
    SF.read(fnSel);
    size_t Ndim;
    getImageSize(SF, Xdim, Ydim, Zdim, Ndim);

    // MaxFreq mask
    MultidimArray<double> V;
    MultidimArray< std::complex<double> > VF;
    V.initZeros(Zdim,Ydim,Xdim);
    FourierTransformer transformer;
    transformer.FourierTransform(V,VF);
    maxFreqMask.initZeros(VF);
    Matrix1D<int> idx(3);
    Matrix1D<double> freq(3);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(maxFreqMask)
    {
        XX(idx)=j;
        YY(idx)=i;
        ZZ(idx)=k;
        FFT_idx2digfreq(V,idx,freq);
        if (freq.module()<=maxFreq)
            A3D_ELEM(maxFreqMask,k,i,j)=1;
    }

    // Prepare symmetry list
    SL.readSymmetryFile(fnSym);

    // Prepare the Task distributor
    SF.findObjects(objId);

    // Prepare mask for evaluating the noise outside
    MultidimArray<int> sphericalMask;
    sphericalMask.resize(Zdim, Ydim, Xdim);
    sphericalMask.setXmippOrigin();
    BinaryCircularMask(sphericalMask, Xdim / 2, INNER_MASK);

    mask.generate_mask(Zdim, Ydim, Xdim);
    MultidimArray<int> &mMask=mask.get_binary_mask();
    mMask.setXmippOrigin();
    FOR_ALL_ELEMENTS_IN_ARRAY3D(sphericalMask)
    if (A3D_ELEM(sphericalMask,k,i,j)==0)
        A3D_ELEM(mMask,k,i,j)=0;

    // Read input code vectors if available
    std::vector<MultidimArray<double> > codes0;
    if (fnCodes0 != "")
    {
        Image<double> I;
        MetaDataDb SFCodes(fnCodes0);

        for (size_t objId : SFCodes.ids())
        {
            I.readApplyGeo(SFCodes, objId);
            I().setXmippOrigin();
            codes0.push_back(I());
        }
        Ncodes0 = codes0.size();
    }
    vq.initialize(SF, codes0);
}

readParams()

void ProgClassifyCL3D::readParams ( )

virtual

Read.

Reimplemented from XmippProgram.

Definition at line 1315 of file mpi_classify_CLTomo_prog.cpp.

{
    fnSel = getParam("-i");
    fnOut = getParam("--oroot");
    fnCodes0 = getParam("--ref0");
    Niter = getIntParam("--iter");
    Nneighbours = getIntParam("--neigh");
    Ncodes0 = getIntParam("--nref0");
    Ncodes = getIntParam("--nref");
    PminSize = getDoubleParam("--minsize");
    sparsity = getDoubleParam("--sparsity");
    DWTsparsity = getDoubleParam("--DWTsparsity");
    maxShiftZ = getDoubleParam("--maxShiftZ");
    maxShiftY = getDoubleParam("--maxShiftY");
    maxShiftX = getDoubleParam("--maxShiftX");
    maxShift=std::max(maxShiftX,maxShiftY);
    maxShift=std::max(maxShift,maxShiftZ);
    maxFreq=getDoubleParam("--maxFreq");
    maxRot = getDoubleParam("--maxRot");
    maxTilt = getDoubleParam("--maxTilt");
    maxPsi = getDoubleParam("--maxPsi");
    classifyAllImages = checkParam("--classifyAllImages");
    randomizeStartingOrientation = checkParam("--randomizeStartingOrientation");
    fnSym = getParam("--sym");
    if (checkParam("--mask"))
        mask.readParams(this);
    dontAlign = checkParam("--dontAlign");
    generateAlignedVolumes = checkParam("--generateAlignedVolumes");

    prmCL3Dprog = this; // FIXME HACK because of the global variable. Solve it properly
}

run()

void ProgClassifyCL3D::run ( )

virtual

Run.

Reimplemented from XmippProgram.

Definition at line 1483 of file mpi_classify_CLTomo_prog.cpp.

{
    Python::initPythonAndNumpy();
    frmFunc = Python::getFunctionRef("sh_alignment.frm", "frm_align");
    wedgeClass = Python::getClassRef("sh_alignment.tompy.filter", "GeneralWedge");

    CREATE_LOG();
    show();
    produceSideInfo();

    // Run all iterations
    int level = 0;
    int Q = vq.P.size();
    vq.run(fnOut, level);

    while (Q < Ncodes)
    {
        if (node->rank == 0)
            std::cout << "Spliting nodes ...\n";

        int Nclean = vq.cleanEmptyNodes();
        int Nsplits = XMIPP_MIN(Q,Ncodes-Q) + Nclean;

        for (int i = 0; i < Nsplits; i++)
        {
            vq.splitFirstNode();
            if (node->rank == 0)
                std::cout << "Currently there are " << vq.P.size() << " nodes"
                << std::endl;
        }

        Q = vq.P.size();
        level++;
        vq.run(fnOut, level);
    }
    if (node->rank == 0)
    {
        std::sort(vq.P.begin(), vq.P.end(), SDescendingClusterSort());
        Q = vq.P.size();
        MetaDataDb SFq, SFclassified, SFaux, SFaux2;
        for (int q = 0; q < Q; q++)
        {
            SFq.read(formatString("class%06d_images@%s_classes_level_%02d.xmd", q + 1,
                                  fnOut.c_str(), level));
            SFq.fillConstant(MDL_REF, integerToString(q + 1));
            SFq.fillConstant(MDL_ENABLED, "1");
            SFclassified.unionAll(SFq);
        }
        SFaux = SF;
        SFaux.subtraction(SFclassified, MDL_IMAGE);
        SFaux.fillConstant(MDL_ENABLED, "-1");
        SFaux2.join1(SFclassified, SF, MDL_IMAGE, LEFT);
        SFclassified.clear();
        SFaux2.unionAll(SFaux);
        SFaux.clear();
        SFaux.sort(SFaux2, MDL_IMAGE);
        SFaux.write(fnOut + "_images.xmd");
    }

    // Produce aligned volumes
    if (generateAlignedVolumes)
    {
        node->barrierWait();
        MetaDataDb MDimages, MDaligned;
        MDimages.read(fnOut+"_images.xmd");
        FileName fnAligned=fnOut+"_aligned.stk";
        FileName fnAlignedMD=fnOut+"_aligned.xmd";
        if (node->rank==0)
            createEmptyFile(fnAligned,(int)Xdim,(int)Ydim,(int)Zdim,MDimages.size());
        node->barrierWait();
        size_t idx=1;
        Image<double> V, Valigned;
        FileName fnImg;
        Matrix2D<double> A,E,T;
        Matrix1D<double> r(3);
        size_t itemId;
        for (size_t objId: MDimages.ids())
        {
            if (idx%node->size==node->rank)
            {
                MDimages.getValue(MDL_IMAGE,fnImg,objId);
                V.read(fnImg);
                V().setXmippOrigin();
                double x,y,z,rot,tilt,psi;
                MDimages.getValue(MDL_ANGLE_ROT,rot,objId);
                MDimages.getValue(MDL_ANGLE_TILT,tilt,objId);
                MDimages.getValue(MDL_ANGLE_PSI,psi,objId);
                MDimages.getValue(MDL_SHIFT_X,x,objId);
                MDimages.getValue(MDL_SHIFT_Y,y,objId);
                MDimages.getValue(MDL_SHIFT_Z,z,objId);

                Euler_angles2matrix(rot, tilt, psi, E, true);
                XX(r)=x;
                YY(r)=y;
                ZZ(r)=z;
                translation3DMatrix(r,T);
                A=E*T;

                applyGeometry(xmipp_transformation::BSPLINE3,Valigned(),V(),A,xmipp_transformation::IS_NOT_INV,xmipp_transformation::DONT_WRAP,0.);
                Valigned.write(fnAligned,idx,true,WRITE_REPLACE);
            }
            if (node->rank==0)
            {
                MDimages.getValue(MDL_ITEM_ID,itemId,objId);
                size_t newId=MDaligned.addObject();
                MDaligned.setValue(MDL_IMAGE,formatString("%06d@%s",idx,fnAligned.c_str()),newId);
                MDaligned.setValue(MDL_ITEM_ID,itemId,newId);
            }
            ++idx;
        }

        if (node->rank == 0)
        {
            MDaligned.write(fnAlignedMD);

            // Correct the class groups
            Q = vq.P.size();
            MetaDataDb SFq, SFqaligned;
            FileName fnClass;
            for (int q = 0; q < Q; q++)
            {
                fnClass=formatString("class%06d_images@%s_classes_level_%02d.xmd", q + 1, fnOut.c_str(), level);
                SFq.read(fnClass);
                SFq.renameColumn(MDL_IMAGE,MDL_IMAGE_ORIGINAL);
                SFqaligned.join1(SFq,MDaligned,MDL_ITEM_ID);
                SFqaligned.write(fnClass,MD_APPEND);
            }
        }
    }
    CLOSE_LOG();
}

show()

void ProgClassifyCL3D::show ( ) const

virtual

Show.

Reimplemented from XmippProgram.

Definition at line 1347 of file mpi_classify_CLTomo_prog.cpp.

{
    if (!verbose)
        return;
    std::cout << "Input images:            " << fnSel << std::endl
    << "Output images:           " << fnOut << std::endl
    << "Iterations:              " << Niter << std::endl;
    if (fnCodes0!="")
        std::cout << "CodesSel0:               " << fnCodes0 << std::endl;
    else
        std::cout << "Codes0:                  " << Ncodes0 << std::endl;
    std::cout << "Codes:                   " << Ncodes << std::endl
    << "Neighbours:              " << Nneighbours << std::endl
    << "Minimum node size:       " << PminSize << std::endl
    << "Sparsity:                " << sparsity << std::endl
    << "DWT Sparsity:            " << DWTsparsity << std::endl
    << "Maximum shift Z:         " << maxShiftZ << std::endl
    << "Maximum shift Y:         " << maxShiftY << std::endl
    << "Maximum shift X:         " << maxShiftX << std::endl
    << "Maximum rot:             " << maxRot << std::endl
    << "Maximum tilt:            " << maxTilt << std::endl
    << "Maximum psi:             " << maxPsi << std::endl
    << "Classify all images:     " << classifyAllImages << std::endl
    << "Symmetry:                " << fnSym << std::endl
    << "Don't align:             " << dontAlign << std::endl
    << "Generate aligned volumes:" << generateAlignedVolumes << std::endl
    ;
    mask.show();
}

Member Data Documentation

classifyAllImages

bool ProgClassifyCL3D::classifyAllImages

Clasify all images.

Definition at line 259 of file mpi_classify_CLTomo.h.

dontAlign

bool ProgClassifyCL3D::dontAlign

Don't align.

Definition at line 287 of file mpi_classify_CLTomo.h.

DWTsparsity

double ProgClassifyCL3D::DWTsparsity

DWT Sparsity factor (0<f<1; 1=drop all coefficients, 0=do not drop any coefficient)

Definition at line 256 of file mpi_classify_CLTomo.h.

fnCodes0

FileName ProgClassifyCL3D::fnCodes0

Input selfile with initial codes.

Definition at line 226 of file mpi_classify_CLTomo.h.

fnOut

FileName ProgClassifyCL3D::fnOut

Output rootname.

Definition at line 229 of file mpi_classify_CLTomo.h.

fnSel

FileName ProgClassifyCL3D::fnSel

Input selfile with the images to quantify.

Definition at line 223 of file mpi_classify_CLTomo.h.

fnSym

FileName ProgClassifyCL3D::fnSym

Symmetry file or code.

Definition at line 232 of file mpi_classify_CLTomo.h.

frmFunc

PyObject* ProgClassifyCL3D::frmFunc

Pointer to the Python FRM alignment function.

Definition at line 340 of file mpi_classify_CLTomo.h.

gaussianInterpolator

GaussianInterpolator ProgClassifyCL3D::gaussianInterpolator

Definition at line 334 of file mpi_classify_CLTomo.h.

generateAlignedVolumes

bool ProgClassifyCL3D::generateAlignedVolumes

Generate aligned subvolumes.

Definition at line 290 of file mpi_classify_CLTomo.h.

mask

Mask ProgClassifyCL3D::mask

Mask.

Definition at line 284 of file mpi_classify_CLTomo.h.

maxFreq

double ProgClassifyCL3D::maxFreq

Maximum frequency for the alignment.

Definition at line 250 of file mpi_classify_CLTomo.h.

maxFreqMask

MultidimArray<unsigned char> ProgClassifyCL3D::maxFreqMask

MaxFreq mask.

Definition at line 349 of file mpi_classify_CLTomo.h.

maxPsi

double ProgClassifyCL3D::maxPsi

Maximum psi.

Definition at line 281 of file mpi_classify_CLTomo.h.

maxRot

double ProgClassifyCL3D::maxRot

Maximum rot.

Definition at line 275 of file mpi_classify_CLTomo.h.

maxShift

double ProgClassifyCL3D::maxShift

Max shift.

Definition at line 346 of file mpi_classify_CLTomo.h.

maxShiftX

double ProgClassifyCL3D::maxShiftX

Maximum shift X.

Definition at line 271 of file mpi_classify_CLTomo.h.

maxShiftY

double ProgClassifyCL3D::maxShiftY

Maximum shift Y.

Definition at line 268 of file mpi_classify_CLTomo.h.

maxShiftZ

double ProgClassifyCL3D::maxShiftZ

Maximum shift Z.

Definition at line 265 of file mpi_classify_CLTomo.h.

maxTilt

double ProgClassifyCL3D::maxTilt

Maximum tilt.

Definition at line 278 of file mpi_classify_CLTomo.h.

Ncodes

int ProgClassifyCL3D::Ncodes

Final number of code vectors.

Definition at line 241 of file mpi_classify_CLTomo.h.

Ncodes0

int ProgClassifyCL3D::Ncodes0

Initial number of code vectors.

Definition at line 238 of file mpi_classify_CLTomo.h.

Niter

int ProgClassifyCL3D::Niter

Number of iterations.

Definition at line 235 of file mpi_classify_CLTomo.h.

Nneighbours

int ProgClassifyCL3D::Nneighbours

Number of neighbours.

Definition at line 244 of file mpi_classify_CLTomo.h.

node

MpiNode* ProgClassifyCL3D::node

Definition at line 331 of file mpi_classify_CLTomo.h.

objId

std::vector<size_t> ProgClassifyCL3D::objId

Definition at line 325 of file mpi_classify_CLTomo.h.

PminSize

double ProgClassifyCL3D::PminSize

Minimum size of a node.

Definition at line 247 of file mpi_classify_CLTomo.h.

randomizeStartingOrientation

bool ProgClassifyCL3D::randomizeStartingOrientation

Use this option to avoid aligning at the beginning all the missing wedges.

Definition at line 262 of file mpi_classify_CLTomo.h.

SF

MetaDataDb ProgClassifyCL3D::SF

Definition at line 322 of file mpi_classify_CLTomo.h.

SL

SymList ProgClassifyCL3D::SL

Definition at line 293 of file mpi_classify_CLTomo.h.

sparsity

double ProgClassifyCL3D::sparsity

Sparsity factor (0<f<1; 1=drop all coefficients, 0=do not drop any coefficient)

Definition at line 253 of file mpi_classify_CLTomo.h.

vq

CL3D ProgClassifyCL3D::vq

Definition at line 328 of file mpi_classify_CLTomo.h.

wedgeClass

PyObject* ProgClassifyCL3D::wedgeClass

Pointer to the Python GeneralWedge class.

Definition at line 343 of file mpi_classify_CLTomo.h.

Xdim

size_t ProgClassifyCL3D::Xdim

Definition at line 337 of file mpi_classify_CLTomo.h.

Ydim

size_t ProgClassifyCL3D::Ydim

Definition at line 337 of file mpi_classify_CLTomo.h.

Zdim

size_t ProgClassifyCL3D::Zdim

Definition at line 337 of file mpi_classify_CLTomo.h.

---

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

• xmipp/libraries/parallel/mpi_classify_CLTomo.h
• xmipp/libraries/parallel/mpi_classify_CLTomo_prog.cpp