SparseSpatialMap Class


Provides core components for SparseSpatialMap, can be used for sparse spatial map building as well as localization using existing map. Also provides utilities for point cloud and plane access.

SparseSpatialMap occupies 2 buffers of camera. Use setBufferCapacity of camera to set an amount of buffers that is not less than the sum of amount of buffers occupied by all components. Refer to Overview _ .


Check whether SparseSpatialMap is is available, always return true.

C: bool easyar_SparseSpatialMap_isAvailable(void)
C++17: static bool isAvailable()
Traditional 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()


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

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


Camera buffers occupied in this component.

C: int easyar_SparseSpatialMap_bufferRequirement(easyar_SparseSpatialMap * This)
C++17: int bufferRequirement()
Traditional 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()


Output port for output frame. See also OutputFrameSource

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


Construct SparseSpatialMap.

C: void easyar_SparseSpatialMap_create(easyar_SparseSpatialMap * * Return)
C++17: static std::shared_ptr<SparseSpatialMap> create()
Traditional C++: static void create(SparseSpatialMap * * Return)
Java: public static @Nonnull SparseSpatialMap create()
Kotlin: companion object fun create(): SparseSpatialMap
Objective-C: + (easyar_SparseSpatialMap *)create
Swift: public static func create() -> SparseSpatialMap
C#: public static SparseSpatialMap create()


Start SparseSpatialMap system.

C: bool easyar_SparseSpatialMap_start(easyar_SparseSpatialMap * This)
C++17: bool start()
Traditional 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 SparseSpatialMap from running。Can resume running by calling start().

C: void easyar_SparseSpatialMap_stop(easyar_SparseSpatialMap * This)
C++17: void stop()
Traditional 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()


Close SparseSpatialMap. SparseSpatialMap can no longer be used.

C: void easyar_SparseSpatialMap_close(easyar_SparseSpatialMap * This)
C++17: void close()
Traditional 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()


Returns the buffer of point cloud coordinate. Each 3D point is represented by three consecutive values, representing X, Y, Z position coordinates in the world coordinate space, each of which takes 4 bytes.

C: void easyar_SparseSpatialMap_getPointCloudBuffer(easyar_SparseSpatialMap * This, easyar_Buffer * * Return)
C++17: std::shared_ptr<Buffer> getPointCloudBuffer()
Traditional C++: void getPointCloudBuffer(Buffer * * Return)
Java: public @Nonnull Buffer getPointCloudBuffer()
Kotlin: fun getPointCloudBuffer(): Buffer
Objective-C: - (easyar_Buffer *)getPointCloudBuffer
Swift: public func getPointCloudBuffer() -> Buffer
C#: public virtual Buffer getPointCloudBuffer()


Returns detected planes in SparseSpatialMap.

C: void easyar_SparseSpatialMap_getMapPlanes(easyar_SparseSpatialMap * This, easyar_ListOfPlaneData * * Return)
C++17: std::vector<std::shared_ptr<PlaneData>> getMapPlanes()
Traditional C++: void getMapPlanes(ListOfPlaneData * * Return)
Java: public java.util.@Nonnull ArrayList<@Nonnull PlaneData> getMapPlanes()
Kotlin: fun getMapPlanes(): ArrayList<PlaneData>
Objective-C: - (NSArray<easyar_PlaneData *> *)getMapPlanes
Swift: public func getMapPlanes() -> [PlaneData]
C#: public virtual List<PlaneData> getMapPlanes()


Perform hit test against the point cloud. The results are returned sorted by their distance to the camera in ascending order.

C: void easyar_SparseSpatialMap_hitTestAgainstPointCloud(easyar_SparseSpatialMap * This, easyar_Vec2F cameraImagePoint, easyar_ListOfVec3F * * Return)
C++17: std::vector<Vec3F> hitTestAgainstPointCloud(Vec2F cameraImagePoint)
Traditional C++: void hitTestAgainstPointCloud(Vec2F cameraImagePoint, ListOfVec3F * * Return)
Java: public java.util.@Nonnull ArrayList<@Nonnull Vec3F> hitTestAgainstPointCloud(@Nonnull Vec2F cameraImagePoint)
Kotlin: fun hitTestAgainstPointCloud(cameraImagePoint: Vec2F): ArrayList<Vec3F>
Objective-C: - (NSArray<easyar_Vec3F *> *)hitTestAgainstPointCloud:(easyar_Vec2F *)cameraImagePoint
Swift: public func hitTestAgainstPointCloud(_ cameraImagePoint: Vec2F) -> [Vec3F]
C#: public virtual List<Vec3F> hitTestAgainstPointCloud(Vec2F cameraImagePoint)


Performs ray cast from the user's device in the direction of given screen point.

Intersections with detected planes are returned. 3D positions on physical planes are sorted by distance from the device in ascending order.

For the camera image coordinate system ([0, 1]^2), x-right, y-down, and origin is at left-top corner. CameraParameters.imageCoordinatesFromScreenCoordinates can be used to convert points from screen coordinate system to camera image coordinate system.

The output point cloud coordinate is in the world coordinate system.

