Namespace easyar

Classes

Accelerometer: L'accéléromètre appelle l'accéléromètre fourni par le système et sort AccelerometerResult. Lorsque l'appareil n'est plus nécessaire, vous pouvez appeler close pour le fermer. Il ne faut plus l'utiliser après l'appel de close. Il n'est pas recommandé de l'ouvrir plusieurs fois simultanément, car cela pourrait entraîner un dysfonctionnement ou une baisse de précision.

AccelerometerResult: Lecture de l'accéléromètre. L'axe X positif pointe du centre de l'appareil vers la droite de l'écran. L'axe Y positif pointe du centre de l'appareil vers la partie supérieure de l'écran. L'axe Z positif pointe perpendiculairement à l'écran vers l'extérieur depuis le centre de l'appareil. Unités pour x, y, z : m/s^2. Unité pour le timestamp : secondes.

AccelerometerResultSink: Port d'entrée des résultats de l'accéléromètre. Utilisé pour exposer un port d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

AccelerometerResultSource: Port de sortie des résultats de l'accéléromètre. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont sécurisés pour les threads.

ARCoreCameraDevice: ARCoreCameraDevice implémente un périphérique de caméra basé sur ARCore, produisant un InputFrame (contenant l'image, les paramètres de la caméra, l'horodatage, les informations de position 6DOF et l'état de suivi).
Pour l'utiliser, il faut d'abord charger libarcore_sdk_c.so via java.lang.System.loadLibrary.
Après sa création, appelez start/stop pour démarrer et arrêter la capture du flux vidéo.
Lorsque le périphérique n'est plus nécessaire, appelez close pour le fermer. Ne continuez pas à l'utiliser après close.
ARCoreCameraDevice produit le InputFrame via inputFrameSource. Connectez inputFrameSource à un InputFrameSink pour l'utilisation.
bufferCapacity indique la capacité de tampon des InputFrame. Si plus de InputFrame que cette capacité sont produits par le périphérique sans être libérés, celui-ci cessera de produire de nouveaux InputFrame jusqu'à la libération des précédents. Cela peut entraîner des blocages d'image, etc.
Remarque : L'implémentation actuelle d'ARCore (v1.13.0) présente une fuite de mémoire lors de la création et de la destruction de session. Des créations et destructions répétées entraîneront une occupation mémoire qui continue de croître et n'est pas libérée après la destruction.

ARCoreDeviceListDownloader: ARCoreDeviceListDownloader est utilisé pour télécharger les mises à jour des paramètres d'étalonnage de la liste des appareils utilisés dans ARCoreCameraDevice.

ARKitCameraDevice: ARKitCameraDevice implémente un appareil photo basé sur ARKit, qui produit des InputFrame (contenant une image, les paramètres de la caméra, un horodatage, des informations de position 6DOF et l'état du suivi). Après sa création, vous pouvez appeler start/stop pour démarrer et arrêter la collecte des données du flux vidéo. Lorsque l'appareil n'est plus nécessaire, appelez close pour le fermer. Il ne doit plus être utilisé après la fermeture. ARKitCameraDevice produit des InputFrame via inputFrameSource. inputFrameSource doit être connecté à un InputFrameSink pour être utilisé. bufferCapacity représente la capacité du tampon des InputFrame. Si plus de InputFrame que cette capacité sont produits par cet appareil et n'ont pas été libérés, l'appareil cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut entraîner des problèmes tels que des images figées.

AttitudeSensor: Le capteur d'attitude appelle le capteur d'attitude fourni par le système et sort AttitudeSensorResult. Lorsque l'appareil n'est plus nécessaire, vous pouvez appeler close pour le fermer. Il ne faut pas continuer à l'utiliser après close. Il n'est pas recommandé de l'ouvrir plusieurs fois simultanément, cela pourrait entraîner une impossibilité d'utilisation ou une perte de précision.

AttitudeSensorResult

Lectures du capteur d'attitude.
L'axe x positif pointe du centre de l'appareil vers la droite de l'écran.
L'axe y positif pointe du centre de l'appareil vers la partie supérieure de l'écran.
L'axe z positif pointe du centre de l'appareil perpendiculairement vers l'extérieur de l'écran.
L'appareil est pivoté d'un angle θ autour des axes (x, y, z).
Le quaternion unitaire de rotation est (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)).
(v0, v1, v2, v3) = (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)).
Le système de coordonnées de référence est défini comme un ensemble de bases orthonormées orientées, où

Z pointe vers le ciel, et est parallèlement au sol.  

(X, Y, Z) forment un trièdre direct.

L'unité de timestamp est la seconde.

AttitudeSensorResultSink: Port d'entrée des résultats du capteur de position.
Utilisé pour exposer un port d'entrée d'un composant.
Tous les membres de cette classe sont thread-safe.

