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

EMAN::Symmetry3D Class Reference

Symmetry3D - A base class for 3D Symmetry objects. More...

#include <symmetry.h>

Inheritance diagram for EMAN::Symmetry3D:

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

Collaboration graph
[legend]
List of all members.

Public Types

typedef vector< vector< Vec3f
> >::const_iterator 
cit
typedef vector< vector< Vec3f
> >::iterator 
ncit

Public Member Functions

 Symmetry3D ()
virtual ~Symmetry3D ()
virtual Dict get_delimiters (const bool inc_mirror=false) const =0
 Every Symmetry3D object must return a dictionary containing the delimiters that define its asymmetric unit (this is not strictly true in the case of the PlatonicSym class).
virtual Transform get_sym (const int n) const =0
 Every Symmetry3D object must provide access to the full set of its symmetry operators via this function.
virtual int get_nsym () const =0
 The total number of unique symmetry operations that will be return by this object when a calling program access Symmetry3D::get_sym.
virtual float get_az_alignment_offset () const
 This functionality is only relevant to platonic symmetries.
virtual bool is_platonic_sym () const
 A function that is used to determine if this is a platonic symmetry object This function is only virtually overidden by the PlatonicSym symmetry, which returns true, not false.
virtual bool is_h_sym () const
 A function that is used to determine if this is a Helical symmetry object This function is only virtually overidden by the HSym symmetry, which returns true, not false.
virtual bool is_c_sym () const
 A function that is used to determine if this is a c symmetry object This function is only virtually overidden by the CSym object, which returns true.
virtual bool is_d_sym () const
 A function that is used to determine if this is a d symmetry object This function is only virtually overidden by the DSym object, which returns true.
virtual bool is_tet_sym () const
 A function that is used to determine if this is the tetrahedral symmetry object This function is only virtually overidden by the TetSym object, which returns true.
virtual int get_max_csym () const =0
 The Symmetry3D object must return the maximum degree of symmetry it exhibits about any one axis.
virtual vector< Vec3fget_asym_unit_points (bool inc_mirror) const =0
 The Symmetry3D object must be capable of returning an ordered list of points on the unit sphere that define its asymmetric unit (with mirror considerations).
vector< Transformgen_orientations (const string &generatorname="eman", const Dict &parms=Dict())
 Ask the Symmetry3D object to generate a set of orientations in its asymmetric unit using an OrientationGenerator constructed from the given parameters (using a Factory).
virtual bool is_in_asym_unit (const float &altitude, const float &azimuth, const bool inc_mirror) const =0
 A function to be used when generating orientations over portion of the unit sphere defined by parameters returned by get_delimiters.
virtual Transform reduce (const Transform &t3d, int n=0) const
 A function that will reduce an orientation, as characterized by Euler anges, into a specific asymmetric unit.
virtual int in_which_asym_unit (const Transform &t3d) const
 A function that will determine in which asymmetric unit a given orientation resides The asymmetric unit 'number' will depend entirely on the order in which different symmetry operations are return by the Symmetry3D::get_sym function.
virtual int point_in_which_asym_unit (const Vec3f &v) const
 A function that will determine in which asymmetric unit a given vector resides The asymmetric unit 'number' will depend entirely on the order in which different symmetry operations are return by the Symmetry3D::get_sym function The vector is a point.
virtual vector< vector< Vec3f > > get_asym_unit_triangles (bool inc_mirror) const =0
 Get triangles that precisely occlude the projection area of the default asymmetric unit.
virtual vector< Transformget_touching_au_transforms (bool inc_mirror=true) const
 Gets a vector of Transform objects that define the set of asymmetric units that touch the default asymmetric unit.
virtual vector< Transformget_syms () const

Static Public Member Functions

vector< Transformget_symmetries (const string &symmetry)

Protected Member Functions

void cache_au_planes () const
 Establish the asymmetric unit planes cache.
void delete_au_planes ()
 Clear the asymmetric unit planes cache.

Protected Attributes

float ** cached_au_planes
 The asymmetric unit planes are cached to provide a great speed up the point_in_which_asym_unit function, which is called by reduce and by in_which_asym_unit.
int cache_size
 Have to remember the cache size.
int num_triangles
 This is stores the number of triangles returned by get_asym_unit_triangles(true).
vector< vector< Vec3f > > au_sym_triangles
 This cache is of size cache_size.

Private Member Functions

 Symmetry3D (const Symmetry3D &)
 Disallow copy construction.
