cs_par.h

#pragma once
namespace sb_cs
{
    public enum class SbProjectType :int 
    {
        SB_PROJECT_TYPE_RETINA = SB_PROJECT_TYPE_RETINA,             
        SB_PROJECT_TYPE_SURFACE = SB_PROJECT_TYPE_SURFACE,           
        SB_PROJECT_TYPE_DEEP_SURFACE = SB_PROJECT_TYPE_DEEP_SURFACE, 
        SB_PROJECT_TYPE_DEEP_CORTEX = SB_PROJECT_TYPE_DEEP_CORTEX    
    };
 
    public enum class SbImageCircularityType :int
    {
        SB_IMAGE_CIRCULARITY_TYPE_NONE = SB_IMAGE_CIRCULARITY_TYPE_NONE,             
        SB_IMAGE_CIRCULARITY_TYPE_HORIZONTAL = SB_IMAGE_CIRCULARITY_TYPE_HORIZONTAL, 
        SB_IMAGE_CIRCULARITY_TYPE_VERTICAL = SB_IMAGE_CIRCULARITY_TYPE_VERTICAL      
    };
 
    public enum class SbFloatingPointPrecisionType :int 
    {
        SB_FLOATING_POINT_OPS_TYPE_SINGLE_PRECISION =  SB_FLOATING_POINT_OPS_TYPE_SINGLE_PRECISION, 
        SB_FLOATING_POINT_OPS_TYPE_HALF_PRECISION =  SB_FLOATING_POINT_OPS_TYPE_HALF_PRECISION      
    };
 
    public enum class SbSvlParOptimizationMode :int 
    {
        SB_SVL_PAR_OPTIMIZATION_TIME_SLOW = SB_SVL_PAR_OPTIMIZATION_TIME_SLOW,
         SB_SVL_PAR_OPTIMIZATION_TIME_MEDIUM = SB_SVL_PAR_OPTIMIZATION_TIME_MEDIUM,
          SB_SVL_PAR_OPTIMIZATION_TIME_FAST = SB_SVL_PAR_OPTIMIZATION_TIME_FAST,
           SB_SVL_PAR_OPTIMIZATION_USE_SELECTED = SB_SVL_PAR_OPTIMIZATION_USE_SELECTED
    };
 
    public ref class SbParSl
    {
    public:
        float speed_boost;
        int detection_out_of_roi;
 
    internal:
        SbParSl(const sb_t_par_sl* const src);
        SbError CopyFromNative(const sb_t_par_sl* const src);
        SbError CopyToNative(sb_t_par_sl* dst);
    };
 
    public ref class SbParLevel 
    {
    public:
        bool enabled;
        float scale;
 
    internal:
        SbParLevel(const sb_t_par_level* const src);
        SbError CopyFromNative(const sb_t_par_level* const src);
        SbError CopyToNative(sb_t_par_level* dst);
    };
 
    public ref class SbPerturbation 
    {
    public:
        int angle;
 
        int flip_horizontal;
 
        int flip_vertical;
 
        SbRange^ angle_range;
 
        int num_synthetic_samples;
    internal:
        SbPerturbation(const sb_t_par_perturbation* const src);
        SbError CopyFromNative(const sb_t_par_perturbation* const src);
        SbError CopyToNative(sb_t_par_perturbation* const dst);
    };
 
    public ref class SbParModel 
    {
    public:
        String^ name;
        SbSize^ obj_size;
        bool enabled;
        array<SbParLevel^>^ levels;
        array<SbPerturbation^>^ perturbations;
        SbRgba^ color;
        SbRgba^ color_opt;
        SbSize^ obj_min_distance;
        SbSize^ obj_stride_coarse;
        SbSize^ obj_stride_fine;
        int num_occurrences;
        float defect_area_percentage;
        float defect_area_threshold;
        SbParModel();
    internal:
        SbParModel(const sb_t_par_model* const src);
        SbError CopyFromNative(const sb_t_par_model* const src);
        SbError CopyToNative(sb_t_par_model* const dst);
    };
 
