Summary  
This chapter explains how to apply Gaussian and median filters to smooth data arrays and reduce noise by performing weighted averaging and median aggregation within local neighborhoods.

General domain of usage  
Image processing

Ruído em imagens aparece como granulação ou distorção indesejada, frequentemente causado por baixa iluminação, artefatos de compressão ou limitações do sensor. Técnicas de suavização auxiliam na **redução do ruído enquanto preservam detalhes importantes da imagem**.


## Desfoque Gaussiano (Suavização de Ruído)
A função `cv2.GaussianBlur` aplica um **desfoque gaussiano**, que suaviza a imagem ao calcular a média dos valores dos pixels utilizando um kernel gaussiano (uma média ponderada que atribui maior importância aos pixels centrais):

- `cv2.GaussianBlur(src, ksize, sigmaX)`:  
  - `src`: imagem de origem a ser suavizada;
  - `ksize`: tamanho do kernel no formato `(width, height)`, ambos os valores devem ser ímpares (por exemplo, `(5, 5)`);
  - `sigmaX`: desvio padrão na direção X; controla o nível de desfoque.  
- A função reduz o ruído e detalhes da imagem ao convoluir a imagem com uma função gaussiana, sendo útil em tarefas como detecção de bordas ou pré-processamento antes da limiarização.

```
blurred = cv2.GaussianBlur(image, ksize, sigmaX)
```

No `cv2.GaussianBlur()`, o parâmetro `sigmaX` é o **desvio padrão do kernel Gaussiano na direção X**, e o mesmo parâmetro na direção Y (`sigmaY`) possui o valor **0 como padrão**. Quando ambos `sigmaX` e `sigmaY` têm valor 0, **o desvio padrão é calculado a partir do tamanho do kernel**.

Estude Mais

## Desfoque Mediano (Remoção de Ruído Sal e Pimenta)
A função `cv2.medianBlur` aplica um **filtro mediano**, que substitui cada valor de pixel pelo valor mediano dos pixels vizinhos na janela do kernel:

- `cv2.medianBlur(src, ksize)`:  
  - `src`: imagem de origem a ser filtrada;
  - `ksize`: tamanho do kernel quadrado (deve ser um inteiro ímpar, por exemplo, `3`, `5`, `7`).  
- O desfoque mediano é especialmente eficaz na remoção de **ruído sal e pimenta**, pois preserva as bordas enquanto elimina pixels ruidosos isolados.

```
median_blurred = cv2.medianBlur(image, ksize)
```

import unittest
import numpy as np
import importlib

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestBlurFilters(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")

    def test_gaussian_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Gaussian blurred image has correct shape and type.",
            f"The variable `gaussian_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_median_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Median blurred image has correct shape and type.",
            f"The variable `median_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_gaussian_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Gaussian blur changes image content.",
            "The variable `gaussian_blurred` should be a NumPy array and differ from `image`."
        )

    def test_median_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Median blur changes image content.",
            "The variable `median_blurred` should be a NumPy array and differ from `image`."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Aprofunde-se em visão computacional dominando redes neurais convolucionais (CNNs) com TensorFlow e Keras. Este curso avançado aborda conceitos essenciais e habilidades práticas, incluindo pré-processamento de imagens, operações de convolução e pooling, construção e treinamento de arquiteturas CNN, implementação de detecção de objetos e aplicação de aprendizado por transferência para enfrentar desafios visuais do mundo real. Adquira experiência prática na resolução de problemas complexos de visão utilizando ferramentas e técnicas padrão da indústria.

Redução de Ruído e Suavização

Desfoque Gaussiano (Suavização de Ruído)

Desfoque Mediano (Remoção de Ruído Sal e Pimenta)

Solução