zed_interface.h

Go to the documentation of this file.

#ifndef __INTERFACE_ZED_H
#define __INTERFACE_ZED_H
 
#include "types_c.h"
#include <stdbool.h>
#include <cuda.h>
#include <cuda_runtime.h>
 
 //#define DEBUG
#ifdef _WIN32
#ifdef INTERFACE_NOEXPORT
#define INTERFACE_API
#else
#ifdef INTERFACE_EXPORT
#define INTERFACE_API __declspec(dllexport)
#else
#define INTERFACE_API __declspec(dllimport)
#endif
#endif
#else
#define INTERFACE_API
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
    INTERFACE_API void sl_unload_all_instances();
 
    INTERFACE_API void sl_unload_instance(int camera_id);
 
    INTERFACE_API bool sl_find_usb_device(enum USB_DEVICE device);
 
    INTERFACE_API bool sl_create_camera(int camera_id);
 
    INTERFACE_API bool sl_is_opened(int camera_id);
 
    INTERFACE_API int sl_open_camera(int camera_id, struct SL_InitParameters* init_parameters, const unsigned int serial_number,  const char* path_svo, const char* ip, int stream_port, const char* output_file, const char* opt_settings_path, const char* opencv_calib_path);
 
 
    INTERFACE_API enum SL_ERROR_CODE sl_start_publishing(int camera_id, struct SL_CommunicationParameters* comm_params);
 
    INTERFACE_API enum SL_ERROR_CODE sl_stop_publishing(int camera_id);
 
    INTERFACE_API CUcontext sl_get_cuda_context(int camera_id);
 
    INTERFACE_API struct SL_InitParameters* sl_get_init_parameters(int camera_id);
 
    INTERFACE_API struct SL_RuntimeParameters* sl_get_runtime_parameters(int camera_id);
 
    INTERFACE_API struct SL_PositionalTrackingParameters* sl_get_positional_tracking_parameters(int camera_id);
 
    INTERFACE_API void sl_close_camera(int camera_id);
 
    INTERFACE_API int sl_set_region_of_interest(int camera_id, void* roi_mask, bool module[SL_MODULE_LAST]);
 
    INTERFACE_API int sl_get_region_of_interest(int camera_id, void* roi_mask, int width, int height, enum SL_MODULE module);
    INTERFACE_API int sl_start_region_of_interest_auto_detection(int camera_id, struct SL_RegionOfInterestParameters* roi_param);
    INTERFACE_API enum SL_REGION_OF_INTEREST_AUTO_DETECTION_STATE sl_get_region_of_interest_auto_detection_status(int camera_id);
    INTERFACE_API int sl_grab(int camera_id, struct SL_RuntimeParameters* runtime);
 
    INTERFACE_API void sl_get_device_list(struct SL_DeviceProperties device_list[MAX_CAMERA_PLUGIN], int* nb_devices);
 
    INTERFACE_API void sl_get_streaming_device_list(struct SL_StreamingProperties streaming_device_list[MAX_CAMERA_PLUGIN], int* nb_devices);
 
    INTERFACE_API int sl_reboot(int sn, bool full_reboot);
 
    INTERFACE_API int sl_enable_recording(int camera_id, const char* filename, enum SL_SVO_COMPRESSION_MODE compression_mode, unsigned int bitrate, int target_fps, bool transcode);
 
    INTERFACE_API struct SL_RecordingStatus* sl_get_recording_status(int camera_id);
    INTERFACE_API void sl_disable_recording(int camera_id);
 
    INTERFACE_API struct SL_RecordingParameters* sl_get_recording_parameters(int camera_id);
 
    INTERFACE_API void sl_pause_recording(int camera_id, bool status);
 
    INTERFACE_API enum SL_ERROR_CODE sl_ingest_data_into_svo(int camera_id, struct SL_SVOData* data);
 
    INTERFACE_API int sl_get_svo_data_size(int camera_id, char key[128], unsigned long long ts_begin, unsigned long long ts_end);
 
    INTERFACE_API enum SL_ERROR_CODE sl_retrieve_svo_data(int camera_id, char key[128], int nb_data, struct SL_SVOData* data, unsigned long long ts_begin, unsigned long long ts_end);
 
    INTERFACE_API int sl_get_svo_data_keys_size(int camera_id);
 
    INTERFACE_API void sl_get_svo_data_keys(int camera_id, int nb_keys, char* keys[128]);
 
    INTERFACE_API int sl_enable_positional_tracking(int camera_id, struct SL_PositionalTrackingParameters* tracking_param, const char* area_file_path);
 
    // /**
    // \brief Initializes and starts the positional tracking processes.
    // This function allows you to enable the position estimation of the SDK. It only has to be called once in the camera's lifetime.
    // 
    // \param camera_id : id of the camera instance.
    // \param initial_world_rotation : rotation of the camera in the world frame when the camera is started. By default, it should be identity.
    // \param initial_world_position : position of the camera in the world frame when the camera is started. By default, it should be identity.
    // \param enable_area_memory : this mode enables the camera to remember its surroundings. This helps correct positional tracking drift, and can be helpful for positioning different cameras relative to one other in space.
    // \param enable_pose_smoothing : this mode enables smooth pose correction for small drift correction.
    // \param set_floor_as_origin : this mode initializes the tracking to be aligned with the floor plane to better position the camera in space.
    // \param set_as_static : this mode defines the camera as static. If true, it will not move in the environment. This allows you to set its position using initial_world_transform.
    // \param enable_imu_fusion : this mode enables or disables IMU fusion. When set to false, only the optical odometry will be used.
    // \param area_file_path : area localization file that describes the surroundings, saved from a previous tracking session.
    // \return \ref SL_ERROR_CODE::SUCCESS if everything went fine, ERROR_CODE::FAILURE otherwise.
    //  */
    //  /**INTERFACE_API int enable_positional_tracking(int camera_id, struct SL_Quaternion *initial_world_rotation, struct SL_Vector3 *initial_world_position, bool enable_area_memory, bool enable_pose_smoothing, bool set_floor_as_origin, bool set_as_static,
    //          bool enable_imu_fusion, const char* area_file_path);*/
    
    INTERFACE_API void sl_disable_positional_tracking(int camera_id, const char* area_file_path);
 
    INTERFACE_API int sl_save_area_map(int camera_id, const char* area_file_path);
 
    INTERFACE_API int sl_get_area_export_state(int camera_id);
 
    INTERFACE_API void sl_set_svo_position(int camera_id, int frame_number);
 
    INTERFACE_API float sl_get_camera_fps(int camera_id);
 
    INTERFACE_API float sl_get_current_fps(int camera_id);
 
    int INTERFACE_API sl_get_width(int camera_id);
 
    int INTERFACE_API sl_get_height(int camera_id);
 
    INTERFACE_API int sl_get_confidence_threshold(int camera_id);
 
    INTERFACE_API struct SL_CameraInformation* sl_get_camera_information(int camera_id, int res_width, int res_height);
 
    INTERFACE_API void sl_update_self_calibration(int camera_id);
 
    INTERFACE_API struct SL_CalibrationParameters* sl_get_calibration_parameters(int camera_id, bool raw_params);
 
    INTERFACE_API struct SL_SensorsConfiguration* sl_get_sensors_configuration(int camera_id);
 
    INTERFACE_API void sl_get_camera_imu_transform(int camera_id, struct SL_Vector3* translation, struct SL_Quaternion* rotation);
 
    INTERFACE_API int sl_get_input_type(int camera_id);
 
    INTERFACE_API int sl_get_zed_serial(int camera_id);
 
    INTERFACE_API int sl_get_camera_firmware(int camera_id);
 
    INTERFACE_API int sl_get_sensors_firmware(int camera_id);
 
    INTERFACE_API int sl_get_camera_model(int camera_id);
 
    INTERFACE_API unsigned long long sl_get_image_timestamp(int camera_id);
 
    INTERFACE_API unsigned long long sl_get_current_timestamp(int camera_id);
 
    INTERFACE_API int sl_get_svo_number_of_frames(int camera_id);
 
    INTERFACE_API bool sl_is_camera_setting_supported(int camera_id, enum SL_VIDEO_SETTINGS setting);
 
    INTERFACE_API enum SL_ERROR_CODE sl_set_camera_settings(int camera_id, enum SL_VIDEO_SETTINGS mode, int value);
 
    INTERFACE_API enum SL_ERROR_CODE sl_set_camera_settings_min_max(int camera_id, enum SL_VIDEO_SETTINGS mode, int min, int max);
 
    INTERFACE_API enum SL_ERROR_CODE sl_set_roi_for_aec_agc(int camera_id, enum SL_SIDE side, struct SL_Rect* roi, bool reset);
 
    INTERFACE_API enum SL_ERROR_CODE sl_get_camera_settings(int c_id, enum SL_VIDEO_SETTINGS mode, int* value);
 
    INTERFACE_API enum SL_ERROR_CODE sl_get_camera_settings_min_max(int c_id, enum SL_VIDEO_SETTINGS mode, int* minvalue, int* maxvalue);
 
    INTERFACE_API enum SL_ERROR_CODE sl_get_roi_for_aec_agc(int id, enum SL_SIDE side, struct SL_Rect* roi);
 
    INTERFACE_API float sl_get_depth_min_range_value(int camera_id);
 
    INTERFACE_API float sl_get_depth_max_range_value(int camera_id);
 
    INTERFACE_API int sl_get_current_min_max_depth(int camera_id, float* min, float* max);
 
    INTERFACE_API int sl_get_number_zed_connected();
 
    INTERFACE_API char* sl_get_sdk_version();
 
    INTERFACE_API int sl_convert_coordinate_system(struct SL_Quaternion* rotation, struct SL_Vector3* translation, enum SL_COORDINATE_SYSTEM coord_system_src, enum SL_COORDINATE_SYSTEM coord_system_dest);
 
    // /**
    // \brief Returns the version of the currently installed ZED SDK.
    // \param major : major int of the version filled
    // \param minor : minor int of the version filled
    // \param patch : patch int of the version filled
    //  */
    // INTERFACE_API void sl_get_sdk_version(int *major, int *minor, int *patch);
 
    INTERFACE_API int sl_get_svo_position(int camera_id);
 
    INTERFACE_API int sl_get_svo_position_at_timestamp(int camera_id, unsigned long long timestamp);
 
    INTERFACE_API unsigned int sl_get_frame_dropped_count(int camera_id);
 
 
 
    INTERFACE_API bool sl_is_positional_tracking_enabled(int camera_id);
 
    INTERFACE_API int sl_get_position_at_target_frame(int camera_id, struct SL_Quaternion* rotation, struct SL_Vector3* position, struct SL_Quaternion* target_quaternion, struct SL_Vector3* target_translation, enum SL_REFERENCE_FRAME reference_frame);
    INTERFACE_API int sl_get_position_data(int camera_id, struct SL_PoseData* poseData, enum SL_REFERENCE_FRAME reference_frame);
    INTERFACE_API int sl_get_position(int camera_id, struct SL_Quaternion* rotation, struct SL_Vector3* position, enum SL_REFERENCE_FRAME reference_frame);
    INTERFACE_API int sl_get_position_array(int camera_id, float* pose, enum SL_REFERENCE_FRAME reference_frame);
 
    INTERFACE_API struct SL_PositionalTrackingStatus* sl_get_positional_tracking_status(int camera_id);
 
    INTERFACE_API int sl_reset_positional_tracking(int camera_id, struct SL_Quaternion rotation, struct SL_Vector3 translation);
    INTERFACE_API int sl_reset_positional_tracking_with_offset(int camera_id, struct SL_Quaternion rotation, struct SL_Vector3 translation, struct SL_Quaternion target_quaternion, struct SL_Vector3 target_translation);
    INTERFACE_API int sl_set_imu_prior_orientation(int camera_id, struct SL_Quaternion rotation);
    INTERFACE_API int sl_get_imu_orientation(int camera_id, struct SL_Quaternion* quat, enum SL_TIME_REFERENCE time_reference);
    INTERFACE_API int sl_get_sensors_data(int camera_id, struct SL_SensorsData* data, enum SL_TIME_REFERENCE time_reference);
 
 
 
    INTERFACE_API void sl_spatial_mapping_merge_chunks(int camera_id, int nb_faces, int* nb_vertices, int* nb_triangles, int* nb_updated_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, const int max_submesh);
 
    INTERFACE_API int sl_enable_spatial_mapping(int camera_id, struct SL_SpatialMappingParameters* mapping_param);
    INTERFACE_API void sl_disable_spatial_mapping(int camera_id);
 
    INTERFACE_API struct SL_SpatialMappingParameters* sl_get_spatial_mapping_parameters(int camera_id);
    INTERFACE_API void sl_pause_spatial_mapping(int camera_id, bool status);
    INTERFACE_API void sl_request_mesh_async(int camera_id);
    INTERFACE_API int sl_get_mesh_request_status_async(int camera_id);
    INTERFACE_API enum SL_SPATIAL_MAPPING_STATE sl_get_spatial_mapping_state(int camera_id);
    INTERFACE_API int sl_update_mesh(int camera_id, int* nb_vertices_per_submesh, int* nb_triangles_per_submesh, int* nb_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, const int max_submesh);
    INTERFACE_API int sl_retrieve_mesh(int camera_id, float* vertices, int* triangles, unsigned char* colors, float* uvs, unsigned char* texture_ptr, const int max_submeshes);
    INTERFACE_API int sl_update_chunks(int camera_id, int* nb_vertices_per_submesh, int* nb_triangles_per_submesh, int* nb_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, const int max_submesh);
    INTERFACE_API int sl_retrieve_chunks(int camera_id, float* vertices, int* triangles, unsigned char* colors, float* uvs, unsigned char* texture_ptr, const int max_submesh);
 
    INTERFACE_API int sl_update_fused_point_cloud(int camera_id, int* nb_vertices_tot);
    INTERFACE_API int sl_retrieve_fused_point_cloud(int camera_id, float* vertices);
    INTERFACE_API int sl_extract_whole_spatial_map(int camera_id);
    INTERFACE_API bool sl_save_mesh(int camera_id, const char* filename, enum SL_MESH_FILE_FORMAT format);
    INTERFACE_API bool sl_save_point_cloud(int c_id, const char* filename, enum SL_MESH_FILE_FORMAT format);
    INTERFACE_API bool sl_load_mesh(int camera_id, const char* filename, int* nb_vertices_per_submesh, int* nb_triangles_per_submesh, int* num_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, int* textures_size, const int max_submesh);
    INTERFACE_API bool sl_apply_texture(int camera_id, int* nb_vertices_per_submesh, int* nb_triangles_per_submesh, int* nb_updated_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, int* textures_size, const int max_submesh);
    INTERFACE_API bool sl_filter_mesh(int camera_id, enum SL_MESH_FILTER filter_params, int* nb_vertices_per_submesh, int* nb_triangles_per_submesh, int* nb_updated_submeshes, int* updated_indices, int* nb_vertices_tot, int* nb_triangles_tot, const int max_submesh);
    INTERFACE_API void sl_spatial_mapping_get_gravity_estimation(int camera_id, struct SL_Vector3* gravity);
 
 
 
    INTERFACE_API int sl_update_whole_mesh(int camera_id, int* nb_vertices, int* nb_triangles);
    INTERFACE_API int sl_retrieve_whole_mesh(int camera_id, float* vertices, int* triangles, unsigned char* colors,  float* uvs, unsigned char* texture_ptr);
    INTERFACE_API bool sl_load_whole_mesh(int camera_id, const char* filename, int* nb_vertices, int* nb_triangles, int* texture_size);
    INTERFACE_API bool sl_apply_whole_texture(int camera_id, int* nb_vertices, int* nb_triangles, int* texture_size);
    INTERFACE_API bool sl_filter_whole_mesh(int camera_id, enum SL_MESH_FILTER filter_params, int* nb_vertices, int* nb_triangles);
 
 
 
    INTERFACE_API struct SL_PlaneData* sl_find_floor_plane(int camera_id, struct SL_Quaternion* reset_quaternion, struct SL_Vector3* reset_translation, struct SL_Quaternion prior_rotation, struct SL_Vector3 prior_translation);
    INTERFACE_API struct SL_PlaneData* sl_find_plane_at_hit(int camera_id, struct SL_Vector2 pixel, struct SL_PlaneDetectionParameters* params, bool thres);
    INTERFACE_API int sl_convert_floorplane_to_mesh(int camera_id, float* vertices, int* triangles, int* nb_vertices_tot, int* nb_triangles_tot);
    INTERFACE_API int sl_convert_hitplane_to_mesh(int camera_id, float* vertices, int* triangles, int* nb_vertices_tot, int* nb_triangles_tot);
 
 
 
    INTERFACE_API int sl_retrieve_measure(int camera_id, void* measure_ptr, enum SL_MEASURE type, enum SL_MEM mem, int width, int height);
    INTERFACE_API int sl_retrieve_image(int camera_id, void* image_ptr, enum SL_VIEW type, enum SL_MEM mem, int width, int height);
 
    INTERFACE_API int sl_convert_image(void* image_in_ptr, void* image_signed_ptr, cudaStream_t stream);
 
 
    INTERFACE_API int sl_enable_streaming(int camera_id, enum SL_STREAMING_CODEC codec, unsigned int bitrate, unsigned short port, int gop_size, int adaptative_bitrate, int chunk_size, int target_framerate);
 
    INTERFACE_API void sl_disable_streaming(int camera_id);
    INTERFACE_API int sl_is_streaming_enabled(int camera_id);
 
    INTERFACE_API struct SL_StreamingParameters* sl_get_streaming_parameters(int camera_id);
 
 
    INTERFACE_API int sl_save_current_image(int camera_id, enum SL_VIEW view, const char* file_name);
    INTERFACE_API int sl_save_current_depth(int camera_id, enum SL_SIDE side, const char* file_name);
    INTERFACE_API int sl_save_current_point_cloud(int camera_id, enum SL_SIDE side, const char* file_name);
 
 
 
