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

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

Referenced by get_asym_unit_triangles().

01331 {
01332         Dict delim = get_delimiters(inc_mirror);
01333         int nsym = params.set_default("nsym",0);
01334         vector<Vec3f> ret;
01335 
01336         if ( nsym == 1 ) {
01337                 if (inc_mirror == false ) {
01338                         ret.push_back(Vec3f(0,-1,0));
01339                         ret.push_back(Vec3f(1,0,0));
01340                         ret.push_back(Vec3f(0,1,0));
01341                         ret.push_back(Vec3f(-1,0,0));
01342                 }
01343                 // else return ret; // an empty vector! this is fine
01344         }
01345         else if (nsym == 2 && !inc_mirror) {
01346                 ret.push_back(Vec3f(0,0,1));
01347                 ret.push_back(Vec3f(0,-1,0));
01348                 ret.push_back(Vec3f(1,0,0));
01349                 ret.push_back(Vec3f(0,1,0));
01350         }
01351         else {
01352                 ret.push_back(Vec3f(0,0,1));
01353                 ret.push_back(Vec3f(0,-1,0));
01354                 if (inc_mirror == true) {
01355                         ret.push_back(Vec3f(0,0,-1));
01356                 }
01357                 float angle = (float)(EMConsts::deg2rad*float(delim["az_max"]));
01358                 float y = -cos(angle);
01359                 float x = sin(angle);
01360                 ret.push_back(Vec3f(x,y,0));
01361         }
01362 
01363         return ret;
01364 
01365 }

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

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

01235                                                                           {
01236         vector<Vec3f> v = get_asym_unit_points(inc_mirror);
01237         int nsym = params.set_default("nsym",0);
01238 
01239         vector<vector<Vec3f> > ret;
01240         if (v.size() == 0) return ret; // nsym == 1 and inc_mirror == true, this is the entire sphere!
01241         if (nsym == 1 && !inc_mirror) {
01242                 Vec3f z(0,0,1);
01243                 vector<Vec3f> tmp;
01244                 tmp.push_back(z);
01245                 tmp.push_back(v[1]);
01246                 tmp.push_back(v[0]);
01247                 ret.push_back(tmp);
01248 
01249                 vector<Vec3f> tmp2;
01250                 tmp2.push_back(z);
01251                 tmp2.push_back(v[2]);
01252                 tmp2.push_back(v[1]);
01253                 ret.push_back(tmp2);
01254 
01255                 vector<Vec3f> tmp3;
01256                 tmp3.push_back(z);
01257                 tmp3.push_back(v[3]);
01258                 tmp3.push_back(v[2]);
01259                 ret.push_back(tmp3);
01260 
01261                 vector<Vec3f> tmp4;
01262                 tmp4.push_back(z);
01263                 tmp4.push_back(v[0]);
01264                 tmp4.push_back(v[3]);
01265                 ret.push_back(tmp4);
01266         }
01267         else if (nsym == 2 && inc_mirror) {
01268                 Vec3f x(1,0,0);
01269                 vector<Vec3f> tmp;
01270                 tmp.push_back(v[1]);
01271                 tmp.push_back(v[0]);
01272                 tmp.push_back(x);
01273                 ret.push_back(tmp);
01274 
01275                 vector<Vec3f> tmp2;
01276                 tmp2.push_back(v[2]);
01277                 tmp2.push_back(v[1]);
01278                 tmp2.push_back(x);
01279                 ret.push_back(tmp2);
01280 
01281                 vector<Vec3f> tmp3;
01282                 tmp3.push_back(v[3]);
01283                 tmp3.push_back(v[2]);
01284                 tmp3.push_back(x);
01285                 ret.push_back(tmp3);
01286 
01287                 vector<Vec3f> tmp4;
01288                 tmp4.push_back(v[0]);
01289                 tmp4.push_back(v[3]);
01290                 tmp4.push_back(x);
01291                 ret.push_back(tmp4);
01292         }
01293         else if (nsym == 2 && !inc_mirror) {
01294                 vector<Vec3f> tmp;
01295                 tmp.push_back(v[0]);
01296                 tmp.push_back(v[2]);
01297                 tmp.push_back(v[1]);
01298                 ret.push_back(tmp);
01299 
01300                 vector<Vec3f> tmp2;
01301                 tmp2.push_back(v[2]);
01302                 tmp2.push_back(v[0]);
01303                 tmp2.push_back(v[3]);
01304                 ret.push_back(tmp2);
01305         }
01306         else if (v.size() == 3) {
01307                 vector<Vec3f> tmp;
01308                 tmp.push_back(v[0]);
01309                 tmp.push_back(v[2]);
01310                 tmp.push_back(v[1]);
01311                 ret.push_back(tmp);
01312         }
01313         else if (v.size() == 4) {
01314                 vector<Vec3f> tmp;
01315                 tmp.push_back(v[0]);
01316                 tmp.push_back(v[3]);
01317                 tmp.push_back(v[1]);
01318                 ret.push_back(tmp);
01319 
01320                 vector<Vec3f> tmp2;
01321                 tmp2.push_back(v[1]);
01322                 tmp2.push_back(v[3]);
01323                 tmp2.push_back(v[2]);
01324                 ret.push_back(tmp2);
01325         }
01326 
01327         return ret;
01328 }

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

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

Referenced by get_asym_unit_points(), and is_in_asym_unit().

01209                                                      {
01210         Dict returnDict;
01211         // Get the parameters of interest
01212         int nsym = params.set_default("nsym",0);
01213         if ( nsym <= 0 ) throw InvalidValueException(nsym,"Error, you must specify a positive non zero nsym");
01214 
01215         if ( inc_mirror ) returnDict["alt_max"] = 180.0f;
01216         else  returnDict["alt_max"] = 90.0f;
01217 
01218         returnDict["az_max"] = 360.0f/(float)nsym;
01219 
01220         return returnDict;
01221 }

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

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

01367                                          {
01368         int nsym = params.set_default("nsym",0);
01369         if ( nsym <= 0 ) throw InvalidValueException(n,"Error, you must specify a positive non zero nsym");
01370 
01371         Dict d("type","eman");
01372         // courtesy of Phil Baldwin
01373         d["az"] = (n%nsym) * 360.0f / nsym;
01374         d["alt"] = 0.0f;
01375         d["phi"] = 0.0f;
01376         return Transform(d);
01377 }

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

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

01224 {
01225         Dict d = get_delimiters(inc_mirror);
01226         float alt_max = d["alt_max"];
01227         float az_max = d["az_max"];
01228 
01229         int nsym = params.set_default("nsym",0);
01230         if ( nsym != 1 && azimuth < 0) return false;
01231         if ( altitude <= alt_max && azimuth <= az_max ) return true;
01232         return false;
01233 }

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 Jun 11 13:49:44 2013 for EMAN2 by  doxygen 1.3.9.1