Permite transformar uma imagem do **domínio espacial** (onde os valores dos pixels são representados diretamente) para o **domínio da frequência** (onde padrões e estruturas são analisados com base em sua frequência). Isso é útil para tarefas como **filtragem de imagem, detecção de bordas e redução de ruído**.

Primeiro, é necessário converter a imagem para **tons de cinza**:


Para calcular a **transformada de Fourier 2D**:

Aqui, `fft2()` converte a imagem do **domínio espacial** para o **domínio da frequência**, e `fftshift()` move os componentes de baixa frequência para o centro.

Para visualizar o **espectro de magnitude**:

Como a transformada de Fourier gera **números complexos**, utilizamos os **valores absolutos (`np.abs()`)** para uma visualização significativa.

A função `np.log` melhora a visibilidade, pois os valores de magnitude bruta variam bastante em escala.


import unittest
import numpy as np
import cv2
import importlib

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

class TestImageProcessing(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")
    
    def test_variables_existence_and_types(self):
        """Check all necessary variables are declared and have correct types."""

        variables_to_check = {
            'gray_image': np.ndarray,
            'dft': np.ndarray,
            'dft_shift': np.ndarray,
            'magnitude_spectrum': np.ndarray
        }

        for var_name, expected_type in variables_to_check.items():
            with self.subTest(variable=var_name):
                var = getattr(user_code, var_name, None)
                condition = var is not None and isinstance(var, expected_type)
                if var is None:
                    failure_message = f"The variable `{var_name}` is not declared."
                elif not isinstance(var, expected_type):
                    failure_message = f"The variable `{var_name}` should be of type `{expected_type.__name__}`, but got `{type(var).__name__}`."
                else:
                    failure_message = ""
                _dynamic_test(
                    self,
                    condition,
                    f"The variable `{var_name}` exists and has the correct type `{expected_type.__name__}`.",
                    failure_message
                )

    def test_grayscale_conversion(self):
        """Check if the image is correctly converted to grayscale."""
        condition = len(user_code.gray_image.shape) == 2
        _dynamic_test(
            self,
            condition,
            "Grayscale image has 2 dimensions.",
            "Grayscale image should have 2 dimensions."
        )
    
    def test_dft_computation(self):
        """Check if the DFT is computed and has the correct shape."""
        condition = user_code.dft.shape == user_code.gray_image.shape
        _dynamic_test(
            self,
            condition,
            "DFT has the same shape as the grayscale image.",
            "DFT should have the same shape as the grayscale image."
        )
    
    def test_dft_shift_computation(self):
        """Check if the DFT shift is correctly computed."""
        condition = user_code.dft_shift.shape == user_code.dft.shape
        _dynamic_test(
            self,
            condition,
            "DFT shift has the same shape as the DFT.",
            "DFT shift should have the same shape as the DFT."
        )
    
    def test_magnitude_spectrum_computation(self):
        """Check if the magnitude spectrum is computed correctly."""
        condition = user_code.magnitude_spectrum.shape == user_code.gray_image.shape
        _dynamic_test(
            self,
            condition,
            "Magnitude spectrum has the same shape as the grayscale image.",
            "Magnitude spectrum should have the same shape as the grayscale image."
        )
    
    def test_magnitude_spectrum_values(self):
        """Ensure the magnitude spectrum contains valid values."""
        condition = np.all(user_code.magnitude_spectrum >= 0)
        _dynamic_test(
            self,
            condition,
            "Magnitude spectrum contains non-negative values.",
            "Magnitude spectrum should contain non-negative values."
        )

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.

Transformada de Fourier

Solução

Transformada de Fourier

Solução