File SaigeVisionAPI.h

Go to the documentation of this file.

#include <stdint.h>
#ifndef SAIGE_VISION_WRAPPER_SAIGE_VISION_API_H_
#define SAIGE_VISION_WRAPPER_SAIGE_VISION_API_H_


#define SAIGEVISION_RUNTIME_VERSION_MAJOR 2
#define SAIGEVISION_RUNTIME_VERSION_MINOR 12
#define SAIGEVISION_RUNTIME_VERSION_PATCH 0

#define SV_STR(x) #x
#define SV_VER(M, m, p) SV_STR(M) "." SV_STR(m) "." SV_STR(p)

#define SAIGEVISION_RUNTIME_VERSION "2.12.0"

#ifdef __linux__
#define SAIGE_VISION_API extern "C"
#elif defined(SAIGEVISIONWRAPPER_EXPORTS)
#define SAIGE_VISION_API extern "C" __declspec(dllexport)
#else
#define SAIGE_VISION_API extern "C" __declspec(dllimport)
#endif

#include <stdint.h>

#include "saige_error.h"
// SaigeVision v2 Constants
constexpr int kMaxLenOfClassName = 63;
constexpr int kMaxNumOfClasses = 255;
constexpr int kMaxLenOfModelName = 63;

constexpr int kMaxLenOfCameraName = 63;
constexpr int kMaxLenOfTrainedVersion = 63;

constexpr int kProjectTypeCLS = 0;  // Classification
constexpr int kProjectTypeDET = 1;  // Detection
constexpr int kProjectTypeSEG = 2;  // Segmentation
constexpr int kProjectTypeIAD = 3;  // Anomaly Detection
constexpr int kProjectTypeOCR = 4;  // OCR
constexpr int kProjectTypeIEN = 5;  // IEN
// Monitoring
constexpr int kMaxLenOfToolName = 63;

// SaigeVision v2 APIs

typedef void* SaigeInferenceHandle;
typedef struct {
    int batchSize;
    int inspectionSizeWidth;
    int inspectionSizeHeight;
} SaigeHandleConfig;
#define SAIGE_SET_BATCH_SIZE 0x01
#define SAIGE_SET_INSPECTION_SIZE 0x02
#define SAIGE_OPTIMIZE_HANDLE 0x04
typedef void* SaigeInferenceResult;

SAIGE_VISION_API int SaigeCreateInferenceHandle(SaigeInferenceHandle* handle, const int projectType,
                                                const char* modelFilePath, const int deviceIndex,
                                                SaigeHandleConfig* config,
                                                const unsigned int flags);

SAIGE_VISION_API int SaigeDestroyInferenceHandle(SaigeInferenceHandle handle);

SAIGE_VISION_API int SaigeCreateInferenceResult(SaigeInferenceResult* result);

SAIGE_VISION_API int SaigeDestroyInferenceResult(SaigeInferenceResult result);

typedef struct {
    char roiMode[kMaxLenOfModelName];

    double left;
    double top;
    double right;
    double bottom;

    int intensityMin;
    int intensityMax;
    int expansion;
    bool inversion;
    double offsetLeft;
    double offsetRight;
    double offsetTop;
    double offsetBottom;

    unsigned char* blindMask;
    int blindMaskWidth;
    int blindMaskHeight;
} SaigeRoiInfo;

typedef struct {
    char networkType[kMaxLenOfModelName + 1];
    int numOfClasses;
    char classNames[kMaxNumOfClasses][kMaxLenOfClassName + 1];
    char classColors[kMaxNumOfClasses][8];
    bool classIsNg[kMaxNumOfClasses];
    const char* description;
    const char* usedGpuName;
    const char* numOfIterations;
    int numOfTrainImages;
    int numOfValidationImages;
    long long trainingTimeStarted;
    long long trainingTimeCompleted;
    long long trainingTimeElapsed;
    char developerVersion[kMaxLenOfTrainedVersion + 1];
    char serverVersion[kMaxLenOfTrainedVersion + 1];
    char moduleVersion[kMaxLenOfTrainedVersion + 1];

    SaigeRoiInfo roiInfo;

    float resizeFactor;
    int cropSizeWidth;
    int cropSizeHeight;

    int imageResizeWidth;
    int imageResizeHeight;
    int targetTextSize;
    const char* targetImageQuality;

    const char* inputDataProcessingMode;
    int cropNumOfRows;
    int cropNumOfCols;
    const char* targetTextShape;
} SaigeModelInfo;

