#include <volume_initial_simulated_annealing.h>

Inheritance diagram for ProgVolumeInitialSimulatedAnnealing:

Collaboration diagram for ProgVolumeInitialSimulatedAnnealing:

Public Member Functions
void	readParams ()
	Read arguments from command line. More...

void	defineParams ()
	Read arguments from command line. More...

void	show ()

void	run ()

void	produceSideinfo ()
	Produce side info: fill arrays with relevant transformation matrices. More...

void	reconstructCurrent ()
	Reconstruct current volume. More...

void	generateProjections ()
	Generate projections from the current volume. More...

void	filterByCorrelation ()
	Filter by correlation. 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	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	fnIn

FileName	fnRoot

FileName	fnSym

FileName	fnInit

double	T0

int	NiterRandom

int	NiterGreedy

double	rejection

int	Nthr

bool	positiveConstraint

bool	keepIntermediateVolumes

double	angularSampling

MetaDataDb	mdIn

MetaDataDb	mdReconstruction

std::vector< GalleryImage >	mdGallery

std::vector< InputImage >	mdInp

FileName	fnAngles

FileName	fnVolume

FileName	fnGallery

FileName	fnGalleryMetaData

Image< double >	gallery

Image< double >	inputImages

int	iter

ThreadVolumeInitialAlignment *	threadResults

Mutex	mutexMaxCC

double	sumCorr

double	sumImprovement

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

Random reconstruction parameters.

Definition at line 61 of file volume_initial_simulated_annealing.h.

Member Function Documentation

◆ defineParams()

void ProgVolumeInitialSimulatedAnnealing::defineParams ( )

virtual

Read arguments from command line.

Reimplemented from XmippProgram.

Definition at line 30 of file volume_initial_simulated_annealing.cpp.

 {
     //usage
     addUsageLine("Generate 3D reconstructions from projections using random orientations");
     //params
     addParamsLine("   -i <md_file>                : Metadata file with input projections");
     addParamsLine("  [--oroot <volume_file=\"rec_random\">]  : Filename for output rootname");
     addParamsLine("  [--sym <symfile=c1>]         : Enforce symmetry in projections");
     addParamsLine("  [--randomIter <N=10>]        : Number of iterations with random assignment");
     addParamsLine("  [--greedyIter <N=0>]         : Number of iterations with greedy assignment");
     addParamsLine("  [--rejection <p=25>]         : Percentage of images to reject for reconstruction");
     addParamsLine("  [--initial <file=\"\">]      : Initial volume if available");
     addParamsLine("  [--keepIntermediateVolumes]  : Keep the volume of each iteration");
     addParamsLine("  [--dontApplyPositive]        : Do not apply positive constraint in the random iterations");
     addParamsLine("  [--T0 <T=0.1>]               : Initial temperature for simulated annealing");
     addParamsLine("  [--thr <n=1>]                : Number of threads");
     addParamsLine("  [--angularSampling <a=5>]    : Angular sampling in degrees for generating the projection gallery");
 }

◆ filterByCorrelation()

void ProgVolumeInitialSimulatedAnnealing::filterByCorrelation ( )

Filter by correlation.

Definition at line 301 of file volume_initial_simulated_annealing.cpp.

 {
     MetaDataVec mdAux;
     mdAux=mdReconstruction;
     mdAux.removeDisabled();
 
     std::vector<double> correlations;
     mdAux.getColumnValues(MDL_MAXCC,correlations);
     std::sort(correlations.begin(),correlations.end());
     auto skip=(size_t)floor(correlations.size()*(rejection/100.0));
     double minCorr=correlations[skip];
     //double maxCorr=correlations[correlations.size()-skip/4-1];
 
     std::vector<double> weights;
     mdAux.getColumnValues(MDL_WEIGHT,weights);
     std::sort(weights.begin(),weights.end());
     double minWeight=weights[skip];
     //double maxWeight=weights[weights.size()-skip/4-1];
 
     for (size_t objId : mdAux.ids())
     {
         double cc, weight;
         mdAux.getValue(MDL_MAXCC,cc,objId);
         if (cc<minCorr) // COSS || cc>maxCorr)
             mdAux.setValue(MDL_ENABLED,-1,objId);
         mdAux.getValue(MDL_WEIGHT,weight,objId);
         if (weight<minWeight) // COSS || weight>maxWeight)
             mdAux.setValue(MDL_ENABLED,-1,objId);
     }
     mdAux.removeDisabled();
     mdAux.write(fnAngles);
 }

