提交PaddleOCR C++示例

Src/PaddleOCR/VLPR/OcrSVTR.cpp

+#include <OcrSVTR.h>
+#include <migraphx/onnx.hpp>
+#include <migraphx/gpu/target.hpp>
+#include <migraphx/gpu/hip.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/quantization.hpp>
+#include <migraphx/reshape2.hpp>
+#include <opencv2/dnn.hpp>
+#include <CommonUtility.h>
+#include <Filesystem.h>
+#include <SimpleLog.h>
+
+using namespace cv::dnn;
+
+namespace migraphxSamples
+{
+SVTR::SVTR():logFile(NULL)
+{
+
+}
+
+SVTR::~SVTR()
+{
+
+    configurationFile.release();
+    
+}
+
+ErrorCode SVTR::Initialize(InitializationParameterOfSVTR InitializationParameterOfSVTR)
+{
+    // 初始化(获取日志文件，加载配置文件等)
+    ErrorCode errorCode = DoCommonInitialization(InitializationParameterOfSVTR);
+    if (errorCode!=SUCCESS)
+    {
+        LOG_ERROR(logFile, "fail to DoCommonInitialization\n");
+        return errorCode;
+    }
+    LOG_INFO(logFile, "success to DoCommonInitialization\n");
+
+    // 获取配置文件参数
+    FileNode netNode = configurationFile["OcrSVTR"];
+    string modelPath = initializationParameter.parentPath + (string)netNode["ModelPath"];
+    string dictPath = (string)netNode["DictPath"];
+
+     // 加载模型
+    if(Exists(modelPath)==false)
+    {
+        LOG_ERROR(logFile,"%s not exist!\n",modelPath.c_str());
+        return MODEL_NOT_EXIST;
+    }
+
+    migraphx::onnx_options onnx_options;
+    onnx_options.map_input_dims["x"]={1,3,48,320};
+    net = migraphx::parse_onnx(modelPath, onnx_options);
+    LOG_INFO(logFile,"succeed to load model: %s\n",GetFileName(modelPath).c_str());
+
+    // 获取模型输入属性
+    std::pair<std::string, migraphx::shape> inputAttribute=*(net.get_parameter_shapes().begin());
+    inputName=inputAttribute.first;
+    inputShape=inputAttribute.second;
+    inputSize=cv::Size(inputShape.lens()[3],inputShape.lens()[2]);
+
+    // 设置模型为GPU模式
+    migraphx::target gpuTarget = migraphx::gpu::target{};
+
+    // 编译模型
+    migraphx::compile_options options;
+    options.device_id=0;                          // 设置GPU设备，默认为0号设备
+    options.offload_copy=true;                    // 设置offload_copy
+    net.compile(gpuTarget,options);               
+    LOG_INFO(logFile,"succeed to compile model: %s\n",GetFileName(modelPath).c_str());
+
+    // Run once by itself
+    migraphx::parameter_map inputData;
+    inputData[inputName]=migraphx::generate_argument(inputShape);
+    net.eval(inputData);  
+
+    std::ifstream in(dictPath);
+    std::string line;
+    if (in)
+    {
+        while (getline(in, line))
+        {
+            charactorDict.push_back(line);
+        }
+        charactorDict.insert(charactorDict.begin(), "#");
+        charactorDict.push_back(" ");
+    }
+    else
+    {
+        std::cout << "no such label file: " << dictPath << ", exit the program..." << std::endl;
+        exit(1);
+    }
+
+    // log
+    LOG_INFO(logFile,"InputMaxSize:%dx%d\n",inputSize.width,inputSize.height);
+    LOG_INFO(logFile,"InputName:%s\n",inputName.c_str());                        
+
+    return SUCCESS;
+}
+
+ErrorCode SVTR::Infer(cv::Mat &img, std::string &resultsChar, float &resultsdScore, float &maxWHRatio)
+{
+    if(img.empty()||img.type()!=CV_8UC3)
+    {
+        LOG_ERROR(logFile, "image error!\n");
+        return IMAGE_ERROR;
+    }
+
+    cv::Mat srcImage;
+    cv::Mat resizeImg;
+    img.copyTo(srcImage);
+
+    float ratio = 1.f;
+    int imgC = 3, imgH = 48;
+    int resizeW;
+    int imgW = int((48 * maxWHRatio));
+    ratio = float(srcImage.cols) / float(srcImage.rows);
+    if (ceil(imgH * ratio) > imgW)
+    {
+        resizeW = imgW;
+    }
+    else
+    {
+        resizeW = int(ceil(imgH * ratio));
+    }
+    cv::resize(srcImage, resizeImg, cv::Size(resizeW, imgH));
+    cv::copyMakeBorder(resizeImg, resizeImg, 0, 0, 0,
+                     int(imgW - resizeImg.cols), cv::BORDER_CONSTANT,
+                     {127, 127, 127});
+
+    resizeImg.convertTo(resizeImg, CV_32FC3, 1.0/255.0);
+    std::vector<cv::Mat> bgrChannels(3);
+    cv::split(resizeImg, bgrChannels);
+    std::vector<float> mean = {0.485f, 0.456f, 0.406f};
+    std::vector<float> scale = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
+    for (auto i = 0; i < bgrChannels.size(); i++)
+    {
+        bgrChannels[i].convertTo(bgrChannels[i], CV_32FC1, 1.0 * scale[i],
+                              (0.0 - mean[i]) * scale[i]);
+    }
+    cv::merge(bgrChannels, resizeImg);
+    cv::Mat inputBlob = cv::dnn::blobFromImage(resizeImg);
+
+    std::vector<std::size_t> inputShapeOfInfer={1,3,48,resizeW};
+
+    // 输入数据
+    migraphx::parameter_map inputData;
+    inputData[inputName]= migraphx::argument{migraphx::shape(inputShape.type(),inputShapeOfInfer), (float*)inputBlob.data};
+
+    // 推理
+    std::vector<migraphx::argument> inferenceResults = net.eval(inputData);
+    
+    // 获取推理结果
+    migraphx::argument result = inferenceResults[0];
+    migraphx::shape outputShape = result.get_shape();
+    int n2 = outputShape.lens()[1];
+    int n3 = outputShape.lens()[2];
+    int n = n2 * n3;
+    std::vector<float> out(n);
+    memcpy(out.data(),result.data(),sizeof(float)*outputShape.elements());
+    out.resize(n);
+
+    int argmaxIdx;
+    int lastIndex = 0;
+    float score = 0.f;
+    int count = 0;
+    float maxValue = 0.0f;
+    for (int j = 0; j < n2; j++)
+    {
+        argmaxIdx = int(std::distance(&out[(j) * n3], 
+                std::max_element(&out[(j) * n3], &out[(j + 1) * n3])));
+        maxValue = float(*std::max_element(&out[(j) * n3], 
+                &out[(j + 1) * n3]));
+
+        if (argmaxIdx > 0 && (!(n > 0 && argmaxIdx == lastIndex))) 
+            {
+                score += maxValue;
+                count += 1;
+                resultsChar += charactorDict[argmaxIdx];
+            }
+        lastIndex = argmaxIdx;
+    }
+    resultsdScore = score / count;
+
+    return SUCCESS;
+}
+
+ErrorCode SVTR::DoCommonInitialization(InitializationParameterOfSVTR InitializationParameterOfSVTR)
+{
+    initializationParameter = InitializationParameterOfSVTR;
+
+    // 获取日志文件
+    logFile=LogManager::GetInstance()->GetLogFile(initializationParameter.logName);
+
+    // 加载配置文件
+    std::string configFilePath=initializationParameter.configFilePath;
+    if(!Exists(configFilePath))
+    {
+        LOG_ERROR(logFile, "no configuration file!\n");
+        return CONFIG_FILE_NOT_EXIST;
+    }
+    if(!configurationFile.open(configFilePath, FileStorage::READ))
+    {
+       LOG_ERROR(logFile, "fail to open configuration file\n");
+       return FAIL_TO_OPEN_CONFIG_FILE;
+    }
+    LOG_INFO(logFile, "succeed to open configuration file\n");
+
+    // 修改父路径
+    std::string &parentPath = initializationParameter.parentPath;
+    if (!parentPath.empty())
+    {
+        if(!IsPathSeparator(parentPath[parentPath.size() - 1]))
+        {
+           parentPath+=PATH_SEPARATOR;
+        }
+    }
+
+    return SUCCESS;
+
+}
+
+
+}