Symmetry3Doperator= (const Symmetry3D &)
 Disallow assignment.

Detailed Description

Symmetry3D - A base class for 3D Symmetry objects.

Objects of this type must provide delimiters for the asymmetric unit (get_delimiters), and must also provide all of the rotational symmetric operations (get_sym(const int n)). They must also provide the total number of unique symmetric operations with get_nsym (except in helical symmetry). get_delimiter returns a dictionary with "alt_max" and "az_max" keys, which correspond to the encompassing azimuth and altitude angles of the asymmetric unit. These can be interpreted in a relatively straight forward fashion when dealing with C and D symmetries to demarcate the asymmetric unit, however when dealing with Platonic symmetries the asymmetric unit is not so trivial. see http://blake.bcm.edu/emanwiki/EMAN2/Symmetry for figures and description of what we're doing here, for all the symmetries, and look in the comments of the PlatonicSym classes themselves. It inherits from a factory base, making it amenable to incorporation in EMAN2 style factories

Author:
David Woolford with Philip Baldwin and Steven Ludtke
Date:
Feb 2008

Definition at line 56 of file symmetry.h.


Member Typedef Documentation

typedef vector<vector<Vec3f> >::const_iterator EMAN::Symmetry3D::cit
 

Definition at line 59 of file symmetry.h.

typedef vector<vector<Vec3f> >::iterator EMAN::Symmetry3D::ncit
 

Definition at line 60 of file symmetry.h.

Referenced by cache_au_planes().


Constructor & Destructor Documentation

Symmetry3D::Symmetry3D  ) 
 

Definition at line 936 of file symmetry.cpp.

Symmetry3D::~Symmetry3D  )  [virtual]
 

Definition at line 937 of file symmetry.cpp.

References cached_au_planes, and delete_au_planes().

00937                         {
00938         if (cached_au_planes != 0 ) {
00939                 delete_au_planes();
00940         }
00941 }

EMAN::Symmetry3D::Symmetry3D const Symmetry3D  )  [private]
 

Disallow copy construction.


Member Function Documentation

void Symmetry3D::cache_au_planes  )  const [protected]
 

Establish the asymmetric unit planes cache.

Definition at line 994 of file symmetry.cpp.

References au_sym_triangles, cache_size, cached_au_planes, EMAN::Vec3< Type >::end(), EMAN::Util::equation_of_plane(), fit, get_asym_unit_triangles(), get_nsym(), get_sym(), ncit, num_triangles, t, and UnexpectedBehaviorException.

Referenced by point_in_which_asym_unit().

00994                                        {
00995         if (cached_au_planes == 0 ) {
00996                 vector< vector<Vec3f> > au_triangles = get_asym_unit_triangles(true);
00997                 num_triangles = au_triangles.size();
00998                 cache_size = get_nsym()*au_triangles.size();
00999 
01000                 cached_au_planes = new float*[cache_size];
01001                 float** fit = cached_au_planes;
01002                 for(int i =0; i < cache_size; ++i,++fit) {
01003                         float *t = new float[4];
01004                         *fit = t;
01005                 }
01006 
01007 
01008                 int k = 0;
01009                 for(int i = 0; i < get_nsym(); ++i) {
01010 
01011                         for( ncit it = au_triangles.begin(); it != au_triangles.end(); ++it, ++k)
01012                         {
01013                                 // For each given triangle
01014                                 vector<Vec3f> points = *it;
01015                                 if ( i != 0 ) {
01016                                         for (vector<Vec3f>::iterator iit = points.begin(); iit != points.end(); ++iit ) {
01017                                                 // Rotate the points in the triangle so that the triangle occupies the
01018                                                 // space of the current asymmetric unit
01019                                                 *iit = (*iit)*get_sym(i);
01020                                         }
01021                                 }
01022 
01023                                 au_sym_triangles.push_back(points);
01024 
01025                                 // Determine the equation of the plane for the points, store it in plane
01026                                 Util::equation_of_plane(points[0],points[2],points[1],cached_au_planes[k]);
01027                         }
01028                 }
01029         }
01030         else throw UnexpectedBehaviorException("Attempt to generate a cache when cache exists");
01031 }

void Symmetry3D::delete_au_planes  )  [protected]
 

Clear the asymmetric unit planes cache.

Definition at line 1033 of file symmetry.cpp.

References cached_au_planes, fit, and UnexpectedBehaviorException.

