【C++并发入门】opencv摄像头帧率计算和多线程相机读取（下）:完整代码实现

于 2024-10-01 14:17:03 发布
阅读量1.1k 收藏 29
点赞数 17
文章标签： c++ opencv 数码相机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73800387/article/details/142670598
版权

前言

  • 高帧率摄像头往往应用在很多opencv项目中，今天就来通过简单计算摄像头帧率，抛出一个单线程读取摄像头会遇到的问题，同时提出一种解决方案，使用多线程对摄像头进行读取。
  • 上一期：【C++并发入门】摄像头帧率计算和多线程相机读取（上）：并发基础概念和代码实现-CSDN博客
  • 本教程使用的环境：
    • opencv C++ 4.5
    • C++11
    • KS1A293黑白240fps摄像头
  • 上一期我们介绍了并发的基础入门知识，讲解了摄像头帧率计算，线程进程，并发和并行，std::thread，std::mutex，死锁，数据竞争问题，以及std::lock_guard。这一期我们来看看如何把并发运用到实际的多线程读取相机上。

1 多线程读取相机

1-1 代码实现
  • 结合上一节我们学习到的内容，我们使用面向对象的思路，简单写出以下的代码
#include<iostream>
#include <opencv2/opencv.hpp>
#include <thread>
#include<chrono>
#define _CRT_SECURE_NO_WARNINGS 1

class ThreadCam
{
private:
	cv::Mat  frame;
	cv::VideoCapture cap;
	std::thread cameraCaptureThread;
	std::thread cameraProcessingThread;
	std::mutex mtx;
	std::chrono::time_point<std::chrono::steady_clock> startTime = std::chrono::steady_clock::now();
	std::chrono::time_point<std::chrono::steady_clock> endTime;

	void cameraCaptureThreadFunc() 
	{
		while (true) 
		{
			{
				std::lock_guard<std::mutex> guard(mtx);
				bool ret = cap.read(frame);
			}
		}
	}
	void cameraProcessingThreadFunc()
	{
		double frame_count = 0;
		double fps = 0;
		while (true)
		{
			if (frame.empty())
				continue;
			frame_count++;
			endTime = std::chrono::steady_clock::now();
	        double timeTaken = std::chrono::duration<double, std::milli>(endTime - startTime).count();
	        if (timeTaken >= 1000)
	        {
	            fps = frame_count;
	            startTime = std::chrono::steady_clock::now();
	            frame_count = 0;
	        }
			

			cv::putText(frame, std::to_string(int(fps)) + " FPS", cv::Point(frame.cols / 4, frame.rows / 3), cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(255, 0, 0), 2);
		
			
			cv::imshow("Frame", frame);
			
			if (cv::waitKey(1) == 'q')
			    break;
			
		}
	}
public:
	ThreadCam() :cap(0)
	{
		if (!cap.isOpened())
		{
			std::cerr << "open camera failed!" << std::endl;
			std::abort();
		}
		cap.set(cv::CAP_PROP_FRAME_WIDTH, 640);
		cap.set(cv::CAP_PROP_FRAME_HEIGHT, 400);
		cap.set(cv::CAP_PROP_FOURCC, cv::VideoWriter::fourcc('M', 'J', 'P', 'G'));
		cameraCaptureThread = std::thread(&ThreadCam::cameraCaptureThreadFunc, this);
		cameraProcessingThread = std::thread(&ThreadCam::cameraProcessingThreadFunc, this);

		cameraCaptureThread.join();
		cameraProcessingThread.join();
	}
};
int main()
{
	try {
		ThreadCam thread_cam;
	
	}
	catch (const std::exception& e) {
		std::cerr << "Exception caught: " << e.what() << std::endl;
		return -1;
	}

	return 0;
}
  • cameraCaptureThreadFunc：这个线程不断地从摄像头捕获帧，并将捕获到的帧存储在frame变量中。它使用std::lock_guard来保证在读取和写入frame时不会发生竞争条件。
  • cameraProcessingThreadFunc：这个线程捕获摄像头画面计算并显示视频的帧率。它首先检查frame是否为空，然后计算自startTime以来的时间。如果时间超过1000毫秒，则计算帧率，重置startTime，并将帧计数器frame_count重置为0。然后，它在每一帧上显示当前的帧率，并在按下’q’键时退出循环。
  • 下面代码创建了一个std::lock_guard对象guard，它自动锁定互斥量mtx。std::lock_guard的作用域是紧随其声明之后的代码块，即大括号{}内的区域。当std::lock_guard对象超出这个作用域时，其析构函数会被调用，这将导致互斥锁被自动释放。
{
	std::lock_guard<std::mutex> guard(mtx);
	bool ret = cap.read(frame);
}
1-2 效果展示

  • 运行效果如下，一看帧率？？？甚至超出了摄像头的最高帧率，这是怎么回事呢请添加图片描述

  • 由于摄像头捕获的线程和摄像头处理(FPS计算的线程)是异步，那也就意味着摄像头处理的线程甚至可能快于摄像头捕获线程的运行速率，导致捕获到的frame会出现连续相同的画面，以导致画面帧数计算错误。那解决这个问题也很简单，如果我们需要计算真正的FPS，我们只需要剔除重复的画面即可。

  • 但是在这样多线程的读取捕获处理下，即使会出现相同的画面，也就不会出现像上一节那样由于耗时操作导致捕获到的画面不及时，一定程度上解决了这个问题。

