Inheritance diagram for ProgAlignVolumes:

Collaboration diagram for ProgAlignVolumes:

Public Member Functions
void	defineParams ()

void	readParams ()

void	run ()

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
Mask	mask

FileName	fn1

FileName	fn2

double	rot0

double	rotF

double	tilt0

double	tiltF

double	psi0

double	psiF

double	step_rot

double	step_tilt

double	step_psi

double	scale0

double	scaleF

double	step_scale

double	z0

double	zF

double	y0

double	yF

double	x0

double	xF

double	step_z

double	step_y

double	step_x

double	grey_scale0

double	grey_scaleF

double	step_grey

double	grey_shift0

double	grey_shiftF

double	step_grey_shift

int	tell

bool	apply

FileName	fnOut

FileName	fnGeo

FileName	fnGray

FileName	fnStore

bool	mask_enabled

bool	usePowell

bool	onlyShift

bool	useFRM

bool	copyGeo

bool	copyGray

bool	store

bool	wrap

double	maxFreq

int	maxShift

bool	dontScale

int	starting_tilt

int	ending_tilt

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

Definition at line 113 of file volume_align_prog.cpp.

Member Function Documentation

◆ defineParams()

void ProgAlignVolumes::defineParams ( )

inlinevirtual

Function in which the param of each Program are defined.

Reimplemented from XmippProgram.

Definition at line 136 of file volume_align_prog.cpp.

     {
 
         addUsageLine("Align two volumes varying orientation, position and scale");
         addParamsLine("   --i1 <volume1>        : the first volume to align");
         addParamsLine("   --i2 <volume2>        : the second one");
         addParamsLine("  [--rot   <rot0=0>  <rotF=0>  <step_rot=1>]  : in degrees");
         addParamsLine("  [--tilt  <tilt0=0> <tiltF=0> <step_tilt=1>] : in degrees");
         addParamsLine("  [--psi   <psi0=0>  <psiF=0>  <step_psi=1>]  : in degrees");
         addParamsLine("  [--scale <sc0=1>   <scF=1>   <step_sc=1>]   : size scale margin");
         addParamsLine("  [--grey_scale <sc0=1> <scF=1> <step_sc=1>]  : grey scale margin");
         addParamsLine("    requires --least_squares;");
         addParamsLine("  [--grey_shift <sh0=0> <shF=0> <step_sh=1>]  : grey shift margin");
         addParamsLine("    requires --least_squares;");
         addParamsLine("  [-z <z0=0> <zF=0> <step_z=1>] : Z position in pixels");
         addParamsLine("  [-y <y0=0> <yF=0> <step_y=1>] : Y position in pixels");
         addParamsLine("  [-x <x0=0> <xF=0> <step_x=1>] : X position in pixels");
         addParamsLine("  [--show_fit]      : Show fitness values");
         addParamsLine("  [--apply <file=\"\">] : Apply best movement to --i2 and store results in this file");
         addParamsLine("  [--covariance]    : Covariance fitness criterion");
         addParamsLine("  [--least_squares] : LS fitness criterion");
         addParamsLine("  [--local]         : Use local optimizer instead of exhaustive search");
         addParamsLine("  [--frm <maxFreq=0.25> <maxShift=10> <tilt0=-90> <tiltF=90>] : Use Fast Rotational Matching, if tilt0 and tiltF are left as -90 and 90 they do not effect the results of the alignment");
         addParamsLine("                    : Maximum frequency is in digital frequencies (<0.5)");
         addParamsLine("                    : Maximum shift is in pixels");
         addParamsLine("                    :+ See Y. Chen, et al. Fast and accurate reference-free alignment of subtomograms. JSB, 182: 235-245 (2013)");
         addParamsLine("  [--onlyShift]     : Only shift");
         addParamsLine("  [--dontScale]     : Do not look for scale changes");
         addParamsLine("  [--copyGeo <file=\"\">] : copy transformation matrix in a txt file. ('A' matrix elements)");
         addParamsLine("  [--copyGray <file=\"\">] : copy gray scale and shift txt file.)");
         addParamsLine("  [--store <file=\"\">] : copy angles and shifts to a txt file.");
         addParamsLine("  [--dontWrap] : Do not wrap input2 when aligning to input1");
         addParamsLine(" == Mask Options == ");
         mask.defineParams(this,INT_MASK,nullptr,nullptr,true);
         addExampleLine("Typically you first look for a rough approximation of the alignment using exhaustive search. For instance, for a global rotational alignment use",false);
         addExampleLine("xmipp_volume_align --i1 volume1.vol --i2 volume2.vol --rot 0 360 15 --tilt 0 180 15 --psi 0 360 15");
         addExampleLine("Then, assume the best alignment is obtained for rot=45, tilt=60, psi=90",false);
         addExampleLine("Now you perform a local search to refine the estimation and apply",false);
         addExampleLine("xmipp_volume_align --i1 volume1.vol --i2 volume2.vol --rot 45 --tilt 60 --psi 90 --local --apply volume2aligned.vol");
         addSeeAlsoLine("xmipp_volumeset_align");
     }

