图像处理（十）——特征检测与匹配

已于 2022-11-27 10:14:40 修改
阅读量3.2k 收藏 16
点赞数 2
分类专栏： 图像处理 南木的下午茶 文章标签： 图像处理
于 2018-12-06 18:40:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Godsolve/article/details/84863017
版权

文章目录

内容：

• 了解OpenCV中实现的SIFT, SURF, ORB等特征检测器的用法，并进行实验。将检测到的特征点用不同大小的圆表示，比较不同方法的效率、效果等。
• 了解OpenCV的特征匹配方法，并进行实验。

SIFT：

SIFT算法的过程实质是在不同尺度空间上查找特征点（关键点），用128维方向向量的方式对特征点进行描述，最后通过对比描述向量实现目标匹配。
概括起来主要有三大步骤：

1、 提取关键点；
在这里插入图片描述
2、 对关键点附加详细的信息（局部特征）也就是所谓的描述器；
在这里插入图片描述
3、 通过两方特征点（附带上特征向量的关键点）的两两比较找出相互匹配的若干对特征点，建立物体间的对应关系。
在这里插入图片描述

运行结果为：
在这里插入图片描述

SURF：

Opencv中Surf算子提取特征，生成特征描述子，匹配特征的流程跟Sift是完全一致的。
这里要着重说一下绘制使用的drawKeypoints方法：
void drawKeypoints( const Mat& image, const vector& keypoints, CV_OUT Mat& outImage, const Scalar& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT );

第一个参数image：原始图像，可以使三通道或单通道图像；
第二个参数keypoints：特征点向量，向量内每一个元素是一个
KeyPoint对象，包含了特征点的各种属性信息；
第三个参数outImage：特征点绘制的画布图像，可以是原图像；
第四个参数color：绘制的特征点的颜色信息，默认绘制的是随机彩色；
第五个参数flags：特征点的绘制模式，其实就是设置特征点的那些信息需要绘制，那些不需要绘制。
而在进行特征点匹配时，当仅使用筛选出的最优匹配点进行匹配的时候，意味着会有很多非最优的特征点不会被匹配，这时候可以设置flags=DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ，意味着那些不是最优特征点的点不会被绘制出来。

ORB：

ORB - (Oriented Fast and Rotated BRIEF)算法是基于FAST特征检测与BRIEF特征描述子匹配实现，相比BRIEF算法中依靠随机方式获取二值点对，ORB通过FAST方法，FAST方式寻找候选特征点方式是假设灰度图像像素点A周围的像素存在连续大于或者小于A的灰度值，选择任意一个像素点P，假设半径为3，周围16个像素表示如下：
在这里插入图片描述
假设存在连续N个点满足
在这里插入图片描述
则像素点P被标记为候选特征点、通常N取值为9、12，上图N=9。 为了简化计算，我们可以只计算1、9、5、13四个点，至少其中三个点满足上述不等式条件，即可将P视为候选点。

ORB比BRIEF方式更加合理，同时具有旋转不变性特征与噪声抑制效果，ORB实现选择不变性特征，是通过对BRIEF描述子的特征点区域的计算得到角度方向参数。

完整的ORB特征描述子算法流程图如下：

在这里插入图片描述

运行结果：在这里插入图片描述
此外，需要注意的是在使用这些方法之前，要对opencv进行扩展，使其能够调用nonfree.hpp、legacy.hpp以及features2d.hpp，而扩展方法是使用cmake对从官网上下载的扩展包进行安装，具体教程参见
https://blog.csdn.net/streamchuanxi/article/details/51044929

代码

// CVE9sift.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include "highgui/highgui.hpp"
//#include "opencv2/nonfree/nonfree.hpp"
//#include "opencv2/legacy/legacy.hpp"

using namespace cv;
using namespace std;

