devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

yolov5分割+检测c++ qt 中部署，以opencv方式（详细代码（全）+复制可用）_yolov5+qt+c++

作者：凡人多烦事01 | 2024-03-24 06:07:29

赞

踩

yolov5+qt+c++

1：版本说明：

qt 5.12.10

opencv 4.5.3 （yolov5模型部署要求opencv>4.5.0）

2：检测的代码

yolo.h
  1. #pragma once
  2. #include<iostream>
  3. #include<cmath>
  4. #include<vector>
  5. #include <opencv2/opencv.hpp>
  6. #include<opencv2/dnn.hpp>
  7.  
  8. class yolo
  9. {
  10. public:
  11.     yolo() {}
  12.     ~yolo(){}
  13.     bool readModel(cv::dnn::Net &net,std::string &netpath, bool isCuda);
  14.     struct Output
  15.     {
  16.         int id;//结果类别id
  17.         float confidence;//结果置信度
  18.         cv::Rect box;//矩形框
  19.  
  20.         int ship_id;//船的id
  21.         int truck_id;//人的id
  22.         int person_id;//人的id
  23.          int  staring_id;//车的id
  24.         int  forklift_id;//车的id
  25.  
  26.         int unload_car_id;//船的id
  27.         int load_car_id;//人的id
  28.         int  private_car_id;//车的id
  29.  
  30.     };
  31.     struct Output_max_confidence
  32.     {
  33.         int id;//结果类别id
  34.         float confidence;//结果置信度
  35.         cv::Rect box;//矩形框
  36.  
  37.     };
  38.     int ship_num;//总人数
  39.     int  car_trucks_num;//总车数
  40.     int person_num;//总船数
  41.     int stacking_area_num;//总人数
  42.     int  car_forklift_num;//总车数
  43.     int unload_car_num;//总船数
  44.     int load_car_num;//总人数
  45.     int  car_private_num;//总车数
  46.  
  47.     bool Detect(cv::Mat &SrcImg, cv::dnn::Net &net, std::vector<Output> &output);
  48.     void drawPred(cv::Mat &img, std::vector<Output> result, std::vector<cv::Scalar> color);
  49.  
  50.     //参数为私有参数，当然也可以是设置成公开或者保护。
  51.     Output_max_confidence get_only_one_max_confidence(std::vector<Output> result);
  52.     float findMax(std::vector<float> vec);
  53.  
  54.     int getPositionOfMax(std::vector<float> vec, int max);
  55. \
  56.     void drawRect(cv::Mat &img, yolo::Output_max_confidence result);
  57. private:
  58.     //计算归一化函数
  59.     float Sigmoid(float x) {
  60.         return static_cast<float>(1.f / (1.f + exp(-x)));
  61.     }
  62.     //anchors
  63.     const float netAnchors[3][6] = { { 10.0, 13.0, 16.0, 30.0, 33.0, 23.0 },{ 30.0, 61.0, 62.0, 45.0, 59.0, 119.0 },{ 116.0, 90.0, 156.0, 198.0, 373.0, 326.0 } };
  64.     //stride
  65.     const float netStride[3] = { 8.0, 16.0, 32.0 };
  66.     const int netWidth = 640; //网络模型输入大小
  67.     const int netHeight = 640;
  68.     float nmsThreshold = 0.02;
  69.     float boxThreshold = 0.05;
  70.     float classThreshold = 0.45;
  71.     //类名
  72. //    std::vector<std::string> className = { "car", "person"};
  73. //    std::vector<std::string> className = { "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
  74. //                                           "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
  75. //                                           "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
  76. //                                           "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
  77. //                                           "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
  78. //                                           "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
  79. //                                           "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
  80. //                                           "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear",
  81. //                                           "hair drier", "toothbrush"};
  82.     std::vector<std::string> className = { "ship","car_trucks","person","stacking_area","car_forklift","unload_car","load_car","car_private"};//"car","person"
  83.  
  84.  
  85. };
