A essência da filtragem de imagens digitais

 

1. Descrição

        Na era digital, as imagens são parte integrante da nossa comunicação e expressão. Das mídias sociais às imagens médicas, a qualidade e o conteúdo das imagens são importantes. É aqui que entram os campos de filtragem e convolução de imagens, dando-nos um kit de ferramentas para transformar e refinar essas narrativas visuais.

        A filtragem de imagens não se trata apenas de melhorar a aparência de uma foto; trata-se de fazer com que a imagem conte sua história. Seja reduzindo o ruído em exames médicos, aprimorando os detalhes intrincados de artefatos arqueológicos ou detectando bordas em carros autônomos, os filtros de imagem desempenham um papel fundamental. Eles moldam a narrativa enfatizando certas características enquanto subjugam outras.

        A espinha dorsal deste processo é a operação de convolução, uma maravilha matemática que nos permite sobrepor imagens com filtros predefinidos para obter diferentes efeitos.

2. O conceito de convolução

        A convolução é uma operação matemática básica que desempenha um papel importante no processamento de imagens. É uma tecnologia fundamental para aplicar filtros a imagens, permitindo tarefas como desfoque, nitidez e detecção de bordas.

        O núcleo da convolução é combinar duas funções para produzir uma terceira função. No processamento de imagens, uma das funções é a imagem de entrada e a outra é uma matriz menor chamada kernel ou filtro. O kernel contém valores numéricos que definem o comportamento do filtro. O processo envolve deslizar um kernel sobre a imagem, multiplicar seu valor pelo valor do pixel correspondente na imagem e, em seguida, somar os resultados. Essa soma é então colocada em um local específico na imagem de saída.

2.1 Convolução unidimensional

        No contexto de convoluções 1D, nossa entrada consiste em matrizes 1D, frequentemente chamadas de vetores de características.

        No cenário de convolução mais básico, realizamos uma multiplicação entre esta matriz e valores numéricos (chamados de filtros ou pesos) para produzir uma matriz de saída chamada mapa de características.

        Neste caso, nosso array inicial tem dimensão 12x1 e o filtro tem dimensão 1x1, portanto, a saída gerada permanece com tamanho 12x1.

        Além disso, é mostrado abaixo um filtro de tamanho 2x1.

        Aqui multiplicamos o primeiro elemento da entrada pelo primeiro elemento do filtro, o segundo elemento da entrada pelo segundo elemento do filtro e então os somamos e escrevemos o resultado na matriz de saída no primeiro elemento.

Aqui, como podemos observar, não podemos mover mais o filtro, portanto a saída será menor, com tamanho 11x1.

2.2 Preenchimento

Preenchimento é a prática de adicionar pixels extras ao redor das bordas de uma imagem. O objetivo do preenchimento é afetar o tamanho da imagem de saída após aplicar uma operação de convolução usando um kernel ou filtro específico.

Abaixo, adicionamos zeros em ambas as extremidades da matriz de entrada, então terminamos com a saída do mesmo tamanho.

Até agora movemos os filtros um por um para a direita, mas não precisamos necessariamente continuar fazendo isso; por exemplo, poderíamos mover três.

2.3 Convolução unidimensional

Fonte

Agora temos uma imagem em tons de cinza de 8 bits com uma grade 5x5. Os valores variam entre 0 e 255.

E temos um kernel 3x3 aleatório:

Quando aplicamos o kernel à entrada:

（-1*170）+（0*245）+（1*0）+（2*234）+（1*42）+（2*64）+（1*32）+（-2*53）+ （0*128）=394

Substituímos o pixel central pelo valor calculado. Em seguida, movemos os grãos um por um (do canto superior esquerdo para o canto inferior direito) e fazemos as contas novamente.

Novamente usamos preenchimento para os pixels das bordas.

3. Filtrar

        A versatilidade do filtro de imagem é alcançada através de uma série de operações. Cada operação tem uma finalidade diferente, moldando a beleza da imagem ou facilitando análises mais profundas.

• filtro de suavização
• filtro de afiação
• filtro de aprimoramento de borda

