img_pal.C

Ir a la documentación de este archivo.

//===========================================================================
//= img_pal.cc                                            Noviembre de 1999 =
//=-------------------------------------------------------------------------=
//= Clases de representacion y procesamiento basico de imagenes digitales   =
//=-------------------------------------------------------------------------=
//= 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/media/jed_img.h"
#include "toolkits/media/_img_sgi.h"

#ifdef VEL_ROSITA
    #include "toolkits/media/img_pal.h"
#endif

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

//===========================================================================
//= Clase IMAGEN_PAL                                                        =
//===========================================================================

IMAGEN_PAL::IMAGEN_PAL()
{
    //printf("IMAGEN_PAL::IMAGEN_PAL\n"); fflush(stdout);
    x_tam = y_tam = 0;  Data = NULL; 
    modo_luminancia = FALSE;

  #ifdef GL_COMPLETO
    con_lista = FALSE;
  #endif
#ifdef NNN
  #ifdef MESA_ENABLED
    _contexto_osmesa = 0;
  #endif
#endif // NNN
}

IMAGEN_PAL::~IMAGEN_PAL()
{
    //printf("IMAGEN_PAL::~IMAGEN_PAL\t");  fflush(stdout);

#ifdef NONONO
  #ifdef GL_COMPLETO1
    if ( !con_lista ) {
        glDeleteTextures(lista_gl);
    }
  #endif
#endif

    if ( Data ) elim();
}

BOOLEAN
IMAGEN_PAL::init(int width, int height)
{
    //printf("IMAGEN_PAL::init(%d, %d);\n", width, height);  fflush(stdout);

    if ( x_tam == width && y_tam == height ) return TRUE;
    elim();
    Data = new PIXEL_PAL[height * width];
    if ( !Data ) return FALSE;
    x_tam = width;
    y_tam = height;
    return TRUE;
}

void
IMAGEN_PAL::elim(void)
{
    //printf("IMAGEN_PAL::elim();\n"); fflush(stdout);
    if ( Data ) {
        delete Data;
        Data = NULL;
        x_tam = y_tam = 0;
    }
}

#ifdef GL_ENABLED
void
IMAGEN_PAL::pintar_gl(void)
{
    //printf("IMAGEN_PAL::pintar_gl\n");  fflush(stdout);
    if ( !Data ) {
        fprintf(stderr,
            "<IMAGEN_PAL> ERROR: Intentando pintar una imagen nula.\n");
        fflush(stderr);
        return;
    }

    // OJO: Debe tenerse activada una PALETA!
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glRasterPos2f(-1, -1);
    glDrawPixels(x_tam, y_tam, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, Data);
}

void
IMAGEN_PAL::activar_gl(void)
// OJO: Debe tenerse activada una PALETA.
// OJO: Se ha presentado que la implementacion de OpenGL de este
//      metodo no se comporta igual en todas partes... por ahora
//      de las alternativas se encuentra activa la mas portable
//      (e ineficiente)
{
    //printf("IMAGEN_PAL::activar_gl\n");  fflush(stdout);

    //-----------------------------------------------------------------------
    if ( !Data ) {
        fprintf(stderr,
            "<IMAGEN_PAL> ERROR: Intentando activar una imagen nula.\n");
        fflush(stderr);
        return;
    }

    //-----------------------------------------------------------------------
#ifdef NONONO
  #ifdef GL_COMPLETO
    if ( !con_lista && acelerable(x_tam, y_tam) ) {
        //printf("<IMAGEN_PAL>: Registrando una textura... ");
        //fflush(stdout);
        glGenTextures(1, &lista_gl);
        ERROR_GL("glGenTextures");

        glBindTexture(GL_TEXTURE_2D, lista_gl);
        ERROR_GL("glBindTexture");

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
            x_tam, y_tam, 0, GL_COLOR_INDEX, 
            GL_UNSIGNED_BYTE, Data);
        ERROR_GL("glTexImage2D");

        //printf("Ok!\n");
        //fflush(stdout);
        con_lista = TRUE;
      }
      else if ( acelerable(x_tam, y_tam) ) {
        //printf("<IMAGEN_PAL>: Reutilizo una textura precompilada!\n");
        //fflush(stdout);
        glBindTexture(GL_TEXTURE_2D, lista_gl);
      }
      else {
        glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_COLOR_INDEX, 
            GL_UNSIGNED_BYTE, Data);
    }
  #endif
#endif

#ifdef NONONO
//  #ifndef GL_COMPLETO
    glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_COLOR_INDEX, 
        GL_UNSIGNED_BYTE, (void *)Data);
//  #endif
#endif

    //-----------------------------------------------------------------------
