SRUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <fstream>
#include <string>
 
#include "opencv2/opencv.hpp"
 
#if (defined(_MSC_VER) && _MSC_VER < 1900)
// filesystem may not exist..
#elif (defined(_MSC_VER) && _MSC_VER <= 1916)
#include <filesystem>
namespace fs = std::experimental::filesystem;
#elif ((defined(_MSC_VER) && _MSC_VER > 1916) || __cplusplus >= 201703L)
#include <filesystem>
namespace fs = std::filesystem;
#endif
 
typedef enum
{
    ImageFilePathMultiByteChar, // multibyte char path of image file
    ImageFilePathWideChar,      // wide char path of image file
    UCGrayImage,                // 8bit 1-channel image 
    UCColorImage,               // 8bit 3-channels image
    UIColorImage,               // 8bit 4-channels image
    UCGrayImage16Bit,           // 16bit 1-channel image
    UCColorImage16Bit,          // 16bit 3-channels image
    UIColorImage16Bit,          // 16bit 4-channels image
    UC8bitImage,                // 8bit 1~4 channels image (for multi page mode)
} eSRInputImageType;
 
static void ConvertImageToDepthOfCV8U(cv::Mat& image)
{
    int depth = image.depth();
 
    double max = 0.;
    double min = 0.;
    switch (depth) {
    case CV_8U:
        return;
    case CV_16U:
        max = 65535.;  // 256^2 - 1
        min = 0;
        break;
    case CV_32F:
    case CV_64F:
    case CV_16F:
        max = 1.;
        min = 0.;
        break;
    case CV_8S:
        max = 127.;
        min = -128.;
        break;
    case CV_16S:
        max = 32767.;   // (256^2)/2 - 1
        min = -32768.;  // (256^2)/2
        break;
    case CV_32S:
        max = 2147483647.;   // (256^4)/2 - 1
        min = -2147483648.;  // (256^4)/2
        break;
    default:
        assert(false && "saige: unsupported image depth");
    }
    if (min != max)    image.convertTo(image, CV_8U, 255.0 / (max - min), -255.0 * min / (max - min));
}
 
static bool OpenImageFile(const std::wstring imagePath, cv::Mat& image, bool asCV8U = false)
{
    const wchar_t* imageFilePath = imagePath.c_str();
 
    size_t sizeOfChar = 0;
 
    size_t sizeOfWChar = wcslen(imageFilePath);
    size_t bufferSize = sizeOfWChar * 2;
 
    std::vector<char> imageFilePathMB(bufferSize);
 
    sizeOfChar = wcstombs(
        imageFilePathMB.data(),
        imageFilePath,
        bufferSize);
 
    std::string ext;
    int isSuccess = 1;
 
    if (sizeOfChar != sizeOfWChar)
    {
#if ((defined(_MSC_VER) && _MSC_VER >= 1900) || __cplusplus >= 201402L)
        std::ifstream ifs(fs::path(imageFilePath), std::ios::in | std::ios::ate | std::ios::binary);
        if (ifs.is_open())
        {
            size_t size = ifs.tellg();
 
            ifs.seekg(0, std::ios::beg);
            std::vector<uchar> buffer(size);
            ifs.read(reinterpret_cast<char*>(&buffer[0]), size);
            ifs.close();
 
            image = cv::imdecode(buffer, cv::IMREAD_UNCHANGED);
        }
        else
        {
            return false;
        }
#else
        // use filename which can be converted to multi byte characters without any loss..
        return false;
#endif
    }
    else
    {
        image = cv::imread(imageFilePathMB.data(), cv::IMREAD_UNCHANGED);
    }
 
    if (image.empty() == true)
    {
        return false;
    }
 
    if (asCV8U)
    {
        ConvertImageToDepthOfCV8U(image);
    }
 
    return true;
}
 
