MegaLandmarkTracker Class¶

Description¶

Provides cloud based visual positioning localization.

MegaLandmarkTracker occupies 1 buffers of camera.

isAvailable¶

Check whether SparseSpatialMap is is available, always return true.

C: bool easyar_MegaLandmarkTracker_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 MegaLandmarkTracker to work, the inputFrame must include camera parameters, timestamp and spatial information. See also InputFrameSink .

C: void easyar_MegaLandmarkTracker_inputFrameSink(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_accelerometerResultSink(easyar_MegaLandmarkTracker * 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¶

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

C: void easyar_MegaLandmarkTracker_locationResultSink(easyar_MegaLandmarkTracker * 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¶

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

C: void easyar_MegaLandmarkTracker_proximityLocationResultSink(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_bufferRequirement(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_outputFrameSource(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_create(easyar_String * server, easyar_String * apiKey, easyar_String * apiSecret, easyar_String * appId, easyar_MegaLandmarkTracker * * Return)
C++: static std::shared_ptr<MegaLandmarkTracker> create(std::string server, std::string apiKey, std::string apiSecret, std::string appId)
Java: public static @Nonnull MegaLandmarkTracker 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): MegaLandmarkTracker
Objective-C: + (easyar_MegaLandmarkTracker *)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) -> MegaLandmarkTracker
C#: public static MegaLandmarkTracker create(string server, string apiKey, string apiSecret, string appId)

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_MegaLandmarkTracker_setRequestTimeParameters(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_setResultPoseType(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_setResultAsyncMode(easyar_MegaLandmarkTracker * 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_MegaLandmarkTracker_setRequestMessage(easyar_MegaLandmarkTracker * 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)

setFilteringCallback¶

Sets location filtering callback. On every location filtering, the callback will be triggered.

C: void easyar_MegaLandmarkTracker_setFilteringCallback(easyar_MegaLandmarkTracker * This, easyar_CallbackScheduler * callbackScheduler, easyar_OptionalOfFunctorOfVoidFromMegaLandmarkTrackerFilteringResponse callback)
C++: void setFilteringCallback(std::shared_ptr<CallbackScheduler> callbackScheduler, std::optional<std::function<void(std::shared_ptr<MegaLandmarkTrackerFilteringResponse>)>> callback)
Java: public void setFilteringCallback(@Nonnull CallbackScheduler callbackScheduler, @Nullable FunctorOfVoidFromMegaLandmarkTrackerFilteringResponse callback)
Kotlin: fun setFilteringCallback(callbackScheduler: CallbackScheduler, callback: FunctorOfVoidFromMegaLandmarkTrackerFilteringResponse?): Unit
Objective-C: - (void)setFilteringCallback:(easyar_CallbackScheduler *)callbackScheduler callback:(void (^)(easyar_MegaLandmarkTrackerFilteringResponse * response))callback
Swift: public func setFilteringCallback(_ callbackScheduler: CallbackScheduler, _ callback: ((MegaLandmarkTrackerFilteringResponse) -> Void)?) -> Void
C#: public virtual void setFilteringCallback(CallbackScheduler callbackScheduler, Optional<Action<MegaLandmarkTrackerFilteringResponse>> callback)

setLocalizationCallback¶

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

C: void easyar_MegaLandmarkTracker_setLocalizationCallback(easyar_MegaLandmarkTracker * This, easyar_CallbackScheduler * callbackScheduler, easyar_OptionalOfFunctorOfVoidFromMegaLandmarkTrackerLocalizationResponse callback)
C++: void setLocalizationCallback(std::shared_ptr<CallbackScheduler> callbackScheduler, std::optional<std::function<void(std::shared_ptr<MegaLandmarkTrackerLocalizationResponse>)>> callback)
Java: public void setLocalizationCallback(@Nonnull CallbackScheduler callbackScheduler, @Nullable FunctorOfVoidFromMegaLandmarkTrackerLocalizationResponse callback)
Kotlin: fun setLocalizationCallback(callbackScheduler: CallbackScheduler, callback: FunctorOfVoidFromMegaLandmarkTrackerLocalizationResponse?): Unit
Objective-C: - (void)setLocalizationCallback:(easyar_CallbackScheduler *)callbackScheduler callback:(void (^)(easyar_MegaLandmarkTrackerLocalizationResponse * response))callback
Swift: public func setLocalizationCallback(_ callbackScheduler: CallbackScheduler, _ callback: ((MegaLandmarkTrackerLocalizationResponse) -> Void)?) -> Void
C#: public virtual void setLocalizationCallback(CallbackScheduler callbackScheduler, Optional<Action<MegaLandmarkTrackerLocalizationResponse>> callback)

start¶

Start MegaLandmarkTracker.

C: bool easyar_MegaLandmarkTracker_start(easyar_MegaLandmarkTracker * 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 MegaLandmarkTracker. Call start() to resume running.

C: void easyar_MegaLandmarkTracker_stop(easyar_MegaLandmarkTracker * 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 MegaLandmarkTracker and clear all internal states.

C: void easyar_MegaLandmarkTracker_reset(easyar_MegaLandmarkTracker * 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 MegaLandmarkTracker. MegaLandmarkTracker can no longer be used.

C: void easyar_MegaLandmarkTracker_close(easyar_MegaLandmarkTracker * 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 MegaLandmarkTracker is paused, or the result async mode is not set to false through setResultAsyncMode, the return value is empty.

C: void easyar_MegaLandmarkTracker_getSyncResult(easyar_MegaLandmarkTracker * This, double timestamp, easyar_Matrix44F cameraTransform, easyar_MotionTrackingStatus trackingStatus, easyar_OptionalOfMegaLandmarkTrackerResult * Return)
C++: std::optional<std::shared_ptr<MegaLandmarkTrackerResult>> getSyncResult(double timestamp, Matrix44F cameraTransform, MotionTrackingStatus trackingStatus)
Java: public @Nullable MegaLandmarkTrackerResult getSyncResult(double timestamp, @Nonnull Matrix44F cameraTransform, int trackingStatus)
Kotlin: fun getSyncResult(timestamp: Double, cameraTransform: Matrix44F, trackingStatus: Int): MegaLandmarkTrackerResult?
Objective-C: - (easyar_MegaLandmarkTrackerResult *)getSyncResult:(double)timestamp cameraTransform:(easyar_Matrix44F *)cameraTransform trackingStatus:(easyar_MotionTrackingStatus)trackingStatus
Swift: public func getSyncResult(_ timestamp: Double, _ cameraTransform: Matrix44F, _ trackingStatus: MotionTrackingStatus) -> MegaLandmarkTrackerResult?
C#: public virtual Optional<MegaLandmarkTrackerResult> getSyncResult(double timestamp, Matrix44F cameraTransform, MotionTrackingStatus trackingStatus)