Implementación de un cuantizador “midtread” en MATLAB 7.0

La cuantización es el paso necesario para convertir una señal analógica a una digital, cuando se muestrea una señal se convierte del mundo analógico al mundo digital, y es necesario expresarlo en 0s y 1s, dícese bits. Aunque no necesariamente es el proceso de una señal analógica per se, puede ser también, por ejemplo, una imagen que necesita ser representada con una cantidad menor de bits, y por lo consiguiente comprimirla, con pérdidas claro está.

Existen variados tipos de cuantización. El tipo de cuantizador se elige dependiendo de la aplicación en que vaya a ser implementado, esto, de acuerdo a las características de la señal. En este caso se hará un pequeño ejemplo con un cuantizador midtread la grafica siguiente muestra el comportamiento de un cuantizador midtread de 3bits.

Figura 1. Características de un cuantizador midtread de 3 bits

El principal uso de este cuantizador es cuando tenemos una señal simétrica en el espectro positivo y negativo, por ejemplo una señal de audio, aunque también se puede aplicar en una imagen, como se muestra en el párrafo siguiente.

En la Figura 1 el eje equis (x) representa la señal a cuantizar y el eje ye (y) es la información ya cuantizada, delta () son los incrementos en los que se va a dividir la señal y esto depende del número de bits que sea el cuantizador, de lo anterior se puede desprender la siguiente tabla:

Código binario	Nivel de Cuantización (y)	Rango de la señal de entrada (x)
011	-3∆	–3.5∆ <= x < –2.5∆
010	-2∆	–2.5∆ <= x < –1.5∆
001	-1∆	–1.5∆ <= x < –0.5∆
000	0	–0.5∆ <= x < 0
100	0	0 <= x < 0.5∆
101	1∆	0.5∆ <= x < 1.5∆
110	2∆	1.5∆ <= x < 2.5∆
111	3∆	2.5∆ <= x < 3.5∆

La variable delta (∆) puede ser calculada de la siguiente manera

Ora si, vamos a ver el siguiente ejemplo, tenemos la señal de entrada x(n) = 254 254 252 254 255 253 y el rango válido de datos es de 250 a 255, que bien puede ser parte de una imagen ;) .

El primer paso es calcular delta.

Sustituyendo ∆ en la tabla anterior tenemos:

Código binario	Nivel de Cuantización (y)	Rango de la señal de entrada (x)
011	-3(0.71428) = -2.14284	–2.5 <= x < –1.7857
010	-2(0.71428) = -1.42856	–1.7857 <= x < –1.07142
001	-1(0.71428) = 0.71428	–1.07142 <= x < –0.35714
000	0	–0.35714 <= x < 0
100	0	0 <= x < 0.35714
101	1(0.71428) = 0.71428	0.35714<= x < 1.07142
110	2(0.71428) = 1.42856	1.07142 <= x < 1.7857
111	3(0.71428) = 2.14284	1.7857 <= x < 2.5

Para poder tener los datos de forma como se muestra en la Figura 1, es necesario definir cual es la media de nuestro rango, que en este caso es:

Si restamos a la señal de entrada la media obtenida en el paso anterior tenemos que:

x(n) – µ = 1.5 1.5 -0.5 1.5 2.5 0.5

ahora el siguiente paso es cuantizar cada valor utilizando la tablita arriba descrita…

x(0) = 1.5, cae entre 1.07142 y 1.7857 a lo cual corresponde un valor de cuantización de 1.42856 o sea 110 binario.

x(1) = 1.5, cae entre 1.07142 y 1.7857 a lo cual corresponde un valor de cuantización de 1.42856 o sea 110 binario.

x(2) = –0.5, cae entre –0.35714 y –1.07142 a lo cual corresponde un valor de cuantización de –1.42856 o sea 010 binario.

x(3) = 1.5, cae entre 1.07142 y 1.7857 a lo cual corresponde un valor de cuantización de 1.42856 o sea 110 binario.

x(4) = 2.5, cae entre 1.7857 y 2.5 a lo cual corresponde un valor de cuantización de 2.14284 o sea 111 binario.

x(5) = 0.5 cae entre 0.35714 y 1.07142 a lo cual corresponde un valor de cuantización de 1.42856 o sea 010 binario.

A continuación se presenta el código en MATLAB 7.0 para llevar a cabo esta cuantización:

x = [254 254 252 254 255 253];

bits = 3;
rango_superior = 255;
rango_inferior = 250;

delta = (rango_superior - rango_inferior)/((2^bits)-1)

mu = ((rango_superior - rango_inferior)/2) + rango_inferior

x_centrada = x - mu

x_cuantizada = floor(x_centrada/delta+0.5) * delta

y los resultados son:

delta =

    0.7143

mu =

  252.5000

x_centrada =

    1.5000    1.5000   -0.5000    1.5000    2.5000    0.5000

x_cuantizada =

    1.4286    1.4286   -0.7143    1.4286    2.8571    0.7143

DPCM (Differential Pulse Code Modulation), Método diferencial para compresión de señales, Parte I, puro rollo