3.1 Filtro de suavização

        Os filtros de suavização, também conhecidos como filtros de desfoque, têm a notável capacidade de melhorar a qualidade da imagem, reduzindo suavemente o ruído, suprimindo detalhes indesejados e criando uma experiência visual mais harmoniosa.

        Essencialmente, um filtro de suavização funciona calculando a média do valor do pixel de uma imagem com os pixels vizinhos. Este processo de média tem um efeito calmante na imagem, tornando-a mais coesa e uniforme. A imagem resultante mantém as suas características principais, mas elimina as pequenas flutuações e inconsistências que podem obscurecer a sua essência.

• caixa
• Gaussiano
• número mediano

3.2 Desfoque de quadro

        Este filtro realiza uma média simples dos valores dos pixels dentro de uma vizinhança definida. O tamanho da vizinhança é chamado de tamanho do kernel . Quanto maior o tamanho do kernel, mais desfocada será a imagem.

fonte

É um filtro de suavização simples e eficiente. É frequentemente usado como a primeira etapa em algoritmos de processamento de imagem, como detecção de bordas e redução de ruído.

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

path = "cath.jpeg"

# read image
image = cv2.imread(path)

# box blur filter
box_blur = cv2.boxFilter(image, -1, (25, 25))

# plot
plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(box_blur, cv2.COLOR_BGR2RGB))
plt.title('Box Blur')
plt.axis('off')

O quadro está desfocado. Imagem fornecida pelo autor.

O método que usamos resulta em um filtro de média simples.boxFiltercv2

cv.boxFilter（src， dprofundidade， ksize[， dst[， âncora[， normalize[， borderType]]]]） -> dst

• srcé a imagem de entrada.
• ddepthé a profundidade desejada da imagem de saída. Defina-o como -1 para fazer com que a imagem de saída tenha a mesma profundidade que a imagem de entrada. Caso contrário, você pode usar , , .cv2.CV_8Ucv2.CV_16Ucv2.CV_32Fcv2.CV_64F
• ksizeé o tamanho do núcleo da caixa. Quanto maior o núcleo, mais forte será o efeito de suavização.
• dsté opcional e gera uma imagem. Se não for fornecido, a função criará uma nova imagem de saída.
• anchoré um ponto de ancoragem opcional no kernel. Geralmente é definido para representar o centro do kernel. Alterar esta configuração pode afetar a posição da saída filtrada.-1, -1
• normalizeé um sinalizador opcional que indica se o kernel deve normalizar pelo número de elementos nele. A normalização ajuda a manter o brilho da imagem relativamente constante.
• borderTypeÉ um sinalizador opcional que indica como lidar com as bordas da imagem.

3.3 Filtro Gaussiano

        É necessária uma média ponderada dos valores dos pixels, com pesos determinados por uma distribuição gaussiana. O peso dos pixels vizinhos diminui à medida que se afastam do pixel central.

        É um filtro de suavização mais complexo do que o desfoque de caixa. Ele preserva melhor as bordas e os detalhes das imagens, ao mesmo tempo que reduz o ruído.

fonte

gaussian_blur = cv2.GaussianBlur(image, (25, 25), 0)

plt.figure(figsize=(10, 8))

plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(gaussian_blur, cv2.COLOR_BGR2RGB))
plt.title('Gaussian Blur')
plt.axis('off')

Desfoque gaussiano. Imagem fornecida pelo autor.

cv.GaussianBlur（src， ksize， sigmaX[， dst[， sigmaY[， borderType]]]） -> dst

• sigmaXé o desvio padrão do kernel gaussiano na direção horizontal. Quanto maior o valor, mais forte será o efeito de desfoque.
• sigmaYé opcional, o desvio padrão do kernel gaussiano na direção vertical. Se não for especificado, o padrão é o mesmo valor de .sigmaX

3.4 Filtro mediano

O filtro mediano substitui cada valor de pixel na imagem pelo valor mediano de seus pixels vizinhos. A mediana é o valor central em uma lista ordenada de valores. Isso significa que o filtro mediano não é afetado por valores discrepantes, como picos de ruído.