Referenced by ~Symmetry3D().

01033                                   {
01034         if (cached_au_planes == 0 ) throw UnexpectedBehaviorException("Attempt to delete a cache that does not exist");
01035         float** fit = cached_au_planes;
01036         for(int i =0; i < cache_size; ++i,++fit) {
01037                 if (*fit == 0) throw UnexpectedBehaviorException("Attempt to delete a cache that does not exist");
01038                 delete [] *fit;
01039                 *fit = 0;
01040         }
01041 
01042         delete [] cached_au_planes;
01043         cached_au_planes = 0;
01044 }

vector< Transform > Symmetry3D::gen_orientations const string &  generatorname = "eman",
const Dict parms = Dict()
 

Ask the Symmetry3D object to generate a set of orientations in its asymmetric unit using an OrientationGenerator constructed from the given parameters (using a Factory).

This is reminiscent of the strategy design pattern

Parameters:
generatorname the string name of the OrientationGenerator, as accessed for the OrientationGenerator factory
parms the parameters handed to OrientationGenerator::set_params after initial construction
Returns:
a set of orientations in the unit sphere

Definition at line 163 of file symmetry.cpp.

References EMAN::OrientationGenerator::gen_orientations(), and EMAN::Util::str_to_lower().

Referenced by EMAN::SymAlignProcessor::align(), and EMAN::RT3DSphereAligner::xform_align_nbest().

00164 {
00165         ENTERFUNC;
00166         vector<Transform> ret;
00167         OrientationGenerator *g = Factory < OrientationGenerator >::get(Util::str_to_lower(generatorname), parms);
00168         if (g) {
00169                 ret = g->gen_orientations(this);
00170                 if( g )
00171                 {
00172                         delete g;
00173                         g = 0;
00174                 }
00175         }
00176         else throw;
00177 
00178         EXITFUNC;
00179 
00180         return ret;
00181 }

virtual vector<Vec3f> EMAN::Symmetry3D::get_asym_unit_points bool  inc_mirror  )  const [pure virtual]
 

The Symmetry3D object must be capable of returning an ordered list of points on the unit sphere that define its asymmetric unit (with mirror considerations).

The list can be any length, and must be constructed carefully. If the list consists of points A B and C, then arcs on the unit sphere connecting A to B, then B to C, then C to A must define the asymmetric unit (with or without its mirror portion). i.e. it is a cyclic list, on any length

Parameters:
inc_mirror whether or not to include the mirror portion of the asymmetric unit
Returns:
a vector or points which define a cyclic set of great arcs on the unit sphere. Each point may be connected to the point that proceeds it, and the last point may be connected to the first point, and this demarcates the asymmetric unit.

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::PlatonicSym, and EMAN::TetrahedralSym.

Referenced by get_touching_au_transforms().

virtual vector<vector<Vec3f> > EMAN::Symmetry3D::get_asym_unit_triangles bool  inc_mirror  )  const [pure virtual]
 

Get triangles that precisely occlude the projection area of the default asymmetric unit.

This will be used for collision detection in Symmetry3D::reduce

Parameters:
inc_mirror whether to include the mirror portion of the asymmetric unit

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, and EMAN::PlatonicSym.

Referenced by cache_au_planes().

virtual float EMAN::Symmetry3D::get_az_alignment_offset  )  const [inline, virtual]
 

This functionality is only relevant to platonic symmetries.

But it could grow into functionality for the other symmetries.

Reimplemented in EMAN::TetrahedralSym, EMAN::IcosahedralSym, and EMAN::Icosahedral2Sym.

Definition at line 86 of file symmetry.h.

Referenced by EMAN::SaffOrientationGenerator::gen_orientations(), EMAN::EvenOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), and EMAN::PlatonicSym::get_asym_unit_points().

00086 { return 0.0; }

virtual Dict EMAN::Symmetry3D::get_delimiters const bool  inc_mirror = false  )  const [pure virtual]
 

Every Symmetry3D object must return a dictionary containing the delimiters that define its asymmetric unit (this is not strictly true in the case of the PlatonicSym class).

Parameters:
inc_mirror whether or not the mirror part of the asymmetric unit should be included in the consideration
Returns:
a dictionary containing atleast "alt_max" and "az_max"

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, and EMAN::PlatonicSym.

