#include <classify_significant.h>

Inheritance diagram for ProgClassifySignificant:

Collaboration diagram for ProgClassifySignificant:

Public Member Functions
	~ProgClassifySignificant ()
	Destructor. More...

void	readParams ()
	Read argument from command line. More...

void	show ()
	Show. More...

void	defineParams ()
	Define parameters. More...

void	produceSideInfo ()

void	run ()

void	generateProjection (size_t volumeIdx, size_t poolIdx, MDRow &currentRow)

void	selectSubset (size_t particleId, bool &flagEmpty)

void	updateClass (int n, double wn)

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	show () 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	fnVols

FileName	fnIds

FileName	fnAngles

FileName	fnOut

int	numFsc

int	pad

double	wmin

bool	onlyIntersection

int	numVotes

bool	isFsc

std::vector< FourierProjector * >	projector

std::vector< FileName >	setFsc

std::vector< size_t >	setIds

std::vector< MetaDataVec >	setAngles

std::vector< MetaDataVec >	classifiedAngles

std::vector< size_t >	currentRowIdx

std::vector< MetaDataVec >	subsetAngles

std::vector< MultidimArray< double > * >	subsetProjections

std::vector< std::vector< size_t > >	subsetProjectionIdx

std::vector< Image< double > * >	Iexp

Projection	Paux

std::vector< std::vector< double > >	setFscValues

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

Classify Significant Parameters.

Definition at line 38 of file classify_significant.h.

Constructor & Destructor Documentation

◆ ~ProgClassifySignificant()

ProgClassifySignificant::~ProgClassifySignificant ( )

Destructor.

Definition at line 34 of file classify_significant.cpp.

 {
     for (size_t i=0; i<projector.size(); i++)
         delete projector[i];
     for (size_t i=0; i<subsetProjections.size(); i++)
         delete subsetProjections[i];
     for (size_t i=0; i<Iexp.size(); i++)
         delete Iexp[i];
 }

Member Function Documentation

◆ defineParams()

void ProgClassifySignificant::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippProgram.

Definition at line 82 of file classify_significant.cpp.

 {
     addUsageLine("Classify a set of images into different classes. See protocol_reconstruct_heterogeneous");
     addParamsLine("   --ref <metadata>            : Reference volumes");
     addParamsLine("   --id <metadata>             : List of itemIds to classified. Sorted.");
     addParamsLine("   --angles <metadata>         : Angles assigned. Each image should have one or several angles");
     addParamsLine("                               : for each volume. The assignment per volume should be organized");
     addParamsLine("                               : in different blocks");
     addParamsLine("   -o <metadata>               : Output metadata with a set of angles per volume");
     addParamsLine("  [--votes <numVotes=5>]       : Minimum number of votes to consider an image belonging to a volume");
     addParamsLine("  [--onlyIntersection]         : Flag to select only the images belonging only to the set intersection");
     addParamsLine("  [--padding <p=2>]            : Padding factor");
     addParamsLine("  [--minWeight <w=0.1>]        : Minimum weight");
     addParamsLine("  [--fsc <md1> <md2>]           : Metadata with FSC values to take into account the SNR in the correlation measure");
 }

◆ generateProjection()

void ProgClassifySignificant::generateProjection	(	size_t	volumeIdx,
		size_t	poolIdx,
		MDRow &	currentRow
	)

Generate the projection of a given volume following the instructions of currentRow. The result is stored in subsetProjections at poolIdx

