Description de l'implémentation de la détection et le comptage des abeilles¶

Détection des abeilles¶

La détection a été faite en Python avec les flux vidéo que j'ai créé avec mon application de simulateur

Voici les différentes méthodes que j'ai pu utiliser.

Méthode manuelle de détection¶

Pour tenter de détecter les abeilles dans un flux vidéo, j'ai initialement utilisé la bibliothèque OpenCV pour effectuer le traitement des images. Voici les étapes que j'ai suivies :

Étape 1: application du filtre de Canny ¶

J'ai commencé par appliquer un filtre de Canny pour détecter les contours des abeilles dans les images. Cette étape permet de mettre en évidence les bords des objets présents dans l'image.

Figure 89 — Filtre de Canny sur les abeilles

Étape 2: détection des contours¶

Ensuite, j'ai procédé à la détection des contours des objets dans l'image. Cette étape permet d'identifier les formes des abeilles à partir des contours détectés.

Conclusion¶

Bien que cette méthode permette de détecter les objets saillants dans l'image, elle présente des limites. Elle ne fonctionne efficacement que lorsque l'arrière-plan est uniforme et ne permet pas de distinguer clairement si un objet unique ou plusieurs objets se trouvent dans une même zone. Par conséquent, j'ai exploré une alternative plus performante.

Algorithme de détection (YOLOv8)¶

J'ai opté pour l'utilisation de l'algorithme de détection YOLOv8 en raison de sa précision et de sa performance. Pour former le modèle, j'ai utilisé un ensemble de données disponible sur cette plateforme, qui comprenait une grande quantité d'images.

Après avoir créé le modèle YOLOv8, j'ai exécuté la commande suivante pour l'entraîner :

yolo detect train data="./bee-gen-4/data.yaml" epochs=100 imgsz=640

Le modèle entraîné a été exporté et se trouve dans le répertoire runs/detect/train/weights/best.pt.

Info

Cette opération a nécessité l'utilisation d'un ordinateur puissant et environ 30 minutes de temps de calcul.

Traitement d'un flux vidéo (MP4)¶

Pour tester l'algorithme de détection avec un flux vidéo, j'ai écrit un script en Python. J'ai dû ajuster le traitement pour ne traiter qu'une image sur quatre afin de maintenir la fluidité de la vidéo.

Warning

Ce script ne fonctionne pas sous l'environnement WSL (Windows Subsystem for Linux), aucune sortie visuelle n'est générée.

Voici le script Python utilisé :

import cv2
from ultralytics import YOLO

# Charger votre modèle personnalisé
model = YOLO('./best.pt')  

# Ouvrir le fichier vidéo
cap = cv2.VideoCapture('record.mp4')

# Vérifier si la vidéo a été ouverte avec succès
if not cap.isOpened():
    print("Erreur : Impossible d'ouvrir la vidéo.")
    exit()

img_count = 0

while True:
    # Capturer frame par frame
    ret, frame = cap.read()

    # Si la frame n'a pas été récupérée correctement, sortir de la boucle
    if not ret:
        break

    # Effectuer une inférence sur la frame
    if img_count % 4 == 0:
        results = model(frame, stream_buffer=True)

        # Récupérer la frame annotée
        annotated_frame = results[0].plot()  # .plot() retourne un tableau numpy qui peut être affiché avec OpenCV

        # Afficher la frame résultante
        cv2.imshow('Inférence YOLOv8', annotated_frame)

    # Appuyer sur 'q' sur le clavier pour sortir de la boucle
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    img_count += 1

# Lorsque tout est terminé, libérer l'objet de capture vidéo
cap.release()

# Fermer toutes les fenêtres OpenCV
cv2.destroyAllWindows()

Ce script utilise le modèle YOLOv8 pour effectuer une inférence sur chaque image du flux vidéo, affichant les résultats en temps réel avec OpenCV.

Voici le résultat :

Figure 91 — Détection des abeilles avec YOLOv8

Comptages des abeilles¶

Le comptage des abeilles se fait en plusieurs étapes, impliquant la détection, le suivi et l'analyse des mouvements des abeilles. Voici une explication détaillée de chaque étape avec des références aux parties spécifiques du code.

Traitement des frames et détection des abeilles¶

