Recuperacin de imagen a partir de su

transformada y la convolucin con filtros

Miller Mateo Murillo
ptica de Fourier, Departamento de Fsica
Universidad Nacional de Colombia
Bogot
09/03/2015

Resumen
En el siguiente trabajo se muestran los resultados obtenido en la recuperacin de una imagen
muestreada utilizando dos mtodos diferentes, uno que utiliza la transformada de Fourier de la imagen y
otro que utiliza la operacin convolucin. Se logr obtener una imagen recuperada mucho mejor que la
imagen de partida, pero que an as no logro reproducir exactamente la imagen a recuperar debido al
bajo perodo espacial del muestreo.

Recuperacin utilizando la transformada

Para recuperar la imagen a partir de la transformada de Fourier, el procedimiento que se realiz es el siguiente:
X Leer la imagen en MATLAB utilizando el comando imread().
X Realizar la transformada de Fourier en dos dimensiones de la imagen utilizando el comando fft2().
X Construir el filtro deseado que en nuestro caso en una dimensin corresponden a las siguientes funciones.
Filtro cuadrado
y = rect

x 
ancho

(1)

Filtro gaussiano 1



2x
y = 0.5 1 + cos
ancho

(2)

Filtro de pirmide
y=

2
2
(x + ancho/2) si x < 0 y =
(x ancho/2) si x > 0
ancho
ancho

(3)

Filtro gaussiano 2

y = 0.54 + 0.46 cos
Donde "ancho" denota el ancho del filtro
mimmurillome@unal.edu.co

133855

2x
ancho


(4)

X Centrar la transformada de fourier con el comando fftshift().

X Multiplicar la transformada de Fourier de la imagen por el filtro que se desea aplicar.
X Realizar la transformada inversa de Fourier del resultado obtenido anteriormente.
Los resultados obtenidos realizando el procedimiento anterior son los siguientes:

Figura 1: Imagen a recuperar con un muestreo de 6 pxeles.

Figura 2: Imgenes recuperadas utilizando filtros cuadrado y gaussiano 1 de ancho 80 pxeles

Figura 3: Imgenes recuperadas utilizando filtros pirmide y sinc de ancho 80 pxeles

Figura 4: Imagen recuperada utilizando el filtro gaussiano 2 de ancho 80 pxeles

Se seleccion que el filtro tuviera un ancho de 80 pxeles suponiendo que el muestreo era el ideal segn el
teorema de Nyquist. Para observar si el muestreo nos puede permitir recuperar con exactitud la imagen
original, podemos observar la siguiente figura en la cual se muestra un perfil de la transformada de Fourier
de la imagen muestreada

Figura 5: Perfil de la magnitud de la transformada de Fourier de la imagen muestreada.

En la imagen anterior se observa que el muestreo tiene un perodo espacial muy bajo por lo cual los espectros
se encuentran superpuestos en la transformada. Por lo tanto no es posible recuperar con exactitud la imagen
que se muestreo.

Recuperacin utilizando convolucin

A partir de lo que se realiz en la recuperacin con la transformada, para recuperar la imagen utilizando la
convolucin lo que se realiz fue la convolucin entre la imagen muestreada y el filtro deseado utilizando la
funcin conv2(). Los filtros que fueron utilizados son de ancho 6 pxeles debido a que la imagen muestreada
tiene ese perodo.

Figura 6: Imagen recuperadas utilizando filtro cuadrado de ancho 6 pxeles

Figura 7: Imagen recuperada utilizando filtro gaussiano 1 de ancho 6 pxeles

Figura 8: Imagen recuperada utilizando filtro pirmide de ancho 6 pxeles

Figura 9: Imagen recuperad utilizando filtro sinc de ancho 6 pxeles

Figura 10: Imagen recuperada utilizando filtro gaussiano 2 de ancho 6 pxeles

Anexo
Al ejecutar el programa se mostrarn dos imagenes una correspondiente a la recuperacin de la imagen a
partir de la transformada incluyendo la forma de los filtros y una segunda imagen que contiene las imagenes
recuperadas a partir de la convolucin. Para que la recuperacin a partir de la transformada se observe bien
la variable ancho debe valer alrededor de 80 pxeles y para que la recuperacin a partir de la convolucin se
observe bien, la variable ancho debe valer alrededor de 6 pxeles.

Cdigo
pi=3.1415926;
a=2;
% Filas para el subplot
b=5;
% Columnas para el subplot
ancho=80; %Ancho del filtro
%LECTURA DE LA IMAGEN Y TRANSFORMADA
f=imread(imagen_m.tif);
F=fft2(f);
modF=abs(F);
FF=fftshift(F);
%CONSTRUCCION DE FILTROS
%Filtro cuadrado
%ancho=80; %Permite cambiar el ancho de manera independiente para cada filtro
filter=zeros(480);
min=240-ancho/2;
max=240+ancho/2;

10

