MegaTracker Class¶

Description¶

Provides cloud based localization.

MegaTracker occupies 1 buffers of camera.

isAvailable¶

Check whether SparseSpatialMap is is available, always return true.

C: bool easyar_MegaTracker_isAvailable(void)
C++: static bool isAvailable()
Java: public static boolean isAvailable()
Kotlin: companion object fun isAvailable(): Boolean
Objective-C: + (bool)isAvailable
Swift: public static func isAvailable() -> Bool
C#: public static bool isAvailable()

inputFrameSink¶

Input port for input frame. For MegaTracker to work, the inputFrame must include camera parameters, timestamp and spatial information. See also InputFrameSink .

C: void easyar_MegaTracker_inputFrameSink(easyar_MegaTracker * This, easyar_InputFrameSink * * Return)
C++: std::shared_ptr<InputFrameSink> inputFrameSink()
Java: public @Nonnull InputFrameSink inputFrameSink()
Kotlin: fun inputFrameSink(): InputFrameSink
Objective-C: - (easyar_InputFrameSink *)inputFrameSink
Swift: public func inputFrameSink() -> InputFrameSink
C#: public virtual InputFrameSink inputFrameSink()

accelerometerResultSink¶

Input port for accelerometer result. See also AccelerometerResultSink .

C: void easyar_MegaTracker_accelerometerResultSink(easyar_MegaTracker * This, easyar_AccelerometerResultSink * * Return)
C++: std::shared_ptr<AccelerometerResultSink> accelerometerResultSink()
Java: public @Nonnull AccelerometerResultSink accelerometerResultSink()
Kotlin: fun accelerometerResultSink(): AccelerometerResultSink
Objective-C: - (easyar_AccelerometerResultSink *)accelerometerResultSink
Swift: public func accelerometerResultSink() -> AccelerometerResultSink
C#: public virtual AccelerometerResultSink accelerometerResultSink()

locationResultSink¶

Optional. Input port for location result. See also LocationResultSink .

C: void easyar_MegaTracker_locationResultSink(easyar_MegaTracker * This, easyar_LocationResultSink * * Return)
C++: std::shared_ptr<LocationResultSink> locationResultSink()
Java: public @Nonnull LocationResultSink locationResultSink()
Kotlin: fun locationResultSink(): LocationResultSink
Objective-C: - (easyar_LocationResultSink *)locationResultSink
Swift: public func locationResultSink() -> LocationResultSink
C#: public virtual LocationResultSink locationResultSink()

proximityLocationResultSink¶

Optional. Input port for proximity location result. See also ProximityLocationResultSink .

C: void easyar_MegaTracker_proximityLocationResultSink(easyar_MegaTracker * This, easyar_ProximityLocationResultSink * * Return)
C++: std::shared_ptr<ProximityLocationResultSink> proximityLocationResultSink()
Java: public @Nonnull ProximityLocationResultSink proximityLocationResultSink()
Kotlin: fun proximityLocationResultSink(): ProximityLocationResultSink
Objective-C: - (easyar_ProximityLocationResultSink *)proximityLocationResultSink
Swift: public func proximityLocationResultSink() -> ProximityLocationResultSink
C#: public virtual ProximityLocationResultSink proximityLocationResultSink()

bufferRequirement¶

Camera buffers occupied in this component.

C: int easyar_MegaTracker_bufferRequirement(easyar_MegaTracker * This)
C++: int bufferRequirement()
Java: public int bufferRequirement()
Kotlin: fun bufferRequirement(): Int
Objective-C: - (int)bufferRequirement
Swift: public func bufferRequirement() -> Int32
C#: public virtual int bufferRequirement()

outputFrameSource¶

Output port for output frame. See also OutputFrameSource .

C: void easyar_MegaTracker_outputFrameSource(easyar_MegaTracker * This, easyar_OutputFrameSource * * Return)
C++: std::shared_ptr<OutputFrameSource> outputFrameSource()
Java: public @Nonnull OutputFrameSource outputFrameSource()
Kotlin: fun outputFrameSource(): OutputFrameSource
Objective-C: - (easyar_OutputFrameSource *)outputFrameSource
Swift: public func outputFrameSource() -> OutputFrameSource
C#: public virtual OutputFrameSource outputFrameSource()

create¶

Creates an instance.

