Este artículo se comparte desde la comunidad de la nube de Huawei " [Python de cero a uno] Fifty-Eight. Mejora de imágenes y computación: nitidez de imágenes con operadores Sobel y Laplacian para realizar la detección de bordes ", autor: Eastmount.

1.Operador Sobel

El operador de Sobel es un operador diferencial discreto para la detección de bordes que combina suavizado gaussiano y derivación diferencial. Este operador se utiliza para calcular el valor aproximado del brillo de la imagen. De acuerdo con el brillo junto al borde de la imagen, los puntos específicos que exceden un cierto número en el área se registran como bordes. El operador de Sobel agrega el concepto de peso sobre la base del operador de Prewitt. Cree que la distancia entre puntos adyacentes tiene diferentes efectos en el píxel actual. Cuanto más cerca esté la distancia del píxel, mayor será el impacto en el píxel actual, por lo que Realización de la imagen Enfoque y resalte los contornos de los bordes [1-4].

El posicionamiento de bordes del operador Sobel es más preciso y se utiliza a menudo en imágenes con mucho ruido y gradientes de escala de grises. Su plantilla de algoritmo se muestra en la fórmula (1), donde dx representa la dirección horizontal y dy representa la dirección vertical [3].

La fórmula de cálculo de píxeles es la siguiente:

La fórmula de cálculo final del píxel del operador Sobel es la siguiente:

El operador Sobel detecta bordes basándose en la diferencia ponderada en el nivel de gris entre los puntos adyacentes superior e inferior y derecho e izquierdo de un píxel, alcanzando un valor extremo en el borde. Tiene un efecto de suavizado del ruido y proporciona información más precisa sobre la dirección de los bordes. Debido a que el operador Sobel combina suavizado gaussiano y derivación diferencial (diferenciación), el resultado será más resistente al ruido. Cuando los requisitos de precisión no son muy altos, el operador Sobel es un método de detección de bordes más utilizado.

Python y OpenCV encapsulan el operador Sobel en la función Sobel (), y su prototipo de función es el siguiente:

dst = Sobel(src, dprofundidad, dx, dy[, dst[, ksize[, escala[, delta[, borderType]]]]])
– src representa la imagen de entrada

– dst representa el mapa de borde de salida, que tiene el mismo tamaño y número de canales que la imagen de entrada

– dprofundidad representa la profundidad requerida de la imagen de destino. Para diferentes imágenes de entrada, la imagen de destino de salida tiene diferentes profundidades.

– dx representa el orden diferencial en la dirección x, tomando el valor 1 o 0

– dy representa el orden de diferencia en la dirección y, tomando el valor 1 o 0

– ksize representa el tamaño del operador Sobel y su valor debe ser un número positivo y un número impar.

– la escala representa la constante de escala de la derivada de escala, no hay ningún factor de escala por defecto

– delta representa un valor incremental opcional agregado al resultado antes de almacenarlo en la imagen de destino

– borderType representa el modo de borde. Para más detalles, consulte BorderTypes

Tenga en cuenta que después de realizar el procesamiento del operador Sobel, también debe llamar a la función convertScaleAbs() para calcular el valor absoluto y convertir la imagen en una imagen de 8 bits para su visualización. El prototipo del algoritmo es el siguiente:

dst = convertScaleAbs(src[, dst[, alfa[, beta]]])
– src representa la matriz original

– dst representa la matriz de salida, con una profundidad de 8 bits

– alfa representa el factor de escala

– beta representa el valor agregado después de escalar los elementos de la matriz original

El código de implementación del operador Sobel es el siguiente.

# -*- codificación: utf-8 -*- 

# Por:Eastmount 

importar cv2 

importar numpy como np 

importar matplotlib.pyplot como plt 



#Leer imagen 

img = cv2.imread('luo.png') 

lenna_img = cv2.cvtColor( img ,cv2.COLOR_BGR2RGB) 

#Imagen procesada en escala de grises 

grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 



#Operador Sobel 

x = cv2.Sobel(grayImage, cv2.CV_16S, 1, 0) #Encontrar el primer orden para x Derivar 