    public ref class SbDevicesPar
    {
    public:
        SbDeviceType type;
 
        array<int>^ id;
    internal:
        SbDevicesPar();
        SbDevicesPar(const sb_t_devices_par* const src);
        SbError CopyFromNative(const sb_t_devices_par* const src);
        SbError CopyToNative(sb_t_devices_par* dst);
    };
 
    public enum class SbNetworkType :int
    {
        SB_NETWORK_TYPE_EFFICIENTNET_B0 = SB_NETWORK_TYPE_EFFICIENTNET_B0,
        SB_NETWORK_TYPE_EFFICIENTNET_B1 = SB_NETWORK_TYPE_EFFICIENTNET_B1,
        SB_NETWORK_TYPE_EFFICIENTNET_B2 = SB_NETWORK_TYPE_EFFICIENTNET_B2,
        SB_NETWORK_TYPE_SDINET0_331 = SB_NETWORK_TYPE_SDINET0_331,
        SB_NETWORK_TYPE_SDINET0_331x128 = SB_NETWORK_TYPE_SDINET0_331x128,
        SB_NETWORK_TYPE_SDINET0_400x160 = SB_NETWORK_TYPE_SDINET0_400x160,
        SB_NETWORK_TYPE_ICNET0_64 = SB_NETWORK_TYPE_ICNET0_64,
        SB_NETWORK_TYPE_ICNET0_128 = SB_NETWORK_TYPE_ICNET0_128
    };
 
    public ref class SbSvlDlParNetwork
    {
    public:
        SbNetworkType type;
        SbSize^ input_size;
        int n_channels;
        SbImageFormat image_format;
        float features_multiplier;
    internal:
        SbSvlDlParNetwork(const sb_t_svl_dl_par_network* const src);
        SbError CopyFromNative(const sb_t_svl_dl_par_network* const src);
        SbError CopyToNative(sb_t_svl_dl_par_network* dst);
    };
 
    public enum class SbLossFnType :int 
    {
        SB_LOSS_FN_TYPE_CCE = SB_LOSS_FN_TYPE_CCE,      
        SB_LOSS_FN_TYPE_FOCAL = SB_LOSS_FN_TYPE_FOCAL,  
        SB_LOSS_FN_TYPE_BCE = SB_LOSS_FN_TYPE_BCE,      
        //SB_LOSS_FN_TYPE_DICE = SB_LOSS_FN_TYPE_DICE,//!< Dice loss.
        //SB_LOSS_FN_TYPE_RMI = SB_LOSS_FN_TYPE_RMI //!< RMI loss.
    };
 
    public enum class SbPerturbationMode :int 
    {
        SB_PERTURBATION_MODE_ONLINE = SB_PERTURBATION_MODE_ONLINE,   
        SB_PERTURBATION_MODE_OFFLINE = SB_PERTURBATION_MODE_OFFLINE, 
        SB_PERTURBATION_MODE_BOTH = SB_PERTURBATION_MODE_BOTH        
    };
 
    public enum class SbPerturbationType :int 
    {
        SB_PERTURBATION_TYPE_IMAGE = SB_PERTURBATION_TYPE_IMAGE,     
        SB_PERTURBATION_TYPE_DEFECTS = SB_PERTURBATION_TYPE_DEFECTS, 
        SB_PERTURBATION_TYPE_BOTH = SB_PERTURBATION_TYPE_BOTH        
    };
 
    public ref class SbSvlDlParPerturbation 
    {
    public:
        String^ inpainter_path;
 
        SbPerturbationMode mode;
 
        SbPerturbationType type;
 
        int flip_horizontal;
 
        int flip_vertical;
 
        float shift_horizontal;
 
        float shift_vertical;
 
        SbRange^ angle_range;
 
        float delta_brightness;
 
        float stretch_contrast;
 
        float delta_scale;
 
    internal:
        SbSvlDlParPerturbation(const sb_t_svl_dl_par_perturbation* const src);
        SbError CopyFromNative(const sb_t_svl_dl_par_perturbation* const src);
        SbError CopyToNative(sb_t_svl_dl_par_perturbation* dst);
    };
 
