Migliorare le applicazioni di computer vision con le visualizzazioni

Passo 1: Impostazione dell'ambiente

Una volta scelto l'ambiente che preferisci, il passo successivo è quello di configurarlo per eseguire le previsioni e visualizzare i risultati. Puoi utilizzare uno qualsiasi degli ambienti sopra citati, a seconda di quello con cui ti trovi più a tuo agio.

Se stai lavorando in Google Colab, tieni presente che per impostazione predefinita utilizza una CPU , il che può rallentare le prestazioni. Per accelerare le cose, passa a una GPU andando nel menu "Runtime", selezionando "Cambia tipo di runtime" e impostando l'acceleratore hardware su GPU (idealmente un T4).

Per preparare il tuo ambiente, dovrai installare il pacchettoUltralytics Python utilizzando il comando indicato di seguito. Negli strumenti basati su notebook come Colab o Jupyter, assicurati di aggiungere un punto esclamativo (!) prima del comando.

pip install ultralytics

‍

Passo 2: Scaricare un file video

Poi avremo bisogno di un video con cui lavorare. Puoi scaricarne facilmente uno da un sito di stock gratuiti come Pexels. Assicurati di scegliere un video che includa oggetti che YOLO11 è in grado di riconoscere. Poiché il modello è stato preaddestrato sul set di dati COCO, è in grado di riconoscere oggetti comuni come persone, automobili e biciclette. 

Per questo tutorial utilizzeremo un video sulla gestione dei bagagli in un affollato terminal aeroportuale. Puoi utilizzare lo stesso video o sceglierne uno diverso che si adatti al tuo progetto.

‍

Passo 3: Importare i pacchetti

Successivamente, possiamo importare le librerie necessarie e caricare il video in ingresso.

Inizieremo importando OpenCV (cv2), una libreria molto utilizzata per lavorare con immagini e video nella computer vision. Importeremo anche la libreria Ultralytics , che ci aiuta a eseguire il rilevamento degli oggetti e a generare analisi dal video.

Quindi, cercheremo di aprire il file video specificando il suo percorso. Assicurati di sostituire "path/to/video.mp4" con la posizione effettiva del file video scaricato. 

Inoltre, il frammento di codice qui sotto include un semplice controllo per assicurarsi che il video venga caricato correttamente. Se il percorso è sbagliato o il file è danneggiato, il programma si arresta e mostra un messaggio di errore: "Errore nella lettura del file video".

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"

‍

Fase 4: preparazione del video writer

Quindi, imposteremo un video writer per salvare l'output. Quando eseguiamo l'analisi, questa parte del codice creerà un nuovo file video che registra i grafici aggiornati generati da ogni fotogramma del video originale.

Nel frammento di codice qui sotto, per prima cosa estraiamo le proprietà chiave dal video in ingresso: la larghezza, l'altezza e i fotogrammi al secondo (fps). Questi valori vengono presi direttamente dal video e convertiti in numeri interi per garantire che siano nel formato corretto per la scrittura dell'output.

Successivamente, utilizziamo la funzione cv2.VideoWriter per creare un nuovo file video, chiamato "analytics_output.avi" (puoi rinominarlo come vuoi). Il video viene salvato utilizzando il formato MJPG, un comune metodo di compressione video. La risoluzione di uscita è impostata a 1280×720 pixel, indipendentemente dalle dimensioni del video originale.

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter(
    "analytics_output.avi",
    cv2.VideoWriter_fourcc(*"MJPG"),
    fps,
    (1280, 720), 
)

‍

Passo 5: Configurazione della soluzione Ultralytics Analytics

Ora configureremo la soluzione Ultralytics Analytics per generare grafici dal video. Puoi scegliere come visualizzare i dati, ad esempio un grafico a linee, a torta, ad area o a barre, e quale modelloYOLO utilizzare. In questo esempio, utilizzeremo il modello leggero "yolo11n.pt" e mostreremo i risultati come un grafico ad area.

analytics = solutions.Analytics(
    show=True, 
    analytics_type="area", 
    model="yolo11n.pt",   
)

‍

Fase 6: Elaborazione del video in ingresso

La parte finale del codice esegue un ciclo che elabora il video un fotogramma alla volta. Ogni fotogramma viene passato allo strumento di analisi, che aggiorna il grafico in tempo reale. Il grafico aggiornato viene poi scritto sul video di uscita. Se un fotogramma non può essere letto, il ciclo si ferma. Dopo aver elaborato tutti i fotogrammi, il video viene salvato e le finestre aperte vengono chiuse.

frame_count = 0
while cap.isOpened():
    success, im0 = cap.read()
    if success:
        frame_count += 1
        results = analytics(im0, frame_count) 

        out.write(results.plot_im) 
    else:
        break
cap.release()
out.release()
cv2.destroyAllWindows() 

‍

Passo 7: Mettere tutto insieme

Infine, mettiamo tutto insieme. Con poche righe di codice in più, possiamo generare due video di output: uno che mostra i risultati delrilevamento degli oggetti YOLO11 con bounding box ed etichette e un altro che mostra i grafici delle analisi in tempo reale.

Per farlo, creeremo due istanze di VideoWriter: una per salvare il video di previsione e un'altra per le analisi. Questa versione del codice include sia il tracciamento degli oggetti che la generazione di grafici, in modo da poter vedere i risultati del rilevamento insieme agli approfondimenti visivi.

Ecco il codice completo e alcuni esempi di previsioni e analisi.

import cv2
from ultralytics import YOLO, solutions

# Load model and video
model = YOLO('yolo11n.pt')
cap = cv2.VideoCapture('path/to/video.mp4')
assert cap.isOpened(), "Error opening video"

# Get properties
w, h = int(cap.get(3)), int(cap.get(4))
fps = cap.get(5)
analytics_res = (1280, 720)

# Writers for prediction and analytics videos
out_pred = cv2.VideoWriter('output_predictions.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
out_ana = cv2.VideoWriter('output_analytics.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, analytics_res)

# Analytics setup
analytics = solutions.Analytics(show=True, analytics_type="area", model='yolo11n.pt')

# Process frames
frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    pred_frame = model.track(frame, persist=True)[0].plot()
    out_pred.write(pred_frame)

    resized = cv2.resize(pred_frame, analytics_res)
    out_ana.write(analytics(resized, frame_count).plot_im)

cap.release(), out_pred.release(), out_ana.release(), cv2.destroyAllWindows()

‍

Quando il codice di cui sopra viene eseguito correttamente, genera due video di output. Il file "output_predictions.avi" mostrerà i risultati del rilevamento degli oggetti con bounding box ed etichette, mentre "output_analytics.avi" mostrerà i grafici di analisi in tempo reale basati sui rilevamenti.

‍

Ecco un fotogramma dell'output analitico basato sulle previsioni. Utilizzando il grafico ad area, possiamo ottenere informazioni come le fluttuazioni nel conteggio delle valigie nel tempo, come ad esempio un picco intorno al fotogramma 268, che indica il movimento o l'attività delle valigie in quella parte del video.

‍