SAIGE_VISION_API int SaigeGetModelInfo(SaigeInferenceHandle handle, SaigeModelInfo* info);

#define SAIGE_DO_NOT_INSPECT "do_not_inspect"
#define SAIGE_DO_NOT_ENHANCE "do_not_enhance"
#define SAIGE_RESIZE_TO_FIT "resize_to_fit"
#define SAIGE_CROP_INTO_TILES "crop_into_tiles"

constexpr int kMaxLenOfTextFormatting = 200;

typedef struct {
    int length;  // length < kMaxLenOfTextFormatting
    bool engLower[kMaxLenOfTextFormatting];
    bool engUpper[kMaxLenOfTextFormatting];
    bool number[kMaxLenOfTextFormatting];
    bool kor[kMaxLenOfTextFormatting];
    bool symbol[kMaxLenOfTextFormatting];
} SaigeTextFormatting;

typedef struct {
    bool calcTime;
    int batchSize;

    const char* oversizedImageHandling;
    int inspectionSizeWidth;
    int inspectionSizeHeight;

    // Cls
    float additionalScores[kMaxNumOfClasses];
    bool calcClassActivationMap;

    // Det
    int maxNumOfDetectedObjects[kMaxNumOfClasses];

    // Seg
    bool calcScoremap;

    bool calcObject;
    // if calcObject == true
    bool calcObjectAreaAndApplyThreshold;
    bool calcObjectScoreAndApplyThreshold;
    int objectBoundaryThresholdPerClass[kMaxNumOfClasses];
    int objectAreaThresholdPerClass[kMaxNumOfClasses];
    double objectScoreThresholdPerClass[kMaxNumOfClasses];

    // IAD
    bool calcMask;
    bool calcHeatmap;
    double anomalyScoreThreshold;
    double heatmapColorRangeMin;
    double heatmapColorRangeMax;

    // if calcObject == true
    double objectBoundaryThreshold;
    int objectAreaThreshold;
    double objectScoreThreshold;

    // OCR
    double polygonScoreThreshold;

    int textSizeRangeMin;
    int textSizeRangeMax;

    int maxNumOfTextObjects;
    double textScoreThreshold;
    SaigeTextFormatting textFormatting;
} SaigeInferenceOption;

// Flags for Inference Options
#define SAIGE_WRITE_ON_MODEL_FILE 0x01
#define SAIGE_SET_CALC_TIME 0x2
#define SAIGE_SET_OVERSIZED_IMAGE_HANDLING 0x4
// CLS
#define SAIGE_SET_ADDITIONAL_SCORES 0x8
#define SAIGE_SET_CALC_CLASS_ACTIVATION_MAP 0x10
// DET
#define SAIGE_SET_MAX_NUM_OF_DETECTED_OBJECTS 0x20
// SEG
#define SAIGE_SET_CALC_SCOREMAP 0x40
#define SAIGE_SET_CALC_OBJECT 0x80
#define SAIGE_SET_CALC_OBJECT_AREA_AND_APPLY_THRESHOLD 0x100
#define SAIGE_SET_CALC_OBJECT_SCORE_AND_APPLY_THRESHOLD 0x200
#define SAIGE_SET_OBJECT_BOUNDARY_THRESHOLD 0x400
#define SAIGE_SET_OBJECT_AREA_THRESHOLD 0x800
#define SAIGE_SET_OBJECT_SCORE_THRESHOLD 0x1000

#define SAIGE_SET_CALC_MASK 0x2000
#define SAIGE_SET_CALC_HEATMAP 0x4000
#define SAIGE_SET_ANOMALY_SCORE_THRESHOLD 0x8000
#define SAIGE_SET_HEATMAP_COLOR_RANGE 0x10000

// OCR
#define SAIGE_SET_POLYGON_SCORE_THRESHOLD 0x20000
#define SAIGE_SET_TEXT_SIZE_RANGE 0x40000
#define SAIGE_SET_NUM_OF_TEXT_OBJECTS 0x80000
#define SAIGE_SET_TEXT_SCORE_THRESHOLD 0x100000
#define SAIGE_SET_TEXT_FORMATTING 0x200000
SAIGE_VISION_API int SaigeSetInferenceOption(SaigeInferenceHandle handle,
                                             SaigeInferenceOption* option,
                                             const unsigned int flags);
