Big Data

Processamento de imagem OpenCV | Processamento de imagem com OpenCV

Introdução

Ola leitores!

OpenCV – Visão de computador de código aberto. É uma das ferramentas mais utilizadas para o processamento de imagens e tarefas de visão artificial. Usado em várias aplicações, como detecção de rosto, captura de vídeo, rastreando objetos em movimento, revelação de objetos, hoje em dia em aplicações Covid, como detecção de máscara, distanciamento social e muito mais. Se você quiser saber mais sobre o OpenCV, verifique isso Ligação.

📌Se você quiser saber mais sobre as bibliotecas Python para processamento de imagens, verifique este link.

📌Se você quiser aprender como processar imagens usando o NumPy, 😋verifique este link.

📌Para mais artigos😉, Clique aqui

Neste blog, Vou cobrir o OpenCV em grandes detalhes, cobrindo algumas das tarefas mais importantes no processamento de imagens por meio da implementação prática. Então vamos começar !! ⌛

Imagem Fonte

Tabela de conteúdo

Detecção de bordas e gradientes de imagem
Dilatação, abertura, fechamento e erosão
Transformação de perspectiva
Pirâmides de imagens
Aparar
Escalado, interpolações e redimensionamento
Limiar, limiares adaptativos e binarização
Afiado
Borrão
Contornos
Detecção de linha usando linhas duras
Encontre cantos
Contando círculos e elipses

Imagem Fonte

Detecção de bordas e gradientes de imagem

É uma das técnicas mais fundamentais e importantes no processamento de imagens.. Confira o código abaixo para uma implementação completa. Para maiores informações, consulte este Ligação.

