sb.h

Go to the documentation of this file.

//Created on : 22 Jan 2016
 
//#define SB_PROFILE_TIME //Abilitare se si deve profilare il tempo di calcolo della sb_project_detection
//#define SB_DEBUG_PROJECT_GET_PAR_MEMORY_LEAK
 
//Il define rende non modificabili dall'utente questi parametri.
//Se si modificano i seguenti parametri la funzione sb_project_set_par da errore.
//sb_t_par.svl.dl.perturbations.inpainter_path
//sb_t_par.svl.dl.perturbations.mode
//sb_t_par.svl.dl.perturbations.type
//sb_t_par.svl.dl.learning_rate
//sb_t_par.svl.dl.network.n_channels
//sb_t_par.svl.dl.network.input_size
//sb_t_par.svl.dl.network.image_format
//sb_t_par.svl.dl.network.freeze_mode
//sb_t_par.svl.dl.loss_fn
//#define SB_ENABLE_DL_RESERVED_PAR
 
#ifdef SB_ENABLE_DL_RESERVED_PAR
//#define SB_ENABLE_TENSORFLOW
#endif
 
//#define ENABLE_TILING_GET_RANGE         // Abilita la funzione sb_par_tiling_get_range
//#define ENABLE_DEEP_RETINA              // Abilita il modulo Deep Retina
//#define NEW_VERSION_SDINET1
//Il define abilita la rete di segmentazione semantica UNet.
//#define NEW_VERSION_DEEP_SURFACE_UNET
 
 
#ifndef INCLUDE_SB_H_
#define INCLUDE_SB_H_
 
#include <time.h>
#include <stdio.h>
 
#ifdef __cplusplus
#  define SB_EXTERN_C extern "C"
#else
#  define SB_EXTERN_C extern
#endif
 
#if defined _MSC_VER
#  define SB_CDECL __cdecl
#else
#  define SB_CDECL
#endif
 
#ifndef SB_DL_DLL //sb_lib
#  ifdef _MSC_VER
#    ifdef SB_API_EXPORTS
#      define SB_EXPORTS __declspec(dllexport)
#      define SB_DL_EXPORTS __declspec(dllimport)
#    else
#      define SB_EXPORTS __declspec(dllimport)
#    endif
#  else
#    ifdef SB_API_EXPORTS
#      define SB_EXPORTS __attribute__ ((visibility ("default")))
#      define SB_DL_EXPORTS __attribute__ ((visibility ("default")))
#    else
#      define SB_EXPORTS
#    endif
#  endif
#  define SB_PUBLIC(return_type) SB_EXTERN_C SB_EXPORTS return_type SB_CDECL
#  define SB_DL_PUBLIC(return_type) SB_EXTERN_C SB_DL_EXPORTS return_type SB_CDECL
#else //sb_dl_lib
#  ifdef _MSC_VER
#    ifdef SB_DL_API_EXPORTS
#      define SB_DL_EXPORTS __declspec(dllexport)
#    else
#      define SB_DL_EXPORTS __declspec(dllimport)
#    endif
#  else
#    ifdef SB_DL_API_EXPORTS
#      define SB_DL_EXPORTS __attribute__ ((visibility ("default")))
#    else
#      define SB_DL_EXPORTS
#    endif
#  endif
#  define SB_PUBLIC(return_type) SB_EXTERN_C return_type SB_CDECL
#  define SB_DL_PUBLIC(return_type) SB_EXTERN_C SB_DL_EXPORTS return_type SB_CDECL
#endif //SB_DL_DLL
 
#if defined __cplusplus
#  define SB_INLINE inline
#else
#  define SB_INLINE static __inline
#endif
 
typedef enum
{
    SB_ERR_NONE = 0, 
    SB_ERR_BASE64_SIZE = 10000, 
    SB_ERR_BUFFER_SIZE = 20000, 
    SB_ERR_CLS = 30000, 
    SB_ERR_CLS_CREATE = 30010, 
    SB_ERR_CLS_NOT_TRAINED = 30020, 
    SB_ERR_CLS_PREDICT = 30030, 
    SB_ERR_CLS_TRAINING = 30040, 
    SB_ERR_DECRYPT = 40000, 
    SB_ERR_DIR_CREATE = 50000, 
    SB_ERR_DIR_EXIST = 50010, 
    SB_ERR_DIR_NOT_EXIST = 50020, 
    SB_ERR_DIR_RENAME = 50025, 
    SB_ERR_DIR_REMOVE = 50030, 
    SB_ERR_DL_CUDA_OUT_OF_MEMORY = 50250, 
    SB_ERR_DL_FRAMEWORK = 50500, 
    SB_ERR_DL_FREEZE_NOT_PRE_TRAINED = 50600, 
    SB_ERR_DL_INPAINTER_NOT_ASSIGNED = 51000, 
    SB_ERR_DL_INPAINTER_NOT_FOUND = 51250, 
    SB_ERR_DL_INPUT_NETWORK_SIZE = 51315, 
    SB_ERR_DL_INTERNAL = 51375, 
    SB_ERR_DL_NETWORK_FILE_NOT_FOUND = 51500, 
    SB_ERR_DL_NO_LABELED_IMAGES = 51625, 
    SB_ERR_DL_NOT_SUPPORTED = 51750, 
    SB_ERR_DL_ONNX_CONVERSION = 51800, 
    SB_ERR_DL_OPENVINO_DATA_NOT_EXIST = 51812, 
    SB_ERR_DL_PRE_TRAINING_BORDERS_EXTENSION_MODE = 51825, 
    SB_ERR_DL_PRE_TRAINING_FEATURES_MULTIPLIER = 51850, 
    SB_ERR_DL_PRE_TRAINING_FILE_NOT_FOUND = 52000, 
    SB_ERR_DL_PRE_TRAINING_FILE_NOT_VALID = 52500, 
    SB_ERR_DL_PRE_TRAINING_IMAGE_CHANNELS = 52515, 
    SB_ERR_DL_PRE_TRAINING_IMAGE_FORMAT = 52530, 
    SB_ERR_DL_PRE_TRAINING_INPUT_SIZE = 52545, 
    SB_ERR_DL_PRE_TRAINING_LOSS_FN = 52560, 
    SB_ERR_DL_PRE_TRAINING_MODELS_NUMBER = 52575, 
    SB_ERR_DL_PRE_TRAINING_NETWORK_TYPE = 52590, 
    SB_ERR_DL_ROI_DEFECTS_NOT_SET = 52615, 
    SB_ERR_DL_ROI_NOT_SET = 52625, 
    SB_ERR_DL_TILING_MODE = 52800, 
    SB_ERR_DL_TILING_RANGE = 52900, 
    SB_ERR_DL_TRAINING_DATA_MISSING = 53000, 
    SB_ERR_ENCRYPT = 60000, 
    SB_ERR_FILE_COPY = 69000, 
    SB_ERR_FILE_EMPTY = 69500, 
    SB_ERR_FILE_EXTENSION = 70000, 
    SB_ERR_FILE_FORMAT = 70010, 
    SB_ERR_FILE_NAME = 70020, 
    SB_ERR_FILE_NAME_EMPTY = 70030, 
    SB_ERR_FILE_NAME_LENGHT = 70035, 
    SB_ERR_FILE_NOT_EXIST = 70040, 
    SB_ERR_FILE_READ = 70050, 
    SB_ERR_FILE_REMOVE = 70055, 
    SB_ERR_FILE_OPEN = 70060, 
    SB_ERR_FILE_SAVE = 70070, 
    SB_ERR_FILE_VERSION = 70075, 
    SB_ERR_FILE_WRITE = 70080, 
    SB_ERR_IMAGE_CHANNELS = 80000, 
    SB_ERR_IMAGE_CIRCULARITY = 80002, 
    SB_ERR_IMAGE_COMPRESSION = 80005, 
    SB_ERR_IMAGE_CREATE = 80010, 
    SB_ERR_IMAGE_DECODE = 80015, 
    SB_ERR_IMAGE_DEPTH = 80020, 
    SB_ERR_IMAGE_ENCODE = 80025, 
    SB_ERR_IMAGE_FORMAT = 80030, 
    SB_ERR_IMAGE_LOAD = 80040, 
    SB_ERR_IMAGE_RESIZE = 80045, 
    SB_ERR_IMAGE_RESOLUTION = 80050, 
    SB_ERR_IMAGE_SIZE = 80070, 
    SB_ERR_IMAGE_SIZE_CIRCULAR = 800075, 
    SB_ERR_IMAGE_TYPE = 80085, 
    SB_ERR_IMAGE_WARP = 80100, 
    SB_ERR_IMAGE_WIDTH_STEP = 800150, 
    SB_ERR_INITIALIZE = 90000, 
    SB_ERR_INSUFFICIENT_FREE_MEMORY = 95000, 
    SB_ERR_INTERNAL = 100000, 
    SB_ERR_INVALID_MAIL_ADDRESS = 110000, 
    SB_ERR_LEVELS_ENABLED = 115000, 
    SB_ERR_LEVELS_NUMBER = 115100, 
    SB_ERR_LIBRARY_DEPENDENCIES = 116000, 
    SB_ERR_LIBRARY_FUNCTION_ADDRESS = 117000, 
    SB_ERR_LIBRARY_OPEN = 11800, 
    SB_ERR_LICENSE = 120000, 
    SB_ERR_LICENSE_CODE = 120010, 
    SB_ERR_LICENSE_CORRUPTED = 120020, 
    SB_ERR_LICENSE_DISABLED = 120025, 
    SB_ERR_LICENSE_EXPIRED = 120030, 
    SB_ERR_LICENSE_FEATURES_NUMBER = 120035, 
    SB_ERR_LICENSE_FILE = 120040, 
    SB_ERR_LICENSE_MACHINE_ID_MATCH = 120050, 
    SB_ERR_LICENSE_MAIL_ADDRESS = 120055, 
    SB_ERR_LICENSE_MARKER = 120060, 
    SB_ERR_LICENSE_MODELS_NUMBER = 120063, 
    SB_ERR_LICENSE_NOT_FOUND = 120065, 
    SB_ERR_LICENSE_SAME_MACHINE_ID = 120070, 
    SB_ERR_LICENSE_TRAINING = 120075, 
    SB_ERR_LICENSE_TYPE = 120080, 
    SB_ERR_LICENSE_VERSION = 120090, 
    SB_ERR_LICENSE_VM = 120100, 
    SB_ERR_LICENSE_WAIT_SERVER = 120110, 
    SB_ERR_MACHINE_ID = 130000, 
    SB_ERR_MALLOC = 140000, 
    SB_ERR_MEMORY_LEAK = 150000, 
    SB_ERR_MODEL_DESC_UTF8 = 152000, 
    SB_ERR_MODEL_DISABLED = 154500,  
    SB_ERR_MODEL_NAME = 155000,  
    SB_ERR_MODEL_NAME_UNDEFINED = 156000,  
    SB_ERR_MODEL_NAME_UTF8 = 15700, 
    SB_ERR_MODEL_NOT_FOUND = 160000, 
    SB_ERR_MODEL_NOT_TRAINED = 162500, 
    SB_ERR_MODELS_ENABLED = 165000,  
    SB_ERR_MODELS_NUMBER = 170000, 
    SB_ERR_NULL_POINTER = 180000, 
    SB_ERR_NO_CLASSIFIED_IMAGE = 190000, 
    SB_ERR_NO_FEATURES_AVAILABLE = 195000, 
    SB_ERR_NO_LEVELS_AVAILABLE = 196000, 
    SB_ERR_NO_FILE_FOUND = 200000, 
    SB_ERR_NO_POINT_FOUND = 205000, 
    SB_ERR_NOT_IMPLEMENTED = 210000, 
    SB_ERR_NVIDIA_NVML = 212500, 
    SB_ERR_PATH_SIZE = 215000, 
    SB_ERR_PROJECT_LOAD_MODE = 217500, 
    SB_ERR_PROJECT_NOT_FOUND = 217600, 
    SB_ERR_PROJECT_TYPE = 218500, 
    SB_ERR_RPF_NAME_EMPTY = 220000, 
    SB_ERR_ROI = 230000, 
    SB_ERR_ROI_BOUNDING_BOX = 230005, 
    SB_ERR_ROI_DEFECTS = 230010, 
    SB_ERR_SAMPLE_BACKGROUND = 239000, 
    SB_ERR_SAMPLE_NOT_FOUND = 240000, 
    SB_ERR_SAMPLE_NUMBER = 240010, 
    SB_ERR_SAMPLE_OUT_OF_IMAGE = 240020, 
    SB_ERR_SAMPLE_WRONG = 240030, 
    SB_ERR_SAMPLE_DISTANCE = 240040, 
    SB_ERR_SAMPLE_SCALE = 240050, 
    SB_ERR_SAMPLES_GT_TOO_MANY = 240200, 
    SB_ERR_SCALE_NOT_FOUND = 240500, 
    SB_ERR_SENTINEL = 241000, 
    SB_ERR_SENTINEL_MASTER_KEY = 241500, 
    SB_ERR_SENTINEL_TOO_MANY_KEYS = 242000, 
    SB_ERR_SENTINEL_RUN_TIME = 242500, 
    SB_ERR_SOCKET = 250000, 
    SB_ERR_SOCKET_ACCEPT = 250010, 
    SB_ERR_SOCKET_BIND = 250020, 
    SB_ERR_SOCKET_CONNECT = 250030, 
    SB_ERR_SOCKET_CLOSED = 250040, 
    SB_ERR_SOCKET_CREATE = 250050, 
    SB_ERR_SOCKET_INVALID_IP = 250060, 
    SB_ERR_SOCKET_INVALID_PORT = 250070, 
    SB_ERR_SOCKET_IOCTL = 250080, 
    SB_ERR_SOCKET_LISTEN = 250090, 
    SB_ERR_SOCKET_MAC = 250095, 
    SB_ERR_SOCKET_RECEIVE = 250100, 
    SB_ERR_SOCKET_SELECT = 250110, 
    SB_ERR_SOCKET_SEND = 250120, 
    SB_ERR_SOCKET_SET_PARAMETER = 250130, 
    SB_ERR_SOCKET_TIMEOUT = 250140, 
    //N.B. Fino a 251999 i codici di errore sono riservati ai socket SB_ERR_SOCKET_xxxxx
    //     Se si cambia modificare anche la funzione sb_err_socket
    SB_ERR_STRING_EMPTY = 253000, 
    SB_ERR_STRING_UTF8 = 254000, 
    SB_ERR_STRUCT_HEADER_WRONG_CODE = 260000, 
    SB_ERR_STRUCT_HEADER_WRONG_SIZE = 260010, 
    SB_ERR_STRUCT_HEADER_WRONG_VERSION = 260020, 
    SB_ERR_SVL_PERTURBATION = 270000, 
    SB_ERR_SVL_WAS_NOT_DONE = 270010, 
    SB_ERR_SVL_WRONG = 270020, 
    SB_ERR_SVL_CHOOSE_FEATURES = 270040, 
    SB_ERR_SVL_CHOOSE_FEATURES_FAST = 270100, 
    SB_ERR_SVL_VALIDATION_DATASET = 277000, 
    SB_ERR_THREAD = 280000, 
    SB_ERR_UUID = 290000, 
    SB_ERR_VERSION = 300000, 
    SB_ERR_VERSION_FORMAT = 300010, 
    SB_ERR_WARP_POINT_NOT_FOUND = 310000, 
    SB_ERR_WRONG_PARAMETER = 320000, 
    SB_ERR_XML = 330000, 
    SB_ERR_XML_NODE_NOT_FOUND = 330010, 
}sb_t_err;
 
