img_rgb.C

Ir a la documentación de este archivo.

//===========================================================================
//= img_rgb.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_rgb.h"
#endif

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

#ifdef GL_VERSION_1_1  // OJO: Toca revisar si esta vaina funciona bien!
    #define GL_COMPLETO // Si se quita, parece que el otro (en jed_defs)
#endif                  // no se activa bien

#ifdef PNG_ENABLED
  #include <png.h>
  #ifndef png_jmpbuf
    #define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
  #endif
#endif

//===========================================================================
//= Funciones utilitarias                                                   =
//===========================================================================

#ifdef X_ENABLED

static int
highbit(unsigned long ul)
{
    int i;
    for (i=31; ((ul&0x80000000) == 0) && i>=0;  i--, ul<<=1);
    return i;
}

#endif

//===========================================================================
//= Clase IMAGEN_RGB                                                        =
//===========================================================================

IMAGEN_RGB::IMAGEN_RGB()
{
    //printf("IMAGEN_RGB::IMAGEN_RGB\n"); fflush(stdout);
    x_tam = y_tam = 0;  Data = NULL;
    _anx_x = 0;
    _anx_y = 0;
    _anx_r = 0;
    _anx_g = 0;
    _anx_b = 0;
    _anx_c = 0;

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

IMAGEN_RGB::~IMAGEN_RGB()
{
    //printf("IMAGEN_RGB::~IMAGEN_RGB\t");  fflush(stdout);
    if ( Data ) elim();
}

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

    if ( x_tam == width && y_tam == height ) return TRUE;
    elim();
// OJO: En PALMOS todavia hay problemas con la asignacion de memoria dinamica
#if PLATAFORMA != PALM_PALMOS_CODEWARRIOR
    Data = new PIXEL_RGB[height * width];
#endif
#if PLATAFORMA == PALM_PALMOS_CODEWARRIOR
    //Data = (PIXEL_RGB *)malloc(height * width * sizeof(PIXEL_RGB));
    Data = (PIXEL_RGB **)malloc(height * sizeof(PIXEL_RGB*));
#endif
    if ( !Data ) return FALSE;

#if PLATAFORMA == PALM_PALMOS_CODEWARRIOR
    int i, j;

    for ( i = 0; i < height; i++ ) {
        Data[i] = (PIXEL_RGB *)malloc(width * sizeof(PIXEL_RGB));

        if ( !Data[i] ) {
            for ( j = 0; j < i; j++ ) {
                free(Data[j]);
            }
            free(Data);
            Data = NULL;
            return FALSE;
        }
    }
#endif

    x_tam = width;
    y_tam = height;
    _anx_x = 0;
    _anx_y = 0;
    _anx_r = 0;
    _anx_g = 0;
    _anx_b = 0;
    _anx_c = 0;
    return TRUE;
}

void
IMAGEN_RGB::elim(void)
{
    //printf("IMAGEN_RGB::elim();\n"); fflush(stdout);
    if ( Data ) {
// OJO: En PALMOS todavia hay problemas con la asignacion de memoria dinamica
#if PLATAFORMA != PALM_PALMOS_CODEWARRIOR
        delete Data;
#endif
#if PLATAFORMA == PALM_PALMOS_CODEWARRIOR
        int i;

        for ( i = 0; i < y_tam; i++ ) {
            free(Data[i]);
        }
        free(Data);
#endif
        Data = NULL;
        x_tam = y_tam = 0;
    }
}

BOOLEAN
IMAGEN_RGB::combinar_stereo(IMAGEN_RGB *Izq, IMAGEN_RGB *Der, int modo)
{
    BYTE r, g, b;
    int x, y, xt, yt;
    int s1, s2;

    xt = Izq->xtam();
    yt = Izq->ytam();

    if ( xt != Der->xtam() || yt != Izq->ytam() ) {
        fprintf(stderr, "<IMAGEN_RGB> - ERROR: Par stereo de tamanno "
                "inconsistente.\n");
        fflush(stderr);
        return FALSE;
    }

    if ( modo == STEREO_INTERLACED ) {
        if ( !init(xt, yt) ) {
            return FALSE;
        }
        for ( x = 0; x < xt; x++ ) {
            for ( y = 0; y < yt; y++ ) {
                if ( y % 2 ) {
                    Izq->getpixel(x, y, r, g, b);
                  }
                  else {
                    Der->getpixel(x, y, r, g, b);
                }
                putpixel(x, y, r, g, b);
            }
        }
      }
      else {
        // Se asume por defecto  (modo_stereo == STEREO_BLUE_RED)  
        if ( !init(xt, yt) ) {
            return FALSE;
        }
        for ( x = 0; x < xt; x++ ) {
            for ( y = 0; y < yt; y++ ) {
                Izq->getpixel(x, y, r, g, b);
                s1 = (BYTE)((((int)r) + ((int)g) + ((int)b)) / 3);
                s1 = (BYTE)((float)s1 * 0.7);
                Der->getpixel(x, y, r, g, b);
                s2 = (BYTE)((((int)r) + ((int)g) + ((int)b)) / 3);
                putpixel(x, y, s1, 0, s2);
            }
        }
      }
    ;
    return TRUE;
}

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

    //- Generacion de primitivas OpenGL -------------------------------------
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glRasterPos2f(-1, -1);
    glDrawPixels(x_tam, y_tam, GL_RGB, GL_UNSIGNED_BYTE, (void*)Data);
}