y = cv2.Sobel(grayImage, cv2.CV_16S, 0, 1) #Encontrar la primera derivada de y 

absX = cv2.convertScaleAbs(x) 

absY = cv2.convertScaleAbs(y) 

Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5 , 0) 

#Se usa para mostrar etiquetas chinas normalmente 

plt.rcParams['font.sans-serif']=['SimHei'] 

#Mostrar 

títulos de gráficos = ['imagen original', 'Sobel operator'] 

imágenes = [lenna_img,Sobel]

para i en rango(2): 

plt.subplot(1,2,i+1), plt.imshow(images[i], 'gris') 

plt.title(titles[i]) 

plt.xticks([]) ,plt.yticks([]) 

plt.show()

Los resultados de la ejecución se muestran en la Figura 1:

2. Operador laplaciano

El operador laplaciano es un operador diferencial de segundo orden en el espacio euclidiano de n dimensiones y se utiliza a menudo en el campo de la mejora de imágenes y la extracción de bordes. Calcula los píxeles en el vecindario a través de la diferencia de escala de grises. El proceso básico es:

Determine el valor de gris del píxel central de la imagen y el valor de gris de otros píxeles a su alrededor;
Si el nivel de gris del píxel central es mayor, aumente el nivel de gris del píxel central;
Por el contrario, la escala de grises del píxel central se reduce para lograr una operación de nitidez de la imagen.

En el proceso de implementación del algoritmo, el operador laplaciano calcula el gradiente en las cuatro u ocho direcciones del píxel central en el vecindario y luego agrega los gradientes para determinar la relación entre la escala de grises del píxel central y la escala de grises de otros píxeles en el vecindario Finalmente, a través de la operación de gradiente Como resultado, se ajusta la escala de grises de píxeles [2].

Una función binaria continua f(x,y), su operación laplaciana se define como:

El operador laplaciano se divide en cuatro vecindarios y ocho vecindarios: cuatro vecindarios es encontrar el gradiente en cuatro direcciones del píxel central del vecindario y ocho vecindarios es encontrar el gradiente en ocho direcciones. Entre ellos, la plantilla de cuatro vecinos se muestra en la fórmula (5):

La fórmula de cálculo de sus píxeles se puede simplificar como:

A través de la plantilla se puede encontrar que cuando la escala de grises de los píxeles en el vecindario es la misma, el resultado de la operación de convolución de la plantilla es 0; cuando la escala de grises del píxel central es mayor que la escala de grises promedio de otros píxeles en el vecindario, el El resultado de la operación de convolución de la plantilla es un número positivo; cuando el nivel de gris del píxel central es menor que el nivel de gris promedio de otros píxeles en el vecindario, la convolución de la plantilla es negativa. El resultado de la operación de convolución se procesa con un factor de atenuación apropiado y se agrega al píxel central original para lograr una imagen más nítida.

La plantilla de ocho vecindarios del operador laplaciano es la siguiente:

La fórmula de cálculo de sus píxeles se puede simplificar como:

Python y OpenCV encapsulan el operador laplaciano en la función Laplacian (), y su prototipo de función es el siguiente:

dst = Laplaciano(src, dprofundidad[, dst[, ksize[, escala[, delta[, borderType]]]]])
– src representa la imagen de entrada

– dst representa el mapa de borde de salida, que tiene el mismo tamaño y número de canales que la imagen de entrada

– dprofundidad representa la profundidad requerida de la imagen de destino

– ksize representa el tamaño de apertura del filtro utilizado para calcular la segunda derivada. Su valor debe ser un número positivo y un número impar, y el valor predeterminado es 1. Para obtener más detalles, consulte getDerivKernels

– escala indica un factor de escala opcional para calcular el valor laplaciano. El valor predeterminado es 1; consulte getDerivKernels para obtener más detalles.

– delta representa un valor incremental opcional agregado al resultado antes de almacenarlo en la imagen de destino. El valor predeterminado es 0

– borderType representa el modo de borde. Para más detalles, consulte BorderTypes

Tenga en cuenta que el operador laplaciano en realidad utiliza principalmente la operación del operador Sobel: al agregar las derivadas en las direcciones x e y de la imagen calculada por el operador Sobel, se obtiene el resultado de nitidez de la imagen de entrada.