typedef void(*sb_fp_trace_callback)(void* const user_data, const char * const msg);
 
SB_PUBLIC(sb_t_err) sb_trace(int trace_enable, int date_time_enable, int line_enable, int trace_win_enable, const char* const filename, sb_fp_trace_callback trace_callback, void* const user_data);
 
SB_PUBLIC(const char*) sb_err_format(sb_t_err code); // group_error
 
typedef struct
{
    int x; 
    int y; 
}sb_t_point;
 
typedef struct
{
    float x;
    float y;
}sb_t_point2d_f;
 
typedef struct
{
    int width;  
    int height; 
}sb_t_size;
 
typedef struct
{
    float width;  
    float height; 
}sb_t_size_flt;
 
typedef struct
{
    int min; 
    int max; 
}sb_t_range;
 
typedef struct
{
    float min; 
    float max; 
}sb_t_range_flt;
 
typedef struct
{
    int x;      
    int y;      
    int width;  
    int height; 
}sb_t_rect;
 
SB_INLINE sb_t_point sb_point(int x, int y)
{
    sb_t_point p;
    p.x = x;
    p.y = y;
    return(p);
}
 
SB_INLINE sb_t_point2d_f sb_point2d_f(float x, float y)
{
    sb_t_point2d_f p;
    p.x = x;
    p.y = y;
    return(p);
}
 
SB_INLINE sb_t_size sb_size(int width, int height)
{
    sb_t_size sz;
    sz.width = width;
    sz.height = height;
    return(sz);
}
 
SB_INLINE sb_t_size_flt sb_size_flt(float width, float height)
{
    sb_t_size_flt sz;
    sz.width = width;
    sz.height = height;
    return(sz);
}
 
SB_INLINE sb_t_range sb_range(int min, int max)
{
    sb_t_range r;
    r.min = min;
    r.max = max;
    return(r);
}
 
SB_INLINE sb_t_range_flt sb_range_flt(float min, float max)
{
    sb_t_range_flt r;
    r.min = min;
    r.max = max;
    return(r);
}
 
SB_INLINE sb_t_rect sb_rect(int x, int y, int width, int height)
{
    sb_t_rect r;
 
    r.x = x;
    r.y = y;
    r.width = width;
    r.height = height;
 
    return r;
}
 
SB_PUBLIC(sb_t_err) sb_polyline_resize(sb_t_point2d_f* points, int size, sb_t_point2d_f center, float angle, float offset);
 // group_geometric
 
#define SB_INIT_ONLY_HW_LICENSE_KEY "ONLY_HW_KEY"
 
#define SB_INIT_ONLY_SB_LICENSE_KEY "ONLY_SB_KEY"
 
#define SB_INIT_NO_LICENSE_KEY      "NO_KEY"
 
#define SB_DELIMITER ";"
 
typedef enum
{
    SB_DL_LIBRARY_NONE = 0, 
    SB_DL_LIBRARY_PYTORCH,  
    SB_DL_LIBRARY_OPENVINO  
}sb_t_dl_library_type;
 
SB_PUBLIC(sb_t_err) sb_init(const char* const license_file);
 
SB_PUBLIC(sb_t_err) sb_init_dl(const char* const search_path, sb_t_dl_library_type lib_type);
 
SB_PUBLIC(sb_t_err) sb_release(void);
 
typedef void * SB_HANDLE;
 
typedef struct
{
    int major;        
    int minor;        
    int vminor;       
    int build_major;  
}sb_t_version;
 
SB_INLINE sb_t_version sb_version(int major, int minor, int vminor, int build_major)
{
    sb_t_version version;
    version.major = major;
    version.minor = minor;
    version.vminor = vminor;
    version.build_major = build_major;
    return(version);
}
 
SB_PUBLIC(int) sb_version_check(sb_t_version version1, sb_t_version version2);
 
typedef struct
{
    signed long long proc_virtual_used;       
    signed long long proc_virtual_used_max;   
    signed long long proc_virtual_max;        
    signed long long proc_physical_used;      
    signed long long proc_physical_used_max;  
    signed long long system_total;            
    signed long long system_used;             
    signed long long system_free;             
}sb_t_memory_info;
 
typedef enum
{
    SB_DEVICE_NONE = -1,   
    SB_DEVICE_CPU = 0,     
    SB_DEVICE_GPU_NVIDIA,  
    SB_DEVICE_IGPU_INTEL,  
    SB_DEVICE_DGPU_INTEL   
}sb_t_device_type;
 
typedef enum
{
    SB_FRAMEWORK_TYPE_NONE = 0, 
    SB_FRAMEWORK_TYPE_SB,       
    SB_FRAMEWORK_TYPE_PYTORCH,  
    SB_FRAMEWORK_TYPE_OPENVINO  
}sb_t_framework_type;
 
#define SB_FRAMEWORKS_MAX_NUMBER 4
 
typedef struct
{
    sb_t_framework_type framework[SB_FRAMEWORKS_MAX_NUMBER];
    
    int size;
}sb_t_frameworks;
 
typedef struct
{
    sb_t_device_type type;
 
    sb_t_frameworks frameworks;
 
    char name[128];
 
    char compute_capability[8];
 
    int id;
 
    sb_t_memory_info memory;
 
    int available;
}sb_t_device_info;
 
typedef struct
{
    sb_t_device_info* device;
 
    int size;
}sb_t_devices_info;
 
typedef struct
{
    sb_t_version version;             
    char version_str[16];             
    char compile_date[32];            
    char compile_time[32];            
    signed long long malloc_size;     
    signed long long malloc_size_max; 
    int dl_modules_enabled;           
    sb_t_devices_info devices;        
}sb_t_info;
 
typedef struct
{
    unsigned char b; 
    unsigned char g; 
    unsigned char r; 
    unsigned char a; 
}sb_t_bgra;
 
SB_INLINE sb_t_bgra sb_bgra(unsigned char b, unsigned char g, unsigned char r, unsigned char a)
{
    sb_t_bgra bgra;
    bgra.b = b;
    bgra.g = g;
    bgra.r = r;
    bgra.a = a;
    return(bgra);
}
 
typedef struct
{
    unsigned char r; 
    unsigned char g; 
    unsigned char b; 
    unsigned char a;
}sb_t_rgba;
 
SB_INLINE sb_t_rgba sb_rgba(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
    sb_t_rgba rgba;
    rgba.r = r;
    rgba.g = g;
    rgba.b = b;
    rgba.a = a;
    return(rgba);
}
 
#define SB_VALUE_NOT_SET                        1000000.0f 
#define SB_PAR_MODELS_NUM                            64    
#define SB_PAR_PERTURBATIONS_NUM                     16    
#define SB_PAR_STRING_LEN                            64    
#define SB_IMAGE_NAME_STRING_LEN                    128    
#define SB_PAR_LEVELS_NUM                            32    
#define SB_PAR_LEVEL_SCALE_GRANULARITY                0.50f
#define SB_PAR_LEVEL_SCALE_MIN                        1.0f 
#define SB_PAR_LEVEL_SCALE_MAX                       16.0f 
#define SB_PAR_RETINA_OBJ_SIZE_MIN                   24    
#define SB_PAR_RETINA_OBJ_SIZE_MAX                 1024    
#define SB_PAR_RETINA_OBJ_STRIDE_COARSE_MIN           4    
#define SB_PAR_RETINA_OBJ_STRIDE_COARSE_MAX          32    
#define SB_PAR_RETINA_OBJ_STRIDE_FINE_MIN             1    
#define SB_PAR_RETINA_OBJ_STRIDE_FINE_MAX             8   
#define SB_PAR_RETINA_OBJ_DISTANCE_MIN                4    
#define SB_PAR_RETINA_NUM_OCCURRENCES_MIN            -1    
                                                  
#define SB_SAMPLE_SCALE_GRANULARITY                  0.25f 
#define SB_SAMPLE_SCALE_MIN                          1.0f  
#define SB_SAMPLE_SCALE_MAX                         32.0f  
 
#define SB_DL_SCALE_MIN                              0.1f  
#define SB_DL_SCALE_MAX                             32.0f  
#define SB_DL_SCALE_GRANULARITY                      0.01f 
 
#define SB_SVL_DL_INPUT_SDINET0_SIZE_DEFAULT       331     
#define SB_SVL_DL_INPUT_SDINET0_SIZE_MIN           128     
#define SB_SVL_DL_INPUT_SDINET0_SIZE_MAX           512     
 
