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/

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
- Raspberry Pi: assicurati di avere un Raspberry Pi con accesso a Internet.
- Python: Python deve essere installato sul tuo sistema.
- OpenCV: installa OpenCV con
pip install opencv-python. - Torch: installa Torch con
pip install torch. - 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 torch2. 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
- Caricamento del modello: carichiamo il modello YOLOv5 con
torch.hub.load. Il modello è impostato per riconoscere oggetti come persone, auto, motociclette, autobus e camion. - Accesso al flusso RTSP: si accede al flusso video con
cv2.VideoCapturedi OpenCV. - Regione di interesse (ROI): definiamo una regione specifica del fotogramma in cui vogliamo riconoscere gli oggetti.
- Salto dei fotogrammi: per ridurre il carico della CPU, elaboriamo un fotogramma ogni 50.
- Soppressione degli avvisi: reindirizziamo
stderrsu/dev/nullper sopprimere gli avvisi del codec HEVC. - Riconoscimento e annotazione degli oggetti: gli oggetti riconosciuti dentro la ROI vengono annotati e mostrati.
- 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!






Hi, I am the author of “Real-Time Object Detection on Raspberry Pi Using YOLOv5 and OpenCV”. Questions, doubts, error reports and requests for more detail are all welcome: write them below and I will answer. You can also rate the page with the stars at the top of the article.