C: void easyar_MegaTracker_create(easyar_String * server, easyar_String * apiKey, easyar_String * apiSecret, easyar_String * appId, easyar_MegaTracker * * Return)
C++: static std::shared_ptr<MegaTracker> create(std::string server, std::string apiKey, std::string apiSecret, std::string appId)
Java: public static @Nonnull MegaTracker create(java.lang.@Nonnull String server, java.lang.@Nonnull String apiKey, java.lang.@Nonnull String apiSecret, java.lang.@Nonnull String appId)
Kotlin: companion object fun create(server: String, apiKey: String, apiSecret: String, appId: String): MegaTracker
Objective-C: + (easyar_MegaTracker *)create:(NSString *)server apiKey:(NSString *)apiKey apiSecret:(NSString *)apiSecret appId:(NSString *)appId
Swift: public static func create(_ server: String, _ apiKey: String, _ apiSecret: String, _ appId: String) throws -> MegaTracker
C#: public static MegaTracker create(string server, string apiKey, string apiSecret, string appId)

createWithToken¶

Creates an instance with API Token.

C: void easyar_MegaTracker_createWithToken(easyar_String * server, easyar_String * apiToken, easyar_String * appId, easyar_MegaTracker * * Return)
C++: static std::shared_ptr<MegaTracker> createWithToken(std::string server, std::string apiToken, std::string appId)
Java: public static @Nonnull MegaTracker createWithToken(java.lang.@Nonnull String server, java.lang.@Nonnull String apiToken, java.lang.@Nonnull String appId)
Kotlin: companion object fun createWithToken(server: String, apiToken: String, appId: String): MegaTracker
Objective-C: + (easyar_MegaTracker *)createWithToken:(NSString *)server apiToken:(NSString *)apiToken appId:(NSString *)appId
Swift: public static func createWithToken(_ server: String, _ apiToken: String, _ appId: String) throws -> MegaTracker
C#: public static MegaTracker createWithToken(string server, string apiToken, string appId)

updateToken¶

Updates API Token.

C: void easyar_MegaTracker_updateToken(easyar_MegaTracker * This, easyar_String * apiToken)
C++: void updateToken(std::string apiToken)
Java: public void updateToken(java.lang.@Nonnull String apiToken)
Kotlin: fun updateToken(apiToken: String): Unit
Objective-C: - (void)updateToken:(NSString *)apiToken
Swift: public func updateToken(_ apiToken: String) -> Void
C#: public virtual void updateToken(string apiToken)

setMegaApiType¶

Sets MEGA API Type. The default is Block.

C: void easyar_MegaTracker_setMegaApiType(easyar_MegaTracker * This, easyar_MegaApiType type)
C++: void setMegaApiType(MegaApiType type)
Java: public void setMegaApiType(int type)
Kotlin: fun setMegaApiType(type: Int): Unit
Objective-C: - (void)setMegaApiType:(easyar_MegaApiType)type
Swift: public func setMegaApiType(_ type: MegaApiType) -> Void
C#: public virtual void setMegaApiType(MegaApiType type)

setSpotVersionId¶

Sets the spot version ID. Only available with MegaApiType.Landmark .

C: void easyar_MegaTracker_setSpotVersionId(easyar_MegaTracker * This, easyar_OptionalOfString spotVersionId)
C++: void setSpotVersionId(std::optional<std::string> spotVersionId)
Java: public void setSpotVersionId(java.lang.@Nullable String spotVersionId)
Kotlin: fun setSpotVersionId(spotVersionId: String?): Unit
Objective-C: - (void)setSpotVersionId:(NSString *)spotVersionId
Swift: public func setSpotVersionId(_ spotVersionId: String?) -> Void
C#: public virtual void setSpotVersionId(Optional<string> spotVersionId)

switchEndPoint¶

Switches remote end point.

C: void easyar_MegaTracker_switchEndPoint(easyar_MegaTracker * This, easyar_String * server, easyar_String * apiKey, easyar_String * apiSecret, easyar_String * appId)
C++: void switchEndPoint(std::string server, std::string apiKey, std::string apiSecret, std::string appId)
Java: public void switchEndPoint(java.lang.@Nonnull String server, java.lang.@Nonnull String apiKey, java.lang.@Nonnull String apiSecret, java.lang.@Nonnull String appId)
Kotlin: fun switchEndPoint(server: String, apiKey: String, apiSecret: String, appId: String): Unit
Objective-C: - (void)switchEndPoint:(NSString *)server apiKey:(NSString *)apiKey apiSecret:(NSString *)apiSecret appId:(NSString *)appId
Swift: public func switchEndPoint(_ server: String, _ apiKey: String, _ apiSecret: String, _ appId: String) -> Void
C#: public virtual void switchEndPoint(string server, string apiKey, string apiSecret, string appId)

switchEndPointWithToken¶

