Ejemplo simple de Listbox en GUIDE de MATLAB 7.0

En el siguiente ejemplo se muestra como agregar un Listbox, introducir nuevos elementos a la lista y desplegar un valor seleccionado de la lista. El código se puede descargar aquí. La explicación paso a paso va como sigue:

Iniciamos tecleando “guide” desde la línea de comandos de MATLAB como se muestra en la siguiente figura:

Y nos mostrará el cuadro de dialogo de GUIDE como se muestra en la imagen siguiente:

Elegimos “Blank GUI (Default)” y presionamos “OK”, dependiendo de la velocidad de la máquina con que estemos trabajando nos mostrará el siguiente cuadro de dialogo… hay que esperar a que se inicialice todo.

Enseguida nos muestra la pantalla principal de GUIDE, que es donde vamos a empezar a agregar controles para hacer nuestra aplicación.

En este punto es bueno grabarlo con un nombre, por si las dudas para si algo, para poderlo estar grabando continuamente. En este caso yo lo nombré: “Ejemplo_ListBox.fig”, automáticamente genera el código “Ejemplo_ListBox.m” en el que vamos a estar trabajando.

A continuación seleccionamos la herramienta “Listbox” y dibujamos la lista en el área de trabajo como se puede observar en la imagen siguiente:

Una vez con el control “Listbox” en el área de trabajo lo siguiente es personalizarlo, para darle un nombre e inicializarlo de requerirse así. Tenemos que dar click izquierdo sobre el control y seleccionar “Property inspector” como se muestra en la imagen siguiente:

Una vez seleccionado “Property Inspector” nos debe aparecer una ventana como se muestra a continuación:

En la imagen anterior se muestran todas las propiedades de nuestro control, para este ejemplo solamente modificaremos los campos de:

1. String: Que es básicamente el texto que aparece en nuestra GUI

2. Tag: Que es el nombre que tiene en nuestra aplicación este objeto

Si lo ejecutamos (Ctrl + T) en este momento, debemos tener una ventana como se muestra a continuación:

Ahora vamos a agregarle un botón para mostrar en un mensaje el texto que tenemos seleccionado en el “Listbox”, yo lo llame “miBoton” y le puse “Mostrar Selección”

Ahora tenemos que agregarle código al botón para que muestre lo que tenemos seleccionado, para eso tenemos que dar click derecho sobre el botón y seleccionar “View Callbacks –> Callback” como se muestra en la imagen siguiente:

La pantalla siguiente nos lleva a nuestro editor y se muestra seleccionado el inicio del callback, notese que el callback es donde agregamos el código de la acción que va a realizar nuestro objeto, en este caso el botón.

Ahora agregamos el siguiente código en el miBoton_Callback:

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

miTexto = get(handles.miCajaDeLista,'string')  %Obtiene todos los valores de la lista

indice_seleccionado = get(handles.miCajaDeLista,'Value'); %Nos dice que posición esta seleccionada

h = msgbox(miTexto,'¿Qué tenemos?','help')    %Muestra la selección en una caja de texto

El código anterior simplemente muestra la selección en una caja de texto, para mostrar como agregar items en tiempo real a la lista acomodamos el tamaño de la lista y agregamos otro botón para introducir lo que nosotros necesitemos en el “Listbox”, como se muestra en la imagen siguiente:

 

A continuación se muestra el código de Agregar_Listbox_Callback, con este código se agrega un nuevo Item en la lista.

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

% Muestra un cuadro de dialogo para introducir un nuevo item en la lista
prompt = {'Nombre'};
dlg_title = 'Agrega un Item a la Lista';
respuesta  = inputdlg(prompt,dlg_title);

% Obtiene todos el contenido de la lista
t = get(handles.miCajaDeLista, 'String');
if ischar(t); t = cellstr(t); end

% Agrega el nuevo Item en la lista
t = [t; respuesta];
% Muestra el nuevo Item en la lista
set(handles.miCajaDeLista, 'String', t);

A continuación se muestra como se ve cuando ejecutamos el GUI y le agregamos un nuevo Item.

Y como se despliega el Item seleccionado en el “Listbox”

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

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:

Graficar la respuesta a la frecuencia y los polos y ceros de un filtro FIR en MATLAB

En este ejemplo se grafican los filtros que vienen como ejemplo en el post anterior: ¿Qué es un filtro de respuesta finita? (FIR:Finite impulse Response). Un ejemplo.

Si tenemos un filtro como se muestra a continuación:

Lo podemos graficar en MATLAB con el siguiente código:

RaizDeDos = 2^(1/2);
h = [1/RaizDeDos 1/RaizDeDos];
freqz(h,1);

La función freqz ejecutada de la manera anterior nos regresa una ventana con la siguiente información:

Como se puede observar nos regresa la magnitud y la fase del filtro, pero solo nos muestra hasta pi, para graficar la respuesta de 2pi, tenemos que hacerlo de la siguiente manera:

RaizDeDos = 2^(1/2);
h = [1/RaizDeDos 1/RaizDeDos];
freqz(h,1,'whole');

Si, es de la misma manera, simplemente  se le agrega ‘whole’ a la función freqz. Para mas información simple y sencillamente teclear doc freqz para acceder a la documentación de MATLAB. La respuesta a la frecuencia queda como a continuación:

Para graficar los polos y ceros del filtro, el código en MATLAB es de la siguiente manera:

RaizDeDos = 2^(1/2);
h = [1/RaizDeDos 1/RaizDeDos];
z = roots(h);
zplane(z',1);

Como se observa, primero se tienen que calcular las raíces de h, ya que tenemos que

y

Así que para calcular los ceros tenemos que calcular las raíces de z en h, por eso la línea z=roots(h); y como nos regresa un vector columna, ponemos la transpuesta en la función zplane. La gráfica quedaría como se muestra a continuación:

Si, es simple como eso, pero para poder llegar a eso tuve que pelearme un buen rato con MATLAB, por eso es que aquí lo pongo, jeje.

 

Technorati Tags: MATLAB,FIR,zplane,freqz,filtros

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

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

¿Cómo demonios se supone que debo interpretar esto? Cuantización escalar uniforme de una imagen en MATLAB

Una parte fundamental del procesamiento digital de imágenes, es la representación de una imagen. De manera muy general, si vemos una imagen como parte de un sistema de adquisición de datos, el sensor es el que se encarga de capturar el brillo de la luz y convertirla a valores que puedan ser usados digitalmente, es nuestro convertidor análogo a digital. De acuerdo a lo que establece Sonka, Hlavac y Boyle en Image Processing, Analysis, and Machine Vision (Ed. Thompson, 2008, USA), la transición entre los valores continuos de la función de la  imagen (brillo) y sus equivalentes en el mundo digital se le llama cuantización, y el número de niveles de cuantización debe ser lo suficientemente grande como para permitir que el ser humano perciba los detalles finos del sombreado en la imagen. 

En este ejemplo vamos a trabajar con una imagen PGM, que al leerla en MATLAB nos regresa una matriz de tamaño NxM. Cada elemento representa un pixel en la imagen, con valores que van de 0 a 255, es decir 256 valores diferentes (8bits). A esta imagen también le podemos aplicar una cuantización ya que con menos bits es posible representar la imagen, con pérdidas debido a que son menos niveles de grises disponibles para mostrar la imagen.

1. %Lee imagene PGM
2. imagen = double(imread('peppers.pgm'));
3. %Crea variables temporales
4. imgQuantized = zeros(512,512);
5. imgQuantizedToDisplay = zeros(512,512);
6. n = 2; %Define bits para cuantización
7. figure();
8. imgQuantized = floor(imagen/(256/(2^n)-1)); %Cuantizar
9. imgQuantizedToDisplay = ((imgQuantized)*(256/2^n));
10. imshow(uint8(imgQuantizedToDisplay));
11. title(['Cuantización a ', num2str(n) ,' bits']);
12. n = 4; %Define bits para cuantización
13. figure();
14. imgQuantized = floor(imagen/(256/(2^n)-1)); %Cuantizar
15. imgQuantizedToDisplay = ((imgQuantized)*(256/2^n));
16. imshow(uint8(imgQuantizedToDisplay));
17. title(['Cuantización a ', num2str(n) ,' bits']);
18. n = 6; %Define bits para cuantización
19. figure();
20. imgQuantized = floor(imagen/(256/(2^n)-1)); %Cuantizar
21. imgQuantizedToDisplay = ((imgQuantized)*(256/2^n));
22. imshow(uint8(imgQuantizedToDisplay));
23. title(['Cuantización a ', num2str(n) ,' bits']);

 

Con n=2 bits podemos representar 2^n=2^2=4 niveles distintos de grises. Así mismo, con n=4 bits podemos representar 2^n=2^4= 16 niveles y con n=6 bits se representan 2^n=2^6=64 niveles en escala de grises.