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

I bordi rappresentano variazioni improvvise nell'intensità dei pixel, che solitamente corrispondono ai contorni degli oggetti. L'individuazione dei bordi facilita il riconoscimento delle forme e la segmentazione.

### Rilevamento dei Bordi con Sobel

L'operatore Sobel calcola i gradienti (variazioni di intensità) sia nelle **direzioni X che Y**, consentendo di rilevare bordi orizzontali e verticali.

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

Parametri principali:
- `src`: immagine di input (deve essere in scala di grigi);
- `ddepth`: profondità dell'immagine di output (ad esempio, `cv2.CV_64F`);
- `dx`: ordine della derivata nella direzione X (impostare `1` per i bordi orizzontali);
- `dy`: ordine della derivata nella direzione Y (impostare `1` per i bordi verticali);
- `ksize`: dimensione del kernel (deve essere dispari, ad esempio `3`, `5`, `7`).

Nota

### Rilevamento dei Bordi con Canny

Il rilevatore di bordi di Canny è un algoritmo multi-fase che **fornisce bordi più accurati** tramite:
1.	Applicazione di un filtro Gaussiano per rimuovere il rumore.
2.	Calcolo dei gradienti di intensità tramite i filtri Sobel.
3.	Soppressione dei bordi deboli.
4.	Utilizzo di doppia soglia e tracciamento dei bordi.

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

- `image`: immagine di input in scala di grigi;
- `threshold1`: soglia inferiore per il rilevamento dei bordi (ad esempio, `50`);
- `threshold2`: soglia superiore per il rilevamento dei bordi (ad esempio, `150`);
- `apertureSize` (opzionale): dimensione del kernel di Sobel (predefinito: `3`, deve essere dispari);
- `L2gradient` (opzionale): utilizzo di un calcolo del gradiente L2 più accurato (predefinito: `False`).

## Un confronto tra i metodi di rilevamento dei bordi:

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

Approfondisci la visione artificiale padroneggiando le reti neurali convoluzionali (CNN) con TensorFlow e Keras. Questo corso avanzato copre concetti fondamentali e competenze pratiche, tra cui la pre-elaborazione delle immagini, le operazioni di convoluzione e pooling, la costruzione e l'addestramento di architetture CNN, l'implementazione del rilevamento degli oggetti e l'applicazione del transfer learning per affrontare sfide visive reali. Acquisisci esperienza pratica nella risoluzione di problemi complessi di visione utilizzando strumenti e tecniche standard del settore.

Rilevamento dei Bordi

Rilevamento dei Bordi con Sobel

Rilevamento dei Bordi con Canny

Un confronto tra i metodi di rilevamento dei bordi:

Soluzione