PaddleOCR2.7+Qt5

最新推荐文章于 2024-07-29 22:19:50 发布
最新推荐文章于 2024-07-29 22:19:50 发布
阅读量1.2k 收藏 14
点赞数 14
分类专栏： 计算机视觉 文章标签： qt 开发语言 PaddleOCR paddle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40732350/article/details/139266056
版权

章节一：Windows 下的 PIP 安装

        官网安装教程地址

        按照里面的教程去安装

         如果使用cuda版本的还要安装tensorrt，不然后面运行demo程序的程序会报如下错。

        下载TensorRT 8版本，tensorrt下载地址

章节二：编译源码

        进入官网源码地址

        下载release2.7

        下载三个模型

        下载推理预测库

          官网下载地址，根据自己的情况下载CPU或对应的自己CUDA版本的GPU

用CMAK打开如下文件

    添加路径OpenCV路径和预测库路径。

图片

    然后Configers，再Generate，如果有报错不用管他，最后在你的构建目录生成了项目，然后开始编译。

        但是编译会报错

在utility.cpp中无法打开包括文件"dirent.h":No such file or directory

        <dirent.h>是个unix系统下常见的接口，但windows平台的MSVC编译器并没有提供这个接口，对于跨平台的项目开发就会带来一些麻烦，如果在MSVC下编译时可能因为windows平台缺少这个接口就要为windows平台另外写一些代码。

        不过大佬已经做了一个windows版本的<dirent.h>，放在了github上面，链接如下：

https://github.com/tronkko/dirent

        下载完后加入这个文件夹：

        然后重新编译，但是会报错找不到_stat，做如下修改就可以了。

//修改前
    struct stat s;
    _stat(dir_name, &s);
//修改后
    struct _stat64 s;
    _stat64(dir_name, &s);

        最后就可以生成成功，生成成功要将这几个dll复制到程序目录。

        onnxruntime和paddle2onnx在这里

        将这个文件复制到程序目录

        源码里面这个文件的路径也要改一下

        然后输入命令运行程序，下面的路径根据自己情况去修改

./ppocr.exe --det_model_dir=F:/Vision/PaddleOCR/2_7/model/ch_PP-OCRv4_det_infer --cls_model_dir=F:/Vision/PaddleOCR/2_7/model/ch_ppocr_mobile_v2.0_cls_infer --rec_model_dir=F:/Vision/PaddleOCR/2_7/model/ch_PP-OCRv4_rec_infer --image_dir=F:/Vision/PaddleOCR/2_7/PaddleOCR-release-2.7/deploy/cpp_infer/build/Release/aa.png

        运行结果如下

章节三：在Qt上编译运行

        pro文件构建

QT       += core gui widgets

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

DEFINES += QT_DEPRECATED_WARNINGS

##################################################################
#指定生成的文件存放位置
##################################################################
MOC_DIR         = $$PWD/temp/moc
RCC_DIR         = $$PWD/temp/rcc
UI_DIR          = $$PWD/temp/ui
OBJECTS_DIR     = $$PWD/temp/obj
DESTDIR         = $$PWD/temp/bin

CONFIG(debug, debug|release) {
    QMAKE_CXXFLAGS_DEBUG += /MTd
}

CONFIG(release, debug|release) {
    QMAKE_CXXFLAGS_RELEASE += /MT
}

PaddleOCR_ROOT = F:/Vision/PaddleOCR/2_7/OCR_Demo/OCR_Demo/ocr
SOURCES += \
#    $$PaddleOCR_ROOT/src/args.cpp \
    $$PaddleOCR_ROOT/src/clipper.cpp \
    $$PaddleOCR_ROOT/src/ocr_cls.cpp \
    $$PaddleOCR_ROOT/src/ocr_det.cpp \
    $$PaddleOCR_ROOT/src/ocr_rec.cpp \
#    $$PaddleOCR_ROOT/src/paddleocr.cpp \
#    $$PaddleOCR_ROOT/src/paddlestructure.cpp \
    $$PaddleOCR_ROOT/src/postprocess_op.cpp \
    $$PaddleOCR_ROOT/src/preprocess_op.cpp \
    $$PaddleOCR_ROOT/src/structure_layout.cpp \
    $$PaddleOCR_ROOT/src/structure_table.cpp \
    $$PaddleOCR_ROOT/src/utility.cpp \
    ScreenWidget/screen.cpp \
    ScreenWidget/screenwidget.cpp \
    main.cpp \
    mainwindow.cpp \
    my_config.cpp \
    my_paddleocr.cpp

