帧差运动检测和颜色检测(C++)

最新推荐文章于 2024-03-02 14:53:09 发布
最新推荐文章于 2024-03-02 14:53:09 发布
阅读量432 收藏 4
点赞数
文章标签： opencv cv 计算机视觉 边缘检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39523365/article/details/113184882
版权

基于视频的烟火检测

首先,对图像进行预处理：

1.对图像分块，将图像分为24*24的小块

2.对每块图像进行运动检测及颜色检测

然后,使用训练好的神经网络对图像进行分类

分块帧差运动检测

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <vector>
using namespace std;
using namespace cv;

//计算二值图像素大于0的个数
int bSums(Mat src)
{
	int counter = 0;
	//迭代器访问像素点
	Mat_<uchar>::iterator it = src.begin<uchar>();
	Mat_<uchar>::iterator itend = src.end<uchar>();
	for (; it != itend; ++it)
	{
		if ((*it)>0) counter += 1;//二值化后，像素点是0或者255
	}
	return counter;
}
//图像块结构体
struct FraRIO
{
	Mat frameRIO;
	int point_x;
	int point_y;
	bool RIO_flag;

};
//每帧图像分块
vector<FraRIO>  DivFra(Mat &image, int width, int height)
{
	char name = 1;
	int m, n;
	m = image.rows / height;
	n = image.cols / width;
	vector<FraRIO> FraRIO_Out;
	FraRIO temFraRIO;
	for (int j = 0; j<m; j++)
	{
		for (int i = 0; i<n; i++)
		{
			Mat temImage(height, width, CV_8UC3, cv::Scalar(0, 0, 0));//
			Mat imageROI = image(Rect(i*width, j*height, temImage.cols, temImage.rows));//rect(x, y, width, height)选定感兴趣区域
			addWeighted(temImage, 1.0, imageROI, 1.0, 0., temImage);//复制扫描出的边界内数据

			temFraRIO.frameRIO = temImage.clone();
			temFraRIO.point_x = i*width;
			temFraRIO.point_y = j*height;
			FraRIO_Out.push_back(temFraRIO);
		}
	}
	return FraRIO_Out;
}

int main()
{
	//读取视频
	VideoCapture capture("C:/Users/Administrator/Desktop/FireCollect/neg/nonfire_indoor_6.avi");
	if (!capture.isOpened())
		return -1;

	//
	double rate = capture.get(CV_CAP_PROP_FPS);
	int delay = 1000 / rate;

	//定义当前帧和临时帧
	Mat frame, tem_frame;

	//定义前一帧和当前帧分割后的结构体数组
	vector<FraRIO> framePro_RIO;
	vector<FraRIO> frame_RIO;

	bool flag = false;

	namedWindow("image", CV_WINDOW_AUTOSIZE);

	while (capture.read(frame)){
		//对当前帧进行分割，大小24*24
		frame_RIO = DivFra(frame,24,24);

		if (false == flag)
		{
			//当前帧数组赋值前一帧数组
			framePro_RIO = frame_RIO;
			flag = true;
		}
		else
		{
			//
			vector<FraRIO>::iterator it_pro = framePro_RIO.begin();
			vector<FraRIO>::iterator it = frame_RIO.begin();
			//对结构体数组进行遍历
			while (it != frame_RIO.end() && it_pro != framePro_RIO.end())
			{
				//当前帧与前一帧做差,存入临时帧
				absdiff(it->frameRIO, it_pro->frameRIO, tem_frame);
				//彩色图转灰度图
				cvtColor(tem_frame, tem_frame, COLOR_BGR2GRAY);
				//二值化
				threshold(tem_frame, tem_frame, 80, 255, CV_THRESH_BINARY);

				cout << bSums(tem_frame) << endl;
				//找出像素大于0的区块
				if (bSums(tem_frame)>0){
					//画出矩形框
					rectangle(frame, cvPoint(it->point_x, it->point_y), cvPoint(it->point_x+it->frameRIO.cols, it->point_y+it->frameRIO.rows), Scalar(255, 0, 0), 1, 1, 0);//能够实时显示运动物体
				}
				it++;
				it_pro++;
			}
			//
			framePro_RIO = frame_RIO;

			imshow("image", frame);

			waitKey(delay);
		}
	}
	return 0;
}