◆ readParams()

void ProgAlignVolumes::readParams ( )

inlinevirtual

Function in which each program will read parameters that it need. If some error occurs the usage will be printed out.

Reimplemented from XmippProgram.

Definition at line 178 of file volume_align_prog.cpp.

     {
         // Get parameters =======================================================
         fn1 = getParam("--i1");
         fn2 = getParam("--i2");
 
         rot0 = getDoubleParam("--rot",0);
         rotF = getDoubleParam("--rot",1);
         step_rot = getDoubleParam("--rot",2);
 
         tilt0 = getDoubleParam("--tilt",0);
         tiltF = getDoubleParam("--tilt",1);
         step_tilt = getDoubleParam("--tilt",2);
 
         psi0 = getDoubleParam("--psi",0);
         psiF = getDoubleParam("--psi",1);
         step_psi = getDoubleParam("--psi",2);
 
         scale0 = getDoubleParam("--scale",0);
         scaleF = getDoubleParam("--scale",1);
         step_scale = getDoubleParam("--scale",2);
 
         grey_scale0 = getDoubleParam("--grey_scale",0);
         grey_scaleF = getDoubleParam("--grey_scale",1);
         step_grey = getDoubleParam("--grey_scale",2);
 
         grey_shift0 = getDoubleParam("--grey_shift",0);
         grey_shiftF = getDoubleParam("--grey_shift",1);
         step_grey_shift = getDoubleParam("--grey_shift",2);
 
         z0 = getDoubleParam("-z",0);
         zF = getDoubleParam("-z",1);
         step_z = getDoubleParam("-z",2);
 
         y0 = getDoubleParam("-y",0);
         yF = getDoubleParam("-y",1);
         step_y = getDoubleParam("-y",2);
 
         x0 = getDoubleParam("-x",0);
         xF = getDoubleParam("-x",1);
         step_x = getDoubleParam("-x",2);
 
         mask_enabled = checkParam("--mask");
         if (mask_enabled)
             mask.read(argc, argv);
 
         usePowell = checkParam("--local");
         useFRM = checkParam("--frm");
         if (useFRM)
         {
             maxFreq=getDoubleParam("--frm",0);
             maxShift=getIntParam("--frm",1);
             starting_tilt=getIntParam("--frm",2);
             ending_tilt=getIntParam("--frm",3);
         }
         onlyShift = checkParam("--onlyShift");
         wrap = !checkParam("--dontWrap");
 
         if (step_rot   == 0)
             step_rot = 1;
         if (step_tilt  == 0)
             step_tilt  = 1;
         if (step_psi   == 0)
             step_psi = 1;
         if (step_scale == 0)
             step_scale = 1;
         if (step_grey  == 0)
             step_grey  = 1;
         if (step_grey_shift  == 0)
             step_grey_shift  = 1;
         if (step_z     == 0)
             step_z = 1;
         if (step_y     == 0)
             step_y = 1;
         if (step_x     == 0)
             step_x = 1;
 
         tell = checkParam("--show_fit");
         apply = checkParam("--apply");
         fnOut = getParam("--apply");
         copyGeo = checkParam("--copyGeo");
         copyGray = checkParam("--copyGray");
         fnGeo = getParam("--copyGeo");
         fnGray = getParam("--copyGray");
         store = checkParam("--store");
         fnStore = getParam("--store");
         dontScale = checkParam("--dontScale");
 
         if (checkParam("--covariance"))
         {
             params.alignment_method = COVARIANCE;
         }
         else if (checkParam("--least_squares"))
         {
             params.alignment_method = LEAST_SQUARES;
         }
         else
         {
             params.alignment_method = COVARIANCE;
         }
     }

