types_c.h

Go to the documentation of this file.

#ifndef __TYPES_C_H__
#define __TYPES_C_H__
 
#define MAX_FUSED_CAMERAS 20
#define WITH_OBJECT_DETECTION 1
#ifdef WITH_UNLIMITED_CAMERA
#define MAX_CAMERA_PLUGIN 20
#else
#define MAX_CAMERA_PLUGIN 4
#endif
 
#define MAX_SUBMESH 1000
 
#include <stdbool.h>
#include <stdint.h>
#include "cuda.h"
 
struct SL_Quaternion {
    float x; 
    float y; 
    float z; 
    float w; 
};
 
struct SL_Vector2 {
    float x;
    float y;
};
 
struct SL_Uint2 {
    unsigned int x;
    unsigned int y;
};
 
struct SL_Vector3 {
    float x;
    float y;
    float z;
};
 
struct SL_Vector4 {
    float x;
    float y;
    float z;
    float w;
};
 
struct SL_Transform
{
    struct SL_Vector3 translation;
    struct SL_Quaternion rotation;
};
 
struct SL_Uchar2 {
    unsigned char x;
    unsigned char y;
};
 
struct SL_Uchar3 {
    unsigned char x;
    unsigned char y;
    unsigned char z;
};
 
struct SL_Uchar4 {
    unsigned char x;
    unsigned char y;
    unsigned char z;
    unsigned char w;
};
 
struct SL_Matrix4f {
    float p[16];
};
 
struct SL_Matrix3f {
    float p[9];
};
 
struct SL_PoseData {
    bool valid;
    uint64_t timestamp;
    struct SL_Quaternion rotation; 
    struct SL_Vector3 translation; 
    int pose_confidence;
    float pose_covariance[36]; 
    float twist[6];
    float twist_covariance[36];
};
 
enum UNITY_PLAN_TYPE {
    UNITY_PLAN_TYPE_FLOOR,
    UNITY_PLAN_TYPE_HIT_HORIZONTAL,
    UNITY_PLAN_TYPE_HIT_VERTICAL,
    UNITY_PLAN_TYPE_HIT_UNKNOWN
};
 
struct SL_PlaneData {
    int error_code; 
    enum UNITY_PLAN_TYPE type;
    struct SL_Vector3 plane_normal; 
    struct SL_Vector3 plane_center; 
    struct SL_Vector3 plane_transform_position; 
    struct SL_Quaternion plane_transform_orientation; 
    struct SL_Vector4 plane_equation;
    struct SL_Vector2 extents; 
    int bounds_size; 
    struct SL_Vector3 bounds[256]; //max 256 points but only BoundsSize are actually filled
};
 
struct SL_IMUData {
    bool is_available;
    uint64_t timestamp_ns;
    struct SL_Vector3 angular_velocity;
    struct SL_Vector3 linear_acceleration;
    struct SL_Vector3 angular_velocity_unc; //uncalibrated
    struct SL_Vector3 linear_acceleration_unc; //uncalibrated
    struct SL_Quaternion orientation;
    struct SL_Matrix3f orientation_covariance;
    struct SL_Matrix3f angular_velocity_convariance;
    struct SL_Matrix3f linear_acceleration_convariance;
};
 
struct SL_BarometerData {
    bool is_available; 
    uint64_t timestamp_ns; 
    float pressure; 
    float relative_altitude; 
};
 
enum SL_HEADING_STATE {
    SL_HEADING_STATE_GOOD,
    SL_HEADING_STATE_OK,
    SL_HEADING_STATE_NOT_GOOD,
    SL_HEADING_STATE_NOT_CALIBRATED,
    SL_HEADING_STATE_MAG_NOT_AVAILABLE,
    SL_HEADING_STATE_LAST
};
 
struct SL_MagnetometerData {
    bool is_available;
    uint64_t  timestamp_ns;
    struct SL_Vector3 magnetic_field_c; //calibrated
    struct SL_Vector3 magnetic_field_unc; //uncalibrated
    float magnetic_heading;
    enum SL_HEADING_STATE magnetic_heading_state;
    float magnetic_heading_accuracy;
    float effective_rate;
};
 
struct SL_TemperatureData {
    float imu_temp; 
    float barometer_temp; 
    float onboard_left_temp; 
    float onboard_right_temp; 
};
 
struct SL_SensorsData {
    //IMU data
    struct SL_IMUData imu; 
    struct SL_BarometerData barometer; 
    struct SL_MagnetometerData magnetometer; 
    struct SL_TemperatureData temperature; 
    int camera_moving_state;
 
    int image_sync_trigger;
};
 
enum SL_ERROR_CODE {
    SL_ERROR_CODE_SENSOR_CONFIGURATION_CHANGED = -6, 
    SL_ERROR_CODE_POTENTIAL_CALIBRATION_ISSUE = -5, 
    SL_ERROR_CODE_CONFIGURATION_FALLBACK = -4,
    SL_ERROR_CODE_SENSORS_DATA_REQUIRED = -3,
    SL_ERROR_CODE_CORRUPTED_FRAME = -2,
    SL_ERROR_CODE_CAMERA_REBOOTING = -1, 
    SL_ERROR_CODE_SUCCESS, 
    SL_ERROR_CODE_FAILURE, 
    SL_ERROR_CODE_NO_GPU_COMPATIBLE, 
    SL_ERROR_CODE_NOT_ENOUGH_GPU_MEMORY, 
    SL_ERROR_CODE_CAMERA_NOT_DETECTED, 
    SL_ERROR_CODE_SENSORS_NOT_INITIALIZED, 
    SL_ERROR_CODE_SENSORS_NOT_AVAILABLE, 
    SL_ERROR_CODE_INVALID_RESOLUTION, 
    SL_ERROR_CODE_LOW_USB_BANDWIDTH, 
    SL_ERROR_CODE_CALIBRATION_FILE_NOT_AVAILABLE, 
    SL_ERROR_CODE_INVALID_CALIBRATION_FILE, 
    SL_ERROR_CODE_INVALID_SVO_FILE, 
    SL_ERROR_CODE_SVO_RECORDING_ERROR, 
    SL_ERROR_CODE_SVO_UNSUPPORTED_COMPRESSION, 
    SL_ERROR_CODE_END_OF_SVOFILE_REACHED, 
    SL_ERROR_CODE_INVALID_COORDINATE_SYSTEM, 
    SL_ERROR_CODE_INVALID_FIRMWARE, 
    SL_ERROR_CODE_INVALID_FUNCTION_PARAMETERS, 
    SL_ERROR_CODE_CUDA_ERROR, 
    SL_ERROR_CODE_CAMERA_NOT_INITIALIZED, 
    SL_ERROR_CODE_NVIDIA_DRIVER_OUT_OF_DATE, 
    SL_ERROR_CODE_INVALID_FUNCTION_CALL, 
    SL_ERROR_CODE_CORRUPTED_SDK_INSTALLATION, 
    SL_ERROR_CODE_INCOMPATIBLE_SDK_VERSION, 
    SL_ERROR_CODE_INVALID_AREA_FILE, 
    SL_ERROR_CODE_INCOMPATIBLE_AREA_FILE, 
    SL_ERROR_CODE_CAMERA_FAILED_TO_SETUP, 
    SL_ERROR_CODE_CAMERA_DETECTION_ISSUE, 
    SL_ERROR_CODE_CANNOT_START_CAMERA_STREAM, 
    SL_ERROR_CODE_NO_GPU_DETECTED, 
    SL_ERROR_CODE_PLANE_NOT_FOUND, 
    SL_ERROR_CODE_MODULE_NOT_COMPATIBLE_WITH_CAMERA, 
    SL_ERROR_CODE_MOTION_SENSORS_REQUIRED, 
    SL_ERROR_CODE_MODULE_NOT_COMPATIBLE_WITH_CUDA_VERSION, 
    SL_ERROR_CODE_DRIVER_FAILURE,  
    SL_ERROR_CODE_CAMERA_EXCEEDS_BANDWIDTH 
};
 
enum SL_RESOLUTION {
    SL_RESOLUTION_HD4K, 
    SL_RESOLUTION_QHDPLUS, 
    SL_RESOLUTION_HD2K, 
    SL_RESOLUTION_HD1536, 
    SL_RESOLUTION_HD1080, 
    SL_RESOLUTION_HD1200, 
    SL_RESOLUTION_HD720, 
    SL_RESOLUTION_SVGA, 
    SL_RESOLUTION_VGA, 
    SL_RESOLUTION_XVGA, 
    SL_RESOLUTION_TXGA, 
    SL_RESOLUTION_AUTO, 
};
 