AttitudeSensorResultSource: Port de sortie des résultats du capteur d'attitude.
Utilisé pour exposer un port de sortie d'un composant.
Tous les membres de cette classe sont thread-safe.

BlockInfo: Le modèle obtenu par reconstruction dense est représenté par un maillage triangulaire, appelé mesh. Comme le mesh est fréquemment mis à jour, pour garantir l'efficacité, le mesh de l'ensemble du modèle reconstruit est divisé en très nombreux mesh blocks. Un mesh block est constitué d'un cube d'environ 1 mètre de côté, contenant des éléments tels que des vertex et des index.
BlockInfo est utilisé pour décrire le contenu d'un mesh block. Les coordonnées (x, y, z) sont les indices du mesh block. En multipliant (x, y, z) par la taille physique de chaque mesh block, on obtient les coordonnées de l'origine de ce mesh block dans le système de coordonnées mondial. Il est possible de filtrer à l'avance les parties à afficher en fonction de la position du mesh block dans le monde, afin d'économiser le temps nécessaire au rendu.

BlockPriorResult: Informations cartographiques préalables.
Les blockIds sont les identifiants de la carte.
Le mode indique comment le système utilise les informations préalables, pouvant être soft ou hard. Référence BlockPriorMode.

Buffer: Buffer stocke un tableau d'octets brut, qui peut être utilisé pour accéder aux données d'image.
Dans l'API Java, le buffer peut être obtenu à partir de Image puis les données sont copiées dans un tableau d'octets Java.
Dans toutes les versions d'EasyAR Sense, vous pouvez accéder aux données d'image. Voir Image.

BufferDictionary: Un mappage de chemins de fichiers vers Buffer. Utilisé pour représenter plusieurs fichiers placés en mémoire.

BufferPool: BufferPool implémente un pool de mémoire qui peut être utilisé pour des fonctions nécessitant une allocation répétée de mémoire de même taille, comme l'accès personnalisé à la caméra, réduisant ainsi le temps d'allocation mémoire.

CalibrationDownloader: CalibrationDownloader est utilisé pour télécharger les mises à jour des paramètres d'étalonnage utilisés dans MotionTracker. Après le téléchargement, il est nécessaire de recréer MotionTracker pour que les modifications prennent effet.

CallbackScheduler: Planificateur de rappel. Il existe deux sous-classes : DelayedCallbackScheduler et ImmediateCallbackScheduler. DelayedCallbackScheduler est utilisé pour retarder les rappels jusqu'à ce qu'ils soient appelés manuellement, adapté aux environnements monothread (comme divers environnements UI). ImmediateCallbackScheduler est utilisé pour exécuter immédiatement les rappels, adapté aux environnements multithread (comme les serveurs ou services en arrière-plan).

CameraDevice: CameraDevice implémente un appareil photo, produisant des InputFrame (contenant une image, des paramètres de caméra et un horodatage). Disponible sur Windows, Mac, Android et iOS.
Après ouverture, vous pouvez appeler start/stop pour commencer et arrêter la capture de données. start/stop n'affecte pas les paramètres de la caméra précédemment définis.
Lorsque l'appareil n'est plus nécessaire, appelez close pour le fermer. Il ne faut plus l'utiliser après close.
CameraDevice produit des InputFrame via inputFrameSource. Connectez inputFrameSource à un InputFrameSink pour l'utiliser.
bufferCapacity indique la capacité du tampon de InputFrame. Si plus de InputFrame que cette capacité sont produits par l'appareil et non libérés, celui-ci cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut entraîner des problèmes comme une image figée.
Sur Android, l'autorisation android.permission.CAMERA doit être déclarée dans AndroidManifest.xml.
Sur iOS, la déclaration d'autorisation NSCameraUsageDescription doit être ajoutée dans Info.plist.

CameraDeviceSelector: Pour sélectionner l'API Camera sur Android (camera1 ou camera2). camera1 offre une meilleure compatibilité mais manque de certaines informations nécessaires, comme les timestamps. camera2 présente des problèmes de compatibilité sur certains appareils. Les différentes options choisiront camera1 ou camera2 en fonction des besoins.

CameraParameters: Paramètres de la caméra, incluant la taille d'image, la distance focale, le point principal, le type de caméra et l'angle de rotation de la caméra par rapport à l'orientation naturelle de l'appareil.

CloudLocalizer: CloudLocalizer implémente la fonction de localisation cloud.

CloudLocalizerBlockInstance: Instance du block localisé par CloudLocalizer

CloudLocalizerResult

CloudRecognizationResult