◆ generateProjections()

void ProgVolumeInitialSimulatedAnnealing::generateProjections ( )

Generate projections from the current volume.

Definition at line 362 of file volume_initial_simulated_annealing.cpp.

 {
     String args=formatString("-i %s -o %s --sampling_rate %f --sym %s --compute_neighbors --angular_distance -1 --experimental_images %s -v 0",
             fnVolume.c_str(),fnGallery.c_str(),angularSampling,fnSym.c_str(),fnAngles.c_str());
     String cmd=(String)"xmipp_angular_project_library "+args;
     if (system(cmd.c_str())==-1)
         REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
     MetaDataVec mdAux(fnGalleryMetaData);
     mdGallery.clear();
     for (size_t objId : mdAux.ids())
     {
         GalleryImage I;
         mdAux.getValue(MDL_IMAGE,I.fnImg,objId);
         mdAux.getValue(MDL_ANGLE_ROT,I.rot,objId);
         mdAux.getValue(MDL_ANGLE_TILT,I.tilt,objId);
         mdGallery.push_back(I);
     }
     gallery.read(fnGallery);
 }

◆ produceSideinfo()

void ProgVolumeInitialSimulatedAnnealing::produceSideinfo ( )

Produce side info: fill arrays with relevant transformation matrices.

Definition at line 382 of file volume_initial_simulated_annealing.cpp.

 {
     mdIn.read(fnIn);
     mdIn.removeDisabled();
 
     mdIn.fillConstant(MDL_MAXCC,"0.0");
     mdIn.fillRandom(MDL_ANGLE_ROT,"uniform",0,360);
     mdIn.fillRandom(MDL_ANGLE_TILT,"uniform",0,180);
     mdIn.fillRandom(MDL_ANGLE_PSI,"uniform",0,360);
     mdIn.fillConstant(MDL_SHIFT_X,"0.0");
     mdIn.fillConstant(MDL_SHIFT_Y,"0.0");
     mdIn.fillConstant(MDL_WEIGHT,"1.0");
 
     fnAngles=fnRoot+".xmd";
     fnVolume=fnRoot+".vol";
     fnGallery=fnRoot+"_gallery.stk";
     fnGalleryMetaData=fnRoot+"_gallery.doc";
 
     size_t xdim, ydim, zdim, ndim;
     getImageSize(mdIn,xdim, ydim, zdim, ndim);
     inputImages().resizeNoCopy(mdIn.size(), 1, ydim, xdim);
 
     Image<double> I;
     size_t n=0;
     MultidimArray<double> mCurrentImage;
     for (size_t objId : mdIn.ids())
     {
         InputImage Ip;
         mdIn.getValue(MDL_IMAGE,Ip.fnImg,objId);
         Ip.maxcc=0.0;
         mdInp.push_back(Ip);
         I.read(Ip.fnImg);
         mCurrentImage.aliasImageInStack(inputImages(),n++);
         memcpy(MULTIDIM_ARRAY(mCurrentImage),MULTIDIM_ARRAY(I()),MULTIDIM_SIZE(mCurrentImage)*sizeof(double));
     }
 
     mdIn.write(fnAngles);
     iter=0;
     if (fnInit=="")
         reconstructCurrent();
     else
     {
         if (system(formatString("cp %s %s",fnInit.c_str(),fnVolume.c_str()).c_str())==-1)
             REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
     }
 
     threadResults=new ThreadVolumeInitialAlignment[Nthr];
 }

◆ readParams()

void ProgVolumeInitialSimulatedAnnealing::readParams ( )

virtual

Read arguments from command line.

Reimplemented from XmippProgram.

Definition at line 50 of file volume_initial_simulated_annealing.cpp.

 {
     fnIn = getParam("-i");
     fnRoot = getParam("--oroot");
     fnSym = getParam("--sym");
     T0 = getDoubleParam("--T0");
     NiterRandom = getIntParam("--randomIter");
     NiterGreedy = getIntParam("--greedyIter");
     rejection = getDoubleParam("--rejection");
     fnInit = getParam("--initial");
     Nthr = getIntParam("--thr");
     positiveConstraint = !checkParam("--dontApplyPositive");
     keepIntermediateVolumes = checkParam("--keepIntermediateVolumes");
     angularSampling=getDoubleParam("--angularSampling");
 }

