EMAN::RT3DSphereAligner Class Reference

3D rotational and translational alignment using spherical sampling, can reduce the search space based on symmetry. More...

#include <aligner.h>

Inheritance diagram for EMAN::RT3DSphereAligner:

[legend]

Collaboration diagram for EMAN::RT3DSphereAligner:

[legend]

List of all members.

Public Member Functions
virtual EMData *	align (EMData *this_img, EMData *to_img, const string &cmp_name, const Dict &cmp_params) const
	See Aligner comments for more details.
virtual EMData *	align (EMData *this_img, EMData *to_img) const
	See Aligner comments for more details.
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.
virtual string	get_name () const
	Get the Aligner's name.
virtual string	get_desc () const
virtual TypeDict	get_param_types () const
Static Public Member Functions
static Aligner *	NEW ()

---

Detailed Description

3D rotational and translational alignment using spherical sampling, can reduce the search space based on symmetry.

can also make use of different OrientationGenerators (random, for example) 160-180% more efficient than the RT3DGridAligner

Author:

David Woolford

Date:

June 23 2009

Definition at line 701 of file aligner.h.

---

Member Function Documentation

EMData * RT3DSphereAligner::align	(	EMData *	this_img,
		EMData *	to_img,
		const string &	cmp_name,
		const Dict &	cmp_params
	)			const [virtual]

See Aligner comments for more details.

Implements EMAN::Aligner.

Definition at line 1473 of file aligner.cpp.

References EMAN::EMData::process(), EMAN::EMData::set_attr(), t, and xform_align_nbest().

Referenced by align().

{

        vector<Dict> alis = xform_align_nbest(this_img,to,1,cmp_name,cmp_params);

        Dict t;
        Transform* tr = (Transform*) alis[0]["xform.align3d"];
        t["transform"] = tr;
        EMData* soln = this_img->process("math.transform",t);
        soln->set_attr("xform.align3d",tr);
        delete tr; tr = 0;

        return soln;

}

virtual EMData* EMAN::RT3DSphereAligner::align	(	EMData *	this_img,
		EMData *	to_img
	)			const [inline, virtual]

See Aligner comments for more details.

Implements EMAN::Aligner.

Definition at line 710 of file aligner.h.

References align().

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

vector< Dict > RT3DSphereAligner::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 1489 of file aligner.cpp.

References EMAN::EMData::calc_ccf(), EMAN::EMData::calc_max_location_wrap(), EMAN::EMData::cmp(), copy(), EMAN::Symmetry3D::gen_orientations(), EMAN::EMData::get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, InvalidParameterException, EMAN::Aligner::params, phi, EMAN::EMData::process(), EMAN::Dict::set_default(), and t.