SAIGE_VISION_API int SaigeGetInferenceOption(SaigeInferenceHandle handle,
                                             SaigeInferenceOption* option);

// Inference Functions
#define SAIGE_IMAGE_COLOR 0x01
#define SAIGE_IMAGE_16BIT 0x02
#define SAIGE_IMAGE_ALPHA 0x04
#define SAIGE_IMAGE_BGR 0x08
#define SAIGE_IMAGE_8BIT_GRAY 0x00
#define SAIGE_IMAGE_24BIT_RGB (SAIGE_IMAGE_COLOR)

#define SAIGE_IMAGE_24BIT_BGR (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_BGR)
#define SAIGE_IMAGE_32BIT_RGBA (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_ALPHA)
#define SAIGE_IMAGE_32BIT_BGRA (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_ALPHA | SAIGE_IMAGE_BGR)

#define SAIGE_IMAGE_16BIT_GRAY (SAIGE_IMAGE_16BIT)
#define SAIGE_IMAGE_48BIT_RGB (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_16BIT)
#define SAIGE_IMAGE_48BIT_BGR (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_16BIT | SAIGE_IMAGE_BGR)
#define SAIGE_IMAGE_64BIT_RGBA (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_16BIT | SAIGE_IMAGE_ALPHA)
#define SAIGE_IMAGE_64BIT_BGRA \
    (SAIGE_IMAGE_COLOR | SAIGE_IMAGE_16BIT | SAIGE_IMAGE_ALPHA | SAIGE_IMAGE_BGR)

SAIGE_VISION_API int SaigeInferFromImageFile(SaigeInferenceHandle handle, const char* imagePath,
                                             SaigeInferenceResult result);
SAIGE_VISION_API int SaigeInferFromByteArray(SaigeInferenceHandle handle,
                                             const unsigned char* imageData, const int width,
                                             const int height, const unsigned int flags,
                                             SaigeInferenceResult result);

SAIGE_VISION_API int SaigeInferFromByteArrayWithProductId(
    SaigeInferenceHandle handle, const unsigned char* imageData, const int width, const int height,
    const unsigned int flags, const char* productId, SaigeInferenceResult result);

// Batch Processing API
SAIGE_VISION_API int SaigeInferFromMultipleByteArray(
    SaigeInferenceHandle handle, const int numOfImages, const unsigned char** imageData,
    const int width, const int height, const unsigned int flags, SaigeInferenceResult* results);

// Multi-page Processing API
SAIGE_VISION_API int SaigeInferFromMultiPageByteArray(SaigeInferenceHandle handle,
                                                      const int numOfPages,
                                                      const unsigned char** imageData,
                                                      const int width, const int height,
                                                      const int* channels, const unsigned int flags,
                                                      SaigeInferenceResult result);
// Get Result APIs

// Classification
SAIGE_VISION_API int SaigeGetInferenceResultScore(SaigeInferenceResult result, float* scores,
                                                  bool includeAddScore);
SAIGE_VISION_API int SaigeGetInferenceResultClass(SaigeInferenceResult result, int* classIndex);

SAIGE_VISION_API int SaigeGetInferenceResultClassActivationMap(SaigeInferenceResult result,
                                                               unsigned char** classActivationMap);
// Detection
typedef struct {
    double center[2];
    double points[8];
    double width;
    double height;
    double angle;
} SaigeRotatedBox;

typedef struct {
    SaigeRotatedBox boundingBox;
    int score;
    int classIndex;
    unsigned int area;
} SaigeDetectedObject;

SAIGE_VISION_API int SaigeGetInferenceResultNumOfDetectedObjects(SaigeInferenceResult result,
                                                                 int* numOfObjects);
SAIGE_VISION_API int SaigeGetInferenceResultDetectedObjects(SaigeInferenceResult result,
                                                            SaigeDetectedObject* detectedObjects);
// Segmentation, Anomaly Detection
typedef struct {
    double center[2];
    double width;
    double height;
    double angle;
} SaigeEllipse;