image = cv2.imread('frutas.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
Hgt, Wdt,_ = imagem.forma
# Sobel Edges
x_sobel = cv2.Sobel(imagem, cv2. CV_64F, 0, 1, ksize=5)
y_sobel = cv2. Sobel(imagem, cv2. CV_64F, 1, 0, ksize=5)
plt.figure(figsize =(20, 20))
plt.subplot(3, 2, 1)
plt.title("Original")
plt.imshow(imagem)
plt.subplot(3, 2, 2)
plt.title("Sobel X")
plt.imshow(x_sobel)
plt.subplot(3, 2, 3)
plt.title("Sobel Y")
plt.imshow(y_sobel)
sobel_or = cv2.bitwise_or(x_sobel, y_sobel)
plt.subplot(3, 2, 4)
plt.imshow(sobel_or)
laplacian = cv2. Laplaciano(imagem, cv2. CV_64F)
plt.subplot(3, 2, 5)
plt.title("Laplaciano")
plt.imshow(laplaciano)
## Há dois valores: limiar1 e limiar2.
## Aqueles gradientes que são maiores que o limiar2 => considerado como uma borda
## Os gradientes que estão abaixo do limiar1 => considerado não ser uma borda.
## Esses gradientes Valores que estão entre limiar1 e limiar2 => classificados como bordas ou não-bordas
# The first threshold gradient
canny = cv2.Canny(imagem, 50, 120)
plt.subplot(3, 2, 6)
plt.imshow(astuto)

Dilatação, abertura, fechamento e erosão

Estas são duas operações fundamentais de processamento de imagem. Eles são usados para eliminar o ruído, encontre um buraco de intensidade ou uma saliência em uma imagem e muito mais. Veja o código a seguir para uma implementação prática. Para maiores informações, consulte este Ligação.

image = cv2.imread('LinuxLogo.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(3, 2, 1)
plt.title("Original")
plt.imshow(imagem)

kernel = np.ones((5,5), por exemplo, uint8)

erosão = cv2.erode(imagem, núcleo, iterações = 1)
plt.subplot(3, 2, 2)
plt.title("Erosão")
plt.imshow(erosão)
dilatação = cv2.dilate(imagem, núcleo, iterações = 1)
plt.subplot(3, 2, 3)
plt.title("Dilatação")
plt.imshow(dilatação)

abertura = cv2.morphologyEx(imagem, cv2.MORPH_OPEN, núcleo)
plt.subplot(3, 2, 4)
plt.title("Abertura")
plt.imshow(abertura)

fechamento = cv2.morphologyEx(imagem, cv2.MORPH_CLOSE, núcleo)
plt.subplot(3, 2, 5)
plt.title("Fechando")
plt.imshow(fechando)

Transformação de perspectiva

Para obter melhores informações sobre uma imagem, podemos mudar a perspectiva de um vídeo ou de uma imagem. Nesta transformação, precisamos fornecer os pontos em uma imagem de onde queremos obter informações, mudando a perspectiva. En OpenCV, usamos duas funções para transformação de perspectiva getPerspectiveTransform () e logo warpPerspective (). Confira o código abaixo para uma implementação completa. Para maiores informações, consulte este Ligação.

image = cv2.imread('scan.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(1, 2, 1)
plt.title("Original")
plt.imshow(imagem)
points_A = np.float32([[320,15], [700,215], [85,610], [530,780]])
points_B = np.float32([[0,0], [420,0], [0,594], [420,594]])
M = cv2.getPerspectiveTransform(points_A, pontos_B)
warped = cv2.warpPerspective(imagem, M, (420,594))
plt.subplot(1, 2, 2)
plt.title("warpPerspective")
plt.imshow(empenado)

Pirâmides de imagens

É uma técnica muito útil quando precisamos escalar na detecção de objetos. OpenCV usa dois tipos comuns de pirâmides de imagens Gaussiano y Laplaciano pirâmide. Use o viver () e pyrDown () função em OpenCV para reduzir ou ampliar uma imagem. Veja o código a seguir para uma implementação prática. Para maiores informações, consulte este Ligação.

image = cv2.imread('butterfly.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(2, 2, 1)
plt.title("Original")
plt.imshow(imagem)
menor = cv2.pyrDown(imagem)
maior = cv2.pyrUp(menor)
plt.subplot(2, 2, 2)
plt.title("Menor")
plt.imshow(menor)
plt.subplot(2, 2, 3)
plt.title("Maior")
plt.imshow(maior)

Aparar

É uma das técnicas mais importantes e fundamentais no processamento de imagens, recorte é usado para obter uma parte específica de uma imagem. Para cortar uma imagem. Você só precisa das coordenadas de uma imagem de acordo com sua área de interesse. Para uma análise completa, veja o seguinte código em OpenCV.

image = cv2.imread('messi.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(
Aigsize =(20, 20))
plt.subplot(2, 2, 1)
plt.title("Original")
plt.imshow(imagem)
Hgt, wdt = image.shape[:2]
start_row, start_col = int(Hgt * .25), int(Wdt * .25)
end_row, end_col = int(altura * .75), int(largura * .75)
recortado = imagem[start_row:end_row , start_col:end_col]
plt.subplot(2, 2, 2)
plt.imshow(recortado)

Escalado, interpolações e redimensionamento

Redimensionamento é uma das tarefas mais simples do OpenCV. Fornece uma redimensionar () função que leva parâmetros como imagem, imagem do tamanho de saída, interpolação, escala xe escala y. Confira o código abaixo para uma implementação completa.

image = cv2.imread('/kaggle/input/opencv-samples-images/data/fruits.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(2, 2, 1)
plt.title("Original")
plt.imshow(imagem)
image_scaled = cv2.resize(imagem, Nenhum, fx=0,75, fy=0,75)
plt.subplot(2, 2, 2)
plt.title("Escala - Interpolação Linear")
plt.imshow(image_scaled)
img_scaled = cv2.resize(imagem, Nenhum, fx=2, fy=2, interpolação = cv2. INTER_CUBIC)
plt.subplot(2, 2, 3)
plt.title("Escala - Interpolação Cúbica")
plt.imshow(img_scaled)
img_scaled = cv2.resize(imagem, (900, 400), interpolação = cv2.INTER_AREA)
plt.subplot(2, 2, 4)
plt.title("Escala - Tamanho distorcido")
plt.imshow(img_scaled)

Limiar, limiares adaptativos e binarização

Confira o código abaixo para uma implementação completa. Para maiores informações, consulte este Ligação.

# Load our new image
image = cv2.imread('Origin_of_Species.jpg', 0)
plt.figure(figsize =(30, 30))
plt.subplot(3, 2, 1)
plt.title("Original")
plt.imshow(imagem)
direito,thresh1 = cv2.threshold(imagem, 127, 255, cv2. THRESH_BINARY)
plt.subplot(3, 2, 2)
plt.title("Binário limiar")
plt.imshow(thresh1)
imagem = cv2. GaussianBlur(imagem, (3, 3), 0)
thresh = cv2.adaptiveThreshold(imagem, 255, cv2. ADAPTIVE_THRESH_MEAN_C, cv2. THRESH_BINARY, 3, 5) 
plt.subplot(3, 2, 3)
plt.title("Limiar médio adaptativo")
plt.imshow(debulhar)
_, th2 = cv2.threshold(imagem, 0, 255, cv2. THRESH_BINARY + cv2. THRESH_OTSU)
plt.subplot(3, 2, 4)
plt.title("Limiar de Otsu")
plt.imshow(th2)
plt.subplot(3, 2, 5)
borrão = cv2. GaussianBlur(imagem, (5,5), 0)
_, th3 = cv2.threshold(borrão, 0, 255, cv2. THRESH_BINARY + cv2. THRESH_OTSU)
plt.title("Limiar de Guassian Otsu")
plt.imshow(th3)
plt.show()

Afiado

Verifique o código a seguir para focar uma imagem usando OpenCV. Para maiores informações, consulte este Ligação

image = cv2.imread('building.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(1, 2, 1)
plt.title("Original")
plt.imshow(imagem)
kernel_sharpening = np.array([[-1,-1,-1], 
                              [-1,9,-1], 
                              [-1,-1,-1]])
sharpened = cv2.filter2D(imagem, -1, kernel_sharpening)
plt.subplot(1, 2, 2)
plt.title("Nitidez da imagem")
plt.imshow(afiado)
plt.show()

Borrão

Verifique o código a seguir para desfocar uma imagem usando OpenCV. Para maiores informações, consulte este Ligação

image = cv2.imread('home.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(2, 2, 1)
plt.title("Original")
plt.imshow(imagem)
kernel_3x3 = np.ones((3, 3), por exemplo, float32) / 9
turva = cv2.filter2D(imagem, -1, kernel_3x3)
plt.subplot(2, 2, 2)
plt.title("3x3 Kernel Blurring")
plt.imshow(borrado)
kernel_7x7 = np.ones((7, 7), por exemplo, float32) / 49
borrado2 = cv2.filter2D(imagem, -1, kernel_7x7)
plt.subplot(2, 2, 3)
plt.title("7x7 Kernel Blurring")
plt.imshow(turva 2)

Contornos

Contornos de imagens: es una forma de identificar los contornos estructurales de un objeto en una imagen. é útil identificar a forma de um objeto. OpenCV fornece um encontrarContours função em que você precisa passar bordas astuta como um parâmetro. Confira o código abaixo para uma implementação completa. Para maiores informações, consulte este Ligação.

# Carregar os dados
image = cv2.imread('pic.png')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
plt.subplot(2, 2, 1)
plt.title("Original")
plt.imshow(imagem)
# Grayscale
gray = cv2.cvtColor(imagem,cv2.COLOR_BGR2GRAY)
# Canny edges
edged = cv2.Canny(cinza, 30, 200)
plt.subplot(2, 2, 2)
plt.title("Bordas canny")
plt.imshow(Afiada)
# Finding Contours
contour, hier = cv2.findContours(Afiada, cv2. RETR_EXTERNAL, cv2. CHAIN_APPROX_NONE)
plt.subplot(2, 2, 3)
plt.imshow(Afiada)
imprimir("Contagem de Contornos = " + str(len(contorno)))
# All contours
cv2.drawContours(imagem, contornos, -1, (0,255,0), 3)
plt.subplot(2, 2, 4)
plt.title("Contornos")
plt.imshow(imagem)

Detecção de linha usando linhas duras

Linhas podem ser detectadas em uma imagem usando linhas Hough. OpenCV fornece um Função HouhLines em que você deve passar o valor limiar. O limite é o voto mínimo para uma linha a ser considerada. Para uma descrição detalhada, ver o código a seguir para uma implantação completa. Para detecção de linha usando linhas Hough em OpenCV. Para maiores informações, consulte este Ligação.

# Load the image
image = cv2.imread('sudoku.png')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
# Grayscale 
gray = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
# Canny Edges
edges = cv2.Canny(cinza, 100, 170, aberturaSize = 3)
plt.subplot(2, 2, 1)
plt.title("Bordas")
plt.imshow(Bordas)
# Run HoughLines Fucntion 
lines = cv2.HoughLines(Bordas, 1, np.pi/180, 200)
# Run for loop through each line
for line in lines:
    rô, theta = linha[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    x_1 = int(x0 + 1000 * (-b))
    y_1 = int(y0 + 1000 * (uma))
    x_2 = int(x0 - 1000 * (-b))
    y_2 = int(y0 - 1000 * (uma))
    cv2.line(imagem, (x_1, y_1), (x_2, y_2), (255, 0, 0), 2)
# Show Final output
plt.subplot(2, 2, 2)
plt.imshow(imagem)

Encontre cantos

Para encontrar os cantos de uma imagem, use el função cornerHarris do OpenCV. Para uma visão geral detalhada, veja o código abaixo para uma implementação completa para encontrar cantos usando OpenCV. Para maiores informações, consulte este Ligação.

# Load image 
image = cv2.imread('tabuleiro de xadrez.png')
# Grayscaling
image = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(10, 10))
cinza = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
# CornerHarris function  want input to be float
gray = np.float32(cinza)
h_corners = cv2.cornerHarris(cinza, 3, 3, 0.05)
kernel = np.ones((7,7),por exemplo, uint8)
h_corners = cv2.dilate(harris_corners, núcleo, iterações = 10)
imagem[h_corners > 0.024 * h_corners.max() ] = [256, 128, 128]
plt.subplot(1, 1, 1)
# Final Output
plt.imshow(imagem)

Contando círculos e elipses

Para contar círculos y elipse en una imagen, use el Función SimpleBlobDetector do OpenCV. Para uma visão geral detalhada, consulte el código a continuación para ver la implementación completa To Count Circles and Ellipse en una imagen usando OpenCV. Para maiores informações, consulte este Ligação.

# Load image
image = cv2.imread('bolhas.jpg')
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
plt.figure(figsize =(20, 20))
detector = cv2. SimpleBlobDetector_create()
# Detect blobs
points = detector.detect(imagem)

em branco = np.zeros((1,1)) 
blobs = cv2.drawKeypoints(imagem, Pontos, em branco, (0,0,255),
                                      cv2. DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
number_of_blobs = len(pontos-chave)
text = "Bolhas totais: " + str(len(pontos-chave))
cv2.putText(Blobs, texto, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100, 0, 255), 2)

plt.subplot(2, 2, 1)

plt.imshow(Blobs)
# Parâmetros de filtragem
# Initialize parameter settiing using cv2.SimpleBlobDetector
params = cv2.SimpleBlobDetector_Params()
# Area filtering parameters
params.filterByArea = True
params.minArea = 100
# Circularity filtering parameters
params.filterByCircularity = True 
params.minCircularity = 0.9
# Convexity filtering parameters
params.filterByConvexity = False
params.minConvexity = 0.2
#  inertia filtering parameters
params.filterByInertia = True
params.minInertiaRatio = 0.01
# detector with the parameters
detector = cv2.SimpleBlobDetector_create(params)
# Detect blobs
keypoints = detector.detect(imagem)
# Draw blobs on our image as red circles
blank = np.zeros((1,1)) 
blobs = cv2.drawKeypoints(imagem, pontos-chave, em branco, (0,255,0),
                                      cv2. DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
number_of_blobs = len(pontos-chave)
text = "Não.  Bolhas circulares: " + str(len(pontos-chave))
cv2.putText(Blobs, texto, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 100, 255), 2)
# Show blobs
plt.subplot(2, 2, 2)
plt.title("Filtrando somente bolhas circulares")
plt.imshow(Blobs)

Notas finais

Então, neste artigo, tivemos uma discussão detalhada sobre Processamento de imagens usando OpenCV. Espero que você aprenda algo com este blog e o ajude no futuro. Obrigado pela leitura e sua paciência. Boa sorte!

Você pode verificar meus artigos aqui: Artigos

Identificação de e-mail: [e-mail protegido]

Conecte-se comigo no LinkedIn: LinkedIn

A mídia mostrada neste artigo de processamento de imagem OpenCV não é propriedade da DataPeaker e é usada a critério do autor.