fonte

median_filtered = cv2.medianBlur(image, 25)

plt.figure(figsize=(10, 8))

plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title( 'Original Image' )
plt.axis( 'off' )

plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(median_filtered, cv2.COLOR_BGR2RGB))
plt.title( 'Median Filter' )
plt.axis( 'off'  )

Filtro mediano. Imagem fornecida pelo autor.

cv.medianBlur（src，ksize[，dst]） -> dst

4. Filtro de nitidez

        Filtros de nitidez são um tipo de técnica de processamento de imagem usada para aprimorar bordas e detalhes finos nas imagens. Ao contrário dos filtros de desfoque, que suavizam os detalhes da imagem, os filtros de nitidez destacam as diferenças na intensidade dos pixels entre áreas adjacentes, melhorando assim as bordas e tornando os recursos mais proeminentes.

        O filtro de nitidez funciona aprimorando os componentes de alta frequência de uma imagem. Os componentes de alta frequência correspondem a mudanças rápidas nos valores dos pixels, que são característicos de bordas e detalhes finos.

        Os filtros de nitidez podem produzir efeitos visualmente atraentes, mas devem ser usados ​​com cautela. A nitidez excessiva pode amplificar o ruído e introduzir artefatos. Muitas vezes, é uma boa prática aplicar um filtro de nitidez a uma imagem que já seja de boa qualidade e com ruído mínimo.

• Filtro Laplaciano
• Máscara de nitidez

4.1 Filtro Laplaciano

O filtro Laplaciano é um filtro de detecção de bordas usado no processamento de imagens. É um filtro de segunda derivada, o que significa que mede a taxa de mudança da intensidade da imagem. Filtros Laplacianos são comumente usados ​​para tornar imagens mais nítidas e detectar bordas.

fonte

laplacian = cv2.Laplacian(image, -1, ksize=5, scale=1,delta=0,borderType=cv2.BORDER_DEFAULT)

plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(laplacian)
plt.title('Laplacian Filter')
plt.axis('off')

Filtro Laplaciano. Imagem fornecida pelo autor.

cv.Laplacian（src，dprofundidade[，dst[，ksize[，escala[，delta[，borderType]]]]]） -> dst

• ksizeé opcional, o tamanho do kernel a ser usado para operações Laplacianas. É definido como um número ímpar, como,,, etc. Se não for fornecido, o valor padrão será o que corresponde a um núcleo 3x3.1351
• scaleé opcional e é o fator de escala aplicado ao valor Laplaciano calculado. Este parâmetro ajuda a aumentar ou reduzir o efeito do Laplaciano.
• deltaé opcional e é um valor a ser adicionado ao valor Laplaciano calculado. Ele pode ser usado para controlar o brilho ou contraste geral da saída.

4.2 Máscara de nitidez

        Envolve criar uma versão desfocada da imagem original (usando um filtro passa-baixa) e depois subtrair essa versão desfocada da imagem original. O resultado é uma imagem com bordas e detalhes destacados. O termo "não nítido" refere-se à criação de uma máscara que destaca o conteúdo não nítido da imagem.

fonte

        A quantidade de nitidez é controlada pela quantidade de desfoque e pelo peso da imagem desfocada. O desfoque geralmente é um desfoque gaussiano, mas outros tipos de desfoque também podem ser usados. Imagens desfocadas geralmente têm pesos entre 0 e 1. Um peso maior resultará em mais nitidez.

blurred = cv2.GaussianBlur(image, (25, 25), 3)
k = 3
unsharp_mask = cv2.addWeighted(image, k-1, blurred, -1.0, 0)

plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(unsharp_mask, cv2.COLOR_BGR2RGB))
plt.title('Unsharp Masking')
plt.axis('off')

Mascaramento pouco nítido. Imagem fornecida pelo autor.

        A filtragem de alto reforço é uma forma comum de mascaramento de nitidez. Ele permite controlar a quantidade de aprimoramento aplicado aos detalhes da imagem. Isso é feito adicionando uma combinação ponderada da imagem original e uma versão desfocada da imagem, onde o peso determina o grau de aprimoramento.

        Esta função é usada para combinar duas imagens com pesos diferentes. Neste contexto, é usado para realizar operações de filtragem de alto reforço.cv2.addWeighted

