• OpenCV之YOLOv3目标检测

    • 💂 个人主页:风间琉璃
    • 🤟 版权: 本文由【风间琉璃】原创、在CSDN首发、需要转载请联系博主
    • 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦

    目录

    前言

    一、预处理

    1.获取分类名

    2.获取输出层名称

    3.图像尺度变换

    二、 模型加载和执行推理

    三、输出解析

    1.网络后处理

    2.边界框绘制

    3.推理时间

    4.FPS计算

    前言

    YOLOv3（You Only Look Once version 3）是一种流行的实时目标检测算法，由Joseph Redmon等人开发。YOLOv3是YOLO系列的第三个版本，它在速度和准确性方面都取得了显著的改进，被广泛用于计算机视觉应用中的实时目标检测任务。

    详细的网络原理参考：目标检测之YOLOv1-v3_风间琉璃•的博客-CSDN博客

    参考文章：YOLOv3 – Deep Learning Based Object Detection – YOLOv3 with OpenCV ( Python / C++ )

     YOLOv3模型及配置文件下载

    weights: https://pjreddie.com/media/files/yolov3.weights

    cfg:https://github.com/pjreddie/darknet/blob/master/cfg/yolov3.cfg

    coco: https://github.com/pjreddie/darknet/blob/master/data/coco.names

    一、预处理

    1.获取分类名

    数据集采用的coco数据集，需要将coco.names包含训练模型的所有类名称加载到内存中。

    1. vector classes;  //标签名
    2.  
    3. string classespath = "F:/data/CQU/VS/YOLOv3/coco.names";
    4.  
    5. //得到网络对应的标签
    6. void getclasses(string classespath )
    7. {
    8. 	ifstream ifs(classespath);
    9. 	string line;
    10. 	while (getline(ifs, line)) 
    11. 	{ 
    12. 		classes.push_back(line); 
    13. 	}
    14. }

    最暴力的方法也可以打开文件，直接类别定义一个80个类别的变量存储。 

    2.获取输出层名称

    YOLOv3由于可以在三个不同的尺度上进行检测，也就是说它有三个输出层，因此我们需要获得它的三个输出层的名称。

    1. //得到网络输出层的名称，yolov3有3种尺度输出
    2. vector getOutputsNames(const Net& net)
    3. {
    4. #if 1
    5. 	//直接获取模型中未连接到任何后续层的输出层的名称,一般是yolov3是三层输出层
    6. 	std::vector names = net.getUnconnectedOutLayersNames();
    7. 	//for (int i = 0; i < names.size(); i++)
    8. 	//{
    9. 		//printf("output layer name : %s\n", names[i].c_str());
    10. 	//}
    11. 	return names;
    12. 		
    13. #elif 0
    14. 	static vector names;
    15. 	if (names.empty())
    16. 	{
    17. 		//获取模型中未连接到任何后续层的输出层的索引,一般是yolov3是三层输出层
    18. 		vector<int> outLayers = net.getUnconnectedOutLayers();
    19. 		//获取模型中的所有层的名称
    20. 		vector layersNames = net.getLayerNames();
    21.  
    22. 		names.resize(outLayers.size());
    23. 		for (size_t i = 0; i < outLayers.size(); ++i)
    24. 		{
    25. 			names[i] = layersNames[outLayers[i] - 1];
    26. 		}
    27. 	}
    28. 	return names;
    29. #endif
    30. }

    这里提供了两种方法，直接获取三层输出层的名称可以使用 getUnconnectedOutLayersNames()，也可以先获取三个输出层的索引，然后通过getLayerNames获得整个网络层的名称，然后再通过索引获取最后输出三层的名称。

    3.图像尺度变换

    神经网络的输入图像需要采用称为blob的特定格式。从输入图像或视频流中读取帧后，将通过blobFromImage函数将其转换为神经网络的输入blob。

    在此过程中，它使用比例因子1/255将图像像素值缩放到0到1的目标范围。它还将图像的大小调整为给定大小（416,416）而不进行裁剪。请注意，不在此处执行任何均值减法，因此将[0,0,0]传递给函数的mean参数，swapRB参数设置为true(即交换R和B)，这里个人认为交换与否问题应该不大，看网上大佬的都写的交换。

    1. int width = 416; 
    2. int height = 416; 
    3.  
    4. //图像预处理
    5. blobFromImage(frame, blob, 1 / 255.0, cv::Size(width, height), Scalar(0, 0, 0), true, false);

    二、 模型加载和执行推理

    加载网络直接使用readNetFromDarknet或者readNet都行。

    1. String config = "F:/data/CQU/VS/YOLOv3/yolov3.cfg";
    2. String weights = "F:/data/CQU/VS/YOLOv3/yolov3.weights";
    3.  
    4. //加载yolo网络模型
    5. Net net = readNetFromDarknet(config, weights);

    这里可以根据个人的情况设置是否使用CUDA加速，我编译过CUDA的OpenCV，所以这里利用第二种方式

    1. #if 0   
    2. 	//cpu推理
    3. 	net.setPreferableBackend(DNN_BACKEND_OPENCV);
    4. 	net.setPreferableTarget(DNN_TARGET_CPU);
    5.  
    6. #elif 1
    7. 	//使用cuda加速
    8. 	net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
    9. 	net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA_FP16);
    10.  
    11. #endif

     预处理和网络模型都加载好了就可以进行图像的预测了

    1. //设置网络的输入
    2. net.setInput(blob);
    3.  
    4. //执行推理，这里有多个输出层，好像不能使用 Mat outsnet.forward(outs, getOutputsNames(net));进行推理
    5. //大概率是因为这里输出层是三层
    6. vector outs;
    7. net.forward(outs, getOutputsNames(net));

    预测的结果保存在outs的Mat类型矩阵中。接下来就需要对这个预测结果进行后处理。 

    三、输出解析

    1.网络后处理

    网络输出的每个边界框都分别由一个包含着类别名字和5个元素的向量表示。前四个元素代表center_x, center_y, width和height。第五个元素表示包含着目标的边界框的置信度。

    其余的元素是和每个类别（如目标种类）有关的置信度。边界框分配给最高分数对应的那一种类。一个边界框的最高分数也叫做它的置信度（confidence）。如果边界框的置信度低于规定的阀值，算法上不再处理这个边界框。

    置信度大于或等于置信度阀值的边界框，将进行非最大抑制。这会减少重叠的边界框数目。

    1. float confThreshold = 0.5; //置信度
    2. float nmsThreshold = 0.4;  // nms阈值
    3.  
    4. //使用非极大值抑制NMS来删除置信度较低的边界框
    5. void postprocess(Mat& frame, const vector& outs)
    6. {
    7. 	//对象的类别标签索引
    8. 	vector<int> classIds;
    9. 	//目标检测的置信度
    10. 	vector<float> confidences;
    11. 	//目标检测的边界框信息
    12. 	vector boxes;
    13.  
    14. 	//对三层输出层分别处理
    15. 	for (int i = 0; i < outs.size(); i++)
    16. 	{
    17. 		//遍历来自网络的所有边界框，并仅保留具有高置信度分数的边界框，将框的类别标签分配为具有该框上最高分数的类别
    18. 		float* data = (float*)outs[i].data;
    19. 		//对某一层处理，输出包含5个元素:x,y,w,h,置信度
    20. 		for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols)
    21. 		{
    22. 			//获取置信度
    23. 			Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
    24. 			Point classIdPoint;
    25. 			double confidence; //最大置信度
    26. 	
    27. 			//获取置信度最大的数值和位置
    28. 			minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
    29. 			if (confidence > confThreshold)
    30. 			{
    31. 				int centerX = (int)(data[0] * frame.cols);
    32. 				int centerY = (int)(data[1] * frame.rows);
    33. 				int width = (int)(data[2] * frame.cols);
    34. 				int height = (int)(data[3] * frame.rows);
    35. 				int left = centerX - width / 2;
    36. 				int top = centerY - height / 2;
    37.  
    38. 				classIds.push_back(classIdPoint.x);
    39. 				confidences.push_back((float)confidence);
    40. 				boxes.push_back(Rect(left, top, width, height));
    41. 			}
    42. 		}
    43. 	}
    44.  
    45. 	//非极大值抑制以消除重叠度较高且置信度较低的边界框
    46. 	vector<int> indices; //NMSBoxes输出，包含经过非最大值抑制后所选的边界框的索引
    47. 	NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
    48. 	for (size_t i = 0; i < indices.size(); ++i)
    49. 	{
    50. 		int idx = indices[i];
    51. 		Rect box = boxes[idx];
    52. 		//在图像上绘制检测结果，包括类别标签、置信度和边界框
    53. 		drawPred(classIds[idx], confidences[idx], box.x, box.y,box.x + box.width, box.y + box.height, frame);
    54. 	}
    55. }

    非极大值抑制由参数nmsThreshold控制。如果nmsThreshold设置太少，比如0.1，我们可能检测不到相同或不同种类的重叠目标。如果设置得太高，比如1，可能出现一个目标有多个边界框包围。

    NMSBoxes 是一个用于执行非极大值抑制（Non-Maximum Suppression，简称NMS）的函数，通常在目标检测和边界框预测等计算机视觉任务中使用。NMS 的目标是减少一组重叠的边界框，以便仅保留最相关的边界框，从而提高检测或识别性能。 

    函数原型：

    void cv::dnn::NMSBoxes(const std::vector& bboxes, const std::vector<float>& scores, float score_threshold, float nms_threshold, std::vector<int>& indices);

    ①bboxes：表示输入的边界框列表。每个边界框通常由 cv::Rect 类型表示，其中包含了左上角和右下角的坐标。这个参数用于传递待执行非极大值抑制的边界框列表。

    ②scores：包含与每个边界框相关的置信度或分数。这些分数用于度量边界框包含的对象的可信度或重要性。

    ③score_threshold：用于指定一个分数阈值。只有分数高于或等于此阈值的边界框才会被考虑进行非极大值抑制。

    ④nms_threshold：表示在执行非极大值抑制时两个边界框之间的IoU（交并比）阈值。如果两个边界框的IoU大于等于此阈值，则其中一个边界框将被抑制。

    ⑤indices：用于返回经过非极大值抑制后保留的边界框的索引列表。这些索引对应于输入边界框列表中的边界框，只有这些边界框被保留。

    该函数的主要作用是根据分数和IoU阈值对输入的边界框列表进行非极大值抑制，然后将保留的边界框的索引存储在 indices 中，以供后续处理使用 。

    2.边界框绘制

    边界框的绘制就是根据将网络的输出结果经过非极大值抑制后的边界框，绘制在原图，并指定类别标签和置信度分数。

    1. //画预测的目标bounding box
    2. void drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame)
    3. {
    4. 	//绘制检测目标的矩形框
    5. 	rectangle(frame, Point(left, top), Point(right, bottom), Scalar(255, 178, 50), 2);
    6.  
    7. 	//获取类别名称及其置信度
    8. 	string label = format("%.2f", conf);
    9. 	if (!classes.empty())
    10. 	{
    11. 		CV_Assert(classId < (int)classes.size());
    12. 		label = classes[classId] + ":" + label;
    13. 	}
    14.  
    15. 	//在边界框的顶部显示标签
    16. 	int baseLine;
    17. 	Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
    18. 	//确保顶部位置足够高以容纳标签
    19. 	top = max(top, labelSize.height);
    20. 	rectangle(frame, Point(left, top - round(1.5 * labelSize.height)), Point(left + round(1.5 * labelSize.width), top + baseLine), Scalar(255, 255, 255), FILLED);
    21. 	putText(frame, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 1);
    22. }

    3.推理时间

    使用OpenCV dnn进行推理，可以测量推理的时间。主要是使用getPerfProfile函数。其函数原型如下：

    cv::Mat cv::dnn::Net::getPerfProfile(std::vector<double>& timings) const;

    timings（输出参数）：用于存储每个网络层的推理时间。这是一个输出参数，getPerfProfile 会填充这个向量，使您能够获取每个层的执行时间信息。 

    getPerfProfile 函数的主要作用是分析深度学习模型的性能，并返回每个网络层的推理时间。让利用freq 将时间从s转换为ms。

    1. //函数getPerfProfile返回推理的总时间（t）以及每个层的时间（在layersTimes中）
    2. //存储每一次推理时间
    3. vector<double> layersTimes; 
    4. //getTickFrequency() 返回时钟频率，通过除以1000，freq将其转换为毫秒，将时间单位从秒（s）转换为毫秒（ms）的缩放因子
    5. double freq = getTickFrequency() / 1000;
    6. //获取推理总时间，并转换将时间单位转换为毫秒
    7. double t = net.getPerfProfile(layersTimes) / freq;
    8.  
    9. string label = format("Inference time: %.2fms", t);
    10. putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 0, 255));

    4.FPS计算

    在网络推理（如深度学习模型的推理）中，帧率（Frames Per Second，FPS）是一项关键的性能指标，用于表示每秒处理的图像帧数量。通常，帧率越高，系统性能越好。

    在图像进行目标检测之前加入下面一句代码，获取当前系统的计时周期

    1. //获得当前系统的计时间周期数,求FPS
    2. double t = (double)getTickCount();

     然后在图像目标检测完加入下面的代码，计算FPS并显示

    1. //FPS计算
    2. t = ((double)getTickCount() - t) / getTickFrequency();//求输入帧后经过的周期数/每秒系统计的周期数=一帧用时多少秒
    3. double fps = 1.0 / t;//求倒数得到每秒经过多少帧，即帧率
    4. string text = format("FPS:%.2f",fps);
    5. cv::putText(frame, text, Point(10, 50), FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 0), 2, 8, 0);

    运行结果：

    YOLOv3 C++

    程序源码：下载链接：https://download.csdn.net/download/qq_53144843/88350694
     

    1. // YOLOv3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    2. //
    3.  
    4.  
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. using namespace cv;
    14. using namespace cv::dnn;
    15. using namespace std;
    16.  
    17. //初始化参数
    18. float confThreshold = 0.5; //置信度
    19. float nmsThreshold = 0.4;  // nms阈值
    20. int width = 416; 
    21. int height = 416; 
    22. vector classes;  //标签名
    23.  
    24. //得到网络输出层名称
    25. vector getOutputsNames(const Net& net); 
    26. //绘制bounding box
    27. void drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame);
    28. //解析输出
    29. void postprocess(Mat& frame, const vector& outs);
    30. //图片检测
    31. void detect_image(string image_path, string config, string weights, string classespath);
    32. //目标检测
    33. void detect_video(string video_path, string config, string weights, string classespath);
    34.  
    35. int main()
    36. {
    37. 	String config = "F:/data/CQU/VS/YOLOv3/yolov3.cfg";
    38. 	String weights = "F:/data/CQU/VS/YOLOv3/yolov3.weights";
    39. 	string classespath = "F:/data/CQU/VS/YOLOv3/coco.names";
    40.  
    41. 	string image_path = "F:/data/CQU/VS/YOLOv3/3.jpg";
    42. 	string video_path = "F:/data/CQU/VS/YOLOv3/car.mp4";
    43. #if 0
    44. 	detect_image(image_path, config, weights, classespath);
    45.  
    46. #elif 1
    47. 	detect_video(video_path, config, weights, classespath);
    48.  
    49. #endif
    50.  
    51. 	return 0;
    52. }
    53.  
    54.  
    55. //得到网络对应的标签
    56. void getclasses(string classespath )
    57. {
    58. 	ifstream ifs(classespath);
    59. 	string line;
    60. 	while (getline(ifs, line)) 
    61. 	{ 
    62. 		classes.push_back(line); 
    63. 	}
    64. }
    65.  
    66.  
    67. //得到网络输出层的名称，yolov3有3种尺度输出
    68. vector getOutputsNames(const Net& net)
    69. {
    70. #if 1
    71. 	//直接获取模型中未连接到任何后续层的输出层的名称,一般是yolov3是三层输出层
    72. 	std::vector names = net.getUnconnectedOutLayersNames();
    73. 	//for (int i = 0; i < names.size(); i++)
    74. 	//{
    75. 		//printf("output layer name : %s\n", names[i].c_str());
    76. 	//}
    77. 	return names;
    78. 		
    79. #elif 0
    80. 	static vector names;
    81. 	if (names.empty())
    82. 	{
    83. 		//获取模型中未连接到任何后续层的输出层的索引,一般是yolov3是三层输出层
    84. 		vector<int> outLayers = net.getUnconnectedOutLayers();
    85. 		//获取模型中的所有层的名称
    86. 		vector layersNames = net.getLayerNames();
    87.  
    88. 		names.resize(outLayers.size());
    89. 		for (size_t i = 0; i < outLayers.size(); ++i)
    90. 		{
    91. 			names[i] = layersNames[outLayers[i] - 1];
    92. 		}
    93. 	}
    94. 	return names;
    95. #endif
    96. }
    97.  
    98.  
    99.  
    100.  
    101. //画预测的目标bounding box
    102. void drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame)
    103. {
    104. 	//绘制检测目标的矩形框
    105. 	rectangle(frame, Point(left, top), Point(right, bottom), Scalar(255, 178, 50), 2);
    106.  
    107. 	//获取类别名称及其置信度
    108. 	string label = format("%.2f", conf);
    109. 	if (!classes.empty())
    110. 	{
    111. 		CV_Assert(classId < (int)classes.size());
    112. 		label = classes[classId] + ":" + label;
    113. 	}
    114.  
    115. 	//在边界框的顶部显示标签
    116. 	int baseLine;
    117. 	Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
    118. 	//确保顶部位置足够高以容纳标签
    119. 	top = max(top, labelSize.height);
    120. 	rectangle(frame, Point(left, top - round(1.5 * labelSize.height)), Point(left + round(1.5 * labelSize.width), top + baseLine), Scalar(255, 255, 255), FILLED);
    121. 	putText(frame, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 1);
    122. }
    123.  
    124.  
    125. //使用非极大值抑制NMS来删除置信度较低的边界框
    126. void postprocess(Mat& frame, const vector& outs)
    127. {
    128. 	//对象的类别标签索引
    129. 	vector<int> classIds;
    130. 	//目标检测的置信度
    131. 	vector<float> confidences;
    132. 	//目标检测的边界框信息
    133. 	vector boxes;
    134.  
    135. 	//对三层输出层分别处理
    136. 	for (int i = 0; i < outs.size(); i++)
    137. 	{
    138. 		//遍历来自网络的所有边界框，并仅保留具有高置信度分数的边界框，将框的类别标签分配为具有该框上最高分数的类别
    139. 		float* data = (float*)outs[i].data;
    140. 		//对某一层处理，输出包含5个元素:x,y,w,h,置信度
    141. 		for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols)
    142. 		{
    143. 			//获取置信度
    144. 			Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
    145. 			Point classIdPoint;
    146. 			double confidence; //最大置信度
    147. 	
    148. 			//获取置信度最大的数值和位置
    149. 			minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
    150. 			if (confidence > confThreshold)
    151. 			{
    152. 				int centerX = (int)(data[0] * frame.cols);
    153. 				int centerY = (int)(data[1] * frame.rows);
    154. 				int width = (int)(data[2] * frame.cols);
    155. 				int height = (int)(data[3] * frame.rows);
    156. 				int left = centerX - width / 2;
    157. 				int top = centerY - height / 2;
    158.  
    159. 				classIds.push_back(classIdPoint.x);
    160. 				confidences.push_back((float)confidence);
    161. 				boxes.push_back(Rect(left, top, width, height));
    162. 			}
    163. 		}
    164. 	}
    165.  
    166. 	//非极大值抑制以消除重叠度较高且置信度较低的边界框
    167. 	vector<int> indices; //NMSBoxes输出，包含经过非最大值抑制后所选的边界框的索引
    168. 	NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
    169. 	for (size_t i = 0; i < indices.size(); ++i)
    170. 	{
    171. 		int idx = indices[i];
    172. 		Rect box = boxes[idx];
    173. 		//在图像上绘制检测结果，包括类别标签、置信度和边界框
    174. 		drawPred(classIds[idx], confidences[idx], box.x, box.y,box.x + box.width, box.y + box.height, frame);
    175. 	}
    176. }
    177.  
    178.  
    179.  
    180. void detect_image(string image_path, string config, string weights, string classespath)
    181. {
    182. 	//加载目标检测标签
    183. 	getclasses(classespath);
    184.  
    185. 	//加载yolo网络模型
    186. 	Net net = readNetFromDarknet(config, weights);
    187.  
    188. 	
    189. #if 0   
    190. 	//cpu推理
    191. 	net.setPreferableBackend(DNN_BACKEND_OPENCV);
    192. 	net.setPreferableTarget(DNN_TARGET_CPU);
    193.  
    194. #elif 1
    195. 	//使用cuda加速
    196. 	net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
    197. 	net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA_FP16);
    198.  
    199. #endif
    200.  
    201. 	cv::Mat frame = cv::imread(image_path);
    202. 	
    203. 	//图片预处理
    204. 	Mat blob = blobFromImage(frame, 1 / 255.0, cv::Size(width, height), Scalar(0, 0, 0), true, false);
    205. 	
    206. 	//设置网络的输入
    207. 	net.setInput(blob);
    208.  
    209. 	//执行推理，这里有多个输出层，好像不能使用 Mat outsnet.forward(outs, getOutputsNames(net));进行推理
    210. 	//大概率是因为这里输出层是三层
    211. 	vector outs;
    212. 	net.forward(outs, getOutputsNames(net));
    213.  
    214. 	//剔除置信度较小的 bounding boxes
    215. 	postprocess(frame, outs);
    216.  
    217. 	//函数getPerfProfile返回推理的总时间（t）以及每个层的时间（在layersTimes中）
    218. 	//存储每一次推理时间
    219. 	vector<double> layersTimes; 
    220. 	//getTickFrequency() 返回时钟频率，通过除以1000，freq将其转换为毫秒，将时间单位从秒（s）转换为毫秒（ms）的缩放因子
    221. 	double freq = getTickFrequency() / 1000;
    222. 	//获取推理总时间，并转换将时间单位转换为毫秒
    223. 	double t = net.getPerfProfile(layersTimes) / freq;
    224.  
    225. 	string label = format("Inference time: %.2fms", t);
    226. 	//putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 0, 255));
    227. 	imshow("YOLOv3", frame);
    228. 	cv::waitKey(0);
    229. }
    230.  
    231. void detect_video(string video_path, string config, string weights, string classespath)
    232. {
    233. 	//加载目标检测标签
    234. 	getclasses(classespath);
    235.  
    236. 	//加载网络
    237. 	Net net = readNetFromDarknet(config, weights);
    238.  
    239. #if 0
    240. 	//cpu推理
    241. 	net.setPreferableBackend(DNN_BACKEND_OPENCV);
    242. 	net.setPreferableTarget(DNN_TARGET_CPU);
    243.  
    244. #elif 1
    245. 	//使用cuda加速
    246. 	net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
    247. 	net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA_FP16);
    248.  
    249. #endif
    250.  
    251. 	// 打开视频流,使用视频文件的路径. 0表示默认摄像头
    252. 	VideoCapture capture(video_path);
    253. 	// 检查是否成功打开视频流
    254. 	if(!capture.isOpened())
    255. 	{
    256. 		std::cerr << "Error: Could not open video stream." << std::endl;
    257.  
    258. 	}
    259. 	Mat frame, blob;
    260.  
    261. 	//处理每一帧
    262. 	while(capture.read(frame))
    263. 	{
    264. 		//图像预处理
    265. 		blobFromImage(frame, blob, 1 / 255.0, cv::Size(width, height), Scalar(0, 0, 0), true, false);
    266.  
    267. 		//设置网络的输入
    268. 		net.setInput(blob);
    269.  
    270. 		//获得当前系统的计时间周期数,求FPS
    271. 		double t = (double)getTickCount();
    272.  
    273. 		//执行推理
    274. 		vector outs;
    275. 		net.forward(outs, getOutputsNames(net));
    276.  
    277. 		//剔除置信度较小的 bounding boxes
    278. 		postprocess(frame, outs);
    279. 		
    280. 		//将图像帧转换为CV_8U格式显示
    281. 		Mat detectedFrame;
    282. 		frame.convertTo(detectedFrame, CV_8U);
    283.  
    284. 		//FPS计算
    285. 		t = ((double)getTickCount() - t) / getTickFrequency();//求输入帧后经过的周期数/每秒系统计的周期数=一帧用时多少秒
    286. 		double fps = 1.0 / t;//求倒数得到每秒经过多少帧，即帧率
    287. 		string text = format("FPS:%.2f",fps);
    288. 		cv::putText(frame, text, Point(10, 50), FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 0), 2, 8, 0);
    289. 		imshow("YOLOv3", frame);
    290. 		int c = waitKey(1);
    291. 		if (c == 27)
    292. 		{
    293. 			break;
    294. 		}
    295. 	}
    296. 	capture.release();
    297. 	waitKey(0);
    298. }

    结束语
    感谢你观看我的文章呐~本次航班到这里就结束啦 🛬

    希望本篇文章有对你带来帮助 🎉，有学习到一点知识~

    躲起来的星星🍥也在努力发光，你也要努力加油（让我们一起努力叭）。

    最后，博主要一下你们的三连呀（点赞、评论、收藏），不要钱的还是可以搞一搞的嘛~

    不知道评论啥的，即使扣个666也是对博主的鼓舞吖 💞 感谢 💐

  • 相关阅读:
    JVM 系列（4）一看就懂的对象内存布局
    【车载开发系列】CAN总线知识进阶篇
    linux 多台机器修改时间同步
    浅谈测试需求分析
    SpringSecurity系列一：05 SpringSecurity 自定义表单登录和注销登录认证
    2023年全国职业院校技能大赛信息安全管理与评估网络安全渗透任务书
    3.5 讲一讲关于小红书的搜索引流技巧【玩赚小红书】
    YOLOv5、YOLOv8改进：Decoupled Head解耦头
    微服务项目：尚融宝（59）（核心业务流程：提现和还款（2））
    网络原理之 TCP解释超详细!!!
  • 原文地址：https://blog.csdn.net/qq_53144843/article/details/132948310