Summary  
The chapter explains how to compute a 2D Fourier transform of array data using NumPy’s fft2 and fftshift functions, then derive and scale the magnitude spectrum via abs and log for visualization.  

General domain of usage  
Image processing

Permite transformar una imagen del **dominio espacial** (donde los valores de los píxeles se representan directamente) al **dominio de la frecuencia** (donde se analizan patrones y estructuras según su frecuencia). Esto es útil para tareas como **filtrado de imágenes, detección de bordes y reducción de ruido**.

Primero, es necesario convertir la imagen a **escala de grises**:


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

Aquí, `fft2()` convierte la imagen del **dominio espacial** al **dominio de la frecuencia**, y `fftshift()` mueve los componentes de baja frecuencia al centro.

Para visualizar el **espectro de magnitud**:

Dado que la transformada de Fourier produce **números complejos**, se toman los **valores absolutos (`np.abs()`)** para una visualización significativa.

La función `np.log` mejora la visibilidad, ya que los valores de magnitud originales varían considerablemente en 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

Introducción integral a la visión por computadora, enfocada en la percepción e interpretación automática de datos visuales. Cubre preprocesamiento de imágenes, extracción de características, detección de objetos y técnicas de aprendizaje profundo utilizadas en sistemas de visión modernos.

La visión por computadora permite a las máquinas interpretar y analizar datos visuales, imitando la percepción humana. Esta sección abarca los conceptos básicos de la representación de imágenes, modelos de color y fundamentos matemáticos esenciales para comprender cómo los ordenadores procesan imágenes. Se explorarán aplicaciones en el mundo real, desde vehículos autónomos hasta imágenes médicas, y se analizará cómo la visión por computadora se integra con la IA y el aprendizaje automático.

OpenCV es una biblioteca potente para la manipulación de imágenes y tareas de visión por computadora. Esta sección abarca técnicas esenciales como el filtrado de imágenes, transformaciones, detección de bordes y segmentación. Aprenderá a realizar desenfoque, umbralización, detección de contornos y extracción de características para mejorar y analizar imágenes de manera eficiente.

Las CNN procesan datos visuales utilizando capas de convolución, agrupamiento y activación para extraer características en tareas como clasificación de imágenes y detección de objetos. Los componentes clave incluyen el padding, la convolución para la extracción de características, el agrupamiento para la reducción de complejidad y la activación para la no linealidad. Arquitecturas populares como AlexNet, VGG y ResNet impulsan la IA en salud, autonomía y seguridad.

La detección de objetos es una tarea fundamental en la visión por computadora que consiste en identificar y localizar objetos dentro de una imagen. A diferencia de la clasificación de imágenes, que asigna una sola etiqueta a toda la imagen, la detección de objetos no solo clasifica los objetos, sino que también determina sus posiciones utilizando cajas delimitadoras. Esta sección abarca técnicas y algoritmos clave utilizados en la detección de objetos, desde métodos tradicionales hasta enfoques basados en aprendizaje profundo como YOLO y U-Net.

La visión por computadora ha avanzado significativamente a lo largo de los años, pasando de métodos básicos de procesamiento de imágenes a técnicas complejas de aprendizaje profundo. Esta sección aborda las innovaciones más recientes en visión por computadora, con énfasis en el aprendizaje por transferencia, el reconocimiento facial y la generación de imágenes. Se explorarán los beneficios de los modelos preentrenados en el rendimiento, los principios de la tecnología de reconocimiento facial y la manera en que la IA crea imágenes mediante aprendizaje profundo.

Transformada de Fourier

Solución

Awesome!

Transformada de Fourier

Solución

Awesome!