Al mismo tiempo, después de realizar el procesamiento del operador laplaciano, también debe llamar a la función convertScaleAbs () para calcular el valor absoluto y convertir la imagen en una imagen de 8 bits para su visualización. Su prototipo de algoritmo es el siguiente:

dst = convertScaleAbs(src[, dst[, alfa[, beta]]])
– src representa la matriz original

– dst representa la matriz de salida, con una profundidad de 8 bits

– alfa representa el factor de escala

– beta representa el valor agregado después de escalar los elementos de la matriz original

Cuando ksize = 1, la función Laplacian () utiliza una apertura de 3 × 3 (plantilla de cuatro vecinos) para el procesamiento de transformación. El siguiente código utiliza el operador laplaciano de ksize=3 para mejorar la nitidez de la imagen. El código es el siguiente:

# -*- codificación: utf-8 -*- 

# Por:Eastmount 

importar cv2 

importar numpy como np 

importar matplotlib.pyplot como plt 



#Leer imagen 

img = cv2.imread('luo.png') 

lenna_img = cv2.cvtColor( img ,cv2.COLOR_BGR2RGB) 

#Imagen procesada en escala de grises 

grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 



#Algoritmo laplaciano 

dst = cv2.Laplacian(grayImage, cv2.CV_16S, ksize = 3) 

Laplaciano = cv2.convertScaleAbs(dst) 

#Usado para mostrar etiquetas chinas normalmente 

plt.rcParams['font.sans-serif']=['SimHei'] 

#Mostrar 

títulos de gráficos = ['imagen original', 'Operador laplaciano'] 

imágenes = [lenna_img, Laplacian] 

para i en el rango (2): 

plt.subplot(1,2,i+1), plt.imshow(imágenes[i], 'gris') 

plt.title(títulos[i])

plt.xticks([]),plt.yticks([]) 

plt.show()

Los resultados de la ejecución se muestran en la Figura 2:

El algoritmo de detección de bordes se basa principalmente en las derivadas de primer y segundo orden de la intensidad de la imagen, pero las derivadas suelen ser muy sensibles al ruido, por lo que se necesita un filtro para filtrar el ruido y se llama al algoritmo de mejora o umbral de la imagen para su procesamiento. y finalmente se realiza la detección de bordes. El siguiente es el proceso de detección de bordes después de la eliminación de ruido y el umbral del filtro gaussiano, y compara cuatro algoritmos comunes de extracción de bordes.

# -*- codificación: utf-8 -*- 

# Por:Eastmount 

importar cv2 

importar numpy como np 

importar matplotlib.pyplot como plt 

#Leer imagen 

img = cv2.imread('luo.png') 

lenna_img = cv2.cvtColor( img , cv2.COLOR_BGR2RGB) 

#Imagen de procesamiento en escala de grises 

grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 

#Filtrado gaussiano 

gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0) 

#Procesamiento de umbral 

ret, binario = cv2.threshold (gaussianBlur, 127, 255, cv2.THRESH_BINARY) 

#Operador de Roberts 

kernelx = np.array([[-1,0],[0,1]], dtype=int) 

kernely = np.array([ [0,- 1],[1,0]], dtype=int) 

x = cv2.filter2D(binario, cv2.CV_16S, kernelx) 

y = cv2.filter2D(binario, cv2.CV_16S, kernely)

absX = cv2.convertScaleAbs(x) 

absY = cv2.convertScaleAbs(y) 

Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0) 

#Prewitt算子

kernelx = np.array([[1,1,1] ,[0,0,0],[-1,-1,-1]], dtype=int) 

kernely = np.array([[-1,0,1],[-1,0,1], [-1,0,1]], dtype=int) 

x = cv2.filter2D(binario, cv2.CV_16S, kernelx) 

y = cv2.filter2D(binario, cv2.CV_16S, kernely) 

absX = cv2.convertScaleAbs(x) 

absY = cv2.convertScaleAbs(y) 

Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0) 

#Sobel算子

x = cv2.Sobel(binary, cv2.CV_16S, 1, 0) 