enum SL_UNIT {
    SL_UNIT_MILLIMETER, 
    SL_UNIT_CENTIMETER, 
    SL_UNIT_METER, 
    SL_UNIT_INCH, 
    SL_UNIT_FOOT 
};
 
enum SL_COORDINATE_SYSTEM {
    SL_COORDINATE_SYSTEM_IMAGE, 
    SL_COORDINATE_SYSTEM_LEFT_HANDED_Y_UP, 
    SL_COORDINATE_SYSTEM_RIGHT_HANDED_Y_UP, 
    SL_COORDINATE_SYSTEM_RIGHT_HANDED_Z_UP, 
    SL_COORDINATE_SYSTEM_LEFT_HANDED_Z_UP, 
    SL_COORDINATE_SYSTEM_RIGHT_HANDED_Z_UP_X_FWD 
};
 
enum SL_CAMERA_STATE {
    SL_CAMERA_STATE_AVAILABLE, 
    SL_CAMERA_STATE_NOT_AVAILABLE, 
};
 
enum SL_MODEL {
    SL_MODEL_ZED, 
    SL_MODEL_ZED_M, 
    SL_MODEL_ZED2, 
    SL_MODEL_ZED2i, 
    SL_MODEL_ZED_X, 
    SL_MODEL_ZED_XM, 
    SL_MODEL_ZED_X_HDR, 
    SL_MODEL_ZED_X_HDR_MINI, 
    SL_MODEL_ZED_X_HDR_MAX, 
    SL_MODEL_ZED_X_NANO, 
    SL_MODEL_VIRTUAL_ZED_X = 11, 
    SL_MODEL_ZED_XONE_GS = 30, 
    SL_MODEL_ZED_XONE_UHD = 31, 
    SL_MODEL_ZED_XONE_HDR = 32, 
};
 
enum SL_MEM
{
    SL_MEM_CPU, 
    SL_MEM_GPU,  
    SL_MEM_BOTH 
};
 
enum SL_BUS_TYPE {
    SL_BUS_TYPE_USB,  
    SL_BUS_TYPE_GMSL, 
    SL_BUS_TYPE_AUTO 
};
 
enum SL_SENSOR_TYPE {
    SL_SENSOR_TYPE_ACCELEROMETER, 
    SL_SENSOR_TYPE_GYROSCOPE, 
    SL_SENSOR_TYPE_MAGNETOMETER, 
    SL_SENSOR_TYPE_BAROMETER, 
};
 
enum SL_SENSORS_UNIT {
    SL_SENSORS_UNIT_M_SEC_2, 
    SL_SENSORS_UNIT_DEG_SEC, 
    SL_SENSORS_UNIT_U_T, 
    SL_SENSORS_UNIT_HPA, 
    SL_SENSORS_UNIT_CELSIUS, 
    SL_SENSORS_UNIT_HERTZ, 
};
 
enum SL_SIDE {
    SL_SIDE_LEFT, 
    SL_SIDE_RIGHT, 
    SL_SIDE_BOTH 
};
 
enum SL_INPUT_TYPE {
    SL_INPUT_TYPE_USB, 
    SL_INPUT_TYPE_SVO, 
    SL_INPUT_TYPE_STREAM, 
    SL_INPUT_TYPE_GMSL 
};
 
enum SL_REFERENCE_FRAME
{
    SL_REFERENCE_FRAME_WORLD,  
    SL_REFERENCE_FRAME_CAMERA, 
};
 
enum SL_TIME_REFERENCE {
    SL_TIME_REFERENCE_IMAGE, 
    SL_TIME_REFERENCE_CURRENT, 
};
 
enum SL_TIMESTAMP_CLOCK {
    SL_TIMESTAMP_CLOCK_SYSTEM_CLOCK, 
    SL_TIMESTAMP_CLOCK_MONOTONIC_CLOCK, 
};
 
enum SL_STREAMING_CODEC {
    SL_STREAMING_CODEC_H264, 
    SL_STREAMING_CODEC_H265, 
};
 
enum SL_VIDEO_SETTINGS
{
    SL_VIDEO_SETTINGS_BRIGHTNESS, 
    SL_VIDEO_SETTINGS_CONTRAST, 
    SL_VIDEO_SETTINGS_HUE, 
    SL_VIDEO_SETTINGS_SATURATION, 
    SL_VIDEO_SETTINGS_SHARPNESS, 
    SL_VIDEO_SETTINGS_GAMMA, 
    SL_VIDEO_SETTINGS_GAIN, 
    SL_VIDEO_SETTINGS_EXPOSURE, 
    SL_VIDEO_SETTINGS_AEC_AGC, 
    SL_VIDEO_SETTINGS_AEC_AGC_ROI, 
    SL_VIDEO_SETTINGS_WHITEBALANCE_TEMPERATURE, 
    SL_VIDEO_SETTINGS_WHITEBALANCE_AUTO, 
    SL_VIDEO_SETTINGS_LED_STATUS, 
    SL_VIDEO_SETTINGS_EXPOSURE_TIME, 
    SL_VIDEO_SETTINGS_ANALOG_GAIN, 
    SL_VIDEO_SETTINGS_DIGITAL_GAIN, 
    SL_VIDEO_SETTINGS_AUTO_EXPOSURE_TIME_RANGE, 
    SL_VIDEO_SETTINGS_AUTO_ANALOG_GAIN_RANGE, 
    SL_VIDEO_SETTINGS_AUTO_DIGITAL_GAIN_RANGE, 
    SL_VIDEO_SETTINGS_EXPOSURE_COMPENSATION, 
    SL_VIDEO_SETTINGS_DENOISING, 
    SL_VIDEO_SETTINGS_SCENE_ILLUMINANCE, 
    SL_VIDEO_SETTINGS_AE_ANTIBANDING, 
    SL_VIDEO_SETTINGS_LAST
};
 
const int SL_VIDEO_SETTINGS_VALUE_AUTO = -1;
 
enum SL_MEASURE {
    SL_MEASURE_DISPARITY, 
    SL_MEASURE_DEPTH, 
    SL_MEASURE_CONFIDENCE, 
    SL_MEASURE_XYZ, 
    SL_MEASURE_XYZRGBA, 
    SL_MEASURE_XYZBGRA, 
    SL_MEASURE_XYZARGB, 
    SL_MEASURE_XYZABGR, 
    SL_MEASURE_NORMALS, 
    SL_MEASURE_DISPARITY_RIGHT, 
    SL_MEASURE_DEPTH_RIGHT, 
    SL_MEASURE_XYZ_RIGHT, 
    SL_MEASURE_XYZRGBA_RIGHT, 
    SL_MEASURE_XYZBGRA_RIGHT, 
    SL_MEASURE_XYZARGB_RIGHT, 
    SL_MEASURE_XYZABGR_RIGHT, 
    SL_MEASURE_NORMALS_RIGHT, 
    SL_MEASURE_DEPTH_U16_MM, 
    SL_MEASURE_DEPTH_U16_MM_RIGHT 
};
 
enum SL_VOXELIZATION_MODE {
    SL_VOXELIZATION_MODE_FIXED,              
    SL_VOXELIZATION_MODE_STEREO_UNCERTAINTY,  
    SL_VOXELIZATION_MODE_LINEAR               
};
 
struct SL_VoxelMeasureParameters {
    float voxel_size;                          
    bool centroid;                             
    enum SL_VOXELIZATION_MODE resolution_mode; 
    float resolution_scale;                    
};
 
