vtkload.C

Ir a la documentación de este archivo.

//===========================================================================
//= vtkload.C                                                 Marzo de 2002 =
//=-------------------------------------------------------------------------=
//= Sistema de lectura de archivos en formato de geometria VTK.             =
//=-------------------------------------------------------------------------=
//= 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").                                         =
//=-------------------------------------------------------------------------=
//= Modificado por Oscar J. Chavarro G.           oscarchavarro@hotmail.com =
//===========================================================================

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "toolkits/util/vtkload.h"
#include "matriz4.h"
#include "arreglo.cc"

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

//#define DEBUG_VTK 1

#define TAM_BUFFER 256

#define COMPARAR_MM()                           \
        if ( v.x < Min->x ) Min->x = v.x;       \
        if ( v.y < Min->y ) Min->y = v.y;       \
        if ( v.z < Min->z ) Min->z = v.z;       \
        if ( v.x > Max->x ) Max->x = v.x;       \
        if ( v.y > Max->y ) Max->y = v.y;       \
        if ( v.z > Max->z ) Max->z = v.z;

#define LEER_LINEA()                                                     \
    if ( !fgets(buffer, TAM_BUFFER, fd) ) {                              \
        fprintf(stderr, "<ESCENA_VTK> Fin de archivo prematuro leyendo " \
                "VTK.\n");                                               \
        fflush(stderr);                                                  \
        return FALSE;                                                    \
    }


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

ESCENA_VTK::ESCENA_VTK(char *archivo)
{
    _nombre_de_archivo = new char[strlen(archivo) + 1];
    strcpy(_nombre_de_archivo, archivo);
    modo_binario = FALSE;
}

ESCENA_VTK::~ESCENA_VTK()
{
    delete _nombre_de_archivo;
}

void
ESCENA_VTK::lower_case(char *cad)
{
    int i;
    char *ptr;

    for ( i = 0, ptr = cad; *ptr != '\0' && i < 256; ptr++,i++ ) {
        *ptr = tolower(*ptr);
    }
}

void
ESCENA_VTK::leer_float_BE(FILE *fd, float *f)
{
    DWORD o, d;

    fread(&o, sizeof(DWORD), 1, fd);  

#ifndef AQZ_BIG_ENDIAN
    BYTE *a, *b;

    a = (BYTE*)(&o);
    b = (BYTE*)(&d);

    b[0] = a[3];
    b[1] = a[2];
    b[2] = a[1];
    b[3] = a[0];
#endif
#ifdef AQZ_BIG_ENDIAN
    d = o;
#endif

    (*f) = *((float *)(&d));
  #ifdef DEBUG_VTK
    #ifdef AQZ_BIG_ENDIAN
    BYTE *a = (BYTE *)(&o);
    #endif
    printf("%02X%02X %02X%02X -> %f\n", a[0], a[1], a[2], a[3], *f);
  #endif
}

void
ESCENA_VTK::leer_DWORD_BE(FILE *fd, DWORD *i)
{
    DWORD o;

    fread(&o, sizeof(DWORD), 1, fd);  

#ifndef AQZ_BIG_ENDIAN
    BYTE *a, *b;

    a = (BYTE*)(&o);
    b = (BYTE*)(i);

    b[0] = a[3];
    b[1] = a[2];
    b[2] = a[1];
    b[3] = a[0];
#endif

#ifdef AQZ_BIG_ENDIAN
    BYTE *a, *b;

    a = (BYTE*)(&o);
    b = (BYTE*)(i);

    b[0] = a[0];
    b[1] = a[1];
    b[2] = a[2];
    b[3] = a[3];
#endif

  #ifdef DEBUG_VTK
    printf("%02X%02X %02X%02X ", a[0], a[1], a[2], a[3]);
  #endif
}

BOOLEAN
ESCENA_VTK::leer_pd(FILE *fd, long int tam, MESH *Geometria)
{
    //-----------------------------------------------------------------------
    VECTOR n;
    float f;
    char buffer[TAM_BUFFER];
    long int i;
    VERTICE_GL *Vector;
    long int tv;

    if ( !fgets(buffer, TAM_BUFFER, fd) ) {
        return FALSE;
    }

    if ( !strstr(buffer, "normals float") ) {
        fprintf(stderr, "<ESCENA_VTK> Atributos distintos a normales en "
                "float\n    no se soportan!\n"); fflush(stderr);
        return FALSE;
    }

    Geometria->get_vertices(&Vector, &tv);

    VECTOR nn;

    for ( i = 0; i < tam && tam <= tv; i++ ) {
        leer_float_BE(fd, &f);   n.x = f;
        leer_float_BE(fd, &f);   n.z = -f;
        leer_float_BE(fd, &f);   n.y = f;

        nn.x = (float)n.x;
        nn.y = (float)n.y;
        nn.z = (float)n.z;
        //nn.z = nn.z / 9;
        nn.normalizar();

        Vector[i].nx = (float)nn.x;
        Vector[i].ny = (float)nn.y;
        Vector[i].nz = (float)nn.z;

    }
    fseek(fd, 1, SEEK_CUR);

    //-----------------------------------------------------------------------

    return TRUE;
}

