devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt+OpenVino部署yolo5模型_qt openvino

作者：Li_阴宅 | 2024-07-13 12:51:41

赞

踩

qt openvino

一、openvino简介

OpenVINO是英特尔针对自家硬件平台开发的一套深度学习工具库，包含推断库，模型优化等等一系列与深度学习模型部署相关的功能。

OpenVINO™工具包是用于快速开发应用程序和解决方案的综合工具包，可解决各种任务，包括模拟人类视觉，自动语音识别，自然语言处理，推荐系统等。该工具包基于最新一代的人工神经网络，包括卷积神经网络（CNN），循环和基于注意力的网络，可在英特尔®硬件上扩展计算机视觉和非视觉工作负载，从而最大限度地提高性能。它通过从边缘到云的高性能，人工智能和深度学习推理来加速应用程序。

install:

https://nickhuang1996.blog.csdn.net/article/details/81385008

二、qt 中配置

安装好后，在pro文件中添入如下信息

  1. OPENVINO_ABS_PATH=$$quote(C:/Program Files (x86)/Intel/openvino_2021.4.752)
  2. OPENVINOPATH=$$OPENVINO_ABS_PATH/inference_engine
  3. OPENVINO_LIB=$$OPENVINOPATH/lib/intel64
  4. OPENVINO_INC=$$OPENVINOPATH/include
  5.  
  6. INCLUDEPATH += $$OPENVINO_INC
  7.  
  8. CONFIG(debug, debug|release) {
  9. LIBS += -L$$OPENVINO_LIB/Debug
  10. LIBS += -linference_engined \
  11.         -linference_engine_c_apid \
  12.         -linference_engine_transformationsd \
  13. } else{
  14. LIBS += -L$$OPENVINO_LIB/Release
  15. LIBS += -linference_engine \
  16.         -linference_engine_c_api \
  17.         -linference_engine_transformations \
  18. }
  19.  
  20.  
  21. OPENCVPATH=$$OPENVINO_ABS_PATH/opencv
  22. OPENCV_LIB=$$OPENCVPATH/lib
  23. OPENCV_INC=$$OPENCVPATH/include
  24. INCLUDEPATH += $$OPENCV_INC
  25.  
  26. CONFIG(debug, debug|release) {
  27. LIBS += -L$$OPENCV_LIB
  28. LIBS += -lopencv_core453d \
  29.         -lopencv_dnn453d \
  30.         -lopencv_ml453d \
  31.         -lopencv_highgui453d \
  32.         -lopencv_imgcodecs453d \
  33.         -lopencv_imgproc453d \
  34.         -lopencv_video453d
  35. }else{
  36. LIBS += -L$$OPENCV_LIB
  37. LIBS += -lopencv_core453 \
  38.         -lopencv_dnn453 \
  39.         -lopencv_ml453 \
  40.         -lopencv_highgui453 \
  41.         -lopencv_imgcodecs453 \
  42.         -lopencv_imgproc453 \
  43.         -lopencv_video453 \
  44.         -lopencv_videoio453
  45. }

