CommonHeaderDLL.h

Go to the documentation of this file.

 
#pragma once
#include <stdio.h>
 
#define SAIGEVISION_MAJOR_DIGIT 1000
#define SAIGEVISION_MINOR_DIGIT 100
 
#define SAIGEVISION_MAJOR 1 
#define SAIGEVISION_MINOR 6
#define SAIGEVISION_PATCHLEVEL 0
#define SAIGEVISION_MINORPATCHLEVEL 0
#define SAIGEVISION_VERSION (SAIGEVISION_MAJOR * SAIGEVISION_MAJOR_DIGIT + SAIGEVISION_MINOR * SAIGEVISION_MINOR_DIGIT + SAIGEVISION_PATCHLEVEL)
 
#define SR_USE_DEPRECATED_FUNCTIONS
 
typedef enum
{
    NO_ERROR_OUT = 0,                   
    NO_LICENCE = 101,                   
    USE_NOT_ALLOCATED_HANDLER = 102,    
    INAPPROPRIATE_HANDLER = 103,        
    OUT_OF_GPU_MEMORY = 104,            
    INAPPROPRIATE_GPU_NUMBER = 105,     
    NULL_INPUT = 106,                   
    INAPPROPRIATE_INPUT = 107,          
    FILE_NOT_FOUND = 108,               
    NULL_HANDLE_FILE_PATH = 109,        
    EMPTY_IMAGE = 110,                  
    SMALL_IMAGE = 111,                  
    NOT_LOAD_NETWORK_IN_GPU = 113,      
    FORWARD_ALGO_TIMEOUT = 114,         
    INAPPROPRIATE_OUTPUT = 115,         
    LOW_VERSION_LICENSE = 116,          
    NO_LICENSE_DONGLE = 117,            
    LOW_VERSION_FILE = 118,             
    LICENSE_EXPIRED = 119,              
    NOT_SUPPORTED_FUNCTION = 120,       
    UNKNOWN_ERROR = 1000,               
} eErrorType;
 
typedef enum
{
    Classification_V1 = 0,      
    Classification_V2 = 1,      
    Classification_V3 = 2,      
    Detection_V1 = 10,          
    Detection_V2 = 11,          
    Segmentation_V1 = 20,       
    Segmentation_V2 = 21,       
    Segmentation_V3 = 22,       
    DefectGenerator_V1 = 30,    
    OCR_Box_V1 = 40,            
    OCR_Text_V1 = 41,           
    SuperResolution_V1 = 60,    
} eAlgorithmType;
 
typedef enum
{
    ClsTrainType,   
    ClsTestType,    
    DetTrainType,   
    DetTestType,    
    SegTrainType,   
    SegTestType,    
    GenTrainType,   
    GenTestType,    
    OCRTrainType,   
    OCRTestType,    
    SuperResolutionTrainType, 
    SuperResolutionTestType, 
} eHandlerType;
 
typedef enum
{
    SR_PIXELSIZE_FILTER_MODE_OFF = 0,       
    SR_PIXELSIZE_FILTER_MODE_ON_FAST = 1,   
    SR_PIXELSIZE_FILTER_MODE_ON_EXACT = 2,  
} eModeOfPixelSizeFilter;
 
typedef enum
{
    SR_CROP_BY_OBJECTSIZE_N_RESIZE_TO_CROPSIZE = 0, 
    SR_CROP_BY_OBJECTSIZE = 1,                      
    SR_CROP_CENTER_BY_CROPSIZE = 2,                 
    SR_CROP_BY_OBJECTSIZE_NOT_SQUARE = 3,           
} eModeOfCropLargeObjects;
 
typedef enum
{
    SR_NONE = 0,
    SR_SIMPLE = 1,
} eFilterObjByRegionType;
 
typedef struct
{
    unsigned int xCenter;
 
    unsigned int yCenter;
 
    unsigned int area;
 
    unsigned int width;
 
    unsigned int height;
 
    float ellipseXCenter;
 
    float ellipseYCenter;
 
    float ellipseWidth;
 
    float ellipseHeight;
 
    float ellipseAngle;
 
    unsigned int classIdx;
 
    double scores[3];
 
    double averageColor[3];
 
 
    int croppedImageWidth;      
    int croppedImageHeight;     
    int croppedImageChannels;   
    void* croppedImage;         
    int nContours;          /* number of contours */
    int* nPointsOnContour;  /* array of number of points on each contour (ex, nPointsOnContour[1]: # of points on the second contour)*/
    int* pointsOnContour;   /* array of x, y coordinates of all points on contours */
    
    int* hierarchies;       
 
    float filteringObjectRatio;
}SR_SegmentedObject;
 
typedef struct
{
    float x;
    float y;
 
    float width;
    float height;
 
    float x_tl;
    float y_tl;
    float x_br;
    float y_br;
 
    float angle;
    
    float score;
    int   classIdx;
}SR_RotatedBox;
 
