C++_2019-04-28_机器视觉——Opencv——基于轮廓匹配

最新推荐文章于 2023-12-18 18:16:20 发布
最新推荐文章于 2023-12-18 18:16:20 发布
阅读量1.8k 收藏 25
点赞数 5
分类专栏： # 机器视觉_应用工程 机器视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41275726/article/details/89645477
版权 
/*
Hu轮廓匹配：
#include "Opencv_MatchShape.h"
#include "Match_Shape_NCC.h"

int main(int argc, char* argv)
{

Opencv_MatchShape demo;
demo.MatchShape_HU();
system("pause");
return 0;
}

*/
#include <iostream>
#include <time.h>

#include <opencv/cxcore.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace cv;
using namespace std;




class Opencv_MatchShape
{
public:
	Opencv_MatchShape();
	~Opencv_MatchShape();

	// 
	void MatchShape_test1();// 轮廓寻找

	// 
	struct ptin
	{
		int DerivativeX;
		int DerivativeY;
		double Magnitude;
		double MagnitudeN;
	}ptin;



	void MatchShape_test2();

	void MatchShape_HU();/* 对比两张图的形状是 否相似越小越相近 */

private:

};

Opencv_MatchShape::Opencv_MatchShape()
{
}

Opencv_MatchShape::~Opencv_MatchShape()
{
}

