#include <symmetry.h>
Inheritance diagram for EMAN::Symmetry3D:
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< Vec3f > | get_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< Transform > | 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). | |
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< Transform > | get_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< Transform > | get_syms () const |
Static Public Member Functions | |
vector< Transform > | get_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. | |
Symmetry3D & | operator= (const Symmetry3D &) |
Disallow assignment. |
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
Definition at line 56 of file symmetry.h.
|
Definition at line 59 of file symmetry.h. |
|
Definition at line 60 of file symmetry.h. Referenced by cache_au_planes(). |
|
Definition at line 936 of file symmetry.cpp. 00936 : cached_au_planes(0),cache_size(0),num_triangles(0),au_sym_triangles() {}
|
|
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 }
|
|
Disallow copy construction.
|
|
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 }
|
|
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 }
|
|
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
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 }
|
|
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
Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, EMAN::PlatonicSym, and EMAN::TetrahedralSym. Referenced by get_touching_au_transforms(). |
|
Get triangles that precisely occlude the projection area of the default asymmetric unit. This will be used for collision detection in Symmetry3D::reduce
Implemented in EMAN::CSym, EMAN::DSym, EMAN::HSym, and EMAN::PlatonicSym. Referenced by cache_au_planes(). |
|
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; }
|
|
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).
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(). |
|
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(). |
|
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(). |
|
Every Symmetry3D object must provide access to the full set of its symmetry operators via this function.
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(). |
|
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 }
|
|
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 }
|
|
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.
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 }
|
|
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.
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 }
|
|
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.
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; }
|
|
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.
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; }
|
|
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.
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; }
|
|
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.
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(). |
|
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.
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; }
|
|
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.
Reimplemented in EMAN::TetrahedralSym. Definition at line 118 of file symmetry.h. Referenced by EMAN::OrientationGenerator::get_az_max(). 00118 { return false; }
|
|
Disallow assignment.
|
|
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.
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 }
|
|
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(). |
|
Have to remember the cache size.
Definition at line 210 of file symmetry.h. Referenced by cache_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.
Definition at line 207 of file symmetry.h. Referenced by cache_au_planes(), delete_au_planes(), point_in_which_asym_unit(), and ~Symmetry3D(). |
|
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(). |