BENEMÉRITA UNIVERSIDAD

AUTÓNOMA DE PUEBLA

“Facultad de Ciencias de la Computación”

Procesamiento Digital de Imagenes

Tarea No.5

FILTROS DE ACLARADO

Víctor Manuel Morales de Jesús

Otoño 2012

DESARROLLO

Se realizó la implementación de corrección de gamma los filtros de aclaramientos

logarítmico y senoidal . A continuación se explicara detalladamente el desarrollo de cada

método.

a) Corrección Gamma

Para implementar este método, se utilizó la siguiente formula:

Donde ingresando el valor gamma podremos alterar la iluminación de la imagen

asignando un nuevo valor a cada pixel de la imagen resultante. El código que realiza esta

tarea es el método siguiente:

public BufferedImage gamma(double gamm){ double gamma=gamm; datos.clear(); conjuntoDatos.removeAllSeries(); imagenModificada = new BufferedImage(imagenOriginal.getWidth(), imagenOriginal.getHeight(),

BufferedImage.TYPE_INT_RGB); for (int i = 0; i < imagenModificada.getWidth(); i++){ for (int j = 0 ; j < imagenModificada.getHeight() ; j++){ int color=imagenOriginal.getRGB(i,j); Color color_obtenido = new Color(color); int col_rojo= color_obtenido.getRed(); int rojoGamma =(int)( 255.0*Math.pow(col_rojo/255.0,gamma)); int col_verde= color_obtenido.getGreen(); int verdeGamma =(int)( 255.0*Math.pow(col_verde/255.0,gamma));

int col_azul= color_obtenido.getBlue(); int azulGamma =(int)( 255.0*Math.pow(col_azul/255.0,gamma)); int colorRGB=(rojoGamma << 16) | (verdeGamma << 8) | azulGamma; imagenModificada.setRGB(i, j, colorRGB);

datos.add(col_rojo,rojoGamma); } } return imagenModificada; //retorno la imagen para pintarla }

En las líneas marcadas de color amarillo se realiza la implementación de la formula para

obtener el nuevo color de la imagen resultante, en la Figura 1 se muestra una imagen a la

cual se le aplicó la corrección gamma y a continuación en se muestran los resultados

obtenidos con diferentes valores de gamma así como la gráfica de la función para cada

caso.

Valor de gamma establecido a 0.5

Se puede observar claramente que existe un aclaramiento en la imagen, la cual ahora se

aproxima a los tonos más claros.

Figura 1. Imagen a la que se le aplicara la corrección gamma

Valor de gamma establecido a 1

En la imagen superior podemos observar que con un valor de gama igual a 1, la imagen

resultante es exactamente igual a la imagen fuente, esto debido a que aplicando la

formula, la variacion del color del pixel resultante no se ve afectado, eso lo podemos

observar en la grafica de la funcion, donde obtenemos la funcion identidad.

Valor de gamma establecido a 2.5

En la imagen se puede observar que con un valor de gamma mayor a 1 la imagen tiende a

oscurecerse y por lo consiguiente la gráfica de la función muestra la tendencia de los

colores de la imagen hacia los tonos oscuros.

En el programa se ha decidido poder elegir un valor gamma máximo de 5, esto debido a

que con valores superiores la imagen prácticamente quedaría en negro como lo muestra

la siguiente figura.

b) Función Logarítmica

Para realizar el aclarado de la imagen utilizando la función logarítmica utilizamos la

siguiente formula:

.

En este caso necesitamos un valor de alfa, el cual pasaremos desde un JComboBox, el

código que realiza el aclarado logarítmico es el siguiente:

public BufferedImage aclaradoLogaritmo (double alf){ double alfa=alf; int maxr=0, maxg=0, maxb=0; double tempr,tempg,tempb, ar, ag, ab; datos.clear(); conjuntoDatos.removeAllSeries(); imagenModificada = new BufferedImage(imagenOriginal.getWidth(), imagenOriginal.getHeight(),

BufferedImage.TYPE_INT_RGB); for (int i = 0; i < imagenModificada.getWidth(); i++){ for (int j = 0 ; j < imagenModificada.getHeight() ; j++){ int color=imagenOriginal.getRGB(i,j); Color color_obtenido = new Color(color); int col_rojo= color_obtenido.getRed(); if(col_rojo>maxr) maxr=col_rojo; int col_verde= color_obtenido.getGreen(); if(col_verde>maxg) maxg=col_verde; int col_azul= color_obtenido.getBlue(); if(col_azul>maxb) maxb=col_azul; } } for(int i = 0;i <imagenModificada.getWidth();i++) for(int j=0; j<imagenModificada.getHeight();j++){ ar = (double) (maxr/Math.log((alfa*maxr) +1)); ag = (double) (maxg/Math.log((alfa*maxg) +1)); ab = (double) (maxb/Math.log((alfa*maxb) +1)); int color=imagenOriginal.getRGB(i,j); Color color_obtenido = new Color(color); int color_rojo= color_obtenido.getRed(); int color_verde= color_obtenido.getGreen(); int color_azul= color_obtenido.getBlue(); tempr = (double) ( ar * ( Math.log( (alfa * color_rojo) + 1 ) ) ); tempg = (double) ( ag * ( Math.log( (alfa * color_verde) + 1 ) ) ); tempb = (double) ( ab * ( Math.log( (alfa * color_azul) + 1 ) ) ); if(tempr<0) color_rojo=0; else if(tempr>255) color_rojo=255; else color_rojo = (int)tempr; if(tempg<0) color_verde=0; else if(tempg>255) color_verde=255; else color_verde = (int)tempg; if(tempb<0) color_azul=0; else if(tempb>255) color_azul=255; else color_azul= (int)tempb; int colorRGB=(color_rojo << 16) | (color_verde << 8) | color_azul; imagenModificada.setRGB(i, j, colorRGB); datos.add(color_rojo,); } return imagenModificada; }

