Universidad de Cuenca

Facultad de Ingeniera
Ingeniera Electrnica y Telecomunicaciones
Laboratorio Procesamiento Digital de Seales.
Juan P. Narvez Bernal
Ral B. Suquinagua Otavalo

INFORME PRCTICA 6: Procesamiento digital de imgenes: Filtrado en el dominio

espacial y filtrado de imgenes en el dominio de la frecuencia aplicando la DFT.

Objetivos.
Procesar una imagen digital mediante filtros lineales y no lineales aplicados en el dominio
espacial de la imagen.
Reforzar los conocimientos sobre aplicaciones de la DFT en el filtrado de imgenes.
Utilizar la transformada de Fourier bidimensional para aplicar un filtro del tipo notch a una
imagen con el fin de eliminar un patrn del tipo moir.

Marco terico.

a) Explique cmo se realiza la convolucin en dos dimensiones

Ya se ha estudiado la convolucin de una sola dimensin es decir se ha procesado solo al pixel de

una fotografa individualmente lo que se proceder a analizar es la convolucin en dos
dimensiones esto sera realizando un procesamiento en una vecindad de cada pixel, este proceso
consiste en:

Definir un pixel central

Ejecutar la operacin sobre los pixeles de una zona predefinida (vecindad)
El resultado de la operacin es la respuesta del proceso en el pixel
Repetir el proceso para los dems pixeles

Se recordara como se realizaba la convolucin en una dimensin para que sea ms fcil explicar la
de dos dimensiones.
Para realizar la convolucin tenamos que rotar 180 a la seal (w) y colocbamos el valor de ms
a la derecha de la seal coincidiendo con el origen de f (j). Luego se completaba con ceros (k), el
primer valor de la convolucin es la suma de productos en la posicin mostrada (k), movemos una
posicin a la derecha y repetimos el proceso (l) hasta llegar a la ltima posicin que se definir
como (n) se muestra detalladamente en la figura1.

El resultado en (o) llamado full, implica un clculo en la manera vista con la imagen completada
con ceros. Recordar la convolucin daba la suma de los 2 anchos.
El resultado en (p) llamado same tiene el mismo tamao que f y se calcula agregando ceros a la
imagen pero se comienza con el punto central de la mscara del filtro (valor 3).

Figura1. Convolucin en una dimensin.

En nuestro caso discreto que son las imgenes la matriz de peso es una matriz de nmeros. Este
filtro es el que rotamos y desplazamos. El pixel (r,c) en la imagen de salida es la suma pesada de
los pixeles de la imagen original vecinos a (r,c). Cada pixel es multiplicado por el peso
correspondiente y la suma de esos productos es el valor del pixel de la imagen final como se
muestra a continuacin.
 Figura2. Convolucin en dos dimensiones.

La operacin matemtica en que consiste la convolucin es simplemente una suma pesada de

pxeles vecinos del pxel fuente. Los pesos son determinados por una matriz llamada mscara de
convolucin, que determina los coeficientes a aplicar sobre los puntos de una determinada rea.
Las dimensiones de la matriz son normalmente impares e iguales, de forma que se pueda
determinar un centro de una matriz cuadrada. La posicin del valor central se corresponde con la
posicin del pxel de salida.

La suma de los pesos en la mscara de convolucin afecta a la intensidad general de la imagen

resultante las mscaras de convolucin tienen coeficientes que suman un total de 1 las mscaras
de convolucin (como las usadas en deteccin de bordes) tienen coeficientes positivos y negativos
y suman un total de 0.
Al realizar la convolucin se presenta un problema que es como tratar los bordes de la imagen.
Cuando la ventana de convolucin se centra en el primer pxel de una imagen en (0,0), la ventana
deslizante sobresale de la imagen en el borde superior y en el izquierdo. Qu valores de la
imagen deben ser multiplicados por esos coeficientes de convolucin que sobresalen de los
bordes?

Existen varias soluciones para resolver ese problema los cuales veremos 2 soluciones que son:

La primera solucin es tratar las celdas vacas en la ventana de convolucin como ceros. Esto se
conoce como zero-padding. Es fcil de realizar pero no es una buena idea si los bordes de la
imagen resultante son tan importantes como el resto de la imagen.

La siguiente solucin es empezar la convolucin en la primera posicin donde la ventana no

sobresalga de la imagen. Si la mscara de convolucin es de tamao 3x3, se empezara
convolucionando con el pxel en (1,1) en vez del pxel en (0,0). Este mtodo es sencillo de
implementar. En la imagen de salida, los bordes convolucionados son copiados para crear una
imagen con el mismo tamao que la imagen de entrada. [1]

b) Explique cmo se interpreta la imagen resultado de obtener la transformada de

Fourier de una imagen.

Se pueden asociar las frecuencias de la transformada de Fourier con patrones de variacin de las
intensidades de la imagen. La frecuencia ms baja corresponde al promedio de los valores de gris
de la imagen. Mientras nos alejamos del origen, las frecuencias corresponden a variaciones suaves
en los tonos de gris. Conforme nos alejamos ms las frecuencias altas empiezan a corresponder a
cambios rpidos o abruptos en los tonos de gris como son por ejemplo los bordes de los objetos
y/o el ruido. [2]

