campo.C

Ir a la documentación de este archivo.

//===========================================================================
//= campo.cc                                         Julio - agosto de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase CAMPO                                          =
//=-------------------------------------------------------------------------=
//= 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 <stdio.h>
#include <string.h>

#include <math.h>
#include "core/campos/campo.h"

//===========================================================================
//===========================================================================

CAMPO::CAMPO()
{
    strcpy(_nombre, "<ANONIMO>");
}

char *
CAMPO::nombre(void)
{
    return _nombre;
}

void
CAMPO::set_nombre(const char *n)
{
    strcpy(_nombre, n);
}


//===========================================================================
//===========================================================================

CAMPO_VECTORIAL::CAMPO_VECTORIAL() : CAMPO()
{
    ;
}

CAMPO_VECTORIAL::~CAMPO_VECTORIAL()
{
    ;
}

//===========================================================================
//= Clase CAMPO_V_CONSTANTE                                                 =
//===========================================================================

CAMPO_V_CONSTANTE::CAMPO_V_CONSTANTE(VECTOR val_inic) : CAMPO_VECTORIAL()
{
    _valor = val_inic;
}

CAMPO_V_CONSTANTE::~CAMPO_V_CONSTANTE()
{
    ;
}

VECTOR
CAMPO_V_CONSTANTE::valor(VECTOR /*posicion*/)
{
    return _valor;
}

void
CAMPO_V_CONSTANTE::set_valor(VECTOR nuevo_valor)
{
    _valor = nuevo_valor;
}


//===========================================================================
//= Clase CAMPO_V_ALMACENADO                                                =
//===========================================================================

CAMPO_V_ALMACENADO::CAMPO_V_ALMACENADO(char * /*archivo*/, VECTOR min, VECTOR max)
: CAMPO_VECTORIAL()
{
    DATa = NULL;
    escala.x = escala.y = escala.z = 1.0;
    x_tam = y_tam = z_tam = 0;
    //
    //
    offset = min;
    escala = (max - min);
    escala.x /= (double)x_tam;
    escala.y /= (double)y_tam;
    escala.z /= (double)z_tam;
}

#define VERIFICAR(x) \
    if ( !(x) ) { \
        fprintf(stderr, "<CAMPO_VECTORIAL> ERROR: Memoria insuficiente!"); \
        fflush(stderr); \
        return; \
    }

#define VERIFICARF(x) \
    if ( !(x) ) { \
        fprintf(stderr, "<CAMPO_VECTORIAL> ERROR: Memoria insuficiente!"); \
        fflush(stderr); \
        return FALSE; \
    }

CAMPO_V_ALMACENADO::CAMPO_V_ALMACENADO(int x, int y, int z, 
                                       VECTOR min, VECTOR max)
{
    int i, j, k;

    DATa = NULL;
    escala.x = escala.y = escala.z = 1.0;
    x_tam = x;
    y_tam = y;
    z_tam = z;

    //- Cree un campo con [x_tam][y_tam][z_tam] elementos ------------------
    DATa = new VECTOR** [x_tam];
    VERIFICAR(DATa);
    for ( i = 0; i < x_tam; i++ ) {
        DATa[i] = new VECTOR* [y_tam];
        VERIFICAR(DATa[i]);
        for ( j = 0; j < y_tam; j++ ) {
            DATa[i][j] = new VECTOR[z_tam];
            VERIFICAR(DATa[i][j]);
            for ( k = 0; k < z_tam; k++ ) {
              //DATa[i][j][k].x = 10*((double)(i+1)/4);
              //DATa[i][j][k].y = 10*((double)(j+1)/4);
              //DATa[i][j][k].z = 0;
                if ( i < x_tam/2 ) {
                    DATa[i][j][k].x = 10;
                  }
                  else {
                    DATa[i][j][k].x = -10;
                }
                if ( j < y_tam/2 ) {
                    DATa[i][j][k].y = 10;
                  }
                  else {
                    DATa[i][j][k].y = -10;
                }
                DATa[i][j][k].z = 0;
            }
        }
    }

    //- Dada el dominio [min]-[max] en R3, determine escala y offset ---------
    offset = min;
    escala = (max - min);
    escala.x /= (double)x_tam;
    escala.y /= (double)y_tam;
    escala.z /= (double)z_tam;
}