void
IMAGEN_RGB::activar_gl(void)
{
    //- Verificacion de sanidad ---------------------------------------------
    //printf("IMAGEN_RGB::activar_gl\n");  fflush(stdout);
    if ( !Data ) {
        fprintf(stderr,
            "<IMAGEN_RGB> ERROR: Intentando activar una imagen nula.\n");
        fflush(stderr);
        return;
    }
    //- Generacion de primitivas OpenGL -------------------------------------
     if ( !(x_tam % 4) )
        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    else if ( !(x_tam % 2) )
        glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
    else
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    //glTexImage2D(GL_TEXTURE_2D, 0, 3, x_tam, y_tam, 0, GL_RGB, 
    //    GL_UNSIGNED_BYTE, (void*)Data);

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

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

void
IMAGEN_RGB::desactivar_como_contexto_gl(void)
{
#ifdef MESA_ENABLED
    if ( _contexto_osmesa ) OSMesaDestroyContext(_contexto_osmesa);
#endif
}

BOOLEAN
IMAGEN_RGB::importar_gl(int x, int y, int xtam, int ytam)
{
    glPushMatrix();

    if ( xtam <= 0 || xtam > 2024 || ytam <=0 || ytam > 2024 ) {
        fprintf(stderr, "<IMAGEN_RGB> Tamanno %d X %d no aceptado.\n",
                xtam, ytam);
        fflush(stderr);
        return FALSE;
    }

    if ( !init(xtam, ytam) ) {
        return FALSE;
    }
    //printf("Creo imagen de %d x %d...\n", x_tam, y_tam);
    //fflush(stdout);

    // Pre: tipo == IMAGEN_RGB24BITS

    // OJO: Esta configuracion previa es realmente necesaria?

    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1, 1, -1, 1, 0.0, 0.1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glRasterPos2f(-1, -1);
    glReadPixels(x, y, x_tam, y_tam, GL_RGB, GL_UNSIGNED_BYTE, Data);

    glPopMatrix();
    return TRUE;
}

#endif // GL_ENABLED



#ifdef NNN

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

    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++ ) {
            getpixel(x, y, r, g, b);
            // OJO: Notese que umbral = f(r, g, b) y deberia poder 
            // especificarse f de una manera menos arbibraria, siempre y
            // cuando se garantice que umbral da de 0 a 255.
            Nueva->putcolorindex(x, y, nivel_de_gris(r, g, b));
        }
    }

    //Pal = NULL;  // #pragma argsused

    return Nueva;
}

IMAGEN *
IMAGEN_RGB::copie(void)
{
    IMAGEN_RGB *Nueva;
    int x, y;
    BYTE r, g, b;

    Nueva = new IMAGEN_RGB();
    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++ ) {
            getpixel(x, y, r, g, b);
            Nueva->putpixel(x, y, r, g, b);
        }
    }

    return Nueva;
}

#endif // NNN

//= METODOS DE PERSISTENCIA (IMPORTACION DE DATOS) ==========================

BOOLEAN
IMAGEN_RGB::importar_ppm(FILE *fd)
{
#ifndef FILESYSTEM_ENABLED
    return FALSE;
#endif
#ifdef FILESYSTEM_ENABLED
    int xsize = 0, ysize = 0;
    int i, j;
    char buffer[MAX_LINE + 1];
    char *ptr = NULL;
    PIXEL_RGB pixel;
    int tipo = 6;

    //- Verificacion de que el archivo esta bien ----------------------------
    if ( !fd ) {
        fprintf(stderr, "<IMAGEN_RGB> ERROR: No se puede abrir el archivo.\n");
        fflush(stderr);
        return FALSE;
    }

    //- Lea y procese el encabezado ppm ------------------------------------
    for ( i = 0; !feof(fd); i++ ) {
        if ( i >= MAX_LINE ) i = 0;
        fread(&buffer[i], sizeof(BYTE), 1, fd);
        buffer[i + 1] = '\0';

        if ( buffer[i] == '\n' && buffer[0] == 'P' && buffer[1] == '5' ) {
            tipo = 5;
        }

        if ( buffer[i] == '\n' && strcmp(buffer, "255\n") == 0 ) {
            break;
          }
          else if ( buffer[i] == '\n' ) {
            ptr = strtok(buffer, " \n");
            if ( ptr ) {
                xsize = atoi(ptr);
                ptr = strtok(NULL, " \n");
                if ( ptr ) {
                    ysize = atoi(ptr);
                }
            }
            i = -1;
        }          
    }

    //- Verifique que el tamanno de la imagen sea coherente -----------------
    if ( xsize <= 0 || xsize > 2024 || ysize <=0 || ysize > 2024 ) {
        fprintf(stderr,
            "<IMAGEN_RGB> Imagen con tamanno %d X %d no aceptada.\n",
            xsize, ysize);
        fflush(stderr);
        return FALSE;
    }

    //- Cree la imagen y lea sus pixels del archivo ppm ---------------------
    PIXEL_RGB *fila;

    if ( !init(xsize, ysize) ) return FALSE;

    if ( tipo == 6 ) {
        for ( i = y_tam - 1; i >= 0 ; i-- ) {
            fila = &(Data[i*x_tam]);
            for ( j = 0; j < x_tam ; j++ ) {
                fread(&pixel, sizeof(PIXEL_RGB), 1, fd);
                fila[j] = pixel;
            }
        }
    }

    if ( tipo == 5 ) {
        for ( i = y_tam - 1; i >= 0 ; i-- ) {
            fila = &(Data[i*x_tam]);
            for ( j = 0; j < x_tam ; j++ ) {
                fread(&pixel.r, sizeof(BYTE), 1, fd);
                fila[j].r = pixel.r;
                fila[j].g = pixel.r;
                fila[j].b = pixel.r;
            }
        }
    }

    return TRUE;
#endif // FILESYSTEM_ENABLED
}