BOOLEAN
ESCENA_VTK::leer_tiras(FILE *fd, long int /*a*/, long int b, MESH *Geometria)
{
    //-----------------------------------------------------------------------
    if ( !modo_binario ) {
        fprintf(stderr, "<ESCENA_VTK> - Modo ASCII no soportado.\n");
        fflush(stderr);
        return FALSE;
    }

    //- Leer los datos ------------------------------------------------------
    DWORD k;
    int i;
    ARREGLO <DWORD> data(100);

    for ( i = 0; i < b; i++ ) {
        //printf("%04d -> [ ", i+1); 
        leer_DWORD_BE(fd, &k);
        //printf("]: %ld\n", k); fflush(stdout);
        if ( (long int)k > Geometria->num_vertices() ) {
            fprintf(stderr, "<ESCENA_VTK> Dato fuera de rango!");
            fflush(stdout);
            return FALSE;
        }
        data.anx(k);
    }
    fseek(fd, 1, SEEK_CUR);

    //- Procesar los datos --------------------------------------------------
    DWORD delta_tam;
    #ifdef DEBUG_VTK
    DWORD acum = 0;
    #endif
    //TRIANGULO_GL dummy;
    COLOR ambient, diffuse, specular;

    //- Felizmente es barato tener oro en la realidad virtual :-)
    ambient.r = ambient.g = ambient.b = 0.2f;
    diffuse.r = 0.85f;    diffuse.g = 0.85f;    diffuse.b = 0.1f;
    specular.r = specular.g = specular.b = 1.0;
    ambient.alpha = diffuse.alpha = specular.alpha = 1.0;
    Geometria->anx_material(ambient, diffuse, specular, "WG_DEFAULT", "", 1);
    //Geometria->anx_triangle(dummy, "WG_DEFAULT");
    void anx_material(COLOR, COLOR, COLOR, char *, char *, int);

    for ( i = 0; i < data.tam(); i++ ) {
        delta_tam = data[i];
      #ifdef DEBUG_VTK
        acum++;
        printf("       . Tira %ld: %ld elementos.\n", acum, delta_tam);
        fflush(stdout);
      #endif
        for ( k = 0; k < delta_tam; k++ ) {
            i++;
            Geometria->anx_indice_tira(data[i]);
        }
        Geometria->anx_tira();
    }
    return TRUE;
}

