Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

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

OrientationGeneratorNEW ()
 Factory support function NEW.

Static Public Attributes

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.

01372 {}

virtual EMAN::OptimumOrientationGenerator::~OptimumOrientationGenerator  )  [inline, virtual]
 

Definition at line 1373 of file symmetry.h.

01373 {}

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:
sym the 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 768 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(), optimize_distances(), EMAN::Dict::set_default(), and EMAN::FactoryBase::set_params().

00769 {
00770         float delta = params.set_default("delta", 0.0f);
00771         int n = params.set_default("n", 0);
00772 
00773         bool inc_mirror = params.set_default("inc_mirror",false);
00774 
00775         if ( delta <= 0 && n <= 0 ) throw InvalidParameterException("Error, you must specify a positive non-zero delta or n");
00776         if ( delta > 0 && n > 0 ) throw InvalidParameterException("Error, the delta and the n arguments are mutually exclusive");
00777 
00778         string generatorname = params.set_default("use","saff");
00779 
00780         if ( n > 0 && generatorname != RandomOrientationGenerator::NAME ) {
00781                 params["delta"] = get_optimal_delta(sym,n);
00782                 params["n"] = (int)0;
00783         }
00784 
00785         // Force the orientation generator to include the mirror - this is because
00786         // We will enventually use it to generate orientations over the intire sphere
00787         // which is C1 symmetry, with the inc_mirror flag set to true
00788         params["inc_mirror"] = true;
00789         OrientationGenerator* g = Factory < OrientationGenerator >::get(generatorname);
00790         g->set_params(copy_relevant_params(g));
00791 
00792 
00793         // get the starting orientation distribution
00794         CSym* unit_sphere = new CSym();
00795         Dict nsym; nsym["nsym"] = 1; unit_sphere->set_params(nsym);
00796 
00797         vector<Transform> unitsphereorientations = g->gen_orientations(unit_sphere);
00798         delete g; g = 0;
00799         delete unit_sphere; unit_sphere = 0;
00800 
00801         vector<Vec3f> angles = optimize_distances(unitsphereorientations);
00802 
00803         vector<Transform> ret;
00804         for (vector<Vec3f>::const_iterator it = angles.begin(); it != angles.end(); ++it ) {
00805                 if ( sym->is_in_asym_unit((*it)[1],(*it)[0],inc_mirror) ) {
00806                         add_orientation(ret,(*it)[0],(*it)[1]);
00807                 }
00808         }
00809 
00810         // reset the params to what they were before they were acted upon by this class
00811         params["inc_mirror"] = inc_mirror;
00812         params["delta"] = delta;
00813         params["n"] = n;
00814 
00815         return ret;
00816 }

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.

01391 { 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.

01386 { 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:
sym the symmetry which defines the interesting asymmetric unit
delta the desired angular spacing of the orientations
Returns:
the number of orientations that will be generated using these parameters

Implements EMAN::OrientationGenerator.

Definition at line 753 of file symmetry.cpp.

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

00754 {
00755         string deltaoptname = params.set_default("use","saff");
00756         Dict a;
00757         a["inc_mirror"] = (bool)params.set_default("inc_mirror",false);
00758         OrientationGenerator *g = Factory < OrientationGenerator >::get(deltaoptname,a);
00759         if (g) {
00760                 int tally = g->get_orientations_tally(sym,delta);
00761                 delete g;
00762                 g = 0;
00763                 return tally;
00764         }
00765         else throw;
00766 }

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::TypeDict::put().

01398                 {
01399                         TypeDict d = OrientationGenerator::get_param_types();
01400                         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.");
01401                         d.put("inc_mirror", EMObject::BOOL, "Indicates whether or not to include the mirror portion of the asymmetric unit. Default is false.");
01402                         d.put("delta", EMObject::FLOAT, "The angular separation of orientations in degrees. This option is mutually exclusively of the n argument.");
01403                         d.put("use", EMObject::STRING, "The orientation generation technique used to generate the initial distribution on the unit sphere.");
01404                         return d;
01405                 }

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.

01379                 {
01380                         return new OptimumOrientationGenerator();
01381                 }

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 818 of file symmetry.cpp.

References EMAN::Vec3< Type >::end(), EMAN::Dict::end(), EMAN::Vec3< Type >::normalize(), v, and EMAN::Vec3f.

Referenced by gen_orientations().

00819 {
00820         vector<Vec3f> points;
00821 
00822         for (vector<Transform>::const_iterator it = v.begin(); it != v.end(); ++it ) {
00823                 points.push_back(Vec3f(0,0,1)*(*it));
00824         }
00825 
00826         if ( points.size() >= 2 ) {
00827                 int max_it = 100;
00828                 float percentage = 0.01f;
00829 
00830                 for ( int i = 0; i < max_it; ++i ){
00831                         unsigned int p1 = 0;
00832                         unsigned int p2 = 1;
00833 
00834                         float distsquared = (points[p1]-points[p2]).squared_length();
00835 
00836                         // Find the nearest points
00837                         for(unsigned int j = 0; j < points.size(); ++j) {
00838                                 for(unsigned int k = j+1; k < points.size(); ++k) {
00839                                         float d = (points[j]-points[k]).squared_length();
00840                                         if ( d < distsquared ) {
00841                                                 distsquared = d;
00842                                                 p1 = j;
00843                                                 p2 = k;
00844                                         }
00845                                 }
00846                         }
00847 
00848                         // Move them apart by a small fraction
00849                         Vec3f delta = percentage*(points[p2]-points[p1]);
00850 
00851                         points[p2] += delta;
00852                         points[p2].normalize();
00853                         points[p1] -= delta;
00854                         points[p1].normalize();
00855                 }
00856         }
00857 
00858         vector<Vec3f> ret;
00859         for (vector<Vec3f>::const_iterator it = points.begin(); it != points.end(); ++it ) {
00860                 float altitude = (float)(EMConsts::rad2deg*acos((*it)[2]));
00861                 float azimuth = (float)(EMConsts::rad2deg*atan2((*it)[1],(*it)[0]));
00862                 ret.push_back(Vec3f(90.0f+azimuth,altitude,0));
00863         }
00864 
00865         return ret;
00866 }


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 51 of file symmetry.cpp.


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 13:43:12 2013 for EMAN2 by  doxygen 1.3.9.1