yolo.cpp
  1. #include "yolo.h"
  2. #include<iostream>
  3. #include<cmath>
  4. #include<vector>
  5. #include <opencv2/opencv.hpp>
  6. #include<opencv2/dnn.hpp>
  7. using namespace std;
  8. using namespace cv;
  9. using namespace dnn;
  10. #pragma execution_character_set("utf-8");
  11. bool yolo::readModel(Net &net, string &netPath, bool isCuda = false) {
  12.     try {
  13.         net = readNetFromONNX(netPath);
  14.         cout<<"load net successfull!"<<endl;
  15.     }
  16.     catch (const std::exception&) {
  17.         return false;
  18.     }
  19.     //cuda
  20.     if (isCuda) {
  21.         net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
  22.         net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
  23.     }
  24.     //cpu
  25.     else {
  26.         net.setPreferableBackend(cv::dnn::DNN_BACKEND_DEFAULT);
  27.         net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
  28.     }
  29.     return true;
  30. }
  31.  
  32.  
  33. bool yolo::Detect(Mat &SrcImg, Net &net, vector<Output> &output) {
  34.     Mat blob;
  35.     int col = SrcImg.cols;
  36.     int row = SrcImg.rows;
  37.     int maxLen = MAX(col, row);
  38.     Mat netInputImg = SrcImg.clone();
  39.     if (maxLen > 1.2*col || maxLen > 1.2*row) {
  40.         Mat resizeImg = Mat::zeros(maxLen, maxLen, CV_8UC3);
  41.         SrcImg.copyTo(resizeImg(Rect(0, 0, col, row)));
  42.         netInputImg = resizeImg;
  43.     }
  44.     blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(netWidth, netHeight), cv::Scalar(104, 117, 123), true, false);
  45.     blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(netWidth, netHeight), cv::Scalar(0, 0,0), true, false);//如果训练集未对图片进行减去均值操作，则需要设置为这句
  46.     //blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(netWidth, netHeight), cv::Scalar(114, 114,114), true, false);
  47.     net.setInput(blob);
  48.     std::vector<cv::Mat> netOutputImg;
  49.     //vector<string> outputLayerName{"345","403", "461","output" };
  50.     //net.forward(netOutputImg, outputLayerName[3]); //获取output的输出
  51.     net.forward(netOutputImg, net.getUnconnectedOutLayersNames());
  52.  
  53.     //接上面
  54.     std::vector<int> classIds;//结果id数组
  55.     std::vector<float> confidences;//结果每个id对应置信度数组
  56.     std::vector<cv::Rect> boxes;//每个id矩形框
  57.     std::vector<int> ship_id;//记录下人数的id号码----补充
  58.     std::vector<int> trucks_id;//记录下车数的id号码----补充
  59.     std::vector<int> person_id;//记录下人数的id号码----补充
  60.     std::vector<int> stacking_id;//记录下车数的id号码----补充
  61.     std::vector<int> forklift_id;//记录下人数的id号码----补充
  62.     std::vector<int> unload_car_id;//记录下车数的id号码----补充
  63.     std::vector<int> load_car_id;//记录下人数的id号码----补充
  64.     std::vector<int> car_private_id;//记录下车数的id号码----补充
  65.  
  66.     float ratio_h = (float)netInputImg.rows / netHeight;
  67.     float ratio_w = (float)netInputImg.cols / netWidth;
  68.     int net_width = className.size() + 5;  //输出的网络宽度是类别数+5
  69.     float* pdata = (float*)netOutputImg[0].data;
  70.     for (int stride = 0; stride < 3; stride++) {    //stride
  71.         int grid_x = (int)(netWidth / netStride[stride]);
  72.         int grid_y = (int)(netHeight / netStride[stride]);
  73.         for (int anchor = 0; anchor < 3; anchor++) { //anchors
  74.             const float anchor_w = netAnchors[stride][anchor * 2];
  75.             const float anchor_h = netAnchors[stride][anchor * 2 + 1];
  76.             for (int i = 0; i < grid_y; i++) {
  77.                 for (int j = 0; j < grid_y; j++) {
  78.                     //float box_score = Sigmoid(pdata[4]);//获取每一行的box框中含有某个物体的概率 yolo5.0
  79.                     float box_score = pdata[4];//获取每一行的box框中含有某个物体的概率 yolo6.0
  80.                     if (box_score > boxThreshold) {
  81.                         //为了使用minMaxLoc(),将85长度数组变成Mat对象
  82.                         cv::Mat scores(1, className.size(), CV_32FC1, pdata + 5);
  83.                         Point classIdPoint;
  84.                         double max_class_socre;
  85.                         minMaxLoc(scores, 0, &max_class_socre, 0, &classIdPoint);
  86.                         //max_class_socre = Sigmoid((float)max_class_socre);  //yolo 5.0
  87.                         max_class_socre = (float)max_class_socre;    //yolo 6.0
  88.                         if (max_class_socre > classThreshold) {
  89.                             //rect [x,y,w,h]
  90.                             //yolov5 5.0格式
  91.                             //float x = (Sigmoid(pdata[0]) * 2.f - 0.5f + j) * netStride[stride];  //x
  92.                             //float y = (Sigmoid(pdata[1]) * 2.f - 0.5f + i) * netStride[stride];   //y
  93.                             //float w = powf(Sigmoid(pdata[2]) * 2.f, 2.f) * anchor_w;   //w
  94.                             //float h = powf(Sigmoid(pdata[3]) * 2.f, 2.f) * anchor_h;  //h
  95.                             //yolov5 6.0格式：
  96.                             float x = pdata[0];// (Sigmoid(pdata[0]) * 2.f - 0.5f + j) * netStride[stride];  //x
  97.                             float y = pdata[1];// (Sigmoid(pdata[1]) * 2.f - 0.5f + i) * netStride[stride];   //y
  98.                             float w = pdata[2];// powf(Sigmoid(pdata[2]) * 2.f, 2.f) * anchor_w;   //w
  99.                             float h = pdata[3];// powf(Sigmoid(pdata[3]) * 2.f, 2.f) * anchor_h;  //h
  100.                             int left = (x - 0.5*w)*ratio_w;
  101.                             int top = (y - 0.5*h)*ratio_h;
  102.  
  103.                             classIds.push_back(classIdPoint.x);
  104.                             confidences.push_back(max_class_socre*box_score);
  105.                             boxes.push_back(Rect(left, top, int(w*ratio_w), int(h*ratio_h)));
  106.  
  107.                         }
  108.                     }
  109.                     pdata += net_width;//指针移到下一行
  110.                 }
  111.             }
  112.         }
  113.     }
  114.  
  115.     //接上面执行非最大抑制以消除具有较低置信度的冗余重叠框（NMS）
  116.     vector<int> nms_result;
  117.     int ship_id_ini=0;//初始化人数，
  118.     int trucks_id_ini=0;//初始化人数，
  119.     int person_id_ini=0;//初始化车辆数
  120.     int stacking_id_ini=0;//初始化车辆数
  121.  
  122.     int forklift_id_ini=0;//初始化车辆数
  123.     int unload_car_id_ini=0;//初始化车辆数
  124.     int load_car_id_ini=0;//初始化车辆数
  125.     int car_private_id_ini=0;//初始化车辆数
  126.  
  127.  
  128.     NMSBoxes(boxes, confidences, classThreshold, nmsThreshold, nms_result);
  129.     for (int i = 0; i < nms_result.size(); i++) {
  130.         int idx = nms_result[i];
  131.         Output result;
  132.         result.id = classIds[idx];
  133.         result.confidence = confidences[idx];
  134.         result.box = boxes[idx];
  135.  
  136.         output.push_back(result);
  137.         if(result.id==0)//当类别数等于船的时候
  138.         {
  139.             result.ship_id=ship_id_ini;//当船等于
  140.             ship_id_ini=ship_id_ini+1;
  141.  
  142.         }
  143.         if(result.id==1)//当类别数等于车的时候
  144.         {
  145.             result.truck_id=trucks_id_ini;//当车数等于
  146.             trucks_id_ini=trucks_id_ini+1;
  147.         }
  148.         if(result.id==2)//当类别数等于人的时候
  149.         {
  150.             result.person_id=person_id_ini;//当人数等于
  151.             person_id_ini=person_id_ini+1;
  152.  
  153.         }if(result.id==3)//当类别数等于人的时候
  154.         {
  155.             result.staring_id=stacking_id_ini;//当人数等于
  156.             stacking_id_ini=stacking_id_ini+1;
  157.  
  158.         }
  159.         if(result.id==4)//当类别数等于人的时候
  160.         {
  161.             result.forklift_id=forklift_id_ini;//当人数等于
  162.             forklift_id_ini=forklift_id_ini+1;
  163.  
  164.         }
  165.         if(result.id==5)//当类别数等于人的时候
  166.         {
  167.             result.unload_car_id=unload_car_id_ini;//当人数等于
  168.             unload_car_id_ini=unload_car_id_ini+1;
  169.  
  170.         }
  171.         if(result.id==6)//当类别数等于人的时候
  172.         {
  173.             result.load_car_id=load_car_id_ini;//当人数等于
  174.             load_car_id_ini=load_car_id_ini+1;
  175.  
  176.         }
  177.         if(result.id==7)//当类别数等于人的时候
  178.         {
  179.             result.private_car_id=car_private_id_ini;//当人数等于
  180.             car_private_id_ini=car_private_id_ini+1;
  181.  
  182.         }
  183.  
  184.     }
  185.  
  186.     ship_num=ship_id_ini;
  187.     car_trucks_num=trucks_id_ini;
  188.     person_num=person_id_ini;
  189.  
  190.     stacking_area_num=stacking_id_ini;
  191.     car_forklift_num=forklift_id_ini ;//总车数
  192.     unload_car_num=unload_car_id_ini;//总船数
  193.     load_car_num=load_car_id_ini;//总人数
  194.     car_private_num=car_private_id_ini;//总车数
  195.  
  196.     if (output.size())
  197.         return true;
  198.     else
  199.         return false;
  200.  
  201. }//这个括号是最后
  202.  
  203. void yolo::drawPred(Mat &img, vector<Output> result, vector<Scalar> color)
  204. {
  205.  
  206.     for (int i = 0; i < result.size(); i++)
  207.     {
  208.         int left, top;
  209.         left = result[i].box.x;
  210.         top = result[i].box.y;
  211.         int color_num = i;
  212.         rectangle(img, result[i].box, color[result[i].id], 2, 8);
  213.         //      string label = className[result[i].id] + ":" + to_string(result[i].confidence)+" id:"+to_string(result[i].person_id);
  214.         string label;
  215.         if(result[i].id==0)
  216.         {
  217.             label = className[result[i].id] ;
  218.         }
  219.         if(result[i].id==1)
  220.         {
  221.             label = className[result[i].id] ;
  222.         }
  223.         if(result[i].id==2)
  224.         {
  225.             label = className[result[i].id] ;
  226.         }
  227.         if(result[i].id==3)
  228.         {
  229.             label = className[result[i].id] ;
  230.         }
  231.         if(result[i].id==4)
  232.         {
  233.             label = className[result[i].id] ;
  234.         }
  235.         if(result[i].id==5)
  236.         {
  237.             label = className[result[i].id] ;
  238.         }
  239.         if(result[i].id==6)
  240.         {
  241.             label = className[result[i].id] ;
  242.         }
  243.         if(result[i].id==7)
  244.         {
  245.             label = className[result[i].id];
  246.         }
  247.         int baseLine;
  248.         Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
  249.         top = max(top, labelSize.height);
  250.         //rectangle(frame, Point(left, top - int(1.5 * labelSize.height)), Point(left + int(1.5 * labelSize.width), top + baseLine), Scalar(0, 255, 0), FILLED);
  251.         putText(img, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 1, color[result[i].id], 2);
  252.     }
  253.     //imshow("res", img);
  254.     //imwrite("./result.jpg", img);
  255.     //waitKey();
  256.     //destroyAllWindows();
  257. }
  258.  
  259. //这个是针对悍马的画框
  260. void yolo::drawRect(cv::Mat &img, yolo::Output_max_confidence result)
  261. {
  262.  
  263.     int left, top;
  264.     left = result.box.x;
  265.     top = result.box.y;
  266.  
  267.     rectangle(img, result.box,Scalar(0,0,255) , 2, 8);
  268.     //      string label = className[result[i].id] + ":" + to_string(result[i].confidence)+" id:"+to_string(result[i].person_id);
  269.     string label;
  270.     if(result.id==0)
  271.     {
  272.         label = className[result.id];
  273.     }
  274.     int baseLine;
  275.     Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
  276.     top = max(top, labelSize.height);
  277.     //rectangle(frame, Point(left, top - int(1.5 * labelSize.height)), Point(left + int(1.5 * labelSize.width), top + baseLine), Scalar(0, 255, 0), FILLED);
  278.     putText(img, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 2,Scalar(0,0,255), 2);
  279.  
  280. }
  281.  
  282. float yolo::findMax(std::vector<float> vec) {
  283.     float max = -999;
  284.     for (auto v : vec) {
  285.         if (max < v) max = v;
  286.     }
  287.     return max;
  288. }
  289.  
  290. int yolo::getPositionOfMax(std::vector<float> vec, int max) {
  291.     auto distance = find(vec.begin(), vec.end(), max);
  292.     return distance - vec.begin();
  293. }
  294.  
  295. //返回一个最大置信度的框
  296. yolo::Output_max_confidence yolo::get_only_one_max_confidence(std::vector<Output> result)
  297. {
  298.  
  299.     std::vector<float>confidence;
  300.     for (int i = 0; i < result.size(); i++)
  301.     {
  302.         confidence.push_back(result.at(i).confidence);
  303.         //        cout<<"result.at(i).confidence"<<result.at(i).confidence<<endl;
  304.     }
  305.     float maxConfidence=findMax(confidence);
  306.     int position = result.size()-getPositionOfMax(confidence, maxConfidence);
  307.     //    cout<<"max_confidengce"<<maxConfidence<<"position:"<<position<<endl;
  308.     Output_max_confidence o_m_c;
  309.     o_m_c.confidence=maxConfidence;
  310.     o_m_c.id=position;
  311.     o_m_c.box=result.at(position).box;
  312.     return o_m_c ;
  313.  
  314. }
