jed_img.C

Ir a la documentación de este archivo.

//===========================================================================
//= jed_img.cc                                                Abril de 1998 =
//=-------------------------------------------------------------------------=
//= 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. =
//===========================================================================

//= ENCABEZADOS DE LIBRERIAS ================================================

#include "jed_defs.h"

//#include <double.h>    // Librerias standard
//#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifdef MOTIF_ENABLED        // Librerias X Window System
    #include <Xm/Xm.h>
#endif

#include "jed_gl.h"  // Librerias de OpenGL

#include "toolkits/media/jed_img.h"

#undef GL_COMPLETO

//===========================================================================
//= FUNCIONES                                                               =
//===========================================================================

#define RANGO(a,b,c) { if (a < b) a = b;  if (a > c) a = c; }

void
calcular_funcion_gamma(BYTE funcion_gamma[256], double factor)
{
    int i, j;
    double y, invgam;

    if (factor < 0.0) {
      invgam = 1.0 / -factor; /* invgram is now positive */
      for (i=0; i<256; i++) {
        y = pow( ((double) i / 255.0), invgam) * 255.0;
        j = (int) floor(y + 0.5);
        RANGO(j,0,255);
        funcion_gamma[255-i] = j;    /* store the entries in reverse order */
      }
    }
    else if (factor > 0.0) {
      invgam = 1.0 / factor;
      for (i=0; i<256; i++) {
        y = pow( ((double) i / 255.0), invgam) * 255.0;
        j = (int) floor(y + 0.5);
        RANGO(j,0,255);
        funcion_gamma[i] = j;
      }
    }
    else {  // factor == 0.0 
      for (i=0; i<256; i++) funcion_gamma[i] = 0;
    }
}

//===========================================================================
//= CLASE IMAGEN                                                            =
//===========================================================================

IMAGEN::IMAGEN()
{
    //printf("IMAGEN::IMAGEN\t"); fflush(stdout);
}

IMAGEN::~IMAGEN()
{
    //printf("IMAGEN::~IMAGEN\n");  fflush(stdout);
}

#ifdef NNN

/* OJO: ESTO NO!
void
IMAGEN::elim(void)
{
    fprintf(stderr, "<IMAGEN>-elim: No se debio haber llamado!\n");
    // al que se debe llamar es a la version de las clases hijas
    fflush(stderr);
}
*/

//= OPERACIONES DE PERSISTENCIA =============================================

BOOLEAN
IMAGEN::importar_ppm(FILE *fd)
{
#ifdef NONONO
    int xtam = 0, ytam = 0;
    int i, j;
    char buffer[MAX_LINE + 1];
    char *ptr = NULL;
    PIXEL_RGB pixel;

    if ( !fd ) {
        fprintf(stderr, "ERROR: No se puede abrir el archivo.");
        fflush(stderr);
        return FALSE;
    }

    //- Inicializacion basada en los datos de la imagen --------------------
    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' && strcmp(buffer, "255\n") == 0 ) {
            break;
          }
          else if ( buffer[i] == '\n' ) {
            ptr = strtok(buffer, " \n");
            if ( ptr ) {
                xtam = atoi(ptr);
                ptr = strtok(NULL, " \n");
                if ( ptr ) {
                    ytam = atoi(ptr);
                }
            }
            i = -1;
        }          
    }

    if ( xtam <= 0 || xtam > 2024 || ytam <=0 || ytam > 2024 ) {
        fprintf(stderr, "Imagen con tamanno %d X %d no aceptada.\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);

    PIXEL_RGB *fila;

    for ( i = y_tam - 1; i >= 0 ; i-- ) {
        fila = &((PIXEL_RGB *)Data)[i*x_tam];
        for ( j = 0; j < x_tam ; j++ ) {
            fread(&pixel, sizeof(PIXEL_RGB), 1, fd);
            //if ( pixel[0] < 5 && pixel[1] < 5 && pixel[2] < 5 ) {
              //pixel[0] = 73; pixel[1] = 97; pixel[3] = 117;
              //pixel[0] = (i*256)/Y_image; pixel[1] = pixel[2] = 0;
            //}
            fila[j] = pixel;
        }
    }

#endif
    return TRUE;
}

//===========================================================================
//= Clase IM_HISTOGRAMA                                                     =
//===========================================================================

IM_HISTOGRAMA::IM_HISTOGRAMA()
{
    int i;

    for ( i = 0; i < 256; i++ ) {
        data[i] = 0;
    }
}

void
IM_HISTOGRAMA::calcule(IMAGEN_PAL &imagen_grises)
{
    int x, y;
    BYTE index;

    for ( x = 0; x < imagen_grises.xtam(); x++ ) {
        for ( y = 0; y < imagen_grises.ytam(); y++ ) {
            index = imagen_grises.getcolorindex(x, y);
            data[index % 256]++;
        }
    }
}

#ifdef GL_ENABLED
void
IM_HISTOGRAMA::pintar_gl(BYTE umbral)
{
    //- Configuracion de OpenGL ----------------------------------------------
    glMatrixMode(GL_PROJECTION);    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);     glPushMatrix();
    glLoadIdentity();
    // OJO: Falta manejar otras cosas como desactivar el modelo de iluminacion
    // y el depth-test para forzar la cosa a salir siempre en 2D

    //- Algoritmo de visualizacion del histograma ----------------------------
    int i;
    long max = 0;
    double x1 = -0.9, x2 = 0.9, y1 = -0.8, y2 = 0.8;

    for ( i = 0; i < 256; i++ ) {
        if ( data[i] > max ) max = data[i]; 
    }

    //glLineWidth(2.5);
    glColor3f(1, 0, 0);
    glBegin(GL_LINES);
    for ( i = 0; i < 256; i++ ) {
        glVertex2d(x1 + (double)i/256, y1);
        glVertex2d(x1 + (double)i/256, y1 + ((double)data[i])/((double)max));
    }
    glEnd();

    glColor3f(1, 1, 0);
    glBegin(GL_LINES);
        glVertex2d(x1, y1);    glVertex2d(x1, y2);
        glVertex2d(x1, y1);    glVertex2d(x2, y1);
    glEnd();

    if ( umbral > 0 && umbral < 255 ) {
        glColor3f(0, 1, 0);
        glBegin(GL_LINES);
            glVertex2d(x1 + (double)umbral/256, y1);
            glVertex2d(x1 + (double)umbral/256, y2);
        glEnd();
    }

    //- Salida ---------------------------------------------------------------
    glMatrixMode(GL_MODELVIEW);    glPopMatrix();
    glMatrixMode(GL_PROJECTION);   glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
}
#endif