2 判重优化

2-1 方法选择
  • 那为了正确计算图像的真实FPS，要做的就是进行判重剔除，那在opencv中如何做到判重呢
    1. 像素级比较：直接比较两张图片的每个像素值。如果所有像素都相同，则认为两张图片一致。
    2. 哈希方法：使用哈希函数（如MD5、SHA-1等）为图片生成一个唯一的指纹。如果两张图片的哈希值相同，则它们很可能是一致的。
    3. 特征匹配： 使用特征检测算法（如SIFT、SURF、ORB等）提取图片中的关键点，然后比较这些关键点的匹配程度。
  • 那我们选择哪一种呢，==答案是都不选!!!==上述图像处理操作都会经历一定程度上的耗时操作，即使按照最简单的将两张图像进行做差的结果来判断图像是否一致都需要进行一次做差运算，这是相对耗时间的。
bool isFrameSame(const  cv::Mat& frame1, const cv::Mat& frame2, double threshold = 1e-5) {

    if (frame1.empty() || frame2.empty()) 
	    return false;
    if (frame1.size() != frame2.size())
	    return false;

    cv::Mat diff;
    cv::absdiff(img1, img2, diff);
    // 检查差值图像是否接近全黑（意味着两幅图像一致）
    double diffMean = cv::mean(diff)[0];
    return diffMean < threshold;
}
  • 这里我们提出一种计算图像帧是否相同的方法，其核心思路就是记录图像捕获时的时间戳，通过对比时间戳是否发生改变来判断图像是否更新。
2-2 时间戳
  • 时间戳（Timestamp）是一个能够表示特定时间点的数据，通常是一个计数器，用来记录自某个特定时间点（如1970年1月1日）以来的秒数或毫秒数。时间戳常用于记录事件的发生时间，或作为文件、数据记录的版本标识。
  • 在C++中，可以使用<chrono>库来获取时间戳。<chrono>库提供了多种时间点（time_point）和时间段（duration）的表示，以及相关的时钟（clock）类型。
  • 我们来看一个例子来获取毫秒时间戳
#include <iostream>
#include <chrono>

int main() {
    // 获取当前系统时间的时间点
    auto now = std::chrono::system_clock::now();

    // 将时间点转换为自纪元（1970年1月1日）以来的毫秒数
    auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());

    // 输出时间戳
    std::cout << "当前时间戳（毫秒）: " << now_ms.count() << std::endl;

    return 0;
}

  • 可以看到得到的是一串非常长的数字请添加图片描述

  • 其中

    • now 的类型是 std::chrono::system_clock::time_point。这是一个表示特定时间点的类型，它是 std::chrono 库中的一个模板类型，专门用于表示系统时间。
    • now_ms 的类型是 std::chrono::milliseconds。这是一个表示时间间隔的类型，它是 std::chrono 库中的一个模板类型，专门用于表示毫秒级的时间间隔。
    • 对于 now_ms.count() 的类型，它是 long long 类型。这是因为 std::chrono::milliseconds::count() 方法返回的是一个表示毫秒数的时间长度，而 std::chrono::milliseconds 类型是一个模板类型，其默认的Rep（表示时间的类型）是 long long。因此，now_ms.count() 返回的纳秒数是一个 long long 类型的整数。
2-3 时间戳存储选择
  • 我们创建一个带时间戳的图像结构体,这个结构体需要存储时间戳和cv::Mat图像,那么问题来了，那我们要选取什么类型来存储时间戳呢.
#include <iostream>
#include <string>

int main() {
    long long numLongLong = 1727760106400LL;

    std::string numString = "1727760106400";
    const char* numConstChar = "1727760106400";
    std::cout << "long long: " << sizeof(numLongLong) << " bytes" << numLongLong << std::endl;
    std::cout << "std::string: " << sizeof(numString) << " bytes" << numString << std::endl;


    std::cout << "const char* pointer: " << sizeof(numConstChar) << " bytes" << numConstChar << std::endl;
  
    return 0;
}
  • 结果如下请添加图片描述
2-3 实现
  • 那我们实现一个结构体
struct FrameWithTimeStamp
{
	long long time_stamp;
	cv::Mat frame;
};
  • 完整代码如下,通过记录时间戳来进行对比