void Opencv_MatchShape::MatchShape_test1()
{
	//***********************计算时间************************************************
	
	double total_time = 0;
	clock_t start_time = clock();
	clock_t stop_time = clock();
	total_time = double(stop_time - start_time) / CLOCKS_PER_SEC;
	
	//***********************************************************************

	char* param="./Resource/Search1.jpg";
	Mat searchImage = imread(param, 1);
	if (searchImage.empty())
	{
		return;
	}
	imshow("searchImage", searchImage);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配__SearchImage灰度化****************************
	
	Mat graySearchImg = cvCreateMat(searchImage.rows, searchImage.cols, CV_8UC1);
	if (searchImage.channels() == 3)
		cvtColor(searchImage, graySearchImg, CV_RGB2GRAY);
	else
	{
		searchImage.copyTo(graySearchImg);
	}
	imshow("graySearchImg", graySearchImg);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配__SearchImage二值化****************************
	/*
	//! type of the threshold operation
	enum { THRESH_BINARY=CV_THRESH_BINARY, THRESH_BINARY_INV=CV_THRESH_BINARY_INV,
		   THRESH_TRUNC=CV_THRESH_TRUNC, THRESH_TOZERO=CV_THRESH_TOZERO,
		   THRESH_TOZERO_INV=CV_THRESH_TOZERO_INV, THRESH_MASK=CV_THRESH_MASK,
		   THRESH_OTSU=CV_THRESH_OTSU };
	*/
	Mat dst_bw;
	threshold(graySearchImg, dst_bw, 20, 255, CV_THRESH_OTSU);	
	imshow("dst_bw", dst_bw);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配__SearchImage边缘检测****************************
	Mat edge;
	Canny(dst_bw, edge, 125, 350);
	imshow("dst_edge", edge);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配_SearchImage'Contours****************************
	/*
	https://docs.opencv.org/2.4/doc/tutorials/imgproc/shapedescriptors/find_contours/find_contours.html
	*/
	/*
	## mode:(定义轮廓的检索模式)
	CV_RETR_EXTERNAL	只检测最外围轮廓，包含在外围轮廓内的内围轮廓将被忽略
	CV_RETR_LIST		检测所有的轮廓，包括内围、外围轮廓，但是检测到的轮廓不建立等级关系，彼此之间独立
	CV_RETR_CCOMP		检测所有的轮廓，但所有的轮廓只建立两个等级关系
	CV_RETR_TREE		检测所有轮廓，所有轮廓建立一个等级树结构

	## method:(定义轮廓的近似方法)
	CV_CHAIN_APPROX_NONE	存储所有的轮廓点
	CV_CHAIN_APPROX_SIMPLE	压缩水平垂直对角等
	CV_CHAIN_APPROX_TC89_L1	近似算法
	*/
	vector<vector<Point>> contours;
	vector<Vec4i> hierarchy;
	findContours(edge, contours, CV_RETR_TREE, CV_CHAIN_APPROX_NONE); //找轮廓
	/// Draw contours
	RNG rng(12345);
	Mat drawing = Mat::zeros(edge.size(), CV_8UC3);
	for (int i = 0; i< contours.size(); i++)
	{
		Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		drawContours(drawing, contours, i, color, 2, 8, hierarchy, 0, Point());
	}
	/// Show in a window
	namedWindow("Contours", CV_WINDOW_AUTOSIZE);
	imshow("Contours", drawing);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配_模板TemplatImage轮廓****************************
	char* param_template = "./Resource/Template.jpg";
	Mat TemplateImage = imread(param_template, 1);
	if (TemplateImage.empty())
	{
		return;
	}
	imshow("Template", TemplateImage);
	waitKey(0);

	//
	Mat grayTemplateImg = cvCreateMat(TemplateImage.rows, TemplateImage.cols, CV_8UC1);
	if (TemplateImage.channels() == 3)
		cvtColor(TemplateImage, grayTemplateImg, CV_RGB2GRAY);
	else
	{
		TemplateImage.copyTo(grayTemplateImg);
	}
	imshow("grayTemplateImg", grayTemplateImg);
	waitKey(0);

	//***********************Opencv自带的轮廓匹配_模板TemplatImage轮廓****************************
	Mat dst_template_bw;
	threshold(grayTemplateImg, dst_template_bw, 0, 255, CV_THRESH_OTSU);
	imshow("dst_template_bw", dst_template_bw);
	waitKey(0);

	/*
	## mode:(定义轮廓的检索模式)
		CV_RETR_EXTERNAL	只检测最外围轮廓，包含在外围轮廓内的内围轮廓将被忽略
		CV_RETR_LIST		检测所有的轮廓，包括内围、外围轮廓，但是检测到的轮廓不建立等级关系，彼此之间独立
		CV_RETR_CCOMP		检测所有的轮廓，但所有的轮廓只建立两个等级关系
		CV_RETR_TREE		检测所有轮廓，所有轮廓建立一个等级树结构
	
	## method:(定义轮廓的近似方法)
		CV_CHAIN_APPROX_NONE	存储所有的轮廓点
		CV_CHAIN_APPROX_SIMPLE	压缩水平垂直对角等
		CV_CHAIN_APPROX_TC89_L1	近似算法
	*/
	//***********************Opencv自带的轮廓匹配_模板TemplatImage边缘检测****************************
	Mat template_edge;
	Canny(dst_template_bw, template_edge, 125, 350);
	imshow("template_edge", template_edge);
	waitKey(0);
	//

	vector<vector<Point>> contours_template;
	vector<Vec4i> hierarchy_template;
	findContours(template_edge, contours_template, hierarchy_template, CV_RETR_TREE, CV_CHAIN_APPROX_NONE); //找轮廓

	/// Draw contours
	RNG rng_template(12345);
	Mat drawing_template = Mat::zeros(template_edge.size(), CV_8UC3);
	for (int i = 0; i< contours_template.size(); i++)
	{
		Scalar color = Scalar(rng_template.uniform(0, 255), rng_template.uniform(0, 255), rng_template.uniform(0, 255));
		drawContours(drawing_template, contours_template, i, color, 2, 8, hierarchy_template, 0, Point());

	}
	/// Show in a window
	namedWindow("Contours_Template", CV_WINDOW_AUTOSIZE);
	imshow("Contours_Template", drawing_template);
	waitKey(0);
	system("pause");

}