y = cv2.Sobel( binario, cv2.CV_16S, 0, 1) 

absX = cv2.convertScaleAbs(x) 

absY = cv2.convertScaleAbs(y) 

Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#拉普拉斯算法

dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3) 

Laplacian = cv2.convertScaleAbs(dst) 

#效果图

titles = ['Imagen fuente', 'Imagen binaria', 'Imagen de Roberts' , 

'Imagen de Prewitt', 'Imagen de Sobel', 'Imagen de Laplacian'] 

imágenes = [lenna_img, binario, Roberts, Prewitt, Sobel, Laplacian] 

para i en np.arange(6): 

plt.subplot(2,3,i +1),plt.imshow(imágenes[i],'gris') 

plt.title(títulos[i]) 

plt.xticks([]),plt.yticks([]) 

plt.show()

Los resultados de salida se muestran en la Figura 3. Entre ellos, el operador laplaciano es relativamente sensible al ruido. Dado que su algoritmo puede causar límites de doble píxel, a menudo se usa para determinar si los píxeles del borde están ubicados en las áreas brillantes u oscuras de la imagen, y rara vez se usa para la detección de bordes. ; el operador Robert es adecuado para imágenes pronunciadas y con poco ruido. El efecto es mejor, especialmente para imágenes con más bordes de más y menos 45 grados, pero la precisión de posicionamiento es pobre; el operador Prewitt tiene un mejor efecto en la extracción de bordes de imágenes con gradientes de gris, sin considerar la distancia entre puntos adyacentes para el píxel actual. La influencia de los puntos; el operador de Sobel tiene en cuenta factores integrales y tiene mejores efectos de procesamiento en imágenes con más ruido.

3. Resumen

Este artículo presenta principalmente el conocimiento de la nitidez de la imagen y la detección de bordes, explica en detalle el operador de Sobel y el operador laplaciano y extrae contornos de bordes a través de pequeñas imágenes de Luoluo. La tecnología de nitidez de imágenes y extracción de bordes puede eliminar el ruido en las imágenes, extraer algunas variables utilizadas para caracterizar las imágenes en la información de la imagen y proporcionar una base para el reconocimiento de imágenes.

referencias:

[1] Escrito por González, traducido por Ruan Qiuqi. Procesamiento de imágenes digitales (3.ª edición) [M] Beijing: Electronic Industry Press, 2013.
[2] Ruan Qiuqi, Procesamiento de imágenes digitales (3.ª edición) [M], Beijing: Electronic Industry Press, 2008.
[3] Yang Xiuzhang, Yu Xiaomin, Fan Yufeng, Li Na. Investigación sobre tecnología de nitidez de imágenes y extracción de bordes basada en trajes de Miao [J] Modern Computer, 2018-10.
[4] Eastmount [Procesamiento de imágenes en Python] 4. Filtrado medio, filtrado de caja, filtrado gaussiano y filtrado de mediana para suavizado de imágenes [EB/OL] (2018-09-02). https://blog.csdn.net/ Eastmount/article/details/82216380.
[5] Eastmount [Procesamiento de imágenes digitales] 7. Explicación detallada del suavizado normal de la imagen, suavizado gaussiano, nitidez laplaciana, de Sobel y Prewitt de la mejora de imagen MFC [EB/OL]. (2015-06-08). https:/ /blog.csdn.net/eastmount/article/details/46378783 . _
[6] DSQiu. Nitidez de imagen (mejora) y detección de bordes [EB/OL] (20 de agosto de 2012). https://dsqiu.iteye.com/blog/1638589.https://blog.csdn.net /poem_qianmo/article/details/23184547.
[7] C. Tomasi, R Manduchi. Filtrado bilateral para imágenes en gris y en color[C]. Actas de la Conferencia Internacional IEEE sobre Visión por Computadora, Bombay, India. 1998:839-846.

Haga clic para seguir y conocer las nuevas tecnologías de Huawei Cloud lo antes posible ~

Python de 0 a 1 | Explicación detallada de los operadores de Sobel y Laplaciano para la nitidez de imágenes

1.Operador Sobel

2. Operador laplaciano

3. Resumen

referencias:

Supongo que te gusta