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

EMAN::CSym Class Reference

An encapsulation of cyclic 3D symmetry. More...

#include <symmetry.h>

Inheritance diagram for EMAN::CSym:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

 CSym ()
virtual ~CSym ()
virtual string get_name () const
 Return CSym::NAME.
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 Dict get_delimiters (const bool inc_mirror=false) const
 Get the altitude and phi angle of the c symmetry, which depends on nysm.
virtual Transform get_sym (const int n) const
 Provides access to the complete set of rotational symmetry operations associated with this symmetry.
virtual int get_nsym () const
 Gets the total number of unique roational symmetry operations associated with this symmetry For C symmetry, this is simply nsym.
virtual int get_max_csym () const
 Gets the maximum symmetry of this object.
virtual vector< Vec3fget_asym_unit_points (bool inc_mirror=false) const
 to demarcate the asymmetric unit.
virtual bool is_in_asym_unit (const float &altitude, const float &azimuth, const bool inc_mirror) const
 A function to be used when generating orientations over portion of the unit sphere defined by parameters returned by get_delimiters.
virtual bool is_c_sym () const
 Returns true - this is indeed a c symmetry object.
virtual vector< vector< Vec3f > > get_asym_unit_triangles (bool inc_mirror) const
 Get triangles that precisely occlude the projection area of the default asymmetric unit.

Static Public Member Functions

Symmetry3DNEW ()
 Factory support function NEW.

Static Public Attributes

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

Private Member Functions

 CSym (const CSym &)
 Disallow copy construction.
CSymoperator= (const CSym &)
 Disallow assignment.

Detailed Description

An encapsulation of cyclic 3D symmetry.

Author:
David Woolford (based on previous work by Phil Baldwin and Steve Ludtke)
Date:
Feb 2008

Definition at line 233 of file symmetry.h.


Constructor & Destructor Documentation

EMAN::CSym::CSym  )  [inline]
 

Definition at line 236 of file symmetry.h.

00236 {};

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

Definition at line 237 of file symmetry.h.

00237 {};

EMAN::CSym::CSym const CSym  )  [private]
 

Disallow copy construction.


Member Function Documentation

vector< Vec3f > CSym::get_asym_unit_points bool  inc_mirror = false  )  const [virtual]
 

to demarcate the asymmetric unit.

The last should may be connected to the first.

Parameters:
inc_mirror whether or not to include the mirror portion of the asymmetric unit
Returns:
a cyclic set of points which can be connected using great arcs on the unit sphere

Implements EMAN::Symmetry3D.

Definition at line 1290 of file symmetry.cpp.

References get_delimiters(), EMAN::Dict::set_default(), EMAN::Vec3f, x, and y.

Referenced by get_asym_unit_triangles().

01291 {
01292         Dict delim = get_delimiters(inc_mirror);
01293         int nsym = params.set_default("nsym",0);
01294         vector<Vec3f> ret;
01295 
01296         if ( nsym == 1 ) {
01297                 if (inc_mirror == false ) {
01298                         ret.push_back(Vec3f(0,-1,0));
01299                         ret.push_back(Vec3f(1,0,0));
01300                         ret.push_back(Vec3f(0,1,0));
01301                         ret.push_back(Vec3f(-1,0,0));
01302                 }
01303                 // else return ret; // an empty vector! this is fine
01304         }
01305         else if (nsym == 2 && !inc_mirror) {
01306                 ret.push_back(Vec3f(0,0,1));
01307                 ret.push_back(Vec3f(0,-1,0));
01308                 ret.push_back(Vec3f(1,0,0));
01309                 ret.push_back(Vec3f(0,1,0));
01310         }
01311         else {
01312                 ret.push_back(Vec3f(0,0,1));
01313                 ret.push_back(Vec3f(0,-1,0));
01314                 if (inc_mirror == true) {
01315                         ret.push_back(Vec3f(0,0,-1));
01316                 }
01317                 float angle = (float)(EMConsts::deg2rad*float(delim["az_max"]));
01318                 float y = -cos(angle);
01319                 float x = sin(angle);
01320                 ret.push_back(Vec3f(x,y,0));
01321         }
01322 
01323         return ret;
01324 
01325 }

vector< vector< Vec3f > > CSym::get_asym_unit_triangles bool  inc_mirror  )  const [virtual]
 

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

This is used for collision detection in Symmetry3D::reduce

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

Implements EMAN::Symmetry3D.

Definition at line 1195 of file symmetry.cpp.

References get_asym_unit_points(), EMAN::Dict::set_default(), v, EMAN::Vec3f, and x.

