tarea n°2 - u-cursos · 2014. 9. 9. · tarea n°2 separabilidad de filtros y transformada de...

Universidad de Chile

Facultad de Ciencias Físicas y Matemáticas

Departamento de Ingeniería Eléctrica

EL7007 – Introducción al Procesamiento Digital de Imágenes

TAREA N°2

SEPARABILIDAD DE FILTROS Y

TRANSFORMADA DE FOURIER

Nombre Alumno : Sebastián Gálvez

Profesor : Claudio Pérez

Profesor Auxiliar : Luis Castillo

Ayudante de Laboratorio: Alonso Astroza

Fecha : 09/09/2014

Santiago, Chile.

EL7007 – Separabilidad de Filtros y Transformada de Fourier

U. de Chile. FCFM. DIE ~1~

Convolución

P1.- Convolución

El objetivo de esta sección de la tarea es estudiar la separabilidad de un filtro 2D

en dos kernels 1D, evaluando costo computacional de los dos casos e implementando

en Matlab la convolución en estas dos modalidades para verificar la teoría.

a) Demostración de separabilidad de la convolución 2D.

Dado un filtro 2D con kernel separable tal que ,

entonces la operación de convolución se puede separar de la siguiente manera:

En efecto, dado que por definición se tiene que la convolución 2D es:

∑∑

∑∑

∑ ∑

∑ ∑

Y utilizando la definición de convolución 1D para y en la variable , se tiene

que:

∑

Ahora se identifica la convolución 1D entre y en la variable , por lo

que finalmente se obtiene lo pedido.

b) Costo computacional de la convolución 2D mediante kernel 2D.



Convolución

Suponiendo que el kernel es de dimensión , y la matriz objetivo

es de tamaño , utilizando la definición de la convolución 2D para un punto

de la matriz resultante:

∑∑

Es fácil ver que para calcular la convolución de un sólo punto de la matriz

resultante de la convolución se requieren productos, y como se debe realizar para

cada uno de los elementos de , en total se requieren multiplicaciones.

c) Costo computacional de la convolución 2D mediante kernels 1D.

En este caso para cada punto sólo se realizan productos por cada

kernel, realizando en la convolución 1D vertical un total de productos por cada

columna, con un total de columnas y en la convolución 1D horizontal la misma

cantidad de multiplicaciones por cada fila, para las filas de .

Así, el total de multiplicaciones realizadas es

d) Filtro Rect de 11x11.

Se implementaron en Matlab las funciones convolucion2D(img,h) y

convolucion1D(img,h1,h2), que retornan la imagen de salida según la convolución

con el filtro y el tiempo de cómputo calculado gracias a las funciones tic y toc. Para más detalles sobre el código dirigirse a la sección Anexos.

En esta oportunidad se probará un filtrado mediante el kernel Rect de 11x11:

, con

[

]

A continuación se muestran en la Figura 1 los resultados obtenidos para las dos

modalidades de convolución implementadas, junto a la Tabla 1 que compara los

tiempos de cómputo de los dos métodos.



Convolución

Como se muestra en la Tabla 1, los tiempos de cómputo de la operación que

utiliza la separabilidad del kernel son considerablemente menores, produciendo un

resultado en el cual no se pueden identificar diferencias. En promedio, se obtuvo una

reducción al 22.19% del tiempo de cómputo de la convolución mediante kernel 2D.

FIGURA 1:(ARRIBA) IMAGEN ORIGINAL. (IZQUIERDA) RESULTADO DE CONVOLUCION

USANDO KERNEL 2D. (DERECHA) RESULTADO DE CONVOLUCION USANDO KERNELS 1D.



Convolución

N° Prueba Convolucion Kernel 2D [s] Convolucion Kernels 1D

[s]

1 0,916442966 0,20552876

2 0,931099869 0,204922828

3 0,910583571 0,200192782

4 0,89404483 0,199765838

5 0,89439788 0,199636523

6 0,89536343 0,198809319

7 0,895287483 0,19870792

8 0,896601978 0,199062612

9 0,893480771 0,198681646

10 0,89350335 0,199771174

11 0,899160768 0,197379057

12 0,898239965 0,198790846

13 0,894828518 0,199895563

14 0,898748192 0,198000999

15 0,89614055 0,199755164

16 0,896326927 0,199509261

17 0,894781308 0,197691875

18 0,894871213 0,198267018

19 0,894307154 0,198927139

20 0,893191353 0,197665602

Tiempo Promedio 0,899070104 0,199548096

Tiempo de Computo para Filtro Rect de 11x11

