img_rgba.C

Ir a la documentación de este archivo.

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

#ifdef VEL_ROSITA
    #include "toolkits/media/img_rgba.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

//===========================================================================
//= Clase IMAGEN_RGBA                                                        =
//===========================================================================

IMAGEN_RGBA::IMAGEN_RGBA()
{
  //printf("IMAGEN_RGBA::IMAGEN_RGBA\n"); fflush(stdout);
    x_tam = y_tam = 0;  Data = NULL; 
  #ifdef GL_COMPLETO
    con_lista = FALSE;
  #endif

  #ifdef MESA_ENABLED
    _contexto_osmesa = 0;
  #endif

}

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

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

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

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

void
IMAGEN_RGBA::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 pixel;
    PIXEL_RGBA *f2, p2;

    for ( i = y_tam - 1; i >= 0 ; i-- ) {
        f2 = &((PIXEL_RGBA *)Data)[i*x_tam];
        for ( j = 0; j < x_tam ; j++ ) {
            p2 = f2[j];
            pixel.r = p2.r;    pixel.g = p2.g;    pixel.b = p2.b;
            fwrite(&pixel, sizeof(PIXEL_RGB), 1, fd);
        }
    }
}


#ifdef NNN

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

    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, a);
            // 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_RGBA::copie(void)
{
    IMAGEN_RGBA *Nueva;
    int x, y;
    BYTE r, g, b, a;

    Nueva = new IMAGEN_RGBA();
    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, a);
            Nueva->putpixel(x, y, r, g, b, a);
        }
    }

    return Nueva;
}

#endif // NNN

#ifdef GL_ENABLED
void
IMAGEN_RGBA::pintar_gl(void)
{
    //printf("IMAGEN_RGBA::pintar_gl\n");  fflush(stdout);
    if ( !Data ) {
        fprintf(stderr,
            "<IMAGEN_RGBA> ERROR: Intentando pintar una imagen nula.\n");
        fflush(stderr);
        return;
    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glRasterPos2f(-1, -1);
    glDrawPixels(x_tam, y_tam, GL_RGBA, GL_UNSIGNED_BYTE, (void*)Data);
}

void
IMAGEN_RGBA::activar_gl(void)
{
    //- Verificacion de sanidad ---------------------------------------------
    //printf("IMAGEN_RGBA::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);

  #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
    if ( ! con_lista ) {
        glGenTextures(1, &lista_gl);
        glBindTexture(GL_TEXTURE_2D, lista_gl);
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, x_tam, y_tam, GL_RGBA, 
                          GL_UNSIGNED_BYTE, (void*)Data);
        con_lista = TRUE;
    }
    glBindTexture(GL_TEXTURE_2D, lista_gl);
  #endif
}

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

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

#endif // GL_ENABLED


BOOLEAN
IMAGEN_RGBA::generar_con_stencil(IMAGEN_RGB *Origen, BYTE r, BYTE g, BYTE b)
{
    //-----------------------------------------------------------------------
    if ( !init(Origen->xtam(), Origen->ytam()) ) return FALSE;

    //-----------------------------------------------------------------------
    int x, y;
    BYTE l = 255, m = 100, n = 10, a = 255;

    for ( x = 0; x < xtam(); x++ ) {
        for ( y = 0; y < ytam(); y++ ) {
            Origen->getpixel(x, y, l, m, n);
            if ( l == r && m == g && n == b ) a = 0;
            else a = 255;
            putpixel(x, y, l, m, n, a);
        }
    }
    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.