paddleOcr v5

Src/Utility/CommonDefinition.h

+// 常用定义
+
+#ifndef __COMMON_DEFINITION_H__
+#define __COMMON_DEFINITION_H__
+
+//#include <opencv2/opencv.hpp>
+
+namespace migraphxSamples
+{
+
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define PATH_SEPARATOR '\\'
+#else
+#define PATH_SEPARATOR '/'
+#endif
+
+#define CONFIG_FILE "../Resource/Configuration.xml"
+
+typedef enum _ErrorCode
+{
+    SUCCESS = 0,              // 0
+    MODEL_NOT_EXIST,          // 模型不存在
+    CONFIG_FILE_NOT_EXIST,    // 配置文件不存在
+    FAIL_TO_LOAD_MODEL,       // 加载模型失败
+    FAIL_TO_OPEN_CONFIG_FILE, // 加载配置文件失败
+    IMAGE_ERROR,              // 图像错误
+} ErrorCode;
+
+typedef struct _ResultOfPrediction
+{
+    float confidence;
+    int label;
+    _ResultOfPrediction() : confidence(0.0f), label(0) {}
+
+} ResultOfPrediction;
+
+typedef struct _InitializationParameterOfClassifier
+{
+    std::string parentPath;
+    std::string configFilePath;
+} InitializationParameterOfClassifier;
+
+} // namespace migraphxSamples
+
+#endif

Src/Utility/Filesystem.cpp