◆ run()

void ProgAlignVolumes::run ( )

inlinevirtual

This function will be start running the program. it also should be implemented by derived classes.

Reimplemented from XmippProgram.

Definition at line 280 of file volume_align_prog.cpp.

     {
         mask.allowed_data_types = INT_MASK;
 
         // Main program =========================================================
         params.V1.read(fn1);
         params.V1().setXmippOrigin();
         params.V2.read(fn2);
         params.V2().setXmippOrigin();
         params.wrap = wrap;
 
         // Initialize best_fit
         double best_fit = 1e38;
         Matrix1D<double> best_align(8);
         bool first = true;
 
         // Generate mask
         if (mask_enabled)
         {
             mask.generate_mask(params.V1());
             params.mask_ptr = &(mask.get_binary_mask());
         }
         else
             params.mask_ptr = nullptr;
 
         // Exhaustive search
         if (!usePowell && !useFRM)
         {
             // Count number of iterations
             int times = 1;
             if (!tell)
             {
                 if (grey_scale0 != grey_scaleF)
                     times *= FLOOR(1 + (grey_scaleF - grey_scale0) / step_grey);
                 if (grey_shift0 != grey_shiftF)
                     times *= FLOOR(1 + (grey_shiftF - grey_shift0) / step_grey_shift);
                 if (rot0 != rotF)
                     times *= FLOOR(1 + (rotF - rot0) / step_rot);
                 if (tilt0 != tiltF)
                     times *= FLOOR(1 + (tiltF - tilt0) / step_tilt);
                 if (psi0 != psiF)
                     times *= FLOOR(1 + (psiF - psi0) / step_psi);
                 if (scale0 != scaleF)
                     times *= FLOOR(1 + (scaleF - scale0) / step_scale);
                 if (z0 != zF)
                     times *= FLOOR(1 + (zF - z0) / step_z);
                 if (y0 != yF)
                     times *= FLOOR(1 + (yF - y0) / step_y);
                 if (x0 != xF)
                     times *= FLOOR(1 + (xF - x0) / step_x);
                 init_progress_bar(times);
             }
             else
                 std::cout << "#grey_factor rot tilt psi scale z y x fitness\n";
 
             // Iterate
             int itime = 0;
             int step_time = CEIL((double)times / 60.0);
             Matrix1D<double> r(3);
             Matrix1D<double> trial(9);
             for (double grey_scale = grey_scale0; grey_scale <= grey_scaleF ; grey_scale += step_grey)
                 for (double grey_shift = grey_shift0; grey_shift <= grey_shiftF ; grey_shift += step_grey_shift)
                     for (double rot = rot0; rot <= rotF ; rot += step_rot)
                         for (double tilt = tilt0; tilt <= tiltF ; tilt += step_tilt)
                             for (double psi = psi0; psi <= psiF ; psi += step_psi)
                                 for (double scale = scale0; scale <= scaleF ; scale += step_scale)
                                     for (ZZ(r) = z0; ZZ(r) <= zF ; ZZ(r) += step_z)
                                         for (YY(r) = y0; YY(r) <= yF ; YY(r) += step_y)
                                             for (XX(r) = x0; XX(r) <= xF ; XX(r) += step_x)
                                             {
                                                 // Form trial vector
                                                 trial(0) = grey_scale;
                                                 trial(1) = grey_shift;
                                                 trial(2) = rot;
                                                 trial(3) = tilt;
                                                 trial(4) = psi;
                                                 trial(5) = scale;
                                                 trial(6) = ZZ(r);
                                                 trial(7) = YY(r);
                                                 trial(8) = XX(r);
                                                 // Evaluate
                                                 double fit = fitness(MATRIX1D_ARRAY(trial));
                                                 // The best?
                                                 if (fit < best_fit || first)
                                                 {
                                                     best_fit = fit;
                                                     best_align = trial;
                                                     first = false;
                                                     if (tell)
                                                         std::cout << "Best so far\n";
                                                 }
                                                 // Show fit
                                                 if (tell)
                                                     std::cout << trial << " " << fit << std::endl;
                                                 else
                                                     if (++itime % step_time == 0)
                                                         progress_bar(itime);
                                             }
             if (!tell)
                 progress_bar(times);
         }
         else if (usePowell)
         {
             // Use Powell optimization
             Matrix1D<double> x(9), steps(9);
             double fitness;
             int iter;
             steps.initConstant(1);
             if (onlyShift)
                 steps(0)=steps(1)=steps(2)=steps(3)=steps(4)=steps(5)=0;
             if (params.alignment_method == COVARIANCE)
                 steps(0)=steps(1)=0;
             if (dontScale)
                 steps(5)=0;
             x(0)=grey_scale0;
             x(1)=grey_shift0;
             x(2)=rot0;
             x(3)=tilt0;
             x(4)=psi0;
             x(5)=scale0;
             x(6)=z0;
             x(7)=y0;
             x(8)=x0;
 
             powellOptimizer(x,1,9,&wrapperFitness,nullptr,0.01,fitness,iter,steps,true);
             best_align=x;
             best_fit=fitness;
             first=false;
         }
         else if (useFRM)
         {
             Python::initPythonAndNumpy();
             PyObject * pFunc = Python::getFunctionRef("sh_alignment.frm", "frm_align");
             double rot,tilt,psi,x,y,z,score;
             Matrix2D<double> A;
             if(starting_tilt!=-90 || ending_tilt!=90){
                 std::cout<<"you are compensating for the missing wedge, the first volume should be rotated with 90 degrees about the y-axis"<<std::endl;
                 PyObject * pSTMMclass = Python::getClassRef("sh_alignment.tompy.filter", "SingleTiltWedge");
                 PyObject * arglist = Py_BuildValue("(ii)", starting_tilt , ending_tilt);
                 PyObject * SingleTiltWedgeMask = PyObject_CallObject(pSTMMclass, arglist);
                 // The order of volumes has to be flipped in order to compensate for a single tilt missing wedge. For those who are not using this mask, no changes in results will happen.
                 alignVolumesFRM(pFunc, params.V2(), params.V1(), SingleTiltWedgeMask, rot,tilt,psi,x,y,z,score,A,maxShift,maxFreq,params.mask_ptr);
                 std::cout<<"If you intend to apply transform using xmipp_transform_geometry, use --inverse flag (if it was not present before), or remove it (if it was present before)"<<std::endl;
                 Py_DECREF(SingleTiltWedgeMask);
                 Py_DECREF(arglist);
                 Py_DECREF(pSTMMclass);
             }
             else{
                 alignVolumesFRM(pFunc, params.V1(), params.V2(), Py_None, rot,tilt,psi,x,y,z,score,A,maxShift,maxFreq,params.mask_ptr);
             }
             best_align.initZeros(9);
             best_align(0)=1; // Gray scale
             best_align(1)=0; // Gray shift
             best_align(2)=rot;
             best_align(3)=tilt;
             best_align(4)=psi;
             best_align(5)=1; // Scale
             best_align(6)=z;
             best_align(7)=y;
             best_align(8)=x;
             best_fit=-score;
             first=false;
         }
 
         if (!first)
             std::cout << "The best correlation is for\n"
             << "Scale                  : " << best_align(5) << std::endl
             << "Translation (X,Y,Z)    : " << best_align(8)
             << " " << best_align(7) << " " << best_align(6)
             << std::endl
             << "Rotation (rot,tilt,psi): "
             << best_align(2) << " " << best_align(3) << " "
             << best_align(4) << std::endl
             << "Best grey scale       : " << best_align(0) << std::endl
             << "Best grey shift       : " << best_align(1) << std::endl
             << "Fitness value         : " << best_fit << std::endl;
         Matrix1D<double> r(3);
         XX(r)            = best_align(8);
         YY(r)            = best_align(7);
         ZZ(r)            = best_align(6);
         Matrix2D<double> A,Aaux;
 
         Euler_angles2matrix(best_align(2), best_align(3), best_align(4),
                             A, true);
 
         translation3DMatrix(r,Aaux);
 
         //A = A + Aaux;
         //A(0,0) -= 1;
         //A(1,1) -= 1;
         //A(2,2) -= 1;
         //A(3,3) -= 1;
         A = A * Aaux;
 
         scale3DMatrix(vectorR3(best_align(5), best_align(5), best_align(5)),Aaux);
         A = A * Aaux;
 
         if (verbose!=0)
             std::cout << "xmipp_transform_geometry will require the following values"
                       << "\n   Angles: " << best_align(2) << " "
                       << best_align(3) << " " << best_align(4)
                       << "\n   Shifts: " << A(0,3) << " " << A(1,3) << " " << A(2,3)
                       << std::endl;
         if (copyGeo)
         {
             std::ofstream outputGeo (fnGeo.c_str());
             outputGeo << A(0,0) << "\n" << A(0,1) << "\n" << A(0,2) << "\n" << A(0,3) << "\n"
                       << A(1,0) << "\n" << A(1,1) << "\n" << A(1,2) << "\n" << A(1,3) << "\n"
                       << A(2,0) << "\n" << A(2,1) << "\n" << A(2,2) << "\n" << A(2,3) << "\n"
                       << A(3,0) << "\n" << A(3,1) << "\n" << A(3,2) << "\n" << A(3,3) << "\n"
                       << std::endl;
             outputGeo.close();
         }
         if (copyGray)
         {
             std::ofstream outputGray (fnGray.c_str());
             outputGray << best_align(0) << "\n"
                        << best_align(1) << "\n"
                        << std::endl;
             outputGray.close();
         }
         if (store)
         {
             std::ofstream outputStore (fnStore.c_str());
             outputStore << best_align(2)  << ", " << best_align(3) << ", " << best_align(4) << ", " << A(0,3) << ", "
                       << A(1,3) << ", " << A(2,3) << ", " << best_fit << std::endl;
             outputStore.close();
         }
         if (apply)
         {
             applyTransformation(params.V2(),params.Vaux(),MATRIX1D_ARRAY(best_align), wrap);
             params.V2()=params.Vaux();
             params.V2.write(fnOut);
         }
     }

