## Detecção de Bordas

Bordas representam mudanças abruptas na intensidade dos pixels, que geralmente correspondem aos limites dos objetos. Detectar bordas auxilia no reconhecimento de formas e na segmentação.

### Detecção de Bordas de Sobel

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


### Detecção de Bordas de Canny

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

## 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

Introdução abrangente à Visão Computacional, com foco na percepção e interpretação de dados visuais por máquinas. Abrange pré-processamento de imagens, extração de características, detecção de objetos e técnicas de aprendizado profundo utilizadas em sistemas de visão modernos.

A visão computacional permite que máquinas interpretem e analisem dados visuais, imitando a percepção humana. Esta seção aborda os fundamentos da representação de imagens, modelos de cor e bases matemáticas essenciais para compreender como os computadores processam imagens. Serão exploradas aplicações do mundo real, desde veículos autônomos até imagens médicas, além de como a visão computacional se integra à IA e ao aprendizado de máquina.

OpenCV é uma biblioteca poderosa para manipulação de imagens e tarefas de visão computacional. Esta seção aborda técnicas essenciais como filtragem de imagens, transformações, detecção de bordas e segmentação. Você aprenderá a realizar desfoque, limiarização, detecção de contornos e extração de características para aprimorar e analisar imagens de forma eficiente.

As CNNs processam dados visuais utilizando camadas de convolução, pooling e ativação para extrair características em tarefas como classificação de imagens e detecção de objetos. Os principais componentes incluem padding, convolução para extração de características, pooling para redução de complexidade e ativação para introdução de não linearidade. Arquiteturas populares como AlexNet, VGG e ResNet impulsionam a IA em saúde, autonomia e segurança.

A detecção de objetos é uma tarefa fundamental em visão computacional que envolve a identificação e localização de objetos dentro de uma imagem. Diferentemente da classificação de imagens, que atribui um único rótulo a toda a imagem, a detecção de objetos não apenas classifica os objetos, mas também determina suas posições utilizando caixas delimitadoras. Esta seção aborda as principais técnicas e algoritmos utilizados em detecção de objetos, abrangendo desde métodos tradicionais até abordagens baseadas em aprendizado profundo, como YOLO e U-Net.

A visão computacional avançou significativamente ao longo dos anos, passando de métodos básicos de processamento de imagens para técnicas complexas de deep learning. Esta seção aborda as inovações mais recentes em visão computacional, com foco em transfer learning, reconhecimento facial e geração de imagens. Serão explorados os benefícios de modelos pré-treinados no desempenho, os princípios da tecnologia de reconhecimento facial e a forma como a IA cria imagens por meio de deep learning.

Detecção de Bordas