TAPsQuaternion.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsQuaternion.hpp

Quaternion class (hpp file).

SUKITTI PUNAK   (07/12/2009)
UPDATE          (11/01/2010)
******************************************************************************/
#ifndef TAPs_QUATERNION_HPP
#define TAPs_QUATERNION_HPP

#include "TAPsVector3.hpp"
#include "TAPsMatrix3x3.hpp"
#include "TAPsMatrix4x4.hpp"

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T>
class Quaternion {
//=============================================================================
public:
    // Member Functions -------------------------------------------------------
    friend std::ostream & operator<< ( std::ostream &output, Quaternion<T> const &obj )
    {
        output << obj.StrInfo();
        return output;
    }
    //-------------------------------------------------------------------------


    Quaternion ();

    Quaternion ( T r, T i, T j, T k );

    Quaternion ( T q[4] );

    Quaternion ( Vector3<T> const & P );

    Quaternion ( Quaternion<T> const &Q );

    //Quaternion ( Matrix3x3<T> const & R3x3 );

    //Quaternion ( Matrix4x4<T> const & R4x4 );

    ~Quaternion ();

    //-------------------------------------------------------------------------
    virtual std::string StrInfo () const;

    //-------------------------------------------------------------------------
    // Operators and Operations

    //inline T & operator[] ( int i );
    //inline T const & operator[] ( int i ) const;

    inline Quaternion<T> operator! ();
    inline void Conjugated ();
    inline Quaternion<T> GetConjugate () const;

    // Assignment Operator
    inline Quaternion<T> & operator= ( Quaternion<T> const &Q );

    inline Quaternion<T> operator+ ( Quaternion<T> const &Q ) const;
    inline Quaternion<T> & operator+= ( Quaternion<T> const &Q );

    inline Quaternion<T> operator- ( Quaternion<T> const &Q ) const;
    inline Quaternion<T> & operator-= ( Quaternion<T> const &Q );

    inline Quaternion<T> operator* ( Quaternion<T> const &Q ) const;
    inline Quaternion<T> operator* ( Vector3<T> const &V ) const;
    inline Quaternion<T> & operator*= ( Quaternion<T> const &Q );

    inline T    InnerProduct ( Quaternion<T> const &Q ) const;

    inline Quaternion<T> operator* ( T a ) const;
    inline Quaternion<T> & operator*= ( T a );

    inline T GetNormSquare () const;
    inline T GetNorm () const;
    inline Quaternion<T> & Normalized ();

    inline Quaternion<T> GetInverse () const;
    inline void Inversed ();

    //-------------------------------------------------------------------------
    // Conversions

    inline Matrix3x3<T> GetRotationMatrix3x3 () const;

    inline Matrix4x4<T> GetRotationMatrix4x4 () const;

    void SetByRotationMatrix3x3 ( Matrix3x3<T> const & R3x3 );

    //void SetFromRotationMatrix3x3 ( Matrix3x3<T> const & R3x3 );

    //void SetFromRotationMatrix4x4 ( Matrix4x4<T> const & R4x4 );

    inline Matrix4x4<T> GetQuaternionMatrix () const;

    inline Matrix4x4<T> GetQuaternionConjugateMatrix () const;

    //-------------------------------------------------------------------------

    inline void SetByRotationAxisAndAngle ( Vector3<T> const & rotAxis, T angle );
    inline void SetByRotationAxisAndAngle ( T rotAxis_x, T rotAxis_y, T rotAxis_z, T angle );

    inline void GetRotationAxisAndAngle ( Vector3<T> & rotAxis, T & angle );
    inline void GetRotationAxisAndAngle ( T& rotAxis_x, T& rotAxis_y, T& rotAxis_z, T& angle );


    inline void RotatePt ( Vector3<T> & P ) const;
    inline void RotatePt ( T & P_x, T & P_y, T & P_z ) const;

    inline Vector3<T> CalRotatedPtOfPt ( Vector3<T> const & P ) const;
    inline Vector3<T> CalRotatedPtOfPt ( T P_x, T P_y, T P_z ) const;

    //-------------------------------------------------------------------------
    // Get/Set Functions

    T GetR () const { return m_r; }
    void SetR ( T r )   { m_r = r; }
    
    T GetI () const { return m_i; }
    void SetI ( T i )   { m_i = i; }
    
    T GetJ () const { return m_j; }
    void SetJ ( T j )   { m_j = j; }
    
    T GetK () const { return m_k; }
    void SetK ( T k )   { m_k = k; }
    
    void SetIJK ( T i, T j, T k )   { m_i=i; m_j=j; m_k=k; }
    void GetIJK ( T &i, T &j, T &k ) const  { i=m_i; j=m_j; k=m_k; }
    
    void SetIJK ( T a[3] )              { m_i=a[0]; m_j=a[1]; m_k=a[2]; }
    void GetIJK ( T a[3] ) const    { a[0]=m_i; a[1]=m_j; a[2]=m_k; }

    void SetIJK ( Vector3<T> const & v )    { m_i=v[0]; m_j=v[1]; m_k=v[2]; }
    void GetIJK ( Vector3<T> & v ) const    { v.SetXYZ( m_i, m_j, m_k ); }

    void SetRIJK ( T a[4] )         { m_r=a[0]; m_i=a[1]; m_j=a[2]; m_k=a[3]; }
    void GetRIJK ( T a[4] ) const   { a[0]=m_r; a[1]=m_i; a[2]=m_j; a[3]=m_k; }
    void SetRIJK ( T r, T i, T j, T k )             { m_r=r; m_i=i; m_j=j; m_k=k; }
    void GetRIJK ( T &r, T &i, T &j, T &k ) const   { r=m_r; i=m_i; j=m_j; k=m_k; }
    //-------------------------------------------------------------------------
    // Data Members -----------------------------------------------------------
//=============================================================================
protected:
    // Member Functions -------------------------------------------------------
    // Data Members -----------------------------------------------------------
    T m_r, m_i, m_j, m_k;   
//=============================================================================
private:
    // Member Functions -------------------------------------------------------
    // Data Members -----------------------------------------------------------
//=============================================================================

#if defined(__gl_h_) || defined(__GL_H__)
public:
    // Transfrom by OpenGL for Drawing by OpenGL
    virtual void TransformByOpenGLForDrawing () const;
#endif

//=============================================================================
}; // END CLASS Quaternion
//=============================================================================

template <typename T>
inline Quaternion<T> operator* ( T a, Quaternion<T> const &Q )  { return Q*a; }

//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
#include "TAPsQuaternion.cpp"
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----