filter(min:max,min:max)=1;
%Filtro gaussiano 1
filter1=ones(480);
x=zeros(1,480);
%ancho=80; %Ancho de la gaussiana
for ii=1:480
dist=abs(ii-240);
if dist>ancho/2
continue;
end
x(ii)=0.5*(1+cos((2*pi*(ii-240))/ancho)); %La funcion me centra el filtro en 240
end
%Estos dos for me forman la gaussiana con la matriz de unos
for ii=1:480
filter1(ii,1:480)=filter1(ii,1:480).*x;
end
for ii=1:480
filter1(1:480,ii)=filter1(1:480,ii).*x;
end
%Filtro piramide
filter2=ones(480);
y=zeros(1,480);
%ancho=80; %Ancho de la piramide
for ii=1:480
dist=abs(ii-240);
if dist>ancho/2 %Condicion para utilizar unicamente el maximo principal
continue;
end
m=2/ancho;
y(ii)=m*(ii-(240-ancho/2)); %La funcion me centra el filtro en 240
if ii>240
y(ii)=m*((240+ancho/2)-ii);
end
end
%Estos dos for me forman la piramide con la matriz de unos
for ii=1:480
filter2(ii,1:480)=filter2(ii,1:480).*y;
end
for ii=1:480
filter2(1:480,ii)=filter2(1:480,ii).*y;
end
%filtro sinc
filter3=ones(480);
%ancho=80;
%Ancho de la sinc utilizando solo el maximo principal
z=zeros(1,480);
for ii=1:480

11

dist=abs(ii-240);
arg=2*pi*(ii-240)/ancho;
if dist>ancho/2
continue;
end
z(ii)=(sin(arg))/arg;
end
z(240)=1;
%Estos dos for me forman la sinc con la matriz de unos
for ii=1:480
filter3(ii,1:480)=filter3(ii,1:480).*z;
end
for ii=1:480
filter3(1:480,ii)=filter3(1:480,ii).*z;
end
%filtro gaussiano 2
filter4=ones(480);
p=zeros(1,480);
for ii=1:480
dist=abs(ii-240);
if dist>ancho/2
continue;
end
p(ii)=0.54+0.46*cos(2*pi*(ii-240)/ancho);
end
%Estos dos for me forman el filtro gaussiano con la matriz de unos
for ii=1:480
filter4(ii,1:480)=filter4(ii,1:480).*p;
end
for ii=1:480
filter4(1:480,ii)=filter4(1:480,ii).*p;
end

%RECUPERACION DE LA IMAGEN A PARTIR DE SU TRANSFORMADA

%filtro rectagular
R=ifft2(F.*filter);
Raux=abs(R);
RR=mat2gray(Raux); %mat2gray me transforma la imagen en escala de grises para imprimirla
%Filtro gaussiano 1
R1=ifft2(F.*filter1);
Raux=abs(R1);
RR1=mat2gray(Raux);
%Filtro piramide
R2=ifft2(F.*filter2);
Raux=abs(R2);
RR2=mat2gray(Raux);
%Filtro sinc
R3=ifft2(F.*filter3);

12

Raux=abs(R3);
RR3=mat2gray(Raux);
%Filtro gaussiano 2
R4=ifft2(F.*filter4);
Raux=abs(R4);
RR4=mat2gray(Raux);
%RECUPEACION DE LA IMAGEN CON CONVOLUCION
%Filtro cuadrado%
Iaux=conv2(mat2gray(f),filter,same); %same me preserva el tamao de la grilla de la imagen
I=mat2gray(Iaux);
%Filtro gaussiano 1
Iaux=conv2(mat2gray(f),filter1,same);
I1=mat2gray(Iaux);
%Filtro piramide
Iaux=conv2(mat2gray(f),filter2,same);
I2=mat2gray(Iaux);
%Filtro sinc
Iaux=conv2(mat2gray(f),filter3,same);
I3=mat2gray(Iaux);
%Filtro gaussiano 2
Iaux=conv2(mat2gray(f),filter4,same);
I4=mat2gray(Iaux);
%IMPRESION IMAGENES
figure;
%Impresion filtros
%Filtro cuadrado
cuad=mat2gray(filter);
subplot(a,b,1);
imshow(cuad);
title(Filtro cuadrado);
%Filtro gaussiano 1
gauss=mat2gray(filter1);
subplot(a,b,2);
imshow(gauss);
title(Filtro gaussiano 1);
%Filtro piramide
pira=mat2gray(filter2);
subplot(a,b,3);
imshow(pira);
title(Filtro piramide);
%Filtro sinc
fsinc=mat2gray(filter3);
subplot(a,b,4);
imshow(fsinc);
title(Filtro sinc);
%Filtro gaussiano 2
gauss2=mat2gray(filter4);
subplot(a,b,5);
imshow(gauss2);
title(Filtro gaussiano 2);
%IMAGEN RECUPERADA CON TRANSFORMADA

13

%RR imagen recuperada rectangulo

subplot(a,b,6);
imshow(RR);
%RR1 imagen recuperada gaussiana
subplot(a,b,7);
imshow(RR1);
%RR2 imagen recuperada piramide
subplot(a,b,8);
imshow(RR2);
%RR3 imagen recuperada sinc
subplot(a,b,9);
imshow(RR3);
%RR4 imagen recuperada gaussiana 2
subplot(a,b,10);
imshow(RR4);
%IMAGEN RECUPERADA CON CONVOLUCION
figure;
c=2;
d=3;
%Filtro cuadrado
subplot(c,d,1);
imshow(I);
title(Filtro cuadrado);
%Filtro gaussiano 1
subplot(c,d,2);
imshow(I1);
title(Filtro gaussiano 1);
%Filtro piramide
subplot(c,d,3);
imshow(I2);
title(Filtro piramide);
%Filtro sinc
subplot(c,d,4);
imshow(I3);
title(Filtro sinc);
%Filtro gaussiano 2
subplot(c,d,5);
imshow(I4);
title(Filtro gaussiano 2);