HEADERS += \
    $$PaddleOCR_ROOT/include/ocr_cls.h \
    $$PaddleOCR_ROOT/include/ocr_det.h \
    $$PaddleOCR_ROOT/include/ocr_rec.h \
#    $$PaddleOCR_ROOT/include/paddleocr.h \
#    $$PaddleOCR_ROOT/include/paddlestructure.h \
    $$PaddleOCR_ROOT/include/postprocess_op.h \
    $$PaddleOCR_ROOT/include/preprocess_op.h \
    $$PaddleOCR_ROOT/include/structure_layout.h \
    $$PaddleOCR_ROOT/include/structure_table.h \
    $$PaddleOCR_ROOT/include/utility.h \
#    $$PaddleOCR_ROOT/include/args.h \
    $$PaddleOCR_ROOT/include/clipper.h \
    $$PaddleOCR_ROOT/include/dirent.h \
    ScreenWidget/screen.h \
    ScreenWidget/screenwidget.h \
    mainwindow.h \
    my_config.h \
    my_paddleocr.h

FORMS += \
    mainwindow.ui

INCLUDEPATH += $$PaddleOCR_ROOT
INCLUDEPATH += $$PaddleOCR_ROOT/include
INCLUDEPATH += $$PWD\ScreenWidget

Inference_ROOT = F:/Vision/PaddleOCR/2_7/prelib/cuda11_0
INCLUDEPATH += $$Inference_ROOT/paddle/include
INCLUDEPATH += $$Inference_ROOT/third_party/install/protobuf/include
INCLUDEPATH += $$Inference_ROOT/third_party/install/glog/include
#INCLUDEPATH += $$Inference_ROOT/third_party/install/gflags/include
INCLUDEPATH += $$Inference_ROOT/third_party/install/xxhash/include
INCLUDEPATH += $$Inference_ROOT/third_party/install/mklml/include
INCLUDEPATH += $$Inference_ROOT/third_party/install/mkldnn/include

LIBS += -L$$Inference_ROOT/paddle/lib -lpaddle_inference
LIBS += -L$$Inference_ROOT/third_party/install/mklml/lib -lmklml
LIBS += -L$$Inference_ROOT/third_party/install/mklml/lib -llibiomp5md
LIBS += -L$$Inference_ROOT/third_party/install/mkldnn/lib -lmkldnn
LIBS += -L$$Inference_ROOT/third_party/install/glog/lib -lglog
#LIBS += -L$$Inference_ROOT/third_party/install/gflags/lib -lgflags_static
LIBS += -L$$Inference_ROOT/third_party/install/protobuf/lib -llibprotobuf
LIBS += -L$$Inference_ROOT/third_party/install/xxhash/lib -lxxhash

OpenCV_ROOT = E:/2021_software/OpenCv/OpenCv3_4_15/install/opencv/build
INCLUDEPATH += $$OpenCV_ROOT/include
INCLUDEPATH += $$OpenCV_ROOT/include/opencv
INCLUDEPATH += $$OpenCV_ROOT/include/opencv2
LIBS += -L$$OpenCV_ROOT/x64/vc15/lib -lopencv_world3415

        自定义一个config类

#pragma once

#include <iomanip>
#include <iostream>
#include <map>
#include <ostream>
#include <string>
#include <vector>

#include "include/utility.h"

using namespace PaddleOCR;

class MY_OCRConfig {
public:
  explicit MY_OCRConfig(const std::string &config_file);

    // common args
    bool use_gpu = false;
    bool use_tensorrt = false;
    int gpu_id = 0;
    int gpu_mem = 4000;
    int cpu_threads = 10;
    bool enable_mkldnn = false;
    std::string precision = "fp32";
    bool benchmark = false;
    std::string output = "./output/";
    std::string image_dir = "";
    std::string type = "ocr";

    // detection related
    std::string det_model_dir = "";
    std::string limit_type = "max";
    int limit_side_len = 960;
    double det_db_thresh = 0.3;
    double det_db_box_thresh = 0.6;
    double det_db_unclip_ratio = 1.5;
    bool use_dilation = false;
    std::string det_db_score_mode = "slow";
    bool visualize = true;