检测的调用代码测试案例

这段调用的例子，只要把frame 改成你们自己的图片即可

  1. yolo test;    //创建yolo类
  2. cv::dnn::Net net; //创建yolo网络
  3. vector< cv::Scalar> color;//Bounding Box颜色 
  4. QString Filename_onnx="quanjingbest.onnx";
  5. cv::String filename_onnx=Filename_onnx.toStdString();
  6. vector<yolo::Output>result_video;
  7. test.readModel(net,filename_onnx,false);
  8. for (int i = 0; i < 80; i++) {
  9.         int b = rand() % 256;
  10.         int g = rand() % 256;
  11.         int r = rand() % 256;
  12.         color.push_back( cv::Scalar(b, g, r));
  13.     }
  14.  
  15. cv::Mat frame=cv::imread("D://1.jpg");
  16. if(test.Detect(frame, net, result_video))          //调用YOLO模型检测
  17.       test.drawPred(frame, result_video, color);
  18. cv::imshow("a",frame);
  19. cv::waitKey(1);

4：分割的主要代码

YoloSeg.h
  1. #ifndef YOLO_SEG_H
  2. #define YOLO_SEG_H
  3.  
  4.  
  5. #pragma once
  6. #include<iostream>
  7. #include<opencv2/opencv.hpp>
  8. #include "yolov5_seg_utils.h"
  9.  
  10. class YoloSeg {
  11. public:
  12.     YoloSeg() {
  13.     }
  14.     ~YoloSeg() {}
  15.     /** \brief Read onnx-model
  16.     * \param[out] read onnx file into cv::dnn::Net
  17.     * \param[in] modelPath:onnx-model path
  18.     * \param[in] isCuda:if true and opencv built with CUDA(cmake),use OpenCV-GPU,else run it on cpu.
  19.     */
  20.     bool ReadModel(cv::dnn::Net& net, std::string& netPath, bool isCuda);
  21.     /** \brief  detect.
  22.     * \param[in] srcImg:a 3-channels image.
  23.     * \param[out] output:detection results of input image.
  24.     */
  25.     bool Detect(cv::Mat& srcImg, cv::dnn::Net& net, std::vector<OutputSeg>& output);
  26.  
  27. #if(defined YOLO_P6 && YOLO_P6==true)
  28.  
  29.     const int _netWidth = 1280;  //ONNX图片输入宽度
  30.     const int _netHeight = 1280; //ONNX图片输入高度
  31.     const int _segWidth = 320;  //_segWidth=_netWidth/mask_ratio
  32.     const int _segHeight = 320;
  33.     const int _segChannels = 32;
  34. #else
  35.  
  36.     const int _netWidth = 640;   //ONNX图片输入宽度
  37.     const int _netHeight = 640;  //ONNX图片输入高度
  38.     const int _segWidth = 160;    //_segWidth=_netWidth/mask_ratio
  39.     const int _segHeight = 160;
  40.     const int _segChannels = 32;
  41.  
  42. #endif // YOLO_P6
  43.  
  44.     float _classThreshold = 0.25;
  45.     float _nmsThreshold = 0.45;
  46.     float _maskThreshold = 0.5;
  47.  
  48. public:
  49.     std::vector<std::string> _className = { "steel"};//类别名，换成自己的模型需要修改此项
  50. };
  51.  
  52. #endif // YOLO_SEG_H
