Class 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.
ImageTracker
Méthodes
isAvailable
bool easyar_ImageTracker_isAvailable(void)
static bool isAvailable()
public static boolean isAvailable()
companion object fun isAvailable(): Boolean
public static func isAvailable() -> Bool
public static bool isAvailable()
Retours
feedbackFrameSink
FeedbackFrame port d'entrée. Les membres InputFrame dans FeedbackFrame doivent obligatoirement posséder une image, un horodatage et des paramètres de caméra. La caméra prend en charge les caméras sténopé et fisheye.
void easyar_ImageTracker_feedbackFrameSink(easyar_ImageTracker * This, easyar_FeedbackFrameSink * * Return)
std::shared_ptr<FeedbackFrameSink> feedbackFrameSink()
public @Nonnull FeedbackFrameSink feedbackFrameSink()
fun feedbackFrameSink(): FeedbackFrameSink
- (easyar_FeedbackFrameSink *)feedbackFrameSink
public func feedbackFrameSink() -> FeedbackFrameSink
public virtual FeedbackFrameSink feedbackFrameSink()
Retours
bufferRequirement
Le nombre de camera buffers occupés par le composant actuel.
int easyar_ImageTracker_bufferRequirement(easyar_ImageTracker * This)
public int bufferRequirement()
fun bufferRequirement(): Int
public func bufferRequirement() -> Int32
public virtual int bufferRequirement()
Retours
outputFrameSource
void easyar_ImageTracker_outputFrameSource(easyar_ImageTracker * This, easyar_OutputFrameSource * * Return)
std::shared_ptr<OutputFrameSource> outputFrameSource()
public @Nonnull OutputFrameSource outputFrameSource()
fun outputFrameSource(): OutputFrameSource
- (easyar_OutputFrameSource *)outputFrameSource
public func outputFrameSource() -> OutputFrameSource
public virtual OutputFrameSource outputFrameSource()
Retours
create
void easyar_ImageTracker_create(easyar_ImageTracker * * Return)
static std::shared_ptr<ImageTracker> create()
public static @Nonnull ImageTracker create()
companion object fun create(): ImageTracker
+ (easyar_ImageTracker *)create
public static func create() -> ImageTracker
public static ImageTracker create()
Retours
createWithMode
Créé avec un mode de suivi spécifique. Sur les téléphones bas de gamme, ImageTrackerMode.PreferPerformance peut être utilisé pour de meilleures performances, mais avec une légère perte de qualité de suivi.
void easyar_ImageTracker_createWithMode(easyar_ImageTrackerMode trackMode, easyar_ImageTracker * * Return)
static std::shared_ptr<ImageTracker> createWithMode(ImageTrackerMode trackMode)
public static @Nonnull ImageTracker createWithMode(int trackMode)
companion object fun createWithMode(trackMode: Int): ImageTracker
+ (easyar_ImageTracker *)createWithMode:(easyar_ImageTrackerMode)trackMode
public static func createWithMode(_ trackMode: ImageTrackerMode) -> ImageTracker
public static ImageTracker createWithMode(ImageTrackerMode trackMode)
Paramètres
Retours
createWithConfig
Créer avec une configuration spécifique
void easyar_ImageTracker_createWithConfig(easyar_ImageTrackerConfig * config, easyar_ImageTracker * * Return)
static std::shared_ptr<ImageTracker> createWithConfig(std::shared_ptr<ImageTrackerConfig> config)
public static @Nonnull ImageTracker createWithConfig(@Nonnull ImageTrackerConfig config)
companion object fun createWithConfig(config: ImageTrackerConfig): ImageTracker
+ (easyar_ImageTracker *)createWithConfig:(easyar_ImageTrackerConfig *)config
public static func createWithConfig(_ config: ImageTrackerConfig) -> ImageTracker
public static ImageTracker createWithConfig(ImageTrackerConfig config)
Paramètres
Retours
setResultPostProcessing
Configurer le post-traitement des résultats.
enablePersistentTargetInstance est désactivé par défaut. Lorsqu'activé, si les données de InputFrame contiennent des informations spatiales, les targetInstances dans ImageTrackerResult incluront toutes les instances détectées (y compris celles non suivies actuellement).
enableMotionFusion est désactivé par défaut. Lorsqu'activé, si les données de InputFrame contiennent des informations temporelles et spatiales, la pose des targetInstances dans ImageTrackerResult subira un traitement via RealTimeCoordinateTransform.
void easyar_ImageTracker_setResultPostProcessing(easyar_ImageTracker * This, bool enablePersistentTargetInstance, bool enableMotionFusion)
void setResultPostProcessing(bool enablePersistentTargetInstance, bool enableMotionFusion)
public void setResultPostProcessing(boolean enablePersistentTargetInstance, boolean enableMotionFusion)
fun setResultPostProcessing(enablePersistentTargetInstance: Boolean, enableMotionFusion: Boolean): Unit
- (void)setResultPostProcessing:(bool)enablePersistentTargetInstance enableMotionFusion:(bool)enableMotionFusion
public func setResultPostProcessing(_ enablePersistentTargetInstance: Bool, _ enableMotionFusion: Bool) -> Void
public virtual void setResultPostProcessing(bool enablePersistentTargetInstance, bool enableMotionFusion)
Paramètres
| Nom |
Type |
Description |
| enablePersistentTargetInstance |
Boolean |
|
| enableMotionFusion |
Boolean |
|
Retours
setResultAsyncMode
Définir le mode asynchrone des résultats. Doit être défini sur true si les résultats sont sortis via outputFrameSource, et sur false si les résultats sont obtenus via getSyncResult. Par défaut, enableAsync est true. Le mode synchrone n'est effectif que lorsque les trames d'entrée contiennent des informations spatiales et qu'une licence XR est utilisée.
bool easyar_ImageTracker_setResultAsyncMode(easyar_ImageTracker * This, bool enableAsync)
bool setResultAsyncMode(bool enableAsync)
public boolean setResultAsyncMode(boolean enableAsync)
fun setResultAsyncMode(enableAsync: Boolean): Boolean
- (bool)setResultAsyncMode:(bool)enableAsync
public func setResultAsyncMode(_ enableAsync: Bool) -> Bool
public virtual bool setResultAsyncMode(bool enableAsync)
Paramètres
| Nom |
Type |
Description |
| enableAsync |
Boolean |
|
Retours
start
Commencez l'algorithme de suivi.
bool easyar_ImageTracker_start(easyar_ImageTracker * This)
public func start() -> Bool
public virtual bool start()
Retours
stop
Suspendre l'algorithme de suivi. Appelez start pour redémarrer le suivi.
void easyar_ImageTracker_stop(easyar_ImageTracker * This)
public func stop() -> Void
public virtual void stop()
Retours
close
void easyar_ImageTracker_close(easyar_ImageTracker * This)
public func close() -> Void
public virtual void close()
Retours
loadTarget
Charger une Target dans le tracker. Une Target ne peut être détectée et suivie qu'après avoir été chargée avec succès dans le tracker.
Cette méthode est une méthode asynchrone. Le processus de chargement peut nécessiter un certain temps. Pendant cette période, la détection des nouvelles cibles et des cibles perdues peut prendre plus de temps que d'habitude, mais le suivi après détection n'est pas affecté. Si vous souhaitez connaître le résultat du chargement, vous devez traiter les données du callback. Le callback sera appelé sur le fil spécifié par le CallbackScheduler. Le fil de suivi et les autres opérations (hormis le chargement/déchargement) ne seront pas bloqués.
void easyar_ImageTracker_loadTarget(easyar_ImageTracker * This, easyar_Target * target, easyar_CallbackScheduler * callbackScheduler, easyar_FunctorOfVoidFromTargetAndBool callback)
void loadTarget(std::shared_ptr<Target> target, std::shared_ptr<CallbackScheduler> callbackScheduler, std::function<void(std::shared_ptr<Target>, bool)> callback)
public void loadTarget(@Nonnull Target target, @Nonnull CallbackScheduler callbackScheduler, @Nonnull FunctorOfVoidFromTargetAndBool callback)
fun loadTarget(target: Target, callbackScheduler: CallbackScheduler, callback: FunctorOfVoidFromTargetAndBool): Unit
- (void)loadTarget:(easyar_Target *)target callbackScheduler:(easyar_CallbackScheduler *)callbackScheduler callback:(void (^)(easyar_Target * target, bool status))callback
public func loadTarget(_ target: Target, _ callbackScheduler: CallbackScheduler, _ callback: @escaping (Target, Bool) -> Void) -> Void
public virtual void loadTarget(Target target, CallbackScheduler callbackScheduler, Action<Target, bool> callback)
Paramètres
Retours
unloadTarget
Déchargez Target du tracker.
Cette méthode est une méthode asynchrone. Le processus de déchargement peut nécessiter un certain temps pour se terminer. Pendant cette période, la détection de nouvelles cibles et des cibles perdues peut prendre plus de temps que d'habitude, mais le suivi après détection n'est pas affecté. Si vous souhaitez connaître le résultat du déchargement, vous devez traiter les données de callback. Le callback sera appelé sur le thread spécifié par CallbackScheduler. Le thread de suivi et les opérations autres que le chargement/déchargement ne seront pas bloqués.
void easyar_ImageTracker_unloadTarget(easyar_ImageTracker * This, easyar_Target * target, easyar_CallbackScheduler * callbackScheduler, easyar_FunctorOfVoidFromTargetAndBool callback)
void unloadTarget(std::shared_ptr<Target> target, std::shared_ptr<CallbackScheduler> callbackScheduler, std::function<void(std::shared_ptr<Target>, bool)> callback)
public void unloadTarget(@Nonnull Target target, @Nonnull CallbackScheduler callbackScheduler, @Nonnull FunctorOfVoidFromTargetAndBool callback)
fun unloadTarget(target: Target, callbackScheduler: CallbackScheduler, callback: FunctorOfVoidFromTargetAndBool): Unit
- (void)unloadTarget:(easyar_Target *)target callbackScheduler:(easyar_CallbackScheduler *)callbackScheduler callback:(void (^)(easyar_Target * target, bool status))callback
public func unloadTarget(_ target: Target, _ callbackScheduler: CallbackScheduler, _ callback: @escaping (Target, Bool) -> Void) -> Void
public virtual void unloadTarget(Target target, CallbackScheduler callbackScheduler, Action<Target, bool> callback)
Paramètres
Retours
targets
Retourne le target actuellement chargé dans le tracker. Si un chargement/déchargement asynchrone est en cours, la valeur de retour avant que le chargement/déchargement ne soit terminé ne reflétera pas les résultats de ces opérations.
void easyar_ImageTracker_targets(const easyar_ImageTracker * This, easyar_ListOfTarget * * Return)
std::vector<std::shared_ptr<Target>> targets()
public java.util.@Nonnull ArrayList<@Nonnull Target> targets()
fun targets(): ArrayList<Target>
- (NSArray<easyar_Target *> *)targets
public func targets() -> [Target]
public virtual List<Target> targets()
Retours
setSimultaneousNum
Définir le nombre maximum d'objectifs pouvant être suivis par le tracker. La valeur par défaut est 1.
bool easyar_ImageTracker_setSimultaneousNum(easyar_ImageTracker * This, int num)
bool setSimultaneousNum(int num)
public boolean setSimultaneousNum(int num)
fun setSimultaneousNum(num: Int): Boolean
- (bool)setSimultaneousNum:(int)num
public func setSimultaneousNum(_ num: Int32) -> Bool
public virtual bool setSimultaneousNum(int num)
Paramètres
| Nom |
Type |
Description |
| num |
Int32 |
|
Retours
simultaneousNum
Obtenir le nombre maximum de cibles pouvant être suivies par le tracker. La valeur par défaut est 1.
int easyar_ImageTracker_simultaneousNum(const easyar_ImageTracker * This)
public int simultaneousNum()
fun simultaneousNum(): Int
public func simultaneousNum() -> Int32
public virtual int simultaneousNum()
Retours
getSyncResult
Obtenir les résultats de sortie synchrones. Si ImageTracker est en pause, ou si le mode asynchrone des résultats n'est pas défini sur false via setResultAsyncMode, alors la valeur de retour est vide.
void easyar_ImageTracker_getSyncResult(easyar_ImageTracker * This, easyar_MotionInputData * motionInputData, easyar_OptionalOfImageTrackerResult * Return)
std::optional<std::shared_ptr<ImageTrackerResult>> getSyncResult(std::shared_ptr<MotionInputData> motionInputData)
public @Nullable ImageTrackerResult getSyncResult(@Nonnull MotionInputData motionInputData)
fun getSyncResult(motionInputData: MotionInputData): ImageTrackerResult?
- (easyar_ImageTrackerResult *)getSyncResult:(easyar_MotionInputData *)motionInputData
public func getSyncResult(_ motionInputData: MotionInputData) -> ImageTrackerResult?
public virtual Optional<ImageTrackerResult> getSyncResult(MotionInputData motionInputData)
Paramètres
Retours