Definition at line 149 of file classify_significant.cpp.

 {
     double rot, tilt, psi, x, y;
     bool flip;
     Matrix2D<double> A;
     Image<double> &Iaux = *Iexp[0];
     auto xdim = (int)XSIZE(Iaux());
 
     currentRow.getValue(MDL_ANGLE_ROT,rot);
     currentRow.getValue(MDL_ANGLE_TILT,tilt);
     currentRow.getValue(MDL_ANGLE_PSI,psi);
     currentRow.getValue(MDL_SHIFT_X,x);
     currentRow.getValue(MDL_SHIFT_Y,y);
     currentRow.getValue(MDL_FLIP,flip);
     A.initIdentity(3);
     MAT_ELEM(A,0,2)=x;
     MAT_ELEM(A,1,2)=y;
     if (flip)
     {
         MAT_ELEM(A,0,0)*=-1;
         MAT_ELEM(A,0,1)*=-1;
         MAT_ELEM(A,0,2)*=-1;
     }
     projectVolume(*(projector[volumeIdx]), Paux, xdim, xdim,  rot, tilt, psi);
 
     if (poolIdx>=subsetProjections.size())
         subsetProjections.emplace_back(new MultidimArray<double>);
     subsetProjections[poolIdx]->resizeNoCopy(xdim, xdim);
     applyGeometry(xmipp_transformation::LINEAR,*(subsetProjections[poolIdx]),Paux(),A,xmipp_transformation::IS_INV,xmipp_transformation::DONT_WRAP,0.);
 
 #ifdef DEBUG
     std::cout << "Row: " << " rot: " << rot << " tilt: " << tilt
               << " psi: " << psi << " sx: " << x << " sy: " << y
               << " flip: " << flip << std::endl;
     Image<double> save;
     save()=*(subsetProjections[poolIdx]);
     save.write(formatString("PPPtheo%02d.xmp",poolIdx));
 #endif
 }

◆ produceSideInfo()

void ProgClassifySignificant::produceSideInfo ( )

Produce side info. An exception is thrown if any of the files is not found

Definition at line 99 of file classify_significant.cpp.

 {
     if (verbose>0)
         std::cerr << "Producing side info ..." << std::endl;
     // Read the reference volumes
     Image<double> V;
     MetaDataVec mdVols;
     mdVols.read(fnVols);
     FileName fnVol;
     int i=1;
     for (size_t objId : mdVols.ids())
     {
         mdVols.getValue(MDL_IMAGE,fnVol, objId);
         std::cout << fnVol << std::endl;
         V.read(fnVol);
         V().setXmippOrigin();
         projector.emplace_back(new FourierProjector(V(),pad,0.5,xmipp_transformation::BSPLINE3));
         currentRowIdx.push_back(0);
 
         MetaDataVec mdAngles, mdAnglesSorted;
 
         mdAngles.read(formatString("angles_%02d@%s",i,fnAngles.c_str()));
         mdAnglesSorted.sort(mdAngles, MDL_ITEM_ID, true);
 
         setAngles.emplace_back(mdAnglesSorted);
         classifiedAngles.emplace_back(MetaDataVec());
         subsetAngles.emplace_back(MetaDataVec());
         subsetProjectionIdx.emplace_back(* (new std::vector<size_t>));
         i += 1;
     }
 
     //Read FSC if present
     MetaDataVec mdFsc;
     std::vector<double> fscAux;
     if(isFsc){
         for (int i=0; i<numFsc; i++){
             std::cout << " fnFsc: " << setFsc[i] << std::endl;
             mdFsc.read(setFsc[i]);
             mdFsc.getColumnValues(MDL_RESOLUTION_FRC,fscAux);
             setFscValues.emplace_back(fscAux);
         }
     }
 
     // Read the Ids
     MetaDataVec mdIds;
     mdIds.read(fnIds);
     mdIds.getColumnValues(MDL_PARTICLE_ID,setIds);
 }

◆ readParams()

void ProgClassifySignificant::readParams ( )

virtual

Read argument from command line.

Reimplemented from XmippProgram.

Definition at line 45 of file classify_significant.cpp.

 {
     fnVols = getParam("--ref");
     fnIds = getParam("--id");
     fnAngles = getParam("--angles");
     fnOut = getParam("-o");
     pad = getIntParam("--padding");
     wmin = getDoubleParam("--minWeight");
     onlyIntersection = checkParam("--onlyIntersection");
     numVotes = getIntParam("--votes");
     isFsc = checkParam("--fsc");
     FileName fnFsc;
     if (isFsc){
         numFsc = getIntParam("--fsc", 0);
         for (int i=1; i<=numFsc; i++){
             fnFsc = getParam("--fsc", i);
             setFsc.emplace_back(fnFsc);
         }
     }
 }