#ifdef NEW_VERSION_SDINET1
#define SB_SVL_DL_INPUT_SDINET1_SIZE_DEFAULT       331     
#define SB_SVL_DL_INPUT_SDINET1_SIZE_MIN           128     
#define SB_SVL_DL_INPUT_SDINET1_SIZE_MAX           512     
#endif
 
#define SB_SVL_DL_BATCH_SIZE_MIN                     4     
#define SB_SVL_DL_BATCH_SIZE_MAX                   512     
 
#define SB_SVL_DL_VALIDATION_PERCENTAGE_MIN          0.0f  
#define SB_SVL_DL_VALIDATION_PERCENTAGE_MAX          0.5f  
 
#define SB_SVL_DL_LEARNING_RATE_MIN                  0.000001f
#define SB_SVL_DL_LEARNING_RATE_MAX                  0.01f 
#define SB_SVL_DL_LEARNING_RATE_DEFAULT              0.001f
 
#define SB_SVL_DL_NUM_TILES_MIN                      1     
#define SB_SVL_DL_NUM_TILES_MAX                     64     
 
#define SB_SVL_DL_FEATURES_MULTIPLIER_MIN            0.5f 
#define SB_SVL_DL_FEATURES_MULTIPLIER_MAX            1.5f 
#define SB_SVL_DL_FEATURES_MULTIPLIER_GRANULARITY    0.1f 
#define SB_SVL_DL_FEATURES_MULTIPLIER_DEFAULT        1.0f 
 
#define SB_SVL_DL_PERTURBATION_SCALE_MIN             0.0f  
#define SB_SVL_DL_PERTURBATION_SCALE_MAX             0.5f  
                                                     
#define SB_SVL_DL_PERTURBATION_SHIFT_MIN             0.0f  
#define SB_SVL_DL_PERTURBATION_SHIFT_MAX             0.5f  
                                                     
#define SB_SVL_DL_PERTURBATION_STRETCH_CONTRAST_MIN  0.0f  
#define SB_SVL_DL_PERTURBATION_STRETCH_CONTRAST_MAX  0.5f  
                                                     
#define SB_SVL_DL_PERTURBATION_DELTA_BRIGHTNESS_MIN  0.0f  
#define SB_SVL_DL_PERTURBATION_DELTA_BRIGHTNESS_MAX  0.5f  
 
#define SB_SURFACE_OPTIONAL_GRAY_LEVEL 128 
 
SB_PUBLIC(sb_t_err) sb_get_info(sb_t_info** const info, int dl_devices_info);
 
SB_PUBLIC(sb_t_err) sb_destroy_info(sb_t_info** const info);
 
SB_PUBLIC(sb_t_err) sb_format_info(const sb_t_info* const info, char* const str, int str_size);
 
SB_PUBLIC(sb_t_err) sb_get_uuid(char* const str, size_t size);
 
SB_PUBLIC(sb_t_err) sb_get_file_version(sb_t_version* const ver, const char* const file);
 
typedef enum
{
    SB_INTERPOLATION_MODE_BILINEAR = 0, 
    SB_INTERPOLATION_MODE_NN            
}sb_t_interpolation_mode;
 
typedef enum
{
    SB_FLOATING_POINT_OPS_TYPE_SINGLE_PRECISION = 0, 
    SB_FLOATING_POINT_OPS_TYPE_HALF_PRECISION        
}sb_t_floating_point_op_type;
 
SB_PUBLIC(int) sb_is_valid_utf8(const char * string);
 
 // group_generic
 
SB_PUBLIC(SB_HANDLE) sb_xml_node_get(SB_HANDLE parent, const char* const name);
 
SB_PUBLIC(SB_HANDLE) sb_xml_node_get_child(SB_HANDLE parent);
 
SB_PUBLIC(SB_HANDLE) sb_xml_node_previous(SB_HANDLE node);
 
SB_PUBLIC(SB_HANDLE) sb_xml_node_next(SB_HANDLE node);
 
SB_PUBLIC(SB_HANDLE) sb_xml_node_add(SB_HANDLE parent, const char* const name, const char* const content);
 
SB_PUBLIC(sb_t_err) sb_xml_node_set(SB_HANDLE parent, const char* const name, const char* const content);
 
SB_PUBLIC(sb_t_err) sb_xml_node_get_name(SB_HANDLE node, char* const str, size_t str_size);
 
SB_PUBLIC(sb_t_err) sb_xml_node_set_attribute(SB_HANDLE node, const char* const attribute_name, const char* const content);
 
SB_PUBLIC(sb_t_err) sb_xml_node_get_attribute(SB_HANDLE node, const char* const attribute_name, char* const str, size_t str_size);
 
SB_PUBLIC(sb_t_err) sb_xml_node_set_itself(SB_HANDLE node, const char* const content);
 
SB_PUBLIC(sb_t_err) sb_xml_node_count(SB_HANDLE parent, const char* const name, int* const cnt);
 
SB_PUBLIC(sb_t_err) sb_xml_node_get_string(SB_HANDLE parent, const char* const name, char* const str, size_t str_size);
 
SB_PUBLIC(sb_t_err) sb_xml_node_get_string_malloc(SB_HANDLE parent, const char* const name, char** const str);
 
SB_PUBLIC(sb_t_err) sb_xml_node_remove(SB_HANDLE parent, const char* const name);
 
SB_PUBLIC(sb_t_err) sb_xml_node_remove_itself(SB_HANDLE node); // group_xml
 
typedef struct
{
    char name[256]; 
    char *fname;    
}sb_t_file;
 
typedef struct
{
    sb_t_file *file; 
    int n;           
    int path_length; 
}sb_t_folder;
 
SB_PUBLIC(sb_t_err) sb_folder_load(sb_t_folder** const f, const char* const path, const char* const ext, int sort, int verbosity);
 
SB_PUBLIC(sb_t_err) sb_folder_destroy(sb_t_folder **folder);
 
SB_PUBLIC(sb_t_err) sb_folder_erase(sb_t_folder *folder, int index);
 
SB_PUBLIC(sb_t_err) sb_folder_create(const char* const path);
 
SB_PUBLIC(sb_t_err) sb_folder_remove(const char* const path);
 
SB_PUBLIC(sb_t_err) sb_folder_rename ( const char* const oldpath, const char* const newpath );
 
SB_PUBLIC(sb_t_err) sb_folder_exist(const char* const path, int* const exist);
 
SB_PUBLIC(sb_t_err) sb_file_extract_name(const char* const full, int with_ext, char* const name, int name_size);
 
SB_PUBLIC(sb_t_err) sb_file_extract_folder(const char* const full, char* const folderpath, int folderpath_size);
 // group_folder
 
SB_PUBLIC(void) sb_free(void* ptr);
 
SB_PUBLIC(void*) sb_malloc(size_t size);
 
SB_PUBLIC(void*) sb_calloc(size_t count, size_t size);
 
SB_PUBLIC(void*) sb_realloc(void* ptr, size_t size);
 
typedef enum
{
    SB_MALLOC_CHECK_MAIN_COUNTER = 0, 
    SB_MALLOC_CHECK_SECOND_COUNTER    
}sb_t_malloc_check;
 
SB_PUBLIC(sb_t_err) sb_malloc_check_memory_leak(sb_t_malloc_check check);
 
SB_PUBLIC(sb_t_err) sb_malloc_check_memory_leak_reset(sb_t_malloc_check check);
 // group_memory
 
typedef enum
{
    SB_LICENSE_MODULE_STATUS_NULL = 0, 
    SB_LICENSE_MODULE_STATUS_ACTIVE,   
    SB_LICENSE_MODULE_STATUS_DISABLED, 
    SB_LICENSE_MODULE_STATUS_ERR,      
}sb_t_license_module_status;
 
typedef enum
{
    SB_LICENSE_NULL = 0,    
    SB_LICENSE_DISABLED,    
    SB_LICENSE_DEMO,        
    SB_LICENSE_MASTER,      
    SB_LICENSE_NOT_PRESENT  
}sb_t_license_type;
 
typedef enum
{
    SB_LICENSE_PREMIUM = 0, 
    SB_LICENSE_STANDARD,    
    SB_LICENSE_BASIC,       
    SB_LICENSE_CONFIGURATION_NUMBER 
}sb_t_license_configuration_id;
 
typedef enum
{
    SB_LICENSE_MODULE_NONE = -1,      
    SB_LICENSE_MODULE_RETINA,         
    SB_LICENSE_MODULE_SURFACE,        
    SB_LICENSE_MODULE_DEEP_CORTEX,    
    SB_LICENSE_MODULE_DEEP_SURFACE,   
    SB_LICENSE_MODULE_DEEP_RETINA,    
    SB_LICENSE_MODULE_NUMBER          
}sb_t_license_module_id;
 
typedef struct
{
    sb_t_license_configuration_id id; 
    int num_models;                   
 
    int num_features;
 
    int num_threads;
 
    float speed_boost;                
}sb_t_license_configuration;
 
typedef struct
{
    sb_t_license_type type;
 
    sb_t_license_configuration configuration;
 
    int training;
 
    sb_t_version version;
 
    signed long long time_start;
 
    signed long long time_end;
 
    signed long long remain;
 
    sb_t_license_module_status status;
 
    sb_t_err err;
 
    char sn[32];
}sb_t_license_module;
 
#define SB_LICENSE_VENDOR_CODE_SIZE 32 
 
typedef struct
{
    char address[256];              
    char company[128];              
    char company_role[128];         
    char mail[128];                 
    char name[128];                 
    char operating_system[128];     
    char phone[32];                 
    char surname[128];              
    char sector_of_interest[1024];  
    char vat[32];                   
    char vendor_code[SB_LICENSE_VENDOR_CODE_SIZE + 4]; 
    char machine_id[36];            
    sb_t_license_module module[SB_LICENSE_MODULE_NUMBER];
    signed long long time_create; 
    signed long long time_modify;
    signed long long time_save;
}sb_t_license;
 
SB_PUBLIC(sb_t_err) sb_license_get_hw_info(char** const str);
 
SB_PUBLIC(sb_t_err) sb_license_check(SB_HANDLE module, char** const msg);
 
SB_PUBLIC(sb_t_err) sb_license_configuration_check(SB_HANDLE module, sb_t_license_configuration_id configuration_id, char** const msg);
 
SB_PUBLIC(sb_t_err) sb_license_get_info(sb_t_license* const info);
 
SB_PUBLIC(sb_t_err) sb_license_format_info(const sb_t_license* const info, char* const str, int str_size);
 
SB_PUBLIC(const char*) sb_license_format_module_id(sb_t_license_module_id code);
 
SB_PUBLIC(const char*) sb_license_format_module_status(sb_t_license_module_status status);
 
SB_PUBLIC(const char*) sb_license_format_type(sb_t_license_type type);
 
SB_PUBLIC(const char*) sb_license_format_configuration(sb_t_license_configuration_id configuration);
 
SB_PUBLIC(sb_t_err) sb_license_apply_v2c(const char* const v2c, char** const msg_err, int verbosity);
 // group_license
 
#define SB_LUT_POINT_NOT_EXIST 0xFFFF
 
typedef struct
{
    unsigned short x; 
    unsigned short y; 
}sb_t_lut_point;
 
SB_PUBLIC(sb_t_err) sb_lut_create(SB_HANDLE* phandle, int width, int height);
 
SB_PUBLIC(sb_t_err) sb_lut_destroy(SB_HANDLE* phandle);
 
SB_PUBLIC(sb_t_err) sb_lut_get_ptr(SB_HANDLE phandle, sb_t_lut_point** const ptr);
 
SB_PUBLIC(sb_t_err) sb_lut_get_size(SB_HANDLE phandle, int* const width, int* const height);
 
SB_PUBLIC(sb_t_err) sb_lut_save(SB_HANDLE phandle, const char* const file_path);
 
SB_PUBLIC(sb_t_err) sb_lut_load(SB_HANDLE* phandle, const char* const file_path);
 
SB_PUBLIC(sb_t_err) sb_lut_warp_point(SB_HANDLE phandle, const sb_t_point* const src, sb_t_point* const dst);
 // group_lut
 