01195                                                                           {
01196         vector<Vec3f> v = get_asym_unit_points(inc_mirror);
01197         int nsym = params.set_default("nsym",0);
01198 
01199         vector<vector<Vec3f> > ret;
01200         if (v.size() == 0) return ret; // nsym == 1 and inc_mirror == true, this is the entire sphere!
01201         if (nsym == 1 && !inc_mirror) {
01202                 Vec3f z(0,0,1);
01203                 vector<Vec3f> tmp;
01204                 tmp.push_back(z);
01205                 tmp.push_back(v[1]);
01206                 tmp.push_back(v[0]);
01207                 ret.push_back(tmp);
01208 
01209                 vector<Vec3f> tmp2;
01210                 tmp2.push_back(z);
01211                 tmp2.push_back(v[2]);
01212                 tmp2.push_back(v[1]);
01213                 ret.push_back(tmp2);
01214 
01215                 vector<Vec3f> tmp3;
01216                 tmp3.push_back(z);
01217                 tmp3.push_back(v[3]);
01218                 tmp3.push_back(v[2]);
01219                 ret.push_back(tmp3);
01220 
01221                 vector<Vec3f> tmp4;
01222                 tmp4.push_back(z);
01223                 tmp4.push_back(v[0]);
01224                 tmp4.push_back(v[3]);
01225                 ret.push_back(tmp4);
01226         }
01227         else if (nsym == 2 && inc_mirror) {
01228                 Vec3f x(1,0,0);
01229                 vector<Vec3f> tmp;
01230                 tmp.push_back(v[1]);
01231                 tmp.push_back(v[0]);
01232                 tmp.push_back(x);
01233                 ret.push_back(tmp);
01234 
01235                 vector<Vec3f> tmp2;
01236                 tmp2.push_back(v[2]);
01237                 tmp2.push_back(v[1]);
01238                 tmp2.push_back(x);
01239                 ret.push_back(tmp2);
01240 
01241                 vector<Vec3f> tmp3;
01242                 tmp3.push_back(v[3]);
01243                 tmp3.push_back(v[2]);
01244                 tmp3.push_back(x);
01245                 ret.push_back(tmp3);
01246 
01247                 vector<Vec3f> tmp4;
01248                 tmp4.push_back(v[0]);
01249                 tmp4.push_back(v[3]);
01250                 tmp4.push_back(x);
01251                 ret.push_back(tmp4);
01252         }
01253         else if (nsym == 2 && !inc_mirror) {
01254                 vector<Vec3f> tmp;
01255                 tmp.push_back(v[0]);
01256                 tmp.push_back(v[2]);
01257                 tmp.push_back(v[1]);
01258                 ret.push_back(tmp);
01259 
01260                 vector<Vec3f> tmp2;
01261                 tmp2.push_back(v[2]);
01262                 tmp2.push_back(v[0]);
01263                 tmp2.push_back(v[3]);
01264                 ret.push_back(tmp2);
01265         }
01266         else if (v.size() == 3) {
01267                 vector<Vec3f> tmp;
01268                 tmp.push_back(v[0]);
01269                 tmp.push_back(v[2]);
01270                 tmp.push_back(v[1]);
01271                 ret.push_back(tmp);
01272         }
01273         else if (v.size() == 4) {
01274                 vector<Vec3f> tmp;
01275                 tmp.push_back(v[0]);
01276                 tmp.push_back(v[3]);
01277                 tmp.push_back(v[1]);
01278                 ret.push_back(tmp);
01279 
01280                 vector<Vec3f> tmp2;
01281                 tmp2.push_back(v[1]);
01282                 tmp2.push_back(v[3]);
01283                 tmp2.push_back(v[2]);
01284                 ret.push_back(tmp2);
01285         }
01286 
01287         return ret;
01288 }

Dict CSym::get_delimiters const bool  inc_mirror = false  )  const [virtual]
 

Get the altitude and phi angle of the c symmetry, which depends on nysm.

The "alt_max" value in the return dicts is 180 or 90 degrees, depending inc_mirror The "az_max" is 360/nsym degrees.

Parameters:
inc_mirror whether or not to include the part of the asymmetric unit which contains the mirror projections of the other half
Returns:
a dictionary containing the keys "alt_max" and "az_max"
Exceptions:
InvalidValueException if nsym is less than or equal to zero

Implements EMAN::Symmetry3D.

Definition at line 1169 of file symmetry.cpp.

References InvalidValueException, and EMAN::Dict::set_default().

Referenced by get_asym_unit_points(), and is_in_asym_unit().