Referenced by align().

                                                                                                                                                                 {

        if ( this_img->get_ndim() != 3 || to->get_ndim() != 3 ) {
                throw ImageDimensionException("This aligner only works for 3D images");
        }

        int searchx = 0;
        int searchy = 0;
        int searchz = 0;

        if (params.has_key("search")) {
                vector<string> check;
                check.push_back("searchx");
                check.push_back("searchy");
                check.push_back("searchz");
                for(vector<string>::const_iterator cit = check.begin(); cit != check.end(); ++cit) {
                        if (params.has_key(*cit)) throw InvalidParameterException("The search parameter is mutually exclusive of the searchx, searchy, and searchz parameters");
                }
                int search  = params["search"];
                searchx = search;
                searchy = search;
                searchz = search;
        } else {
                searchx = params.set_default("searchx",3);
                searchy = params.set_default("searchy",3);
                searchz = params.set_default("searchz",3);
        }

        float rphi = params.set_default("rphi",180.f);
        float dphi = params.set_default("dphi",10.f);
        float threshold = params.set_default("threshold",0.f);
        if (threshold < 0.0f) throw InvalidParameterException("The threshold parameter must be greater than or equal to zero");
        bool verbose = params.set_default("verbose",false);

        vector<Dict> solns;
        if (nsoln == 0) return solns; // What was the user thinking?
        for (unsigned int i = 0; i < nsoln; ++i ) {
                Dict d;
                d["score"] = 1.e24;
                Transform t; // identity by default
                d["xform.align3d"] = &t; // deep copy is going on here
                solns.push_back(d);
        }

        Dict d;
        d["inc_mirror"] = true; // This should probably always be true for 3D case. If it ever changes we might have to make inc_mirror a parameter
        if ( params.has_key("delta") && params.has_key("n") ) {
                throw InvalidParameterException("The delta and n parameters are mutually exclusive in the RT3DSphereAligner aligner");
        } else if ( params.has_key("n") ) {
                d["n"] = params["n"];
        } else {
                // If they didn't specify either then grab the default delta - if they did supply delta we're still safe doing this
                d["delta"] = params.set_default("delta",10.f);
        }

        Symmetry3D* sym = Factory<Symmetry3D>::get((string)params.set_default("sym","c1"));
        vector<Transform> transforms = sym->gen_orientations((string)params.set_default("orientgen","eman"),d);

        float verbose_alt = -1.0f;;
        for(vector<Transform>::const_iterator trans_it = transforms.begin(); trans_it != transforms.end(); trans_it++) {
                Dict params = trans_it->get_params("eman");
                float az = params["az"];
                if (verbose) {
                        float alt = params["alt"];
                        if ( alt != verbose_alt ) {
                                verbose_alt = alt;
                                cout << "Trying angle " << alt << endl;
                        }
                }
                for( float phi = -rphi-az; phi <= rphi-az; phi += dphi ) {
                        params["phi"] = phi;
                        Transform t(params);
                        EMData* transformed = this_img->process("math.transform",Dict("transform",&t));
                        EMData* ccf = transformed->calc_ccf(to);
                        IntPoint point = ccf->calc_max_location_wrap(searchx,searchy,searchz);
                        Dict altered_cmp_params(cmp_params);
                        if (cmp_name == "dot.tomo") {
                                altered_cmp_params["ccf"] = ccf;
                                altered_cmp_params["tx"] = point[0];
                                altered_cmp_params["ty"] = point[1];
                                altered_cmp_params["tz"] = point[2];
                        }

                        float best_score = transformed->cmp(cmp_name,to,altered_cmp_params);
                        delete transformed; transformed =0;
                        delete ccf; ccf =0;

                        unsigned int j = 0;
                        for ( vector<Dict>::iterator it = solns.begin(); it != solns.end(); ++it, ++j ) {
                                if ( (float)(*it)["score"] > best_score ) { // Note greater than - EMAN2 preferes minimums as a matter of policy
                                        vector<Dict>::reverse_iterator rit = solns.rbegin();
                                        copy(rit+1,solns.rend()-j,rit);
                                        Dict& d = (*it);
                                        d["score"] = best_score;
                                        d["xform.align3d"] = &t; // deep copy is going on here
                                        break;
                                }
                        }

                }
        }
        delete sym; sym = 0;
        return solns;

}

virtual string EMAN::RT3DSphereAligner::get_name

(

)

const [inline, virtual]

Get the Aligner's name.

Each Aligner is identified by a unique name.

Returns:

The Aligner's name.

Implements EMAN::Aligner.

Definition at line 720 of file aligner.h.

                        {
                                return "rt.3d.sphere";
                        }

virtual string EMAN::RT3DSphereAligner::get_desc

(

)

const [inline, virtual]

Implements EMAN::Aligner.

Definition at line 725 of file aligner.h.

                        {
                                return "3D rotational and translational alignment using spherical sampling. Can reduce the search space if symmetry is supplied";
                        }

static Aligner* EMAN::RT3DSphereAligner::NEW

(

)

[inline, static]

Definition at line 730 of file aligner.h.

                        {
                                return new RT3DSphereAligner();
                        }

virtual TypeDict EMAN::RT3DSphereAligner::get_param_types

(

)

const [inline, virtual]

Implements EMAN::Aligner.

Definition at line 735 of file aligner.h.

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

                        {
                                TypeDict d;
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (asymmetry).");
                                d.put("orientgen", EMObject::STRING,"Advanced. The orientation generation strategy. Default is eman");
                                d.put("delta", EMObject::FLOAT,"Angle the separates points on the sphere. This is exclusive of the \'n\' paramater. Default is 10");
                                d.put("n", EMObject::INT,"An alternative to the delta argument, this is the number of points you want generated on the sphere. Default is OFF");
                                d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10.");
                                d.put("rphi", EMObject::FLOAT,"The range of angles to sample in the phi direction. Default is 180.");
                                d.put("search", EMObject::INT,"The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive.");
                                d.put("searchx", EMObject::INT,"The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchy", EMObject::INT,"The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchz", EMObject::INT,"The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }

---

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

• aligner.h
• aligner.cpp