void Opencv_MatchShape::MatchShape_test2()
{
	char* param = "./Resource/Template.jpg";
	Mat src = imread(param, 1);

	if (src.empty())
	{
		return;
	}

	Mat gray;
	cvtColor(src, gray, CV_RGB2GRAY);
	if (gray.type() != CV_8UC1)
	{
		return;
	}
	imshow("gray", gray);
	waitKey(0);

	Mat bw;
	threshold(gray, bw, 20, 255, CV_THRESH_OTSU);
	imshow("bw", bw);
	waitKey(0);

	Mat edge;
	Canny(bw, edge, 125, 350);
	imshow("dst_edge", edge);
	waitKey(0);

	vector<vector<Point>> contours;
	vector<Vec4i> hierarchy;
	findContours(edge, contours, CV_RETR_TREE, CV_CHAIN_APPROX_NONE); //找轮廓

	Mat gx, gy;
	Sobel(gray, gx, CV_32F, 1, 0);
	Sobel(gray, gy, CV_32F, 0, 1);

	Mat magnitude, direction;
	cartToPolar(gx, gy, magnitude, direction);
	long contoursLength = 0;
	double magnitudeTemp = 0;
	int originx = contours[0][0].x;
	int originy = contours[0][0].y;

	typedef struct my
	{
		int DerivativeX;
		int DerivativeY;
		double Magnitude;
		double MagnitudeN;
	}ptin;
	// 提取dx\dy\mag\log信息	
	vector<vector<ptin>> contoursInfo;
	// 提取相对坐标位置
	vector<vector<Point>> contoursRelative;

	// 开始提取
	for (int i = 0; i < contours.size(); i++) {
		int n = contours[i].size();
		contoursLength += n;
		contoursInfo.push_back(vector<ptin>(n));
		vector<Point> points(n);
		for (int j = 0; j < n; j++) {
			int x = contours[i][j].x;
			int y = contours[i][j].y;
			points[j].x = x - originx;
			points[j].y = y - originy;
			ptin pointInfo;
			pointInfo.DerivativeX = gx.at<float>(y, x);
			pointInfo.DerivativeY = gy.at<float>(y, x);
			magnitudeTemp = magnitude.at<float>(y, x);
			pointInfo.Magnitude = magnitudeTemp;
			if (magnitudeTemp != 0)
				pointInfo.MagnitudeN = 1 / magnitudeTemp;
			contoursInfo[i][j] = pointInfo;
		}
		contoursRelative.push_back(points);
	}


	// 计算目标图像梯度
	char* param1 = "./Resource/Search2.jpg";
	Mat src_search = imread(param1, 1);
	Mat grayImage;
	if (src_search.empty())
	{
		cout << "空" << endl;
		return;
	}	
	if (src_search.channels() == 3)
	{
		cvtColor(src_search, grayImage, CV_RGB2GRAY);
	}
	else
	{
		src_search.copyTo(grayImage);
	}
	if (grayImage.type() != CV_8UC1)
	{
		cout << "!CV_8UC1" << endl;
		return;
	}
	Mat gradx, grady;
	Sobel(grayImage, gradx, CV_32F, 1, 0);
	Sobel(grayImage, grady, CV_32F, 0, 1);
	

	Mat mag, angle;
	cartToPolar(gradx, grady, mag, angle);


	// NCC模板匹配
	double minScore = 0.7;		//deafult value
	double greediness = 0.8;		//deafult value
	double nGreediness = 0.8;		//deafult value
	double nMinScore = 0.7;		//deafult value

	double partialScore = 0;
	double resultScore = 0;
	int resultX = 0;
	int resultY = 0;
	double start = (double)getTickCount();
	for (int row = 0; row < grayImage.rows; row++) 
	{
		for (int col = 0; col < grayImage.cols; col++) {
			double sum = 0;
			long num = 0;
			for (int m = 0; m < contoursRelative.size(); m++) {
				for (int n = 0; n < contoursRelative[m].size(); n++) {
					num += 1;
					int curX = col + contoursRelative[m][n].x;
					int curY = row + contoursRelative[m][n].y;
					if (curX < 0 || curY < 0 || curX > grayImage.cols - 1 || curY > grayImage.rows - 1) {
						continue;
					}

					// 目标边缘梯度
					double sdx = gradx.at<float>(curY, curX);
					double sdy = grady.at<float>(curY, curX);

					// 模板边缘梯度
					double tdx = contoursInfo[m][n].DerivativeX;
					double tdy = contoursInfo[m][n].DerivativeY;

					// 计算匹配
					if ((sdy != 0 || sdx != 0) && (tdx != 0 || tdy != 0))
					{
						double nMagnitude = mag.at<float>(curY, curX);
						if (nMagnitude != 0)
							sum += (sdx * tdx + sdy * tdy) * contoursInfo[m][n].MagnitudeN / nMagnitude;
					}

					// 任意节点score之和必须大于最小阈值
					partialScore = sum / num;
					if (partialScore < min((minScore - 1) + (nGreediness * num), nMinScore * num))
						break;
				}
			}

			// 保存匹配起始点
			if (partialScore > resultScore)
			{
				resultScore = partialScore;
				resultX = col;
				resultY = row;
			} 
		}
	}
	cout << resultY << endl;
	cout << resultX << endl;
	CvPoint point;
	point.x = resultX;
	point.y = resultY;
	circle(src_search, point, 10, Scalar(255, 255, 255), 8);
	imshow("src", src_search);
	waitKey(0);

}

