Filtro de entropia para asignatura de Percepción

Computacional.
Los filtros de imagenes tienen mucha utilidad hoy en dia gracias a el aprovechamiento de los recursos digitales y la versatilidad
que tienen estos para cambiar su forma de presentación, sus dimensiones y su equivalencia.

Entropía: métodos basados en el análisis de los resultados de la aplicación de algoritmos que utilizan la entropía de las regiones
frontal y de fondo, la entropía cruzada entre la imagen original y binarizada. [1] En 1948, Claude E. Shannon consiguió medir la
aleatoriedad de la señal transmitida, lo que se traduce en determinar la incertidumbre que lleva, su cantidad de información.[2] La
medida de la información que descubrió Shannon es la entropía. Medida en bits, define la cantidad de información contenida en la
fuente de transmisión a partir de lainformación particular de cada salida.[2]

Para calcular la entropia de una imagen por medio de Lenguaje Python, utilizaremos la libreria de Sci-Kit Image para
procesamiento de imagenes y varias de sus funciones.

In [1]: %matplotlib inline

import numpy as np
import matplotlib
from matplotlib import pyplot
import skimage
from skimage import io, color, feature
from skimage.util import img_as_ubyte
from skimage.filters import rank
from skimage.filters.rank import entropy

Ahora procedemos a digitalizar la imagen a aplicarle el filtro de entropia incluido en la libreria de filtros de Sci-kit Image(skimage)

In [2]: rgbImg = io.imread("tema5_actividad.png")

pyplot.imshow(rgbImg)
pyplot.show()
print(rgbImg.shape)
print(type(rgbImg))

(512, 512, 4)
<class 'numpy.ndarray'>

Como podemos ver, la imagen esta compuesta por 3 componentes las cuales son: alto, largo y profundidad. la funcion de entropia
de python solo acepta vectores de 2 dimensiones, porlo que procederemos a eliminar la profundidad de la imagen con el comando
rgb2gray incluido en Skimage.

In [3]: grayImg = color.rgb2gray(rgbImg)

pyplot.imshow(grayImg,cmap='gray')
pyplot.show()
print(grayImg.shape) # (512,512), a 2 dimensional grayscale image
 (512, 512)

la imagen ha pasado a 2 dimensiones y por consecuencia la imagen ha cambiado de color. para la correcta visualización de la
imagen, debemos agregar el argumento "cmap='gray'" el cual ajusta los gráficos para que se visualizen con el mapa de colores en
la escala de grises.

con el fin de que la funcion de entropia para imagenes de python pueda entregarnos la imagen filtrada, debemos procesar la
imagen nuevamnete, dividiendola en 2 arrays de 2 dimensiones. Esto con el fin de que el filtro pueda realizar el before vs after y
entregarnos el resultado directamente.

Tambien convertiremos la imagen a formato de bytes sin signo (unsigned byte) para eliminar los valores negativos de la imagen (si
los hubiere) y tambien para cambiar los valores de coma flotante (float) por valores enteros de 8 bits, los cuales rondan entre 0 y
255.

Binarización: es una técnica que consiste en la realización de un barrido en la matriz de la imagen digital, por medio de bucles o
recursividad, con el fin de que el proceso produzca la reducción de la escala de grises a dos únicos valores. Negro (= 0) y blanco
(= 255), o lo que es lo mismo, un sistema binario de ausencia y presencia de color 0-1. [1]

In [4]: grayscale_image = img_as_ubyte(grayImg[::2,::2])

#img_as_ubyte#Convert an image to unsigned byte format, with values in [0, 255].

pyplot.imshow(grayscale_image, cmap='gray')
pyplot.show()
print(type(grayscale_image))
print(grayscale_image.shape)
grayscale_image

C:\Users\Escritorio\Anaconda3\lib\site-packages\skimage\util\dtype.py:141: UserWarning: Possible precis

ion loss when converting from float64 to uint8
.format(dtypeobj_in, dtypeobj_out))

