OpenCV + YOLO : Détecte des objets avec l'IA en 20 minutes

Tu veux que ton ordi « voie » ce qu'il y a dans une image ? Identifier une voiture, un chien, une personne, une pizza — automatiquement, sans rien faire ? C'est exactement ce que permet YOLO, un modèle d'IA de détection d'objets qui tourne en temps réel. Dans ce tutoriel, tu vas apprendre à l'utiliser avec OpenCV, la bibliothèque star du traitement d'image. Résultat : en 20 minutes, ton PC voit le monde comme un humain. Et tout ça avec 20 lignes de Python.

Le problème : apprendre à une machine à « voir »

Nos yeux et notre cerveau font un travail incroyable : en une fraction de seconde, on identifie les objets autour de nous. Une voiture, un piéton, un feu rouge — tout ça est instantané. Mais comment apprendre ça à un ordinateur ?

Pendant longtemps, c'était un cauchemar. Il fallait des tonnes de code, des GPUs hors de prix, et un doctorat en computer vision. YOLO (You Only Look Once) a tout changé. C'est un modèle pré-entraîné capable de détecter 80 catégories d'objets en une seule passe, sur une image ou une vidéo, en temps réel. Et le meilleur ? Il tourne même sur un CPU basique.

OpenCV, de son côté, est la boîte à outils ultime pour manipuler des images en Python : charger une photo, dessiner des rectangles, afficher du texte, capturer la webcam… En combinant les deux, on obtient un système de vision par ordinateur accessible à tous.

💡 Idée d'illustration : Une photo de rue avec des personnes et des voitures, entourées de rectangles colorés avec des labels (« person 0.92 », « car 0.87 », « traffic light 0.95 »).

Étape 1 : Installer les outils

Ouvre un terminal et tape :

bash

# Installe OpenCV et ultralytics (la lib officielle YOLO)
pip install opencv-python ultralytics

Vérifie que tout est bien installé :

python

# test_install.py
import cv2
from ultralytics import YOLO

print(f"✅ OpenCV version : {cv2.__version__}")
print(f"✅ Ultralytics (YOLO) importé avec succès")

Lance le script :

bash

python3 test_install.py

Tu devrais voir :

plaintext

✅ OpenCV version : 4.11.0
✅ Ultralytics (YOLO) importé avec succès

🎉 Ce que tu viens d'accomplir : Les deux bibliothèques fondamentales de la vision par ordinateur sont prêtes. On passe à l'action.

Étape 2 : Ton premier détecteur d'objets (sur une image)

On va utiliser YOLOv8 nano — le modèle le plus léger, parfait pour démarrer. Voici le script complet :

python

# detecteur.py — Ton premier détecteur d'objets avec YOLO
from ultralytics import YOLO
import cv2

# 1. Charge YOLOv8 nano (le plus rapide, ~6 Mo seulement)
modele = YOLO("yolov8n.pt")  # téléchargé automatiquement au premier lancement

# 2. Fais la détection sur une image
image_path = "ma_photo.jpg"  # remplace par le chemin de TON image
resultats = modele(image_path)

# 3. Récupère l'image annotée et affiche-la
image_annotee = resultats[0].plot()  # plot() dessine les boîtes et labels

cv2.imshow("Objets détectés", image_annotee)
print("Appuie sur une touche pour fermer l'image...")
cv2.waitKey(0)  # attend qu'on appuie sur une touche
cv2.destroyAllWindows()

Teste avec une image du web

bash

# Télécharge une image d'exemple
python3 -c "
import urllib.request
urllib.request.urlretrieve('https://images.unsplash.com/photo-1441986300917-64674bd600d8?w=800', 'magasin.jpg')
print('✅ Image téléchargée : magasin.jpg')
"

# Lance la détection
python3 detecteur.py

Modifie image_path = "magasin.jpg" dans le script, ou passe directement le nom.

Ce que tu devrais voir : Une fenêtre s'ouvre avec l'image, et les objets sont entourés de rectangles colorés avec un label et un score de confiance (ex: « bottle 0.88 », « person 0.91 »).

🎉 Ce que tu viens d'accomplir : En 6 lignes de code effectives, ton PC analyse une image et te dit ce qu'elle contient. Magique, non ?

Étape 3 : Détection en temps réel avec ta webcam

Passons au niveau supérieur : la détection en direct. Ta webcam capture 30 images par seconde, et YOLO analyse chaque image en temps réel.

python

# webcam_detector.py — YOLO en direct depuis ta webcam
from ultralytics import YOLO
import cv2

# 1. Charge le modèle
modele = YOLO("yolov8n.pt")