Chaque frame de la vidéo est traitée pour détecter les abeilles et suivre leurs mouvements :

while True:
    ret, frame = cap.read()
    if not ret:
        break

    annotated_frame = frame.copy()

    cv2.line(annotated_frame, (0, barre_haut), (frame.shape[1], barre_haut), COLOR_GREEN, 2)
    cv2.line(annotated_frame, (0, barre_bas), (frame.shape[1], barre_bas), COLOR_RED, 2)

    if img_count % 4 == 0:
        detections = model.track(frame, persist=True)

        for detection in detections:
            for box in detection.boxes:
                if box.id is not None:
                    id = str(box.id).split("[")[1].split(".")[0]
                    x1, y1, x2, y2 = box.xyxy[0]
                    cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                    cv2.putText(annotated_frame, str(id), (cx + 10, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLOR_RED, 2)

                    tracker = next((t for t in trackers if t['tracker'] == int(id)), None)
                    if tracker is None:
                        tracker = {'tracker': int(id), 'touchTopBarre': False, 'touchBottomBarre': False, 'firstTouchBarre': 'none', 'addData': False}
                        trackers.append(tracker)

Chaque frame est copiée pour être annotée avec des informations supplémentaires.
Les barres horizontales sont dessinées sur la frame annotée.
Les frames sont traitées toutes les quatre frames pour des raisons de performance (img_count % 4 == 0).
Le modèle YOLO effectue une détection d'objets sur la frame actuelle (model.track(frame, persist=True)).
Pour chaque détection, un ID unique est attribué à l'abeille, et son centre est calculé.
Un tracker est créé ou mis à jour pour chaque abeille détectée, permettant de suivre son passage à travers les barres.

Suivi et comptage des abeilles¶

Le suivi des abeilles se fait en vérifiant leur position par rapport aux barres et en mettant à jour les compteurs en conséquence :

if cy < barre_haut:
    tracker['touchTopBarre'] = True
    color = COLOR_GREEN
    if tracker['firstTouchBarre'] == 'none':
        tracker['firstTouchBarre'] = 'top'
elif cy > barre_bas:
    tracker['touchBottomBarre'] = True
    color = COLOR_RED
    if tracker['firstTouchBarre'] == 'none':
        tracker['firstTouchBarre'] = 'bottom'
else:
    color = COLOR_BLUE

if tracker['touchTopBarre'] and tracker['touchBottomBarre'] and not tracker['addData']:
    if tracker['firstTouchBarre'] == 'bottom':
        abeilles_qui_sortent += 1
        tracker['addData'] = True
    elif tracker['firstTouchBarre'] == 'top':
        abeilles_qui_rentrent += 1
        tracker['addData'] = True

cv2.circle(annotated_frame, (cx, cy), 5, color, -1)

La position de chaque abeille est vérifiée par rapport aux barres (barre_haut et barre_bas).
Si l'abeille est au-dessus de barre_haut, elle est marquée comme ayant touché la barre supérieure.
Si l'abeille est en dessous de barre_bas, elle est marquée comme ayant touché la barre inférieure.
Si une abeille a touché les deux barres et n'a pas encore été comptée (not tracker['addData']), le programme vérifie quelle barre a été touchée en premier pour déterminer si l'abeille est entrante ou sortante.
Le compteur correspondant (abeilles_qui_sortent ou abeilles_qui_rentrent) est incrémenté en conséquence.
Un point coloré est dessiné au centre de l'abeille pour indiquer son état (vert pour sortante, rouge pour entrante, bleu pour intermédiaire).

Affichage des compteurs et frame annotée¶

Les compteurs sont affichés sur la frame annotée pour une visualisation en temps réel :

cv2.putText(annotated_frame, f'Sorties: {abeilles_qui_sortent}', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, COLOR_GREEN, 2)
cv2.putText(annotated_frame, f'Entrees: {abeilles_qui_rentrent}', (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, COLOR_RED, 2)

cv2.imshow('Inférence YOLOv8', annotated_frame)

Les compteurs abeilles_qui_sortent et abeilles_qui_rentrent sont affichés en haut à gauche de la frame annotée.
La frame annotée est affichée dans une fenêtre pour permettre à l'utilisateur de voir les résultats en temps réel.