TABLA 1: COMPARACIÓN DE TIEMPO DE CÓMPUTO PARA CONVOLUCION MEDIANTE KERNEL

2D Y KERNELS 1D PARA FILTRO RECT.

e) Filtro Gussiano de 5x5.

En esta ocasión se estudia la separabilidad del filtro gaussiano:

, con

[ ]

En la Figura 2 se pueden observar los resultados obtenidos para las dos

modalidades de convolución para el caso del filtro Gaussiano. Al igual que el caso

anterior no existen diferencias notables entre una u otra modalidad. Además, en la

Tabla 2 se muestran los tiempos de cómputo de cada caso para 20 pruebas distintas.

En este caso se observa una mayor reducción de cómputo al utilizar la separabilidad,

logrando el 12,89% del tiempo de cómputo respecto de la convolución por kernel 2D.



Convolución

N° Prueba Convolucion Kernel 2D [s] Convolucion Kernels 1D

[s]

1 1,225609493 0,157860879

2 1,229642061 0,156425691

3 1,233532588 0,157912195

4 1,239563581 0,164254776

5 1,265457321 0,157937647

6 1,224659954 0,157509882

7 1,235604497 0,167642411

8 1,25225449 0,165174758

9 1,246819165 0,162525653

10 1,232138862 0,158940145

11 1,262345146 0,165228126

12 1,256461119 0,156372734

13 1,234753483 0,157257821

14 1,23139992 0,157873195

15 1,230817799 0,159452888

16 1,226567654 0,156390797

17 1,221546136 0,158663041

18 1,229174065 0,158830945

19 1,226984335 0,156050884

20 1,21053673 0,155912948

Tiempo Promedio 1,23579342 0,159410871

Tiempo de Computo para Filtro Gaussiano de 5x5

TABLA 2: COMPARACIÓN DE TIEMPO DE CÓMPUTO PARA CONVOLUCION MEDIANTE KERNEL

2D Y KERNELS 1D PARA FILTRO GAUSSIANO.

FIGURA 2:(IZQUIERDA) CONVOLUCIÓN USANDO KERNELS 1D. (DERECHA) CONVOLUCIÓN

USANDO KERNEL 2D.



Transformada de Fourier

P2.- Transformada de Fourier

a) Respuesta en frecuencia de Filtros 2D

Los filtros con respuesta al impulso [

] [

] poseen las

siguientes respuestas de frecuencia, calculadas mediante la transformada de Fourier:

{ } [

] { } [

]

Esto se condice con la noción de respuesta en frecuencia de una señal

correspondiente a un impulso ideal, la cual es una señal rectangular, mientras que la

respuesta en frecuencia de una señal rectangular es un impulso.

Es así que para determinar la respuesta asociada a los filtros y

, gracias a la linealidad de { } basta restar y sumar las respuestas calculadas

previamente. Con esto se tiene que:

{ } [

] { } [

]

b) Gráficos de Respuesta en frecuencia de Filtros 2D

A continuación se muestran en las Figuras 3 y 4 los resultados obtenidos al

aplicar las funciones fft2 y fftshift para calcular la respuesta en frecuencia de los filtros

y .

Claramente, el caso del filtro Resta presenta una característica de filtro pasa alto, permitiendo detectar variaciones rápidas de valores de pixeles en una imagen, como lo son los bordes, mientras que el filtro Suma realiza exactamente lo opuesto, actuando como un pasa bajos, al atenuar los cambios rápidos y dejar en la imagen resultante del filtrado las áreas de pixeles en donde no existen cambios bruscos en la tonalidad.




FIGURA 3: RESPUESTA EN FRECUENCIA DEL FILTRO RESTA

FIGURA 4: RESPUESTA EN FRECUENCIA DEL FILTRO SUMA




FIGURA 6:(IZQ.) IMAGEN FILTRADA CON RESTA. (DERECHA) IMAGEN FILTRADA CON SUMA.

c) Filtrado de imagen.

Considerando los filtros Suma y Resta de las preguntas anteriores, al aplicarlos a la imagen de la Figura 5, previa normalización se obtuvieron los resultados mostrados en la Figura 6. Se utilizó la función de Matlab imfilter para realizar el filtrado.

FIGURA 5: IMAGEN ORIGINAL A FILTRAR




Es evidente que los resultados son consistentes con las hipótesis planteadas en la parte b). Además, no es tan sencillo visualizar los efectos del filtro Suma debido a que se trata de un filtro de tamaño 3x3, aplicado en una imagen de 512x512, por lo que atenúa primordialmente detalles difíciles de percibir.

a) Filtrado de imagen con redimensionamiento de filtros.

