METODO DE DETECCION DE

BORDES

ERIKA LOPEZ ANTONIO

INSTITUTO TECNOLOGICO DE LAZARO CARDENAS
DETECCION DE BORDES

Un borde, dentro de una imagen es considerado un tipo de discontinuidad, por lo

que este puede ser detectado usando derivadas de primer y segundo orden.
La derivada de primer orden para una imagen es el gradiente, el cual, para la
función en dos dimensiones; f (x,y), viene dado por la siguiente formula:

La magnitud de este vector es:

Esta cantidad se puede simplificar en algunos casos, omitiendo la raíz cuadrada

de la operación:

O usando el valor absoluto de los términos:

Esta aproximación, se comporta también como una derivada, esto quiere decir,
que se hace cero en área de intensidad constante y sus valores son
proporcionados al grado de cambio de intensidad, en áreas donde los valores de
los pixeles son variables. Es común referirse a la magnitud del gradiente o su
aproximación simplemente como “el grandiente”

MATLAB
Ejemplo en matlab de la detección de bordes definiendo un filtro para detección de
bordes.
 La imagen a filtrar debe estar en escala de grises.
 Para convertir RGB a escala de grises se utiliza el comando:

Imagen_gray=rgb2gray(Imagen_RGB);
 >> filter=[1 2 1;0 0 0;-1 -2 -1];
>> Im_RGB=imread('medusa.jpg');
>> Im_gray=rgb2gray(Im_RGB);
>> Im_edge=filter2(filter,Im_gray);
>> imshow(Im_RGB);
>>figure,imshow(Im_edge);

Se realiza para atenuar el ruido de una imagen.

 Usualmente se aplica a imágenes en escala de grises.

Imagen2=medfilt2(Imagen)
Ejemplo:

>> Im_RGB=imread('fruta.jpg');
>> Im_gray=rgb2gray(Im_RGB);
>> Im_gray=imnoise(Im_gray, 'salt
& pepper');
>> imshow(Im_gray)
>> Im_filt=medfilt2(Im_gray);
>> figure, imshow(Im_filt)

 Se realiza con el comando:

imagen_edge=edge(imagen_gray,’mascara’);

 Se requiere que la imagen esté en escala de grises.

 mascara es el tipo de mascara a utilizar (sobel, canny,prewit, …) ya
predefinidas en Matlab.
 Se realiza la detección de bordes de una imagen utilizando la máscara de
"sobel".
 >> Im_RGB=imread('Penguins.jpg');
>> Im_gray=rgb2gray(Im_RGB);
>> Im_edge=edge(Im_gray,'sobel');
>> imshow(Im_edge)

Conversión de una imagen en escala de grises a una imagen lógica (0=negro,

1=blanco).
 Se realiza con el comando:

Imagen_bin=imagen<=Umbral

Dónde: Umbral es un número entre 0 y 255.

 También se puede usar el siguiente comando cuando se requiere binarizar
una imagen RGB directamente.

Imagen_bin=im2bw(Imagen,level)

Dónde: level es el nivel de umbral entre 0 y 1.

Binarización de una imagen con un umbral de 128.

>> Im_bin=Im_gray>=128
OPERADOR DE PREWITT

Se busca implementar un detector de bordes mediante detección por gradiente,

según el operador de Prewitt o Sobel. Se optó por la implementación del operador
de Prewitt, que consiste en los siguientes Kernels:

De esta manera, el gradiente de una imagen en la dirección horizontal es

y el gradiente en la dirección vertical es .

Es importante destacar que el gradiente horizontal permite detectar bordes
orientados verticalmente, mientras que para el gradiente vertical se detectan los
bordes orientados horizontalmente.
Finalmente, el gradiente total de la imagen se puede obtener mediante distintas
formas de combinar , donde los métodos más utilizados son:

Luego, la imagen del gradiente debe ser binarizada con un umbral adecuado para
la detección de los bordes deseados.
a) Implementación de filtrado con operador Prewitt.
Mediante la función de Matlab conv2, se logró implementar el filtrado de cada
componente del operador de Prewitt con la imagen de entrada spiderweb.jpg, la
cual se muestra en la Figura 1. Los resultados obtenidos se muestran en las
imágenes Im1 e Im2 de la Figura 2. Se observa que existen diferencias entre los
bordes resaltados en cada imagen, aunque existen algunas partes en común
debido a las componentes diagonales de la imagen. En ambas se identifica la
presencia de ruido debido a que este operador resalta los cambios en la
intensidad sin importar que sean cambios leves.