三、yolo5部署代码

  1. #ifndef YOLO5PLUGIN_H
  2. #define YOLO5PLUGIN_H
  3.  
  4. #include "DefectInterface.h"
  5. #include <inference_engine.hpp>
  6. #include <opencv2/dnn/dnn.hpp>
  7. #include <opencv2/opencv.hpp>
  8.  
  9. using namespace InferenceEngine;
  10. using namespace cv;
  11.  
  12. class QIcon;
  13.  
  14. struct T_Yolov5sYamlData
  15. {
  16.     QVector<QString> names;
  17.     QVector<bool> shows;
  18. };
  19.  
  20. class Yolo5Plugin : public QObject, public DefectInterface
  21. {
  22.     /* 注意： QObject只能放在这里，放在父类继承会编译错误 */
  23.     Q_OBJECT
  24. #if QT_VERSION >= 0x050000
  25.     Q_PLUGIN_METADATA(IID IPlugin_iid FILE "Yolo5Plugin.json")
  26. #endif // QT_VERSION >= 0x050000
  27.     Q_INTERFACES(DefectInterface)
  28.  
  29. public:
  30.     typedef struct
  31.     {
  32.         float prob;
  33.         int label;
  34.         QRectF rect;
  35.     } T_Object;
  36.  
  37.     Yolo5Plugin();
  38.     ~Yolo5Plugin();
  39.     PluginSpec::E_TypeFlag typeFlag() const;
  40.     QIcon icon() const;
  41.  
  42.     int init(const T_DefectSpec &spec);
  43.     bool isInitialized() const;
  44.     int run(const T_DefectSpec &spec, T_DefectResult &result);
  45.     DefectInterface *newInstance();
  46.  
  47. private:
  48.     double sigmoid(double x);
  49.  
  50.     std::vector<int> get_anchors(int net_grid);
  51.  
  52.     bool parse_yolov5(const Blob::Ptr &blob, int net_grid,
  53.                       float cof_threshold, int item_size,
  54.                       std::vector<cv::Rect> &o_rect,
  55.                       std::vector<float> &o_rect_cof,
  56.                       std::vector<float> &o_labels);
  57.  
  58.     void resize(const cv::Mat &graySrc, cv::Mat &dst, double &scale);
  59.  
  60.     bool processFrame(const cv::Mat &gray, int item_size, std::vector<T_Object> &detected_objects);
  61.  
  62. private:
  63.     std::string _input_name;
  64.     ExecutableNetwork _network;
  65.     OutputsDataMap _outputinfo;
  66.     T_Yolov5sYamlData _yolov5sYamlData;
  67.     bool m_isInitialized;
  68.     QString m_modelPath;
  69. };
  70.  
  71. #endif // YOLO5PLUGIN_H

  1. #include "Yolo5Plugin.h"
  2. #include <memory>
  3. #include <iostream>
  4. #include <fstream>
  5. #include <istream>
  6. #include <string>
  7. #include <QPointF>
  8. #include <QRect>
  9. #include <QSizeF>
  10. #include <QTextCodec>
  11. #include <QDebug>
  12. #include <QIcon>
  13. #include <QDir>
  14. #include <QTime>
  15. #include <omp.h>
  16.  
  17. #include "yaml-cpp/yaml.h"
  18.  
  19. using namespace std;
  20.  
  21. static std::mutex mtx;
  22. static omp_lock_t lock_use;
  23. static omp_lock_t s_lock;
  24.  
  25. #define IMG_LEN 640
  26. #define IMG_LEN_F  640.0f
  27.  
  28. //https://github.com/fb029ed/yolov5_cpp_openvino/blob/master/cvmart_competition/openvino_cpp_code/my_detector.cpp
  29.  
  30. bool isFileExist(const QString &fullFilePath)
  31. {
  32.     QFileInfo fileInfo(fullFilePath);
  33.     if(fileInfo.exists())
  34.     {
  35.         return true;
  36.     }
  37.     return false;
  38. }
  39.  
  40. bool isDirExist(const QString &fullPath)
  41. {
  42.     if(fullPath.isEmpty())
  43.     {
  44.         return false;
  45.     }
  46.     QDir dir(fullPath);
  47.     if(dir.exists())
  48.     {
  49.         return true;
  50.     }
  51.     return false;
  52. }
  53.  
  54. bool parseClass(const string &path, T_Yolov5sYamlData &data)
  55. {
  56.     data.names.clear();
  57.     data.shows.clear();
  58.     try
  59.     {
  60.         YAML::Node tRoot = YAML::LoadFile(path);
  61.         YAML::Node tNames = tRoot["Names"];
  62.         for(int i = 0; i < tNames.size(); ++i)
  63.         {
  64.             std::string name = tNames[i].as<std::string>();
  65.             data.names.append(QString::fromStdString(name));
  66.         }
  67.         if(tRoot["Shows"])
  68.         {
  69.             for(int i = 0; i < tRoot["Shows"].size(); ++i)
  70.             {
  71.                 bool isShow = tRoot["Shows"][i].as<bool>();
  72.                 data.shows.append(isShow);
  73.             }
  74.         }
  75.     }
  76.     catch (YAML::Exception &e)
  77.     {
  78.         const char *err_msg = e.what();
  79.         qDebug() << "exception caught: {}" << err_msg;
  80.         return false;
  81.     }
  82.     catch (...)
  83.     {
  84.         qDebug() << "exception caught:  unknown";
  85.         return false;
  86.     }
  87.     return true;
  88. }
  89.  
  90. Yolo5Plugin::Yolo5Plugin()
  91.     : m_isInitialized(false), m_modelPath("")
  92. {
  93.  
  94. }
  95.  
  96. Yolo5Plugin::~Yolo5Plugin()
  97. {
  98.  
  99. }
  100.  
  101. PluginSpec::E_TypeFlag Yolo5Plugin::typeFlag() const
  102. {
  103.     return PluginSpec::E_TypeFlag::Defect;
  104. }
  105.  
  106. QIcon Yolo5Plugin::icon() const
  107. {
  108.     return QIcon(":/Yolo5Plugin.png");
  109. }
  110.  
  111. int Yolo5Plugin::init(const T_DefectSpec &spec)
  112. {
  113.     qDebug() << spec.arguments;
  114.     /* 判断参数是否有变化，有则重新加载，没有则跳过 */
  115.     QString dirPath = spec.arguments.value("-path").toString();
  116.     if(m_modelPath == dirPath)
  117.     {
  118.         qDebug() << "Initialized";
  119.         return 0;
  120.     }
  121.     m_modelPath = dirPath;
  122.     m_errmsg = "";
  123.  
  124.     if(!isDirExist(dirPath))
  125.     {
  126.         m_errmsg = "The model path does not exist";
  127.         return -1;
  128.     }
  129.     /* 模型路径 */
  130.     QTextCodec *code = QTextCodec::codecForName("GB2312");
  131.     std::string modelPath = code->fromUnicode(dirPath).data();
  132.     string xml_path = modelPath + "/yolov5s.xml";
  133.     string bin_path = modelPath + "/yolov5s.bin";
  134.     string class_path = modelPath + "/yolov5s.yaml";
  135.     if(!isFileExist(QString::fromStdString(xml_path)))
  136.     {
  137.         m_errmsg = "yolov5s.xml does not exist";
  138.         return -1;
  139.     }
  140.     if(!isFileExist(QString::fromStdString(bin_path)))
  141.     {
  142.         m_errmsg = "yolov5s.bin does not exist";
  143.         return -1;
  144.     }
  145.     if(!isFileExist(QString::fromStdString(class_path)))
  146.     {
  147.         m_errmsg = "yolov5s.yaml does not exist";
  148.         return -1;
  149.     }
  150. //    qDebug() << "xml_path:" << QString::fromStdString(xml_path);
  151.  
  152.     bool b = parseClass(class_path, _yolov5sYamlData);
  153.     if(!b)
  154.     {
  155.         m_errmsg = "yolov5s.yaml parsing failed";
  156.         return -1;
  157.     }
  158.     /* 推理引擎初始化 */
  159.     Core ie;
  160.     CNNNetwork network = ie.ReadNetwork(xml_path, bin_path);
  161.     network.setBatchSize(1);
  162.  
  163.     /* 输入设置 */
  164.     InputInfo::Ptr input_info = network.getInputsInfo().begin()->second;
  165.     _input_name = network.getInputsInfo().begin()->first;
  166.     input_info->getPreProcess().setResizeAlgorithm(RESIZE_BILINEAR);
  167.     input_info->setPrecision(Precision::FP32);
  168.     input_info->getInputData()->setLayout(Layout::NCHW);
  169.  
  170.     ICNNNetwork::InputShapes inputShapes = network.getInputShapes();
  171.     SizeVector &inSizeVector = inputShapes.begin()->second;
  172.     network.reshape(inputShapes);
  173.  
  174.     /* 输出设置 */
  175.     _outputinfo = OutputsDataMap(network.getOutputsInfo());
  176.     for (auto &output : _outputinfo)
  177.     {
  178.         output.second->setPrecision(Precision::FP32);
  179.     }
  180.     /* 加载网络 */
  181.     _network = ie.LoadNetwork(network, "CPU");
  182.  
  183.     m_isInitialized = true;
  184.  
  185.     return 0;
  186. }
  187.  
  188. bool Yolo5Plugin::isInitialized() const
  189. {
  190.     return m_isInitialized;
  191. }
  192.  
  193. int Yolo5Plugin::run(const T_DefectSpec &spec, T_DefectResult &result)
  194. {
  195.     if(!isInitialized())
  196.     {
  197.         m_errmsg = "uninitialized";
  198.         return -1;
  199.     }
  200.     try
  201.     {
  202.         /* 解析参数 */
  203.         double confidence_thr = spec.arguments.value("-confidenceThr").toString().toDouble();
  204.         int split_col_num = spec.arguments.value("-split_col_num").toString().toInt();
  205.         int split_row_num = spec.arguments.value("-split_row_num").toString().toInt();
  206.  
  207.         /* 大图变ROI */
  208.         int maxW = spec.frameParam.width;
  209.         int maxH = spec.frameParam.height;
  210.         Mat grayMat(maxH, maxW, CV_8UC1, spec.pImage);
  211.         if(!spec.rect.isEmpty())
  212.         {
  213.             maxW = spec.rect.width();
  214.             maxH = spec.rect.height();
  215.             grayMat = grayMat(cv::Rect(spec.rect.x(), spec.rect.y(),
  216.                                        spec.rect.width(), spec.rect.height()));
  217.         }
  218.         /* 分割图片 */
  219.         vector<Mat> tiles;
  220.         vector<int> baseXs;
  221.         vector<int> baseYs;
  222.         int subWidth  =  maxW / split_col_num;
  223.         int subHeight =  maxH / split_row_num;
  224.         for(int i = 0; i < split_row_num; i++)
  225.         {
  226.             for(int j = 0; j < split_col_num; ++j)
  227.             {
  228.                 int baseX = j * subWidth;
  229.                 int baseY = i * subHeight;
  230.                 Rect tile_rect = cv::Rect(baseX, baseY, subWidth, subHeight);
  231.                 tiles.push_back(grayMat(tile_rect));
  232.                 baseXs.push_back(baseX);
  233.                 baseYs.push_back(baseY);
  234.             }
  235.         }
  236.         auto calFunction = [ & ](int i, const Mat gray, int baseX, int baseY)
  237.         {
  238.             int item_size = _yolov5sYamlData.names.size() + 5;   //N+5
  239.             std::vector<Yolo5Plugin::T_Object> detected_objects;
  240.             processFrame(gray, item_size,  detected_objects);
  241.             mtx.lock();
  242.             for(int i = 0; i < detected_objects.size(); ++i)
  243.             {
  244.                 int label = detected_objects.at(i).label;
  245.                 float prob = detected_objects.at(i).prob;
  246.                 if(_yolov5sYamlData.shows.value(label, true))
  247.                 {
  248.                     QRectF box        = detected_objects.at(i).rect;
  249.                     QString name      = _yolov5sYamlData.names.value(label, "None");
  250.                     /* 置信度阈值 */
  251.                     if(prob > confidence_thr)
  252.                     {
  253.                         /* 合并结果 */
  254.                         double rectX = box.x() + baseX;
  255.                         double rectY = box.y() + baseY;
  256.                         double w = box.width();
  257.                         double h = box.height();
  258.                         if(!spec.rect.isEmpty())
  259.                         {
  260.                             result.boxVec.push_back(QRectF(rectX + spec.rect.x(), rectY + spec.rect.y(), w, h));
  261.                         }
  262.                         else
  263.                         {
  264.                             result.boxVec.push_back(QRectF(rectX, rectY, w, h));
  265.                         }
  266.                         result.nameVec.push_back(name);
  267.                         result.confidenceVec.push_back(prob);
  268.                     }
  269.                 }
  270.             }
  271.             mtx.unlock();
  272.         };
  273.         /* 多线程检测 */
  274.         vector<std::thread> threads;
  275.         for (int i = 0; i < tiles.size(); i++)
  276.         {
  277.             threads.push_back(std::thread(calFunction, i, tiles[i], baseXs.at(i), baseYs.at(i)));
  278.         }
  279.         for (int i = 0; i < threads.size(); i++)
  280.         {
  281.             threads[i].join();
  282.         }
  283.     }
  284.     catch(cv::Exception &e )
  285.     {
  286.         const char *err_msg = e.what();
  287.         m_errmsg = QString(err_msg);
  288.         qDebug() << "exception caught: {}" << err_msg;
  289.         return -1;
  290.     }
  291.     catch(...)
  292.     {
  293.         m_errmsg = "exception caught:  unknown";
  294.         qDebug() << "exception caught:  unknown";
  295.         return -1;
  296.     }
  297.     return 0;
  298. }
  299.  
  300. DefectInterface *Yolo5Plugin::newInstance()
  301. {
  302.     return new Yolo5Plugin();
  303. }
  304.  
  305. double Yolo5Plugin::sigmoid(double x)
  306. {
  307.     return (1 / (1 + exp(-x)));
  308. }
  309.  
  310. std::vector<int> Yolo5Plugin::get_anchors(int net_grid)
  311. {
  312.     vector<int> anchors(6);
  313.     int a80[6] = { 10, 13, 16, 30, 33, 23 };
  314.     int a40[6] = { 30, 61, 62, 45, 59, 119 };
  315.     int a20[6] = { 116, 90, 156, 198, 373, 326 };
  316.     if(net_grid == 80)
  317.     {
  318.         anchors.insert(anchors.begin(), a80, a80 + 6);
  319.     }
  320.     else if(net_grid == 40)
  321.     {
  322.         anchors.insert(anchors.begin(), a40, a40 + 6);
  323.     }
  324.     else if(net_grid == 20)
  325.     {
  326.         anchors.insert(anchors.begin(), a20, a20 + 6);
  327.     }
  328.     return anchors;
  329. }
  330.  
  331. bool Yolo5Plugin::parse_yolov5(const Blob::Ptr &blob, int net_grid,
  332.                                float cof_threshold, int item_size,
  333.                                std::vector<Rect> &o_rect,
  334.                                std::vector<float> &o_rect_cof,
  335.                                std::vector<float> &o_labels)
  336. {
  337.     vector<int> anchors = get_anchors(net_grid);
  338.     LockedMemory<const void> blobMapped = as<MemoryBlob>(blob)->rmap();
  339.     const float *output_blob = blobMapped.as<float *>();
  340.  
  341.     size_t gi =  net_grid * item_size;
  342.     size_t ggi = net_grid * gi;
  343.     size_t anchor_n = 3;
  344.  
  345. //    omp_set_num_threads(8);
  346. //    #pragma omp parallel for
  347.     for (int n = 0; n < anchor_n; ++n)
  348.     {
  349.         for (int i = 0; i < net_grid; ++i)
  350.         {
  351.             for (int j = 0; j < net_grid; ++j)
  352.             {
  353.                 double box_prob = output_blob[n * ggi + i * gi + j * item_size + 4];
  354.                 box_prob = sigmoid(box_prob);
  355.                 /* 框置信度不满足则整体置信度不满足 */
  356.                 if (box_prob < cof_threshold)
  357.                 {
  358.                     continue;
  359.                 }
  360.                 /* 此处输出为中心点坐标,需要转化为角点坐标   */
  361.                 double x = output_blob[n * ggi + i * gi + j * item_size + 0];
  362.                 double y = output_blob[n * ggi + i * gi + j * item_size + 1];
  363.                 double w = output_blob[n * ggi + i * gi + j * item_size + 2];
  364.                 double h = output_blob[n * ggi + i * gi + j * item_size + 3];
  365.  
  366.                 double max_prob = 0;
  367.                 int idx = 0;
  368.                 for (int t = 5; t < item_size; ++t)
  369.                 {
  370.                     double tp = output_blob[n * ggi + i * gi + j * item_size + t];
  371.                     tp = sigmoid(tp);
  372.                     if (tp > max_prob)
  373.                     {
  374.                         max_prob = tp;
  375.                         idx = t - 5;
  376.                     }
  377.                 }
  378.                 double cof = box_prob * max_prob;
  379.                 if (cof < cof_threshold)
  380.                 {
  381.                     continue;
  382.                 }
  383.  
  384.                 x = (sigmoid(x) * 2 - 0.5 + j) * 640.0f / net_grid;
  385.                 y = (sigmoid(y) * 2 - 0.5 + i) * 640.0f / net_grid;
  386.                 w = pow(sigmoid(w) * 2, 2) * anchors[2 * n];
  387.                 h = pow(sigmoid(h) * 2, 2) * anchors[2 * n + 1];
  388.                 double r_x = x - w / 2;
  389.                 double r_y = y - h / 2;
  390.                 Rect rect = Rect(int(r_x), int(r_y), int(w), int(h));
  391.                 o_rect.push_back(rect);
  392.                 o_rect_cof.push_back(cof);
  393.                 o_labels.push_back(idx);
  394.             }
  395.         }
  396.     }
  397.     return true;
  398. }
  399.  
  400. void Yolo5Plugin::resize(const Mat &graySrc, Mat &dst, double &scale)
  401. {
  402.     Mat src = graySrc;
  403.     cvtColor(src, src, COLOR_GRAY2RGB);
  404.     int width = src.cols;
  405.     int height = src.rows;
  406.     scale = min(640.0 / width, 640.0 / height);
  407.     int w = round(width * scale);
  408.     int h = round(height * scale);
  409.     Mat resize_img;
  410.     cv::resize(src, resize_img, Size(w, h));  // 640*X or X*640
  411.     int top = 0, bottom = 0, left = 0, right = 0;
  412.     if (w > h)
  413.     {
  414.         top = (w - h) / 2;
  415.         bottom = (w - h) - top;
  416.     }
  417.     else if (h > w)
  418.     {
  419.         left = (h - w) / 2;
  420.         right = (h - w) - left;
  421.     }
  422.  
  423.     copyMakeBorder(resize_img, resize_img, top, bottom, left, right, BORDER_CONSTANT, Scalar(114, 114, 114));  // 640*640
  424.     cvtColor(resize_img, resize_img, cv::COLOR_BGR2RGB);
  425.     dst = resize_img;
  426. }
  427.  
  428. bool Yolo5Plugin::processFrame(const Mat &gray, int item_size,
  429.                                std::vector<Yolo5Plugin::T_Object> &detected_objects)
  430. {
  431.     /* resize  && 颜色通道转换 */
  432.     Mat src = gray;
  433.     cvtColor(src, src, COLOR_GRAY2RGB);
  434.     int width = src.cols;
  435.     int height = src.rows;
  436.     double scale = min(640.0 / width, 640.0 / height);
  437.     int w = round(width * scale);
  438.     int h = round(height * scale);
  439.     Mat resize_img;
  440.     cv::resize(src, resize_img, Size(w, h));  // 640*X or X*640
  441.     int top = 0, bottom = 0, left = 0, right = 0;
  442.     if (w > h)
  443.     {
  444.         top = (w - h) / 2;
  445.         bottom = (w - h) - top;
  446.     }
  447.     else if (h > w)
  448.     {
  449.         left = (h - w) / 2;
  450.         right = (h - w) - left;
  451.     }
  452.  
  453.     copyMakeBorder(resize_img, resize_img, top, bottom, left, right, BORDER_CONSTANT, Scalar(114, 114, 114));  // 640*640
  454.     cvtColor(resize_img, resize_img, cv::COLOR_BGR2RGB);
  455.  
  456.     /* 推断请求和blob填充 */
  457.     InferRequest infer_request = _network.CreateInferRequest();
  458.     Blob::Ptr frameBlob = infer_request.GetBlob(_input_name);
  459.  
  460.     size_t img_size = IMG_LEN * IMG_LEN;
  461.     InferenceEngine::LockedMemory<void> blobMapped = InferenceEngine::as<InferenceEngine::MemoryBlob>(frameBlob)->wmap();
  462.     float *blob_data = blobMapped.as<float *>();
  463. //    omp_set_num_threads(4);
  464. //    #pragma omp parallel for
  465.     for (int row = 0; row < IMG_LEN; row++)
  466.     {
  467.         for (int col = 0; col < IMG_LEN; col++)
  468.         {
  469.             for (int ch = 0; ch < 3; ch++)
  470.             {
  471.                 blob_data[img_size * ch + row * IMG_LEN + col] = float(resize_img.at<Vec3b>(row, col)[ch]) / 255.0f;
  472.             }
  473.         }
  474.     }
  475.     /* 推断执行 */
  476.     infer_request.Infer();
  477.  
  478.     /* 获取推断结果 */
  479.     int net_grids[3] = {80, 40, 20};
  480.     vector<Blob::Ptr> blobs;
  481.     for (auto &output : _outputinfo)
  482.     {
  483.         auto output_name = output.first;
  484.         Blob::Ptr blob = infer_request.GetBlob(output_name);
  485.         blobs.push_back(blob);
  486.     }
  487.  
  488.     float cof_threshold = 0.25;
  489.  
  490.     vector<Rect> o_rect;
  491.     vector<float> o_rect_cof;
  492.     vector<int> labels;
  493.  
  494.     QTime globalTime2;
  495.     globalTime2.start();
  496.     for(int i = 0; i < blobs.size(); ++i)
  497.     {
  498.         if(i < 3)
  499.         {
  500.             vector<Rect> o_rect_temp;
  501.             vector<float> o_rect_cof_temp;
  502.             vector<float> o_labels_temp;
  503.             parse_yolov5(blobs[i], net_grids[i], cof_threshold, item_size,
  504.                          o_rect_temp, o_rect_cof_temp, o_labels_temp);
  505.             o_rect.insert(o_rect.end(), o_rect_temp.begin(), o_rect_temp.end());
  506.             o_rect_cof.insert(o_rect_cof.end(), o_rect_cof_temp.begin(), o_rect_cof_temp.end());
  507.             labels.insert(labels.end(), o_labels_temp.begin(), o_labels_temp.end());
  508.         }
  509.     }
  510.  
  511.     /* NMS去除同一个物体多余的框 */
  512.     float nms_area_threshold = 0.45;
  513.     vector<int> final_id;
  514.     dnn::NMSBoxes(o_rect, o_rect_cof, cof_threshold, nms_area_threshold, final_id);
  515.  
  516.     int num = final_id.size();
  517.     for (int i = 0; i < num; ++i)
  518.     {
  519.         int label = labels[final_id[i]];
  520.         Rect resize_rect = o_rect[final_id[i]];
  521.         int find_col = int(max(resize_rect.x - left, 0) / scale);
  522.         int find_row = int(max(resize_rect.y - top, 0) / scale);
  523.         int find_w = int(resize_rect.width / scale);
  524.         int find_h = int(resize_rect.height / scale);
  525.         QRectF rawrect(find_col, find_row, find_w, find_h);
  526.         float cof = o_rect_cof[final_id[i]];
  527.         detected_objects.push_back(T_Object{cof, label, rawrect});
  528.     }
  529.     return true;
  530. }
  531.  
  532. #if QT_VERSION < 0x050000
  533.     Q_EXPORT_PLUGIN2(Yolo5Plugin, Yolo5Plugin)
  534. #endif // QT_VERSION < 0x050000

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/819555
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号