Src/PaddleOCR/VLPR/OcrSVTR.h

+// PaddleOCR车牌识别
+
+#ifndef __OCR_SVTR_H__
+#define __OCR_SVTR_H__
+
+#include <string>
+#include <migraphx/program.hpp>
+#include <opencv2/opencv.hpp>
+#include <CommonDefinition.h>
+
+using namespace std;
+using namespace cv;
+using namespace migraphx;
+
+namespace migraphxSamples
+{
+
+class SVTR
+{
+public:
+    SVTR();
+
+    ~SVTR();
+
+    ErrorCode Initialize(InitializationParameterOfSVTR InitializationParameterOfSVTR);
+
+    ErrorCode Infer(cv::Mat &img, std::string &resultsChar, float &resultsdScore, float &maxWHRatio);
+
+private:
+    ErrorCode DoCommonInitialization(InitializationParameterOfSVTR InitializationParameterOfSVTR);
+
+private:
+    cv::FileStorage configurationFile;
+    InitializationParameterOfSVTR initializationParameter;
+    FILE *logFile;
+
+    migraphx::program net;
+    cv::Size inputSize;
+    string inputName;
+    migraphx::shape inputShape;
+    string dictPath;
+    std::vector<std::string> charactorDict;
+
+};
+}
+
+#endif
\ No newline at end of file

