add text detection model from ppocrv3 (#180)

CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.24)
+set(project_name "opencv_zoo_text_detection_ppocr")
+
+PROJECT (${project_name})
+
+set(OPENCV_VERSION "4.8.0")
+set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
+find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
+# Find OpenCV, you may need to set OpenCV_DIR variable
+# to the absolute path to the directory containing OpenCVConfig.cmake file
+# via the command line or GUI
+
+file(GLOB SourceFile
+    "demo.cpp")
+# If the package has been found, several variables will
+# be set, you can find the full list with descriptions
+# in the OpenCVConfig.cmake file.
+# Print some message showing some of them
+message(STATUS "OpenCV library status:")
+message(STATUS "    config: ${OpenCV_DIR}")
+message(STATUS "    version: ${OpenCV_VERSION}")
+message(STATUS "    libraries: ${OpenCV_LIBS}")
+message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
+
+# Declare the executable target built from your sources
+add_executable(${project_name} ${SourceFile})
+
+# Link your application with OpenCV libraries
+target_link_libraries(${project_name} PRIVATE ${OpenCV_LIBS})

LICENSE

@@ -0,0 +1,203 @@
+Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2016 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.

README.md

@@ -0,0 +1,60 @@
+# PP-OCRv3 Text Detection
+
+PP-OCRv3: More Attempts for the Improvement of Ultra Lightweight OCR System.
+
+Note:
+
+- The int8 quantization model may produce unstable results due to some loss of accuracy.
+- Original Paddle Models source of English: [here](https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_det_infer.tar).
+- Original Paddle Models source of Chinese: [here](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_infer.tar).
+- `IC15` in the filename means the model is trained on [IC15 dataset](https://rrc.cvc.uab.es/?ch=4&com=introduction), which can detect English text instances only.
+- `TD500` in the filename means the model is trained on [TD500 dataset](http://www.iapr-tc11.org/mediawiki/index.php/MSRA_Text_Detection_500_Database_(MSRA-TD500)), which can detect both English & Chinese instances.
+- Visit https://docs.opencv.org/master/d4/d43/tutorial_dnn_text_spotting.html for more information.
+
+## Demo
+
+### Python
+
+Run the following command to try the demo:
+
+```shell
+# detect on camera input
+python demo.py
+# detect on an image
+python demo.py --input /path/to/image -v
+
+# get help regarding various parameters
+python demo.py --help
+```
+
+### C++
+
+Install latest OpenCV and CMake >= 3.24.0 to get started with:
+
+```shell
+# A typical and default installation path of OpenCV is /usr/local
+cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
+cmake --build build
+# detect on camera input
+./build/opencv_zoo_text_detection_ppocr -m=/path/to/model
+# detect on an image
+./build/opencv_zoo_text_detection_ppocr -m=/path/to/model -i=/path/to/image -v
+# get help messages
+./build/opencv_zoo_text_detection_ppocr -h
+```
+
+### Example outputs
+
+![mask](./example_outputs/mask.jpg)
+
+![gsoc](./example_outputs/gsoc.jpg)
+
+## License
+
+All files in this directory are licensed under [Apache 2.0 License](./LICENSE).
+
+## Reference
+
+- https://arxiv.org/abs/2206.03001
+- https://github.com/PaddlePaddle/PaddleOCR
+- https://docs.opencv.org/master/d4/d43/tutorial_dnn_text_spotting.html

demo.cpp

@@ -0,0 +1,183 @@
+#include <iostream>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace dnn;
+
+vector< pair<cv::dnn::Backend, cv::dnn::Target> > backendTargetPairs = {
+        std::make_pair<cv::dnn::Backend, cv::dnn::Target>(dnn::DNN_BACKEND_OPENCV, dnn::DNN_TARGET_CPU),
+        std::make_pair<cv::dnn::Backend, cv::dnn::Target>(dnn::DNN_BACKEND_CUDA, dnn::DNN_TARGET_CUDA),
+        std::make_pair<cv::dnn::Backend, cv::dnn::Target>(dnn::DNN_BACKEND_CUDA, dnn::DNN_TARGET_CUDA_FP16),
+        std::make_pair<cv::dnn::Backend, cv::dnn::Target>(dnn::DNN_BACKEND_TIMVX, dnn::DNN_TARGET_NPU),
+        std::make_pair<cv::dnn::Backend, cv::dnn::Target>(dnn::DNN_BACKEND_CANN, dnn::DNN_TARGET_NPU)};
+        
+
+std::string keys =
+"{ help  h           |                                              | Print help message. }"
+"{ model m           | text_detection_ch_ppocrv3_2023may.onnx       | Usage: Set model type, defaults to text_detection_ch_ppocrv3_2023may.onnx }"
+"{ input i           |                                              | Usage: Path to input image or video file. Skip this argument to capture frames from a camera.}"
+"{ width             | 736                                          | Usage: Resize input image to certain width, default = 736. It should be multiple by 32.}"
+"{ height            | 736                                          | Usage: Resize input image to certain height, default = 736. It should be multiple by 32.}"
+"{ binary_threshold  | 0.3                                          | Usage: Threshold of the binary map, default = 0.3.}"
+"{ polygon_threshold | 0.5                                          | Usage: Threshold of polygons, default = 0.5.}"
+"{ max_candidates    | 200                                          | Usage: Set maximum number of polygon candidates, default = 200.}"
+"{ unclip_ratio      | 2.0                                          | Usage: The unclip ratio of the detected text region, which determines the output size, default = 2.0.}"
+"{ save s            | true                                         | Usage: Specify to save file with results (i.e. bounding box, confidence level). Invalid in case of camera input.}"
+"{ viz v             | true                                         | Usage: Specify to open a new window to show results. Invalid in case of camera input.}"
+"{ backend bt        | 0                                            | Choose one of computation backends: "
+"0: (default) OpenCV implementation + CPU, "
+"1: CUDA + GPU (CUDA), "
+"2: CUDA + GPU (CUDA FP16), "
+"3: TIM-VX + NPU, "
+"4: CANN + NPU}";
+
+
+class PPOCRDet {
+public:
+
+    PPOCRDet(string modPath, Size inSize = Size(736, 736), float binThresh = 0.3,
+        float polyThresh = 0.5, int maxCand = 200, double unRatio = 2.0,
+        dnn::Backend bId = DNN_BACKEND_DEFAULT, dnn::Target tId = DNN_TARGET_CPU) : modelPath(modPath), inputSize(inSize), binaryThreshold(binThresh),
+        polygonThreshold(polyThresh), maxCandidates(maxCand), unclipRatio(unRatio),
+        backendId(bId), targetId(tId)
+    {
+        this->model = TextDetectionModel_DB(readNet(modelPath));
+        this->model.setPreferableBackend(backendId);
+        this->model.setPreferableTarget(targetId);
+
+        this->model.setBinaryThreshold(binaryThreshold);
+        this->model.setPolygonThreshold(polygonThreshold);
+        this->model.setUnclipRatio(unclipRatio);
+        this->model.setMaxCandidates(maxCandidates);
+
+        this->model.setInputParams(1.0 / 255.0, inputSize, Scalar(122.67891434, 116.66876762, 104.00698793));
+    }
+    pair< vector<vector<Point>>, vector<float> > infer(Mat image) {
+        CV_Assert(image.rows == this->inputSize.height && "height of input image != net input size ");
+        CV_Assert(image.cols == this->inputSize.width && "width of input image != net input size ");
+        vector<vector<Point>> pt;
+        vector<float> confidence;
+        this->model.detect(image, pt, confidence);
+        return make_pair< vector<vector<Point>> &, vector< float > &>(pt, confidence);
+    }
+
+private:
+    string modelPath;
+    TextDetectionModel_DB model;
+    Size inputSize;
+    float binaryThreshold;
+    float polygonThreshold;
+    int maxCandidates;
+    double unclipRatio;
+    dnn::Backend backendId;
+    dnn::Target targetId;
+
+};
+
+Mat visualize(Mat image, pair< vector<vector<Point>>, vector<float> >&results, double fps=-1, Scalar boxColor=Scalar(0, 255, 0), Scalar textColor=Scalar(0, 0, 255), bool isClosed=true, int thickness=2)
+{
+    Mat output;
+    image.copyTo(output);
+    if (fps > 0)
+        putText(output, format("FPS: %.2f", fps), Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, textColor);
+    polylines(output, results.first, isClosed, boxColor, thickness);
+    return output;
+}
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    parser.about("Use this program to run Real-time Scene Text Detection with Differentiable Binarization in opencv Zoo  using OpenCV.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    int backendTargetid = parser.get<int>("backend");
+    String modelName = parser.get<String>("model");
+
+    if (modelName.empty())
+    {
+        CV_Error(Error::StsError, "Model file " + modelName + " not found");
+    }
+
+    Size inpSize(parser.get<int>("width"), parser.get<int>("height"));
+    float binThresh = parser.get<float>("binary_threshold");
+    float polyThresh = parser.get<float>("polygon_threshold");
+    int maxCand = parser.get<int>("max_candidates");
+    double unRatio = parser.get<float>("unclip_ratio");
+    bool save = parser.get<bool>("save");
+    bool viz = parser.get<float>("viz");
+
+    PPOCRDet model(modelName, inpSize, binThresh, polyThresh, maxCand, unRatio, backendTargetPairs[backendTargetid].first, backendTargetPairs[backendTargetid].second);
+
+    //! [Open a video file or an image file or a camera stream]
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(parser.get<String>("input"));
+    else
+        cap.open(0);
+    if (!cap.isOpened())
+        CV_Error(Error::StsError, "Cannot opend video or file");
+    Mat originalImage;
+    static const std::string kWinName = modelName;
+    while (waitKey(1) < 0)
+    {
+        cap >> originalImage;
+        if (originalImage.empty())
+        {
+            if (parser.has("input"))
+            {
+                cout << "Frame is empty" << endl;
+                break;
+            }
+            else
+                continue;
+        }
+        int originalW = originalImage.cols;
+        int originalH = originalImage.rows;
+        double scaleHeight = originalH / double(inpSize.height);
+        double scaleWidth = originalW / double(inpSize.width);
+        Mat image;
+        resize(originalImage, image, inpSize);
+
+        // inference
+        TickMeter tm;
+        tm.start();
+        pair< vector<vector<Point>>, vector<float> > results = model.infer(image);
+        tm.stop();
+        auto x = results.first;
+        // Scale the results bounding box
+        for (auto &pts : results.first)
+        {
+            for (int i = 0; i < 4; i++)
+            {
+                pts[i].x = int(pts[i].x * scaleWidth);
+                pts[i].y = int(pts[i].y * scaleHeight);
+            }
+        }
+        originalImage = visualize(originalImage, results, tm.getFPS());
+        tm.reset();
+        if (parser.has("input"))
+        {
+            if (save)
+            {
+                cout << "Result image saved to result.jpg\n";
+                imwrite("result.jpg", originalImage);
+            }
+            if (viz)
+                imshow(kWinName, originalImage);
+        }
+        else
+            imshow(kWinName, originalImage);
+    }
+    return 0;
+}
+
+

demo.py

@@ -0,0 +1,154 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+import argparse
+
+import numpy as np
+import cv2 as cv
+
+from ppocr_det import PPOCRDet
+
+# Check OpenCV version
+assert cv.__version__ >= "4.8.0", \
+       "Please install latest opencv-python to try this demo: python3 -m pip install --upgrade opencv-python"
+
+# Valid combinations of backends and targets
+backend_target_pairs = [
+    [cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_CPU],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA_FP16],
+    [cv.dnn.DNN_BACKEND_TIMVX,  cv.dnn.DNN_TARGET_NPU],
+    [cv.dnn.DNN_BACKEND_CANN,   cv.dnn.DNN_TARGET_NPU]
+]
+
+parser = argparse.ArgumentParser(description='PP-OCR Text Detection (https://arxiv.org/abs/2206.03001).')
+parser.add_argument('--input', '-i', type=str,
+                    help='Usage: Set path to the input image. Omit for using default camera.')
+parser.add_argument('--model', '-m', type=str, default='./text_detection_en_ppocrv3_2023may.onnx',
+                    help='Usage: Set model path, defaults to text_detection_en_ppocrv3_2023may.onnx.')
+parser.add_argument('--backend_target', '-bt', type=int, default=0,
+                    help='''Choose one of the backend-target pair to run this demo:
+                        {:d}: (default) OpenCV implementation + CPU,
+                        {:d}: CUDA + GPU (CUDA),
+                        {:d}: CUDA + GPU (CUDA FP16),
+                        {:d}: TIM-VX + NPU,
+                        {:d}: CANN + NPU
+                    '''.format(*[x for x in range(len(backend_target_pairs))]))
+parser.add_argument('--width', type=int, default=736,
+                    help='Usage: Resize input image to certain width, default = 736. It should be multiple by 32.')
+parser.add_argument('--height', type=int, default=736,
+                    help='Usage: Resize input image to certain height, default = 736. It should be multiple by 32.')
+parser.add_argument('--binary_threshold', type=float, default=0.3,
+                    help='Usage: Threshold of the binary map, default = 0.3.')
+parser.add_argument('--polygon_threshold', type=float, default=0.5,
+                    help='Usage: Threshold of polygons, default = 0.5.')
+parser.add_argument('--max_candidates', type=int, default=200,
+                    help='Usage: Set maximum number of polygon candidates, default = 200.')
+parser.add_argument('--unclip_ratio', type=np.float64, default=2.0,
+                    help=' Usage: The unclip ratio of the detected text region, which determines the output size, default = 2.0.')
+parser.add_argument('--save', '-s', action='store_true',
+                    help='Usage: Specify to save file with results (i.e. bounding box, confidence level). Invalid in case of camera input.')
+parser.add_argument('--vis', '-v', action='store_true',
+                    help='Usage: Specify to open a new window to show results. Invalid in case of camera input.')
+args = parser.parse_args()
+
+def visualize(image, results, box_color=(0, 255, 0), text_color=(0, 0, 255), isClosed=True, thickness=2, fps=None):
+    output = image.copy()
+
+    if fps is not None:
+        cv.putText(output, 'FPS: {:.2f}'.format(fps), (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, text_color)
+
+    pts = np.array(results[0])
+    output = cv.polylines(output, pts, isClosed, box_color, thickness)
+
+    return output
+
+if __name__ == '__main__':
+    backend_id = backend_target_pairs[args.backend_target][0]
+    target_id = backend_target_pairs[args.backend_target][1]
+
+    # Instantiate model
+    model = PPOCRDet(modelPath=args.model,
+               inputSize=[args.width, args.height],
+               binaryThreshold=args.binary_threshold,
+               polygonThreshold=args.polygon_threshold,
+               maxCandidates=args.max_candidates,
+               unclipRatio=args.unclip_ratio,
+               backendId=backend_id,
+               targetId=target_id)
+
+    # If input is an image
+    if args.input is not None:
+        original_image = cv.imread(args.input)
+        original_w = original_image.shape[1]
+        original_h = original_image.shape[0]
+        scaleHeight = original_h / args.height
+        scaleWidth = original_w / args.width
+        image = cv.resize(original_image, [args.width, args.height])
+
+        # Inference
+        results = model.infer(image)
+
+        # Scale the results bounding box
+        for i in range(len(results[0])):
+            for j in range(4):
+                box = results[0][i][j]
+                results[0][i][j][0] = box[0] * scaleWidth
+                results[0][i][j][1] = box[1] * scaleHeight
+
+        # Print results
+        print('{} texts detected.'.format(len(results[0])))
+        for idx, (bbox, score) in enumerate(zip(results[0], results[1])):
+            print('{}: {} {} {} {}, {:.2f}'.format(idx, bbox[0], bbox[1], bbox[2], bbox[3], score))
+
+        # Draw results on the input image
+        original_image = visualize(original_image, results)
+
+        # Save results if save is true
+        if args.save:
+            print('Resutls saved to result.jpg\n')
+            cv.imwrite('result.jpg', original_image)
+
+        # Visualize results in a new window
+        if args.vis:
+            cv.namedWindow(args.input, cv.WINDOW_AUTOSIZE)
+            cv.imshow(args.input, original_image)
+            cv.waitKey(0)
+    else: # Omit input to call default camera
+        deviceId = 0
+        cap = cv.VideoCapture(deviceId)
+
+        tm = cv.TickMeter()
+        while cv.waitKey(1) < 0:
+            hasFrame, original_image = cap.read()
+            if not hasFrame:
+                print('No frames grabbed!')
+                break
+
+            original_w = original_image.shape[1]
+            original_h = original_image.shape[0]
+            scaleHeight = original_h / args.height
+            scaleWidth = original_w / args.width
+            frame = cv.resize(original_image, [args.width, args.height])
+            # Inference
+            tm.start()
+            results = model.infer(frame) # results is a tuple
+            tm.stop()
+
+            # Scale the results bounding box
+            for i in range(len(results[0])):
+                for j in range(4):
+                    box = results[0][i][j]
+                    results[0][i][j][0] = box[0] * scaleWidth
+                    results[0][i][j][1] = box[1] * scaleHeight
+
+            # Draw results on the input image
+            original_image = visualize(original_image, results, fps=tm.getFPS())
+
+            # Visualize results in a new Window
+            cv.imshow('{} Demo'.format(model.name), original_image)
+
+            tm.reset()

ppocr_det.py

@@ -0,0 +1,59 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+import numpy as np
+import cv2 as cv
+
+class PPOCRDet:
+    def __init__(self, modelPath, inputSize=[736, 736], binaryThreshold=0.3, polygonThreshold=0.5, maxCandidates=200, unclipRatio=2.0, backendId=0, targetId=0):
+        self._modelPath = modelPath
+        self._model = cv.dnn_TextDetectionModel_DB(
+            cv.dnn.readNet(self._modelPath)
+        )
+
+        self._inputSize = tuple(inputSize) # (w, h)
+        self._inputHeight = inputSize[0]
+        self._inputWidth = inputSize[1]
+        self._binaryThreshold = binaryThreshold
+        self._polygonThreshold = polygonThreshold
+        self._maxCandidates = maxCandidates
+        self._unclipRatio = unclipRatio
+        self._backendId = backendId
+        self._targetId = targetId
+
+        self._model.setPreferableBackend(self._backendId)
+        self._model.setPreferableTarget(self._targetId)
+
+        self._model.setBinaryThreshold(self._binaryThreshold)
+        self._model.setPolygonThreshold(self._polygonThreshold)
+        self._model.setUnclipRatio(self._unclipRatio)
+        self._model.setMaxCandidates(self._maxCandidates)
+
+        self._model.setInputSize(self._inputSize)
+        self._model.setInputMean((123.675, 116.28, 103.53))
+        self._model.setInputScale(1.0/255.0/np.array([0.229, 0.224, 0.225]))
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self._backendId = backendId
+        self._targetId = targetId
+        self._model.setPreferableBackend(self._backendId)
+        self._model.setPreferableTarget(self._targetId)
+
+    def setInputSize(self, input_size):
+        self._inputSize = tuple(input_size)
+        self._model.setInputSize(self._inputSize)
+        self._model.setInputMean((123.675, 116.28, 103.53))
+        self._model.setInputScale(1.0/255.0/np.array([0.229, 0.224, 0.225]))
+
+    def infer(self, image):
+        assert image.shape[0] == self._inputSize[1], '{} (height of input image) != {} (preset height)'.format(image.shape[0], self._inputSize[1])
+        assert image.shape[1] == self._inputSize[0], '{} (width of input image) != {} (preset width)'.format(image.shape[1], self._inputSize[0])
+
+        return self._model.detect(image)