#if WITH_OBJECT_DETECTION
 
 
    INTERFACE_API struct SL_AI_Model_status* sl_check_AI_model_status(enum SL_AI_MODELS model, int gpu_id);
 
    INTERFACE_API int sl_optimize_AI_model(enum SL_AI_MODELS model, int gpu_id);
 
    INTERFACE_API int sl_enable_object_detection(int camera_id, struct SL_ObjectDetectionParameters* object_detection_parameters);
 
    INTERFACE_API struct SL_ObjectDetectionParameters* sl_get_object_detection_parameters(int camera_id);
 
 
    INTERFACE_API void sl_disable_object_detection(int camera_id, unsigned int instance_id, bool force_disable_all_instances);
 
    INTERFACE_API int sl_enable_body_tracking(int camera_id, struct SL_BodyTrackingParameters* body_tracking_parameters);
 
    INTERFACE_API struct SL_BodyTrackingParameters* sl_get_body_tracking_parameters(int camera_id);
 
    INTERFACE_API void sl_disable_body_tracking(int camera_id, unsigned int instance_id, bool force_disable_all_instances);
 
    INTERFACE_API int sl_generate_unique_id(char* uuid);
 
    INTERFACE_API int sl_ingest_custom_box_objects(int camera_id, int nb_objects, struct SL_CustomBoxObjectData* objects_in);
 
    INTERFACE_API int sl_retrieve_objects(int camera_id, struct SL_ObjectDetectionRuntimeParameters* object_detection_runtime_parameters, struct SL_Objects* objects, unsigned int instance_id);
 
    INTERFACE_API int sl_retrieve_bodies(int camera_id, struct SL_BodyTrackingRuntimeParameters* body_tracking_runtime_parameters, struct SL_Bodies* bodies, unsigned int instance_id);
 
 
    INTERFACE_API int sl_update_objects_batch(int camera_id, int* nb_batches);
 
    INTERFACE_API int sl_get_objects_batch(int camera_id, int index, struct SL_ObjectsBatch* objs_batch);
 
    INTERFACE_API int sl_get_objects_batch_csharp(int camera_id, int index, int* nb_data, int* id, int* label, int* sublabel, int* tracking_state,
        struct SL_Vector3 positions[MAX_TRAJECTORY_SIZE], float position_covariances[MAX_TRAJECTORY_SIZE][6], struct SL_Vector3 velocities[MAX_TRAJECTORY_SIZE], unsigned long long timestamps[MAX_TRAJECTORY_SIZE],
        struct SL_Vector2 bounding_boxes_2d[MAX_TRAJECTORY_SIZE][4], struct SL_Vector3 bounding_boxes[MAX_TRAJECTORY_SIZE][8], float confidences[MAX_TRAJECTORY_SIZE], int action_states[MAX_TRAJECTORY_SIZE],
        struct SL_Vector2 head_bounding_boxes_2d[MAX_TRAJECTORY_SIZE][4], struct SL_Vector3 head_bounding_boxes[MAX_TRAJECTORY_SIZE][8],
        struct SL_Vector3 head_positions[MAX_TRAJECTORY_SIZE]);
 
