Nota: Neste post, trabalharemos apenas com imagens em escala de cinza para facilitar o acompanhamento.

O que é uma imagem?

Uma imagem pode ser pensada como uma matriz de valores, onde cada valor representa a intensidade de um pixel. Existem três tipos principais de formatos de imagem:

• Binário: Uma imagem neste formato é representada por uma única matriz 2-D com valores de 0 (preto) e 1 (branco). É a forma mais simples de representação de imagem.

• Escala de cinza: Neste formato, uma imagem é representada por uma única matriz 2-D com valores variando de 0 a 255; onde 0 representa preto e 255 representa branco. Os valores intermediários representam vários tons de cinza.

• Escala RGB: Aqui, uma imagem é representada por três matrizes 2-D (uma para cada canal de cor: Vermelho, Verde e Azul), com valores variando de 0 a 255. Cada matriz contém valores de pixel para um componente de cor, e a combinação desses três canais nos dá a imagem colorida.

Filtros

Filtros são ferramentas usadas para modificar imagens aplicando determinadas operações. Um filtro é uma matriz (também chamada de kernel) que se move pela imagem, realizando cálculos nos valores de pixel dentro de sua janela. Abordaremos dois tipos comuns de filtros: Filtros de Média e Filtros de Mediana.

Filtros Médios

Um filtro médio é usado para reduzir o ruído calculando a média dos valores de pixel dentro de uma janela. Ele substitui o pixel central da janela pela média de todos os valores de pixel dessa janela. A função cv2.blur() aplica um filtro médio com um tamanho de kernel de 3x3, o que significa que considera uma janela 3x3 de pixels ao redor de cada pixel para calcular a média. Isso ajuda a suavizar a imagem.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Applies a Mean Filter of size 3 x 3
blurred_image = cv2.blur(image, (3, 3))

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(blurred_image, cmap='gray')
plt.title('Mean Filtered Image')
plt.axis("off")
plt.show()

Filtros medianos

Um filtro mediano é usado para reduzir o ruído, substituindo o valor de cada pixel pelo valor mediano de todos os pixels em uma janela. É particularmente eficaz na remoção de ruídos de sal e pimenta. A função cv2.medianBlur() aplica um filtro mediano com tamanho de kernel 3. Este método substitui cada pixel pelo valor mediano dos valores dos pixels em sua vizinhança, o que ajuda a preservar as bordas e ao mesmo tempo remover o ruído. Aqui, quanto maior o tamanho do kernel, mais desfocada fica a imagem.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Applies a Median Filter with a kernel size of 3
blurred_image = cv2.medianBlur(image, 3)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(blurred_image, cmap='gray')
plt.title('Median Filtered Image')
plt.axis("off")
plt.show()

Filtros personalizados

Você pode criar filtros personalizados para aplicar operações específicas em suas imagens. A função cv2.filter2D() permite aplicar qualquer kernel personalizado a uma imagem. A função cv2.filter2D() aplica um kernel personalizado (filtro) à imagem. O kernel é uma matriz que define a operação a ser realizada nos valores dos pixels. Neste exemplo, o kernel aprimora certos recursos da imagem com base nos valores especificados.

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Define a custom filter kernel
kernel = np.array([[2, -1, 5],
                   [-5, 5, -1],
                   [0, -1, 0]])

filtered_image = cv2.filter2D(image, -1, kernel)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(filtered_image, cmap='gray')
plt.title('Filtered Image')
plt.axis('off')

plt.show()

Limiar

Nota: nos trechos de código, você verá _ , imagem ao atribuir a imagem com limite. Isso ocorre porque a função cv2.threshold retorna dois valores: o valor limite usado e a imagem limite. Como precisamos apenas da imagem com limite, usamos _ para ignorar o valor do limite.

O limite converte uma imagem em uma imagem binária definindo valores de pixel com base em uma condição. Existem vários tipos de técnicas de limiar:

Limiar Global

Limite Simples

Este método define um valor limite fixo para a imagem inteira. Pixels com valores acima do limite são definidos para o valor máximo (255) e aqueles abaixo são definidos para 0. A função cv2.threshold() é usada para limite simples. Pixels com intensidade maior que 127 são definidos como brancos (255), e aqueles com intensidade menor ou igual a 127 são definidos como preto (0), produzindo uma imagem binária.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

_, thresholded_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(thresholded_image, cmap='gray')
plt.title('Thresholded Image')
plt.axis("off")
plt.show()

Limite de Otsu

O método de Otsu determina o valor limite ideal automaticamente com base no histograma da imagem. Este método minimiza a variância intraclasse e maximiza a variância entre classes. Ao definir o valor limite como 0 e usar cv2.THRESH_OTSU, a função calcula automaticamente o melhor valor limite para separar o primeiro plano do fundo.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

_, otsu_thresholded_image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY   cv2.THRESH_OTSU)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(otsu_thresholded_image, cmap='gray')
plt.title("Otsu's Thresholded Image")
plt.axis("off")
plt.show()

Limiar adaptativo

Limiar adaptativo médio

No Limite Adaptativo Médio, o valor limite para cada pixel é calculado com base na média dos valores de pixel em uma vizinhança local em torno desse pixel. Este método ajusta o limite dinamicamente em diferentes regiões da imagem. A função cv2.adaptiveThreshold() calcula o limite para cada pixel com base no valor médio dos valores dos pixels em uma vizinhança local 11x11. Um valor constante de 2 é subtraído desta média para ajustar o limite. Este método é eficaz para imagens com condições de iluminação variadas.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

mean_adaptive_thresholded_image = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(mean_adaptive_thresholded_image, cmap='gray')
plt.title('Mean Adaptive Thresholded Image')
plt.axis("off")
plt.show()

Limiar adaptativo gaussiano

Limite adaptativo gaussiano calcula o valor limite para cada pixel com base em uma soma ponderada gaussiana dos valores de pixel em uma vizinhança local. Este método geralmente fornece melhores resultados em casos com iluminação não uniforme. No Limite Adaptativo Gaussiano, o limite é determinado por uma soma ponderada de valores de pixel em uma vizinhança 11x11. O valor constante 2 é subtraído desta média ponderada para ajustar o limite. Este método é útil para lidar com imagens com iluminação e sombras variadas.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

gaussian_adaptive_thresholded_image = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(gaussian_adaptive_thresholded_image, cmap='gray')
plt.title('Gaussian Adaptive Thresholded Image')
plt.axis("off")
plt.show()

Referências

• Encord.com
• Pyimagesearch.com
• Limite OpenCV
• Filtragem OpenCV