Inheritance diagram for ProgVolumeFindSymmetry:

Collaboration diagram for ProgVolumeFindSymmetry:

Public Member Functions
void	defineParams ()

void	readParams ()

void	threadEvaluateSymmetry (int thrId)

void	run ()

double	evaluateSymmetry (double *p)

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
int	rot_sym

bool	useSplines

FileName	fn_input

FileName	fn_output

String	sym2

double	rot0

double	rotF

double	step_rot

double	rotLocal

double	tilt0

double	tiltF

double	step_tilt

double	z0

double	zF

double	step_z

double	zLocal

double	Ts

double	heightFraction

bool	local

bool	helical

bool	helicalDihedral

Mask	mask_prm

int	numberOfThreads

int	Cn

Image< double >	volume

std::vector< double >	rotVector

std::vector< double >	tiltVector

std::vector< double >	zVector

ThreadTaskDistributor *	td

MultidimArray< double >	vbest_corr

MultidimArray< double >	vbest_rot

MultidimArray< double >	vbest_tilt

MultidimArray< double >	vbest_z

Image< double >	helicalCorrelation

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 41 of file volume_find_symmetry.cpp.

Member Function Documentation

◆ defineParams()

void ProgVolumeFindSymmetry::defineParams ( )

inlinevirtual

Function in which the param of each Program are defined.

Reimplemented from XmippProgram.

Definition at line 58 of file volume_find_symmetry.cpp.

     {
         addUsageLine("Find a symmetry rotational axis.");
         addUsageLine("+The output is of the form");
         addUsageLine("+Symmetry axis (rot,tilt)= 10 20 -->    0.33682   0.059391    0.93969",true);
         addUsageLine("+The angles represent the rot and tilt angles of the symmetry axis ");
         addUsageLine("+see [[http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/Conventions#Euler_Angles][the note on Euler angles]] ");
         addUsageLine("+convention in Xmipp). The rest of the numbers is the axis itself in X, Y, Z ");
         addUsageLine("+coordinates. In this way, the symmetry axis is a line that passes through the ");
         addUsageLine("+center of the volume and whose direction is this vector.");
         addUsageLine("+It is important that the volume is correctly centered.");
         addSeeAlsoLine("volume_center, transform_geometry");
         addParamsLine(" -i <volumeFile>                : Volume to process");
         addParamsLine("[-o+ <file=\"\">]               : Metadata with the orientation of the symmetry axis");
         addParamsLine("                                : In helical mode, there is a file called output.xmp ");
         addParamsLine("                                : with the correlation map (vertical axis is the rotation, ");
         addParamsLine("                                : horizontal axis is the translation)");
         addParamsLine("[--thr <N=1>]                   : Number of threads");
         addParamsLine("--sym <mode>                    : Symmetry mode");
         addParamsLine("    where <mode>");
         addParamsLine("           rot <n>              : Order of the rotational axis");
         addParamsLine("           helical              : Helical symmetry.");
         addParamsLine("           helicalDihedral      : Helical-Dihedral symmetry.");
         addParamsLine("[--sym2 <Cn=C1>]                : Additional Cn symmetry. Only for helical and helicalDihedral");
         addParamsLine("==Locate rotational axis==");
         addParamsLine("[--rot  <rot0=0>  <rotF=355> <step=5>]: Limits for rotational angle search");
         addParamsLine("[--tilt <tilt0=0> <tiltF=90> <step=5>]: Limits for tilt angle search");
         addParamsLine("[--localRot <rot0> <tilt0>]     : Perform a local search around this angle");
         addParamsLine("[--useSplines+]                 : Use cubic B-Splines for the interpolations");
         addParamsLine("==Locate helical parameters==");
         addParamsLine("[-z <z0=1> <zF=10> <zstep=0.5>] : Search space for the shift in Z (in Angstroms)");
         addParamsLine("[--sampling <T=1>]              : Sampling rate in A/pix");
         addParamsLine("[--rotHelical <rot0=-357> <rotF=357> <step=3>]: Search space for rotation around Z");
         addParamsLine("[--localHelical <z> <rot>]      : Perform a local search around this angle and shift");
         addParamsLine("[--heightFraction <f=1>]        : Use this fraction of the volume");
         mask_prm.defineParams(this,INT_MASK,nullptr,"Restrict the comparison to the mask area.",true);
         addExampleLine("A typical application for a rotational symmetry axis is ",false);
         addExampleLine("xmipp_volume_center -i volume.vol");
         addExampleLine("xmipp_volume_find_symmetry -i volume.vol --sym rot 3");
         addExampleLine("Presume the symmetry axis is in rot=20, tilt=10. To align vertically the axis use",false);
         addExampleLine("xmipp_transform_geometry -i volume.vol --rotate_volume euler 20 10 0");
         addExampleLine("For locating the helical parameters use",false);
         addExampleLine("xmipp_volume_find_symmetry -i volume --sym helical -z 0 6 1 --mask circular -32 --thr 2 -o parameters.xmd");
     }