/* 对比两张图的形状是 否相似越小越相近 */
void Opencv_MatchShape::MatchShape_HU()
{
	cv::Mat src_template, hsv_base;
	cv::Mat src_search, hsv_test1;

	src_template = imread("./Resource/a.jpg");//模板
	src_search = imread("./Resource/b.jpg");//待测图
	int thresh = 100;
	double ans = 0, result = 0;

	Mat imageresult1, imageresult2;

	if (src_template.type() == CV_8UC3)
	{
		cvtColor(src_template, imageresult1, CV_RGB2GRAY);
		cvtColor(src_search, imageresult2, CV_RGB2GRAY);
	}
	else
	{
		src_template.copyTo(imageresult1);
		src_search.copyTo(imageresult2);
	}

	blur(imageresult1, imageresult1, Size(3, 3));
	blur(imageresult2, imageresult2, Size(3, 3));

	threshold(imageresult1, hsv_base, 20, 255, CV_THRESH_OTSU);
	threshold(imageresult2, hsv_test1, 20, 255, CV_THRESH_OTSU);	

	Canny(hsv_base, imageresult1, thresh, thresh * 2);
	Canny(hsv_test1, imageresult2, thresh, thresh * 2);	

	std::vector<std::vector<cv::Point>>contours1, contours2;
	std::vector<Vec4i>hierarchy1, hierarchy2;
	CvSize Ssize;
	Ssize.height = src_template.rows;;
	Ssize.width = src_template.cols;
	Mat drawing1(Ssize, CV_8UC3, Scalar(0, 0, 0));
	findContours(imageresult1, contours1, hierarchy1, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));
	RNG rng(12345);
	int T_w, T_h;
	for (int i = 0; i<contours1.size(); i++)
	{
		Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		drawContours(drawing1, contours1, i, color, 1, 8, hierarchy1, 0, cv::Point());

		Rect boundRect = boundingRect(contours1[i]);//检测外轮廓//对外轮廓加加矩形框  ——不带旋转		
		rectangle(drawing1, boundRect, Scalar(0, 255, 0), 3);

		RotatedRect box = minAreaRect(Mat(contours1[i]));
		Point2f rect[4];
		box.points(rect);  //把最小外接矩形四个端点复制给rect数组
		for (int j = 0; j<4; j++)
		{
			line(drawing1, rect[j], rect[(j + 1) % 4], Scalar(0, 255, 0), 2, 8);  //绘制最小外接矩形每条边
		}
		if (box.size.height>box.size.width)
		{
			T_w = box.size.height;
			T_h = box.size.width;
		}
		else
		{
			T_h = box.size.height;
			T_w = box.size.width;
		}
		cout << T_w << endl<< T_h << endl;

	}
	namedWindow("imageresult2", 0);
	imshow("imageresult1", drawing1);
	
	CvSize Ssize2;
	Ssize2.height = src_search.rows;;
	Ssize2.width = src_search.cols;
	Mat drawing2(Ssize2, CV_8UC3, Scalar(0, 0, 0));;
	findContours(imageresult2, contours2, hierarchy2, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE, cvPoint(0, 0));
	vector<Rect> boundRect(contours2.size());//包围矩形框
	vector<RotatedRect> box(contours2.size());
	for (int i = 0; i<contours2.size(); i++)
	{
		Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		drawContours(drawing2, contours2, i, color, 1, 8, hierarchy2, 0, cv::Point());
		
		boundRect[i] = boundingRect(contours2[i]);//检测外轮廓//对外轮廓加加矩形框  		
		rectangle(drawing2, boundRect[i], Scalar(0, 0, 255), 3);

		box[i] = minAreaRect(Mat(contours2[i]));
		Point2f rect[4];
		box[i].points(rect);  //把最小外接矩形四个端点复制给rect数组
		for (int j = 0; j<4; j++)
		{
			line(drawing2, rect[j], rect[(j + 1) % 4], Scalar(0, 255, 0), 2, 8);  //绘制最小外接矩形每条边
		}
	}	

	std::cout << "contours1.size()的值"<<contours1.size() << endl;
	int k = 0;
	
	for (int i = 0; i<contours1.size(); i++)
	{
		for (size_t j = 0; j < contours2.size(); j++)
		{			 
			ans = matchShapes(contours1[i], contours2[j], CV_CONTOURS_MATCH_I1, 0);
			k = j;
			std::cout << "第" << i << " 和 " << k << "的匹配值：" << ans << " " << endl;
		
			// string
			/*匹配值*/
			string label;
			stringstream stream;
			stream << (float)ans;
			/*角度*/
			//stream << ",";
			//stream << box[j].angle;			
			stream >> label;
			
			// 
			cout << box[j].size.width<< endl;
			cout << box[j].size.height << endl;
			float temp_size,w,h;
			if (box[j].size.width < box[j].size.height)
			{
				h = box[j].size.width;
				w = box[j].size.height;
			}
			else
			{
				w = box[j].size.width;
				h = box[j].size.height;
			}
			cout << w << endl;
			cout << h << endl;
			//筛选最接近尺寸的形状-长和宽的比较
			/*int T = 15;
			if (sqrt(abs((w - T_w)*(w - T_w) + (h - T_h)*(h - T_h))) < T)
			{
				putText(drawing2, label, Point(box[j].center.x, box[j].center.y), CV_FONT_BLACK, 1, Scalar(0, 255, 0), 2);
			}*/
			putText(drawing2, label, Point(box[j].center.x, box[j].center.y), CV_FONT_BLACK, 1, Scalar(0, 255, 0), 2);
		}			
	}
	namedWindow("imageresult2", 0);
	imshow("imageresult2", drawing2);
	waitKey(0);
}

 