+#include <Filesystem.h>
+#include <algorithm>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fstream>
+#ifdef _WIN32
+#include <io.h>
+#include <direct.h>
+#include <Windows.h>
+#else
+#include <unistd.h>
+#include <dirent.h>
+#endif
+
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define PATH_SEPARATOR '\\'
+#else
+#define PATH_SEPARATOR '/'
+#endif
+
+using namespace std;
+
+namespace migraphxSamples
+{
+
+static std::vector<std::string> SplitString(std::string str, std::string separator)
+{
+    std::string::size_type pos;
+    std::vector<std::string> result;
+    str += separator; // 扩展字符串以方便操作
+    int size = str.size();
+
+    for(int i = 0; i < size; i++)
+    {
+        pos = str.find(separator, i);
+        if(pos < size)
+        {
+            std::string s = str.substr(i, pos - i);
+            result.push_back(s);
+            i = pos + separator.size() - 1;
+        }
+    }
+    return result;
+}
+
+#if defined _WIN32 || defined WINCE
+const char dir_separators[] = "/\\";
+
+struct dirent
+{
+    const char* d_name;
+};
+
+struct DIR
+{
+#ifdef WINRT
+    WIN32_FIND_DATAW data;
+#else
+    WIN32_FIND_DATAA data;
+#endif
+    HANDLE handle;
+    dirent ent;
+#ifdef WINRT
+    DIR() {}
+    ~DIR()
+    {
+        if(ent.d_name)
+            delete[] ent.d_name;
+    }
+#endif
+};
+
+DIR* opendir(const char* path)
+{
+    DIR* dir        = new DIR;
+    dir->ent.d_name = 0;
+#ifdef WINRT
+    string full_path = string(path) + "\\*";
+    wchar_t wfull_path[MAX_PATH];
+    size_t copied = mbstowcs(wfull_path, full_path.c_str(), MAX_PATH);
+    CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+    dir->handle = ::FindFirstFileExW(
+        wfull_path, FindExInfoStandard, &dir->data, FindExSearchNameMatch, NULL, 0);
+#else
+    dir->handle = ::FindFirstFileExA((string(path) + "\\*").c_str(),
+                                     FindExInfoStandard,
+                                     &dir->data,
+                                     FindExSearchNameMatch,
+                                     NULL,
+                                     0);
+#endif
+    if(dir->handle == INVALID_HANDLE_VALUE)
+    {
+        /*closedir will do all cleanup*/
+        delete dir;
+        return 0;
+    }
+    return dir;
+}
+
+dirent* readdir(DIR* dir)
+{
+#ifdef WINRT
+    if(dir->ent.d_name != 0)
+    {
+        if(::FindNextFileW(dir->handle, &dir->data) != TRUE)
+            return 0;
+    }
+    size_t asize = wcstombs(NULL, dir->data.cFileName, 0);
+    CV_Assert((asize != 0) && (asize != (size_t)-1));
+    char* aname  = new char[asize + 1];
+    aname[asize] = 0;
+    wcstombs(aname, dir->data.cFileName, asize);
+    dir->ent.d_name = aname;
+#else
+    if(dir->ent.d_name != 0)
+    {
+        if(::FindNextFileA(dir->handle, &dir->data) != TRUE)
+            return 0;
+    }
+    dir->ent.d_name = dir->data.cFileName;
+#endif
+    return &dir->ent;
+}
+
+void closedir(DIR* dir)
+{
+    ::FindClose(dir->handle);
+    delete dir;
+}
+#else
+#include <dirent.h>
+#include <sys/stat.h>
+const char dir_separators[] = "/";
+#endif
+
+static bool isDir(const string& path, DIR* dir)
+{
+#if defined _WIN32 || defined WINCE
+    DWORD attributes;
+    BOOL status = TRUE;
+    if(dir)
+        attributes = dir->data.dwFileAttributes;
+    else
+    {
+        WIN32_FILE_ATTRIBUTE_DATA all_attrs;
+#ifdef WINRT
+        wchar_t wpath[MAX_PATH];
+        size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+        CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+        status = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &all_attrs);
+#else
+        status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
+#endif
+        attributes = all_attrs.dwFileAttributes;
+    }
+
+    return status && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+#else
+    (void)dir;
+    struct stat stat_buf;
+    if(0 != stat(path.c_str(), &stat_buf))
+        return false;
+    int is_dir = S_ISDIR(stat_buf.st_mode);
+    return is_dir != 0;
+#endif
+}
+
+bool IsDirectory(const string& path) { return isDir(path, NULL); }
+
+bool Exists(const string& path)
+{
+
+#if defined _WIN32 || defined WINCE
+    BOOL status = TRUE;
+    {
+        WIN32_FILE_ATTRIBUTE_DATA all_attrs;
+#ifdef WINRT
+        wchar_t wpath[MAX_PATH];
+        size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+        CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+        status = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &all_attrs);
+#else
+        status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
+#endif
+    }
+
+    return !!status;
+#else
+    struct stat stat_buf;
+    return (0 == stat(path.c_str(), &stat_buf));
+#endif
+}
+
+bool IsPathSeparator(char c) { return c == '/' || c == '\\'; }
+
+string JoinPath(const string& base, const string& path)
+{
+    if(base.empty())
+        return path;
+    if(path.empty())
+        return base;
+
+    bool baseSep = IsPathSeparator(base[base.size() - 1]);
+    bool pathSep = IsPathSeparator(path[0]);
+    string result;
+    if(baseSep && pathSep)
+    {
+        result = base + path.substr(1);
+    }
+    else if(!baseSep && !pathSep)
+    {
+        result = base + PATH_SEPARATOR + path;
+    }
+    else
+    {
+        result = base + path;
+    }
+    return result;
+}
+
+static bool wildcmp(const char* string, const char* wild)
+{
+    const char *cp = 0, *mp = 0;
+
+    while((*string) && (*wild != '*'))
+    {
+        if((*wild != *string) && (*wild != '?'))
+        {
+            return false;
+        }
+
+        wild++;
+        string++;
+    }
+
+    while(*string)
+    {
+        if(*wild == '*')
+        {
+            if(!*++wild)
+            {
+                return true;
+            }
+
+            mp = wild;
+            cp = string + 1;
+        }
+        else if((*wild == *string) || (*wild == '?'))
+        {
+            wild++;
+            string++;
+        }
+        else
+        {
+            wild   = mp;
+            string = cp++;
+        }
+    }
+
+    while(*wild == '*')
+    {
+        wild++;
+    }
+
+    return *wild == 0;
+}
+
+static void glob_rec(const string& directory,
+                     const string& wildchart,
+                     std::vector<string>& result,
+                     bool recursive,
+                     bool includeDirectories,
+                     const string& pathPrefix)
+{
+    DIR* dir;
+
+    if((dir = opendir(directory.c_str())) != 0)
+    {
+        /* find all the files and directories within directory */
+        try
+        {
+            struct dirent* ent;
+            while((ent = readdir(dir)) != 0)
+            {
+                const char* name = ent->d_name;
+                if((name[0] == 0) || (name[0] == '.' && name[1] == 0) ||
+                   (name[0] == '.' && name[1] == '.' && name[2] == 0))
+                    continue;
+
+                string path  = JoinPath(directory, name);
+                string entry = JoinPath(pathPrefix, name);
+
+                if(isDir(path, dir))
+                {
+                    if(recursive)
+                        glob_rec(path, wildchart, result, recursive, includeDirectories, entry);
+                    if(!includeDirectories)
+                        continue;
+                }
+
+                if(wildchart.empty() || wildcmp(name, wildchart.c_str()))
+                    result.push_back(entry);
+            }
+        }
+        catch(...)
+        {
+            closedir(dir);
+            throw;
+        }
+        closedir(dir);
+    }
+    else
+    {
+        printf("could not open directory: %s", directory.c_str());
+    }
+}
+
+void GetFileNameList(const string& directory,
+                     const string& pattern,
+                     std::vector<string>& result,
+                     bool recursive,
+                     bool addPath)
+{
+    // split pattern
+    vector<string> patterns = SplitString(pattern, ",");
+
+    result.clear();
+
+    for(int i = 0; i < patterns.size(); ++i)
+    {
+        string eachPattern = patterns[i];
+        std::vector<string> eachResult;
+        glob_rec(directory, eachPattern, eachResult, recursive, true, directory);
+        for(int j = 0; j < eachResult.size(); ++j)
+        {
+            if(IsDirectory(eachResult[j]))
+                continue;
+            if(addPath)
+            {
+                result.push_back(eachResult[j]);
+            }
+            else
+            {
+                result.push_back(GetFileName(eachResult[j]));
+            }
+        }
+    }
+    std::sort(result.begin(), result.end());
+}
+
+void GetFileNameList2(const string& directory,
+                      const string& pattern,
+                      std::vector<string>& result,
+                      bool recursive,
+                      bool addPath)
+{
+    // split pattern
+    vector<string> patterns = SplitString(pattern, ",");
+
+    result.clear();
+
+    for(int i = 0; i < patterns.size(); ++i)
+    {
+        string eachPattern = patterns[i];
+        std::vector<string> eachResult;
+        glob_rec(directory, eachPattern, eachResult, recursive, true, directory);
+        for(int j = 0; j < eachResult.size(); ++j)
+        {
+            string filePath = eachResult[j];
+            if(IsDirectory(filePath))
+            {
+                filePath = filePath + "/";
+                for(int k = 0; k < filePath.size(); ++k)
+                {
+                    if(IsPathSeparator(filePath[k]))
+                    {
+                        filePath[k] = '/';
+                    }
+                }
+            }
+            if(addPath)
+            {
+                result.push_back(filePath);
+            }
+            else
+            {
+                if(!IsDirectory(filePath))
+                {
+                    result.push_back(GetFileName(filePath));
+                }
+            }
+        }
+    }
+    std::sort(result.begin(), result.end());
+}
+
+void RemoveAll(const string& path)
+{
+
+    if(!Exists(path))
+        return;
+
+    if(IsDirectory(path))
+    {
+        std::vector<string> entries;
+        GetFileNameList2(path, string(), entries, false, true);
+        for(size_t i = 0; i < entries.size(); i++)
+        {
+            const string& e = entries[i];
+            RemoveAll(e);
+        }
+#ifdef _MSC_VER
+        bool result = _rmdir(path.c_str()) == 0;
+#else
+        bool result = rmdir(path.c_str()) == 0;
+#endif
+        if(!result)
+        {
+            printf("can't remove directory: %s\n", path.c_str());
+        }
+    }
+    else
+    {
+#ifdef _MSC_VER
+        bool result = _unlink(path.c_str()) == 0;
+#else
+        bool result = unlink(path.c_str()) == 0;
+#endif
+        if(!result)
+        {
+            printf("can't remove file: %s\n", path.c_str());
+        }
+    }
+}
+
+void Remove(const string& directory, const string& extension)
+{
+
+    DIR* dir;
+
+    static int numberOfFiles = 0;
+
+    if((dir = opendir(directory.c_str())) != 0)
+    {
+        /* find all the files and directories within directory */
+        try
+        {
+            struct dirent* ent;
+            while((ent = readdir(dir)) != 0)
+            {
+                const char* name = ent->d_name;
+                if((name[0] == 0) || (name[0] == '.' && name[1] == 0) ||
+                   (name[0] == '.' && name[1] == '.' && name[2] == 0))
+                    continue;
+
+                string path = JoinPath(directory, name);
+
+                if(isDir(path, dir))
+                {
+                    Remove(path, extension);
+                }
+
+                // �ж���չ��
+                if(extension.empty() || wildcmp(name, extension.c_str()))
+                {
+                    RemoveAll(path);
+                    ++numberOfFiles;
+                    printf("%s deleted! number of deleted files:%d\n", path.c_str(), numberOfFiles);
+                }
+            }
+        }
+        catch(...)
+        {
+            closedir(dir);
+            throw;
+        }
+        closedir(dir);
+    }
+    else
+    {
+        printf("could not open directory: %s", directory.c_str());
+    }
+
+    // ����RemoveAllɾ��Ŀ¼
+    RemoveAll(directory);
+}
+string GetFileName(const string& path)
+{
+    string fileName;
+    int indexOfPathSeparator = -1;
+    for(int i = path.size() - 1; i >= 0; --i)
+    {
+        if(IsPathSeparator(path[i]))
+        {
+            fileName             = path.substr(i + 1, path.size() - i - 1);
+            indexOfPathSeparator = i;
+            break;
+        }
+    }
+    if(indexOfPathSeparator == -1)
+    {
+        fileName = path;
+    }
+
+    return fileName;
+}
+string GetFileName_NoExtension(const string& path)
+{
+    string fileName = GetFileName(path);
+    string fileName_NoExtension;
+    for(int i = fileName.size() - 1; i > 0; --i)
+    {
+        if(fileName[i] == '.')
+        {
+            fileName_NoExtension = fileName.substr(0, i);
+            break;
+        }
+    }
+
+    return fileName_NoExtension;
+}
+
+string GetExtension(const string& path)
+{
+    string fileName;
+    for(int i = path.size() - 1; i >= 0; --i)
+    {
+        if(path[i] == '.')
+        {
+            fileName = path.substr(i, path.size() - i);
+            break;
+        }
+    }
+
+    return fileName;
+}
+
+string GetParentPath(const string& path)
+{
+    string fileName;
+    for(int i = path.size() - 1; i >= 0; --i)
+    {
+        if(IsPathSeparator(path[i]))
+        {
+            fileName = path.substr(0, i + 1);
+            break;
+        }
+    }
+
+    return fileName;
+}
+
+static bool CreateDirectory(const string& path)
+{
+#if defined WIN32 || defined _WIN32 || defined WINCE
+#ifdef WINRT
+    wchar_t wpath[MAX_PATH];
+    size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+    CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+    int result = CreateDirectoryA(wpath, NULL) ? 0 : -1;
+#else
+    int result = _mkdir(path.c_str());
+#endif
+#elif defined __linux__ || defined __APPLE__
+    int result = mkdir(path.c_str(), 0777);
+#else
+    int result = -1;
+#endif
+
+    if(result == -1)
+    {
+        return IsDirectory(path);
+    }
+    return true;
+}
+
+bool CreateDirectories(const string& directoryPath)
+{
+    string path = directoryPath;
+
+    for(;;)
+    {
+        char last_char = path.empty() ? 0 : path[path.length() - 1];
+        if(IsPathSeparator(last_char))
+        {
+            path = path.substr(0, path.length() - 1);
+            continue;
+        }
+        break;
+    }
+
+    if(path.empty() || path == "./" || path == ".\\" || path == ".")
+        return true;
+    if(IsDirectory(path))
+        return true;
+
+    size_t pos = path.rfind('/');
+    if(pos == string::npos)
+        pos = path.rfind('\\');
+    if(pos != string::npos)
+    {
+        string parent_directory = path.substr(0, pos);
+        if(!parent_directory.empty())
+        {
+            if(!CreateDirectories(parent_directory))
+                return false;
+        }
+    }
+
+    return CreateDirectory(path);
+}
+
+bool CopyFile(const string srcPath, const string dstPath)
+{
+    std::ifstream srcFile(srcPath, ios::binary);
+    std::ofstream dstFile(dstPath, ios::binary);
+
+    if(!srcFile.is_open())
+    {
+        printf("can not open %s\n", srcPath.c_str());
+        return false;
+    }
+    if(!dstFile.is_open())
+    {
+        printf("can not open %s\n", dstPath.c_str());
+        return false;
+    }
+    if(srcPath == dstPath)
+    {
+        printf("src can not be same with dst\n");
+        return false;
+    }
+    char buffer[2048];
+    unsigned int numberOfBytes = 0;
+    while(srcFile)
+    {
+        srcFile.read(buffer, 2048);
+        dstFile.write(buffer, srcFile.gcount());
+        numberOfBytes += srcFile.gcount();
+    }
+    srcFile.close();
+    dstFile.close();
+    return true;
+}
+
+bool CopyDirectories(string srcPath, const string dstPath)
+{
+    if(srcPath == dstPath)
+    {
+        printf("src can not be same with dst\n");
+        return false;
+    }
+
+    // ȥ������·���ָ���
+    srcPath = srcPath.substr(0, srcPath.size() - 1);
+
+    vector<string> fileNameList;
+    GetFileNameList2(srcPath, "", fileNameList, true, true);
+
+    string parentPathOfSrc = GetParentPath(srcPath);
+    int length             = parentPathOfSrc.size();
+
+    // create all directories
+    for(int i = 0; i < fileNameList.size(); ++i)
+    {
+        // create directory
+        string srcFilePath     = fileNameList[i];
+        string subStr          = srcFilePath.substr(length, srcFilePath.size() - length);
+        string dstFilePath     = dstPath + subStr;
+        string parentPathOfDst = GetParentPath(dstFilePath);
+        CreateDirectories(parentPathOfDst);
+    }
+
+    // copy file
+    for(int i = 0; i < fileNameList.size(); ++i)
+    {
+        string srcFilePath = fileNameList[i];
+        if(IsDirectory(srcFilePath))
+        {
+            continue;
+        }
+        string subStr      = srcFilePath.substr(length, srcFilePath.size() - length);
+        string dstFilePath = dstPath + subStr;
+
+        // copy file
+        CopyFile(srcFilePath, dstFilePath);
+
+        // process
+        double process = (1.0 * (i + 1) / fileNameList.size()) * 100;
+        printf("%s done! %f% \n", GetFileName(fileNameList[i]).c_str(), process);
+    }
+    printf("all done!(the number of files:%d)\n", fileNameList.size());
+
+    return true;
+}
+
+} // namespace migraphxSamples

