EMAN2
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions
EMAN::OptimumOrientationGenerator Class Reference

Optimum orientation generator. More...

#include <symmetry.h>

Inheritance diagram for EMAN::OptimumOrientationGenerator:
Inheritance graph
[legend]
Collaboration diagram for EMAN::OptimumOrientationGenerator:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 OptimumOrientationGenerator ()
virtual ~OptimumOrientationGenerator ()
virtual string get_name () const
 Return "opt".
virtual string get_desc () const
 Get a description.
virtual TypeDict get_param_types () const
 Get a dictionary containing the permissable parameters of this class.
virtual vector< Transformgen_orientations (const Symmetry3D *const sym) const
 Generate Saff orientations in the asymmetric unit of the symmetry.

Static Public Member Functions

static OrientationGeneratorNEW ()
 Factory support function NEW.

Static Public Attributes

static const string NAME = "opt"
 The name of this class - used to access it from factories etc. Should be "icos".

Private Member Functions

 OptimumOrientationGenerator (const OptimumOrientationGenerator &)
 Disallow copy construction.
OptimumOrientationGeneratoroperator= (const OptimumOrientationGenerator &)
 Disallow assignment.
virtual int get_orientations_tally (const Symmetry3D *const sym, const float &delta) const
 This function returns how many orientations will be generated for a given delta (angular spacing) It does this by simulated gen_orientations.
vector< Vec3foptimize_distances (const vector< Transform > &v) const
 Optimize the distances in separating points on the unit sphere, as described by the the rotations in Transform objects.

Detailed Description

Optimum orientation generator.

Optimally distributes points on a unit sphere, then slices out a correctly sized asymmetric unit, depending on the symmetry type. The approach relies on an initial distribution of points on the unit sphere, which may be generated using any of the other orientation generators. By default, the Saff orientation generator is used.

Author:
David Woolford
Date:
March 2008

Definition at line 1369 of file symmetry.h.


Constructor & Destructor Documentation

EMAN::OptimumOrientationGenerator::OptimumOrientationGenerator ( ) [inline]

Definition at line 1372 of file symmetry.h.

Referenced by NEW().

{}
virtual EMAN::OptimumOrientationGenerator::~OptimumOrientationGenerator ( ) [inline, virtual]

Definition at line 1373 of file symmetry.h.

{}
EMAN::OptimumOrientationGenerator::OptimumOrientationGenerator ( const OptimumOrientationGenerator ) [private]

Disallow copy construction.


Member Function Documentation

vector< Transform > OptimumOrientationGenerator::gen_orientations ( const Symmetry3D *const  sym) const [virtual]

Generate Saff orientations in the asymmetric unit of the symmetry.

Parameters:
symthe symmetry which defines the interesting asymmetric unit
Returns:
a vector of Transform objects containing the set of evenly distributed orientations

Implements EMAN::OrientationGenerator.

Definition at line 770 of file symmetry.cpp.

References EMAN::OrientationGenerator::add_orientation(), angles, EMAN::FactoryBase::copy_relevant_params(), EMAN::OrientationGenerator::gen_orientations(), EMAN::OrientationGenerator::get_optimal_delta(), InvalidParameterException, EMAN::Symmetry3D::is_in_asym_unit(), EMAN::RandomOrientationGenerator::NAME, optimize_distances(), EMAN::FactoryBase::params, EMAN::Dict::set_default(), and EMAN::FactoryBase::set_params().

{
        float delta = params.set_default("delta", 0.0f);
        int n = params.set_default("n", 0);

        bool inc_mirror = params.set_default("inc_mirror",false);

        if ( delta <= 0 && n <= 0 ) throw InvalidParameterException("Error, you must specify a positive non-zero delta or n");
        if ( delta > 0 && n > 0 ) throw InvalidParameterException("Error, the delta and the n arguments are mutually exclusive");

        string generatorname = params.set_default("use","saff");

        if ( n > 0 && generatorname != RandomOrientationGenerator::NAME ) {
                params["delta"] = get_optimal_delta(sym,n);
                params["n"] = (int)0;
        }

        // Force the orientation generator to include the mirror - this is because
        // We will enventually use it to generate orientations over the intire sphere
        // which is C1 symmetry, with the inc_mirror flag set to true
        params["inc_mirror"] = true;
        OrientationGenerator* g = Factory < OrientationGenerator >::get(generatorname);
        g->set_params(copy_relevant_params(g));


        // get the starting orientation distribution
        CSym* unit_sphere = new CSym();
        Dict nsym; nsym["nsym"] = 1; unit_sphere->set_params(nsym);

        vector<Transform> unitsphereorientations = g->gen_orientations(unit_sphere);
        delete g; g = 0;
        delete unit_sphere; unit_sphere = 0;

        vector<Vec3f> angles = optimize_distances(unitsphereorientations);

        vector<Transform> ret;
        for (vector<Vec3f>::const_iterator it = angles.begin(); it != angles.end(); ++it ) {
                if ( sym->is_in_asym_unit((*it)[1],(*it)[0],inc_mirror) ) {
                        add_orientation(ret,(*it)[0],(*it)[1]);
                }
        }

        // reset the params to what they were before they were acted upon by this class
        params["inc_mirror"] = inc_mirror;
        params["delta"] = delta;
        params["n"] = n;

        return ret;
}
virtual string EMAN::OptimumOrientationGenerator::get_desc ( ) const [inline, virtual]

