VS+Yolov3+QT+opencv（GPU版）

#pragma once
//这段代码一定要加，这是在yolo_v2_class.hpp文件中使用opencv函数
#ifdef _WIN32
#define OPENCV
#define GPU
#endif

#include 
#include "ui_mianwindow.h"
#include "yolo_v2_class.hpp"
#include "opencv\highgui.h"
#include "opencv2\opencv.hpp"
#include "opencv2\core\core.hpp"
#include "opencv2\highgui\highgui.hpp"
#include 
#include 

#pragma comment(lib, "yolo_cpp_dll.lib")//引入yolo链接库
#pragma execution_character_set("utf-8")
using namespace cv;

class mianwindow : public QMainWindow
{
    Q_OBJECT

public:
    mianwindow(QWidget *parent = Q_NULLPTR);

    void draw_boxes(Mat mat_img, std::vector result_vec, std::vectorstring> obj_names);

    std::vectorstring> objects_names_from_file(std::string const filename);
    QImage cvMat2QImage(const Mat& mat);
    Mat QImage2cvMat(QImage image);


private:
    Ui::mianwindowClass ui;
};

#include "mianwindow.h"
#include "yolo_v2_class.hpp"
#include 
mianwindow::mianwindow(QWidget *parent)
    : QMainWindow(parent)
{
    ui.setupUi(this);

    QImage q_image(QString("E:/TX_workCode/DataInfo/images/dog.jpg"));

    ui.label_img->setPixmap(QPixmap::fromImage(q_image));
    
    std::string names_file = "coco.names";
    std::string cfg_file = "yolov3.cfg";
    std::string weights_file = "yolov3.weights";
    Detector detector(cfg_file, weights_file); //初始化Detector

    std::vectorstring> obj_names;
    obj_names = objects_names_from_file(names_file);
    //测试是否成功读入分类对象文件
    for (int i = 0; i )
    {
        qDebug() <<"第i个:" << QString(QString::fromLocal8Bit(obj_names[i].c_str()));
    }
    
    Mat frame = QImage2cvMat(q_image);
    std::vector result_vec = detector.detect(frame);
    draw_boxes(frame, result_vec, obj_names);

    QImage det_image = cvMat2QImage(frame);
    ui.label_detectorImg->setPixmap(QPixmap::fromImage(det_image));

}
//以下draw_boxes和objects_names_from_file两段代码来自yolo_console_dll.sln
//给Mat类型的图像画出检测出对象框
void mianwindow::draw_boxes(cv::Mat mat_img, std::vector result_vec, std::vectorstring> obj_names)
{
    int const colors[6][3] = { { 1,0,1 },{ 0,0,1 },{ 0,1,1 },{ 0,1,0 },{ 1,1,0 },{ 1,0,0 } };
    for (auto &i : result_vec) {
        cv::Scalar color = obj_id_to_color(i.obj_id);
        cv::rectangle(mat_img, cv::Rect(i.x, i.y, i.w, i.h), color, 2);
        if (obj_names.size() > i.obj_id) {
            std::string obj_name = obj_names[i.obj_id];
            if (i.track_id > 0) obj_name += " - " + std::to_string(i.track_id);
            cv::Size const text_size = getTextSize(obj_name, cv::FONT_HERSHEY_COMPLEX_SMALL, 1.2, 2, 0);
            int const max_width = (text_size.width > i.w + 2) ? text_size.width : (i.w + 2);
            cv::rectangle(mat_img, cv::Point2f(std::max((int)i.x - 1, 0), std::max((int)i.y - 30, 0)),
                cv::Point2f(std::min((int)i.x + max_width, mat_img.cols - 1), std::min((int)i.y, mat_img.rows - 1)),
                color, CV_FILLED, 8, 0);
            putText(mat_img, obj_name, cv::Point2f(i.x, i.y - 10), cv::FONT_HERSHEY_COMPLEX_SMALL, 1.2, cv::Scalar(0, 0, 0), 2);
        }
    }

}
//读names文件中对象类别名称保存在vector容器中
std::vectorstring> mianwindow::objects_names_from_file(std::string const filename) {
    std::ifstream file(filename);
    std::vectorstring> file_lines;
    if (!file.is_open()) return file_lines;
    for (std::string line; getline(file, line);) file_lines.push_back(line);
    std::cout <<"object names loaded \n";
    return file_lines;
}

//---------QImage与Mat类型相互转换----------------------------------------------------------
QImage mianwindow::cvMat2QImage(const cv::Mat& mat)
{
    // 8-bits unsigned, NO. OF CHANNELS = 1  
    if (mat.type() == CV_8UC1)
    {
        QImage image(mat.cols, mat.rows, QImage::Format_Indexed8);
        // Set the color table (used to translate colour indexes to qRgb values)  
        image.setColorCount(256);
        for (int i = 0; i <256; i++)
        {
            image.setColor(i, qRgb(i, i, i));
        }
        // Copy input Mat  
        uchar *pSrc = mat.data;
        for (int row = 0; row )
        {
            uchar *pDest = image.scanLine(row);
            memcpy(pDest, pSrc, mat.cols);
            pSrc += mat.step;
        }
        return image;
    }
    // 8-bits unsigned, NO. OF CHANNELS = 3  
    else if (mat.type() == CV_8UC3)
    {
        // Copy input Mat  
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat  
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
        return image.rgbSwapped();
    }
    else if (mat.type() == CV_8UC4)
    {
        qDebug() <<"CV_8UC4";
        // Copy input Mat  
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat  
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32);
        return image.copy();
    }
    else
    {
        qDebug() <<"ERROR: Mat could not be converted to QImage.";
        return QImage();
    }
}
cv::Mat mianwindow::QImage2cvMat(QImage image)
{
    cv::Mat mat;
    qDebug() << image.format();
    switch (image.format())
    {
    case QImage::Format_ARGB32:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32_Premultiplied:
        mat = cv::Mat(image.height(), image.width(), CV_8UC4, (void*)image.constBits(), image.bytesPerLine());
        break;
    case QImage::Format_RGB888:
        mat = cv::Mat(image.height(), image.width(), CV_8UC3, (void*)image.constBits(), image.bytesPerLine());
        cv::cvtColor(mat, mat, CV_BGR2RGB);
        break;
    case QImage::Format_Indexed8:
        mat = cv::Mat(image.height(), image.width(), CV_8UC1, (void*)image.constBits(), image.bytesPerLine());
        break;
    }
    return mat;
}