CloudRecognizer: CloudRecognizer implémente la fonction de reconnaissance cloud. Cette fonction nécessite la création d'une bibliothèque de reconnaissance cloud sur le cloud pour être utilisée. Veuillez consulter la documentation EasyAR CRS. Lorsque ce composant n'est plus nécessaire, vous pouvez appeler close pour le fermer. Après la fermeture, il ne doit plus être utilisé. Avant d'utiliser CloudRecognizer, vous devez configurer et préparer un ImageTracker. Tout target retourné doit être chargé manuellement dans le ImageTracker à l'aide de loadTarget avant d'être tracké. Après le chargement, la reconnaissance et le suivi du target sont identiques à l'utilisation d'un target local. Une fois un target reconnu, vous pouvez l'obtenir depuis le callback. Vous devez ensuite utiliser l'UID du target pour distinguer les différents targets. Le runtimeID du target est généré dynamiquement et ne convient pas comme identifiant unique dans le cadre d'une reconnaissance cloud.

DelayedCallbackScheduler: Planificateur de rappel différé. Utilisé pour reporter les rappels jusqu'à ce qu'ils soient appelés manuellement, adapté aux environnements monothread (comme divers environnements d'interface utilisateur). Tous les membres de cette classe sont thread-safe.

DenseSpatialMap: DenseSpatialMap est utilisé pour reconstruire précisément l'environnement en trois dimensions de manière dense. Son modèle reconstruit est représenté par un maillage triangulaire, appelé mesh. DenseSpatialMap occupe 1 buffer de la caméra.

DeviceAuxiliaryInfo

Engine

EventDumpRecorder: Enregistreur de vidage d'événements. Utilisé pour enregistrer des informations de diagnostic critiques dans un fichier EED. Tous les membres de cette classe sont thread-safe.

FeedbackFrame: Trame de rétroaction.
Contient une trame d'entrée et une trame de sortie historique, utilisée par des composants de traitement synchrone à rétroaction comme ImageTracker.

FeedbackFrameFork: Séparateur de trames de rétroaction. Pour transmettre en parallèle une trame de rétroaction à plusieurs composants. Tous les membres de cette classe sont thread-safe.

FeedbackFrameSink: Ports d'entrée de trames de retour. Permet d'exposer les ports d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

FeedbackFrameSource: Port de sortie de trame de rétroaction.
Utilisé pour exposer un port de sortie d'un composant.
Tous les membres de cette classe sont thread-safe.

FrameFilterResult: FrameFilterResult est la classe de base pour tous les résultats des composants utilisant des algorithmes synchrones.

Gyroscope: Gyroscope appelle le gyroscope fourni par le système et produit GyroscopeResult. Lorsque l'appareil n'est plus nécessaire, vous pouvez appeler close pour le fermer. Il ne faut plus l'utiliser après la fermeture. Il n'est pas recommandé de l'ouvrir plusieurs fois simultanément, car cela peut entraîner une impossibilité d'utilisation ou une diminution de la précision.

GyroscopeResult: Lecture du gyroscope. L'axe x positif s'étend du centre de l'appareil vers la droite de l'écran. L'axe y positif s'étend du centre de l'appareil vers le haut de l'écran. L'axe z positif s'étend perpendiculairement vers l'extérieur depuis le centre de l'appareil. x, y, z représentent la vitesse angulaire de rotation autour des axes correspondants, en radians par seconde. Le sens de rotation positif est le sens inverse des aiguilles d'une montre lorsqu'on regarde l'appareil depuis un point situé dans la direction positive d'un axe. L'unité de timestamp est la seconde.

GyroscopeResultSink: Port d'entrée des résultats du gyroscope. Utilisé pour exposer un port d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

GyroscopeResultSource: Port de sortie des résultats du gyroscope. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

Image

Image stocke les données d'image, utilisées pour représenter une image en mémoire. Image fournit un accès aux données brutes sous forme de tableau d'octets, ainsi que des interfaces pour accéder aux informations telles que la largeur/hauteur. Dans toutes les versions d'EasyAR Sense, vous pouvez accéder aux données d'image. Sur iOS, on peut y accéder ainsi :

#import <easyar/buffer.oc.h>
#import <easyar/image.oc.h>

easyar_OutputFrame * outputFrame = [outputFrameBuffer peek];
if (outputFrame != nil) {
    easyar_Image * i = [[outputFrame inputFrame] image];
    easyar_Buffer * b = [i buffer];
    char * bytes = calloc([b size], 1);
    memcpy(bytes, [b data], [b size]);
    // use bytes here
    free(bytes);
}

Sur Android :

import cn.easyar.*;

OutputFrame outputFrame = outputFrameBuffer.peek();
if (outputFrame != null) {
    InputFrame inputFrame = outputFrame.inputFrame();
    Image i = inputFrame.image();
    Buffer b = i.buffer();
    byte[] bytes = new byte[b.size()];
    b.copyToByteArray(0, bytes, 0, bytes.length);
    // use bytes here
    b.dispose();
    i.dispose();
    inputFrame.dispose();
    outputFrame.dispose();
}

ImageHelper: Classe d'aide d'image

ImageTarget: ImageTarget représente une cible d'image plane, qui peut être suivie par un ImageTracker. Les valeurs dans ImageTarget doivent d'abord être renseignées via des méthodes telles que create... avant de pouvoir être lues. Elles peuvent ensuite être détectée et suivie par le ImageTracker après avoir été chargées avec succès dans celui-ci via loadTarget.

ImageTargetParameters: ImageTargetParameters représente les paramètres nécessaires à la création de ImageTarget.

ImageTracker: ImageTracker réalise la détection et le suivi de cartes planes.
ImageTracker occupe (1 + SimultaneousNum) buffers de camera. Utilisez camera.setBufferCapacity pour définir une capacité de buffer d'au moins le nombre total de buffers de camera occupés par tous les composants.
Après la création, appelez start/stop pour démarrer et arrêter l'exécution. Les appels start/stop sont très légers.
Lorsque le composant n'est plus nécessaire, appelez close pour le fermer. Ne continuez pas à l'utiliser après close.
ImageTracker reçoit en entrée FeedbackFrame via feedbackFrameSink. Connectez FeedbackFrameSource à feedbackFrameSink pour l'utiliser.
Avant qu'une Target puisse être suivie par ImageTracker, vous devez la charger via loadTarget/unloadTarget. Les résultats du chargement/déchargement peuvent être obtenus via des rappels d'interface passés en paramètre.

ImageTrackerConfig: ImageTracker création de configuration

ImageTrackerResult: ImageTracker le résultat

ImmediateCallbackScheduler: Planificateur de rappel immédiat. Utilisé pour exécuter immédiatement les rappels, peut être utilisé dans un environnement multithread (comme des serveurs ou services en arrière-plan). Tous les membres de cette classe sont threadsafe.

InertialCameraDevice: InertialCameraDevice implémente un périphérique de caméra basé sur l'inertie de mouvement, produisant un InputFrame avec un CameraTransformType de FiveDofRotXZ (contenant l'image, les paramètres de la caméra, l'horodatage, la matrice de transformation de pose et l'état de suivi). Après sa création, on peut appeler start/stop pour démarrer et arrêter la capture des données du flux vidéo. Lorsque le périphérique n'est plus nécessaire, on peut appeler close pour le fermer. Il ne faut plus l'utiliser après close. InertialCameraDevice produit le InputFrame via inputFrameSource. inputFrameSource doit être connecté à un InputFrameSink pour utilisation. bufferCapacity représente la capacité du tampon des InputFrame. Si plus de InputFrame que cette capacité sont produits par ce périphérique et n'ont pas été libérés, le périphérique cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut provoquer des blocages d'image, etc.