static void* GetImageDataByInputImageType(const std::wstring imagePath, const eSRInputImageType inputType, int& height, int& width, int* channel = nullptr)
{
    if (inputType == eSRInputImageType::ImageFilePathMultiByteChar || inputType == eSRInputImageType::ImageFilePathWideChar)
    {
        return nullptr;
    }
 
    cv::Mat image;
 
    bool isOpened = OpenImageFile(imagePath, image);
 
    if ((image.empty() == true) || (isOpened == false))
    {
        std::wcout << "GetImageDataByInputImageType: wrong file path or damaged file.." << imagePath << std::endl;
        return nullptr;
    }
 
    width = image.size().width;
    height = image.size().height;
    int c = image.channels();
 
    unsigned char* ucData = nullptr;
 
    bool bIsColor = false;
 
    // copy image data to ucData
    switch (inputType)
    {
    case eSRInputImageType::ImageFilePathMultiByteChar:
    case eSRInputImageType::ImageFilePathWideChar:
        break;
    case eSRInputImageType::UCGrayImage:
        ucData = new unsigned char[width * height * 1];
        if (c == 3)
        {
            cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
        }
        else if (c == 4)
        {
            cv::cvtColor(image, image, cv::COLOR_BGRA2GRAY);
        }
        memcpy(ucData, image.data, sizeof(unsigned char) * width * height * 1);
        break;
    case eSRInputImageType::UCColorImage:
        ucData = new unsigned char[width * height * 3];
        if (c == 4)
        {
            cv::cvtColor(image, image, cv::COLOR_BGRA2BGR);
        }
        bIsColor = (c == 1) ? 0 : 1;
 
        if (bIsColor)
        {
            memcpy(ucData, image.data, sizeof(unsigned char) * width * height * 3);
        }
        else
        {
            for (int i = 0; i < width * height; i++)
            {
                ucData[3 * i + 0] = image.data[c * i + 0 * bIsColor];
                ucData[3 * i + 1] = image.data[c * i + 1 * bIsColor];
                ucData[3 * i + 2] = image.data[c * i + 2 * bIsColor];
            }
        }
        break;
    case eSRInputImageType::UIColorImage:
        bIsColor = (c == 1) ? 0 : 1;
        ucData = new unsigned char[width * height * 4];
        for (int i = 0; i < width * height; i++)
        {
            ucData[4 * i + 0] = image.data[c * i + 0 * bIsColor];
            ucData[4 * i + 1] = image.data[c * i + 1 * bIsColor];
            ucData[4 * i + 2] = image.data[c * i + 2 * bIsColor];
            if (c == 4)
            {
                ucData[4 * i + 3] = image.data[c * i + 3 * bIsColor];
            }
            else
            {
                ucData[4 * i + 3] = 255;
            }
        }
        break;
    case eSRInputImageType::UCGrayImage16Bit:
        ucData = new unsigned char[width * height * 1 * 2]; // channels = 1, element size = 2
        if (c == 3)
        {
            cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
        }
        else if (c == 4)
        {
            cv::cvtColor(image, image, cv::COLOR_BGRA2GRAY);
        }
        memcpy(ucData, image.data, sizeof(unsigned char) * width * height * 1 * 2);
        break;
    case eSRInputImageType::UCColorImage16Bit:
        ucData = new unsigned char[width * height * 3 * 2]; // channels = 3, element size = 2
        if (c == 1)
        {
            cv::cvtColor(image, image, cv::COLOR_GRAY2BGR);
        }
        else if (c == 4)
        {
            cv::cvtColor(image, image, cv::COLOR_BGRA2BGR);
        }
        memcpy(ucData, image.data, sizeof(unsigned char) * width * height * 3 * 2);
        break;
    case eSRInputImageType::UIColorImage16Bit:
        ucData = new unsigned char[width * height * 4 * 2]; // channels = 4, element size = 2
        if (c == 1)
        {
            cv::cvtColor(image, image, cv::COLOR_GRAY2BGRA);
        }
        else if (c == 3)
        {
            cv::cvtColor(image, image, cv::COLOR_BGR2BGRA);
        }
        memcpy(ucData, image.data, sizeof(unsigned char) * width * height * 4 * 2);
        break;
    case eSRInputImageType::UC8bitImage:
        ucData = new unsigned char[width * height * image.channels()];
        memcpy(ucData, image.data, sizeof(unsigned char) * width * height * image.channels());
        break;
    default:
        break;
    }
 
    if (channel != nullptr) {
        *channel = image.channels();
    }
 
    return (void*)ucData;
}
 
