## Detección de bordes

Los bordes representan cambios bruscos en la intensidad de los píxeles, que generalmente corresponden a los límites de los objetos. La detección de bordes ayuda en el reconocimiento de formas y la segmentación.

### Detección de bordes con Sobel

El operador Sobel calcula los gradientes (cambios de intensidad) en las direcciones **X y Y**, lo que ayuda a detectar bordes horizontales y verticales.


### Detección de bordes con Canny

El detector de bordes de Canny es un algoritmo de múltiples etapas que **proporciona bordes más precisos** mediante:
1.	Aplicación de desenfoque gaussiano para eliminar el ruido.
2.	Cálculo de gradientes de intensidad utilizando filtros Sobel.
3.	Supresión de bordes débiles.
4.	Uso de doble umbral y seguimiento de bordes.

## Comparación de métodos de detección de bordes:

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

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.

Detección de Bordes

Detección de bordes

Detección de bordes con Sobel

Detección de bordes con Canny