Filtragem Espacial: Blur de Caixa e Gaussiano

• Construir um kernel de blur de caixa normalizado e um kernel de blur gaussiano de um dado tamanho e sigma, e explicar por que a normalização de kernel (pesos somando 1) é exigida.
• Rodar uma pequena imagem por ambos os kernels à mão e comparar os resultados.
• Explicar a razão real e prática pela qual a separabilidade do kernel gaussiano em duas passadas 1D importa para o desempenho.

the-convolution-and-correlation-operation definiu a mecânica de janela deslizante no abstrato, usando um kernel de média genérico como o seu exemplo resolvido. Este conceito torna isso concreto com os dois kernels fixos reais mais comuns usados para suavização: o blur de caixa e o blur gaussiano. Ambos são kernels genuinamente simples, projetados à mão e de forma fechada, exatamente o tipo de processamento de kernel fixo sobre o qual o limite de escopo desta disciplina (traçado precisamente em the-convolution-and-correlation-operation contra convolution-as-a-sliding-dot-product em ai-theory/deep-learning) trata.

A suavização não é um fim em si mesma aqui; é preparação. the-sobel-operator-and-gradient-based-edge-detection e the-canny-edge-detector, imediatamente a seguir, ambos dependem de suprimir o ruído em nível de pixel antes de computar um gradiente, já que um operador de gradiente amplifica o ruído tão prontamente quanto detecta bordas reais. Ter um kernel de blur funcional e bem compreendido em mãos agora é o que faz o estágio de suavização desse passo posterior ser mais do que uma caixa-preta.

O blur de caixa: média uniforme, normalizada

O kernel de suavização mais simples pondera cada pixel na sua vizinhança igualmente. Um kernel de blur de caixa 3x3 é:

text
w_caixa = (1/9) * [1 1 1]
                  [1 1 1]
                  [1 1 1]

Normalização significa que os pesos do kernel somam exatamente 1 (aqui, 9 * 1/9 = 1). Isto é exigido porque convolver uma região de intensidade constante com um kernel não normalizado escalaria o seu brilho para cima ou para baixo pela soma dos pesos do kernel; normalizar garante que uma região uniformemente brilhante ou escura seja deixada inalterada em brilho médio depois de embaçada, só a sua variação local é suavizada.

O blur gaussiano: ponderando por distância

O blur de caixa trata um pixel a 3 células de distância exatamente como um pixel adjacente, que não é como o blur óptico ou de sensor real se comporta. O kernel gaussiano em vez disso amostra a função gaussiana 2D:

text
G(x, y) = (1 / (2*pi*sigma^2)) * exp(-(x^2 + y^2) / (2*sigma^2))

em deslocamentos inteiros (x, y) a partir do centro do kernel, depois normaliza as amostras resultantes para somar 1. Um sigma maior produz um kernel mais largo e mais achatado (blur mais forte, já que pixels mais distantes ainda recebem peso significativo); um sigma menor concentra o peso perto do centro (um blur mais suave, próximo da identidade).

Separabilidade: por que o blur gaussiano é rápido na prática

Uma propriedade chave, real e praticamente importante da gaussiana: ela é separável, a função gaussiana 2D fatora exatamente num produto de duas gaussianas 1D, G(x, y) = G(x) * G(y). Isto significa que uma convolução gaussiana 2D pode ser computada como duas convoluções 1D em sequência, primeiro embaçando toda linha, depois embaçando toda coluna do resultado, um custo por pixel O(k) + O(k) = O(2k) em vez de O(k^2) para um kernel 2D direto do mesmo tamanho k x k. Esta é a razão específica e concreta pela qual bibliotecas de imagem reais implementam o blur gaussiano como duas passadas em vez de um grande kernel 2D; o blur de caixa também pode ser separado desta forma (ele é um produto de dois kernels uniformes 1D), mas a economia importa mais conforme o tamanho do kernel cresce.

Exemplo 1: blur de caixa na imagem de listra de 4x4