#define SB_IMAGE_FILE_EXTENSIONS "pgm"  SB_DELIMITER \
                                 "ppm"  SB_DELIMITER \
                                 "bmp"  SB_DELIMITER \
                                 "png"  SB_DELIMITER \
                                 "tif"  SB_DELIMITER \
                                 "tiff" SB_DELIMITER \
                                 "jpeg" SB_DELIMITER \
                                 "jpg"
 
typedef enum
{
    SB_IMAGE_FORMAT_BW8 = 0, 
    SB_IMAGE_FORMAT_BGR888,  
    SB_IMAGE_FORMAT_RGB888,  
    SB_IMAGE_FORMAT_UI32     
}sb_t_image_format;
 
SB_PUBLIC(const char*) sb_image_format(sb_t_image_format format);
 
typedef enum
{
    SB_IMAGE_COMPRESS_NONE = 0, 
    SB_IMAGE_COMPRESS_RLE,      
    SB_IMAGE_COMPRESS_JPEG,     
    SB_IMAGE_COMPRESS_PNG       
}sb_t_image_compress_type;
 
typedef struct
{
    unsigned int value; 
    int x;              
    int y;              
    int length;         
    int offset;         
}sb_t_rle_seg;
 
typedef struct
{
    sb_t_rle_seg* seg; 
    int size;          
}sb_t_rle;
 
typedef struct
{
    unsigned char* data;      
    unsigned char* free_data; 
    int width;                
    int height;               
    int width_step;           
    int size;                 
    int free_data_size;       
    sb_t_image_format format; 
    int bytes_per_pixel;
 
    sb_t_image_compress_type compression;   
    int                      free_rle;      
    sb_t_rle                 rle;           
 
#ifdef SB_PUBLIC_INTERNAL_ENABLE
#ifdef SB_USE_OPENCV
    IplImage *cvi;
#else
    void* cvi;
#endif
#endif
}sb_t_image;
 
SB_PUBLIC(sb_t_err) sb_image_create(sb_t_image** const pimg, int width, int height, sb_t_image_format format);
 
SB_PUBLIC(sb_t_err) sb_image_create_header(sb_t_image** const pimg, int width, int height, int width_step, sb_t_image_format format);
 
SB_PUBLIC(sb_t_err) sb_image_destroy(sb_t_image** const pimg);
 
typedef enum
{
    SB_IMAGE_COMPRESS_PAR_JPEG_QUALITY = 1, 
}sb_t_image_compress_par;
 
SB_PUBLIC(sb_t_err) sb_image_compress(sb_t_image** const dst, sb_t_image* const src, sb_t_image_compress_type compression, const void* const params);
 
SB_PUBLIC(sb_t_err) sb_image_decompress(sb_t_image** const dst, sb_t_image* const src);
 
SB_PUBLIC(sb_t_err) sb_image_set_clip_blend(sb_t_image* const img, int x, int y, const sb_t_rgba* const color);
 
SB_PUBLIC(sb_t_err) sb_image_get_pixel(const sb_t_image* const img, int x, int y, sb_t_rgba* const color);
 
SB_PUBLIC(sb_t_err) sb_image_set_data(sb_t_image* const img, unsigned char* const data);
 
SB_PUBLIC(sb_t_err) sb_image_clone(sb_t_image** const dst, const sb_t_image* const src);
 
SB_PUBLIC(sb_t_err) sb_image_copy(const sb_t_image* const src, sb_t_image* const dst);
 
SB_PUBLIC(sb_t_err) sb_image_copy_rect(const sb_t_image* const src, sb_t_rect rect, sb_t_image** const dst);
 
SB_PUBLIC(sb_t_err) sb_image_clean(sb_t_image* const img);
 
SB_PUBLIC(sb_t_err) sb_image_save(const sb_t_image* const img, const char* const file, const int* const params);
 
SB_PUBLIC(sb_t_err) sb_image_load(sb_t_image** const img, const char* const file);
 
SB_PUBLIC(sb_t_err) sb_image_convert(sb_t_image** const dst, sb_t_image* const src, sb_t_image_format format);
 
typedef enum
{
    SB_IMAGE_FLIP_BOTH = -1,      
    SB_IMAGE_FLIP_HORIZONTAL = 0, 
    SB_IMAGE_FLIP_VERTICAL = 1    
}sb_t_image_flip_mode;
 
SB_PUBLIC(sb_t_err) sb_image_flip(const sb_t_image* const src, sb_t_image* const dst, sb_t_image_flip_mode mode);
 
SB_PUBLIC(sb_t_err) sb_image_shift(const sb_t_image* const src, sb_t_image* const dst, int x_shift, int y_shift, int circular);
 
SB_PUBLIC(sb_t_err) sb_image_rotate(const sb_t_image* const src, sb_t_point centre, double angle, sb_t_interpolation_mode interpolation_mode, sb_t_image* const dst);
 
SB_PUBLIC(sb_t_err) sb_image_resize(const sb_t_image* const src, sb_t_rect rect, float scale, sb_t_interpolation_mode interpolation_mode, sb_t_image* const dst);
 
SB_PUBLIC(sb_t_err) sb_image_get_sample(const sb_t_image* const src, sb_t_point centre, double angle_rad, float scale, sb_t_image* const dst);
 
SB_PUBLIC(sb_t_err) sb_image_change_brightness(const sb_t_image* const src, sb_t_image* const dst, float delta_brightness);
 
SB_PUBLIC(sb_t_err) sb_image_change_contrast(const sb_t_image* const src, sb_t_image* const dst, float delta_contrast);
 
typedef enum
{
    SB_IMAGE_CIRCULARITY_TYPE_NONE = 0,    
    SB_IMAGE_CIRCULARITY_TYPE_HORIZONTAL,  
    SB_IMAGE_CIRCULARITY_TYPE_VERTICAL     
}sb_t_image_circularity_type;
 
SB_PUBLIC(const char*) sb_image_circularity_type_format(sb_t_image_circularity_type type);
 
SB_PUBLIC(sb_t_err) sb_image_read_size(sb_t_size* const size, const char* const file);
 // group_image
 
typedef struct
{
    sb_t_rect     bounding_box; 
    sb_t_rgba     color;        
    unsigned char lut[256];     
    sb_t_image*   img;          
}sb_t_roi;
 
SB_PUBLIC(sb_t_err) sb_roi_create(sb_t_roi** const roi, int width, int height);
 
SB_PUBLIC(sb_t_err) sb_roi_create_header(sb_t_roi** const roi, int width, int height, int width_step);
 
SB_PUBLIC(sb_t_err) sb_roi_destroy(sb_t_roi** const roi);
 
SB_PUBLIC(sb_t_err) sb_roi_reset(sb_t_roi* const roi);
 
SB_PUBLIC(sb_t_err) sb_roi_evaluate_bounding_box(sb_t_roi* const roi);
 
SB_PUBLIC(sb_t_err) sb_roi_set_data(sb_t_roi* const roi, unsigned char* const data);
 
SB_PUBLIC(sb_t_err) sb_roi_set_rect(sb_t_roi* const roi, unsigned char gl, sb_t_rect rect, int reset_roi);
 
SB_PUBLIC(sb_t_err) sb_roi_set_circle(sb_t_roi* const roi, unsigned char gl, int center_x, int center_y, int radius, int reset_roi);
 
 
SB_PUBLIC(sb_t_err) sb_roi_set_circular_crown(sb_t_roi* const roi, unsigned char gl, int center_x, int center_y, int radius_min, int radius_max, int start_angle, int end_angle, int reset_roi);
 
SB_PUBLIC(sb_t_err) sb_roi_set_ellipse(sb_t_roi* const roi, unsigned char gl, int center_x, int center_y, int radius_x, int radius_y, int reset_roi);
 
SB_PUBLIC(sb_t_err) sb_roi_clone(sb_t_roi** const dst, const sb_t_roi* const src);
 
SB_PUBLIC(sb_t_err) sb_roi_compress(sb_t_roi* const roi);
 
SB_PUBLIC(sb_t_err) sb_roi_decompress(sb_t_roi* const roi);
 
SB_PUBLIC(sb_t_err) sb_roi_plot(sb_t_image* const image, const sb_t_roi* const roi, const unsigned char* lut, sb_t_rgba color);
 
SB_PUBLIC(sb_t_err) sb_roi_apply_lut(sb_t_roi* const roi, unsigned char *lut); // group_roi
 
typedef enum
{
    SB_OBJ_TEST = 0, 
    SB_OBJ_LEARNING  
}sb_t_obj_type;
 
typedef enum
{
    SB_TRUTH_UNDEFINED = 0,
 
    SB_TRUTH_TRUE_POSITIVE, 
 
    SB_TRUTH_TRUE_NEGATIVE,
 
    SB_TRUTH_FALSE_POSITIVE,
 
    SB_TRUTH_FALSE_NEGATIVE,
 
    SB_TRUTH_OPTIONAL_POSITIVE, 
 
    SB_TRUTH_OPTIONAL_NEGATIVE,
 
    SB_TRUTH_OUT_OF_ROI,
 
    SB_TRUTH_MODEL_DISABLED 
}sb_t_truth;
 
typedef enum
{
 
    SB_SAMPLE_REQUIRED = 0,
 
    SB_SAMPLE_OPTIONAL
}sb_t_sample_classify_mode;
 
typedef struct
{
    sb_t_image* img; 
    float max;       
    float min;       
}sb_t_sample_weights_image;
 
typedef struct
{
    char uuid[36];                             
    char image_name[SB_IMAGE_NAME_STRING_LEN]; 
 
    sb_t_point centre;
 
    sb_t_point centre_warp;
 
    sb_t_point vertex[4];
 
    sb_t_point vertex_warp[4];
    
    char model_name[SB_PAR_STRING_LEN];
    
    float scale;
 
    sb_t_obj_type type;
 
    float weight;
 
    sb_t_sample_weights_image weights_image;
 
    sb_t_truth truth;
 
    sb_t_sample_classify_mode classify_mode;
    void* user_data;
    int user_data_size;
 
    int is_near;
 
    float IoU;
 
    float defect_area_percentage;
} sb_t_sample;
 
SB_PUBLIC(const char*) sb_format_truth(sb_t_truth truth);
 
SB_PUBLIC(sb_t_err) sb_sample_clone(const sb_t_sample* const src, sb_t_sample* const dst);
 
SB_PUBLIC(sb_t_err) sb_sample_destroy(sb_t_sample* const sample);
 
SB_PUBLIC(sb_t_err) sb_sample_weights_image_overlay(sb_t_image* const image, const sb_t_sample* const s);
 
typedef struct
{
    sb_t_sample *sample; 
    int size;            
}sb_t_samples;
 
SB_PUBLIC(sb_t_err) sb_samples_create(sb_t_samples** const samples);
 
SB_PUBLIC(sb_t_err) sb_samples_destroy(sb_t_samples** const samples);
 
SB_PUBLIC(sb_t_err) sb_samples_clone(sb_t_samples** const dst, const sb_t_samples* const src);
 
SB_PUBLIC(sb_t_err) sb_samples_insert(sb_t_samples* const samples, const sb_t_sample* const sample, int sample_index);
 
SB_PUBLIC(sb_t_err) sb_samples_remove(sb_t_samples* const samples, int sample_index);
 
SB_PUBLIC(sb_t_err) sb_samples_swap(sb_t_samples* const samples, int sample_index_1, int sample_index_2);
 
SB_PUBLIC(sb_t_err) sb_sample_get_vertex(sb_t_point centre, float scale, sb_t_size obj_size, sb_t_point* const ul, sb_t_point* const br, sb_t_size* const size);
 
SB_PUBLIC(sb_t_err) sb_sample_get_model_index(const sb_t_sample* const s, SB_HANDLE handle, int* const model_index);
 
SB_PUBLIC(sb_t_err) sb_sample_get_level_index(const sb_t_sample* const s, SB_HANDLE handle, int* const level_index);
 
