EMAN::RT2Dto3DTreeAligner Class Reference

Alignment of a 2D image into a 3D volume using a hierarchical method with gradually decreasing downsampling in Fourier space. More...

#include <aligner.h>

Inheritance diagram for EMAN::RT2Dto3DTreeAligner:

Collaboration diagram for EMAN::RT2Dto3DTreeAligner:

Public Member Functions
virtual EMData *	align (EMData *this_img, EMData *to_img, const string &cmp_name="sqeuclidean", const Dict &cmp_params=Dict()) const
	See Aligner comments for more details. More...
virtual EMData *	align (EMData *this_img, EMData *to_img) const
	See Aligner comments for more details. More...
virtual vector< Dict >	xform_align_nbest (EMData *this_img, EMData *to_img, const unsigned int nsoln, const string &cmp_name, const Dict &cmp_params) const
	See Aligner comments for more details. More...
virtual string	get_name () const
	Get the Aligner's name. More...
virtual string	get_desc () const
virtual TypeDict	get_param_types () const
Public Member Functions inherited from EMAN::Aligner
virtual	~Aligner ()
virtual Dict	get_params () const
	Get the Aligner parameters in a key/value dictionary. More...
virtual void	set_params (const Dict &new_params)
	Set the Aligner parameters using a key/value dictionary. More...

Static Public Member Functions
static Aligner *	NEW ()

Static Public Attributes
static const string	NAME = "rotate_translate_2d_to_3d_tree"

Private Member Functions
bool	testort (EMData *small_this, EMData *small_to, vector< float > &s_score, vector< Transform > &s_xform, int i, Dict &upd, Transform initxf, int maxshift, int maxang) const

Additional Inherited Members
Protected Attributes inherited from EMAN::Aligner
Dict	params

Detailed Description

Alignment of a 2D image into a 3D volume using a hierarchical method with gradually decreasing downsampling in Fourier space.

In theory, very fast, and without need for a "refine" aligner. Comparator is ignored. Uses an inbuilt comparison.

Parameters

sym	The symmtery to use as the basis of the spherical sampling
verbose	Turn this on to have useful information printed to standard out

Author

Steve Ludtke

Date

Feburary 2016

Finished by MuyuanChen, 07/2018

Definition at line 1825 of file aligner.h.

Member Function Documentation

align() [1/2]

virtual EMData * EMAN::RT2Dto3DTreeAligner::align ( EMData *  this_img, EMData *  to_img  ) const

inlinevirtual

See Aligner comments for more details.

Implements EMAN::Aligner.

Definition at line 1834 of file aligner.h.

                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }

References align().

align() [2/2]

virtual EMData * EMAN::RT2Dto3DTreeAligner::align ( EMData *  this_img, EMData *  to_img, const string &  cmp_name = "sqeuclidean", const Dict &  cmp_params = Dict()  ) const

virtual

See Aligner comments for more details.

Implements EMAN::Aligner.

Referenced by align().

get_desc()

virtual string EMAN::RT2Dto3DTreeAligner::get_desc ( ) const

inlinevirtual

Implements EMAN::Aligner.

Definition at line 1849 of file aligner.h.

                        {
                                return "3D rotational and translational alignment using a hierarchical approach in Fourier space. Should be very fast and not require 'refine' alignment.";
                        }

get_name()

virtual string EMAN::RT2Dto3DTreeAligner::get_name ( ) const

inlinevirtual

Get the Aligner's name.

Each Aligner is identified by a unique name.

Returns

The Aligner's name.

Implements EMAN::Aligner.

Definition at line 1844 of file aligner.h.

                        {
                                return NAME;
                        }

References NAME.

get_param_types()

virtual TypeDict EMAN::RT2Dto3DTreeAligner::get_param_types ( ) const

inlinevirtual

Implements EMAN::Aligner.

Definition at line 1859 of file aligner.h.

                        {
                                TypeDict d;
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (no symmetry)");
                                d.put("maxshift", EMObject::INT,"maximum shift allowed");
//                              d.put("sigmathis", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
//                              d.put("sigmato", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("initxform", EMObject::TRANSFORMARRAY,"An array of Transforms storing the starting positions.");
                                d.put("maxang", EMObject::FLOAT,"maximum angle from initial rotation.");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                d.put("maxres", EMObject::FLOAT,"Maximum resolution to consider when full sampling is used");
                                d.put("minres", EMObject::FLOAT,"Minimum resolution to consider when full sampling is used");
                                return d;
                        }

