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 "cuda.h"
 
struct SL_Quaternion {
    float x; 
    float y; 
    float z; 
    float w; 
};
 
struct SL_Vector2 {
    float x;
    float 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;
    unsigned long long 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;
    unsigned long long 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; 
    unsigned long long 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;
    unsigned long long  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 USB_DEVICE {
    USB_DEVICE_OCULUS,
    USB_DEVICE_HTC,
    USB_DEVICE_STEREOLABS
};
 
struct USB_product {
    int id_vendor;
    int id_product;
};
 
enum SL_ERROR_CODE {
 
    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 
};
 
enum SL_RESOLUTION {
    SL_RESOLUTION_HD4K, 
    SL_RESOLUTION_QHDPLUS, 
    SL_RESOLUTION_HD2K, 
    SL_RESOLUTION_HD1080, 
    SL_RESOLUTION_HD1200, 
    SL_RESOLUTION_HD720, 
    SL_RESOLUTION_SVGA, 
    SL_RESOLUTION_VGA, 
    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_VIRTUAL_ZED_X = 10, 
    SL_MODEL_ZED_XONE_GS = 30, 
    SL_MODEL_ZED_XONE_UHD = 31, 
};
 
enum SL_MEM
{
    SL_MEM_CPU, 
    SL_MEM_GPU  
};
 
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_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_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_VIEW {
    SL_VIEW_LEFT, 
    SL_VIEW_RIGHT, 
    SL_VIEW_LEFT_GRAY, 
    SL_VIEW_RIGHT_GRAY, 
    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 
};
 
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              
};
 
enum SL_POSITIONAL_TRACKING_MODE {
    SL_POSITIONAL_TRACKING_MODE_GEN_1, 
    SL_POSITIONAL_TRACKING_MODE_GEN_2, 
};
 
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, 
    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_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,       
    SL_OBJECT_SUBCLASS_BICYCLE,      
    SL_OBJECT_SUBCLASS_CAR,          
    SL_OBJECT_SUBCLASS_MOTORBIKE,    
    SL_OBJECT_SUBCLASS_BUS,          
    SL_OBJECT_SUBCLASS_TRUCK,        
    SL_OBJECT_SUBCLASS_BOAT,         
    SL_OBJECT_SUBCLASS_BACKPACK,     
    SL_OBJECT_SUBCLASS_HANDBAG,      
    SL_OBJECT_SUBCLASS_SUITCASE,     
    SL_OBJECT_SUBCLASS_BIRD,        
    SL_OBJECT_SUBCLASS_CAT,         
    SL_OBJECT_SUBCLASS_DOG,         
    SL_OBJECT_SUBCLASS_HORSE,       
    SL_OBJECT_SUBCLASS_SHEEP,       
    SL_OBJECT_SUBCLASS_COW,         
    SL_OBJECT_SUBCLASS_CELLPHONE,   
    SL_OBJECT_SUBCLASS_LAPTOP,      
    SL_OBJECT_SUBCLASS_BANANA,      
    SL_OBJECT_SUBCLASS_APPLE,       
    SL_OBJECT_SUBCLASS_ORANGE,      
    SL_OBJECT_SUBCLASS_CARROT,      
    SL_OBJECT_SUBCLASS_PERSON_HEAD, 
    SL_OBJEC_SUBCLASS_SPORTSBALL    
};
 
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_HUMAN_BODY_70_FAST_DETECTION, /**< Related to \ref SL_BODY_TRACKING_MODEL_HUMAN_BODY_FAST*/
    //SL_AI_MODELS_HUMAN_BODY_70_MEDIUM_DETECTION, /**< Related to \ref SL_BODY_TRACKING_MODEL_HUMAN_BODY_MEDIUM*/
    //SL_AI_MODELS_HUMAN_BODY_70_ACCURATE_DETECTION, /**< Related to \ref SL_BODY_TRACKING_MODEL_HUMAN_BODY_ACCURATE*/
    SL_AI_MODELS_PERSON_HEAD_DETECTION, 
    SL_AI_MODELS_PERSON_HEAD_ACCURATE_DETECTION, 
    SL_AI_MODELS_REID_ASSOCIATION, 
    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_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,
    SL_POSITION_TYPE_LAST
};
 