Src/Utility/Filesystem.h

+// 文件以及目录处理
+
+#ifndef __FILE_SYSTEM_H__
+#define __FILE_SYSTEM_H__
+
+#include <string>
+#include <vector>
+
+namespace migraphxSamples
+{
+
+// 路径是否存在
+bool Exists(const std::string& path);
+
+// 路径是否为目录
+bool IsDirectory(const std::string& path);
+
+// 是否是路径分隔符(Linux:‘/’,Windows:’\\’)
+bool IsPathSeparator(char c);
+
+// 路径拼接
+std::string JoinPath(const std::string& base, const std::string& path);
+
+// 创建多级目录,注意：创建多级目录的时候，目标目录是不能有文件存在的
+bool CreateDirectories(const std::string& directoryPath);
+
+/** 生成符合指定模式的文件名列表(支持递归遍历)
+*
+* pattern: 模式,比如"*.jpg","*.png","*.jpg,*.png"
+* addPath：是否包含父路径
+* 注意：
+    1. 多个模式使用","分割,比如"*.jpg,*.png"
+    2. 支持通配符'*','?' ,比如第一个字符是7的所有文件名:"7*.*", 以512结尾的所有jpg文件名："*512.jpg"
+    3. 使用"*.jpg"，而不是".jpg"
+    4. 空string表示返回所有结果
+    5. 不能返回子目录名
+*
+*/
+void GetFileNameList(const std::string& directory,
+                     const std::string& pattern,
+                     std::vector<std::string>& result,
+                     bool recursive,
+                     bool addPath);
+
+// 与GetFileNameList的区别在于如果有子目录，在addPath为true的时候会返回子目录路径(目录名最后有"/")
+void GetFileNameList2(const std::string& directory,
+                      const std::string& pattern,
+                      std::vector<std::string>& result,
+                      bool recursive,
+                      bool addPath);
+
+// 删除文件或者目录,支持递归删除
+void Remove(const std::string& directory, const std::string& extension = "");
+
+/** 获取路径的文件名和扩展名
+ *
+ *  示例：path为D:/1/1.txt,则GetFileName()为1.txt,GetFileName_NoExtension()为1,GetExtension()为.txt,GetParentPath()为D:/1/
+ */
+std::string GetFileName(const std::string& path);
+std::string GetFileName_NoExtension(const std::string& path);
+std::string GetExtension(const std::string& path);
+std::string GetParentPath(const std::string& path);
+
+// 拷贝文件
+bool CopyFile(const std::string srcPath, const std::string dstPath);
+
+/** 拷贝目录
+ *
+ * 示例：CopyDirectories("D:/0/1/2/","E:/3/");实现把D:/0/1/2/目录拷贝到E:/3/目录中(即拷贝完成后的目录结构为E:/3/2/)
+ * 注意：
+    1.第一个参数的最后不能加”/”
+    2.不能拷贝隐藏文件
+*/
+bool CopyDirectories(std::string srcPath, const std::string dstPath);
+
+} // namespace migraphxSamples
+
+#endif