Figura3. a) Imagen de un circuito integrado. b) Espectro de Fourier de la imagen a).

Desarrollo.
1.1. Parte 1: Filtrado de Imgenes Digitales en el dominio espacial.

a) Implemente el Algoritmo de la convolucin en dos dimensiones.

1) Imprima el cdigo fuente de la funcin myConv2.m.

function [y]= myconv2(x,h,var)

[n m]=size(x);
[n1 m1]=size(h) ;
%Se calcula el padding de cada kernel
pad=(n1-1)/2;
%Rota el kernel a 180
h=rot90(h,2);
if var=='same'
%Se crea una matriz que contendr a la imagen, para insertarle ceros
alrededor dependiendo del padding.
zI=zeros(n+(pad*2), m+(pad*2)); % se crea la matriz de ceros
zI(pad+1:n+pad,pad+1:m+pad)=x;
[n m] = size(zI);
%Se crean variables auxiliares
I0 = zeros();
for x = pad+1: n-pad
for y=pad+1: m-pad
aux1 = zI(x-pad: x+pad, y-pad: y+pad);
aux2 = aux1.*h;
I0(x,y) = sum(aux2(:)) ;
end
end
%Devuelve la imagen a su tamao original, quitandole el padding.
y = I0(pad+1: n-pad,pad+1: m-pad) ;
else
zI=zeros(n+(pad*2)+2, m+(pad*2)+2);
zI(pad+2:n+pad+1,pad+2:m+pad+1)=x;
[n m] = size(zI);
I0 = zeros();
for x = pad+1: n-pad
for y=pad+1: m-pad
aux1 = zI(x-pad: x+pad, y-pad: y+pad);
aux2 = aux1.*h;
I0(x,y) = sum(aux2(:)) ;
end
end
y = I0(pad+1: n-pad,pad+1: m-pad) ;
end

2) Explique el funcionamiento de su algoritmo.

La funcin myconv2 tiene tres variables de ingreso que son x la matriz de entrada, h la matriz de
ncleo (respuesta al impulso) y var que sirve para identificar si se visualiza la matriz completa para
que se d este caso var debe ser igual a cualquier palabra diferente de same o solamente la
matriz central es decir una matriz con el tamao de la matriz entrante para la cual var debe de ser
same.
Lo primero que se hace es obtener el tamao de las matriz x y h luego se calcula el padding de
cada ncleo para poder saber el nmero de iteraciones, se invierte la matriz h de forma que gire
180 grados, se realiza una pregunta para ver si se muestra la matriz completa o solamente su
matriz del centro como se explic anteriormente. Luego se cre una matriz de ceros y se coloca en
el centro la matriz x la cual llamaremos zI, luego se crean los for que bsicamente realizan todo el
programa que consiste en ir generando matrices del tamao de h de la matriz zI y ambas matrices
se multiplican y se almacenan en I0 y as sucesivamente se mueven todos las posiciones de zI
Una vez que se guardan todos los valores se separan eliminamos las columnas y filas que tenga
ceros y mostramos el resultado ya sea este en el caso same o en el caso full la matriz resultante.

b) Filtrado del Ruido de tipo Sal y Pimienta