#include<iostream>
#include <opencv2/opencv.hpp>
#include <thread>
#include<chrono>
#define _CRT_SECURE_NO_WARNINGS 1
struct FrameWithTimeStamp
{
	long long time_stamp;
	cv::Mat frame;
};

class ThreadCam
{
private:
	FrameWithTimeStamp  frame_t;
	cv::VideoCapture cap;
	std::thread cameraCaptureThread;
	std::thread cameraProcessingThread;
	std::mutex mtx;
	std::chrono::time_point<std::chrono::steady_clock> startTime = std::chrono::steady_clock::now();
	std::chrono::time_point<std::chrono::steady_clock> endTime;
	void setCurrentTimeStamp(long long& time_stamp)
	{
		auto now = std::chrono::system_clock::now();

		// 将时间点转换为自纪元（1970年1月1日）以来的毫秒数
		auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
		time_stamp = now_ms.count();
	}
	void cameraCaptureThreadFunc() 
	{
		while (true) 
		{
			{
				std::lock_guard<std::mutex> guard(mtx);
				bool ret = cap.read(frame_t.frame);
				setCurrentTimeStamp(frame_t.time_stamp);
			}
		}
	}
	void cameraProcessingThreadFunc()
	{
		double frame_count = 0;
		double fps = 0;
		auto now = std::chrono::system_clock::now();
		long long last_timeStamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
		while (true)
		{
			if (frame_t.frame.empty())
				continue;

			if (last_timeStamp == frame_t.time_stamp)
				continue;
			frame_count++;
			endTime = std::chrono::steady_clock::now();
	        double timeTaken = std::chrono::duration<double, std::milli>(endTime - startTime).count();
	        if (timeTaken >= 1000)
	        {
	            fps = frame_count;
	            startTime = std::chrono::steady_clock::now();
	            frame_count = 0;
	        }
			last_timeStamp = frame_t.time_stamp;

			cv::putText(frame_t.frame, std::to_string(int(fps)) + " FPS", cv::Point(frame_t.frame.cols / 4, frame_t.frame.rows / 3), cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(255, 0, 0), 2);
			cv::putText(frame_t.frame, std::to_string(frame_t.time_stamp), cv::Point(frame_t.frame.cols /2, frame_t.frame.rows / 3), cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(255, 0, 0), 2);
		
			
			cv::imshow("Frame", frame_t.frame);
			
			if (cv::waitKey(1) == 'q')
			    break;
			
		}
	}
public:
	ThreadCam() :cap(0)
	{
		if (!cap.isOpened())
		{
			std::cerr << "open camera failed!" << std::endl;
			std::abort();
		}
		cap.set(cv::CAP_PROP_FRAME_WIDTH, 640);
		cap.set(cv::CAP_PROP_FRAME_HEIGHT, 400);
		cap.set(cv::CAP_PROP_FOURCC, cv::VideoWriter::fourcc('M', 'J', 'P', 'G'));
		cameraCaptureThread = std::thread(&ThreadCam::cameraCaptureThreadFunc, this);
		cameraProcessingThread = std::thread(&ThreadCam::cameraProcessingThreadFunc, this);

		cameraCaptureThread.join();
		cameraProcessingThread.join();
	}
};
int main()
{
	try {
		ThreadCam thread_cam;
	
	}
	catch (const std::exception& e) {
		std::cerr << "Exception caught: " << e.what() << std::endl;
		return -1;
	}

	return 0;
}
  • 效果如下，稳定在相机的最高帧率180fps左右,右边是显示的时间戳请添加图片描述

总结

  • 至此我们完成了多线程相机的全部读取，正式完成了C++并发第一步
  • 后续用空更新更多的并发教程~感谢大家的支持
  • 如有错误，欢迎指出！！！！！！