Referenced by EMAN::SaffOrientationGenerator::gen_orientations(), EMAN::EvenOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::SaffOrientationGenerator::get_orientations_tally(), EMAN::EvenOrientationGenerator::get_orientations_tally(), EMAN::EmanOrientationGenerator::get_orientations_tally(), and get_touching_au_transforms().

virtual int EMAN::Symmetry3D::get_max_csym  )  const [pure virtual]
 

The Symmetry3D object must return the maximum degree of symmetry it exhibits about any one axis.

This function is only called in the AsymmUnitOrientationGenerator.

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::TetrahedralSym, EMAN::OctahedralSym, EMAN::IcosahedralSym, and EMAN::Icosahedral2Sym.

Referenced by EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::get_orientations_tally(), and EMAN::PlatonicSym::init().

virtual int EMAN::Symmetry3D::get_nsym  )  const [pure virtual]
 

The total number of unique symmetry operations that will be return by this object when a calling program access Symmetry3D::get_sym.

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::TetrahedralSym, EMAN::OctahedralSym, EMAN::IcosahedralSym, and EMAN::Icosahedral2Sym.

Referenced by cache_au_planes(), EMAN::BackProjectionReconstructor::finish(), EMAN::RandomOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::OrientationGenerator::get_az_max(), EMAN::Transform::get_nsym(), EMAN::EmanOrientationGenerator::get_orientations_tally(), EMAN::Transform::get_sym_proj(), get_syms(), get_touching_au_transforms(), and point_in_which_asym_unit().

virtual Transform EMAN::Symmetry3D::get_sym const int  n  )  const [pure virtual]
 

Every Symmetry3D object must provide access to the full set of its symmetry operators via this function.

Parameters:
n the symmetry operator number
Returns:
a Transform object describing the symmetry operation

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::TetrahedralSym, EMAN::OctahedralSym, EMAN::IcosahedralSym, and EMAN::Icosahedral2Sym.

Referenced by cache_au_planes(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::Transform::get_sym(), EMAN::Transform::get_sym_proj(), get_syms(), get_touching_au_transforms(), and reduce().

vector< Transform > Symmetry3D::get_symmetries const string &  symmetry  )  [static]
 

Definition at line 1200 of file symmetry.cpp.

References EMAN::Factory< T >::get(), and get_syms().

Referenced by EMAN::SymAlignProcessor::align(), EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::do_insert_slice_work(), EMAN::SymSearchProcessor::process_inplace(), and EMAN::RT3DSymmetryAligner::xform_align_nbest().

01201 {
01202         Symmetry3D* sym = Factory<Symmetry3D>::get(Util::str_to_lower(symmetry));
01203         vector<Transform> ret = sym->get_syms();
01204         delete sym;
01205         return ret;
01206 }

vector< Transform > Symmetry3D::get_syms  )  const [virtual]
 

Definition at line 1184 of file symmetry.cpp.

References get_nsym(), and get_sym().

Referenced by EMAN::BackProjectionReconstructor::finish(), get_symmetries(), and EMAN::ApplySymProcessor::process().

01185 {
01186 
01187         vector<Transform> ret;
01188 //      if (t.is_identity()) {
01189                 for(int i = 0; i < get_nsym(); ++i ) {
01190                         ret.push_back(get_sym(i));
01191                 }
01192 //      } else {
01193 //              for(int i = 0; i < get_nsym(); ++i ) {
01194 //                      ret.push_back(get_sym(i)*t);
01195 //              }
01196 //      }
01197         return ret;
01198 }

vector< Transform > Symmetry3D::get_touching_au_transforms bool  inc_mirror = true  )  const [virtual]
 

Gets a vector of Transform objects that define the set of asymmetric units that touch the default asymmetric unit.

The 'default asymmetric unit' is defined by the results of Symmetry3d::get_asym_unit_points and is sensitive to whether or not you want to include the mirror part of the asymmetric unit. This function is useful when used in conjunction with Symmetry3D::reduce, and particularly when finding the angular deviation of particles through different stages of iterative Single Particle Reconstruction This function could be expanded to work for an asymmetric unit number supplied by the user.

Parameters:
inc_mirror whether or not to include the mirror portion of the asymmetric unit
Returns:
a vector of Transform objects that map the default asymmetric unit to the neighboring asymmetric unit

Definition at line 1115 of file symmetry.cpp.

References EMAN::Dict::end(), get_asym_unit_points(), get_delimiters(), get_nsym(), get_sym(), is_d_sym(), is_platonic_sym(), EMAN::Vec3< Type >::squared_length(), t, EMAN::Vec3f, x, and y.

