ExampleSegPostProcess.cpp

This is an example of how to post-process after seg module. More details about this example.

 
#include "SegmentationTestDLL.h"
#include "SegPostProcessFunctionsDLL.h"
#include "SRUtils.h"
#include <algorithm>
#include <numeric>
 
/* define this variable when user want to use new score threshold other than preset values. */
//#define SR_USE_NEW_SCORE_THRESHOLD 
 
/* define this variable when user want to use new pixel size threshold other than preset values. */
//#define SR_USE_NEW_PIXEL_SIZE_THRESHOLD 
 
/* define this variable when user want filter contours smaller than a threshold of pixel size by calculating appoximate contour sizes.*/
#define SR_FILTER_OBJECTS_BY_APPROXIMATE_SIZE 
 
/* define this variable when user want filter contours smaller than a threshold of pixel size by calculating appoximate contour sizes.*/
//#define SR_FILTER_OBJECTS_BY_EXACT_SIZE 
 
/* define this variable when user want to get cropped image of segmented objects.*/
//#define SR_CROP_AND_STORE_SEGMENTED_OBJECT 
 
/* define this variable when user want to get scores(average, min, max) of semgmented objects.*/
//#define SR_GET_SCORES_OF_SEGMENTED_OBJECT
 
/* define this variable when user want to get average color(in BGR order) of semgmented objects.*/
//#define SR_GET_AVERAGE_COLOR_OF_SEGMENTED_OBJECT
 
/* define this variable when user want to limit the forward time of classfication algorithm. */
//#define SR_USE_FORWARD_TIME_LIMIT
 
std::vector<cv::Scalar> colorsForSkeleton{
    cv::Scalar(255, 0, 0),
    cv::Scalar(0, 0, 255),
    cv::Scalar(0, 255, 0),
    cv::Scalar(255, 0, 255),
    cv::Scalar(0, 255, 255),
    cv::Scalar(255, 255, 0)
};
 