    // classification related
    bool use_angle_cls = false;
    std::string cls_model_dir = "";
    double cls_thresh = 0.9;
    int cls_batch_num = 1;

    // recognition related
    std::string rec_model_dir = "";
    int rec_batch_num = 6;
    std::string rec_char_dict_path = "./ppocr_keys_v1.txt";
    int rec_img_h = 48;
    int rec_img_w = 320;

    // layout model related
    std::string layout_model_dir = "";
    std::string layout_dict_path = "../../ppocr/utils/dict/layout_dict/layout_publaynet_dict.txt";
    double layout_score_threshold = 0.5;
    double layout_nms_threshold = 0.5;

    // structure model related
    std::string table_model_dir = "";
    int table_max_len = 488;
    int table_batch_num = 1;
    bool merge_no_span_structure = true;
    std::string table_char_dict_path = "../../ppocr/utils/dict/table_structure_dict_ch.txt";

    // ocr forward related
    bool det = true;
    bool rec = true;
    bool cls = false;
    bool table = false;
    bool layout = false;


private:
  // Load configuration
  std::map<std::string, std::string> LoadConfig(const std::string &config_file);

  std::vector<std::string> split(const std::string &str,
                                 const std::string &delim);

  std::map<std::string, std::string> config_map_;
};

#include "my_config.h"
#include <qdebug.h>

std::vector<std::string> MY_OCRConfig::split(const std::string &str,
                                          const std::string &delim) {
  std::vector<std::string> res;
  if ("" == str)
    return res;
  int strlen = str.length() + 1;
  char *strs = new char[strlen];
  std::strcpy(strs, str.c_str());

  int delimlen = delim.length() + 1;
  char *d = new char[delimlen];
  std::strcpy(d, delim.c_str());

  char *p = std::strtok(strs, d);
  while (p) {
    std::string s = p;
    res.push_back(s);
    p = std::strtok(NULL, d);
  }

  delete[] strs;
  delete[] d;
  return res;
}

std::map<std::string, std::string>
MY_OCRConfig::LoadConfig(const std::string &config_path) {
  auto config = Utility::ReadDict(config_path);

  std::map<std::string, std::string> dict;
  for (int i = 0; i < config.size(); i++) {
    // pass for empty line or comment
    if (config[i].size() <= 1 || config[i][0] == '#') {
      continue;
    }

    //
    std::vector<std::string> res = split(config[i], " ");
    if (res.size() < 2) {
        dict[res[0]] = "";
    }else{
        dict[res[0]] = res[1];
    }
  }
  return dict;
}