enum SL_VIEW {
    SL_VIEW_LEFT, 
    SL_VIEW_RIGHT, 
    SL_VIEW_LEFT_GRAY, 
    SL_VIEW_RIGHT_GRAY, 
    SL_VIEW_LEFT_NV12_UNRECTIFIED,  
    SL_VIEW_RIGHT_NV12_UNRECTIFIED, 
    SL_VIEW_LEFT_UNRECTIFIED, 
    SL_VIEW_RIGHT_UNRECTIFIED, 
    SL_VIEW_LEFT_UNRECTIFIED_GRAY, 
    SL_VIEW_RIGHT_UNRECTIFIED_GRAY, 
    SL_VIEW_SIDE_BY_SIDE, 
    SL_VIEW_DEPTH, 
    SL_VIEW_CONFIDENCE, 
    SL_VIEW_NORMALS, 
    SL_VIEW_DEPTH_RIGHT, 
    SL_VIEW_NORMALS_RIGHT, 
    SL_VIEW_LEFT_BGRA,              
    SL_VIEW_LEFT_BGR,               
    SL_VIEW_RIGHT_BGRA,             
    SL_VIEW_RIGHT_BGR,              
    SL_VIEW_LEFT_UNRECTIFIED_BGRA,  
    SL_VIEW_LEFT_UNRECTIFIED_BGR,   
    SL_VIEW_RIGHT_UNRECTIFIED_BGRA, 
    SL_VIEW_RIGHT_UNRECTIFIED_BGR,  
    SL_VIEW_SIDE_BY_SIDE_BGRA,      
    SL_VIEW_SIDE_BY_SIDE_BGR,       
    SL_VIEW_SIDE_BY_SIDE_GRAY,      
    SL_VIEW_SIDE_BY_SIDE_UNRECTIFIED_BGRA,      
    SL_VIEW_SIDE_BY_SIDE_UNRECTIFIED_BGR,       
    SL_VIEW_SIDE_BY_SIDE_UNRECTIFIED_GRAY,      
    SL_VIEW_DEPTH_BGRA,             
    SL_VIEW_DEPTH_BGR,              
    SL_VIEW_DEPTH_GRAY,             
    SL_VIEW_CONFIDENCE_BGRA,        
    SL_VIEW_CONFIDENCE_BGR,         
    SL_VIEW_CONFIDENCE_GRAY,        
    SL_VIEW_NORMALS_BGRA,           
    SL_VIEW_NORMALS_BGR,            
    SL_VIEW_NORMALS_GRAY,           
    SL_VIEW_DEPTH_RIGHT_BGRA,       
    SL_VIEW_DEPTH_RIGHT_BGR,        
    SL_VIEW_DEPTH_RIGHT_GRAY,       
    SL_VIEW_NORMALS_RIGHT_BGRA,     
    SL_VIEW_NORMALS_RIGHT_BGR,      
    SL_VIEW_NORMALS_RIGHT_GRAY      
};
 
enum SL_OBJECT_TRACKING_STATE
{
    SL_OBJECT_TRACKING_STATE_OFF,       
    SL_OBJECT_TRACKING_STATE_OK,        
    SL_OBJECT_TRACKING_STATE_SEARCHING, 
    SL_OBJECT_TRACKING_STATE_TERMINATE  
};
 
enum SL_POSITIONAL_TRACKING_STATE {
    SL_POSITIONAL_TRACKING_STATE_SEARCHING, 
    SL_POSITIONAL_TRACKING_STATE_OK, 
    SL_POSITIONAL_TRACKING_STATE_OFF, 
    SL_POSITIONAL_TRACKING_STATE_FPS_TOO_LOW, 
    SL_POSITIONAL_TRACKING_STATE_SEARCHING_FLOOR_PLANE, 
    SL_POSITIONAL_TRACKING_STATE_UNAVAILABLE, 
};
 
enum SL_ODOMETRY_STATUS
{
    SL_ODOMETRY_STATUS_OK,          
    SL_ODOMETRY_STATUS_UNAVAILABLE  
};
 
enum SL_SPATIAL_MEMORY_STATUS {
    SL_MAP_TRACKING_STATUS_OK = 0,              
    SL_MAP_TRACKING_STATUS_LOOP_CLOSED = 1,     
    SL_MAP_TRACKING_STATUS_SEARCHING = 2,       
    SL_MAP_TRACKING_STATUS_OFF = 3,             
    SL_MAP_TRACKING_STATUS_INITIALIZING = 4,                        
    SL_MAP_TRACKING_STATUS_KNOWN_MAP = 5,                           
    SL_MAP_TRACKING_STATUS_MAP_UPDATE = 6,                      
    SL_MAP_TRACKING_STATUS_LOST = 7,                            
    SL_MAP_TRACKING_STATUS_NOT_ENOUGH_MEMORY_FOR_TRACKING = 8       
};
 
enum SL_POSITIONAL_TRACKING_MODE {
    SL_POSITIONAL_TRACKING_MODE_GEN_1, 
    SL_POSITIONAL_TRACKING_MODE_GEN_2, 
    SL_POSITIONAL_TRACKING_MODE_GEN_3  
};
 
enum SL_POSITIONAL_TRACKING_FUSION_STATUS {
    SL_POSITIONAL_TRACKING_FUSION_STATUS_VISUAL_INERTIAL = 0,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_VISUAL = 1,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_INERTIAL = 2,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_GNSS = 3,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_VISUAL_INERTIAL_GNSS = 4,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_VISUAL_GNSS = 5,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_INERTIAL_GNSS = 6,
    SL_POSITIONAL_TRACKING_FUSION_STATUS_UNAVAILABLE = 7
};
 
struct SL_PositionalTrackingStatus
{
    enum SL_ODOMETRY_STATUS odometry_status;
    enum SL_SPATIAL_MEMORY_STATUS spatial_memory_status;
    enum SL_POSITIONAL_TRACKING_FUSION_STATUS tracking_fusion_status;
};
 
enum SL_REGION_OF_INTEREST_AUTO_DETECTION_STATE
{
    SL_REGION_OF_INTEREST_AUTO_DETECTION_STATE_RUNNING, 
    SL_REGION_OF_INTEREST_AUTO_DETECTION_STATE_READY, 
    SL_REGION_OF_INTEREST_AUTO_DETECTION_STATE_NOT_ENABLED, 
};
 
 
enum SL_AREA_EXPORTING_STATE {
    SL_AREA_EXPORTING_STATE_SUCCESS, 
    SL_AREA_EXPORTING_STATE_RUNNING, 
    SL_AREA_EXPORTING_STATE_NOT_STARTED, 
    SL_AREA_EXPORTING_STATE_FILE_EMPTY, 
    SL_AREA_EXPORTING_STATE_FILE_ERROR, 
    SL_AREA_EXPORTING_STATE_SPATIAL_MEMORY_DISABLED, 
};
 
enum SL_SPATIAL_MAPPING_STATE {
    SL_SPATIAL_MAPPING_STATE_INITIALIZING, 
    SL_SPATIAL_MAPPING_STATE_OK, 
    SL_SPATIAL_MAPPING_STATE_NOT_ENOUGH_MEMORY, 
    SL_SPATIAL_MAPPING_STATE_NOT_ENABLED, 
    SL_SPATIAL_MAPPING_STATE_FPS_TOO_LOW, 
};
 
enum SL_SPATIAL_MAP_TYPE {
    SL_SPATIAL_MAP_TYPE_MESH, 
    SL_SPATIAL_MAP_TYPE_FUSED_POINT_CLOUD 
};
 
enum SL_MESH_FILTER {
    SL_MESH_FILTER_LOW, 
    SL_MESH_FILTER_MEDIUM, 
    SL_MESH_FILTER_HIGH, 
};
 
enum SL_MESH_FILE_FORMAT {
    SL_MESH_FILE_FORMAT_PLY, 
    SL_MESH_FILE_FORMAT_PLY_BIN, 
    SL_MESH_FILE_FORMAT_OBJ, 
};
 
enum SL_DEPTH_MODE {
    SL_DEPTH_MODE_NONE, 
    SL_DEPTH_MODE_PERFORMANCE, 
    SL_DEPTH_MODE_QUALITY, 
    SL_DEPTH_MODE_ULTRA, 
    SL_DEPTH_MODE_NEURAL_LIGHT,  
    SL_DEPTH_MODE_NEURAL, 
    SL_DEPTH_MODE_NEURAL_PLUS 
};
 
enum SL_FLIP_MODE {
    SL_FLIP_MODE_OFF, 
    SL_FLIP_MODE_ON, 
    SL_FLIP_MODE_AUTO, 
};
 
enum SL_COPY_TYPE
{
    SL_COPY_TYPE_CPU_CPU, 
    SL_COPY_TYPE_CPU_GPU, 
    SL_COPY_TYPE_GPU_GPU, 
    SL_COPY_TYPE_GPU_CPU  
};
 
enum SL_SVO_COMPRESSION_MODE {
    SL_SVO_COMPRESSION_MODE_LOSSLESS, 
    SL_SVO_COMPRESSION_MODE_H264, 
    SL_SVO_COMPRESSION_MODE_H265, 
    SL_SVO_COMPRESSION_MODE_H264_LOSSLESS, 
    SL_SVO_COMPRESSION_MODE_H265_LOSSLESS, 
};
 
enum SL_SVO_ENCODING_PRESET {
    SL_SVO_ENCODING_PRESET_DEFAULT, 
    SL_SVO_ENCODING_PRESET_ULTRAFAST, 
    SL_SVO_ENCODING_PRESET_FAST, 
    SL_SVO_ENCODING_PRESET_MEDIUM, 
    SL_SVO_ENCODING_PRESET_SLOW, 
};
 