Src/PaddleOCR/VLPR/VLPR.cpp

+#include <VLPR.h>
+#include <SimpleLog.h>
+
+namespace migraphxSamples
+{
+VLPR::VLPR():logFile(NULL)
+{
+
+}
+
+VLPR::~VLPR()
+{
+
+    configurationFile.release();
+    
+}
+
+ErrorCode VLPR::Initialize(InitializationParameterOfDB initParamOfDB, InitializationParameterOfSVTR initParamOfSVTR)
+{
+    // 初始化DB
+    initParamOfDB.parentPath = "";
+    initParamOfDB.configFilePath = CONFIG_FILE;
+    initParamOfDB.logName = "";
+    ErrorCode errorCode=db.Initialize(initParamOfDB);
+    if(errorCode!=SUCCESS)
+    {
+        LOG_ERROR(stdout, "fail to initialize db!\n");
+        exit(-1);
+    }
+    LOG_INFO(stdout, "succeed to initialize db\n");
+
+    // 初始化SVTR
+    initParamOfSVTR.parentPath = "";
+    initParamOfSVTR.configFilePath = CONFIG_FILE;
+    initParamOfSVTR.logName = "";
+    errorCode=svtr.Initialize(initParamOfSVTR);
+    if(errorCode!=SUCCESS)
+    {
+        LOG_ERROR(stdout, "fail to initialize svtr!\n");
+        exit(-1);
+    }
+    LOG_INFO(stdout, "succeed to initialize svtr\n");
+}
+
+ErrorCode VLPR::Infer(cv::Mat &img, std::vector<std::string> &recTexts, std::vector<float> &recTextScores)
+{
+    // DB推理
+    db.Infer(img,imgLists);
+
+    for (int i = 0; i < imgLists.size(); i++)
+    {
+        float maxWHRatio = float(imgLists[i].cols) / float(imgLists[i].rows);
+        
+        // SVTR推理
+        svtr.Infer(imgLists[i], recText, recTextScore, maxWHRatio);
+        recTexts.push_back(recText);
+        recTextScores.push_back(recTextScore);
+    }
+
+    return SUCCESS;
+
+}
+
+}
\ No newline at end of file

Src/PaddleOCR/VLPR/VLPR.h

+// PaddleOCR车牌识别
+#ifndef __VLPR_H__
+#define __VLPR_H__
+
+#include <OcrDB.h>
+#include <OcrSVTR.h>
+#include <opencv2/opencv.hpp>
+#include <CommonDefinition.h>
+
+namespace migraphxSamples
+{
+
+class VLPR
+{
+public:
+    VLPR();
+
+    ~VLPR();
+
+    ErrorCode Initialize(InitializationParameterOfDB initParamOfDB, InitializationParameterOfSVTR initParamOfSVTR);
+
+    ErrorCode Infer(cv::Mat &img, std::vector<std::string> &recTexts, std::vector<float> &recTextScores);
+
+private:
+    DB db;
+    SVTR svtr;
+    FILE *logFile;
+    cv::FileStorage configurationFile;
+    std::vector<cv::Mat> imgLists; 
+    std::string recText;
+    float recTextScore;
+       
+};
+}
+
+#endif
\ No newline at end of file

