vs_float.C

Ir a la documentación de este archivo.

//===========================================================================
//= vs_float.cc   Junio de 1998, revisado y extendido desde octubre de 1999 =
//=                                             y seguido en enero del 2000 =
//=-------------------------------------------------------------------------=
//= Definicion de clases de visores de sensores float                       =
//=-------------------------------------------------------------------------=
//= 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"
#include "jed_gl.h"

#include "framework/visual/visor.h"

#ifdef VEL_ROSITA
    #include "framework/visual/v_sensor.h"
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//===========================================================================
//= Constantes y macros                                                     =
//===========================================================================

#define ESPERO(tipo, msg) \
    if ( tipo_token != (tipo) ) { \
        fprintf(stderr, "<VISOR_SENSOR_FLOAT> " \
          "ERROR: Esperaba %s y recibi [%s].\n", \
          (msg), cad); fflush(stderr);  return FALSE; \
    }

#define VERIFICAR(c) \
    if ( !(c) ) {\
        fprintf(stderr, \
            "<VISOR_SENSOR_FLOAT> " \
            "ERROR: No se pudo crear un objeto dinamico!\n");\
        fflush(stderr);\
        exit(1);\
    }

#define DATA_PERCENT() ((data[pos]-min_val)/(max_val-min_val))
#define DATA_I_PERCENT(i) ((data[(i)]-min_val)/(max_val-min_val))

//===========================================================================
//= Clase VISOR_SENSOR_FLOAT                                           =
//===========================================================================

VISOR_SENSOR_FLOAT::VISOR_SENSOR_FLOAT() : VISOR_SENSOR()
{
    Sensor = NULL;
    _nombre_variable = NULL;
    _tipo = 1;
    min_val = 0;
    max_val = 1.0;

    //- Configuracion del vector de estado ----------------------------------
    data = NULL;
    configurar_vector_de_estado(1);
}

VISOR_SENSOR_FLOAT::VISOR_SENSOR_FLOAT(int nuevo_tipo, float min, float max)
{
    Sensor = NULL;
    _nombre_variable = NULL;
    _tipo = nuevo_tipo;
    min_val = min;
    max_val = max;

    //- Configuracion del vector de estado ----------------------------------
    data = NULL;
    configurar_vector_de_estado(1);
}

VISOR_SENSOR_FLOAT::~VISOR_SENSOR_FLOAT()
{
    if ( data ) delete data;
}

void
VISOR_SENSOR_FLOAT::configurar_vector_de_estado(int tam)
{
    if ( data ) delete data;

    pos = 0;
    data = new float[tam];
    if ( !data ) {
        _tipo = 0;
        tam_data = 0;
    }
    tam_data = tam;
    data[pos] = min_val;
}

