Este artigo foi compartilhado pela comunidade Huawei Cloud " [Python de zero a um] cinquenta e oito. Aprimoramento e computação de imagens: nitidez de imagens com operadores Sobel e Laplaciano para realizar a detecção de bordas ", autor: eastmount.

1. Operador Sobel

O operador Sobel é um operador diferencial discreto para detecção de bordas que combina suavização gaussiana e derivação diferencial. Este operador é utilizado para calcular o valor aproximado do brilho da imagem.De acordo com o brilho próximo à borda da imagem, pontos específicos que excedem um determinado número na área são registrados como bordas. O operador Sobel adiciona o conceito de peso com base no operador Prewitt. Ele acredita que a distância entre pontos adjacentes tem efeitos diferentes no pixel atual. Quanto mais próxima a distância do pixel, maior será o impacto no pixel atual, assim realizando a imagem Aumente a nitidez e destaque os contornos das bordas [1-4].

O posicionamento das bordas do operador Sobel é mais preciso e é frequentemente usado em imagens com muito ruído e gradientes de escala de cinza. Seu modelo de algoritmo é mostrado na fórmula (1), onde dx representa a direção horizontal e dy representa a direção vertical [3].

A fórmula de cálculo de pixels é a seguinte:

A fórmula de cálculo final do pixel do operador Sobel é a seguinte:

O operador Sobel detecta bordas com base na diferença ponderada no nível de cinza entre os pontos adjacentes superior e inferior e esquerdo e direito de um pixel, atingindo um valor extremo na borda. Ele tem um efeito de suavização no ruído e fornece informações mais precisas sobre a direção das bordas. Como o operador Sobel combina suavização gaussiana e derivação diferencial (diferenciação), o resultado será mais resistente ao ruído.Quando os requisitos de precisão não são muito altos, o operador Sobel é um método de detecção de borda mais comumente usado.

Python e OpenCV encapsulam o operador Sobel na função Sobel(), e seu protótipo de função é o seguinte:

dst = Sobel(src, dprofundidade, dx, dy[, dst[, ksize[, escala[, delta[, borderType]]]]])
– src representa a imagem de entrada

– dst representa o mapa de arestas de saída, que tem o mesmo tamanho e número de canais que a imagem de entrada

– dprofundidade representa a profundidade necessária da imagem alvo. Para diferentes imagens de entrada, a imagem alvo de saída tem profundidades diferentes.

– dx representa a ordem diferencial na direção x, assumindo o valor 1 ou 0

– dy representa a ordem da diferença na direção y, assumindo o valor 1 ou 0

– ksize representa o tamanho do operador Sobel e seu valor deve ser um número positivo e um número ímpar.

– escala representa a constante de escala da derivada de escala, não há fator de escala por padrão

– delta representa um valor delta opcional a ser adicionado ao resultado antes de armazená-lo na imagem de destino

– borderType representa o modo de borda. Para mais detalhes, consulte BorderTypes

Observe que após o processamento do operador Sobel, também é necessário chamar a função convertScaleAbs() para calcular o valor absoluto e converter a imagem em uma imagem de 8 bits para exibição. O protótipo do algoritmo é o seguinte:

dst = convertScaleAbs(src[, dst[, alfa[, beta]]])
– src representa o array original

– dst representa o array de saída, com profundidade de 8 bits

– alfa representa o fator de escala

– beta representa o valor adicionado após dimensionar os elementos originais do array

O código de implementação do operador Sobel é o seguinte.

# -*- codificação: utf-8 -*- 

# Por:Eastmount 

import cv2 

import numpy as np 

import matplotlib.pyplot as plt 



#Read image 

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

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

#Imagem processada em escala de cinza 

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



#Operador Sobel 

x = cv2.Sobel(grayImage, cv2.CV_16S, 1, 0) #Encontre a primeira ordem para x Derive 

y = cv2.Sobel(grayImage, cv2.CV_16S, 0, 1) #Encontre a primeira derivada de y 

absX = cv2.convertScaleAbs(x) 

absY = cv2.convertScaleAbs(y) 

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

#Usado para exibir rótulos chineses normalmente 

plt.rcParams['font.sans-serif']=['SimHei'] #Exibir 
títulos 

gráficos = ['imagem original', 'operador Sobel'] 
imagens = [lenna_img,Sobel]



para i no intervalo (2): 

plt.subplot(1,2,i+1), plt.imshow(imagens[i], 'cinza') 

plt.title(títulos[i]) 

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

plt.show()

Os resultados da execução são mostrados na Figura 1:

2. Operador Laplaciano

O operador Laplaciano é um operador diferencial de segunda ordem no espaço euclidiano n-dimensional e é frequentemente usado no campo de aprimoramento de imagens e extração de bordas. Ele calcula pixels na vizinhança através da diferença da escala de cinza. O processo básico é:

Determine o valor de cinza do pixel central da imagem e o valor de cinza dos demais pixels ao seu redor;
Se o nível de cinza do pixel central for maior, aumente o nível de cinza do pixel central;
Pelo contrário, a escala de cinzentos do pixel central é reduzida para conseguir uma operação de nitidez da imagem.

No processo de implementação do algoritmo, o operador Laplaciano calcula o gradiente nas quatro ou oito direções do pixel central na vizinhança e, em seguida, adiciona os gradientes para determinar a relação entre a escala de cinza do pixel central e a escala de cinza de outros pixels em a vizinhança.Finalmente, através da operação de gradiente Como resultado, a escala de cinza do pixel é ajustada [2].

Uma função binária contínua f(x,y), sua operação Laplaciana é definida como:

O operador Laplaciano é dividido em quatro vizinhanças e oito vizinhanças. Quatro vizinhanças é encontrar o gradiente em quatro direções do pixel central da vizinhança, e oito vizinhanças é encontrar o gradiente em oito direções. Entre eles, o modelo de quatro vizinhos é mostrado na fórmula (5):

A fórmula de cálculo de seus pixels pode ser simplificada como:

Pode-se descobrir através do modelo que quando a escala de cinza dos pixels na vizinhança é a mesma, o resultado da operação de convolução do modelo é 0; quando a escala de cinza do pixel central é maior que a escala de cinza média dos outros pixels na vizinhança, o O resultado da operação de convolução do modelo é um número positivo; quando a escala de cinza do pixel central é inferior à escala de cinza média de outros pixels na vizinhança, a convolução do modelo é negativa. Ao processar o resultado da operação de convolução com um fator de atenuação apropriado e adicioná-lo ao pixel central original, a imagem pode ser aprimorada.

O modelo de oito vizinhanças do operador Laplaciano é o seguinte:

A fórmula de cálculo de seus pixels pode ser simplificada como:

Python e OpenCV encapsulam o operador Laplacian na função Laplacian(), e seu protótipo de função é o seguinte:

dst = Laplaciano(src, dprofundidade[, dst[, ksize[, escala[, delta[, borderType]]]]])
– src representa a imagem de entrada

– dst representa o mapa de arestas de saída, que tem o mesmo tamanho e número de canais que a imagem de entrada

– dprofundidade representa a profundidade necessária da imagem alvo

– ksize representa o tamanho da abertura do filtro usado para calcular a segunda derivada. Seu valor deve ser um número positivo e um número ímpar, e o valor padrão é 1. Para mais detalhes, consulte getDerivKernels

– escala representa um fator de escala opcional para calcular o valor do operador Laplaciano. O valor padrão é 1, consulte getDerivKernels para mais detalhes

– delta representa um valor incremental opcional adicionado ao resultado antes de armazená-lo na imagem de destino. O valor padrão é 0

– borderType representa o modo de borda. Para mais detalhes, consulte BorderTypes

Observe que o operador Laplaciano, na verdade, usa principalmente a operação do operador Sobel. Ao adicionar as derivadas na direção xey da imagem calculada pelo operador Sobel, o resultado de nitidez da imagem de entrada é obtido.

Ao mesmo tempo, após realizar o processamento do operador Laplaciano, você também precisa chamar a função convertScaleAbs() para calcular o valor absoluto e converter a imagem em uma imagem de 8 bits para exibição. O protótipo do algoritmo é o seguinte:

dst = convertScaleAbs(src[, dst[, alfa[, beta]]])
– src representa o array original

– dst representa o array de saída, com profundidade de 8 bits

– alfa representa o fator de escala

– beta representa o valor adicionado após dimensionar os elementos originais do array

Quando ksize=1, a função Laplacian() usa uma abertura 3×3 (modelo de quatro vizinhos) para processamento de transformação. O código a seguir usa o operador Laplaciano de ksize=3 para aumentar a nitidez da imagem. O código é o seguinte:

# -*- codificação: utf-8 -*- 

# Por:Eastmount 

import cv2 

import numpy as np 

import matplotlib.pyplot as plt 



#Read image 

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

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

#Imagem de processamento em escala de cinza 

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



#Algoritmo Laplaciano 

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

Laplaciano = cv2.convertScaleAbs(dst) 

#Usado para exibir rótulos chineses normalmente 

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

#Display graphics 

title = ['original image', 'Laplacian operator'] 

images = [lenna_img , Laplacian] 

for i in range (2): 

plt.subplot(1,2,i+1), plt.imshow(imagens[i], 'cinza') 

plt.title(títulos[i])

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

plt.show()

Os resultados da execução são mostrados na Figura 2:

O algoritmo de detecção de borda é baseado principalmente nas derivadas de primeira e segunda ordem da intensidade da imagem, mas as derivadas são geralmente muito sensíveis ao ruído, portanto, é necessário um filtro para filtrar o ruído, e o algoritmo de aprimoramento de imagem ou limite é chamado para processamento, e finalmente a detecção de bordas é realizada. A seguir está o processo de detecção de bordas após o uso de filtragem gaussiana para redução de ruído e limite, e compara quatro algoritmos comuns de extração de bordas.

# -*- codificação: utf-8 -*- 

# Por:Eastmount 

import cv2 

import numpy as np 

import matplotlib.pyplot as plt 

#Read image 

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

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

#Imagem de processamento em escala de cinza 

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

#Filtro gaussiano 

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

#Threshold processamento 

ret, binário = cv2.threshold (gaussianBlur, 127, 255, cv2.THRESH_BINARY) 

#Roberts operador 

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

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

x = cv2.filter2D(binário, cv2.CV_16S, kernelx) 

y = cv2.filter2D(binário, 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(binário, cv2.CV_16S, kernelx) 

y = cv2.filter2D(binário, 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(binário, cv2.CV_16S, 1, 0) 

y = cv2.Sobel( binário, 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 = ['Imagem de origem', 'Imagem binária', 'Imagem de Roberts' , 

'Imagem Prewitt','Imagem Sobel', 'Imagem Laplacian'] 

imagens = [lenna_img, binário, Roberts, Prewitt, Sobel, Laplacian] 

para i em np.arange(6): 

plt.subplot(2,3,i +1),plt.imshow(imagens[i],'cinza') 

plt.title(títulos[i]) 

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

plt.show()

Os resultados de saída são mostrados na Figura 3. Entre eles, o operador Laplaciano é relativamente sensível ao ruído. Como seu algoritmo pode causar limites de pixel duplo, é frequentemente usado para determinar se os pixels das bordas estão localizados nas áreas claras ou escuras da imagem e raramente é usado para detecção de bordas. ; o operador Robert é adequado para imagens íngremes e com baixo ruído. O efeito é melhor, especialmente para imagens com mais bordas de mais e menos 45 graus, mas a precisão do posicionamento é baixa; o operador Prewitt tem um efeito melhor na extração de bordas de imagens com gradientes de cinza, sem considerar a distância entre pontos adjacentes para o pixel atual. A influência dos pontos; o operador Sobel leva em consideração fatores abrangentes e tem melhores efeitos de processamento em imagens com mais ruído.

3. Resumo

Este artigo apresenta principalmente o conhecimento de nitidez de imagem e detecção de bordas, explica detalhadamente o operador Sobel e o operador Laplaciano e extrai contornos de bordas por meio de pequenas imagens Luoluo. A tecnologia de nitidez de imagem e extração de bordas pode eliminar o ruído nas imagens, extrair algumas variáveis usadas para caracterizar imagens nas informações da imagem e fornecer uma base para o reconhecimento de imagens.

referências:

[1] Escrito por Gonzalez, traduzido por Ruan Qiuqi. Digital Image Processing (3ª edição) [M]. Pequim: Electronic Industry Press, 2013.
[2] Ruan Qiuqi. Processamento digital de imagens (3ª edição) [M]. Pequim: Electronic Industry Press, 2008.
[3] Yang Xiuzhang, Yu Xiaomin, Fan Yufeng, Li Na. Pesquisa sobre tecnologia de nitidez de imagem e extração de bordas baseada em trajes Miao [J]. Modern Computer, 2018-10.
[4] Eastmount. [Processamento de imagem Python] 4. Filtragem média, filtragem de caixa, filtragem gaussiana e filtragem mediana para suavização de imagem [EB/OL]. (2018-09-02). https://blog.csdn . net / Eastmount/artigo/detalhes/82216380.
[5] Eastmount. [Processamento de imagem digital] 7. Explicação detalhada da suavização normal da imagem, suavização gaussiana, nitidez Laplaciana, Sobel e Prewitt do aprimoramento de imagem MFC [EB/OL]. (2015-06-08). https:/ / blog .csdn.net/eastmount/article/ details/46378783.
[6] DSQiu. Nitidez de imagem (aprimoramento) e detecção de bordas [EB/OL]. (2012-08-20). https://dsqiu.iteye.com/blog/1638589.https://blog.csdn. net /poem_qianmo/article/details/23184547.
[7] C. Tomasi, R Manduchi. Filtragem bilateral para imagens em cinza e coloridas[C]. Anais da Conferência Internacional IEEE sobre Visão Computacional, Bombaim, Índia. 1998:839-846.

Clique para seguir e conhecer as novas tecnologias da Huawei Cloud o mais rápido possível~

Python de 0 a 1 | Explicação detalhada dos operadores Sobel e Laplaciano para nitidez de imagem

1. Operador Sobel

2. Operador Laplaciano

3. Resumo

referências:

Acho que você gosta