SB_PUBLIC(sb_t_err) sb_samples_distance(SB_HANDLE project, const sb_t_sample* const sample1, const sb_t_sample* const sample2, const sb_t_roi* const roi, float* const distance, int* const are_near); // group_samples
 
 
typedef enum
{
    SB_PIXEL_CONNECTION_4 = 0,
 
    SB_PIXEL_CONNECTION_8
}sb_t_pixel_connection;
 
typedef enum
{
    SB_BLOB_DISTANCE_MODE_BOUNDING_BOX = 0,
    SB_BLOB_DISTANCE_MODE_CONTOUR
}sb_t_blob_distance_mode;
 
typedef struct
{
    unsigned char lut[256]; 
    sb_t_range area;   
    sb_t_range height; 
    sb_t_range width;  
    sb_t_pixel_connection connection_type; 
    int blob_rle;           
    int blob_contour;
    int blob_min_rot_rect;
    sb_t_blob_distance_mode blob_distance_mode;
    int merge_distance;     
    sb_t_range merge_area;  
    sb_t_range merge_height;
    sb_t_range merge_width; 
    int keep_deleted;       
    int verbosity;          
}sb_t_blob_par;
 
typedef struct
{
    long long time_rle;        
    long long time_blob;       
    long long time_contour;    
    long long time_merge;      
    long long time_sort;       
    long long time_export;     
    long long time_total;      
    int merged;                
    int deleted;               
    int deleted_for_area_max;  
    int deleted_for_area_min;  
    int deleted_for_width_max; 
    int deleted_for_width_min; 
    int deleted_for_height_max;
    int deleted_for_height_min;
    sb_t_range deleted_area;   
    sb_t_range deleted_width;  
    sb_t_range deleted_height; 
}sb_t_blobs_info;
 
typedef enum
{
    SB_BLOB_OK = 0,               
    SB_BLOB_DELETED_BEFORE_MERGE, 
    SB_BLOB_DELETED_AFTER_MERGE   
}sb_t_blob_deleted;
 
typedef struct
{
    sb_t_point2d_f bar;   
    int area;             
    int od;               
    int lut;              
    sb_t_rect rect;       
    sb_t_rle rle;
    sb_t_point* contour;  
    int contour_size;     
    sb_t_truth truth;     
    sb_t_blob_deleted deleted;          
    char model_name[SB_PAR_STRING_LEN]; 
    float angle;
    sb_t_point2d_f coord_min_rot_rect[4];
    float m_xx;
    float m_yy;
    float m_xy;
}sb_t_blob;
 
typedef struct
{
    int size;               
    sb_t_blob* blob;        
    sb_t_blobs_info info;   
    sb_t_blobs_info info_gt;
}sb_t_blobs;
 
SB_PUBLIC(sb_t_err) sb_blobs_create(sb_t_blobs** const blobs);
 
SB_PUBLIC(sb_t_err) sb_blob_init_par(sb_t_blob_par* const par);
 
SB_PUBLIC(sb_t_err) sb_blob_format_par(int* const c, char* const str, int str_size, int indentation, const sb_t_blob_par* const par);
 
SB_PUBLIC(sb_t_err) sb_blobs_detection(sb_t_blobs** const blobs, const sb_t_image* const image, const sb_t_roi* const roi, const sb_t_blob_par* const par, sb_t_image_circularity_type circularity_type);
 
SB_PUBLIC(sb_t_err) sb_blob_intersect(const sb_t_blob* const blob1, const sb_t_blob* const blob2, int extract_blob_seg, sb_t_blob** const res);
 
SB_PUBLIC(sb_t_err) sb_blobs_plot_roi(const sb_t_blobs* const blobs, sb_t_roi* const roi, unsigned char gl);
 
SB_PUBLIC(sb_t_err) sb_blob_plot_roi(const sb_t_blob* const blob, sb_t_roi* const roi, unsigned char gl);
 
SB_PUBLIC(sb_t_err) sb_blobs_clone(sb_t_blobs** const dst, const sb_t_blobs* const src);
 
SB_PUBLIC(sb_t_err) sb_blobs_destroy(sb_t_blobs** const blobs);
 
SB_PUBLIC(sb_t_err) sb_blob_destroy(sb_t_blob* const blob);
 
SB_PUBLIC(sb_t_err) sb_blob_copy(sb_t_blob* const dst, const sb_t_blob* const src);
 // group_blob
 
SB_PUBLIC(sb_t_err) sb_roi_set_blob(sb_t_roi* const roi, unsigned char gl, const sb_t_image* const src, const sb_t_blob_par* const par, const sb_t_point* const start_point, int fill_holes, sb_t_range hole_area, const sb_t_rect* analysis_rect);
 // group_roi
 
typedef enum
{
    SB_PROJECT_TYPE_RETINA = 0,   
    SB_PROJECT_TYPE_SURFACE,      
    SB_PROJECT_TYPE_DEEP_SURFACE, 
    SB_PROJECT_TYPE_DEEP_CORTEX,  
    SB_PROJECT_TYPE_DEEP_RETINA   
}sb_t_project_type;
 
SB_PUBLIC(const char*) sb_project_type_format(sb_t_project_type type);
 
#define SB_PROJECTS_NUM     32
#define SB_PROJECT_UUID_LEN 36
 
typedef struct
{
    sb_t_project_type type;                      
    char              uuid[SB_PROJECT_UUID_LEN]; 
    char              name[SB_PAR_STRING_LEN];   
}sb_t_project_info;
 
typedef struct
{
    sb_t_project_info* info;  
    int                size;  
}sb_t_projects_info; // group_project 1
 
#define SB_SOLUTION_EXT "rprj"
 
typedef struct
{
    sb_t_projects_info projects; 
    int current_project;         
    sb_t_version version;        
}sb_t_solution_info;
 
SB_PUBLIC(sb_t_err) sb_solution_get_info(const char* const solution_file, sb_t_solution_info** const solution);
 
SB_PUBLIC(sb_t_err) sb_solution_destroy_info(sb_t_solution_info** const solution);
 
SB_PUBLIC(sb_t_err) sb_solution_set_current_project(const char* const solution_file, const char* const project_uuid);
 
SB_PUBLIC(sb_t_err) sb_solution_remove_project(const char* const solution_file, const char* const project_uuid);
 
SB_PUBLIC(sb_t_err) sb_solution_get_version(const char* const solution_file, sb_t_version* version, char* const version_str, int size_version_str);
 // group_solution
 
 
SB_PUBLIC(sb_t_err) sb_project_get_info(SB_HANDLE handle, sb_t_project_info* project_info);
 
SB_PUBLIC(sb_t_err) sb_project_destroy(SB_HANDLE* phandle);
 
typedef enum
{
    SB_PROJECT_MODE_DETECTION_ONLY = 0,
    SB_PROJECT_MODE_DETECTION_AND_SVL, 
    SB_PROJECT_MODE_NO_DETECTION       
}sb_t_project_mode;
 
SB_PUBLIC(sb_t_err) sb_project_create(SB_HANDLE* phandle, const char* const project_name, sb_t_project_type project_type);
 
SB_PUBLIC(sb_t_err) sb_project_load(SB_HANDLE* phandle, const char* const solution_file, const char* const project_uuid, sb_t_project_mode mode);
 
SB_PUBLIC(sb_t_err) sb_project_save(SB_HANDLE handle, const char* const solution_file, sb_t_project_mode mode);
 
SB_PUBLIC(sb_t_err) sb_project_clone(SB_HANDLE src, SB_HANDLE* pdst, sb_t_project_mode mode, int regenerate_uuid);
 
SB_PUBLIC(sb_t_err) sb_project_invalidate(SB_HANDLE handle, const char* const model_name, float scale);
 
typedef enum
{
    SB_PROJECT_TRAINED_NONE = 0, 
    SB_PROJECT_TRAINED,          
    SB_PROJECT_TRAINED_OPENVINO
}sb_t_project_training_status;
 
SB_PUBLIC(const char*) sb_project_training_status_format(sb_t_project_training_status training_status);
 
SB_PUBLIC(sb_t_err) sb_project_check_trained(SB_HANDLE handle, const char* const model_name, float scale, sb_t_project_training_status* const training_status);
 
SB_PUBLIC(sb_t_err) sb_project_get_default_features(SB_HANDLE handle, char* str, int size);
 
SB_PUBLIC(sb_t_err) sb_project_set_sensitivity(SB_HANDLE handle, const char* const model_name, float scale, float sensitivity);
 
SB_PUBLIC(sb_t_err) sb_project_get_sensitivity(SB_HANDLE handle, const char* const model_name, float scale, float* const sensitivity);
 
SB_PUBLIC(sb_t_err) sb_project_get_notes(SB_HANDLE handle, char** const note);
 
SB_PUBLIC(sb_t_err) sb_project_set_notes(SB_HANDLE handle, const char* const note);
 
SB_PUBLIC(sb_t_err) sb_project_get_name(SB_HANDLE handle, char** const name);
 
SB_PUBLIC(sb_t_err) sb_project_set_name(SB_HANDLE handle, const char* const name);
 
SB_PUBLIC(sb_t_err) sb_project_get_custom_par_root(SB_HANDLE handle, SB_HANDLE* node_root);
 
SB_PUBLIC(sb_t_err) sb_project_get_svl_version(SB_HANDLE handle, sb_t_version* const version, char* const version_str, int size_version_str);
 
SB_PUBLIC(sb_t_err) sb_project_detection(SB_HANDLE handle, const sb_t_image* const img, const sb_t_roi* const roi, const sb_t_roi* const roi_defects, const sb_t_samples* const samples);
 
SB_PUBLIC(sb_t_err) sb_project_copy_labeling(const char* const path_solution_dst, const char* const path_solution_src, int copy_roi, int copy_labeling, int verbosity);
 
typedef struct
{
    float width_min;  
    float width_max;  
    float height_min; 
    float height_max; 
}sb_t_scale_offset_par;
 
SB_PUBLIC(sb_t_err) sb_project_set_scale_offset_par(SB_HANDLE handle, sb_t_scale_offset_par scale_offset);
 
SB_PUBLIC(sb_t_err) sb_project_get_scale_offset_par(SB_HANDLE handle, sb_t_scale_offset_par* const scale_offset);
 
SB_PUBLIC(sb_t_err) sb_project_openvino_conversion(SB_HANDLE handle, const char* const converter_path);
 // group_project 2
 
#define SB_PAR_FEATURES_NAMES_LEN 256 
 
typedef struct sb_t_svl_res sb_t_svl_res;
 
typedef struct
{
    sb_t_image* image;
    sb_t_roi* roi;         
    sb_t_roi* roi_defects; 
    SB_HANDLE warped2ori;  
}sb_t_svl_pre_elaboration;
 
typedef enum
{
    SB_SVL_COMMAND_STOP = 0,
    SB_SVL_COMMAND_CONTINUE,
    SB_SVL_COMMAND_ABORT,
    SB_SVL_COMMAND_CONTINUE_NO_RESET,
     SB_SVL_COMMAND_NEXT_STEP
}sb_t_svl_command;
 
SB_PUBLIC(const char*) sb_svl_command_format(sb_t_svl_command command);
 
typedef enum
{
    SB_SVL_PAR_OPTIMIZATION_TIME_SLOW = 0,
    SB_SVL_PAR_OPTIMIZATION_TIME_MEDIUM,
    SB_SVL_PAR_OPTIMIZATION_TIME_FAST,
    SB_SVL_PAR_OPTIMIZATION_USE_SELECTED,
}sb_t_svl_par_optimization_mode;
 
SB_PUBLIC(const char*) sb_svl_par_optimization_mode_format(sb_t_svl_par_optimization_mode mode);
 
typedef sb_t_err(*sb_fp_svl_pre_elaboration)(const SB_HANDLE image_info, void* const user_data, const char* const image_file, int image_index, sb_t_svl_pre_elaboration* const pre_elaboration);
 
typedef sb_t_err(*sb_fp_svl_progress)(void* const user_data, sb_t_svl_res* res, int force);
 