◆ evaluateSymmetry()

double ProgVolumeFindSymmetry::evaluateSymmetry ( double * p )

inline

Definition at line 359 of file volume_find_symmetry.cpp.

     {
         MultidimArray<double> volume_sym, volume_aux;
         const MultidimArray<double> &mVolume=volume();
         Matrix2D<double> sym_matrix;
         if (!helical && !helicalDihedral)
         {
             Matrix2D<double> Euler;
             Matrix1D<double> sym_axis;
 
             double rot=p[1];
             double tilt=p[2];
 
             // Compute symmetry axis
             Euler_angles2matrix(rot, tilt, 0., Euler);
             Euler.getRow(2, sym_axis);
             sym_axis.selfTranspose();
 
             // Symmetrize along this axis
             volume_sym = volume();
             for (int n = 1; n < rot_sym; n++)
             {
                 rotation3DMatrix(360.0 / rot_sym * n, sym_axis, sym_matrix);
                 if (useSplines)
                     applyGeometry(xmipp_transformation::BSPLINE3, volume_aux, mVolume, sym_matrix,
                                   xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP);
                 else
                     applyGeometry(xmipp_transformation::LINEAR, volume_aux, mVolume, sym_matrix,
                                   xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP);
                 volume_sym += volume_aux;
             }
             return -correlationIndex(mVolume, volume_sym, &mask_prm.get_binary_mask());
         }
         else
         {
             double rotHelical=p[1];
             double zHelical=p[2];
             if (zHelical<0 || zHelical>ZSIZE(mVolume)*0.4)
                 return 1e38;
             if (zHelical<z0 || zHelical>zF || rotHelical<rot0 || rotHelical>rotF)
                 return 1e38;
             symmetry_Helical(volume_sym, mVolume, zHelical, DEG2RAD(rotHelical), 0, &mask_prm.get_binary_mask(), helicalDihedral, heightFraction,Cn);
             double corr=correlationIndex(mVolume, volume_sym, &mask_prm.get_binary_mask());
 //#define DEBUG
 #ifdef DEBUG
 
                 Image<double> save;
                 save()=mVolume;
                 save.write("PPPvol.vol");
                 save()=volume_sym;
                 save.write("PPPvolsym.vol");
                 typeCast(mask_prm.get_binary_mask(),save());
                 save.write("PPPmask.vol");
                 std::cout << p[1] << " " << p[2] << " " << p[3] << " -> " << corr << std::endl;
                 char c;
                 std::cin >> c;
 #endif
             return -corr;
         }
     }

◆ readParams()

void ProgVolumeFindSymmetry::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 104 of file volume_find_symmetry.cpp.

     {
         fn_input = getParam("-i");
         fn_output = getParam("-o");
         String mode;
         mode=getParam("--sym");
         if (mode=="helical")
             helical=true;
         else if (mode=="helicalDihedral")
             helicalDihedral=true;
         else
         {
             helical=false;
             helicalDihedral=false;
             rot_sym = getIntParam("--sym",1);
         }
         useSplines = checkParam("--useSplines");
         if (helical || helicalDihedral)
         {
             Ts=getDoubleParam("--sampling");
             heightFraction=getDoubleParam("--heightFraction");
             local=checkParam("--localHelical");
             if (local)
             {
                 zLocal=getDoubleParam("--localHelical",0)/Ts;
                 rotLocal=getDoubleParam("--localHelical",1);
             }
             z0=getDoubleParam("-z",0)/Ts;
             zF=getDoubleParam("-z",1)/Ts;
             step_z=getDoubleParam("-z",2)/Ts;
             rot0=getDoubleParam("--rotHelical",0);
             rotF=getDoubleParam("--rotHelical",1);
             step_rot=getDoubleParam("--rotHelical",2);
             sym2 = getParam("--sym2");
             Cn=std::stoi(sym2.substr(1));
         }
         else
         {
             local=checkParam("--localRot");
             if (local)
             {
                 rot0=getDoubleParam("--localRot",0);
                 tilt0=getDoubleParam("--localRot",1);
             }
             else
             {
                 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);
             }
         }
         mask_prm.allowed_data_types = INT_MASK;
         if (checkParam("--mask"))
             mask_prm.readParams(this);
         numberOfThreads=getIntParam("--thr");
     }