Reusando a imagem de digital-images-as-discrete-functions, computando a saída de blur de caixa em (1,1), exatamente como feito no Exemplo 1 de the-convolution-and-correlation-operation: saída = 660/9 = 73,33. Em (2,2) (também 200 no original), a vizinhança 3x3 é:

text
[200  10  10]
[ 10  10  10]
[ 10  10 200]
Soma = 200+10+10+10+10+10+10+10+200 = 470
Saída = 470/9 = 52,22

Ambos os pixels diagonais brilhantes são puxados em direção aos seus arredores mais escuros, o efeito visual do embaçamento tornado numericamente concreto.

Exemplo 2: um pequeno kernel gaussiano, sigma = 1, e verificação de normalização

Uma aproximação gaussiana 3x3 discretizada comum para sigma ~= 1 (antes da normalização):

text
[1 2 1]
[2 4 2]
[1 2 1]
Soma dos pesos brutos = 1+2+1+2+4+2+1+2+1 = 16

Kernel normalizado: divida cada entrada por 16:

text
w_gauss = (1/16) * [1 2 1]
                    [2 4 2]
                    [1 2 1]

Aplicando isto à mesma vizinhança em (1,1) do Exemplo 1 ([10,10,200 / 10,200,10 / 200,10,10]):

text
(1*10 + 2*10 + 1*200 + 2*10 + 4*200 + 2*10 + 1*200 + 2*10 + 1*10) / 16
= (10+20+200+20+800+20+200+20+10) / 16
= 1300 / 16
= 81,25

Compare com os 73,33 do blur de caixa na mesma posição: o kernel ponderado pelo centro da gaussiana (peso 4 no centro versus o 1 uniforme do blur de caixa) preserva mais da influência do pixel brilhante original, um blur menor e mais suave do que o kernel de caixa uniforme no mesmo tamanho 3x3, exatamente a diferença qualitativa que a Teoria Central descreve.

Exemplo 3: separabilidade na prática, contando operações

Para um kernel 5x5 aplicado a um único pixel: uma convolução 2D direta exige 25 multiplicações e 24 adições por pixel de saída. Usando a separabilidade (duas passadas 1D de comprimento 5), cada passada exige 5 multiplicações e 4 adições, para um total de 2*(5+4) = 18 operações, versus 49 para a abordagem 2D direta. A diferença se amplia conforme o tamanho de kernel k cresce: O(k^2) direto versus O(2k) separável, uma economia genuinamente grande e real para os kernels maiores que um blur forte exige.

• "Um kernel de blur maior sempre só significa 'mais do mesmo', sem nenhuma diferença real de custo." O Exemplo 3 mostra que o custo do kernel cresce quadraticamente (O(k^2)) sem separabilidade, uma preocupação de desempenho real e de primeira ordem para kernels grandes, que é exatamente por que a separabilidade importa praticamente, não só teoricamente.
• "Um kernel não normalizado só produziria um blur ligeiramente fora, nada demais." Um kernel não normalizado sistematicamente clareia ou escurece a imagem inteira pela soma de pesos do kernel, um defeito visível de primeira ordem, não uma questão menor de arredondamento, que é por que a normalização é uma exigência rígida, não um refinamento.
• "Blur gaussiano e blur de caixa são basicamente intercambiáveis." O Exemplo 2 mostra que eles produzem saídas numéricas diferentes na mesma entrada no mesmo tamanho de kernel, porque a estrutura ponderada pelo centro da gaussiana trata pixels de vizinhança próximos e distantes diferentemente, enquanto o blur de caixa trata cada vizinho identicamente; a diferença visual e numérica é real, não cosmética.

O blur de caixa (média uniforme e normalizada) e o blur gaussiano (pesos amostrados de uma gaussiana 2D, também normalizados) são os dois kernels de suavização fixos reais e padrão construídos diretamente sobre a mecânica de janela deslizante de the-convolution-and-correlation-operation, e a separabilidade da gaussiana em duas passadas 1D é a razão específica e prática pela qual ela pode ser computada eficientemente em tamanhos de kernel maiores. A suavização não é o ponto final desta disciplina; é preparação para as computações de gradiente sensíveis a ruído que the-sobel-operator-and-gradient-based-edge-detection constrói em seguida.