#include <angular_continuous_assign.h>

Inheritance diagram for ProgAngularContinuousAssign:

Collaboration diagram for ProgAngularContinuousAssign:

Public Member Functions
	ProgAngularContinuousAssign ()
	Empty constructor. More...

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

void	show ()
	Show. More...

void	defineParams ()
	Define parameters. More...

void	preProcess ()

void	processImage (const FileName &fnImg, const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut)

Public Member Functions inherited from XmippMetadataProgram
MetaData *	getInputMd ()

MetaDataVec &	getOutputMd ()

	XmippMetadataProgram ()
	Empty constructor. More...

virtual int	tryRead (int argc, const char **argv, bool reportErrors=true)

virtual void	init ()

virtual void	setup (MetaData *md, const FileName &o="", const FileName &oroot="", bool applyGeo=false, MDLabel label=MDL_IMAGE)

virtual	~XmippMetadataProgram ()

void	setMode (WriteModeMetaData _mode)

void	setupRowOut (const FileName &fnImgIn, const MDRow &rowIn, const FileName &fnImgOut, MDRow &rowOut) const
	Prepare rowout. More...

virtual void	wait ()
	Wait for the distributor to finish. More...

virtual void	checkPoint ()
	For very long programs, it may be needed to write checkpoints. More...

virtual void	run ()
	Run over all images. 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)

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	fn_ref

double	gaussian_DFT_sigma

double	gaussian_Real_sigma

double	weight_zero_freq

int	max_no_iter

bool	quiet

double	max_shift

double	max_angular_change

MultidimArray< double >	reDFTVolume

MultidimArray< double >	imDFTVolume

Mask	mask_Fourier

Mask	mask_Real

Public Attributes inherited from XmippMetadataProgram
FileName	fn_in
	Filenames of input and output Metadata. More...

FileName	fn_out

FileName	baseName

FileName	pathBaseName

FileName	oextBaseName

bool	apply_geo
	Apply geo. More...

size_t	ndimOut
	Output dimensions. More...

size_t	zdimOut

size_t	ydimOut

size_t	xdimOut

DataType	datatypeOut

size_t	mdInSize
	Number of input elements. 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 XmippMetadataProgram
virtual void	initComments ()

virtual void	postProcess ()

virtual bool	getImageToProcess (size_t &objId, size_t &objIndex)

void	show () const override

virtual void	startProcessing ()

virtual void	finishProcessing ()

virtual void	writeOutput ()

virtual void	showProgress ()

virtual void	defineLabelParam ()

Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes inherited from XmippMetadataProgram
WriteModeMetaData	mode
	Metadata writing mode: OVERWRITE, APPEND. More...

FileName	oext
	Output extension and root. More...

FileName	oroot

MDLabel	image_label
	MDLabel to be used to read/write images, usually will be MDL_IMAGE. More...

bool	produces_an_output
	Indicate that a unique final output is produced. More...

bool	produces_a_metadata
	Indicate that the unique final output file is a Metadata. More...

bool	each_image_produces_an_output
	Indicate that an output is produced for each image in the input. More...

bool	allow_apply_geo

bool	decompose_stacks
	Input Metadata will treat a stack file as a set of images instead of a unique file. More...

bool	delete_output_stack
	Delete previous output stack file prior to process images. More...

bool	get_image_info
	Get the input image file dimensions to further operations. More...

bool	save_metadata_stack
	Save the associated output metadata when output file is a stack. More...

bool	track_origin
	Include the original input image filename in the output stack. More...

bool	keep_input_columns
	Keep input metadata columns. More...

bool	remove_disabled
	Remove disabled images from the input selfile. More...

bool	allow_time_bar
	Show process time bar. More...

bool	input_is_metadata
	Input is a metadata. More...

bool	single_image
	Input is a single image. More...

bool	input_is_stack
	Input is a stack. More...

bool	output_is_stack
	Output is a stack. More...

bool	create_empty_stackfile

bool	delete_mdIn

size_t	time_bar_step
	Some time bar related counters. More...

size_t	time_bar_size

size_t	time_bar_done

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

Predict Continuous Parameters.

Definition at line 39 of file angular_continuous_assign.h.

Constructor & Destructor Documentation

◆ ProgAngularContinuousAssign()

ProgAngularContinuousAssign::ProgAngularContinuousAssign ( )

Empty constructor.

Definition at line 51 of file angular_continuous_assign.cpp.

 {
     produces_a_metadata = true;
 }

Member Function Documentation

◆ defineParams()

void ProgAngularContinuousAssign::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgAngularContinuousAssign >.