C: void easyar_SparseSpatialMap_hitTestAgainstPlanes(easyar_SparseSpatialMap * This, easyar_Vec2F cameraImagePoint, easyar_ListOfVec3F * * Return)
C++17: std::vector<Vec3F> hitTestAgainstPlanes(Vec2F cameraImagePoint)
Traditional C++: void hitTestAgainstPlanes(Vec2F cameraImagePoint, ListOfVec3F * * Return)
Java: public java.util.@Nonnull ArrayList<@Nonnull Vec3F> hitTestAgainstPlanes(@Nonnull Vec2F cameraImagePoint)
Kotlin: fun hitTestAgainstPlanes(cameraImagePoint: Vec2F): ArrayList<Vec3F>
Objective-C: - (NSArray<easyar_Vec3F *> *)hitTestAgainstPlanes:(easyar_Vec2F *)cameraImagePoint
Swift: public func hitTestAgainstPlanes(_ cameraImagePoint: Vec2F) -> [Vec3F]
C#: public virtual List<Vec3F> hitTestAgainstPlanes(Vec2F cameraImagePoint)


Get the map data version of the current SparseSpatialMap.

C: void easyar_SparseSpatialMap_getMapVersion(easyar_String * * Return)
C++17: static std::string getMapVersion()
Traditional C++: static void getMapVersion(String * * Return)
Java: public static java.lang.@Nonnull String getMapVersion()
Kotlin: companion object fun getMapVersion(): String
Objective-C: + (NSString *)getMapVersion
Swift: public static func getMapVersion() -> String
C#: public static string getMapVersion()


UnloadMap specified SparseSpatialMap data via callback function.The return value of callback indicates whether unload map succeeds (true) or fails (false).

C: void easyar_SparseSpatialMap_unloadMap(easyar_SparseSpatialMap * This, easyar_String * mapID, easyar_CallbackScheduler * callbackScheduler, easyar_OptionalOfFunctorOfVoidFromBool resultCallBack)
C++17: void unloadMap(std::string mapID, std::shared_ptr<CallbackScheduler> callbackScheduler, std::optional<std::function<void(bool)>> resultCallBack)
Traditional C++: void unloadMap(String * mapID, CallbackScheduler * callbackScheduler, OptionalOfFunctorOfVoidFromBool resultCallBack)
Java: public void unloadMap(java.lang.@Nonnull String mapID, @Nonnull CallbackScheduler callbackScheduler, @Nullable FunctorOfVoidFromBool resultCallBack)
Kotlin: fun unloadMap(mapID: String, callbackScheduler: CallbackScheduler, resultCallBack: FunctorOfVoidFromBool?): Unit
Objective-C: - (void)unloadMap:(NSString *)mapID callbackScheduler:(easyar_CallbackScheduler *)callbackScheduler resultCallBack:(void (^)(bool))resultCallBack
Swift: public func unloadMap(_ mapID: String, _ callbackScheduler: CallbackScheduler, _ resultCallBack: ((Bool) -> Void)?) -> Void
C#: public virtual void unloadMap(string mapID, CallbackScheduler callbackScheduler, Optional<Action<bool>> resultCallBack)


Set configurations for SparseSpatialMap. See also SparseSpatialMapConfig .

C: void easyar_SparseSpatialMap_setConfig(easyar_SparseSpatialMap * This, easyar_SparseSpatialMapConfig * config)
C++17: void setConfig(std::shared_ptr<SparseSpatialMapConfig> config)
Traditional C++: void setConfig(SparseSpatialMapConfig * config)
Java: public void setConfig(@Nonnull SparseSpatialMapConfig config)
Kotlin: fun setConfig(config: SparseSpatialMapConfig): Unit
Objective-C: - (void)setConfig:(easyar_SparseSpatialMapConfig *)config
Swift: public func setConfig(_ config: SparseSpatialMapConfig) -> Void
C#: public virtual void setConfig(SparseSpatialMapConfig config)


Returns configurations for SparseSpatialMap. See also SparseSpatialMapConfig .

C: void easyar_SparseSpatialMap_getConfig(easyar_SparseSpatialMap * This, easyar_SparseSpatialMapConfig * * Return)
C++17: std::shared_ptr<SparseSpatialMapConfig> getConfig()
Traditional C++: void getConfig(SparseSpatialMapConfig * * Return)
Java: public @Nonnull SparseSpatialMapConfig getConfig()
Kotlin: fun getConfig(): SparseSpatialMapConfig
Objective-C: - (easyar_SparseSpatialMapConfig *)getConfig
Swift: public func getConfig() -> SparseSpatialMapConfig
C#: public virtual SparseSpatialMapConfig getConfig()


Start localization in loaded maps. Should set LocalizationMode first.

C: bool easyar_SparseSpatialMap_startLocalization(easyar_SparseSpatialMap * This)
C++17: bool startLocalization()
Traditional C++: bool startLocalization()
Java: public boolean startLocalization()
Kotlin: fun startLocalization(): Boolean
Objective-C: - (bool)startLocalization
Swift: public func startLocalization() -> Bool
C#: public virtual bool startLocalization()


Stop localization in loaded maps.

C: void easyar_SparseSpatialMap_stopLocalization(easyar_SparseSpatialMap * This)
C++17: void stopLocalization()
Traditional C++: void stopLocalization()
Java: public void stopLocalization()
Kotlin: fun stopLocalization(): Unit
Objective-C: - (void)stopLocalization
Swift: public func stopLocalization() -> Void
C#: public virtual void stopLocalization()