◆ reconstructCurrent()

void ProgVolumeInitialSimulatedAnnealing::reconstructCurrent ( )

Reconstruct current volume.

Definition at line 334 of file volume_initial_simulated_annealing.cpp.

 {
     String args=formatString("-i %s -o %s --sym %s --weight --thr %d -v 0",fnAngles.c_str(),fnVolume.c_str(),fnSym.c_str(),Nthr);
     String cmd=(String)"xmipp_reconstruct_fourier "+args;
     if (system(cmd.c_str())==-1)
         REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
 
     args=formatString("-i %s --mask circular %d -v 0",fnVolume.c_str(),-XSIZE(inputImages())/2);
     cmd=(String)"xmipp_transform_mask "+args;
     if (system(cmd.c_str())==-1)
         REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
 
     if (iter<=NiterRandom && positiveConstraint)
     {
         args=formatString("-i %s --select below 0 --substitute value 0 -v 0",fnVolume.c_str());
         cmd=(String)"xmipp_transform_threshold "+args;
         if (system(cmd.c_str())==-1)
             REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
     }
 
     if (keepIntermediateVolumes)
     {
         cmd=formatString("cp %s %s_iter%02d.vol",fnVolume.c_str(),fnRoot.c_str(),iter);
         if (system(cmd.c_str())==-1)
             REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot open shell");
     }
 }

◆ run()

void ProgVolumeInitialSimulatedAnnealing::run ( )

virtual

Run.

Reimplemented from XmippProgram.

Definition at line 262 of file volume_initial_simulated_annealing.cpp.

 {
     show();
     produceSideinfo();
 
     bool finish=false;
     iter=1;
     ThreadManager thMgr(Nthr,this);
     do
     {
         // Generate projections from the volume
         generateProjections();
 
         // Align the input images to the projections
         mdReconstruction.clear();
         sumCorr=sumImprovement=0;
         init_progress_bar(mdIn.size());
         thMgr.run(threadAlignSubset);
         progress_bar(mdIn.size());
         size_t nImg=0;
         for (size_t objId : mdIn.ids())
             mdIn.setValue(MDL_MAXCC,mdInp[nImg++].maxcc,objId);
         std::cout << "Iter " << iter << " avg.correlation=" << sumCorr/mdIn.size()
                   << " avg.improvement=" << sumImprovement/mdIn.size() << std::endl;
 
         // Remove too good and too bad images
         filterByCorrelation();
 
         // Reconstruct
         reconstructCurrent();
 
         finish=(iter==(NiterRandom+NiterGreedy));
         iter++;
     } while (!finish);
     deleteFile(fnRoot+"_gallery_sampling.xmd");
     deleteFile(fnRoot+"_gallery.stk");
     deleteFile(fnRoot+"_gallery.doc");
 }

◆ show()

void ProgVolumeInitialSimulatedAnnealing::show ( )

Show.

Definition at line 67 of file volume_initial_simulated_annealing.cpp.

 {
     if (verbose > 0)
     {
         std::cout << "Input metadata              : "  << fnIn        << std::endl;
         std::cout << "Output rootname             : "  << fnRoot      << std::endl;
         std::cout << "T0                          : "  << T0          << std::endl;
         std::cout << "Number of random iterations : "  << NiterRandom << std::endl;
         std::cout << "Number of greedy iterations : "  << NiterGreedy << std::endl;
         std::cout << "Rejection percentage        : "  << rejection   << std::endl;
         std::cout << "Number of threads           : "  << Nthr        << std::endl;
         std::cout << "Apply positive constraint   : "  << positiveConstraint << std::endl;
         std::cout << "Keep intermediate volumes   : "  << keepIntermediateVolumes << std::endl;
         std::cout << "Angular sampling            : "  << angularSampling << std::endl;
         if (fnSym != "")
             std::cout << "Symmetry for projections    : "  << fnSym << std::endl;
         if (fnInit !="")
             std::cout << "Initial volume              : "  << fnInit << std::endl;
     }
 }