BOOLEAN
IMAGEN_RGB::importar_sgirgb(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 != 3 ) {
        fprintf(stderr,
            "<IMAGEN_RGB> - ERROR: Solo se soporta el formato RGB.\n");
        fflush(stderr);
        return FALSE;
    }

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

    return TRUE;
}

BOOLEAN
IMAGEN_RGB::importar_pcx(FILE *fd)
{
#ifndef FILESYSTEM_ENABLED
    return FALSE;
#endif
#ifdef FILESYSTEM_ENABLED
    BYTE *Tmp_buffer;
    BYTE *m_palette_buffer;

    elim();

    if ( !fd ) return FALSE;

    //- Lea el encabezado PCX -----------------------------------------------
    int byte;

    byte = getc(fd); // format PCX
    if ( byte != 10 ) {    fclose(fd);     return FALSE;    }
    byte = getc(fd); // version info
    if ( byte != 5 ) {     fclose(fd);     return FALSE;    }

    //- Determine el tamanno de la imagen y asignele memoria ----------------
    int x1, y1, x2, y2;

    rewind(fd);  fgetc(fd);fgetc(fd);fgetc(fd);fgetc(fd); // Me reubico...
    x1 = fgetc(fd);    x1 |= fgetc(fd)<<8;
    y1 = fgetc(fd);    y1 |= fgetc(fd)<<8;
    x2 = fgetc(fd);    x2 |= fgetc(fd)<<8;
    y2 = fgetc(fd);    y2 |= fgetc(fd)<<8;
    x_tam       = x2 - x1 + 1;
    y_tam       = y2 - y1 + 1;

    Tmp_buffer = new unsigned char [(x_tam * y_tam)];

    //- Lea los datos de la imagen ------------------------------------------
    int w_count = 0;
    int repeat;
    int i;

    fseek(fd, 128, SEEK_SET); // Brincar el encabezado
    while ( w_count < (x_tam * y_tam) ) {
        byte = getc(fd);
        if ( byte > 0xbf ) {
            repeat = 0x3f & byte;
            byte = getc(fd);
            for (i = 0; i < repeat; i++) {
                Tmp_buffer[w_count++] = (BYTE)byte;
            }
          }
          else {
            Tmp_buffer[w_count++] = (BYTE)byte;
        }
    }

    //- Lea los datos de la paleta de colores -------------------------------
    m_palette_buffer = new unsigned char [768];
    fseek (fd, -769, SEEK_END);
    byte = getc(fd);
    if ( byte != 12 ) {
        fclose(fd);
        return FALSE;
    }
    for (i = 0; i < 768; i++) {
        byte = getc(fd);
        m_palette_buffer[i] = (BYTE)byte;
    }
    fclose (fd);

    //- Importe los datos PCX a mi arreglo de imagen ------------------------
    int x, y;
    BYTE r, g, b;

    Data = new PIXEL_RGB [x_tam * y_tam];
    if ( !Data ) {
        fprintf(stderr,"<IMAGEN_RGB> ERROR: Memoria insuficiente.\n");
        fflush(stderr);
        return FALSE;
    }
    for ( y = 0; y < y_tam; y++ ) {
        for ( x = 0; x < x_tam; x++ ) {
            r = m_palette_buffer[3*Tmp_buffer[y*x_tam+x]+0];
            g = m_palette_buffer[3*Tmp_buffer[y*x_tam+x]+1];
            b = m_palette_buffer[3*Tmp_buffer[y*x_tam+x]+2];
            putpixel(x, y_tam-y-1, r, g, b);
        }
    }
    delete Tmp_buffer;

    return TRUE;
#endif // FILESYSTEM_ENABLED
}

