ExampleDetRuntimeSimple.cpp

This is an example of how to inspect sample images by using the minimum number of functions of det module. More details about this example.

 
#include "DetectorTestDLL.h"
#include "SRUtils.h"
 
int main()
{
    std::wstring data_dir = L"../../../examples/data";
 
    // trained model path
    std::wstring trainedModelPath = data_dir + L"/models/lego_sample_model.srDet";
 
    // image paths to classify
    std::vector<std::wstring> imagePaths(5);
    imagePaths[0] = data_dir + L"/images/Lego/sample1.png";
    imagePaths[1] = data_dir + L"/images/Lego/sample2.png";
    imagePaths[2] = data_dir + L"/images/Lego/sample3.png";
    imagePaths[3] = data_dir + L"/images/Lego/sample4.png";
    imagePaths[4] = data_dir + L"/images/Lego/sample5.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)
    ***********************************************************/
    //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
    ***********************************************************/
    int verbosity = 2;
 
    /***********************************************************
    *    0-2. GPU 번호 설정
    *    gpuIndex - 사용하고자 하는 gpu의 번호
    *       Multi GPU 가 가능한 License의 경우에 한하여 gpuIndex를
    *       0~3까지 설정해 줄 수 있다. 아닌 경우 gpuIndex는 0을 사용하여야 한다.
    ***********************************************************/
    int gpuIndex = 0;
 
    /***********************************************************
    *    1.  모델 파일 및 검사 결과 handle 생성,
    *        Create handles for model files and inspection results
    ***********************************************************/
    DetTestHandle handle = nullptr;
    srStatus = SR_CreateDetTestHandleByWideCharPath_ErrorType(&handle, trainedModelPath.c_str());
    if (srStatus != NO_ERROR_OUT || handle == nullptr)
    {
        std::wcout << "Saige Vision failed: Please check the file path of trained model." << std::endl;
    }
    DetTestResult detTestResult = nullptr;
    srStatus = SR_MakeDetTestResult_ErrorType(&detTestResult);
    if (srStatus != NO_ERROR_OUT || detTestResult == nullptr)
    {
        PrintErrorType(srStatus, verbosity);
        SR_DestroyDetTestHandle(handle);
        return -1;
    }
 
    /***********************************************************
    *    2. 클래스 정보 확인 (Optional)
    *       Check class information
    ***********************************************************/
    // Print all detection test parameters
    srStatus = SR_PrintDetTestParameters(handle);
    if (srStatus != NO_ERROR_OUT)
    {
        PrintErrorType(srStatus, verbosity);
        // if you get this error, it's possible that the handle is not created.
        SR_DestroyDetTestHandle(handle);
        return -1;
    }
 
    int numberOfClassesOutput = 0;
 
    // Get the number of classes
    srStatus = SR_GetDetTestNumberOfClasses(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_DestroyDetTestHandle(handle);
        return -1;
    }
    /***********************************************************
    *    3. 검사 옵션 확인 및 수정 (Optional)
    *       Check inspection options and set new values
    ***********************************************************/
    //pass
 
    /***********************************************************
    *    4. 메모리를 GPU 및 CPU에 할당합니다.
    *       Allocate GPU and CPU memory
    ***********************************************************/
    srStatus = SR_LoadDetTestNetworkInGPU(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_DestroyDetTestHandle(handle);
        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);
        }
 
        /***********************************************************
        *    5. 이미지 검사하기, Inspect images
        ***********************************************************/
        if (inputImageType == eSRInputImageType::ImageFilePathMultiByteChar)
        {
            // Check whether 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_ApplyDetTestFromImageFile(handle, imagePathMB.data(), detTestResult);
        }
        else if (inputImageType == eSRInputImageType::ImageFilePathWideChar)
        {
            srStatus = SR_ApplyDetTestFromImageFileByWideCharPath(handle, imagePaths[i_img].c_str(), detTestResult);
        }
        else if (inputImageType == eSRInputImageType::UCGrayImage)
        {
            srStatus = SR_ApplyDetTestFrom8bitCharGrayArray(handle, ucImageData, h, w, detTestResult);
        }
        else if (inputImageType == eSRInputImageType::UCColorImage)
        {
            srStatus = SR_ApplyDetTestFrom8bitCharColorArray(handle, ucImageData, h, w, detTestResult);
        }
        else if (inputImageType == eSRInputImageType::UIColorImage)
        {
            srStatus = SR_ApplyDetTestFromUnsignedIntColorArray(handle, uiImageData, h, w, detTestResult);
        }
 
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input data is not loaded successfully.
            continue; // jump to next image
        }
 
        /***********************************************************
        *    6. 검사 결과 받아오기, Retrieve inspection results
        ***********************************************************/
        int numberOfBoxesOutput = 0;
        long inspectionTimeOutput = 0;
 
        // Get the number of detected boxes
        srStatus = SR_GetDetTestResultNumberOfBoxes(detTestResult, &numberOfBoxesOutput);
        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 inspection time
        srStatus = SR_GetDetTestInspectionTime(detTestResult, &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
        }
 
        std::vector<SR_DetectedBox> detectedBoxes(numberOfBoxesOutput);
 
        // Get the information of all the detected boxes.
        srStatus = SR_GetDetTestResultDetectedBoxes(detTestResult, numberOfBoxesOutput, detectedBoxes.data());
        if (srStatus != NO_ERROR_OUT)
        {
            PrintErrorType(srStatus, verbosity);
            // if you get this error, it's possible that the input's [# of boxes] does not match the result's or the input pointer is not allocated (nullptr).
            continue; // jump to next image
        }
 
        if (verbosity >= 2)
        {
            std::cout << "====== Detection Test Result ======" << std::endl;
            std::wcout << imagePaths[i_img] << std::endl;
            std::cout << "  - Number of final detected boxes: " << numberOfBoxesOutput << std::endl;
            std::cout << "  - Inspection time: " << inspectionTimeOutput << std::endl;
            std::cout << "  - Detected boxes information" << std::endl;
        }
        for (int i = 0; i < numberOfBoxesOutput; i++)
        {
            int xmin = static_cast<int>(detectedBoxes[i].box.x_tl);
            int ymin = static_cast<int>(detectedBoxes[i].box.y_tl);
            int xmax = static_cast<int>(detectedBoxes[i].box.x_br);
            int ymax = static_cast<int>(detectedBoxes[i].box.y_br);
 
            if (verbosity >= 2)
            {
                printf("  - %d-th box info(label, score, x_topLeft, y_topLeft, x_bottomRight, y_bottomRight): %d, %0.2f, %d, %d, %d, %d\n",
                    i, detectedBoxes[i].box.classIdx, detectedBoxes[i].box.score, xmin, ymin, xmax, ymax);
            }
        }
 
        if (ucImageData != nullptr)
        {
            delete[] ucImageData;
        }
        if (uiImageData != nullptr)
        {
            delete[] uiImageData;
        }
    }
 
    /***********************************************************
    *    7. Handle 파괴, Destruct handles
    ***********************************************************/
    srStatus = SR_DeleteDetTestResult(detTestResult);
    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_DestroyDetTestHandle(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;
}
 
 
// Common Functions