octree_n.C

Ir a la documentación de este archivo.

//===========================================================================
//= octree_n.cc                                           Diciembre de 1999 =
//=-------------------------------------------------------------------------=
//= Definicion de la clase estructural de OCTREE (NODO_OCTREE)              =
//=-------------------------------------------------------------------------=
//= 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 "toolkits/geom/geometria.h"

#ifdef VEL_ROSITA
    #include "toolkits/geom/octree_n.h"
#endif

#include <stdlib.h>

//===========================================================================
//= Variables globales                                                      =
//===========================================================================

int DIRECCIONES_octantes[8][3] = {
    {1, 1, 1},
    {-1, 1, 1},
    {1, -1, 1},
    {-1, -1, 1},
    {1, 1, -1},
    {-1, 1, -1},
    {1, -1, -1},
    {-1, -1, -1}
};

//===========================================================================
//= Clase NODO_OCTREE                                                       =
//===========================================================================

void
NODO_OCTREE::init(void)
{
    relleno = FALSE;
    hijos = NULL;
}

void
NODO_OCTREE::elim(void)
{
    int i;

    if ( hijos ) {
        for ( i = 0; i < 8; i++ ) {
            hijos[i].elim();
        }
    }

    if ( hijos ) {
        // OJO: Es importante usar free y no delete porque inexplicablemente
        //      esto se moria en la destructora (que ahora ni existe ni se
        //      llama)
        free((void *)hijos);
        hijos = NULL;
    }
}

void
NODO_OCTREE::compactar(void)
{
    if ( !hijos ) return;

    int i;
    BOOLEAN inicial = hijos[0].relleno;

    for ( i = 0; i < 8; i++ ) {
        if ( hijos[i].hijos ||
             hijos[i].relleno != inicial ) return;
    }
    elim();
    relleno = inicial;
}

void
NODO_OCTREE::calcular(GEOMETRIA *Fuente, int nivel, VECTOR origen, double lado)
{
    //- Caso trivial --------------------------------------------------------
    if ( nivel == 0 ) {
        if ( Fuente->clasificar_punto(origen) == 1 ) {
            relleno = TRUE;
          }
          else {
            relleno = FALSE;
        }
        return;
    }

    //- Caso recursivo ------------------------------------------------------
    int i;
    VECTOR sub_origen;

    // OJO: Es importante no usar new, y LLAMAR EXPLICITAMENTE a `init`
    //      (la constructora)... 
    hijos = (NODO_OCTREE *) malloc(sizeof(NODO_OCTREE) * 8);
    for ( i = 0; i < 8; i++ ) {
        hijos[i].init();
    }

    for ( i = 0; i < 8; i++ ) {
        sub_origen.x = origen.x + DIRECCIONES_octantes[i][0] * (lado/4);
        sub_origen.y = origen.y + DIRECCIONES_octantes[i][1] * (lado/4);
        sub_origen.z = origen.z + DIRECCIONES_octantes[i][2] * (lado/4);
        hijos[i].calcular(Fuente, nivel-1, sub_origen, lado/2);
        hijos[i].compactar();
    }
    compactar();
}

#ifdef GL_ENABLED
void
NODO_OCTREE::pintar_gl(VECTOR origen, double lado)
{
    //- Caso trivial --------------------------------------------------------
    if ( !hijos ) {
        if ( relleno ) {
            glPushMatrix();
            glTranslated(origen.x, origen.y, origen.z);
            pintar_cubo_solido(lado);
            glPopMatrix();
        }
        return;
    }

    //- Caso recursivo ------------------------------------------------------
    int i;
    VECTOR sub_origen;

    for ( i = 0; i < 8; i++ ) {
        sub_origen.x = origen.x + DIRECCIONES_octantes[i][0] * (lado/4);
        sub_origen.y = origen.y + DIRECCIONES_octantes[i][1] * (lado/4);
        sub_origen.z = origen.z + DIRECCIONES_octantes[i][2] * (lado/4);
        hijos[i].pintar_gl(sub_origen, lado/2);
    }
}
#endif // GL_ENABLED

void
NODO_OCTREE::leer(FILE *fd)
{
    char d = leer_elemento_octree(fd);

    //- Caso trivial --------------------------------------------------------
    init();
    if ( d == 0 ) {
        relleno = TRUE;
        return;
    }
    if ( d == 1 ) {
        relleno = FALSE;
        return;
    }

    //- Caso recursivo ------------------------------------------------------
    int i;

    // OJO: Es importante no usar new, y LLAMAR EXPLICITAMENTE a `init`
    //      (la constructora)... 
    hijos = (NODO_OCTREE *) malloc(sizeof(NODO_OCTREE) * 8);
    for ( i = 0; i < 8; i++ ) {
        hijos[i].init();
        hijos[i].leer(fd);
    }
    //leer_elemento_octree(FILE *fd);
}

void
NODO_OCTREE::escribir(FILE *fd)
{
    //- Caso trivial --------------------------------------------------------
    if ( !hijos ) {
        if ( relleno ) {
            escribir_elemento_octree(fd, 0);
        }
        else {
            escribir_elemento_octree(fd, 1);
        }
        return;
    }

    //- Caso recursivo ------------------------------------------------------
    int i;

    escribir_elemento_octree(fd, 2);
    for ( i = 0; i < 8; i++ ) {
        hijos[i].escribir(fd);
    }
    //escribir_elemento_octree(fd, 3);
}

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