int main()
{
    std::wstring data_dir = L"../../../examples/data";
 
    // trained model path
    std::wstring trainedModelPath = data_dir + L"/models/stackcell_sample.srSeg";
 
    // image paths to classify
    std::vector<std::wstring> imagePaths(1);
    imagePaths[0] = data_dir + L"/images/StackCell/sample.png";
 
 
    eErrorType srStatus = eErrorType::NO_ERROR_OUT;
 
    /***********************************************************
    *    0. 이미지 인풋 타입 설정
    *    inputImageType -
    *             ImageFilePathMultiByteChar:   from file path (multi byte char)
    *             ImageFilePathWideChar: from file path (wide char)
    *             UCGrayImage:  from memory(8bit unsigned char gray image)
    *             UCColorImage: from memory(8bit unsigned char color image)
    *             UIColorImage: from memory(32bit unsigned int color image)
    *             UCGrayImage16Bit: from memory(16bit unsigned char gray image)
    *             UCColorImage16Bit: from memory(16bit unsigned char color image)
    *             UIColorImage16Bit: from memory(64bit-16bit * 4channels- unsigned int color image)
    ***********************************************************/
    //eSRInputImageType inputImageType = eSRInputImageType::ImageFilePathMultiByteChar;
    //eSRInputImageType inputImageType = eSRInputImageType::ImageFilePathWideChar;
    eSRInputImageType inputImageType = eSRInputImageType::ImageFilePathWideChar;
    //eSRInputImageType inputImageType = eSRInputImageType::UCColorImage;
    //eSRInputImageType inputImageType = eSRInputImageType::UIColorImage;
    //eSRInputImageType inputImageType = eSRInputImageType::UCGrayImage16Bit;
    //eSRInputImageType inputImageType = eSRInputImageType::UCColorImage16Bit;
    //eSRInputImageType inputImageType = eSRInputImageType::UIColorImage16Bit;
 
    unsigned char* ucImageData = nullptr; // unsigned char image data
    unsigned int*  uiImageData = nullptr; // unsigned int image data
 
    /***********************************************************
    *    0-1. 정보 띄우기 단계 설정 (Verbosity)
    *    verbosity -
    *             0:    only warning
    *             1:    warning + model info
    *             2:    warning + model info + result info
    *             3:    warning + model info + result info + image display
    *    overlayAlpha - display 이미지 = 원본 이미지 * overlayAlpha + segmentation 라벨 * (1 - overlayAlpha)
    *    displayTime - 결과 이미지 display 하는 시간 (milliseconds)
    *    resizeFactor - 결과 이미지 display 하는 스케일 (display 크기 = 원본 크기 * resizeFactor)
    ***********************************************************/
    int verbosity = 3;
    double overlayAlpha = 0.7;
    int displayTime = 100;
    double resizeFactor = 0.5;
 
    /***********************************************************
    *    0-2. GPU 번호 설정
    *    gpuIndex - 사용하고자 하는 gpu의 번호
    *       Multi GPU 가 가능한 License의 경우에 한하여 gpuIndex를
    *       0~3까지 설정해 줄 수 있다. 아닌 경우 gpuIndex는 0을 사용하여야 한다.
    ***********************************************************/
    int gpuIndex = 0;
 
    /***********************************************************
    *    0-3. Segmentation 검사 방법 설정
    ***********************************************************/
    int outputMode = SR_MULTI_CLASS_CV_CONTOUR_OUTPUT;
 
    /***********************************************************
    *    1.  모델 파일 및 검사 결과 handle 생성,
    *        Create handles for model files and inspection results
    ***********************************************************/
    SegTestHandle handle = SR_CreateSegTestHandleByWideCharPath(trainedModelPath.c_str());
    if (handle == nullptr)
    {
        std::wcout << "Saige Vision failed: Please check the file path of trained model." << std::endl;
    }
 
    SegTestResult segTestResult = SR_MakeSegTestResult();
 
 
    /***********************************************************
    *    2. 클래스 정보 확인 (Optional)
    *       Check class information
    ***********************************************************/
    // Print segmentation Test Parameters() by calling one fuctions
    srStatus = SR_PrintSegTestParametersWithoutBG(handle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
    int numberOfClassesOutput = 0;
    int maxStrLenOfClassName = 0;
 
    // Get the number of classes
    srStatus = SR_GetSegTestNumberOfClassesWithoutBG(handle, &numberOfClassesOutput);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
    // Get the maximum length of class names
    srStatus = SR_GetSegTestMaxStrLenOfClassName(handle, &maxStrLenOfClassName);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
    std::vector<std::string> classNames(numberOfClassesOutput);
    std::vector<std::wstring> wClassNames(numberOfClassesOutput);
    std::vector<int> classColorsOutput(numberOfClassesOutput);
 
    char* classNameOutput = new char[maxStrLenOfClassName];
    wchar_t* wClassNameOutput = new wchar_t[maxStrLenOfClassName];
 
    for (int i = 0; i < numberOfClassesOutput; i++)
    {
        // Get a color of single class
        srStatus = SR_GetSegTestOneClassColorByIdxWithoutBG(handle, i, &(classColorsOutput[i]));
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input index is out of bound(# of classes) or input pointer is not allocated (nullptr).
            SR_DestroySegTestHandle(handle);
            return -1;
        }
 
        // Get a name of single class by multi byte char (char*)
        srStatus = SR_GetSegTestOneClassNameWithMultiByteCharByIdxWithoutBG(handle, i, classNameOutput);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input index is out of bound(# of classes) or input pointer is not allocated (nullptr).
            SR_DestroySegTestHandle(handle);
            return -1;
        }
 
        // Get a name of single class by wide char (wchar_t*)
        srStatus = SR_GetSegTestOneClassNameWithWideCharByIdxWithoutBG(handle, i, wClassNameOutput);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input index is out of bound(# of classes) or input pointer is not allocated (nullptr).
            SR_DestroySegTestHandle(handle);
            return -1;
        }
        classNames[i] = classNameOutput;
        wClassNames[i] = wClassNameOutput;
    }
 
    delete[] classNameOutput;
    delete[] wClassNameOutput;
 
    /***********************************************************
    *    3. 검사 옵션 확인 및 수정 (Optional)
    *       Check inspection options and set new values
    ***********************************************************/
    /*
    학습에서 사용한 이미지 크기와 검사에서 사용하는 이미지 크기가 다를 경우 아래 함수를 호출하여
    검사 이미지 사이즈에 맞게 최대 검사 사이즈를 설정하여야 합니다.
    최대 검사 사이즈 보다 큰 이미지가 들어올 경우 최대 검사 사이즈로 리사이즈된 후 검사됩니다.
    단 이 함수는 SR_LoadSegTestNetworkInGPU 함수를 호출하기 전 호출되어야 합니다.
    SR_GetSegTestMaxInspectionSize 함수를 통해 현재 설정되어 있는 최대 검사 사이즈를 확인할 수 있습니다.
    */
    /*
    srStatus = SR_SetSegTestMaxInspectionSize(SegTestHandle handle, int maxInspectionHeight, int maxInspectionWidth, bool writeOnModel);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that SR_LoadSegTestNetwork is already called.
        SR_DestroySegTestHandle(handle);
        return -1;
    }*/
 
    std::vector<int> scoreThresholdOutput(numberOfClassesOutput);
    std::vector<int> pixelSizeThresholdOutput(numberOfClassesOutput);
 
    // Get the score threshold for each class
    srStatus = SR_GetSegTestMinScoreThresholdWithoutBG(handle, scoreThresholdOutput.data());
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
    // Get the area threshold for each class
    srStatus = SR_GetSegTestMinPixelSizeThresholdWithoutBG(handle, pixelSizeThresholdOutput.data());
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
# ifdef SR_USE_NEW_SCORE_THRESHOLD
    std::vector<int> scoreThreshold(numberOfClassesOutput);
 
    for (int i = 0; i < numberOfClassesOutput; i++)
    {
        scoreThreshold[i] = 100; // Set the new score threshold for each class
    }
    srStatus = SR_SetSegTestMinScoreThresholdWithoutBG(handle, numberOfClassesOutput, scoreThreshold.data(), true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
# ifdef SR_USE_NEW_PIXEL_SIZE_THRESHOLD
    std::vector<int> pixelSizeThreshold(numberOfClassesOutput);
 
    for (int i = 0; i < numberOfClassesOutput; i++)
    {
        pixelSizeThreshold[i] = 200; // Set the new pixel-size threshold for each class
    }
    srStatus = SR_SetSegTestMinPixelSizeThresholdWithoutBG(handle, numberOfClassesOutput, pixelSizeThreshold.data(), true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the input pointer is not allocated (nullptr).
        SR_DestroySegTestHandle(handle);
        return -1;
    }
    pixelSizeThresholdOutput = pixelSizeThreshold;
#endif
 
#if (!defined(SR_FILTER_OBJECTS_BY_EXACT_SIZE)) && (!defined(SR_FILTER_OBJECTS_BY_APPROXIMATE_SIZE))
    srStatus = SR_SetSegTestModeOfFilteringByPixelSize(handle, eModeOfPixelSizeFilter::SR_PIXELSIZE_FILTER_MODE_OFF, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created or filter mode is not appropriate.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_FILTER_OBJECTS_BY_EXACT_SIZE
    // "SaigeVision Error: CANNOT USE FILTERING FUNCTION IN CURRENT OUTPUT MODE"
    assert(outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT || outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT);
    srStatus = SR_SetSegTestModeOfFilteringByPixelSize(handle, eModeOfPixelSizeFilter::SR_PIXELSIZE_FILTER_MODE_ON_EXACT, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created or filter mode is not appropriate.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_FILTER_OBJECTS_BY_APPROXIMATE_SIZE
    // "SaigeVision Error: CANNOT USE FILTERING FUNCTION IN CURRENT OUTPUT MODE"
    assert(outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT || outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT);
    srStatus = SR_SetSegTestModeOfFilteringByPixelSize(handle, eModeOfPixelSizeFilter::SR_PIXELSIZE_FILTER_MODE_ON_FAST, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created or filter mode is not appropriate.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_CROP_AND_STORE_SEGMENTED_OBJECT
    srStatus = SR_SetSegTestIsToStoreCroppedImage(handle, true, 1, eModeOfCropLargeObjects::SR_CROP_BY_OBJECTSIZE, 0.0f, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_GET_SCORES_OF_SEGMENTED_OBJECT
    srStatus = SR_SetSegTestIsToCalcObjectScores(handle, true, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_GET_AVERAGE_COLOR_OF_SEGMENTED_OBJECT
    srStatus = SR_SetSegTestIsToCalcAverageColor(handle, true, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
#ifdef SR_USE_FORWARD_TIME_LIMIT
    float timeLimit = 1000; // milliseconds
    srStatus = SR_SetSegTestForwardTimeLimitVariables(handle, timeLimit, true, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
#ifndef SR_USE_FORWARD_TIME_LIMIT
    srStatus = SR_SetSegTestIsToUseForwardTimeLimit(handle, false, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
#endif
 
    /***********************************************************
    *    3-1. 검사 후 후처리 파라미터 설정 및 handle 생성
    *       Check post process options and create handle
    ***********************************************************/
    SR_SegPostProcessOptions segPostProcessOptions;
    segPostProcessOptions.nProducts = 3;
    segPostProcessOptions.nTargetTopsPerProduct = 26;
    segPostProcessOptions.nTargetBottomsPerProduct = 25;
    segPostProcessOptions.topClassIdx = 0;
    segPostProcessOptions.bottomClassIdx = 1;
    segPostProcessOptions.convexityDefectThreshold = 30;
 
    segPostProcessOptions.useImageDataAtTop = true;
    segPostProcessOptions.isTopBrighterThanBackGround = true;   
    segPostProcessOptions.useImageDataAtBottom = true;
    segPostProcessOptions.isBottomBrighterThanBackGround = true;
 
    segPostProcessOptions.maxLengthOfSkeletonToRemoveAtTop = 5.0f;
    segPostProcessOptions.maxRatioThresholdOfMedianLengthToRemoveAtTop = 0.5f;
    segPostProcessOptions.minLengthOfSkeletonToKeepAtTop = 50.0f;
 
    segPostProcessOptions.maxLengthOfSkeletonToRemoveAtBottom = 10.0f;
    segPostProcessOptions.maxRatioThresholdOfMedianLengthToRemoveAtBottom = 0.5f;
    segPostProcessOptions.minLengthOfSkeletonToKeepAtBottom = 40.0f;
 
    SegPostProcessHandle segPostProcessHandle = SR_CreateSegPostProcessHandle(eSegPostProcessType::StackCell, segPostProcessOptions);
 
    /***********************************************************
    *    4. 메모리를 GPU 및 CPU에 할당합니다.
    *       Allocate GPU and CPU memory
    ***********************************************************/
    srStatus = SR_LoadSegTestNetworkInGPU(handle, gpuIndex);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the inserted index is not applicable.
        SR_DestroySegTestHandle(handle);
        return -1;
    }
 
    for (size_t i_img = 0; i_img < imagePaths.size(); i_img++)
    {
        int h = 0, w = 0;
        switch (inputImageType)
        {
        case eSRInputImageType::UCGrayImage:
        case eSRInputImageType::UCColorImage:
        case eSRInputImageType::UCGrayImage16Bit:
        case eSRInputImageType::UCColorImage16Bit:
            ucImageData = (unsigned char*)GetImageDataByInputImageType(imagePaths[i_img], inputImageType, h, w);
            break;
        case eSRInputImageType::UIColorImage:
        case eSRInputImageType::UIColorImage16Bit:
            uiImageData = (unsigned int*)GetImageDataByInputImageType(imagePaths[i_img], inputImageType, h, w);
            break;
        }
 
        /***********************************************************
        *    5. 이미지 검사하기, Inspect images
        ***********************************************************/
        if (inputImageType == eSRInputImageType::ImageFilePathMultiByteChar)
        {
            // Check if given image path(UNICODE) can be converted to ASCII CODE without any loss.
            size_t sizeOfChar = 0;
            size_t sizeOfWChar = wcslen(imagePaths[i_img].c_str());
            size_t bufferSize = sizeOfWChar * 2;
            std::vector<char> imagePathMB(bufferSize);
 
            sizeOfChar = wcstombs(
                imagePathMB.data(),
                imagePaths[i_img].c_str(),
                bufferSize
            );
 
            if (sizeOfChar != sizeOfWChar)
            {
                std::wcout << "Saige Vision FAILED: Wrong Image path" << imagePaths[i_img] << std::endl;
                continue;
            }
            srStatus = SR_ApplySegTestFromImageFile(handle, imagePathMB.data(), segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::ImageFilePathWideChar)
        {
            srStatus = SR_ApplySegTestFromImageFileByWideCharPath(handle, imagePaths[i_img].c_str(), segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage)
        {
            srStatus = SR_ApplySegTestFrom8bitCharGrayArray(handle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage)
        {
            srStatus = SR_ApplySegTestFrom8bitCharColorArray(handle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage)
        {
            srStatus = SR_ApplySegTestFromUnsignedIntColorArray(handle, uiImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage16Bit)
        {
            srStatus = SR_ApplySegTestFrom16bitCharGrayArray(handle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage16Bit)
        {
            srStatus = SR_ApplySegTestFrom16bitCharColorArray(handle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage16Bit)
        {
            srStatus = SR_ApplySegTestFrom16bitUnsignedIntColorArray(handle, uiImageData, h, w, segTestResult, outputMode);
        }
 
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input data is not loaded successfully.
            if (verbosity >= 3)
            {
                DisplayFailedImageOnCVWindow(imagePaths[i_img], "FAIL TO segment", "segmentation Result", displayTime, resizeFactor);
            }
            continue; // jump to next image
        }
 
        /***********************************************************
        *    6. 검사 결과 받아오기, Retrieve inspection results
        ***********************************************************/
        if (inputImageType == eSRInputImageType::ImageFilePathWideChar || inputImageType == eSRInputImageType::ImageFilePathMultiByteChar)
        {
            // Get dimension of input image to draw results later..
            srStatus = SR_GetSegTestResultOriginalImageSize(segTestResult, &w, &h);
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the input pointer is not allocated (nullptr).
                continue; // jump to next image
            }
        }
 
 
        long inspectionTimeOutput = 0, loadImageTimeOutput = 0;
        // Get the inspection time
        srStatus = SR_GetSegTestInspectionTime(segTestResult, &inspectionTimeOutput);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input pointer is not allocated (nullptr).
            continue; // jump to next image
        }
 
        // Get the image-loading time
        srStatus = SR_GetSegTestLoadImageTime(segTestResult, &loadImageTimeOutput);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input pointer is not allocated (nullptr).
            continue; // jump to next image
        }
 
 
        /* Getting output matrix is optional when output mode is SR_ONE_CLASS_CV_CONTOUR_OUTPUT or SR_MULTI_CLASS_CV_CONTOUR_OUTPUT.
        * Output matrix 를 가져오는 과정은 SR_ONE_CLASS_CV_CONTOUR_OUTPUT or SR_MULTI_CLASS_CV_CONTOUR_OUTPUT 두 모드일 경우 optional 입니다.
        */
        int matrixChannelOutput = 0, matrixSizeOutput = 0;
        std::vector<unsigned char> outputMatrix;
 
        if (outputMode == SR_ONE_CLASS_MATRIX_OUTPUT ||
            outputMode == SR_MULTI_CLASS_MATRIX_OUTPUT ||
            outputMode == SR_MULTI_CLASS_HEATMAP_OUTPUT)
        {
            // Get the dimension of output matrix
            srStatus = SR_GetSegTestOutputMatrixSizeInfo(segTestResult, &matrixChannelOutput, &matrixSizeOutput);
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the input pointer is not allocated (nullptr).
                continue; // jump to next image
            }
 
            outputMatrix.resize(matrixSizeOutput);
            // Get the data of output matrix (score matrix)
            srStatus = SR_GetSegTestOutputMatrix(segTestResult, matrixSizeOutput, outputMatrix.data());
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the input's size(matrixSizeOutput) does not match the result's or input pointer is not allocated (nullptr).
                continue; // jump to next image
            }
        }
 
        // Get Segmented objects
        // segmented object after filtering (# of classes x # of objects)
        std::vector<SR_SegmentedObject> segmentedObject;
 
        // deleted object after filtering (# of classes x # of objects)
        std::vector<SR_SegmentedObject> deletedObject;
 
        if (outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT || outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT)
        {
            int nSegmentedObjects = 0;
            srStatus = SR_GetSegTestNumberOfSegmentedObjects(segTestResult, &nSegmentedObjects);
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the segTestResult is not created (nullptr).
                continue; // jump to next image
            }
            segmentedObject.resize(nSegmentedObjects);
 
            srStatus = SR_GetSegTestSegmentedObjects(segTestResult, segmentedObject.data());
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the segTestResult is not created (nullptr).
                continue; // jump to next image
            }
 
            if (verbosity >= 2)
            {
                std::cout << "  - the number of segmented objects: " << segmentedObject.size() << std::endl;
                for (int i = 0; i < segmentedObject.size(); i++)
                {
                    std::cout << "  - " << i << "-th segmented objects : " <<
                        "class[" << segmentedObject[i].classIdx << "], " <<
                        "area[" << segmentedObject[i].area << "], " <<
                        "width[" << segmentedObject[i].width << "], " <<
                        "height[" << segmentedObject[i].height << "], " <<
                        "x_center[" << segmentedObject[i].xCenter << "], " <<
                        "y_center[" << segmentedObject[i].yCenter << "], " <<
                        "scores(average, min, max)[" << segmentedObject[i].scores[0] << ", "
                        << segmentedObject[i].scores[1] << ", "
                        << segmentedObject[i].scores[2] << "], "
                        "average_color(B, G, R)[" << segmentedObject[i].averageColor[0] << ", " <<
                        segmentedObject[i].averageColor[1] << ", " <<
                        segmentedObject[i].averageColor[2] << "]" << std::endl;
                }
            }
 
            // if user want to check the deleted objects by filtering, call this functions.
            int nDeletedObjects = 0;
            srStatus = SR_GetSegTestNumberOfDeletedObjects(segTestResult, &nDeletedObjects);
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the segTestResult is not created (nullptr).
                continue; // jump to next image
            }
 
            deletedObject.resize(nDeletedObjects);
            srStatus = SR_GetSegTestDeletedObjects(segTestResult, deletedObject.data());
            if (srStatus != NO_ERROR_OUT)
            {
                PrintErrorType(srStatus, verbosity);
                // if you get this error, it's possible that the segTestResult is not created (nullptr).
                continue; // jump to next image
            }
 
            if (verbosity >= 2)
            {
                std::cout << "  - the number of deleted objects: " << deletedObject.size() << std::endl;
            }
        }
 
        /***********************************************************
        *    7. 이미지 후처리 하기, Post-process images
        ***********************************************************/
        auto startPostProcess = std::chrono::system_clock::now();
 
        // SR_UseImageDataFrom~ : optional
        // SR_SegPostProcessOptions 의 useImageData 를 사용하는 경우에 설정해야 합니다.
        if (inputImageType == eSRInputImageType::ImageFilePathMultiByteChar)
        {
            // Check if given image path(UNICODE) can be converted to ASCII CODE without any loss.
            size_t sizeOfChar = 0;
            size_t sizeOfWChar = wcslen(imagePaths[i_img].c_str());
            size_t bufferSize = sizeOfWChar * 2;
            std::vector<char> imagePathMB(bufferSize);
 
            sizeOfChar = wcstombs(
                imagePathMB.data(),
                imagePaths[i_img].c_str(),
                bufferSize
            );
 
            if (sizeOfChar != sizeOfWChar)
            {
                std::wcout << "Saige Vision FAILED: Wrong Image path" << imagePaths[i_img] << std::endl;
                continue;
            }
            srStatus = SR_UseImageDataFromImageFile(segPostProcessHandle, imagePathMB.data());
        }
        else if (inputImageType == eSRInputImageType::ImageFilePathWideChar)
        {
            srStatus = SR_UseImageDataFromImageFileByWideCharPath(segPostProcessHandle, imagePaths[i_img].c_str());
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage)
        {
            srStatus = SR_UseImageDataFrom8bitCharGrayArray(segPostProcessHandle, ucImageData, h, w);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage)
        {
            srStatus = SR_UseImageDataFrom8bitCharColorArray(segPostProcessHandle, ucImageData, h, w);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage)
        {
            srStatus = SR_UseImageDataFromUnsignedIntColorArray(segPostProcessHandle, uiImageData, h, w);
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage16Bit)
        {
            srStatus = SR_UseImageDataFrom16bitCharGrayArray(segPostProcessHandle, ucImageData, h, w);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage16Bit)
        {
            srStatus = SR_UseImageDataFrom16bitCharColorArray(segPostProcessHandle, ucImageData, h, w);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage16Bit)
        {
            srStatus = SR_UseImageDataFrom16bitUnsignedIntColorArray(segPostProcessHandle, uiImageData, h, w);
        }
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the segTestResult is not created (nullptr).
            continue; // jump to next image
        }
 
        srStatus = SR_SegRunPostProcessByTestResultHandle(segPostProcessHandle, segTestResult);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input data is not loaded successfully.
            if (verbosity >= 3)
            {
                DisplayFailedImageOnCVWindow(imagePaths[i_img], "FAIL TO post-process", "segmentation Result", displayTime, resizeFactor);
            }
            continue; // jump to next image
        }
        auto durationPostProcess = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - startPostProcess);
 
        /***********************************************************
        *    8. 후처리 결과 받아오기, Retrieve post-processing results
        ***********************************************************/
        int nSegSkeletonsOutput = 0;
        srStatus = SR_SegPostProcessGetNumberOfSkeletons(segPostProcessHandle, &nSegSkeletonsOutput);
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the segPostProcessHandle is not created (nullptr).
            continue; // jump to next image
        }
 
        std::vector<SR_SegPostProcessSkeleton> segSkeletons(nSegSkeletonsOutput);
        srStatus = SR_SegPostProcessGetSkeletons(segPostProcessHandle, segSkeletons.data());
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the segPostProcessHandle is not created (nullptr).
            continue; // jump to next image
        }
 
        std::vector<int> topCounts;
        std::vector<int> bottomCounts;
        for (int i = 0; i < segPostProcessOptions.nProducts; i++)
        {
            auto top = std::count_if(segSkeletons.begin(), segSkeletons.end(),
                [i, segPostProcessOptions](SR_SegPostProcessSkeleton&a) {
                return a.idxClass == segPostProcessOptions.topClassIdx && a.idxProduct == i; });
            topCounts.push_back(top);
            auto bottom = std::count_if(segSkeletons.begin(), segSkeletons.end(),
                [i, segPostProcessOptions](SR_SegPostProcessSkeleton&a) {
                return a.idxClass == segPostProcessOptions.bottomClassIdx && a.idxProduct == i; });
            bottomCounts.push_back(bottom);
        }
 
        // Display time
        if (verbosity >= 2)
        {
            std::cout << "====== segmentation Test Result ======" << std::endl;
            std::wcout << imagePaths[i_img] << std::endl;
            std::cout << "  - Image width, height: " << w << ", " << h << std::endl;
            std::cout << "  - Image Loading time: " << loadImageTimeOutput << std::endl;
            std::cout << "  - Inspection time: " << inspectionTimeOutput << std::endl;
            std::cout << "  - Post-processing time: " << static_cast<double>(durationPostProcess.count()) << std::endl;
            std::cout << "    - top skeletons: " << std::accumulate(topCounts.begin(), topCounts.end(), 0) << " ( ";
            for (auto cnt : topCounts) {
                std::cout << cnt << " ";
            }
            std::cout << ")" << std::endl;
            std::cout << "    - bottom skeletons: " << std::accumulate(bottomCounts.begin(), bottomCounts.end(), 0) << " ( ";
            for (auto cnt : bottomCounts) {
                std::cout << cnt << " ";
            }
            std::cout << ")" << std::endl;
 
            std::cout << std::endl;
        }
 
        // Draw images
        if (verbosity >= 3)
        {
            cv::Mat image = cv::Mat();
 
            if (inputImageType == eSRInputImageType::UCGrayImage)
            {
                image = cv::Mat(h, w, CV_8UC1, ucImageData);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else if (inputImageType == eSRInputImageType::UCColorImage)
            {
                image = cv::Mat(h, w, CV_8UC3, ucImageData);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else if (inputImageType == eSRInputImageType::UIColorImage)
            {
                image = cv::Mat(h, w, CV_8UC4, uiImageData);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else if (inputImageType == eSRInputImageType::UCGrayImage16Bit)
            {
                image = cv::Mat(h, w, CV_16UC1, ucImageData);
                image.convertTo(image, CV_8U, 1.0 / 256.0);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else if (inputImageType == eSRInputImageType::UCColorImage16Bit)
            {
                image = cv::Mat(h, w, CV_16UC3, ucImageData);
                image.convertTo(image, CV_8U, 1.0 / 256.0);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else if (inputImageType == eSRInputImageType::UIColorImage16Bit)
            {
                image = cv::Mat(h, w, CV_16UC4, uiImageData);
                image.convertTo(image, CV_8U, 1.0 / 256.0);
                image = image.clone(); /* to prevent modifying raw data */
            }
            else
            {
                int isSuccess = OpenImageFile(imagePaths[i_img].c_str(), image);
                if (isSuccess == 0)
                {
                    std::cout << "Saige Vision FAILED: Fail to open image file to display" << std::endl;
                    continue;
                }
            }
 
            if (outputMode == SR_ONE_CLASS_MATRIX_OUTPUT || outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT)
            {
                if (image.channels() == 4)
                {
                    cv::cvtColor(image, image, cv::COLOR_BGRA2BGR);
                }
                cv::Mat imageCheck = image.clone();
                unsigned char* data = imageCheck.data;
 
                if (outputMode == SR_ONE_CLASS_MATRIX_OUTPUT)
                {
                    if (image.channels() == 1)
                    {
                        for (int i_pixel = 0; i_pixel < matrixSizeOutput; i_pixel++)
                        {
                            if (outputMatrix[i_pixel] > 0)
                            {
                                data[i_pixel] = outputMatrix[i_pixel];
                            }
                        }
                    }
                    else if (image.channels() == 3)
                    {
                        for (int i_pixel = 0; i_pixel < matrixSizeOutput; i_pixel++)
                        {
                            if (outputMatrix[i_pixel] > 0)
                            {
                                data[3 * i_pixel + 0] = 0;
                                data[3 * i_pixel + 1] = 0;
                                data[3 * i_pixel + 2] = outputMatrix[i_pixel];
                            }
                        }
                    }
                }
                else if (outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT)
                {
                    cv::Scalar whiteScalar = cv::Scalar(255.0);
 
                    if (image.channels() == 1)
                    {
                        whiteScalar = cv::Scalar(255.0);
                    }
                    else if (image.channels() == 3)
                    {
                        whiteScalar = cv::Scalar(0, 0, 255.0);
                    }
 
                    for (int i_c = 0; i_c < segmentedObject.size(); i_c++)
                    {
                        std::vector<std::vector<cv::Point>> contours;
                        std::vector<cv::Vec4i> hierarchy;
 
                        convertSRSegmentedObjectToOpencvFormat(segmentedObject[i_c], contours, hierarchy);
 
                        cv::drawContours(imageCheck, contours, -1, whiteScalar, -1, 8, hierarchy);
                    }
                }
 
                cv::Mat finalUnifiedImage;
                double beta = 1.0 - overlayAlpha;
                double gamma = 0;
                cv::addWeighted(image, overlayAlpha, imageCheck, beta, gamma, finalUnifiedImage);
 
                cv::namedWindow("Segmentation Result", cv::WINDOW_NORMAL);
                cv::resizeWindow("Segmentation Result", w * resizeFactor, h * resizeFactor);
                cv::imshow("Segmentation Result", finalUnifiedImage);
                cv::waitKey(displayTime);
            }
            else if (outputMode == SR_MULTI_CLASS_MATRIX_OUTPUT || outputMode == SR_MULTI_CLASS_HEATMAP_OUTPUT || outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT)
            {
                if (image.channels() == 4)
                {
                    cv::cvtColor(image, image, cv::COLOR_BGRA2BGR);
                }
                else if (image.channels() == 1)
                {
                    cv::cvtColor(image, image, cv::COLOR_GRAY2BGR);
                }
 
                cv::Mat imageCheck = image.clone();
 
                if (outputMode == SR_MULTI_CLASS_MATRIX_OUTPUT || outputMode == SR_MULTI_CLASS_HEATMAP_OUTPUT)
                {
                    unsigned char* data = imageCheck.data;
 
                    for (int i_pixel = 0; i_pixel < w * h; i_pixel++)
                    {
                        int maxVal = 0;
                        int channel = 0;
                        for (int c = 0; c < numberOfClassesOutput; c++)
                        {
                            if (outputMatrix[i_pixel + c * w * h] > maxVal)
                            {
                                maxVal = outputMatrix[i_pixel + c * w * h];
                                channel = c;
                            }
                        }
 
                        unsigned char* tmp = (unsigned char*)(&classColorsOutput[channel]);
                        int b = 0, g = 0, r = 0;
                        std::memcpy(&b, tmp, 1);
                        std::memcpy(&g, tmp + 1, 1);
                        std::memcpy(&r, tmp + 2, 1);
 
                        if (maxVal != 0) // else: background
                        {
                            data[3 * i_pixel + 0] = b * (maxVal / 255.0);
                            data[3 * i_pixel + 1] = g * (maxVal / 255.0);
                            data[3 * i_pixel + 2] = r * (maxVal / 255.0);
                        }
                    }
                }
                else if (outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT)
                {
                    for (int i_c = 0; i_c < segmentedObject.size(); i_c++)
                    {
                        unsigned char* tmp = (unsigned char*)(&classColorsOutput[segmentedObject[i_c].classIdx]);
                        int b = 0, g = 0, r = 0;
                        std::memcpy(&b, tmp, 1);
                        std::memcpy(&g, tmp + 1, 1);
                        std::memcpy(&r, tmp + 2, 1);
 
                        cv::Scalar overlayScalar = cv::Scalar(b, g, r);
 
                        std::vector<std::vector<cv::Point>> contours;
                        std::vector<cv::Vec4i> hierarchy;
 
                        convertSRSegmentedObjectToOpencvFormat(segmentedObject[i_c], contours, hierarchy);
 
                        cv::drawContours(imageCheck, contours, -1, overlayScalar, -1, 8, hierarchy);
                    }
                }
 
                cv::Mat finalUnifiedImage;
                double beta = 1.0 - overlayAlpha;
                double gamma = 0.0;
                cv::addWeighted(image, overlayAlpha, imageCheck, beta, gamma, finalUnifiedImage);
 
                cv::namedWindow("Segmentation Result", cv::WINDOW_NORMAL);
                cv::resizeWindow("Segmentation Result", w * resizeFactor, h * resizeFactor);
                cv::imshow("Segmentation Result", finalUnifiedImage);
                cv::waitKey(displayTime);
 
#ifdef SR_CROP_AND_STORE_SEGMENTED_OBJECT
                // comments to show cropped images
                //for (int i_c = 0; i_c < segmentedObject.size(); i_c++)
                //{
                //  if (segmentedObject[i_c].croppedImage != nullptr)
                //  {
                //      int dataType = CV_MAKETYPE(CV_8U, segmentedObject[i_c].croppedImageChannels);
                //      cv::Mat croppedImage = cv::Mat(segmentedObject[i_c].croppedImageHeight, segmentedObject[i_c].croppedImageWidth, dataType, segmentedObject[i_c].croppedImage);
 
                //      cv::namedWindow("Segmentation Cropped Image", cv::WINDOW_NORMAL);
                //      cv::resizeWindow("Segmentation Cropped Image", croppedImage.size().width, croppedImage.size().height);
                //      cv::imshow("Segmentation Cropped Image", croppedImage);
                //      cv::waitKey(displayTime);
                //  }
                //}
#endif
            }
 
            {
 
            int iterSkelColor = 0;
            cv::Mat imageCheck = image.clone();
            cv::Mat imageCheck2 = image.clone();
            for (int i_s = 0; i_s < segSkeletons.size(); i_s++)
            {
                unsigned char* tmp = (unsigned char*)(&classColorsOutput[segSkeletons[i_s].idxClass]);
                int b = 0, g = 0, r = 0;
                std::memcpy(&b, tmp, 1);
                std::memcpy(&g, tmp + 1, 1);
                std::memcpy(&r, tmp + 2, 1);
 
                cv::Scalar overlayScalar = cv::Scalar(b, g, r);
                
                for (int i_p = 0; i_p < segSkeletons[i_s].nPoints; i_p++)
                {
                    cv::Point pt0(segSkeletons[i_s].xPts[i_p], segSkeletons[i_s].yPts[i_p]);
                    cv::circle(imageCheck, pt0, 1, colorsForSkeleton[iterSkelColor % colorsForSkeleton.size()], 1);
                }
 
                for (int i_p = 0; i_p < segSkeletons[i_s].nPoints - 1; i_p++)
                {
                    cv::Point pt0(segSkeletons[i_s].xPts[i_p], segSkeletons[i_s].yPts[i_p]);
                    cv::Point pt1(segSkeletons[i_s].xPts[i_p + 1], segSkeletons[i_s].yPts[i_p + 1]);
                    cv::line(imageCheck, pt0, pt1, overlayScalar, 1);
 
                    cv::line(imageCheck2, pt0, pt1, overlayScalar, 3);
                }
                iterSkelColor++;
            }
 
            cv::Mat finalUnifiedImage;
            double beta = 1.0 - overlayAlpha;
            double gamma = 0.0;
            cv::addWeighted(image, overlayAlpha, imageCheck, beta, gamma, finalUnifiedImage);
 
            cv::namedWindow("Post-process Result", cv::WINDOW_NORMAL);
            cv::resizeWindow("Post-process Result", w * resizeFactor, h * resizeFactor);
            cv::imshow("Post-process Result", finalUnifiedImage);
            cv::waitKey(displayTime);
 
            cv::Mat finalUnifiedImage2;
            cv::addWeighted(image, overlayAlpha, imageCheck2, beta, gamma, finalUnifiedImage2);
 
            cv::namedWindow("Post-process Result2", cv::WINDOW_NORMAL);
            cv::resizeWindow("Post-process Result2", w * resizeFactor, h * resizeFactor);
            cv::imshow("Post-process Result2", finalUnifiedImage2);
            cv::waitKey(displayTime);
 
            }
        }
 
        if (ucImageData != nullptr)
        {
            delete[] ucImageData;
        }
        if (uiImageData != nullptr)
        {
            delete[] uiImageData;
        }
    }
 
    /***********************************************************
    *    9. Handle 파괴, Destruct handles
    ***********************************************************/
    srStatus = SR_DestroySegPostProcessHandle(segPostProcessHandle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the input pointer is not allocated (nullptr).
        return -1;
    }
    srStatus = SR_DeleteSegTestResult(segTestResult);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the input pointer is not allocated (nullptr).
        return -1;
    }
    srStatus = SR_DestroySegTestHandle(handle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the input pointer is not allocated (nullptr).
        return -1;
    }
 
    std::cout << "SaigeVision successfully completed, please press enter key to terminate" << std::endl;
    std::cin.get();
    return 0;
}