/// Recorder implements recording for current rendering screen.
/// Currently Recorder only works on Android (4.3 or later) and iOS with OpenGL ES 2.0 context.
/// Due to the dependency to OpenGLES, every method in this class (except requestPermissions, including the destructor) has to be called in a single thread containing an OpenGLES context.
/// **Unity Only** If in Unity, Multi-threaded rendering is enabled, scripting thread and rendering thread will be two separate threads, which makes it impossible to call updateFrame in the rendering thread. For this reason, to use Recorder, Multi-threaded rendering option shall be disabled.
/// </summary>
@interfaceeasyar_Recorder:easyar_RefBase
+(instancetype)newNS_UNAVAILABLE;
-(instancetype)initNS_UNAVAILABLE;
/// <summary>
/// Returns true only on Android 4.3 or later, or on iOS.
/// </summary>
+(bool)isAvailable;
/// <summary>
/// Requests recording permissions from operating system. You can call this function or request permission directly from operating system. It is only available on Android and iOS. On other platforms, it will call the callback directly with status being granted. This function need to be called from the UI thread.
/// Get the position component of the vertices in `meshAll` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
voideasyar_SceneMesh_getVerticesAll(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Get the normal component of vertices in `meshAll`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
voideasyar_SceneMesh_getNormalsAll(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Get the index data in `meshAll`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
voideasyar_SceneMesh_getIndicesAll(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// Get the position component of the vertices in `meshUpdated` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
voideasyar_SceneMesh_getVerticesIncremental(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Get the normal component of vertices in `meshUpdated`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
voideasyar_SceneMesh_getNormalsIncremental(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Get the index data in `meshUpdated`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
voideasyar_SceneMesh_getIndicesIncremental(easyar_SceneMesh*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Gets the description object of `mesh block` in `meshUpdate`. The return value is an array of `BlockInfo`_ elements, each of which is a detailed description of a `mesh block`.
/// </summary>
voideasyar_SceneMesh_getBlocksInfoIncremental(easyar_SceneMesh*This,/* OUT */easyar_ListOfBlockInfo**Return);
/// <summary>
/// Get the edge length of a `mesh block` in meters.
/// The dense reconstructed model is represented by triangle mesh, or simply denoted as mesh. Because mesh updates frequently, in order to ensure efficiency, the mesh of the whole reconstruction model is divided into many mesh blocks. A mesh block is composed of a cube about 1 meter long, with attributes such as vertices and indices.
///
/// BlockInfo is used to describe the content of a mesh block. (x, y, z) is the index of mesh block, the coordinates of a mesh block's origin in world coordinate system can be obtained by multiplying (x, y, z) by the physical size of mesh block. You may filter the part you want to display in advance by the mesh block's world coordinates for the sake of saving rendering time.
/// </summary>
structBlockInfo
{
/// <summary>
/// x in index (x, y, z) of mesh block.
/// </summary>
intx;
/// <summary>
/// y in index (x, y, z) of mesh block.
/// </summary>
inty;
/// <summary>
/// z in index (x, y, z) of mesh block.
/// </summary>
intz;
/// <summary>
/// Number of vertices in a mesh block.
/// </summary>
intnumOfVertex;
/// <summary>
/// startPointOfVertex is the starting position of the vertex data stored in the vertex buffer, indicating from where the stored vertices belong to current mesh block. It is not equal to the number of bytes of the offset from the beginning of vertex buffer. The offset is startPointOfVertex*3*4 bytes.
/// </summary>
intstartPointOfVertex;
/// <summary>
/// The number of indices in a mesh block. Each of three consecutive vertices form a triangle.
/// </summary>
intnumOfIndex;
/// <summary>
/// Similar to startPointOfVertex. startPointOfIndex is the starting position of the index data stored in the index buffer, indicating from where the stored indices belong to current mesh block. It is not equal to the number of bytes of the offset from the beginning of index buffer. The offset is startPointOfIndex*3*4 bytes.
/// </summary>
intstartPointOfIndex;
/// <summary>
/// Version represents how many times the mesh block has updated. The larger the version, the newer the block. If the version of a mesh block increases after calling `DenseSpatialMap.updateSceneMesh`_ , it indicates that the mash block has changed.
/// SceneMesh is used to manage and preserve the results of `DenseSpatialMap`_.
/// There are two kinds of meshes saved in SceneMesh, one is the mesh of the whole reconstructed scene, hereinafter referred to as `meshAll`, the other is the recently updated mesh, hereinafter referred to as `meshUpdated`. `meshAll` is a whole mesh, including all vertex data and index data, etc. `meshUpdated` is composed of several `mesh block` s, each `mesh block` is a cube, which contains the mesh formed by the object surface in the corresponding cube space.
/// `meshAll` is available only when the `DenseSpatialMap.updateSceneMesh`_ method is called specifying that all meshes need to be updated. If `meshAll` has been updated previously and not updated in recent times, the data in `meshAll` is remain the same.
/// Get the number of indices in `meshAll`. Since every 3 indices form a triangle, the returned value should be a multiple of 3.
/// </summary>
intgetNumOfIndexAll();
/// <summary>
/// Get the position component of the vertices in `meshAll` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
voidgetVerticesAll(/* OUT */Buffer**Return);
/// <summary>
/// Get the normal component of vertices in `meshAll`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
voidgetNormalsAll(/* OUT */Buffer**Return);
/// <summary>
/// Get the index data in `meshAll`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
voidgetIndicesAll(/* OUT */Buffer**Return);
/// <summary>
/// Get the number of vertices in `meshUpdated`.
/// </summary>
intgetNumOfVertexIncremental();
/// <summary>
/// Get the number of indices in `meshUpdated`. Since every 3 indices form a triangle, the returned value should be a multiple of 3.
/// </summary>
intgetNumOfIndexIncremental();
/// <summary>
/// Get the position component of the vertices in `meshUpdated` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
voidgetVerticesIncremental(/* OUT */Buffer**Return);
/// <summary>
/// Get the normal component of vertices in `meshUpdated`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
voidgetNormalsIncremental(/* OUT */Buffer**Return);
/// <summary>
/// Get the index data in `meshUpdated`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
voidgetIndicesIncremental(/* OUT */Buffer**Return);
/// <summary>
/// Gets the description object of `mesh block` in `meshUpdate`. The return value is an array of `BlockInfo`_ elements, each of which is a detailed description of a `mesh block`.
/// </summary>
voidgetBlocksInfoIncremental(/* OUT */ListOfBlockInfo**Return);
/// <summary>
/// Get the edge length of a `mesh block` in meters.
/// The dense reconstructed model is represented by triangle mesh, or simply denoted as mesh. Because mesh updates frequently, in order to ensure efficiency, the mesh of the whole reconstruction model is divided into many mesh blocks. A mesh block is composed of a cube about 1 meter long, with attributes such as vertices and indices.
///
/// BlockInfo is used to describe the content of a mesh block. (x, y, z) is the index of mesh block, the coordinates of a mesh block's origin in world coordinate system can be obtained by multiplying (x, y, z) by the physical size of mesh block. You may filter the part you want to display in advance by the mesh block's world coordinates for the sake of saving rendering time.
/// </summary>
@interfaceeasyar_BlockInfo:NSObject
/// <summary>
/// x in index (x, y, z) of mesh block.
/// </summary>
@property(nonatomic)intx;
/// <summary>
/// y in index (x, y, z) of mesh block.
/// </summary>
@property(nonatomic)inty;
/// <summary>
/// z in index (x, y, z) of mesh block.
/// </summary>
@property(nonatomic)intz;
/// <summary>
/// Number of vertices in a mesh block.
/// </summary>
@property(nonatomic)intnumOfVertex;
/// <summary>
/// startPointOfVertex is the starting position of the vertex data stored in the vertex buffer, indicating from where the stored vertices belong to current mesh block. It is not equal to the number of bytes of the offset from the beginning of vertex buffer. The offset is startPointOfVertex*3*4 bytes.
/// </summary>
@property(nonatomic)intstartPointOfVertex;
/// <summary>
/// The number of indices in a mesh block. Each of three consecutive vertices form a triangle.
/// </summary>
@property(nonatomic)intnumOfIndex;
/// <summary>
/// Similar to startPointOfVertex. startPointOfIndex is the starting position of the index data stored in the index buffer, indicating from where the stored indices belong to current mesh block. It is not equal to the number of bytes of the offset from the beginning of index buffer. The offset is startPointOfIndex*3*4 bytes.
/// </summary>
@property(nonatomic)intstartPointOfIndex;
/// <summary>
/// Version represents how many times the mesh block has updated. The larger the version, the newer the block. If the version of a mesh block increases after calling `DenseSpatialMap.updateSceneMesh`_ , it indicates that the mash block has changed.
/// SceneMesh is used to manage and preserve the results of `DenseSpatialMap`_.
/// There are two kinds of meshes saved in SceneMesh, one is the mesh of the whole reconstructed scene, hereinafter referred to as `meshAll`, the other is the recently updated mesh, hereinafter referred to as `meshUpdated`. `meshAll` is a whole mesh, including all vertex data and index data, etc. `meshUpdated` is composed of several `mesh block` s, each `mesh block` is a cube, which contains the mesh formed by the object surface in the corresponding cube space.
/// `meshAll` is available only when the `DenseSpatialMap.updateSceneMesh`_ method is called specifying that all meshes need to be updated. If `meshAll` has been updated previously and not updated in recent times, the data in `meshAll` is remain the same.
/// </summary>
@interfaceeasyar_SceneMesh:easyar_RefBase
+(instancetype)newNS_UNAVAILABLE;
-(instancetype)initNS_UNAVAILABLE;
/// <summary>
/// Get the number of vertices in `meshAll`.
/// </summary>
-(int)getNumOfVertexAll;
/// <summary>
/// Get the number of indices in `meshAll`. Since every 3 indices form a triangle, the returned value should be a multiple of 3.
/// </summary>
-(int)getNumOfIndexAll;
/// <summary>
/// Get the position component of the vertices in `meshAll` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
-(easyar_Buffer*)getVerticesAll;
/// <summary>
/// Get the normal component of vertices in `meshAll`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
-(easyar_Buffer*)getNormalsAll;
/// <summary>
/// Get the index data in `meshAll`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
-(easyar_Buffer*)getIndicesAll;
/// <summary>
/// Get the number of vertices in `meshUpdated`.
/// </summary>
-(int)getNumOfVertexIncremental;
/// <summary>
/// Get the number of indices in `meshUpdated`. Since every 3 indices form a triangle, the returned value should be a multiple of 3.
/// </summary>
-(int)getNumOfIndexIncremental;
/// <summary>
/// Get the position component of the vertices in `meshUpdated` (in the world coordinate system). The position of a vertex is described by three coordinates (x, y, z) in meters. The position data are stored tightly in `Buffer`_ by `x1, y1, z1, x2, y2, z2, ...` Each component is of `float` type.
/// </summary>
-(easyar_Buffer*)getVerticesIncremental;
/// <summary>
/// Get the normal component of vertices in `meshUpdated`. The normal of a vertex is described by three components (nx, ny, nz). The normal is normalized, that is, the length is 1. Normal data are stored tightly in `Buffer`_ by `nx1, ny1, nz1, nx2, ny2, nz2,....` Each component is of `float` type.
/// </summary>
-(easyar_Buffer*)getNormalsIncremental;
/// <summary>
/// Get the index data in `meshUpdated`. Each triangle is composed of three indices (ix, iy, iz). Indices are stored tightly in `Buffer`_ by `ix1, iy1, iz1, ix2, iy2, iz2,...` Each component is of `int32` type.
/// </summary>
-(easyar_Buffer*)getIndicesIncremental;
/// <summary>
/// Gets the description object of `mesh block` in `meshUpdate`. The return value is an array of `BlockInfo`_ elements, each of which is a detailed description of a `mesh block`.
/// Returns the pose of the center of the detected plane.The pose's transformed +Y axis will be point normal out of the plane, with the +X and +Z axes orienting the extents of the bounding rectangle.
/// Check whether SparseSpatialMap is is available, always return true.
/// </summary>
booleasyar_SparseSpatialMap_isAvailable(void);
/// <summary>
/// Input port for input frame. For SparseSpatialMap to work, the inputFrame must include camera parameters, timestamp and spatial information. See also `InputFrameSink`_
/// </summary>
voideasyar_SparseSpatialMap_inputFrameSink(easyar_SparseSpatialMap*This,/* OUT */easyar_InputFrameSink**Return);
/// 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.
/// </summary>
voideasyar_SparseSpatialMap_getPointCloudBuffer(easyar_SparseSpatialMap*This,/* OUT */easyar_Buffer**Return);
/// <summary>
/// Returns detected planes in SparseSpatialMap.
/// </summary>
voideasyar_SparseSpatialMap_getMapPlanes(easyar_SparseSpatialMap*This,/* OUT */easyar_ListOfPlaneData**Return);
/// <summary>
/// Perform hit test against the point cloud. The results are returned sorted by their distance to the camera in ascending order.
/// </summary>
voideasyar_SparseSpatialMap_hitTestAgainstPointCloud(easyar_SparseSpatialMap*This,easyar_Vec2FcameraImagePoint,/* OUT */easyar_ListOfVec3F**Return);
/// <summary>
/// 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.
/// </summary>
voideasyar_SparseSpatialMap_hitTestAgainstPlanes(easyar_SparseSpatialMap*This,easyar_Vec2FcameraImagePoint,/* OUT */easyar_ListOfVec3F**Return);
/// <summary>
/// Get the map data version of the current SparseSpatialMap.
/// </summary>
voideasyar_SparseSpatialMap_getMapVersion(/* OUT */easyar_String**Return);
/// <summary>
/// UnloadMap specified SparseSpatialMap data via callback function.The return value of callback indicates whether unload map succeeds (true) or fails (false).
/// Returns the pose of the center of the detected plane.The pose's transformed +Y axis will be point normal out of the plane, with the +X and +Z axes orienting the extents of the bounding rectangle.
/// </summary>
Matrix44FgetPose();
/// <summary>
/// Returns the length of this plane's bounding rectangle measured along the local X-axis of the coordinate space centered on the plane.
/// </summary>
floatgetExtentX();
/// <summary>
/// Returns the length of this plane's bounding rectangle measured along the local Z-axis of the coordinate frame centered on the plane.
/// </summary>
floatgetExtentZ();
};
/// <summary>
/// Configuration used to set the localization mode.
/// Sets localization configurations. See also `LocalizationMode`_.
/// </summary>
voidsetLocalizationMode(LocalizationMode_value);
/// <summary>
/// Returns localization configurations. See also `LocalizationMode`_.
/// </summary>
LocalizationModegetLocalizationMode();
};
/// <summary>
/// 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 <Overview.html>`__ .
/// Check whether SparseSpatialMap is is available, always return true.
/// </summary>
staticboolisAvailable();
/// <summary>
/// Input port for input frame. For SparseSpatialMap to work, the inputFrame must include camera parameters, timestamp and spatial information. See also `InputFrameSink`_
/// </summary>
voidinputFrameSink(/* OUT */InputFrameSink**Return);
/// <summary>
/// Camera buffers occupied in this component.
/// </summary>
intbufferRequirement();
/// <summary>
/// Output port for output frame. See also `OutputFrameSource`_
/// </summary>
voidoutputFrameSource(/* OUT */OutputFrameSource**Return);
/// <summary>
/// Construct SparseSpatialMap.
/// </summary>
staticvoidcreate(/* OUT */SparseSpatialMap**Return);
/// <summary>
/// Start SparseSpatialMap system.
/// </summary>
boolstart();
/// <summary>
/// Stop SparseSpatialMap from running。Can resume running by calling start().
/// </summary>
voidstop();
/// <summary>
/// Close SparseSpatialMap. SparseSpatialMap can no longer be used.
/// </summary>
voidclose();
/// <summary>
/// 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.
/// </summary>
voidgetPointCloudBuffer(/* OUT */Buffer**Return);
/// <summary>
/// Returns detected planes in SparseSpatialMap.
/// </summary>
voidgetMapPlanes(/* OUT */ListOfPlaneData**Return);
/// <summary>
/// Perform hit test against the point cloud. The results are returned sorted by their distance to the camera in ascending order.
/// </summary>
voidhitTestAgainstPointCloud(Vec2FcameraImagePoint,/* OUT */ListOfVec3F**Return);
/// <summary>
/// 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.
/// </summary>
voidhitTestAgainstPlanes(Vec2FcameraImagePoint,/* OUT */ListOfVec3F**Return);
/// <summary>
/// Get the map data version of the current SparseSpatialMap.
/// </summary>
staticvoidgetMapVersion(/* OUT */String**Return);
/// <summary>
/// UnloadMap specified SparseSpatialMap data via callback function.The return value of callback indicates whether unload map succeeds (true) or fails (false).
/// Returns pose of the origin of VIO system in camera coordinate system.
/// </summary>
-(easyar_Matrix44F*)getVioPose;
/// <summary>
/// Returns the pose of origin of the map in camera coordinate system, when localization is successful.
/// Otherwise, returns pose of the origin of VIO system in camera coordinate system.
/// </summary>
-(easyar_Matrix44F*)getMapPose;
/// <summary>
/// Returns true if the system can reliablly locate the pose of the device with regard to the map.
/// Once relocalization succeeds, relative pose can be updated by motion tracking module.
/// As long as the motion tracking module returns normal tracking status, the localization status is also true.
/// </summary>
-(bool)getLocalizationStatus;
/// <summary>
/// Returns current localized map ID.
/// </summary>
-(NSString*)getLocalizationMapID;
@end
@interfaceeasyar_PlaneData:easyar_RefBase
+(instancetype)newNS_UNAVAILABLE;
-(instancetype)initNS_UNAVAILABLE;
/// <summary>
/// Constructor
/// </summary>
+(easyar_PlaneData*)create;
/// <summary>
/// Returns the type of this plane.
/// </summary>
-(easyar_PlaneType)getType;
/// <summary>
/// Returns the pose of the center of the detected plane.The pose's transformed +Y axis will be point normal out of the plane, with the +X and +Z axes orienting the extents of the bounding rectangle.
/// </summary>
-(easyar_Matrix44F*)getPose;
/// <summary>
/// Returns the length of this plane's bounding rectangle measured along the local X-axis of the coordinate space centered on the plane.
/// </summary>
-(float)getExtentX;
/// <summary>
/// Returns the length of this plane's bounding rectangle measured along the local Z-axis of the coordinate frame centered on the plane.
/// </summary>
-(float)getExtentZ;
@end
/// <summary>
/// Configuration used to set the localization mode.
/// Returns localization configurations. See also `LocalizationMode`_.
/// </summary>
-(easyar_LocalizationMode)getLocalizationMode;
@end
/// <summary>
/// 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 <Overview.html>`__ .
/// </summary>
@interfaceeasyar_SparseSpatialMap:easyar_RefBase
+(instancetype)newNS_UNAVAILABLE;
-(instancetype)initNS_UNAVAILABLE;
/// <summary>
/// Check whether SparseSpatialMap is is available, always return true.
/// </summary>
+(bool)isAvailable;
/// <summary>
/// Input port for input frame. For SparseSpatialMap to work, the inputFrame must include camera parameters, timestamp and spatial information. See also `InputFrameSink`_
/// </summary>
-(easyar_InputFrameSink*)inputFrameSink;
/// <summary>
/// Camera buffers occupied in this component.
/// </summary>
-(int)bufferRequirement;
/// <summary>
/// Output port for output frame. See also `OutputFrameSource`_
/// </summary>
-(easyar_OutputFrameSource*)outputFrameSource;
/// <summary>
/// Construct SparseSpatialMap.
/// </summary>
+(easyar_SparseSpatialMap*)create;
/// <summary>
/// Start SparseSpatialMap system.
/// </summary>
-(bool)start;
/// <summary>
/// Stop SparseSpatialMap from running。Can resume running by calling start().
/// </summary>
-(void)stop;
/// <summary>
/// Close SparseSpatialMap. SparseSpatialMap can no longer be used.
/// </summary>
-(void)close;
/// <summary>
/// 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.
/// </summary>
-(easyar_Buffer*)getPointCloudBuffer;
/// <summary>
/// Returns detected planes in SparseSpatialMap.
/// </summary>
-(NSArray<easyar_PlaneData*>*)getMapPlanes;
/// <summary>
/// Perform hit test against the point cloud. The results are returned sorted by their distance to the camera in ascending order.
/// 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.
/// Get the map data version of the current SparseSpatialMap.
/// </summary>
+(NSString*)getMapVersion;
/// <summary>
/// UnloadMap specified SparseSpatialMap data via callback function.The return value of callback indicates whether unload map succeeds (true) or fails (false).