◆ run()

void ProgClassifySignificant::run ( )

virtual

Predict angles and shift. At the input the pose parameters must have an initial guess of the parameters. At the output they have the estimated pose.

Reimplemented from XmippProgram.

Definition at line 850 of file classify_significant.cpp.

 {
     show();
     produceSideInfo();
 
     std::ofstream fs("./correlations.txt", std::ofstream::out);
 
     if (verbose>0)
     {
         std::cerr << "Classifying images ..." << std::endl;
         init_progress_bar(setIds.size());
     }
 
     Matrix1D<double> winning(projector.size());
     Matrix1D<double> corrDiff(projector.size());
     Matrix1D<double> weight;
 
     MultidimArray<double> I1, I2;
     MultidimArray<double> Iexp1, Iexp2;
     bool I1isEmpty, I2isEmpty;
     double corr1exp, corr2exp;
     bool flagEmpty=true;
 
     for (size_t iid=0; iid<setIds.size(); iid++)
     {
         flagEmpty=true;
         size_t id=setIds[iid];
         selectSubset(id, flagEmpty);
         if (flagEmpty)
             continue;
 
         winning.initZeros();
         corrDiff.initZeros();
         Image<double> Iaux = *Iexp[0];
         auto xdim = (int)XSIZE(Iaux());
         I1.initZeros(1, 1, xdim, xdim);
         I2.initZeros(1, 1, xdim, xdim);
         Iexp1.initZeros(1, 1, xdim, xdim);
         Iexp2.initZeros(1, 1, xdim, xdim);
 
         for (size_t ivol1=0; ivol1<projector.size(); ivol1++)
         {
             std::vector<size_t> &subset1=subsetProjectionIdx[ivol1];
             for (size_t ivol2=ivol1+1; ivol2<projector.size(); ivol2++)
             {
                 std::vector<size_t> &subset2=subsetProjectionIdx[ivol2];
                 size_t i1=0;
                 do //for (size_t i1=0; i1<subset1.size(); i1++)
                 {
                     //std::cout << "subset1.size()" << subset1.size() << std::endl;
                     if (subset1.size()==0)
                         I1isEmpty=true;
                     else
                     {
                         //MultidimArray<double> &I1=*(subsetProjections[subset1[i1]]);
                         I1=*(subsetProjections[subset1[i1]]);
                         Iexp1 = (*(Iexp[subset1[i1]]))();
                         I1isEmpty = false;
                         //std::cout << "subset1[i1]" << subset1[i1] << std::endl;
                     }
 
                     size_t i2=0;
                     do //for (size_t i2=0; i2<subset2.size(); i2++)
                     {
                         //std::cout << "subset2.size()" << subset2.size() << std::endl;
                         if (subset2.size()==0)
                             I2isEmpty=true;
                         else
                         {
                             //MultidimArray<double> &I2=*(subsetProjections[subset2[i2]]);
                             I2=*(subsetProjections[subset2[i2]]);
                             Iexp2 = (*(Iexp[subset2[i2]]))();
                             I2isEmpty=false;
                             //std::cout << "subset2[i2]" << subset2[i2] << std::endl;
                         }
 /*
                         //AJ ADDING NEW CORRELATION MEASURE
                         double ccI1Iexp1;
                         double ccI1Iexp2;
                         double ccI2Iexp1;
                         double ccI2Iexp2;
                         calculateNewCorrelation(I1, I2, Iexp1, Iexp2, ccI1Iexp1, ccI2Iexp2, isFsc, setFsc1, setFsc2);
                         if (std::isnan(ccI1Iexp1))
                             ccI1Iexp1=-1.0;
                         if (std::isnan(ccI2Iexp2))
                             ccI2Iexp2=-1.0;
 */
                         //AJ ORIGINAL CORRELATION MEASURE
                         computeWeightedCorrelation(I1, I2, Iexp1, Iexp2, corr1exp, corr2exp, I1isEmpty, I2isEmpty,
                                 xdim, onlyIntersection, numVotes);
 
                         if (std::isnan(corr1exp))
                             corr1exp=-1.0;
                         if (std::isnan(corr2exp))
                             corr2exp=-1.0;
 
                         double corrDiff12=corr1exp-corr2exp;
                         if (corrDiff12>0 && corr1exp>0)
                         {
                             VEC_ELEM(winning,ivol1)+=1;
                             VEC_ELEM(corrDiff,ivol1)+=corrDiff12;
                             VEC_ELEM(corrDiff,ivol2)-=corrDiff12;
                         }
                         else if (corrDiff12<0 && corr2exp>0)
                         {
                             VEC_ELEM(winning,ivol2)+=1;
                             VEC_ELEM(corrDiff,ivol2)-=corrDiff12;
                             VEC_ELEM(corrDiff,ivol1)+=corrDiff12;
                         }
 
 
 /*
                             //AJ NEW CORRELATION MEASURE
                             double ccI1Iexp1;
                             double ccI1Iexp2;
                             double ccI2Iexp1;
                             double ccI2Iexp2;
                             calculateNewCorrelation(I1, I2, Iexp1, Iexp2, ccI1Iexp1, ccI2Iexp2, isFsc, setFsc1, setFsc2);
                             if (std::isnan(ccI1Iexp1))
                                 ccI1Iexp1=-1.0;
                             if (std::isnan(ccI2Iexp2))
                                 ccI2Iexp2=-1.0;
 
                             double corrDiff12=ccI1Iexp1-ccI2Iexp2;
                             if (corrDiff12>0 && ccI1Iexp1>0)
                             {
                                 VEC_ELEM(winning,ivol1)+=1;
                                 VEC_ELEM(corrDiff,ivol1)+=corrDiff12;
                                 VEC_ELEM(corrDiff,ivol2)-=corrDiff12;
                             }
                             else if (corrDiff12<0 && ccI2Iexp2>0)
                             {
                                 VEC_ELEM(winning,ivol2)+=1;
                                 VEC_ELEM(corrDiff,ivol2)-=corrDiff12;
                                 VEC_ELEM(corrDiff,ivol1)+=corrDiff12;
                             }
 */
                             /*Image<double> save;
                             save()=Iexp1;
                             save.write("PPPexp1.xmp");
                             save()=Iexp2;
                             save.write("PPPexp2.xmp");
                             save()=I1;
                             save.write("PPP1.xmp");
                             save()=I2;
                             save.write("PPP2.xmp");
                             std::cout << id << " " << ccI1Iexp1 << " " << ccI2Iexp2 << " " << I1isEmpty << " " << I2isEmpty << std::endl;
                             std::cout << "winning=" << winning << std::endl;
                             std::cout << "corrDiff=" << corrDiff << std::endl;
 
                             char c;
                             std::cout << "Press any key" << std::endl;
                             std::cin >> c;*/
 
 
                         i2++;
                     }while(i2<subset2.size());
 
                     i1++;
                 }while(i1<subset1.size());
             }
         }
         double iNcomparisons=1.0/winning.sum();
         winning*=iNcomparisons;
         weight=corrDiff;
         weight*=iNcomparisons;
         weight*=winning;
 
 //      std::cout << corrDiff << std::endl;
 //      std::cout << winning << std::endl;
 //      std::cout << weight << std::endl;
 
 
         int nBest=weight.maxIndex();
         double wBest=VEC_ELEM(weight,nBest);
         if (wBest>0)
             updateClass(nBest,wBest);
         if (verbose>0)
             progress_bar(iid);
 
     }
     progress_bar(setIds.size());
 
     // Write output
     MetaDataDb md;
     for (size_t ivol=0; ivol<projector.size(); ivol++)
     {
         size_t objId=md.addObject();
         md.setValue(MDL_REF3D,(int)ivol+1,objId);
         md.setValue(MDL_CLASS_COUNT,classifiedAngles[ivol].size(),objId);
     }
     md.write("classes@"+fnOut);
     for (size_t ivol=0; ivol<projector.size(); ivol++)
     {
         md.clear();
         if (classifiedAngles[ivol].size()>0)
         {
             md = classifiedAngles[ivol];
             double currentWmax=md.getColumnMax(MDL_WEIGHT);
             double currentWmin=md.getColumnMin(MDL_WEIGHT);
             if (currentWmax>currentWmin)
                 md.operate(formatString("weight=%f*(weight-%f)+%f",(1.0-wmin)/(currentWmax-currentWmin),currentWmin,wmin));
             else
                 md.operate(formatString("weight=%f",wmin));
             md.setValueCol(MDL_REF3D,(int)ivol+1);
         }
         else
             REPORT_ERROR(ERR_VALUE_EMPTY,formatString("Class %d have been depleted of images. Cannot continue processing",ivol));
         md.write(formatString("class%06d_images@%s",ivol+1,fnOut.c_str()),MD_APPEND);
     }
 
     fs.close();
 
 }