En las líneas marcadas de amarillo se encuentran las operaciones establecidas en la

fórmula para obtener el aclarado de la imagen aplicando la función logarítmica, los if’s los

empleo únicamente para verificar que los valores obtenidos de las operaciones se

encuentren en un rango de 0 a 255, ya que si excediera de esos rangos existirían

problemas al pintar el pixel de la imagen.

En las imágenes siguientes se muestran distintas pruebas realizadas con diferentes valores

para el valor de alfa, mostrando distintos niveles de aclaramiento según el valor de alfa.

Valor Alfa establecido a .20

En la imagen superior se muestra el resultado de aplicar el filtro logaritmico con un valor alfa igual

a 20, se puede observar que el resultado es bueno, ya que presenta una aclarado uniforme de la

imagen.

Valor Alfa establecido a 1

En la imagen superior se muestra el resultado de aplicar el filtro logaritmico con un valor alfa igual

a 1, que es el mayor valor alfa que puede establecerse, se puede observar claramente la diferencia

con la imagen anterior.

b) Función Seno

Para implementar el aclarado por medio de la función Seno, partimos de la formula

siguiente:

El código que realiza el filtro utilizando la función seno es el siguiente:

public BufferedImage aclaradoSeno(){ datos.clear(); conjuntoDatos.removeAllSeries(); int maxr=0, maxg=0, maxb=0; double tempr,tempg,tempb, ar, ag, ab; imagenModificada = new BufferedImage(imagenOriginal.getWidth(), imagenOriginal.getHeight(),

BufferedImage.TYPE_INT_RGB); for (int i = 0; i < imagenModificada.getWidth(); i++){ for (int j = 0 ; j < imagenModificada.getHeight() ; j++){ int color=imagenOriginal.getRGB(i,j); Color color_obtenido = new Color(color); int col_rojo= color_obtenido.getRed(); if(col_rojo>maxr) maxr=col_rojo; int col_verde= color_obtenido.getGreen(); if(col_verde>maxg) maxg=col_verde; int col_azul= color_obtenido.getBlue(); if(col_azul>maxb) maxb=col_azul; } } for(int i = 0;i <imagenModificada.getWidth();i++) for(int j=0; j<imagenModificada.getHeight();j++){ int color=imagenOriginal.getRGB(i,j); Color color_obtenido = new Color(color);

int col_rojo= color_obtenido.getRed(); int col_verde= color_obtenido.getGreen(); int col_azul= color_obtenido.getBlue(); ar = Math.PI * col_rojo/(2*maxr); ag = Math.PI * col_verde/(2*maxg); ab = Math.PI * col_azul/(2*maxb); tempr = (double)(maxr * Math.sin(ar)); tempg = (double)(maxg * Math.sin(ag)); tempb = (double)(maxb * Math.sin(ab)); if(tempr<0) col_rojo=0; else if(tempr>255) col_rojo=255; else col_rojo = (int)tempr; if(tempg<0) col_verde=0; else if(tempg>255) col_verde=255; else col_verde = (int)tempg; if(tempb<0) col_azul=0; else if(tempb>255) col_azul=255; else col_azul= (int)tempb; int colorRGB=(col_rojo << 16) | (col_verde << 8) | col_azul; imagenModificada.setRGB(i, j, colorRGB); } return imagenModificada; }

En el texto marcado se muestra la implementación de la fórmula para obtener el filtro,

donde se realizan las operaciones.

El resultado de aplicar el filtro de la función seno es el que se muestra en la siguiente

imagen:

CONCLUSIONES

Podemos concluir aunque existen distintos tipos de filtros de aclarado de imágenes

como lo son Corrección Gamma, Filtro de Función Logaritmo, Filtro de Función Seno,

cada uno de estos filtros permiten obtener resultados muy específicos, aunque a simple

vista el resultado es aparenta ser muy similar, cada filtro brinda la posibilidad de obtener

el aclarado de una imagen según se requiera.

Una ventaja de los filtros elaborados es que son muy simples de implementar y de igual

forma no son costosos en recursos para su implementación.

Por ultimo puedo concluir que debido a la posibilidad de poder usar los distintos filtros, es

posible un mejor procesamiento de las imágenes digitales, ya que cada uno de ellos puede

obtener mejores resultados en imágenes con características distintas.