Definition at line 86 of file angular_continuous_assign.cpp.

 {
     addUsageLine("Make a continuous angular assignment");
     addUsageLine("+This program assigns Euler angles to experimental projections by ");
     addUsageLine("+minimizing the difference between the given experimental image and ");
     addUsageLine("+the central slice of a reference volume in Fourier space. All ");
     addUsageLine("+interpolations are based on a B-spline model of the images and the ");
     addUsageLine("+volume. The translations are also optimized. Since an iterative ");
     addUsageLine("+optimization is performed, it must be initialized with some rough ");
     addUsageLine("+estimate of the angles. The output of xmipp_angular_predict can be ");
     addUsageLine("+used as initialization without any transformation.");
     addUsageLine("+The method is fully described at http://www.ncbi.nlm.nih.gov/pubmed/15885434");
     defaultComments["-i"].clear();
     defaultComments["-i"].addComment("Metadata with initial alignment");
     defaultComments["-o"].clear();
     defaultComments["-o"].addComment("Metadata with output alignment");
     XmippMetadataProgram::defineParams();
     addParamsLine("   --ref <volume>              : Reference volume");
     addParamsLine("  [--gaussian_Fourier <s=0.5>] : Weighting sigma in Fourier space");
     addParamsLine("                               :+Small values of this parameter concentrate ");
     addParamsLine("                               :+the optimization on low frequencies. This ");
     addParamsLine("                               :+value should be below 1.");
     addParamsLine("  [--gaussian_Real    <s=0.5>] : Weighting sigma in Real space");
     addParamsLine("                               :+Small values of this parameter concentrate ");
     addParamsLine("                               :+the optimization in the image center. This ");
     addParamsLine("                               :+value should be below 1.");
     addParamsLine("  [--zerofreq_weight  <s=0. >] : Zero-frequency weight");
     addParamsLine("  [--max_iter <max=60>]        : Maximum number of iterations");
     addParamsLine("                               :+Convergence might be reached before this number of iterations");
     addParamsLine("  [--max_shift <s=-1>]         : Maximum shift allowed");
     addParamsLine("                               :+Use this option to limit the maximum shift that the ");
     addParamsLine("                               :+optimization process can find. If the minimum is ");
     addParamsLine("                               :+found beyond this limit (note it is an absolute limit ");
     addParamsLine("                               :+on the shift and it is not relative to the initial shift), ");
     addParamsLine("                               :+then the solution given by the initial guess is kept ");
     addParamsLine("                               :+since the optimized one looks suspicious.");
     addParamsLine("  [--max_angular_change <a=-1>]: Maximum angular change allowed");
     addParamsLine("                               :+Use this option to limit the maximum angular ");
     addParamsLine("                               :+change with respect to the initial solution ");
     addParamsLine("                               :+that the optimization algorithm can find. If ");
     addParamsLine("                               :+the solution found is beyond this limit, then ");
     addParamsLine("                               :+the initial solution is returned instead of the ");
     addParamsLine("                               :+optimized one since this latter looks suspicious.");
     addExampleLine("A typical use is:",false);
     addExampleLine("xmipp_angular_continuous_assign -i anglesFromDiscreteAssignment.doc --ref reference.vol -o assigned_angles.xmd");
 }

◆ preProcess()

void ProgAngularContinuousAssign::preProcess ( )

virtual

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

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgAngularContinuousAssign >.

Definition at line 134 of file angular_continuous_assign.cpp.

 {
     // Read the reference volume
     Image<double> V;
     V.read(fn_ref);
     V().setXmippOrigin();
 
     // Prepare the masks in real space
     Mask mask_Real3D;
     mask_Real3D.type = mask_Real.type = GAUSSIAN_MASK;
     mask_Real3D.mode = mask_Real.mode = INNER_MASK;
 
     mask_Real3D.sigma = mask_Real.sigma = gaussian_Real_sigma * ((double)XSIZE(V()));
 
     mask_Real3D.generate_mask(V());
     mask_Real.generate_mask(YSIZE(V()), XSIZE(V()));
 
     double gs2 = 2. * PI * gaussian_Real_sigma * gaussian_Real_sigma * ((double)XSIZE(V()) * (double) XSIZE(V()));
     double gs3 = gs2 * sqrt(2. * PI) * gaussian_Real_sigma * ((double) XSIZE(V()));
 
     mask_Real3D.get_cont_mask() *= gs3;
     mask_Real.get_cont_mask() *= gs2;
 
     //For debugging
     /*Image<double> mask2D_test;
     mask2D_test.read("ident2D.spi"); //Identity image
     mask2D_test().setXmippOrigin();
     mask_Real.apply_mask(mask2D_test(), mask2D_test());
     mask2D_test.write("mask_2Dtest.xmp");*/
 
     // Prepare the weight function in Fourier space
     mask_Fourier.type = GAUSSIAN_MASK;
     mask_Fourier.mode = INNER_MASK;
 
     mask_Fourier.sigma = gaussian_DFT_sigma * ((double)XSIZE(V()));
     mask_Fourier.generate_mask(YSIZE(V()), XSIZE(V()));
 
     double gsf2 = 2. * PI * gaussian_DFT_sigma * gaussian_DFT_sigma * ((double)XSIZE(V()) * (double)XSIZE(V()));
     mask_Fourier.get_cont_mask() *= gsf2;
     mask_Fourier.get_cont_mask()(0, 0) *= weight_zero_freq;
 
     // Weight the input volume in real space
     mask_Real3D.apply_mask(V(), V());
 
     // Perform the DFT of the reference volume
     int Status;
     reDFTVolume = V();
     imDFTVolume.resize(V());
     CenterFFT(reDFTVolume, false);
     VolumeDftRealToRealImaginary(MULTIDIM_ARRAY(reDFTVolume),
                                  MULTIDIM_ARRAY(imDFTVolume), XSIZE(V()), YSIZE(V()), ZSIZE(V()),
                                  &Status);
     CenterFFT(reDFTVolume, true);
     CenterFFT(imDFTVolume, true);
 }