Para estudiar los efectos de aumentar las dimensiones de los filtros Suma y Resta en 3,5 y 7 veces sobre la imagen de la Figura 5, se utilizó la función imresize con la opción „nearest‟. De esta forma, se obtuvieron los resultados mostrados en las Figuras 7 y 8.

FIGURA 7: (IZQUIERDA) RESULTADO USANDO FILTRO RESTA 9X9. (CENTRO)RESULTADO

USANDO FILTRO RESTA 15X15. (DERECHA)RESULTADO USANDO FILTRO RESTA 21X21.

FIGURA 8: (IZQUIERDA) RESULTADO USANDO FILTRO SUMA 9X9. (CENTRO)RESULTADO

USANDO FILTRO SUMA 15X15. (DERECHA)RESULTADO USANDO FILTRO SUMA 21X21.




Al observar los cambios producidos al aumentar la dimensión del filtro, se puede notar que se abarca una mayor banda en el espectro de frecuencia, por lo que el filtro Resta que es pasa alto, considera las variaciones rápidas con un rango mayor, llegando a resaltar bordes bastante gruesos. En el caso del filtro Suma como pasa bajos, se acentúa el efecto de suavizado, logrando una imagen un tanto borrosa al aumentar el tamaño en 21 veces.



Anexos

Anexos

A continuación se anexa el código de las funciones implementadas y de los script

utilizados para mostrar los resultados de cada pregunta.

convolucion2D.m

function [outimg,timeelapsed]=convolucion2D(img,h) %retorna convolucion 2D de img con kernel 2D h %tambien retorna tiempo de computo n=length(h(1,:)); [N,M]=size(img); newimg=zeros(N+n,M+n); outimg=zeros(N,M); timer=tic; %inicio timer newimg((n-1)/2 + (1:N) ,(n-1)/2 + (1:M) )=img; for u=1:N for v=1:M for i=1:n for j=1:n outimg(u,v)=outimg(u,v)+h(i,j)*newimg(u-i+n,v-j+n); end end end end timeelapsed=toc(timer); %obtengo tiempo de computo % disp(sprintf('Tiempo de Convolucion Kernel 2D = %f [s]',timeelapsed))

convolucion1D.m

function [outimg,timeelapsed]=convolucion1D(img,h1,h2) %retorna convolucion usando los kernels 1D h1 y h2 %tambien retorna tiempo de computo

n=length(h1); if(n~=length(h2)) disp('ERROR, kernels 1D de distinto largo') return end

[N,M]=size(img); newimg=zeros(N+n,M+n); vertconvimg=zeros(N,M);

newimg((n-1)/2 + (1:N) ,(n-1)/2 + (1:M) )=img; timer=tic; %inicio timer



Anexos

for u=1:N for v=1:M for i=1:n vertconvimg(u,v)=vertconvimg(u,v)+h1(i)*newimg(u-i+n,v+(n-

1)/2); end end end

newimg((n-1)/2 + (1:N) ,(n-1)/2 + (1:M) )=vertconvimg; outimg=zeros(N,M); for u=1:N for v=1:M for j=1:n outimg(u,v)=outimg(u,v)+h2(j)*newimg(u+(n-1)/2,v-j+n); end end end

timeelapsed=toc(timer); %obtengo tiempo de computo % disp(sprintf('Tiempo de Convolucion Kernels 1D = %f [s]',timeelapsed))

Tarea2p1.m

%% Tarea2p1 %% p1 d) % 2D conv clear all; close all; I1=imread('I1.bmp'); h=(1/121)*ones(11,11); figure;imshow(I1);title('Imagen Original')

[I1_2D,t2D]=convolucion2D(I1,h); figure;imshow(uint8(I1_2D));title('Convolucion con kernel 2D Rect de 11x11')

% 1D conv h1=(1/11)*ones(11,1); h2=h1'; [I1_1D,t1D]=convolucion1D(I1,h1,h2); figure;imshow(uint8(I1_1D));title('Convolucion con kernels 1D que componen

filtro Rect de 11x11') disp(sprintf('Tiempo Convolucion Kernel 2D = %f',t2D)) disp(sprintf('Tiempo Convolucion Kernels 1D = %f',t1D)) % time measuring

% t1D=zeros(20,1); % t2D=zeros(20,1); % for i=1:20 % [~,t2D(i)]=convolucion2D(I1,h); % [~,t1D(i)]=convolucion1D(I1,h1,h2); % end % disp(sprintf('Tiempo Convolucion Kernel 2D = %f',mean(t2D))) % disp(sprintf('Tiempo Convolucion Kernels 1D = %f',mean(t1D)))



Anexos