InputFrame: Entrée de trame.
Contient une image, les paramètres de la caméra, un horodatage, la transformation de la caméra par rapport au système de coordonnées mondial et l'état de suivi.
Les paramètres de la caméra, l'horodatage, la transformation de la caméra par rapport au système de coordonnées mondial et l'état de suivi sont tous optionnels, mais des composants algorithmiques spécifiques peuvent imposer des exigences particulières sur l'entrée.

InputFrameFork: Séparateur de trame d'entrée. Utilisé pour transmettre une trame d'entrée en parallèle à plusieurs composants. Tous les membres de cette classe sont thread-safe.

InputFramePlayer: Lecteur de trames d'entrée. Il existe un port de sortie de trame d'entrée pour extraire les trames d'entrée du fichier EIF. Tous les membres de cette classe sont thread-safe.

InputFrameRecorder: Enregistreur de trames d'entrée. Dispose d'un port d'entrée et d'un port de sortie pour les trames d'entrée, permettant d'enregistrer les trames transitantes dans un fichier EIF. Tous les membres de cette classe sont thread-safe.

InputFrameSink: Port d'entrée de trame d'entrée. Utilisé pour exposer les ports d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

InputFrameSource: Port de sortie de trame d'entrée. Utilisé pour exposer le port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

InputFrameThrottler: Accélérateur de trame d'entrée. Comporte un port d'entrée et un port de sortie pour les trames d'entrée. Empêche les nouvelles trames d'entrer dans le composant algorithmique lorsque celui-ci n'a pas terminé le traitement de la trame précédente. InputFrameThrottler consomme 1 buffer de camera. Utilisez setBufferCapacity du camera pour définir une capacité d'au moins la somme des buffers de camera consommés par tous les composants. Tous les membres de cette classe sont thread-safe (sécurisés pour les threads). Note importante : La connexion et la déconnexion de son signalInput (signal d'entrée) ne doivent pas être effectuées pendant un flux de données actif, sinon le système peut se bloquer dans un état où aucune sortie n'est possible. (Il est recommandé de finaliser les connexions du flux de données avant de démarrer le Camera.)

InputFrameToFeedbackFrameAdapter: Adaptateur de trame d'entrée vers trame de rétroaction.
Comporte un port d'entrée pour la trame d'entrée, un port d'entrée pour la trame de sortie historique et un port de sortie pour la trame de rétroaction. Combine la trame d'entrée et la trame de sortie historique en une trame de rétroaction, transmise aux composants algorithmiques nécessitant une trame de rétroaction en entrée, tels que ImageTracker.
À chaque arrivée d'une trame d'entrée, celle-ci est associée à la dernière trame de sortie historique pour former la trame de rétroaction. Si aucune trame de sortie historique n'a été fournie précédemment, cette partie reste vide dans la trame de rétroaction.
L'InputFrameToFeedbackFrameAdapter occupe 1 buffer de caméra. Utilisez setBufferCapacity sur la caméra pour définir une capacité au moins égale au nombre total de buffers occupés par tous les composants.
Tous les membres de cette classe sont thread-safe.

InputFrameToOutputFrameAdapter: Adaptateur de trame d'entrée vers trame de sortie.
Comporte un port d'entrée pour la trame d'entrée et un port de sortie pour la trame de sortie. Utilisé pour encapsuler la trame d'entrée dans une trame de sortie, permettant une fonction de rendu direct sans connecter de composant algorithmique.
Tous les membres de cette classe sont thread-safe.

JniUtility: Classe utilitaire JNI. Utilisé pour encapsuler des tableaux Java et des ByteBuffer dans Unity. Non pris en charge sur la plateforme iOS.

LocationResult: Lecture de position. Les unités de latitude et longitude sont en degrés. L'altitude est en mètres. horizontalAccuracy représente la précision horizontale, en mètres. verticalAccuracy indique la précision verticale, en mètres.

LocationResultSink: Port d'entrée des résultats de position.
Utilisé pour exposer un port d'entrée d'un composant.
Tous les membres de cette classe sont sûrs pour les threads.

LocationResultSource: Port de sortie de résultats de position. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

Log: Classe de journalisation. Utilisée pour afficher les journaux ou définir une fonction personnalisée de sortie de journal.

Magnetometer: Le magnétomètre fait appel au magnétomètre fourni par le système et produit un résultat MagnetometerResult. Lorsque l'appareil n'est plus nécessaire, vous pouvez appeler close pour le fermer. Après la fermeture, son utilisation ne doit pas être poursuivie. Il est déconseillé de l'ouvrir plusieurs fois simultanément, cela pourrait entraîner un dysfonctionnement ou une précision réduite.

MagnetometerResult: Lecture du magnétomètre. La direction positive de l'axe x va du centre de l'appareil vers la droite de l'écran. La direction positive de l'axe y va du centre de l'appareil vers le haut de l'écran. La direction positive de l'axe z va du centre de l'appareil perpendiculairement à l'écran vers l'extérieur. Unités pour x, y, z : uT (micro-tesla). Unité pour timestamp : secondes.

MagnetometerResultSink: Port d'entrée des résultats du magnétomètre. Utilisé pour exposer un port d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

MagnetometerResultSource: Port de sortie des résultats du magnétomètre. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

Matrix33F: Matrice carrée du troisième ordre. L'arrangement des données est row-major.

Matrix44F: Matrice carrée d'ordre quatre. Les données sont disposées en rangée-majeure.

MegaLandmarkFilter: MegaLandmarkFilter implémente la fonction de filtrage de localisation cloud VPS.

MegaLandmarkFilterResult

MegaTracker: Fournit la fonction de localisation cloud. MegaTracker occupe 1 buffer de camera.

MegaTrackerBlockInstance: Instance de bloc du MegaTracker.

MegaTrackerLocalizationResponse: Réponse à la demande de localisation de MegaTracker

MegaTrackerResult: La sortie de MegaTracker sera mise à jour à la fréquence OutputFrame.

MotionInputData: Données d'entrée de mouvement.
Contient l'horodatage, la transformation par rapport au référentiel monde et l'état de suivi.

MotionTrackerCameraDevice: MotionTrackerCameraDevice implémente un appareil photo avec suivi de mouvement 6DOF à l'échelle réelle, produisant un InputFrame (contenant l'image, les paramètres de la caméra, l'horodatage, les informations de position 6DOF et l'état de suivi).
Après création, vous pouvez appeler start/stop pour démarrer et arrêter le flux de données.
Lorsque l'appareil n'est plus nécessaire, appelez close pour le fermer. Il ne doit plus être utilisé après close.
MotionTrackerCameraDevice produit des InputFrame via inputFrameSource. Connectez inputFrameSource à un InputFrameSink pour l'utiliser.