MY_OCRConfig::MY_OCRConfig(const std::string &config_file)
{
   config_map_ = LoadConfig(config_file);

   // common args
   this->use_gpu        = (config_map_["use_gpu"] == "true");
   this->use_tensorrt   = (config_map_["use_tensorrt"] == "true");
   this->gpu_id         = stoi(config_map_["gpu_id"]);
   this->gpu_mem        = stoi(config_map_["gpu_mem"]);
   this->cpu_threads    = stoi(config_map_["cpu_threads"]);
   this->enable_mkldnn  = (config_map_["enable_mkldnn"] == "true");
   this->precision      = config_map_["precision"];
   this->benchmark      = (config_map_["benchmark"] == "true");
   this->output         = config_map_["output"];
   this->image_dir      = config_map_["image_dir"];
   this->type           = config_map_["type"];

   // detection related
   this->det_model_dir       = config_map_["det_model_dir"];
   this->limit_type          = config_map_["limit_type"];
   this->limit_side_len      = stoi(config_map_["limit_side_len"]);
   this->det_db_thresh       = stod(config_map_["det_db_thresh"]);
   this->det_db_box_thresh   = stod(config_map_["det_db_box_thresh"]);
   this->det_db_unclip_ratio = stod(config_map_["det_db_unclip_ratio"]);
   this->use_dilation        = (config_map_["use_dilation"] == "true");
   this->det_db_score_mode   = config_map_["det_db_score_mode"];
   this->visualize           = (config_map_["visualize"] == "true");

   // classification related
   this->use_angle_cls   = (config_map_["use_angle_cls"] == "true");
   this->cls_model_dir   = config_map_["cls_model_dir"];
   this->cls_thresh      = stod(config_map_["cls_thresh"]);
   this->cls_batch_num   = stoi(config_map_["cls_batch_num"]);

   // recognition related
   this->rec_model_dir        = config_map_["rec_model_dir"];
   this->rec_batch_num        = stoi(config_map_["rec_batch_num"]);
   this->rec_char_dict_path   = config_map_["rec_char_dict_path"];
   this->rec_img_h            = stoi(config_map_["rec_img_h"]);
   this->rec_img_w            = stoi(config_map_["rec_img_w"]);

   // layout model related
   this->layout_model_dir        = config_map_["layout_model_dir"];
   this->layout_dict_path        = config_map_["layout_dict_path"];
   this->layout_score_threshold  = stod(config_map_["layout_score_threshold"]);
   this->layout_nms_threshold    = stod(config_map_["layout_nms_threshold"]);

   // structure model related
   this->table_model_dir           = config_map_["table_model_dir"];
   this->table_max_len             = stoi(config_map_["table_max_len"]);
   this->table_batch_num           = stoi(config_map_["table_batch_num"]);
   this->merge_no_span_structure   = (config_map_["merge_no_span_structure"] == "true");
   this->table_char_dict_path      = config_map_["table_char_dict_path"];

   // ocr forward related
   this->det     = (config_map_["det"] == "true");
   this->rec     = (config_map_["rec"] == "true");
   this->cls     = (config_map_["cls"] == "true");
   this->table   = (config_map_["table"] == "true");
   this->layout  = (config_map_["layout"] == "true");
   qDebug()<<this->det<<config_map_["det"].c_str()<<QString(config_map_["det"].c_str())<<this->rec<<this->cls<<this->rec_model_dir.c_str();
}

        自定义一个ocr类

#pragma once

#include <include/ocr_cls.h>
#include <include/ocr_det.h>
#include <include/ocr_rec.h>

#include "my_config.h"

using namespace PaddleOCR;
class MY_PPOCR {
public:
  explicit MY_PPOCR();
  ~MY_PPOCR();

  std::vector<std::vector<OCRPredictResult>> ocr(std::vector<cv::Mat> img_list,
                                                 bool det = true,
                                                 bool rec = true,
                                                 bool cls = true);
  std::vector<OCRPredictResult> ocr(cv::Mat img, bool det = true,
                                    bool rec = true, bool cls = true);

  void reset_timer();
  void benchmark_log(int img_num);
    MY_OCRConfig *p_config;
protected:
  std::vector<double> time_info_det = {0, 0, 0};
  std::vector<double> time_info_rec = {0, 0, 0};
  std::vector<double> time_info_cls = {0, 0, 0};

  void det(cv::Mat img, std::vector<OCRPredictResult> &ocr_results);
  void rec(std::vector<cv::Mat> img_list,
           std::vector<OCRPredictResult> &ocr_results);
  void cls(std::vector<cv::Mat> img_list,
           std::vector<OCRPredictResult> &ocr_results);

private:
  std::unique_ptr<DBDetector> detector_;
  std::unique_ptr<Classifier> classifier_;
  std::unique_ptr<CRNNRecognizer> recognizer_;
};

#include "my_paddleocr.h"
#include <qdebug.h>
//#include "auto_log/autolog.h"


MY_PPOCR::MY_PPOCR()
{
    qDebug()<<"aaa1";
    p_config = new MY_OCRConfig("./ocrconfig.txt");

    qDebug()<<"aaa2";
    //
    if (p_config->det) {
      this->detector_.reset(new DBDetector(
          p_config->det_model_dir, p_config->use_gpu, p_config->gpu_id, p_config->gpu_mem,
          p_config->cpu_threads, p_config->enable_mkldnn, p_config->limit_type,
          p_config->limit_side_len, p_config->det_db_thresh, p_config->det_db_box_thresh,
          p_config->det_db_unclip_ratio, p_config->det_db_score_mode, p_config->use_dilation,
          p_config->use_tensorrt, p_config->precision));
    }

    qDebug()<<"aaa3";
    //
    if (p_config->cls && p_config->use_angle_cls) {
      this->classifier_.reset(new Classifier(
          p_config->cls_model_dir, p_config->use_gpu, p_config->gpu_id, p_config->gpu_mem,
          p_config->cpu_threads, p_config->enable_mkldnn, p_config->cls_thresh,
          p_config->use_tensorrt, p_config->precision, p_config->cls_batch_num));
    }
    qDebug()<<"aaa4";

    //
    if (p_config->rec) {
      this->recognizer_.reset(new CRNNRecognizer(
          p_config->rec_model_dir, p_config->use_gpu, p_config->gpu_id, p_config->gpu_mem,
          p_config->cpu_threads, p_config->enable_mkldnn, p_config->rec_char_dict_path,
          p_config->use_tensorrt, p_config->precision, p_config->rec_batch_num,
          p_config->rec_img_h, p_config->rec_img_w));
    }
    qDebug()<<"aaa5";
}