typedef struct {
    SaigeRotatedBox boundingBox;
    SaigeRotatedBox boundingRotBox;
    SaigeEllipse fittedEllipse;

    unsigned int area;
    unsigned int classIndex;
    double score;

    int numOfContours;
    int* numOfPointsOnContour;
    int* pointsOnContour;
} SaigeSegmentedObject;

// Segmentation
SAIGE_VISION_API int SaigeGetInferenceResultNumOfSegmentedObjects(SaigeInferenceResult result,
                                                                  int* num);
SAIGE_VISION_API int SaigeGetInferenceResultSegmentedObjects(SaigeInferenceResult result,
                                                             SaigeSegmentedObject* segObjects);
SAIGE_VISION_API int SaigeGetInferenceResultMask(SaigeInferenceResult result, unsigned char** mask);
SAIGE_VISION_API int SaigeGetInferenceResultScoremapSEG(SaigeInferenceResult result,
                                                        unsigned char** scoremap);
SAIGE_VISION_API int SaigeGetInferenceResultIsOversized(SaigeInferenceResult result,
                                                        bool* isOversized);

// Anomaly Detection
SAIGE_VISION_API int SaigeGetInferenceResultAnomalyScores(SaigeInferenceResult result,
                                                          double* anomalyScore, double* minScore,
                                                          double* maxScore);
SAIGE_VISION_API int SaigeGetInferenceResultIsNg(SaigeInferenceResult result, bool* isNg);
SAIGE_VISION_API int SaigeGetInferenceResultScoremapIAD(SaigeInferenceResult result,
                                                        float** scoremap);
SAIGE_VISION_API int SaigeGetInferenceResultHeatmap(SaigeInferenceResult result, float** heatmap);
// OCR
typedef struct {
    int numOfPoints;
    double* points;
    double polygonScore;
    double textSize;
    double textScore;
    char* text;
    int textLength;
} SaigeTextObject;

SAIGE_VISION_API int SaigeGetInferenceResultNumOfTextObjects(SaigeInferenceResult result, int* num);
SAIGE_VISION_API int SaigeGetInferenceResultTextObjects(SaigeInferenceResult result,
                                                        SaigeTextObject* textObjects);

SAIGE_VISION_API int SaigeGetInferenceResultEnhancedImage(SaigeInferenceResult result,
                                                          unsigned char** image);

// Common
SAIGE_VISION_API int SaigeGetInferenceResultInspectionTime(SaigeInferenceResult result,
                                                           long long* imreadTime,
                                                           long long* inferenceTime,
                                                           long long* postProcessingTime);
SAIGE_VISION_API int SaigeGetInferenceResultProductId(SaigeInferenceResult result,
                                                      const char** productId, unsigned int* length);
// Error Handling & Error Message
SAIGE_VISION_API const char* SaigeStrError(const int errnum);

SAIGE_VISION_API const char* SaigeGetModuleVersion();
// Set Monitoring Information

SAIGE_VISION_API int SaigeSetHandleMetadata(SaigeInferenceHandle handle, const char* key,
                                            const char* value);
SAIGE_VISION_API int SaigeSetInferenceMetadata(SaigeInferenceResult result, const char* key,
                                               const char* value);

SAIGE_VISION_API int SaigeSetResultMetadata(SaigeInferenceResult result, const char* key,
                                            const char* value);

SAIGE_VISION_API int SaigeInitializeAlignModule(const int gpuIndex, const int sourceWidth,
                                                const int sourceHeight, const int targetWidth,
                                                const int targetHeight);
SAIGE_VISION_API int SaigeFinalizeAlignModule();
SAIGE_VISION_API int SaigeAlignImageFromByteArray(const unsigned char* sourceImage,
                                                  const int sourceWidth, const int sourceHeight,
                                                  const int sourceChannel,
                                                  const unsigned char* targetImage,
                                                  const int targetWidht, const int targetHeight,
                                                  const int targetChannel, unsigned int flag,
                                                  unsigned char* croppedSourceImage);
SAIGE_VISION_API int SaigeAlignImageFromFile(const char* sourceImagePath,
                                             const char* targetImagePath, int* cropWidth,
                                             int* cropHeight, int* cropChannel,
                                             unsigned char* croppedSourceImage);


#endif  // SAIGE_VISION_WRAPPER_SAIGE_VISION_API_H_