◆ selectSubset()

void ProgClassifySignificant::selectSubset	(	size_t	particleId,
		bool &	flagEmpty
	)

Choose the subset for particleID and generate its projections

Definition at line 190 of file classify_significant.cpp.

 {
     size_t poolIdx=0;
     FileName fnImg;
     for (size_t i=0; i<projector.size(); i++)
     {
         subsetAngles[i].clear();
         subsetProjectionIdx[i].clear();
         size_t crIdx=currentRowIdx[i];
         if (crIdx>=setAngles[i].size())
             return;
         MDRowVec currentRow;
         setAngles[i].getRow(currentRow, crIdx);
         /*if (i==0) // First time we see this image
         {
             currentRow.getValue(MDL_IMAGE,fnImg);
             Iexp.read(fnImg);
             std::cout << "Particle fnImg: " << fnImg << std::endl;
         }*/
         size_t currentParticleId;
         currentRow.getValue(MDL_PARTICLE_ID,currentParticleId);
         size_t idxMax=setAngles[i].size();
         while (currentParticleId<=particleId)
         {
             if (currentParticleId==particleId)
             {
                 flagEmpty=false;
                 subsetAngles[i].addRow(currentRow);
                 subsetProjectionIdx[i].emplace_back(poolIdx);
                 currentRow.getValue(MDL_IMAGE,fnImg);
                 Iexp.emplace_back(new Image<double>);
                 Iexp[poolIdx]->read(fnImg);
                 //std::cout << "Particle fnImg: " << fnImg << " in " << poolIdx << std::endl;
                 generateProjection(i,poolIdx,currentRow);
                 poolIdx+=1;
             }
             crIdx+=1;
             if (crIdx<idxMax)
             {
                 setAngles[i].getRow(currentRow, crIdx);
                 currentRow.getValue(MDL_PARTICLE_ID,currentParticleId);
             }
             else
                 break;
         }
         currentRowIdx[i]=crIdx;
     }
 #ifdef DEBUG
     std::cout << "Reading " << fnImg << std::endl;
     char c;
     std::cout << "Press any key" << std::endl;
     std::cin >> c;
 #endif
 }