YoloSeg.cpp
  1. #include "yolo_seg.h"
  2.  
  3. #include"yolo_seg.h"
  4. using namespace std;
  5. using namespace cv;
  6. using namespace cv::dnn;
  7.  
  8. bool YoloSeg::ReadModel(Net& net, string& netPath, bool isCuda = false) {
  9.     try {
  10.         net = readNet(netPath);
  11. #if CV_VERSION_MAJOR==4 &&CV_VERSION_MINOR==7&&CV_VERSION_REVISION==0
  12.         net.enableWinograd(false);  //bug of opencv4.7.x in AVX only platform ,https://github.com/opencv/opencv/pull/23112 and https://github.com/opencv/opencv/issues/23080
  13.         //net.enableWinograd(true);		//If your CPU supports AVX2, you can set it true to speed up
  14. #endif
  15.     }
  16.     catch (const std::exception&) {
  17.         return false;
  18.     }
  19.     if (isCuda) {
  20.         //cuda
  21.         net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
  22.         net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA); //or DNN_TARGET_CUDA_FP16
  23.     }
  24.     else {
  25.         //cpu
  26.         cout << "Inference device: CPU" << endl;
  27.         net.setPreferableBackend(cv::dnn::DNN_BACKEND_DEFAULT);
  28.         net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
  29.     }
  30.     return true;
  31. }
  32.  
  33.  
  34. bool YoloSeg::Detect(Mat& srcImg, Net& net, vector<OutputSeg>& output) {
  35.     Mat blob;
  36.     output.clear();
  37.     int col = srcImg.cols;
  38.     int row = srcImg.rows;
  39.     Mat netInputImg;
  40.     Vec4d params;
  41.     LetterBox(srcImg, netInputImg, params, cv::Size(_netWidth, _netHeight));
  42.     blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(_netWidth, _netHeight), cv::Scalar(0, 0, 0), true, false);
  43.     //**************************************************************************************************************************************************/
  44.     //如果在其他设置没有问题的情况下但是结果偏差很大，可以尝试下用下面两句语句
  45.     // If there is no problem with other settings, but results are a lot different from  Python-onnx , you can try to use the following two sentences
  46.     //
  47.     //$ blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(_netWidth, _netHeight), cv::Scalar(104, 117, 123), true, false);
  48.     //$ blobFromImage(netInputImg, blob, 1 / 255.0, cv::Size(_netWidth, _netHeight), cv::Scalar(114, 114,114), true, false);
  49.     //****************************************************************************************************************************************************/
  50.     net.setInput(blob);
  51.     std::vector<cv::Mat> net_output_img;
  52.     //*********************************************************************************************************************************
  53.     //net.forward(net_output_img, net.getUnconnectedOutLayersNames());
  54.     //opencv4.5.x和4.6.x这里输出不一致，推荐使用下面的固定名称输出
  55.     // 如果使用net.forward(net_output_img, net.getUnconnectedOutLayersNames())，需要确认下net.getUnconnectedOutLayersNames()返回值中output0在前，output1在后，否者出错
  56.     //
  57.     // The outputs of opencv4.5.x and 4.6.x are inconsistent.Please make sure "output0" is in front of "output1" if you use net.forward(net_output_img, net.getUnconnectedOutLayersNames())
  58.     //*********************************************************************************************************************************
  59.     vector<string> output_layer_names{ "output0","output1" };
  60.     net.forward(net_output_img, output_layer_names); //获取output的输出
  61.  
  62.     std::vector<int> class_ids;//结果id数组
  63.     std::vector<float> confidences;//结果每个id对应置信度数组
  64.     std::vector<cv::Rect> boxes;//每个id矩形框
  65.     std::vector<vector<float>> picked_proposals;  //output0[:,:, 5 + _className.size():net_width]===> for mask
  66.     int net_width = _className.size() + 5 + _segChannels;// 80 + 5 + 32 = 117
  67.     int out0_width= net_output_img[0].size[2];
  68.  
  69. //    assert(net_width == out0_width, "Error Wrong number of _className or _segChannels");  //模型类别数目不对或者_segChannels设置错误
  70.     int net_height = net_output_img[0].size[1];// 25200
  71.     float* pdata = (float*)net_output_img[0].data;
  72.     for (int r = 0; r < net_height; r++) {    //lines
  73.         float box_score = pdata[4];
  74.         if (box_score >= _classThreshold) {
  75.             cv::Mat scores(1, _className.size(), CV_32FC1, pdata + 5); //  可是 后面不只是有80个类别的概率；
  76.             Point classIdPoint;
  77.             double max_class_socre;
  78.             minMaxLoc(scores, 0, &max_class_socre, 0, &classIdPoint);
  79.             max_class_socre = (float)max_class_socre;
  80.             if (max_class_socre >= _classThreshold) {
  81.  
  82.                 vector<float> temp_proto(pdata + 5 + _className.size(), pdata + net_width); // Mask Coeffcients,mask的掩码系数
  83.                 picked_proposals.push_back(temp_proto);
  84.                 //rect [x,y,w,h]
  85.                 float x = (pdata[0] - params[2]) / params[0];  //x
  86.                 float y = (pdata[1] - params[3]) / params[1];  //y
  87.                 float w = pdata[2] / params[0];  //w
  88.                 float h = pdata[3] / params[1];  //h
  89.                 int left = MAX(int(x - 0.5 * w + 0.5), 0);
  90.                 int top = MAX(int(y - 0.5 * h + 0.5), 0);
  91.                 class_ids.push_back(classIdPoint.x);
  92.                 confidences.push_back(max_class_socre * box_score);
  93.                 boxes.push_back(Rect(left, top, int(w + 0.5), int(h + 0.5)));
  94.             }
  95.         }
  96.         pdata += net_width;//下一行
  97.  
  98.     }
  99.  
  100.     //NMS
  101.     vector<int> nms_result;
  102.     cv::dnn::NMSBoxes(boxes, confidences, _classThreshold, _nmsThreshold, nms_result);
  103.     std::vector<vector<float>> temp_mask_proposals;
  104.     Rect holeImgRect(0, 0, srcImg.cols, srcImg.rows);
  105.     for (int i = 0; i < nms_result.size(); ++i) {
  106.  
  107.         int idx = nms_result[i];
  108.         OutputSeg result;
  109.         result.id = class_ids[idx];
  110.         result.confidence = confidences[idx];
  111.         result.box = boxes[idx] & holeImgRect;
  112.         temp_mask_proposals.push_back(picked_proposals[idx]);
  113.         output.push_back(result);
  114.     }
  115.  
  116.     MaskParams mask_params;
  117.     mask_params.params = params;
  118.     mask_params.srcImgShape = srcImg.size();
  119.     for (int i = 0; i < temp_mask_proposals.size(); ++i) {
  120.         GetMask2(Mat(temp_mask_proposals[i]).t(), net_output_img[1], output[i], mask_params); // 注意这里是net_output_img[1]，为原型mask
  121.     }
  122.  
  123.  
  124.     //******************** ****************
  125.     // 老版本的方案，如果上面GetMask2出错，建议使用这个。
  126.     // If the GetMask2() still reports errors , it is recommended to use GetMask().
  127.     // Mat mask_proposals;
  128.     //for (int i = 0; i < temp_mask_proposals.size(); ++i)
  129.     //	mask_proposals.push_back(Mat(temp_mask_proposals[i]).t());
  130.     //GetMask(mask_proposals, net_output_img[1], output, mask_params);
  131.     //*****************************************************/
  132.  
  133.  
  134.     if (output.size())
  135.         return true;
  136.     else
  137.         return false;
  138. }