BOOLEAN
IMAGEN_RGB::importar_png(FILE *fd)
{
  #ifndef PNG_ENABLED
    fprintf(stderr, 
"<IMAGEN_RGB::importar_png> - ERROR: AQUYNZA ha sido compilado sin soporte\n"
"    para procesar archivos en formato PNG, probablemente debido a la\n"
"    ausencia de la libreria libpng o a sus encabezados.\n"
"    Recompile AQUYNZA con la opcion PNG_ENABLED activada si desea usar\n"
"    esta operacion.\n"
);
    fflush(stderr);
    return FALSE;
  #endif

  #ifdef PNG_ENABLED
    elim();

    //- 1. Acceso inicial a un archivo en formato PNG -----------------------
    png_structp lector_libpng;         // Acceso a los algoritmos de libpng
    png_infop info_ptr;
    png_uint_32 width, height;
    int bit_depth, color_type, interlace_type;

    // OJO: Notese que no se estan usando las funciones asincronicas de
    //      manejo de error, esto puede mejorarse.
    lector_libpng = png_create_read_struct(PNG_LIBPNG_VER_STRING,
                                           NULL, NULL, NULL);

    if ( !lector_libpng ) {
        return FALSE;
    }

    /* Allocate/initialize the memory for image information.  REQUIRED. */
    info_ptr = png_create_info_struct(lector_libpng);
    if ( !info_ptr ) {
        png_destroy_read_struct(&lector_libpng, NULL, NULL);
        return FALSE;
    }

    /* Set error handling if you are using the setjmp/longjmp method (this is
     * the normal method of doing things with libpng).  REQUIRED unless you
     * set up your own error handlers in the png_create_read_struct() earlier.
     */
    if ( setjmp(png_jmpbuf(lector_libpng)) ) {
        png_destroy_read_struct(&lector_libpng, &info_ptr, NULL);
        return FALSE;
    }
    png_init_io(lector_libpng, fd);
    png_read_info(lector_libpng, info_ptr);
    png_get_IHDR(lector_libpng, info_ptr, &width, &height, &bit_depth, 
                 &color_type, &interlace_type, NULL, NULL);

    //- 2. Configuracion de un formato de imagen compatible con AQUYNZA -----

    /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
     * byte into separate bytes (useful for paletted and grayscale images). */
    png_set_packing(lector_libpng);

    /* Expand paletted colors into true RGB triplets */
/*
    if (color_type == PNG_COLOR_TYPE_PALETTE) {
        png_set_palette_rgb(lector_libpng);
    }
*/

#ifdef NONONO
    /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
    if ( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) {
        png_set_gray_1_2_4_to_8(lector_libpng);
    }

    /* Expand paletted or RGB images with transparency to full alpha channels
     * so the data will be available as RGBA quartets.  */
    if ( png_get_valid(lector_libpng, info_ptr, PNG_INFO_tRNS)) {
        png_set_tRNS_to_alpha(lector_libpng);
    }
#endif

    /* Set the background color to draw transparent and alpha images over.
     * It is possible to set the red, green, and blue components directly
     * for paletted images instead of supplying a palette index.  Note that
     * even if the PNG file supplies a background, you are not required to
     * use it - you should use the (solid) application background if it has one
     */
    png_color_16 my_background, *image_background;

    if ( png_get_bKGD(lector_libpng, info_ptr, &image_background) ) {
        png_set_background(lector_libpng, image_background,
                           PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
      }
    else {
        png_set_background(lector_libpng, &my_background,
                           PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
    }

    /* Add filler (or alpha) byte (before/after each RGB triplet) */
//    png_set_filler(lector_libpng, 0xff, PNG_FILLER_AFTER);

    //- 3. Leida de la imagen, directamente a la memoria de usuaio ----------
    unsigned char **row_pointers;
    unsigned int row, pass, y;
    unsigned int number_passes;
    unsigned char *Data;

    number_passes = png_set_interlace_handling(lector_libpng);
    row_pointers = new unsigned char * [height];
    Data = new unsigned char [3 * width * height];
    for ( row = 0; row < height; row++ ) {
        row_pointers[row] = (unsigned char *)&Data[row*width*3];
    }

    for ( pass = 0; pass < number_passes; pass++ ) {
        for ( y = 0; y < height; y++ ) {
            png_read_rows(lector_libpng, &row_pointers[y], NULL, 1);
        }
    }

    png_read_end(lector_libpng, info_ptr);
    png_destroy_read_struct(&lector_libpng, &info_ptr, NULL);
    delete row_pointers;

    //- 4. Prueba: exportar la imagen a formato PPM -------------------------
    unsigned int i, j, idx;
    BYTE r, g, b;

    if ( !init(width, height) ) {
        delete Data;
        return FALSE;
    }

    for ( i = 0; i < height; i++ ) {
        for ( j = 0, idx = 0; j < width; j++, idx += 3 ) {
            r = row_pointers[i][idx];
            g = row_pointers[i][idx+1];
            b = row_pointers[i][idx+2];
            putpixel(j, i, r, g, b);
        }
    }

    delete Data;

    //-----------------------------------------------------------------------
    return TRUE;
  #endif // PNG_ENABLED
}

BOOLEAN
IMAGEN_RGB::importar_jpeg(FILE *fd)
{
  #ifndef JPEG_ENABLED
    fprintf(stderr, 
"<IMAGEN_RGB::importar_jpeg> - ERROR: AQUYNZA ha sido compilado sin soporte\n"
"    para procesar archivos en formato JPEG, probablemente debido a la\n"
"    ausencia de la libreria libjpeg o a sus encabezados.\n"
"    Recompile AQUYNZA con la opcion JPEG_ENABLED activada si desea usar\n"
"    esta operacion.\n"
);
    fflush(stderr);
    return FALSE;
  #endif

  #ifdef JPEG_ENABLED
    //- Importe los datos JPEG ----------------------------------------------
    char error_cad[200];
    int planos;
    BYTE *Tmp_buffer =
        IMAGEN_importar_jpeg(fd, &x_tam, &y_tam, &planos, error_cad);

    if ( !Tmp_buffer ) {
        fprintf(stderr, "<IMAGEN_RGB> ERROR: archivo JPEG invalido!\n");
        fflush(stderr);
        return FALSE;
    }

    if ( error_cad[0] ) {
        fprintf(stderr,
            "<IMAGEN_RGB> Warning: Archivo JPEG con problemas! : %s\n",
            error_cad);
        fflush(stderr);
    }

    if ( planos != 3 && planos != 1 ) {
        fprintf(stderr,
            "<IMAGEN_RGB> SORRY\n"
            "Solo se han implementado JPEGs con 1 o 3 planos.\n");
        fflush(stderr);
        return FALSE;
    }

    //- Importe los datos JPEG a mi arreglo de imagen -----------------------
    int x, y;
    BYTE r, g, b;

    Data = new PIXEL_RGB [x_tam * y_tam];
    if ( !Data ) {
        fprintf(stderr,"<IMAGEN_RGB> ERROR: Memoria insuficiente.\n");
        fflush(stderr);
        return FALSE;
    }

    if ( planos == 3 ) {
        for ( y = 0; y < y_tam; y++ ) {
            for ( x = 0; x < x_tam; x++ ) {
                r = Tmp_buffer[3*(y*x_tam+x)];
                g = Tmp_buffer[3*(y*x_tam+x)+1];
                b = Tmp_buffer[3*(y*x_tam+x)+2];
                putpixel(x, y_tam-y-1, r, g, b);
            }
        }
      }
      else if ( planos == 1 ) {
        for ( y = 0; y < y_tam; y++ ) {
            for ( x = 0; x < x_tam; x++ ) {
                r = Tmp_buffer[y*x_tam+x];
                g = r;
                b = r;
                putpixel(x, y_tam-y-1, r, g, b);
            }
        }
    }
    free(Tmp_buffer);
    return TRUE;
  #endif // JPEG_ENABLED
}

BOOLEAN
IMAGEN_RGB::exportar_jpeg(FILE *fd, int calidad_jpeg)
{
  #ifndef JPEG_ENABLED
    fprintf(stderr, 
"<IMAGEN_RGB::importar_jpeg> - ERROR: AQUYNZA ha sido compilado sin soporte\n"
"    para procesar archivos en formato JPEG, probablemente debido a la\n"
"    ausencia de la libreria libjpeg o a sus encabezados.\n"
"    Recompile AQUYNZA con la opcion JPEG_ENABLED activada si desea usar\n"
"    esta operacion.\n"
);
    fflush(stderr);
    return FALSE;
  #endif

  #ifdef JPEG_ENABLED
    if ( !fd ) return FALSE;
    IMAGEN_exportar_jpeg(fd, calidad_jpeg, x_tam, y_tam, (BYTE *)Data);
    return TRUE;
  #endif // JPEG_ENABLED
}


void
IMAGEN_RGB::exportar_ppm(FILE *fd)
{
    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;

    for ( i = y_tam - 1; i >= 0 ; i-- ) {
        fila = &((PIXEL_RGB *)Data)[i*x_tam];
        for ( j = 0; j < x_tam ; j++ ) {
            pixel = fila[j];
            fwrite(&pixel, sizeof(PIXEL_RGB), 1, fd);
        }
    }
}

//= SOPORTE PARA EL SISTEMA X11 =============================================

#ifdef X_ENABLED

//= SERVICIOS DE COPIA A ESTRUCTURAS XImage ==================================

void
IMAGEN_RGB::copiar_ximage(Display *Mi_display, XImage *imagen)
{
    Screen *Zona =
        ScreenOfDisplay(Mi_display, DefaultScreen(Mi_display));

    int depth = DefaultDepthOfScreen(Zona);

    //- Copia dependiente del formato actual ---------------------------------
    switch ( depth ) {
      case 6: case 8:
        copiar_imagenX_depth8(Mi_display, imagen);
        break;
      case 16:
        copiar_imagenX_depth16(Mi_display, imagen);
        break;
      case 24: case 32:
        copiar_imagenX_depth24(Mi_display, imagen);
        break;
      default:
        fprintf(stderr, "ERROR!: Profundidad %d desconocida o no soportada.\n",
            depth);
        fflush(stderr);
    }

}

void
IMAGEN_RGB::copiar_imagenX_depth8(Display *Mi_display, XImage *imagen)
{
    unsigned char *bitp = (unsigned char*)imagen->data;
    unsigned char r, g, b, min = 255;
    static PALETA *Paleta = NULL;
    int i, j, k;
    double min_dist, dist;

    if ( !Paleta ) {
        Paleta = new PALETA;
        Paleta->importe_x(Mi_display,
            DefaultColormap(Mi_display, DefaultScreen(Mi_display)));
    }

    //- Inicialice un cache de colores -------------------------------------
    int cache[64][64][64];

    for ( i = 0; i < 64; i++ ) {
        for ( j = 0; j < 64; j++ ) {
            for ( k = 0; k < 64; k++ ) {
                cache[i][j][k] = -1;
            }
        }
    }

    //- Version de RGB 24 bits a Visual 8 bits -----------------------------
    unsigned char rr, gg, bb;

    for ( j = 0; j < y_tam; j++ ) {
        for ( i = 0; i < x_tam; i++ ) {
            r = ((BYTE *)Data)[3 * (j * x_tam + i)];
            g = ((BYTE *)Data)[3 * (j * x_tam + i) + 1];
            b = ((BYTE *)Data)[3 * (j * x_tam + i) + 2];
            rr = r >> 2;
            gg = g >> 2;
            bb = b >> 2;
            if ( cache[rr][gg][bb] == -1 ) {
                min_dist = FLT_MAX;
                for ( k = 0; k < Paleta->tam_tabla; k++ ) {
                    dist = DISTANCIA(r, g, b, 
                                     Paleta->tabla[k].r,
                                     Paleta->tabla[k].g,
                                     Paleta->tabla[k].b);
                    if ( dist < min_dist ) {
                        min_dist = dist;
                        min = k;
                    }
                }
                cache[rr][gg][bb] = min;
            }
            bitp[((y_tam - j - 1) * x_tam + i)] = cache[rr][gg][bb];
        }
    }
}

void
IMAGEN_RGB::copiar_imagenX_depth16(Display *Mi_display, XImage *imagen)
{
    Visual *vi=DefaultVisual(Mi_display,DefaultScreen(Mi_display));
    int rshift = 15 - highbit(vi->red_mask);
    int gshift = 15 - highbit(vi->green_mask);
    int bshift = 15 - highbit(vi->blue_mask);
    int bmap_order = BitmapBitOrder(Mi_display);
    unsigned char *bitp;
    int i, j, k = 0;
    int c;

    bitp = (unsigned char*)imagen->data;
    for ( j = y_tam - 1; j >= 0; j-- ) {
        for ( i = 0; i < x_tam; i++ ) {
            k = j * x_tam + i;
            c = (((int)((BYTE*)Data)[3*k]*256 >> rshift) & vi->red_mask) |
                (((int)((BYTE*)Data)[3*k+1] * 256>> gshift) & vi->green_mask) |
                (((int)((BYTE*)Data)[3*k+2] * 256>> bshift) & vi->blue_mask);
            if ( bmap_order == MSBFirst ) {
                *bitp++ = (c >> 8) & 0xff;
                *bitp++ = c & 0xff;
              }
              else {
                *bitp++ = c & 0xff;
                *bitp++ = (c >> 8) & 0xff;
            }
        }
    }
}

void
IMAGEN_RGB::copiar_imagenX_depth24(Display *Mi_display, XImage *imagen)
{
    unsigned char *ptr = (unsigned char*)imagen->data;
    int bmap_order = BitmapBitOrder(Mi_display);
    int i, j, k = 0;

    // OJO: No se tiene en cuenta el alineamiento a la palabra... sera
    //      que funciona para imagenes cuyo ancho no sea multiplo de
    //      2, 4 u 8?
    // OJO: No tiene en cuenta las mascaras de color que pueda estar
    //      usando el servidor X11, y supone que son 0x00FF0000,
    //      0x0000FF00 y 0x000000FF.
    if ( bmap_order == MSBFirst ) {
        // Este algoritmo no ha sido probado
        for ( j = y_tam - 1; j >= 0; j-- ) {        
            for ( i = 0; i < x_tam; i++ ) {
                k = x_tam * j + i;
                *ptr++ = (unsigned char)(Data[k].r); // Canal rojo
                *ptr++ = (unsigned char)(Data[k].g); // Canal verde
                *ptr++ = (unsigned char)(Data[k].b); // Canal azul
                *ptr++ = (unsigned char)(0x00);
            }
        }
    }
    else {
        // Funciona bien en i386_LINUX_GCC
        for ( j = y_tam - 1; j >= 0; j-- ) {        
            for ( i = 0; i < x_tam; i++ ) {
                k = x_tam * j + i;
                *ptr++ = (unsigned char)(Data[k].b); // Canal azul
                *ptr++ = (unsigned char)(Data[k].g); // Canal verde
                *ptr++ = (unsigned char)(Data[k].r); // Canal rojo
                *ptr++ = (unsigned char)(0x00);
            }
        }
    }
}

//= SERVICIOS DE CREACION DE ESTRUCTURAS XImage =============================

XImage *
IMAGEN_RGB::exportar_ximage(Display *Mi_display)
{
    XImage *Imagen_en_formato_X11;
    int depth;

    Screen *Zona =
        ScreenOfDisplay(Mi_display, DefaultScreen(Mi_display));

    depth = DefaultDepthOfScreen(Zona);

    //- Creacion de una imagen a partir de los datos de imagen --------------
    switch ( depth ) {
      case 6: case 8:
        Imagen_en_formato_X11 = crear_imagenX_depth8(Mi_display);
        break;
      case 16:
        Imagen_en_formato_X11 = crear_imagenX_depth16(Mi_display);
        break;
      case 24: case 32:
        Imagen_en_formato_X11 = crear_imagenX_depth24(Mi_display);
        break;
      default:
        fprintf(stderr, "<IMAGEN_RGB::exportar_ximage> - ERROR: "
                "Profundidad %d desconocida o no soportada.\n", depth);
        fflush(stderr);
        return NULL;
    }

    return Imagen_en_formato_X11;
}

XImage *
IMAGEN_RGB::crear_imagenX_depth8(Display *Mi_display)
{
    Screen *Zona =
        ScreenOfDisplay(Mi_display, DefaultScreen(Mi_display));

    //- Creacion de la estructura de imagen y su arreglo de pixels ----------
    int depth = DefaultDepthOfScreen(Zona);
    unsigned char *mi_data = (unsigned char *)malloc(x_tam * y_tam);;
    XImage *newimage = XCreateImage(Mi_display,
        DefaultVisual(Mi_display, DefaultScreen(Mi_display)),
        depth, ZPixmap, 0, (char *)mi_data,
        x_tam, y_tam, 8, x_tam);

    //- Copiado de los datos de imagen al arreglo de pixels -----------------
    copiar_imagenX_depth8(Mi_display, newimage);

    return newimage;
}

XImage *
IMAGEN_RGB::crear_imagenX_depth16(Display *Mi_display)
{
    Screen *Zona =
        ScreenOfDisplay(Mi_display, DefaultScreen(Mi_display));

    //- Creacion de la estructura de imagen y su arreglo de pixels ----------
    int depth = DefaultDepthOfScreen(Zona);
    unsigned char *mi_data = (unsigned char *)malloc(2 * x_tam * y_tam);
    XImage *newimage = XCreateImage(Mi_display,
        DefaultVisual(Mi_display, DefaultScreen(Mi_display)),
        depth, ZPixmap, 0, (char *)mi_data,
        x_tam, y_tam, 16, 0);

    //- Copiado de los datos de imagen al arreglo de pixels -----------------
    copiar_imagenX_depth16(Mi_display, newimage);

    return newimage;
}

XImage *
IMAGEN_RGB::crear_imagenX_depth24(Display *Mi_display)
{
    Screen *Zona =
        ScreenOfDisplay(Mi_display, DefaultScreen(Mi_display));

    //- Creacion de la estructura de imagen y su arreglo de pixels ----------
    int depth = DefaultDepthOfScreen(Zona);
    unsigned char *mi_data = (unsigned char *)malloc(4 * x_tam * y_tam);
    XImage *newimage = XCreateImage(
        Mi_display,        // Conexion con el servidor X11
        DefaultVisual(Mi_display, DefaultScreen(Mi_display)),   // Visual
        depth,             // Bits Por Pixel del servidor X11
        ZPixmap,           // Formato
        0,                 // Offset
        (char *)mi_data,   // Arreglo con los datos del pixel
        x_tam,             // Ancho de la imagen
        y_tam,             // Alto de la imagen
        32,                // (8 | 16 | 32) Alineamiento a la palabra...
        0                  // ? bytes_per_line
    );

    //- Copiado de los datos de imagen al arreglo de pixels -----------------
    copiar_imagenX_depth24(Mi_display, newimage);

    return newimage;
}

//= SERVICIOS DE CREACION DE ESTRUCTURAS TIPO Pixmap ========================

Pixmap
IMAGEN_RGB::exportar_pixmap(Display *_display, Screen *_screen, Window _window)
{
    GC gc;
    XImage *Imagen;
    Pixmap el_pixmap;

//    XtDisplay(padre), XtScreen(padre), XtWindow(padre)

    Imagen = exportar_ximage(_display);

    //- Dibuje la imagen en un pixmap ----------------------------------------
    // OJO: Esto que?
// #ifdef MOTIF_ENABLED
//    if ( !Imagen ) return (Pixmap)XmUNSPECIFIED_PIXMAP;
//  #endif
//  #ifndef MOTIF_ENABLED
    if ( !Imagen ) return (Pixmap)NULL;
//  #endif

    el_pixmap = XCreatePixmap(_display, _window,
        x_tam, y_tam, DefaultDepthOfScreen(_screen));

    gc = XCreateGC(_display, _window, 0, NULL);

    XSetFunction(_display, gc, GXcopy);
    XPutImage(_display, el_pixmap, gc, Imagen, 0,0,0,0, x_tam, y_tam);
    XFreeGC(_display, gc);
    XDestroyImage(Imagen);

    return (Pixmap)el_pixmap;
}

#endif // X_ENABLED

#if PLATAFORMA == i386_WIN32_VC
void
IMAGEN_RGB::importar_win32dc(HDC dc, int xpos, int ypos, int ancho, int alto)
{
    int x, y;
    COLORREF p;
    BYTE r, g, b;

    if ( ancho != x_tam || alto != y_tam ) {
        init(ancho, alto);
    }

    for ( y = 0; y < alto; y++ ) {
        for ( x = 0; x < ancho; x++ ) {
            p = GetPixel(dc, x+xpos, y+ypos);
            r = (BYTE)(p & 0x000000FFL);
            g = (BYTE)((p & 0x0000FF00) >> 8);
            b = (BYTE)((p & 0x00FF0000) >> 16);
            putpixel(x, y, r, g, b);
        }
    }
}

void
IMAGEN_RGB::exportar_win32dc(HDC dc, int xpos, int ypos)
{
    int x, y;
    COLORREF p;
    BYTE r, g, b;

    for ( y = 0; y < y_tam; y++ ) {
        for ( x = 0; x < x_tam; x++ ) {
            getpixel(x, y, r, g, b);
            p = (COLORREF)r + 256*((COLORREF)g) + 256*256*((COLORREF)b);
            SetPixel(dc, x+xpos, y+ypos, p);
        }
    }
}
#endif // PLATAFORMA == i386_WIN32_VC

#if PLATAFORMA == PALM_PALMOS_CODEWARRIOR
void
IMAGEN_RGB::exportar_palm(int xpos, int ypos)
{
    BYTE r, g, b;
    int i, j;

    for ( i = 0; i < x_tam; i++ ) {
        for ( j = 0; j < y_tam; j++ ) {
            getpixel(i, j, r, g, b);
            PALM_putpixel(i + xpos, j + ypos, r, g, b);
        }
    }
}
#endif // PLATAFORMA == PALM_PALMOS_CODEWARRIOR

//= METODOS DE PROCESAMIENTO DE IMAGENES ====================================

void
IMAGEN_RGB::aplicar_correccion_gamma(BYTE funcion_gamma[256])
{
    int i, j;
    PIXEL_RGB a, b;

    for ( i = 0; i < y_tam ; i++ ) {
        for ( j = 0; j < x_tam ; j++ ) {
            getpixel(j, i, a.r, a.g, a.b);
            b.r = funcion_gamma[a.r];
            b.g = funcion_gamma[a.g];
            b.b = funcion_gamma[a.b];
            getpixel(j, i, b.r, b.g, b.b);
        }
    }

}

//= METODOS DE PRUEBA =======================================================

void
IMAGEN_RGB::tmp_degradecito(int mtipo)
{
    int i, j;
    PIXEL_RGB c;

    for ( i = 0; i < y_tam ; i++ ) {
        for ( j = 0; j < x_tam ; j++ ) {
            switch ( mtipo ) {
              case 0: c.r = c.g = c.b = 0; break;
              case 2: 
                  //c.r = c.g = c.b = 0; 
                  c.r = (BYTE)(255*RANDOM());
                  c.g = c.r;//(BYTE)(255*RANDOM());
                  c.b = c.r;//(BYTE)(255*RANDOM());
                  break;
              case 3: c.r = 255; c.g = c.b = 0; break;
              case 4: c.g = 255; c.r = c.b = 0; break;
              case 5: c.b = 255; c.r = c.g = 0; break;
              case 6: c.r = (BYTE)((double)(i*256)/y_tam); c.g=c.b=0; break;
              case 7: c.g = (BYTE)((double)(i*256)/y_tam); c.r=c.b=0; break;
              case 8: c.b = (BYTE)((double)(i*256)/y_tam); c.r=c.g=0; break;
              case 9:
                if ( (i % 2 && !(j % 2)) || 
                     (j % 2 && !(i % 2)) ) {
                    c.r = 255;
                    c.g = 255;
                    c.b = 255;
                  }
                  else {
                    c.r = 0;
                    c.g = 0;
                    c.b = 0;
                }
                if ( i == y_tam/2 ) {
                    c.r = 255;
                    c.g = 0;
                    c.b = 0;
                }
                if ( j == x_tam/2) {
                    c.r = 0;
                    c.g = 255;
                    c.b = 0;
                }
                break;
              case 1: default: c.r = c.g = c.b = 255; break;
            }
            putpixel(j, i, c.r, c.g, c.b);
        }
    }

}

void
IMAGEN_RGB::linea(int x0, int y0, int x1, int y1, BYTE r, BYTE g, BYTE b)
{
    double dx, dy;
    double dxdy;
    double dydx;
    int x, y;
    double xx, yy;

    dx = (double)(x1-x0);
    dy = (double)(y1-y0);

    if ( fabs(dx) > EPSILON && fabs(dy/dx) <= 1 && x1 > x0 ) {
        // Pendiente entre -1 y 1
        dydx = dy/dx;
        for ( x = x0, yy = (double)y0; x <= x1; x++ ) {
            y = (int)yy;
            if ( x >= 0 && x < xtam() &&
                 y >= 0 && y < ytam() ) {
                putpixel(x, y, r, g, b);
            }
            yy += dydx;
        }
      }
      else if ( fabs(dx) > EPSILON && fabs(dy/dx) <= 1 && x1 < x0 ) {
        // Pendiente entre -1 y 1
        dydx = dy/dx;
        for ( x = x1, yy = (double)y1; x <= x0; x++ ) {
            y = (int)yy;
            if ( x >= 0 && x < xtam() &&
                 y >= 0 && y < ytam() ) {
                putpixel(x, y, r, g, b);
            }
            yy += dydx;
        }
      }
      else if ( fabs(dy) > EPSILON && y1 > y0 ) {
        // Pendiente mayor a 1 o menor a -1
        dxdy = dx/dy;
        for ( y = y0, xx = (double)x0; y <= y1; y++ ) {
            x = (int)xx;
            if ( x >= 0 && x < xtam() &&
                 y >= 0 && y < ytam() ) {
                putpixel(x, y, r, g, b);
            }
            xx += dxdy;
        }
      }
      else if ( fabs(dy) > EPSILON && y1 < y0 ) {
        // Pendiente mayor a 1 o menor a -1
        dxdy = dx/dy;
        for ( y = y1, xx = (double)x1; y <= y0; y++ ) {
            x = (int)xx;
            if ( x >= 0 && x < xtam() &&
                 y >= 0 && y < ytam() ) {
                putpixel(x, y, r, g, b);
            }
            xx += dxdy;
        }
      }
    ;
}

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