ObjectTarget: ObjectTarget représente une cible d'objet 3D, qui peut être suivie par ObjectTracker. La taille d'ObjectTarget est déterminée par le fichier obj. Elle peut être modifiée en ajustant le paramètre scale, dont la valeur par défaut est 1. Après avoir été chargé avec succès dans ObjectTracker via loadTarget, ObjectTarget peut être détecté et suivi par ObjectTracker.

ObjectTargetParameters: ObjectTargetParameters représente les paramètres requis pour la création d'un ObjectTarget.

ObjectTracker: ObjectTracker met en œuvre la détection et le suivi de cibles d'objets 3D. ObjectTracker occupe les tampons de (1 + SimultaneousNum) caméras. Utilisez setBufferCapacity de la caméra pour définir un nombre de tampons de caméra non inférieur à celui requis par tous les composants. Après la création, vous pouvez appeler start/stop pour démarrer et arrêter l'exécution. Les appels start/stop sont très légers. Lorsque le composant n'est plus nécessaire, appelez close pour le fermer. Il ne doit pas être utilisé après close. ObjectTracker reçoit des FeedbackFrame en entrée via feedbackFrameSink. Connectez FeedbackFrameSource à feedbackFrameSink pour l'utiliser. Avant qu'une Target puisse être suivie par ObjectTracker, vous devez la charger via loadTarget/unloadTarget. Les résultats du chargement/déchargement peuvent être obtenus via un rappel d'interface passé en paramètre.

