black_grayscale_line_following.py

# Ce travail est publié sous licence MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Tous droits réservés.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Exemple de suivi de ligne noire en niveaux de gris
#
# Créer un robot suiveur de ligne demande beaucoup d'efforts. Ce script d'exemple
# montre comment réaliser la partie vision artificielle du robot suiveur de ligne. Vous
# pouvez utiliser la sortie de ce script pour piloter un robot à entraînement différentiel afin de
# suivre une ligne. Ce script génère simplement une valeur de virage unique qui indique
# à votre robot d'aller à gauche ou à droite.
#
# Pour que ce script fonctionne correctement, vous devez pointer la caméra vers une ligne avec un
# angle d'environ 45 degrés. Veillez à ce que seule la ligne soit dans le
# champ de vision de la caméra.

import csi
import time
import math

# Suit une ligne noire. Utilisez [(128, 255)] pour suivre une ligne blanche.
GRAYSCALE_THRESHOLD = [(0, 64)]

# Chaque roi est (x, y, w, h). L'algorithme de détection de ligne essaiera de trouver le
# centroïde du plus grand blob dans chaque roi. La position x des centroïdes
# sera ensuite moyennée avec des poids différents où le plus grand poids est attribué
# au roi près du bas de l'image et un poids moindre au roi suivant, et ainsi de suite.
ROIS = [  # [ROI, poids]
    (0, 100, 160, 20, 0.7),  # Vous devrez ajuster les poids pour votre application
    (0, 50, 160, 20, 0.3),  # en fonction de la configuration de votre robot.
    (0, 0, 160, 20, 0.1),
]

# Calcule le diviseur de poids (nous calculons cela pour que vous n'ayez pas à faire en sorte que les poids totalisent 1).
weight_sum = 0
for r in ROIS:
    weight_sum += r[4]  # r[4] est le poids du roi.

# Configuration de la caméra...
csi0 = csi.CSI()
csi0.reset()  # Initialiser le capteur de la caméra.
csi0.pixformat(csi.GRAYSCALE)  # utiliser les niveaux de gris.
csi0.framesize(csi.QQVGA)  # utiliser QQVGA pour la vitesse.
csi0.snapshot(time=2000)  # Laisser les nouveaux réglages prendre effet.
csi0.auto_gain(False)  # doit être désactivé pour le suivi de couleur
csi0.auto_whitebal(False)  # doit être désactivé pour le suivi de couleur
clock = time.clock()  # Suit le FPS.

while True:
    clock.tick()  # Suivre les millisecondes écoulées entre les snapshots().
    img = csi0.snapshot()  # Prendre une photo et renvoyer l'image.

    centroid_sum = 0

    for r in ROIS:
        blobs = img.find_blobs(
            GRAYSCALE_THRESHOLD, roi=r[0:4], merge=True
        )  # r[0:4] est le tuple du roi.

        if blobs:
            # Trouve le blob ayant le plus de pixels.
            largest_blob = max(blobs, key=lambda b: b.pixels)

            # Dessine un rectangle autour du blob.
            img.draw_detection(largest_blob)

            centroid_sum += largest_blob.cx * r[4]  # r[4] est le poids du roi.

    center_pos = centroid_sum / weight_sum  # Détermine le centre de la ligne.

    # Convertit la center_pos en angle de déviation. Nous utilisons une opération
    # non linéaire afin que la réponse devienne plus forte à mesure que nous nous
    # éloignons de la ligne. Les opérations non linéaires sont utiles à appliquer sur la sortie
    # d'algorithmes comme celui-ci pour provoquer une réponse de type "déclencheur".
    deflection_angle = 0

    # Le 80 provient de la moitié de la résolution X, le 60 provient de la moitié de la résolution Y.
    # L'équation ci-dessous calcule simplement l'angle d'un triangle dont
    # le côté opposé du triangle est l'écart de la position centrale
    # par rapport au centre et le côté adjacent est la moitié de la résolution Y. Cela limite
    # l'angle de sortie à environ -45 à 45. (Ce n'est pas tout à fait -45 et 45).
    deflection_angle = -math.atan((center_pos - 80) / 60)

    # Convertit l'angle en radians en degrés.
    deflection_angle = math.degrees(deflection_angle)

    # Vous obtenez maintenant un angle indiquant de combien tourner le robot, qui
    # intègre la partie de la ligne la plus proche du robot et les parties de
    # la ligne plus éloignées du robot pour une meilleure prédiction.
    print("Turn Angle: %f" % deflection_angle)

    print(clock.fps())  # Remarque : votre OpenMV Cam fonctionne environ deux fois moins vite lorsqu'elle est
    # connectée à votre ordinateur. Le nombre d'images par seconde (FPS) devrait augmenter une fois déconnectée.