<class 'numpy.ndarray'>
(256, 256)

Out[4]: array([[ 0, 130, 254, ..., 52, 100, 202],

[190, 105, 142, ..., 160, 169, 216],
[214, 183, 130, ..., 206, 212, 238],
...,
[248, 226, 225, ..., 132, 121, 175],
[234, 223, 167, ..., 100, 212, 173],
[236, 213, 128, ..., 184, 94, 180]], dtype=uint8)

Con la imagen lista para el filtro de entropia, procedemos a construir los núcleos(tambien llamados matrices de prueba, matrices de
pesos, kernels y mascaras.).

Primero, usaremos una mascara conformada por una matriz de enteros positivos aleatorios de tamaño 3 columnas x 3 filas. Luego,
usaremos una mascara o kernel de 3x3 conformada por unos binarios. Creamos un filtro de entropia para la imagen en los 2
arrays 2D, y usamos las 2 mascaras para observar que pasa si alteramos los valores del kernel de 3x3.
In [5]: list3x3=[[238,0,52]
,[130,105,145]
,[190,94,167]]
mask3x3=np.asarray(list3x3)
maskones3x3=np.ones((3, 3))
graphic1a=rank.entropy(grayscale_image, mask3x3)
graphic1b=rank.entropy(grayscale_image, maskones3x3)

Habiendo aplicado el filtro de entropia a la imagen previamente procesada, procedemos a visualizar los resultados. Debido a que la
imagen ha perdido la profundidad de los colores[4], debemos indicar que la imagen maneja una escala de grises.

In [6]: pyplot.subplot(121)
pyplot.imshow(graphic1a,cmap='gray')
pyplot.tight_layout()
pyplot.subplot(122)
pyplot.imshow(graphic1b,cmap='gray')
pyplot.tight_layout()
pyplot.show()

Por ultimo, calculamos la desviación estandar de los procedimientos y observamos si hubo algún cambio importante.

In [7]: print(graphic1a.shape)
print(rgbImg.std())
print(grayscale_image.std())
print(graphic1a.std())
print(graphic1b.std())

(256, 256)
82.34419385595886
71.38656673323888
0.15180249787763664
0.1528926326329955

Durante todo el procesamiento de la imagen, se observan cambios en la desviación tipica en la información de la imagen. Esto
indica que se han perdido datos durante el proceso. Cuando ingresamos el array de valores aleatorios de 3 columnmas x 3 filas,
logramos emparejar mas píxeles que cuando ingresamos el array de binario. Concluyendo con el primer experimento, encontramos
que con la mascara de valores aleatorios se produce menos entropia.

Siguiendo las indicaciones, procedemos a agrandar el kernel para el filtro de entropia a un valor de 5 columnas x 5 filas.

In [8]: list5x5=[[240,270,0.9,1.7,1.2]
,[0.1,0.6,0.3,1.1,1.9]
,[0.3,2.4,0.7,2.3,1.4]
,[1.0,1.8,190,1.6,2.1]
,[2.7,0.4,1.3,2.9,217]]
mask5x5=np.asarray(list5x5)
maskones5x5=np.ones((5, 5))
graphic2a=rank.entropy(grayscale_image, mask5x5)
graphic2b=rank.entropy(grayscale_image, maskones5x5)

Observamos los resultados del filtro con la función Imshow de matplotlib.pyplot.

In [9]: pyplot.subplot(121)
pyplot.imshow(graphic2a,cmap='gray')
pyplot.tight_layout()
pyplot.subplot(122)
pyplot.imshow(graphic2b,cmap='gray')
pyplot.tight_layout()
pyplot.show()
 aplicamos estadística al resultado. ambos sigma son iguales para las 2 diferentes máscaras de 5x5. Podemos decir que la entropía
aumentó con respecto al primer gráfico.

In [10]: print(graphic2a.shape)
print(rgbImg.std())
print(grayscale_image.std())
print(graphic2a.std())
print(graphic2b.std())

