Operador
En el procesamiento de imágenes, la detección de bordes es una parte inseparable y los operadores pueden considerarse un medio para la detección de bordes. Como nosotros que aprendemos EE, el operador es como un filtro Butterworth, que filtra lo que no queremos y deja lo que necesitamos; también es como el colador de arroz que vimos cuando éramos jóvenes. El arroz que comemos en casa es mixto con muchas cosas "extrañas", como piedras pequeñas, espigas de trigo, etc., a diferencia del arroz que compramos ahora, que es tamizado por máquinas para nosotros, es raro que nuestros dientes puedan hacer clic repentinamente cuando comemos arroz. Por un momento , fue realmente doloroso en ese momento.
En este artículo se utiliza el operador Sobel, que utiliza dos núcleos de 3 × 3 convolucionados con la imagen original para calcular el valor aproximado de la derivada, uno para cambios horizontales y otro para cambios verticales.
Si definimos A como la imagen de origen y G x G_xGRAMOx和G y G_yGRAMOySon dos imágenes, cada punto contiene las aproximaciones derivadas vertical y horizontal, entonces el cálculo es el siguiente:
G x = [- 1 0 + 1 - 2 0 + 2 - 1 0 + 1] ∗ AG y = [- 1 - 2 - 1 0 0 0 + 1 + 2 + 1] ∗ A G_x = \ begin {bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \\ \ end {bmatrix} * A \ quad \ quad \ quad G_y = \ begin {bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \\ \ end {bmatrix} \ * AGRAMOx=⎣⎡- 1- 2- 1000+ 1+ 2+ 1⎦⎤∗AGRAMOy=⎣⎡- 10+ 1- 20+ 2- 10+ 1⎦⎤ ∗A
aquí,∗ *∗ representa la operación de convolución, es decir, se multiplican las posiciones correspondientes de las dos matrices, es decir, multiplicación de puntos.
Obviamente, el "píxel" de una imagen no es todo 3 × 3, e incluso ninguna imagen es tan pequeña. Entonces, el método de implementación anterior también es muy simple, es decir, comenzando desde la esquina superior izquierda de A, mover línea por línea y luego regrese a la línea siguiente, hasta la esquina inferior derecha.
Aquí hay una foto de mi blogger favorito (victorzhou).
En la mayoría de los casos, el tamaño de la imagen "filtrada" debe ser igual a la imagen original. Generalmente, hay dos formas de resolverlo. Aquí utilizo relleno de cero en la periferia de la imagen procesada, es decir, oscurecimiento.
Implementación de algoritmos
Después de una breve introducción, mi código se da a continuación. El código consta de varias partes. Primero, se da la parte principal:
def sobel_v(img, threshold):
'''
edge detection with the vertical Sobel filter
Parameters
----------
img : TYPE
the image input.
threshold : TYPE
varies for application [0 255].
Returns
-------
mag : TYPE
output after edge detection.
'''
G_x = np.array([[-1, 0, 1],[-2, 0, 2],[-1, 0, 1]])
rows = np.size(img, 0)
columns = np.size(img, 1)
mag = np.zeros(img.shape)
for i in range(0, rows - 2):
for j in range(0, columns - 2):
v = sum(sum(G_x * img[i:i+3, j:j+3])) # vertical
mag[i+1, j+1] = v
for p in range(0, rows):
for q in range(0, columns):
if mag[p, q] < threshold:
mag[p, q] = 0
return mag
Esta es la detección en la dirección vertical. Las imágenes antes y después del procesamiento se comparan de la siguiente manera:
Entonces la detección en la dirección horizontal es muy simple.
def sobel_h(img, threshold):
'''
edge detection with the horizon Sobel filter
Parameters
----------
img : TYPE
the image input.
threshold : TYPE
varies for application [0 255].
Returns
-------
mag : TYPE
output after edge detection.
'''
G_y = np.array([[-1, -2, -1],[0, 0, 0],[1, 2, 1]])
rows = np.size(img, 0)
columns = np.size(img, 1)
mag = np.zeros(img.shape)
for i in range(0, rows - 2):
for j in range(0, columns - 2):
h = sum(sum(G_y * img[i:i+3, j:j+3])) # horizon
mag[i+1, j+1] = h
for p in range(0, rows):
for q in range(0, columns):
if mag[p, q] < threshold:
mag[p, q] = 0
return mag
Las direcciones horizontal y vertical se realizan al mismo tiempo, es decir, al calcular cada píxel, los valores horizontal y vertical se pueden procesar como una suma cuadrada.
def sobel(img, threshold):
'''
edge detection based on sobel
Parameters
----------
img : TYPE
the image input.
threshold : TYPE
varies for application [0 255].
Returns
-------
mag : TYPE
output after edge detection.
'''
G_x = np.array([[-1, 0, 1],[-2, 0, 2],[-1, 0, 1]])
G_y = np.array([[-1, -2, -1],[0, 0, 0],[1, 2, 1]])
rows = np.size(img, 0)
columns = np.size(img, 1)
mag = np.zeros(img.shape)
for i in range(0, rows - 2):
for j in range(0, columns - 2):
v = sum(sum(G_x * img[i:i+3, j:j+3])) # vertical
h = sum(sum(G_y * img[i:i+3, j:j+3])) # horizon
mag[i+1, j+1] = np.sqrt((v ** 2) + (h ** 2))
for p in range(0, rows):
for q in range(0, columns):
if mag[p, q] < threshold:
mag[p, q] = 0
return mag
Obviamente, el efecto de la última imagen es el mejor.
Digresión
Se adjuntan dos pequeños programas, que se utilizan para la visualización y el procesamiento de imágenes. El cuadro de comparación anterior viene dado por estos dos programas.
import numpy as np
import cv2
def img_show(img):
cv2.namedWindow("Image")
cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def sub_plot(img_1, img_2):
l = np.size(img, 1)/4 # a quarter of the columns
rows = np.size(img, 0)
interval = np.ones((rows, int(l)))
interval = interval * 255
img_o = np.concatenate((img_1, interval, img_2), axis=1)
return img_o
img = cv2.imread('CNN/pic1.jpg', 0) # read an image
mag = sobel(img, 70)
mag_v = sobel_v(img, 70)
mag_h = sobel_h(img, 70)
# img_show(mag)
v = sub_plot(img, mag_v)
h = sub_plot(img, mag_h)
a = sub_plot(img, mag)
v, h, av, h, a v ,h ,a son tres imágenes comparativas.
(Esto es solo un presagio de CNN)
- - - - - - - - - - - - - - - - ---------------- --------------- -
Este artículo apareció por primera vez enzyairelu.cn
Bienvenido a mi sitio web para comentar y discutir
el buzón personal [email protected]
- - - - - - - - - - - - - - - -------- - ---------------------- -