Member Data Documentation

◆ apply

bool ProgAlignVolumes::apply

Definition at line 126 of file volume_align_prog.cpp.

◆ copyGeo

bool ProgAlignVolumes::copyGeo

Definition at line 129 of file volume_align_prog.cpp.

◆ copyGray

bool ProgAlignVolumes::copyGray

Definition at line 129 of file volume_align_prog.cpp.

◆ dontScale

bool ProgAlignVolumes::dontScale

Definition at line 132 of file volume_align_prog.cpp.

◆ ending_tilt

int ProgAlignVolumes::ending_tilt

Definition at line 133 of file volume_align_prog.cpp.

◆ fn1

FileName ProgAlignVolumes::fn1

Definition at line 118 of file volume_align_prog.cpp.

◆ fn2

FileName ProgAlignVolumes::fn2

Definition at line 118 of file volume_align_prog.cpp.

◆ fnGeo

FileName ProgAlignVolumes::fnGeo

Definition at line 127 of file volume_align_prog.cpp.

◆ fnGray

FileName ProgAlignVolumes::fnGray

Definition at line 127 of file volume_align_prog.cpp.

◆ fnOut

FileName ProgAlignVolumes::fnOut

Definition at line 127 of file volume_align_prog.cpp.

◆ fnStore

FileName ProgAlignVolumes::fnStore