La teoría del siguiente choro mareador y las figuras pirateadas fueron tomad@s de:
Data Compression: The Complete Reference. David Salomon. Fourth Edition. Springer. 2007. Section 4.26: DPCM
Digital Signal Processing: Fundamentals and Applications. Li Tan. Academic Press. 2008. Section 11.3: Examples of Differential Pulse Code Modulation, and Adaptive DPCM G.721

La compresión por DPCM es parte de la familia de métodos compresión por codificación diferencial. La idea general es usar valores pasados recuperados como base para predecir el dato actual de entrada. Esto se basa en el hecho, por ejemplo, que los pixeles en una imagen o muestras adyacentes en el audio digitalizado se encuentran correlacionadas. Los valores correlacionados son generalmente similares, así que sus diferencias son pequeñas, esto resultando en una compresión.
A continuación se muestra el esquema simple de compresión diferencial para poder entender el principio del DPCM.



                           Codificador                                 Decodificador

Figura 1. CoDec Diferencial

La imagen anterior muestra un ejemplo de un codificador diferencial, se observa como el dato actual se almacena en una unidad de almacenamiento, llámese “Delay” (o retardo pues si no les gusta agringarse), para ser usado para codificar el siguiente dato, o sea, . Claro, la explicación anterior esta sumamente simplificada, en este ejemplo se muestra el uso de un cuantizador, eso significa que se tiene una compresión con perdidas o “lossy” y esto significa que nuestro dato codificado es realmente el cual ya contiene un error de cuantización. Esto significa que la codificación por diferencias (o diferencial, como ustedes gusten y manden) nos mete en un nuevo problema: La acumulación de errores.

Entonces hay que tomar ventaja de lo que se menciona anteriormente, los datos que se van a comprimir están correlacionados. Esto significa que en general un dato depende de varios de sus vecinos, no solamente del anterior. Una mejor predicción puede ser lograda usando N de los datos previos para codificar el valor actual , entonces tendremos una función , para predecir el dato actual .

Ora si, en seguida pueden observar (jeje, como visita al museo) el diagrama del DPCM. (oooooohhhh!)


                          Codificador                                   Decodificador

Figura 2. DPCM

Oquey, oquey, haber encuentren la(s) diferencia(s) entre la Figura 1 y la Figura 2. ¿Está fácil? ¿que no? …

…

…

Pues si, cambiamos “Delay” por “Pred.” y se acabo el asunto.

Si.

Como se explicaba antes, el predictor viene siendo la funcioncica esta:

En donde tenemos que es una función que nos afecta un conjunto de N pixeles y en base a esto obtenemos una mejor predicción de nuestro valor actual, es decir tratamos de minimizar el error introducido por la cuantificación.

Esta es la primera parte de dos, en esta ocasión fue el rollo previo a un ejemplo peque para poder explicar la DPCM.

wavedemo: Herramienta didáctica en MATLAB para wavelets. Ejemplo para descomponer una imagen paso a paso

En este post no voy a hablar de la teoría de las wavelets, eso ya tocará en otra ocasión. Buscando desesperadamente información cuando estaba tratando de entender el “image denoising” usando wavelets, me tope con este demo que trae incluido del toolbox de wavelets en MATLAB. Aquí pongo un ejemplo muy simple para ver como se realiza una transformada wavelet aplicada a una imagen.

Primero se tiene que cargar el demo, simple y sencillamente poniendo lo siguiente en la línea de comandos:

wavedemo

y aparece a continuación la siguiente ventana

Como se muestra en la imagen anterior, se tienen tres opciones, la primera es un buen ejemplo para mostrar los comandos utilizados a bajo nivel por MATLAB para realizar la transformada wavelet de manera secuencial. En este ejemplo presionamos el botón que dice: “Command line mode” y nos muestra la siguiente ventana

como se puede observar, cuenta con varios ejemplos aplicando la transformada wavelet, continuamos presionando el botón que dice “Wavelet 2-D” y nos muestra la siguiente pantalla

Es importante notar en donde dice Image, obviamente se selecciona la imagen que queremos mostrar en el ejemplo, y presionamos “Start >>” para ir paso a paso o “AutoPlay” para que lo reproduzca automáticamente.

A continuación se muestran algunos de los pasos:

¿Qué es un filtro de respuesta finita? (FIR:Finite Impulse Response): Un ejemplo.

Este post trata sobre un ejemplo tomado del Libro: Digital Signal Processing Using MATLAB and Wavelets, de Michael Weeks, Capítulo 3.

Básicamente, existen principalmente tres tipos de filtros: pasabajas que dejan pasar solamente bajas frecuencias; pasaaltas que dejan pasar altas frecuencias y pasabanda que permiten el paso de todo el espectro, no es menester de este ejemplo el explicar en teoría que es un filtro (eso tomaría demasiado) ni tratar el diseño de los mismos (eso tomaría aún más).

El nombre FIR viene de la manera en que el filtro afecta una señal. Una función impulso es una entrada bastante interesante, donde la señal es 0 siempre, excepto en un lugar donde tiene valor de 1 (una unidad). Se llama también delta Dirac en tiempo continuo y delta Kronecker en discreto (shhh!). La respuesta de un filtro FIR a esta entrada es de duración finita, y por lo consiguiente se le da este nombre.