Get a description.

Returns:
a clear desciption of this class

Implements EMAN::FactoryBase.

Definition at line 1391 of file symmetry.h.

{ return "Generate optimally distributed orientations within an asymmetric using a basic optimization technique"; }
virtual string EMAN::OptimumOrientationGenerator::get_name ( ) const [inline, virtual]

Return "opt".

Returns:
the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 1386 of file symmetry.h.

References NAME.

{ return NAME; }
int OptimumOrientationGenerator::get_orientations_tally ( const Symmetry3D *const  sym,
const float &  delta 
) const [private, virtual]

This function returns how many orientations will be generated for a given delta (angular spacing) It does this by simulated gen_orientations.

Parameters:
symthe symmetry which defines the interesting asymmetric unit
deltathe desired angular spacing of the orientations
Returns:
the number of orientations that will be generated using these parameters

Implements EMAN::OrientationGenerator.

Definition at line 755 of file symmetry.cpp.

References EMAN::OrientationGenerator::get_orientations_tally(), EMAN::FactoryBase::params, and EMAN::Dict::set_default().

{
        string deltaoptname = params.set_default("use","saff");
        Dict a;
        a["inc_mirror"] = (bool)params.set_default("inc_mirror",false);
        OrientationGenerator *g = Factory < OrientationGenerator >::get(deltaoptname,a);
        if (g) {
                int tally = g->get_orientations_tally(sym,delta);
                delete g;
                g = 0;
                return tally;
        }
        else throw;
}
virtual TypeDict EMAN::OptimumOrientationGenerator::get_param_types ( ) const [inline, virtual]

Get a dictionary containing the permissable parameters of this class.

Returns:
a dictionary containing the permissable parameters of this class parameters are explained in the dictionary itself

Reimplemented from EMAN::OrientationGenerator.

Definition at line 1397 of file symmetry.h.

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

                {
                        TypeDict d = OrientationGenerator::get_param_types();
                        d.put("n", EMObject::INT, "The number of orientations to generate. This option is mutually exclusively of the delta argument.Will attempt to get as close to the number specified as possible.");
                        d.put("inc_mirror", EMObject::BOOL, "Indicates whether or not to include the mirror portion of the asymmetric unit. Default is false.");
                        d.put("delta", EMObject::FLOAT, "The angular separation of orientations in degrees. This option is mutually exclusively of the n argument.");
                        d.put("use", EMObject::STRING, "The orientation generation technique used to generate the initial distribution on the unit sphere.");
                        return d;
                }
static OrientationGenerator* EMAN::OptimumOrientationGenerator::NEW ( ) [inline, static]

Factory support function NEW.

Returns:
a newly instantiated class of this type

Definition at line 1378 of file symmetry.h.

References OptimumOrientationGenerator().

                {
                        return new OptimumOrientationGenerator();
                }
OptimumOrientationGenerator& EMAN::OptimumOrientationGenerator::operator= ( const OptimumOrientationGenerator ) [private]

Disallow assignment.

vector< Vec3f > OptimumOrientationGenerator::optimize_distances ( const vector< Transform > &  v) const [private]

Optimize the distances in separating points on the unit sphere, as described by the the rotations in Transform objects.

Definition at line 820 of file symmetry.cpp.

References EMAN::Vec3< Type >::normalize(), and EMAN::EMConsts::rad2deg.

Referenced by gen_orientations().

{
        vector<Vec3f> points;

        for (vector<Transform>::const_iterator it = v.begin(); it != v.end(); ++it ) {
                points.push_back(Vec3f(0,0,1)*(*it));
        }

        if ( points.size() >= 2 ) {
                int max_it = 100;
                float percentage = 0.01f;

                for ( int i = 0; i < max_it; ++i ){
                        unsigned int p1 = 0;
                        unsigned int p2 = 1;

                        float distsquared = (points[p1]-points[p2]).squared_length();

                        // Find the nearest points
                        for(unsigned int j = 0; j < points.size(); ++j) {
                                for(unsigned int k = j+1; k < points.size(); ++k) {
                                        float d = (points[j]-points[k]).squared_length();
                                        if ( d < distsquared ) {
                                                distsquared = d;
                                                p1 = j;
                                                p2 = k;
                                        }
                                }
                        }

                        // Move them apart by a small fraction
                        Vec3f delta = percentage*(points[p2]-points[p1]);

                        points[p2] += delta;
                        points[p2].normalize();
                        points[p1] -= delta;
                        points[p1].normalize();
                }
        }

        vector<Vec3f> ret;
        for (vector<Vec3f>::const_iterator it = points.begin(); it != points.end(); ++it ) {
                float altitude = (float)(EMConsts::rad2deg*acos((*it)[2]));
                float azimuth = (float)(EMConsts::rad2deg*atan2((*it)[1],(*it)[0]));
                ret.push_back(Vec3f(90.0f+azimuth,altitude,0));
        }

        return ret;
}

Member Data Documentation

const string OptimumOrientationGenerator::NAME = "opt" [static]

The name of this class - used to access it from factories etc. Should be "icos".

Definition at line 1414 of file symmetry.h.

Referenced by get_name().


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