SegmentationTestDLL.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __linux__
    #define DLLTYPE_SEGMENTATION
#elif _WIN32
    #ifdef DLLEXPORT_SEGMENTATION
    #define DLLTYPE_SEGMENTATION extern "C" __declspec(dllexport)
    #else
    #define DLLTYPE_SEGMENTATION extern "C" __declspec(dllimport)
    #endif
#endif
 
#include "CommonHeaderDLL.h"
 
typedef enum
{
    SR_ONE_CLASS_MATRIX_OUTPUT = 0,         
    SR_MULTI_CLASS_MATRIX_OUTPUT = 1,       
    SR_ONE_CLASS_CV_CONTOUR_OUTPUT = 2,     
    SR_MULTI_CLASS_CV_CONTOUR_OUTPUT = 3,   
    SR_MULTI_CLASS_HEATMAP_OUTPUT = 4,
    SR_MULTI_CLASS_ARRAY_OUTPUT = 5,        
} eSegTestOutputType;
 
typedef void* SegTestHandle;
typedef void* SegTestResult;
 
DLLTYPE_SEGMENTATION SegTestHandle  SR_CreateSegTestHandle(const char* filePath);
 
DLLTYPE_SEGMENTATION SegTestHandle  SR_CreateSegTestHandleByWideCharPath(const wchar_t* filePath);
 
DLLTYPE_SEGMENTATION SegTestResult  SR_MakeSegTestResult();
DLLTYPE_SEGMENTATION eErrorType     SR_LoadSegTestNetworkInGPU(SegTestHandle handle, 
                                                                int GPUNumber,
                                                                int batchSize = 1);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestAlgorithmType(SegTestHandle handle, 
                                                               eAlgorithmType* algoType);
 