Suponiendo que la Figura 1 tiene una entrada x[n] = [1,0]. La salida sería [0.5,0.5], y cero después de eso. Se pueden obtener estas salidas aplicándolas en orden a la estructura del filtro. En el tiempo 0, x[0] aparece en la entrada, y cualquier cosa antes de esto es cero, que es lo que el elemento delay producirá como salida. En el siguiente intervalo de tiempo x[0] será la salida del delay mientras que x[1] será la entrada actual.

Figura 1: Filtro FIR con coeficientes {0.5,0.5}

¿Cómo se expresa y[n] en forma de ecuación? Como se observa de calcular y[0] y y[1], se tiene exactamente el mismo patrón:

y[0] = 0.5x[0] + 0.5x[-1]

y[1] = 0.5x[1] + 0.5x[0]

esto se generaliza como:

y[n] = 0.5x[n] + 0.5x[n-1]

La Figura 2 muestra la forma general de un filtro FIR, para K+1 coeficientes (son K+1, porque se empieza en 0 y se cuenta hasta K). El número de coeficientes también es llamado taps. Por convención el número de taps es igual al número de coeficientes. Así que un filtro con coeficientes {b0, b1, …, bK} tiene K+1 taps, debido a que tiene K+1 coeficientes. De todas maneras se dice que el orden es K. En otras palabras el orden del filtro y los taps expresan lo mismo pero con diferencia de 1.

Figura 2: Forma generalizada de un Filtro FIR

Con la estructura de la Figura 2 es posible determinar la salida. También es posible determinar la ecuación de la salida, la cual es:

y[n] = b[0]x[n-0] + b[1]x[n-1] + b[2]x[n-2] + … + b[K]x[n-K]

Nótese que para cualquier índice que se usa para b[.] es usado en x[n-.]. Esto significa que podemos representar todo lo que se encuentra al lado derecho de la ecuación como una sumatoria:

¡Hey!, eso parece como una convolución, ¿no es así?

Un filtro pasabajas, puede llamarse también filtro promediador, mientras que un pasaaltas, puede ser llamado filtro diferenciador, debido a que estos términos describen el funcionamiento de los filtros.

Por ejemplo, un filtro FIR con dos coeficientes de 0.5 y 0.5, se observa que la salida es:

y[n] = 0.5x[n] + 0.5x[n-1], o equivalentemente y[n]=(x[n]+x[n-1])/2

dicha salida, encuentra el promedio entre la entrada actual y la anterior. Si se observa la respuesta a la frecuencia de dicho filtro, se observa que las partes de bajas frecuencias (cambian lentamente) aparecen en la salida, mientras que el filtro decrementa las partes de altas frecuencias (cambian rápidamente).

Para el filtro de diferencias, se pueden tener coeficientes de {0.5 , –0.5} donde:

y[n]=(x[n]-x[n-1])/2

Esto da el cambio entre las dos muestras, escalado por 1/2 para ser consistente con el filtro de promedios. Como es de esperarse, la respuesta a la frecuencia de dicho filtro, debe atenuar las partes de cambios lentos en la señal, y enfatizar la parte que cambia rápidamente, concluyendo que es un filtro pasaaltas.

Ejemplo para leer una imagen PGM en Visual Basic 6.0

En el mundo de los programadores de software, Visual Basic no sirve para nada, je je, y para un par de cosas es cierto, pero para el resto, no. Déjenme explicarme un poco en esto. Visual Basic es un lenguaje desarrollado para hacer aplicaciones rápidas, en pocas palabras es un RAD (Rapid Application Development) como a los geeks de IBM los 80's les gusto llamarle.

Así que por ende, debe tener unas cosas por otras, es un lenguaje hasta cierto punto fácil de aprender y puedes desarrollar interfaces graficas de tres patadas, pero, pierdes un poco de control sobre la programación así que nada en cuestiones como programación orientada a objetos y apuntadores), conste no es solo esto, si no una lista que desconozco y tampoco necesito conocer. Otra de las desventajas es la lentitud para ejecutar los programas. Esta última es muy notable si lo comparamos con lenguajes un tanto más específicos para el procesamiento digital de imágenes, como por ejemplo MATLAB, o hasta LabVIEW.

Dejando de lado un poco el rollo, este ejemplo lo iniciaremos haciendo la interfaz gráfica de nuestro ejemplito, en una forma de Visual Basic, no iniciaré desde la creación del proyecto para no volver este post muy largo como el ejemplo de GUIDE. Primero ponemos un PictureBox y un CommandButton, el primero lo dejé con el nombre que le pone por default VB Picture1 y el segundo le puse cmdLoadPGM y le cambié el caption a “Cargar PGM”

La siguiente función es la que se encarga de leer el archivo PGM de la PC, y lo despliega en el Picturebox que le pasamos como parámetro:

Public Function LoadPGMtoPictureBox(strPGMpath As String, myPictureBox As PictureBox)
    
    Dim bytes() As Byte
    Dim pFileLenght As Long
    Dim iWidth As Long
    Dim iHeight As Long
    Dim i As Long
    Dim j As Long
    Dim iCountZeros As Long
    Dim iCounter As Long
    Dim strCatchWidth As String
    Dim strCatchHeight As String
    Dim pFileLength As Long
    Dim ptrToBytes As Long
    Const PGM_MAGIC_NUMBER = "P5"
    Dim u As Long
    Dim u2 As Long
    
    pFileLength = FileLen(strPGMpath)
    
    ReDim bytes(1 To pFileLength)
    
    Open strPGMpath For Binary Access Read As #10
    
        Get #10, 1, bytes
    
    Close #10
        
    If Not Chr(bytes(1)) & Chr(bytes(2)) = PGM_MAGIC_NUMBER Then _
	
        Exit Function
    
    iCountZeros = 0
    iCounter = 4
    strCatchWidth = ""
    strCatchHeight = ""
    
    Do
        strCatchWidth = strCatchWidth & Chr(bytes(iCounter))
        iCounter = iCounter + 1
    Loop While IsNumeric(Chr(bytes(iCounter)))
    
    Do
        strCatchHeight = strCatchHeight & Chr(bytes(iCounter))
        iCounter = iCounter + 1
    Loop While IsNumeric(Chr(bytes(iCounter)))
    
    
    iWidth = CInt(strCatchWidth)
    iHeight = CInt(strCatchHeight)
    
    For i = 0 To iHeight - 1
        For j = 0 To iWidth - 1
            ptrToBytes = ((i) * iWidth) + j
            u = bytes(ptrToBytes + &H10)
            u2 = RGB(u, u, u)
            SetPixelV myPictureBox.hdc, j, i, u2
        Next j
    Next i

    myPictureBox.ScaleMode = 3
    myPictureBox.Height = iHeight
    myPictureBox.Width = iWidth
    
End Function

Codificación RLE para una imagen binaria en MATLAB

La codificacion RLE (Run Length Encoding) se aplica a cadenas de caracteres en las cuales existe una secuencia de datos. En este caso tenemos una imagen binaria, que es resultado de aplicar la extracción de bits a una imagen en escala de grises, como se pretende extraer solo un bit en especifico de la imagen, pues el resultado es una imagen binaria, en la cual se tienen valores de 0 o 1 dependiendo del valor del pixel. La imagen será del mismo tamaño de la imagen original puesto que es una operación de pixel por pixel.

Para visualizar de mejor manera lo que se intenta hacer aquí es menester mostrar un ejemplo. La imagen es una matriz de 2D de MxN, y tendremos para una imagen de 8x8 una matriz como la siguiente:

 

De lo anterior se desprende:

a) Aquí podemos observar la imagen de 8x8 original, en la cual cada valor de la matriz representa un pixel de 8 bits, o sea valores de 0-255.

b) En esta imagen se representa cada valor en su equivalente binario, con el propósito de visualizar el valor en bits de cada pixel.

c) El ultimo ejemplo de estas tres imágenes muestra el valor extraído de cada pixel para el bit mas significativo (MSB), o sea el bit 8.

La matriz que nos interesa es la matriz contenida en c). Para poder codificarla tenemos que tener una cadena de valores en los cuales existan secuencias de valores repetidos. En este caso son solo 0 y 1, y dado a que es una matriz 2D, tenemos que redimensionarla a 1D, y quedaría como se muestra a continuación:

 

Tenemos una secuencia de valores que se representa en 16 caracteres, y debido a que sabemos que tendremos una secuencia de ceros y unos es importante notar el primer número y después de ahí solo se irán alternando.

Necesitamos establecer una manera de poder decodificar nuestra cadena de caracteres, y reconstruir la imagen original, necesitamos saber un par de datos para regresar a nuestra imagen original. Como se decía en el párrafo anterior es necesario saber con que valor se empieza la secuencia de caracteres, también es necesario saber el tamaño de la imagen original, para que al reconstruir la secuencia unidimensional la podamos regresar a 2D de la misma manera que la original.

Así que el encabezado nos quedará mas o menos de la siguiente manera: Fb M N . . . Secuencia . . .

En donde Fb es el primer caracter, M y N es el tamaño de la imagen original y Secuencia, como su nombre lo indica es la cadena de valores que vamos a almacenar iniciando con Fb y alternando hasta terminar. El ejemplo anterior nos quedaría como a continuación:

1 8 8 1 1 1 4 1 3 1 1 1 1 1

Ahora si, despues de tanto rollo, aqui esta el código en MATLAB para hacer esto.

a = imread('c:\matlab7\work\lena.pgm');
[cols rows] = size(a);
b = BitExtraction(a,8,1,1);
figure(1); imshow(a);
figure(2); imshow(uint8(b));
myEncodedImageB = EncodeRLEimage(b);

Este es el código de la función para extraer bits de la imagen:

function x = BitExtraction(myImagen, B, n ,L)

myImagenNueva = myImagen;
[rows cols] = size(myImagen);

for i = 1 : rows
    for j = 1 : cols
        u = double(myImagen(i,j));
        iEne = floor(u/2^(B-n));
        iEneMenosUno = floor(u/2^(B-(n-1)));
       BitExtraido = iEne - (2*iEneMenosUno);
       if BitExtraido == 1
           BitExtraido = L;
       else
           BitExtraido = 0;
       end
       myImagenNueva(i,j) = BitExtraido;
    end