enum SL_MAT_TYPE
{
    SL_MAT_TYPE_F32_C1, 
    SL_MAT_TYPE_F32_C2, 
    SL_MAT_TYPE_F32_C3, 
    SL_MAT_TYPE_F32_C4, 
    SL_MAT_TYPE_U8_C1,  
    SL_MAT_TYPE_U8_C2,  
    SL_MAT_TYPE_U8_C3,  
    SL_MAT_TYPE_U8_C4,  
    SL_MAT_TYPE_U16_C1, 
    SL_MAT_TYPE_S8_C4 
};
 
enum SL_OBJECT_SUBCLASS
{
    SL_OBJECT_SUBCLASS_PERSON = 0,       
    SL_OBJECT_SUBCLASS_BICYCLE = 1,      
    SL_OBJECT_SUBCLASS_CAR = 2,          
    SL_OBJECT_SUBCLASS_MOTORBIKE = 3,    
    SL_OBJECT_SUBCLASS_BUS = 4,          
    SL_OBJECT_SUBCLASS_TRUCK = 5,        
    SL_OBJECT_SUBCLASS_BOAT = 6,         
    SL_OBJECT_SUBCLASS_BACKPACK = 7,     
    SL_OBJECT_SUBCLASS_HANDBAG = 8,      
    SL_OBJECT_SUBCLASS_SUITCASE = 9,     
    SL_OBJECT_SUBCLASS_BIRD = 10,        
    SL_OBJECT_SUBCLASS_CAT = 11,         
    SL_OBJECT_SUBCLASS_DOG = 12,         
    SL_OBJECT_SUBCLASS_HORSE = 13,       
    SL_OBJECT_SUBCLASS_SHEEP = 14,       
    SL_OBJECT_SUBCLASS_COW = 15,         
    SL_OBJECT_SUBCLASS_CELLPHONE = 16,   
    SL_OBJECT_SUBCLASS_LAPTOP = 17,      
    SL_OBJECT_SUBCLASS_BANANA = 18,      
    SL_OBJECT_SUBCLASS_APPLE = 19,       
    SL_OBJECT_SUBCLASS_ORANGE = 20,      
    SL_OBJECT_SUBCLASS_CARROT = 21,      
    SL_OBJECT_SUBCLASS_PERSON_HEAD = 22, 
    SL_OBJECT_SUBCLASS_SPORTSBALL = 23,  
    SL_OBJECT_SUBCLASS_MACHINERY = 24,   
    SL_OBJECT_SUBCLASS_LAST = 25         
};
 
enum SL_OBJECT_ACTION_STATE
{
    SL_OBJECT_ACTION_STATE_IDLE,   
    SL_OBJECT_ACTION_STATE_MOVING, 
};
 
enum SL_OBJECT_DETECTION_MODEL {
    SL_OBJECT_DETECTION_MODEL_MULTI_CLASS_BOX_FAST, 
    SL_OBJECT_DETECTION_MODEL_MULTI_CLASS_BOX_MEDIUM, 
    SL_OBJECT_DETECTION_MODEL_MULTI_CLASS_BOX_ACCURATE, 
    SL_OBJECT_DETECTION_MODEL_PERSON_HEAD_BOX_FAST, 
    SL_OBJECT_DETECTION_MODEL_PERSON_HEAD_BOX_ACCURATE, 
    SL_OBJECT_DETECTION_MODEL_CUSTOM_BOX_OBJECTS, 
    SL_OBJECT_DETECTION_MODEL_CUSTOM_YOLOLIKE_BOX_OBJECTS 
};
 
enum SL_BODY_TRACKING_MODEL
{
    SL_BODY_TRACKING_MODEL_HUMAN_BODY_FAST, 
    SL_BODY_TRACKING_MODEL_HUMAN_BODY_MEDIUM, 
    SL_BODY_TRACKING_MODEL_HUMAN_BODY_ACCURATE, 
};
 
enum SL_AI_MODELS {
    SL_AI_MODELS_MULTI_CLASS_DETECTION, 
    SL_AI_MODELS_MULTI_CLASS_MEDIUM_DETECTION, 
    SL_AI_MODELS_MULTI_CLASS_ACCURATE_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_FAST_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_MEDIUM_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_ACCURATE_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_38_FAST_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_38_MEDIUM_DETECTION, 
    SL_AI_MODELS_HUMAN_BODY_38_ACCURATE_DETECTION, 
    SL_AI_MODELS_PERSON_HEAD_DETECTION, 
    SL_AI_MODELS_PERSON_HEAD_ACCURATE_DETECTION, 
    SL_AI_MODELS_REID_ASSOCIATION, 
    SL_AI_MODELS_NEURAL_LIGHT_DEPTH, 
    SL_AI_MODELS_NEURAL_DEPTH, 
    SL_AI_MODELS_NEURAL_PLUS_DEPTH, 
    SL_AI_MODELS_LAST
};
 
enum SL_OBJECT_FILTERING_MODE {
    SL_OBJECT_FILTERING_MODE_NONE, 
    SL_OBJECT_FILTERING_MODE_NMS_3D, 
    SL_OBJECT_FILTERING_MODE_NMS_3D_PER_CLASS, 
};
 
enum SL_OBJECT_ACCELERATION_PRESET {
    SL_OBJECT_ACCELERATION_PRESET_DEFAULT = 0, 
    SL_OBJECT_ACCELERATION_PRESET_LOW = 1, 
    SL_OBJECT_ACCELERATION_PRESET_MEDIUM = 2, 
    SL_OBJECT_ACCELERATION_PRESET_HIGH = 3 
};
 
struct SL_ObjectTrackingParameters {
    enum SL_OBJECT_ACCELERATION_PRESET object_acceleration_preset;
 
    float velocity_smoothing_factor;
 
    float min_velocity_threshold;
 
    float prediction_timeout_s;
 
    float min_confirmation_time_s;
};
 
enum SL_INFERENCE_PRECISION {
    SL_INFERENCE_PRECISION_FP32 = 0,
    SL_INFERENCE_PRECISION_FP16 = 1,
    SL_INFERENCE_PRECISION_INT8 = 2
};
 
 
enum SL_BODY_FORMAT
{
    SL_BODY_FORMAT_BODY_18,
    SL_BODY_FORMAT_BODY_34,
    SL_BODY_FORMAT_BODY_38,
 
#if 0
    SL_BODY_FORMAT_BODY_70,
#endif
};
enum SL_BODY_KEYPOINTS_SELECTION
{
    SL_BODY_KEYPOINTS_SELECTION_FULL,
    SL_BODY_KEYPOINTS_SELECTION_UPPER_BODY,
    //SL_BODY_KEYPOINTS_SELECTION_HAND
};
 
 
enum SL_BODY_18_PARTS
{
    SL_BODY_18_PARTS_NOSE, 
    SL_BODY_18_PARTS_NECK, 
    SL_BODY_18_PARTS_RIGHT_SHOULDER, 
    SL_BODY_18_PARTS_RIGHT_ELBOW, 
    SL_BODY_18_PARTS_RIGHT_WRIST, 
    SL_BODY_18_PARTS_LEFT_SHOULDER, 
    SL_BODY_18_PARTS_LEFT_ELBOW, 
    SL_BODY_18_PARTS_LEFT_WRIST, 
    SL_BODY_18_PARTS_RIGHT_HIP, 
    SL_BODY_18_PARTS_RIGHT_KNEE, 
    SL_BODY_18_PARTS_RIGHT_ANKLE, 
    SL_BODY_18_PARTS_LEFT_HIP, 
    SL_BODY_18_PARTS_LEFT_KNEE, 
    SL_BODY_18_PARTS_LEFT_ANKLE, 
    SL_BODY_18_PARTS_RIGHT_EYE, 
    SL_BODY_18_PARTS_LEFT_EYE, 
    SL_BODY_18_PARTS_RIGHT_EAR, 
    SL_BODY_18_PARTS_LEFT_EAR, 
    SL_BODY_18_PARTS_LAST
};
 