• image: Esta é a imagem original.
• k - 1: Este é o peso da imagem original. Subtrair 1 disso garante que a contribuição da imagem original seja dimensionada de acordo com o fator de aprimoramento. O valor coloca mais ênfase em detalhes aprimorados.kk - 1
• blurred: Esta é uma imagem borrada.
• -0.5: Este é o peso da imagem desfocada. Valores negativos subtraem o desfoque da imagem.
• 0: Este é um valor de deslocamento. Após a adição ponderada, ele é adicionado ao resultado.

5. Filtro de aprimoramento de borda

        O filtro de aprimoramento de borda é um filtro de imagem usado para aprimorar as bordas de uma imagem. As bordas são os limites entre as diferentes regiões de uma imagem e são importantes para fornecer informações sobre a estrutura e a forma dos objetos na imagem.

• Filtro Sobel
• Filtro pré-wett
• Laplaciano filtrado gaussiano
• Detector de borda inteligente

5.1 Filtro Sobel

        O filtro Sobel é usado para detectar bordas calculando o gradiente de intensidade da imagem em cada pixel. Ele usa dois núcleos de convolução separados (um para a direção horizontal e outro para a direção vertical) para aproximar o gradiente.

Operador Sobel. fonte

        O filtro Sobel é um filtro de detecção de bordas popular porque é relativamente simples de implementar e muito eficaz na detecção de bordas. No entanto, também pode ser sensível ao ruído, por isso é frequentemente usado em conjunto com outros filtros, como o Desfoque Gaussiano, para reduzir o ruído na imagem antes de aplicar o filtro Sobel.

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Apply Sobel Filter
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=25)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=25)
sobel_edges = np.sqrt(sobel_x**2 + sobel_y**2)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(sobel_edges, cmap='gray')
plt.title('Sobel Filter')
plt.axis('off')

Filtro Sobel. Imagem fornecida pelo autor.

cv.Sobel（src, dprofundidade, dx, dy[, dst[, ksize[, escala[, delta[, borderType]]]]]） -> dst

• dxe: a ordem das derivadas nas direções xey, respectivamente. Esses valores determinam a direção na qual o gradiente é calculado. Por exemplo, defina e calcule o gradiente na direção x.dydx=1dy=0
• ksize(opcional): O tamanho do kernel Sobel usado para cálculos. Geralmente é definido como um número ímpar, como,,, etc. Se não for fornecido, o valor padrão será o que corresponde a um núcleo 3x3.1353
• scale(Opcional): Fator de escala a ser aplicado aos valores Sobel calculados. Este parâmetro ajuda a aumentar ou diminuir o efeito do operador Sobel.
• delta(Opcional): Valor a ser adicionado ao valor Sobel calculado. Ele pode ser usado para controlar o brilho ou contraste geral da saída.

5.2 Filtro pré-umedecido

Semelhante ao filtro Sobel, o filtro Prewitt também calcula o gradiente de intensidade da imagem para detectar bordas. Ele usa um kernel mais simples que o kernel Sobel, mas ainda é eficaz para destacar bordas.

• A intensidade do filtro deve ser ajustada cuidadosamente para evitar nitidez excessiva da imagem.
• Se possível, o filtro deve ser aplicado a uma versão da imagem sem ruído.
• Os filtros devem ser usados ​​em conjunto com outras técnicas de processamento de imagem (como suavização) para melhorar a qualidade geral da imagem.

Operador Prewett. fonte

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Prewitt Filter
kernel_x = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
kernel_y = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]])

prewitt_x = cv2.filter2D(image, cv2.CV_64F, kernel_x)
prewitt_y = cv2.filter2D(image, cv2.CV_64F, kernel_y)
prewitt_edges = np.sqrt(prewitt_x**2 + prewitt_y**2)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(prewitt_edges, cmap='gray')
plt.title('Prewitt Filter')
plt.axis('off')

