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

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 de Sobel

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

```
# 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 clave:
- `src`: imagen de entrada (debe estar en escala de grises);
- `ddepth`: profundidad de la imagen de salida (por ejemplo, `cv2.CV_64F`);
- `dx`: orden de la derivada en la dirección X (establecer en `1` para bordes horizontales);
- `dy`: orden de la derivada en la dirección Y (establecer en `1` para bordes verticales);
- `ksize`: tamaño del kernel (debe ser impar, por ejemplo, `3`, `5`, `7`).

Nota

### Detección de Bordes de 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 usando filtros de Sobel.
3.	Supresión de bordes débiles.
4.	Uso de doble umbral y seguimiento de bordes.

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

- `image`: imagen de entrada en escala de grises;
- `threshold1`: umbral inferior para la detección de bordes (por ejemplo, `50`);
- `threshold2`: umbral superior para la detección de bordes (por ejemplo, `150`);
- `apertureSize` (opcional): tamaño del kernel de Sobel (por defecto: `3`, debe ser impar);
- `L2gradient` (opcional): uso de un cálculo de gradiente L2 más preciso (por defecto: `False`).

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

Sumérgete en la visión por computadora dominando las redes neuronales convolucionales (CNN) con TensorFlow y Keras. Este curso avanzado abarca conceptos esenciales y habilidades prácticas, incluyendo el preprocesamiento de imágenes, operaciones de convolución y agrupamiento, construcción y entrenamiento de arquitecturas CNN, implementación de detección de objetos y aplicación de aprendizaje por transferencia para abordar desafíos visuales del mundo real. Obtén experiencia práctica resolviendo problemas complejos de visión utilizando herramientas y técnicas estándar de la industria.

Detección de Bordes

Detección de Bordes de Sobel

Detección de Bordes de Canny

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

Solución