Comment convertir des ImageFrames et des GpuBuffers
Les calculateurs ImageFrameToGpuBufferCalculator et GpuBufferToImageFrameCalculator effectuent des allers-retours entre des paquets de type ImageFrame et GpuBuffer. ImageFrame fait référence aux données d'image présentes dans la mémoire du processeur dans l'un des nombreux formats d'image bitmap. GpuBuffer fait référence aux données d'image dans la mémoire GPU. Pour en savoir plus, consultez la section Concepts de framework : GpuBuffer to ImageFrame Converters. Vous pouvez consulter un exemple dans:
Visualiser les résultats de perception
Le AnnotationOverlayCalculator permet de superposer les résultats de perception, tels que les cadres de délimitation, les flèches et les ovales, sur les images vidéo alignées sur les objets reconnus. Les résultats peuvent être affichés dans une fenêtre de diagnostic lors de l'exécution sur un poste de travail ou dans un cadre de texture lors de l'exécution sur l'appareil. Vous trouverez un exemple d'utilisation de AnnotationOverlayCalculator dans les sections suivantes:
Exécuter des calculatrices en parallèle
Dans le graphique d'une calculatrice, MediaPipe exécute régulièrement des nœuds de calcul distincts en parallèle. MediaPipe gère un pool de threads et exécute chaque calculatrice dès qu'un thread est disponible et que toutes ses entrées sont prêtes. Chaque instance de calculateur n'est exécutée que pour un ensemble d'entrées à la fois. La plupart des calculateurs doivent donc être compatibles avec les threads et non compatibles avec les threads.
Pour permettre à un même simulateur de traiter plusieurs entrées en parallèle, il existe deux approches:
- Définissez plusieurs nœuds de calculateur et distribuez les paquets d'entrée à tous les nœuds.
- Rendez la calculatrice thread-safe et configurez son paramètre
max_in_flight.
La première approche peut être suivie à l'aide des calculateurs conçus pour répartir les paquets entre d'autres calculateurs, tels que RoundRobinDemuxCalculator. Une même RoundRobinDemuxCalculator peut distribuer des paquets successifs sur plusieurs nœuds ScaleImageCalculator configurés de manière identique.
La deuxième approche permet d'appeler jusqu'à max_in_flight de la méthode CalculatorBase::Process sur le même nœud de calcul. Les paquets de sortie de CalculatorBase::Process sont automatiquement classés par code temporel avant d'être transmis aux calculateurs en aval.
Dans les deux cas, vous devez savoir que la calculatrice exécutée en parallèle ne peut pas maintenir l'état interne de la même manière qu'une calculatrice séquentielle normale.
Générer des horodatages lors de l'utilisation d'ImmmediateInputStreamHandler
Le ImmediateInputStreamHandler distribue chaque paquet dès qu'il arrive dans un flux d'entrée. Par conséquent, elle peut distribuer un paquet avec un horodatage plus élevé d'un flux d'entrée avant de distribuer un paquet avec un horodatage inférieur à partir d'un autre flux d'entrée. Si ces horodatages d'entrée sont tous deux utilisés pour les paquets envoyés à un flux de sortie, ce flux indiquera que les horodatages n'augmentent pas de manière monotone. Pour y remédier, le simulateur doit prendre soin de ne sortir un paquet qu'une fois le traitement de son code temporel terminé.
Pour ce faire, vous pouvez attendre que les paquets d'entrée aient été reçus de tous les flux d'entrée pour cet horodatage ou ignorer un paquet qui arrive avec un horodatage déjà traité.
Modifier les paramètres au moment de l'exécution
Il existe deux approches principales pour modifier les paramètres d'un graphique de calculateur pendant l'exécution de l'application:
- Redémarrez le graphique de la calculatrice avec le
CalculatorGraphConfigmodifié. - Envoi de nouvelles options de calculateur via des paquets sur des flux d'entrée de graphe
La première approche présente l'avantage d'exploiter des outils de traitement CalculatorGraphConfig tels que les "sous-graphiques". La deuxième approche présente l'avantage de permettre aux calculateurs et aux paquets actifs de rester en cours lorsque les paramètres changent. Les contributeurs de Mediapipe étudient actuellement d'autres approches pour atteindre ces deux avantages.
Traiter des flux d'entrée en temps réel
Mediapipe peut être utilisé pour traiter des flux de données en ligne ou hors connexion. Pour le traitement hors connexion, les paquets sont transférés dans le graphe dès que les calculateurs sont prêts à les traiter. Pour le traitement en ligne, un paquet pour chaque trame est transmis dans le graphe lors de l'enregistrement de cette trame.
Le framework MediaPipe ne nécessite que l'attribution d'horodatages monotones croissants aux paquets successifs. Par convention, les calculateurs et les graphiques en temps réel utilisent la durée d'enregistrement ou de présentation comme code temporel pour chaque paquet, chaque horodatage représentant des microsecondes depuis Jan/1/1970:00:00:00. Cela permet de traiter les paquets provenant de différentes sources dans un ordre cohérent à l'échelle mondiale.
Normalement, pour le traitement hors connexion, chaque paquet d'entrée est traité et le traitement se poursuit aussi longtemps que nécessaire. Pour le traitement en ligne, il est souvent nécessaire de supprimer les paquets d'entrée afin de suivre le rythme de l'arrivée des trames de données d'entrée.
Lorsque les entrées arrivent trop fréquemment, la technique recommandée pour supprimer des paquets consiste à utiliser les calculateurs MediaPipe spécialement conçus à cet effet, tels que FlowLimiterCalculator et PacketClonerCalculator.
Pour le traitement en ligne, il est également nécessaire de déterminer rapidement quand le traitement peut se poursuivre. MediaPipe prend en charge cela en propageant des limites d'horodatage entre les calculateurs. Les limites d'horodatage indiquent les intervalles d'horodatage qui ne contiennent aucun paquet d'entrée et permettent aux calculateurs de commencer immédiatement à traiter ces horodatages. Les calculatrices conçues pour un traitement en temps réel doivent calculer soigneusement les limites d'horodatage afin de commencer le traitement le plus rapidement possible. Par exemple, MakePairCalculator utilise l'API SetOffset pour propager les limites d'horodatage des flux d'entrée aux flux de sortie.
Puis-je exécuter MediaPipe sur MS Windows ?
Actuellement, la portabilité de MediaPipe est compatible avec Debian Linux, Ubuntu Linux, macOS, Android et iOS. Le cœur du framework MediaPipe est une bibliothèque C++ conforme à la norme C++11. Elle est donc relativement facile à porter sur des plates-formes supplémentaires.