智能之心
关注
专栏目录
【全网独家】OpenCV C++ 图像处理实战：基于NCC多角度多目标匹配（代码+测试部署）
走向CTO的路上...
08-17 439
基于归一化互相关（Normalized Cross-Correlation, NCC）的方法进行多角度多目标匹配是一种常用的图像匹配技术。该方法可以在不同角度和尺度下，准确地找到图像中的多个目标对象，广泛应用于机器人视觉导航、工业检测、图像识别等领域。基于NCC的多角度多目标匹配技术，通过对模板图像进行多角度、多尺度变换，可以有效解决目标在不同视角和尺度下的匹配问题，具有较高的鲁棒性和适应性。但在实际应用中，可能需要结合其他特征提取方法（如SIFT、SURF等）提高匹配稳定性和准确性。
OpenCV-Python实战（1）——OpenCV简介与图像处理基础
热门推荐
盼小辉丶的博客
08-10 22万+
OpenCV 是一个的跨平台计算机视觉库，可以运行在 Linux、Windows 和 Mac OS 操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时也提供了 Python 接口，实现了图像处理和计算机视觉方面的很多通用算法。在本文中，将介绍 OpenCV 库，包括它的主要模块和典型应用场景，同时使用 OpenCV-Python 实战讲解图像处理基础要点。
基于轮廓匹配算法OpenCV
05-05
基于网上整理出来方便大家使用，基于轮廓匹配的程序执行档，已加入Opencv dll 可直接运行
opencv c++ 轮廓匹配
lucust的博客
12-03 1685
a）几何计算公式： p、q为阶数，当p+q = 1时，几何矩为一阶矩，p+q = 2，几何矩为二阶矩，依次类推。。因此，对于二值图像有： 所有前景像素的x坐标之和： 所有前景像素的y坐标之和： 所有前景像素的个数： 注：前景像素为像素值为对应类型的满像素值的像素。b）几何中心矩计算公式 Hu矩计算公式： 性质：Hu矩具有放缩不变性，旋转不变性。
OpenCV C++案例实战八《基于Hu矩轮廓匹配》
Zero___Chen的博客
12-18 6115
OpenCV C++案例实战八《基于Hu矩轮廓匹配》前言一、查找轮廓二、计算Hu矩三、显示效果四、源码总结 前言 本文将使用OpenCV C++ 基于Hu矩进行轮廓匹配。 一、查找轮廓 原图 测试图 vector<vector<Point>>findContour(Mat Image) { Mat gray; cvtColor(Image, gray, COLOR_BGR2GRAY); Mat thresh; threshold(gray, thresh, 0, 25
机器视觉（一）2D形状匹配
14号先生的博客
11-08 4330
在2D的机器视觉应用中，模板匹配比较常见， 常见的匹配算法有基于灰度的匹配，基于边缘的匹配，基于形状的匹配等。推荐《机器视觉算法与应用》这本书，这本书是halcon开发人员撰写，对于模板匹配介绍的比较详细。下面介绍基于形状的模板匹配。 在pcl和opencv中都有关于linemod的实现。本算法是基于linemod的2D版本，主要从opencv的源码修改。 1 算法的基本流程如下： (1)...
OpenCV——CvMatchShapes函数
weixin_34238633的博客
10-27 1258
功能：根据计算比较两张图像Hu不变距（函数返回值代表相似度大小，完全相同的图像返回值是0，返回值最大是1） double cvMatchShapes(const void* object1, const void* object2, int method, double parameter = 0); ...
OpenCV实战（1）——OpenCV与图像处理基础
盼小辉丶的博客
10-24 6万+
OpenCV 是一个跨平台计算机视觉和机器学习库，实现了图像处理和计算机视觉方面的很多通用算法。本节将介绍 OpenCV 的基础知识，以及如何编译运行 OpenCV 程序，并介绍如何完成最基本的图像处理任务——读取、显示和保存图像。除此之外，鼠标事件和图形绘制也是 OpenCV 计算机视觉项目中常用的基本功能，本节介绍了如何使用这两个重要的 OpenCV 功能。
OpenCV实战（15）——轮廓检测详解
盼小辉丶的博客
03-22 7690
在计算机视觉领域，轮廓通常指图像中对象边界的一系列点。因此，轮廓通常描述了对象边界的关键信息，包含了有关对象形状的主要信息，该信息可用于形状分析与对象检测和识别。本节中，我们首先介绍如何提取图像中轮廓，然后讲解如何计算轮廓的形状描述符。
Learning_OpenCV_Second_Edition-C++
05-08
《Learning OpenCV 第二版》是一本专注于C++编程的计算机视觉库——OpenCV的教程。这本书涵盖了OpenCV的基础知识到高级应用，是学习和掌握OpenCV的重要参考资料。以下是根据书名和描述提取的一些关键知识点： 1. **...
OpenCV实战（2）——OpenCV核心数据结构
盼小辉丶的博客
11-16 4万+
cv::Mat 类是用于保存图像(以及其他矩阵数据)的数据结构，该数据结构是所有 OpenCV 类和函数的核心，这是 OpenCV 库的一个关键元素，用于处理图像和矩阵(从计算和数学的角度来看，图像本质上是一个矩阵)，同时 cv::Mat 数据结构结合了优雅的内存管理机制，因此，使用起来十分高效。本节中，我们介绍了 cv::Mat 结构的基本用法，并且深入探索了创建 cv::Mat 数据结构时的内存分配方式。
轮廓匹配算法
06-01
一个可以实现图像中多个轮廓一一匹配的算法
opencv3/C++轮廓的提取与筛选方式
12-23
轮廓提取 findContours发现轮廓 findContours( InputOutputArray binImg, //输入8bit图像，0值像素值不变，非0的像素看成1；（变为二值图像） OutputArrayOfArrays contours,//输出找到的轮廓对象 OutputArray, hierachy// 图像的拓扑结构 int mode, //轮廓返回的模式(RETR_TREE等) int method,//发现方法(CHAIN_APPROX_SIMPLE等) Point offset=Point()//轮廓像素的位移（默认没有位移（0, 0）） ) 【报错问题】 f
cvMatchShapes例子
01-18
介绍如何使用OpenCV中的CvMatchShapes的使用的例程，具体参见：http://blog.csdn.net/xizero00/article/details/7448070
Opencv-（35）轮廓匹配
qq_51325797的博客
03-14 5021
轮廓匹配 基本原理 根据图形的几何矩和Hu矩计算图像的轮廓是否匹配 图像几何矩和Hu矩 代码演示 #include<opencv2/opencv.hpp> #include<iostream> using namespace cv; using namespace std; void contour_info(Mat& image, vector<vector<Point>>& contours); int main() { Mat src
一步一步实现多尺度多角度的形状匹配算法(C++版本)
楷尘·极客
11-20 2万+
前言 用过halcon形状匹配的都知道，这个算子贼好用，随便截一个ROI做模板就可以在搜索图像中匹配到相似的区域，并且能输出搜索图像的位置，匹配尺度，匹配角度。现在我们就要利用opencv在C++的环境下复现这个效果。 我们先看下复现的效果图，提升下学习的欲望(要在搜索图像中找到所有的K字母)。 下图是模板图像，为一个"K"字母。 下图是待搜索的图像，其中的K字符存在旋转，缩放，残缺遮...
【OpenCV】OpenCV-Python/C++实现简单物体轮廓的识别
Quentin的博客
08-27 2175
要求： 识别orange.jpg中的橙子。要求OpenCV内置函数中所有数字形式的参数随机上下波动10%以内不影响识别。 orange.jpg Python实现 import cv2 as cv import matplotlib.pyplot as plt # 打开图像 filename = './orange.jpg' image = cv.imread(filename) # 将BGR格式转成HSV格式 HSV = cv.cvtColor(image, cv.COLOR_...
[C++] opencv - findContours(查找轮廓)函数介绍和使用场景
最新发布
老狼工作室的博客
12-18 5322
OpenCV中的findContours函数可以在二值图像中检测轮廓，非常适用于计算机视觉任务。通过查找轮廓，我们可以提取出图像中的连续区域，从而进行目标检测、图像分割等操作。
opencv形状匹配（cv2.matchShape）
qq_40107571的博客
12-11 3244
opencv形状匹配（cv2.matchShape）
Ubuntu 18.04 安装 OpenCV-3.4.3及opencv_contrib-3.4.3详细步骤
然后，将opencv_contrib-3.4.3文件夹重命名为opencv_contrib，移动到opencv-3.4.3的目录下，这样可以方便后续的配置和编译步骤。 在进行编译前，确保你的系统已经安装了所有必要的依赖库。对于Ubuntu 18.04，这通常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

智能之心

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值