ObjectTrackerResult: ObjectTracker Résultat de

OutputFrame: Cadre de sortie. Contient le cadre d'entrée avec les composants traités de manière synchrone.

OutputFrameBuffer: Tampon de trame de sortie.
Il existe un port d'entrée de trame de sortie et une fonction d'obtention de trame de sortie pour transformer l'acquisition asynchrone en interrogation synchrone, adaptée au rendu image par image.
OutputFrameBuffer occupe 1 tampon de caméra. Utilisez setBufferCapacity de la caméra pour définir une capacité au moins égale au nombre total de tampons utilisés par tous les composants.
Tous les membres de cette classe sont thread-safe.

OutputFrameFork: Séparateur de trames de sortie. Utilisé pour transmettre une trame de sortie en parallèle à plusieurs composants. Tous les membres de cette classe sont thread-safe.

OutputFrameJoin: Fusionneur de trames de sortie. Utilisé pour fusionner les trames de sortie de plusieurs composants en une seule trame de sortie. Tous les membres de cette classe sont thread-safe. Il convient de noter que la connexion et la déconnexion de ses multiples entrées ne doivent pas être effectuées pendant l'afflux de données, sinon il pourrait tomber dans un état où il ne peut pas sortir. (Il est recommandé de terminer la connexion du flux de données avant de démarrer la Camera.)

OutputFrameSink: Porte d'entrée du cadre de sortie. Utilisé pour exposer les ports d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

OutputFrameSource: Port de sortie de trame de sortie. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

PlaneData

PoseUtility

ProximityLocationResult: Lecture de position proximale. x, y, z unités en mètres. L'origine est l'origine de la tuile de carte. y vers le haut. accuracy unités en mètres. timestamp, validTime unités en secondes. is2d indique si y n'est pas utilisé.

ProximityLocationResultSink: Port d'entrée des résultats de localisation à proximité.
Utilisé pour exposer les ports d'entrée d'un composant.
Tous les membres de cette classe sont thread-safe.

ProximityLocationResultSource: Port de sortie des résultats de position proximale. Utilisé pour exposer un port de sortie d'un composant. Tous les membres de cette classe sont thread-safe.

Recorder: Recorder implémente la fonctionnalité d'enregistrement d'écran pour l'environnement de rendu actuel. Actuellement, Recorder fonctionne uniquement dans les environnements Android (4.3 ou plus récent) et iOS avec OpenGL ES 3.0. En raison de sa dépendance à OpenGLES, toutes les fonctions de cette classe (à l'exception de requestPermissions, y compris le destructeur) doivent être appelées dans un unique thread contenant un contexte OpenGLES. Unity Uniquement Dans Unity, si la fonctionnalité Multi-threaded rendering est utilisée, le thread de script sera séparé du thread de rendu, rendant impossible l'appel de updateFrame sur le thread de rendu. Par conséquent, si vous avez besoin d'utiliser l'enregistrement d'écran, vous devriez désactiver la fonctionnalité Multi-threaded rendering. Pour une utilisation sur Android, la déclaration de permission android.permission.RECORD_AUDIO doit être ajoutée dans AndroidManifest.xml. Pour une utilisation sur iOS, la déclaration de permission NSMicrophoneUsageDescription doit être ajoutée dans Info.plist.