Src/PaddleOCR/VLPR/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/PaddleOCR/VLPR/utility.cpp

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <dirent.h>
+#include <utility.h>
+#include <iostream>
+#include <ostream>
+
+#include <vector>
+
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#endif
+
+namespace migraphxSamples {
+
+std::vector<std::string> Utility::ReadDict(const std::string &path) {
+  std::ifstream in(path);
+  std::string line;
+  std::vector<std::string> m_vec;
+  if (in) {
+    while (getline(in, line)) {
+      m_vec.push_back(line);
+    }
+  } else {
+    std::cout << "no such label file: " << path << ", exit the program..."
+              << std::endl;
+    exit(1);
+  }
+  return m_vec;
+}
+
+void Utility::VisualizeBboxes(const cv::Mat &srcimg,
+                              const std::vector<OCRPredictResult> &ocr_result,
+                              const std::string &save_path) {
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  for (int n = 0; n < ocr_result.size(); n++) {
+    cv::Point rook_points[4];
+    for (int m = 0; m < ocr_result[n].box.size(); m++) {
+      rook_points[m] =
+          cv::Point(int(ocr_result[n].box[m][0]), int(ocr_result[n].box[m][1]));
+    }
+
+    const cv::Point *ppt[1] = {rook_points};
+    int npt[] = {4};
+    cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+  }
+
+  cv::imwrite(save_path, img_vis);
+  std::cout << "The detection visualized image saved in " + save_path
+            << std::endl;
+}
+
+void Utility::VisualizeBboxes(const cv::Mat &srcimg,
+                              const StructurePredictResult &structure_result,
+                              const std::string &save_path) {
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  img_vis = crop_image(img_vis, structure_result.box);
+  for (int n = 0; n < structure_result.cell_box.size(); n++) {
+    if (structure_result.cell_box[n].size() == 8) {
+      cv::Point rook_points[4];
+      for (int m = 0; m < structure_result.cell_box[n].size(); m += 2) {
+        rook_points[m / 2] =
+            cv::Point(int(structure_result.cell_box[n][m]),
+                      int(structure_result.cell_box[n][m + 1]));
+      }
+      const cv::Point *ppt[1] = {rook_points};
+      int npt[] = {4};
+      cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+    } else if (structure_result.cell_box[n].size() == 4) {
+      cv::Point rook_points[2];
+      rook_points[0] = cv::Point(int(structure_result.cell_box[n][0]),
+                                 int(structure_result.cell_box[n][1]));
+      rook_points[1] = cv::Point(int(structure_result.cell_box[n][2]),
+                                 int(structure_result.cell_box[n][3]));
+      cv::rectangle(img_vis, rook_points[0], rook_points[1], CV_RGB(0, 255, 0),
+                    2, 8, 0);
+    }
+  }
+
+  cv::imwrite(save_path, img_vis);
+  std::cout << "The table visualized image saved in " + save_path << std::endl;
+}
+
+// list all files under a directory
+void Utility::GetAllFiles(const char *dir_name,
+                          std::vector<std::string> &all_inputs) {
+  if (NULL == dir_name) {
+    std::cout << " dir_name is null ! " << std::endl;
+    return;
+  }
+  struct stat s;
+  stat(dir_name, &s);
+  if (!S_ISDIR(s.st_mode)) {
+    std::cout << "dir_name is not a valid directory !" << std::endl;
+    all_inputs.push_back(dir_name);
+    return;
+  } else {
+    struct dirent *filename; // return value for readdir()
+    DIR *dir;                // return value for opendir()
+    dir = opendir(dir_name);
+    if (NULL == dir) {
+      std::cout << "Can not open dir " << dir_name << std::endl;
+      return;
+    }
+    std::cout << "Successfully opened the dir !" << std::endl;
+    while ((filename = readdir(dir)) != NULL) {
+      if (strcmp(filename->d_name, ".") == 0 ||
+          strcmp(filename->d_name, "..") == 0)
+        continue;
+      // img_dir + std::string("/") + all_inputs[0];
+      all_inputs.push_back(dir_name + std::string("/") +
+                           std::string(filename->d_name));
+    }
+  }
+}
+
+cv::Mat Utility::GetRotateCropImage(const cv::Mat &srcimage,
+                                    std::vector<std::vector<int>> box) {
+  cv::Mat image;
+  srcimage.copyTo(image);
+  std::vector<std::vector<int>> points = box;
+
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+
+  cv::Mat img_crop;
+  image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
+
+  for (int i = 0; i < points.size(); i++) {
+    points[i][0] -= left;
+    points[i][1] -= top;
+  }
+
+  int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
+                                pow(points[0][1] - points[1][1], 2)));
+  int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
+                                 pow(points[0][1] - points[3][1], 2)));
+
+  cv::Point2f pts_std[4];
+  pts_std[0] = cv::Point2f(0., 0.);
+  pts_std[1] = cv::Point2f(img_crop_width, 0.);
+  pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
+  pts_std[3] = cv::Point2f(0.f, img_crop_height);
+
+  cv::Point2f pointsf[4];
+  pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
+  pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
+  pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
+  pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
+
+  cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
+
+  cv::Mat dst_img;
+  cv::warpPerspective(img_crop, dst_img, M,
+                      cv::Size(img_crop_width, img_crop_height),
+                      cv::BORDER_REPLICATE);
+
+  if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
+    cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
+    cv::transpose(dst_img, srcCopy);
+    cv::flip(srcCopy, srcCopy, 0);
+    return srcCopy;
+  } else {
+    return dst_img;
+  }
+}
+
+std::vector<int> Utility::argsort(const std::vector<float> &array) {
+  const int array_len(array.size());
+  std::vector<int> array_index(array_len, 0);
+  for (int i = 0; i < array_len; ++i)
+    array_index[i] = i;
+
+  std::sort(
+      array_index.begin(), array_index.end(),
+      [&array](int pos1, int pos2) { return (array[pos1] < array[pos2]); });
+
+  return array_index;
+}
+
+std::string Utility::basename(const std::string &filename) {
+  if (filename.empty()) {
+    return "";
+  }
+
+  auto len = filename.length();
+  auto index = filename.find_last_of("/\\");
+
+  if (index == std::string::npos) {
+    return filename;
+  }
+
+  if (index + 1 >= len) {
+
+    len--;
+    index = filename.substr(0, len).find_last_of("/\\");
+
+    if (len == 0) {
+      return filename;
+    }
+
+    if (index == 0) {
+      return filename.substr(1, len - 1);
+    }
+
+    if (index == std::string::npos) {
+      return filename.substr(0, len);
+    }
+
+    return filename.substr(index + 1, len - index - 1);
+  }
+
+  return filename.substr(index + 1, len - index);
+}
+
+bool Utility::PathExists(const std::string &path) {
+#ifdef _WIN32
+  struct _stat buffer;
+  return (_stat(path.c_str(), &buffer) == 0);
+#else
+  struct stat buffer;
+  return (stat(path.c_str(), &buffer) == 0);
+#endif // !_WIN32
+}
+
+void Utility::CreateDir(const std::string &path) {
+#ifdef _WIN32
+  _mkdir(path.c_str());
+#else
+  mkdir(path.c_str(), 0777);
+#endif // !_WIN32
+}
+
+void Utility::print_result(const std::vector<OCRPredictResult> &ocr_result) {
+  for (int i = 0; i < ocr_result.size(); i++) {
+    std::cout << i << "\t";
+    // det
+    std::vector<std::vector<int>> boxes = ocr_result[i].box;
+    if (boxes.size() > 0) {
+      std::cout << "det boxes: [";
+      for (int n = 0; n < boxes.size(); n++) {
+        std::cout << '[' << boxes[n][0] << ',' << boxes[n][1] << "]";
+        if (n != boxes.size() - 1) {
+          std::cout << ',';
+        }
+      }
+      std::cout << "] ";
+    }
+    // rec
+    if (ocr_result[i].score != -1.0) {
+      std::cout << "rec text: " << ocr_result[i].text
+                << " rec score: " << ocr_result[i].score << " ";
+    }
+
+    // cls
+    if (ocr_result[i].cls_label != -1) {
+      std::cout << "cls label: " << ocr_result[i].cls_label
+                << " cls score: " << ocr_result[i].cls_score;
+    }
+    std::cout << std::endl;
+  }
+}
+
+cv::Mat Utility::crop_image(cv::Mat &img, const std::vector<int> &box) {
+  cv::Mat crop_im;
+  int crop_x1 = std::max(0, box[0]);
+  int crop_y1 = std::max(0, box[1]);
+  int crop_x2 = std::min(img.cols - 1, box[2] - 1);
+  int crop_y2 = std::min(img.rows - 1, box[3] - 1);
+
+  crop_im = cv::Mat::zeros(box[3] - box[1], box[2] - box[0], 16);
+  cv::Mat crop_im_window =
+      crop_im(cv::Range(crop_y1 - box[1], crop_y2 + 1 - box[1]),
+              cv::Range(crop_x1 - box[0], crop_x2 + 1 - box[0]));
+  cv::Mat roi_img =
+      img(cv::Range(crop_y1, crop_y2 + 1), cv::Range(crop_x1, crop_x2 + 1));
+  crop_im_window += roi_img;
+  return crop_im;
+}
+
+cv::Mat Utility::crop_image(cv::Mat &img, const std::vector<float> &box) {
+  std::vector<int> box_int = {(int)box[0], (int)box[1], (int)box[2],
+                              (int)box[3]};
+  return crop_image(img, box_int);
+}
+
+void Utility::sorted_boxes(std::vector<OCRPredictResult> &ocr_result) {
+  std::sort(ocr_result.begin(), ocr_result.end(), Utility::comparison_box);
+  if (ocr_result.size() > 0) {
+    for (int i = 0; i < ocr_result.size() - 1; i++) {
+      for (int j = i; j > 0; j--) {
+        if (abs(ocr_result[j + 1].box[0][1] - ocr_result[j].box[0][1]) < 10 &&
+            (ocr_result[j + 1].box[0][0] < ocr_result[j].box[0][0])) {
+          std::swap(ocr_result[i], ocr_result[i + 1]);
+        }
+      }
+    }
+  }
+}
+
+std::vector<int> Utility::xyxyxyxy2xyxy(std::vector<std::vector<int>> &box) {
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+  std::vector<int> box1(4, 0);
+  box1[0] = left;
+  box1[1] = top;
+  box1[2] = right;
+  box1[3] = bottom;
+  return box1;
+}
+
+std::vector<int> Utility::xyxyxyxy2xyxy(std::vector<int> &box) {
+  int x_collect[4] = {box[0], box[2], box[4], box[6]};
+  int y_collect[4] = {box[1], box[3], box[5], box[7]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+  std::vector<int> box1(4, 0);
+  box1[0] = left;
+  box1[1] = top;
+  box1[2] = right;
+  box1[3] = bottom;
+  return box1;
+}
+
+float Utility::fast_exp(float x) {
+  union {
+    uint32_t i;
+    float f;
+  } v{};
+  v.i = (1 << 23) * (1.4426950409 * x + 126.93490512f);
+  return v.f;
+}
+
+std::vector<float>
+Utility::activation_function_softmax(std::vector<float> &src) {
+  int length = src.size();
+  std::vector<float> dst;
+  dst.resize(length);
+  const float alpha = float(*std::max_element(&src[0], &src[0 + length]));
+  float denominator{0};
+
+  for (int i = 0; i < length; ++i) {
+    dst[i] = fast_exp(src[i] - alpha);
+    denominator += dst[i];
+  }
+
+  for (int i = 0; i < length; ++i) {
+    dst[i] /= denominator;
+  }
+  return dst;
+}
+
+float Utility::iou(std::vector<int> &box1, std::vector<int> &box2) {
+  int area1 = std::max(0, box1[2] - box1[0]) * std::max(0, box1[3] - box1[1]);
+  int area2 = std::max(0, box2[2] - box2[0]) * std::max(0, box2[3] - box2[1]);
+
+  // computing the sum_area
+  int sum_area = area1 + area2;
+
+  // find the each point of intersect rectangle
+  int x1 = std::max(box1[0], box2[0]);
+  int y1 = std::max(box1[1], box2[1]);
+  int x2 = std::min(box1[2], box2[2]);
+  int y2 = std::min(box1[3], box2[3]);
+
+  // judge if there is an intersect
+  if (y1 >= y2 || x1 >= x2) {
+    return 0.0;
+  } else {
+    int intersect = (x2 - x1) * (y2 - y1);
+    return intersect / (sum_area - intersect + 0.00000001);
+  }
+}
+
+float Utility::iou(std::vector<float> &box1, std::vector<float> &box2) {
+  float area1 = std::max((float)0.0, box1[2] - box1[0]) *
+                std::max((float)0.0, box1[3] - box1[1]);
+  float area2 = std::max((float)0.0, box2[2] - box2[0]) *
+                std::max((float)0.0, box2[3] - box2[1]);
+
+  // computing the sum_area
+  float sum_area = area1 + area2;
+
+  // find the each point of intersect rectangle
+  float x1 = std::max(box1[0], box2[0]);
+  float y1 = std::max(box1[1], box2[1]);
+  float x2 = std::min(box1[2], box2[2]);
+  float y2 = std::min(box1[3], box2[3]);
+
+  // judge if there is an intersect
+  if (y1 >= y2 || x1 >= x2) {
+    return 0.0;
+  } else {
+    float intersect = (x2 - x1) * (y2 - y1);
+    return intersect / (sum_area - intersect + 0.00000001);
+  }
+}
+
+} // namespace migraphxSamples
\ No newline at end of file