MY_PPOCR::~MY_PPOCR()
{
    delete p_config;
}

std::vector<std::vector<OCRPredictResult>>
MY_PPOCR::ocr(std::vector<cv::Mat> img_list, bool det, bool rec, bool cls)
{
    std::vector<std::vector<OCRPredictResult>> ocr_results;
    if (!det) {
        std::vector<OCRPredictResult> ocr_result;
        ocr_result.resize(img_list.size());
        if (cls && this->classifier_) {
            this->cls(img_list, ocr_result);
            for (int i = 0; i < img_list.size(); i++) {
                if (ocr_result[i].cls_label % 2 == 1 &&
                    ocr_result[i].cls_score > this->classifier_->cls_thresh) {
                    cv::rotate(img_list[i], img_list[i], 1);
                }
            }
        }
        if (rec) {
            this->rec(img_list, ocr_result);
        }
        for (int i = 0; i < ocr_result.size(); ++i) {
            std::vector<OCRPredictResult> ocr_result_tmp;
            ocr_result_tmp.push_back(ocr_result[i]);
            ocr_results.push_back(ocr_result_tmp);
        }
    } else {
      for (int i = 0; i < img_list.size(); ++i) {
        std::vector<OCRPredictResult> ocr_result =
            this->ocr(img_list[i], true, rec, cls);
        ocr_results.push_back(ocr_result);
      }
    }
    return ocr_results;
}

std::vector<OCRPredictResult> MY_PPOCR::ocr(cv::Mat img, bool det, bool rec, bool cls)
{
    std::vector<OCRPredictResult> ocr_result;
    // det
    this->det(img, ocr_result);
    // crop image
    std::vector<cv::Mat> img_list;
    for (int j = 0; j < ocr_result.size(); j++) {
        cv::Mat crop_img;
        crop_img = Utility::GetRotateCropImage(img, ocr_result[j].box);
        img_list.push_back(crop_img);
    }
    // cls
    if (cls && this->classifier_) {
        this->cls(img_list, ocr_result);
        for (int i = 0; i < img_list.size(); i++) {
          if (ocr_result[i].cls_label % 2 == 1 &&
              ocr_result[i].cls_score > this->classifier_->cls_thresh) {
              cv::rotate(img_list[i], img_list[i], 1);
          }
        }
    }
    // rec
    if (rec) {
        this->rec(img_list, ocr_result);
    }
    return ocr_result;
}

void MY_PPOCR::det(cv::Mat img, std::vector<OCRPredictResult> &ocr_results)
{
    std::vector<std::vector<std::vector<int>>> boxes;
    std::vector<double> det_times;

    this->detector_->Run(img, boxes, det_times);

    for (int i = 0; i < boxes.size(); i++) {
        OCRPredictResult res;
        res.box = boxes[i];
        ocr_results.push_back(res);
    }
    // sort boex from top to bottom, from left to right
    Utility::sorted_boxes(ocr_results);
    this->time_info_det[0] += det_times[0];
    this->time_info_det[1] += det_times[1];
    this->time_info_det[2] += det_times[2];
}

void MY_PPOCR::rec(std::vector<cv::Mat> img_list, std::vector<OCRPredictResult> &ocr_results)
{
    std::vector<std::string> rec_texts(img_list.size(), "");
    std::vector<float> rec_text_scores(img_list.size(), 0);
    std::vector<double> rec_times;
    this->recognizer_->Run(img_list, rec_texts, rec_text_scores, rec_times);
    // output rec results
    for (int i = 0; i < rec_texts.size(); i++) {
        ocr_results[i].text = rec_texts[i];
        ocr_results[i].score = rec_text_scores[i];
    }
    this->time_info_rec[0] += rec_times[0];
    this->time_info_rec[1] += rec_times[1];
    this->time_info_rec[2] += rec_times[2];
}