◆ show()

void ProgClassifySignificant::show ( )

Show.

Definition at line 67 of file classify_significant.cpp.

 {
     if (!verbose)
         return;
     std::cout
     << "Reference volumes:   " << fnVols            << std::endl
     << "Ids:                 " << fnIds             << std::endl
     << "Angles:              " << fnAngles          << std::endl
     << "Output:              " << fnOut             << std::endl
     << "Padding factor:      " << pad               << std::endl
     << "Min. Weight:         " << wmin              << std::endl
     ;
 }

◆ updateClass()

void ProgClassifySignificant::updateClass	(	int	n,
		double	wn
	)

Update class

Definition at line 825 of file classify_significant.cpp.

 {
     double CCbest=-1e38;
     int idCCbest=-1;
     MetaDataVec &subsetAngles_n = subsetAngles[n];
     for (size_t objId : subsetAngles_n.ids())
     {
         double cc;
         subsetAngles_n.getValue(MDL_MAXCC, cc, objId);
         if (cc>CCbest)
         {
             CCbest=cc;
             idCCbest=objId;
         }
     }
     if (idCCbest>=0)
     {
         MDRowVec newRow;
         subsetAngles_n.getRow(newRow, idCCbest);
         // COSS newRow.setValue(MDL_WEIGHT,wn);
         classifiedAngles[n].addRow(newRow);
     }
 }