Definition at line 127 of file volume_align_prog.cpp.

◆ grey_scale0

double ProgAlignVolumes::grey_scale0

Definition at line 123 of file volume_align_prog.cpp.

◆ grey_scaleF

double ProgAlignVolumes::grey_scaleF

Definition at line 123 of file volume_align_prog.cpp.

◆ grey_shift0

double ProgAlignVolumes::grey_shift0

Definition at line 124 of file volume_align_prog.cpp.

◆ grey_shiftF

double ProgAlignVolumes::grey_shiftF

Definition at line 124 of file volume_align_prog.cpp.

◆ mask

Mask ProgAlignVolumes::mask

Definition at line 116 of file volume_align_prog.cpp.

◆ mask_enabled

bool ProgAlignVolumes::mask_enabled

Definition at line 128 of file volume_align_prog.cpp.

◆ maxFreq

double ProgAlignVolumes::maxFreq

Definition at line 130 of file volume_align_prog.cpp.

◆ maxShift

int ProgAlignVolumes::maxShift

Definition at line 131 of file volume_align_prog.cpp.

◆ onlyShift

bool ProgAlignVolumes::onlyShift

Definition at line 129 of file volume_align_prog.cpp.

◆ psi0

double ProgAlignVolumes::psi0

Definition at line 119 of file volume_align_prog.cpp.

◆ psiF

double ProgAlignVolumes::psiF