#ifdef NONONO
#ifdef GL_COMPLETO
    if ( !con_lista ) {
        glGenTextures(1, &lista_gl);
        glBindTexture(GL_TEXTURE_2D, lista_gl);
        if ( modo_luminancia ) {
            gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, x_tam, y_tam,
                          GL_LUMINANCE,  GL_UNSIGNED_BYTE, (void *)Data);
          }
          else {
            gluBuild2DMipmaps(GL_TEXTURE_2D, GL_COLOR_INDEX, x_tam, y_tam,
                          GL_COLOR_INDEX,  GL_UNSIGNED_BYTE, (void *)Data);
        }
        con_lista = TRUE;
    }
    glBindTexture(GL_TEXTURE_2D, lista_gl);
#endif
#endif
//#ifndef GL_COMPLETO
    if ( modo_luminancia ) {
        glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_LUMINANCE, 
            GL_UNSIGNED_BYTE, (void *)Data);
      }
      else {
        glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_COLOR_INDEX, 
            GL_UNSIGNED_BYTE, (void *)Data);
    }
//#endif
}

#endif // GL_COMPLETO

void
IMAGEN_PAL::set_modo_luminancia(BOOLEAN m)
{
    modo_luminancia = m;
}

//===========================================================================
//= Metodos para importar datos DOOM                                        =
//===========================================================================

BOOLEAN
IMAGEN_PAL::importar_wadsprite(FILE *fd)
{
    if ( !fd ) {
        fprintf(stderr,
            "<IMAGEN_PAL> - ERROR: No se puede abrir el archivo WAD.\n");
        fflush(stderr);
        return FALSE;
    }
    unsigned long global_offset = ftell(fd);

    //- Lea el encabezado y cree la imagen vacia ----------------------------
    WORD xtam = 0, ytam = 0, left_offset = 0, top_offset = 0;

    lea_WORD_BE(&xtam, fd);
    lea_WORD_BE(&ytam, fd);
    lea_WORD_BE(&left_offset, fd);
    lea_WORD_BE(&top_offset, fd);

    if ( xtam < 1 || xtam > 2024 || ytam < 1 || ytam > 2024 ) {
        fprintf(stderr,
            "<IMAGEN_PAL> WAD-Sprite con tamanno %d X %d no aceptado.\n",
            xtam, ytam);
        fflush(stderr);
        return FALSE;
    }

    if ( !init(xtam, ytam) ) return FALSE;

    //- Cargue los pixels en la imagen columna por columna ------------------
    int x, y, l;
    unsigned long local_offset;
    BYTE y_start, y_size;
    BYTE *buffer_columna;

    buffer_columna = new BYTE[ytam + 2];
    if ( !buffer_columna ) {
        fprintf(stderr, 
          "<IMAGEN_PAL> - ERROR: "
          "No hay memoria para un buffer temporal de %d bytes.", ytam);
        fflush(stderr);
        return FALSE;
    }

    for ( x = 0; x < x_tam; x++ ) {
        // Localice la x-esima columna
        fseek(fd, global_offset + 8 + x*4, SEEK_SET);
        lea_DWORD_BE(&local_offset, fd);
        fseek(fd, global_offset + local_offset, SEEK_SET);

        // Cargue la x-esima columna
        lea_BYTE(&y_start, fd);
        for ( y = 0; y_start != 0xFF; ) {
            lea_BYTE(&y_size, fd);
            fread(buffer_columna, sizeof(BYTE), y_size + 2, fd);
            for ( ; y < y_start && y < y_tam; y++ ) {
                // Esto coloca en "negro" los pixels transparentes 
                // (OJO: mejorar!)
                putcolorindex(x, y_tam-y-1, 0);
            }
            for ( l = 1; l <= y_size; y++, l++ ) {
                putcolorindex(x, y_tam-y-1, buffer_columna[l]);
            }
            lea_BYTE(&y_start, fd);
        }
        for ( ; y < y_tam; y++ ) {
            // Esto coloca en "negro" los pixels transparentes  (OJO: mejorar!)
            putcolorindex(x, y_tam-y-1, 0);
        }
    }

    delete buffer_columna;
    return TRUE;
}

BOOLEAN
IMAGEN_PAL::importar_wadflat(FILE *fd, WORD xtam, WORD ytam)
{
    if ( !fd ) {
        fprintf(stderr, "ERROR: No se puede abrir el archivo WAD.");
        fflush(stderr);
        return FALSE;
    }
    if ( !init(xtam, ytam) ) return FALSE;

    fread(Data, sizeof(BYTE), xtam*ytam, fd);

    return TRUE;
}