火焰颜色模型(opencv2_用到YCrCb)

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
using namespace std;
using namespace cv;


void ImgMean(float& c1, float& c2, float& c3, Mat pImg)
{
	int nPixel = pImg.rows*pImg.cols;	// number of pixels in image
	c1 = 0; c2 = 0; c3 = 0;

	//累加各通道的值
	MatConstIterator_<Vec3b> it = pImg.begin<Vec3b>();
	MatConstIterator_<Vec3b> itend = pImg.end<Vec3b>();

	while (it != itend)
	{
		c1 += (*it)[0];
		c2 += (*it)[1];
		c3 += (*it)[2];
		it++;

	}
	//累加各通道的值

	c1 = c1 / nPixel;
	c2 = c2 / nPixel;
	c3 = c3 / nPixel;
}

int bSums(Mat &src)
{
	int counter = 0;
	//迭代器访问像素点
	Mat_<uchar>::iterator it = src.begin<uchar>();
	Mat_<uchar>::iterator itend = src.end<uchar>();
	for (; it != itend; ++it)
	{
		if ((*it)>0) counter += 1;//二值化后，像素点是0或者255
	}
	return counter;
}
int main(){

	Mat srcImg = imread("G:/fire/ship1.jpg");
	Mat m_pcurFrameYCrCb;
	Mat pImgResult;

	m_pcurFrameYCrCb.create(srcImg.size(), srcImg.type());
	pImgResult.create(srcImg.size(), srcImg.type());
	cvtColor(srcImg, m_pcurFrameYCrCb, CV_BGR2YCrCb);
	//m_pcurFrameYCrCb = srcImg.clone();

	float yy_mean = 0, cr_mean = 0, cb_mean = 0;
	ImgMean(cb_mean, cr_mean, yy_mean, m_pcurFrameYCrCb);
	uchar r = 0, g = 0, b = 0;
	uchar yy = 0, cr = 0, cb = 0;


	for (int i = 0; i<srcImg.rows; i++){
		for (int j = 0; j<srcImg.cols; j++){

			b = srcImg.at<Vec3b>(i, j)[0];
			g = srcImg.at<Vec3b>(i, j)[1];
			r = srcImg.at<Vec3b>(i, j)[2];

			cb = m_pcurFrameYCrCb.at<Vec3b>(i, j)[0];
			cr = m_pcurFrameYCrCb.at<Vec3b>(i, j)[1];
			yy = m_pcurFrameYCrCb.at<Vec3b>(i, j)[2];

			if (r>120 && yy>cb&&cr>cb&&yy>yy_mean && (abs(cb - cr)>40))
				//if (r>12 && r>g && g>b && yy>cb&&cr>cb && cr>cr_mean  && cb<cb_mean && yy>yy_mean && (abs(cb - cr)>40))
			{
				pImgResult.at<Vec3b>(i, j)[0] = 255;
				pImgResult.at<Vec3b>(i, j)[1] = 255;
				pImgResult.at<Vec3b>(i, j)[2] = 255;
			}
			else
			{
				pImgResult.at<Vec3b>(i, j)[0] = 0;
				pImgResult.at<Vec3b>(i, j)[1] = 0;
				pImgResult.at<Vec3b>(i, j)[2] = 0;

			}

		}
	}
	//彩色图转灰度图
	cvtColor(pImgResult, pImgResult, COLOR_BGR2GRAY);
	//二值化
	//threshold(pImgResult, pImgResult, 80, 255, CV_THRESH_BINARY);
	cout << bSums(pImgResult) << endl;
	namedWindow("Color", WINDOW_NORMAL);
	imshow("Color", pImgResult);

	waitKey(0);

	return 0;
}