b) Binarización de Im1 e Im2.

Se implementó la función de Matlab im2bin(img,t), que permite establecer un
umbral t entre 0 y 1 de manera que si el umbral es superado en la imagen se tiene
un valor 0. En caso contrario, se tiene un valor de 1. Así, luego de varias pruebas,
se determinó que un umbral adecuado para percibir los bordes en la imagen es
t1=0.21, con lo cual se lograron los resultados mostrados en la Figura 3. Se
pueden percibir claramente los bordes de la telaraña, más un poco de ruido binario
que puede ser reducido con un filtro mediano si se desea.

c) y d) Gradiente máximo y efecto del umbral.

Se combinaron las imágenes Im1 e Im2 mediante la ecuación (2) para obtener el
gradiente completo de la imagen, luego se binarizó la imagen del gradiente
máximo, y se buscó un umbral t2, tal que los bordes fueran apenas perceptibles.
El valor encontrado para esta condición es de t2=0.42. Así, en la Figura 4, se
muestran las imágenes binarias con los bordes detectados para este umbral y

para
de t2.
En la imagen con umbral igual a t2 apenas se pueden percibir algunos bordes. Sin
embargo, al disminuirlo a la mitad ya se pueden detectar perfectamente varios
bordes de la imagen. Para el caso de la imagen de bordes detectada para ¼ del
valor de t2, se observa que los bordes de la telaraña se comienzan a mezclar,
debido a que se están considerando las diferencias menores entre las
intensidades de los pixeles correspondientes a los sectores entre los bordes de la
telaraña, este efecto se acentúa cuando el umbral se elige cada vez menor, donde
un valor muy pequeño como 1/32 de t2 no permite percibir ningún borde en la
imagen, debido a que se considera que toda variación muy pequeña es un borde.

function [im1,im2]=prewitt(img,graph)
%Detector de bordes mediante operador Prewitt
%Si el parámetro graph es 1, grafica Im1 e Im2.
if nargin <2
graph=0;
end
P_hor=[-1 0 1;-1 0 1;-1 0 1];
P_vert=[-1 -1 -1; 0 0 0; 1 1 1];
im1=conv2(double(img),double(P_hor),'same');
im2=conv2(double(img),double(P_vert),'same');
if(graph==1)
figure;
colormap(gray)
subplot('Position',[0.05,0.25,0.4,0.5])
imagesc(im1)
title(sprintf('Im1, Kernel Prewitt Horizontal\n (Detecta Bordes
Verticales)'))
subplot('Position',[0.55,0.25,0.4,0.5])
imagesc(im2)
title(sprintf('Im2, Kernel Prewitt Vertical\n (Detecta Bordes
Horizontales)'))
end
e) Bordes relacionados con la telaraña
Finalmente, se determinó que un umbral con valor entre t2 y ½ t2 podría permitir
detectar los bordes de las telarañas únicamente, por lo que finalmente se lograron
resultados adecuados con el valor de umbral t3=0.28. Los resultados se muestran
en la Figura 5, donde se aprecian claramente los bordes de la telaraña en todas
las direcciones.

Gradiente por Operador de Roberts

Análogo al primer problema de esta tarea, el segundo problema plantea
implementar el operador de Roberts, compuesto por los siguientes Kernels:
a) Implementación de filtrado con operador Roberts.
La implementación es análoga a la del operador de Prewitt, ya que sólo basta
cambiar los Kernels utilizados. En este caso se utiliza la imagen de entrada
ldda.jpg, la cual se muestra en la Figura 6. Los resultados obtenidos al aplicar el
operador de
Roberts en cada componente se muestran en las imágenes Im3 e Im4 de la Figura
7.
En este caso, debido a que los kernels son de tamaño 2x2, no es claro que un
operador realice detección de bordes horizontales y otro de bordes verticales, pero
sí existe una diferencia en las direcciones de los bordes resaltados en las
imágenes mostradas en la Figura 7.
b) Binarización de Im3 e Im4.
Se utilizó la misma función desarrollada para p1.b), determinando que un umbral
adecuado es t4=0.1, logrando las imágenes binarias mostradas en la Figura 8.