typedef struct 
{
    SR_RotatedBox box;
 
    int croppedImageWidth;
    int croppedImageHeight;
    int croppedImageChannels;
    void* croppedImage;
    float filteringObjectRatio;
}SR_DetectedBox;
 
typedef struct
{
    SR_RotatedBox box;
 
    const wchar_t*  wtext;
    const char*     text;
}SR_OCRTextBox;
 
typedef struct
{
    int classIdx;
    int* scoresOriginal;
    int* scoresIncludingAdd;
    int numClass;
    int camImageWidth;
    int camImageHeight;
    void* camImage;
}SR_ClassifiedResult;
 
static void PrintErrorType(eErrorType errorType, int verbosity = 2)
{
    if (errorType == NO_ERROR_OUT)
    {
        if (verbosity >= 2)
        {
            printf("Saige Vision SUCCESS, NO_ERROR_OUT, %d \n", NO_ERROR_OUT);
        }
    }
    else if (errorType == NO_LICENCE)
    {
        printf("Saige Vision FAILED, NO_LICENCE: FEATURE NOT FOUND, %d \n", NO_LICENCE);
    }
    else if (errorType == LOW_VERSION_LICENSE)
    {
        printf("Saige Vision FAILED, LOW_VERSION_LICENSE, %d \n", LOW_VERSION_LICENSE);
    }
    else if (errorType == NO_LICENSE_DONGLE)
    {
        printf("Saige Vision FAILED, NO_LICENSE_DONGLE: USB DONGLE NOT FOUND, %d \n", NO_LICENSE_DONGLE);
    }
    else if (errorType == USE_NOT_ALLOCATED_HANDLER)
    {
        printf("Saige Vision FAILED, USE_NOT_ALLOCATED_HANDLER, %d \n", USE_NOT_ALLOCATED_HANDLER);
    }
    else if (errorType == INAPPROPRIATE_HANDLER)
    {
        printf("Saige Vision FAILED, INAPPROPRIATE_HANDLER, %d \n", INAPPROPRIATE_HANDLER);
    }
    else if (errorType == OUT_OF_GPU_MEMORY)
    {
        printf("Saige Vision FAILED, OUT_OF_GPU_MEMORY, %d \n", OUT_OF_GPU_MEMORY);
    }
    else if (errorType == INAPPROPRIATE_GPU_NUMBER)
    {
        printf("Saige Vision FAILED, INAPPROPRIATE_GPU_NUMBER, %d \n", INAPPROPRIATE_GPU_NUMBER);
    }
    else if (errorType == NULL_INPUT)
    {
        printf("Saige Vision FAILED, NULL_INPUT, %d \n", NULL_INPUT);
    }
    else if (errorType == INAPPROPRIATE_INPUT)
    {
        printf("Saige Vision FAILED, INAPPROPRIATE_INPUT, %d \n", INAPPROPRIATE_INPUT);
    }
    else if (errorType == FILE_NOT_FOUND)
    {
        printf("Saige Vision FAILED, FILE_NOT_FOUND, %d \n", FILE_NOT_FOUND);
    }
    else if (errorType == NULL_HANDLE_FILE_PATH)
    {
        printf("Saige Vision FAILED, NULL_HANDLE_FILE_PATH, %d \n", NULL_HANDLE_FILE_PATH);
    }
    else if (errorType == EMPTY_IMAGE)
    {
        printf("Saige Vision FAILED, EMPTY_IMAGE, %d \n", EMPTY_IMAGE);
    }
    else if (errorType == SMALL_IMAGE)
    {
        printf("Saige Vision FAILED, SMALL_IMAGE, %d \n", SMALL_IMAGE);
    }
    else if (errorType == NOT_LOAD_NETWORK_IN_GPU)
    {
        printf("Saige Vision FAILED, NOT_LOAD_NETWORK_IN_GPU, %d \n", NOT_LOAD_NETWORK_IN_GPU);
    }
    else if (errorType == FORWARD_ALGO_TIMEOUT)
    {
        printf("Saige Vision FAILED, FORWARD_ALGO_TIMEOUT, %d \n", FORWARD_ALGO_TIMEOUT);
    }
    else if (errorType == INAPPROPRIATE_OUTPUT)
    {
        printf("Saige Vision FAILED, INAPPROPRIATE_OUTPUT, %d \n", INAPPROPRIATE_OUTPUT);
    }
    else if (errorType == LOW_VERSION_FILE)
    {
        printf("Saige Vision FAILED, LOW_VERSION_FILE, %d \n", LOW_VERSION_FILE);
    }
    else if (errorType == LICENSE_EXPIRED)
    {
        printf("Saige Vision FAILED, LICENSE_EXPIRED, %d \n", LICENSE_EXPIRED);
    }
    else
    {
        printf("Saige Vision FAILED, UNKNOWN_ERROR, %d \n", UNKNOWN_ERROR);
    }
}