Détection d'objets 3D (3D Bounding Boxes) en Python avec MediaPipe Objectron

Introduction

La détection d'objets prend de l'ampleur et des améliorations sont apportées à plusieurs approches pour la résoudre. Au cours des deux dernières années, les méthodes basées sur YOLO ont surpassé les autres en termes de précision et de rapidité, avec des avancées récentes telles que YOLOv7 et YOLOv6 (qui ont été publiées indépendamment, après YOLOv7).

Cependant – tout cela est préoccupant Détection d'objets 2D, ce qui est une tâche difficile en soi. Récemment, nous avons pu réaliser avec succès Détection d'objets 3D, et bien que ces détecteurs soient encore à un stade plus instable que les détecteurs d’objets 2D, leur précision augmente.

Dans ce guide, nous effectuerons la détection d'objets 3D en Python avec Objectron de MediaPipe.

Remarque: MediaPipe est le framework open source de Google permettant de créer des pipelines d'apprentissage automatique pour traiter des images, des vidéos et des flux audio, principalement pour les appareils mobiles. Il est utilisé à la fois en interne et en externe et fournit des modèles pré-entraînés pour diverses tâches, telles que la détection de visage, le maillage de visage, l'estimation de main et de pose, la segmentation des cheveux, la détection d'objets, le suivi de boîtes, etc.

Tous ces éléments peuvent et sont utilisés pour des tâches en aval, telles que l'application de filtres sur les visages, la mise au point automatisée de la caméra, la vérification biométrique, la robotique contrôlée manuellement, etc. La plupart des projets sont disponibles avec des API pour Android, iOS, C++, Python et JavaScript, tandis que certains ne sont disponibles que pour certaines langues.

Dans ce guide, nous travaillerons avec Objectron de MediaPipe, disponible pour Android, C++, Python et JavaScript.

MediaPipe et détection d'objets 3D

Les Objetron la solution a été formée sur le Ensemble de données Objectron, qui contient de courtes vidéos centrées sur les objets. Le jeu de données ne contient que 9 objets : vélos, livres, bouteilles, appareils photo, boîtes de céréales, chaises, tasses, ordinateurs portables et chaussures, ce n'est donc pas un jeu de données très général, mais le traitement et l'approvisionnement de ces vidéos sont assez coûteux (poses de caméra, rares nuages ​​de points, caractérisation des surfaces planaires, etc. pour chaque image de chaque vidéo), ce qui fait que l'ensemble de données fait près de 2 téraoctets.

Le modèle Objectron entraîné (connu sous le nom de sur mesure pour les projets MediaPipe) est formé sur quatre catégories : chaussures, chaises, tasses et appareils photo.

La détection d'objets 2D utilise le terme « boîtes englobantes », alors qu'il s'agit en réalité de rectangles. La détection d'objets 3D prédit réellement boîtes autour des objets, à partir desquels vous pouvez déduire leur orientation, leur taille, leur volume approximatif, etc. C'est une tâche assez difficile à entreprendre, surtout compte tenu du manque d'ensembles de données appropriés et du coût de leur création. Bien que difficile, le problème est prometteur pour divers Vuforia applications!

La solution Objectron peut fonctionner en mode à une ou deux étapes : le mode à une étape est plus efficace pour détecter plusieurs objets, tandis que le mode à deux étapes est plus efficace pour détecter un seul objet principal dans la scène et fonctionne de manière significative. plus rapide. Le pipeline en une seule étape utilise un backbone MobileNetV2, tandis que le pipeline en deux étapes utilise l'API de détection d'objets TensorFlow.

Lorsqu'un objet est détecté dans une vidéo, aucune prédiction supplémentaire n'est effectuée sur chaque image pour deux raisons :

• Les prédictions continues introduisent une grande instabilité (en raison de la stochasticité inhérente aux prédictions)
• Il est coûteux d'exécuter de grands modèles sur chaque image

L'équipe confie les prédictions lourdes aux premières rencontres uniquement, puis suit cette boîte tant que l'objet en question est toujours dans la scène. Une fois la ligne de mire interrompue et l’objet réintroduit, une prédiction est à nouveau effectuée. Cela permet d'utiliser des modèles plus grands avec une plus grande précision, tout en maintenant les exigences de calcul faibles, et réduit les exigences matérielles pour l'inférence en temps réel !

Allons-y et installons MediaPipe, importons la solution Objectron et appliquons-la à des images statiques et à un flux vidéo provenant directement d'une caméra.

Installation de MediaPipe

Commençons par installer MediaPipe et préparons une méthode d'assistance pour récupérer des images à partir d'une URL donnée :

! pip install mediapipe

Une fois le framework installé, importons-le avec les bibliothèques communes :

import mediapipe as mp

import cv2
import numpy as np
import matplotlib.pyplot as plt

Définissons une méthode d'assistance pour récupérer des images à partir d'une URL et qui renvoie un tableau RVB représentant cette image :

import PIL
import urllib

def url_to_array(url):
    req = urllib.request.urlopen(url)
    arr = np.array(bytearray(req.read()), dtype=np.int8)
    arr = cv2.imdecode(arr, -1)
    arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
    return arr