Src/PaddleOCR/VLPR/utility.h

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <stdlib.h>
+#include <vector>
+
+#include <algorithm>
+#include <cstring>
+#include <fstream>
+#include <numeric>
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+
+namespace migraphxSamples {
+
+struct OCRPredictResult {
+  std::vector<std::vector<int>> box;
+  std::string text;
+  float score = -1.0;
+  float cls_score;
+  int cls_label = -1;
+};
+
+struct StructurePredictResult {
+  std::vector<float> box;
+  std::vector<std::vector<int>> cell_box;
+  std::string type;
+  std::vector<OCRPredictResult> text_res;
+  std::string html;
+  float html_score = -1;
+  float confidence;
+};
+
+class Utility {
+public:
+  static std::vector<std::string> ReadDict(const std::string &path);
+
+  static void VisualizeBboxes(const cv::Mat &srcimg,
+                              const std::vector<OCRPredictResult> &ocr_result,
+                              const std::string &save_path);
+
+  static void VisualizeBboxes(const cv::Mat &srcimg,
+                              const StructurePredictResult &structure_result,
+                              const std::string &save_path);
+
+  template <class ForwardIterator>
+  inline static size_t argmax(ForwardIterator first, ForwardIterator last) {
+    return std::distance(first, std::max_element(first, last));
+  }
+
+  static void GetAllFiles(const char *dir_name,
+                          std::vector<std::string> &all_inputs);
+
+  static cv::Mat GetRotateCropImage(const cv::Mat &srcimage,
+                                    std::vector<std::vector<int>> box);
+
+  static std::vector<int> argsort(const std::vector<float> &array);
+
+  static std::string basename(const std::string &filename);
+
+  static bool PathExists(const std::string &path);
+
+  static void CreateDir(const std::string &path);
+
+  static void print_result(const std::vector<OCRPredictResult> &ocr_result);
+
+  static cv::Mat crop_image(cv::Mat &img, const std::vector<int> &area);
+  static cv::Mat crop_image(cv::Mat &img, const std::vector<float> &area);
+
+  static void sorted_boxes(std::vector<OCRPredictResult> &ocr_result);
+
+  static std::vector<int> xyxyxyxy2xyxy(std::vector<std::vector<int>> &box);
+  static std::vector<int> xyxyxyxy2xyxy(std::vector<int> &box);
+
+  static float fast_exp(float x);
+  static std::vector<float>
+  activation_function_softmax(std::vector<float> &src);
+  static float iou(std::vector<int> &box1, std::vector<int> &box2);
+  static float iou(std::vector<float> &box1, std::vector<float> &box2);
+
+private:
+  static bool comparison_box(const OCRPredictResult &result1,
+                             const OCRPredictResult &result2) {
+    if (result1.box[0][1] < result2.box[0][1]) {
+      return true;
+    } else if (result1.box[0][1] == result2.box[0][1]) {
+      return result1.box[0][0] < result2.box[0][0];
+    } else {
+      return false;
+    }
+  }
+};
+
+} // namespace migraphxSamples
\ No newline at end of file

