cs_sb.h

#pragma once
#include <windows.h>
#include "sb.h"
using namespace System;
using namespace System::Runtime::InteropServices;
#include "cs_common.h"
 
namespace sb_cs
{
    public enum class SbDlLibraryType :int {
        SB_DL_LIBRARY_NONE = SB_DL_LIBRARY_NONE,        
        SB_DL_LIBRARY_PYTORCH = SB_DL_LIBRARY_PYTORCH,  
        SB_DL_LIBRARY_OPENVINO = SB_DL_LIBRARY_OPENVINO 
    };
 
    public ref class SbRgba {
    public:
        unsigned char r; 
        unsigned char g; 
        unsigned char b; 
        unsigned char a; 
        SbRgba();
        SbRgba(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
    internal:
        SbRgba(const sb_t_rgba* const src);
        SbError CopyFromNative(const sb_t_rgba* const src);
        SbError CopyToNative(sb_t_rgba* dst);
    };
 
    public ref class SbBgra {
    public:
        unsigned char b; 
        unsigned char g; 
        unsigned char r; 
        unsigned char a; 
        SbBgra();
        SbBgra(unsigned char b, unsigned char g, unsigned char r, unsigned char a);
    internal:
        SbBgra(const sb_t_bgra* const src);
        SbError CopyFromNative(const sb_t_bgra* const src);
        SbError CopyToNative(sb_t_bgra* dst);
    };
 
    public ref class SbSize {
    public:
        int width;  
        int height; 
        SbSize();
        SbSize(int width, int height);
        String^ ToString() override;
    internal:
        SbSize(const sb_t_size* const src);
        SbError CopyFromNative(const sb_t_size* const src);
        SbError CopyToNative(sb_t_size* dst);
    };
 
    public ref class SbSizeFlt {
    public:
        float width;  
        float height; 
        SbSizeFlt();
        SbSizeFlt(float width, float height);
        String^ ToString() override;
    internal:
        SbSizeFlt(const sb_t_size_flt* const src);
        SbError CopyFromNative(const sb_t_size_flt* const src);
        SbError CopyToNative(sb_t_size_flt* dst);
    };
 
    public ref class SbRange {
    public:
        int min; 
        int max; 
        SbRange();
        SbRange(int _min, int _max);
        String^ ToString() override;
    internal:
        SbRange(const sb_t_range* const src);
        SbError CopyFromNative(const sb_t_range* const src);
        SbError CopyToNative(sb_t_range* dst);
    };
 
    public ref class SbRangeFlt {
    public:
        float min; 
        float max; 
        SbRangeFlt();
        SbRangeFlt(float min, float max);
        String^ ToString() override;
    internal:
        SbRangeFlt(const sb_t_range_flt* const src);
        SbError CopyFromNative(const sb_t_range_flt* const src);
        SbError CopyToNative(sb_t_range_flt* dst);
    };
 
    public ref class SbPoint {
    public:
        int x;  
        int y;  
        SbPoint();
        SbPoint(int x, int y);
        String^ ToString() override;
    internal:
        SbPoint(const sb_t_point* const src);
        SbError CopyFromNative(const sb_t_point* const src);
        SbError CopyToNative(sb_t_point* dst);
    };
 
    public ref class SbPoint2dF {
    public:
        float x;  
        float y;  
        SbPoint2dF();
        SbPoint2dF(float x, float y);
        String^ ToString() override;
    internal:
        SbPoint2dF(const sb_t_point2d_f* const src);
        SbError CopyFromNative(const sb_t_point2d_f* const src);
        SbError CopyToNative(sb_t_point2d_f* dst);
    };
 
    public ref class SbRect {
    public:
        int x;      
        int y;      
        int width;  
        int height; 
        SbRect(int x, int y, int width, int height);
        SbRect();
        String^ ToString() override;
    internal:
        SbRect(const sb_t_rect* const src);
        SbError CopyFromNative(const sb_t_rect* const src);
    };
 
    public ref class SbMemoryInfo {
    public:
        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;             
    internal:
        SbMemoryInfo(const sb_t_memory_info* const src);
        SbError CopyFromNative(const sb_t_memory_info* const src);
    };
 
    public ref class SbDeviceInfo {
    public:
        SbDeviceType type;
 
        array<SbFrameworkType^>^ frameworks;
 
        String^ name;
 
        String^ compute_capability;
 
        int id;
 
        SbMemoryInfo^ memory;
    internal:
        SbDeviceInfo(const sb_t_device_info* const src);
        SbError CopyFromNative(const sb_t_device_info* const src);
    };
 
    public ref class SbMetrics
    {
    public:
        float accuracy;
        float recall;
        float precision;
        float f1_score;
        float specificity;
    internal:
        SbMetrics(const sb_t_metrics* const sb_metrics);
        SbError CopyFromNative(const sb_t_metrics* const sb_metrics);
    };
 
    public ref class SbInfo: SbCommon
    {
    public:
        SbVersion^ version;
        String^ version_str;
        String^ compile_date;
        String^ compile_time;
        signed long long malloc_size;
        signed long long malloc_size_max;
        int dl_modules_enabled;
        array<SbDeviceInfo^>^ devices;
        SbError Refresh(int dl_devices_info);
        String^ Format();
    internal:
        SbInfo();
        ~SbInfo();
        SbError CopyFromNative(sb_t_info* const src);
        sb_t_info* sb_info;
    };
 
    public ref class Sb
    {
    public:
        static SbError Init(String ^ license_file);
        static SbError InitDl(String^ search_path, SbDlLibraryType LibType);
        static SbError Release();
        static SbError CheckMemoryLeak();
        static SbError CheckMemoryLeakReset();
        static SbInfo^ GetInfo(int dl_devices_info);
        static String ^ SbInitOnlyHwLicenseKey = SB_INIT_ONLY_HW_LICENSE_KEY;
        static String^ SbInitOnlySbLicenseKey = SB_INIT_ONLY_SB_LICENSE_KEY;
        static String^ SbInitNoLicenseKey = SB_INIT_NO_LICENSE_KEY;
        static String^ FormatDeviceType(SbDeviceType value);
        static String^ FormatFrameworkType(SbFrameworkType value);
    };
 
    class SbUtils
    {
    public:
        static SbError StringCopyToNative(char* const dst, int dst_size, String^ src);
        static String^ StringCopyFromNative(const char* const src);
        static String^ StringCopyFromNative(char* const src);
    }; // group_cs_common   
 // group_cs    
}
 
#include "cs_folder.h"
#include "cs_license.h"
#include "cs_image.h"
#include "cs_sample.h"
#include "cs_blob.h"
#include "cs_par.h"
#include "cs_roi.h"
#include "cs_res.h"
#include "cs_project.h"
#include "cs_solution.h"