mug = 'https://goodstock.photos/wp-content/uploads/2018/01/Laptop-Coffee-Mug-on-Table.jpg'
mug = url_to_array(mug)

Enfin, nous souhaiterons importer à la fois la solution Objectron et les utilitaires de dessin pour visualiser les prédictions :

mp_objectron = mp.solutions.objectron
mp_drawing = mp.solutions.drawing_utils

Détection d'objets 3D sur des images statiques avec MediaPipe

Les Objectron La classe autorise plusieurs arguments, notamment :

• static_image_mode: Que vous alimentiez une image ou un flux d'images (vidéo)
• max_num_objects: Le nombre maximum d'objets identifiables
• min_detection_confidence: Le seuil de confiance de détection (à quel point le réseau doit être sûr pour classer un objet pour la classe donnée)
• model_name: Quel modèle vous souhaitez charger entre les deux 'Cup', 'Shoe', 'Camera' ainsi que le 'Chair'.

En gardant cela à l’esprit – instancions une instance Objectron et process() l'image d'entrée :

objectron = mp_objectron.Objectron(
    static_image_mode=True,
    max_num_objects=5,
    min_detection_confidence=0.2,
    model_name='Cup')


results = objectron.process(mug)

Les results contiennent les repères 2D et 3D du ou des objets détectés ainsi que la rotation, la translation et l'échelle de chacun. Nous pouvons traiter les résultats et dessiner les cadres de délimitation assez facilement à l'aide des utilitaires de dessin fournis :

if not results.detected_objects:
    print(f'No box landmarks detected.')


annotated_image = mug.copy()
for detected_object in results.detected_objects:
    
    mp_drawing.draw_landmarks(annotated_image, 
                              detected_object.landmarks_2d, 
                              mp_objectron.BOX_CONNECTIONS)

    
    mp_drawing.draw_axis(annotated_image, 
                         detected_object.rotation, 
                         detected_object.translation)
  

fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(annotated_image)
ax.axis('off')
plt.show()

Cela se traduit par:

Détection d'objets 3D à partir d'une vidéo ou d'une webcam avec MediaPipe

Une application plus intéressante concerne les vidéos ! Vous n'avez pas besoin de beaucoup modifier le code pour accueillir des vidéos, que vous en fournissiez une à partir de la webcam ou un fichier vidéo existant. OpenCV est un choix naturel pour lire, manipuler et insérer des images vidéo dans le modèle Objectron :

cap = cv2.VideoCapture(0)



objectron = mp_objectron.Objectron(static_image_mode=False,
                            max_num_objects=5,
                            min_detection_confidence=0.4,
                            min_tracking_confidence=0.70,
                            model_name='Cup')
                            

while cap.isOpened():
    success, image = cap.read()

    image.flags.writeable = False
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    results = objectron.process(image)

    image.flags.writeable = True
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    if results.detected_objects:
        for detected_object in results.detected_objects:
            
            mp_drawing.draw_landmarks(image, 
                                      detected_object.landmarks_2d, 
                                      mp_objectron.BOX_CONNECTIONS)
            
            mp_drawing.draw_axis(image, 
                                 detected_object.rotation,
                                 detected_object.translation)

    cv2.imshow('MediaPipe Objectron', cv2.flip(image, 1))
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Rendre l'image non inscriptible avec image.flags.writeable = False rend le processus un peu plus rapide et constitue un changement facultatif. Le final cv2.flip() sur l’image résultante est également facultatif – et rend simplement la sortie en miroir pour la rendre un peu plus intuitive.

Lorsqu'il est exécuté sur un appareil photo et une tasse Ikea courante dans le monde entier, voici les résultats :

La sortie est légèrement instable, mais gère bien la translation rotationnelle, même avec une main tremblante tenant la caméra basse résolution. Que se passe-t-il lorsqu'un objet est sorti du cadre ?

Les prédictions s'arrêtent pour l'objet à la première détection, et le suivi de boîte détecte clairement que l'objet a quitté le cadre et effectue à nouveau la prédiction et le suivi dès que l'objet rentre dans le cadre. Il semble que le suivi fonctionne un peu mieux lorsque le modèle peut voir le poignée de tasse, car les sorties sont plus instables lorsque la poignée n'est pas visible (probablement parce qu'il est plus difficile de déterminer avec précision la véritable orientation de la tasse).

De plus, certains angles semblent produire des sorties nettement plus stables que d’autres, dans des conditions d’éclairage difficiles. Pour les tasses en particulier, il est utile de pouvoir voir le rebord de la tasse car cela facilite la perspective, plutôt que de voir une projection orthogonale de l'objet.

De plus, lors des tests sur une tasse transparente, le modèle a eu des difficultés à déterminer qu'il s'agissait bien d'une tasse. Il s'agit probablement d'un exemple de hors distribution objet, car la plupart des tasses sont opaques et ont différentes couleurs.

Conclusion

La détection d'objets 3D est encore un peu jeune, et Objectron de MediaPipe en est une démonstration performante ! Bien que sensible aux conditions d’éclairage, aux types d’objets (tasses transparentes ou opaques, etc.) et légèrement instable, Objectron donne un bon aperçu de ce qui sera bientôt possible de faire avec une précision et une accessibilité plus élevées que jamais.