zh路西法
关注
基于MFC的网络摄像头视频读取显示程序
10-25
此程序是基于MFC平台的网络摄像头视频读取，并进行显示的程序，摄像头采集视频信息，并通过WiFi传递到PC端，PC端上位机，用opencv读取视频信息，并进行显示。次程序需要opencv库。
【C++并发入门】摄像头帧率计算和多线程相机读取（上）：并发基础概念和代码实现
最新发布
m0_73800387的博客
09-29 1193
本文介绍了并发的基础入门知识，讲解了摄像头帧率计算，线程进程，并发和并行，std::thread，std::mutex，死锁，数据竞争问题，以及std::lock_guard
C++ 和opencv 利用多线程的方法实现图像的识别检测模板程序，速度大大提升。有利于工程应用和学习
10-08
C++ 和opencv 利用多线程的方法实现图像的识别检测模板程序，速度大大提升。有利于工程应用和学习
OpenCV获取并设置摄像头拍摄视频的帧率、分辨率
12-10
OpenCV获取并设置摄像头拍摄视频的帧率、分辨率
OpenCV~捕获摄像头 帧率fps和waitkey函数 问题
2401_84121702的博客
04-18 567
最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。由于篇幅有限，这里以图片的形式给大家展示一小部分。
opencv计算摄像头图像帧数
SpacePotato的博客
06-04 199
【代码】opencv计算摄像头图像帧数。
c++ && OpenCV的多线程实时视频传输（TCP on Windows）
linxizi0622的博客
02-03 5131
c++ && OpenCV的多线程实时视频传输（TCP on Windows）
C++基于 opencv实现的视频剪辑软件项目源码
12-13
7. **多线程与并发**：为了提高性能，视频处理可能会使用多线程或并发技术，例如使用OpenCV的`cv::parallel_for`进行并行处理，或者利用C++11以上的线程库。 8. **编译构建系统**：项目可能使用CMake或其他构建工具...
opencv控制多摄像头
10-23
总之，OpenCV控制多摄像头涉及的主要知识点有：OpenCV的VideoCapture类，摄像头设备ID，GUI编程，以及可能的多线程或并发处理。通过掌握这些技术，你可以构建出能够同时监控和处理多个摄像头输入的应用程序，满足...
OpenCV4-Video-Source-Code:OpenCV4视频源代码-opencv source code
03-24
5. **多线程与并发**：在处理大量视频数据时，OpenCV可能会利用多线程来提高效率。例如，在视频读取过程中，可能有一个线程负责读取帧，另一个线程负责处理和显示帧。理解源代码中的线程管理可以帮助优化性能。 6. ...
opencv下实现显示并更改摄像头分辨率，帧率
06-04
opencv下实现显示并更改摄像头分辨率，帧率，同时能显示多个摄像头，基于Opencv2.0以后的版本
OpenCV显示摄像头FPS
12-22
基于OpenCV2.3.1+VS2008实现的显示设想头帧速FPS
qt-opencv-multithreaded-1.21Qt结合OpenCV多线程图像处理
04-04
Qt中利用OpenCV2.4.4多线程打开多摄像机 每个线程处理一个摄像机，从中拿出帧显示到主线程的Label控件上 模拟了一个16个摄像机的场景，有不开多线程和打开多线程的对比。 可以明显感觉到打开多线程后主界面不卡了。 只是个多线程的小例子，还有很多不足之处，有待各位完善。 注意：pro文件中的include和lib文件目录需要根据自己电脑上的情况重新配置
C++与OpenCV的多线程开发技术
12-08
基于C++与OpenCV，利用多线程开发技术，实现图像分割、图像分类、文件重命名以及文件过滤等功能，根据CPU支持线程数量进行并发计算。
QT多线程采集摄像头数据处理显示(QVideoProbe+QCamera+QThread)
03-26 6909
一、环境介绍 操作系统介绍：ubuntu 18.04 、windows、Android QT版本: 5.12.6 摄像头: USB摄像头、虚拟机挂载本机自带摄像头 二、功能介绍 在子线程里通过QVideoProbe捕获摄像头一帧数据，处理之后(加时间水印)，再通过信号/槽机制发送给主线程，在UI界面显示。 子线程方式采用moveToThread方式实现，因为需要用到QVideoPr...
在opencv中如何设置和获取帧速率
weixin_42593130的博客
01-16 3641
在 OpenCV 中，可以使用 cv2.CAP_PROP_FPS 属性来设置和获取帧速率。 设置帧速率的示例代码如下： import cv2 # 打开摄像头 cap = cv2.VideoCapture(0) # 设置帧速率为 30 fps cap.set(cv2.CAP_PROP_FPS, 30) ...
C++并发多线程（一）
weixin_30838921的博客
04-09 37
并发：两个或者更多的任务同时发生，一个程序同时执行多个独立的任务。 以往计算机 单核CPU 某一个时刻只能执行一个任务 由操作系统调度 每秒钟进行多次所谓的任务切换并发的假象（不是真正的并发），这种切换（上下文切换）时要有时间开销的。 线程 每个进程（执行起来的可执行程序），都有一个主线程 这个主线程是唯一的 也就是一个进程中只能有一个主线程。当你执行要给刻执行程序 ，产生了一个...
opencv 摄像头帧率
10-16
使用 OpenCV 获取摄像头帧率的方法如下： ```python import cv2 cap = cv2.VideoCapture(0) # 获取摄像头帧率 fps = cap.get(cv2.CAP_PROP_FPS) print("摄像头帧率为：", fps) cap.release() ``` 其中，`cv2.VideoCapture(0)` 表示打开编号为 0 的摄像头，如果有多个摄像头，可以尝试不同的编号。`cap.get(cv2.CAP_PROP_FPS)` 表示获取摄像头的帧率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值