En ambas imágenes se nota que existe una alta cantidad de ruido binario, debido
a que los bordes se perderían si se aumenta el umbral. Se puede observar que
existen diferencias en los bordes detectados, aunque mayoritariamente se
comparten los bordes en ambas imágenes debido a las múltiples direcciones de
las líneas en el cuadro.
c) Magnitud del gradiente y versión coloreable del cuadro.
Se combinaron las componentes del gradiente aproximado por operador de
Roberts calculando la magnitud del gradiente mediante la ecuación (1), y se
binarizó la imagen resultante con un umbral t5=0.065, el cual demostró los
mejores resultados para el objetivo de crear una imagen “coloreable”, es decir con
sólo los bordes de las figuras. El resultado se muestra en la Figura 9 (Izquierda).
Además de lo pedido, se probó la efectividad de un filtrado mediano con una
ventana de 2x2, logrando mostrar que se elimina parte del ruido binario presente,
además de suavizar las líneas diagonales y se obtiene un mejor efecto visual. Por
otro lado también se mezclan algunos bordes detectados, generando zonas más
oscuras que pierden detalle, como por ejemplo los ojos de las damas. La imagen
final resultante se muestra en la Figura 9 (Derecha).

Los resultados logrados son totalmente satisfactorios y se demuestra que el

filtrado mediano reduce considerablemente el ruido binario, logrando una imagen
más suave y con bordes más definidos que utilizando únicamente el gradiente.
 function [im3,im4]=roberts(img,graph)
%Detector de bordes mediante operador Roberts
%Si el parámetro graph es 1, grafica Im3 e Im4.
if nargin <2
graph=0;
end
R_hor=[0 1;-1 0];
R_vert=[1 0;0 -1];
im3=conv2(double(img),double(R_hor),'same');
im4=conv2(double(img),double(R_vert),'same');
if(graph==1)
figure;
colormap(gray)
subplot('Position',[0.05,0.25,0.4,0.5])
imagesc(im3)
title(sprintf('Im3, Kernel Roberts Horizontal\n (Detecta Bordes
Verticales)'))
subplot('Position',[0.55,0.25,0.4,0.5])
imagesc(im4)
title(sprintf('Im4, Kernel Roberts Vertical\n (Detecta Bordes
Horizontales)'))
end

DETECTOR DE BORDES SOBEL

El detector de borde Sobel usa la máscara que se muestra en la figura 3.3 para
aproximar digitalmente las primeras derivadas Gx y Gy, de tal manera, que el
gradiente en el punto central de un vecindario puede ser computado por el
detector de Sobel como sigue:

Entonces, un pixel en la ubicación (x,y) es considerado un pixel de borde si g≥T en

esa ubicación, donde T es un umbral que debe ser especificado.
Figura 3.3 Mascaras del detector Sobel.

El código en Matlab del operador de Sobel para la detección de bordes es:

 function S = BordeSobel(imagen)
im=imread(imagen);
imD = double(im);
radio=1;
%el operador de Sobel usa mascarilla de 3x3=>radio=1
matriz = RefMatriz(imD,radio);
[f,c] = size(matriz);
for i=1+radio:(f-radio)
for j=1+radio:(c-radio)
sumfil=(matriz(i+radio,j-radio)+2*matriz(i+radio,j)+
matriz(i+radio,j+radio))-(matriz(i-radio,j-radio)+

2*matriz(i-radio,j)+matriz(i-radio,j+radio));

sumcol=(matriz(i-radio,j+radio)+2*matriz(i,j+radio)+
matriz(i+radio,j+radio))-(matriz(i-radio,j-radio)+

2*matriz(i,j-radio)+matriz(i+radio,j-radio));
G(i-radio,j-radio)=fix(sumfil+sumcol);
end
end
S=Negativo(G);
subplot(1,2,1);
imshow(imagen);
title('Imagen Original');
subplot(1,2,2);
imshow(uint8(S));
title('Deteccion de Bordes usando Sobel');

BIBLIOGRAFIA
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
Implementación de un algoritmo para la detección y conto de células en
imágenes microscópicas.
Autores: Moreira Quiroz José, Valencia Delgado Vladimir, Chávez Burbano
Patricia.
Facultad de Ingeniería en Electricidad y Computación (FIELC)
Escuela Superior Politécnica del Litoral (ESPOL)
Campus Gustavo Galindo.
I Seminario sobre Sistemas Inteligentes 2006