terreno.h

Ir a la documentación de este archivo.

//===========================================================================
//= terreno.cc                                              Octubre de 1999 =
//=-------------------------------------------------------------------------=
//= Definicion de la clase TERRENO                                          =
//= NOTA: No incluya este encabezado en los modulos.  Incluya a             =
//=       geometria.h.                                                      =
//=-------------------------------------------------------------------------=
//= 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. =
//===========================================================================

#include "jed_defs.h"

#ifndef __GEOMETRIA__
    #error "No incluya a terreno.h, incluya a geometria.h!"
#endif

#ifdef VEL_ROSITA
    #include "toolkits/geom/geometria.h"
#endif
#include "toolkits/util/dem.h"

//#define DEBUG_TERRENO 1

#ifdef DEBUG_TERRENO
  #include "lista.cc"
#endif

class TERRENO : public GEOMETRIA
{
  private:
    //-----------------------------------------------------------------------
    PALETA *Paleta;
    IMAGEN *imagen;
    long int _x_tam;    // Tamanno del terreno en muestras
    long int _y_tam;
    long int vertices_tam; // Arreglo de vertices con la geometria del terreno
    VERTICE_GL *vertices_arr;
    GLubyte *colores_arr;
    GLuint **TIras_arr; // Arreglo dinamico de tiras (c/u es un arreglo)

    VECTOR _min;
    VECTOR _max;
    double _escala;
    double _factor_exageracion;

    //- Elementos de depuracion ---------------------------------------------
    LISTA <int> arr_debug_x;
    LISTA <int> arr_debug_y;
  #ifdef DEBUG_TERRENO
    COLOR color_debug;
  #endif

    //- Servicios privados --------------------------------------------------

    // Usados en la visualizacion
  #ifdef GL_ENABLED
    void pintar_tiras_gl(void);
    void pintar_tirasv_gl(void);
  #endif

    // Operaciones basicas
    void calcular_color(float z, float *r, float *g, float *b);
    VECTOR calcule_subnormal(int x1, int y1, int x2, int y2, int x3, int y3);
    VECTOR calcule_normal(int x, int y);
    double interseccion_celda(RAYO *Rayo, VECTOR &punto, VECTOR &normal,
                              int x, int y);
    int coord2index_x(double x_coord);
    int coord2index_y(double y_coord);

  public:
    //- Operaciones standard de GEOMETRIA AQUYNZA ---------------------------
    TERRENO(GLOBAL_DEM *Fuente,
        long int origen_x, long int origen_y, long int xtam, long int ytam,
        double escala, double exageracion);
    virtual ~TERRENO();

    // Servicios para raytracers y algoritmos especiales de geometria
    double interseccion(RAYO *Rayo, VECTOR &punto, VECTOR &normal);

    // Otros
    void anexar_textura(IMAGEN *img);
    int clasificar_punto(VECTOR p);
    virtual GEOMETRIA *crear_copia(void);

    void minmax(VECTOR *min, VECTOR *max);

  #ifdef GL_ENABLED
    void
    pintar_gl(CALIDAD_VISUAL *Calidad, MATERIAL* Material, CAMARA *Camara);
  #endif
    void pintar_povray(FILE *fd);
    void pintar_aqz(FILE *fd);

    //- Operaciones particulares de la clase TERRENO ------------------------
    void set_paleta(PALETA *P);
//    double altura(double xx, double yy);
    BOOLEAN seleccionar(RAYO *Rayito, int *i, int *j);
    double index2coord_x(int i);
    double index2coord_y(int j);
    void elim(void);
};

inline int
TERRENO::coord2index_x(double x_coord)
{
    int i;

    i = (int)(x_coord / (1000*_escala)) - 1;

    return i;
}

inline int
TERRENO::coord2index_y(double y_coord)
{
    int j;

    // OJO: Ese -2 es machete!
    j = (int)(y_coord / (1000 * _escala)) + _y_tam - 1 - 2;

    return j;
}

inline double
TERRENO::index2coord_x(int i)
{
    double x;

    //x = (i+1) * 1000 * _escala;
    x = vertices_arr[i].x;

    return x;
}

inline double
TERRENO::index2coord_y(int j)
{
    double y;

    //y = 1000 * _escala * (j + 1 - _y_tam);
    y = vertices_arr[j*_x_tam].y;

    return y;
}