火焰颜色模型(opencv2_没用到YCrCb_1)

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
using namespace std;
using namespace cv;


void ImgMean(float& c1, float& c2, float& c3, Mat pImg)
{
	int nPixel = pImg.rows*pImg.cols;	// number of pixels in image
	c1 = 0; c2 = 0; c3 = 0;

	uchar* pData = pImg.data;
	uchar* pcurPixel = pData;
	//累加各通道的值

	for (int y = 0; y< pImg.rows; y++)
	{
		pcurPixel = pData;
		for (int x = 0; x < pImg.cols; x++)
		{
			c1 += pcurPixel[0];
			c2 += pcurPixel[1];
			c3 += pcurPixel[2];
			pcurPixel += 3;
		}
		pData += pImg.step;
	}

	//累加各通道的值

	c1 = c1 / nPixel;
	c2 = c2 / nPixel;
	c3 = c3 / nPixel;
}

int bSums(Mat &src)
{
	int counter = 0;
	//迭代器访问像素点
	Mat_<uchar>::iterator it = src.begin<uchar>();
	Mat_<uchar>::iterator itend = src.end<uchar>();
	for (; it != itend; ++it)
	{
		if ((*it)>0) counter += 1;//二值化后，像素点是0或者255
	}
	return counter;
}
int main(){

	Mat srcImg = imread("G:/fire/ship1.jpg");
	Mat m_pcurFrameYCrCb;
	Mat pImgResult;

	m_pcurFrameYCrCb.create(srcImg.size(), srcImg.type());

	pImgResult.create(srcImg.size(), srcImg.type());
	
	m_pcurFrameYCrCb = srcImg.clone();
	//cvtColor(srcImg, m_pcurFrameYCrCb, CV_BGR2YCrCb);

	uchar* pData = (uchar*)srcImg.data;
	uchar* pDataYCrCb = (uchar*)m_pcurFrameYCrCb.data;

	uchar* pDataResult = (uchar*)pImgResult.data;

	uchar* pcurPixel = pData;
	uchar* pcurPixelYCrCb = pDataYCrCb;
	uchar* pcurPixelResult = pDataResult;

	float yy_mean = 0, cr_mean = 0, cb_mean = 0;


	ImgMean(cb_mean, cr_mean, yy_mean, m_pcurFrameYCrCb);
	uchar r = 0, g = 0, b = 0;
	uchar yy = 0, cr = 0, cb = 0;

	for (int y = 0; y< srcImg.rows; y++)
	{
		pcurPixel = pData + y*srcImg.step;
		pcurPixelYCrCb = pDataYCrCb + y*m_pcurFrameYCrCb.step;
		pcurPixelResult = pDataResult + y* pImgResult.step;

		for (int x = 0; x < srcImg.cols; x++)
		{
			b = pcurPixel[0];
			g = pcurPixel[1];
			r = pcurPixel[2];

			cb = pcurPixelYCrCb[0];
			cr = pcurPixelYCrCb[1];
			yy = pcurPixelYCrCb[2];
			//根据公式判断该点是否符合火焰颜色模型的条件
			if (r>120 && yy>cb&&cr>cb&&yy>yy_mean && (abs(cb - cr)>40))
			{
				//*pcurPixelResult = 255;
				pcurPixelResult[0] = 255;
				pcurPixelResult[1] = 255;
				pcurPixelResult[2] = 255;

			}
			else
			{
				//*pcurPixelResult = 0;
				pcurPixelResult[0] = 0;
				pcurPixelResult[1] = 0;
				pcurPixelResult[2] = 0;
			}
			pcurPixel += 3;
			pcurPixelYCrCb += 3;
			//pcurPixelResult++;
			pcurPixelResult += 3;
		}
	}

	//彩色图转灰度图
	cvtColor(pImgResult, pImgResult, COLOR_BGR2GRAY);
	//二值化
	//threshold(pImgResult, pImgResult, 80, 255, CV_THRESH_BINARY);
	//cout << bSums(pImgResult) << endl;
	namedWindow("Color", WINDOW_NORMAL);
	imshow("Color", pImgResult);

	waitKey(0);

	return 0;
}