end
x = myImagenNueva;

Este es la función encargada de codificar la imagen.

function eImg = EncodeRLEimage(myImage)
    encoded = [];
    [cols rows] = size(myImage);
    img1D = double(reshape(myImage,1,[]));
    SizeOf1D = cols*rows;
    counter = 0;
    encoded = [img1D(1)];
    for i =1:SizeOf1D-1
        if img1D(i)==img1D(i+1)
            counter=counter+1;
        else
            encoded = [encoded counter];
            counter = 1;
        end
    end

    if counter ~= 1
    encoded = [encoded counter+1];
    end

    eImg = encoded;

¿Sirve de algo?

Technorati Tags: Procesamiento Digital de Imagenes,Tratamiento Digital de Imagenes,Extraccion de Bits,Imagen PGM,Codificacion RLE,RLE

¿Qué es compresión de Imágenes?

Antes de terminar el compresor (que en estos momentos creo que no va a servir mas que de práctica, je je je, bueno, de todos modos no pensaba desbancar al JPG, todavía), quiero explicar un poco que es la compresión de imágenes. Voy a empezar por poner un par de definiciones:

Según Gonzalez et al:

"La compresión de imágenes aborda el problema de reducir la cantidad de datos para representar una imagen digital. La compresión se logra removiendo una o más de las tres posibles redundancias básicas. (a)Redundancia de código: cuando se usan códigos de palabra menos óptimos (de menor longitud). (b)Redundancia interpixelaria: Que resulta de la correlación entre pixeles de una imagen. (c)Redundancia psicovisual: La cual se da debido a los datos que el sistema de visión humano ignora"¹

Según Wikipedia:

"Compresión de imágenes es la aplicación de la compresión de datos en imágenes digitales. En efecto, el objetivo es reducir redundancias en la imagen con el objetivo de transmitirla o almacenarla en una manera eficiente. La compresión puede ser con pérdidas (lossy), o sin pérdidas (lossless). La compresión con pérdidas que produce diferencias imperceptibles se llama también visualmente sin pérdidas (visual lossless)."²

Entonces podemos decir que se trata de reducir el número de bits con necesarios para representar una imagen. Y hay de dos tipos (que pueden ser tres, y no es el chiste del gato). Con pérdidas, sin pérdidas y visualmente sin pérdidas. En el ejemplo de compresor que estoy tratando de hacer, es un compresor con pérdidas, de una imagen en escala de grises de 8 bits.

Pero bueno, ¿cómo le hacemos para saber si el compresor que estamos haciendo vale la pena? Pues fácil, hacemos un montón de pruebas, observamos las imágenes resultantes y la que no se vea tan peor pues decimos que es nuestra imagen codificada usando un compresor con pérdidas. También lo podemos hacer de la manera fancy, usamos PSNR o MSE o cualquier otra medida de error matemática para ver que tanto se distorsiona en referencia con la imagen original.

---

1. Digital Image Processing 2nd Edition (DIP/2e)
   by Gonzalez and Woods
   © 2002. Prentice Hall
   
2. Image Compression
   From Wikipedia, the free encyclopedia. Extracted July 28th, 2009
   

Update del Compresor que estoy haciendo

• Ya tengo el algoritmo para hacer la extracción de Bits.
• Ya tengo el código para codificar la imagen binaria en RLE (gracias JMG, ya lo tenía arrinconado)
• Ya tengo el código para decodificar la imagen codificada con lo anterior

Ahora solo me falta hacer pruebas suficientes para llegar a una conclusión.

Lo voy a terminar...

... algún día.

Idea para un compresor de imágenes con pérdidas usando extracción de bits y codificación RLE a una imagen PGM

Tengo una idea para hacer un compresor de imágenes PGM (por si se preguntan, no, no tengo fijación alguna con este tipo de imágenes solo que es sencillo, ¡gulp!, trabajar con ellas) con pérdidas usando la extracción de bits (medio explicada aquí) y codificación RLE. La idea principal viene de el hecho de que al aplicar un algoritmo extracción de bits a una imagen tenemos un arreglo binario como resultado, tendremos 1 arreglo 2D de ceros y unos por cada bit extraído, es decir que para una imagen de 8-bits, tendremos 8 arreglos de binarios. De esto podemos observar que cada imagen resultante contiene información de la imagen, y se puede observar una degradación empezando del bit más significativo hacia abajo. Se pueden emplear un par de estas imágenes para codificarlas usando un algoritmo de RLE aprovechando que tendremos secuencias de unos y ceros; luego al recuperarlas y aplicarles algún tipo de técnica de Diethering, para mejorar la calidad de la imagen resultante, claro, con pérdida de información con respecto a la original.

A continuación listo los pasos que creo que son necesarios para este algoritmo:

