## Rilevamento dei bordi

I bordi rappresentano cambiamenti improvvisi nell'intensità dei pixel, che solitamente corrispondono ai confini degli oggetti. Il rilevamento dei bordi aiuta nel riconoscimento delle forme e nella segmentazione.

### Rilevamento dei bordi con Sobel

L'operatore Sobel calcola i gradienti (variazioni di intensità) sia nella **direzione X che Y**, aiutando a rilevare bordi orizzontali e verticali.


### Rilevamento dei bordi con Canny

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

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

Introduzione completa alla computer vision, con particolare attenzione alla percezione e interpretazione automatica dei dati visivi. Include la pre-elaborazione delle immagini, l'estrazione delle caratteristiche, il rilevamento degli oggetti e le tecniche di deep learning utilizzate nei sistemi di visione moderni.

La computer vision consente alle macchine di interpretare e analizzare dati visivi, imitando la percezione umana. Questa sezione tratta le basi della rappresentazione delle immagini, dei modelli di colore e delle fondamenta matematiche essenziali per comprendere come i computer elaborano le immagini. Verranno esplorate applicazioni reali, dai veicoli autonomi all'imaging medico, e verrà illustrato come la computer vision si integri con l'AI e il machine learning.

OpenCV è una potente libreria per la manipolazione delle immagini e le attività di computer vision. Questa sezione tratta tecniche essenziali come il filtraggio delle immagini, le trasformazioni, il rilevamento dei bordi e la segmentazione. Verranno illustrate operazioni di sfocatura, thresholding, rilevamento dei contorni ed estrazione delle caratteristiche per migliorare e analizzare le immagini in modo efficiente.

Le CNN elaborano dati visivi utilizzando strati di convoluzione, pooling e attivazione per estrarre caratteristiche utili in compiti come la classificazione delle immagini e il rilevamento degli oggetti. I componenti chiave includono il padding, la convoluzione per l'estrazione delle caratteristiche, il pooling per la riduzione della complessità e l'attivazione per introdurre non linearità. Architetture popolari come AlexNet, VGG e ResNet alimentano l'IA nei settori sanitario, dell'autonomia e della sicurezza.

Il rilevamento oggetti è un compito fondamentale nella computer vision che consiste nell'identificare e localizzare oggetti all'interno di un'immagine. A differenza della classificazione delle immagini, che assegna un'unica etichetta all'intera immagine, il rilevamento oggetti non solo classifica gli oggetti ma ne determina anche le posizioni utilizzando riquadri di delimitazione. Questa sezione tratta le principali tecniche e algoritmi utilizzati nel rilevamento oggetti, dai metodi tradizionali agli approcci basati su deep learning come YOLO e U-Net.

La computer vision ha compiuto notevoli progressi nel corso degli anni, passando da metodi di elaborazione delle immagini di base a tecniche complesse di deep learning. Questa sezione approfondisce le ultime innovazioni nella computer vision, concentrandosi su transfer learning, riconoscimento facciale e generazione di immagini. Verranno esaminati i vantaggi dei modelli pre-addestrati sulle prestazioni, i principi della tecnologia di riconoscimento facciale e il modo in cui l'IA crea immagini tramite deep learning.

Rilevamento dei Bordi

Rilevamento dei bordi

Rilevamento dei bordi con Sobel

Rilevamento dei bordi con Canny