#ifdef GL_ENABLED
void
VISOR_SENSOR_FLOAT::pintar_gl(void)
{
    //-----------------------------------------------------------------------
    // Calcule la nueva posicion a manejar
    pos++;
    if ( pos >= tam_data ) {
        pos = 0;
    }

    // Actualice el valor de la posicion actual
    if ( Sensor ) data[pos] = Sensor->evaluar();
    else data[pos] = 0;

    if ( data[pos] < min_val ) data[pos] = min_val;
    if ( data[pos] > max_val ) data[pos] = max_val;

    //-----------------------------------------------------------------------
    float split1_tam = 1.75f, x_split2 = 0.85f;
    int i;

    camara.subbillboard_gl(tam_grilla,
                           x_grilla, y_grilla, dx_grilla, dy_grilla,
                           cuadre_grilla);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glShadeModel(GL_FLAT);
    ACTIVAR_TRANSPARENCIA(_transparencia);

switch ( _tipo ) {
  //---------------------------------------------------------------------------
  case 1: // Cuadro de altura proporcional al valor
    // OJO: Esto deberia venir de una paleta!
    glColor4f(1, 0, 0, (float)_transparencia);
    jvs_cuadro_gl(-1, -1, 2, 2, DATA_PERCENT(), _transparencia);
    break;
  //---------------------------------------------------------------------------
  case 2: // Cuadro de color en escala
    glColor4f(DATA_PERCENT(), 0, 1 - DATA_PERCENT(), (float)_transparencia);
    jvs_cuadro_gl(-1, -1, split1_tam, 2, 1.0, _transparencia);
    jvs_pintar_paleta(x_split2, -1, 0.15f, 2, _transparencia);
    break;
  //---------------------------------------------------------------------------
  case 3: // Grafica de valor contra tiempo   
    glColor4f(1, 1, 1, (float)_transparencia);
    glBegin(GL_LINES);
        glVertex2f(-1, -1); glVertex2f(-1, 1);
        glVertex2f(-1, -1); glVertex2f(1, -1);
    glEnd();

    glColor4f(1, 1, 0, (float)_transparencia);
    glBegin(GL_LINE_STRIP);
    for ( i = 0; i < tam_data && i <= pos; i++ ) {
        glVertex2f(-1 + 2*(float)i/tam_data, 2*DATA_I_PERCENT(i)-1);
        glVertex2f(-1 + 2*(float)(i+1)/tam_data, 2*DATA_I_PERCENT(i)-1);
    }
    glEnd();
    break;

  //---------------------------------------------------------------------------
  case 4: // Grafica de valor contra tiempo con escala
    glColor4f(1, 1, 1, (float)_transparencia);
    glBegin(GL_LINES);
        glVertex2f(-1, -1); glVertex2f(-1, 1);
        glVertex2f(-1, -1); glVertex2f(1, -1);
    glEnd();

    glBegin(GL_LINES);
    for ( i = 0; i < tam_data && i <= pos; i++ ) {
        glColor4f(DATA_I_PERCENT(i), 0, 1 - DATA_I_PERCENT(i), (float)_transparencia);
        glVertex2f(-1 + 2*((float)i)/tam_data, -1);
        glVertex2f(-1 + 2*((float)i+1)/tam_data, 2*DATA_I_PERCENT(i)-1);
    }
    glEnd();
    break;

  //---------------------------------------------------------------------------
  default: // Traza una X para indicar que algo no esta bien...
    glColor3f(1.0f, 1.0f, 1.0f);
    glBegin(GL_LINES);
        glVertex2f(-1, -1);     glVertex2f(1, 1);
        glVertex2f(-1, 1);      glVertex2f(1, -1);
    glEnd();
    break;
  //---------------------------------------------------------------------------
}

}
#endif // GL_ENABLED

int
VISOR_SENSOR_FLOAT::tipo(void)
{
    return T_FLOAT;
}

//= SERVICIOS DE PERSISTENCIA ===============================================

BOOLEAN
VISOR_SENSOR_FLOAT::leer(TOKENIZADOR *Sabiondo)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos;

    //- Ejecute el parser especifico de la COSA_RIGIDA -----------------
    pos = 1;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
            case 1:
              ESPERO(TK_CADENA, "un nombre de variable de estado");
              des_comille(cad);
              _nombre_variable = new char [strlen(cad) + 1];
              VERIFICAR(_nombre_variable);
              strcpy(_nombre_variable, cad);
              pos++;
              break;
            case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
            default:
              if ( tipo_token == TK_CERRAR ) break;
              ESPERO(TK_IDENTIFICADOR, "un identificador (3)");
              if ( strcmp(cad, "tipo") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero");
                  _tipo = atoi(cad);
                  if ( _tipo == 3 || _tipo == 4 ) {
                      configurar_vector_de_estado(100);
                  }
                }
                else if ( strcmp(cad, "min") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero");
                  min_val = (float)atof(cad);
                }
                else if ( strcmp(cad, "max") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero");
                  max_val = (float)atof(cad);
                }
                if ( !leer_sensor(Sabiondo, cad) ) {
                  return FALSE;
                }
              ;
              break;
        }
    }

    return TRUE;
}

BOOLEAN
VISOR_SENSOR_FLOAT::asociar_sensor(SENSOR *S)
{
    if ( S->tipo() != T_FLOAT ) return FALSE;
    Sensor = (SENSOR_FLOAT *)S;
    Sensor->sensar();
    return TRUE;
}

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