ImageTracker Class

Inherits: TargetTracker

Description

ImageTracker实现了image target的检测和跟踪。

ImageTracker检测和跟踪 ImageTarget 。你需要首先调用 attachStreamer 将 FrameStreamer 连接至ImageTracker，然后 FrameStreamer 的输出图像将被tracker使用。你可以通过start/stop来开始和停止跟踪。start和stop是非常轻量的调用。

在Target可以被ImageTracker跟踪之前，你需要通过异步方法loadTarget/unloadTarget或同步方法loadTargetBlocked/unloadTargetBlocked将它载入。如果需要非阻塞的调用，推荐使用异步的接口。可以通过传入接口的回调来获取load/unload的结果。

可以使用 FrameStreamer.peek 来获取一帧 Frame 。Frame中包含当前的camera图像和跟踪到的 TargetInstance 。

Constructor

C: void easyar_ImageTracker__ctor(easyar_ImageTracker * * Return)

C++11: ImageTracker()

Traditional C++: ImageTracker()

Java: public ImageTracker()

Objective-C: + (easyar_ImageTracker *) create

Swift (since EasyAR SDK 2.1.0): public convenience init()

默认的模式是 ImageTrackerMode.PreferQuality 。

createWithMode

C: void easyar_ImageTracker_createWithMode(easyar_ImageTrackerMode mode, easyar_ImageTracker * * Return)

C++11: static std::shared_ptr<ImageTracker> createWithMode(ImageTrackerMode mode)

Traditional C++: static void createWithMode(ImageTrackerMode mode, ImageTracker * * Return)

Java: public static native ImageTracker createWithMode(int mode)

Objective-C: + (easyar_ImageTracker *)createWithMode:(easyar_ImageTrackerMode)mode

Swift (since EasyAR SDK 2.1.0): public static func createWithMode(_ mode: ImageTrackerMode) -> ImageTracker

(since 2.2.0) 在2.2.0中，我们增强了跟踪的质量，但在低端手机上可能会运行更慢和更耗能。可以使用 ImageTrackerMode.PreferPerformance 来获得更好的性能，但是跟踪效果会有些许损失。

loadTarget

加载一个 Target 进入tracker。Target只有在成功加载进入tracker之后才能被识别和跟踪。

这个方法是异步方法。加载过程可能会需要一些时间来完成，这段时间内新的和丢失的target的检测可能会花比平时更多的时间，但是检测到之后的跟踪不受影响。如果你希望知道加载的结果，需要处理callback数据。callback将会在其它线程上被调用。跟踪线程和除了其它加载/卸载之外的操作都不会被阻塞。

C: void easyar_ImageTracker_loadTarget(easyar_ImageTracker * This, easyar_Target * target, easyar_FunctorOfVoidFromPointerOfTargetAndBool callback)

C++11: void loadTarget(std::shared_ptr<Target> target, std::function<void(std::shared_ptr<Target>, bool)> callback)

Traditional C++: void loadTarget(Target * target, FunctorOfVoidFromPointerOfTargetAndBool callback)

Java: public native void loadTarget(Target target, FunctorOfVoidFromPointerOfTargetAndBool callback)

Objective-C: - (void)loadTarget:(easyar_Target *)target callback:(void (^)(easyar_Target * target, bool status))callback

Swift (since EasyAR SDK 2.1.0): public override func loadTarget(_ target: Target, _ callback: @escaping (Target, Bool) -> Void) -> Void

unloadTarget

从tracker中卸载 Target 。

这个方法是异步方法。卸载过程可能会需要一些时间来完成，这段时间内新的和丢失的target的检测可能会花比平时更多的时间，但是检测到之后的跟踪不受影响。如果你希望知道卸载的结果，需要处理callback数据。callback将会在其它线程上被调用。跟踪线程和除了其它加载/卸载之外的操作都不会被阻塞。

C: void easyar_ImageTracker_unloadTarget(easyar_ImageTracker * This, easyar_Target * target, easyar_FunctorOfVoidFromPointerOfTargetAndBool callback)

C++11: void unloadTarget(std::shared_ptr<Target> target, std::function<void(std::shared_ptr<Target>, bool)> callback)

Traditional C++: void unloadTarget(Target * target, FunctorOfVoidFromPointerOfTargetAndBool callback)

Java: public native void unloadTarget(Target target, FunctorOfVoidFromPointerOfTargetAndBool callback)

Objective-C: - (void)unloadTarget:(easyar_Target *)target callback:(void (^)(easyar_Target * target, bool status))callback

Swift (since EasyAR SDK 2.1.0): public override func unloadTarget(_ target: Target, _ callback: @escaping (Target, Bool) -> Void) -> Void

loadTargetBlocked

加载一个 Target 进入tracker。Target只有在成功加载进入tracker之后才能被识别和跟踪。