void MY_PPOCR::cls(std::vector<cv::Mat> img_list, std::vector<OCRPredictResult> &ocr_results)
{
    std::vector<int> cls_labels(img_list.size(), 0);
    std::vector<float> cls_scores(img_list.size(), 0);
    std::vector<double> cls_times;
    this->classifier_->Run(img_list, cls_labels, cls_scores, cls_times);
    // output cls results
    for (int i = 0; i < cls_labels.size(); i++) {
        ocr_results[i].cls_label = cls_labels[i];
        ocr_results[i].cls_score = cls_scores[i];
    }
    this->time_info_cls[0] += cls_times[0];
    this->time_info_cls[1] += cls_times[1];
    this->time_info_cls[2] += cls_times[2];
}

void MY_PPOCR::reset_timer()
{
    this->time_info_det = {0, 0, 0};
    this->time_info_rec = {0, 0, 0};
    this->time_info_cls = {0, 0, 0};
}

        核心调用代码


    //
    std::vector<cv::Mat> img_list;
    cv::Mat srcimg = cv::imread(qstr2str(fileName).data(), cv::IMREAD_COLOR);
    img_list.push_back(srcimg);
    p_ocr->reset_timer();

    //
    QElapsedTimer  RunTimer;
    RunTimer.start();
    std::vector<std::vector<OCRPredictResult>> ocr_results = p_ocr->ocr(img_list, p_ocr->p_config->det, p_ocr->p_config->rec, p_ocr->p_config->cls);
    ui->textBrowser->append(QString("检测时间:%1ms ---------------------").arg(RunTimer.elapsed()));

    //
    for (int i = 0; i < img_list.size(); ++i) {
        std::vector<OCRPredictResult> &ocr_result = ocr_results[i];
        for (int i = 0; i < ocr_result.size(); i++) {
            QString oustr;
            oustr += QString::number(i) + " ";

            // det
//            std::vector<std::vector<int>> boxes = ocr_result[i].box;
//            if (boxes.size() > 0) {
//                oustr += "det boxes: [";
//                for (int n = 0; n < boxes.size(); n++) {
//                    oustr +=  "[" + QString::number(boxes[n][0]) + "," + QString::number(boxes[n][1]) + "]";
//                    if (n != boxes.size() - 1) {
//                        oustr +=  ",";
//                    }
//                }
//                oustr +=  "]";
//            }

            // rec
            if (ocr_result[i].score != -1.0) {
                  oustr += " score: " + QString::number(ocr_result[i].score,'f',2) + " text: " + QString::fromUtf8(ocr_result[i].text.c_str()) + " ";
            }

            // cls
            if (ocr_result[i].cls_label != -1) {
              oustr += "cls label: " + QString::number(ocr_result[i].cls_label) + " cls score: " + ocr_result[i].cls_score;
            }

            //
//            oustr += "\r\n";
            ui->textBrowser->append(oustr);
        }

        //
        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_list[i], ppt, npt, 1, 1, CV_RGB(255, 0, 0), 2, 8, 0);
        }

        //
        QImage outimage;
        cvMat2QImage(img_list[i], outimage);
        ui->label_image->setPixmap(QPixmap::fromImage(outimage.scaled(ui->label_image->width(),
                                                                      ui->label_image->height(),
                                                                      Qt::KeepAspectRatio)));
    }

        程序目录包含这个几个文件，如果你没有，在源码路径和预测库路径去搜索

        ocrconfig.txt是自定义的配置

# common args
use_gpu false
use_tensorrt false
gpu_id 0
gpu_mem 4000
cpu_threads 10
enable_mkldnn false
precision fp32
benchmark false
output ./output/
image_dir 
type ocr

# detection related
det_model_dir F:\Vision\PaddleOCR\2_7\model\ch_PP-OCRv4_det_infer
limit_type max
limit_side_len 960
det_db_thresh 0.3
det_db_box_thresh 0.6
det_db_unclip_ratio 1.5
use_dilation false
det_db_score_mode slow
visualize true