Switches remote end point with API Token.

C: void easyar_MegaTracker_switchEndPointWithToken(easyar_MegaTracker * This, easyar_String * server, easyar_String * apiToken, easyar_String * appId)
C++: void switchEndPointWithToken(std::string server, std::string apiToken, std::string appId)
Java: public void switchEndPointWithToken(java.lang.@Nonnull String server, java.lang.@Nonnull String apiToken, java.lang.@Nonnull String appId)
Kotlin: fun switchEndPointWithToken(server: String, apiToken: String, appId: String): Unit
Objective-C: - (void)switchEndPointWithToken:(NSString *)server apiToken:(NSString *)apiToken appId:(NSString *)appId
Swift: public func switchEndPointWithToken(_ server: String, _ apiToken: String, _ appId: String) -> Void
C#: public virtual void switchEndPointWithToken(string server, string apiToken, string appId)

bindBlockPrior¶

Binds to a specific block prior. An automatic unbind will be performed during reset or end point switching.

C: void easyar_MegaTracker_bindBlockPrior(easyar_MegaTracker * This, easyar_BlockPriorResult * blockPrior)
C++: void bindBlockPrior(std::shared_ptr<BlockPriorResult> blockPrior)
Java: public void bindBlockPrior(@Nonnull BlockPriorResult blockPrior)
Kotlin: fun bindBlockPrior(blockPrior: BlockPriorResult): Unit
Objective-C: - (void)bindBlockPrior:(easyar_BlockPriorResult *)blockPrior
Swift: public func bindBlockPrior(_ blockPrior: BlockPriorResult) -> Void
C#: public virtual void bindBlockPrior(BlockPriorResult blockPrior)

unbindBlockPrior¶

Release bind to any block.

C: void easyar_MegaTracker_unbindBlockPrior(easyar_MegaTracker * This)
C++: void unbindBlockPrior()
Java: public void unbindBlockPrior()
Kotlin: fun unbindBlockPrior(): Unit
Objective-C: - (void)unbindBlockPrior
Swift: public func unbindBlockPrior() -> Void
C#: public virtual void unbindBlockPrior()

setRequestTimeParameters¶

Sets request time parameters. timeoutMilliseconds is connection timeout. requestIntervalMilliseconds is the expected request interval, and the default value is 1000 and the minimum value is 300, with a longer value results a larger overall error.

C: void easyar_MegaTracker_setRequestTimeParameters(easyar_MegaTracker * This, easyar_OptionalOfInt timeoutMilliseconds, int requestIntervalMilliseconds)
C++: void setRequestTimeParameters(std::optional<int> timeoutMilliseconds, int requestIntervalMilliseconds)
Java: public void setRequestTimeParameters(java.lang.@Nullable Integer timeoutMilliseconds, int requestIntervalMilliseconds)
Kotlin: fun setRequestTimeParameters(timeoutMilliseconds: Int?, requestIntervalMilliseconds: Int): Unit
Objective-C: - (void)setRequestTimeParameters:(NSNumber *)timeoutMilliseconds requestIntervalMilliseconds:(int)requestIntervalMilliseconds
Swift: public func setRequestTimeParameters(_ timeoutMilliseconds: Int32?, _ requestIntervalMilliseconds: Int32) -> Void
C#: public virtual void setRequestTimeParameters(Optional<int> timeoutMilliseconds, int requestIntervalMilliseconds)

setResultPoseType¶

Sets type of result pose. enableLocalization and enableStabilization default to true.

C: void easyar_MegaTracker_setResultPoseType(easyar_MegaTracker * This, bool enableLocalization, bool enableStabilization)
C++: void setResultPoseType(bool enableLocalization, bool enableStabilization)
Java: public void setResultPoseType(boolean enableLocalization, boolean enableStabilization)
Kotlin: fun setResultPoseType(enableLocalization: Boolean, enableStabilization: Boolean): Unit
Objective-C: - (void)setResultPoseType:(bool)enableLocalization enableStabilization:(bool)enableStabilization
Swift: public func setResultPoseType(_ enableLocalization: Bool, _ enableStabilization: Bool) -> Void
C#: public virtual void setResultPoseType(bool enableLocalization, bool enableStabilization)

setResultAsyncMode¶

Sets result async mode. Set true If results are to be outputted via outputFrameSource, false if results are to be fetched via getSyncResult. enableAsync defaults to true. Sync mode is only available with a XR license.