inline double
TERRENO::interseccion_celda(RAYO *Rayo, VECTOR &punto, VECTOR &normal, 
                            int x, int y)
{
    //- Determine los puntos extremos de los triangulos ---------------------
    VECTOR a, b, c, d;

    a.x = index2coord_x(x);
    a.y = index2coord_y(y);
    a.z = vertices_arr[y*_x_tam + x].z;

    b.x = index2coord_x(x);
    b.y = index2coord_y(y+1);
    b.z = vertices_arr[(y+1)*_x_tam + x].z;

    c.x = index2coord_x(x+1);
    c.y = index2coord_y(y);
    c.z = vertices_arr[y*_x_tam + x+1].z;

    d.x = index2coord_x(x+1);
    d.y = index2coord_y(y+1);
    d.z = vertices_arr[(y+1)*_x_tam + x+1].z;

    //- Preparativos con los planos de T1 y T2 ------------------------------
    VECTOR O = Rayo->origen;
    VECTOR l = Rayo->direccion;
    double T = 0;
    double pp, pq, m;
    double D;

    l.normalizar();

    //- Pruebo con T1 -------------------------------------------------------
    double t1 = INFINITO;
    VECTOR p1, n1;

    n1 = (a-b).producto_cruz(d-b);
    n1.normalizar();
    D = n1.x*d.x + n1.y*d.y + n1.z*d.z;  // Constante D de la ecuacion del
                                         // plano. 
    pp = n1.producto_punto(l);
    pq = n1.producto_punto(O-b);
    if ( pp < -EPSILON && pq > EPSILON ||
         pp > EPSILON && pq < -EPSILON ) { 
        //- 'n1' y 'l' estan "mirandose de frente", estamos en el plano -----
        // Pero tenemos que ver si esta en el triangulo en el plano XY...
        t1 = (-1) * (  (n1.x*O.x + n1.y*O.y + n1.z*O.z - D) / 
                      (n1.x*l.x + n1.y*l.y + n1.z*l.z)       );
        p1 = O + l * t1;
        m = (d.y - a.y)/(d.x - a.x);
        if ( p1.x >= a.x-EPSILON && p1.y <= d.y+EPSILON && 
             p1.y >= m*(p1.x - a.x) + a.y - EPSILON ) {
            //- Listo, si llegamos hasta aqui es porque aqui hay interseccion
            normal = n1;
            punto = p1;
            T = t1;
          }
          else {
            t1 = INFINITO;
        }
    }

    //- Pruebo con T2 -------------------------------------------------------
    double t2 = 0.0;
    VECTOR p2, n2;

    n2 = (d-c).producto_cruz(a-c);
    n2.normalizar();
    D = n2.x*d.x + n2.y*d.y + n2.z*d.z;  // Constante D de la ecuacion del
                                         // plano. 
    pp = n2.producto_punto(l);
    pq = n2.producto_punto(O-c);
    if ( pp < -EPSILON && pq > EPSILON ||
         pp > EPSILON && pq < -EPSILON ) { 
        //- 'n2' y 'l' estan "mirandose de frente", estamos en el plano -----
        // Pero tenemos que ver si esta en el triangulo en el plano XY...
        t2 = (-1) * (  (n2.x*O.x + n2.y*O.y + n2.z*O.z - D) / 
                      (n2.x*l.x + n2.y*l.y + n2.z*l.z)       );
        p2 = O + l * t2;
        m = (d.y - a.y)/(d.x - a.x);
        if ( p2.x <= d.x+EPSILON && p2.y >= c.y-EPSILON && 
             p2.y <= m*(p2.x - a.x) + a.y + EPSILON ) {
            //- Listo, si llegamos hasta aqui es porque aqui hay interseccion
            if ( t2 <= t1 + EPSILON ) {
                normal = n2;
                punto = p2;
                T = t2;
            }
        }
    }

    //-----------------------------------------------------------------------
    return T;
}

