SIFT、SURF、ORB算法学习笔记

文章目录

SIFT、SURF、ORB算法学习笔记
- 一、 SIFT
- （1）构建尺度空间
- （2）使用DOG近似LOG定位极值点（关键点）
- （3）计算关键点方向
- （4）关键点描述子的生成
- （5）代码实现
- 二、SURF
- （1）构建Hessian（黑塞矩阵）
- （2）构建尺度空间
- （3）检测特征点
- （4）计算特征点方向
- （5）生成特征点描述子
- （6）特征点匹配
- （7）代码实现
- 三、ORB
- - 1.ORB简介
  - 2.ORB步骤
  - - （1）利用oFAST算法提取特征点
    - （3）特征点匹配
    - （4）代码实现

一、 SIFT

尺度不变特征转换(Scale-invariant feature transform）是一种用来侦测与描述影像中的局部性特征的视觉算法，即通过求一幅图中的特征点及其有关尺度和方向的描述子得到特征，并进行图像特征点匹配。SIFT所查找到的关键点是一些十分突出，不会因光照，仿射变换和噪音等因素而变化的点，如角点、边缘点、暗区的亮点及亮区的暗点等，噪声也保持一定程度的稳定性，除此之外SIFT还具有独特性，多量性，高速性，可扩展性等特点。

（1）构建尺度空间

①尺度空间的表示
二维图像的尺度空间函数L，高斯函数与原图像的卷积。L(x,y,σ)=G(x,y,σD)∗I(x,y)(公式1)L(x,y,\sigma)=G(x,y,\sigma_D)*I(x,y) \tag{公式1}L(x,y,σ)=G(x,y,σD)∗I(x,y)(公式1)

其中二维高斯函数为：
Gσ(x,y)=12πσ2exp(−x2+y22σ2)(公式2)G_\sigma(x,y)=\frac{1}{\sqrt{2\pi \sigma^2}}exp(-\frac{x^2+y^2}{2\sigma^2}) \tag{公式2}Gσ(x,y)=2πσ21exp(−2σ2x2+y2)(公式2)

符号“*”表示卷积。
在二维空间中，这个公式生成的曲面的等高线是从中心开始呈正态分布的同心圆，如图分布不为零的像素组成的卷积矩阵与原始图像做变换。每个像素的值都是周围相邻像素值的加权平均。（根据高斯函数的可分离性，可对二维高斯模糊函数进行改进。）

图1.1 二维高斯函数的曲面表示

② 高斯金字塔的构建
尺度空间在实现时使用高斯金字塔表示,高斯金字塔的构建分为两部分：对图像做不同尺度的高斯模糊；对图像做降采样(隔点采样)。后来有（2）点改进得到了高斯差分金字塔。

（2）使用DOG近似LOG定位极值点（关键点）

①（laplacian-gauss）LOG
LOG（高斯-拉普拉斯算子）是一种边缘检测算子，产生稳定的图像特征。公式为：
Log≜ΔGσ(x,y)+∂2Gσ(x,y)∂y2=x2+y2−2σ2σ4e(x2+y2)2σ2(公式3)Log \triangleq \Delta G_\sigma(x,y)+ \frac{\partial^2G_\sigma(x,y)}{\partial y^2}=\frac{x^2+y^2-2\sigma^2}{\sigma^4}e^{\frac{(x^2+y^2)}{2\sigma^2}} \tag{公式3}Log≜ΔGσ(x,y)+∂y2∂2Gσ(x,y)=σ4x2+y2−2σ2e2σ2(x2+y2)(公式3)
在此，LOG空间中的极值点被初步筛选特征点，由于LOG计算比较耗时，故采用DOG计算（DOG是LOG计算的近似，如图1.2所示）。

图1.2 DOG与LOG的比较

②Difference of Gaussian(DOG)：
为了有效的在尺度空间检测到稳定的关键点，作者提出了高斯差分尺度空间（DOG scale-space），公式为，利用不同尺度的高斯差分核与图像卷积生成。
在实际计算时，使用高斯金字塔每组中相邻上下两层图像相减（如图1.3），得到高斯差分图像，接着进行极值检测。
D(x,y,σ)=L(x,y,kσ)−L(x,y,σ)(公式4)D(x,y,\sigma)=L(x,y,k\sigma)-L(x,y,\sigma) \tag{公式4}D(x,y,σ)=L(x,y,kσ)−L(x,y,σ)(公式4)

图1.3 高斯差分金字塔的生成

通过比较当前点周围8个点的大小与上层9个和下层9个点大小确定当前点是否是极值点，总共同9*2+8 = 26个像素点比较，是极值点，就认定该点为初步筛选出的特征点。然后接着通过拟和三维二次函数以精确确定关键点的位置和3尺度（达到亚像素精度），同时去除低对比度的关键点和不稳定的边缘响应点。

图1.4 选取特征点

（3）计算关键点方向

为了使描述符具有旋转不变性，需要利用图像的局部特征为给每一个关键点分配一个基准方向，使用图像梯度的方法求取局部结构的稳定方向。对于在DOG金字塔中检测出的关键点，采集其所在高斯金字塔图像3σ邻域窗口内像素的梯度和方向分布特征。在完成关键点的梯度计算后，生成直方图如图4，来统计邻域内像素的梯度和方向。方向直方图的峰值则代表了该特征点处邻域梯度的方向，以直方图中最大值作为该关键点的主方向，保留峰值大于主方向峰值80％的方向作为该关键点的辅方向。通过以上步骤，对于每一个关键点，拥有三个信息：位置、尺度以及方向。

图1.5 关键点方向直方图

（4）关键点描述子的生成

接下来建立一个描述符，以便于提高特征点正确匹配的概率，用一组向量将这个关键点描述出来，使其不随各种变化而改变，比如光照变化、视角变化等。Lowe作者建议描述子使用在关键点尺度空间内44的窗口中计算的8个方向的梯度信息，共44*8=128维向量表征作为每一个特征点的描述子。特征向量形成后，为了去除光照变化的影响，需要对它们进行归一化处理，并设置门限值，最后按特征点的尺度对特征描述向量进行排序。至此，SIFT特征描述向量生成。

（5）代码实现

%matplotlib inline
import numpy as np
import cv2
from matplotlib import pyplot as plt
from PIL import Image#导入两张图片
imgname_01 = './01.jpg'
imgname_02 = './02.jpg'
#利用现有的cv2模块方法，创建一个SIFT的对象
sift = cv2.xfeatures2d.SIFT_create()```img_01 = cv2.imread(imgname_01)
img_02 = cv2.imread(imgname_02)#显示原有的2张图片
hmerge_original = np.hstack((img_01, img_02)) #水平拼接
#由于plt 和cv2 的处理通道不同 cv2是BGR  plt是RGB 因此需要利用到cv2.cvtColor方法转换
img_original = cv2.cvtColor(hmerge_original, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_original)
ax1.set_title("Image_original")
plt.savefig('Image_original.png')'''
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) #灰度处理图像img_plt = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB) #灰度处理图像
plt.imshow(img_plt)
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)img_plt02 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB) #灰度处理图像
plt.imshow(img_plt02)
'''keypoint_01, descriptor_01 = sift.detectAndCompute(img_01,None)   #keypoint是特征点，descriptor是描述子
keypoint_02, descriptor_02 = sift.detectAndCompute(img_02,None)  #test
print(type(keypoint_01))
print(len(str(keypoint_01)))
print(type(descriptor_01))
print(descriptor_01.shape)img_03 = cv2.drawKeypoints(img_01,keypoint_01,img_01,color=(255,0,255)) #画出特征点，并显示为红色圆圈
img_04 = cv2.drawKeypoints(img_02,keypoint_02,img_02,color=(255,0,255)) #画出特征点，并显示为红色圆圈
hmerge_change = np.hstack((img_03, img_04)) #水平拼接
img_change = cv2.cvtColor(hmerge_change, cv2.COLOR_BGR2RGB) fig, ax1 = plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_change)
ax1.set_title("Image_Keypoints")
plt.savefig('img_Keypoints.png')# BFmatcher（Brute-Force Matching）暴力匹配   暴力方法找到点集1中每个descriptor在点集2中距离最近的descriptor；找寻到的距离最小就认为匹配#应用BFMatch暴力方法找到点集1中每个descriptor在点集2中距离最近的descriptor；找寻到的距离最小就认为匹配er.knnMatch( )函数来进行核心的匹配，knnMatch（k-nearest neighbor classification）k近邻分类算法。
# 进行特征检测，得到2张图片的特征点和描述子img_01 = cv2.imread(imgname_01)
img_02 = cv2.imread(imgname_02)
keypoint_01, descriptor_01 = sift.detectAndCompute(img_01, None)
keypoint_02, descriptor_02 = sift.detectAndCompute(img_02, None)
bf = cv2.BFMatcher()# k = 2 返回点集1中每个描述点在点集2中 距离最近的2个匹配点，使用matches变量存储matches = bf.knnMatch(descriptor_01, descriptor_02, k = 2)
# 调整ratio， ratio test： 阈值
ratio = 0.5
good = []#我的理解：比较 m n到点集1描述子的欧氏距离
for m,n in matches:if m.distance < ratio * n.distance:good.append([m])img5 = cv2.drawMatchesKnn(img_01, keypoint_01, img_02, keypoint_02, good, None, flags=2)img_sift = cv2.cvtColor(img5, cv2.COLOR_BGR2RGB) #灰度处理图像plt.rcParams['figure.figsize'] = (20.0, 20.0)
plt.imshow(img_sift)
plt.savefig('img_SIFT.png')cv2.destroyAllWindows()

参考大佬博客资料：
https://blog.csdn.net/abcjennifer/article/details/7639488
https://blog.csdn.net/zddblog/article/details/7521424
https://blog.csdn.net/sss_369/article/details/84674639
https://blog.csdn.net/touch_dream/article/details/62237018
https://blog.csdn.net/silence2015/article/details/77101295
https://blog.csdn.net/abcjennifer/article/details/7639681
https://www.cnblogs.com/herenzhiming/articles/5276106.html

二、SURF

加速稳健特征（Speeded Up Robust Features），是一种稳健的局部特征点检测和描述算法。SURF的出现很大程度是对SIFT算法的改进，提升了算法的执行效率，SIFT缺点是实时性不高，并且对于边缘光滑目标的特征点提取能力较弱，SURF算法在实时计算机视觉系统中应用提供了可能。
Surf改进了特征的提取和描述方式，用一种更为高效的方式完成特征的提取和描述，具体实现流程与SIFT相似，为构建Hessian（黑塞矩阵），构建尺度空间，检测特征点，确定特征点方向，生成特征点描述子。

（1）构建Hessian（黑塞矩阵）

构建Hessian矩阵的目的是为了生成图像稳定的边缘点，构建Hessian矩阵的过程对应于Sift算法中的高斯卷积过程。黑塞矩阵（Hessian Matrix）是一个多元函数的二阶偏导数构成的方阵，描述了函数的局部曲率。
对一个图像f（x，y），其Hessian矩阵如下：
H(f(x,y))=[∂2f∂x2∂2f∂x∂y∂2f∂x∂y∂2f∂y2](公式5)H(f(x,y))=\begin{bmatrix}\frac{\partial^2f }{\partial x^2} && \frac{\partial^2f}{\partial x \partial y} \\\\ \frac{\partial^2f}{\partial x \partial y} && \frac{\partial^2f}{\partial y^2} \end{bmatrix} \tag{公式5}H(f(x,y))=⎣⎢⎡∂x2∂2f∂x∂y∂2f∂x∂y∂2f∂y2∂2f⎦⎥⎤(公式5)
在构造Hessian矩阵前需要对图像进行高斯滤波，经过滤波后的Hessian矩阵表述为:H(x,σ)=[Lxx(x,σ)Lxy(x,σ)Lxy(x,σ)Lyy(x,σ)](公式6)H(x,\sigma)=\begin{bmatrix} L_{xx}(x,\sigma) && L_{xy}{(x,\sigma)} \\\\ L_{xy}(x,\sigma) &&L_{yy}(x,\sigma) \end{bmatrix} \tag{公式6}H(x,σ)=⎣⎡Lxx(x,σ)Lxy(x,σ)Lxy(x,σ)Lyy(x,σ)⎦⎤(公式6)
所不同的是，为了提高运算速度，Surf使用了盒式滤波器来近似替代高斯滤波器。

（2）构建尺度空间

类比于sift算法的高斯金字塔构造过程，surf算法没有了降采样的过程，SURF算法处理速度有所提高。对于SURF算法，图像的大小总是不变的，SURF采用不断增大盒子滤波模板的尺寸的间接方法。，尺度σ也是在改变。 SURF中采用9X9尺寸的滤波器作为起始滤波器，之后的滤波器尺寸可由以下公式计算得出：FilterSize=3×(2octave×interval+1)Filter Size = 3 \times (2^{octave} \times interval + 1)FilterSize=3×(2octave×interval+1),SIFT与SURF在构建高斯金字塔中的差异可以由图1直观的显示。

图2.1 两种算法在构建高斯金字塔的差异

图2.1中a为高斯模板保持不变，图像大小改变的情况，适用于sift算法，图b是高斯模板改变，图像大小保持不变的情况，适用于surf算法。一幅灰度图像经过尺度空间中不同尺寸盒子滤波器的滤波处理，可以生成多幅Hessian行列式图像，从而构成了图像金字塔。

图2.2 一幅Hessian行列式图像的产生过程

（3）检测特征点

SURF 中特征点的定位和 SIFT 算法基本相似，在每一组中选取相邻的三层Hessian行列式图像，对于中间层的每一个Hessian行列式值都可以做为待比较的点，在空间中选取该点周围的26个点进行比较大小，若该点大于其他26个点，则该点为特征点。再设定Hessian行列式的阀值，低于Hessian行列式阀值的点不能作为最终的特征点。滤除一些不稳定或者定位错误的关键点，筛选出最终的稳定的特征点。

图2.3 选取特征点

（4）计算特征点方向

在SURF算法中，主方向是对以特征点为中心的6s(S为特征点所在的尺度值)为半径的圆形区域内的Haar小波响应做统计运算得到的。在这个圆形领域内做一个60度的扇形区域，统计这个扇形区域内的haar小波特征总和，然后转动扇形区域，再统计小波特征总和。小波特征总和最大的方向为主方向。

图2.4 特征点方向

（5）生成特征点描述子

首先在特征点周围取一个正方形框，框的边长为20s(s是所检测到该特征点所在的尺度)。在特征点周围取一个44的矩形区域块，所取得矩形区域方向是沿着特征点的主方向。每个子区域统计25个像素的水平方向和垂直方向（都相对于主方向）的haar小波特征，该haar小波特征为水平方向值之后、垂直方向值之后、水平方向绝对值之后以及垂直方向绝对值之和4个方向。所以一共有44*4=64维向量作为Surf特征的描述子，比Sift特征的描述子减少了一半。

图2.5 描述子维度确定

（6）特征点匹配

SURF算法特征点匹配和SIFT算法大致相似，这里就不在叙述。

（7）代码实现


%matplotlib inlineimport numpy as np
import cv2
from matplotlib import pyplot as plt
imgname_01 = '01.jpg'
imgname_02 = '02.jpg'
imgname_03 = 'test_keypoint.jpg'# 设定阈值，阈值越大，能够识别的特征也就越少
#surf = cv2.xfeatures2d.SURF_create(1000)
surf = cv2.xfeatures2d.SURF_create()#先获取img_03的关键点，单独检测更加的直观。
img_03 = cv2.imread(imgname_03)
keypoint_03, descriptor_03 = surf.detectAndCompute(img_03,None)
img_keypoint = cv2.drawKeypoints(img_03,keypoint_03,img_03,color=(0,255,0))img_kp = cv2.cvtColor(img_keypoint, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_kp)
ax1.set_title("Image_Keypoints")
plt.savefig('img_Keypoints.png')#test
print(type(keypoint_01))
print(len(str(keypoint_01)))
print(type(descriptor_01))
#64维的描述子
print(descriptor_01.shape)#获取两张相似的图片img_01 与 img_02的img_01 = cv2.imread(imgname_01)
keypoint_01, descriptor_01 = surf.detectAndCompute(img_01,None)
img_02 = cv2.imread(imgname_02)
keypoint_02, descriptor_02 = surf.detectAndCompute(img_02,None)
img_03 = cv2.drawKeypoints(img_01, keypoint_01, img_01, color=(255, 255, 0))
img_04 = cv2.drawKeypoints(img_02, keypoint_02, img_02, color=(255, 255, 0))img_original = np.hstack((img_03, img_04)) #水平拼接
img_original = cv2.cvtColor(img_original, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_original)
ax1.set_title("img_original")
plt.savefig('img_original.png')'''
FLANN(Fast_Library_for_Approximate_Nearest_Neighbors)快速最近邻搜索包，它是一个对大数据集和高维特征进行最近邻搜索的算法的集合,
而且这些算法都已经被优化过了。在面对大数据集时它的效果要好于 BFMatcher。使用FLANN匹配需要传入两个字典参数：
第一个参数是IndexParams，对于SIFT和SURF，可以传入参数index_params=dict(algorithm=FLANN_INDEX_KDTREE, trees=5)。
对于ORB，可以传入参数index_params=dict(algorithm=FLANN_INDEX_LSH, table_number=6, key_size=12,
第二个参数是SearchParams，可以传入参数search_params=dict(checks=100)，它来指定递归遍历的次数，值越高结果越准确，但是消耗的时间也越多。
'''
img_01 = cv2.imread(imgname_01)
img_02 = cv2.imread(imgname_02)FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks = 50)
flann = cv2.FlannBasedMatcher(index_params,search_params)matches = flann.knnMatch(descriptor_01, descriptor_02, k = 2)
ratio = 0.6good = []
for m,n in matches:if m.distance < 0.6 * n.distance:good.append([m])
img_04 = cv2.drawMatchesKnn(img_01, keypoint_01, img_02 ,keypoint_02, good, None, flags=2)
img_SURF = cv2.cvtColor(img_04, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_SURF)
ax1.set_title("img_SURF")
plt.savefig('img_SURF.png')cv2.destroyAllWindows()

参考大佬博客资料：
https://www.cnblogs.com/gfgwxw/p/9415218.html
https://blog.csdn.net/jiaoyangwm/article/details/79991915
https://blog.csdn.net/dcrmg/article/details/52601010
https://blog.csdn.net/lien0906/article/details/79494837

三、ORB

1.ORB简介

ORB（Oriented FAST and Rotated BRIEF）是一种快速特征点提取和描述的算法。ORB算法特征检测是将FAST特征点的检测方法与BRIEF特征描述子结合起来，并在它们原来的基础上做了改进与优化。具体的步骤大致分为利用改进FAST算法的oFAST算法提取特征点，并确定特征点方向；然后利用BRIEF算法改进的rBRIEF算法生成特征描述子，最后进行特征点匹配。

2.ORB步骤

（1）利用oFAST算法提取特征点

FAST算法是一种非常快的提取特征点的方法，FAST核心思想就是找出那些特殊的点，即拿一个点跟它周围的点比较，如果它和其中大部分的点都不一样就可以认为它是一个特征点。但是对于这里来说，有两点不足：

①提取到的特征点没有方向；
②提取到的特征点不满足尺度变化。
ORB特征提取是由FAST（Features from Accelerated Segment Test）算法发展来的，针对特征点不满足尺度变化，作者像SIFT算法中那样，建立尺度图像金字塔，通过在不同尺度下的图像中提取特征点以达到满足尺度变化的效果。针对提取到的特征点没有方向的问题，作者采用了Rosin提出的一种称为“intensity centroid”（灰度质心法）的方法确定了特征点的方向，具体的步骤如下：
①粗提取，从图像中选取一点P，以P为圆心画一个半径为3pixel的圆。圆周上如果有连续n个像素点的灰度值比P点的灰度值大或者小，则认为P为特征点。
②机器学习的决策树算法进一步筛选，使用ID3算法训练一个决策树，将特征点圆周上的16个像素输入决策树中，以此来筛选出最优的FAST特征点。
③使用非极大值抑制算法去除临近位置多个特征点的问题。
④构建金字塔实现尺度不变性，来实现尺度不变性，不同比例的图像提取特征点总和作为这幅图像的oFAST特征点。
⑤用灰度质心法（Intensity Centriod）为每个特征点计算了主方向。灰度质心法是假设某特征点的灰度与该邻域重心之间存在偏移，通过这个特征点到重心的向量，就能算出该特征点的主方向。Rosin将邻域矩（moment）定义为：m=∑x,yxpyqI(x,y)m = \sum_{x,y}x^py^qI(x,y) m=x,y∑xpyqI(x,y)，然后质心定义为:C=(m10m00,m01m00)C=(\frac {m_{10}} {m_{00}},\frac {m_{01}} {m_{00}})C=(m00m10,m00m01)。然后求取向量OC的方向，同时如果把x,y的范围保持在[−r,r]之间（r为该特征点邻域的半径），以特征点为坐标原点，则得到的方向角为θ=atan2(m10,m10)\theta = atan2(m_{10},m_{10})θ=atan2(m10,m10)。

####（2）利用rBRIEF生成特征描述子
BRIEF算法的核心思想是在关键点P的周围以一定模式选取N个点对，把这N个点对的比较结果组合起来作为描述子，ORB中使用统计学习的方法来重新选择点对集合，但BRIEF算法有个严重的缺点是特征描述子不具备旋转不变性。

ORB算法在两个方面对BRIEF算法进行了改进，形成rBRIEF算法，改进的步骤为：①采用积分图像解决BRIEF算法的噪声敏感性。②利用改进的FAST算法求得的特征点主方向，ORB在计算BRIEF描述子时建立的坐标系是以特征点为圆心，以特征点和取点区域的形心的连线为X轴建立2维坐标系,后判别和二进制编码，使得描述子具有旋转不变性。在31x31的窗口中，产生一对随机点后，以随机点为中心，取5x5的子窗口，比较两个子窗口内的像素和的大小进行二进制编码，而非仅仅由两个随机点决定二进制编码。

（3）特征点匹配

在ORB特征点的匹配时，与SURF与SIFT算法使用的比较两个特征点之间的欧氏距离不同，ORB采用的是汉明距离，设定一个阈值来判断是否能够匹配成功。公式为：D(b1,b2)=b1⨁b2D(b_1,b_2) = b_1 \bigoplus b_2D(b1,b2)=b1⨁b2,D的值越小，表明两个特征点的相似度越高，异或运算也进一步加快了ORB的算法速度。

（4）代码实现

%matplotlib inline
import numpy as np
import cv2
from matplotlib import pyplot as plt
imgname_01 = '01.jpg'
imgname_02 = '02.jpg'
imgname_03 = 'test_keypoint.jpg'
#创建一个ORB对象
orb = cv2.ORB_create()
#先获取img_03的关键点，单独检测更加的直观。
img_03 = cv2.imread(imgname_03)
keypoint_03, descriptor_03 = orb.detectAndCompute(img_03,None)
img_keypoint = cv2.drawKeypoints(img_03,keypoint_03,img_03,color=(0,255,0))img_kp = cv2.cvtColor(img_keypoint, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (10,10))
ax1.imshow(img_kp)
ax1.set_title("Image_Keypoints")
plt.savefig('img_Keypoints.png')#test
print(type(keypoint_03))
print(len(str(keypoint_03)))
print(type(descriptor_03))
#64维的描述子
print(descriptor_03.shape)#检测两幅不同角度拍摄的图片的特征点
img_01 = cv2.imread(imgname_01)
keypoint_01, descriptor_01 = orb.detectAndCompute(img_01,None)
img_02 = cv2.imread(imgname_02)
keypoint_02, descriptor_02 = orb.detectAndCompute(img_02,None)
img_03 = cv2.drawKeypoints(img_01, keypoint_01, img_01, color=(255, 255, 0))
img_04 = cv2.drawKeypoints(img_02, keypoint_02, img_02, color=(255, 255, 0))img_original = np.hstack((img_03, img_04)) #水平拼接
img_original = cv2.cvtColor(img_original, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_original)
ax1.set_title("img_original")
plt.savefig('img_original.png')# BFMatcher解决匹配
img_01 = cv2.imread(imgname_01)
img_02 = cv2.imread(imgname_02)bf = cv2.BFMatcher()
matches = bf.knnMatch(descriptor_01,descriptor_02, k=2)
print(type(matches))#<class 'list'># 调整ratio
good = []
ratio = 0.7
for m,n in matches:if m.distance < ratio * n.distance:good.append([m])img_05 = cv2.drawMatchesKnn(img_01,keypoint_01,img_02,keypoint_02,good,None,flags=2)
img_ORB = cv2.cvtColor(img_05, cv2.COLOR_BGR2RGB) fig,ax1=plt.subplots(1, 1, figsize = (20,20))
ax1.imshow(img_ORB)
ax1.set_title("img_ORB")
plt.savefig('img_ORB.png')cv2.destroyAllWindows()

参考资料：

https://blog.csdn.net/andylanzhiyong/article/details/84729196
https://www.cnblogs.com/zjiaxing/p/5616653.html
https://blog.csdn.net/qq_20791919/article/details/80176643
https://blog.csdn.net/monk1992/article/details/93469078
https://blog.csdn.net/weixin_30567471/article/details/99190350
https://blog.csdn.net/zhangziju/article/details/79754652

[图像特征匹配]SIFT、SURF、ORB算法笔记以及代码实现相关推荐

SIFT,SURF,ORB,FAST 特征提取算法比较
SIFT,SURF,ORB,FAST 特征提取算法比较主要的特征检测方法有以下几种,在一般的图像处理库中(如OpenCV, VLFeat, Boofcv等)都会实现. FAST ,Machine L ...
SIFT,SURF,ORB,FAST,BRISK 特征提取算法比较
SIFT,SURF,ORB,FAST 特征提取算法比较图像处理的基础就是要进行特征点的提取,feature(interest points) detect 的方法也在不断的进步,边检测,角点检测,直 ...
[转]SIFT,SURF,ORB,FAST 特征提取算法比较
转载地址:https://blog.csdn.net/vonzhoufz/article/details/46461849 主要的特征检测方法有以下几种,在一般的图像处理库中(如opencv, VLF ...
opencv中的SIFT,SURF,ORB,FAST 特征描叙算子比较
opencv中的SIFT,SURF,ORB,FAST 特征描叙算子比较参考: http://wenku.baidu.com/link?url=1aDYAJBCrrK-uk2w3sSNai7h52x_ ...
【Python+OpenCV】主流特征点检测器和描述子总结与实现附拼接结果(SIFT,SURF,ORB,AKAZE,FAST,BRIEF,CenSurE,BEBLID,SuperPoint)
文章目录准备工作 SIFT SURF ORB AKAZE FAST与BRIEF CenSurE BEBLID 匹配点后的图像拼接 SuperPoint 总结准备工作先准备两张待处理的图像,要求有 ...
光流 | 图像特征匹配：特征光流与角点特征
/********************************************************** github:https://github.com/MichaelBeechan ...
图像特征：SIFT特征
建议看->转自: SIFT特征点提取:https://blog.csdn.net/lingyunxianhe/article/details/79063547 计算机视觉中的特征点提取算法比较 ...
图像特征点—SIFT特征点
图像特征点-SIFT特征点关于SIFT特征点,以下三篇博客说的非常详细,再次不再赘述. https://mp.weixin.qq.com/s/XVB88f119gRqpwTTRvTyrA https ...
详解计算机视觉中的特征点检测：Harris / SIFT / SURF / ORB
作者丨Encoder@知乎来源丨https://zhuanlan.zhihu.com/p/36382429 编辑丨极市平台本文仅用于学术分享,若侵权,联系后台作删文处理.极市导读 Harris角点 ...

[图像特征匹配]SIFT、SURF、ORB算法笔记以及代码实现