BOOLEAN
IMAGEN_PAL::importar_sgibw(FILE *fd)
{
    //- Chequeo de sanidad --------------------------------------------------
    if ( !fd ) {
        fprintf(stderr, "<IMAGEN_RGB> Error: Archivo invalido!\n");
        return FALSE;
    }

    //-----------------------------------------------------------------------
    LECTOR_SGIRGB *Constructor = NULL;

    Constructor = new LECTOR_SGIRGB;
    if ( !Constructor ) {
        fprintf(stderr, "<IMAGEN_RGB> ERROR: Memoria insuficiente\n");
        fflush(stderr);
        return FALSE;
    }

    Constructor->init(fd);

    // Round up so rows are long-word aligned  
    if ( Constructor->sizeZ != 1 ) {
        fprintf(stderr,
            "<IMAGEN_RGB> - ERROR: Solo se soporta el formato BW.\n");
        fflush(stderr);
        return FALSE;
    }

    init(Constructor->x_tam, Constructor->y_tam);
    Constructor->leer((BYTE *)Data);
    Constructor->elim();

    delete Constructor;

    return TRUE;
}

void
IMAGEN_PAL::pegar_subimagen(IMAGEN_PAL *sprite, int offset_x, int offset_y)
{
    int x, y, i, j;

    for ( x = offset_x, i = 0; x < x_tam && i < sprite->x_tam; x++, i++ ) {
        for ( y = offset_y, j = 0; y < y_tam && j < sprite->y_tam; y++, j++ ) {
            if ( offset_x >= 0 && offset_y >= 0 )
                putcolorindex(x, y, sprite->getcolorindex(i, j));
        }
    }
}

void
IMAGEN_PAL::exportar_ppm(FILE *fd, PALETA *Pal)
{
    char cad[180];
    int i, j;

    sprintf(cad, "P6\n"
                 "# PPM CREATED BY: AQUYNZA http://www.aquynza.org\n");
    fwrite(cad, sizeof(char), strlen(cad), fd);
    sprintf(cad, "%d %d\n", x_tam, y_tam);
    fwrite(cad, sizeof(char), strlen(cad), fd);
    sprintf(cad, "255\n");
    fwrite(cad, sizeof(char), 4, fd);


    //- Manejo de imagenes nativas de 24 bits por pixel -----------------------
    //PIXEL_RGB *fila, pixel;
    //PIXEL_RGBA *f2, p2;

    fprintf(stderr,
        "<IMAGEN_PAL> - Warning: Grabar PPM no esta implementado en modo nativo para \n"
        "soportar un formato indexado, exportando como PPM de 24 bits por pixel!\n");
    fflush(stderr);

    //- Manejo de imagenes nativas de 8 bits por pixel -----------------------
    //- Se usa la paleta actual para exportarlas a 24 bits por pixel ---------
    PIXEL_PAL index;
    PIXEL_RGB pixel;
    for ( i = 0; i < y_tam ; i++ ) {
        for ( j = 0; j < x_tam ; j++ ) {
            index = ((PIXEL_PAL *)Data)[i * x_tam + j];
            //pixel = LA_paleta.pal2rgb(index.index);
            // OJO: Esto no va a funcionar porque le falta saber la paleta
            // (Pista: intentar agarrarla de la de OpenGL directamente).
            pixel = Pal->pal2rgb(index);
            fwrite(&pixel, sizeof(PIXEL_RGB), 1, fd);
        }
    }
}

#ifdef NNN

#ifdef GL_ENABLED
#define ERROR_GL(op)                                                    \
        switch (glGetError()) {                                         \
          case GL_INVALID_ENUM:                                         \
            printf("[<<GL_INVALID_ENUM en %s!>>]\n", (op));             \
            fflush(stdout);  return;                                    \
          case GL_INVALID_VALUE:                                        \
            printf("[<<GL_INVALID_VALUE en %s!>>\n]", (op));            \
            fflush(stdout);  return;                                    \
          case GL_INVALID_OPERATION:                                    \
            printf("[<<GL_INVALID_OPERATION en %s!>>]\n", (op));        \
            fflush(stdout);  return;                                    \
          case GL_STACK_OVERFLOW:                                       \
            printf("[<<GL_STACK_OVERFLOW en %s!>>]\n", (op));           \
            fflush(stdout);  return;                                    \
          case GL_STACK_UNDERFLOW:                                      \
            printf("[<<GL_STACK_UNDERFLOW en %s!>>]\n", (op));          \
            fflush(stdout);  return;                                    \
          case GL_OUT_OF_MEMORY:                                        \
            printf("[<<GL_OUT_OF_MEMORY en %s!>>]\n", (op));            \
            fflush(stdout);  return;                                    \
          default: break;                                               \
        }
#endif // GL_ENABLED

#ifdef NONONO
static BOOLEAN
acelerable(int x, int y)
{
    int c, i;

    for ( i = 0, c = 0; i < 32; i++ ) {
        if ( x & (1<<i) ) c++;
    }
    if ( c > 1 ) return FALSE;

    for ( i = 0, c = 0; i < 32; i++ ) {
        if ( y & (1<<i) ) c++;
    }
    if ( c > 1 ) return FALSE;

    return TRUE;
}