Definition at line 119 of file volume_align_prog.cpp.

◆ rot0

double ProgAlignVolumes::rot0

Definition at line 119 of file volume_align_prog.cpp.

◆ rotF

double ProgAlignVolumes::rotF

Definition at line 119 of file volume_align_prog.cpp.

◆ scale0

double ProgAlignVolumes::scale0

Definition at line 121 of file volume_align_prog.cpp.

◆ scaleF

double ProgAlignVolumes::scaleF

Definition at line 121 of file volume_align_prog.cpp.

◆ starting_tilt

int ProgAlignVolumes::starting_tilt

Definition at line 133 of file volume_align_prog.cpp.

◆ step_grey

double ProgAlignVolumes::step_grey

Definition at line 123 of file volume_align_prog.cpp.

◆ step_grey_shift

double ProgAlignVolumes::step_grey_shift

Definition at line 124 of file volume_align_prog.cpp.

◆ step_psi

double ProgAlignVolumes::step_psi

Definition at line 120 of file volume_align_prog.cpp.

◆ step_rot

double ProgAlignVolumes::step_rot

Definition at line 120 of file volume_align_prog.cpp.

◆ step_scale

double ProgAlignVolumes::step_scale

Definition at line 121 of file volume_align_prog.cpp.

◆ step_tilt

double ProgAlignVolumes::step_tilt

Definition at line 120 of file volume_align_prog.cpp.

◆ step_x

double ProgAlignVolumes::step_x

Definition at line 122 of file volume_align_prog.cpp.

◆ step_y

double ProgAlignVolumes::step_y

Definition at line 122 of file volume_align_prog.cpp.

◆ step_z

double ProgAlignVolumes::step_z

Definition at line 122 of file volume_align_prog.cpp.

◆ store

bool ProgAlignVolumes::store

Definition at line 129 of file volume_align_prog.cpp.

◆ tell

int ProgAlignVolumes::tell

Definition at line 125 of file volume_align_prog.cpp.

◆ tilt0

double ProgAlignVolumes::tilt0

Definition at line 119 of file volume_align_prog.cpp.

◆ tiltF

double ProgAlignVolumes::tiltF

Definition at line 119 of file volume_align_prog.cpp.

◆ useFRM

bool ProgAlignVolumes::useFRM

Definition at line 129 of file volume_align_prog.cpp.

◆ usePowell

bool ProgAlignVolumes::usePowell

Definition at line 129 of file volume_align_prog.cpp.

◆ wrap

bool ProgAlignVolumes::wrap

Definition at line 129 of file volume_align_prog.cpp.

◆ x0

double ProgAlignVolumes::x0

Definition at line 122 of file volume_align_prog.cpp.

◆ xF

double ProgAlignVolumes::xF

Definition at line 122 of file volume_align_prog.cpp.

◆ y0

double ProgAlignVolumes::y0

Definition at line 122 of file volume_align_prog.cpp.

◆ yF

double ProgAlignVolumes::yF

Definition at line 122 of file volume_align_prog.cpp.

◆ z0

double ProgAlignVolumes::z0

Definition at line 122 of file volume_align_prog.cpp.

◆ zF

double ProgAlignVolumes::zF

Definition at line 122 of file volume_align_prog.cpp.

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

xmipp/libraries/reconstruction/volume_align_prog.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ defineParams()

◆ readParams()

◆ run()

Member Data Documentation

◆ apply

◆ copyGeo

◆ copyGray

◆ dontScale

◆ ending_tilt

◆ fn1

◆ fn2

◆ fnGeo

◆ fnGray

◆ fnOut

◆ fnStore

◆ grey_scale0

◆ grey_scaleF

◆ grey_shift0

◆ grey_shiftF

◆ mask

◆ mask_enabled

◆ maxFreq

◆ maxShift

◆ onlyShift

◆ psi0

◆ psiF

◆ rot0

◆ rotF

◆ scale0

◆ scaleF

◆ starting_tilt

◆ step_grey

◆ step_grey_shift

◆ step_psi

◆ step_rot

◆ step_scale

◆ step_tilt

◆ step_x

◆ step_y

◆ step_z

◆ store

◆ tell

◆ tilt0

◆ tiltF

◆ useFRM

◆ usePowell

◆ wrap

◆ x0

◆ xF

◆ y0

◆ yF

◆ z0

◆ zF