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

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

Referenced by get_asym_unit_triangles().

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

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

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

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

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

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

Referenced by get_asym_unit_points(), and is_in_asym_unit().

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

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 transform containing the correct rotational symmetric operation.
Exceptions:
InvalidValueException if nsym is less than or equal to zero

Implements EMAN::Symmetry3D.

Definition at line 1330 of file symmetry.cpp.

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

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

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

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

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

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 Tue Jul 12 13:53:17 2011 for EMAN2 by  doxygen 1.3.9.1