Logiciels de vision événementielle : SDK, formats et intégration

Que traite un logiciel de vision basée sur les événements ?

Une caméra événementielle signale les changements de luminosité plutôt que de fournir une image vidéo conventionnelle à chaque intervalle. Un événement décodé identifie généralement un pixel, une polarité et un horodatage. Votre application doit préserver la signification de ces champs grâce à l'acquisition, au filtrage, à l'enregistrement et à l'inférence. Le comparaison basée sur les événements et basée sur les trames explique quand ce modèle de données est utile.

Distinguer trois formats dans la conception : l'encodage du capteur ou du transport, la représentation d'événement décodée utilisée par le logiciel et la représentation passée à un algorithme. Un fichier contenant des paquets de capteurs bruts, un tableau d'événements décodés et une image accumulée servent à différentes fins. La conversion entre eux peut modifier l'utilisation de la mémoire, le coût de traitement et les informations de synchronisation disponibles en aval.

Comment évaluer un SDK de caméra événementielle

Commencez par le capteur exact, le micrologiciel de la caméra et la plate-forme hôte. Une démonstration de bureau n'établit pas la prise en charge d'une image Linux intégrée, d'un processeur ARM ou de votre licence de production. Demandez au fournisseur les systèmes d'exploitation pris en charge, les architectures de processeur, les conditions de redistribution et les exigences en matière d'interface de caméra. Vérifiez l'application sur la plate-forme prévue avant de valider la carte du transporteur.

• Acquisition : découverte, configuration, décodage et rapport d'erreurs des appareils.
• Calendrier : origine de l'horodatage, gestion du survol, déclencheurs externes et alignement multi-appareils.
• Reproductibilité : enregistrements, export de configuration et version logicielle identifiée.
• Déploiement : fonctionnement sans tête, binaires pris en charge, comportement de redémarrage et conditions de licence.
• Observabilité : nombre d'événements, profondeur de file d'attente, données supprimées et utilisation des ressources de l'hôte.

Créer un pipeline avec des limites temporelles explicites

Séparez l’acquisition de la visualisation coûteuse, de l’écriture sur disque et de l’inférence de modèle. Sinon, un consommateur lent peut retarder les nouvelles données avant même que l’algorithme ne démarre. Définissez une file d'attente limitée et une politique de surcharge explicite. Supprimer la fenêtre la plus ancienne, réduire la région d'intérêt et arrêter avec une erreur ont des conséquences différentes ; choisissez le comportement qui correspond à l'application et enregistrez quand cela se produit.

Utilisez les horodatages des capteurs pour décrire le moment où les observations ont eu lieu et une horloge hôte monotone pour mesurer les durées de traitement. La soustraction des horodatages d'horloges non liées ne produit pas une latence de bout en bout valide. Si la caméra doit être combinée avec une IMU ou une caméra conventionnelle, établissez la relation d'horloge et le processus d'étalonnage décrits dans notre guide de synchronisation capteur-fusion.

Un petit exemple d'enregistrement-inspection

L'exemple Python suivant compte les événements décodés dans un enregistrement pris en charge et indique la durée de leurs horodatages. Il utilise l'API de streaming Metavision documentée et nécessite une installation et un enregistrement de SDK compatible. Il s'agit d'un exemple d'inspection, pas d'une référence de caméra Alvexis ou d'un détecteur.

import argparse
from metavision_sdk_stream import Camera, CameraStreamSlicer

parser = argparse.ArgumentParser()
parser.add_argument("recording")
args = parser.parse_args()
source = Camera.from_file(args.recording)
count, first_us, last_us = 0, None, None

for batch in CameraStreamSlicer(source.move()):
    events = batch.events
    if events.size:
        start = int(events["t"][0])
        end = int(events["t"][-1])
        first_us = start if first_us is None else min(first_us, start)
        last_us = end if last_us is None else max(last_us, end)
        count += int(events.size)

span_s = 0.0 if first_us is None else (last_us - first_us) / 1_000_000
print({"events": count, "event_timestamp_span_s": span_s})

La période d'horodatage couvre le premier jusqu'au dernier événement observé ; il ne mesure pas la durée du fichier, le délai d'acquisition ou le débit de traitement. Les périodes vides et les réinitialisations de l’horloge nécessitent un traitement séparé en production. Conservez la configuration de l'appareil et les métadonnées d'enregistrement à côté du fichier afin qu'un deuxième ingénieur puisse reproduire l'interprétation.

Validez les scènes calmes, les scènes occupées et la reprise après panne

Testez une scène stationnaire, un mouvement représentatif et une scène délibérément exigeante. Le scintillement, les vibrations de la caméra et les mouvements texturés peuvent créer des taux d'événements très différents. Enregistrez à la fois le comportement typique et le pire des cas que vous avez observé. Répétez l'opération avec le stockage et les communications actifs, car ces charges de travail sont en concurrence pour la mémoire et le temps CPU.

Lorsque l'algorithme utilise un réseau de neurones, vérifiez le tenseur résultant et les opérateurs pris en charge avant de choisir un accélérateur. Une caméra d'événements ne nécessite pas automatiquement un NPU, et un NPU n'accepte pas automatiquement un flux d'événements. Notre Guide d'architecture FPGA, NPU et MPU sépare les services d'acquisition, de prétraitement, d'inférence et d'application.

Questions avant de choisir une pile logicielle

Puis-je utiliser un modèle de vision par ordinateur normal ?

Seulement après avoir défini une représentation d'entrée compatible et validé son comportement. L'accumulation d'événements dans des images peut permettre la réutilisation d'une étape de traitement d'image, mais modifie la distribution des données et ajoute une fenêtre de synchronisation. Évaluez la demande complète sur des données représentatives.

Une démo d'ordinateur portable fonctionnel prouve-t-elle la compatibilité intégrée ?

Non. Confirmez l'architecture du processeur, le système d'exploitation, l'interface du capteur, le pilote, la licence SDK et l'utilisation soutenue des ressources de la plate-forme cible réelle.

Que dois-je envoyer pour une discussion d’intégration ?

Envoyez la référence de la caméra ou du capteur, l'échantillon d'enregistrement, la sortie prévue, le délai acceptable, la plate-forme hôte, l'interface et l'environnement de déploiement. Ces apports rendent la discussion suffisamment concrète pour identifier les premiers risques d’intégration.