%% p1 e) I1=imread('I1.bmp');

h1g=(1/12)*[1;3;4;3;1]; h2g=h1g'; hg=h1g*h2g; % 2D conv

[I1_2Dg,t2Dg]=convolucion2D(I1,hg); figure;imshow(uint8(I1_2Dg));title('Convolucion con kernel 2D Gaussiano de

5x5')

% 1D conv

[I1_1Dg,t1Dg]=convolucion1D(I1,h1g,h2g); figure;imshow(uint8(I1_1Dg));title('Convolucion con kernels 1D que componen

filtro Gaussiano de 5x5')

disp(sprintf('Tiempo Convolucion Kernel 2D = %f',t2Dg)) disp(sprintf('Tiempo Convolucion Kernels 1D = %f',t1Dg))

% time measuring

% t1Dg=zeros(20,1); % t2Dg=zeros(20,1); % for i=1:20 % [~,t2Dg(i)]=convolucion2D(I1,hg); % [~,t1Dg(i)]=convolucion1D(I1,h1g,h2g); % end % disp(sprintf('Tiempo Convolucion Kernel 2D = %f [s]',mean(t2Dg))) % disp(sprintf('Tiempo Convolucion Kernels 1D = %f [s]',mean(t1Dg)))

Tarea2p2.m

%% Tarea2p2 clear all;

ha=zeros(3,3); ha(2,2)=9; hb=ones(3,3); resta=ha-hb; suma=ha+hb; sumafilt=suma/sum(suma(:)); %% Respuesta en Freq p2a) y b) close all; F_ha=fftshift(abs(fft2(ha))); F_hb=fftshift(abs(fft2(hb)));

% figure;imagesc(F_ha);colorbar; % figure;imagesc(F_hb);colorbar;



Anexos

F_resta=fftshift(abs(fft2(resta))); F_suma=fftshift(abs(fft2(suma))); figure h1 = bar3(F_resta); title('Respuesta en frecuencia de h_a-h_b ') colorbar for k = 1:length(h1) zdata = get(h1(k),'ZData'); set(h1(k),'CData',zdata,... 'FaceColor','interp') end

figure h2 = bar3(F_suma); title('Respuesta en frecuencia de h_a+h_b ') colorbar for k = 1:length(h2) zdata = get(h2(k),'ZData'); set(h2(k),'CData',zdata,... 'FaceColor','interp') end %% p2 c) close all; I2=imread('I2.bmp');

figure;imshow(I2);title('Imagen Original') figure; I2_resta=imfilter(I2,resta,'conv'); subplot(121);subimage(I2_resta);title('Imagen Filtrada con h_a-h_b') I2_suma=imfilter(I2,sumafilt,'conv'); subplot(122);subimage(I2_suma);title('Imagen Filtrada con h_a+h_b') %% p2 d) close all; resta_x3=imresize(resta,3,'nearest'); resta_x5=imresize(resta,5,'nearest'); resta_x7=imresize(resta,7,'nearest'); suma_x3=imresize(suma,3,'nearest'); suma_x3=suma_x3/sum(suma_x3(:)); suma_x5=imresize(suma,5,'nearest'); suma_x5=suma_x5/sum(suma_x5(:)); suma_x7=imresize(suma,7,'nearest'); suma_x7=suma_x7/sum(suma_x7(:)); I2=imread('I2.bmp'); I2_restax3=imfilter(I2,resta_x3,'conv'); I2_restax5=imfilter(I2,resta_x5,'conv'); I2_restax7=imfilter(I2,resta_x7,'conv'); I2_sumax3=imfilter(I2,suma_x3,'conv'); I2_sumax5=imfilter(I2,suma_x5,'conv'); I2_sumax7=imfilter(I2,suma_x7,'conv');

figure; subplot(131) subimage(I2_restax3); title('Filtro Resta 9x9') subplot(132) subimage(I2_restax5);title('Filtro Resta 15x15')



Anexos

subplot(133) subimage(I2_restax7);title('Filtro Resta 21x21')

figure; subplot(131) subimage(I2_sumax3);title('Filtro Suma 9x9') subplot(132) subimage(I2_sumax5);title('Filtro Suma 15x15') subplot(133) subimage(I2_sumax7);title('Filtro Suma 21x21')



Bibliografía

Bibliografía

“Resumen_3” – EL7007 Introducción al Procesamiento Digital de Imágenes

– Caludio A. Perez, Departamento de Ingeniería Eléctrica, Universidad de

Chile, 2014.

tarea n°2 - u-cursos · 2014. 9. 9. · tarea n°2 separabilidad de filtros y transformada de...

Documents