Summary  
This chapter demonstrates how to implement Sobel and Canny edge detection to compute image gradients, suppress noise, and extract object boundaries.  

General domain of usage  
Image processing

Bordas representam mudanças súbitas na intensidade dos pixels, que geralmente correspondem aos limites dos objetos. A detecção de bordas auxilia no reconhecimento de formas e na segmentação.

### Detecção de Bordas de Sobel

O operador de Sobel calcula gradientes (mudanças de intensidade) nas direções **X e Y**, auxiliando na detecção de bordas horizontais e verticais.

```
# Convert to grayscale
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

# Apply Sobel filter
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)  # Detects vertical edges
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)  # Detects horizontal edges
sobel_combined = cv2.magnitude(sobel_x, sobel_y)  # Combines both directions
```

Parâmetros principais:
- `src`: imagem de entrada (deve estar em escala de cinza);
- `ddepth`: profundidade da imagem de saída (por exemplo, `cv2.CV_64F`);
- `dx`: ordem da derivada na direção X (definir `1` para bordas horizontais);
- `dy`: ordem da derivada na direção Y (definir `1` para bordas verticais);
- `ksize`: tamanho do kernel (deve ser ímpar, por exemplo, `3`, `5`, `7`).

Nota

### Detecção de Bordas de Canny

O Detector de Bordas de Canny é um algoritmo de múltiplos estágios que **fornece bordas mais precisas** por meio de:
1.	Aplicação de desfoque Gaussiano para remover ruídos.
2.	Cálculo dos gradientes de intensidade usando filtros de Sobel.
3.	Supressão de bordas fracas.
4.	Uso de dupla limiarização e rastreamento de bordas.

```
# Apply Canny Edge Detector 
canny_image = cv2.Canny(image, threshold1, threshold2, apertureSize, L2gradient)  
```

- `image`: imagem de entrada em tons de cinza;
- `threshold1`: limite inferior para detecção de bordas (ex.: `50`);
- `threshold2`: limite superior para detecção de bordas (ex.: `150`);
- `apertureSize` (opcional): tamanho do kernel de Sobel (padrão: `3`, deve ser ímpar);
- `L2gradient` (opcional): utiliza cálculo de gradiente L2 mais preciso (padrão: `False`).

## Uma comparação dos métodos de detecção de bordas:

import unittest
import numpy as np
import importlib
import cv2

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 TestEdgeDetection(unittest.TestCase):

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

    def test_output_types(self):
        gray = getattr(user_code, "gray_image", None)
        sobel = getattr(user_code, "sobel_img", None)
        canny = getattr(user_code, "canny_img", None)
        _dynamic_test(
            self,
            all(isinstance(x, np.ndarray) for x in [gray, sobel, canny]),
            "All edge detection outputs are NumPy arrays.",
            "Grayscale, Sobel, and Canny images should all be NumPy arrays."
        )

    def test_sobel_kernel_parameters(self):
        gray = user_code.gray_image
        sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
        sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
        combined = cv2.magnitude(sobel_x, sobel_y)
        student = user_code.sobel_img

        similarity = np.allclose(student, combined, atol=1e-5)
        _dynamic_test(
            self,
            similarity,
            "Sobel image matches expected output with kernel size of 3 and depth as cv2.CV_64F.",
            "Sobel image does not match expected output using correct parameters (kernel size of 3, depth as cv2.CV_64F)."
        )

    def test_canny_thresholds(self):
        gray = user_code.gray_image
        expected = cv2.Canny(gray, 200, 300)
        student = user_code.canny_img

        similarity = np.array_equal(student, expected)
        _dynamic_test(
            self,
            similarity,
            "Canny edge output matches thresholds 200-300.",
            "Canny edge image should be computed with thresholds 200 and 300."
        )

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.

Detecção de Bordas

Detecção de Bordas de Sobel

Detecção de Bordas de Canny

Uma comparação dos métodos de detecção de bordas:

Solução