    public ref class SbSvlDlPar
    {
    public:
        String^ network_path;
 
        SbSvlDlParNetwork^ network;
 
        int pre_trained;
 
        SbSvlDlParPerturbation^ perturbations;
 
        float learning_rate;
 
        int num_epochs;
 
        int batch_size;
 
        float validation_percentage;
 
        int save_best;
 
        SbSize^ tile_factor;
 
        int auto_tiling;
 
        SbSizeFlt^ scale;
 
        SbLossFnType loss_fn;
 
    internal:
        SbSvlDlPar(const sb_t_svl_dl_par* const src);
        SbError CopyFromNative(const sb_t_svl_dl_par* const src);
        SbError CopyToNative(sb_t_svl_dl_par* dst);
    };
 
    public ref class SbSvlSlPar
    {
    public:
        float goodness_target;
        String^ features;
        SbSvlParOptimizationMode optimization_mode;
        int auto_levels;
 
    internal:
        SbSvlSlPar(const sb_t_svl_sl_par* const src);
        SbError CopyFromNative(const sb_t_svl_sl_par* const src);
        SbError CopyToNative(sb_t_svl_sl_par* dst);
    };
 
    public ref class SbSvlPar
    {
        // TODO callback
    public:
        String^ project_path;
        String^ image_ext;
        float free_memory_percentage;
        int num_threads;
        int reproducibility;
        SbImageCircularityType image_circularity_type;
        SbDevicesPar^ devices;
        SbSvlSlPar^ sl;
        SbSvlDlPar^ dl;
    internal:
        sb_fp_svl_pre_elaboration fp_pre_elaboration;
        sb_fp_svl_progress fp_progress;
        sb_fp_svl_command fp_command;
        void* user_data;
        SbSvlPar(const sb_t_svl_par* const src);
        SbError CopyFromNative(const sb_t_svl_par* const src);
        SbError CopyToNative(sb_t_svl_par* dst);
    };
 
    public ref class SbPar: SbCommon
    {
    public:
        SbProjectType project_type;
 
        array<SbParModel^>^ models;
 
        array<unsigned char, 2>^collaborations;
 
        int num_threads;
 
        SbBlobPar^ blob_par;
 
        SbDevicesPar^ devices;
 
        SbInterpolationMode resize_mode;
 
        SbFloatingPointPrecisionType floating_point_precision;
 
        SbRgba^ color_opt;
 
        int surface_blob_analysis;
 
        SbParSl^ sl;
 
        SbSvlPar^ svl; 
 
        SbError AddModel(String^ model_name);
 
        SbError RemoveModel(String^ model_name);
 
        SbError AddLevel(String^ model_name, float scale);
 
        SbError RemoveLevel(String^ model_name, float scale);
 
        SbError SetCollaboration(String^ model_name1, String^ model_name2, bool value);
 
        int GetCollaboration(String^ model_name1, String^ model_name2);
 
        String^ Format();
        
        static String^ FormatProjectType(SbProjectType value);
 
        static String^ FormatImageCircularityType(SbImageCircularityType value);
 
        static String^ FormatFloatingPointPrecisionType(SbFloatingPointPrecisionType value);
 
        static String^ FormatNetworkType(SbNetworkType value);
 
        static String^ FormatLossFnType(SbLossFnType value);
 
        static String^ FormatSvlParOptimizationMode(SbSvlParOptimizationMode value);
 
        static String^ FormatPerturbationMode(SbPerturbationMode value);
 
        static String^ FormatPerturbationType(SbPerturbationType value);
 
    internal:
        //E' obbligatorio che sia un puntatore in un progetto CLR
        sb_t_par* sb_par;
        SbPar();
        ~SbPar();
        SbError CopyToNative();
        //src viene utilizzato solo nel caso in cui this->sb_par e' NULL.
        //In questo caso la funzione alloca this->sb_par e poi copia src
        SbError CopyFromNative();
        SbError CopyFromNative(const sb_t_par* const src);
    }; // group_cs_parameters // group_cs
}