struct SL_Resolution {
    long long width;
    long long 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;
    int enable_image_validity_check;
};
 
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;
 
    unsigned char path[512];
    enum  SL_MODEL camera_model;
 
    unsigned int sn;
    enum SL_INPUT_TYPE input_type;
};
 
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_smothing;
    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;
 
};
 
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;
};
 
struct SL_SVOData
{
    char key[128];
    unsigned long long timestamp_ns;
    char* content;
    int content_size;
};
 
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;
};
 
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;
};
 
 
#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_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;
};
 
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;
 
#if 0
    struct SL_BatchParameters batch_parameters;
#endif
    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;
};
 
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;
};
 
struct SL_Objects
{
    int nb_objects;
    unsigned long long 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;
    unsigned long long 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]; 
    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]; 
    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]; 
    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]; 
    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;
};
 
 
 
enum SL_FUSION_ERROR_CODE {
    SL_FUSION_ERROR_CODE_GNSS_DATA_COVARIANCE_MUST_VARY= -8, 
    SL_FUSION_ERROR_CODE_BODY_FORMAT_MISMATCH = -7, 
    SL_FUSION_ERROR_CODE_MODULE_NOT_ENABLED = -6, 
    SL_FUSION_ERROR_CODE_SOURCE_MISMATCH = -5, 
    SL_FUSION_ERROR_CODE_CONNECTION_TIMED_OUT = -4, 
    SL_FUSION_ERROR_CODE_MEMORY_ALREADY_USED = -3, 
    SL_FUSION_ERROR_CODE_INVALID_IP_ADDRESS = -2, 
    SL_FUSION_ERROR_CODE_FAILURE = -1, 
    SL_FUSION_ERROR_CODE_SUCCESS = 0, 
    SL_FUSION_ERROR_CODE_FUSION_INCONSISTENT_FPS = 1, 
    SL_FUSION_ERROR_CODE_FUSION_FPS_TOO_LOW = 2, 
    SL_FUSION_ERROR_CODE_INVALID_TIMESTAMP = 3, 
    SL_FUSION_ERROR_CODE_INVALID_COVARIANCE = 4, 
    SL_FUSION_ERROR_CODE_NO_NEW_DATA_AVAILABLE = 5 
};
 
enum SL_SENDER_ERROR_CODE {
    SL_SENDER_ERROR_CODE_DISCONNECTED = -1, 
    SL_SENDER_ERROR_CODE_SUCCESS = 0, 
    SL_SENDER_ERROR_CODE_GRAB_ERROR = 1, 
    SL_SENDER_ERROR_CODE_INCONSISTENT_FPS = 2, 
    SL_SENDER_ERROR_CODE_FPS_TOO_LOW = 3 
};
 
enum SL_COMM_TYPE
{
    SL_COMM_TYPE_LOCAL_NETWORK, 
    SL_COMM_TYPE_INTRA_PROCESS 
};
 
enum SL_GNSS_STATUS
{
    SL_GNSS_STATUS_UNKNOWN, 
    SL_GNSS_STATUS_SINGLE,
    SL_GNSS_STATUS_DGNSS,
    SL_GNSS_STATUS_RTK_FIX,
    SL_GNSS_STATUS_RTK_FLOAT,
    SL_GNSS_STATUS_PPS      
};
 
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 
};
 
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;
};
 
 
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;
 
    struct SL_SynchronizationParameter synchronization_parameters; 
};
 
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 {
    unsigned long long int 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;
    unsigned long long ts;
    double position_covariance[9];
    double longitude_std;
    double latitude_std;
    double altitude_std;
};
 
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;
    unsigned long long timestamp;
};
 
struct SL_ECEF 
{
    double x;
    double y;
    double z;
};
 
struct SL_UTM
{
    double northing;
    double easting;
    double gamma;
    char UTMZone[256];
};
 
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;
 
};
 
#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