01116 {
01117         vector<Transform>  ret;
01118         vector<int> hit_cache;
01119 
01120         vector<Vec3f> points = get_asym_unit_points(inc_mirror);
01121         // Warning, this is a gross hack because it is assuming that the asym_unit_points
01122         // returned by DSym are in a particular orientation with respect to symmetric axes
01123         // if the internals of DSym change it could change what we should do here...
01124         // but for the time being it will do
01125         if (inc_mirror && is_d_sym() && (get_nsym()/2 % 2 == 0)) {
01126                 Dict delim = get_delimiters(false);
01127                 float angle = (float)(EMConsts::deg2rad*float(delim["az_max"]));
01128                 float y = -cos(angle);
01129                 float x = sin(angle);
01130                 points.push_back(Vec3f(x,y,0));
01131         }
01132         else if ( is_d_sym() && (get_nsym()/2 % 2 == 1)) {
01133                 Dict delim = get_delimiters(false);
01134                 float angle = float(delim["az_max"])/2.0f;
01135 //              cout << "Odd dsym using " << angle << endl;
01136                 angle *= (float)EMConsts::deg2rad;
01137                 float y = -cos(angle);
01138                 float x = sin(angle);
01139                 points.push_back(Vec3f(x,y,0));
01140 
01141                 if ( inc_mirror ) {
01142                         angle = 3.0f*(float(delim["az_max"]))/2.0f;
01143                         angle *= (float)EMConsts::deg2rad;
01144                         float y = -cos(angle);
01145                         float x = sin(angle);
01146                         points.push_back(Vec3f(x,y,0));
01147                 }
01148         }
01149 
01150         typedef vector<Vec3f>::const_iterator const_point_it;
01151         for(const_point_it point = points.begin(); point != points.end(); ++point ) {
01152 
01153                 for(int i = 1; i < get_nsym(); ++i) {
01154 
01155                         if ( find(hit_cache.begin(),hit_cache.end(),i) != hit_cache.end() ) continue;
01156                         Transform t = get_sym(i);
01157                         Vec3f result = (*point)*t;
01158 
01159                         if (is_platonic_sym()) {
01160                                 for(const_point_it tmp = points.begin(); tmp != points.end(); ++tmp ) {
01161                                         Vec3f tt = result-(*tmp);
01162                                         if (tt.squared_length() < 0.01f) {
01163                                                 hit_cache.push_back(i);
01164                                                 ret.push_back(t);
01165                                         }
01166 
01167                                 }
01168                         }
01169                         else {
01170                                 result -= *point;
01171                                 if (result.squared_length() < 0.05f) {
01172                                         hit_cache.push_back(i);
01173                                         ret.push_back(t);
01174                                 }
01175                         }
01176                 }
01177 
01178         }
01179 
01180         return ret;
01181 }

int Symmetry3D::in_which_asym_unit const Transform t3d  )  const [virtual]
 

A function that will determine in which asymmetric unit a given orientation resides The asymmetric unit 'number' will depend entirely on the order in which different symmetry operations are return by the Symmetry3D::get_sym function.

Parameters:
t3d a Transform characterizing an orientation
Returns:
the asymmetric unit number the the orientation is in

Definition at line 975 of file symmetry.cpp.

References EMAN::Transform::invert(), point_in_which_asym_unit(), and EMAN::Vec3f.

Referenced by reduce().

00976 {
00977         // Here it is assumed that final destination of the orientation (as encapsulated in the t3d object) is
00978         // in the z direction, so in essence we will start in the direction z and 'undo' the orientation to get the real
00979         // direction
00980         Vec3f p(0,0,1);
00981 
00982         Transform o(t3d);
00983         // Orientations are alway transposed when dealing with asymmetric units, projections,etc
00984         // We take the transpose to 'undo' the transform and get the true direction of the point.
00985         o.invert();
00986         // Figure out where the point would end up. No we could just as easily not transpose and do
00987         // left multiplation (as in what occurs in the FourierReconstructor during slice insertion)
00988         p = o*p;
00989 
00990         return point_in_which_asym_unit(p);
00991 }

virtual bool EMAN::Symmetry3D::is_c_sym  )  const [inline, virtual]
 

A function that is used to determine if this is a c symmetry object This function is only virtually overidden by the CSym object, which returns true.

Returns:
false - indicating that this is not a helical symmetry object

