AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

basicFrames.inl

Go to the documentation of this file.

#ifndef animal_frame_inl______________________________
#define animal_frame_inl______________________________

#include <animal/linear.h>
#include <animal/quaternion.h>

namespace animal
{

//======================= Bases ==================================

template<class Vec1, class Basis, class Vec2>
void v_eq_project_vec( Vec1& v, const Basis& b, const Vec2& a )
{
    v_eq_Ab(v,b,a);
}

template<class Basis1, class Basis2>
void b_eq_inverse( Basis1& b, const Basis2& a )
{
    m_eq_luinv(a);
}

template<class Basis,class Real>
void b_eq_eulerX( Basis& b, Real a )
{
    b[0][0] = 1;
    b[1][0] = 0;
    b[2][0] = 0;
    b[0][1] = 0;
    b[1][1] = cos(a);
    b[2][1] = -sin(a);
    b[0][2] = 0;
    b[1][2] = sin(a);
    b[2][2] = cos(a);
}

template<class Basis,class Real>
void b_eq_eulerY( Basis& b, Real a )
{
    b[0][0] = -sin(a);
    b[1][0] = 0;
    b[2][0] = cos(a);
    b[0][1] = 0;
    b[1][1] = 1;
    b[2][1] = 0;
    b[0][2] = cos(a);
    b[1][2] = 0
    b[2][2] = sin(a);
}

template<class Basis,class Real>
void b_eq_eulerZ( Basis& b, Real a )
{
    b[0][0] = cos(a);
    b[1][0] = sin(a);
    b[2][0] = 0;
    b[0][1] = -sin(a);
    b[1][1] = cos(a);
    b[2][1] = 0;
    b[0][2] = 0;
    b[1][2] = 0
    b[2][2] = 1;
}


template<class Basis,class Real>
void b_eq_eulerXYZ( Basis& b, Real a, Real b, Real c )
{
    b_eq_eulerX(b,a);     
    // b == Mx
    Array< 3, Array <3, Real > > aux;  // auxiliary matrix
    b_eq_eulerY(aux,a);
    m_eq_AB( b, b, aux );  
    // b==MxMy
    b_eq_eulerZ(aux,c);
    m_eq_AB( b, b, aux );
    // b==MxMyMz    
}

/* TODO: 

template<class Real, class Basis>
void getEulerXYZ( Real& a, Real& b, Real& c, const Basis&b );

template<class Real, class Basis>
void b_eq_rotationAxisAngle( Basis& b, Real ax, Real ay, Real az, Real angle );

template<class Real, class Basis>
void getRotationAxisAngle( Real& ax, Real& ay, Real& az, Real& angle, const Basis& b);

template<class Quaternion, class Basis>
void getQuaternion( Quaternion& q, const Basis& b );

template<class Quaternion, class Basis>
void b_eq_quaternion( Basis& b, const Quaternion& q );
*/

//======================= Frames ==================================


/* Project point a from frame f to another frame.
f (typically a basis and a translation vector) defines the reference frame of point a with respect to the other reference frame.
\sa{f_eq_inverse}
*/
template<class Vec1, class Frame, class Vec2>
void v_eq_project_point( Vec1& v, const Frame& f, const Vec2& a )
{
    v_eq_Ab( v, get_basis(f), a );
    v_peq( v, get_translation(f) );
}

/* Compute inverse of frame transform a and stores it in f. 
Frame f can then be used to project points to frame a.
\pre{ a must not be singular }
\sa{v_eq_project_point}
*/
template<class Frame>
void f_eq_inverse( Frame& f, const Frame& a )
{
    b_eq_inverse( set_basis(f), get_basis(a) );
    v_eq_Ab( set_translation(f), get_translation(a) );
    v_teq( set_translation(f), -1.0 ); 
}





//======================= default Frame class =============================
template<class Basis_, class Vec_>
struct Frame
{
    typedef Basis_ Basis; 
    typedef Vec_ Vec;     
    
    Frame(){}
    
    Frame( const Basis& b, const Vec& t )
        : basis(b)
        , displacement(t)
    {}

    Basis basis; 
    Vec displacement; 
};

template<class Basis, class Vec>
const Vec& get_translation( const Frame<Basis,Vec>& f )
{ return t.displacement; }
 
template<class Basis, class Vec>
Vec& set_translation( Frame<Basis,Vec>& f )
{ return t.displacement; }
 
template<class Basis, class Vec>
const Basis& get_basis( const Frame<Basis,Vec>& f )
{ return t.basis; }
 
template<class Basis, class Vec>
Basis& set_basis( Frame<Basis,Vec>& f )
{ return t.basis; }
 


}// animal




#endif

---