yolov5_seg_utils.h
  1. #ifndef YOLOV5_SEG_UTILS_H
  2. #define YOLOV5_SEG_UTILS_H
  3.  
  4.  
  5. #pragma once
  6. #include<iostream>
  7. #include <numeric>
  8. #include<opencv2/opencv.hpp>
  9.  
  10. #define YOLO_P6 false //是否使用P6模型
  11. #define ORT_OLD_VISON 12  //ort1.12.0 之前的版本为旧版本API
  12.  
  13. struct OutputSeg {
  14.     int id;             //结果类别id
  15.     float confidence;   //结果置信度
  16.     cv::Rect box;       //矩形框
  17.     cv::Mat boxMask;       //矩形框内mask，节省内存空间和加快速度
  18. };
  19. struct MaskParams {
  20.     int segChannels = 32;
  21.     int segWidth = 160;
  22.     int segHeight = 160;
  23.     int netWidth = 640;
  24.     int netHeight = 640;
  25.     float maskThreshold = 0.5;
  26.     cv::Size srcImgShape;
  27.     cv::Vec4d params;
  28.  
  29. };
  30. bool CheckParams(int netHeight, int netWidth, const int* netStride, int strideSize);
  31. void DrawPred(cv::Mat& img, std::vector<OutputSeg> result, std::vector<std::string> classNames, std::vector<cv::Scalar> color);
  32. void LetterBox(const cv::Mat& image, cv::Mat& outImage,
  33.     cv::Vec4d& params, //[ratio_x,ratio_y,dw,dh]
  34.     const cv::Size& newShape = cv::Size(640, 640),
  35.     bool autoShape = false,
  36.     bool scaleFill = false,
  37.     bool scaleUp = true,
  38.     int stride = 32,
  39.     const cv::Scalar& color = cv::Scalar(114, 114, 114));
  40. void GetMask(const cv::Mat& maskProposals, const cv::Mat& maskProtos, std::vector<OutputSeg>& output, const MaskParams& maskParams);
  41. void GetMask2(const cv::Mat& maskProposals, const cv::Mat& maskProtos, OutputSeg& output, const MaskParams& maskParams);
  42.  
  43. #endif // YOLOV5_SEG_UTILS_H
 yolov5_seg_utils.cpp
  1. #include "yolov5_seg_utils.h"
  2.  
  3. #pragma once
  4. #include "yolov5_seg_utils.h"
  5. using namespace cv;
  6. using namespace std;
  7. bool CheckParams(int netHeight, int netWidth, const int* netStride, int strideSize) {
  8.     if (netHeight % netStride[strideSize - 1] != 0 || netWidth % netStride[strideSize - 1] != 0)
  9.     {
  10.         cout << "Error:_netHeight and _netWidth must be multiple of max stride " << netStride[strideSize - 1] << "!" << endl;
  11.         return false;
  12.     }
  13.     return true;
  14. }
  15.  
  16. void LetterBox(const cv::Mat& image, cv::Mat& outImage, cv::Vec4d& params, const cv::Size& newShape,
  17.     bool autoShape, bool scaleFill, bool scaleUp, int stride, const cv::Scalar& color)
  18. {
  19.     if (false) {
  20.         int maxLen = MAX(image.rows, image.cols);
  21.         outImage = Mat::zeros(Size(maxLen, maxLen), CV_8UC3);
  22.         image.copyTo(outImage(Rect(0, 0, image.cols, image.rows)));
  23.         params[0] = 1;
  24.         params[1] = 1;
  25.         params[3] = 0;
  26.         params[2] = 0;
  27.     }
  28.  
  29.     cv::Size shape = image.size();
  30.     float r = std::min((float)newShape.height / (float)shape.height,
  31.         (float)newShape.width / (float)shape.width);
  32.     if (!scaleUp)
  33.         r = std::min(r, 1.0f);
  34.  
  35.     float ratio[2]{ r, r };
  36.     int new_un_pad[2] = { (int)std::round((float)shape.width * r),(int)std::round((float)shape.height * r) };
  37.  
  38.     auto dw = (float)(newShape.width - new_un_pad[0]);
  39.     auto dh = (float)(newShape.height - new_un_pad[1]);
  40.  
  41.     if (autoShape)
  42.     {
  43.         dw = (float)((int)dw % stride);
  44.         dh = (float)((int)dh % stride);
  45.     }
  46.     else if (scaleFill)
  47.     {
  48.         dw = 0.0f;
  49.         dh = 0.0f;
  50.         new_un_pad[0] = newShape.width;
  51.         new_un_pad[1] = newShape.height;
  52.         ratio[0] = (float)newShape.width / (float)shape.width;
  53.         ratio[1] = (float)newShape.height / (float)shape.height;
  54.     }
  55.  
  56.     dw /= 2.0f;
  57.     dh /= 2.0f;
  58.  
  59.     if (shape.width != new_un_pad[0] && shape.height != new_un_pad[1])
  60.     {
  61.         cv::resize(image, outImage, cv::Size(new_un_pad[0], new_un_pad[1]));
  62.     }
  63.     else {
  64.         outImage = image.clone();
  65.     }
  66.  
  67.     int top = int(std::round(dh - 0.1f));
  68.     int bottom = int(std::round(dh + 0.1f));
  69.     int left = int(std::round(dw - 0.1f));
  70.     int right = int(std::round(dw + 0.1f));
  71.     params[0] = ratio[0];
  72.     params[1] = ratio[1];
  73.     params[2] = left;
  74.     params[3] = top;
  75.     cv::copyMakeBorder(outImage, outImage, top, bottom, left, right, cv::BORDER_CONSTANT, color);
  76. }
  77.  
  78. void GetMask(const cv::Mat& maskProposals, const cv::Mat& maskProtos, std::vector<OutputSeg>& output, const MaskParams& maskParams) {
  79.     //cout << maskProtos.size << endl;
  80.  
  81.     int seg_channels = maskParams.segChannels;
  82.     int net_width = maskParams.netWidth;
  83.     int seg_width = maskParams.segWidth;
  84.     int net_height = maskParams.netHeight;
  85.     int seg_height = maskParams.segHeight;
  86.     float mask_threshold = maskParams.maskThreshold;
  87.     Vec4f params = maskParams.params;
  88.     Size src_img_shape = maskParams.srcImgShape;
  89.  
  90.     Mat protos = maskProtos.reshape(0, { seg_channels,seg_width * seg_height });
  91.  
  92.     Mat matmul_res = (maskProposals * protos).t();
  93.     Mat masks = matmul_res.reshape(output.size(), { seg_width,seg_height });
  94.     vector<Mat> maskChannels;
  95.     split(masks, maskChannels);
  96.     for (int i = 0; i < output.size(); ++i) {
  97.         Mat dest, mask;
  98.         //sigmoid
  99.         cv::exp(-maskChannels[i], dest);
  100.         dest = 1.0 / (1.0 + dest);
  101.  
  102.         Rect roi(int(params[2] / net_width * seg_width), int(params[3] / net_height * seg_height), int(seg_width - params[2] / 2), int(seg_height - params[3] / 2));
  103.         dest = dest(roi);
  104.         resize(dest, mask, src_img_shape, INTER_NEAREST);
  105.  
  106.         //crop
  107.         Rect temp_rect = output[i].box;
  108.         mask = mask(temp_rect) > mask_threshold;
  109.         output[i].boxMask = mask;
  110.     }
  111. }
  112. void GetMask2(const Mat& maskProposals, const Mat& mask_protos, OutputSeg& output, const MaskParams& maskParams) {
  113.     int seg_channels = maskParams.segChannels;
  114.     int net_width = maskParams.netWidth;
  115.     int seg_width = maskParams.segWidth;
  116.     int net_height = maskParams.netHeight;
  117.     int seg_height = maskParams.segHeight;
  118.     float mask_threshold = maskParams.maskThreshold;
  119.     Vec4f params = maskParams.params;
  120.     Size src_img_shape = maskParams.srcImgShape;
  121.  
  122.     Rect temp_rect = output.box;
  123.     // 把已经到原图的检测框坐标信息  映射到  获得mask原型分支的输入尺寸上【160, 160】
  124.     int rang_x = floor((temp_rect.x * params[0] + params[2]) / net_width * seg_width);
  125.     int rang_y = floor((temp_rect.y * params[1] + params[3]) / net_height * seg_height);
  126.     int rang_w = ceil(((temp_rect.x + temp_rect.width) * params[0] + params[2]) / net_width * seg_width) - rang_x;
  127.     int rang_h = ceil(((temp_rect.y  + temp_rect.height) * params[0] + params[3]) / net_width * seg_height) - rang_y;
  128.  
  129.     //
  130.     rang_w = MAX(rang_w, 1);
  131.     rang_h = MAX(rang_h, 1);
  132.     if (rang_x + rang_w > seg_width){
  133.         if (seg_width - rang_x > 0)
  134.             rang_w =seg_width -rang_x;
  135.         else
  136.             rang_x -= 1;
  137.     }
  138.     if (rang_y + rang_h > seg_height) {
  139.         if (seg_height - rang_y > 0)
  140.             rang_h = seg_height - rang_y;
  141.         else
  142.             rang_y -= 1;
  143.     }
  144.  
  145.     vector<Range> roi_ranges;
  146.     roi_ranges.push_back(Range(0,1));
  147.     roi_ranges.push_back(Range::all());
  148.     roi_ranges.push_back(Range(rang_y, rang_h+rang_y));
  149.     roi_ranges.push_back(Range(rang_x, rang_w+rang_x));
  150.  
  151.     // 裁剪mask原型
  152.     Mat temp_mask_protos = mask_protos(roi_ranges).clone(); // 剪裁原型，保存检测框内部的原型，其余位置清零,  以此来获得感兴趣区域(roi)
  153.     Mat protos = temp_mask_protos.reshape(0, { seg_channels, rang_w*rang_h});// 检测至检测框大小？
  154.  
  155.     // mask系数与mask原型做矩阵乘法
  156.     Mat matmul_res = (maskProposals * protos).t(); // mask系数【1,32】 与 mask原型【32, h*w】进行矩阵相称
  157.     Mat masks_feature = matmul_res.reshape(1,{rang_h, rang_w}); //【1,h,w】
  158.     Mat dest, mask;
  159.  
  160.     // sigmod
  161.     cv::exp(-masks_feature, dest);
  162.     dest = 1.0 / (1.0 + dest);
  163.  
  164.     // 检测框坐标 映射到 原图尺寸
  165.     int left = floor((net_width / seg_width * rang_x - params[2]) / params[0]);
  166.     int top = floor((net_width / seg_height * rang_y - params[3]) / params[1]);
  167.     int width = ceil(net_width / seg_height * rang_w / params[0]);
  168.     int height = ceil(net_height / seg_height * rang_h / params[1]);
  169.  
  170.     // 检测框mask缩放到原图尺寸
  171.     resize(dest, mask, Size(width, height), INTER_NEAREST);
  172.  
  173.     // 阈值化
  174.     mask = mask(temp_rect - Point(left, top)) > mask_threshold;
  175.     output.boxMask = mask;
  176. }
  177.  
  178. void DrawPred(Mat& img, vector<OutputSeg> result, std::vector<std::string> classNames, vector<Scalar> color) {
  179.     Mat mask = img.clone();
  180.     for (int i=0; i< result.size(); i++){
  181.         int left, top;
  182.         left = result[i].box.x;
  183.         top = result[i].box.y;
  184.         int color_num =i;
  185.  
  186.         // 目标画框
  187.         rectangle(img, result[i].box, color[result[i].id], 2, 8);
  188.  
  189.         // 目标mask，这里非目标像素值为0
  190.         mask(result[i].box).setTo(color[result[i].id], result[i].boxMask);
  191.         string label = classNames[result[i].id] + ":" + to_string(result[i].confidence);
  192.  
  193.         // 框左上角打印信息
  194.         int baseLine;
  195.         Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
  196.         top = max(top, labelSize.height);
  197.         putText(img, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 0.5, color[result[i].id], 2);
  198.     }
  199.  
  200.     addWeighted(img, 0.5, mask, 0.5, 0, img);
  201. }
