quaternion.h

/*
-------------------------------------------------------------------------------
libfob - C++ interface to Ascension Technology Corporation's
         Flock of Birds position and orientation measurement system.
Copyright (C) 2002 Nathan Cournia

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------
*/

//FILE:         quaternion.h
//AUTHOR:       Nathan Cournia <nathan@cournia.com>
//NOTE:         Not by any means a complete implementaion.

#ifndef COURNIA_QUATERNION_H
#define COURNIA_QUATERNION_H 1

#include <iostream>
#include <cmath>
#include "fob/vector.h"
#include "fob/matrix.h"

namespace math {
    class quaternion;
    std::ostream& operator<< ( std::ostream& o, const math::quaternion& vec );
}


class math::quaternion {
private:
    math::vector3 m_v;
    real_t m_w;


    friend std::ostream& math::operator<< ( std::ostream& o, const math::quaternion& vec );

public:

    quaternion( void ): m_w( 1.0 ) 
    { }


    quaternion( const math::vector3& v_, real_t w_ ): m_v( v_ ), m_w( w_ ) 
    { }


    quaternion( real_t x_, real_t y_, real_t z_, real_t w_ ):
        m_v( x_, y_, z_ ), m_w( w_ ) 
    { }

    quaternion( const math::quaternion& p ): m_v( p.m_v ), m_w( p.m_w )  
    { }

    inline math::quaternion& operator= ( const math::quaternion& p ) {
        m_v = p.m_v;
        m_w = p.m_w;
        return *this;
    }

    inline real_t w( void ) const { 
        return m_w; 
    }

    inline real_t x( void ) const { 
        return m_v.x( ); 
    }

    inline real_t y( void ) const { 
        return m_v.y( ); 
    }

    inline real_t z( void ) const { 
        return m_v.z( ); 
    }


    inline math::vector3 v( void ) const { 
        return m_v; 
    }


    inline math::vector3 vec( void ) const { 
        return m_v; 
    }


    inline real_t scalar( void ) const { 
        return m_w; 
    }


    inline void set( real_t x_, real_t y_, real_t z_, real_t w_ ) {
        m_v.set( x_, y_, z_ );
        m_w = w_;
    }


    inline void
    set( const math::vector3& v_,  real_t w_ ) {
        m_v = v_;
        m_w = w_;
    }


    inline math::quaternion conjugate( void ) const {
        return math::quaternion( -1.0 * m_v, m_w );
    }


    inline math::quaternion operator! ( void ) const {
        return math::quaternion( -1.0 * m_v, m_w );
    }


    inline double
    magnitude( void ) const {
        return sqrt( (double)(m_w * m_w + math::dot( m_v, m_v )) );
    }


    inline void
    normalize( void ) {
        double mag = magnitude( );
        m_w /= mag;
        m_v.x( m_v.x( ) / mag );
        m_v.y( m_v.y( ) / mag );
        m_v.z( m_v.z( ) / mag );
    }


    void
    set_identity( void ) {
        m_w = 1.0;
        m_v.set( 0.0, 0.0, 0.0 );
    }


    math::matrix4
    get_rotation_matrix( void ) const;


    void
    get_rotation_matrix( math::matrix4& m ) const;


    math::matrix4
    get_transposed_rotation_matrix( void ) const;


    void
    get_transposed_rotation_matrix( math::matrix4& m ) const;

    math::quaternion 
    operator* ( const math::quaternion& rhs ) const;


    math::vector3 
    operator* ( const math::vector3& rhs ) const;


    void
    from_angle_axis( real_t radians, const math::vector3& axis );


    void
    get_angle_axis( real_t& radians, math::vector3& axis ) const;


    void
    from_angles( real_t x_rad, real_t y_rad, real_t z_rad );


    void
    from_matrix3( const real_t *mat );


    void
    from_matrix4( const real_t *mat );


    static math::quaternion
    slerp( real_t percent, const math::quaternion& qa, 
        math::quaternion qb );

    

    static const math::quaternion IDENTITY;
}; //end of class math::quaternion

#endif

---