Src/Sample.cpp

+#include <Sample.h>
+#include <opencv2/dnn.hpp>
+#include <SimpleLog.h>
+#include <Filesystem.h>
+#include <VLPR.h>
+#include <fstream>
+
+
+using namespace std;
+using namespace cv;
+using namespace cv::dnn;
+using namespace migraphx;
+using namespace migraphxSamples;
+
+
+void Sample_VLPR()
+{
+    // 创建PaddleOCR车牌识别
+    VLPR vlpr;
+    InitializationParameterOfDB initParamOfDB; 
+    InitializationParameterOfSVTR initParamOfSVTR;
+    vlpr.Initialize(initParamOfDB, initParamOfSVTR);
+
+    // 读取测试图片
+    cv:: Mat Image=cv::imread("../Resource/Images/vlpr.jpg", 1);
+
+    // 推理
+    std::vector<std::string> recTexts;
+    std::vector<float> recTextScores;
+    double time1 = getTickCount();
+    vlpr.Infer(Image, recTexts, recTextScores); 
+    double time2 = getTickCount();
+    double elapsedTime = (time2 - time1)*1000 / getTickFrequency();
+    LOG_INFO(stdout, "inference time:%f ms\n", elapsedTime);
+
+    // 打印结果
+    for (int i = 0; i < recTexts.size(); i++) 
+    {
+        printf("VLPR Result:[%s, %f]\n", recTexts[i].c_str(), recTextScores[i]);
+    }
+}
\ No newline at end of file

