types_c.h

Go to the documentation of this file.

#ifndef __TYPES_C_H__
#define __TYPES_C_H__
 
#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>
 
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_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_SensorData {
    //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_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_HD2K, 
    SL_RESOLUTION_HD1080, 
    SL_RESOLUTION_HD720, 
    SL_RESOLUTION_VGA 
};
 
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, 
};
 
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
};
 
enum SL_REFERENCE_FRAME
{
    SL_REFERENCE_FRAME_WORLD,  
    SL_REFERENCE_FRAME_CAMERA, 
};
 
enum SL_SENSOR_WORLD {
    SL_SENSOR_WORLD_OFF, 
    SL_SENSOR_WORLD_IMU_GRAVITY 
};
 
 
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_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, 
};
 
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_SENSING_MODE {
    SL_SENSING_MODE_STANDARD,
    SL_SENSING_MODE_FILL
};
 
enum SL_DEPTH_MODE {
    SL_DEPTH_MODE_NONE, 
    SL_DEPTH_MODE_PERFORMANCE, 
    SL_DEPTH_MODE_QUALITY, 
    SL_DEPTH_MODE_ULTRA, 
    SL_DEPTH_MODE_NEURAL 
};
 
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_DETECTION_MODEL {
    SL_DETECTION_MODEL_MULTI_CLASS_BOX, 
    SL_DETECTION_MODEL_MULTI_CLASS_BOX_ACCURATE, 
    SL_DETECTION_MODEL_HUMAN_BODY_FAST, 
    SL_DETECTION_MODEL_HUMAN_BODY_ACCURATE, 
    SL_DETECTION_MODEL_MULTI_CLASS_BOX_MEDIUM, 
    SL_DETECTION_MODEL_HUMAN_BODY_MEDIUM, 
    SL_DETECTION_MODEL_PERSON_HEAD_BOX, 
    SL_DETECTION_MODEL_PERSON_HEAD_BOX_ACCURATE, 
    SL_DETECTION_MODEL_CUSTOM_BOX_OBJECTS 
};
 