Reimplemented in EMAN::CSym.

Definition at line 106 of file symmetry.h.

Referenced by EMAN::RandomOrientationGenerator::gen_orientations(), and EMAN::OrientationGenerator::get_az_max().

00106 { return false; }

virtual bool EMAN::Symmetry3D::is_d_sym  )  const [inline, virtual]
 

A function that is used to determine if this is a d symmetry object This function is only virtually overidden by the DSym object, which returns true.

Returns:
false - indicating that this is not a helical symmetry object

Reimplemented in EMAN::DSym.

Definition at line 112 of file symmetry.h.

Referenced by EMAN::OrientationGenerator::get_az_max(), and get_touching_au_transforms().

00112 { return false; }

virtual bool EMAN::Symmetry3D::is_h_sym  )  const [inline, virtual]
 

A function that is used to determine if this is a Helical symmetry object This function is only virtually overidden by the HSym symmetry, which returns true, not false.

Returns:
false - indicating that this is not a helical symmetry object

Reimplemented in EMAN::HSym.

Definition at line 100 of file symmetry.h.

Referenced by EMAN::SaffOrientationGenerator::gen_orientations(), EMAN::EvenOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::SaffOrientationGenerator::get_orientations_tally(), EMAN::EvenOrientationGenerator::get_orientations_tally(), and EMAN::EmanOrientationGenerator::get_orientations_tally().

00100 { return false; }

virtual bool EMAN::Symmetry3D::is_in_asym_unit const float &  altitude,
const float &  azimuth,
const bool  inc_mirror
const [pure virtual]
 

A function to be used when generating orientations over portion of the unit sphere defined by parameters returned by get_delimiters.

In platonic symmetry altitude and azimuth alone are not enough to correctly demarcate the asymmetric unit. See the get_delimiters comments.

Parameters:
altitude the EMAN style altitude of the 3D orientation in degrees
azimuth the EMAN style azimuth of the 3D orientation in degrees
inc_mirror whether or not to include orientations if they are in the mirror portion of the asymmetric unit
Returns:
true or false, depending on whether or not the orientation is within the asymmetric unit

Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::PlatonicSym, and EMAN::TetrahedralSym.

Referenced by EMAN::OptimumOrientationGenerator::gen_orientations(), EMAN::SaffOrientationGenerator::gen_orientations(), EMAN::EvenOrientationGenerator::gen_orientations(), EMAN::RandomOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::SaffOrientationGenerator::get_orientations_tally(), EMAN::EvenOrientationGenerator::get_orientations_tally(), and EMAN::EmanOrientationGenerator::get_orientations_tally().

virtual bool EMAN::Symmetry3D::is_platonic_sym  )  const [inline, virtual]
 

A function that is used to determine if this is a platonic symmetry object This function is only virtually overidden by the PlatonicSym symmetry, which returns true, not false.

Returns:
false - indicating that this is not a platonic symmetry object

Reimplemented in EMAN::PlatonicSym.

Definition at line 94 of file symmetry.h.

Referenced by EMAN::SaffOrientationGenerator::gen_orientations(), EMAN::EvenOrientationGenerator::gen_orientations(), EMAN::EmanOrientationGenerator::gen_orientations(), EMAN::OrientationGenerator::get_az_max(), EMAN::SaffOrientationGenerator::get_orientations_tally(), EMAN::EvenOrientationGenerator::get_orientations_tally(), EMAN::EmanOrientationGenerator::get_orientations_tally(), and get_touching_au_transforms().

00094 { return false; }

virtual bool EMAN::Symmetry3D::is_tet_sym  )  const [inline, virtual]
 

A function that is used to determine if this is the tetrahedral symmetry object This function is only virtually overidden by the TetSym object, which returns true.

Returns:
false - indicating that this is not a tetrahedral symmetry object

Reimplemented in EMAN::TetrahedralSym.

Definition at line 118 of file symmetry.h.

Referenced by EMAN::OrientationGenerator::get_az_max().

00118 { return false; }

Symmetry3D& EMAN::Symmetry3D::operator= const Symmetry3D  )  [private]
 

Disallow assignment.

int Symmetry3D::point_in_which_asym_unit const Vec3f v  )  const [virtual]
 

A function that will determine in which asymmetric unit a given vector resides The asymmetric unit 'number' will depend entirely on the order in which different symmetry operations are return by the Symmetry3D::get_sym function The vector is a point.