main.cpp

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <vector>
using namespace std;
using namespace cv;

//计算二值图像素大于0的个数
int bSums(Mat src)
{
	int counter = 0;
	//迭代器访问像素点
	Mat_<uchar>::iterator it = src.begin<uchar>();
	Mat_<uchar>::iterator itend = src.end<uchar>();
	for (; it != itend; ++it)
	{
		if ((*it)>0) counter += 1;//二值化后，像素点是0或者255
	}
	return counter;
}
//图像块结构体
struct FraRIO
{
	Mat frameRIO;
	int point_x;
	int point_y;
	bool RIO_flag;

};
//每帧图像分块
vector<FraRIO>  DivFra(Mat &image, int width, int height)
{
	char name = 1;
	int m, n;
	m = image.rows / height;
	n = image.cols / width;
	vector<FraRIO> FraRIO_Out;
	FraRIO temFraRIO;
	for (int j = 0; j<m; j++)
	{
		for (int i = 0; i<n; i++)
		{
			Mat temImage(height, width, CV_8UC3, cv::Scalar(0, 0, 0));//
			Mat imageROI = image(Rect(i*width, j*height, temImage.cols, temImage.rows));//rect(x, y, width, height)选定感兴趣区域
			addWeighted(temImage, 1.0, imageROI, 1.0, 0., temImage);//复制扫描出的边界内数据

			temFraRIO.frameRIO = temImage.clone();
			temFraRIO.point_x = i*width;
			temFraRIO.point_y = j*height;
			FraRIO_Out.push_back(temFraRIO);
		}
	}
	return FraRIO_Out;
}

void ImgMean(float& c1, float& c2, float& c3, Mat pImg)
{
	int nPixel = pImg.rows*pImg.cols;	// number of pixels in image
	c1 = 0; c2 = 0; c3 = 0;

	//累加各通道的值
	MatConstIterator_<Vec3b> it = pImg.begin<Vec3b>();
	MatConstIterator_<Vec3b> itend = pImg.end<Vec3b>();

	while (it != itend)
	{
		c1 += (*it)[0];
		c2 += (*it)[1];
		c3 += (*it)[2];
		it++;

	}
	//累加各通道的值

	c1 = c1 / nPixel;
	c2 = c2 / nPixel;
	c3 = c3 / nPixel;
}

Mat ColorDet(Mat srcImg){
	Mat m_pcurFrameYCrCb;
	Mat pImgResult;

	m_pcurFrameYCrCb.create(srcImg.size(), srcImg.type());
	pImgResult.create(srcImg.size(), srcImg.type());
	//cvtColor(srcImg, m_pcurFrameYCrCb, CV_BGR2YCrCb);
	m_pcurFrameYCrCb = srcImg.clone();

	float yy_mean = 0, cr_mean = 0, cb_mean = 0;
	ImgMean(cb_mean, cr_mean, yy_mean, m_pcurFrameYCrCb);
	uchar r = 0, g = 0, b = 0;
	uchar yy = 0, cr = 0, cb = 0;


	for (int i = 0; i<srcImg.rows; i++){
		for (int j = 0; j<srcImg.cols; j++){

			b = srcImg.at<Vec3b>(i, j)[0];
			g = srcImg.at<Vec3b>(i, j)[1];
			r = srcImg.at<Vec3b>(i, j)[2];

			cb = m_pcurFrameYCrCb.at<Vec3b>(i, j)[0];
			cr = m_pcurFrameYCrCb.at<Vec3b>(i, j)[1];
			yy = m_pcurFrameYCrCb.at<Vec3b>(i, j)[2];

			if (r>120 && yy>cb&&cr>cb&&yy>yy_mean && (abs(cb - cr)>40))
				//if (r>12 && r>g && g>b && yy>cb&&cr>cb && cr>cr_mean  && cb<cb_mean && yy>yy_mean && (abs(cb - cr)>40))
			{
				pImgResult.at<Vec3b>(i, j)[0] = 255;
				pImgResult.at<Vec3b>(i, j)[1] = 255;
				pImgResult.at<Vec3b>(i, j)[2] = 255;

			}
			else
			{
				pImgResult.at<Vec3b>(i, j)[0] = 0;
				pImgResult.at<Vec3b>(i, j)[1] = 0;
				pImgResult.at<Vec3b>(i, j)[2] = 0;

			}

		}
	}
	//彩色图转灰度图
	cvtColor(pImgResult, pImgResult, COLOR_BGR2GRAY);

	return pImgResult;
}