Src/Sample.h

+// 示例程序
+
+#ifndef __SAMPLE_H__
+#define __SAMPLE_H__
+
+
+// VLPR  sample
+void Sample_VLPR();
+
+
+#endif
\ No newline at end of file

Src/Utility/CommonDefinition.h

+// 常用数据类型和宏定义
+
+#ifndef __COMMON_DEFINITION_H__
+#define __COMMON_DEFINITION_H__
+
+#include <string>
+#include <opencv2/opencv.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace migraphxSamples
+{
+   
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define  PATH_SEPARATOR '\\'
+#else
+#define  PATH_SEPARATOR '/'
+#endif
+
+#define CONFIG_FILE                                                     "../Resource/Configuration.xml"
+
+typedef struct  __Time
+{
+    string year;
+    string month;
+    string day;
+    string hour;
+    string minute;
+    string second;
+    string millisecond; // ms
+    string microsecond; // us
+    string weekDay;
+}_Time;
+
+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  _ResultOfDetection
+{
+    Rect boundingBox;
+    float confidence;
+    int classID;
+    string className;
+    bool exist;
+
+    _ResultOfDetection():confidence(0.0f),classID(0),exist(true){}
+
+}ResultOfDetection;
+
+typedef struct  _InitializationParameterOfDetector
+{
+    std::string parentPath;
+    std::string configFilePath;
+    cv::Size inputSize;
+    std::string logName;
+}InitializationParameterOfDetector;
+
+typedef struct _InitializationParameterOfDetector InitializationParameterOfDB;
+typedef struct _InitializationParameterOfDetector InitializationParameterOfSVTR;
+
+}
+
+#endif
+

Src/Utility/CommonUtility.cpp

+#include <CommonUtility.h>
+#include <assert.h>
+#include <ctype.h>
+#include <time.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <sstream>
+#include <vector>
+
+#ifdef _WIN32
+#include <io.h>
+#include <direct.h>
+#include <Windows.h>
+#else
+#include <unistd.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#endif
+
+#include <SimpleLog.h>
+
+namespace migraphxSamples
+{
+
+
+_Time GetCurrentTime3()
+{
+    _Time 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",tv.tv_usec/1000);
+	currentTime.millisecond = string(temp);
+    sprintf(temp, "%03d", tv.tv_usec % 1000);
+	currentTime.microsecond = string(temp);
+    sprintf(temp, "%d", p->tm_wday);
+    currentTime.weekDay = string(temp);
+#endif
+    return currentTime;
+}
+
+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;
+}
+
+
+bool CompareConfidence(const ResultOfDetection &L,const ResultOfDetection &R)
+{
+    return L.confidence > R.confidence;
+}
+
+bool CompareArea(const ResultOfDetection &L,const ResultOfDetection &R)
+{
+    return L.boundingBox.area() > R.boundingBox.area();
+}
+
+void NMS(vector<ResultOfDetection> &detections, float IOUThreshold)
+{
+    // sort
+    std::sort(detections.begin(), detections.end(), CompareConfidence);
+
+    for (int i = 0; i<detections.size(); ++i)
+    {
+        if (detections[i].exist)
+        {
+            for (int j = i + 1; j<detections.size(); ++j)
+            {
+                if (detections[j].exist)
+                {
+                    // compute IOU
+                    float intersectionArea = (detections[i].boundingBox & detections[j].boundingBox).area();
+                    float intersectionRate = intersectionArea / (detections[i].boundingBox.area() + detections[j].boundingBox.area() - intersectionArea);
+
+                    if (intersectionRate>IOUThreshold)
+                    {
+                        detections[j].exist = false;
+                    }
+                }
+            }
+        }
+    }
+
+}
+
+}