◆ run()

void ProgVolumeFindSymmetry::run ( )

inlinevirtual

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

Reimplemented from XmippProgram.

Definition at line 205 of file volume_find_symmetry.cpp.

     {
         // Read input volume
         volume.read(fn_input);
         volume().setXmippOrigin();
         mask_prm.generate_mask(volume());
         double best_corr, best_rot, best_tilt, best_z;
         td=nullptr;
 
         if (!helical && !helicalDihedral)
         {
             // Look for the rotational symmetry axis
             if (!local)
             {
                 if (verbose>0)
                     std::cerr << "Searching symmetry axis ...\n";
                 for (double rot = rot0; rot <= rotF; rot += step_rot)
                     for (double tilt = tilt0; tilt <= tiltF; tilt += step_tilt)                    {
                         rotVector.push_back(rot);
                         tiltVector.push_back(tilt);
                     }
                 vbest_corr.resizeNoCopy(numberOfThreads);
                 vbest_corr.initConstant(-1e38);
                 vbest_rot.initZeros(numberOfThreads);
                 vbest_tilt.initZeros(numberOfThreads);
                 td = new ThreadTaskDistributor(rotVector.size(), 5);
                 ThreadManager thMgr(numberOfThreads,this);
                 thMgr.run(globalThreadEvaluateSymmetry);
                 best_corr=-1e38;
                 FOR_ALL_ELEMENTS_IN_ARRAY1D(vbest_corr)
                 if (vbest_corr(i)>best_corr)
                 {
                     best_corr=vbest_corr(i);
                     best_rot=vbest_rot(i);
                     best_tilt=vbest_tilt(i);
                 }
             }
             else
             {
                 Matrix1D<double> p(2), steps(2);
                 p(0)=rot0;
                 p(1)=tilt0;
                 double fitness;
                 int iter;
                 steps.initConstant(1);
                 powellOptimizer(p,1,2,&evaluateSymmetryWrapper,this,0.01,
                                 fitness,iter,steps,true);
                 best_rot=p(0);
                 best_tilt=p(1);
             }
             Matrix2D<double> Euler;
             Matrix1D<double> sym_axis;
             Euler_angles2matrix(best_rot, best_tilt, 0., Euler);
             Euler.getRow(2, sym_axis);
             if (verbose!=0)
                 std::cout << "Symmetry axis (rot,tilt)= " << best_rot << " "
                 << best_tilt << " --> " << sym_axis << std::endl;
             if (fn_output!="")
             {
                 std::vector<double> direction;
                 direction.push_back(XX(sym_axis));
                 direction.push_back(YY(sym_axis));
                 direction.push_back(ZZ(sym_axis));
 
                 MetaDataVec MD;
                 size_t id=MD.addObject();
                 MD.setValue(MDL_ANGLE_ROT,best_rot,id);
                 MD.setValue(MDL_ANGLE_TILT,best_tilt,id);
                 MD.setValue(MDL_DIRECTION,direction,id);
                 MD.write(fn_output);
             }
         }
         else
         {
             // If helical or helical dihedral
             if (heightFraction<=1.0)
             {
                 int zFirst=FIRST_XMIPP_INDEX(round(heightFraction*ZSIZE(volume())));
                 int zLast=LAST_XMIPP_INDEX(round(heightFraction*ZSIZE(volume())));
                 MultidimArray<int> &mask=mask_prm.get_binary_mask();
                 FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
                     if (k<zFirst || k>zLast)
                         A3D_ELEM(mask,k,i,j)=0;
             }
 
             if (!local)
             {
                 int ydim=0, xdim=0;
                 for (double rot = rot0; rot <= rotF; rot += step_rot)
                 {
                     ydim++;
                     for (double z = z0; z <= zF; z += step_z)
                     {
                         if (ydim==1)
                             xdim++;
                         rotVector.push_back(rot);
                         zVector.push_back(z);
                     }
                 }
                 vbest_corr.resizeNoCopy(numberOfThreads);
                 vbest_corr.initConstant(-1e38);
                 vbest_rot.initZeros(numberOfThreads);
                 vbest_z.initZeros(numberOfThreads);
                 helicalCorrelation().initZeros(ydim,xdim);
                 td = new ThreadTaskDistributor(rotVector.size(), 5);
                 ThreadManager thMgr(numberOfThreads,this);
                 thMgr.run(globalThreadEvaluateSymmetry);
                 best_corr=-1e38;
                 FOR_ALL_ELEMENTS_IN_ARRAY1D(vbest_corr)
                 if (vbest_corr(i)>best_corr)
                 {
                     best_corr=vbest_corr(i);
                     best_rot=vbest_rot(i);
                     best_z=vbest_z(i);
                 }
             }
             else
             {
                 Matrix1D<double> p(2), steps(2);
                 p(0)=rotLocal;
                 p(1)=zLocal;
                 double fitness;
                 int iter;
                 steps.initConstant(1);
                 powellOptimizer(p,1,2,&evaluateSymmetryWrapper,this,0.01,
                                 fitness,iter,steps,true);
                 best_rot=p(0);
                 best_z=p(1);
                 best_corr=-fitness;
 
             }
             if (verbose!=0)
                 std::cout << "Symmetry parameters (z,rot)= " << best_z*Ts << " " << best_rot << " correlation=" << best_corr << std::endl;
             if (fn_output!="")
             {
                 MetaDataVec MD;
                 size_t id=MD.addObject();
                 MD.setValue(MDL_ANGLE_ROT,best_rot,id);
                 MD.setValue(MDL_SHIFT_Z,best_z*Ts,id);
                 MD.write(fn_output);
                 if (!local)
                     helicalCorrelation.write(fn_output.removeAllExtensions()+".xmp");
             }
         }
         delete td;
     }