Src/Utility/SimpleLog.h

+// 简易日志
+
+#ifndef __SIMPLE_LOG_H__
+#define __SIMPLE_LOG_H__
+
+#include <time.h>
+#include <string>
+#include <map>
+#include <thread>
+#include <mutex>
+#if(defined WIN32 || defined _WIN32)
+#include <Windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+using namespace std;
+
+/** 简易日志
+ *
+ * 不依赖于其他第三方库，只需要包含一个头文件就可以使用。提供了4种日志级别，包括INFO,DEBUG,WARN和ERROR。
+ *
+ * 示例1:
+    //
+ 初始化日志，在./Log/目录下创建两个日志文件log1.log和log2.log(注意：目录./Log/需要存在，否则日志创建失败)
+    LogManager::GetInstance()->Initialize("./Log/","log1");
+    LogManager::GetInstance()->Initialize("./Log/","log2");
+
+    // 写日志
+    string log = "Hello World";
+    LOG_INFO(LogManager::GetInstance()->GetLogFile("log1"), "%s\n", log.c_str()); // 写入log1.log
+    LOG_INFO(LogManager::GetInstance()->GetLogFile("log2"), "%s\n", log.c_str()); // 写入log2.log
+
+    // 关闭日志
+    LogManager::GetInstance()->Close("log1");
+    LogManager::GetInstance()->Close("log2");
+
+  * 示例2:
+    // 将日志输出到控制台
+    string log = "Hello World";
+    LOG_INFO(stdout, "%s\n", log.c_str());
+
+  * 注意：
+    1. 需要C++11
+    2. 多线程的时候需要加锁(打开#define LOG_MUTEX)，否则会导致日志显示混乱
+
+*/
+
+// #define LOG_MUTEX  // 加锁
+
+class LogManager
+{
+    private:
+    LogManager() {}
+
+    public:
+    ~LogManager() {}
+    inline void Initialize(const string& parentPath, const string& logName)
+    {
+        // 日志名为空表示输出到控制台
+        if(logName.size() == 0)
+            return;
+
+        // 查找该日志文件，如果没有则创建
+        std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
+        if(iter == logMap.end())
+        {
+            string pathOfLog = parentPath + logName + ".log";
+            FILE* logFile    = fopen(pathOfLog.c_str(), "a"); // w:覆盖原有文件,a:追加
+            if(logFile != NULL)
+            {
+                logMap.insert(std::make_pair(logName, logFile));
+            }
+        }
+    }
+    inline FILE* GetLogFile(const string& logName)
+    {
+        std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
+        if(iter == logMap.end())
+        {
+            return NULL;
+        }
+
+        return (*iter).second;
+    }
+    inline void Close(const string& logName)
+    {
+        std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
+        if(iter == logMap.end())
+        {
+            return;
+        }
+
+        fclose((*iter).second);
+        logMap.erase(iter);
+    }
+    inline std::mutex& GetLogMutex() { return logMutex; }
+
+    // Singleton
+    static LogManager* GetInstance()
+    {
+        static LogManager logManager;
+        return &logManager;
+    }
+
+    private:
+    std::map<string, FILE*> logMap;
+    std::mutex logMutex;
+};
+
+#ifdef LOG_MUTEX
+#define LOCK LogManager::GetInstance()->GetLogMutex().lock()
+#define UNLOCK LogManager::GetInstance()->GetLogMutex().unlock()
+#else
+#define LOCK
+#define UNLOCK
+#endif
+
+// log time
+typedef struct _LogTime
+{
+    string year;
+    string month;
+    string day;
+    string hour;
+    string minute;
+    string second;
+    string millisecond; // ms
+    string microsecond; // us
+    string weekDay;
+} LogTime;
+
+inline LogTime GetTime()
+{
+    LogTime currentTime;
+
+#if(defined WIN32 || defined _WIN32)
+    SYSTEMTIME systemTime;
+    GetLocalTime(&systemTime);
+
+    char temp[8] = {0};
+    sprintf(temp, "%04d", systemTime.wYear);
+    currentTime.year = string(temp);
+    sprintf(temp, "%02d", systemTime.wMonth);
+    currentTime.month = string(temp);
+    sprintf(temp, "%02d", systemTime.wDay);
+    currentTime.day = string(temp);
+    sprintf(temp, "%02d", systemTime.wHour);
+    currentTime.hour = string(temp);
+    sprintf(temp, "%02d", systemTime.wMinute);
+    currentTime.minute = string(temp);
+    sprintf(temp, "%02d", systemTime.wSecond);
+    currentTime.second = string(temp);
+    sprintf(temp, "%03d", systemTime.wMilliseconds);
+    currentTime.millisecond = string(temp);
+    sprintf(temp, "%d", systemTime.wDayOfWeek);
+    currentTime.weekDay = string(temp);
+#else
+    struct timeval tv;
+    struct tm* p;
+    gettimeofday(&tv, NULL);
+    p = localtime(&tv.tv_sec);
+
+    char temp[8] = {0};
+    sprintf(temp, "%04d", 1900 + p->tm_year);
+    currentTime.year = string(temp);
+    sprintf(temp, "%02d", 1 + p->tm_mon);
+    currentTime.month = string(temp);
+    sprintf(temp, "%02d", p->tm_mday);
+    currentTime.day = string(temp);
+    sprintf(temp, "%02d", p->tm_hour);
+    currentTime.hour = string(temp);
+    sprintf(temp, "%02d", p->tm_min);
+    currentTime.minute = string(temp);
+    sprintf(temp, "%02d", p->tm_sec);
+    currentTime.second = string(temp);
+    sprintf(temp, "%03d", (int)(tv.tv_usec / 1000));
+    currentTime.millisecond = string(temp);
+    sprintf(temp, "%03d", (int)(tv.tv_usec % 1000));
+    currentTime.microsecond = string(temp);
+    sprintf(temp, "%d", p->tm_wday);
+    currentTime.weekDay = string(temp);
+#endif
+    return currentTime;
+}
+
+#define LOG_TIME(logFile)                               \
+    do                                                  \
+    {                                                   \
+        LogTime currentTime = GetTime();                \
+        fprintf(((logFile == NULL) ? stdout : logFile), \
+                "%s-%s-%s %s:%s:%s.%s\t",               \
+                currentTime.year.c_str(),               \
+                currentTime.month.c_str(),              \
+                currentTime.day.c_str(),                \
+                currentTime.hour.c_str(),               \
+                currentTime.minute.c_str(),             \
+                currentTime.second.c_str(),             \
+                currentTime.millisecond.c_str());       \
+    } while(0)
+
+#define LOG_INFO(logFile, logInfo, ...)                                          \
+    do                                                                           \
+    {                                                                            \
+        LOCK;                                                                    \
+        LOG_TIME(logFile);                                                       \
+        fprintf(((logFile == NULL) ? stdout : logFile), "INFO\t");               \
+        fprintf(((logFile == NULL) ? stdout : logFile),                          \
+                "[%s:%d (%s) ]: ",                                               \
+                __FILE__,                                                        \
+                __LINE__,                                                        \
+                __FUNCTION__);                                                   \
+        fprintf(((logFile == NULL) ? stdout : logFile), logInfo, ##__VA_ARGS__); \
+        fflush(logFile);                                                         \
+        UNLOCK;                                                                  \
+    } while(0)
+
+#define LOG_DEBUG(logFile, logInfo, ...)                                         \
+    do                                                                           \
+    {                                                                            \
+        LOCK;                                                                    \
+        LOG_TIME(logFile);                                                       \
+        fprintf(((logFile == NULL) ? stdout : logFile), "DEBUG\t");              \
+        fprintf(((logFile == NULL) ? stdout : logFile),                          \
+                "[%s:%d (%s) ]: ",                                               \
+                __FILE__,                                                        \
+                __LINE__,                                                        \
+                __FUNCTION__);                                                   \
+        fprintf(((logFile == NULL) ? stdout : logFile), logInfo, ##__VA_ARGS__); \
+        fflush(logFile);                                                         \
+        UNLOCK;                                                                  \
+    } while(0)
+
+#define LOG_ERROR(logFile, logInfo, ...)                                         \
+    do                                                                           \
+    {                                                                            \
+        LOCK;                                                                    \
+        LOG_TIME(logFile);                                                       \
+        fprintf(((logFile == NULL) ? stdout : logFile), "ERROR\t");              \
+        fprintf(((logFile == NULL) ? stdout : logFile),                          \
+                "[%s:%d (%s) ]: ",                                               \
+                __FILE__,                                                        \
+                __LINE__,                                                        \
+                __FUNCTION__);                                                   \
+        fprintf(((logFile == NULL) ? stdout : logFile), logInfo, ##__VA_ARGS__); \
+        fflush(logFile);                                                         \
+        UNLOCK;                                                                  \
+    } while(0)
+
+#define LOG_WARN(logFile, logInfo, ...)                                          \
+    do                                                                           \
+    {                                                                            \
+        LOCK;                                                                    \
+        LOG_TIME(logFile);                                                       \
+        fprintf(((logFile == NULL) ? stdout : logFile), "WARN\t");               \
+        fprintf(((logFile == NULL) ? stdout : logFile),                          \
+                "[%s:%d (%s) ]: ",                                               \
+                __FILE__,                                                        \
+                __LINE__,                                                        \
+                __FUNCTION__);                                                   \
+        fprintf(((logFile == NULL) ? stdout : logFile), logInfo, ##__VA_ARGS__); \
+        fflush(logFile);                                                         \
+        UNLOCK;                                                                  \
+    } while(0)
+
+#endif // __SIMPLE_LOG_H__

Src/Utility/clipper.h

+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  6.4.2                                                           *
+* Date      :  27 February 2017                                                *
+* Website   :  http://www.angusj.com                                           *
+* Copyright :  Angus Johnson 2010-2017                                         *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+* See also:                                                                    *
+* "Polygon Offsetting by Computing Winding Numbers"                            *
+* Paper no. DETC2005-85513 pp. 565-575                                         *
+* ASME 2005 International Design Engineering Technical Conferences             *
+* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+* September 24-28, 2005 , Long Beach, California, USA                          *
+* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
+*                                                                              *
+*******************************************************************************/
+
+#pragma once
+
+#ifndef clipper_hpp
+#define clipper_hpp
+
+#define CLIPPER_VERSION "6.4.2"
+
+// use_int32: When enabled 32bit ints are used instead of 64bit ints. This
+// improve performance but coordinate values are limited to the range +/- 46340
+//#define use_int32
+
+// use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
+//#define use_xyz
+
+// use_lines: Enables line clipping. Adds a very minor cost to performance.
+#define use_lines
+
+// use_deprecated: Enables temporary support for the obsolete functions
+//#define use_deprecated
+
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <list>
+#include <ostream>
+#include <queue>
+#include <set>
+#include <stdexcept>
+#include <vector>
+
+namespace ClipperLib {
+
+enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+enum PolyType { ptSubject, ptClip };
+// By far the most widely used winding rules for polygon filling are
+// EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
+// Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
+// see http://glprogramming.com/red/chapter11.html
+enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+
+#ifdef use_int32
+typedef int cInt;
+static cInt const loRange = 0x7FFF;
+static cInt const hiRange = 0x7FFF;
+#else
+typedef signed long long cInt;
+static cInt const loRange = 0x3FFFFFFF;
+static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
+typedef signed long long long64; // used by Int128 class
+typedef unsigned long long ulong64;
+
+#endif
+
+struct IntPoint {
+  cInt X;
+  cInt Y;
+#ifdef use_xyz
+  cInt Z;
+  IntPoint(cInt x = 0, cInt y = 0, cInt z = 0) : X(x), Y(y), Z(z){};
+#else
+  IntPoint(cInt x = 0, cInt y = 0) : X(x), Y(y){};
+#endif
+
+  friend inline bool operator==(const IntPoint &a, const IntPoint &b) {
+    return a.X == b.X && a.Y == b.Y;
+  }
+  friend inline bool operator!=(const IntPoint &a, const IntPoint &b) {
+    return a.X != b.X || a.Y != b.Y;
+  }
+};
+//------------------------------------------------------------------------------
+
+typedef std::vector<IntPoint> Path;
+typedef std::vector<Path> Paths;
+
+inline Path &operator<<(Path &poly, const IntPoint &p) {
+  poly.push_back(p);
+  return poly;
+}
+inline Paths &operator<<(Paths &polys, const Path &p) {
+  polys.push_back(p);
+  return polys;
+}
+
+std::ostream &operator<<(std::ostream &s, const IntPoint &p);
+std::ostream &operator<<(std::ostream &s, const Path &p);
+std::ostream &operator<<(std::ostream &s, const Paths &p);
+
+struct DoublePoint {
+  double X;
+  double Y;
+  DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {}
+  DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {}
+};
+//------------------------------------------------------------------------------
+
+#ifdef use_xyz
+typedef void (*ZFillCallback)(IntPoint &e1bot, IntPoint &e1top, IntPoint &e2bot,
+                              IntPoint &e2top, IntPoint &pt);
+#endif
+
+enum InitOptions {
+  ioReverseSolution = 1,
+  ioStrictlySimple = 2,
+  ioPreserveCollinear = 4
+};
+enum JoinType { jtSquare, jtRound, jtMiter };
+enum EndType {
+  etClosedPolygon,
+  etClosedLine,
+  etOpenButt,
+  etOpenSquare,
+  etOpenRound
+};
+
+class PolyNode;
+typedef std::vector<PolyNode *> PolyNodes;
+
+class PolyNode {
+public:
+  PolyNode();
+  virtual ~PolyNode(){};
+  Path Contour;
+  PolyNodes Childs;
+  PolyNode *Parent;
+  PolyNode *GetNext() const;
+  bool IsHole() const;
+  bool IsOpen() const;
+  int ChildCount() const;
+
+private:
+  // PolyNode& operator =(PolyNode& other);
+  unsigned Index; // node index in Parent.Childs
+  bool m_IsOpen;
+  JoinType m_jointype;
+  EndType m_endtype;
+  PolyNode *GetNextSiblingUp() const;
+  void AddChild(PolyNode &child);
+  friend class Clipper; // to access Index
+  friend class ClipperOffset;
+};
+
+class PolyTree : public PolyNode {
+public:
+  ~PolyTree() { Clear(); };
+  PolyNode *GetFirst() const;
+  void Clear();
+  int Total() const;
+
+private:
+  // PolyTree& operator =(PolyTree& other);
+  PolyNodes AllNodes;
+  friend class Clipper; // to access AllNodes
+};
+
+bool Orientation(const Path &poly);
+double Area(const Path &poly);
+int PointInPolygon(const IntPoint &pt, const Path &path);
+
+void SimplifyPolygon(const Path &in_poly, Paths &out_polys,
+                     PolyFillType fillType = pftEvenOdd);
+void SimplifyPolygons(const Paths &in_polys, Paths &out_polys,
+                      PolyFillType fillType = pftEvenOdd);
+void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
+
+void CleanPolygon(const Path &in_poly, Path &out_poly, double distance = 1.415);
+void CleanPolygon(Path &poly, double distance = 1.415);
+void CleanPolygons(const Paths &in_polys, Paths &out_polys,
+                   double distance = 1.415);
+void CleanPolygons(Paths &polys, double distance = 1.415);
+
+void MinkowskiSum(const Path &pattern, const Path &path, Paths &solution,
+                  bool pathIsClosed);
+void MinkowskiSum(const Path &pattern, const Paths &paths, Paths &solution,
+                  bool pathIsClosed);
+void MinkowskiDiff(const Path &poly1, const Path &poly2, Paths &solution);
+
+void PolyTreeToPaths(const PolyTree &polytree, Paths &paths);
+void ClosedPathsFromPolyTree(const PolyTree &polytree, Paths &paths);
+void OpenPathsFromPolyTree(PolyTree &polytree, Paths &paths);
+
+void ReversePath(Path &p);
+void ReversePaths(Paths &p);
+
+struct IntRect {
+  cInt left;
+  cInt top;
+  cInt right;
+  cInt bottom;
+};
+
+// enums that are used internally ...
+enum EdgeSide { esLeft = 1, esRight = 2 };
+
+// forward declarations (for stuff used internally) ...
+struct TEdge;
+struct IntersectNode;
+struct LocalMinimum;
+struct OutPt;
+struct OutRec;
+struct Join;
+
+typedef std::vector<OutRec *> PolyOutList;
+typedef std::vector<TEdge *> EdgeList;
+typedef std::vector<Join *> JoinList;
+typedef std::vector<IntersectNode *> IntersectList;
+
+//------------------------------------------------------------------------------
+
+// ClipperBase is the ancestor to the Clipper class. It should not be
+// instantiated directly. This class simply abstracts the conversion of sets of
+// polygon coordinates into edge objects that are stored in a LocalMinima list.
+class ClipperBase {
+public:
+  ClipperBase();
+  virtual ~ClipperBase();
+  virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
+  bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
+  virtual void Clear();
+  IntRect GetBounds();
+  bool PreserveCollinear() { return m_PreserveCollinear; };
+  void PreserveCollinear(bool value) { m_PreserveCollinear = value; };
+
+protected:
+  void DisposeLocalMinimaList();
+  TEdge *AddBoundsToLML(TEdge *e, bool IsClosed);
+  virtual void Reset();
+  TEdge *ProcessBound(TEdge *E, bool IsClockwise);
+  void InsertScanbeam(const cInt Y);
+  bool PopScanbeam(cInt &Y);
+  bool LocalMinimaPending();
+  bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin);
+  OutRec *CreateOutRec();
+  void DisposeAllOutRecs();
+  void DisposeOutRec(PolyOutList::size_type index);
+  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
+  void DeleteFromAEL(TEdge *e);
+  void UpdateEdgeIntoAEL(TEdge *&e);
+
+  typedef std::vector<LocalMinimum> MinimaList;
+  MinimaList::iterator m_CurrentLM;
+  MinimaList m_MinimaList;
+
+  bool m_UseFullRange;
+  EdgeList m_edges;
+  bool m_PreserveCollinear;
+  bool m_HasOpenPaths;
+  PolyOutList m_PolyOuts;
+  TEdge *m_ActiveEdges;
+
+  typedef std::priority_queue<cInt> ScanbeamList;
+  ScanbeamList m_Scanbeam;
+};
+//------------------------------------------------------------------------------
+
+class Clipper : public virtual ClipperBase {
+public:
+  Clipper(int initOptions = 0);
+  bool Execute(ClipType clipType, Paths &solution,
+               PolyFillType fillType = pftEvenOdd);
+  bool Execute(ClipType clipType, Paths &solution, PolyFillType subjFillType,
+               PolyFillType clipFillType);
+  bool Execute(ClipType clipType, PolyTree &polytree,
+               PolyFillType fillType = pftEvenOdd);
+  bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType subjFillType,
+               PolyFillType clipFillType);
+  bool ReverseSolution() { return m_ReverseOutput; };
+  void ReverseSolution(bool value) { m_ReverseOutput = value; };
+  bool StrictlySimple() { return m_StrictSimple; };
+  void StrictlySimple(bool value) { m_StrictSimple = value; };
+// set the callback function for z value filling on intersections (otherwise Z
+// is 0)
+#ifdef use_xyz
+  void ZFillFunction(ZFillCallback zFillFunc);
+#endif
+protected:
+  virtual bool ExecuteInternal();
+
+private:
+  JoinList m_Joins;
+  JoinList m_GhostJoins;
+  IntersectList m_IntersectList;
+  ClipType m_ClipType;
+  typedef std::list<cInt> MaximaList;
+  MaximaList m_Maxima;
+  TEdge *m_SortedEdges;
+  bool m_ExecuteLocked;
+  PolyFillType m_ClipFillType;
+  PolyFillType m_SubjFillType;
+  bool m_ReverseOutput;
+  bool m_UsingPolyTree;
+  bool m_StrictSimple;
+#ifdef use_xyz
+  ZFillCallback m_ZFill; // custom callback
+#endif
+  void SetWindingCount(TEdge &edge);
+  bool IsEvenOddFillType(const TEdge &edge) const;
+  bool IsEvenOddAltFillType(const TEdge &edge) const;
+  void InsertLocalMinimaIntoAEL(const cInt botY);
+  void InsertEdgeIntoAEL(TEdge *edge, TEdge *startEdge);
+  void AddEdgeToSEL(TEdge *edge);
+  bool PopEdgeFromSEL(TEdge *&edge);
+  void CopyAELToSEL();
+  void DeleteFromSEL(TEdge *e);
+  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
+  bool IsContributing(const TEdge &edge) const;
+  bool IsTopHorz(const cInt XPos);
+  void DoMaxima(TEdge *e);
+  void ProcessHorizontals();
+  void ProcessHorizontal(TEdge *horzEdge);
+  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutPt *AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutRec *GetOutRec(int idx);
+  void AppendPolygon(TEdge *e1, TEdge *e2);
+  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
+  OutPt *AddOutPt(TEdge *e, const IntPoint &pt);
+  OutPt *GetLastOutPt(TEdge *e);
+  bool ProcessIntersections(const cInt topY);
+  void BuildIntersectList(const cInt topY);
+  void ProcessIntersectList();
+  void ProcessEdgesAtTopOfScanbeam(const cInt topY);
+  void BuildResult(Paths &polys);
+  void BuildResult2(PolyTree &polytree);
+  void SetHoleState(TEdge *e, OutRec *outrec);
+  void DisposeIntersectNodes();
+  bool FixupIntersectionOrder();
+  void FixupOutPolygon(OutRec &outrec);
+  void FixupOutPolyline(OutRec &outrec);
+  bool IsHole(TEdge *e);
+  bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
+  void FixHoleLinkage(OutRec &outrec);
+  void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt);
+  void ClearJoins();
+  void ClearGhostJoins();
+  void AddGhostJoin(OutPt *op, const IntPoint offPt);
+  bool JoinPoints(Join *j, OutRec *outRec1, OutRec *outRec2);
+  void JoinCommonEdges();
+  void DoSimplePolygons();
+  void FixupFirstLefts1(OutRec *OldOutRec, OutRec *NewOutRec);
+  void FixupFirstLefts2(OutRec *InnerOutRec, OutRec *OuterOutRec);
+  void FixupFirstLefts3(OutRec *OldOutRec, OutRec *NewOutRec);
+#ifdef use_xyz
+  void SetZ(IntPoint &pt, TEdge &e1, TEdge &e2);
+#endif
+};
+//------------------------------------------------------------------------------
+
+class ClipperOffset {
+public:
+  ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25);
+  ~ClipperOffset();
+  void AddPath(const Path &path, JoinType joinType, EndType endType);
+  void AddPaths(const Paths &paths, JoinType joinType, EndType endType);
+  void Execute(Paths &solution, double delta);
+  void Execute(PolyTree &solution, double delta);
+  void Clear();
+  double MiterLimit;
+  double ArcTolerance;
+
+private:
+  Paths m_destPolys;
+  Path m_srcPoly;
+  Path m_destPoly;
+  std::vector<DoublePoint> m_normals;
+  double m_delta, m_sinA, m_sin, m_cos;
+  double m_miterLim, m_StepsPerRad;
+  IntPoint m_lowest;
+  PolyNode m_polyNodes;
+
+  void FixOrientations();
+  void DoOffset(double delta);
+  void OffsetPoint(int j, int &k, JoinType jointype);
+  void DoSquare(int j, int k);
+  void DoMiter(int j, int k, double r);
+  void DoRound(int j, int k);
+};
+//------------------------------------------------------------------------------
+
+class clipperException : public std::exception {
+public:
+  clipperException(const char *description) : m_descr(description) {}
+  virtual ~clipperException() throw() {}
+  virtual const char *what() const throw() { return m_descr.c_str(); }
+
+private:
+  std::string m_descr;
+};
+//------------------------------------------------------------------------------
+
+} // ClipperLib namespace
+
+#endif // clipper_hpp