//SIFT算法
int main(int argc, char *argv[])
{
	Mat image01 = imread(argv[1]);
	Mat image02 = imread(argv[2]);
	Mat image1, image2;
	GaussianBlur(image01, image1, Size(3, 3), 0.5);
	GaussianBlur(image02, image2, Size(3, 3), 0.5);

	//提取特征点
	SiftFeatureDetector siftDetector(30);  //限定提起前15个特征点
	vector<KeyPoint> keyPoint1, keyPoint2;
	siftDetector.detect(image1, keyPoint1);
	siftDetector.detect(image2, keyPoint2);

	//绘制特征点
	drawKeypoints(image1, keyPoint1, image1, Scalar::all(-1), DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
	drawKeypoints(image2, keyPoint2, image2, Scalar::all(-1), DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
	namedWindow("KeyPoints of image1", 0);
	namedWindow("KeyPoints of image2", 0);

	imshow("KeyPoints of image1", image1);
	imshow("KeyPoints of image2", image2);

	//特征点描述，为下边的特征点匹配做准备
	SiftDescriptorExtractor siftDescriptor;
	Mat imageDesc1, imageDesc2;
	siftDescriptor.compute(image1, keyPoint1, imageDesc1);
	siftDescriptor.compute(image2, keyPoint2, imageDesc2);

	//特征点匹配并显示匹配结果
	BruteForceMatcher<L2<float>> matcher;
	vector<DMatch> matchePoints;
	matcher.match(imageDesc1, imageDesc2, matchePoints, Mat());
	Mat imageOutput;
	drawMatches(image01, keyPoint1, image02, keyPoint2, matchePoints, imageOutput);
	namedWindow("Mathch Points", 0);
	imshow("Mathch Points", imageOutput);
	waitKey();
	return 0;
}
//SURF算法

int main(int argc, char *argv[])
{
	Mat image01 = imread(argv[1]);
	Mat image02 = imread(argv[2]);
	Mat image1, image2;
	image1 = image01.clone();
	image2 = image02.clone();

	//提取特征点  
	SurfFeatureDetector surfDetector(4000);  //hessianThreshold,海塞矩阵阈值，并不是限定特征点的个数 
	vector<KeyPoint> keyPoint1, keyPoint2;
	surfDetector.detect(image1, keyPoint1);
	surfDetector.detect(image2, keyPoint2);

	//绘制特征点  
	drawKeypoints(image1, keyPoint1, image1, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
	drawKeypoints(image2, keyPoint2, image2, Scalar::all(-1), DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
	imshow("KeyPoints of image1", image1);
	imshow("KeyPoints of image2", image2);

	//特征点描述，为下边的特征点匹配做准备  
	SurfDescriptorExtractor SurfDescriptor;
	Mat imageDesc1, imageDesc2;
	SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
	SurfDescriptor.compute(image2, keyPoint2, imageDesc2);

	//特征点匹配并显示匹配结果  
	//BruteForceMatcher<L2<float>> matcher;  
	FlannBasedMatcher matcher;
	vector<DMatch> matchePoints;
	matcher.match(imageDesc1, imageDesc2, matchePoints, Mat());

	//提取强特征点
	double minMatch = 1;
	double maxMatch = 0;
	for (int i = 0; i < matchePoints.size(); i++)
	{
		//匹配值最大最小值获取
		minMatch = minMatch > matchePoints[i].distance ? matchePoints[i].distance : minMatch;
		maxMatch = maxMatch < matchePoints[i].distance ? matchePoints[i].distance : maxMatch;
	}
	//最大最小值输出
	cout << "最佳匹配值是： " << minMatch << endl;
	cout << "最差匹配值是： " << maxMatch << endl;

	//获取排在前边的几个最优匹配结果
	vector<DMatch> goodMatchePoints;
	for (int i = 0; i < matchePoints.size(); i++)
	{
		if (matchePoints[i].distance < minMatch + (maxMatch - minMatch) / 2)
		{
			goodMatchePoints.push_back(matchePoints[i]);
		}
	}

	//绘制最优匹配点
	Mat imageOutput;
	drawMatches(image01, keyPoint1, image02, keyPoint2, goodMatchePoints, imageOutput, Scalar::all(-1),
		Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	imshow("Mathch Points", imageOutput);
	waitKey();
	return 0;
}

//ORB

#include <iostream>
#include <fstream>
#include <sstream>

#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;

void KeyPointsToPoints(vector<KeyPoint> kpts, vector<Point2f> &pts);

bool refineMatchesWithHomography(
	const std::vector<cv::KeyPoint>& queryKeypoints,
	const std::vector<cv::KeyPoint>& trainKeypoints,
	float reprojectionThreshold, std::vector<cv::DMatch>& matches,
	cv::Mat& homography);

/** @function main */
/*int main(int argc, char* argv[]) {

	/************************************************************************/
	/* 特征点检测，特征提取，特征匹配，计算投影变换                            */
	/************************************************************************/

	// 读取图片
	Mat img1Ori = imread("1.jpg", 0);
	Mat img2Ori = imread("2.jpg", 0);

	// 缩小尺度
	Mat img1, img2;
	resize(img1Ori, img1, Size(img1Ori.cols / 4, img1Ori.cols / 4));
	resize(img2Ori, img2, Size(img2Ori.cols / 4, img2Ori.cols / 4));

	cv::Ptr<cv::FeatureDetector> detector = new cv::ORB(1000);						// 创建orb特征点检测
	cv::Ptr<cv::DescriptorExtractor> extractor = new cv::FREAK(true, true);			// 用Freak特征来描述特征点
	cv::Ptr<cv::DescriptorMatcher> matcher = new cv::BFMatcher(cv::NORM_HAMMING,	// 特征匹配，计算Hamming距离
		true);

	vector<KeyPoint> keypoints1;	// 用于保存图中的特征点	
	vector<KeyPoint> keypoints2;
	Mat descriptors1;				// 用于保存图中的特征点的特征描述
	Mat descriptors2;

	detector->detect(img1, keypoints1);		// 检测第一张图中的特征点
	detector->detect(img2, keypoints2);

	extractor->compute(img1, keypoints1, descriptors1);		// 计算图中特征点位置的特征描述
	extractor->compute(img2, keypoints2, descriptors2);

	vector<DMatch> matches;
	matcher->match(descriptors1, descriptors2, matches);

	Mat imResultOri;
	drawMatches(img1, keypoints1, img2, keypoints2, matches, imResultOri,
		CV_RGB(0, 255, 0), CV_RGB(0, 255, 0));
	cout << "[Info] # of matches : " << matches.size() << endl;

	Mat matHomo;
	refineMatchesWithHomography(keypoints1, keypoints2, 3, matches, matHomo);
	cout << "[Info] Homography T : " << matHomo << endl;
	cout << "[Info] # of matches : " << matches.size() << endl;

	Mat imResult;
	drawMatches(img1, keypoints1, img2, keypoints2, matches, imResult,
		CV_RGB(0, 255, 0), CV_RGB(0, 255, 0));

	// 计算光流
	vector<uchar> vstatus;
	vector<float> verrs;
	vector<Point2f> points1;
	vector<Point2f> points2;
	KeyPointsToPoints(keypoints1, points1);

	calcOpticalFlowPyrLK(img1, img2, points1, points2, vstatus, verrs);

	Mat imOFKL = img1.clone();
	for (int i = 0; i < vstatus.size(); i++) {
		if (vstatus[i] && verrs[i] < 15) {
			line(imOFKL, points1[i], points2[i], CV_RGB(255, 255, 255), 1, 8, 0);
			circle(imOFKL, points2[i], 3, CV_RGB(255, 255, 255), 1, 8, 0);
		}
	}


	imwrite("opt.jpg", imOFKL);
	imwrite("re1.jpg", imResultOri);
	imwrite("re2.jpg", imResult);

	imshow("Optical Flow", imOFKL);
	imshow("origin matches", imResultOri);
	imshow("refined matches", imResult);
	waitKey();

	return -1;
}

bool refineMatchesWithHomography(
	const std::vector<cv::KeyPoint>& queryKeypoints,
	const std::vector<cv::KeyPoint>& trainKeypoints,
	float reprojectionThreshold, std::vector<cv::DMatch>& matches,
	cv::Mat& homography) {
	const int minNumberMatchesAllowed = 8;

	if (matches.size() < minNumberMatchesAllowed)
		return false;

	// Prepare data for cv::findHomography
	std::vector<cv::Point2f> srcPoints(matches.size());
	std::vector<cv::Point2f> dstPoints(matches.size());

	for (size_t i = 0; i < matches.size(); i++) {
		srcPoints[i] = trainKeypoints[matches[i].trainIdx].pt;
		dstPoints[i] = queryKeypoints[matches[i].queryIdx].pt;
	}

	// Find homography matrix and get inliers mask
	std::vector<unsigned char> inliersMask(srcPoints.size());
	homography = cv::findHomography(srcPoints, dstPoints, CV_FM_RANSAC,
		reprojectionThreshold, inliersMask);

	std::vector<cv::DMatch> inliers;
	for (size_t i = 0; i < inliersMask.size(); i++) {
		if (inliersMask[i])
			inliers.push_back(matches[i]);
	}

	matches.swap(inliers);
	return matches.size() > minNumberMatchesAllowed;
}

void KeyPointsToPoints(vector<KeyPoint> kpts, vector<Point2f> &pts) {
	for (int i = 0; i < kpts.size(); i++) {
		pts.push_back(kpts[i].pt);
	}

	return;
}
南木Sir
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Go 图像处理
qq_39335595的博客
05-17 273
Golang中的image包提供了基本的图像类型、颜色模型、以及用于处理图像的各种函数和接口。
图像特征匹配总结
伊特
05-19 2643
大部分转自 https://blog.csdn.net/ssw_1990/article/details/72629655 OpenCV官方文档：https://docs.opencv.org 参考文献：Feature Matching：http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_matcher/py_ma...
OpenCV入门10——特征点检测与匹配
Atticus的博客
11-23 711
特征点检测与匹配是计算机视觉中非常重要的内容。不是所有图像操作都是对每个像素进行处理，有些只需使用4个顶点即可，如图像的拼接、二维码定位等。
图像特征提取与匹配方法总结
常先生
11-19 4174
在图像处理的过程中，特征点的选取与匹配是其中非常重要的一个部分，常见的应用场景有，图像的目标检测与追踪、地图场景关键点信息的提取等。 图像关键点特征选取与匹配一共包括三个步骤： 1、关键点检测 2、关键点描述 3、关键点匹配 在关键点检测的方法中： 首先需要知道角点的概念，角点检测(Corner Detection)是计算机视觉系统中用来获得图像特征的一种方法，广泛应用于运动检测、图像匹配、视频跟踪、三维建模和目标识别等领域中，也称为特征点检测。 角点的检测算法： 1、Moravec角点检测
SIFT图像特征匹配学习笔记
cmdxly的博客
10-02 2045
来源 https://www.analyticsvidhya.com/blog/2019/10/detailed-guide-powerful-sift-technique-image-matching-python/ 总览 SIFT（尺度不变特征变换）简单介绍 如何使用SIFT执行特征匹配 python实现SIFT 介绍 看一下下面的图像组合，并考虑它们之间的共同元素： 显然我们可以看到每张图片都有埃菲尔铁塔，同时我们也可以注意到每张图像都有不同的背景，这是因为图片从不同角度拍摄的，并且在前景中也有
特征点检测与匹配
m0_63520910的博客
04-12 8654
参考博客图像特征匹配方法——SIFT算法原理及实现_Eating Lee的博客-CSDN博客_sift匹配算法 参考博客https://blog.csdn.net/v_JULY_v/article/details/6186942 在图像处理中，有时候并不需要使用目标所有的像素，所以，可以从图像中提取能够表示图像特性或者局部特性的像素，这些像素叫做角点或者特征点。 使用它可以极大地减少数据量，提高计算速度。它的应用也很广泛，比如基于特征点的图像匹配、定位和三维重建。 一、特征点检测 1、角点 角.
【计算机视觉、关键点检测、特征提取和匹配】基于SIFT、PCA-SIFT和GLOH算法在不同图像之间建立特征对应关系，并实现点匹配算法和图像匹配（Matlab代码实现）
最新发布
weixin_46039719的博客
03-07 1272
在本次任务中，我们尝试构建一个系统，能够检测图像中的关键点，从中提取不变的特征，并最终进行如上所述的特征匹配。然后，在找到图像中的关键点后，我们试图从这些关键点中提取出有区分性的特征。在这个任务中，我们尝试实现和评估一些算法，如HARRIS、MSER、SIFT、PCA-SIFT、GLOH，然后我们在symfeat数据集中测试我们的算法，该数据集包含展示了光照、年龄和渲染风格等各种戏剧性变化的图像对。在标准的CBIR系统中，从单个图像中自动检测出兴趣点，然后在这些兴趣点处计算特征向量。行百里者，半于九十。
图像配准（匹配）与变化检测
xys430381_1的专栏
04-23 3184
然而，像素级或物体级的变化检测方法不适用于土地利用变化分析。造成这种情况的主要原因可能是，场景中的物体，如植被生长和个别建筑的拆除/建造，不会直接影响土地使用类别，即它们在场景中的变化不会改变土地利用类别，例如，从住宅区到工业区。因此，在场景尺度上改进变化检测方法至关重要。SLCD最简单的方法，即后分类方法，将场景变化检测任务视为一个独立的分类，忽略时间相关性信息，从而遭受误差累积。换句话说，它几乎没有考虑多时间图像的时间相关性。
相似图像块的搜索（匹配）问题分析1——计算机视觉问题中常用到的一种策略
SimonCoder的专栏
03-31 4744
在计算机视觉的很多问题中，在对图像/视频进行处理时，很多方法都是基于图像块进行处理的（而且为了增加处理过程的鲁棒性，有些方法使图像块有部分重叠），比如图像去噪、去除图像文本覆盖、图像超分辨等任务。 噪声图像文本覆盖图像低分辨率图像基于图像块进行处理时，在很多情况下都要进行相似图像块的搜索（匹配），之所以要搜索相似块，是因为要利用相似块之间的稀疏与低秩的性质，图像的稀疏性通常使用字典来进行处理，图...
计算机视觉基础（5）——特征点及其描述子
猪猪和超超的博客
10-17 4550
本文我们将学习到特征点及其描述子。在特征点检测中，我们将学习角点检测和SIFT关键点检测器，角点检测以哈里斯角点检测器为例进行说明，SIFT将从高斯拉普拉斯算子和高斯差分算子展开。在描述子部分，我们将分别学习SIFT描述子和二进制描述子的概念、基本计算流程以及优劣评价，并给出实例进行说明。
数字图像处理——Java编程与实验
04-15
《数字图像处理——Java编程与实验》是一本深入探讨图像处理技术并结合Java编程实践的教程。这本书涵盖了图像处理的多个关键领域，旨在帮助读者理解并应用这些技术。以下是其中涉及的一些核心知识点： 1. **图像...
《MATLAB图像处理——能力提高与应用案例》配套程序
05-27
《MATLAB图像处理——能力提高与应用案例》配套程序是一份专为学习和提升MATLAB在图像处理领域技能而设计的资源包。该资源包旨在帮助用户深入理解MATLAB图像处理的基本概念、算法以及实际应用，通过实例学习，增强...
MirrorSymmetry-master.zip——基于SIFT的图像对称轴检测算法
07-14
在图像处理领域，对称性是物体或场景一个重要的视觉特性，它可以帮助我们理解图像内容并进行各种识别任务。本文将深入探讨“基于SIFT（尺度不变特征变换）的图像对称轴检测算法”，该算法是 MirrorSymmetry-master ...
商标识别系统设计——图像处理实习.docx
07-05
商标识别系统设计是一个结合了图像处理技术的实践项目，旨在通过MATLAB实现对商标的自动检测和识别。在这个过程中，图像处理技术起到了关键作用，主要包括图像增强、图像分割和基于灰度的模板匹配等核心环节。 图像...
ColorSymDetect-master.zip——RGB图像的对称轴检测算法代码实现
07-14
在图像处理领域，对称轴检测是一项重要的技术，它能够帮助我们识别并分析图像中的对称结构。"ColorSymDetect-master.zip"是一个包含RGB图像对称轴检测算法代码实现的压缩包，对于学习和研究图像处理，特别是对称性...
特征点检测之SIFT
sprd_xiaoqi的博客
03-08 1331
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 一、sift简介 二、计算方法 1. 尺度空间极值点 哈 2. 关键点定位 哈 3. 关键点方向分配 哈 4. 特征点的描述 哈 三、问题 哈 总结 提示： ...
【图像处理】图像配准、图像增强和图像分割研究（Matlab代码实现）
weixin_46039719的博客
09-26 998
图像处理领域涉及到许多重要的技术，其中包括图像配准、图像增强和图像分割。这些技术在不同的图像应用中发挥着重要的作用。图像配准是指将多幅图像在空间上进行对齐，使得它们在几何、形状和灰度上具有一致性。常见的图像配准方法包括基于特征点的配准和基于互信息的配准。图像配准在医学影像、遥感影像等领域中广泛应用，用于将不同视角或不同时间拍摄的图像进行对比和分析。图像增强是改善图像质量和提高图像视觉效果的过程。通过调整图像的亮度、对比度、锐化等参数，可以增强图像的细节并改善图像的可视化效果。
OpenCV——SIFT特征检测
DDsoup 24小时不打烊芜湖！
03-12 5618
算法描述 SIFT特征不只具有尺度不变性，即使改变旋转角度，图像亮度或拍摄视角，仍然能够得到好的检测效果。整个算法分为以下几个部分： 建立尺度空间，寻找极值 构建图像高斯金字塔，求取DOG，发现最大与最小值在每一级 构建的高斯金字塔，每一层根据sigma的值不同，可以分为几个待级，最少有4个。 关键点定位 我们在像素级别获得了极值点的位置，但是更准确的值应该在亚像素位置，如何得到--这个过程称为关键点（准确/精确）定位。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南木Sir

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

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

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

打赏作者

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

抵扣说明：

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

余额充值