BOOLEAN
ESCENA_VTK::leer_puntos(FILE *fd, char *tipo, long int n, MESH *Geometria, 
                        VECTOR *Min, VECTOR *Max)
{
    //-----------------------------------------------------------------------
    int i;
    VERTICE_GL v;
    float f;

    lower_case(tipo);

    if ( strcmp(tipo, "float") == 0 ) {
        if ( !modo_binario ) {
            fprintf(stderr, "<ESCENA_VTK> El modo ASCII "
                  "aun no se soporta!\n"); 
            fflush(stderr);
            return FALSE;
        }
      #ifdef DEBUG_VTK
        printf("      . Leo %ld vertices float en modo binario!\n", n);
      #endif
        
        for ( i = 0; i < n; i++ ) {
            //printf("[%04d] ", i+1);
            leer_float_BE(fd, &f);   v.x = f/100;
            leer_float_BE(fd, &f);   v.z = -f/100;
            leer_float_BE(fd, &f);   v.y = f/100;
            v.nx = 0;
            v.ny = 0;
            v.nz = 1;

            //v.z *= 9;

            COMPARAR_MM();
            Geometria->anx_vertex(v);


            //printf(" - < %.2f %.2f %.2f >\n", v.x, v.y, v.z);

        }
        fseek(fd, 1, SEEK_CUR);
      }
      else {
        fprintf(stderr, "<ESCENA_VTK> El tipo de datos \"%s\" para "
          "vertices aun no se soporta!\n", tipo); 
        fflush(stderr);
        return FALSE;
      }
    ;

    //-----------------------------------------------------------------------
    return TRUE;

#ifdef NONONO

    vtkDataArray *array;

    if ( ! strncmp(tipo, "bit", 3) )
    {
        array = vtkBitArray::New();
        array->SetNumberOfComponents(numComp);
        unsigned char *ptr=((vtkBitArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            char line[256];
            this->IS->getline(line,256);
            this->IS->read((char *)ptr,sizeof(unsigned char)*(numTuples*numComp+7)/8);
            if (this->IS->eof())
            {
                vtkErrorMacro(<<"Error reading binary bit array!");
                free(tipo);
                return NULL;
            }
        }
        else 
        {
            int b;
            for (int i=0; i<numTuples; i++)
            {
                for (int j=0; j<numComp; j++)
                {
                    if ( !this->Read(&b) )
                    {
                        vtkErrorMacro(<<"Error reading ascii bit array! tuple: " << i << ", component: " << j);
                        free(tipo);
                        return NULL;
                    }
                    else
                    {
                        ((vtkBitArray *)array)->SetValue(i*numComp+j,b);
                    }
                }
            }
        }
    }
  
    else if ( ! strncmp(tipo, "char", 4) )
    {
        array = vtkCharArray::New();
        array->SetNumberOfComponents(numComp);
        char *ptr = ((vtkCharArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "unsigned_char", 13) )
    {
        array = vtkUnsignedCharArray::New();
        array->SetNumberOfComponents(numComp);
        unsigned char *ptr = ((vtkUnsignedCharArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "short", 5) )
    {
        array = vtkShortArray::New();
        array->SetNumberOfComponents(numComp);
        short *ptr = ((vtkShortArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap2BERange(ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "unsigned_short", 14) )
    {
        array = vtkUnsignedShortArray::New();
        array->SetNumberOfComponents(numComp);
        unsigned short *ptr = ((vtkUnsignedShortArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap2BERange((short *)ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "int", 3) )
    {
        array = vtkIntArray::New();
        array->SetNumberOfComponents(numComp);
        int *ptr = ((vtkIntArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap4BERange(ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "unsigned_int", 12) )
    {
        array = vtkUnsignedIntArray::New();
        array->SetNumberOfComponents(numComp);
        unsigned int *ptr = ((vtkUnsignedIntArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap4BERange((int *)ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "long", 4) )
    {
        array = vtkLongArray::New();
        array->SetNumberOfComponents(numComp);
        long *ptr = ((vtkLongArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap4BERange((int *)ptr,numTuples*numComp);
        }

        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "unsigned_long", 13) )
    {
        array = vtkUnsignedLongArray::New();
        array->SetNumberOfComponents(numComp);
        unsigned long *ptr = ((vtkUnsignedLongArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap4BERange((int *)ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "float", 5) )
    {
        array = vtkFloatArray::New();
        array->SetNumberOfComponents(numComp);
        float *ptr = ((vtkFloatArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
            vtkByteSwap::Swap4BERange(ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else if ( ! strncmp(tipo, "double", 6) )
    {
        array = vtkDoubleArray::New();
        array->SetNumberOfComponents(numComp);
        double *ptr = ((vtkDoubleArray *)array)->WritePointer(0,numTuples*numComp);
        if ( this->FileTipo == VTK_BINARY )
        {
            ReadBinaryData(this->IS, ptr, numTuples, numComp);
                //      vtkByteSwap::Swap4BERange(ptr,numTuples*numComp);
        }
        else 
        {
            ReadASCIIData(this, ptr, numTuples, numComp);
        }
    }
  
    else 
    {
        vtkErrorMacro(<< "Unsupported data tipo: " << tipo);
        free(tipo);
        return NULL;
    }

    free(tipo);
#endif
}

BOOLEAN
ESCENA_VTK::leer_dataset(FILE *fd, MESH *Geometria, double *Escala_optima)
{
    //-----------------------------------------------------------------------
    // Esto es para calcular el factor de escala optima
    VECTOR min, max;

    min.x = INFINITO;
    min.y = INFINITO;
    min.z = INFINITO;
    max.x = -INFINITO;
    max.y = -INFINITO;
    max.z = -INFINITO;

    //-----------------------------------------------------------------------
    char *ptr;
    char buffer[TAM_BUFFER];
    long int num_elems1;
    long int num_elems2;

    ptr = strtok(NULL, " \t\n\r");
    if ( !ptr ) {
        fprintf(stderr,"<ESCENA_VTK> - Parse error (init).\n"); fflush(stderr);
        return FALSE;
    }
    lower_case(ptr);

    if ( strcmp(ptr, "polydata") != 0 ) {
        fprintf(stderr,"<ESCENA_VTK> - Parse error (polydata).\n");
        fflush(stderr);
        return FALSE;
    }

    while ( fgets(buffer, TAM_BUFFER, fd) ) {
        ptr = strtok(buffer, " \t\n\r");
        if ( !ptr ) {
            fprintf(stderr,"<ESCENA_VTK> - Parse error (data) en [%s].\n",
                    buffer);
            fflush(stderr); 
            break;
            //return FALSE;
        }
        lower_case(ptr);

        if ( strcmp(ptr, "field") == 0 ) {
            // 1
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento field\n");
          #endif
            fprintf(stderr,"<ESCENA_VTK> Segmento FIELD no soportado.\n");
            fflush(stderr);
            exit(1);
          }
          else if ( strcmp(ptr, "points") == 0 ) {
            // 2
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento points\n");
          #endif
            ptr = strtok(NULL, " \t\n\r");
            if ( !ptr ) {
                fprintf(stderr,"<ESCENA_VTK> - Parse error (points).\n");
                fflush(stderr); return FALSE;
            }
            num_elems1 = atol(ptr);
            ptr = strtok(NULL, " \t\n\r");
            if ( !ptr ) {
                fprintf(stderr,"<ESCENA_VTK> - Parse error (points).\n");
                fflush(stderr); return FALSE;
            }
          #ifdef DEBUG_VTK
            printf("      . Leyendo %ld vertices de tipo %s\n", 
                   num_elems1, ptr);
          #endif
            if ( !leer_puntos(fd, ptr, num_elems1, Geometria, &min, &max) ) {
                return FALSE;
            }
          }
          else if ( strcmp(ptr, "vertices") == 0 ) {
            // 3
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento \n");
          #endif
            fprintf(stderr,"<ESCENA_VTK> Segmento VERTICES no soportado.\n");
            fflush(stderr);
            exit(1);
          }
          else if ( strcmp(ptr, "lines") == 0 ) {
            // 4
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento lines\n");
          #endif
            fprintf(stderr,"<ESCENA_VTK> Segmento LINES no soportado.\n");
            fflush(stderr);
            exit(1);
          }
          else if ( strcmp(ptr, "polygons") == 0 ) {
            // 5
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento polygons\n");
          #endif
            fprintf(stderr,"<ESCENA_VTK> Segmento POLYGONS no soportado.\n");
            fflush(stderr);
            exit(1);
          }
          else if ( strcmp(ptr, "triangle_strips") == 0 ) {
            // 6
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento triangle_strips\n");
          #endif
            ptr = strtok(NULL, " \t\n\r");
            if ( !ptr ) {
                fprintf(stderr,"<ESCENA_VTK> - Parse error (tstrips).\n");
                fflush(stderr); return FALSE;
            }
            num_elems1 = atol(ptr);
            ptr = strtok(NULL, " \t\n\r");
            if ( !ptr ) {
                fprintf(stderr,"<ESCENA_VTK> - Parse error (tstrips).\n");
                fflush(stderr); return FALSE;
            }
            num_elems2 = atol(ptr);
          #ifdef DEBUG_VTK
            printf("      . Leyendo %ld tiras de triangulos (con %ld "
                   "referencias a vertices)\n", 
                   num_elems1, num_elems2);
          #endif
            if ( !leer_tiras(fd, num_elems1, num_elems2, Geometria) ) {
                return FALSE;
            }
          }
          else if ( strcmp(ptr, "cell_data") == 0 ) {
            // 7
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento cell_data\n");
          #endif
            fprintf(stderr,"<ESCENA_VTK> Segmento CELL_DATA no soportado.\n");
            fflush(stderr);
            exit(1);
          }
          else if ( strcmp(ptr, "point_data") == 0 ) {
            // 8
          #ifdef DEBUG_VTK
            printf("    - Leyendo segmento point_data\n");
          #endif
            ptr = strtok(NULL, " \t\n\r");
            if ( !ptr ) {
                fprintf(stderr,"<ESCENA_VTK> - Parse error (tstrips).\n");
                fflush(stderr); return FALSE;
            }
            num_elems1 = atol(ptr);
          #ifdef DEBUG_VTK
            printf("      . Leyendo %ld grupos de atributos de vertice.\n", 
                   num_elems1);
          #endif
            if ( !leer_pd(fd, num_elems1, Geometria) ) {
                return FALSE;
            }
          }
          else {
            // 9
            fprintf(stderr,
                    "<ESCENA_VTK> - Parse error (segmento [%s] invalido).\n",
                    ptr);
            fflush(stderr); return FALSE;
          }
        ;
    }
    
    //-----------------------------------------------------------------------
    VECTOR factor;
    factor = max - min;
    (*Escala_optima) = 5/factor.norma();
  #ifdef DEBUG_VTK
    printf("Min:  < %.2f %.2f %.2f >\n", min.x, min.y, min.z);
    printf("Max:  < %.2f %.2f %.2f >\n", max.x, max.y, max.z);
    printf("Escala optima = %.2f\n", *Escala_optima); fflush(stdout);
  #endif
    return TRUE;
}

BOOLEAN
ESCENA_VTK::leer(FILE *fd, MESH *Geometria, double *Escala_optima)
{
    //- Lea el encabezado VTK -----------------------------------------------
    char buffer[TAM_BUFFER];
    char *ptr;

  #ifdef DEBUG_VTK
    printf("<ESCENA_VTK> - Leyendo archivo VTK:\n");
    printf("  - Leyendo encabezado VTK:\n");
  #endif

    LEER_LINEA();
    if ( strncmp ("# vtk DataFile Version", buffer, 20) ) {
        fprintf(stderr, "<ESCENA_VTK> Formato de archivo VTK desconocido.\n");
        fflush(stderr);
        return FALSE;
    }
  #ifdef DEBUG_VTK
    printf("    - Formato reconocido.\n");
  #endif

    LEER_LINEA();
    ptr = strchr(buffer, '\n');
    if ( ptr ) ptr[0] = '\0';
  #ifdef DEBUG_VTK
    printf("    - El titulo de los datos es \"%s\".\n", buffer);
  #endif

    LEER_LINEA();
    lower_case(buffer);
    if ( strstr(buffer, "ascii") ) {
        modo_binario = FALSE;
      }
      else if ( strstr(buffer, "binary") ) {
        modo_binario = TRUE;
      }
      else {
        fprintf(stderr, "<ESCENA_VTK> Formato de archivo invalido "
                "<binario/ascci>.\n");
        fflush(stderr);
        return FALSE;
      }
    ;
  #ifdef DEBUG_VTK
    printf("    - El formato de representacion de datos es %s.\n", 
           modo_binario?"binario":"ascii");
  #endif

    //-----------------------------------------------------------------------
    LEER_LINEA();

    ptr = strtok(buffer, " \t\n\r");
    lower_case(ptr);
    if ( strcmp(ptr, "dataset") == 0 ) { 
      #ifdef DEBUG_VTK
        printf("  - Leyendo un archivo VTK con informacion tipo DATASET:\n");
      #endif    
        return leer_dataset(fd, Geometria, Escala_optima);
      }
      else if ( strcmp(ptr, "cell_data") == 0 ) { 
      #ifdef DEBUG_VTK
          printf("  - Leyendo un archivo VTK tipo CELL_DATA:\n"); 
      #endif    
      }
      else if ( strcmp(ptr, "point_data") == 0 ) { 
      #ifdef DEBUG_VTK
          printf("  - Leyendo un archivo VTK tipo POINT_DATA:\n");
      #endif    
      }
      else { 
        fprintf(stderr, "<ESCENA_VTK> - Error, bloque \"%s\" invalido.\n",
                ptr);
        fflush(stderr);
      }
    ;

    //-----------------------------------------------------------------------
    return TRUE;
}

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

void
importar_VTK(ESCENA_VTK *Lector, MESH *Geometria, double *Escala_optima)
{
    Geometria->set_nombre_de_archivo(Lector->_nombre_de_archivo);

    //- Exporte la geometria y la topologia de la malla ----------------------
  #ifdef DEBUG_VTK
    clrscr();
    printf("<ESCENA_VTK> -> Leyendo archivo VTK [%s]\n",
           Lector->_nombre_de_archivo); 
    fflush(stdout);
  #endif
 
    FILE *fd;

    fd = fopen(Lector->_nombre_de_archivo, "rb");
    if ( !fd ) {
        fprintf(stderr, "<importar_VTK> - Error leyendo VTK\n"); 
        fprintf(stderr, "  - No puedo abrir el archivo \"%s\".\n", 
                Lector->_nombre_de_archivo); 
        fflush(stderr);
        exit(1);
    }

    if ( !Lector->leer(fd, Geometria, Escala_optima) ) {
        fprintf(stderr, "<importar_VTK> - Error leyendo VTK\n"); 
        fflush(stderr);
        //exit(1);
    }
    fclose(fd);

    Geometria->init();
}

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