# 2. Ouvre la webcam (0 = webcam par défaut, 1 = externe)
webcam = cv2.VideoCapture(0)

print("🎥 Webcam démarrée. Appuie sur 'q' pour quitter.")

while True:
    # 3. Capture une image de la webcam
    succes, image = webcam.read()
    if not succes:
        print("❌ Impossible de lire la webcam")
        break

    # 4. Lance YOLO sur l'image
    resultats = modele(image, verbose=False)

    # 5. Dessine les détections sur l'image
    image_annotee = resultats[0].plot()

    # 6. Affiche l'image dans une fenêtre
    cv2.imshow("Détection en direct (q = quitter)", image_annotee)

    # 7. Quitte si on appuie sur 'q'
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

# 8. Nettoie
webcam.release()
cv2.destroyAllWindows()
print("👋 À bientôt !")

Lance-le :

bash

python3 webcam_detector.py

Promène-toi devant ta webcam, montre des objets (une tasse, un livre, ton téléphone…). Tu verras les rectangles apparaître en temps réel !

🎉 Ce que tu viens d'accomplir : Un système de vision en temps réel, comme ceux utilisés dans les voitures autonomes ou les caméras de surveillance intelligentes.

Étape 4 : Compte les objets et exporte les résultats

Maintenant qu'on détecte, on peut exploiter ces données. Voici comment compter combien de personnes passent devant ta caméra :

python

# compteur.py — Compte les personnes détectées, exporte en JSON
from ultralytics import YOLO
import cv2, json, time
from collections import Counter

modele = YOLO("yolov8n.pt")
webcam = cv2.VideoCapture(0)

print("📊 Compteur d'objets démarré. Appuie sur 'q' pour arrêter.")

compteur_global = Counter()
derniere_analyse = time.time()

while True:
    succes, image = webcam.read()
    if not succes:
        break

    # Analyse toutes les 2 secondes pour éviter de saturer
    if time.time() - derniere_analyse > 2:
        resultats = modele(image, verbose=False)
        objets = resultats[0].boxes  # toutes les boîtes détectées

        # Compte par catégorie
        noms = [modele.names[int(b.cls)] for b in objets]
        compteur_local = Counter(noms)
        compteur_global.update(noms)

        # Affiche dans le terminal
        print(f"\n--- Analyse à {time.strftime('%H:%M:%S')} ---")
        for nom, nb in compteur_local.most_common():
            print(f"  {nom}: {nb}")
        print(f"  Total objets: {len(objets)}")

        derniere_analyse = time.time()

    # Affiche l'image
    image_annotee = resultats[0].plot() if resultats else image
    cv2.imshow("Compteur (q = quitter + export)", image_annotee)

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

# Sauvegarde en JSON
with open("stats_vision.json", "w") as f:
    json.dump(dict(compteur_global), f, indent=2, ensure_ascii=False)

print(f"\n📁 Stats sauvegardées dans stats_vision.json")
print(f"🏆 Top 5 : {compteur_global.most_common(5)}")

webcam.release()
cv2.destroyAllWindows()

🎉 Ce que tu viens d'accomplir : Tu ne fais plus que « voir », tu quantifies. Tu peux compter les clients dans un magasin, les voitures sur une route, les produits sur un tapis roulant.

Étape 5 : Interface web avec Streamlit (bonus pro)

Transforme tout ça en application web que tu peux partager :

python

# webapp_detector.py
import streamlit as st
from ultralytics import YOLO
import cv2, tempfile, os
from PIL import Image
import numpy as np

st.set_page_config(page_title="Détecteur d'Objets IA", page_icon="🔍")
st.title("🔍 Détecteur d'Objets IA")
st.caption("Upload une image, l'IA détecte tout ce qu'elle contient.")

@st.cache_resource
def charge_modele():
    return YOLO("yolov8n.pt")

modele = charge_modele()

fichier = st.file_uploader("📁 Choisis une image", type=["jpg", "jpeg", "png", "webp"])

if fichier:
    # Affiche l'original
    col1, col2 = st.columns(2)
    with col1:
        st.image(fichier, caption="Image originale", use_container_width=True)

    # Sauvegarde temporaire et détection
    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
        tmp.write(fichier.read())
        tmp_path = tmp.name

    with st.spinner("🤖 L'IA analyse l'image..."):
        resultats = modele(tmp_path)
        image_annotee = resultats[0].plot()
        # Convertit BGR (OpenCV) en RGB (PIL)
        image_rgb = cv2.cvtColor(image_annotee, cv2.COLOR_BGR2RGB)

    with col2:
        st.image(image_rgb, caption="Objets détectés", use_container_width=True)

    # Statistiques
    objets = resultats[0].boxes
    if len(objets) > 0:
        noms = [modele.names[int(b.cls)] for b in objets]
        confiances = [float(b.conf) for b in objets]

        st.success(f"✅ {len(objets)} objet(s) détecté(s) !")
        st.metric("Confiance moyenne", f"{sum(confiances)/len(confiances)*100:.1f}%")

        for nom, conf in zip(noms, confiances):
            st.write(f"- {nom} (confiance : {conf*100:.0f}%)")
    else:
        st.info("Aucun objet détecté dans cette image.")

    os.unlink(tmp_path)  # nettoie

