Merge branch 'master' of /home/vanhoey/CGoGN
* 'master' of /home/vanhoey/CGoGN: qqs modifs :-) added new dependency to package uuid-dev in README added howto (in README_ECLIPSE) install CMake Editor in Eclipse corrections dans AHEM : _CELL et _ORBIT added tests to vector_gen and updated frame new naming convention for frames : XYZ instead of TBN rename localFrame -> Frame ; move from Utils to Geom namespace localFrame.hpp : handling cross product of orthogonal vectors Euler angle name conventions used in localFrame updated comment for localFrame
| ... | ... | @@ -29,7 +29,7 @@ |
| namespace CGoGN { | ||
| namespace Utils { | ||
| namespace Geom { | ||
| /** | ||
| * Util for rotation of a 3D point (or vector) around a given line (going through the origin) and of a given angle | ||
| ... | ... | @@ -41,37 +41,79 @@ template <typename REAL> |
| Geom::Vector<3,REAL> rotate (Geom::Vector<3,REAL> axis, REAL angle, Geom::Vector<3,REAL> p) ; | ||
| /** | ||
| * Util for conversion from spherical to carthesian coordinates. | ||
| * Util for conversion from spherical to cartesian coordinates. | ||
| * The spherical coordinates are in radius-longitude-latitude | ||
| * @param sph the spherical coordinates | ||
| * @return the carthesian coordinates | ||
| * @return the cartesian coordinates | ||
| */ | ||
| template<typename REAL> | ||
| Geom::Vector<3,REAL> sphericalToCarth (const Geom::Vector<3,REAL>& sph) ; | ||
| Geom::Vector<3,REAL> sphericalToCart (const Geom::Vector<3,REAL>& sph) ; | ||
| /** | ||
| * Util for conversion from carthesian to spherical coordinates. | ||
| * Util for conversion from cartesian to spherical coordinates. | ||
| * The spherical coordinates are in radius-longitude-latitude | ||
| * @param carth the carthesian coordinates | ||
| * @param cart the cartesian coordinates | ||
| * @return the spherical coordinates | ||
| */ | ||
| template<typename REAL> | ||
| Geom::Vector<3,REAL> carthToSpherical (const Geom::Vector<3,REAL>& carth) ; | ||
| Geom::Vector<3,REAL> cartToSpherical (const Geom::Vector<3,REAL>& cart) ; | ||
| /** | ||
| * Class for representing a direct local frame composed of 3 orthonormal vectors T (tangent), B (bitangent) and N (normal). | ||
| * This class can compress/decompress a local frame, switching from its explicit representation (3 vectors) to its compressed representation (1 vector). | ||
| * Tests if the frame is direct, normalized and orthogonal | ||
| * @param X the first vector of the frame | ||
| * @param Y the second vector of the frame | ||
| * @param Z the third vector of the frame | ||
| * @param epsilon tolerated error | ||
| * @return true if the frame is direct, normalized and orthogonal | ||
| */ | ||
| template<typename PFP> | ||
| bool isDirectOrthoNormalFrame(const typename PFP::VEC3& X, const typename PFP::VEC3& Y, const typename PFP::VEC3& Z, typename PFP::REAL epsilon = 1e-5) ; | ||
| /** | ||
| * Tests if the frame is direct | ||
| * @param X the first vector of the frame | ||
| * @param Y the second vector of the frame | ||
| * @param Z the third vector of the frame | ||
| * @param epsilon tolerated error | ||
| * @return true if the frame is direct | ||
| */ | ||
| template<typename PFP> | ||
| bool isDirectFrame(const typename PFP::VEC3& X, const typename PFP::VEC3& Y, const typename PFP::VEC3& Z, typename PFP::REAL epsilon = 1e-7) ; | ||
| /** | ||
| * Tests if the frame is orthogonal | ||
| * @param X the first vector of the frame | ||
| * @param Y the second vector of the frame | ||
| * @param Z the third vector of the frame | ||
| * @param epsilon tolerated error | ||
| * @return true if the frame is orthogonal | ||
| */ | ||
| template<typename PFP> | ||
| bool isOrthogonalFrame(const typename PFP::VEC3& X, const typename PFP::VEC3& Y, const typename PFP::VEC3& Z, typename PFP::REAL epsilon = 1e-5) ; | ||
| /** | ||
| * Tests if the frame is normalized | ||
| * @param X the first vector of the frame | ||
| * @param Y the second vector of the frame | ||
| * @param Z the third vector of the frame | ||
| * @param epsilon tolerated error | ||
| * @return true if the frame is normalized | ||
| */ | ||
| template<typename PFP> | ||
| bool isNormalizedFrame(const typename PFP::VEC3& X, const typename PFP::VEC3& Y, const typename PFP::VEC3& Z, typename PFP::REAL epsilon = 1e-5) ; | ||
| /** | ||
| * Class for representing a direct right-handed local frame composed of 3 orthonormal vectors T (tangent), B (bitangent) and N (normal). | ||
| * This class can compress/decompress a local frame, switching from its explicit representation (3 vectors) to its compressed representation (1 vector composed of the Euler angles). | ||
| * Usage : | ||
| * VEC3 T,B,N ; // current set of orthonormal vectors composing the direct frame. | ||
| * LocalFrame<PFP> lf(T,B,N) ; // Constructor from explicit expression. | ||
| * VEC3 X,Y,Z ; // current set of orthonormal vectors composing the direct frame. | ||
| * Frame<PFP> lf(X,Y,Z) ; // Constructor from explicit expression. | ||
| * if (lf.isOrthoNormalDirect()) // test if the frame is Orthogonal, Normalized and Direct | ||
| * VEC3 compressed = lf.getCompressed() ; // Extract compressed frame | ||
| * LocalFrame<PFP> decompressed(compressed) ; // Constructor from implicit (compressed) expression. | ||
| * | ||
| * All formulae were provided by "Représentation compacte d'un repère local", june 14th, 2011 by K. Vanhoey | ||
| * Frame<PFP> newLf(compressed) ; // Constructor from implicit (compressed) expression. | ||
| */ | ||
| template <typename PFP> | ||
| class LocalFrame | ||
| class Frame | ||
| { | ||
| typedef typename PFP::REAL REAL ; | ||
| typedef typename Geom::Vector<2,REAL> VEC2 ; | ||
| ... | ... | @@ -79,32 +121,40 @@ class LocalFrame |
| private: // fields | ||
| /** | ||
| * The three explicit vectors | ||
| * The Euler angles | ||
| */ | ||
| VEC3 m_T,m_B,m_N ; | ||
| VEC3 m_EulerAngles ; | ||
| public: // methods | ||
| /** | ||
| * Constructor from explicit data | ||
| * @param T the tangent vector | ||
| * @param B the bitangent vector | ||
| * @param N the normal vector | ||
| * @param X the tangent vector | ||
| * @param Y the bitangent vector | ||
| * @param Z the normal vector | ||
| */ | ||
| LocalFrame(const VEC3& T, const VEC3& B, const VEC3& N) ; | ||
| Frame(const VEC3& X, const VEC3& Y, const VEC3& Z) ; | ||
| /** | ||
| * Constructor from implicit (compressed representation) | ||
| * @param compressedFrame an implicit (compressed) version of the local frame (can be produced by localFrame.getCompressed()) | ||
| * @param compressedFrame an implicit (compressed) version of the local frame (can be produced by Frame.getCompressed()) | ||
| */ | ||
| LocalFrame(const VEC3& compressedFrame) ; | ||
| Frame(const VEC3& compressedFrame) ; | ||
| ~LocalFrame() {} ; | ||
| ~Frame() {} ; | ||
| /** | ||
| * Returns a compressed version of the current local frame | ||
| * A VEC3 is not sufficient to completely define a local frame (if phiN=0, the decompression is not unique). | ||
| */ | ||
| VEC3 getCompressed() const ; | ||
| const VEC3& getCompressed() const { return m_EulerAngles ; } ; | ||
| /** | ||
| * Returns a decompressed frame (set of 3 VEC3) | ||
| * @param X : the X vector | ||
| * @param Y : the Y vector | ||
| * @param Z : the Z vector | ||
| */ | ||
| void getFrame(VEC3& X, VEC3& Y, VEC3& Z) const ; | ||
| /** | ||
| * Tests if the frames are identical | ||
| ... | ... | @@ -112,100 +162,61 @@ public: // methods |
| * @param epsilon the authorized deviation | ||
| * @return true if frames are identical (or deviate less than epsilon) | ||
| */ | ||
| bool equals(const LocalFrame<PFP>& lf, REAL epsilon = 1e-6) const ; | ||
| bool equals(const Frame<PFP>& lf, REAL epsilon = 1e-6) const ; | ||
| /** | ||
| * Equality of frames | ||
| * Identical to calling equals with default epsilon | ||
| * @return true if frames are identical | ||
| */ | ||
| bool operator==(const LocalFrame<PFP>& lf) const ; | ||
| bool operator==(const Frame<PFP>& lf) const ; | ||
| /** | ||
| * Inequality of frames | ||
| * Identical to calling !equals with default epsilon | ||
| * @return false if frames are identical | ||
| */ | ||
| bool operator!=(const LocalFrame<PFP>& lf) const ; | ||
| /** | ||
| * Tests if the frame is direct | ||
| * @return true if the frame is direct | ||
| */ | ||
| bool isDirect(REAL epsilon = 1e-7) const ; | ||
| /** | ||
| * Tests if the frame is orthogonal | ||
| * @return true if the frame is orthogonal | ||
| */ | ||
| bool isOrthogonal(REAL epsilon = 1e-5) const ; | ||
| /** | ||
| * Tests if the frame is normalized | ||
| * @return true if the frame is normalized | ||
| */ | ||
| bool isNormalized(REAL epsilon = 1e-5) const ; | ||
| </ |