RecorderConfiguration: RecorderConfiguration est la configuration de démarrage de Recorder.

SceneMesh

SignalSink: Port d'entrée de signal. Utilisé pour exposer un port d'entrée d'un composant. Tous les membres de cette classe sont thread-safe.

SignalSource: Port de sortie de signal.
Utilisé pour exposer un port de sortie d'un composant.
Tous les membres de cette classe sont thread-safe.

SparseSpatialMap: Fournir les fonctionnalités principales du système SparseSpatialMap : génération et stockage de cartes, chargement de cartes et localisation. Il permet également d'obtenir des informations environnementales telles que des nuages de points et des plans, et d'effectuer un hit Test.
SparseSpatialMap utilise 2 buffers de camera. Utilisez setBufferCapacity de camera pour définir un nombre de buffers au moins égal à celui requis par l'ensemble des composants.

SparseSpatialMapConfig: pour configurer la stratégie de localisation sparse mapping

SparseSpatialMapManager: Classe de gestion SparseSpatialMap, utilisée pour gérer la fonctionnalité de partage de SparseSpatialMap.

SparseSpatialMapResult: Obtenir la sortie du système de cartographie sparse et de localisation, qui sera mise à jour à la fréquence OutputFrame.

Storage

SurfaceTracker: SurfaceTracker assure le suivi des surfaces environnementales.
SurfaceTracker occupe 1 tampon (buffer) de caméra. La capacité du tampon de la caméra doit être définie via camera.setBufferCapacity avec une valeur au moins égale au nombre total de tampons utilisés par tous les composants.
Après création, les méthodes start/stop peuvent être appelées pour démarrer et arrêter le fonctionnement. Ces appels sont très légers en ressources.
Lorsque le composant n'est plus nécessaire, appelez close pour le fermer. Il ne doit plus être utilisé après fermeture.
SurfaceTracker reçoit les InputFrame via inputFrameSink. Connectez InputFrameSource à inputFrameSink pour l'utiliser.

SurfaceTrackerResult: SurfaceTracker

Target: Target est la classe de base dans EasyAR pour toutes les cibles qui peuvent être suivies par ImageTracker ou d'autres algorithmes.

TargetInstance: TargetInstance est la cible suivie par le tracker.
TargetInstance inclut la Target d'origine suivie ainsi que l'état et la pose actuels de cette Target.

TargetTrackerResult: TargetTrackerResult est la classe de base de ImageTrackerResult et ObjectTrackerResult.

TextureId: TextureId encapsule les objets de texture dans les API graphiques. Pour OpenGL/OpenGLES, utilisez getInt et fromInt ; pour Direct3D, utilisez getPointer et fromPointer.

ThreeDofCameraDevice: ThreeDofCameraDevice implémente un appareil photo à trois degrés de liberté (3 dof), produisant un InputFrame dont le CameraTransformType est ThreeDofRotOnly (contenant l'image, les paramètres de l'appareil photo, le timestamp, la matrice de transformation de position et d'orientation, et l'état de suivi). Après sa création, on peut appeler start/stop pour démarrer et arrêter la capture du flux vidéo. Lorsqu'il n'est plus nécessaire, on peut appeler close pour le fermer. Il ne faut plus l'utiliser après close. ThreeDofCameraDevice sort le InputFrame via inputFrameSource. Cette inputFrameSource doit être connectée à un InputFrameSink pour être utilisée. La bufferCapacity indique la capacité du tampon des InputFrame. Si plus de InputFrame que ce nombre sont produits par l'appareil et n'ont pas été libérés, l'appareil cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut entraîner des problèmes comme un blocage de l'image.

Vec2F: vecteur float à deux dimensions

Vec2I: Vecteur int bidimensionnel.

Vec3D: vecteur double à trois dimensions

Vec3F: Vecteur float tridimensionnel

Vec4F: Vecteur float à quatre dimensions.

Vec4I: Vecteur int à quatre dimensions.

VideoInputFramePlayer: Entrez le lecteur de trames.
Il existe un port de sortie de trames d'entrée pour extraire les trames d'entrée des fichiers EIF MKV.
Tous les membres de cette classe sont thread-safe.

VideoInputFrameRecorder: Enregistreur de trames d'entrée. Comporte un port d'entrée pour les trames d'entrée et un port de sortie pour les trames d'entrée, permettant d'enregistrer les trames transitant dans un fichier MKV EIF. Tous les membres de cette classe sont thread-safe.