Lance avec :

bash

streamlit run webapp_detector.py

Ouvre http://localhost:8501, upload une photo, et regarde l'IA travailler.

🎉 Ce que tu viens d'accomplir : Une application web complète de computer vision. Tu peux l'héberger gratuitement sur Streamlit Cloud et la partager avec le monde entier.

Pièges classiques (et comment les éviter)

❌ Piège 1 : « ModuleNotFoundError: No module named 'cv2' »

Pourquoi : OpenCV n'est pas installé. Solution :

bash

pip install opencv-python
# Si tu es sous Linux et que ça échoue :
pip install opencv-python-headless

❌ Piège 2 : « La webcam ne s'ouvre pas / erreur (-215) »

Pourquoi : Mauvais index de webcam, ou la webcam est utilisée par une autre application. Solution :

python

# Essaie différents index
for i in range(3):
    cap = cv2.VideoCapture(i)
    if cap.isOpened():
        print(f"✅ Webcam trouvée à l'index {i}")
        cap.release()

Sur Linux, vérifie aussi les permissions : ls -la /dev/video*

❌ Piège 3 : « La détection est trop lente, ça rame »

Pourquoi : Ton CPU galère avec le modèle par défaut. Solution : Utilise le modèle nano (yolov8n.pt) au lieu de small/medium/large. Tu peux aussi réduire la résolution :

python

webcam.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
webcam.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

❌ Piège 4 : « Les rectangles de détection clignotent dans tous les sens »

Pourquoi : YOLO détecte à chaque frame, et les boîtes varient légèrement. Solution : C'est normal. Pour du rendu propre, tu peux moyenner sur 3 frames ou utiliser un tracker comme BoTSORT (intégré dans YOLOv8) :

python

resultats = modele.track(image, persist=True, verbose=False)

❌ Piège 5 : « cv2.imshow() ne marche pas sur mon serveur headless / Docker »

Pourquoi : Pas de serveur X11 (interface graphique). Solution : Installe opencv-python-headless, ou sauvegarde l'image au lieu de l'afficher :

python

cv2.imwrite("resultat.jpg", image_annotee)

Pour aller plus loin

1. Entraîne YOLO sur tes propres objets

Tu veux détecter des pièces mécaniques, des fruits spécifiques, ou tes propres produits ? Avec aussi peu que 50 images annotées, tu peux fine-tuner YOLO :

bash

# Prépare tes données au format YOLO (un dossier images/ et labels/)
# Puis lance l'entraînement :
yolo train data=mon_dataset.yaml model=yolov8n.pt epochs=50 imgsz=640

En 30 minutes sur un GPU gratuit (Google Colab), ton modèle personnalisé est prêt.

2. Ajoute un système d'alerte

Détecte un événement et déclenche une action. Par exemple, envoie un email quand ta webcam voit un colis devant ta porte :

python

if "person" in noms and "backpack" in noms:
    print("📦 Colis détecté devant la porte !")
    # envoie une notification Telegram, un email, etc.

3. Utilise YOLOv8 sur Raspberry Pi

Oui, ça tourne sur un Raspberry Pi 4 ou 5 ! Utilise le modèle yolov8n (nano), réduis la résolution à 320×240, et tu as un détecteur d'objets autonome à 50 €. Parfait pour un projet domotique.

Ce que tu as appris aujourd'hui

En 20 minutes, tu as : - ✅ Installé OpenCV et YOLO sur ta machine - ✅ Détecté des objets sur une image fixe en 6 lignes de code - ✅ Créé un détecteur en temps réel via ta webcam - ✅ Compté et exporté les statistiques de détection en JSON - ✅ Construit une interface web complète avec Streamlit - ✅ Appris les pièges classiques et les pistes pour aller plus loin

La computer vision n'est plus réservée aux labos de recherche. Avec YOLO et OpenCV, tu as entre les mains le même type de technologie que les voitures autonomes, les caisses automatiques de supermarché, et les systèmes de surveillance intelligents.

Alors, qu'est-ce que ton PC va « voir » aujourd'hui ? 👀