Src/Utility/CommonUtility.h

+// 常用工具
+
+#ifndef __COMMON_UTILITY_H__
+#define __COMMON_UTILITY_H__
+
+#include <mutex>
+#include <string>
+#include <vector>
+#include <CommonDefinition.h>
+
+using namespace std;
+
+namespace migraphxSamples
+{
+
+// 分割字符串
+std::vector<std::string> SplitString(std::string str,std::string separator);
+
+// 排序规则: 按照置信度或者按照面积排序
+bool CompareConfidence(const ResultOfDetection &L,const ResultOfDetection &R);
+bool CompareArea(const ResultOfDetection &L,const ResultOfDetection &R);
+
+void NMS(std::vector<ResultOfDetection> &detections, float IOUThreshold);
+
+}
+
+#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
+#include <CommonUtility.h>
+#include <opencv2/opencv.hpp>
+#include <SimpleLog.h>
+
+using namespace cv;
+ 
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define  PATH_SEPARATOR '\\'
+#else
+#define  PATH_SEPARATOR '/'
+#endif
+
+namespace migraphxSamples
+{
+
+#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
+		{
+			LOG_INFO(stdout, "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)
+			{
+				LOG_INFO(stdout, "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)
+			{
+				LOG_INFO(stdout, "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;
+						LOG_INFO(stdout, "%s deleted! number of deleted files:%d\n", path.c_str(), numberOfFiles);
+					}
+
+				}
+			}
+			catch (...)
+			{
+				closedir(dir);
+				throw;
+			}
+			closedir(dir);
+		}
+		else
+		{
+			LOG_INFO(stdout, "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())
+        {
+            LOG_ERROR(stdout,"can not open %s\n",srcPath.c_str());
+            return false;
+        }
+        if(!dstFile.is_open())
+        {
+			LOG_ERROR(stdout, "can not open %s\n", dstPath.c_str());
+            return false;
+        }
+        if(srcPath==dstPath)
+        {
+			LOG_ERROR(stdout, "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)
+        {
+			LOG_ERROR(stdout, "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;
+			LOG_INFO(stdout, "%s done! %f% \n", GetFileName(fileNameList[i]).c_str(), process);
+        }
+		LOG_INFO(stdout, "all done!(the number of files:%d)\n", fileNameList.size());
+
+        return true;
+
+
+    }
+
+}
+
+

Src/Utility/Filesystem.h

+// 文件以及目录处理
+
+#ifndef __FILE_SYSTEM_H__
+#define __FILE_SYSTEM_H__
+
+#include <vector>
+#include <string>
+
+using namespace std;
+ 
+namespace migraphxSamples
+{
+
+// 路径是否存在
+bool Exists(const std::string &path);
+
+// 路径是否为目录
+bool IsDirectory(const std::string &path);
+
+// 是否是路径分隔符(Linux:‘/’,Windows:’\\’)
+bool IsPathSeparator(char c);
+
+// 路径拼接
+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/
+
+*/
+string GetFileName(const std::string &path); // 1.txt
+string GetFileName_NoExtension(const std::string &path); // 1
+string GetExtension(const std::string &path);// .txt
+string GetParentPath(const std::string &path);// D:/1/
+
+// 拷贝文件:CopyFile("D:/1.txt","D:/2.txt");将1.txt拷贝为2.txt
+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);
+
+}
+
+#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/main.cpp

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <Sample.h>
+
+void MIGraphXSamplesUsage(char* programName)
+{
+    printf("Usage : %s <index> \n", programName);
+    printf("index:\n");
+    printf("\t 0) PaddleOCR VLPR sample.\n");
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2 || argc > 2)
+    {
+        MIGraphXSamplesUsage(argv[0]);
+        return -1;
+    }
+    if (!strncmp(argv[1], "-h", 2))
+    {
+        MIGraphXSamplesUsage(argv[0]);
+        return 0;
+    }
+    switch (*argv[1])
+    {  
+        case '0':
+            {
+                Sample_VLPR();
+                break;
+            }
+        default :
+            {
+                MIGraphXSamplesUsage(argv[0]);
+                break;
+            }
+    }
+    return 0;
+}
\ No newline at end of file

requirements.txt

-shapely
-pyclipper
-numpy
-opencv-contrib-python==4.6.0.66
-pillow
+./3rdParty/opencv-3.4.11_mini.tar.gz
+
\ No newline at end of file