enum SL_AI_MODELS {
    SL_AI_MODELS_MULTI_CLASS_DETECTION, // related to sl::DETECTION_MODEL::MULTI_CLASS_BOX
    SL_AI_MODELS_MULTI_CLASS_MEDIUM_DETECTION, // related to sl::DETECTION_MODEL::MULTI_CLASS_BOX_MEDIUM
    SL_AI_MODELS_MULTI_CLASS_ACCURATE_DETECTION, // related to sl::DETECTION_MODEL::MULTI_CLASS_BOX_ACCURATE
    SL_AI_MODELS_HUMAN_BODY_FAST_DETECTION, // related to sl::DETECTION_MODEL::HUMAN_BODY_FAST
    SL_AI_MODELS_HUMAN_BODY_MEDIUM_DETECTION, // related to sl::DETECTION_MODEL::HUMAN_BODY_MEDIUM
    SL_AI_MODELS_HUMAN_BODY_ACCURATE_DETECTION, // related to sl::DETECTION_MODEL::HUMAN_BODY_ACCURATE
    SL_AI_MODELS_PERSON_HEAD_DETECTION, // related to sl::DETECTION_MODEL::PERSON_HEAD_BOX
    SL_AI_MODELS_PERSON_HEAD_ACCURATE_DETECTION, // related to sl::DETECTION_MODEL::PERSON_HEAD_BOX_ACCURATE
    SL_AI_MODELS_REID_ASSOCIATION, // related to sl::BatchParameters::enable
    SL_AI_MODELS_NEURAL_DEPTH, // related to sl::DEPTH_MODE::NEURAL
    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_BODY_FORMAT
{
    SL_BODY_FORMAT_POSE_18,
 
    SL_BODY_FORMAT_POSE_34,
};
 
enum SL_BODY_PARTS_POSE_18
{
    SL_BODY_PARTS_POSE_18_NOSE,
    SL_BODY_PARTS_POSE_18_NECK,
    SL_BODY_PARTS_POSE_18_RIGHT_SHOULDER,
    SL_BODY_PARTS_POSE_18_RIGHT_ELBOW,
    SL_BODY_PARTS_POSE_18_RIGHT_WRIST,
    SL_BODY_PARTS_POSE_18_LEFT_SHOULDER,
    SL_BODY_PARTS_POSE_18_LEFT_ELBOW,
    SL_BODY_PARTS_POSE_18_LEFT_WRIST,
    SL_BODY_PARTS_POSE_18_RIGHT_HIP,
    SL_BODY_PARTS_POSE_18_RIGHT_KNEE,
    SL_BODY_PARTS_POSE_18_RIGHT_ANKLE,
    SL_BODY_PARTS_POSE_18_LEFT_HIP,
    SL_BODY_PARTS_POSE_18_LEFT_KNEE,
    SL_BODY_PARTS_POSE_18_LEFT_ANKLE,
    SL_BODY_PARTS_POSE_18_RIGHT_EYE,
    SL_BODY_PARTS_POSE_18_LEFT_EYE,
    SL_BODY_PARTS_POSE_18_RIGHT_EAR,
    SL_BODY_PARTS_POSE_18_LEFT_EAR,
    SL_BODY_PARTS_POSE_18_LAST
};
 
enum SL_BODY_PARTS_POSE_34
{
    SL_BODY_PARTS_POSE_34_PELVIS,
    SL_BODY_PARTS_POSE_34_NAVAL_SPINE,
    SL_BODY_PARTS_POSE_34_CHEST_SPINE,
    SL_BODY_PARTS_POSE_34_NECK,
    SL_BODY_PARTS_POSE_34_LEFT_CLAVICLE,
    SL_BODY_PARTS_POSE_34_LEFT_SHOULDER,
    SL_BODY_PARTS_POSE_34_LEFT_ELBOW,
    SL_BODY_PARTS_POSE_34_LEFT_WRIST,
    SL_BODY_PARTS_POSE_34_LEFT_HAND,
    SL_BODY_PARTS_POSE_34_LEFT_HANDTIP,
    SL_BODY_PARTS_POSE_34_LEFT_THUMB,
    SL_BODY_PARTS_POSE_34_RIGHT_CLAVICLE,
    SL_BODY_PARTS_POSE_34_RIGHT_SHOULDER,
    SL_BODY_PARTS_POSE_34_RIGHT_ELBO,
    SL_BODY_PARTS_POSE_34_RIGHT_WRIST,
    SL_BODY_PARTS_POSE_34_RIGHT_HAND,
    SL_BODY_PARTS_POSE_34_RIGHT_HANDTIP,
    SL_BODY_PARTS_POSE_34_RIGHT_THUMB,
    SL_BODY_PARTS_POSE_34_LEFT_HIP,
    SL_BODY_PARTS_POSE_34_LEFT_KNEE,
    SL_BODY_PARTS_POSE_34_LEFT_ANKLE,
    SL_BODY_PARTS_POSE_34_LEFT_FOOT,
    SL_BODY_PARTS_POSE_34_RIGHT_HIP,
    SL_BODY_PARTS_POSE_34_RIGHT_KNEE,
    SL_BODY_PARTS_POSE_34_RIGHT_ANKLE,
    SL_BODY_PARTS_POSE_34_RIGHT_FOOT,
    SL_BODY_PARTS_POSE_34_HEAD,
    SL_BODY_PARTS_POSE_34_NOSE,
    SL_BODY_PARTS_POSE_34_LEFT_EYE,
    SL_BODY_PARTS_POSE_34_LEFT_EAR,
    SL_BODY_PARTS_POSE_34_RIGHT_EYE,
    SL_BODY_PARTS_POSE_34_RIGHT_EAR,
    SL_BODY_PARTS_POSE_34_LEFT_HEEL,
    SL_BODY_PARTS_POSE_34_RIGHT_HEEL,
    SL_BODY_PARTS_POSE_34_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;
};
 
struct SL_RuntimeParameters
{
    enum SL_SENSING_MODE sensing_mode;
    enum  SL_REFERENCE_FRAME reference_frame;
    bool enable_depth;
    int confidence_threshold;
    int texture_confidence_threshold;
    bool remove_saturated_areas;
};
 
struct SL_DeviceProperties {
    enum  SL_CAMERA_STATE camera_state;
    int id;
    enum  SL_MODEL camera_model;
    unsigned int sn;
};
 
struct SL_CameraParameters {
    float fx; 
    float fy; 
    float cx; 
    float cy; 
    double disto[5]; 
    float v_fov; 
    float h_fov; 
    float d_fov; 
    struct SL_Resolution image_size; 
};
 
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;
};
 
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_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;
};
 
 
#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; // the model file is currently present on the host
    bool optimized; // an engine file with the expected architecure is found.
};
 
struct SL_ObjectDetectionParameters
{
    bool image_sync; // data synchronized
    bool enable_tracking;
    bool enable_mask_output;
    enum  SL_DETECTION_MODEL model;
    bool enable_body_fitting;
    enum SL_BODY_FORMAT body_format;
    float max_range;
    struct SL_BatchParameters batch_parameters;
    enum SL_OBJECT_FILTERING_MODE filtering_mode;
    float prediction_timeout_s;
};
 
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];
    int minimum_keypoints_threshold;
};
 
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;
    float confidence;
 
    //Mask
    int* mask;
    //int* mask; //IntPtr to an sl::Mat object.
 
    //Image
    struct SL_Vector2 bounding_box_2d[4];
    struct SL_Vector3 position;
    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 keypoint_2d[34];
    struct SL_Vector3 keypoint[34];
    float position_covariance[6];
    float keypoint_confidence[34];
    struct SL_Vector3 local_position_per_joint[34];
    struct SL_Quaternion local_orientation_per_joint[34];
    struct SL_Quaternion global_root_orientation;
};
 
struct SL_CustomBoxObjectData {
    char unique_object_id[37];
    struct SL_Vector2 bounding_box_2d[4];
 
    int label;
 
    float probability;
    bool is_grounded;
};
 
struct SL_Objects
{
    int nb_object;
    unsigned long long image_ts;
    int is_new;
    int is_tracked;
    enum  SL_DETECTION_MODEL detection_model;
    struct SL_ObjectData object_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 keypoints_2d[MAX_TRAJECTORY_SIZE][18];
    struct SL_Vector3 keypoints[MAX_TRAJECTORY_SIZE][18];
    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][18];
};
 
/*
Defines a 2D rectangle with top-left corner coordinates and width/height in pixels.
*/
struct SL_Rect
{
    int x;
    int y;
    int width;
    int height;
};
 
#endif
 
#endif