CAMPO_V_ALMACENADO::~CAMPO_V_ALMACENADO()
{
    elim();
}

void
CAMPO_V_ALMACENADO::elim(void)
{
    int i, j;

    if ( !DATa ) return;

    for ( i = 0; i < x_tam; i++ ) {
        for ( j = 0; j < y_tam; j++ ) {
            delete DATa[i][j];
        }
        delete DATa[i];
    }
    delete DATa;

    x_tam = y_tam = z_tam = 0;
    DATa = NULL;
}

BOOLEAN
CAMPO_V_ALMACENADO::leer(char *archivo)
{
    FILE *fd;
    int i, j, k;

    elim();

    fd = fopen(archivo, "rb");
    if ( !fd ) {
        fprintf(stderr, "<CAMPO_V_ALMACENADO> ERROR: No se puede abrir el\n"
            "archivo \"%s\".\n", archivo);
        fflush(stderr);
        return FALSE;
    }

    lea_WORD_BE(&x_tam, fd);
    lea_WORD_BE(&y_tam, fd);
    lea_WORD_BE(&z_tam, fd);

    printf("Leo un campo de %d x %d x %d elementos!\n", x_tam, y_tam, z_tam);
    fflush(stdout);

    DATa = new VECTOR** [x_tam];
    VERIFICARF(DATa);
    for ( i = 0; i < x_tam; i++ ) {
        DATa[i] = new VECTOR* [y_tam];
        VERIFICARF(DATa[i]);
        for ( j = 0; j < y_tam; j++ ) {
            DATa[i][j] = new VECTOR[z_tam];
            VERIFICARF(DATa[i][j]);
            for ( k = 0; k < z_tam; k++ ) {
                lea_WORD_BE(&DATa[i][j][k].x, fd);
                lea_WORD_BE(&DATa[i][j][k].y, fd);
                lea_WORD_BE(&DATa[i][j][k].z, fd);
                DATa[i][j][k] = DATa[i][j][k];
            }
        }
    }


    fclose(fd);

    return TRUE;
}

BOOLEAN
CAMPO_V_ALMACENADO::grabar(char *archivo)
{
    FILE *fd;
    int i, j, k;

    fd = fopen(archivo, "wb");
    if ( !fd ) {
        fprintf(stderr, "<CAMPO_V_ALMACENADO> ERROR: No se puede abrir el\n"
            "archivo \"%s\".\n", archivo);
        fflush(stderr);
        return FALSE;
    }

    fwrite(&x_tam, sizeof(int), 1, fd);
    fwrite(&y_tam, sizeof(int), 1, fd);
    fwrite(&z_tam, sizeof(int), 1, fd);

    for ( i = 0; i < x_tam; i++ ) {
        for ( j = 0; j < y_tam; j++ ) {
            for ( k = 0; k < z_tam; k++ ) {
                fwrite(&DATa[i][j][k].x, sizeof(double), 1, fd);
                fwrite(&DATa[i][j][k].y, sizeof(double), 1, fd);
                fwrite(&DATa[i][j][k].z, sizeof(double), 1, fd);
            }
        }
    }

    fclose(fd);

    return TRUE;
}

VECTOR
CAMPO_V_ALMACENADO::valor(VECTOR posicion)
{
    VECTOR a(0, 0, 0);

    posicion = posicion - offset;

    int i = ((int)floor(posicion.x/escala.x));
    int j = ((int)floor(posicion.y/escala.y));
    int k = ((int)floor(posicion.z/escala.z));

    if ( i < 0 || j < 0 || k < 0 ||
         i >= x_tam || j >= y_tam || k >= z_tam ) {
        return a;
    }
    return DATa[i][j][k];

    //printf("matriz[%d][%d][%d] = <%.2f, %.2f, %.2f>\n", i, j, k,
    //    DATa[i][j][k].x, DATa[i][j][k].y, DATa[i][j][k].z);
    //fflush(stdout);

    //return a;
}

void
CAMPO_V_ALMACENADO::cambiar_posicion(int i, int j, int k, VECTOR nuevo_valor)
{
    if ( i < 0 || j < 0 || k < 0 || i >= x_tam || j >= y_tam || k >= z_tam ) {
        return;
    }
    if ( !DATa ) return;
    DATa[i][j][k] = nuevo_valor;
}


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