Src/main.cpp

+#include "ocr_engine.hpp"
+
+using namespace ppocr;
+ 
+int main(int argc, char** argv)
+{
+    std::string det_model_onnx = "../Resource/Models/ppocrv5_server_det_infer.onnx";
+    std::string rec_model_onnx = "../Resource/Models/ppocrv5_server_rec_infer.onnx";
+    std::string img_path = "../Resource/Images/20250703205038.png";
+    std::string character_dict_path = "../Resource/ppocr_keys_v5.txt";
+    float segm_thres=0.3;
+    float box_thresh=0.3; 
+    ppOcrEngine ocr_engine(det_model_onnx,
+        rec_model_onnx,
+        character_dict_path,
+        segm_thres,
+        box_thresh,
+        true,
+        "fp32");
+       
+    cv::Mat img=cv::imread(img_path);
+    ocr_engine.forward(img);
+    return 0;
+}
+ 
\ No newline at end of file

Src/ocr_engine.hpp

+#pragma once
+#include<iostream>
+#include <migraphx/program.hpp>
+#include <migraphx/onnx.hpp>
+#include <migraphx/gpu/target.hpp>
+#include <migraphx/quantization.hpp>
+#include <hip/hip_runtime_api.h>
+#include <opencv2/opencv.hpp>
+#include "CommonDefinition.h"
+#include "Filesystem.h"
+#include "SimpleLog.h"
+#include "clipper.h"
+
+namespace ppocr{
+    struct _TEXT_BOX
+    {
+        cv::Rect  t_rect;
+        float score;
+    };
+    using T_BOX = struct _TEXT_BOX;
+
+    class CTCDecode
+    {
+    private:
+        //inference image
+        float* data;
+        std::unordered_map<std::string, migraphx::argument> device_data;
+        migraphx::program net;
+        int batch_size;
+        int net_input_width;
+        int net_input_height;
+        int net_input_channel;
+        bool offload_copy;
+        std::string precision_mode;
+
+        std::unordered_map<std::string, migraphx::argument> dev_argument;
+        void* input_buffer_device;
+        void* output_buffer_device;
+        void* output_buffer_host;
+
+
+        migraphx::shape input_shape;
+        migraphx::shape output_shape;
+        std::string input_name;
+        std::string output_name;
+
+        //postprocess: n_channel->model output channel,feature_size--> feature size one channel
+        int n_channel;
+        int feature_size;
+        std::vector<std::string> k_words;
+        
+    public:
+        CTCDecode(std::string rec_model_path,
+        std::string precision_mode="fp32",
+        int image_width=480,
+        int image_height=48,
+        int channel=3,
+        int batch_size = 1,
+        bool offload_copy = true,
+        std::string character_dict_path="./ppocr_keys_v5.txt");
+        
+        ~CTCDecode();
+        /**
+         * @brief 字符识别编码，可支持，最长可支持预测90个字符，18385个字符
+         */
+        std::string forward(cv::Mat& img);
+        
+    private:
+        /**
+         * @brief 预处理
+         * pixel = (src_img*scale-0.5)/0.5;
+         * scale = 1.0/255
+         * @param img  字符图片
+         * @param data 预处理输出
+         * @param img_w 模型输入宽
+         * @param img_h 模型输入高
+         * @return 成功：true,失败：false
+         */
+        bool preproc(cv::Mat img,float* data,int img_w=480,int img_h=48);
+
+        /**
+         * @brief 模型预测后处理，获取每行中概率最大的字符，组成一句长度最大为90个字符的句子，模型预测输出shape=[1,90,18385]
+         * @param feature model output 
+         * @return 成功：text,失败：""
+         */
+        std::string postprocess(float* feature);
+        
+        /**
+         * @brief 解码，将模型预测输出与字符集关联起来
+         * @param probs 模型预测的最大概率
+         * @param indexs 模型预测的最大概率的索引值
+         * @param mean_prob 预测句子的平均概率
+         * @return 成功：text,失败：""
+         */
+        std::string decode(std::vector<float>& probs,std::vector<int>& indexs,float& mean_prob);
+        
+    };
+ 
+    class OcrDet
+    {
+    private:
+        std::string precision_mode;
+        bool offload_copy;
+        migraphx::program net;
+        migraphx::shape input_shape;
+        migraphx::shape output_shape;
+        std::string input_name;
+        std::string output_name;
+        int det_batch_size;
+        int data_size ; 
+        float segm_thres;
+        float box_thres;  
+
+        int net_input_width;
+        int net_input_height;
+        int net_input_channel;
+        
+        float* data;
+        
+        //Allocate device buffer and host buffer,if offload_copy is false
+        std::unordered_map<std::string, migraphx::argument> dev_argument;
+        void* input_buffer_device;
+        void* output_buffer_device;
+        void* output_buffer_host;
+        //postprocess
+        int n_channel;
+        int feature_size;  //single channel feature map size.
+        int output_width;
+        int output_height;
+        int max_candidates;//maximun number of candidates contours.
+
+    public:
+        OcrDet(std::string det_model_path,
+            std::string precision_mode="float32",
+            bool offload_copy = true,
+            float segm_thres = 0.3,
+            float box_thresh = 0.7);
+        ~OcrDet();
+        bool forward(cv::Mat& img,std::vector<std::vector<std::vector<int>>>& text_roi_boxes);
+        
+    private:
+        /**
+         * @brief 预处理
+         * pixel = (scale*src_img*mean/std);
+         * scale = 1.0/255
+         * mean = [0.485, 0.456, 0.406]
+         * std = [0.229, 0.224, 0.225]  
+         * @param img  字符图片
+         * @param data 预处理输出
+         * @return 成功：w,h维度的缩放比例
+         */
+        cv::Size preproc(cv::Mat img,float* data);
+        
+        /**
+         * @brief 后处理，通过模型预测的二值图获取文本区域
+         * @param feature  模型预测tensor（这里字符检测使用了dbnet）
+         * @param boxes 字符区域坐标
+         * @return 成功：0,失败：-1
+         */
+        int  postprocess(float* feature, std::vector<std::vector<std::vector<int>>> &boxes);
+        
+        
+         
+
+        int boxes_from_bitmap(cv::Mat& bit_map,std::vector<T_BOX>& box);
+
+        std::vector<std::vector<std::vector<int>>>boxes_from_bitmap(
+        const cv::Mat pred, const cv::Mat bitmap, const float &box_thresh,
+        const float &det_db_unclip_ratio, const bool &use_polygon_score);
+        
+        std::vector<std::vector<float>> Mat2Vector(cv::Mat mat);
+        
+        /**
+         * @brief 统计多边形区域的平均得分
+         * @param contour  字符区域的轮廓点集合
+         * @param pred  模型预测二值图
+         * @return score
+         */
+        float polygon_score_acc(std::vector<cv::Point> contour,cv::Mat pred);
+        
+
+        /**
+         * @brief 对模型预测的区域进行向内或向外扩散，扩散比例是unclip_ratio ，目的是找到更加合适的字符区域
+         * @param box  字符区域坐标
+         * @param pred  模型预测二值图
+         * @return 处理后的字符区域
+         */
+        cv::RotatedRect unClip(std::vector<std::vector<float>> box,
+                                      const float &unclip_ratio);
+        
+         /**
+         * @brief 计算偏移距离
+         *  distance = area * unclip_ratio / dist;
+         *  area = ∑(x_i*y_{i+1} - x_{i+1}*y_i)
+         *  dist = sqrtf(dx * dx + dy * dy)
+         *
+         * @param box  字符区域坐标
+         * @param unclip_ratio  缩放比例
+         * @param distance 偏移距离
+         * @return  NONE
+         */
+        void get_contour_area(const std::vector<std::vector<float>> &box,
+                                   float unclip_ratio, float &distance) ;
+        
+        /**
+         * @brief 无效字符区域过滤。首先将boxes映射回原始图像，然后过滤无效区域
+         * @param boxes  字符区域坐标
+         * @param ratio_h  垂直方向缩放比例
+         * @param ratio_w  水平方向缩放比例
+         * @param srcimg   原始图像
+         * 
+         * @return  字符区域有效坐标
+         */
+        std::vector<std::vector<std::vector<int>>> filter_det_res(std::vector<std::vector<std::vector<int>>> boxes,
+                                float ratio_h, float ratio_w, cv::Mat srcimg);
+        
+        /**
+         * @brief 对字符区域按照从上到下，从左到右的顺序排序
+         * @param pts  字符区域坐标
+         * 
+         * @return  字符区域有效坐标
+         */
+        std::vector<std::vector<int>> order_points_clockwise(std::vector<std::vector<int>> pts);
+        
+         /**
+         * @brief 获取最小矩形坐标
+         * @param box  字符区域最小外接矩形的坐标
+         * @param ssid  box的最大边
+         * @return  字符区域有效坐标
+         */
+        std::vector<std::vector<float>> get_mini_boxes(cv::RotatedRect box,float &ssid) ;
+        
+        /**
+         * @brief 计算bitmap上的t_rect区域的平均分数
+         * @param box_array  模型预测的字符区域
+         * @param pred  模型预测二值图
+         * @return score
+         */
+        float box_score_fast(std::vector<std::vector<float>> box_array,cv::Mat pred) ;
+
+        void visualize_boxes(const cv::Mat &srcimg,
+        const std::vector<std::vector<std::vector<int>>> &boxes) ;
+        
+        bool text_recognition(const cv::Mat &srcimg,
+        const std::vector<std::vector<std::vector<int>>> &boxes);
+
+    };
+
+    class ppOcrEngine { 
+        private:
+            std::shared_ptr<OcrDet> text_detector;
+            std::shared_ptr<CTCDecode> text_recognizer;
+        public:
+            ppOcrEngine(const std::string &det_model_path,
+                    const std::string &rec_model_path,
+                    const std::string &character_dict_path,
+                    const float segm_thres=0.3,
+                    const float box_thresh=0.7,
+                    bool offload_copy =true,
+                    std::string precision_mode = "fp32") ;
+            ~ppOcrEngine();
+            std::vector<std::string> forward(cv::Mat &srcimg);
+    };
+
+}

docker/Dockerfile

+FROM image.sourcefind.cn:5000/dcu/admin/base/migraphx:5.0.0-ubuntu22.04-dtk25.04.1-py3.10
\ No newline at end of file

model.properties

+# 模型唯一标识
+modelCode =
+# 模型名称
+modelName=ppocrv5_migraphx
+# 模型描述
+modelDescription=ppocrv5 
+# 应用场景
+appScenario=制造,政府,医疗,科研,交通,教育
+# 框架类型
+frameType=migraphx