vector.h

Ir a la documentación de este archivo.

//===========================================================================
//= vector.h                                                Febrero de 1997 =
//=-------------------------------------------------------------------------=
//= Clase reutilizable VECTOR de tipo <x, y, z>, con enfasis en             =
//= aplicaciones de geometria.                                              =
//=-------------------------------------------------------------------------=
//= 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 __VECTOR__
#define __VECTOR__

#include <stdio.h>
//#include <math.h>

#include "jed_defs.h"

#define DISTANCIA_V(a, b) (DISTANCIA( (a).x, (a).y, (a).z,\
                                      (b).x, (b).y, (b).z ))
#define MAGNITUD(a) (DISTANCIA( (a).x, (a).y, (a).z,\
                                0.0, 0.0 ,0.0 ))

class VECTOR {
  public:
    double x;
    double y;
    double z;

    VECTOR ();
    VECTOR (double ax, double ay, double az);
    inline VECTOR producto_cruz(VECTOR v2);
    inline double  producto_punto(VECTOR v2);
    inline void punto_medio(VECTOR a, VECTOR b);
    inline void normalizar(void);
    inline double norma(void);
    inline void direccion_euler(double *yaw, double *pitch);
    inline VECTOR operator + (VECTOR a);
    inline VECTOR operator - (VECTOR a);
    inline VECTOR operator * (double c);
    inline void operator *= (double c);
    inline VECTOR operator / (double c);
    inline void operator /= (double c);
    inline void rotar_x(double);
    inline void rotar_y(double);
    inline void rotar_z(double);
    void imprimir(void);
};

//===========================================================================
//= TODAS LAS OPERACIONES SOBRE VECTORES SON AHORA INLINE!                  =
//===========================================================================

inline double
VECTOR::norma(void)
{
    return DISTANCIA(0.0, 0.0, 0.0, x, y, z);
}

inline VECTOR
VECTOR::producto_cruz(VECTOR v2)
{
    return VECTOR ( y*v2.z - v2.y*z,
                   -(x*v2.z - v2.x*z),
                   x*v2.y - v2.x*y );
}

inline double
VECTOR::producto_punto(VECTOR v2)
{
    return ( (x*v2.x) + (y*v2.y) + (z*v2.z) );
}

inline VECTOR
VECTOR::operator * (double c)
{
    VECTOR v;

    v.x = c*this->x;
    v.y = c*this->y;
    v.z = c*this->z;
    
    return v;
}

inline void
VECTOR::operator *= (double c)
{
    x *= c;
    y *= c;
    z *= c;
}

inline void
VECTOR::operator /= (double c)
{
    x /= c;
    y /= c;
    z /= c;
}

inline VECTOR
VECTOR ::operator / (double c)
{
    VECTOR v;

    if ( IGUAL(c, 0.0) ){
       fprintf(stderr,"Error: Division por cero\n");
       return v;
    }
    else{
       v.x = (this->x)/c;
       v.y = (this->y)/c;
       v.z = (this->z)/c;
    }

    return v;
}

inline VECTOR
VECTOR ::operator + (VECTOR a)
{
    VECTOR v;
 
    v.x = this->x + a.x;
    v.y = this->y + a.y;
    v.z = this->z + a.z;
   
    return v;
}

inline VECTOR
VECTOR ::operator - (VECTOR a)
{
    VECTOR v;
 
    v.x = this->x - a.x;
    v.y = this->y - a.y;
    v.z = this->z - a.z;
   
    return v;
}

inline void
VECTOR::normalizar(void)
{
    double norma = DISTANCIA(0.0, 0.0, 0.0, x, y, z);
    norma = 1/norma;
    (*this) = (*this) * norma;
}

inline void
VECTOR::direccion_euler(double *yaw, double *pitch)
{
    VECTOR yo_normal = (*this);
    double sp;

    yo_normal.normalizar();

    (*pitch) = acos(yo_normal.z);
    sp = sin(*pitch);
    if ( fabs(sp) < EPSILON ) {
        (*yaw) = 0;
      }
      else {
        yo_normal.z = 0;
        yo_normal.normalizar();
        if ( yo_normal.y > 0) {
            (*yaw) = acos(yo_normal.x);
          }
          else {
            (*yaw) = -acos(yo_normal.x);
        }
    }
    (*pitch) -= DEG2RAD(90);
    (*pitch) *= -1;
}

inline void
VECTOR::punto_medio(VECTOR a, VECTOR b) 

{
    x = (a.x + b.x)/2.0;
    y = (a.y + b.y)/2.0;
    z = (a.z + b.z)/2.0;
}

// Rotaciones respecto a un eje principal:

inline void
VECTOR::rotar_y(double angulo)
{ 
    double z_ant;

    z_ant=z;
    z= z_ant*cos(angulo) - x*sin(angulo);
    x= z_ant*sin(angulo) + x*cos(angulo);
}

inline void
VECTOR::rotar_x(double angulo)
{ 
    double y_ant;

    y_ant=y;
    y= y_ant*cos(angulo) - z*sin(angulo);
    z= y_ant*sin(angulo) + z*cos(angulo);
}

inline void
VECTOR::rotar_z(double angulo)
{   
    double x_ant;

    x_ant=x;
    x= x_ant*cos(angulo) - y*sin(angulo);
    y= x_ant*sin(angulo) + y*cos(angulo);
}

#endif

//===========================================================================
//= 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.