• Aplicar la extracción de bits a la imagen. Resultado: 8 imágenes (1 por bit en este caso)
• Seleccionar las imágenes que serán empleadas para la codificación RLE. Resultado: conjunto de imágenes a comprimir.
• Aplicar RLE a un cada una de las imágenes seleccionadas en el paso anterior. Resultado: n número de conjuntos de datos (1 por imagen). El total de datos obtenidos aquí nos dará como resultado una compresión.
• Para descomprimir la imagen, aplicamos RLE inversa a los conjuntos de datos. Resultado: n número de imágenes binarias.
• Se combinan las imágenes obtenidas en el paso anterior (esto es posible asignando cada bit y reconstruyendo la imagen de 8bits). Resultado: Imagen de 8bits con pérdida de información.
• A la imagen resultante le aplicamos algún tipo de Diethering para mejorar la calidad. Resultado imagen codificada y decodificada con pérdidas.

No se hasta que punto sea posible obtener una buena imagen como resultado, o que tan buena compresión se pueda lograr para mantener un balance entre calidad de imagen y compresión.

Ya pondré los resultados en un post en cuanto tenga algo que valga la pena. :)

Ejemplo para cargar una imagen PGM en LabVIEW sin IMAQ

¡También LabVIEW puede Procesar Imágenes!

Je je, antes de que alguien del cuerpo técnico y ventas de National Instruments lea esto, mejor rectifico.

Dado a la naturaleza de LabVIEW también se pueden implementar un par de algoritmos (ja ja, de acuerdo, el universo de posibilidades es infinito, “the sky is the limit”) de la manera en que se haría con MATLAB (según un ingeniero de campo de NI me platicó que al principio eran una sola compañía lo que ahora es Mathworks y NI, pero en algún punto en el tiempo se separaron, así que se disputan el origen del engine de matrices ambos, claro que el inge de NI juraba que era de ellos, jeje, me imagino que dirían los de Mathworks) , ya saben el paradigma orientado a datos que manejan estos de National Instruments, claro ellos tienen un Toolkit dedicado al procesamiento de imágenes, pero este post se enfocará en implementarlo sin el uso del tan famoso Vision Development Module.

Como ya he puesto en otros posts vamos a leer imágenes PGM ya que LabVIEW no cuenta con una librería para leer este tipo de imágenes. Las imágenes PGM son ampliamente usadas para probar algoritmos de procesamiento digital de imágenes,  son fotos en escala de grises cada byte representa un pixel, es decir 8 bits, 256 posibles escalas de grises.