分割的调用代码测试案例
  1.  
  2. void frmMain::test_yoloseg()
  3. {
  4.     string model_path = "20231001segquanjing.onnx";
  5.     YoloSeg test;
  6.     Net net;
  7.     if (test.ReadModel(net, model_path, true)) {
  8.         cout << "read net ok!" << endl;
  9.     }
  10.     else {
  11.         return ;
  12.     }
  13.     vector<OutputSeg> result;
  14.     cv::Mat img_seg_test=cv::imread("E:/data_seg/quanjingCameraPicture2/1/segdata2278.jpg");
  15.  
  16.  
  17.     bool find = test.Detect(img_seg_test, net, result);
  18.  
  19.     if (find) {
  20.         DrawPred(img_seg_test, result, test._className, color);
  21.     }
  22.     else {
  23.         cout << "Detect Failed!"<<endl;
  24.     }
  25.  
  26.  
  27.     string label = "steel:" ; //ms
  28.     putText(img_seg_test, label, Point(30,30), FONT_HERSHEY_SIMPLEX,0.5, Scalar(0,0,255), 2, 8);
  29.  
  30.     QPixmap img_test_xmap= my_publiction.cvMatToQPixmap(img_seg_test);
  31.     // 设置QLabel的最小尺寸
  32.     ui->lab1->setMinimumSize(600, 600);
  33.     ui->lab1->setScaledContents(true);
  34.     img_test_xmap = img_test_xmap.scaled( ui->lab1->width(),  ui->lab1->height(), Qt::KeepAspectRatio,Qt::SmoothTransformation); // 将图像缩放到QLabel的大小
  35.     ui->lab1->setPixmap(img_test_xmap);
  36. //    imshow("result", img_seg_test);
  37.  
  38.  
  39.  
  40. }

 分割的效果图如下：

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

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

  

闽ICP备14008679号