quaternion.h

Ir a la documentación de este archivo.

//===========================================================================
//= quaternion.h                                               Mayo de 1999 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase QUATERNION                                     =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#ifndef __QUATERNION__
#define __QUATERNION__

#include "jed_defs.h"
#include "vector.h"

class QUATERNION
{
  public:
    VECTOR direccion;
    double magnitud;

    inline QUATERNION operator * (QUATERNION a);
    inline QUATERNION operator + (QUATERNION a);
    inline QUATERNION operator * (double n);
    inline QUATERNION inversa(void);
    inline void importar_quaternion_puro(VECTOR v);
    inline void importar_angulo_eje(double angulo, VECTOR eje);
    inline double norma(void);
    inline void normalizar(void);

    //inline void exportar_angulo_eje(double &angulo, VECTOR &eje);
/*
 Conjugate: q* = [w, -v] 
 Norm: N(q) = w2 + x2 + y2 + z2 
 Inverse: q-1 = q* / N(q) 
 Unit Quaternion: q is a unit quaternion if N(q)= 1 and then q-1 = q* 

    inline conjugado
    inline unidad

    inline identidad();
       // ? No se sabe, porque es [1, (0,0,0)] cuando esta en multiplicacion
       //                    y es [0, (0,0,0)] cuando esta en suma!
*/

};

inline void
QUATERNION::importar_angulo_eje(double angulo, VECTOR eje)
{
    magnitud = cos(angulo/2);
    direccion = eje * sin(angulo/2);
}

#ifdef NONONO
inline void
QUATERNION::exportar_angulo_eje(double &angulo, VECTOR &eje)
{
    //angulo = 2 * acos(magnitud);
    //eje = direccion * (1/sin(angulo/2));
    angulo = 0;
    eje = direccion;
}
#endif

inline QUATERNION
QUATERNION::operator * (QUATERNION a)
{
    QUATERNION b;

    b.magnitud = magnitud * a.magnitud - direccion.producto_punto(a.direccion);

    b.direccion = a.direccion*magnitud + direccion*a.magnitud +
                  direccion.producto_cruz(a.direccion);

    return b;
}

inline QUATERNION
QUATERNION::operator + (QUATERNION a)
{
    QUATERNION b;

    b.magnitud = magnitud + a.magnitud;
    b.direccion = direccion + a.direccion;

    return b;
}

inline QUATERNION
QUATERNION::operator * (double n)
{
    QUATERNION b;

    b.magnitud = magnitud * n;
    b.direccion = direccion * n;

    return b;
}

inline QUATERNION
QUATERNION::inversa(void)
{
    QUATERNION inversa;
    double denominador = ( (magnitud*magnitud) + 
                           (direccion.x*direccion.x) + 
                           (direccion.y*direccion.y) +
                           (direccion.z*direccion.z*direccion.z) );

    inversa.magnitud = magnitud;
    inversa.direccion = direccion * (-1);
    inversa = inversa * (1/denominador);

    return inversa;
}

inline void
QUATERNION::importar_quaternion_puro(VECTOR v)
{
    magnitud = 0;
    direccion = v;
}

inline double
QUATERNION::norma(void)
{
    return (magnitud * magnitud) + direccion.producto_punto(direccion);
}

inline void
QUATERNION::normalizar(void)
{
    double n = norma();
    magnitud *= 1/n;
    direccion *= 1/n;
}

#endif // __QUATERNION__

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.