Parameters:
v a Vec3f characterizing a point
Returns:
the asymmetric unit number the the orientation is in

Definition at line 1046 of file symmetry.cpp.

References au_sym_triangles, cache_au_planes(), cached_au_planes, EMAN::Vec3< Type >::dot(), get_nsym(), t, v, and EMAN::Vec3f.

Referenced by in_which_asym_unit(), and EMAN::AutoMaskAsymUnit::process_inplace().

01047 {
01048         if (cached_au_planes == 0) {
01049                 cache_au_planes();
01050         }
01051         
01052         float epsNow=0.01f;
01053         int k = 0;
01054         for(int i = 0; i < get_nsym(); ++i) {
01055                 for( int j = 0; j < num_triangles; ++j,++k) {
01056                         vector<Vec3f> points = au_sym_triangles[k];
01057 
01058                         float* plane = cached_au_planes[k];
01059                         Vec3f tmp = p;
01060 
01061                         // Determine the intersection of p with the plane - do this by finding out how much p should be scaled by
01062                         float scale = plane[0]*tmp[0]+plane[1]*tmp[1]+plane[2]*tmp[2];
01063                         if ( scale != 0 )
01064                                 scale = -plane[3]/scale;
01065                         else {
01066                                 // parralel!
01067                                 continue;
01068                         }
01069 
01070                         // If the scale factor is less than zero, then p is definitely not in this asymmetric unit
01071                         if (scale <= 0) continue;
01072 
01073                         // This is the intersection point
01074                         Vec3f pp = tmp*scale;
01075 
01076                         // Now we have to see if the point p is inside the region bounded by the points, or if it is outside
01077                         // If it is inside the region then p is in this asymmetric unit.
01078 
01079                         // This formula take from FIXME fill in once I get to work
01080                         Vec3f v = points[2]-points[0];
01081                         Vec3f u = points[1]-points[0];
01082                         Vec3f w = pp - points[0];
01083 
01084                         float udotu = u.dot(u);
01085                         float udotv = u.dot(v);
01086                         float udotw = u.dot(w);
01087                         float vdotv = v.dot(v);
01088                         float vdotw = v.dot(w);
01089 
01090                         float d = 1.0f/(udotv*udotv - udotu*vdotv);
01091                         float s = udotv*vdotw - vdotv*udotw;
01092                         s *= d;
01093 
01094                         float t = udotv*udotw - udotu*vdotw;
01095                         t *= d;
01096 
01097                         // We've done a few multiplications, so detect when there are tiny residuals that may throw off the final
01098                         // decision
01099                         if (fabs(s) < Transform::ERR_LIMIT ) s = 0;
01100                         if (fabs(t) < Transform::ERR_LIMIT ) t = 0;
01101 
01102                         if ( fabs((fabs(s)-1.0)) < Transform::ERR_LIMIT ) s = 1;
01103                         if ( fabs((fabs(t)-1.0)) < Transform::ERR_LIMIT ) t = 1;
01104 
01105                         // The final decision, if this is true then we've hit the jackpot
01106                         if ( s >= -epsNow && t >= -epsNow && (s+t) <= 1+epsNow ) {
01107 //                              cout << " i " << i << " j " << j << " s " << s  << " t " << t << " s+t " << s+t << endl;
01108                                 return i;
01109                         }
01110                 }
01111         }
01112 
01113         return -1;
01114 }


Member Data Documentation

vector< vector<Vec3f> > EMAN::Symmetry3D::au_sym_triangles [mutable, protected]
 

This cache is of size cache_size.

Definition at line 214 of file symmetry.h.

Referenced by cache_au_planes(), and point_in_which_asym_unit().

int EMAN::Symmetry3D::cache_size [mutable, protected]
 

Have to remember the cache size.

Definition at line 210 of file symmetry.h.

Referenced by cache_au_planes().

float** EMAN::Symmetry3D::cached_au_planes [mutable, protected]
 

The asymmetric unit planes are cached to provide a great speed up the point_in_which_asym_unit function, which is called by reduce and by in_which_asym_unit.

Definition at line 207 of file symmetry.h.

Referenced by cache_au_planes(), delete_au_planes(), point_in_which_asym_unit(), and ~Symmetry3D().

int EMAN::Symmetry3D::num_triangles [mutable, protected]
 

This is stores the number of triangles returned by get_asym_unit_triangles(true).

Definition at line 212 of file symmetry.h.

Referenced by cache_au_planes().


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