typedef sb_t_err(*sb_fp_svl_command)(void* const user_data, sb_t_svl_res* res, sb_t_svl_command* const command, const char* const msg);
 
typedef enum
{
    SB_NETWORK_TYPE_NONE = 0,
    SB_NETWORK_TYPE_EFFICIENTNET_B0 = 1,
    SB_NETWORK_TYPE_EFFICIENTNET_B1,
    SB_NETWORK_TYPE_EFFICIENTNET_B2,
    SB_NETWORK_TYPE_SDINET0 = 101,
#ifdef NEW_VERSION_SDINET1
    SB_NETWORK_TYPE_SDINET1 = 110,
#endif
 
#ifdef NEW_VERSION_DEEP_SURFACE_UNET
    SB_NETWORK_TYPE_UNET_256 = 130,
#endif
    SB_NETWORK_TYPE_ICNET0_64 = 200,
    SB_NETWORK_TYPE_ICNET0_128,
 
    SB_NETWORK_TYPE_ODNET0 = 300, //TODO DR
 
    //Must be the last
    SB_NETWORK_TYPE_END
}sb_t_network_type;
 
SB_PUBLIC(const char*) sb_network_type_format(sb_t_network_type type);
 
typedef enum
{
    SB_NETWORK_FREEZE_MODE_NONE = 0,
    SB_NETWORK_FREEZE_MODE_FIRST_BLOCK = 1000,
    SB_NETWORK_FREEZE_MODE_ENCODER = 2000,
    SB_NETWORK_FREEZE_MODE_ENCODER_DECODER = 3000,
    
    SB_NETWORK_FREEZE_MODE_END
}sb_t_network_freeze_mode;
 
SB_PUBLIC(const char*) sb_network_freeze_mode_format(sb_t_network_freeze_mode freeze_mode);
 
typedef struct
{
    sb_t_network_type type;
 
    sb_t_size input_size;
 
    sb_t_image_format image_format;
 
    int n_channels;
 
    float features_multiplier;
 
    sb_t_network_freeze_mode freeze_mode;
}sb_t_svl_dl_par_network;
 
 //TODO aggiungere questa nota quando si riabilita la funzione sb_par_tiling_get_range
 //The @ref sb_par_tiling_get_range function returns the variability range of the image resolution given the @ref sb_t_svl_dl_tiling_par.scale "scale" and the number of tiles.
 
typedef enum
{
    SB_TILING_MODE_MANUAL = 0,
 
    SB_TILING_MODE_AUTO
}sb_t_tiling_mode;
 
SB_PUBLIC(const char*) sb_tiling_mode_format(sb_t_tiling_mode mode);
 
typedef enum
{
    SB_LOSS_FN_TYPE_CCE = 0,
    SB_LOSS_FN_TYPE_FOCAL,
    SB_LOSS_FN_TYPE_BCE,
    //SB_LOSS_FN_TYPE_DICE,
    //SB_LOSS_FN_TYPE_RMI,
#ifdef ENABLE_DEEP_RETINA
    SB_LOSS_FN_TYPE_YOLO,
#endif
}sb_t_loss_fn_type;
 
SB_PUBLIC(const char*) sb_loss_fn_type_format(sb_t_loss_fn_type type);
 
typedef enum
{
    SB_IMAGE_BORDERS_EXTENSION_MODE_NONE = 0,
    SB_IMAGE_BORDERS_EXTENSION_MODE_V_0,
    SB_IMAGE_BORDERS_EXTENSION_MODE_V_127,
    SB_IMAGE_BORDERS_EXTENSION_MODE_V_255,
    SB_IMAGE_BORDERS_EXTENSION_MODE_LAST,
    SB_IMAGE_BORDERS_EXTENSION_MODE_IMAGE_AVG,
    SB_IMAGE_BORDERS_EXTENSION_MODE_KERNEL_AVG,
    SB_IMAGE_BORDERS_EXTENSION_MODE_MIRRORING,
    SB_IMAGE_BORDERS_EXTENSION_MODE_BORDER_AVG,
    SB_IMAGE_BORDERS_EXTENSION_MODE_BORDER_AVG_LOCAL,
    SB_IMAGE_BORDERS_EXTENSION_MODE_KERNEL_AVG_17x1
}sb_t_image_borders_extension_mode;
 
SB_PUBLIC(const char*) sb_image_borders_extension_mode_format(sb_t_image_borders_extension_mode mode);
 
typedef enum
{
    SB_PERTURBATION_MODE_ONLINE = 0,
 
    SB_PERTURBATION_MODE_OFFLINE,
 
    SB_PERTURBATION_MODE_BOTH
}sb_t_perturbation_mode;
 
SB_PUBLIC(const char*) sb_perturbation_mode_format(sb_t_perturbation_mode mode);
 
typedef enum
{
    SB_PERTURBATION_TYPE_IMAGE = 0, 
    SB_PERTURBATION_TYPE_DEFECTS,
 
    SB_PERTURBATION_TYPE_BOTH
}sb_t_perturbation_type;
 
SB_PUBLIC(const char*) sb_perturbation_type_format(sb_t_perturbation_type type);
 
typedef struct
{
    char inpainter_path[512];
 
    sb_t_perturbation_mode mode;
 
    sb_t_perturbation_type type;
 
    int flip_horizontal;
 
    int flip_vertical;
 
    float shift_horizontal;
 
    float shift_vertical;
 
    sb_t_range angle_range;
 
    float delta_brightness;
 
    float stretch_contrast;
 
    float delta_scale;
}sb_t_svl_dl_par_perturbation;
 
#define SB_PRE_TRAINING_EXT "ptf"
 
typedef struct
{
    sb_t_tiling_mode mode;
 
    int num_tiles;
 
    sb_t_range_flt scale;
}sb_t_svl_dl_tiling_par;
 
typedef struct 
{
    sb_t_svl_dl_par_network network;
 
    char pre_training_file[512];
 
    int load_pre_training_models;
 
    sb_t_svl_dl_par_perturbation perturbations;
 
    float learning_rate;
 
    int num_epochs;
 
    int batch_size;
 
    float validation_percentage;
 
    int save_best;
 
    sb_t_loss_fn_type loss_fn;
 
    sb_t_svl_dl_tiling_par tiling_par_width;
 
    sb_t_svl_dl_tiling_par tiling_par_height;
 
    sb_t_image_borders_extension_mode borders_extension_mode;
 
}sb_t_svl_dl_par;
 
typedef struct 
{
    float goodness_target;
    char  features[SB_PAR_FEATURES_NAMES_LEN];
    sb_t_svl_par_optimization_mode optimization_mode;
 
    int auto_levels;
}sb_t_svl_sl_par;
 
#define SB_DEVICES_MAX_NUMBER 4
 
typedef struct
{
    sb_t_device_type type;
 
    sb_t_framework_type framework;
 
    int id[SB_DEVICES_MAX_NUMBER];
}sb_t_devices_par;
 
typedef struct {
    sb_fp_svl_pre_elaboration fp_pre_elaboration;
    
    sb_fp_svl_progress fp_progress;
    
    sb_fp_svl_command fp_command;
    
    void* user_data;
    
    char  project_path[512];
    
    char  image_ext[64];
    
    float free_memory_percentage;
    
    int num_threads;
    
    int reproducibility;
    
    sb_t_devices_par devices;
 
    sb_t_svl_sl_par sl;
 
    sb_t_svl_dl_par dl;
 
    sb_t_image_circularity_type image_circularity_type;
}sb_t_svl_par;
 // group_svl
 
typedef struct
{
    int angle;
 
    int flip_horizontal;
 
    int flip_vertical;
 
    sb_t_range angle_range;
 
    int num_synthetic_samples;
}sb_t_par_perturbation;
 
typedef struct
{
    sb_t_par_perturbation perturbation[SB_PAR_PERTURBATIONS_NUM];
 
    int size;
}sb_t_par_perturbations;
 
typedef struct
{
    int enabled;
    float scale;
}sb_t_par_level;
 
typedef struct
{
    sb_t_par_level level[SB_PAR_LEVELS_NUM];
 
    int size;
}sb_t_par_levels;
 
typedef struct
{
    char name[SB_PAR_STRING_LEN];
 
    char description[SB_PAR_STRING_LEN];
 
    sb_t_size obj_size;
 
    int enabled;
 
    sb_t_par_levels levels;
 
    sb_t_par_perturbations perturbations;
 
    sb_t_rgba color;
 
    sb_t_rgba color_opt;
 
    sb_t_size obj_min_distance;
 
    sb_t_size obj_stride_coarse;
 
    sb_t_size obj_stride_fine;
 
    int num_occurrences;
 
    float defect_area_percentage;
 
    float defect_area_threshold;
}sb_t_par_model;
 
typedef struct
{
    sb_t_par_model model[SB_PAR_MODELS_NUM]; 
 
    int size;
}sb_t_par_models;
 
typedef struct
{
    float speed_boost;
    
    int detection_out_of_roi;
}sb_t_par_sl;
 
typedef struct
{
    sb_t_project_type project_type; 
 
    sb_t_par_models models; 
 
    unsigned char collaborations[SB_PAR_MODELS_NUM][SB_PAR_MODELS_NUM];
 
    int num_threads;  
 
    sb_t_blob_par blob_par;
 
    sb_t_devices_par devices;
 
    sb_t_interpolation_mode resize_mode;
 
    sb_t_floating_point_op_type floating_point_precision;
 
    sb_t_rgba color_opt;
 
    int surface_blob_analysis;
 
    sb_t_par_sl sl;
 
    sb_t_svl_par svl;
}sb_t_par;
 
SB_PUBLIC(sb_t_err) sb_par_create(sb_t_par** const par, sb_t_project_type project_type);
 
SB_PUBLIC(sb_t_err) sb_par_destroy(sb_t_par** const par);
 
SB_PUBLIC(sb_t_err) sb_par_copy(sb_t_par* const dst, const sb_t_par* const src);
 
SB_PUBLIC(sb_t_err) sb_par_clone(sb_t_par** const dst, const sb_t_par* const src);
 
SB_PUBLIC(sb_t_err) sb_par_compare(const sb_t_par* const par1, const sb_t_par* const par2);
 
SB_PUBLIC(sb_t_err) sb_par_init(sb_t_par* const par, sb_t_project_type project_type);
 
SB_PUBLIC(sb_t_err) sb_par_add_model(sb_t_par* const par, const char* const model_name);
 
SB_PUBLIC(sb_t_err) sb_par_remove_model(sb_t_par* const par, const char* const model_name);
 
SB_PUBLIC(sb_t_err) sb_par_set_model_description(sb_t_par* const par, const char* const model_name, const char* const description);
 
SB_PUBLIC(sb_t_err) sb_par_set_devices(sb_t_par* const par, sb_t_device_type device_type, sb_t_framework_type framework, int id, int svl);
 
SB_PUBLIC(sb_t_err) sb_par_add_level(sb_t_par* const par, const char* const model_name, float scale);
 
SB_PUBLIC(sb_t_err) sb_par_remove_level(sb_t_par* const par, const char* const model_name, float scale);
 
SB_PUBLIC(sb_t_err) sb_par_set_collaboration(sb_t_par *par, const char* const model_name_1, const char* const model_name_2, int value);
 
SB_PUBLIC(sb_t_err) sb_par_get_collaboration(sb_t_par *par, const char* const model_name_1, const char* const model_name_2, int* const value);
 
SB_PUBLIC(sb_t_err) sb_par_format(const sb_t_par* const par, char* const str, int str_size);
 
SB_PUBLIC(const char*) sb_floating_point_precision_type_format(sb_t_floating_point_op_type type);
 
SB_PUBLIC(const char*) sb_interpolation_mode_format(sb_t_interpolation_mode mode);
 
SB_PUBLIC(const char*) sb_device_type_format(sb_t_device_type type);
 
SB_PUBLIC(const char*) sb_framework_type_format(sb_t_framework_type type);
 
#ifdef ENABLE_TILING_GET_RANGE
typedef enum
{
    SB_DL_TILING_CALC_TYPE_NONE = 0,    
    SB_DL_TILING_CALC_TYPE_IMAGE_SIZE,  
    SB_DL_TILING_CALC_TYPE_IMAGE_SCALE
}sb_t_dl_auto_tile_calc_type;
 