VideoPlayer: VideoPlayer est une classe de lecture vidéo. EasyAR prend en charge la lecture vidéo standard, la vidéo transparente et la diffusion en continu. Le contenu vidéo sera rendu sur la texture passée à setRenderTexture. Cette classe ne prend en charge que les textures OpenGLES 3.0. En raison de sa dépendance à OpenGLES, toutes les fonctions de cette classe (y compris le destructeur) doivent être appelées dans un seul thread contenant un contexte OpenGLES. La version actuelle nécessite que la largeur et la hauteur soient des multiples de 16. Formats de fichiers vidéo pris en charge Windows : Formats compatibles Media Foundation. L'installation de codecs supplémentaires permet de prendre en charge plus de formats. Veuillez consulter Supported Media Formats in Media Foundation. DirectShow n'est pas pris en charge. Mac : Non pris en charge Android : Formats pris en charge par le système. Veuillez consulter Supported media formats. iOS : Formats pris en charge par le système. Aucune documentation de référence valide n'est actuellement disponible.

VisionOSARKitCameraDevice: VisionOSARKitCameraDevice implémente un périphérique caméra basé sur VisionOS ARKit, produisant des InputFrame (contenant l'image, les paramètres de la caméra, l'horodatage, les informations de position 6DOF et l'état du suivi). Après sa création, les méthodes start/stop peuvent être appelées pour démarrer et arrêter la capture du flux vidéo. Lorsque l'appareil n'est plus nécessaire, close peut être appelé pour le fermer. Il ne doit plus être utilisé après close. VisionOSARKitCameraDevice sort des InputFrame via inputFrameSource. inputFrameSource doit être connecté à un InputFrameSink pour utilisation. bufferCapacity indique la capacité de la mémoire tampon des InputFrame. Si plus de InputFrame que cette capacité sont produits par l'appareil et n'ont pas été libérés, celui-ci cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut provoquer des blocages d'image, etc.

XREALCameraDevice: XREALCameraDevice implémente un périphérique caméra basé sur le plugin XREAL Enterprise Native SDK, produisant des InputFrame (ne permettant pas d'obtenir l'image, les paramètres de la caméra, l'horodatage, les informations de position 6DOF et l'état du suivi). Après sa création, vous pouvez appeler start/stop pour commencer et arrêter la capture des données du flux vidéo. Il est essentiel de s'assurer que isDeviceSupported renvoie true avant d'appeler start. Lorsque le périphérique n'est plus nécessaire, appelez close pour le fermer. Il ne doit plus être utilisé après close. XREALCameraDevice produit des InputFrame via inputFrameSource. Ce inputFrameSource doit être connecté à un InputFrameSink pour être utilisé. bufferCapacity représente la capacité du tampon pour les InputFrame. Si plus de InputFrame que cette capacité sont produits par ce périphérique et n'ont pas été libérés, le périphérique cessera de produire de nouveaux InputFrame jusqu'à ce que les précédents soient libérés. Cela peut entraîner des problèmes tels que le gel de l'image.

Énumérations

AndroidCameraApiType

ARCoreCameraDeviceFocusMode

ARCoreDeviceListDownloadStatus

ARKitCameraDeviceFocusMode

BlockPriorMode: Mode de fonctionnement des informations cartographiques a priori

CalibrationDownloadStatus

CameraDeviceFocusMode

CameraDevicePreference

CameraDevicePresetProfile

CameraDeviceType: Type de périphérique d'appareil photo

CameraModelType: Type de modèle d'appareil photo

CameraState

CameraTransformType: Type de transformation de caméra.

CloudLocalizerStatus: État de localisation dans le nuage.

CloudRecognizationStatus

EngineOperatingSystem

ImageTrackerMode

InertialCameraDeviceFocusMode

LocalizationMode

LogLevel

MegaApiType: Types d'API MEGA

MegaLandmarkFilterStatus

MegaTrackerLocalizationStatus

MotionTrackerCameraDeviceFocusMode

MotionTrackerCameraDeviceFPS

MotionTrackerCameraDeviceQualityLevel

MotionTrackerCameraDeviceResolution

MotionTrackerCameraDeviceTrackingMode

MotionTrackingStatus: Décrire la qualité du suivi de mouvement de l'appareil.

PermissionStatus

PixelFormat: PixelFormat représente le format de pixel de l'image. Pour tous les formats, l'orientation des pixels se fait de gauche à droite et de haut en bas.

PlaneType

RecordProfile

RecordStatus

RecordVideoOrientation

RecordVideoSize

RecordZoomMode

StorageType: StorageType indique l'emplacement de stockage des images, fichiers json, vidéos ou autres fichiers.
StorageType spécifie le répertoire racine où les fichiers sont stockés. Vous pouvez utiliser des chemins relatifs par rapport à ce répertoire racine dans toutes les interfaces concernées.

TargetStatus

ThreeDofCameraDeviceFocusMode

ValidationState

VideoInputFrameRecorderCompletionReason

VideoInputFrameRecorderVideoCodec

VideoStatus

VideoType

Table of Contents

Namespace easyar

Classes

Énumérations