References EMAN::EMObject::BOOL, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, EMAN::TypeDict::put(), EMAN::EMObject::STRING, and EMAN::EMObject::TRANSFORMARRAY.

NEW()

static Aligner * EMAN::RT2Dto3DTreeAligner::NEW ( )

inlinestatic

Definition at line 1854 of file aligner.h.

                        {
                                return new RT2Dto3DTreeAligner();
                        }

testort()

bool RT2Dto3DTreeAligner::testort ( EMData *  small_this, EMData *  small_to, vector< float > &  s_score, vector< Transform > &  s_xform, int  i, Dict &  upd, Transform  initxf, int  maxshift, int  maxang  ) const

private

Definition at line 3339 of file aligner.cpp.

                                                                                                                                                                                          {
        Transform t;
        Dict aap=s_xform[i].get_params("eman");
        
        int ny=small_this->get_ysize();
        if (params.has_key("initxform")){
                // when doing refinement, search around the given position
                const vector< Transform > xfs=params["initxform"];
                Dict xf0=xfs[i].get_params("eman");
                aap["tx"]=(float)xf0["tx"]*ny/(float)params["boxsize"];
                aap["ty"]=(float)xf0["ty"]*ny/(float)params["boxsize"];
                
        }
        else{
                aap["tx"]=0;
                aap["ty"]=0;
        }
        aap["tz"]=0;
        for (Dict::const_iterator p=upd.begin(); p!=upd.end(); p++) {
                aap[p->first]=(float)aap[p->first]+(float)p->second;
        }
        
        t.set_params(aap);
 
        
        if (maxang>0){
                
                Transform tmp=initxf * t.inverse();
                float r=tmp.get_params("spin")["omega"];
                if(r>maxang)
                        return false;
                
        }
        // rotate in Fourier space then use a CCF to find translation
//      EMData *stt=small_this->process("xform",Dict("transform",EMObject(&t),"zerocorners",1));
        EMData *stt=small_this->project("gauss_fft", Dict("transform", EMObject(&t), "returnfft", 1));
        EMData *ccf=small_to->calc_ccf(stt);
        
                
        IntPoint ml=ccf->calc_max_location_wrap(maxshift,maxshift,0);
        aap["tx"]=(int)aap["tx"]+(int)ml[0];
        aap["ty"]=(int)aap["ty"]+(int)ml[1];
 
        t.set_params(aap);
        stt->translate(t.get_trans());
//      EMData *st2=small_this->project("gauss_fft", Dict("transform", EMObject(&t), "returnfft", 1));
        
        float sim;
        sim=stt->cmp("frc",small_to, Dict("pmin",(float)ny*0.125f, "pmax", (float)ny*0.33f));
 
        delete ccf;
        delete stt;
 
        // If the score is better than before, we update this particular best value
        if (sim<s_score[i]) {
                s_score[i]=sim;
//              s_coverage[i]=1;//st2->get_attr("fft_overlap");
                s_xform[i]=t;
 
                return true;
        }
        return false;
}

References EMAN::Dict::begin(), EMAN::EMData::calc_ccf(), EMAN::Dict::end(), EMAN::Transform::get_params(), EMAN::Transform::get_trans(), EMAN::Dict::has_key(), EMAN::Transform::inverse(), EMAN::Aligner::params, EMAN::Transform::set_params(), and EMAN::EMData::translate().

Referenced by xform_align_nbest().

xform_align_nbest()

vector< Dict > RT2Dto3DTreeAligner::xform_align_nbest ( EMData *  this_img, EMData *  to_img, const unsigned int  nsoln, const string &  cmp_name, const Dict &  cmp_params  ) const

virtual

See Aligner comments for more details.

Reimplemented from EMAN::Aligner.