Member Data Documentation

◆ classifiedAngles

std::vector<MetaDataVec> ProgClassifySignificant::classifiedAngles

Definition at line 73 of file classify_significant.h.

◆ currentRowIdx

std::vector<size_t> ProgClassifySignificant::currentRowIdx

Definition at line 75 of file classify_significant.h.

◆ fnAngles

FileName ProgClassifySignificant::fnAngles

Filename of angles assigned

Definition at line 46 of file classify_significant.h.

◆ fnIds

FileName ProgClassifySignificant::fnIds

Filename of indexes to study

Definition at line 44 of file classify_significant.h.

◆ fnOut

FileName ProgClassifySignificant::fnOut

Output file

Definition at line 48 of file classify_significant.h.

◆ fnVols

FileName ProgClassifySignificant::fnVols

Filename of the reference volumes

Definition at line 42 of file classify_significant.h.

◆ Iexp

std::vector<Image<double> *> ProgClassifySignificant::Iexp

Definition at line 83 of file classify_significant.h.

◆ isFsc

bool ProgClassifySignificant::isFsc

To check if there is FSC provided by user

Definition at line 61 of file classify_significant.h.

◆ numFsc

int ProgClassifySignificant::numFsc

FSC file

Definition at line 50 of file classify_significant.h.

◆ numVotes

int ProgClassifySignificant::numVotes

Minimum number of votes to consider an image belonging to a volume

Definition at line 59 of file classify_significant.h.

◆ onlyIntersection

bool ProgClassifySignificant::onlyIntersection

Flag to select only the images belonging only to the set intersection

Definition at line 57 of file classify_significant.h.

◆ pad

int ProgClassifySignificant::pad

Padding factor

Definition at line 53 of file classify_significant.h.

◆ Paux

Projection ProgClassifySignificant::Paux

Definition at line 85 of file classify_significant.h.

◆ projector

std::vector<FourierProjector *> ProgClassifySignificant::projector

Definition at line 65 of file classify_significant.h.

◆ setAngles

std::vector<MetaDataVec> ProgClassifySignificant::setAngles

Definition at line 71 of file classify_significant.h.

◆ setFsc

std::vector<FileName> ProgClassifySignificant::setFsc

Definition at line 67 of file classify_significant.h.

◆ setFscValues

std::vector< std::vector<double> > ProgClassifySignificant::setFscValues

Definition at line 87 of file classify_significant.h.

◆ setIds

std::vector<size_t> ProgClassifySignificant::setIds

Definition at line 69 of file classify_significant.h.

◆ subsetAngles

std::vector<MetaDataVec> ProgClassifySignificant::subsetAngles

Definition at line 77 of file classify_significant.h.

◆ subsetProjectionIdx

std::vector< std::vector<size_t> > ProgClassifySignificant::subsetProjectionIdx

Definition at line 81 of file classify_significant.h.

◆ subsetProjections

std::vector<MultidimArray<double> *> ProgClassifySignificant::subsetProjections

Definition at line 79 of file classify_significant.h.

◆ wmin

double ProgClassifySignificant::wmin

Min. Weight

Definition at line 55 of file classify_significant.h.

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

xmipp/legacy/libraries/reconstruction/classify_significant.h
xmipp/legacy/libraries/reconstruction/classify_significant.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~ProgClassifySignificant()

Member Function Documentation

◆ defineParams()

◆ generateProjection()

◆ produceSideInfo()

◆ readParams()

◆ run()

◆ selectSubset()

◆ show()

◆ updateClass()

Member Data Documentation

◆ classifiedAngles

◆ currentRowIdx

◆ fnAngles

◆ fnIds

◆ fnOut

◆ fnVols

◆ Iexp

◆ isFsc

◆ numFsc

◆ numVotes

◆ onlyIntersection

◆ pad

◆ Paux

◆ projector

◆ setAngles

◆ setFsc

◆ setFscValues

◆ setIds

◆ subsetAngles

◆ subsetProjectionIdx

◆ subsetProjections

◆ wmin