enum SL_BODY_34_PARTS
{
    SL_BODY_34_PARTS_PELVIS, 
    SL_BODY_34_PARTS_NAVAL_SPINE, 
    SL_BODY_34_PARTS_CHEST_SPINE, 
    SL_BODY_34_PARTS_NECK, 
    SL_BODY_34_PARTS_LEFT_CLAVICLE, 
    SL_BODY_34_PARTS_LEFT_SHOULDER, 
    SL_BODY_34_PARTS_LEFT_ELBOW, 
    SL_BODY_34_PARTS_LEFT_WRIST, 
    SL_BODY_34_PARTS_LEFT_HAND, 
    SL_BODY_34_PARTS_LEFT_HANDTIP, 
    SL_BODY_34_PARTS_LEFT_THUMB, 
    SL_BODY_34_PARTS_RIGHT_CLAVICLE, 
    SL_BODY_34_PARTS_RIGHT_SHOULDER, 
    SL_BODY_34_PARTS_RIGHT_ELBOW, 
    SL_BODY_34_PARTS_RIGHT_WRIST, 
    SL_BODY_34_PARTS_RIGHT_HAND, 
    SL_BODY_34_PARTS_RIGHT_HANDTIP, 
    SL_BODY_34_PARTS_RIGHT_THUMB, 
    SL_BODY_34_PARTS_LEFT_HIP, 
    SL_BODY_34_PARTS_LEFT_KNEE, 
    SL_BODY_34_PARTS_LEFT_ANKLE, 
    SL_BODY_34_PARTS_LEFT_FOOT, 
    SL_BODY_34_PARTS_RIGHT_HIP, 
    SL_BODY_34_PARTS_RIGHT_KNEE, 
    SL_BODY_34_PARTS_RIGHT_ANKLE, 
    SL_BODY_34_PARTS_RIGHT_FOOT, 
    SL_BODY_34_PARTS_HEAD, 
    SL_BODY_34_PARTS_NOSE, 
    SL_BODY_34_PARTS_LEFT_EYE, 
    SL_BODY_34_PARTS_LEFT_EAR, 
    SL_BODY_34_PARTS_RIGHT_EYE, 
    SL_BODY_34_PARTS_RIGHT_EAR, 
    SL_BODY_34_PARTS_LEFT_HEEL, 
    SL_BODY_34_PARTS_RIGHT_HEEL, 
    SL_BODY_34_PARTS_LAST
};
 
 
enum SL_BODY_38_PARTS
{
    SL_BODY_38_PARTS_PELVIS, 
    SL_BODY_38_PARTS_SPINE_1, 
    SL_BODY_38_PARTS_SPINE_2, 
    SL_BODY_38_PARTS_SPINE_3, 
    SL_BODY_38_PARTS_NECK, 
    SL_BODY_38_PARTS_NOSE, 
    SL_BODY_38_PARTS_LEFT_EYE, 
    SL_BODY_38_PARTS_RIGHT_EYE, 
    SL_BODY_38_PARTS_LEFT_EAR, 
    SL_BODY_38_PARTS_RIGHT_EAR, 
    SL_BODY_38_PARTS_LEFT_CLAVICLE, 
    SL_BODY_38_PARTS_RIGHT_CLAVICLE, 
    SL_BODY_38_PARTS_LEFT_SHOULDER, 
    SL_BODY_38_PARTS_RIGHT_SHOULDER, 
    SL_BODY_38_PARTS_LEFT_ELBOW, 
    SL_BODY_38_PARTS_RIGHT_ELBOW, 
    SL_BODY_38_PARTS_LEFT_WRIST, 
    SL_BODY_38_PARTS_RIGHT_WRIST, 
    SL_BODY_38_PARTS_LEFT_HIP, 
    SL_BODY_38_PARTS_RIGHT_HIP, 
    SL_BODY_38_PARTS_LEFT_KNEE, 
    SL_BODY_38_PARTS_RIGHT_KNEE, 
    SL_BODY_38_PARTS_LEFT_ANKLE, 
    SL_BODY_38_PARTS_RIGHT_ANKLE, 
    SL_BODY_38_PARTS_LEFT_BIG_TOE, 
    SL_BODY_38_PARTS_RIGHT_BIG_TOE, 
    SL_BODY_38_PARTS_LEFT_SMALL_TOE, 
    SL_BODY_38_PARTS_RIGHT_SMALL_TOE, 
    SL_BODY_38_PARTS_LEFT_HEEL, 
    SL_BODY_38_PARTS_RIGHT_HEEL, 
    // Hands
    SL_BODY_38_PARTS_LEFT_HAND_THUMB_4, 
    SL_BODY_38_PARTS_RIGHT_HAND_THUMB_4, 
    SL_BODY_38_PARTS_LEFT_HAND_INDEX_1, 
    SL_BODY_38_PARTS_RIGHT_HAND_INDEX_1, 
    SL_BODY_38_PARTS_LEFT_HAND_MIDDLE_4, 
    SL_BODY_38_PARTS_RIGHT_HAND_MIDDLE_4, 
    SL_BODY_38_PARTS_LEFT_HAND_PINKY_1, 
    SL_BODY_38_PARTS_RIGHT_HAND_PINKY_1, 
    SL_BODY_38_PARTS_LAST
};
 
#if 0
enum SL_BODY_70_PARTS
{
    SL_BODY_70_PARTS_PELVIS,
    SL_BODY_70_PARTS_SPINE_1,
    SL_BODY_70_PARTS_SPINE_2,
    SL_BODY_70_PARTS_SPINE_3,
    SL_BODY_70_PARTS_NECK,
    SL_BODY_70_PARTS_NOSE,
    SL_BODY_70_PARTS_LEFT_EYE,
    SL_BODY_70_PARTS_RIGHT_EYE,
    SL_BODY_70_PARTS_LEFT_EAR,
    SL_BODY_70_PARTS_RIGHT_EAR,
    SL_BODY_70_PARTS_LEFT_CLAVICLE,
    SL_BODY_70_PARTS_RIGHT_CLAVICLE,
    SL_BODY_70_PARTS_LEFT_SHOULDER,
    SL_BODY_70_PARTS_RIGHT_SHOULDER,
    SL_BODY_70_PARTS_LEFT_ELBOW,
    SL_BODY_70_PARTS_RIGHT_ELBOW,
    SL_BODY_70_PARTS_LEFT_WRIST,
    SL_BODY_70_PARTS_RIGHT_WRIST,
    SL_BODY_70_PARTS_LEFT_HIP,
    SL_BODY_70_PARTS_RIGHT_HIP,
    SL_BODY_70_PARTS_LEFT_KNEE,
    SL_BODY_70_PARTS_RIGHT_KNEE,
    SL_BODY_70_PARTS_LEFT_ANKLE,
    SL_BODY_70_PARTS_RIGHT_ANKLE,
    SL_BODY_70_PARTS_LEFT_BIG_TOE,
    SL_BODY_70_PARTS_RIGHT_BIG_TOE,
    SL_BODY_70_PARTS_LEFT_SMALL_TOE,
    SL_BODY_70_PARTS_RIGHT_SMALL_TOE,
    SL_BODY_70_PARTS_LEFT_HEEL,
    SL_BODY_70_PARTS_RIGHT_HEEL,
    // Hands
    // Left
    SL_BODY_70_PARTS_LEFT_HAND_THUMB_1,
    SL_BODY_70_PARTS_LEFT_HAND_THUMB_2,
    SL_BODY_70_PARTS_LEFT_HAND_THUMB_3,
    SL_BODY_70_PARTS_LEFT_HAND_THUMB_4,
    SL_BODY_70_PARTS_LEFT_HAND_INDEX_1,
    SL_BODY_70_PARTS_LEFT_HAND_INDEX_2,
    SL_BODY_70_PARTS_LEFT_HAND_INDEX_3,
    SL_BODY_70_PARTS_LEFT_HAND_INDEX_4,
    SL_BODY_70_PARTS_LEFT_HAND_MIDDLE_1,
    SL_BODY_70_PARTS_LEFT_HAND_MIDDLE_2,
    SL_BODY_70_PARTS_LEFT_HAND_MIDDLE_3,
    SL_BODY_70_PARTS_LEFT_HAND_MIDDLE_4,
    SL_BODY_70_PARTS_LEFT_HAND_RING_1,
    SL_BODY_70_PARTS_LEFT_HAND_RING_2,
    SL_BODY_70_PARTS_LEFT_HAND_RING_3,
    SL_BODY_70_PARTS_LEFT_HAND_RING_4,
    SL_BODY_70_PARTS_LEFT_HAND_PINKY_1,
    SL_BODY_70_PARTS_LEFT_HAND_PINKY_2,
    SL_BODY_70_PARTS_LEFT_HAND_PINKY_3,
    SL_BODY_70_PARTS_LEFT_HAND_PINKY_4,
    //Right
    SL_BODY_70_PARTS_RIGHT_HAND_THUMB_1,
    SL_BODY_70_PARTS_RIGHT_HAND_THUMB_2,
    SL_BODY_70_PARTS_RIGHT_HAND_THUMB_3,
    SL_BODY_70_PARTS_RIGHT_HAND_THUMB_4,
    SL_BODY_70_PARTS_RIGHT_HAND_INDEX_1,
    SL_BODY_70_PARTS_RIGHT_HAND_INDEX_2,
    SL_BODY_70_PARTS_RIGHT_HAND_INDEX_3,
    SL_BODY_70_PARTS_RIGHT_HAND_INDEX_4,
    SL_BODY_70_PARTS_RIGHT_HAND_MIDDLE_1,
    SL_BODY_70_PARTS_RIGHT_HAND_MIDDLE_2,
    SL_BODY_70_PARTS_RIGHT_HAND_MIDDLE_3,
    SL_BODY_70_PARTS_RIGHT_HAND_MIDDLE_4,
    SL_BODY_70_PARTS_RIGHT_HAND_RING_1,
    SL_BODY_70_PARTS_RIGHT_HAND_RING_2,
    SL_BODY_70_PARTS_RIGHT_HAND_RING_3,
    SL_BODY_70_PARTS_RIGHT_HAND_RING_4,
    SL_BODY_70_PARTS_RIGHT_HAND_PINKY_1,
    SL_BODY_70_PARTS_RIGHT_HAND_PINKY_2,
    SL_BODY_70_PARTS_RIGHT_HAND_PINKY_3,
    SL_BODY_70_PARTS_RIGHT_HAND_PINKY_4,
    SL_BODY_70_PARTS_LAST
};
#endif
 