◆ threadEvaluateSymmetry()

void ProgVolumeFindSymmetry::threadEvaluateSymmetry ( int thrId )

inline

Definition at line 164 of file volume_find_symmetry.cpp.

     {
         Matrix1D<double> p(2);
         DIRECT_A1D_ELEM(vbest_corr,thrId) = 0;
         DIRECT_A1D_ELEM(vbest_rot,thrId)  = 0;
         if (helical || helicalDihedral)
             DIRECT_A1D_ELEM(vbest_z,thrId) = 0;
         else
             DIRECT_A1D_ELEM(vbest_tilt,thrId) = 0;
         size_t first, last;
         if (thrId==0)
             init_progress_bar(rotVector.size());
         while (td->getTasks(first, last))
         {
             for (size_t i=first; i<=last; i++)
             {
                 XX(p)=rotVector[i];
                 if (helical || helicalDihedral)
                     YY(p)=zVector[i];
                 else
                     YY(p)=tiltVector[i];
                 double corr=-evaluateSymmetry(MATRIX1D_ARRAY(p)-1);
                 if (helical || helicalDihedral)
                     DIRECT_MULTIDIM_ELEM(helicalCorrelation(),i)=corr;
                 if (corr > DIRECT_A1D_ELEM(vbest_corr,thrId))
                 {
                     DIRECT_A1D_ELEM(vbest_corr,thrId) = corr;
                     DIRECT_A1D_ELEM(vbest_rot,thrId) = XX(p);
                     if (helical || helicalDihedral)
                         DIRECT_A1D_ELEM(vbest_z,thrId) = YY(p);
                     else
                         DIRECT_A1D_ELEM(vbest_tilt,thrId) = YY(p);
                 }
             }
             if (thrId==0)
                 progress_bar(last);
         }
         if (thrId==0)
             progress_bar(rotVector.size());
     }

Member Data Documentation

◆ Cn

int ProgVolumeFindSymmetry::Cn

Definition at line 55 of file volume_find_symmetry.cpp.

◆ fn_input

FileName ProgVolumeFindSymmetry::fn_input

Definition at line 46 of file volume_find_symmetry.cpp.

◆ fn_output

FileName ProgVolumeFindSymmetry::fn_output

Definition at line 46 of file volume_find_symmetry.cpp.

◆ heightFraction

double ProgVolumeFindSymmetry::heightFraction

Definition at line 50 of file volume_find_symmetry.cpp.

◆ helical

bool ProgVolumeFindSymmetry::helical

Definition at line 52 of file volume_find_symmetry.cpp.

◆ helicalCorrelation

Image<double> ProgVolumeFindSymmetry::helicalCorrelation

Definition at line 356 of file volume_find_symmetry.cpp.

◆ helicalDihedral

bool ProgVolumeFindSymmetry::helicalDihedral

Definition at line 52 of file volume_find_symmetry.cpp.

◆ local

bool ProgVolumeFindSymmetry::local

Definition at line 51 of file volume_find_symmetry.cpp.

◆ mask_prm

Mask ProgVolumeFindSymmetry::mask_prm

