ExampleSeg+ClsRuntime.cpp

This is an example of how to inspect sample images by applying seg module and continuously classifying the segmented objects. More details about this example.

 
#include "SegmentationTestDLL.h"
#include "ClassifierTestDLL.h"
#include "SRUtils.h"
 
int main()
{
    std::wstring data_dir = L"../../../examples/data";
 
    // trained model path
    std::wstring trainedModelPath_seg = data_dir + L"/models/pcb_sample_model.srSeg";
    std::wstring trainedModelPath_cls = data_dir + L"/models/pcb_cls_sample_model.srCls";
 
    // image paths to classify
    std::vector<std::wstring> imagePaths(4);
    imagePaths[0] = data_dir + L"/images/PCB/Image-1.png";
    imagePaths[1] = data_dir + L"/images/PCB/Image-2.png";
    imagePaths[2] = data_dir + L"/images/PCB/Image-3.png";
    imagePaths[3] = data_dir + L"/images/PCB/Image-4.png";
 
    /***********************************************************
    *    최대 이미지 수 설정 (Max # of images to inspect)
    *     - 검사할 최대 이미지 수를 설정합니다. (Set maximum number of images to inspect)
    *     - 기본적으로 2의 배수로 설정할 것을 추천드리며 크게 설정할 수록
    *       GPU 메모리 할당량이 커지니 메모리가 부족하다면 더 작은 수로 설정해주세요.
    *       (Recommend to set this value as multiple of 2, and if GPU memory is low, set the value as lower number.)
    *     - 최대 이미지 수 보다 많은 이미지가 들어올 시에 내부적으로 여러번의 검사를 수행하게 됩니다.
    *       (If more images than nMaxImages are inserted to the inspection function, multiple inspections are conducted automatically.)
    ***********************************************************/
    int          nMaxImages = 32; /* 4, 8, 16, 32, 64 */
 
    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)
    ***********************************************************/
    //eSRInputImageType inputImageType = eSRInputImageType::ImageFilePathMultiByteChar;
    //eSRInputImageType inputImageType = eSRInputImageType::ImageFilePathWideChar;
    //eSRInputImageType inputImageType = eSRInputImageType::UCGrayImage;
    eSRInputImageType inputImageType = eSRInputImageType::UCColorImage;
    //eSRInputImageType inputImageType = eSRInputImageType::UIColorImage;
 
    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_ONE_CLASS_CV_CONTOUR_OUTPUT;
    // "Saige Vision assertion: For seg + cls inspection, use SR_ONE_CLASS_CV_CONTOUR_OUTPUT or SR_ONE_CLASS_CV_CONTOUR_OUTPUT mode only"
    assert(outputMode == SR_ONE_CLASS_CV_CONTOUR_OUTPUT || outputMode == SR_MULTI_CLASS_CV_CONTOUR_OUTPUT);
 
    /***********************************************************
    *    1.  모델 파일 및 검사 결과 handle 생성,
    *        Create handles for model files and inspection results
    ***********************************************************/
    SegTestHandle segHandle = nullptr;
    srStatus = SR_CreateSegTestHandleByWideCharPath_ErrorType(&segHandle, trainedModelPath_seg.c_str());
    if (srStatus != NO_ERROR_OUT || segHandle == nullptr)
    {
        std::wcout << "Saige Vision failed: Please check the file path of trained model." << std::endl;
    }
    ClsTestHandle clsHandle = nullptr;
    srStatus = SR_CreateClsTestHandleByWideCharPath_ErrorType(&clsHandle, trainedModelPath_cls.c_str());
    if (srStatus != NO_ERROR_OUT || clsHandle == nullptr)
    {
        std::wcout << "Saige Vision failed: Please check the file path of trained model." << std::endl;
    }
 
    SegTestResult segTestResult = nullptr;
    srStatus = SR_MakeSegTestResult_ErrorType(&segTestResult);
    std::vector<ClsTestResult> clsTestResults(nMaxImages);
    for (size_t i = 0; i < nMaxImages; i++)
    {
        srStatus = SR_MakeClsTestResult_ErrorType(&clsTestResults[i]);
    }
 
    /***********************************************************
    *    2. 클래스 정보 확인 (Optional)
    *       Check class information
    ***********************************************************/
    /* Segmentaion information */
    srStatus = SR_PrintSegTestParametersWithoutBG(segHandle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the handle is not created.
        SR_DestroySegTestHandle(segHandle);
        return -1;
    }
 
    /* Classification information */
    srStatus = SR_PrintClsTestParameters(clsHandle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the handle is not created.
        SR_DestroyClsTestHandle(clsHandle);
        return -1;
    }
 
    // Get classification test parameters one by one
    int numberOfClassesOutput = 0;
    int maxStrLenOfClassName = 0;
 
    // Get the number of classes
    srStatus = SR_GetClsTestNumberOfClasses(clsHandle, &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_DestroyClsTestHandle(clsHandle);
        return -1;
    }
 
    // Get the maximum length of class names
    srStatus = SR_GetClsTestMaxStrLenOfClassName(clsHandle, &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_DestroyClsTestHandle(clsHandle);
        return -1;
    }
 
    std::vector<std::wstring> wClassNames(numberOfClassesOutput);
    std::vector<std::string> classNames(numberOfClassesOutput);
    std::vector<int> classColorsOutput(numberOfClassesOutput);
 
    wchar_t*    wClassNameOutput = new wchar_t[maxStrLenOfClassName];
    char*       classNameOutput = new char[maxStrLenOfClassName];
 
    for (int i = 0; i < numberOfClassesOutput; i++)
    {
        // Get a color of single class
        srStatus = SR_GetClsTestOneClassColor(clsHandle, 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_DestroyClsTestHandle(clsHandle);
            return -1;
        }
 
        // Get a name of single class by multi byte char (char*)
        srStatus = SR_GetClsTestOneClassNameWithMultiByteChar(clsHandle, 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_DestroyClsTestHandle(clsHandle);
            return -1;
        }
 
        // Get a name of single class by wide char (wchar_t*)
        srStatus = SR_GetClsTestOneClassNameWithWideChar(clsHandle, 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_DestroyClsTestHandle(clsHandle);
            return -1;
        }
        wClassNames[i] = wClassNameOutput;
        classNames[i] = classNameOutput;
    }
 
    delete[] wClassNameOutput;
    delete[] classNameOutput;
    
    /***********************************************************
    *    3. 검사 옵션 확인 및 수정 (Optional)
    *       Check inspection options and set new values
    ***********************************************************/
    bool isToCrop = false;
    int cropSize = -1;
    eModeOfCropLargeObjects modeOfCrop = eModeOfCropLargeObjects::SR_CROP_BY_OBJECTSIZE_N_RESIZE_TO_CROPSIZE;
    float marginOfCrop = 0.05;
    srStatus = SR_GetSegTestIsToStoreCroppedImage(segHandle, &isToCrop, &cropSize, &modeOfCrop, &marginOfCrop);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that trained model file's version is low
        // please retrain with new version of Saige Vision (higher than 1.3.1)
        SR_DestroySegTestHandle(segHandle);
        return -1;
    }
 
    srStatus = SR_SetSegTestIsToStoreCroppedImage(segHandle, true, cropSize, modeOfCrop, marginOfCrop, true);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that handle is not created.
        SR_DestroySegTestHandle(segHandle);
        return -1;
    }
 
 
    /***********************************************************
    *    4. 메모리를 GPU 및 CPU에 할당합니다.
    *       Allocate GPU and CPU memory
    ***********************************************************/
    srStatus = SR_LoadSegTestNetworkInGPU(segHandle, 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(segHandle);
        return -1;
    }
    srStatus = SR_LoadClsTestNetworkInGPU(clsHandle, gpuIndex, nMaxImages);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the inserted index is not applicable.
        SR_DestroyClsTestHandle(clsHandle);
        return -1;
    }
 
    for (size_t i_img = 0; i_img < imagePaths.size(); i_img++)
    {
        int h = 0, w = 0;
        if (inputImageType == eSRInputImageType::UIColorImage)
        {
            uiImageData = (unsigned int*)GetImageDataByInputImageType(imagePaths[i_img], inputImageType, h, w);
        }
        else
        {
            ucImageData = (unsigned char*)GetImageDataByInputImageType(imagePaths[i_img], inputImageType, h, w);
        }
 
        /***********************************************************
        *    (Segmentation) 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(segHandle, imagePathMB.data(), segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::ImageFilePathWideChar)
        {
            srStatus = SR_ApplySegTestFromImageFileByWideCharPath(segHandle, imagePaths[i_img].c_str(), segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage)
        {
            srStatus = SR_ApplySegTestFrom8bitCharGrayArray(segHandle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage)
        {
            srStatus = SR_ApplySegTestFrom8bitCharColorArray(segHandle, ucImageData, h, w, segTestResult, outputMode);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage)
        {
            srStatus = SR_ApplySegTestFromUnsignedIntColorArray(segHandle, 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
        }
 
        /***********************************************************
        *    (Segmentation) 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
        }
 
        // Display and draw
        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::endl;
        }
 
        // Get Segmented objects
        // segmented object after filtering (# of classes x # of objects)
        std::vector<SR_SegmentedObject> segmentedObject;
        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 << "]" << std::endl;
            }
        }
 
        /* Classification 검사 수행 */
        if (nSegmentedObjects > 0)
        {
            if (clsTestResults.size() < nSegmentedObjects)
            {
                clsTestResults.resize(nSegmentedObjects, nullptr);
                for (size_t i = 0; i < clsTestResults.size(); i++)
                {
                    if (clsTestResults[i] == nullptr)
                        srStatus = SR_MakeClsTestResult_ErrorType(&clsTestResults[i]);
                }
            }
 
            /***********************************************************
            *    (Classification) 5. 이미지 검사하기, Inspect images
            ***********************************************************/
            srStatus = SR_ApplyClsTestFromSegmentedObjects(clsHandle, nSegmentedObjects, segmentedObject.data(), clsTestResults.data());
            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
            }
 
            /***********************************************************
            *    (Classification) 6. 검사 결과 받아오기, Retrieve inspection results
            ***********************************************************/
            // Get the inspection time
            srStatus = SR_GetClsTestInspectionTime(clsTestResults[0], &inspectionTimeOutput);
            if (srStatus != NO_ERROR_OUT)
            {
                // if you get this error, it's possible that the input pointer is not allocated (nullptr).
                PrintErrorType(srStatus, verbosity);
            }
 
            // Get the image-loading time
            srStatus = SR_GetClsTestLoadImageTime(clsTestResults[0], &loadImageTimeOutput);
            if (srStatus != NO_ERROR_OUT)
            {
                // if you get this error, it's possible that the input pointer is not allocated (nullptr).
                PrintErrorType(srStatus, verbosity);
            }
            std::cout << "====== classification Test Result (Total) ======" << std::endl;
            std::cout << "  - Image Loading time: " << loadImageTimeOutput << std::endl;
            std::cout << "  - Inspection time: " << inspectionTimeOutput << std::endl;
 
            // Display
            if (verbosity >= 2)
            {
                for (size_t i = 0; i < nSegmentedObjects; i++)
                {
                    std::vector<int> scoreOutput(numberOfClassesOutput);
                    int classOutput = -1;
 
                    srStatus = SR_GetClsTestResultScore(clsTestResults[i], numberOfClassesOutput, scoreOutput.data(), true);
                    if (srStatus != NO_ERROR_OUT)
                    {
                        PrintErrorType(srStatus, verbosity);
                        // if you get this error, it's possible that the input's [# of classes] does not match the result's or input pointer is not allocated (nullptr).
                        continue; // jump to next image
                    }
                    srStatus = SR_GetClsTestResultClass(clsTestResults[i], &classOutput);
                    if (srStatus != NO_ERROR_OUT)
                    {
                        PrintErrorType(srStatus, verbosity);
                        // if you get this error, it's possible that input pointer is not allocated (nullptr).
                        continue; // jump to next image
                    }
 
                    std::cout << "====== classification Test Result (Single) ======" << std::endl;
                    for (int j = 0; j < numberOfClassesOutput; j++)
                    {
                        std::cout << "  - " << j << "-th class score: " << scoreOutput[j] << std::endl;
                    }
                    std::cout << "  - Result Class: " << classOutput << std::endl;
                }
            }
        }
 
        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
            {
                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 (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();
 
            for (size_t i_o = 0; i_o < nSegmentedObjects; i_o++)
            {
                int classIdx = 0;
                SR_GetClsTestResultClass(clsTestResults[i_o], &classIdx);
 
                unsigned char* tmp = (unsigned char*)(&classColorsOutput[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_o], contours, hierarchy);
                cv::drawContours(imageCheck, contours, -1, overlayScalar, -1, 8, hierarchy);
 
                int dataType = CV_MAKETYPE(CV_8U, segmentedObject[i_o].croppedImageChannels);
                cv::Mat croppedImage = cv::Mat(segmentedObject[i_o].croppedImageHeight, segmentedObject[i_o].croppedImageWidth, dataType, segmentedObject[i_o].croppedImage);
                cv::putText(croppedImage, classNames[classIdx],
                    cv::Point(int(croppedImage.size().width * 0.1), int(croppedImage.size().height * 0.9)), // Coordinates
                    cv::FONT_HERSHEY_COMPLEX_SMALL, // Font
                    2.0, // Scale. 2.0 = 2x bigger
                    overlayScalar, // BGR Color
                    4 // Line Thickness (Optional)
                );
            }
 
            cv::Mat finalUnifiedImage;
            double beta = 1.0 - overlayAlpha;
            double gamma = 0.0;
            cv::addWeighted(image, overlayAlpha, imageCheck, beta, gamma, finalUnifiedImage);
 
            cv::namedWindow("Segmentation Contour Result", cv::WINDOW_NORMAL);
            cv::resizeWindow("Segmentation Contour Result", w * resizeFactor, h * resizeFactor);
            cv::imshow("Segmentation Contour Result", finalUnifiedImage);
            cv::waitKey(displayTime);
 
            for (size_t i_o = 0; i_o < nSegmentedObjects; i_o++)
            {
                if (segmentedObject[i_o].croppedImage != nullptr)
                {
                    int dataType = CV_MAKETYPE(CV_8U, segmentedObject[i_o].croppedImageChannels);
                    cv::Mat croppedImage = cv::Mat(segmentedObject[i_o].croppedImageHeight, segmentedObject[i_o].croppedImageWidth, dataType, segmentedObject[i_o].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);
                }
            }
        }
 
        if (ucImageData != nullptr)
        {
            delete[] ucImageData;
        }
        if (uiImageData != nullptr)
        {
            delete[] uiImageData;
        }
    }
 
    /***********************************************************
    *    7. Handle 파괴, Destruct handles
    ***********************************************************/
    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;
    }
    for (size_t i = 0; i < clsTestResults.size(); i++)
    {
        srStatus = SR_DeleteClsTestResult(clsTestResults[i]);
        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(segHandle);
    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_DestroyClsTestHandle(clsHandle);
    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;
}