Filtro pré-wett. Imagem fornecida pelo autor.

5.3 Laplaciano de filtragem gaussiana

        O filtro LoG combina os efeitos de desfoque e detecção de bordas. Primeiro aplica o desfoque gaussiano à imagem e depois calcula o operador Laplaciano na imagem desfocada. O resultado é que as bordas da imagem são aprimoradas e o ruído é suprimido.

Laplaciano do filtro gaussiano. fonte

        O filtro LoG é um filtro separável, o que significa que pode ser calculado convolvendo a imagem com um único kernel (ou seja, uma matriz 3x3). O kernel consiste em pesos projetados para realçar as bordas da imagem.

• A intensidade do filtro deve ser ajustada cuidadosamente para evitar nitidez excessiva da imagem.
• Se possível, o filtro deve ser aplicado a uma versão da imagem sem ruído.
• Os filtros devem ser usados ​​em conjunto com outras técnicas de processamento de imagem (como suavização) para melhorar a qualidade geral da imagem.

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Apply Laplacian of Gaussian (LoG) Filter
log_edges = cv2.Laplacian(image, cv2.CV_64F)
log_edges = cv2.convertScaleAbs(log_edges)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(log_edges, cmap='gray')
plt.title('LoG Filter')
plt.axis('off')

Filtro LoG. Imagem fornecida pelo autor.

A operação Laplaciana pode gerar valores positivos e negativos, que podem não ser adequados para visualização. A função é usada para converter a saída da operação Laplaciana em um valor absoluto e depois em um tipo de dados mais adequado para exibição de imagem ().cv2.convertScaleAbs(log_edges)uint8

5.4 Detector de borda inteligente

        O detector de bordas Canny é uma técnica popular de processamento de imagens usada para detectar bordas em imagens.

Detector de borda inteligente. fonte

Os detectores de borda astutos funcionam identificando áreas em uma imagem com intensidade que muda rapidamente, que geralmente correspondem a limites de objetos ou características importantes.

A saída do detector de bordas Canny é uma imagem binária onde os pixels das bordas são marcados com branco e os pixels que não são da borda com preto. A técnica é versátil e pode ser ajustada ajustando parâmetros como o desvio padrão do desfoque gaussiano e o limite de detecção de borda.

canny_edges = cv2.Canny(image, 30, 60)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(canny_edges, cmap='gray')
plt.title('Canny Edge Filter')
plt.axis('off')

Filtro de borda inteligente. Imagem fornecida pelo autor.

cv.Canny(Imagem, Limite1, Limite2[, Bordas[, ApertureSize[, L2Gradient]]]) -> Bordas

cv.Canny（dx, dy, limite1, limite2[， arestas[， L2gradiente]]） -> borda

• image: A imagem de entrada à qual a detecção de bordas do Canny será aplicada. Geralmente é uma imagem em tons de cinza.
• threshold1e: Estes são os limites inferior e superior usados ​​na etapa de limite duplo. O algoritmo Canny marca os pixels com magnitudes de gradiente acima como bordas fortes e os pixels entre as bordas como bordas fracas. Os pixels abaixo são considerados sem borda e serão descartados.threshold2threshold2threshold1threshold2threshold1
• apertureSize(Opcional): O tamanho do kernel Sobel usado para cálculos de gradiente. Geralmente é definido como , ou . Se não for fornecido, o valor padrão será.3573
• L2gradient(opcional): Sinalizador que indica se a norma L2 deve ser usada para calcular a magnitude do gradiente. Se , então use a distância euclidiana. Se , a norma L1 é usada. O valor padrão é .TrueFalseFalse

        Basicamente, a filtragem de imagens consiste em extrair insights ocultos de dados de pixel. Através do poder matemático da convolução, melhora as bordas, reduz o ruído e transforma imagens brutas em histórias envolventes. Este processo combina propósito com tecnologia, solidificando a poderosa capacidade da filtragem de imagens de revelar o invisível e melhorar a percepção visual. Okan Jernigan

·