enum SL_MODULE {
    SL_MODULE_ALL = 0, 
    SL_MODULE_DEPTH = 1,
    SL_MODULE_POSITIONAL_TRACKING = 2,
    SL_MODULE_OBJECT_DETECTION = 3,
    SL_MODULE_BODY_TRACKING = 4,
    SL_MODULE_SPATIAL_MAPPING = 5,
    SL_MODULE_LAST = 6
};
 
enum SL_POSITION_TYPE {
    SL_POSITION_TYPE_RAW,
    SL_POSITION_TYPE_FUSION
};
 
struct SL_Resolution {
    int width;
    int height;
};
 
struct SL_InitParameters
{
    enum  SL_INPUT_TYPE input_type;
 
    enum  SL_RESOLUTION resolution;
 
    int camera_fps;
 
    int camera_device_id;
 
    enum SL_FLIP_MODE camera_image_flip;
 
    bool camera_disable_self_calib;
 
    bool enable_right_side_measure;
 
    bool svo_real_time_mode;
    
    enum SL_DEPTH_MODE depth_mode;
    
    int depth_stabilization;
    
    float depth_minimum_distance;
    
    float depth_maximum_distance;
    
    enum  SL_UNIT coordinate_unit;
    
    enum  SL_COORDINATE_SYSTEM coordinate_system;
    
    int sdk_gpu_id;
 
    int sdk_verbose;
    bool sensors_required;
    
    bool enable_image_enhancement;
 
    float open_timeout_sec;
 
    bool async_grab_camera_recovery;
 
    float grab_compute_capping_fps;
    bool enable_image_validity_check;
 
    struct SL_Resolution maximum_working_resolution;
 
    unsigned char svo_decryption_key[256];
};
 
struct SL_RuntimeParameters
{
    enum SL_REFERENCE_FRAME reference_frame;
 
    bool enable_depth;
        
    bool enable_fill_mode;
        
    int confidence_threshold;
    
    int texture_confidence_threshold;
 
    bool remove_saturated_areas;
};
 
struct SL_DeviceProperties {
    enum  SL_CAMERA_STATE camera_state;
 
    int id;
 
    char path[512];
    char video_device[512];
    int i2c_port;
    enum  SL_MODEL camera_model;
 
    unsigned int sn;
    int gmsl_port;
    unsigned char identifier[3];
    char camera_badge[128];
 
    char camera_sensor_model[128];
    char camera_name[128];
    enum SL_INPUT_TYPE input_type;
    unsigned char sensor_address_left;
    unsigned char sensor_address_right;
};
 
struct SL_CameraParameters {
    float fx;
 
    float fy;
 
    float cx;
 
    float cy;
 
    double disto[12];
 
    float v_fov;
 
    float h_fov;
 
    float d_fov;
 
    struct SL_Resolution image_size;
 
    float focal_length_metric;
};
 
struct SL_CalibrationParameters
{
    struct SL_CameraParameters left_cam;
    struct SL_CameraParameters right_cam;
    struct SL_Vector4 rotation;
    struct SL_Vector3 translation;
};
 
struct SL_SensorParameters {
    enum  SL_SENSOR_TYPE type; 
    float resolution; 
    float sampling_rate; 
    struct SL_Vector2 range; 
    float noise_density; 
    float random_walk; 
    enum  SL_SENSORS_UNIT sensor_unit; 
    bool is_available; 
};
 
 
struct SL_CameraConfiguration {
    struct SL_CalibrationParameters calibration_parameters;
    struct SL_CalibrationParameters calibration_parameters_raw;
    unsigned int firmware_version;
    float fps;
    struct SL_Resolution resolution;
};
 
struct SL_SensorsConfiguration
{
    unsigned int firmware_version;
    struct SL_Vector4 camera_ium_rotation;
    struct SL_Vector3 camera_imu_translation;
    struct SL_Vector4 ium_magnetometer_rotation;
    struct SL_Vector3 ium_magnetometer_translation;
    struct SL_SensorParameters accelerometer_parameters;
    struct SL_SensorParameters gyroscope_parameters;
    struct SL_SensorParameters magnetometer_parameters;
    struct SL_SensorParameters barometer_parameters;
};
 
 
struct SL_CameraInformation {
    unsigned int serial_number;
    enum SL_MODEL camera_model;
    enum SL_INPUT_TYPE input_type;
    struct SL_CameraConfiguration camera_configuration;
    struct SL_SensorsConfiguration sensors_configuration;
};
 
 
struct SL_PositionalTrackingParameters
{
    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;
    float depth_min_range;
    bool set_gravity_as_origin;
    enum SL_POSITIONAL_TRACKING_MODE mode;
 
    bool enable_localization_only;
 
    bool enable_2d_ground_mode;
};
 
struct SL_Landmark
{
    uint64_t id;
    struct SL_Vector3 position;
};
 
struct SL_Landmark2D
{
    uint64_t id;
 
    struct SL_Uint2 image_position;
    
    float dynamic_confidence;
};
 
struct SL_RegionOfInterestParameters
{
    float depth_far_threshold_meters;
 
    float image_height_ratio_cutoff;
 
    bool auto_apply_module[SL_MODULE_LAST];
};
 
struct SL_PlaneDetectionParameters {
 
    float max_distance_threshold;
 
    float normal_similarity_threshold;
};
 
struct SL_RecordingStatus {
    bool is_recording;
    bool is_paused;
    bool status;
    double current_compression_time;
    double current_compression_ratio;
    double average_compression_time;
    double average_compression_ratio;
};
 
struct SL_RecordingParameters {
    unsigned char video_filename[256];
 
    enum SL_SVO_COMPRESSION_MODE compression_mode;
 
    unsigned int bitrate;
 
    unsigned int target_framerate;
 
    bool transcode_streaming_input;
 
    unsigned char encryption_key[256];
 
    enum SL_SVO_ENCODING_PRESET encoding_preset;
};
 
struct SL_SVOData
{
    char* key;
    int key_size;
    char* content;
    int content_size;
    uint64_t timestamp_ns;
};
 
struct SL_StreamingParameters {
 
    enum SL_STREAMING_CODEC codec;
 
    unsigned short port;
 
    unsigned int bitrate;
 
    int gop_size;
 
    bool adaptative_bitrate;
 
    unsigned short chunk_size;
 
 
    unsigned int target_framerate;
};
 
struct SL_StreamingProperties {
    unsigned char ip[16];
 
    unsigned short port;
 
    unsigned int serial_number;
 
    int current_bitrate;
 
    enum SL_STREAMING_CODEC codec;
 
    enum SL_MODEL camera_model;
};
 
struct SL_SpatialMappingParameters {
    float resolution_meter;
    float range_meter;
    bool save_texture;
    bool use_chunk_only;
    int max_memory_usage;
    bool reverse_vertex_order;
    enum SL_SPATIAL_MAP_TYPE map_type;
    int stability_counter;
    float disparity_std;
 
    float decay;
 
    bool enable_forget_past;
};
 
 
#if WITH_OBJECT_DETECTION
#define MAX_NUMBER_OBJECT 75
#define MAX_TRAJECTORY_SIZE 200
 
struct SL_BatchParameters
{
    bool enable;
    float id_retention_time;
    float latency;
};
 
struct SL_AI_Model_status {
    bool downloaded; 
    bool optimized; 
};
 
struct SL_ObjectDetectionParameters
{
    unsigned int instance_module_id;
 
    bool enable_tracking;
    bool enable_segmentation;
    enum  SL_OBJECT_DETECTION_MODEL detection_model;
 
    char* fused_objects_group_name;
 
    char* custom_onnx_file;
 
    struct SL_Resolution custom_onnx_dynamic_input_shape;
 
