Bordes: Variaciones fuertes de la intensidad que
corresponden a las fronteras de los objetos
visualizados.[1]
Operadores de gradiente
Detectan
los bordes en base a las derivadas espaciales
de la imagen que se calculan mediante
operadores de convolución.
La derivada de una señal continua proporciona las variaciones locales con respecto a la variable,
de forma que el valor de la derivada es mayor cuanto más rápidas son estas variaciones.
En el caso de funciones bidimensionales f(x,y), la derivada es un vector que apunta en la
dirección de la máxima variación de f(x,y) y cuyo módulo es proporcional a dicha variación. Este
vector se denomina gradiente y se define:
Figura 1. La imagen muestra las funciones gradientes
La primera función es la derivada parcial fx(x,y) (gradiente de fila
GF(i,j) ) y gradiente en el eje Y (GC(i,j)), se obtienen mediante la convolución de
la imagen con las máscaras. La magnitud y orientación del vector gradiente obtiene la imagen final, como lo muestra la función 2.
Operador de Roberts.
Obtiene buena respuesta ante bordes diagonales. Ofrece buenas prestaciones en cuanto a
localización. El gran inconveniente de este operador es su extremada sensibilidad al ruido y por
tanto tiene pobres cualidades de detección. [1]
En el caso discreto, se puede aproximar la derivada diferenciando los valores contiguos.
*Aproximación discreta en esa región:
*Otra alternativa: diferencias cruzadas:
Es el operador de gradiente más simple. Utiliza direcciones diagonales para calcular el vector gradiente mediante las mascaras que se muestran en la figura 1.1.[1]
Figura 1.1. Mascaras de operador de Roberts.
Pseudocodigo para el Operador de Roberts.
1. Leemos la imagen en escala de grises.
2. Se obtiene el tamaño de la imagen.
3. Creamos las matriz para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.
Bordex = np.zeros((row, col), dtype=np.uint8)
Bordey = np.zeros((row, col), dtype=np.uint8)
Final = np.zeros((row, col), dtype=np.uint8)
5. Creamos dos arrays para el filtro de Borde en X y otro en Y de tipo float, en este caso el tamaño será de 2x2.
x = np.array([[1,0],[0,-1]], dtype=np.float)
y = np.array([[0,1],[-1, 0]], dtype=np.float)
6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad, esto para X.
6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1
c = j-1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [c, i] * x[1, 0]
+ image [i, j] * x [1, 1]
c = j-1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [c, i] * x[1, 0]
+ image [i, j] * x [1, 1]
.
7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad., esto para Y.
7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1c = j-1
Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [c, i] * y[1, 0]
+ image [i, j] * y [1, 1]
8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación.
Mx=pow(Bordex,2)
My=pow(Bordey,2)
Final = ((Mx)+(My))**0.5
9. Mostramos la imagen original.
10. Mostramos la imagen Final aplicada la función.
11. Guardamos Imagen.
12. Cerramos ventanas.
13. Fin
Figura 1.2 Ejemplo de una imagen original y su función operador de Roberts.
Operador de Prewitt.
El operador de Prewitt expande la definición del gradiente en máscara de 3 x 3 para ser más inmune al ruido, utiliza la misma ecuación que Roberts, pero con una constante k=1 como se muestra en la figura 1.3.[1]
Figura 1.3. Mascaras de operador de Prewitt
Este operador no otorga importancia especial a píxeles cercanos al centro de la máscara
Pseudocodigo para el Operador de Prewitt.
1. Leemos la imagen en escala de grises.
2. Se obtiene el tamaño de la imagen.
3. Creamos las matriz para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.
Bordex = np.zeros((row, col), dtype=np.uint8)
Bordey = np.zeros((row, col), dtype=np.uint8)
Final = np.zeros((row, col), dtype=np.uint8)
5. Creamos dos arrays para el filtro de Borde en X y otro en Y de tipo float, en este caso el tamaño será de 3x3.
x = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float)
6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad, esto para X.
6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1
b = i + 1
c = j-1
d = j + 1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
+ image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
+ image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]
b = i + 1
c = j-1
d = j + 1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
+ image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
+ image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]
7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad., esto para Y.
7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1b = i + 1
c = j-1
d = j + 1
Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [a, d] * y[0, 2]
+ image [i, c] * y[1, 0] + image [i, j] *y [1, 1] + image [i, d] * y [1, 2]
+ image [b, c] * y [2, 0] + image [b, j]*y [2, 1] + image [b, d] * y [2, 2]
8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación.
Mx=pow(Bordex,2)
My=pow(Bordey,2)
Final = ((Mx)+(My))**0.5
9. Mostramos la imagen original.
10. Mostramos la imagen final aplicada la función.
11. Guardamos Imagen.
12. Cerramos ventanas.
13. Fin
Figura 1.4 Ejemplo de una imagen original y su función operador de Prewitt.
Operador de Sobel.
De igual manera que en el operador de Robert, para este operador usamos la misma ecuación que es la magnitud del gradiente, al igual que los demás operadores Sx y Sy puede implementarse usando máscaras de convolución.[2]
Este operador pone un especial énfasis en pixeles cercanos al centro de la máscara, este maneja una constante k=2, se obtiene con el producto de un vector de diferenciación por uno de suavizamiento. [2]
Figura 1.5. Mascaras del operador de Sobel
Pseudocodigo para el Operador de Sobel.
Nota: En este caso solo cambia las máscaras
1. Leemos la imagen en escala de grises.
2. Se obtiene el tamaño de la imagen.
3. Creamos las matriz para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.
Bordex = np.zeros((row, col), dtype=np.uint8)
Bordey = np.zeros((row, col), dtype=np.uint8)
Final = np.zeros((row, col), dtype=np.uint8)
5. Creamos dos arrays para el filtro de Borde en X y otro en Y de tipo float, en este caso el tamaño será de 3x3.
x = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float)
6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad, esto para X.
6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1
b = i + 1
c = j-1
d = j + 1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
+ image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
+ image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]
b = i + 1
c = j-1
d = j + 1
Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
+ image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
+ image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]
7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1 y termine con una posición menos para el manejo de la vecindad., esto para Y.
7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:
a = i-1b = i + 1
c = j-1
d = j + 1
Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [a, d] * y[0, 2]
+ image [i, c] * y[1, 0] + image [i, j] *y [1, 1] + image [i, d] * y [1, 2]
+ image [b, c] * y [2, 0] + image [b, j]*y [2, 1] + image [b, d] * y [2, 2]
8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación.
Mx=pow(Bordex,2)
My=pow(Bordey,2)
Final = ((Mx)+(My))**0.5
9. Mostramos la imagen original.
10. Mostramos la imagen final, aplicada la función.
11. Guardamos Imagen.
12. Cerramos ventanas.
13. Fin
Figura 1.4 Ejemplo de una imagen original y su función operador de Sobel.
Laplaciano de una Gaussiana.
Este detector de orillas se basa en la
segundas derivadas o Laplaciano de una Gaussiana.
La ventaja de usar un operador que se basa en la segunda derivada es que se puede estimar con
mayor presición la localización de la orilla, que es exactamente donde la segunda derivada cruza
cero.
En una primera aproximación al Laplaciano de una Gaussiana, podría preprocesarse la imagen
con un suavizamiento Gaussiano, para eliminar ruido, seguido de un operador Laplaciano. El
Laplaciano de una Gaussiana (LOG: Laplacian of a Gaussian) se expresa como:[3]
∇^2G = (∂^2G/∂x ^2
) + (∂^ 2G/∂y^ 2
)
Donde G es una distribución normal o Gaussiana en dos dimensiones.
Figura 1.5.Máscara 3x3 para el operador Laplaciano.
Figura 1.6.Máscara 3x3 para el operador Laplaciano de una Gaussiana.
Referencias
[1]http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/ramos_r_m/capitulo3.pdf
[2]http://www.sc.ehu.es/ccwgrrom/transparencias/pdf-vision-1-transparencias/capitulo-6.pdf
Consulta 15 de Diciembre del 2016
Consulta 8 de Enero del 2017