C: bool easyar_MegaTracker_setResultAsyncMode(easyar_MegaTracker * This, bool enableAsync)
C++: bool setResultAsyncMode(bool enableAsync)
Java: public boolean setResultAsyncMode(boolean enableAsync)
Kotlin: fun setResultAsyncMode(enableAsync: Boolean): Boolean
Objective-C: - (bool)setResultAsyncMode:(bool)enableAsync
Swift: public func setResultAsyncMode(_ enableAsync: Bool) -> Bool
C#: public virtual bool setResultAsyncMode(bool enableAsync)

setRequestMessage¶

C: void easyar_MegaTracker_setRequestMessage(easyar_MegaTracker * This, easyar_String * message)
C++: void setRequestMessage(std::string message)
Java: public void setRequestMessage(java.lang.@Nonnull String message)
Kotlin: fun setRequestMessage(message: String): Unit
Objective-C: - (void)setRequestMessage:(NSString *)message
Swift: public func setRequestMessage(_ message: String) -> Void
C#: public virtual void setRequestMessage(string message)

setLocalizationCallback¶

Sets localization callback. On every localization, the callback will be triggered.

C: void easyar_MegaTracker_setLocalizationCallback(easyar_MegaTracker * This, easyar_CallbackScheduler * callbackScheduler, easyar_OptionalOfFunctorOfVoidFromMegaTrackerLocalizationResponse callback)
C++: void setLocalizationCallback(std::shared_ptr<CallbackScheduler> callbackScheduler, std::optional<std::function<void(std::shared_ptr<MegaTrackerLocalizationResponse>)>> callback)
Java: public void setLocalizationCallback(@Nonnull CallbackScheduler callbackScheduler, @Nullable FunctorOfVoidFromMegaTrackerLocalizationResponse callback)
Kotlin: fun setLocalizationCallback(callbackScheduler: CallbackScheduler, callback: FunctorOfVoidFromMegaTrackerLocalizationResponse?): Unit
Objective-C: - (void)setLocalizationCallback:(easyar_CallbackScheduler *)callbackScheduler callback:(void (^)(easyar_MegaTrackerLocalizationResponse * response))callback
Swift: public func setLocalizationCallback(_ callbackScheduler: CallbackScheduler, _ callback: ((MegaTrackerLocalizationResponse) -> Void)?) -> Void
C#: public virtual void setLocalizationCallback(CallbackScheduler callbackScheduler, Optional<Action<MegaTrackerLocalizationResponse>> callback)

start¶

Start MegaTracker.

C: bool easyar_MegaTracker_start(easyar_MegaTracker * This)
C++: bool start()
Java: public boolean start()
Kotlin: fun start(): Boolean
Objective-C: - (bool)start
Swift: public func start() -> Bool
C#: public virtual bool start()

stop¶

Stop MegaTracker. Call start() to resume running.

C: void easyar_MegaTracker_stop(easyar_MegaTracker * This)
C++: void stop()
Java: public void stop()
Kotlin: fun stop(): Unit
Objective-C: - (void)stop
Swift: public func stop() -> Void
C#: public virtual void stop()

reset¶

Reset MegaTracker and clear all internal states.

C: void easyar_MegaTracker_reset(easyar_MegaTracker * This)
C++: void reset()
Java: public void reset()
Kotlin: fun reset(): Unit
Objective-C: - (void)reset
Swift: public func reset() -> Void
C#: public virtual void reset()

close¶

Close MegaTracker. MegaTracker can no longer be used.

C: void easyar_MegaTracker_close(easyar_MegaTracker * This)
C++: void close()
Java: public void close()
Kotlin: fun close(): Unit
Objective-C: - (void)close
Swift: public func close() -> Void
C#: public virtual void close()

getSyncResult¶

Get synchronized result. If MegaTracker is paused, or the result async mode is not set to false through setResultAsyncMode, the return value is empty.

C: void easyar_MegaTracker_getSyncResult(easyar_MegaTracker * This, easyar_MotionInputData * motionInputData, easyar_OptionalOfMegaTrackerResult * Return)
C++: std::optional<std::shared_ptr<MegaTrackerResult>> getSyncResult(std::shared_ptr<MotionInputData> motionInputData)
Java: public @Nullable MegaTrackerResult getSyncResult(@Nonnull MotionInputData motionInputData)
Kotlin: fun getSyncResult(motionInputData: MotionInputData): MegaTrackerResult?
Objective-C: - (easyar_MegaTrackerResult *)getSyncResult:(easyar_MotionInputData *)motionInputData
Swift: public func getSyncResult(_ motionInputData: MotionInputData) -> MegaTrackerResult?
C#: public virtual Optional<MegaTrackerResult> getSyncResult(MotionInputData motionInputData)