    float max_range;
    struct SL_BatchParameters batch_parameters;
    enum SL_OBJECT_FILTERING_MODE filtering_mode;
 
    float prediction_timeout_s;
    bool allow_reduced_precision_inference;
};
 
enum SL_OBJECT_CLASS
{
    SL_OBJECT_CLASS_PERSON,          
    SL_OBJECT_CLASS_VEHICLE,         
    SL_OBJECT_CLASS_BAG,             
    SL_OBJECT_CLASS_ANIMAL,          
    SL_OBJECT_CLASS_ELECTRONICS,     
    SL_OBJECT_CLASS_FRUIT_VEGETABLE, 
    SL_OBJECT_CLASS_SPORT,           
    SL_OBJECT_CLASS_LAST
};
 
 
struct SL_ObjectDetectionRuntimeParameters
{
    float detection_confidence_threshold;
    int object_class_filter[(int)SL_OBJECT_CLASS_LAST];
    int object_confidence_threshold[(int)SL_OBJECT_CLASS_LAST];
 
    struct SL_ObjectTrackingParameters object_tracking_parameters;
 
    struct SL_ObjectTrackingParameters object_class_tracking_parameters[(int)SL_OBJECT_CLASS_LAST];
};
 
struct SL_CustomObjectDetectionProperties {
    int class_id;
 
    bool enabled;
 
    float detection_confidence_threshold;
 
    bool is_grounded;
 
    bool is_static;
 
    float tracking_timeout;
 
    float tracking_max_dist;
 
    float max_box_width_normalized;
 
    float min_box_width_normalized;
 
    float max_box_height_normalized;
 
    float min_box_height_normalized;
 
    float max_box_width_meters;
 
    float min_box_width_meters;
 
    float max_box_height_meters;
 
    float min_box_height_meters;
 
    enum SL_OBJECT_SUBCLASS native_mapped_class;
 
    enum SL_OBJECT_ACCELERATION_PRESET object_acceleration_preset;
 
    float max_allowed_acceleration;
 
    struct SL_ObjectTrackingParameters object_tracking_parameters;
};
 
struct SL_CustomObjectDetectionRuntimeParameters {
    struct SL_CustomObjectDetectionProperties object_detection_properties;
 
    struct SL_CustomObjectDetectionProperties* object_class_detection_properties;
 
    unsigned int number_custom_detection_properties;
};
 
struct SL_BodyTrackingParameters {
    unsigned int instance_module_id;
 
    bool enable_tracking;
 
    bool enable_segmentation;
 
    enum SL_BODY_TRACKING_MODEL detection_model;
 
    bool enable_body_fitting;
 
    enum SL_BODY_FORMAT body_format;
 
    enum SL_BODY_KEYPOINTS_SELECTION body_selection;
 
    float max_range;
    float prediction_timeout_s;
    bool allow_reduced_precision_inference;
};
 
struct SL_BodyTrackingRuntimeParameters {
    float detection_confidence_threshold;
 
    int minimum_keypoints_threshold;
    float skeleton_smoothing;
};
 
struct SL_ObjectData
{
    int id;
    unsigned char unique_object_id[37];
 
    int raw_label;
    enum  SL_OBJECT_CLASS label;
    enum  SL_OBJECT_SUBCLASS sublabel;
    enum  SL_OBJECT_TRACKING_STATE tracking_state;
    enum  SL_OBJECT_ACTION_STATE action_state;
    struct SL_Vector3 position;
    float confidence;
 
    int* mask;
    //int* mask; //IntPtr to an sl::Mat object.
 
    struct SL_Vector2 bounding_box_2d[4];
    struct SL_Vector3 head_position;
    struct SL_Vector3 velocity;
    struct SL_Vector3 dimensions;
    struct SL_Vector3 bounding_box[8];
    struct SL_Vector3 head_bounding_box[8];
    struct SL_Vector2 head_bounding_box_2d[4];
    float position_covariance[6];
};
 
struct SL_CustomBoxObjectData {
    char unique_object_id[37];
    struct SL_Vector2 bounding_box_2d[4];
 
    int label;
 
    float probability;
    bool is_grounded;
 
    bool is_static;
 
    float tracking_timeout;
 
    float tracking_max_dist;
 
    float max_box_width_meters;
 
    float min_box_width_meters;
 
    float max_box_height_meters;
 
    float min_box_height_meters;
 
    float max_allowed_acceleration;
 
    float velocity_smoothing_factor;
 
    float min_velocity_threshold;
 
    float prediction_timeout_s;
 
    float min_confirmation_time_s;
};
 
struct SL_CustomMaskObjectData {
    char unique_object_id[37];
    struct SL_Vector2 bounding_box_2d[4];
 
    int label;
 
    float probability;
    bool is_grounded;
 
    bool is_static;
 
    float tracking_timeout;
 
    float tracking_max_dist;
    
    unsigned char* box_mask;
 
    float max_box_width_meters;
 
    float min_box_width_meters;
 
    float max_box_height_meters;
 
    float min_box_height_meters;
 
    float max_allowed_acceleration;
 
    float velocity_smoothing_factor;
 
    float min_velocity_threshold;
 
    float prediction_timeout_s;
 
    float min_confirmation_time_s;
};
 
struct SL_Objects
{
    int nb_objects;
    uint64_t timestamp;
    int is_new;
    int is_tracked;
    enum  SL_OBJECT_DETECTION_MODEL detection_model;
    struct SL_ObjectData object_list[MAX_NUMBER_OBJECT];
};
 
struct SL_BodyData
{
    int id;
    unsigned char unique_object_id[37];
    enum  SL_OBJECT_TRACKING_STATE tracking_state;
    enum  SL_OBJECT_ACTION_STATE action_state;
    struct SL_Vector3 position;
    struct SL_Vector3 velocity;
    float position_covariance[6];
    float confidence;
 
    int* mask;
    //int* mask; //IntPtr to an sl::Mat object.
 
    struct SL_Vector2 bounding_box_2d[4];
    struct SL_Vector3 head_position;
 
    struct SL_Vector3 dimensions;
    struct SL_Vector3 bounding_box[8];
    struct SL_Vector3 head_bounding_box[8];
    struct SL_Vector2 head_bounding_box_2d[4];
    struct SL_Vector2 keypoint_2d[38];
    struct SL_Vector3 keypoint[38];
 
    float keypoint_confidence[38];
    float keypoint_covariances[38][6];
    struct SL_Vector3 local_position_per_joint[38];
    struct SL_Quaternion local_orientation_per_joint[38];
    struct SL_Quaternion global_root_orientation;
};
 
struct SL_Bodies
{
    int nb_bodies;
    uint64_t timestamp;
    int is_new;
    int is_tracked;
    enum SL_INFERENCE_PRECISION inference_precision_mode;
    enum SL_BODY_FORMAT body_format;
    struct SL_BodyData body_list[MAX_NUMBER_OBJECT];
};
 
struct SL_ObjectsBatch {
    int nb_data;
    int id; 
    enum SL_OBJECT_CLASS label; 
    enum SL_OBJECT_SUBCLASS sublabel; 
    enum SL_OBJECT_TRACKING_STATE tracking_state; 
    struct SL_Vector3 positions[MAX_TRAJECTORY_SIZE]; 
    float position_covariances[MAX_TRAJECTORY_SIZE][6]; 
    struct SL_Vector3 velocities[MAX_TRAJECTORY_SIZE]; 
    uint64_t 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]; 
    enum SL_OBJECT_ACTION_STATE 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
struct SL_BodiesBatch {
    int nb_data;
    int id; 
    enum SL_OBJECT_TRACKING_STATE tracking_state; 
    struct SL_Vector3 positions[MAX_TRAJECTORY_SIZE]; 
    float position_covariances[MAX_TRAJECTORY_SIZE][6]; 
    struct SL_Vector3 velocities[MAX_TRAJECTORY_SIZE]; 
    uint64_t 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]; 
    enum SL_OBJECT_ACTION_STATE action_states[MAX_TRAJECTORY_SIZE]; 
    struct SL_Vector2 keypoints_2d[MAX_TRAJECTORY_SIZE][70];
    struct SL_Vector3 keypoints[MAX_TRAJECTORY_SIZE][70];
 
    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];
 
    float keypoints_confidences[MAX_TRAJECTORY_SIZE][70];
};
 
#endif
 
struct SL_Rect
{
    int x;
    int y;
    int width;
    int height;
};
 
#endif
 
struct SL_InputType
{
    enum SL_INPUT_TYPE input_type;
 
    unsigned int serial_number;
 
    unsigned int id;
 
    char svo_input_filename[256];
 
    char stream_input_ip[128];
 