这是个同步方法。加载过程可能会需要一些时间来完成，这段时间内新的和丢失的target的检测可能会花比平时更多的时间，但是检测到之后的跟踪不受影响。它会阻塞调用线程。但是跟踪线程以及camera线程等不会被阻塞。

C: bool easyar_ImageTracker_loadTargetBlocked(easyar_ImageTracker * This, easyar_Target * target)

C++11: bool loadTargetBlocked(std::shared_ptr<Target> target)

Traditional C++: bool loadTargetBlocked(Target * target)

Java: public native boolean loadTargetBlocked(Target target)

Objective-C: - (bool)loadTargetBlocked:(easyar_Target *)target

Swift (since EasyAR SDK 2.1.0): public override func loadTargetBlocked(_ target: Target) -> Bool

unloadTargetBlocked

从tracker中卸载 Target 。

这是个同步方法。卸载过程可能会需要一些时间来完成，这段时间内新的和丢失的target的检测可能会花比平时更多的时间，但是检测到之后的跟踪不受影响。它会阻塞调用线程。但是跟踪线程以及camera线程等不会被阻塞。

C: bool easyar_ImageTracker_unloadTargetBlocked(easyar_ImageTracker * This, easyar_Target * target)

C++11: bool unloadTargetBlocked(std::shared_ptr<Target> target)

Traditional C++: bool unloadTargetBlocked(Target * target)

Java: public native boolean unloadTargetBlocked(Target target)

Objective-C: - (bool)unloadTargetBlocked:(easyar_Target *)target

Swift (since EasyAR SDK 2.1.0): public override func unloadTargetBlocked(_ target: Target) -> Bool

targets

返回当前已经被加载进入tracker的target。如果异步的加载/卸载正在执行，在加载/卸载完成之前的返回值将不会反应这些加载/卸载的结果。

C: void easyar_ImageTracker_targets(easyar_ImageTracker * This, easyar_ListOfPointerOfTarget * * Return)

C++11: std::vector<std::shared_ptr<Target>> targets()

Traditional C++: void targets(ListOfPointerOfTarget * * Return)

Java: public native java.util.ArrayList<Target> targets()

Objective-C: - (NSArray<easyar_Target *> *)targets

Swift (since EasyAR SDK 2.1.0): public override func targets() -> [Target]

setSimultaneousNum

设置最大可被tracker跟踪的目标个数。默认值为1。

C: bool easyar_ImageTracker_setSimultaneousNum(easyar_ImageTracker * This, int num)

C++11: bool setSimultaneousNum(int num)

Traditional C++: bool setSimultaneousNum(int num)

Java: public native boolean setSimultaneousNum(int num)

Objective-C: - (bool)setSimultaneousNum:(int)num

Swift (since EasyAR SDK 2.1.0): public override func setSimultaneousNum(_ num: Int32) -> Bool

simultaneousNum

获取最大可被tracker跟踪的目标个数。默认值为1。

C: int easyar_ImageTracker_simultaneousNum(easyar_ImageTracker * This)

C++11: int simultaneousNum()

Traditional C++: int simultaneousNum()

Java: public native int simultaneousNum()

Objective-C: - (int)simultaneousNum

Swift (since EasyAR SDK 2.1.0): public override func simultaneousNum() -> Int32

attachStreamer

将FrameStreamer连接到tracker。在有FrameStreamer连接之前，tracker不会开始运行跟踪。

Attach null object 将会断开tracker之前与 FrameStreamer 的连接。

C: bool easyar_ImageTracker_attachStreamer(easyar_ImageTracker * This, easyar_FrameStreamer * obj)

C++11: bool attachStreamer(std::shared_ptr<FrameStreamer> obj)

Traditional C++: bool attachStreamer(FrameStreamer * obj)

Java: public native boolean attachStreamer(FrameStreamer obj)

Objective-C: - (bool)attachStreamer:(easyar_FrameStreamer *)obj

Swift (since EasyAR SDK 2.1.0): public override func attachStreamer(_ obj: FrameStreamer?) -> Bool

start

开始跟踪算法。在有FrameStreamer连接之前跟踪不会真正开始。

C: bool easyar_ImageTracker_start(easyar_ImageTracker * This)

C++11: bool start()

Traditional C++: bool start()

Java: public native boolean start()

Objective-C: - (bool)start

Swift (since EasyAR SDK 2.1.0): public override func start() -> Bool

stop

停止跟踪算法。调用start来重新启动跟踪。

C: bool easyar_ImageTracker_stop(easyar_ImageTracker * This)

C++11: bool stop()

Traditional C++: bool stop()

Java: public native boolean stop()

Objective-C: - (bool)stop

Swift (since EasyAR SDK 2.1.0): public override func stop() -> Bool