Para esta seccin del informe trabajaremos sobre la imagen lena512.bmp corrompida con ruido
del tipo `salt & pepper'. Utilice el cdigo provisto en los archivos: LenaPepperMan.m como punto
de partida.

En esta parte del informe deber incluir los resultados del filtrado as como el cdigo
correspondiente a la implementacin de cada uno de los filtros.
Tome en cuenta que deber considerar tambin los bordes de la imagen, de tal modo que el 100%
de la imagen sea procesada mediante su programa.

1) Filtro por promediado mvil.

Implemente un sistema de filtrado por promediado mvil para tratar de eliminar el ruido en la
imagen:

Convolucione la imagen de Lena512.bmp con el siguiente kernel:

MovingAverageKer = [1/9 1/9 1/9; 1/9 1/9 1/9; 1/9 1/9 1/9];
Modifique el kernel y grafique los resultados para los siguientes vecindarios:

clc
clear all
close all
lena = imread('lena512.bmp');
figure(1)
imshow(lena)
lena_noise = imnoise(lena,'salt & pepper',0.02);
figure(2)
imshow(lena_noise)
lena1= im2double(lena_noise);
MovingAverageKer = [1/9 1/9 1/9 ; 1/9 1/9 1/9 ; 1/9 1/9 1/9 ];
%MovingAverageKer = [1/25 1/25 1/25 1/25 1/25;1/25 1/25 1/25 1/25
1/25;1/25 1/25 1/25 1/25 1/25;1/25 1/25 1/25 1/25 1/25;1/25 1/25 1/25
1/25 1/25];
%MovingAverageKer = [1/49 1/49 1/49 1/49 1/49 1/49 1/49 ; 1/49 1/49 1/49
1/49 1/49 1/49 1/49; 1/49 1/49 1/49 1/49 1/49 1/49 1/49; 1/49 1/49 1/49
1/49 1/49 1/49 1/49; 1/49 1/49 1/49 1/49 1/49 1/49 1/49; 1/49 1/49 1/49
1/49 1/49 1/49 1/49; 1/49 1/49 1/49 1/49 1/49 1/49 1/49];
%MovingAverageKer =
[1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 ; 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 ;1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441;1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441
1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441 1/441];
lena_conv=conv2(lena1,MovingAverageKer,'same');
lena_res= im2uint8(lena_conv);
figure(3)
imshow(lena_res)
title('promediado movil, vecindario 3x3')
%title('promediado movil, vecindario 5x5')
%title('promediado movil, vecindario 7x7')
%title('promediado movil, vecindario 21x21')
 promediado movil, vecindario 3x3 promediado movil, vecindario 5x5

promediado movil, vecindario 7x7 promediado movil, vecindario 21x21

En este punto se realiza el promedio mediante una convolucin, el kernel define el vecindario y
por lo tanto el factor que debe ser el promedio, esto nos ahorra mucho esfuerzo ya que con bucles
incluye mayor cdigo.
Para procesar la matriz primeramente se la convierte a datos tipo double, se hace la convolucin y
para visualizar la matriz se los convierte a datos sin signo de 8 bits, tal como en el punto 2.

2) Median Filter - Filtrado No-Lineal

Implemente un sistema de filtrado no lineal utilizando un Median Filter con el fin de eliminar el
ruido en la imagen.
Recuerde que el Median Filter, utiliza un vecindario similar al utilizado en el filtrado por
promediado mvil y que se desplaza haciendo un barrido por la imagen original, pero con la
diferencia que en lugar de obtener el promedio del vecindario, lo que hace es obtener la media del
conjunto de valores: Utilice el comando median de Matlab.

Grafique los resultados para los siguientes vecindarios:

Vecindario cuadrado de 3x3.

clear all
close all

lena = imread('lena512.bmp');
figure(1)
imshow(lena)
lena_noise = imnoise(lena,'salt & pepper',0.02);
figure(3)
imshow(lena_noise)
lena_noise1 = lena_noise;
%denoising a given area:
%Median Filter 3x3 neighborhood
for y=2:511
for x=2:511
lena_noise(x,y) = median( [(lena_noise(x-1,y-1))
,(lena_noise(x,y-1)) , (lena_noise(x+1,y-1)) , (lena_noise(x-1,y)) ,
(lena_noise(x+1,y)) , (lena_noise(x-1,y+1)) , (lena_noise(x,y+1)) ,
(lena_noise(x-1,y+1)) ]);
end
end
%denoising for edges
w=1;
for x=2:511
lena_noise(x,w) = median( [(lena_noise(x-1,w)) ,(lena_noise(x,w)) ,
(lena_noise(x+1,w)) ]);
end
w=1;
for x=2:511
lena_noise(w,x) = median( [(lena_noise(w,x-1)) ,(lena_noise(w,x)) ,
(lena_noise(w,x+1)) ]);
end

w=512;
for x=2:511
lena_noise(x,w) = median( [(lena_noise(x-1,w)) ,(lena_noise(x,w)) ,
(lena_noise(x+1,w)) ]);
end
w=512;
for x=2:511
lena_noise(w,x) = median( [(lena_noise(w,x-1)) ,(lena_noise(w,x)) ,
(lena_noise(w,x+1)) ]);
end
figure(4)
imshow(lena_noise)
title('filtrado Lena, vecindario 3x3')
 filtrado Lena, vecindario 3x3

Vecindario cuadrado de 5x5.

clear all
close all

lena = imread('lena512.bmp');
figure(1)
imshow(lena)

lena_noise = imnoise(lena,'salt & pepper',0.02);

figure(3)
imshow(lena_noise)
lena_noise1 = lena_noise;
%denoising a given area:
%Median Filter 5x5 neighborhood
for y=3:510
for x=3:510
A= lena_noise(x-2:x+2,y-2:y+2);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
%denoising for edges
for y=1:2
for x=3:510
A= lena_noise(x-2:x+2,y);
lena_noise(x,y) = median( A);
end
end

for y=1:2
for x=3:510
A= lena_noise(y:y+2,x-2:x+2);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%critical
for y=511:512
for x=3:510
A= lena_noise(y-2:y,x-2:x+2);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%end critical
for y=511:512
for x=3:510
A= lena_noise(x-2:x+2,y);
lena_noise(x,y) = median( A);
end
end

figure(4)
imshow(lena_noise)
title('filtrado Lena, vecindario 5x5')

filtrado Lena, vecindario 5x5

 Vecindario cuadrado de 7x7.

clear all
close all

lena = imread('lena512.bmp');
figure(1)
imshow(lena)

lena_noise = imnoise(lena,'salt & pepper',0.02);

figure(3)
imshow(lena_noise)

lena_noise1 = lena_noise;
%denoising a given area:
%Median Filter 7x7 neighborhood
for y=4:508
for x=4:508
A= lena_noise(x-3:x+3,y-3:y+3);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
%denoising for edges
for y=1:4
for x=4:508
A= lena_noise(x-3:x+3,y);
lena_noise(x,y) = median( A);
end
end

for y=1:4
for x=4:508
A= lena_noise(y:y+3,x-3:x+3);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%critical
for y=509:512
for x=4:508
A= lena_noise(y-3:y,x-3:x+3);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%end critical
for y=509:512
for x=4:508
A= lena_noise(x-3:x+3,y);
lena_noise(x,y) = median( A);
end
end
figure(4)
imshow(lena_noise)
title('filtrado Lena, vecindario 7x7')
 filtrado Lena, vecindario 7x7

Vecindario cuadrado de 21x21.

clear all
close all

lena = imread('lena512.bmp');
figure(1)
imshow(lena)

lena_noise = imnoise(lena,'salt & pepper',0.02);

figure(3)
imshow(lena_noise)

lena_noise1 = lena_noise;

%denoising a given area:

%Median Filter 21x21 neighborhood
for y=11:501
for x=11:501
A= lena_noise(x-10:x+10,y-10:y+10);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end

%denoising for edges

for y=1:11
for x=11:501
 A= lena_noise(x-10:x+10,y:y+1);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end

for y=1:11
for x=11:501
A= lena_noise(y:y+1,x-10:x+10);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end

for y=502:512
for x=11:501
A= lena_noise(x-10:x+10,y-1:y);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end

%critical
for y=502:512
for x=11:501
A= lena_noise(y-1:y,x-10:x+10);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%end critical

for y=502:512
for x=11:501
A= lena_noise(y-1:y,x-10:x+10);
v = reshape( A.' ,1,numel(A));
lena_noise(y,x) = median( v);
end
end
%===========================================|
%denoising for corners
%===========================================|
for y=1:10%corner izquierdo superior
for x=1:10
A= lena_noise(x:x+3,y:y+3);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
for y=1:10%corner izquierdo inferior
for x=502:512
A= lena_noise(x-3:x,y:y+3);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
for y=502:512%corner derecho superior
for x=1:10
A= lena_noise(x:x+3,y-3:y);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
for y=502:512%corner derecho inferior
for x=502:512
A= lena_noise(x-3:x,y-3:y);
v = reshape( A.' ,1,numel(A));
lena_noise(x,y) = median( v);
end
end
figure(4)
imshow(lena_noise)
title('filtrado Lena, vecindario 21x21')

filtrado Lena, vecindario 21x21

Escriba sus impresiones y justifique el porqu de los resultados obtenidos (respecto a la calidad
de la imagen obtenida).

La calidad de imagen se pierde, est difuminada, esto se debe a que se coge el valor medio del
vecindario que escogemos, entonces mientras mayor sea el tamao del vecindario, menor va a ser
la calidad de la imagen como se ve en las figuras de arriba.

Explique brevemente el funcionamiento de su programa, comentando las partes de cdigo

relevantes.

Primeramente leemos la imagen, la mostramos para luego comparar. Posteriormente

contaminamos la seal con ruido tipo sal y pimienta, igualmente la mostramos. Luego hacemos en
un doble bucle el recorrido de la mediana para los determinados vecindarios, al momento de
elegir los vecindarios lo hacemos generando una matriz y luego todo esa matriz convirtindola a
un vector dado que la mediana acepta un arreglo de valores y no una matriz, esto nos sirve para el
centro de la matriz, pero los mrgenes quedan con ese ruido. Por ultimo procedemos a quitar el
ruido de los mrgenes y de las esquinas con vecindarios rectangulares, para ello lo hacemos de la
misma forma que la primera parte.

De los vecindarios de 3x3 hasta 7x7 no se elimin el ruido de las esquinas dado que mximo 3
pixeles se nos escapan pero en el caso del vecindario de 21x21 ya es crtico porque ya no son
simples 3 pixeles, esto aumenta a 10 pixeles.

Por qu este filtro no puede implementarse mediante una convolucin?

La convolucin bidimensional multiplica a toda al vecindario y lo suma, lo que en el literal uno

implementamos para el promediado mvil, pero aqu es diferente dado que tenemos que coger el
valor medio y eso no se puede lograr con una convolucin bidimensional.

3) Operador Laplaciano

Importe la imagen moon.bmp a Matlab.

moon1 = imread('moon.bmp');
Imagen Original

Para procesar los datos utilice el tipo de datos double, por lo que debe convertir las imgenes
ledas a este tipo de dato.

moon= im2double(moon1); %step one

 Para visualizar las seales obtenidas convierta las matrices resultantes al tipo de datos enteros
sin signo de 8 bits, use el comando uint8.

moon_res= im2uint8(moon_sum); %step two

Obtenga y visualice la imagen resultante del Laplaciano de la imagen: convolucione la imagen

cargada con el siguiente kernel:
LapKernel2 = [-1 -1 -1; -1 8 -1; -1 -1 -1];

LapKernel2 = [-1 -1 -1; -1 8 -1; -1 -1 -1];

moon_conv=conv2(moon,LapKernel2,'same'); %step three
moon_sum=moon_conv+moon;

Sume la seal original ms el Laplaciano y visualice la seal resultante.

moon_sum=moon_conv+moon;

Describa lo que observa, e indique cual es el rol del operador Laplaciano en el mejoramiento
del detalle de la imagen.
convolucion por el kernel Imagen filtrada

Se observa que los filos de la imagen se realzan y est ms ntida, esto es debido a la convulucin
por el kernel Laplaciano como se ve en la figura de la izquierda de arriba, que tiene la funcin de
sacar los mximos de la seal (filos) y despus procedemos a sumarle a la seal original y por este
motivo se visualiza as este tipo de imagen.

Incluya en el informe el cdigo de su programa con una detallada explicacin.

clc
close all
clear all
%original picture
moon1 = imread('moon.bmp');
figure, imshow(moon1)
title('Imagen Original')
moon= im2double(moon1); %step one

%sharpening

LapKernel2 = [-1 -1 -1; -1 8 -1; -1 -1 -1];

moon_conv=conv2(moon,LapKernel2,'same'); %step three
moon_sum=moon_conv+moon;
moon_res= im2uint8(moon_sum); %step two
figure, imshow(moon_res)
title('Imagen filtrada')
figure, imshow(moon_conv)
title('convolucion por el kernel')

Primeramente leemos la imagen a procesar y procedemos a mostrarla en pantalla para poder

comparar los resultados antes del filtro y despus del filtro, convertmos la matriz de la imagen a
datos tipo double para tener una mayor fidelidad, ahora hacemos la convolucion de dos
dimensiones y ponemos el parmetro same para tener la matriz resultante del mismo tamao que
la imagen original, luego sumamos la matriz de la convolucin con la matriz de la imagen original,
lo convertimos a datos enteros sin signo de 8 bits y procedemos a visualizar nuestra imagen
filtrada, se puede ver un resultado bien satisfactorio.

Parte 2: Filtrado en el Dominio de la Frecuencia

a) Tarea:
El objetivo de esta prctica es eliminar el patrn de moire de una imagen utilizando un filtro
selectivo en frecuencia del tipo notch. La imagen que se muestra a continuacin se muestra
distorsionada por un patrn de ruido que se visualiza con un patrn particular de frecuencia:
A continuacin se muestra el espectro de la imagen donde puede apreciarse los componentes de
ruido claramente identidades:

Su tarea consiste en crear una funcin en el dominio de la frecuencia que elimine los componentes
identificados como fuentes del ruido y restaurar la imagen de tal modo que el patrn de moire
desaparezca,

Utilizaremos dos procedimientos:

1) Utilizando un filtro pasa bajo de tipo Butterworth para el cual usted estimara los
parmetros de orden n y radio D0

Bsicamente lo que hace este filtro es eliminar ciertos componentes indeseados de la

imagen, en este caso queremos eliminar el ruido. Para tener diferentes resultados se debe
variar el radio del filtro y el orden (de mayor orden se acerca al filtro ideal). A nuestro
criterio con un filtro butterworth de radio 30 y de orden 2 se logra un resultado
satisfactorio.

Para la implementacin del filtro partimos haciendo un circulo de dimensiones de la

imagen original, se puede observar que se asemeja mucho a un filtro tipo notch como se
ve en la figura de abajo.

n=2;
d0=30;
[r,c]=size(DFT_imageN);

notch=zeros(r,c);
butterworth=zeros(r,c);

for i=1:r
for j=1:c
notch(i,j)= sqrt( (i-(r/2))^2 + (j-(c/2))^2);
end
end
A continuacin desarrollamos una expresin que nos permita introducir el orden y radio
de dicho filtro para ello lo realizamos de la siguiente manera:

for i=1:r
for j=1:c
butterworth(i,j)= 1 / (1+ (notch(i,j)/d0)^(2*n) ) ;
end
end

Una vez obtenido el filtro deseado procedemos a multiplicar por el matriz origen (es decir
la imagen con ruido en el dominio de la frecuencia) y posteriormente realizamos la
transformada inversa de Fourier en tiempo discreto para proceder a visualizar los
resultados:

for i=1:r
for j=1:c
butterworth(i,j)= 1 / (1+ (notch(i,j)/d0)^(2*n) ) ;
end
end
%multiplico la imagen por el filtro butterworth en frecuencia
for i=1:r
for j=1:c
resp(i,j)=(butterworth(i,j))*DFT_imageN(i,j);

end
end
imageNfilt=abs(ifft2(resp));
figure,
imshow(imageNfilt,[])
title('imagen filtrada')
figure,
mesh(abs(log(notch)))
title('filtro notch')
figure,
mesh(abs(log(butterworth)))
title('filtro butterworth')
Como se puede ver en la imagen filtrada se ha eliminado el ruido casi en su totalidad, pero
al variar el orden del filtro, concretamente de mayor orden se nota ms el ruido, esto se
debe a que no elimina los componentes de ruido de los bordes.
imagen filtrada
2) Utilizando un sistema de filtrado selectivo tipo notch, en el que localizara un filtro
notch (por cada par de componentes) en cada componente de ruido localizado en el
espectro de la imagen.

1) La imagen original (aquella que incluye el ruido).

Se puede observar claramente el ruido en la imagen original, el objetivo de dicho punto es aplicar
el filtro notch y eliminar dicho ruido.

3) El espectro bidimensional de la imagen original.

Los puntos blancos en forma de cruz que se observa en la imagen es el ruido presente en la
imagen anterior por lo cual se debe eliminar.
4) El espectro tridimensional de la imagen original (utilice el comando mesh de
Matlab).
Se observa en la imagen claramente los picos de color amarillo son el ruido presente en la imagen
por lo cual se procede a colocar un filtro notch para eliminarlo.

5) El espectro bidimensional del filtro utilizado para para eliminar el patrn de moire.
Es el filtro que se va a utilizar para eliminar el ruido de la imagen original.

6) El espectro tridimensional del filtro (utilice el comando mesh de Matlab).

Se puede observar que es el mismo filtro que se diseo en los anterores puntos si no vista
en 3D.
 7) El espectro bidimensional de la imagen filtrada.

Se observa en la imagen que se han suprimido las cruces blancas que se explic en el
punto 3 sustituyndolas con puntos negros que son resultado del filtro.
8) El espectro tridimensional de la imagen filtrada (utilice el comando mesh de
Matlab).
Se nota claramente que se eliminaron varias componentes de ruido es decir los picos de
color amarillo que se explicaron en el punto 4, para seguir mejorando la imagen se
procede a modificar el filtro pero con dicho filtro se obtienen buenos resultados.

9) La imagen filtrada resultante y mejorada luego de aplicar el filtro que ha diseado.

Se puede observar claramente que ya no presenta ruido la imagen es decir se ha recuperado
mucho de la imagen original gracias al filtro aplicado.

Documentacin
A continuacin se adjunta el cdigo que se us para el diseo del filtro Notch como se observa
cada lnea esta comentada y especificando que hace.

%Filtrado de imgenes en el dominio de la frecuencia

close all
clc
clear all
% Se carga la imagen que se analizara mediante el comando imread.
imageN=rgb2gray(uint8(imread('woman.jpg')));
[f,c]=size(imageN);
% Se realiza el calculo de la DFT de la imagen original
DFT_imageN=fft2(imageN);
% Shifth spectrum to center
DFT_imageN=(fftshift(DFT_imageN));
% Se muestra la DFT de la imagen original
figure, imshow(DFT_imageN)
figure,
% Se muestra la imagen original
imshow((imageN));
imshow(uint8(imageN));
% Se muestra el espectro bidimensional de la imagen original.
F=log(abs(fftshift(fft2(double(imageN))))+1);
figure,
imshow(F,[])
%Empiece su programa aqui:
% Se calcula manualmente los valores del filtro como se observa
% se usaron 24 posiciones es decir 48 puntos
H_NR=zeros(f,c);

D0k =10;
uk1 =45; vk1 =0; uk2 = 90; vk2 = 0;
uk3 = 133; vk3 = 0; uk4 = 175; vk4 = 0;
uk5 = 20; vk5 = 55; uk6 = 65; vk6 = 55;
uk7 = 108; vk7 = 55; uk8 = 150; vk8 = 55;
uk9 = 20; vk9 = -55; uk10 = 65; vk10 = -55;
uk11 = 108; vk11 = -55; uk12 = 150; vk12 = -55;

uk13 =45; vk13 =100; uk14 = 90; vk14 = 100;

uk15 = 133; vk15 =100; uk16 = 175; vk16 = 100;
uk17 = 45; vk17 = -100; uk18 = 90; vk18 = -100;
uk19 = 133; vk19 = -100; uk20 = 175; vk20 = -100;
uk21 = 20; vk21 = 145; uk22 = 0; vk22 = 100;
uk23 = 108; vk23 = 145; uk24 = 108; vk24 = -145;
% Se observo que con filtro de orden 10 ya se observa claramente la
% la imagen original.
n = 10;

%Computing the filter

for i=1:1:f
for j=1:1:c
%Se procede a construir el filtros NOTCH
Dk1 = sqrt((i-f/2-uk1)^2+(j-c/2-vk1)^2);
Dmk1 = sqrt((i-f/2+uk1)^2+(j-c/2+vk1)^2);
Dk2 = sqrt((i-f/2-uk2)^2+(j-c/2-vk2)^2);
Dmk2 = sqrt((i-f/2+uk2)^2+(j-c/2+vk2)^2);
Dk3 = sqrt((i-f/2-uk3)^2+(j-c/2-vk3)^2);
Dmk3 = sqrt((i-f/2+uk3)^2+(j-c/2+vk3)^2);
Dk4 = sqrt((i-f/2-uk4)^2+(j-c/2-vk4)^2);
Dmk4 = sqrt((i-f/2+uk4)^2+(j-c/2+vk4)^2);
Dk5 = sqrt((i-f/2-uk5)^2+(j-c/2-vk5)^2);
Dmk5 = sqrt((i-f/2+uk5)^2+(j-c/2+vk5)^2);
Dk6 = sqrt((i-f/2-uk6)^2+(j-c/2-vk6)^2);
Dmk6 = sqrt((i-f/2+uk6)^2+(j-c/2+vk6)^2);
Dk7 = sqrt((i-f/2-uk7)^2+(j-c/2-vk7)^2);
Dmk7 = sqrt((i-f/2+uk7)^2+(j-c/2+vk7)^2);
Dk8 = sqrt((i-f/2-uk8)^2+(j-c/2-vk8)^2);
Dmk8 = sqrt((i-f/2+uk8)^2+(j-c/2+vk8)^2);
Dk9 = sqrt((i-f/2-uk9)^2+(j-c/2-vk9)^2);
Dmk9 = sqrt((i-f/2+uk9)^2+(j-c/2+vk9)^2);
Dk10 = sqrt((i-f/2-uk10)^2+(j-c/2-vk10)^2);
Dmk10 = sqrt((i-f/2+uk10)^2+(j-c/2+vk10)^2);
Dk11 = sqrt((i-f/2-uk11)^2+(j-c/2-vk11)^2);
Dmk11 = sqrt((i-f/2+uk11)^2+(j-c/2+vk11)^2);
Dk12 = sqrt((i-f/2-uk12)^2+(j-c/2-vk12)^2);
Dmk12 = sqrt((i-f/2+uk12)^2+(j-c/2+vk12)^2);

Dk13 = sqrt((i-f/2-uk13)^2+(j-c/2-vk13)^2);
Dmk13 = sqrt((i-f/2+uk13)^2+(j-c/2+vk13)^2);
Dk14 = sqrt((i-f/2-uk14)^2+(j-c/2-vk14)^2);
 Dmk14 = sqrt((i-f/2+uk14)^2+(j-c/2+vk14)^2);
Dk15 = sqrt((i-f/2-uk15)^2+(j-c/2-vk15)^2);
Dmk15 = sqrt((i-f/2+uk15)^2+(j-c/2+vk15)^2);
Dk16 = sqrt((i-f/2-uk16)^2+(j-c/2-vk16)^2);
Dmk16 = sqrt((i-f/2+uk16)^2+(j-c/2+vk16)^2);
Dk17 = sqrt((i-f/2-uk17)^2+(j-c/2-vk17)^2);
Dmk17 = sqrt((i-f/2+uk17)^2+(j-c/2+vk17)^2);
Dk18 = sqrt((i-f/2-uk18)^2+(j-c/2-vk18)^2);
Dmk18 = sqrt((i-f/2+uk18)^2+(j-c/2+vk18)^2);
Dk19 = sqrt((i-f/2-uk19)^2+(j-c/2-vk19)^2);
Dmk19 = sqrt((i-f/2+uk19)^2+(j-c/2+vk19)^2);
Dk20 = sqrt((i-f/2-uk20)^2+(j-c/2-vk20)^2);
Dmk20 = sqrt((i-f/2+uk20)^2+(j-c/2+vk20)^2);
Dk21 = sqrt((i-f/2-uk21)^2+(j-c/2-vk21)^2);
Dmk21 = sqrt((i-f/2+uk21)^2+(j-c/2+vk21)^2);
Dk22 = sqrt((i-f/2-uk22)^2+(j-c/2-vk22)^2);
Dmk22 = sqrt((i-f/2+uk22)^2+(j-c/2+vk22)^2);
Dk23 = sqrt((i-f/2-uk23)^2+(j-c/2-vk23)^2);
Dmk23 = sqrt((i-f/2+uk23)^2+(j-c/2+vk23)^2);
Dk24 = sqrt((i-f/2-uk24)^2+(j-c/2-vk24)^2);
Dmk24 = sqrt((i-f/2+uk24)^2+(j-c/2+vk24)^2);
% Formula para el calculo del filtro
H_NR(i,j) = ((1 / (1+ (D0k/Dk1)^(2*n))) * (1 / (1+
(D0k/Dmk1)^(2*n))) ) * ((1 / (1+ (D0k/Dk2)^(2*n)))* (1 / (1+
(D0k/Dmk2)^(2*n))) )*((1 / (1+ (D0k/Dk3)^(2*n)))* (1 / (1+
(D0k/Dmk3)^(2*n))) )*((1 / (1+ (D0k/Dk4)^(2*n)))* (1 / (1+
(D0k/Dmk4)^(2*n))) )*((1 / (1+ (D0k/Dk5)^(2*n)))* (1 / (1+
(D0k/Dmk5)^(2*n))) )*((1 / (1+ (D0k/Dk6)^(2*n)))* (1 / (1+
(D0k/Dmk6)^(2*n))) )*((1 / (1+ (D0k/Dk7)^(2*n)))* (1 / (1+
(D0k/Dmk7)^(2*n))) )*((1 / (1+ (D0k/Dk8)^(2*n)))* (1 / (1+
(D0k/Dmk8)^(2*n))) ) * ((1 / (1+ (D0k/Dk9)^(2*n)))* (1 / (1+
(D0k/Dmk9)^(2*n))) ) * ((1 / (1+ (D0k/Dk10)^(2*n)))* (1 / (1+
(D0k/Dmk10)^(2*n))) )* ((1 / (1+ (D0k/Dk11)^(2*n)))* (1 / (1+
(D0k/Dmk11)^(2*n))) ) * ((1 / (1+ (D0k/Dk12)^(2*n)))* (1 / (1+
(D0k/Dmk12)^(2*n))) *((1 / (1+ (D0k/Dk13)^(2*n))) * (1 / (1+
(D0k/Dmk13)^(2*n))) ) * ((1 / (1+ (D0k/Dk14)^(2*n)))* (1 / (1+
(D0k/Dmk14)^(2*n))) )*((1 / (1+ (D0k/Dk15)^(2*n)))* (1 / (1+
(D0k/Dmk15)^(2*n))) )*((1 / (1+ (D0k/Dk16)^(2*n)))* (1 / (1+
(D0k/Dmk16)^(2*n))) )*((1 / (1+ (D0k/Dk17)^(2*n)))* (1 / (1+
(D0k/Dmk17)^(2*n))) )*((1 / (1+ (D0k/Dk18)^(2*n)))* (1 / (1+
(D0k/Dmk18)^(2*n))) )*((1 / (1+ (D0k/Dk19)^(2*n)))* (1 / (1+
(D0k/Dmk19)^(2*n))) )*((1 / (1+ (D0k/Dk20)^(2*n)))* (1 / (1+
(D0k/Dmk20)^(2*n))) ) * ((1 / (1+ (D0k/Dk21)^(2*n)))* (1 / (1+
(D0k/Dmk21)^(2*n))) ) * ((1 / (1+ (D0k/Dk22)^(2*n)))* (1 / (1+
(D0k/Dmk22)^(2*n))) )* ((1 / (1+ (D0k/Dk23)^(2*n)))* (1 / (1+
(D0k/Dmk23)^(2*n))) ) * ((1 / (1+ (D0k/Dk24)^(2*n)))* (1 / (1+
(D0k/Dmk24)^(2*n))) ));
end
end
% Se calcula la DFT de la imagen filtrada
DFT_imageNfilt=DFT_imageN.*H_NR;
% Se calcula la nueva imagen
imageNfilt=abs(ifft2(DFT_imageNfilt));
% Se muestra el espectro bidimensional del filtro usado.
figure,
imshow(H_NR,[])
% Se calcula y muestra el espectro bidimensional de la imagen filtrada.
R=log(abs(fftshift(fft2(double(imageNfilt))))+1);
figure,
imshow(R,[])
% Se muestra el espectro tridimensional del filtro.
figure, mesh(abs(log(H_NR+1)))
title('Output Spectrum filtro')
% Se muestra el espectro tridimensional de la imagen original
figure, mesh(abs(log(DFT_imageN+1)))
title('Original Image 3D Spectrum')
% Se muestra el espectro tridimensional de la imagen fiinal
figure, mesh(abs(log(DFT_imageNfilt+1)))
title('Output Image Spectrum filtro')
% Se muestra la imagen final es decir la filtrada.
figure, imshow(uint8(imageNfilt))
title('Output Image')

Conclusiones y Recomendaciones

Se pudo poner en practica todos los conociemiento aprendidos en clase para la realizacion
correcta de la practica, Se noto la importancia de realizar fiiltrado ya sea en el dominio
espacial o en el dominio de la frecuencia aplicando la DFT.
Se logr implementar correctamente la convolucin en dos dimensiones es decir mediante
el uso de condicionales y bucles para concluir que se llega a la misma respuesta mediante
el comando conv2 que es prediseado por matlab.

Al momento de desarrollar el filtro Notch se not que depende demasiado la imagen final
del filtro diseado, mientras ms puntos es mejor ya que se eliminan ms componentes de
ruido en este caso se not que 48 puntos eran suficientes para que de buenos resultados,
tambin se not que al suprimir los valores del centro de la imagen original la imagen
resultante era una imagen negra eso se debe a que se eliminan los valores con mayor
ganancia.

Al momento de usar el orden del filtro se recomienda no usar un valor muy alto ya que la
imagen final se comienza a ver borrosa.

En general si escogemos de mayor tamao los vecindarios, menor va a ser la calidad de la

imagen, esto corrobora lo hablado en clase.

En la parte del promediado mvil se puede ver los bordes oscuros, esto se lo aprecia de
mejor manera en el vecindario de 21x21, se debe a que se hace la convolucin en los
mrgenes por ceros, dado que fuera de los mrgenes de la imagen no existen valores.

Bibliografa

[1] << Convolucin en 2D >> [En lnea]. Disponible en:

http://www2.fisica.unlp.edu.ar/materias/procesamiento_de_imagenes/Clase2_Imagenes_2011.p
df
[2] << Frequency domain filtering for grayscale images>> [En lnea]. Disponible en:

https://www.mathworks.com/matlabcentral/fileexchange/40579-frequency-domain-filtering-for-
grayscale-images/all_files
[2] Gonzalez & Woods, Digital Image Processing, Pearson Education, Prentice Hall, Second Edition,
2002

[3] Gonzalez & Woods, Digital Image Processing, Pearson Education, Prentice Hall, Second
Edition, 2002