inline double
TERRENO::interseccion(RAYO *Rayo, VECTOR &punto, VECTOR &normal)
{
    //= FASE 1 ==============================================================

    //- Determine la situacion actual y escoja el algoritmo de busqueda -----
    int tipo_situacion = 0; // 0: <N/A> 1: dz~=0 2: abs(m)<=1 3: abs(m)>1
    VECTOR r; // Proyeccion de Rayo->direccion en el plano <x, y>
    double m=0; // Pendiente de la recta definida por r
    double b=0; // La recta es f_de_y = m*x + b ... 

    arr_debug_x.elim();
    arr_debug_y.elim();

    //- Miro si la situacion es de tipo 1 -
    r = Rayo->direccion;
    r.normalizar();
    r.z = 0; // OJO: ESTA PROYECCION SUPONE QUE EL TERRENO ESTA EN XY...
             //      LO CUAL SIEMPRE ES CIERTO
    if ( r.norma() < 5*EPSILON ) {
        tipo_situacion = 1;
      #ifdef DEBUG_TERRENO
        color_debug.r = 1; color_debug.g = 0; color_debug.b = 0;
      #endif
    }

    //- Miro si la situacion es de tipo 2 o 3 -
    if ( !tipo_situacion ) {
        r.normalizar();
        if ( fabs(r.x) >= fabs(r.y) ) {
            tipo_situacion = 2;
          #ifdef DEBUG_TERRENO
            color_debug.r = 0; color_debug.g = 1; color_debug.b = 1;
          #endif
          }
          else {
            tipo_situacion = 3;
          #ifdef DEBUG_TERRENO
            color_debug.r = 1; color_debug.g = 0; color_debug.b = 1;
          #endif
        }
    }

    //- Ejecucion de las pruebas en casos de situacion 1 --------------------
    int x, y;

    if ( tipo_situacion == 1 ) {
        x = coord2index_x(Rayo->origen.x);
        y = coord2index_y(Rayo->origen.y);
        if ( x >= -1 && x <= _x_tam - 3 &&
             y > 0 && y <= _y_tam ) {
            arr_debug_x.anx(x+2); arr_debug_y.anx(y-1);
        }
    }
    //- Ejecucion de las pruebas en casos de situacion 2 --------------------
    double f_de_x;

    if ( tipo_situacion == 2 ) {
        m = r.y / r.x;
        b = Rayo->origen.y - m*Rayo->origen.x;
        for ( x = 1; x < _x_tam - 2; x++ ) {
            f_de_x = m * index2coord_x(x) + b;
            y = coord2index_y(f_de_x);
            if ( y >= 1 && y < _y_tam - 2 ) {
                arr_debug_x.anx(x); arr_debug_y.anx(y);
            }
            if ( y >= 2 && y < _y_tam - 2 ) {
                arr_debug_x.anx(x); arr_debug_y.anx(y-1);
            }
            if ( y >= 3 && y < _y_tam - 2 ) {
                arr_debug_x.anx(x); arr_debug_y.anx(y-2);
            }
        }
    }

    //- Ejecucion de las pruebas en casos de situacion 3 --------------------
    double f_de_y;

    if ( tipo_situacion == 3 ) {
        m = r.x / r.y;
        b = Rayo->origen.x - m*Rayo->origen.y;
        for ( y = 1; y < _y_tam - 2; y++ ) {
            f_de_y = m * index2coord_y(y) + b;
            x = coord2index_x(f_de_y);
            if ( x >= 0 && x < _x_tam - 3 ) {
                arr_debug_x.anx(x+1); arr_debug_y.anx(y);
            }
            if ( x >= -1 && x < _x_tam - 4 ) {
                arr_debug_x.anx(x+2); arr_debug_y.anx(y);
            }
            if ( x >= -2 && x < _x_tam - 5 ) {
                arr_debug_x.anx(x+3); arr_debug_y.anx(y);
            }
        }
    }

    //= FASE 2 ==============================================================

    //-----------------------------------------------------------------------
    double T = 0, distancia_minima = INFINITO, t;
    VECTOR p, n;

#ifdef NONONO
    // OJO: La idea de la FASE 1 es no hacer esto asi de exhaustivo...
    for ( x = 1; x < _x_tam - 2; x++ ) {
        for ( y = 1; y < _y_tam - 2; y++ ) {
            t = interseccion_celda(Rayo, p, n, x, y);
            if ( (t > EPSILON) && (t < distancia_minima) ) {
                distancia_minima = t;
                T = t;
                punto = p;
                normal = n;
            }
        }
    }
#endif
//#ifdef NONONO
    // ... PERO DESAFORTUNADAMENTE TODAVIA NO FUNCIONA BIEN LA PRE-SELECCION,
    // REVISELO CON EL RAYTRACER SOBRE EL EJEMPLO raytrace3.aqz Y SE HARA
    // EVIDENTE...
    int i;

    for ( i = 0; i < arr_debug_x.tam(); i++ ) {
        x = arr_debug_x[i];
        y = arr_debug_y[i];
        t = interseccion_celda(Rayo, p, n, x, y);
        if ( (t > EPSILON) && (t < distancia_minima) ) {
            distancia_minima = t;
            T = t;
            punto = p;
            normal = n;
        }
    }
//#endif

    return T;
}

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