DLLTYPE_SEGMENTATION eErrorType     SR_PrintSegTestParametersWithoutBG(SegTestHandle handle);
 
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfClassesWithoutBG(SegTestHandle handle, 
                                                                            int* numberOfClasses);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMaxStrLenOfClassName(SegTestHandle handle,
                                                                      int* len);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassNameWithWideCharByIdxWithoutBG(SegTestHandle handle, 
                                                                                        const int classIdx, 
                                                                                        wchar_t* className);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassNameWithMultiByteCharByIdxWithoutBG(SegTestHandle handle, 
                                                                                             const int classIdx,
                                                                                             char* className);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassColorByIdxWithoutBG(SegTestHandle handle, 
                                                                             const int classIdx,
                                                                             int* classColor);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMinScoreThresholdWithoutBG(SegTestHandle handle, 
                                                                            int* scoreThreshold);
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMinScoreThresholdWithoutBG(SegTestHandle handle, 
                                                                            int numOfClasses,
                                                                            int* scoreThreshold,
                                                                            bool writeOnModelFile = true);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMinPixelSizeThresholdWithoutBG(SegTestHandle handle, 
                                                                                int* areaThreshold);
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMinPixelSizeThresholdWithoutBG(SegTestHandle handle,
                                                                                int numOfClasses,
                                                                                int* areaThreshold,
                                                                                bool writeOnModelFile = true);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestModeOfFilteringByPixelSize(SegTestHandle handle,
                                                                            eModeOfPixelSizeFilter* modeOfFiltering);
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestModeOfFilteringByPixelSize(SegTestHandle handle,
                                                                            eModeOfPixelSizeFilter modeOfFiltering,
                                                                            bool writeOnModelFile = true);
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMaxGPUMemorySizeInByte(SegTestHandle handle,
    unsigned long long maxGPUMemorySizeInByte);
 
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMaxInspectionSize(SegTestHandle handle,
    int maxInspectionHeight,
    int maxInspectionWidth,
    bool writeOnModelFile = true);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMaxInspectionSize(SegTestHandle handle,
    int* maxInspectionHeight,
    int* maxInspectionWidth);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestForwardTimeLimit(SegTestHandle handle,
                                                                 float* forwardTimeLimit); /* milliseconds */
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestIsToUseForwardTimeLimit(SegTestHandle handle, 
                                                                         bool* bIsToUseForwardTimeLimit);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestForwardTimeLimitVariables(SegTestHandle handle, 
                                                                           float* forwardTimeLimit,  /* milliseconds */
                                                                           bool* bIsToUseForwardTimeLimit);
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestForwardTimeLimit(SegTestHandle handle,  
                                                                  float forwardTimeLimit,  /* milliseconds */
                                                                  bool writeOnModelFile = true); 
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestIsToUseForwardTimeLimit(SegTestHandle handle,
                                                                         bool bIsToUseForwardTimeLimit,
                                                                         bool writeOnModelFile = true); 
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestForwardTimeLimitVariables(SegTestHandle handle, 
                                                                           float forwardTimeLimit, /* milliseconds */
                                                                           bool bIsToUseForwardTimeLimit,
                                                                           bool writeOnModelFile = true);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestCropParamsUsedForExportingResults(SegTestHandle handle,
                                                                                    int* cropHeight,
                                                                                    int* cropWidth,
                                                                                    eModeOfCropLargeObjects* mode,
                                                                                    float* margin);
 
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestIsToStoreCroppedImage(SegTestHandle handle,
                                                                        bool isToStoreCroppedImage,
                                                                        int defaultCropSize,
                                                                        eModeOfCropLargeObjects modeOfCropLargeObjects = SR_CROP_BY_OBJECTSIZE_N_RESIZE_TO_CROPSIZE, 
                                                                        float margin = 0.05,
                                                                        bool writeOnModelFile = true);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestIsToStoreCroppedImage(SegTestHandle handle,
                                                                        bool* isToStoreCroppedImage,
                                                                        int* defaultCropSize,
                                                                        eModeOfCropLargeObjects* modeOfCropLargeObjects,
                                                                        float* margin);
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestIsToCalcObjectScores(SegTestHandle handle,
                                                                     bool isToCalcObjectScores,
                                                                     bool writeOnModelFile = true);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestIsToCalcObjectScores(SegTestHandle handle,
                                                                        bool* isToCalcObjectScores);
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestIsToCalcAverageColor(SegTestHandle handle,
                                                                     bool isToCalcAverageColors,
                                                                     bool writeOnModelFile = true);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestIsToCalcAverageColor(SegTestHandle handle,
                                                                        bool* isToCalcAverageColors);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfPages(SegTestHandle handle,
                                                                int* numberOfPages);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMaxStrLenOfPageName(SegTestHandle handle,
                                                                    int* len);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOnePageNameWithWideChar(SegTestHandle handle,
                                                                        const int pageIdx,
                                                                        wchar_t* pageName);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOnePageNameWithMultiByteChar(SegTestHandle handle,
                                                                            const int pageIdx,
                                                                            char* pageName);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromImageFile(SegTestHandle handle,
                                                                const char* imagePath, 
                                                                SegTestResult segTestResult, 
                                                                int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromImageFileByWideCharPath(SegTestHandle handle, 
                                                                                const wchar_t* imagePath, 
                                                                                SegTestResult segTestResult, 
                                                                                int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFrom8bitCharGrayArray(SegTestHandle handle, 
                                                                        const unsigned char* imageData, 
                                                                        const int height, 
                                                                        const int width, 
                                                                        SegTestResult segTestResult, 
                                                                        int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFrom8bitCharColorArray(SegTestHandle handle, 
                                                                            const unsigned char* imageData, 
                                                                            const int height, 
                                                                            const int width, 
                                                                            SegTestResult segTestResult, 
                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromUnsignedIntColorArray(SegTestHandle handle, 
                                                                            const unsigned int* imageData,
                                                                            const int height, 
                                                                            const int width, 
                                                                            SegTestResult segTestResult, 
                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFrom16bitCharGrayArray(SegTestHandle handle,
                                                                            const unsigned char* imageData,
                                                                            const int height,
                                                                            const int width,
                                                                            SegTestResult segTestResult,
                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFrom16bitCharColorArray(SegTestHandle handle, 
                                                                            const unsigned char* imageData, 
                                                                            const int height, 
                                                                            const int width, 
                                                                            SegTestResult segTestResult, 
                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFrom16bitUnsignedIntColorArray(SegTestHandle handle, 
                                                                            const unsigned int* imageData,
                                                                            const int height, 
                                                                            const int width, 
                                                                            SegTestResult segTestResult, 
                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultiple8bitCharGrayArrays(SegTestHandle handle,
                                                                                    int numberOfImages,
                                                                                    unsigned char** imageData,
                                                                                    int* heights,
                                                                                    int* widths,
                                                                                    SegTestResult* segTestResults,
                                                                                    int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultiple8bitCharColorArrays(SegTestHandle handle,
                                                                                    int numberOfImages,
                                                                                    unsigned char** imageData,
                                                                                    int* heights,
                                                                                    int* widths,
                                                                                    SegTestResult* segTestResults,
                                                                                    int flag);
 
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultipleUnsignedIntColorArrays(SegTestHandle handle,
                                                                                        int numberOfImages,
                                                                                        unsigned int** imageData,
                                                                                        int* heights,
                                                                                        int* widths,
                                                                                        SegTestResult* segTestResults,
                                                                                        int flag);
 
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultiPage8bitCharArrays(SegTestHandle handle,
                                                                                int numOfPages,
                                                                                unsigned char** imageData,
                                                                                int height,
                                                                                int width,
                                                                                int* channels,
                                                                                SegTestResult segTestResult,
                                                                                int flag);
 
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultiPageImageFileByWideCharPath(SegTestHandle handle,
                                                                                        int numOfPages,
                                                                                        const wchar_t** imagePaths,
                                                                                        SegTestResult segTestResult,
                                                                                        int flag);
 
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromMultiPageImageFileByMultiByteCharPath(SegTestHandle handle,
                                                                                            int numOfPages,
                                                                                            const char** imagePaths,
                                                                                            SegTestResult segTestResult,
                                                                                            int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_ApplySegTestFromDetectedBoxes(SegTestHandle handle,
                                                                    int numberOfBoxes,
                                                                    SR_DetectedBox* detectedBoxes,
                                                                    SegTestResult* segTestResults, 
                                                                    int flag);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOutputMatrixSizeInfo(SegTestResult segTestResult,
                                                                        int* scoreMatrixChannel,
                                                                        int* scoreMatrixSize);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOutputMatrix(SegTestResult segTestResult, 
                                                                int scoreMatrixSize,
                                                                unsigned char* scoreMatrixData);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestROI(SegTestResult segTestResult,
                                                    int* xROI, int* yROI, int* wROI, int* hROI);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfSegmentedObjects(SegTestResult segTestResult,
                                                                            int* numberOfSegmentedObjects);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestSegmentedObjects(SegTestResult segTestResult,
                                                                  SR_SegmentedObject* segmentedObjects);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfDeletedObjects(SegTestResult segTestResult,
                                                                        int* numberOfDeletedObjects);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestDeletedObjects(SegTestResult segTestResult,
                                                                SR_SegmentedObject* deletedObjects);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestResultOriginalImageSize(SegTestResult segTestResult,
                                                                        int* width, 
                                                                        int* height);
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestInspectionTime(SegTestResult segTestResult, 
                                                                long* inspectionTimeInLong); /* milliseconds */
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestInspectionTimeInDouble(SegTestResult segTestResult,
                                                                double* inspectionTimeInDouble); /* milliseconds */
 
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestLoadImageTime(SegTestResult segTestResult,
                                                                long* imageLoadingTimeInLong); /* milliseconds */
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestLoadImageTimeInDouble(SegTestResult segTestResult,
                                                                        double* imageLoadingTimeInDouble); /* milliseconds */
DLLTYPE_SEGMENTATION eErrorType     SR_DestroySegTestHandle(SegTestHandle handle);
 
DLLTYPE_SEGMENTATION eErrorType     SR_DeleteSegTestResult(SegTestResult segTestResult);
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestOptionsAsDefault(SegTestHandle handle);
 
DLLTYPE_SEGMENTATION eErrorType     SR_WriteSegTestOptionsOnModelFile(SegTestHandle handle);
 
/***********************************************************
* For SaigeVision software
***********************************************************/
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestOutputMode(SegTestHandle handle, int outputMode, bool writeOnModel);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOutputMode(SegTestHandle handle, int* outputMode);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestResultArraySize(SegTestResult segTestResult, int* arraySize);
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestResultPixelArray(SegTestResult segTestResult, int arraySize, int* indexArray, unsigned char* valueArray);
 
 
#ifdef SR_USE_DEPRECATED_FUNCTIONS
/***********************************************************************************************************************
*   These Functions are provided for users who started using Saige Vision API before v1.2.0
*   which cares the background class for some reasons.
*   We recommed to change these functions to above functions with "WithoutBG".
*
*   아래 함수들은 세이지 비젼 API를 v1.2.0 이전부터 사용해오던 유저를 위하여 제공됩니다.
*   v1.2.0이전에는 Saige Vision UI와 달리 API에서는 Background를 포함시켰었기 때문에 이와 같은 함수들을 제공합니다.
*   하지만 background를 고려하지 않는 WithoutBG 함수들로 교체하는 것을 권장합니다.
***********************************************************************************************************************/
/* Print a model parameters including background (class name, class colors, score threshold...)*/
DLLTYPE_SEGMENTATION eErrorType     SR_PrintSegTestParametersWithBG(SegTestHandle handle);
 
/* Get the number of classes including background*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfClassesWithBG(SegTestHandle handle, int* numberOfClasses);
 
/* Get a wide char name of certain class by given index including background*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassNameWithWideCharByIdxWithBG(SegTestHandle handle, const int index, wchar_t* className);
 
/* Get a multi byte char name of certain class by given index including background*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassNameWithMultiByteCharByIdxWithBG(SegTestHandle handle, const int index, char* className);
 
/* Get a color of certain class by given index including background*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassColorByIdxWithBG(SegTestHandle handle, const int index, int* classColor);
 
/* Get minimum score thresholds for each class except for background*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMinScoreThresholdWithBG(SegTestHandle handle, int* scoreThreshold);
 
/* Set minimum score thresholds for each class except for background*/
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMinScoreThresholdWithBG(SegTestHandle handle, int numberOfClasses, int* scoreThreshold);
 
/* This function behaves identically with SR_PrintSegTestParametersWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_PrintSegTestParameters(SegTestHandle handle);
 
/* This function behaves identically with SR_GetSegTestNumberOfClassesWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestNumberOfClasses(SegTestHandle handle, int* numberOfClasses);
 
/* This function behaves identically with SR_GetSegTestOneClassNameWithWideCharByIdxWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassName(SegTestHandle handle, const int index, wchar_t* className);
 
/* This function behaves identically with SR_GetSegTestOneClassNameWithMultiByteCharByIdxWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassNameWith1byteCharacter(SegTestHandle handle, const int index, char* className);
 
/* This function behaves identically with SR_GetSegTestOneClassColorByIdxWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestOneClassColor(SegTestHandle handle, const int index, int* classColor);
 
/* This function behaves identically with SR_GetSegTestMinScoreThresholdWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestEachClassThreshold(SegTestHandle handle, int* threshold);
 
/* This function behaves identically with SR_SetSegTestMinScoreThresholdWithBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestEachClassThreshold(SegTestHandle handle, int* threshold);
 
/* This function behaves identically with SR_GetSegTestMinPixelSizeThresholdWithoutBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_GetSegTestMinimumPixelSizeThreshold(SegTestHandle handle, int* minimumPixelSizeThreshold);
 
/* This function behaves identically with SR_SetSegTestMinPixelSizeThresholdWithoutBG*/
DLLTYPE_SEGMENTATION eErrorType     SR_SetSegTestMinimumPixelSizeThreshold(SegTestHandle handle, int* minimumPixelSizeThreshold);
#endif