SB_PUBLIC(const char*) sb_dl_auto_tile_calc_type_format(sb_t_dl_auto_tile_calc_type type);
 
SB_PUBLIC(sb_t_err) sb_par_tiling_get_range(sb_t_range_flt* const range, int img_size, sb_t_range_flt scale, int net_size, int tiles, sb_t_tiling_mode tiling_mode, sb_t_image_circularity_type circularity_type, sb_t_dl_auto_tile_calc_type mode);
 
SB_PUBLIC(sb_t_err) sb_par_tiling_get_range_info(const sb_t_par* const par, sb_t_size img_size, char** const pmsg);
#endif //ENABLE_TILING_GET_RANGE // group_parameters
 
typedef enum
{
    SB_IMAGE_TRUTH_UNDEFINED=0,
    SB_IMAGE_TRUTH_GOOD,
    SB_IMAGE_TRUTH_NO_GOOD,
    SB_IMAGE_TRUTH_OVERKILL,
    SB_IMAGE_TRUTH_ESCAPE
}sb_t_surface_image_truth;
 
 
typedef struct
{
    char* string;
    int   words;  
    int   lines;  
}sb_t_ocr_res;
 
typedef struct
{
    float accuracy;
 
    float recall;
 
    float precision;
 
    float f1_score;
 
    float specificity;
}sb_t_metrics;
 
typedef struct
{
    sb_t_point ul;  
 
    sb_t_metrics pixel_metrics;
 
    sb_t_image *model;
 
    sb_t_image *truth;
 
    sb_t_image *weight;
 
 
    sb_t_blobs* blobs;
 
    sb_t_surface_image_truth image_truth;
}sb_t_surface_res;
 
typedef struct
{
    int tp;
 
    int tn;
 
    int fp;
 
    int fn;
 
    int op;
 
    int on;
 
    int out_of_roi;
 
    int disabled;
 
    sb_t_surface_res* surface;
}sb_t_res_model;
 
typedef struct
{
    sb_t_res_model* model;  
    int size;               
}sb_t_res_models;
 
typedef enum
{
    SB_TILE_TYPE_NOT_USED = 0,
    SB_TILE_TYPE_USED,
    SB_TILE_TYPE_USED_SVL
} sb_t_tile_type;
 
SB_PUBLIC(const char*) sb_tile_type_format(sb_t_tile_type type);
 
typedef struct
{
    sb_t_rect rect;      
    sb_t_tile_type type; 
}sb_t_tile;
 
typedef struct
{
    sb_t_tile* tile; 
    int size;        
}sb_t_tiles;
 
typedef struct
{
    sb_t_size factor;     
    sb_t_size_flt scale;  
    sb_t_tiles tiles;     
}sb_t_tiles_info;
 
SB_PUBLIC(sb_t_err) sb_tiles_info_clone(sb_t_tiles_info** const pdst, const sb_t_tiles_info* const src);
 
SB_PUBLIC(sb_t_err) sb_tiles_info_destroy(sb_t_tiles_info** const ptiles);
 
SB_PUBLIC(sb_t_err) sb_tiles_info_no_overlap(sb_t_tiles_info* const tiles, sb_t_size img_size, int offset);
 
//TODO TABELLA DEI PUNTATORI NEI RISULTATI
typedef struct
{
    int is_valid;
 
    sb_t_par par;
 
    sb_t_samples samples; 
 
    sb_t_ocr_res ocr;
 
    sb_t_res_model global;  
 
    sb_t_res_models models; 
    
    long long time_us;    
 
    sb_t_devices_par devices;    
 
     sb_t_tiles_info* tiles;
 
     sb_t_version svl_version;
 
    sb_t_err err;               
}sb_t_res;
 
SB_PUBLIC(sb_t_err) sb_res_destroy(sb_t_res** const res);
 
SB_PUBLIC(sb_t_err) sb_res_clone(sb_t_res** const dst, const sb_t_res* const src);
 
SB_PUBLIC(sb_t_err) sb_res_compress(sb_t_res* const res);
 
SB_PUBLIC(sb_t_err) sb_res_decompress(sb_t_res* const res);
 // group_res
 
typedef struct
{
    int tp;  
 
    int tn;    
 
    int fp;
 
    int fn;
 
    int op;
 
    int on;
 
    int out_of_roi;
 
    int mod_disabled;
    sb_t_range_flt tp_weight; 
    sb_t_range_flt tn_weight; 
    sb_t_range_flt fp_weight; 
    sb_t_range_flt fn_weight; 
    sb_t_range_flt op_weight; 
    sb_t_range_flt on_weight; 
    sb_t_range_flt or_weight; 
 
    sb_t_metrics metrics;
 
    float score;
}sb_t_stat_model;
 
typedef struct
{
    sb_t_stat_model model[SB_PAR_MODELS_NUM];
 
    int size;
}sb_t_stat_models;
 
typedef struct
{
    sb_t_par par;
    sb_t_stat_models models;   
    sb_t_stat_model global;    
 
    int no_good;
 
    int good;                  
 
    int overkill;
 
    int escape;
 
    sb_t_metrics metrics;
 
 
    long long time_us;              
    long long time_us_average;      
    long long time_blob_us;         
    long long time_blob_us_average; 
    long long time_res_us;          
    long long time_res_us_average;  
    int elaborated;                 
}sb_t_stat;
 
SB_PUBLIC(sb_t_err) sb_stat_format(const sb_t_stat* const stat, char* const str, int str_size);
 
SB_PUBLIC(sb_t_err) sb_stat_destroy(sb_t_stat** const stat);
 
SB_PUBLIC(sb_t_err) sb_stat_reset(sb_t_stat* const stat, const sb_t_par* const par);
 
SB_PUBLIC(sb_t_err) sb_stat_from_res(sb_t_stat* const stat, const sb_t_res* const res);
 // group_stat
 
typedef struct
{
    int index;                          
    int lut_level[SB_PAR_LEVELS_NUM];   
}sb_t_par_model_lut;
 
typedef struct
{
    char* models;
    sb_t_par_model_lut lut_model_cur2new[SB_PAR_MODELS_NUM]; 
    sb_t_par_model_lut lut_model_new2cur[SB_PAR_MODELS_NUM]; 
 
    sb_t_par par_cur;                   
    sb_t_par par_new;                   
}sb_t_par_changes_info;
 
SB_PUBLIC(sb_t_err) sb_project_get_par_changes_info(SB_HANDLE handle, const sb_t_par * const par, sb_t_par_changes_info** const par_changes_info);
 
SB_PUBLIC(sb_t_err) sb_project_destroy_par_changes_info(sb_t_par_changes_info** const par_changes_info);
 
SB_PUBLIC(sb_t_err) sb_project_change_type(const char* const solution_file, const char* const project_uuid, sb_t_project_type project_type);
 
#ifdef SB_DEBUG_PROJECT_GET_PAR_MEMORY_LEAK
SB_PUBLIC(sb_t_err) sb_project_get_par_imp(const char* const file, const char* const function, int line, SB_HANDLE handle, sb_t_par** const par);
#define sb_project_get_par(handle, par) sb_project_get_par_imp(__FILE__, __FUNCTION__, __LINE__, handle, par)
#else
SB_PUBLIC(sb_t_err) sb_project_get_par(SB_HANDLE handle, sb_t_par** const par);
#endif
 
SB_PUBLIC(sb_t_err) sb_project_set_par(SB_HANDLE handle, const sb_t_par* const par);
 
SB_PUBLIC(sb_t_err) sb_project_get_res(SB_HANDLE handle, sb_t_res** const res, int details);
 
SB_PUBLIC(sb_t_err) sb_project_reset_stat(SB_HANDLE handle);
 
SB_PUBLIC(sb_t_err) sb_project_get_stat(SB_HANDLE handle, sb_t_stat** const stat);
 
typedef struct
{
    sb_t_image* img; 
    char* info;      
}sb_t_elaborated_image;
 
typedef struct
{
    sb_t_elaborated_image* imgs; 
    int size;                    
}sb_t_elaborated_images;
 
typedef struct
{
    sb_t_par* par;
    sb_t_elaborated_images imgs; 
}sb_t_project_detection_info;
 
SB_PUBLIC(sb_t_err) sb_project_detection_destroy_info(sb_t_project_detection_info** const di);
 
SB_PUBLIC(sb_t_err) sb_project_detection_get_info(SB_HANDLE handle, const sb_t_image* const src, const sb_t_roi* const roi, sb_t_project_detection_info** const di);
 // group_project 3
 
#define SB_IMAGE_INFO_EXT "rtn"
 
typedef enum
{
    SB_IMAGE_INFO_TYPE_NONE = 0, 
    SB_IMAGE_INFO_TYPE_TEST,     
    SB_IMAGE_INFO_TYPE_SVL,      
    SB_IMAGE_INFO_TYPE_SVL_USED, 
}sb_t_image_info_type;
 
typedef struct
{
    sb_t_project_info       project_info;  
    sb_t_image_info_type    type;          
}sb_t_image_info_detail;
 
typedef struct
{
    sb_t_image_info_detail* details;        
    int                      size;          
}sb_t_image_info_details;
 
SB_PUBLIC(sb_t_err) sb_image_info_get_version(const char* const image_file, sb_t_version* version, char* const version_str, int size_version_str);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_details(const char* const image_file, sb_t_image_info_details** details);
 
SB_PUBLIC(sb_t_err) sb_image_info_destroy_details(sb_t_image_info_details** const details);
 
SB_PUBLIC(sb_t_err) sb_image_info_change_project(const char* const image_file, const sb_t_project_info* const project_info_old, SB_HANDLE module_handle_new);
 
SB_PUBLIC(sb_t_err) sb_image_info_remove_project(const char* const image_file, const char* const project_uuid);
 
SB_PUBLIC(sb_t_err) sb_image_info_load(SB_HANDLE* image_info, const char* const image_file, SB_HANDLE module_handle);
 
SB_PUBLIC(sb_t_err) sb_image_info_destroy(SB_HANDLE* image_info);
 
SB_PUBLIC(sb_t_err) sb_image_info_save(SB_HANDLE image_info);
 
SB_PUBLIC(sb_t_err) sb_image_info_clone(SB_HANDLE src, SB_HANDLE* pdst, SB_HANDLE module_handle);
 
SB_PUBLIC(sb_t_err) sb_image_info_copy_labeling(SB_HANDLE dst, const char* const image_file, const sb_t_project_info* src_prj, int roi, int ground_truth, int* copied);
 
SB_PUBLIC(sb_t_err) sb_image_info_add_sample(SB_HANDLE image_info, const sb_t_sample* const sample);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_samples(SB_HANDLE image_info, const sb_t_samples* const samples);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_samples(SB_HANDLE image_info, sb_t_samples** const samples);
 
SB_PUBLIC(sb_t_err) sb_image_info_check_samples(const sb_t_samples* const samples, SB_HANDLE project, SB_HANDLE image_info, sb_t_size image_size);
 
SB_PUBLIC(sb_t_err) sb_image_info_reset(SB_HANDLE image_info);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_type(SB_HANDLE image_info, sb_t_image_info_type type);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_type(SB_HANDLE image_info, const char* const model_name, sb_t_image_info_type* const type);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_tiles_svl(SB_HANDLE handle, sb_t_tiles_info** const ptiles);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_project_info(SB_HANDLE handle, sb_t_project_info* const project_info);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_notes(SB_HANDLE image_info, const char* const str);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_notes(SB_HANDLE image_info, char** const str);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_name(SB_HANDLE image_info, char* const str, int str_size);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_results(SB_HANDLE image_info, const sb_t_res* const res);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_results(SB_HANDLE image_info, sb_t_res** const res, int compressed);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_project_name(SB_HANDLE image_info, const char* const project_name);
 