#if 0
    INTERFACE_API int sl_update_bodies_batch(int camera_id, int* nb_batches);
 
 
 
    INTERFACE_API int sl_get_bodies_batch(int camera_id, int index, struct SL_BodiesBatch* bodies_batch);
 
 
#endif
#endif
#ifdef __cplusplus
}
#endif
 
 
#ifdef __cplusplus
extern "C" {
#endif
    
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_init(struct SL_InitFusionParameters* params);
    
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_process();
 
    /*
    * \brief adds a camera to the multi camera handler
    * \param [in] uuid : unique ID that is associated with the camera for easy access.
    * \param [in] params : communications parameters
    * \param [in] pose_translation : position of the camera
    * \param [in] pose_rotation : orientation of the camera
    * \return SL_FUSION_ERROR_CODE
    * */
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_subscribe(struct SL_CameraIdentifier* uuid, struct SL_CommunicationParameters* params, struct SL_Vector3* pose_translation, struct SL_Quaternion* pose_rotation);
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_retrieve_image(void* mat, struct SL_CameraIdentifier* uuid, int width, int height);
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_retrieve_measure(void* mat, struct SL_CameraIdentifier* uuid, enum SL_MEASURE measure, int width, int height);
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_unsubscribe(struct SL_CameraIdentifier* uuid);
 
    /*
    * \brief update the pose of the camera in the fusion coordinate space
    * \param [in] uuid : unique ID that is associated with the camera for easy access.
    * \param [in] pose_translation : new position of the camera
    * \param [in] pose_rotation : new orientation of the camera
    * \return SL_FUSION_ERROR_CODE
    * */
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_update_pose(struct SL_CameraIdentifier* uuid, struct SL_Vector3* pose_translation, struct SL_Quaternion* pose_rotation);
    
    /*
    * \brief Returns the state of a connected data sender.
    * \param [in] uuid : Identifier of the camera.
    * \return SL_SENDER_ERROR_CODE : State of the sender 
    * */
    INTERFACE_API enum SL_SENDER_ERROR_CODE sl_fusion_get_sender_state(struct SL_CameraIdentifier* uuid);
 
    INTERFACE_API void sl_fusion_read_configuration_file(char json_config_filename[256], enum SL_COORDINATE_SYSTEM coord_system, enum SL_UNIT unit, struct SL_FusionConfiguration* configs, int* nb_cameras);
 
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_enable_body_tracking(struct SL_BodyTrackingFusionParameters* params);
 
    INTERFACE_API void sl_fusion_disable_body_tracking();
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_retrieve_bodies(struct SL_Bodies* bodies, struct SL_BodyTrackingFusionRuntimeParameters* rt, struct SL_CameraIdentifier uuid);
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_get_process_metrics(struct SL_FusionMetrics* metrics);
 
 
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_enable_positional_tracking(struct SL_PositionalTrackingFusionParameters* params);
 
    INTERFACE_API enum SL_POSITIONAL_TRACKING_STATE sl_fusion_get_position(struct SL_PoseData* pose, enum SL_REFERENCE_FRAME reference_frame, enum SL_UNIT unit,
                                                           struct SL_CameraIdentifier* uuid, enum SL_POSITION_TYPE retrieve_type);
 
 
    INTERFACE_API struct SL_FusedPositionalTrackingStatus* sl_fusion_get_fused_positional_tracking_status();
 
    INTERFACE_API void sl_fusion_disable_positional_tracking();
 
 
    INTERFACE_API enum SL_FUSION_ERROR_CODE sl_fusion_ingest_gnss_data(struct SL_GNSSData* gnss_data, bool radian);
 
    INTERFACE_API enum SL_POSITIONAL_TRACKING_STATE sl_fusion_get_current_gnss_data(struct SL_GNSSData* data, bool radian);
 
    INTERFACE_API enum SL_GNSS_FUSION_STATUS sl_fusion_get_geo_pose(struct SL_GeoPose* pose, bool radian);
 
    INTERFACE_API enum SL_GNSS_FUSION_STATUS sl_fusion_geo_to_camera(struct SL_LatLng* in, struct SL_PoseData* out, bool radian);
 
    INTERFACE_API enum SL_GNSS_FUSION_STATUS sl_fusion_camera_to_geo(struct SL_PoseData* in, struct SL_GeoPose* out, bool radian);
 
    INTERFACE_API unsigned long long sl_fusion_get_current_timestamp();
 
    INTERFACE_API enum SL_GNSS_FUSION_STATUS sl_fusion_get_current_gnss_calibration_std(float* yaw_std, struct SL_Vector3* position_std);
 
    INTERFACE_API void sl_fusion_get_geo_tracking_calibration(struct SL_Vector3* translation, struct SL_Quaternion* rotation);
 
    INTERFACE_API void sl_fusion_close();
 
#ifdef __cplusplus
}
#endif
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
    INTERFACE_API void* sl_mat_create_new(int width, int height, enum SL_MAT_TYPE type, enum SL_MEM mem);
    INTERFACE_API void* sl_mat_create_new_empty();
    INTERFACE_API bool sl_mat_is_init(void* ptr);
    INTERFACE_API void sl_mat_free(void* ptr, enum SL_MEM mem);
    INTERFACE_API void sl_mat_get_infos(void* ptr, char* buffer);
 
    // GET values
    INTERFACE_API int sl_mat_get_value_uchar(void* ptr, int col, int row, unsigned char* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_uchar2(void* ptr, int col, int row, struct SL_Uchar2* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_uchar3(void* ptr, int col, int row, struct SL_Uchar3* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_uchar4(void* ptr, int col, int row, struct SL_Uchar4* value, enum SL_MEM mem);
 
    INTERFACE_API int sl_mat_get_value_float(void* ptr, int col, int row, float* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_float2(void* ptr, int col, int row, struct SL_Vector2* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_float3(void* ptr, int col, int row, struct SL_Vector3* value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_value_float4(void* ptr, int col, int row, struct SL_Vector4* value, enum SL_MEM mem);
 
    // SET VALUE
    INTERFACE_API int sl_mat_set_value_uchar(void* ptr, int col, int row, unsigned char value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_uchar2(void* ptr, int col, int row, struct SL_Uchar2 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_uchar3(void* ptr, int col, int row, struct SL_Uchar3 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_uchar4(void* ptr, int col, int row, struct SL_Uchar4 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_float(void* ptr, int col, int row, float value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_float2(void* ptr, int col, int row, struct SL_Vector2 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_float3(void* ptr, int col, int row, struct SL_Vector3 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_value_float4(void* ptr, int col, int row, struct SL_Vector4 value, enum SL_MEM mem);
 
    //SET TO
    INTERFACE_API int sl_mat_set_to_uchar(void* ptr, unsigned char value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_uchar2(void* ptr, struct SL_Uchar2 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_uchar3(void* ptr, struct SL_Uchar3 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_uchar4(void* ptr, struct SL_Uchar4 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_float(void* ptr, float value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_float2(void* ptr, struct SL_Vector2 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_float3(void* ptr, struct SL_Vector3 value, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_to_float4(void* ptr, struct SL_Vector4 value, enum SL_MEM mem);
 
    INTERFACE_API int sl_mat_update_cpu_from_gpu(void* ptr);
    INTERFACE_API int sl_mat_update_gpu_from_cpu(void* ptr);
    INTERFACE_API int sl_mat_copy_to(void* ptr, void* ptr_dest, enum SL_COPY_TYPE cpy_type);
 
    INTERFACE_API int sl_mat_read(void* ptr, const char* file_path);
    INTERFACE_API int sl_mat_write(void* ptr, const char* file_path);
    INTERFACE_API int sl_mat_get_width(void* ptr);
    INTERFACE_API int sl_mat_get_height(void* ptr);
    INTERFACE_API int sl_mat_get_channels(void* ptr);
    INTERFACE_API int sl_mat_get_memory_type(void* ptr);
 
    INTERFACE_API int sl_mat_get_data_type(void* ptr);
    INTERFACE_API int sl_mat_get_pixel_bytes(void* ptr);
    INTERFACE_API int sl_mat_get_step(void* ptr, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_step_bytes(void* ptr, enum SL_MEM mem);
    INTERFACE_API int sl_mat_get_width_bytes(void* ptr);
    INTERFACE_API bool sl_mat_is_memory_owner(void* ptr);
    INTERFACE_API struct SL_Resolution sl_mat_get_resolution(void* ptr);
    INTERFACE_API void sl_mat_alloc(void* ptr, int width, int height, enum SL_MAT_TYPE type, enum SL_MEM mem);
    INTERFACE_API int sl_mat_set_from(void* ptr, void* ptr_source, enum SL_COPY_TYPE copy_type);
    INTERFACE_API int* sl_mat_get_ptr(void* ptr, enum SL_MEM mem);
    INTERFACE_API int sl_mat_clone(void* ptr, void* ptr_source);
 
    INTERFACE_API void sl_mat_swap(void* ptr_1, void* ptr_2);
 
#ifdef __cplusplus
}
#endif
 
#endif