Yolov5 DNN部署

大佬的链接，代码也用的大佬的，我在这里做个注释学习，不理解的配合大佬文章看

#include <fstream>    //负责文件写入读取的库

#include <opencv2/opencv.hpp>


//加载类别列表
std::vector<std::string> load_class_list()
{
	std::vector<std::string> class_list;
	std::ifstream ifs("F://DK_work//object_localization//yolov5_onnxruntime//models//coco.names");
	std::string line;
	while (getline(ifs, line))
	{
		class_list.push_back(line);
	}
	return class_list;
}

//加载onnx模型
void load_net(cv::dnn::Net &net, bool is_cuda)
{
	auto result = cv::dnn::readNet("F:/DK_work/object_localization/yolov5_onnxruntime/models/real2onnx/best.onnx");
	if (is_cuda)
	{
		std::cout << "Attempty to use CUDA\n";
		result.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
		result.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA_FP16);
	}
	else
	{
		std::cout << "Running on CPU\n";
		result.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
		result.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
	}
	net = result;
}

//设置框框颜色
const std::vector<cv::Scalar> colors = { cv::Scalar(255, 255, 0), cv::Scalar(0, 255, 0), cv::Scalar(0, 255, 255), cv::Scalar(255, 0, 0) };

const float INPUT_WIDTH = 640.0;     //输入宽度
const float INPUT_HEIGHT = 640.0;     //输入高度
const float SCORE_THRESHOLD = 0.5;     //class_score_threshold
const float NMS_THRESHOLD = 0.4;        //nms_threshold
const float CONFIDENCE_THRESHOLD = 0.1;  //confidence_threshold

//检测到的目标结构体
struct Detection
{
	int class_id;
	float confidence;
	cv::Rect box;
};

//原始图片添加黑边
cv::Mat format_yolov5(const cv::Mat &source) {
	int col = source.cols;
	int row = source.rows;
	int _max = MAX(col, row);
	cv::Mat result = cv::Mat::zeros(_max, _max, CV_8UC3);
	source.copyTo(result(cv::Rect(0, 0, col, row)));
	//cv::imshow("resize", result);
	return result;
}

void detect(cv::Mat &image, cv::dnn::Net &net, std::vector<Detection> &output, const std::vector<std::string> &className) {
	cv::Mat blob;

	auto input_image = format_yolov5(image);
    // blobFromImage opencv中数据预处理api
	cv::dnn::blobFromImage(input_image, blob, 1. / 255., cv::Size(INPUT_WIDTH, INPUT_HEIGHT), cv::Scalar(), true, false);
	
	net.setInput(blob);
	std::vector<cv::Mat> outputs;
	net.forward(outputs, net.getUnconnectedOutLayersNames());   // net.getUnconnectedOutLayersNames获取每个未连接输出层的层的名字

	float x_factor = input_image.cols / INPUT_WIDTH;
	float y_factor = input_image.rows / INPUT_HEIGHT;
	
	float *data = (float *)outputs[0].data;

	const int dimensions = 6;
	const int rows = 25500; //22743 //25200

	std::vector<int> class_ids;
	std::vector<float> confidences;
	std::vector<cv::Rect> boxes;

	for (int i = 0; i < rows; ++i) {

		float confidence = data[4];
		if (confidence >= CONFIDENCE_THRESHOLD) {

			float * classes_scores = data + 5;
			cv::Mat scores(1, className.size(), CV_32FC1, classes_scores);
			cv::Point class_id;
			double max_class_score;
			minMaxLoc(scores, 0, &max_class_score, 0, &class_id);  //minMaxLoc 返回scores中最大最小值，最大最小值位置
			if (max_class_score > SCORE_THRESHOLD) {

				confidences.push_back(confidence);

				class_ids.push_back(class_id.x);

				float x = data[0];
				float y = data[1];
				float w = data[2];
				float h = data[3];
				int left = int((x - 0.5 * w) * x_factor);
				int top = int((y - 0.5 * h) * y_factor);
				int width = int(w * x_factor);
				int height = int(h * y_factor);
				boxes.push_back(cv::Rect(left, top, width, height));
				
			}

		}

		data += 6;

	}

	std::vector<int> nms_result;
	cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, nms_result);   //NMSBoxes opencv dnn 中计算 NMS 的 api
	for (int i = 0; i < nms_result.size(); i++) {
		int idx = nms_result[i];
		Detection result;
		result.class_id = class_ids[idx];
		result.confidence = confidences[idx];
		result.box = boxes[idx];
		output.push_back(result);
	}
}

int main(int argc, char **argv)
{

	std::vector<std::string> class_list = load_class_list();

	cv::Mat frame;
	cv::VideoCapture capture("F:/DK_work/object_localization/yolov5_onnxruntime/images/RGB_image.avi");
	if (!capture.isOpened())
	{
		std::cerr << "Error opening video file\n";
		return -1;
	}

	bool is_cuda = argc > 1 && strcmp(argv[1], "cuda") == 0;

	cv::dnn::Net net;
	load_net(net, false);

	auto start = std::chrono::high_resolution_clock::now();   //
	int frame_count = 0;
	float fps = -1;
	int total_frames = 0;

	while (true)
	{
		capture.read(frame);
		if (frame.empty())
		{
			std::cout << "End of stream\n";
			break;
		}

		std::vector<Detection> output;
		detect(frame, net, output, class_list);

		frame_count++;
		total_frames++;

		int detections = output.size();
		//std::cout << detections << std::endl;
		for (int i = 0; i < detections; ++i)
		{

			auto detection = output[i];
			auto box = detection.box;
			auto classId = detection.class_id;
			const auto color = colors[classId % colors.size()];
			cv::rectangle(frame, box, color, 3);
			
			//cv::rectangle(frame, cv::Point(box.x, box.y - 20), cv::Point(box.x + box.width, box.y), color, cv::FILLED);
			//cv::putText(frame, class_list[classId].c_str(), cv::Point(box.x, box.y - 5), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
			//cv::imshow("output1", frame);
		}
        //每隔30秒计算fps
		if (frame_count >= 30)
		{

			auto end = std::chrono::high_resolution_clock::now();
			fps = frame_count * 1000.0 / std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();

			frame_count = 0;
			start = std::chrono::high_resolution_clock::now();
		}
        //输出fps
		if (fps > 0)
		{

			std::ostringstream fps_label;
			fps_label << std::fixed << std::setprecision(2);
			fps_label << "FPS: " << fps;
			std::string fps_label_str = fps_label.str();

			cv::putText(frame, fps_label_str.c_str(), cv::Point(10, 25), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 0, 255), 2);
		}

		cv::imshow("output", frame);

		if (cv::waitKey(1) != -1)
		{
			capture.release();
			std::cout << "finished by user\n";
			break;
		}
	}

	std::cout << "Total frames: " << total_frames << "\n";

	return 0;
}