SB_PUBLIC(sb_t_err) sb_image_info_apply_par_changes(SB_HANDLE image_info, const sb_t_par_changes_info *info);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_roi(SB_HANDLE image_info, const sb_t_roi* const roi);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_roi(SB_HANDLE image_info, sb_t_roi** const roi, int width, int height, int compressed);
 
SB_PUBLIC(sb_t_err) sb_image_info_set_roi_defects(SB_HANDLE image_info, const sb_t_roi* const defects);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_roi_defects(SB_HANDLE image_info, sb_t_roi** const defects, int width, int height, int compressed);
 
SB_PUBLIC(sb_t_err) sb_image_info_get_custom_par_root(SB_HANDLE handle, SB_HANDLE* node_root);
 // group_image_info
 
 
SB_PUBLIC(sb_t_err) sb_folder_filter_images(sb_t_folder* const folder, SB_HANDLE module, sb_t_image_info_type image_info_type);
 // group_folder_2
 
 
typedef enum
{
    SB_SVL_STOP_NONE = 0,
 
    SB_SVL_STOP_CONFLICT,
 
    SB_SVL_STOP_USER_REQUEST,
 
    SB_SVL_STOP_MEMORY,
 
    SB_SVL_STOP_RESET_MANDATORY,
 
    SB_SVL_STOP_RESET_OPTIONAL,
 
    SB_SVL_STOP_WARNING
}sb_t_svl_stop_reason;
 
typedef struct
{
    char *msg;                             
    sb_t_err err;                          
    char file_name[2][512];                
    float scale[2];                        
    int num_samples;                       
    char model_name[2][SB_PAR_STRING_LEN]; 
    int sample_index[2];                   
    sb_t_point centre[2];                  
    float dist;                            
    float min_dist;                        
    int models_number[2];                  
    sb_t_svl_dl_par_network par_network[2];
    sb_t_loss_fn_type loss_fn[2];          
}sb_t_svl_err;
 
#define SB_CLS_0    "cls0"    
#define SB_CLS_1    "cls1"    
 
#define SB_FEATURE_0A       "0A"       
#define SB_FEATURE_0B       "0B"       
#define SB_FEATURE_0A_RI    "0A_RI"    
#define SB_FEATURE_0B_RI    "0B_RI"    
#define SB_FEATURE_2A       "2A"       
#define SB_FEATURE_2B       "2B"       
#define SB_FEATURE_2C       "2C"       
#define SB_FEATURE_2D       "2D"       
#define SB_FEATURE_2A_R     "2A.R"     
#define SB_FEATURE_2AA_R    "2AA.R"    
#define SB_FEATURE_2B_R     "2B.R"     
#define SB_FEATURE_2C_R     "2C.R"     
#define SB_FEATURE_2D_R     "2D.R"     
#define SB_FEATURE_2A_G     "2A.G"     
#define SB_FEATURE_2AA_G    "2AA.G"    
#define SB_FEATURE_2B_G     "2B.G"     
#define SB_FEATURE_2C_G     "2C.G"     
#define SB_FEATURE_2D_G     "2D.G"     
#define SB_FEATURE_2A_B     "2A.B"     
#define SB_FEATURE_2AA_B    "2AA.B"    
#define SB_FEATURE_2B_B     "2B.B"     
#define SB_FEATURE_2C_B     "2C.B"     
#define SB_FEATURE_2D_B     "2D.B"     
#define SB_FEATURE_2A_RI    "2A_RI"    
#define SB_FEATURE_2B_RI    "2B_RI"    
#define SB_FEATURE_2C_RI    "2C_RI"    
#define SB_FEATURE_2A_RI_R  "2A_RI.R"  
#define SB_FEATURE_2AA_RI_R "2AA_RI.R" 
#define SB_FEATURE_2B_RI_R  "2B_RI.R"  
#define SB_FEATURE_2C_RI_R  "2C_RI.R"  
#define SB_FEATURE_2A_RI_G  "2A_RI.G"  
#define SB_FEATURE_2AA_RI_G "2AA_RI.G" 
#define SB_FEATURE_2B_RI_G  "2B_RI.G"  
#define SB_FEATURE_2C_RI_G  "2C_RI.G"  
#define SB_FEATURE_2A_RI_B  "2A_RI.B"  
#define SB_FEATURE_2AA_RI_B "2AA_RI.B" 
#define SB_FEATURE_2B_RI_B  "2B_RI.B"  
#define SB_FEATURE_2C_RI_B  "2C_RI.B"  
#define SB_FEATURE_3A       "3A"       
#define SB_FEATURE_3B       "3B"       
#define SB_FEATURE_3C       "3C"       
#define SB_FEATURE_3D       "3D"       
#define SB_FEATURE_3E       "3E"       
#define SB_FEATURE_4A       "4A"        //group_features
 
#define SB_FEATURES SB_FEATURE_0A        SB_DELIMITER \
                    SB_FEATURE_0B        SB_DELIMITER \
                    SB_FEATURE_0A_RI     SB_DELIMITER \
                    SB_FEATURE_0B_RI     SB_DELIMITER \
                    SB_FEATURE_2A        SB_DELIMITER \
                    SB_FEATURE_2A_R      SB_DELIMITER \
                    SB_FEATURE_2A_G      SB_DELIMITER \
                    SB_FEATURE_2A_B      SB_DELIMITER \
                    SB_FEATURE_2AA_R     SB_DELIMITER \
                    SB_FEATURE_2AA_G     SB_DELIMITER \
                    SB_FEATURE_2AA_B     SB_DELIMITER \
                    SB_FEATURE_2B        SB_DELIMITER \
                    SB_FEATURE_2B_R      SB_DELIMITER \
                    SB_FEATURE_2B_G      SB_DELIMITER \
                    SB_FEATURE_2B_B      SB_DELIMITER \
                    SB_FEATURE_2C        SB_DELIMITER \
                    SB_FEATURE_2C_R      SB_DELIMITER \
                    SB_FEATURE_2C_G      SB_DELIMITER \
                    SB_FEATURE_2C_B      SB_DELIMITER \
                    SB_FEATURE_2D        SB_DELIMITER \
                    SB_FEATURE_2D_R      SB_DELIMITER \
                    SB_FEATURE_2D_G      SB_DELIMITER \
                    SB_FEATURE_2D_B      SB_DELIMITER \
                    SB_FEATURE_2A_RI     SB_DELIMITER \
                    SB_FEATURE_2A_RI_R   SB_DELIMITER \
                    SB_FEATURE_2A_RI_G   SB_DELIMITER \
                    SB_FEATURE_2A_RI_B   SB_DELIMITER \
                    SB_FEATURE_2AA_RI_R  SB_DELIMITER \
                    SB_FEATURE_2AA_RI_G  SB_DELIMITER \
                    SB_FEATURE_2AA_RI_B  SB_DELIMITER \
                    SB_FEATURE_2B_RI     SB_DELIMITER \
                    SB_FEATURE_2B_RI_R   SB_DELIMITER \
                    SB_FEATURE_2B_RI_G   SB_DELIMITER \
                    SB_FEATURE_2B_RI_B   SB_DELIMITER \
                    SB_FEATURE_2C_RI     SB_DELIMITER \
                    SB_FEATURE_2C_RI_R   SB_DELIMITER \
                    SB_FEATURE_2C_RI_G   SB_DELIMITER \
                    SB_FEATURE_2C_RI_B   SB_DELIMITER \
                    SB_FEATURE_3A        SB_DELIMITER \
                    SB_FEATURE_3B        SB_DELIMITER \
                    SB_FEATURE_3C        SB_DELIMITER \
                    SB_FEATURE_3D        SB_DELIMITER \
                    SB_FEATURE_3E        SB_DELIMITER \
                    SB_FEATURE_4A
 
SB_PUBLIC(const char*) sb_feature_description(const char* const feature);
 
typedef struct
{
    char image_name[SB_IMAGE_NAME_STRING_LEN]; 
    sb_t_image_info_type type;                 
}sb_t_svl_res_image;
 
typedef struct
{
    sb_t_svl_res_image* image; 
    int size;                  
}sb_t_svl_res_images;
 
typedef struct
{
    float loss;
    float validation_loss;
    sb_t_metrics metrics;
    sb_t_metrics validation_metrics;
}sb_t_svl_res_epoch;
 
typedef struct
{
    sb_t_svl_res_epoch* epoch; 
    int saved_epoch;           
    int size;                  
}sb_t_svl_res_epochs;
 
typedef struct
{
    float goodness;
    float accuracy;
    float score;
    int tp;
    int fp;
    int tn;
    int fn;
    int op;
    int on;
    int out_of_roi;
    int mod_disabled;
    int reset;
    int num_samples_l;
    int num_samples_t;
    int num_img_l;
    int num_tiles_l;
    int num_tiles_u;
    int num_tiles_v;
    long long num_pixels_roi_l;
    long long num_pixels_roi_u;
    long long num_pixels_roi_v;
    long long num_pixels_defect_l;
    long long num_pixels_defect_u;
    long long num_pixels_defect_v;
    sb_t_svl_par_optimization_mode optimization_mode;
    char classificator[32];
    char features[SB_PAR_FEATURES_NAMES_LEN];
    char features_available[SB_PAR_FEATURES_NAMES_LEN];
    char* warning;
    sb_t_svl_res_epochs epochs;
}sb_t_svl_res_level;
 
typedef struct
{
    sb_t_svl_res_level level[SB_PAR_LEVELS_NUM]; 
    int size;                                    
}sb_t_svl_res_levels;
 
typedef struct
{
    sb_t_svl_res_levels levels;
    sb_t_svl_res_level  global;
}sb_t_svl_res_model;
 
typedef struct
{
    sb_t_svl_res_model model[SB_PAR_MODELS_NUM];
    int size;
}sb_t_svl_res_models;
 
#define SB_SVL_STEP_INITIALIZATION    "initializing data for svl" 
#define SB_SVL_STEP_SEARCHING_RECIPE  "choosing recipe"           
#define SB_SVL_STEP_TRAINING_RECIPE   "training recipe"           
#define SB_SVL_STEP_FINALIZATION      "finalization of svl"       
#define SB_SVL_STEP_FINISHED          "svl has finished"          
 
struct sb_t_svl_res {
    sb_t_par par;                       
    sb_t_svl_stop_reason  stop_reason;  
    sb_t_svl_command      last_command; 
 
    char running_step[256];
    sb_t_svl_err err;
    sb_t_svl_res_models models;
    sb_t_svl_res_level global;
    sb_t_samples* list_tp;
    sb_t_samples* list_tn;
    sb_t_samples* list_fp;
    sb_t_samples* list_fn;
    sb_t_samples* list_op;
    sb_t_samples* list_on;
    sb_t_samples* list_out_of_roi;
    sb_t_svl_res_images* list_img_elab;
    int num_img_svl;
    int num_img_test;
    long long time_ms;
    long long time_ms_last_improvement;
    long long time_left_ms;
    int reset_done;
    sb_t_devices_par devices;
};
 
SB_PUBLIC(sb_t_err) sb_svl_run(SB_HANDLE handle);
 
SB_PUBLIC(sb_t_err) sb_svl_reset(SB_HANDLE handle);
 
SB_PUBLIC(sb_t_err) sb_svl_stop_request(SB_HANDLE handle);
 
SB_PUBLIC(sb_t_err) sb_svl_get_res(SB_HANDLE handle, sb_t_svl_res** const res);
 
SB_PUBLIC(sb_t_err) sb_svl_destroy_res(sb_t_svl_res** const res);
 
SB_PUBLIC(sb_t_err) sb_svl_clone_res(sb_t_svl_res** const dst, const sb_t_svl_res* const src);
 
SB_PUBLIC(sb_t_err) sb_svl_save_pre_training(SB_HANDLE handle, const char* const file_name);
 
SB_PUBLIC(sb_t_err) sb_pre_training_get_par(sb_t_par** const par, const char* const file_name);
 // group_svl
 
SB_PUBLIC(sb_t_err) sb_surface_model_to_gl(const sb_t_par * const par, const char* const model_name, unsigned char* const gl, unsigned char* const gl_opt);
 
 // group_surface // group_cpp
#endif