El ejemplo que propongo consta de un VI (instrumento virtual) principal y 3 subVIs. (Los VIs se pueden ver como la contraparte de las funciones en los programas por texto). La primera parte consta de leer un archivo del disco duro, se lee como archivo binario, como resultado de este se obtiene un arreglo de bytes que contiene los valores leídos en el archivo. En seguida pasa por un parser para el encabezado del archivo PGM, que básicamente comienza con dos bytes en ascii representando “P5”, en seguida viene el ancho, seguido del alto de la imagen, y para finalizar el nivel de grises en que está codificada la imagen. En medio de estos debe de estar como separador un espacio, ya sea un espacio en blanco (0x20), un carrier return (0x0D), un line feed (0x0A) o un tab (0x09). También hay que notar que después del “P5” se pueden tener comentarios y se identifican con el símbolo (#) al principio de la línea. Para más información del formato PGM, favor de ir a la página de la especificación.

A continuación se muestra el VI principal que realiza el leer el archivo, procesar la información y mostrarla en pantalla.

 

 

Una de las funciones del VI “ParsePGMHeader.vi” es determinar si es un archivo válido, es por eso que la salida del VI se alambra a un case para determinar si es válido y continuar o de lo contrario terminar el programa, como se observa en las figuras anteriores. Tengo que agradecer a un miembro del foro de NI (JB) de donde tome el VI para mostrar un msgbox en LabVIEW si lo necesitan pueden checar el foro. (n.d.r: el post es algo viejo y es para una versión de LabVIEW algo vieja por ende, y no se si la versión 8.6 ya tenga algo embebido). A continuación se muestra el diagrama a bloques de “ParsePGMHeader.vi”

Este parser lo que hace es que lee el bufer de bytes que se leen de el archivo y busca el encabezado, de ahí saca el ancho y el alto de la imagen, (tengo que confesar que este algoritmo no cumple completamente con la especificación, ya que asume que la imagen es de 256 niveles de grises, pero eso no es necesariamente cierto según la especificación; y entonces los pixeles ya no serían necesariamente de un byte, sino de dos. :S) Así como también, determina si es un archivo válido. En seguida lee el valor isPGM? y se mete a un case, para determinar si se continúa con la ejecución o se detiene le programa.

En caso de ser verdadero, se agarra el buffer de datos y se obtiene el buffer de la imagen, como datos de entrada se tiene la salida del VI anterior, el cual le pasa el buffer, en donde empieza la imagen y el ancho y alto de la misma. La salida de este VI nos da un arreglo en 2D conteniendo la imagen. A continuacion se muestra el diagrama del VI “GetPGMImageData.vi”.

La salida de este VI se usa para dibujar la imagen PGM en un objeto picture. También da como salida el ancho y alto de la imagen. En seguida se muestra el “DrawPGMImage.vi”. A la cual se le pasa como entrada el arreglo en 2D conteniendo la imagen y a la salida se le conecta  un objeto picture. El diagrama se muestra a continuación.

 

 

Al final en el VI se agrega un nodo de propiedades para poder modificar el ancho y alto de la imagen a mostrar, dependiendo del tamaño de la imagen original.

Como decía al principio, es que se trata de cargar la imagen sin necesidad de tener el Toolkit de procesamiento de imágenes, ya que trae integradas funciones para leer archivos png, jpg y bmp, pero no los pgm. Igual, si quieren los archivos para hacer pruebas solo mándenme un email y se los envío con gusto. Todavía ando viendo como hacerle para poder subir archivos y linkearlos al blog, creo que no me va a quedar de otra que usar un disco virtual.

Simple, ¿no?

Cómo mostrar una imagen transformada con fft2 en GUIDE usando MATLAB7

Este ejemplo es para complementar el ejemplo anterior de “Un ejemplo simple de una interfaz gráfica usando GUIDE en MATLAB para Procesamiento Digital de Imágenes”. En esa ocasión el énfasis que puse fue en mostrar como se crea la interfaz gráfica y como se muestra una imagen en pantalla. Ahora se muestra como agregar el código para mostrar la transformada de Fourier usando la función fft2 que viene incluida en MATLAB.

Si se sigue el ejemplo anterior solamente tendremos que agregar el siguiente código al callback del botón relacionado al procesamiento de la imagen.

% --- Executes on button press in ProcesarImagen.
function ProcesarImagen_Callback(hObject, eventdata, handles)
% hObject    handle to ProcesarImagen (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

 guidata(hObject, handles);

% Carga la imagen de la variable global a una local.
 mImage = handles.myImage; 

% Calcula la transformada de fourier  
 mImage2 = fft2(double(mImage));
% Acondiciona la imagen para mostrar las magnitudes centradas
 s = fftshift(log(abs(mImage2)));
 limites = [(min(s(:))) (max(s(:)))];
 set(handles.axes2, 'CLim', limites);
 image( s, 'Parent', handles.axes2, 'CDataMapping', 'scaled');
 axis(handles.axes2, 'off');
 guidata(hObject, handles);

No tengo manera de subir los archivos todavia, y no quiero ponerlos en un servidor externo así que si alguien le interesa alguno de los ejemplos que aqui se ponen, simplemente manden un email y se los mando

Ejemplo simple de una interfaz gráfica usando GUIDE en MATLAB para procesamiento digital de imágenes

Hace poco que aprendí lo básico de crear interfaces gráficas en Matlab. En realidad es hasta cierto punto simple, pero también creo que no es del todo amigable para crear GUIs. Si, estoy de acuerdo que tiene un estilo de editor para hacernos más fácil la existencia. Pero no es del todo intuitivo, o al menos es lo que pienso en el par de programitas que he tenido oportunidad de hacer. Bueno dejando las quejas a un lado, voy a empezar con el ejemplo. Voy a crear una ventana en la que se cargue una imagen por medio de un botón y desplegarla en la ventana, y hacer un procesamiento sencillo y también mostrarlo en pantalla, se que es un ejemplo muy básico, pero creo que es perfecto para empezar. (o al menos es lo que andaba buscando yo cuando quise hacer esto)

Lo primero que tenemos que hacer es iniciar el editor GUIDE que se puede hacer de dos maneras, la primera es desde el menú de inicio: File –> New –> GUI como se muestra en la siguiente imagen.

También se puede iniciar desde la línea de comandos o “command window” de Matlab poniendo “guide”.  Aparece una ventana de inicio del GUIDE.

La ventana anterior es (como su nombre lo indica) el lanzador rápido para el GUIDE con varias opciones, la que vamos a seleccionar es la que viene por default y presionamos “OK” y nos aparece el editor de interfaces gráficas en blanco, como se muestra a continuación:

Como primer paso vamos a insertar el objeto que nos va a servir para desplegar la imagen en la ventana. En este caso Matlab lo maneja con “axes”, así que presionamos el botón que esta en la barra de herramientas de la izquierda y ponemos dos “axes” que es donde vamos a cargar la imagen original y la procesada, como se muestra en la siguiente imagen.

Luego presionando el botón “Push Button” (1) ponemos dos botones (2) que el primero nos va a servir para seleccionar el archivo de la imagen y el segundo para procesarla, también vamos a mostrar donde se seleccionan y se cambian las propiedades del objeto (3).

En la figura siguiente se muestra el inspector de propiedades “property inspector” en donde podemos modificar las propiedades del botón. En el (1)  se modifica el texto del botón, y en (2), se modifica el nombre del botón.

Modificamos (1) y (2) para cada botón de manera que nos quede como en la imagen siguiente.

 

En donde dice String simple y sencillamente cambiamos el texto que tiene el botón y en donde dice tag se define el nombre del botón, esto es importante, porque aquí es donde definimos el nombre que va a tener la función “Callback” que es la que se manda llamar cuando se presiona el botón. En la imagen siguiente se muestra como queda la GUI con los cambios hechos. Tambien se muestra como tener acceso a la función donde vamos a poner el código que nos cargue la imagen en pantalla.

A continuación se abre la ventana del editor de códigos de MATLAB y nos selecciona el inicio de la función en la que debemos agregarle nuestro código que en este ejemplo nos va a seleccionar un archivo para ponerlo en axes1. 

Una vez que tenemos el editor de MATLAB abierto, buscamos el siguiente código y le agregamos la línea de código que se muestra a continuación, lo que se esta haciendo es agregar una variable para almacenar en memoria la imagen que vamos a cargar .

% --- Executes just before GuiBasica is made visible.
function GuiBasica_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to GuiBasica (see VARARGIN)

% Choose default command line output for GuiBasica
handles.output = hObject;

%Add variable to hold images (Agregar variable para almacenar imágenes)
handles.myImage = [];

% Update handles structure
guidata(hObject, handles);

La línea que agregué en el código anterior es donde dice handles.myImage = []; que nos va a servir para almacenar la imagen temporalmente para procesarla cuando tengamos que hacerlo en el botón que definimos para procesar la imagen.

El código siguiente se agrega en el callback del botón CargarImagen.

% --- Executes on button press in CargarImagen.
function CargarImagen_Callback(hObject, eventdata, handles)
% hObject    handle to CargarImagen (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
try
    [filename,pathname] = uigetfile('*.pgm','Selecciona imagen para abrir');

    if isequal(filename,0)
        %Do nothing yet
    else
        handles.myImage = imread(fullfile(pathname, filename));

        [X, myMap] = gray2ind(handles.myImage);
        mImagen2 = ind2rgb(X,myMap);

        image(mImagen2, 'Parent', handles.axes1);
        colormap(gray);
    end
    guidata(hObject, handles);
catch
    msgbox('Error')
end

Y agregando el código siguiente al callback del botón ProcesarImagen como se muestra a continuación hacemos nuestro ejemplo de procesamiento, aquí solamente voy a hacer el negativo de la imagen para ilustrar el ejemplo con algo simple, en este caso se pretende mostrar como hacer un GUI en MATLAB, no dar una clase de procesamiento de imágenes.

% --- Executes on button press in ProcesarImagen.
function ProcesarImagen_Callback(hObject, eventdata, handles)
% hObject    handle to ProcesarImagen (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
    guidata(hObject, handles);
    mImage = handles.myImage;   
    mImage2 = 255-mImage;
    [X, myMap] = gray2ind(mImage2);
    mImagen2 = ind2rgb(X,myMap);

    image(mImagen2, 'Parent', handles.axes2);

Y a continuación se muestra como queda el resultado final de nuestra GUI.

Si todo se ha hecho como se indica, debería de funcionar. jeje. En caso de que me falte un paso o que algo no se entienda solo manden un correo y trataré de corregirlo. gustavo.ramirez.v@gmail.com

Ejemplo de extracción de bits de una imagen en escala de grises de 8 bits en MATLAB

En este caso supongamos que tenemos una imagen en formato PGM, (escala de grises de 256 niveles, o sea 8 bits). Si queremos extraer la información de cada bit entonces tenemos lo siguiente:

• u, es el valor del pixel al que le vamos a extraer el bit
• B, es el número de bits usado para representar un pixel
• n, es el bit que queremos extraer de cada pixel, B es el menos significativo y 1 es el más significativo
• L, es en nivel máximo que puede tener nuestra imagen

Según Anil K. Jain en su libro Fundamentals of Digital Image Processing, en el capítulo dedicado al mejoramiento de imágenes (o image enhancement), explica la extracción de bits en una imagen y define al pixel u de la siguiente manera: 

y queremos que nuestro pixel resultado v de la extracción de bit sea:

El autor define kn como se muestra a continuación:

En donde:

En  este caso u puede tomar valores entre 0 y 255 (ya que es una imagen PGM de 8 bits). Por ejemplo si decimos que u = 237 y queremos extraer el bit más significativo entonces tenemos que n = 8  y B = 8. Representando u en su equivalente binario tendriamos que u = 11101101. Nos quedaría de la siguiente manera:

1. in = i8 = int[237/(2^8-8)] = 237
2. in-1 = i7 = int[237/(2^8-7)] = int[237/2^1] = int[237/2] = int[118.5] = 118
3. kn = k8 = 237 – 2*118 = 237 – 236 = 1

Enseguida se muestra el codigo en MATLAB para llevar a cabo la extracción de bits de la imagen del bote:

clc;clear;
myImagen = imread('boat.pgm');
myImagenNueva = myImagen;
[rows cols] = size(myImagen);

B = 8;
L = 255;

for n = 1:B
    for i = 1 : rows
        for j = 1 : cols 
            u = double(myImagen(i,j));
            iEne = floor(u/2^(B-n));
            iEneMenosUno = floor(u/2^(B-(n-1)));
            BitExtraido = iEne - (2*iEneMenosUno);
            if BitExtraido == 1
                BitExtraido = L;
            else
                BitExtraido = 0;
            end
            myImagenNueva(i,j) = BitExtraido;
        end
    end
    subplot(2,4,n);
    imshow(myImagenNueva);
    title(['Bit', num2str(n)]);
end