int main()
{
	int interval = 0;
	// /root/zhangsong/fairworks/github/darknet-master/fireworks/data/TestVideo_5.mp4
	// /root/zhangsong/fairworks/github/darknet-master/data/zs_test_video/CA28_S20201015133001_E20201015163000_005710781-005851374.mp4
	// /root/zhangsong/fairworks/github/darknet-master/fireworks/data/fog/longgang-07-57-54_08-03-59_0-1.mp4
	// /root/zhangsong/fairworks/github/darknet-master/fireworks/data/S1090009-12.MP4
	// /root/zhangsong/fairworks/github/darknet-master/fireworks/data/20200406082838_4.mp4  fireworks/data/G92X211K400_CVR_10-03-00_10-06-59_0.mp4  真实货车冒烟数据
	//读取视频
	VideoCapture capture("/root/zhangsong/fairworks/github/darknet-master/data/zs_test_video/CA28_S20201015133001_E20201015163000_005710781-005851374.mp4");
	if (!capture.isOpened())
		return -1;

	//
	double rate = capture.get(CV_CAP_PROP_FPS);
	int delay = 1000 / rate;

	//定义当前帧和临时帧
	Mat frame, tem_frame;

	//定义前一帧和当前帧分割后的结构体数组
	vector<FraRIO> framePro_RIO;
	vector<FraRIO> frame_RIO;

	bool flag = false;

	namedWindow("image", CV_WINDOW_AUTOSIZE);

	while (capture.read(frame)){
		interval++;
		if(interval%3 != 0)
		{
			continue;
		}
		//对当前帧进行分割，大小24*24
		frame_RIO = DivFra(frame, 15, 15);

		if (false == flag)
		{
			//当前帧数组赋值前一帧数组
			framePro_RIO = frame_RIO;
			flag = true;
		}
		else
		{
			//
			vector<FraRIO>::iterator it_pro = framePro_RIO.begin();
			vector<FraRIO>::iterator it = frame_RIO.begin();
			//对结构体数组进行遍历
			while (it != frame_RIO.end() && it_pro != framePro_RIO.end())
			{
				//当前帧与前一帧做差,存入临时帧
				absdiff(it->frameRIO, it_pro->frameRIO, tem_frame);
				//彩色图转灰度图
				cvtColor(tem_frame, tem_frame, COLOR_BGR2GRAY);
				//二值化
				threshold(tem_frame, tem_frame, 8, 255, CV_THRESH_BINARY);

				//cout << bSums(ColorDet(it->frameRIO)) << endl;
				//tem_frame = tem_frame & ColorDet(it->frameRIO);

				//cout << bSums(tem_frame) << endl;

				//找出像素大于0的区块
				if (bSums(tem_frame)>150){
					//画出矩形框
					rectangle(frame, cvPoint(it->point_x, it->point_y), cvPoint(it->point_x + it->frameRIO.cols, it->point_y + it->frameRIO.rows), Scalar(255, 0, 0), 4, 8, 0);//能够实时显示运动物体
				}
				it++;
				it_pro++;
			}
			//
			framePro_RIO = frame_RIO;

        	cv::Size show_size = cv::Size((int)(640), (int)(360));
        	cv::Mat show_image;
        	cv::resize(frame, show_image, show_size);

			imshow("image", show_image);

			waitKey(delay);
			//waitKey(1);
		}
	}
	return 0;
}
AI松子666
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
语音识别端点检测程序C++
01-21
过零率、预加重、短时能量等的函数一目了然，是自学语音识别端点提取的好资料，在VS2010中编译通过 过零率、预加重、短时能量等的函数一目了然，是自学语音识别端点提取的好资料，在VS2010中编译通过
帧差法目标检测完整代码
05-25
基于帧差法利用opencv2.0进行目标检测，适用于静态背景下
6种肤色检测方法的原理及实现（C++）
Mr Qin的博客
01-18 4356
参考：https://blog.csdn.net/qq_22527639/article/details/81501565 6种肤色检测算法实现简介：原理介绍：代码实现（C++）： 简介： 肤色分割的原理就是在不同的颜色区间进行颜色分割，内容都大致相同，包括 (1) 基于HSV颜色空间的阈值肤色识别 (2) 基于RGB颜色空间的阈值肤色识别 (3) 基于YCbCr颜色空间的阈值肤色识别 (4) 基于YCbCr颜色空间和椭圆皮肤模型的皮肤识别 (5) 基于YCbCr颜色空间的Otsu阈值肤色识别 (6）OPe
C++ opencv实现颜色识别
weixin_39276851的博客
06-12 6410
看效果 下面源代码 Object.h #pragma once #include <string> #include <cv.h> #include <highgui.h> using namespace std; using namespace cv; class Object { public: Object(); ~Object(void); Object(string name); int getXPos(); void setXPos(i
C++实现人脸检测、分割、并计算人脸各个部分的颜色
最新发布
活到老、学到老
03-02 391
人脸分割提取颜色是一个计算机视觉领域的技术问题，其目标是从人脸图像中提取人脸的各个部分，并得到各个部分的颜色分布。该技术在人脸识别、美颜、虚拟化妆等领域有着广泛的应用。常用的分割方法包括： * 基于肤色的分割 * 基于边缘的分割 * 基于深度学习的分割。：首先需要检测出人脸的位置和大小。
opencv3颜色识别(C++)
qq7835144的博客
07-08 1万+
文章目录opencv3颜色识别(C++)目标思路1. 读取图像2. 对比度调整（直方图均衡）3.RGB颜色分类4.形态学去噪声代码结果 opencv3颜色识别(C++) 目标 给定一幅图像，可以是读取指定文件或者从摄像机获取，识别图像中的颜色。这里我们只识别8种颜色，包括黑、红、绿、黄、蓝、紫、靛、白。这8种颜色是RGB颜色空间中位于8个顶点的颜色。 思路 1. 读取图像 读取摄像机的一帧 Vid...
chapter6 基于C++的opencv颜色detection
我不是程序员的博客
09-13 247
#include <opencv2/imgcodecs.hpp> #include <opencv2/highgui.hpp> #include <opencv2/imgproc.hpp> #include <iostream> using namespace cv; using namespace std; /////////////// Color Detection ////////////////////// void main() { s.
Opencvsharp_Threshold
zzhhziqi的博客
11-18 1678
public static double Threshold(CvArr src, CvArr dst, double threshold, double maxValue, ThresholdType thresholdType); 第一个参数，InputArray类型的src，输入数组，填单通道 , 8或32位浮点类型的Mat即可。 第二个参数，OutputArray类型的ds
OpenCV - C++实战（05） — 颜色检测
qq_41921826的博客
02-21 4707
本专栏介绍OpencV 计算机视觉程序库，基于C++语言编程，提供完整代码，持续更新文章。
Opencv通过颜色区分电线
weixin_45081640的博客
03-10 1656
Opencv检测不同颜色的电线是否接好 机器视觉检测物体要根据检测对象的特征找到最方便快捷的方法，最近做了一个靠颜色像素来区分电线的小项目，颜色区分是inRange方法，这个方法检测的是HSV彩色图像的范围，需要将图像转换为HSV图像。 如图，要检测图中六条线是否都接好并且位置没有错误，观察背景，大多都是灰黑色的物体，只有这些电线颜色比较鲜明，因此选择用颜色像素来区分。 设计算法：其实也没有什么...
C++/OpenCV：同颜色检测提取
己亥谷雨
09-15 2155
看到这个老哥写了一个类，但是没有demo，就使用这个类写了个例子 【OpenCV】OpenCV创建颜色识别类-class ColorDetector_Taily老段的专栏-CSDN博客 头文件 ColorDetector.h #pragma once #ifndef COLORDETECTOR_H_ #define COLORDETECTOR_H_ #include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui
c++识别象限标
weixin_50847463的博客
08-28 215
思想：在每帧图像上进行Hough圆检测，会检测出来许多圆，如下图所示，后续如何过滤出需要的圆？通过颜色检测，所以这里需要在每帧图像上遍历所有的圆，在每个圆内进行颜色检测。最近用到象限标定位，去网上找资料发现这方面的介绍太少了，就用了传统的方法（形状+颜色）进行检测，后期如果发现更好的方法，再来更新。象限标样式如下图所示。这个代码改进的部分还有许多，这里先进行一下记录。后续有时间改进后再来进行补充。在进行颜色检测之前，需要提取出黄黑的HSV值。将黄色与黑色的HSV阈值带入代码中。黄色提取结果如下图所示。
OpenCV [c++]（图像处理基础示例程序汇总）
NCUTer
06-25 7323
目录一、图像读取与显示二、图像预处理[高斯滤波、canny边缘检测、膨胀腐蚀]Canny边缘检测三、图像裁剪 四、绘制形状和添加文本 五、透视投影变换矫正 六、颜色检测 七、形状检测和轮廓检测[findContours(),approxPolyDP()] 八、人脸识别九、虚拟画笔作画十、文档扫描 十一.车牌区域级联检测定位opencv与VS环境配置参考我的另一篇文章：vs2019 + opencv4.3.0 开发环境配置（后续更新QT与OpenCV配置）_NCUTer的博客-CSDN博客 wait
基于均值和中值的帧差法移动物体检测c++实现源码+详细代码注释.zip
06-21
基于均值和中值的帧差法移动物体检测c++实现源码+详细代码注释.zip 【资源介绍说明】 基于均值和中值的帧差法移动物体检测，使用求多帧图像的均值和中值，得到视频背景，当前图像减去背景得到帧差图像，利用帧差图像...
基于C++的高斯差分算子边缘检测设计与实现
05-12
基于C++的高斯差分算子边缘检测设计与实现
opencv运动目标检测帧差法
07-08
opencv2.4.11 实现帧差法，检测运动目标，也可使用电脑摄像头，检测运动目标。代码清晰易懂，直接运行。
OpenCV颜色识别
热门推荐
zengwh
06-05 3万+
彩色模型数字图像处理中常用的采用模型是RGB（红，绿，蓝）模型和HSV（色调，饱和度，亮度），RGB广泛应用于彩色监视器和彩色视频摄像机，我们平时的图片一般都是RGB模型。而HSV模型更符合人描述和解释颜色的方式，HSV的彩色描述对人来说是自然且非常直观的。HSV模型HSV模型中颜色的参数分别是：色调（H：hue），饱和度（S：saturation），亮度（V：value）。由A. R. Smith
C++ | 基于C++的OpenCV图像处理 Image Processing
weixin_44649780的博客
10-12 3272
1.照片上的一个像素是p,那么p[x]指的就是p的动态数组（dynamic array），p[a][b]指的就是动作位置空间。
opencv+色偏检测
twinkle_star1314的博客
07-07 1796
// sepiancheck.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "cv.h"   #include "highgui.h"   #include "iostream"   #include "math.h"   using namespace cv; /*****
c++opencv视频运动目标检测帧差法
01-28
帧差法是通过比较连续视频帧之间的差异来检测运动目标。实现帧差法的步骤如下： 1. 读取视频：首先，使用OpenCV库中的视频读取函数从视频文件中逐帧读取视频。 2. 预处理：对于读取的每一帧图像，可以进行一些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值