01169                                                      {
01170         Dict returnDict;
01171         // Get the parameters of interest
01172         int nsym = params.set_default("nsym",0);
01173         if ( nsym <= 0 ) throw InvalidValueException(nsym,"Error, you must specify a positive non zero nsym");
01174 
01175         if ( inc_mirror ) returnDict["alt_max"] = 180.0f;
01176         else  returnDict["alt_max"] = 90.0f;
01177 
01178         returnDict["az_max"] = 360.0f/(float)nsym;
01179 
01180         return returnDict;
01181 }

virtual string EMAN::CSym::get_desc  )  const [inline, virtual]
 

Get a description.

Returns:
a clear desciption of this class

Implements EMAN::FactoryBase.

Definition at line 255 of file symmetry.h.

00255 { return "C symmetry support"; }

virtual int EMAN::CSym::get_max_csym  )  const [inline, virtual]
 

Gets the maximum symmetry of this object.

This is used by OrientationGenerators, and is probably not something a general user would utilize.

Returns:
the degree of of cyclic symmetry (nsym) - this is the maximum symmetry

Implements EMAN::Symmetry3D.

Definition at line 296 of file symmetry.h.

00296 { return params["nsym"]; }

virtual string EMAN::CSym::get_name  )  const [inline, virtual]
 

Return CSym::NAME.

Returns:
the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 250 of file symmetry.h.

00250 { return NAME; }

virtual int EMAN::CSym::get_nsym  )  const [inline, virtual]
 

Gets the total number of unique roational symmetry operations associated with this symmetry For C symmetry, this is simply nsym.

Returns:
the degree of of cyclic symmetry (nsym)

Implements EMAN::Symmetry3D.

Definition at line 289 of file symmetry.h.

00289 { return params["nsym"]; };

virtual TypeDict EMAN::CSym::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

Implements EMAN::FactoryBase.

Definition at line 260 of file symmetry.h.

References EMAN::TypeDict::put().

00261                 {
00262                         TypeDict d;
00263                         d.put("nsym", EMObject::INT, "The symmetry number");
00264                         return d;
00265                 }

Transform CSym::get_sym const int  n  )  const [virtual]
 

Provides access to the complete set of rotational symmetry operations associated with this symmetry.

Rotational symmetry operations for C symmetry are always about the z-axis (in the EMAN convention), and therefore the only non zero return angle is azimuth. Specifically, it is n*360/nsym degrees.

Parameters:
n the rotational symmetry operation number. If n is greater than nsym we take n modulo nsym
Returns:
a transform3d containing the correct rotational symmetric operation.
Exceptions:
InvalidValueException if nsym is less than or equal to zero

Implements EMAN::Symmetry3D.

Definition at line 1327 of file symmetry.cpp.

References InvalidValueException, and EMAN::Dict::set_default().

01327                                          {
01328         int nsym = params.set_default("nsym",0);
01329         if ( nsym <= 0 ) throw InvalidValueException(n,"Error, you must specify a positive non zero nsym");
01330 
01331         Dict d("type","eman");
01332         // courtesy of Phil Baldwin
01333         d["az"] = (n%nsym) * 360.0f / nsym;
01334         d["alt"] = 0.0f;
01335         d["phi"] = 0.0f;
01336         return Transform(d);
01337 }

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

Returns true - this is indeed a c symmetry object.

Returns:
true - indicating that this is a c symmetry object

Reimplemented from EMAN::Symmetry3D.

Definition at line 320 of file symmetry.h.

00320 { return  true; }

bool CSym::is_in_asym_unit const float &  altitude,
const float &  azimuth,
const bool  inc_mirror
const [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

Implements EMAN::Symmetry3D.

Definition at line 1183 of file symmetry.cpp.

References get_delimiters(), and EMAN::Dict::set_default().

01184 {
01185         Dict d = get_delimiters(inc_mirror);
01186         float alt_max = d["alt_max"];
01187         float az_max = d["az_max"];
01188 
01189         int nsym = params.set_default("nsym",0);
01190         if ( nsym != 1 && azimuth < 0) return false;
01191         if ( altitude <= alt_max && azimuth <= az_max ) return true;
01192         return false;
01193 }

Symmetry3D* EMAN::CSym::NEW  )  [inline, static]
 

Factory support function NEW.

Returns:
a newly instantiated class of this type

Definition at line 242 of file symmetry.h.

00243                 {
00244                         return new CSym();
00245                 }

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

Disallow assignment.


Member Data Documentation

const string CSym::NAME = "c" [static]
 

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

Definition at line 40 of file symmetry.cpp.


The documentation for this class was generated from the following files:
Generated on Thu Dec 9 13:48:51 2010 for EMAN2 by  doxygen 1.3.9.1