#ifndef GL_COMPLETO
    glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_COLOR_INDEX, 
        GL_UNSIGNED_BYTE, Data);
#endif
}
#endif // NONONO


#ifdef GL_ENABLED
void
IMAGEN_PAL::activar_como_contexto_gl(void)
{
#ifdef MESA_ENABLED
    fprintf(stderr,
        "<IMAGEN_PAL> - ERROR: GL no implementado en este tipo de imagen!\n");
    fflush(stderr);
    exit(-10);
/*
   _contexto_osmesa = OSMesaCreateContext( GL_RGBA, NULL );
   OSMesaMakeCurrent(_contexto_osmesa, Data, GL_UNSIGNED_BYTE, x_tam, y_tam);
*/
#endif
#ifndef MESA_ENABLED
    fprintf(stderr, "<IMAGEN_PAL> - ERROR: El contexto GL sobre una imagen\n"
                    "solo ha sido implementado para MESA!\n");
    fflush(stderr);
    exit(-4);
#endif
}

void
IMAGEN_PAL::desactivar_como_contexto_gl(void)
{
#ifdef MESA_ENABLED
   if ( _contexto_osmesa ) OSMesaDestroyContext(_contexto_osmesa);
#endif
}
#endif // GL_ENABLED

IMAGEN_PAL *
IMAGEN_PAL::exportar_a_grises(PALETA *Pal)
{
    IMAGEN_PAL *Nueva = NULL;
    int x, y;
    BYTE r, g, b, index;

    Nueva = new IMAGEN_PAL();

    if ( !Nueva->init(x_tam, y_tam) ) {
        fprintf(stderr, "Warning[JED_IMG]: No hay memoria para crear una "
            "imagen en tonos de gris de %d x %d pixels!\n", x_tam, y_tam);
        fflush(stderr);
        return NULL;
    }

    for ( x = 0; x < x_tam; x++ ) {
        for ( y = 0; y < y_tam; y++ ) {
            index = getcolorindex(x, y);
            r = Pal->tabla[index].r;
            g = Pal->tabla[index].g;
            b = Pal->tabla[index].b;
            Nueva->putcolorindex(x, y, nivel_de_gris(r, g, b));
        }
    }
    return Nueva;
}

void
IMAGEN_PAL::umbralizar(BYTE umbral)
/*
PRE: El umbral esta entre 0 y 255, en donde 0 es negro, 255 es blanco y
los valores intermedios son grises uniformemente distribuidos (por luminancia).
*/
{
    int x, y;

    for ( x = 0; x < x_tam; x++ ) {
        for ( y = 0; y < y_tam; y++ ) {
            if ( getcolorindex(x, y) > umbral ) {
                putcolorindex(x, y, 255);
              }
              else {
                putcolorindex(x, y, 0);
            }
        }
    }
}

void
IMAGEN_PAL::umbralizar_adaptativo(void)
{
    double pct = 15.0;           // Make smaller to darken the image 
    double factor_divisor = 8.0; // Fraccion de una fila para el promediaje
    int x, y, inc;
    double promedio, s, sum;
    long N, i;

    N = (long)x_tam * (long)y_tam;

    s = (int)(double)(x_tam/factor_divisor);
    sum = 127*s;

    for ( i = 0, x = 0, y = 0, inc = 1; i < N-1; i++, x += inc ) {
        //- Chequeo de limites para el recorrido en zig-zag -
        if ( x >= x_tam ) {
            x = x_tam-1; y++; inc = -1;
          } 
          else if ( x < 0 ) {
            x = 0; y++; inc = 1;
        }

        //- Estime el promedio de los ultimos x_tam/factor_divisor pixels. -
        sum -= sum/s - getcolorindex(x, y); promedio = sum/s;

        //- Binarizacion de un pixel -
        if ( getcolorindex(x, y) < promedio * (100-pct) / 100.0 ) {
            putcolorindex(x, y, 0); 
          }
          else {
            putcolorindex(x, y, 255); 
        }
    }

}

IMAGEN *
IMAGEN_PAL::copie(void)
{
    IMAGEN_PAL *Nueva;
    int x, y;

    Nueva = new IMAGEN_PAL();
    if ( !Nueva ) {
        fprintf(stderr,"ERROR: No hay memoria para crear una nueva imagen!\n");
        fflush(stderr);
        return NULL;
    }

    if ( !Nueva->init(x_tam, y_tam)  ) {
        fprintf(stderr,"ERROR: No hay memoria para crear una nueva imagen!\n");
        fflush(stderr);
        delete Nueva;
        return NULL;
    }

    for ( x = 0; x < x_tam; x++ ) {
        for ( y = 0; y < y_tam; y++ ) {
            Nueva->putcolorindex(x, y, getcolorindex(x, y));
        }
    }

    return Nueva;
}

#endif // NNN

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