    unsigned short stream_input_port;
};
 
 
/*
\brief Structure containing the self diagnostic results of the image/depth
 
That information can be retrieved by get_health_status(), and enabled by sl::InitParameters::enable_image_validity_check
 */
struct SL_HealthStatus {
    bool enabled;
 
    bool low_image_quality;
 
    bool low_lighting;
 
    bool low_depth_reliability;
 
    bool low_motion_sensors_reliability;
};
 
 
enum SL_FUSION_ERROR_CODE {
    SL_FUSION_ERROR_CODE_FUSION_INCONSISTENT_FPS = -5,
    SL_FUSION_ERROR_CODE_FUSION_FPS_TOO_LOW = -4,
    SL_FUSION_ERROR_CODE_INVALID_TIMESTAMP = -3,
    SL_FUSION_ERROR_CODE_INVALID_COVARIANCE = -2,
    SL_FUSION_ERROR_CODE_NO_NEW_DATA_AVAILABLE = -1,
    SL_FUSION_ERROR_CODE_SUCCESS = 0,
    SL_FUSION_ERROR_CODE_GNSS_DATA_NEED_FIX = 1,
    SL_FUSION_ERROR_CODE_GNSS_DATA_COVARIANCE_MUST_VARY = 2,
    SL_FUSION_ERROR_CODE_BODY_FORMAT_MISMATCH = 3,
    SL_FUSION_ERROR_CODE_MODULE_NOT_ENABLED = 4,
    SL_FUSION_ERROR_CODE_SOURCE_MISMATCH = 5,
    SL_FUSION_ERROR_CODE_CONNECTION_TIMED_OUT = 6,
    SL_FUSION_ERROR_CODE_MEMORY_ALREADY_USED = 7,
    SL_FUSION_ERROR_CODE_INVALID_IP_ADDRESS = 8,
    SL_FUSION_ERROR_CODE_FAILURE = 9
};
 
enum SL_SENDER_ERROR_CODE {
    SL_SENDER_ERROR_CODE_GRAB_ERROR = -3, /*< The sender encountered a grab error. Check sender's hardware and connection. */
    SL_SENDER_ERROR_CODE_INCONSISTENT_FPS = -2, /*< The sender does not run with a constant frame rate. */
    SL_SENDER_ERROR_CODE_FPS_TOO_LOW = -1, 
    SL_SENDER_ERROR_CODE_SUCCESS = 0, /*< Standard code indicating successful behavior. */
    SL_SENDER_ERROR_CODE_DISCONNECTED = 1 /*< The sender has been disconnected. */
};
 
enum SL_COMM_TYPE
{
    SL_COMM_TYPE_LOCAL_NETWORK, 
    SL_COMM_TYPE_INTRA_PROCESS 
};
 
enum SL_GNSS_STATUS
{
    SL_GNSS_STATUS_UNKNOWN = 0,
    SL_GNSS_STATUS_SINGLE = 1,
    SL_GNSS_STATUS_DGNSS = 2,
    SL_GNSS_STATUS_RTK_FIX = 3,
    SL_GNSS_STATUS_PPS = 5,
    SL_GNSS_STATUS_RTK_FLOAT = 4
};
 
enum SL_GNSS_MODE
{
    SL_GNSS_MODE_UNKNOWN,
    SL_GNSS_MODE_NO_FIX,
    SL_GNSS_MODE_FIX_2D,
    SL_GNSS_MODE_FIX_3D  
};
 
enum SL_GNSS_FUSION_STATUS {
    SL_GNSS_FUSION_STATUS_OK = 0,
    SL_GNSS_FUSION_STATUS_OFF = 1,                          
    SL_GNSS_FUSION_STATUS_CALIBRATION_IN_PROGRESS = 2,
    SL_GNSS_FUSION_STATUS_RECALIBRATION_IN_PROGRESS = 3 
};
 
enum SL_FUSION_REFERENCE_FRAME {
    SL_FUSION_REFERENCE_FRAME_WORLD = 0, 
    SL_FUSION_REFERENCE_FRAME_BASELINK = 1, 
};
 
struct SL_FusedPositionalTrackingStatus
{        
    enum SL_ODOMETRY_STATUS odometry_status;
    enum SL_SPATIAL_MEMORY_STATUS spatial_memory_status;
    enum SL_GNSS_STATUS gnss_status;
    enum SL_GNSS_MODE gnss_mode;
    enum SL_GNSS_FUSION_STATUS gnss_fusion_status;
    enum SL_POSITIONAL_TRACKING_FUSION_STATUS tracking_fusion_status;
};
 
struct  SL_CommunicationParameters
{
    enum SL_COMM_TYPE communication_type;
    unsigned int ip_port;
    char ip_add[128];
};
 
struct SL_FusionConfiguration {
    int serial_number;
 
    struct SL_CommunicationParameters comm_param;
 
    struct SL_Vector3 position;
 
    struct SL_Quaternion rotation;
 
    struct SL_InputType input_type;
    bool override_gravity;
};
 
 
struct SL_SynchronizationParameter {
    double windows_size;
 
    double data_source_timeout;
 
    bool keep_last_data;
 
    double maximum_lateness;
};
 
struct SL_InitFusionParameters
{
    enum SL_UNIT coordinate_units;
 
    enum SL_COORDINATE_SYSTEM coordinate_system;
 
    bool output_performance_metrics;
 
    bool verbose;
 
    unsigned timeout_period_number;
 
    int sdk_gpu_id;
    CUcontext sdk_cuda_ctx;
    struct SL_SynchronizationParameter synchronization_parameters; 
 
    struct SL_Resolution maximum_working_resolution;
};
 
struct SL_BodyTrackingFusionParameters
{
    bool enable_tracking;
 
    bool enable_body_fitting;
};
 
struct SL_BodyTrackingFusionRuntimeParameters
{
    int skeleton_minimum_allowed_keypoints;
    int skeleton_minimum_allowed_camera;
 
    float skeleton_smoothing;
};
 
struct SL_CameraIdentifier {
    uint64_t sn;
};
 
struct SL_CameraMetrics
{
    struct SL_CameraIdentifier uuid;
 
    float received_fps;
 
    float received_latency;
 
    float synced_latency;
 
    bool is_present;
 
    float ratio_detection;
 
    float delta_ts;
};
 
struct SL_FusionMetrics {
    float mean_camera_fused;
 
    float mean_stdev_between_camera;
 
    struct SL_CameraMetrics camera_individual_stats[MAX_FUSED_CAMERAS];
};
 
 
 
struct SL_GNSSData
{
    double longitude;
    double latitude;
    double altitude;
    uint64_t ts;
    double position_covariance[9];
    double longitude_std;
    double latitude_std;
    double altitude_std;
    enum SL_GNSS_STATUS gnss_status;
    enum SL_GNSS_MODE gnss_mode;
};
 
struct SL_LatLng
{
    double latitude;
    double longitude;
    double altitude;
};
 
struct SL_GeoPose
{
    struct SL_Vector3 translation;
    struct SL_Quaternion rotation;
    float pose_covariance[36];
    double horizontal_accuracy;
    double vertical_accuracy;
    struct SL_LatLng latlng_coordinates;
    double heading;
    uint64_t timestamp;
};
 
struct SL_ECEF 
{
    double x;
    double y;
    double z;
};
 
struct SL_UTM
{
    double northing;
    double easting;
    double gamma;
    char UTMZone[256];
};
 
struct SL_ENU
{
    double east;
    double north;
    double up;
};
 
struct SL_GNSSCalibrationParameters {
    float target_yaw_uncertainty;
    bool enable_translation_uncertainty_target;
    float target_translation_uncertainty;
    bool enable_reinitialization;
    float gnss_vio_reinit_threshold;
    bool enable_rolling_calibration;
    struct SL_Vector3 gnss_antenna_position;
};
 
struct SL_PositionalTrackingFusionParameters {
    bool enable_GNSS_fusion;
 
    struct SL_GNSSCalibrationParameters gnss_calibration_parameters;
 
    struct SL_Vector3 base_footprint_to_world_translation;
 
    struct SL_Quaternion base_footprint_to_world_rotation;
 
    struct SL_Vector3 base_footprint_to_baselink_translation;
 
    struct SL_Quaternion base_footprint_to_baselink_rotation;
 
    bool set_gravity_as_origin;
    struct SL_CameraIdentifier tracking_camera_id;
};
 
#if 0
 
 
struct SL_SpatialMappingFusionParameters
{
    float resolution_meter;
 
    float range_meter;
 
    bool use_chunk_only;
 
    int max_memory_usage;
 
    float disparity_std;
 
    float decay;
 
    bool enable_forget_past;
 
    int stability_counter;
    enum SL_SPATIAL_MAP_TYPE map_type;
};
#endif
 
#endif