◆ processImage()

void ProgAngularContinuousAssign::processImage	(	const FileName &	fnImg,
		const FileName &	fnImgOut,
		const MDRow &	rowIn,
		MDRow &	rowOut
	)

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.

Implements XmippMetadataProgram.

Definition at line 191 of file angular_continuous_assign.cpp.

 {
     // Read the image and take its angles from the Metadata
     // if they are available. If not, take them from the header.
     // If not, set them to 0.
     Image<double> img;
     img.read(fnImg);
     img().setXmippOrigin();
 
     double old_rot, old_tilt, old_psi, old_shiftX, old_shiftY;
     rowIn.getValue(MDL_ANGLE_ROT,old_rot);
     rowIn.getValue(MDL_ANGLE_TILT,old_tilt);
     rowIn.getValue(MDL_ANGLE_PSI,old_psi);
     rowIn.getValue(MDL_SHIFT_X,old_shiftX);
     rowIn.getValue(MDL_SHIFT_Y,old_shiftY);
 
     Matrix1D<double> pose(5);
     pose(0) = old_rot;
     pose(1) = old_tilt;
     pose(2) = old_psi;
     pose(3) = -old_shiftX; // The convention of shifts is different
     pose(4) = -old_shiftY; // for Slavica
 
     mask_Real.apply_mask(img(), img());
 
     double cost = CSTSplineAssignment(reDFTVolume, imDFTVolume,
                                       img(), mask_Fourier.get_cont_mask(), pose, max_no_iter);
 
     Matrix2D<double> Eold, Enew;
     Euler_angles2matrix(old_rot,old_tilt,old_psi,Eold);
     Euler_angles2matrix(pose(0),pose(1),pose(2),Enew);
     double angular_change=Euler_distanceBetweenMatrices(Eold,Enew);
     double shift=sqrt(pose(3)*pose(3)+pose(4)*pose(4));
     double new_rot=old_rot;
     double new_tilt=old_tilt;
     double new_psi=old_psi;
     double new_shiftX=old_shiftX;
     double new_shiftY=old_shiftY;
     if (angular_change<max_angular_change || max_angular_change<0)
     {
         new_rot    =  pose(0);
         new_tilt   =  pose(1);
         new_psi    =  pose(2);
     }
     else
         cost=-1;
     if (shift<max_shift || max_shift<0)
     {
         new_shiftX = -pose(3);
         new_shiftY = -pose(4);
     }
     else
         cost=-1;
 
     rowOut.setValue(MDL_ANGLE_ROT,  new_rot);
     rowOut.setValue(MDL_ANGLE_TILT, new_tilt);
     rowOut.setValue(MDL_ANGLE_PSI,  new_psi);
     rowOut.setValue(MDL_SHIFT_X,    new_shiftX);
     rowOut.setValue(MDL_SHIFT_Y,    new_shiftY);
     rowOut.setValue(MDL_COST,      cost);
 }

◆ readParams()

void ProgAngularContinuousAssign::readParams ( )

virtual

Read argument from command line.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgAngularContinuousAssign >.

Definition at line 57 of file angular_continuous_assign.cpp.

 {
     XmippMetadataProgram::readParams();
     fn_ref = getParam("--ref");
     gaussian_DFT_sigma = getDoubleParam("--gaussian_Fourier");
     gaussian_Real_sigma = getDoubleParam("--gaussian_Real");
     weight_zero_freq = getDoubleParam("--zerofreq_weight");
     max_no_iter = getIntParam("--max_iter");
     max_shift = getDoubleParam("--max_shift");
     max_angular_change = getDoubleParam("--max_angular_change");
 }

◆ show()

void ProgAngularContinuousAssign::show ( )

Show.

Definition at line 70 of file angular_continuous_assign.cpp.

 {
     if (!verbose)
         return;
     XmippMetadataProgram::show();
     std::cout << "Reference volume:    " << fn_ref              << std::endl
     << "Gaussian Fourier:    " << gaussian_DFT_sigma  << std::endl
     << "Gaussian Real:       " << gaussian_Real_sigma << std::endl
     << "Zero-frequency weight:"<< weight_zero_freq    << std::endl
     << "Max. Iter:           " << max_no_iter         << std::endl
     << "Max. Shift:          " << max_shift           << std::endl
     << "Max. Angular Change: " << max_angular_change  << std::endl
     ;
 }