Definition at line 2998 of file aligner.cpp.

                                                                                                                                                                    {
        if (this_img->get_zsize()!=1 || to->get_zsize()==1) throw InvalidParameterException("ERROR (RT2Dto3DTreeAligner): first image must be 2D and second 3D");
 
        if (nrsoln == 0) throw InvalidParameterException("ERROR (RT2Dto3DTreeAligner): nsoln must be >0"); // What was the user thinking?
        
        
        int verbose = params.set_default("verbose",0);
        int nsoln = nrsoln*2;
        if (nrsoln<16) nsoln=32;                // we start with at least 32 solutions, but then gradually decrease with increasing scale
        if (params.has_key("initxform")){// refine alignment
                const vector< Transform > xfs=params["initxform"];
                nsoln=xfs.size();
        }
        
        vector<float> s_score(nsoln,1.0e24);
        vector<float> s_step(nsoln*3,7.5f);
        vector<Transform> s_xform(nsoln);
        
        int curiter=-1;
        int sexp_start=4;
        int ny=this_img->get_ysize();
        int maxshift00=(int)params.set_default("maxshift",ny/4);
        float maxres = params.set_default("maxres",-1.0f);
        float apix=(float)this_img->get_attr("apix_x");
        int maxny=ny;
        int maxrescut=ny/2;
        if (maxres>0){
                maxrescut=int(ny*apix/maxres);
                maxny=maxrescut*3/2*2;
                if(maxny>ny) maxny=ny;
        }
        if (verbose>0)
                printf("\n\n*******\nmax resolution %1.2f, box size %d\n", maxres, maxny);
        
        
        float maxang=params.set_default("maxang",-1.0);
        Transform initxf;
        
        if (params.has_key("initxform")){
                const vector< Transform > xfs=params["initxform"];
                initxf.set_params(xfs[0].get_params("eman"));
                for (unsigned int i=0; i<nsoln; i++){
                        s_xform[i].set_params(xfs[i].get_params("eman"));
                }
                sexp_start=9;
                
                
                curiter=0;
                float s=2.5;            // random initial direction to avoid bias, increased initial step 12/30/20
                if ((maxang>0) && (s>maxang/2)){
                        s=maxang/2;
                }
                std::random_device rd;
                std::uniform_int_distribution<int> dist(0, 1);
                for (int i=0; i<nsoln*3; i++) {
                        s_step[i]=s*(dist(rd))?1.0:-1.0;
                }
        }
        
        if (verbose>0) printf("%d solutions\n",nsoln);
        
        // !!!!!! IMPORTANT NOTE - we are inverting the order of this and to here to match convention in other aligners, and the transform that project the 3D image to the 2D image is returned.
        EMData *base_this;
        EMData *base_to;
        if (this_img->is_complex()) base_to=this_img->copy();
        else {
                base_to=this_img->do_fft();
                base_to->process_inplace("xform.phaseorigin.tocorner");
        }
 
        if (to->is_complex()) base_this=to->copy();
        else {
                base_this=to->do_fft();
                base_this->process_inplace("xform.phaseorigin.tocorner");
        }
 
 
 
        if (base_this->get_xsize()!=base_this->get_ysize()+2 || base_this->get_ysize()!=base_this->get_zsize()
                || base_to->get_xsize()!=base_to->get_ysize()+2 /*|| base_to->get_ysize()!=base_to->get_zsize()*/) throw InvalidCallException("ERROR (RT3DTreeAligner): requires cubic images with even numbered box sizes");
 
        base_this->process_inplace("xform.fourierorigin.tocenter");             // easier to chop out Fourier subvolumes
        base_to->process_inplace("xform.fourierorigin.tocenter");
        
        params["boxsize"]=ny;
 
 
        string axname[] = {"az","alt","phi"};
 
        // We start with 32^3, 64^3 ...
        
        for (int sexp=sexp_start; sexp<10; sexp++) {
                curiter++;
                int ss=pow(2.0,sexp);
                if (ss==16) ss=24;              // 16 may be too small, but 32 takes too long...
                if (ss==32) ss=48;              // 16 may be too small, but 32 takes too long...
                if (ss>maxny) ss=maxny;
                
                int maxshift=maxshift00*ss/ny;
                if (maxshift00<0) maxshift=-1;
                if (verbose>0) printf("\nSize %d, maxshift %d\n",ss, maxshift);
                
                EMData *small_this=base_this->get_clip(Region(0,(ny-ss)/2,(ny-ss)/2,ss+2,ss,ss));       // This one is 3D
                EMData *small_to=  base_to->  get_clip(Region(0,(ny-ss)/2,0,ss+2,ss,1));                // to is 2D
                small_this->process_inplace("xform.fourierorigin.tocorner");                                    // after clipping back to canonical form
                small_this->process_inplace("filter.highpass.gauss",Dict("cutoff_pixels",4));
                
                small_to->process_inplace("xform.fourierorigin.tocorner");
                small_to->process_inplace("filter.highpass.gauss",Dict("cutoff_pixels",4));
                
                if (ss<maxny){
                        small_to->process_inplace("filter.lowpass.gauss",Dict("cutoff_abs",0.375f));
                        small_this->process_inplace("filter.lowpass.gauss",Dict("cutoff_abs",0.375f));
                }
                
                small_this->process_inplace("xform.fourierorigin.tocenter");
 
                // This is a solid estimate for very complete searching, 2.5 is a bit arbitrary
                // make sure the altitude step hits 90 degrees, not absolutely necessary for this, but can't hurt
//              float astep = 89.999/floor(pi/(2.5*2.0*atan(2.0/ss)));
                float astep = 89.999/floor(pi/(1.5*2.0*atan(2.0/ss)));
                if ((maxang>0) && (astep>maxang/2)){
                        astep=maxang/2;
                }
 
                // This is drawn from single particle analysis testing, which in that case insures that enough sampling to
                // reasonably fill Fourier space is achieved, but doesn't perfectly apply to SPT
//              float astep = (float)(89.99/ceil(90.0*9.0/(8.0*sqrt((float)(4300.0/ss)))));     // 8 is (3+speed) from SPA with speed=5
 
                // This insures we make at least one real effort at each level
                for (int i=0; i<nsoln; i++) {
                        s_score[i]=1.0e24;      // reset the scores since the different scales will not match
                        if (fabs(s_step[i*3+0])<astep/4.0) s_step[i*3+0]*=2.0;
                        if (fabs(s_step[i*3+1])<astep/4.0) s_step[i*3+1]*=2.0;
                        if (fabs(s_step[i*3+2])<astep/4.0) s_step[i*3+2]*=2.0;
                }
 
                // This is for the first loop, we do a full search in a heavily downsampled space
                if (curiter==0) {
                        // Genrate points on a sphere in an asymmetric unit
                        if (verbose>1) printf("stage 1 - ang step %1.2f\n",astep);
                        Dict d;
                        d["inc_mirror"] = 1;
                        d["delta"] = astep;
                        Symmetry3D* sym = Factory<Symmetry3D>::get((string)params.set_default("sym","c1"));
                        // We don't generate for phi, since this can produce a very large number of orientations
                        vector<Transform> transforms = sym->gen_orientations("eman", d);
                        if (verbose>0) printf("%d orientations to test (%lu)\n",(int)(transforms.size()*(360.0/astep)),transforms.size());
 
                        for (unsigned int it=0; it<transforms.size(); it++) {
                                if (verbose>2) {
                                        printf("  %d/%lu \r",it,transforms.size());
                                        fflush(stdout);
                                }
                                for (float phi=0; phi<360.0; phi+=astep) {
                                        Transform t = transforms[it];
                                        Dict aap=t.get_params("eman");
                                        aap["phi"]=phi;
                                        aap["tx"]=0;
                                        aap["ty"]=0;
                                        aap["tz"]=0;
                                        t.set_params(aap);
//                                      t.invert();
//                                      aap=t.get_params("eman");
 
                                        // somewhat strangely, rotations are actually much more expensive than FFTs, so we use a CCF for translation
                                        EMData *stt=small_this->project("gauss_fft", Dict("transform", EMObject(&t), "returnfft", 1));
                                        
//                                      EMData *stt=small_this->process("xform",Dict("transform",EMObject(&t),"zerocorners",1));
                                        EMData *ccf=small_to->calc_ccf(stt);
                                        IntPoint ml=ccf->calc_max_location_wrap(maxshift,maxshift,0);
 
                                        aap["tx"]=(int)ml[0];
                                        aap["ty"]=(int)ml[1];
                                        aap["tz"]=0;//(int)ml[2];
                                        t.set_params(aap);
                                        
                                        delete stt;
                                        delete ccf;
                                        stt=small_this->project("gauss_fft", Dict("transform", EMObject(&t), "returnfft", 1));
                                        //                                      stt=small_this->process("xform",Dict("transform",EMObject(&t),"zerocorners",1));
                                        // we have to do 1 slow transform here now that we have the translation
 
//                                      float sim=stt->cmp("ccc.tomo.thresh",small_to,Dict("sigmaimg",sigmathis,"sigmawith",sigmato));
//                                      float sim=stt->cmp("ccc.tomo.thresh",small_to);
                                        float sim=stt->cmp("frc",small_to);
//                                      float sim=stt->cmp("fsc.tomo.auto",small_to,Dict("sigmaimg",sigmathisv,"sigmawith",sigmatov));
//                                      float sim=stt->cmp("fsc.tomo.auto",small_to);
 
                                        // We want to make sure our starting points are somewhat separated from each other, so we replace any angles too close to an existing angle
                                        // If we find an existing 'best' angle within range, then we either replace it or skip
                                        int worst=-1;
                                        float worstv=1.0e20;
                                        for (int i=0; i<nsoln; i++) {
                                                if (s_score[i]>1.0e20) continue;        // hasn't been set yet
                                                Transform tdif=s_xform[i].inverse();
                                                tdif=tdif*t;
                                                float adif=tdif.get_rotation("spin")["omega"];
                                                if (adif<astep*4) {
                                                        worst=i;
//                                                      printf("= %1.3f\n",adif);
                                                }
                                        }
 
                                        // if we weren't close to an existing angle, then we find the lowest current score and use that
                                        if (worst==-1) {
                                                // First we find the worst solution in the list of possible best solutions, or the first
                                                // solution which is currently "empty"
                                                for (int i=0; i<nsoln; i++) {
                                                        if (s_score[i]>1.0e20) { worst=i; break; }
                                                        if (s_score[i]<worstv) {worst=i; worstv=s_score[i];}
//                                                      if (s_score[i]<s_score[worst]) worst=i;
                                                }
                                        }
 
                                        // If the current solution is better than the 'worst' of the previous solutions, then we
                                        // displace it. Note that there is no sorting performed here
                                        if (sim<s_score[worst]) {
                                                s_score[worst]=sim;
//                                              s_coverage[worst]=1;//stt->get_attr("fft_overlap");
                                                s_xform[worst]=t;
                                        }
                                        delete stt;
                                }
                        }
                        if (verbose>2) printf("\n");
 
 
                }
                // Once we have our initial list of best locations, we just refine each possibility individually
                else {
                        // We generate a search pattern around each existing solution
                        if (verbose>1) printf("stage 2 (%1.2f)\n",astep);
                        for (int i=0; i<nsoln; i++) {
 
                                if (verbose>2) {
                                        printf("  %d\t%d\r",i,nsoln);
                                        fflush(stdout);
                                }
                                // We work an axis at a time until we get where we want to be. Somewhat like a simplex
                                int changed=1;
                                Dict upd0;
                                int r=testort(small_this,small_to,s_score,s_xform,i,upd0,initxf,maxshift, maxang);
                                while (changed) {
                                        changed=0;
                                        for (int axis=0; axis<3; axis++) {
                                                if (fabs(s_step[i*3+axis])<astep/4.0) continue;         // skip axes where we already have enough precision on this axis
                                                Dict upd;
                                                upd[axname[axis]]=s_step[i*3+axis];
                                                // when moving az, we move phi in the opposite direction by the same amount since the two are singular at alt=0
                                                // phi continues to move independently. I believe this should produce a more monotonic energy surface
                                                if (axis==0) upd[axname[2]]=-s_step[i*3+axis];
 
                                                int r=testort(small_this,small_to,s_score,s_xform,i,upd,initxf,maxshift, maxang);
 
                                                // If we fail, we reverse direction with a slightly smaller step and try that
                                                // Whether this fails or not, we move on to the next axis
                                                if (r) changed=1;
                                                else {
                                                        s_step[i*3+axis]*=-0.75;
                                                        upd[axname[axis]]=s_step[i*3+axis];
                                                        r=testort(small_this,small_to,s_score,s_xform,i,upd,initxf,maxshift, maxang);
                                                        if (r) changed=1;
                                                }
                                                if (verbose>4) printf("\nX %1.3f\t%1.3f\t%1.3f\t%d\t",s_step[i*3],s_step[i*3+1],s_step[i*3+2],changed);
                                        }
                                        if (verbose>3) {
                                                        Dict aap=s_xform[i].get_params("eman");
                                                        printf("\n%1.3f\t%1.3f\t%1.3f\t%1.3f\t%1.3f\t%1.3f\t(%1.3f)",s_step[i*3],s_step[i*3+1],s_step[i*3+2],float(aap["az"]),float(aap["alt"]),float(aap["phi"]),s_score[i]);
                                        }
 
                                        if (!changed) {
//                                              for (int j=0; j<3; j++) s_step[i*3+j]*-0.75;
                                                changed=1;
                                        }
                                        if (fabs(s_step[i*3])<astep/4 && fabs(s_step[i*3+1])<astep/4 && fabs(s_step[i*3+2])<astep/4) changed=0;
                                }
 
                                // Ouch, exhaustive (local) search
//                              for (int daz=-1; daz<=1; daz++) {
//                                      for (int dalt=-1; dalt<=1; dalt++) {
//                                              for (int dphi=-1; dphi<=1; dphi++) {
//                                                      Dict upd;
//                                                      upd["az"]=daz*astep;
//                                                      upd["alt"]=dalt*astep;
//                                                      upd["phi"]=dphi*astep;
//                                                      int r=testort(small_this,small_to,s_score,s_coverage,s_xform,i,upd);
//                                              }
//                                      }
//                              }
                        }
                }
                // lazy earlier in defining s_ vectors, so lazy here too and inefficiently sorting
                // We are sorting inside the outermost loop so we can decrease the number of solutions
                // before we get to the finest precision
                for (unsigned int i=0; i<nsoln-1; i++) {
                        for (unsigned int j=i+1; j<nsoln; j++) {
                                if (s_score[i]>s_score[j]) {
                                        float t=s_score[i]; s_score[i]=s_score[j]; s_score[j]=t;
                                        Transform tt=s_xform[i]; s_xform[i]=s_xform[j]; s_xform[j]=tt;
                                }
                        }
                }
                for (unsigned int i=0; i<nsoln-1; i++) {
                        Transform tt=s_xform[i];
                        tt.set_trans(tt.get_trans()*(float)ny/(float)ss);
                        s_xform[i]=tt;
                }
 
                // At each level of sampling we (potentially) decrease the number of answers we check in detail
                // assuming we are gradually homing in on the best solution
                nsoln/=2;
                if (nsoln<nrsoln) nsoln=nrsoln;
 
 
                delete small_this;
                delete small_to;
                if (ss>=maxny && curiter>0) break;
        }
 
        delete base_this;
        delete base_to;
 
 
        // initialize results
        vector<Dict> solns;
        for (unsigned int i = 0; i < nrsoln; ++i ) {
                Dict d;
                d["score"] = s_score[i];
//              d["coverage"] = s_coverage[i];
//              s_xform[i].invert();    // this is because we inverted the order of the input images above to match convention
                d["xform.align3d"] = &s_xform[i];
                d["xform.projection"] = &s_xform[i]; // we actually return the transform that project the 3D reference to 2D image.
                solns.push_back(d);
        }
 
        return solns;
}

References EMAN::EMData::calc_ccf(), EMAN::Symmetry3D::gen_orientations(), EMAN::Factory< T >::get(), EMAN::EMData::get_clip(), EMAN::Aligner::get_params(), EMAN::Transform::get_params(), EMAN::Transform::get_rotation(), EMAN::Transform::get_trans(), EMAN::Dict::has_key(), InvalidCallException, InvalidParameterException, EMAN::Transform::inverse(), EMAN::Aligner::params, EMAN::Dict::set_default(), EMAN::Transform::set_params(), EMAN::Transform::set_trans(), EMAN::Dict::size(), and testort().

Member Data Documentation

NAME

const string RT2Dto3DTreeAligner::NAME = "rotate_translate_2d_to_3d_tree"

static

Definition at line 1874 of file aligner.h.

Referenced by get_name().

---

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

• aligner.h
• aligner.cpp