void
IM_HISTOGRAMA::imprima(void)
{
    int i;

    for ( i = 0; i < 256; i++ ) {
      //printf("H[%d] = %d.\n", i, data[i]);
        // Esta version simplificada facilita la integracion con aplicaciones
        // externas como "Khoros".
        printf("%ld\n", data[i]);
    }
    fflush(stdout);
}

BYTE
IM_HISTOGRAMA::generar_umbral_seleccion_iterativa(void)
/*
Tomado del cookbook [????], capitulo 3, ejemplo thris
*/
{
    long i, told, umbral, a, b, c, d, N;

    //- Calcule el valor promedio de intensidad de gris en la imagen -------
    umbral = 0;  N = 0;
    for ( i = 0; i < 256; i++ ) {
        umbral += i * data[i];
        N += data[i];
    }
    umbral = (long)(umbral/(double)N);

    // NPI de porque este ciclo! 
    do {
        told = umbral;
        a = 0; b = 0;
        for ( i=0; i <= told; i++ ) {
            a += i*data[i];
            b += data[i];
        }
        b += b;

        c = 0; d = 0;
        for ( i = told + 1; i < 256; i++ ) {
            c += i*data[i];
            d += data[i];
        }
        d += d;

        if ( b == 0 ) b = 1;
        if ( d == 0 ) d = 1;
        umbral = a/b + c/d;
    } while ( umbral != told );

    return (BYTE)umbral;
}

BYTE
IM_HISTOGRAMA::generar_umbral_otsu(void)
{
    int min_index, max_index, i, umbral;
    double p[260], y, z, media_global, varianza_global;
    long N;

    for ( i = 0, N = 0; i < 256; i++ ) N += data[i]; // Puntos en la imagen

    //- Normalice el histograma en una funcion de distribucion 'p' -----------
    for ( i = 0; i < 260; i++ ) p[i] = 0.0;
    for ( i = 1; i <= 256; i++ ) {    
        p[i] = (double)data[i-1]/(double)N;
    }

    //- Minimize la varianza entre grupos ------------------------------------
    // Calcule media y varianza globales
    media_global = otsu_u(p, 256);
    varianza_global = 0.0;
    for ( i = 1; i <= 256; i++ ) {
        varianza_global += (i-media_global) * (i-media_global) * p[i];
    }

    // Notese que solo se considera el maximo intervalo del histograma que ni
    // empieza ni termina con un valor de 0. Aqui se calcula dicho intervalo:
    for ( i = 1, min_index = -1, max_index = -1; i <= 256; i++ ) {
        if ( (min_index < 0) && (p[i] > 0.0) ) min_index = i;
        if ( p[i] > 0.0 ) max_index = i;                  
    }

    // Seleccione el umbral
    z = -1.0;  umbral = 0;
    for ( i = min_index; i <= max_index; i++ ) {
        y = otsu_nu(p, i, media_global, varianza_global);  //- Calcule NU -
        if ( y >= z ) {                  // Es el mayor?
            z = y;                       // Si! ==> Guarde el valor y el indice
            umbral = i;
        }
    }

    return (BYTE)umbral;
}

double
IM_HISTOGRAMA::otsu_u(double *p, int k)
{
    int i;
    double x = 0.0;

    for ( i = 1; i <= k; i++ ) x += (double)i * p[i];
    return x;
}

double
IM_HISTOGRAMA::otsu_w(double *p, int k)
{
    int i;
    double x=0.0;

    for ( i = 1; i <= k; i++ ) x += p[i];
    return x;
}

double
IM_HISTOGRAMA::otsu_nu(double *p,int k,double media_global,double varianza_global)
/*
OJO: ???  -Esto no se entiende!-
*/
{
    double x, sum;

    sum = otsu_w(p, k);
    x = media_global * sum - otsu_u(p, k);
    x = x * x;
    sum = sum * (1.0 - sum);
    if ( sum > 0 ) {
        x = x/sum;
      }
      else {
        x = 0.0;
    }
    return x / varianza_global;
}

/* OJO: ESTO NO!
BOOLEAN
IMAGEN::init(int width, int height)
{
    printf("Imagen en %d x %d? No debio pasar!\n", width, height);
    fflush(stdout);
    return FALSE;
}*/

#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.