(256, 256)
82.34419385595886
71.38656673323888
0.1658699196884161
0.1658699196884161

La ultima prueba para la imagen será aplicar un filtro de entropia con una máscara de dimensiones 7x7 con valores aleatorios y
otra rellena de unos.

In [11]: list7x7=[[50,2,15,70,25,150,85]
,[30,21,27,3,44,102,56]
,[1,20,50,37,64,12,24]
,[12,65,50,26,90,55,11]
,[6,39,58,70,32,18,44]
,[14,48,36,19,29,10,46]
,[1,20,50,47,17,23,35]]
mask7x7=np.asarray(list7x7)
maskones7x7=np.ones((7, 7))
graphic3a=rank.entropy(grayscale_image, mask7x7)
graphic3b=rank.entropy(grayscale_image, maskones7x7)

Visualizamos los resultados de los filtros.

In [12]: pyplot.subplot(121)
pyplot.imshow(graphic3a,cmap='gray')
pyplot.tight_layout()
pyplot.subplot(122)
pyplot.imshow(graphic3b,cmap='gray')
pyplot.tight_layout()
pyplot.show()

La entropia volvió a aumentar, por ende la imagen se ve mas turbia. no se notan diferencias al cambiar las mascaras.

In [13]: print(graphic3a.shape)
print(rgbImg.std())
print(grayscale_image.std())
print(graphic3a.std())
print(graphic3b.std())

(256, 256)
82.34419385595886
71.38656673323888
0.17330883588497756
0.17330883588497756
Conclusión
Al aplicar un filtro de entropia a la imagen, se pierden datos en el proceso, disminuyendo la calidad de la imagen. Si aumentamos
las dimensiones de la mascara para el filtro, obtenemos que la entropia aumenta y la imagen filtrada se visualizará mas turbia y
desordenada. Los resultados del filtro de entropia se pueden mejorar cambiando los valores de la máscara por valores similares a
los de la imagen. Podemos usar mascaras en binario, enteros y decimales. Los filtros basados en entropia solo entregan
fracciones de la imagen original. Mejorar los resultados implica modificar la mascara en su totalidad, valor por valor. Un ejemplo de
aplicación de los filtros de entropía es cuando queremos reducir la dimensionalidad de una imagen o de una base de datos.[5] si
queremos mejorar la calidad de la imagen en un sector de interés debemos cambiar las dimensiones del núcleo y sus coeficientes
respectivos.

Referencias
[1]R. Magro, "BINARIZACIÓN DE IMÁGENES DIGITALES Y SU ALGORITMIA COMO HERRAMIENTA APLICADA A LA ILUSTRACIÓN
ENTOMOLÓGICA", Boletín de la Sociedad Entomológica Aragonesa (S.E.A.), no. 53, pp. 443,445, 2013.

[2]I. Blasco Hernanz, "ALGORITMOS DE DETECCIÓN DE IMAGENES RUIDOSAS Y DUPLICADAS", Pregrado, Universidad
Autónoma de Madrid, 2008.

[3]"Entropy — skimage v0.15.dev0 docs", Scikit-image.org. [Online]. Available: http://scikit-

image.org/docs/dev/auto_examples/filters/plot_entropy.html. [Accessed: 08- Jan- 2019].

[4]"Tutorial de Digitalizacin de Imgenes - Terminologa bsica", Preservationtutorial.library.cornell.edu, 2003. [Online].

Available: http://preservationtutorial.library.cornell.edu/tutorial-spanish/intro/intro-04.html. [Accessed: 08- Jan- 2019].

[5]M. Romero, M. Camio and M. Álvarez, "USO DE LA ENTROPÍA CONDICIONAL COMO MÉTODO PARA LA REDUCCIÓN DE
DIMENSIONALIDAD. UNA APLICACIÓN EN GESTIÓN DE LA INNOVACIÓN", Pregrado, Universidad Nacional Del Centro de la
Provincia de Buenos Aires, 2015.