Definition at line 53 of file volume_find_symmetry.cpp.

◆ numberOfThreads

int ProgVolumeFindSymmetry::numberOfThreads

Definition at line 54 of file volume_find_symmetry.cpp.

◆ rot0

double ProgVolumeFindSymmetry::rot0

Definition at line 48 of file volume_find_symmetry.cpp.

◆ rot_sym

int ProgVolumeFindSymmetry::rot_sym

Definition at line 44 of file volume_find_symmetry.cpp.

◆ rotF

double ProgVolumeFindSymmetry::rotF

Definition at line 48 of file volume_find_symmetry.cpp.

◆ rotLocal

double ProgVolumeFindSymmetry::rotLocal

Definition at line 48 of file volume_find_symmetry.cpp.

◆ rotVector

std::vector<double> ProgVolumeFindSymmetry::rotVector

Definition at line 353 of file volume_find_symmetry.cpp.

◆ step_rot

double ProgVolumeFindSymmetry::step_rot

Definition at line 48 of file volume_find_symmetry.cpp.

◆ step_tilt

double ProgVolumeFindSymmetry::step_tilt

Definition at line 49 of file volume_find_symmetry.cpp.

◆ step_z

double ProgVolumeFindSymmetry::step_z

Definition at line 50 of file volume_find_symmetry.cpp.

◆ sym2

String ProgVolumeFindSymmetry::sym2

Definition at line 47 of file volume_find_symmetry.cpp.

◆ td

ThreadTaskDistributor* ProgVolumeFindSymmetry::td

Definition at line 354 of file volume_find_symmetry.cpp.

◆ tilt0

double ProgVolumeFindSymmetry::tilt0

Definition at line 49 of file volume_find_symmetry.cpp.

◆ tiltF

double ProgVolumeFindSymmetry::tiltF

Definition at line 49 of file volume_find_symmetry.cpp.

◆ tiltVector

std::vector<double> ProgVolumeFindSymmetry::tiltVector

Definition at line 353 of file volume_find_symmetry.cpp.

◆ Ts

double ProgVolumeFindSymmetry::Ts

Definition at line 50 of file volume_find_symmetry.cpp.

◆ useSplines

bool ProgVolumeFindSymmetry::useSplines

Definition at line 45 of file volume_find_symmetry.cpp.

◆ vbest_corr

MultidimArray<double> ProgVolumeFindSymmetry::vbest_corr

Definition at line 355 of file volume_find_symmetry.cpp.

◆ vbest_rot

MultidimArray<double> ProgVolumeFindSymmetry::vbest_rot

Definition at line 355 of file volume_find_symmetry.cpp.

◆ vbest_tilt

MultidimArray<double> ProgVolumeFindSymmetry::vbest_tilt

Definition at line 355 of file volume_find_symmetry.cpp.

◆ vbest_z

MultidimArray<double> ProgVolumeFindSymmetry::vbest_z

Definition at line 355 of file volume_find_symmetry.cpp.

◆ volume

Image<double> ProgVolumeFindSymmetry::volume

Definition at line 352 of file volume_find_symmetry.cpp.

◆ z0

double ProgVolumeFindSymmetry::z0

Definition at line 50 of file volume_find_symmetry.cpp.

◆ zF

double ProgVolumeFindSymmetry::zF

Definition at line 50 of file volume_find_symmetry.cpp.

◆ zLocal

double ProgVolumeFindSymmetry::zLocal

Definition at line 50 of file volume_find_symmetry.cpp.

◆ zVector

std::vector<double> ProgVolumeFindSymmetry::zVector

Definition at line 353 of file volume_find_symmetry.cpp.

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

xmipp/libraries/reconstruction/volume_find_symmetry.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ defineParams()

◆ evaluateSymmetry()

◆ readParams()

◆ run()

◆ threadEvaluateSymmetry()

Member Data Documentation

◆ Cn

◆ fn_input

◆ fn_output

◆ heightFraction

◆ helical

◆ helicalCorrelation

◆ helicalDihedral

◆ local

◆ mask_prm

◆ numberOfThreads

◆ rot0

◆ rot_sym

◆ rotF

◆ rotLocal

◆ rotVector

◆ step_rot

◆ step_tilt

◆ step_z

◆ sym2

◆ td

◆ tilt0

◆ tiltF

◆ tiltVector

◆ Ts

◆ useSplines

◆ vbest_corr

◆ vbest_rot

◆ vbest_tilt

◆ vbest_z

◆ volume

◆ z0

◆ zF

◆ zLocal

◆ zVector