Table of Contents

Class ImageTracker

Namespace
easyar

ImageTracker implements the detection and tracking of planar cards. ImageTracker occupies (1 + SimultaneousNum) camera buffers. Should use camera.setBufferCapacity to set a value not less than the total number of camera buffers occupied by all components. After creation, you can call start/stop to start and stop the operation. start/stop are very lightweight calls. When the component is no longer needed, you can call close to close it. Should not be used after close. ImageTracker inputs via feedbackFrameSink FeedbackFrame. FeedbackFrameSource should be connected to feedbackFrameSink for use. Before Target can be tracked by ImageTracker, you need to load it via loadTarget/unloadTarget. You can pass the callback of the interface to get the result of load/unload.

ImageTracker

Methods

isAvailable

Return true.

bool easyar_ImageTracker_isAvailable(void)
static bool isAvailable()
public static boolean isAvailable()
companion object fun isAvailable(): Boolean
+ (bool)isAvailable
public static func isAvailable() -> Bool
public static bool isAvailable()

Returns

Boolean

feedbackFrameSink

FeedbackFrame input port. The InputFrame member in FeedbackFrame must have image, timestamp, and camera parameters. The camera supports pinhole and fisheye cameras.

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()

Returns

FeedbackFrameSink

bufferRequirement

The current number of camera buffers occupied by the component.

int easyar_ImageTracker_bufferRequirement(easyar_ImageTracker * This)
int bufferRequirement()
public int bufferRequirement()
fun bufferRequirement(): Int
- (int)bufferRequirement
public func bufferRequirement() -> Int32
public virtual int bufferRequirement()

Returns

Int32

outputFrameSource

OutputFrame output port.

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()

Returns

OutputFrameSource

create

Create. The default tracking mode is ImageTrackerMode.PreferQuality.

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()

Returns

ImageTracker

createWithMode

Create with a specific tracking mode. On low-end mobile phones, you can use ImageTrackerMode.PreferPerformance to achieve better performance, but there will be a slight loss in tracking performance.

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)

Parameters

trackMode ImageTrackerMode

Returns

ImageTracker

createWithConfig

Create with a specific configuration.

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)

Parameters

config ImageTrackerConfig

Returns

ImageTracker

setResultPostProcessing

Set result post-processing. The default value of enablePersistentTargetInstance is false. When enabled, if the InputFrame data contains spatial information, targetInstances in ImageTrackerResult will include all recognized instances (including those not currently tracked). The default value of enableMotionFusion is false. When enabled, if the InputFrame data contains temporal and spatial information, the pose of targetInstances in ImageTrackerResult will be processed using 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)

Parameters

enablePersistentTargetInstance Boolean
enableMotionFusion Boolean

Returns

Void

setResultAsyncMode

Set result asynchronous mode. If the result is output via outputFrameSource, set it to true. If the result is obtained via getSyncResult, set it to false. The default value of enableAsync is true. Synchronous mode is only effective if the input frame contains spatial information and an XR License is used.

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)

Parameters

enableAsync Boolean

Returns

Boolean

start

Start the tracking algorithm.

bool easyar_ImageTracker_start(easyar_ImageTracker * This)
bool start()
public boolean start()
fun start(): Boolean
- (bool)start
public func start() -> Bool
public virtual bool start()

Returns

Boolean

stop

Pause the tracking algorithm. Call start to restart tracking.

void easyar_ImageTracker_stop(easyar_ImageTracker * This)
void stop()
public void stop()
fun stop(): Unit
- (void)stop
public func stop() -> Void
public virtual void stop()

Returns

Void

close

Close. Should not be used after close.

void easyar_ImageTracker_close(easyar_ImageTracker * This)
void close()
public void close()
fun close(): Unit
- (void)close
public func close() -> Void
public virtual void close()

Returns

Void

loadTarget

Load a Target into the tracker. Target can only be recognized and tracked after being successfully loaded into the tracker. This method is asynchronous. The loading process may take some time to complete. During this period, detecting new and lost targets may take more time than usual, but tracking after detection is unaffected. If you want to know the loading result, you need to handle the callback data. The callback will be called on the thread specified by CallbackScheduler. The tracking thread and other operations except loading/unloading will not be blocked.

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)

Parameters

target Target
callbackScheduler CallbackScheduler
callback Action<,>

Returns

Void

unloadTarget

Unload a Target from the tracker. This method is asynchronous. The unloading process may take some time to complete. During this period, detecting new and lost targets may take more time than usual, but tracking after detection is unaffected. If you want to know the unloading result, you need to handle the callback data. The callback will be called on the thread specified by CallbackScheduler. The tracking thread and other operations except loading/unloading will not be blocked.

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)

Parameters

target Target
callbackScheduler CallbackScheduler
callback Action<,>

Returns

Void

targets

Return the currently loaded Target in the tracker. If an asynchronous load/unload operation is in progress, the return value before the load/unload completes will not reflect the results of these operations.

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()

Returns

List<>

setSimultaneousNum

Set the maximum number of targets that can be tracked by the tracker. The default value is 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)

Parameters

num Int32

Returns

Boolean

simultaneousNum

Get the maximum number of targets that can be tracked by the tracker. The default value is 1.

int easyar_ImageTracker_simultaneousNum(const easyar_ImageTracker * This)
int simultaneousNum()
public int simultaneousNum()
fun simultaneousNum(): Int
- (int)simultaneousNum
public func simultaneousNum() -> Int32
public virtual int simultaneousNum()

Returns

Int32

getSyncResult

Get synchronous output result. If ImageTracker is paused or the result asynchronous mode is not set to false via setResultAsyncMode, the return value is null.

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)

Parameters

motionInputData MotionInputData

Returns

Optional<ImageTrackerResult>