# classification related
use_angle_cls false
cls_model_dir F:\Vision\PaddleOCR\2_7\model\ch_ppocr_mobile_v2.0_cls_infer
cls_thresh 0.9
cls_batch_num 1

# recognition related
rec_model_dir F:\Vision\PaddleOCR\2_7\model\ch_PP-OCRv4_rec_infer
rec_batch_num 6
rec_char_dict_path ./ppocr_keys_v1.txt
rec_img_h 48
rec_img_w 320

# layout model related
layout_model_dir 
layout_dict_path ./layout_publaynet_dict.txt
layout_score_threshold 0.5
layout_nms_threshold 0.5

# structure model related
table_model_dir 
table_max_len 488
table_batch_num 1
merge_no_span_structure true
table_char_dict_path ./table_structure_dict_ch.txt

# ocr forward related
det true
rec true
cls false
table false
layout false

        最后运行结果

       有需要源码测试的， 这是源码地址

QtHalcon
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用qt+PaddleOCR做一个OCR软件demo
ShareProgress的博客
07-01 6047
文章目录使用qt+PaddleOCR做一个OCR软件demo效果展示1 建立环境1.1 vs项目环境1.2 qtcreator项目环境1.2.1 源代码整理1.2.2 依赖项整理如下1.2.3 模型文件如下1.2.4 在.pro文件中设置依赖库的模式1.2.5 pro文件中添加.h和.lib2 在工程代码中添加截图功能2.1 新建截图类并连接信号2.2 QImage转cv::Mat3 在工程代码中集成PaddleOCR3.1 初始化PaddleOCR3.2 修改文字识别类的run函数，增加一个返回结果的值的
QT与paddleOCR2.6版本的联合使用（外加避坑注意事项）
Helloorld_1的博客
04-18 2083
QT5.15.2+opencv4.5.2+VS2019+paddleocr2.6（截止到目前的最新版）+cpu部署。我是选择中英文超轻量PP-OCRV3的推理模型，三个都下载。下载dirent-master。
Python，Paddleocr安装及简单测试，小白适用
最新发布
qq_61523551的博客
07-29 503
因为这个模块依赖paddle，还需要单独安装，若未自行配置过paddle-gpu，那么默认安装的是paddle-cpu。可以看出Paddleocr还是很强的，图片中的文字有一些倾斜。不仅自己修正了图片，识别也非常准确。模型的下载后会存在你的本地，路径为C:\Users\你的用户名\.paddleocr\whl。如果无法联网的话，也可以通过U盘从可以联网的电脑上复制。这里需要注意一下，首次模型需要在线下载所以需要联网。简单功能、首先准备一张图片test.jpg。
PaddleOCR-release-2.7
09-06
经典OCR开源代码，python代码
安装PaddleOCR-2.7.0版本-笔记
hsg77的专栏
08-12 2368
安装PaddleOCR-2.7.0版本-笔记
QT使用PaddleOCR和百度OCR进行文字识别
TinyHou的博客
02-12 8388
近些年人工智能大热，做这个Demo也是想对其有个初步的了解。关于文字识别已经有了一些很棒的开源项目可供选择，本文最终选择了PaddleOCR，使用项目中提供的代码和模型便可获得比较不错的中英文识别效果，不需要对人工智能领域有深入的了解，应用过程中的麻烦主要来自于环境的配置，本文即是配置过程的记录。 一些开源项目可能更侧重于算法方面，比如我也试了一下opencv教程中的文字识别，感觉官方提供的模型识别效果并不好（也可能是我用法不对），如果你想获得理想的效果，可能需要找到更好的模型甚至自己去训练。 效果.
qt ocr 百度飞浆paddleocr测试软件.zip
06-25
用QT写的利用高拍仪识别身份证的一个软件，还有不成熟的地方，大家多多指教
QT5+VS2017+PaddleOCR2.6总结
qq_17169835的博客
05-17 1035
用tesseract调用程序调用出现问题，后面改用飞桨paddleocr，捣鼓了两周才弄好。
Ubuntu12.04安装python2.7+QT4
07-17
在Ubuntu 12.04操作系统中安装Python 2.7和QT4是一个常见的任务，尤其是在进行图形化界面开发时。以下将详细讲解这个过程，包括必要的步骤和所需的包。 首先，确保你的Ubuntu系统是最新的。打开终端并运行以下命令...
Python 2.7 + QT4 1
10-13
Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + QT4 Python 2.7 + ...
最新的PaddleOCR release/2.7
04-08
PaddleOCR旨在打造一套丰富、领先、且实用的OCR工具库，助力开发者训练出更好的模型，并应用落地。 -发布PP-OCRv4，提供mobile和server两种模型 PP-OCRv4-mobile：速度可比情况下，中文场景效果相比于PP-OCRv3再提升4.5%，英文场景提升10%，80语种多语言模型平均识别准确率提升8%以上 PP-OCRv4-server：发布了目前精度最高的OCR模型，中英文场景上检测模型精度提升4.9%， 识别模型精度提升2% 可参考快速开始 一行命令快速使用，同时也可在飞桨AI套件(PaddleX)中的通用OCR产业方案中低代码完成模型训练、推理、高性能部署全流程 -发布PP-ChatOCR ,使用融合PP-OCR模型和文心大模型的通用场景关键信息抽取全新方案
使用qt+PaddleOCR做一个OCR软件demo（源码+发布版本）
07-01
使用qt+PaddleOCR做一个OCR软件demo
Python 2.7 + QT4 2
10-13
Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python 2.7 + QT4Python ...
打包pyqt5 linux下运行,Ubuntu 14.04 LTS 搭建 Python2.7+Qt 5.5+PyQt5开发环境
weixin_34809240的博客
04-30 1047
Python有许许多多的GUI开发包，PyQt正式其中之一。那么什么是PyQt呢，PyQt是基于Qt框架开发的一个用于创建GUI程序的工具包。它将python语言和Qt库成功融合在了一起。PyQt有数量庞大的类、函数和方法。它是一个跨平台的工具包，目前PyQt官网提供PyQt4和 PyQt5两种不同版本的文档说明。说到Qt，就必须解释一下什么是Qt，Qt是一个跨平台的C++图形用户界面应用开发程序...
Qt使用PaddleOCR成功 GPU
MFgming的博客
07-23 1642
一、windows： 二、Linux： 下载预测库： https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0/guides/05_inference_deployment/inference/build_and_install_lib_cn.html
Qt使用PaddleOCR成功 CPU
MFgming的博客
07-07 2170
paddleOCR部署测试（C++ &python) 一：使用Python部署PaddleOCR 先安装Python，可能是全网最详细的 Python 安装教程（windows） https://zhuanlan.zhihu.com/p/111168324?from_voters_page=true 再装git，最新版Git(2.32.0)下载安装教程，简单明了 附带idea配置 https://blog.csdn.net/weixin_45692705/article/details/
PaddleOCR 多线程版本（python）
qq_30811703的博客
05-30 1710
封装成http服务进行调用。
PaddleOCR 2.1版本 GPU部署 （C++/CUDA 11.0）
qq_43814893的博客
08-16 3030
PaddleOCR 2.1版本 GPU部署 （C++）时隔一年，由于工作原因，对PaddleOCR进行GPU版本的部署，同时对识别精度和速度要求更高，故对GPU版本进行部署，和CPU版本大差不差，但是可能坑和细节更多，因此本文详细部署不做过多叙述，可能着重放在变化上CPU版本部署见上篇文章：https://blog.csdn.net/qq_43814893/article/details/119415960?...
vs+qt paddleocr
06-01
这是一个比较广泛的问题，可以从不同的角度来回答。 首先，VS和Qt都是常用的集成开发环境（IDE），但VS一般被认为是Windows平台上最优秀的IDE之一，而Qt则是一个跨平台的GUI（图形用户界面）开发框架。因此，如果你的开发平台是Windows，那么VS可能更适合你；如果你需要跨平台开发，那么Qt可能更适合你。 PaddleOCR是一个基于PaddlePaddle深度学习平台的OCR（光学字符识别）工具库，它提供了丰富的OCR算法和模型，可以用于识别各种类型的图片中的文字。因此，如果你需要开发OCR相关的项目，那么PaddleOCR可能是一个很好的选择。 综合考虑以上因素，如果你需要在Windows平台上开发OCR相关的项目，那么使用VS+PaddleOCR可能是一个比较好的选择；如果你需要跨平台开发OCR相关的项目，那么使用Qt+PaddleOCR可能更适合你。当然，这只是一种建议，具体的开发环境和工具库选择还需要根据你的具体需求和经验进行决策。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值