static void DisplayFailedImageOnCVWindow(std::wstring& imagePath, std::string failPhrase, std::string windowName, int displayTime, const float resizeFactor)
{
    cv::Mat failImage = cv::Mat();
 
    bool isOpened = OpenImageFile(imagePath, failImage);
 
    if ((failImage.empty() == true) || (isOpened == false))
    {
        return;
    }
 
    if (failImage.channels() == 1)
    {
        cv::cvtColor(failImage, failImage, cv::COLOR_GRAY2BGR);
    }
    else if (failImage.channels() == 4)
    {
        cv::cvtColor(failImage, failImage, cv::COLOR_BGRA2BGR);
    }
 
    cv::putText(failImage, failPhrase,
        cv::Point(0, 0), // Coordinates
        cv::FONT_HERSHEY_COMPLEX_SMALL, // Font
        2.0, // Scale. 2.0 = 2x bigger
        cv::Scalar(0, 0, 255), // BGR Color
        8 // Line Thickness (Optional) 
    );
 
    cv::putText(failImage, failPhrase,
        cv::Point(int(failImage.size().width * 0.25), int(failImage.size().height * 0.25)), // Coordinates
        cv::FONT_HERSHEY_COMPLEX_SMALL, // Font
        2.0, // Scale. 2.0 = 2x bigger
        cv::Scalar(0, 0, 255), // BGR Color
        8 // Line Thickness (Optional)
    );
 
    cv::putText(failImage, failPhrase,
        cv::Point(int(failImage.size().width * 0.5), int(failImage.size().height * 0.5)), // Coordinates
        cv::FONT_HERSHEY_COMPLEX_SMALL, // Font
        2.0, // Scale. 2.0 = 2x bigger
        cv::Scalar(0, 0, 255), // BGR Color
        8 // Line Thickness (Optional)
    );
 
    cv::putText(failImage, failPhrase,
        cv::Point(int(failImage.size().width * 0.75), int(failImage.size().height * 0.75)), // Coordinates
        cv::FONT_HERSHEY_COMPLEX_SMALL, // Font
        2.0, // Scale. 2.0 = 2x bigger
        cv::Scalar(0, 0, 255), // BGR Color
        8 // Line Thickness (Optional)
    );
 
    cv::namedWindow(windowName, cv::WINDOW_NORMAL);
    cv::resizeWindow(windowName, failImage.size().width * resizeFactor, failImage.size().height * resizeFactor);
    cv::imshow(windowName, failImage);
    cv::waitKey(displayTime);
 
    return;
}
 
static void convertSRSegmentedObjectToOpencvFormat(const SR_SegmentedObject& object, std::vector<std::vector<cv::Point>>& contours, std::vector<cv::Vec4i>& hierarchies)
{
    contours.clear();
    contours.resize(object.nContours);
 
    hierarchies.clear();
    hierarchies.resize(object.nContours);
 
    int pointsIdx = 0;
    for (size_t i_c = 0; i_c < contours.size(); i_c++)
    {
        for (size_t i_p = 0; i_p < object.nPointsOnContour[i_c]; i_p++)
        {
            cv::Point point = cv::Point(object.pointsOnContour[pointsIdx], object.pointsOnContour[pointsIdx + 1]);
            contours[i_c].push_back(point);
 
            pointsIdx += 2;
        }
 
        hierarchies[i_c][0] = object.hierarchies[4 * i_c + 0];
        hierarchies[i_c][1] = object.hierarchies[4 * i_c + 1];
        hierarchies[i_c][2] = object.hierarchies[4 * i_c + 2];
        hierarchies[i_c][3] = object.hierarchies[4 * i_c + 3];
    }
}