Vai al contenuto
ELECTRONICS ENGINEERINGelectronics-engineering.com
Python

Riconoscimento di oggetti in tempo reale su Raspberry Pi con YOLOv5 e OpenCV

Il riconoscimento di oggetti è un affascinante campo della visione artificiale che permette ai computer di identificare e localizzare oggetti in immagini o flussi video. Questo articolo ti guida nella configurazione…

https://www.electronics-engineering.com/it/riconoscimento-di-oggetti-in-tempo-reale-su-raspberry-pi-con-yolov5-e-opencv/

Ti è stata utile questa pagina? Votala:
media 5,0 su 1 voto
Riconoscimento di oggetti in tempo reale su Raspberry Pi con YOLOv5 e OpenCV

Il riconoscimento di oggetti è un affascinante campo della visione artificiale che permette ai computer di identificare e localizzare oggetti in immagini o flussi video. Questo articolo ti guida nella configurazione del riconoscimento di oggetti in tempo reale su un Raspberry Pi con YOLOv5 e OpenCV. Gestiremo anche in modo efficace gli avvisi e ci concentreremo sul riconoscimento di oggetti specifici come persone, auto, motociclette, autobus e camion all’interno di una regione di interesse (ROI) definita.

Prerequisiti

  1. Raspberry Pi: assicurati di avere un Raspberry Pi con accesso a Internet.
  2. Python: Python deve essere installato sul tuo sistema.
  3. OpenCV: installa OpenCV con pip install opencv-python.
  4. Torch: installa Torch con pip install torch.
  5. YOLOv5: useremo il modello YOLOv5 di Ultralytics.

Guida passo passo

1. Preparare l’ambiente

Per prima cosa, assicurati di avere installato i pacchetti Python necessari:

pip install opencv-python torch

2. Definire lo script di riconoscimento degli oggetti

Ecco lo script Python che acquisisce il video da un flusso RTSP, elabora ogni fotogramma per riconoscere gli oggetti e mostra i risultati con una regione di interesse (ROI). Abbiamo aggiunto anche dei passaggi per sopprimere gli avvisi indesiderati e ottimizzare le prestazioni.

import logging
import cv2
import torch
import time
import os

# Configure custom logger to capture only warnings related to HEVC codec
logging.basicConfig(level=logging.WARNING, format='%(levelname)s - %(message)s')
logger = logging.getLogger('HEVC_Warnings')
logger.setLevel(logging.WARNING)

# Load YOLOv5 model (small version for better performance on Raspberry Pi)
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)

# Define vehicle classes (YOLOv5 class indices for vehicles)
classes = [0, 2, 3, 5, 7]  # Indices for person, car, motorcycle, bus, and truck

# Access the RTSP stream
rtsp_url = "rtsp://<login>:<password>@<ip_address>:554/h264Preview_01_main"
cap = cv2.VideoCapture(rtsp_url)

# Define region of interest (ROI) coordinates (x, y, width, height)
roi_x, roi_y, roi_width, roi_height = 100, 100, 400, 300

def detect_and_signal(frame):
    results = model(frame)
    detections = results.xyxy[0]  # Extract detections

    vehicle_detected = False
    for *box, conf, cls in detections:
        if int(cls) in classes:
            vehicle_detected = True
            if int(cls) == 0:
                print("Person detected")
            elif int(cls) == 2:
                print("Car detected")
            elif int(cls) == 7:
                print("Truck detected")
            else:
                print("Other vehicle detected: " + cls)

            # Draw rectangle around ROI
            cv2.rectangle(frame, (roi_x, roi_y), (roi_x + roi_width, roi_y + roi_height), (255, 0, 0), 2)

            # Draw rectangle for visualization around detected object
            cv2.rectangle(frame, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), (0, 255, 0), 2)
            # Add class label and confidence score
            label = f'{model.names[int(cls)]} {conf:.2f}'
            cv2.putText(frame, label, (int(box[0]), int(box[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # Send signal if any vehicle is detected
    # GPIO.output(18, GPIO.HIGH if vehicle_detected else GPIO.LOW)

# Set skip factor (process every nth frame)
skip_factor = 50  # Process every 50th frame
frame_count = 0

# Redirect stderr to /dev/null to suppress warnings
os.environ['FFREPORT'] = 'file=/dev/null'

while True:
    ret, frame = cap.read()
    if not ret or frame is None:
        print("Failed to capture frame. Retrying...")
        continue

    # Skip frames
    if frame_count % skip_factor == 0:
        try:
            # Resize frame to reduce resolution
            frame_resized = cv2.resize(frame, (640, 480))
            # Draw square around the ROI
            cv2.rectangle(frame_resized, (roi_x, roi_y), (roi_x + roi_width, roi_y + roi_height), (255, 0, 0), 2)

            # Extract region of interest (ROI) from the frame
            roi = frame_resized[roi_y:roi_y + roi_height, roi_x:roi_x + roi_width]
            # Resize ROI for better performance
            roi_resized = cv2.resize(roi, (640, 480))
        except cv2.error as e:
            print(f"Error processing ROI: {e}")
            continue

        start_time = time.time()
        detect_and_signal(roi_resized)
        end_time = time.time()
        print(f"Frame processed in {end_time - start_time:.2f} seconds")

        # Display the processed frame with ROI and detections (for debugging)
        cv2.imshow('Frame', frame_resized)

    frame_count += 1

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
# GPIO.cleanup()

(Facoltativo) Altra ottimizzazione

se vogliamo ottimizzare ancora di più lo script, è possibile ridurre la risoluzione dell’immagine: per esempio 192×192 pixel e roi_x, roi_y, roi_width, roi_height = 50, 50, 100, 100

-> roi_x, roi_y, roi_width, roi_height = 50, 50, 100, 100
-> frame_resized = cv2.resize(frame, (192, 192))-> roi_resized = cv2.resize(roi, (192, 192))

Spiegazione

  1. Caricamento del modello: carichiamo il modello YOLOv5 con torch.hub.load. Il modello è impostato per riconoscere oggetti come persone, auto, motociclette, autobus e camion.
  2. Accesso al flusso RTSP: si accede al flusso video con cv2.VideoCapture di OpenCV.
  3. Regione di interesse (ROI): definiamo una regione specifica del fotogramma in cui vogliamo riconoscere gli oggetti.
  4. Salto dei fotogrammi: per ridurre il carico della CPU, elaboriamo un fotogramma ogni 50.
  5. Soppressione degli avvisi: reindirizziamo stderr su /dev/null per sopprimere gli avvisi del codec HEVC.
  6. Riconoscimento e annotazione degli oggetti: gli oggetti riconosciuti dentro la ROI vengono annotati e mostrati.
  7. Ottimizzazione delle prestazioni: il fotogramma viene ridimensionato prima dell’elaborazione per migliorare le prestazioni.

Prova

Conclusione

Questa configurazione permette di eseguire il riconoscimento di oggetti in tempo reale su un Raspberry Pi con un uso ottimizzato della CPU. Il codice elabora un fotogramma ogni 50 per ridurre il carico e si concentra su una ROI definita per un riconoscimento mirato. Seguendo questi passaggi puoi realizzare e ottimizzare in modo efficace il riconoscimento di oggetti per varie applicazioni.

Sentiti libero di modificare il codice per adattarlo alle tue esigenze specifiche, ad esempio regolando la ROI, il fattore di salto o le classi di oggetti riconosciuti. Buona programmazione!

Iscriviti
Notificami
guest
1 commento
Vecchi
Più recenti Le più votate
1
0
Esprimete la vostra opinione commentando.x