文章目录

Features2D类介绍
- 1. cv::AgastFeatureDetector
- 2. cv::AKAZE
- 3. cv::BRISK
- 4. cv::FastFeatureDetector
- 5. cv::GFTTDetector
- 6. cv::KAZE
- 7. cv::MSER
- 8. cv::SimpleBlobDetector
- 9. cv::StarDetector
- 10. cv::SIFT
- 11. cv::SURF
- 12. cv::FastFeatureDetector
- 13. cv::AgastFeatureDetector
- 14. cv::BRISK
- 15. cv::ORB
- 16. cv::MSER
- 17. cv::GFTTDetector
- 18. cv::SimpleBlobDetector
- 19. cv::KAZE
- 20. cv::AKAZE
- 21. cv::AgastFeatureDetector
- 22. cv::FastFeatureDetector
- 23. cv::StarDetector
- - 描述子匹配类
- 24. cv::FlannBasedMatcher
- 25. cv::BFMatcher
- 26. drawMatches 绘制匹配的特征点

Features2D类介绍

以下是OpenCV中继承自cv::Features2D的所有类：

cv::AgastFeatureDetector: Adaptive and Generic Accelerated Segment Test (AGAST) 特征检测器。
cv::AKAZE: Accelerated-KAZE (AKAZE) 特征检测器和描述子提取器。
cv::BRISK: Binary Robust Invariant Scalable Keypoints (BRISK) 特征检测器和描述子提取器。
cv::FastFeatureDetector: FAST 特征检测器。
cv::GFTTDetector: Good Features to Track (GFTT) 特征检测器。
cv::KAZE: KAZE (Accelerated-Kernelized) 特征检测器和描述子提取器。
cv::MSER: Maximally Stable Extremal Regions (MSER) 特征检测器和描述子提取器。
cv::ORB: Oriented FAST and Rotated BRIEF (ORB) 特征检测器和描述子提取器。
cv::SimpleBlobDetector: 简单的二值化Blob检测器。
cv::BRISK_Impl: BRISK 特征检测器和描述子提取器的实现。
cv::DescriptorMatcher: 特征描述子匹配器。
cv::FastFeatureDetector_Impl: FAST 特征检测器的实现。
cv::FlannBasedMatcher: 基于FLANN库的特征描述子匹配器。
cv::GFTTDetector_Impl: GFTT 特征检测器的实现。
cv::KAZE_Impl: KAZE 特征检测器和描述子提取器的实现。
cv::DescriptorExtractor: 特征描述子提取器。
cv::MSER_Impl: MSER 特征检测器和描述子提取器的实现。
cv::ORB_Impl: ORB 特征检测器和描述子提取器的实现。
cv::SimpleBlobDetector_Impl: 简单的二值化Blob检测器的实现。
cv::BFMatcher: Brute-Force Matcher，暴力匹配器。
cv::FlannIndexParams: FLANN索引参数。
cv::FlannMatcher: 基于FLANN库的暴力匹配器。
cv::FlannSearchParams: FLANN搜索参数。
cv::GenericDescriptorMatcher: 通用特征描述子匹配器。
cv::VGG: VGG特征检测器和描述子提取器。

1. cv::AgastFeatureDetector

cv::AgastFeatureDetector::create() 是 OpenCV 中用于创建 AGAST 特征检测器的静态函数。AGAST（Adaptive and Generic Corner Detection Based on the Accelerated Segment Test）是一种快速的角点检测算法，用于在图像中找到显著的角点特征。

函数原型如下：

Ptr<AgastFeatureDetector> cv::AgastFeatureDetector::create(
    int threshold = 10,
    bool nonmaxSuppression = true,
    AgastFeatureDetector::DetectorType type = AgastFeatureDetector::OAST_9_16
)

参数解释：

threshold：阈值，用于控制角点检测的灵敏度。较高的阈值将导致检测到较强的角点，而较低的阈值将导致检测到更多的角点。默认值为10。
nonmaxSuppression：是否进行非极大值抑制。如果设置为 true，将对检测到的角点进行非极大值抑制，只保留最显著的角点。默认值为 true。
type：AGAST 检测器类型，用于指定采用的算法变体。可以选择以下类型之一：
- AgastFeatureDetector::OAST_5_8：5邻域/8邻域的 OAST（Original Accelerated Segment Test）算法。
- AgastFeatureDetector::OAST_7_12d：7邻域/12邻域的 OAST 算法（默认）。
- AgastFeatureDetector::OAST_7_12s：7邻域/12邻域的 OAST 算法（稍微改进的版本）。
- AgastFeatureDetector::OAST_9_16：9邻域/16邻域的 OAST 算法。
返回值是一个指向 AgastFeatureDetector 对象的智能指针 (Ptr)，你可以使用它来执行 AGAST 特征检测。

cv::AgastFeatureDetector是一个快速而又鲁棒的特征检测器，它可以检测到图像中的极值点（如角点、边缘点等）。它实现了Adaptive and Generic Accelerated Segment Test (AGAST)算法，可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::AgastFeatureDetector> detector = cv::AgastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

2. cv::AKAZE

函数cv::AKAZE::create()是OpenCV中用于创建AKAZE（Accelerated-KAZE）特征检测器和描述符提取器的函数。AKAZE是一种基于非线性尺度空间的特征检测算法，它在图像中检测和描述局部特征。

函数原型如下：

Ptr<AKAZE> cv::AKAZE::create(
    int descriptor_type = AKAZE::DESCRIPTOR_MLDB,
    int descriptor_size = 0,
    int descriptor_channels = 3,
    float threshold = 0.001f,
    int nOctaves = 4,
    int nOctaveLayers = 4,
    int diffusivity = KAZE::DIFF_PM_G2
);

参数说明：

descriptor_type：描述符类型，有两种选项：AKAZE::DESCRIPTOR_KAZE和AKAZE::DESCRIPTOR_MLDB。默认值为AKAZE::DESCRIPTOR_MLDB。
descriptor_size：描述符大小。对于AKAZE::DESCRIPTOR_KAZE，它是64；对于AKAZE::DESCRIPTOR_MLDB，它是0（自动计算）。默认值为0。
descriptor_channels：描述符通道数，对于AKAZE::DESCRIPTOR_KAZE，它是1；对于AKAZE::DESCRIPTOR_MLDB，它是3。默认值为3。
threshold：特征点检测的阈值，用于决定哪些特征点应该被保留。较大的值会导致更少的特征点被检测到。默认值为0.001f。
nOctaves：尺度空间中的八度数。默认值为4。
nOctaveLayers：每个八度的层数。默认值为4。
diffusivity：尺度空间扩散函数的类型。有四个选项：KAZE::DIFF_PM_G1、KAZE::DIFF_PM_G2、KAZE::DIFF_WEICKERT和KAZE::DIFF_CHARBONNIER。默认值为KAZE::DIFF_PM_G2。

函数返回一个指向AKAZE对象的智能指针(Ptr<AKAZE>)，您可以使用该指针进行特征检测和描述符提取。

cv::AKAZE是一种加速的特征检测器和描述子提取器。它基于KAZE算法，使用非线性尺度空间技术来检测稳定的关键点，并提取描述子。它对光照变化和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测和描述子提取。它的使用方法如下：

cv::Ptr<cv::AKAZE> detector = cv::AKAZE::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

3. cv::BRISK

cv::BRISK::create()是OpenCV库中的一个函数，用于创建BRISK特征检测器对象。它可以被用于在图像中检测出稳定的局部特征，这些特征可以被用于图像匹配、物体识别和3D重建等应用中。

该函数的语法如下：

cv::Ptr<BRISK> cv::BRISK::create(
    int thresh,           // 特征点提取阈值
    int octaves = 3,      // 金字塔层数
    float patternScale = 1.0f // 特征点采样尺度因子
);

下面是参数的详细说明：

thresh：特征点提取阈值，值越高提取的特征点越少。
octaves：金字塔层数，用于生成多尺度的特征点。
patternScale：特征点采样尺度因子，用于确定生成特征点时所使用的采样尺度。

函数返回一个cv::Ptr<BRISK>类型的智能指针对象，该对象可以用于访问和调用BRISK特征检测器的其他方法和属性。

cv::BRISK是一种二进制特征检测器和描述子提取器。它基于对图像进行分层，使用分块构建描述子的方法。它对旋转、光照和尺度变化具有鲁棒性。它的使用方法如下：

cv::Ptr<cv::BRISK> detector = cv::BRISK::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

4. cv::FastFeatureDetector

cv::FastFeatureDetector::create() 函数是OpenCV中的一个函数，用于创建一个FastFeatureDetector对象。

FastFeatureDetector是OpenCV中用于快速检测图像特征点的类。它基于FAST（Features from Accelerated Segment Test）算法，该算法是一种快速且稳健的特征点检测方法。

create() 函数的主要作用是根据给定的参数创建FastFeatureDetector对象。它接受一个可选的字符串参数，用于指定算法的变体。如果没有指定参数，默认使用默认变体。

以下是create()函数的一般用法：

Ptr<FastFeatureDetector> cv::FastFeatureDetector::create(
    int threshold,  // 阈值，用于判断像素是否是特征点的强度差异
    bool nonmaxSuppression = true,  // 是否执行非极大值抑制
    int type = FastFeatureDetector::TYPE_9_16  // 算法变体，默认为TYPE_9_16
);

参数说明：

threshold：用于判断像素是否是特征点的强度差异的阈值。较高的阈值将导致更少但质量较高的特征点被检测出来。
nonmaxSuppression：是否执行非极大值抑制。默认情况下，它会对检测到的特征点执行非极大值抑制，只保留局部极大值。
type：算法的变体，有三种可选值：TYPE_5_8、TYPE_7_12和TYPE_9_16。这些值分别对应于FAST算法使用5个、7个和9个相邻像素进行强度差异判断。

函数返回一个Ptr指针，指向新创建的FastFeatureDetector对象。可以使用该指针来对图像进行特征点检测。

cv::FastFeatureDetector是一种快速的特征检测器，它可以检测到图像中的角点。它基于一种简单而快速的算法，可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

5. cv::GFTTDetector

cv::GFTTDetector::create() 是 OpenCV 库中的一个函数，用于创建一个 GFTT（Good Features to Track）检测器对象。

GFTT 是一种特征点检测算法，用于在图像中寻找具有良好跟踪性能的特征点。它通过计算图像中各个像素点的角点响应值，来确定哪些点可以被认为是良好的特征点。

函数原型如下：

Ptr<GFTTDetector> cv::GFTTDetector::create(
    int maxCorners,
    double qualityLevel,
    double minDistance,
    int blockSize = 3,
    bool useHarrisDetector = false,
    double k = 0.04
)

参数说明：

maxCorners：指定最大特征点数目，即最多检测到的特征点数目。
qualityLevel：指定角点响应值的最低质量水平。仅保留具有响应值高于此阈值的角点。
minDistance：指定两个特征点之间的最小距离。如果两个特征点之间的距离小于此值，则其中一个会被删除。
blockSize：指定用于计算每个像素点的角点响应值时使用的领域块的大小。默认值为3。
useHarrisDetector：一个布尔值，用于指定是否使用 Harris 角点检测算法。如果为 true，则使用 Harris 角点检测算法计算角点响应值；如果为 false，则使用 Shi-Tomasi 角点检测算法计算角点响应值。默认值为 false。
k：用于计算 Harris 角点响应值的常数。仅当 useHarrisDetector 设置为 true 时有效。默认值为 0.04。

返回值：

返回一个指向 cv::GFTTDetector 对象的智能指针（Ptr）。可以使用该指针来调用 GFTT 检测器的其他方法和函数。

cv::GFTTDetector是一种基于Harris角点检测算法的特征检测器。它可以检测到图像中的角点，并对光照和尺度变化具有鲁棒性。它的使用方法如下：

cv::Ptr<cv::GFTTDetector> detector = cv::GFTTDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

6. cv::KAZE

cv::KAZE::create() 函数是 OpenCV 库中的一个函数，用于创建 KAZE 特征检测器和描述符提取器。KAZE 是一种基于非线性尺度空间的特征检测和描述算法，适用于计算机视觉中的图像匹配、目标跟踪和图像拼接等任务。

该函数的完整声明如下：

Ptr<KAZE> cv::KAZE::create(
    bool extended = false,
    bool upright = false,
    float threshold = 0.001f,
    int nOctaves = 4,
    int nOctaveLayers = 4,
    int diffusivity = KAZE::DIFF_PM_G2
);

下面是各个参数的详细说明：

extended：一个布尔值，表示是否使用扩展的描述符。默认为 false，表示使用默认的描述符长度（64维）。如果设置为 true，则使用扩展的描述符长度（128维）。
upright：一个布尔值，表示是否使用直立的特征。默认为 false，表示检测器会计算特征的方向。如果设置为 true，则检测器将不计算特征的方向，仅检测特征的位置。
threshold：一个浮点数，表示特征响应的阈值。默认为 0.001f。在特征检测过程中，低于此阈值的特征将被丢弃。
nOctaves：一个整数，表示尺度空间的层数。默认为 4。较高的值将导致更多的尺度空间，并提供更好的尺度不变性，但会增加计算量。
nOctaveLayers：一个整数，表示每个尺度空间层中的计算层数。默认为 4。较高的值可以提供更好的特征细节，但也会增加计算量。
diffusivity：一个整数，表示扩散类型。默认为 KAZE::DIFF_PM_G2，表示使用 PM G2 扩散类型。还可以选择其他扩散类型，如 KAZE::DIFF_PM_G1、KAZE::DIFF_WEICKERT 和 KAZE::DIFF_CHARBONNIER。

该函数返回一个指向 cv::KAZE 对象的智能指针 (Ptr<KAZE>)，可以用于对图像进行特征提取和匹配。

cv::KAZE是一种加速的特征检6. cv::KAZE（续）

测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到边缘和角点等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::KAZE> detector = cv::KAZE::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

7. cv::MSER

cv::MSER::create() 是 OpenCV 库中的一个函数，用于创建 MSER（Maximally Stable Extremal Regions）的实例。MSER 是一种用于检测图像中稳定的极值区域的算法。

以下是 cv::MSER::create() 函数的详解：

static Ptr<MSER> cv::MSER::create(
    int _delta = 5,
    int _min_area = 60,
    int _max_area = 14400,
    double _max_variation = 0.25,
    double _min_diversity = 0.2,
    int _max_evolution = 200,
    double _area_threshold = 1.01,
    double _min_margin = 0.003,
    int _edge_blur_size = 5
)

参数解释：

_delta：用于控制区域间的灰度值差异的阈值。较大的值会导致更多的区域生成，默认值为5。
_min_area：最小区域面积。较小的区域将被丢弃，默认值为60。
_max_area：最大区域面积。较大的区域将被丢弃，默认值为14400。
_max_variation：最大变化率。用于控制区域在不同尺度下的变化情况，默认值为0.25。
_min_diversity：最小多样性。控制区域之间的相似性程度，默认值为0.2。
_max_evolution：最大进化次数。控制区域的最大进化次数，默认值为200。
_area_threshold：面积阈值。用于控制区域的增长，默认值为1.01。
_min_margin：最小边缘距离。用于控制区域之间的最小边缘距离，默认值为0.003。
_edge_blur_size：边缘模糊大小。用于控制边缘模糊的卷积核大小，默认值为5。

返回值：
函数返回一个指向 MSER 对象的智能指针 (Ptr<MSER>)。

使用 cv::MSER::create() 函数可以创建一个 MSER 对象，然后可以使用该对象的其他成员函数来执行 MSER 算法的操作，例如 detectRegions 函数用于检测图像中的稳定极值区域。

cv::MSER是一种检测图像中极值区域（如连通域）的特征检测器。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::MSER> detector = cv::MSER::create();
std::vector<std::vector<cv::Point>> regions;
detector->detectRegions(image, regions);

8. cv::SimpleBlobDetector

cv::SimpleBlobDetector::create() 函数是 OpenCV 库中用于创建简单的斑点检测器的静态成员函数。该函数用于构建 cv::SimpleBlobDetector 类的实例，该类用于在图像中检测斑点（blob）。

以下是关于 cv::SimpleBlobDetector::create() 函数的详细解释：

Ptr<SimpleBlobDetector> cv::SimpleBlobDetector::create(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params())

参数：

parameters：斑点检测器的参数，是 SimpleBlobDetector::Params 类型的对象，可以根据需要进行设置。如果不提供参数，则使用默认参数。

返回值：

Ptr<SimpleBlobDetector>：指向 cv::SimpleBlobDetector 实例的智能指针。

功能：

该函数用于创建 cv::SimpleBlobDetector 类的实例，以进行斑点检测。

cv::SimpleBlobDetector是一种基于二值化图像中的斑点检测算法的特征检测器。它可以检测到图像中的圆形斑点，并可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::SimpleBlobDetector> detector = cv::SimpleBlobDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

9. cv::StarDetector

cv::StarDetector::create() 是 OpenCV 中的一个函数，用于创建 Star 特征检测器的实例。以下是该函数的详细解释：

cv::Ptr<cv::StarDetector> cv::StarDetector::create(
    int maxSize = 45,
    int responseThreshold = 30,
    int lineThresholdProjected = 10,
    int lineThresholdBinarized = 8,
    int suppressNonmaxSize = 5
)

参数说明：

maxSize：星特征的最大尺寸。默认值为 45。星特征是一种具有一组尺寸的角点，该参数指定了角点的最大尺寸。
responseThreshold：响应阈值。默认值为 30。该参数定义了特征点响应值的阈值。只有响应值大于阈值的特征点才会被检测到。
lineThresholdProjected：投影线阈值。默认值为 10。用于在二进制图像中查找线段的阈值。这些线段可用于检测角点。
lineThresholdBinarized：二值化线阈值。默认值为 8。用于在二值化图像中查找线段的阈值。同样，这些线段可用于检测角点。
suppressNonmaxSize：非最大值抑制尺寸。默认值为 5。抑制邻近特征点的距离阈值，以避免检测到过多的特征点。

返回值：

返回一个 cv::Ptr<cv::StarDetector> 对象，表示创建的 Star 特征检测器的实例。
请注意，Star 特征检测器是一种已被废弃的特征检测器，自OpenCV 3.1版本起已被标记为废弃。推荐使用更现代的特征检测器，如 SIFT、SURF 或 ORB。
cv::StarDetector是一种基于Hessian检测器的特征检测器，它可以检测到图像中的角点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::StarDetector> detector = cv::StarDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

10. cv::SIFT

cv::SIFT::create() 是 OpenCV 库中 SIFT（尺度不变特征变换）算法的创建函数。它返回一个指向 cv::SIFT 对象的智能指针，该对象可以用于检测图像中的 SIFT 特征点。

下面是对 cv::SIFT::create() 函数的详细解释：

cv::Ptr<cv::SIFT> cv::SIFT::create(
    int nfeatures = 0,
    int nOctaveLayers = 3,
    double contrastThreshold = 0.04,
    double edgeThreshold = 10,
    double sigma = 1.6
)

参数解释：

nfeatures：要检测的最大特征点数量。默认值为 0，表示检测所有的特征点。
nOctaveLayers：金字塔每组的层数。默认值为 3。
contrastThreshold：用于排除低对比度特征的阈值。默认值为 0.04。
edgeThreshold：用于排除边缘响应的阈值。默认值为 10。
sigma：高斯平滑系数。默认值为 1.6。

返回值：

cv::Ptr<cv::SIFT>：一个指向 cv::SIFT 对象的智能指针。

使用 cv::SIFT::create() 函数创建 SIFT 对象后，您可以调用该对象的其他方法来提取和处理图像中的 SIFT 特征点。一些常用的方法包括 detectAndCompute()、detect() 和 compute()。

cv::SIFT是一种基于尺度空间的特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到边缘和角点等不同类型的特征。但是，由于SIFT是基于专利算法的，因此需要注意其使用许可问题。它的使用方法如下：

cv::Ptr<cv::SIFT> detector = cv::SIFT::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

11. cv::SURF

cv::SURF::create() 是OpenCV库中的函数，用于创建一个SURF（Speeded Up Robust Features）对象，用于检测和描述图像中的特征点。

以下是对 cv::SURF::create() 函数的详细解释：

函数原型：

static Ptr<SURF> cv::SURF::create(
    double hessianThreshold = 100,
    int nOctaves = 4,
    int nOctaveLayers = 3,
    bool extended = false,
    bool upright = false
)

参数解释：

hessianThreshold：Hessian阈值，用于过滤检测到的特征点，默认值为100。较大的值会过滤掉较弱的特征点，较小的值会保留更多的特征点。
nOctaves：金字塔层数，默认值为4。金字塔层数决定了图像尺度空间的分辨率，较大的值可以检测到更小尺寸的特征点，但计算开销也会增加。
nOctaveLayers：每个金字塔层的内部层数，默认值为3。每个金字塔层的内部层数决定了特征点的数量和质量，较大的值可以检测到更多的特征点，但也会增加计算开销。
extended：扩展SURF描述符标志，默认值为false。如果设置为true，则将生成扩展的SURF描述符，长度为128维；如果设置为false，则将生成64维的SURF描述符。
upright：直立（不旋转）SURF标志，默认值为false。如果设置为true，则检测的特征点将不考虑旋转不变性，可以提高计算效率。

返回值：
该函数返回一个 Ptr<SURF> 指针，指向创建的SURF对象。可以使用该对象对图像进行特征点检测和描述。

cv::SURF是一种基于尺度空间的特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到边缘和角点等不同类型的特征。但是，由于SURF是基于专利算法的，因此需要注意其使用许可问题。它的使用方法如下：

cv::Ptr<cv::xfeatures2d::SURF> detector = cv::xfeatures2d::SURF::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

12. cv::FastFeatureDetector

cv::FastFeatureDetector::create() 是 OpenCV 库中用于创建 Fast 特征检测器对象的函数。Fast 特征检测器是一种高速的角点检测算法，常用于计算机视觉和图像处理任务中。

该函数的声明如下：

Ptr<FastFeatureDetector> cv::FastFeatureDetector::create(
    int threshold = 10,
    bool nonmaxSuppression = true,
    int type = FastFeatureDetector::TYPE_9_16
);

参数解释：

threshold：用于确定角点的阈值。较大的阈值会导致检测到的角点数量减少，而较小的阈值会导致检测到的角点数量增多。默认值为 10。
nonmaxSuppression：一个布尔值，指示是否应用非最大值抑制。如果设置为 true，将对检测到的角点应用非最大值抑制以消除重复的角点。默认值为 true。
type：Fast 特征检测器的类型。它定义了检测器使用的像素比较模式。可选的类型有：
- FastFeatureDetector::TYPE_5_8：使用 16 个像素进行比较。
- FastFeatureDetector::TYPE_7_12：使用 16 个像素进行比较。
- FastFeatureDetector::TYPE_9_16：使用 16 个像素进行比较（默认值）。

函数返回一个指向 FastFeatureDetector 对象的智能指针 (Ptr<FastFeatureDetector>)，可以通过该指针访问 Fast 特征检测器的方法和属性。

cv::FastFeatureDetector是一种基于图像亮度变化的特征检测器，它可以快速检测图像中的角点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

13. cv::AgastFeatureDetector

cv::AgastFeatureDetector::create() 是 OpenCV 中用于创建 AGAST 特征检测器对象的函数。AGAST（Adaptive and Generic Accelerated Segment Test）是一种快速的角点检测算法，可用于在图像中寻找角点或关键点。

该函数的详细解释如下：

函数原型：

Ptr<AgastFeatureDetector> cv::AgastFeatureDetector::create(
    int threshold=10,
    bool nonmaxSuppression=true,
    int type=AgastFeatureDetector::OAST_9_16
)

参数：

threshold：设置阈值，用于确定像素是否为角点。默认值为10。
nonmaxSuppression：是否应用非最大值抑制来消除冗余角点。默认值为true。
type：指定 AGAST 检测器的类型。默认值为 AgastFeatureDetector::OAST_9_16，表示使用 9/16 OAST 角点检测器。还有其他可用的选项，例如 AgastFeatureDetector::OAST_7_12d、AgastFeatureDetector::OAST_5_8 等。

返回值：
返回一个指向 AgastFeatureDetector 对象的智能指针 (Ptr)，该对象可以用于在图像中检测角点。

cv::AgastFeatureDetector是一种基于图像亮度变化的特征检测器，它可以快速检测图像中的角点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::AgastFeatureDetector> detector = cv::AgastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

14. cv::BRISK

cv::BRISK::create() 是 OpenCV 中的一个函数，用于创建 BRISK（Binary Robust Invariant Scalable Keypoints）关键点检测器和描述符提取器的实例。BRISK 是一种用于计算机视觉中特征点检测和描述的算法。

下面是对 cv::BRISK::create() 函数的详细解释：

Ptr<BRISK> cv::BRISK::create(
  int thresh,
  int octaves = 3,
  float patternScale = 1.0f
)

参数：

thresh：控制特征点检测的阈值。较小的阈值会导致更多的特征点，但可能会包括更多的噪声。较大的阈值会过滤掉一些较弱的特征点，但可能会错过一些细节。
octaves：图像金字塔的层数。较大的层数可以检测到更大尺度的特征，但也会增加计算量。
patternScale：BRISK 特征描述符计算时使用的采样尺度。

返回值：

Ptr<BRISK>：返回 BRISK 关键点检测器和描述符提取器的实例指针。

cv::BRISK是一种二进制特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::BRISK> detector = cv::BRISK::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

15. cv::ORB

cv::ORB::create() 是 OpenCV 库中的一个函数，用于创建 ORB（Oriented FAST and Rotated BRIEF）特征检测器和描述子生成器的实例。ORB 是一种计算机视觉算法，结合了 FAST 特征检测器和 BRIEF 描述子生成器，并在此基础上进行了改进，以提供更好的速度和性能。

以下是关于 cv::ORB::create() 函数的详细解释：

函数原型：

Ptr<ORB> cv::ORB::create(
    int nfeatures = 500,
    float scaleFactor = 1.2f,
    int nlevels = 8,
    int edgeThreshold = 31,
    int firstLevel = 0,
    int WTA_K = 2,
    int scoreType = ORB::HARRIS_SCORE,
    int patchSize = 31,
    int fastThreshold = 20
)

参数说明：

nfeatures：表示期望检测到的特征点数量，默认为 500。实际检测到的特征点数量可能会小于这个值。
scaleFactor：表示金字塔图像之间的尺度因子，默认为 1.2f。用于生成多尺度图像金字塔。
nlevels：表示金字塔图像的层数，默认为 8。每一层都是通过对前一层图像进行下采样得到的。
edgeThreshold：表示边缘阈值，默认为 31。用于在计算图像中的角点时过滤掉边缘响应较弱的像素。
firstLevel：表示金字塔的起始层索引，默认为 0。通常设置为 0，表示从最底层开始检测特征。
WTA_K：表示计算描述子时使用的像素比较数量，默认为 2。可以设置为 2 或 3，分别表示使用 2 比特或 3 比特的 BRIEF 描述子。
scoreType：表示计算特征点角度响应函数时使用的得分类型，默认为 ORB::HARRIS_SCORE。还可以选择 ORB::FAST_SCORE，根据 FAST 角点检测器的得分计算角度响应。
patchSize：表示计算 BRIEF 描述子的像素邻域大小，默认为 31。通常与 FAST 特征检测器的邻域大小一致。
fastThreshold：表示 FAST 特征检测器的响应阈值，默认为 20。用于检测特征点。

返回值：

Ptr<ORB>：返回 ORB 特征检测器和描述子生成器的实例指针。

cv::ORB是一种二进制特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::ORB> detector = cv::ORB::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

16. cv::MSER

cv::MSER::create() 是 OpenCV 库中的一个函数，用于创建基于极值区域的区域检测器（Maximally Stable Extremal Regions，简称 MSER）。MSER 是一种常用的图像分割算法，用于检测图像中稳定的连通区域。

以下是关于 cv::MSER::create() 函数的详细解释：

cv::Ptr<cv::MSER> cv::MSER::create(
    int delta = 5,
    int min_area = 60,
    int max_area = 14400,
    double max_variation = 0.25,
    double min_diversity = 0.2,
    int max_evolution = 200,
    double area_threshold = 1.01,
    double min_margin = 0.003,
    int edge_blur_size = 5
)

该函数返回一个 cv::Ptr<cv::MSER> 对象，可以用于创建 MSER 区域检测器。
参数说明：

delta：delta 参数用于指定灰度值的变化阈值。默认值为 5，表示灰度值变化超过 5 的像素将被认为是一个极值区域的一部分。
min_area：min_area 参数指定了最小的区域面积。默认值为 60，表示小于 60 个像素的区域将被忽略。
max_area：max_area 参数指定了最大的区域面积。默认值为 14400，表示大于 14400 个像素的区域将被忽略。
max_variation：max_variation 参数用于指定区域的灰度值变化率。默认值为 0.25，表示灰度值变化率超过 0.25 的区域将被忽略。
min_diversity：min_diversity 参数指定了区域的多样性。默认值为 0.2，表示多样性小于 0.2 的区域将被忽略。
max_evolution：max_evolution 参数指定了区域的最大演化步数。默认值为 200，表示最多进行 200 步演化。
area_threshold：area_threshold 参数用于指定区域的面积阈值。默认值为 1.01，表示面积相似度超过 1.01 的区域将被合并。
min_margin：min_margin 参数指定了区域的最小边缘距离。默认值为 0.003，表示边缘距离小于 0.003 的区域将被合并。
edge_blur_size：edge_blur_size 参数用于指定边缘模糊的尺寸。默认值为 5，表示边缘尺寸为 5x5。

这些参数可以根据具体应用的需求进行调整，以获得最佳的区域检测结果。

cv::MSER是一种基于图像区域的特征检测器，它可以快速检测图像中的稳定区域。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::MSER> detector = cv::MSER::create();
std::vector<std::vector<cv::Point>> regions;
detector->detectRegions(image, regions);

17. cv::GFTTDetector

cv::GFTTDetector::create()是OpenCV库中的一个函数，用于创建GFTT（Good Features to Track）角点检测器的实例。以下是该函数的详细解释：

cv::Ptr<cv::GFTTDetector> cv::GFTTDetector::create(
    int maxCorners, // 要检测的最大角点数
    double qualityLevel, // 角点的最小可接受质量水平
    double minDistance, // 角点之间的最小欧几里得距离
    int blockSize, // 角点检测中使用的领域块的大小
    bool useHarrisDetector = false, // 是否使用Harris角点检测器（默认为false）
    double k = 0.04 // Harris角点检测器的自由参数k
);

参数解释：

maxCorners：要检测的最大角点数。这是指在图像中找到的最强角点的数量上限。
qualityLevel：角点的最小可接受质量水平。它是一个0到1之间的值，表示作为角点的像素的质量阈值。只有那些大于此阈值的像素才会被认为是角点。
minDistance：角点之间的最小欧几里得距离。如果两个角点之间的距离小于此值，则其中一个角点将被抑制。这可以帮助确保在稠密角点区域只选择最强的角点。
blockSize：角点检测中使用的领域块的大小。在计算角点响应函数时，该参数指定了每个像素的相邻区域的大小。
useHarrisDetector：一个布尔值，指定是否使用Harris角点检测器。如果设置为true，则使用Harris角点检测器，否则使用Shi-Tomasi角点检测器。默认值为false。
k：Harris角点检测器的自由参数k。对于Harris角点检测器，它是角点响应函数的自由参数，其值一般在0.04到0.06之间。

返回值：

一个指向cv::GFTTDetector实例的智能指针（cv::Ptr<cv::GFTTDetector>）。

cv::GFTTDetector是一种基于图像梯度的特征检测器，它可以快速检测图像中的角点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::GFTTDetector> detector = cv::GFTTDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

18. cv::SimpleBlobDetector

cv::SimpleBlobDetector::create() 函数是 OpenCV 库中用于创建简单斑点检测器的静态方法。它返回一个指向 cv::Ptr<cv::SimpleBlobDetector> 的智能指针，该指针指向创建的检测器对象。通过该对象，可以对图像进行斑点检测，并提取图像中的斑点信息。

以下是 cv::SimpleBlobDetector::create() 函数的详细解释：

static Ptr<SimpleBlobDetector> create(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params())

参数：

parameters：一个可选参数，用于设置斑点检测器的参数。它是 SimpleBlobDetector::Params 类型的对象，默认为空。

返回值：

cv::Ptr<cv::SimpleBlobDetector> 智能指针，指向创建的简单斑点检测器对象。

cv::SimpleBlobDetector是一种基于图像二值化的特征检测器，它可以检测图像中的斑点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::SimpleBlobDetector::Params params;
cv::Ptr<cv::SimpleBlobDetector> detector = cv::SimpleBlobDetector::create(params);
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

19. cv::KAZE

cv::KAZE::create() 是 OpenCV 中的函数，用于创建 KAZE 特征检测器对象。KAZE（“KApaZey”）是一种基于尺度不变特征变换（Scale-Invariant Feature Transform，简称 SIFT）的特征描述子。下面是有关 cv::KAZE::create() 函数的详细说明：

cv::Ptr<cv::KAZE> cv::KAZE::create(
    bool extended = false,
    bool upright = false,
    float threshold = 0.001f,
    int nOctaves = 4,
    int nOctaveLayers = 4,
    int diffusivity = KAZE::DIFF_PM_G2
)

参数解释：

extended（可选）：表示是否使用扩展的 KAZE 描述子，默认值为 false。如果设置为 true，则描述子的维度将增加，提供更多的特征信息。
upright（可选）：表示是否使用无方向（upright）的 KAZE 描述子，默认值为 false。如果设置为 true，则描述子将不包含方向信息。
threshold（可选）：表示特征点检测的阈值，默认值为 0.001f。该阈值决定了特征点的质量，较低的阈值会产生更多的特征点。
nOctaves（可选）：表示图像金字塔的层数，默认值为 4。较大的值会产生更多的尺度空间，但也会增加计算量。
nOctaveLayers（可选）：表示每个金字塔层的内插间隔数，默认值为 4。增加该值可以提高特征点的密度，但也会增加计算量。
diffusivity（可选）：表示扩散方程类型，影响特征点的尺度选择行为，默认值为 KAZE::DIFF_PM_G2。其他可选值包括 KAZE::DIFF_PM_G1、KAZE::DIFF_WEICKERT 和 KAZE::DIFF_CHARBONNIER。

返回值：
该函数返回一个指向 cv::KAZE 对象的智能指针 (cv::Ptr)。

使用 cv::KAZE::create() 函数可以方便地创建 KAZE 特征检测器对象，并根据需要设置相关参数。特征检测器对象可以用于提取图像中的特征点及其描述子，以进行各种计算机视觉任务，如特征匹配、图像拼接等。

cv::KAZE是一种基于尺度空间的特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::KAZE> detector = cv::KAZE::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

20. cv::AKAZE

cv::AKAZE::create() 函数是 OpenCV 库中的一个函数，用于创建 AKAZE (Accelerated-KAZE) 特征检测器和描述符提取器的实例。AKAZE 是一种针对图像特征检测和描述符提取的算法，它在 KAZE (Kanade-Lucas-Tomasi 特征检测器和描述符提取器) 的基础上进行了改进和优化。

函数原型如下：

Ptr<AKAZE> cv::AKAZE::create(
    int descriptor_type = AKAZE::DESCRIPTOR_MLDB,
    int descriptor_size = 0,
    int descriptor_channels = 3,
    float threshold = 0.001f,
    int nOctaves = 4,
    int nOctaveLayers = 4,
    int diffusivity = KAZE::DIFF_PM_G2
)

下面是各个参数的详细说明：

descriptor_type：描述符类型，可以是以下常量之一：
- AKAZE::DESCRIPTOR_KAZE_UPRIGHT：未旋转的 KAZE 描述符 (64 维)。
- AKAZE::DESCRIPTOR_KAZE：KAZE 描述符 (128 维)。
- AKAZE::DESCRIPTOR_MLDB_UPRIGHT：未旋转的 MLDB 描述符 (48 维)。
- AKAZE::DESCRIPTOR_MLDB：MLDB 描述符 (64 维)。
descriptor_size：描述符维度大小，默认为 0，表示使用默认的维度大小。如果指定了非零值，将会重新计算描述符的大小。
descriptor_channels：描述符的通道数，默认为 3。可以是 1、2 或 3。对于颜色图像，可以使用 3 个通道，对于灰度图像，可以使用 1 个通道。
threshold：特征点检测阈值，默认为 0.001f。用于控制提取的特征点的数量。值越小，提取的特征点越多。
nOctaves：图像金字塔的层数，默认为 4。金字塔层数越多，尺度空间范围越广，可以检测到更多尺度的特征。
nOctaveLayers：每个金字塔层的子层数，默认为 4。每个子层都是一个尺度空间。
diffusivity：扩散系数，默认为 KAZE::DIFF_PM_G2。扩散系数控制图像的扩散过程，可以选择 KAZE::DIFF_PM_G1、KAZE::DIFF_WEICKERT 或 KAZE::DIFF_CHARBONNIER。

函数返回一个指向 AKAZE 类型的智能指针 Ptr<AKAZE>，可以用于调用 AKAZE 类中的其他成员函数，如 detectAndCompute 来检测图像中的特征点并计算其描述符。

cv::AKAZE是一种基于尺度空间的特征检测器和描述子提取器，它可以在不同的图像尺度下检测稳定的关键点，并提取描述子。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。与cv::KAZE相比，cv::AKAZE可以更好地处理鲁棒性和旋转不变性。它的使用方法如下：

cv::Ptr<cv::AKAZE> detector = cv::AKAZE::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
detector->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

21. cv::AgastFeatureDetector

cv::AgastFeatureDetector::create() 是 OpenCV 库中的一个函数，用于创建 AGAST 特征检测器的实例。AGAST（Adaptive and Generic Accelerated Segment Test）是一种用于特征检测的快速算法。

函数原型如下：

Ptr<AgastFeatureDetector> cv::AgastFeatureDetector::create(
    int threshold = 10,
    bool nonmaxSuppression = true,
    AgastType type = AGAST_9_16
)

该函数返回一个 Ptr<AgastFeatureDetector> 对象，该对象是一个智能指针，指向 AGAST 特征检测器的实例。

函数参数解释：

threshold：特征点检测的阈值。只有当像素与其邻域像素之间的差异大于该阈值时，才会被视为特征点。默认值为 10。
nonmaxSuppression：是否进行非最大值抑制。如果设置为 true，则在检测到特征点后，将在周围的邻域内选择具有最大响应的特征点。默认为 true。
type：AGAST 算法的类型。可以选择不同的类型，例如 AGAST_5_8、AGAST_7_12d、AGAST_7_12s、OAST_9_16 等。默认为 AGAST_9_16。

cv::AgastFeatureDetector是一种快速的角点检测器，它可以在不同的图像尺度下检测稳定的角点。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::AgastFeatureDetector> detector = cv::AgastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

22. cv::FastFeatureDetector

cv::FastFeatureDetector::create() 是 OpenCV 中用于创建 FastFeatureDetector 类的静态函数。FastFeatureDetector 是一个快速特征检测器，用于在图像中找到关键点（特征点）。下面是该函数的详细解释：

Ptr<FastFeatureDetector> cv::FastFeatureDetector::create(
    int threshold,        // 阈值，用于确定特征点的强度
    bool nonmaxSuppression = true,   // 是否应用非最大值抑制
    int type = FastFeatureDetector::TYPE_9_16  // 使用的模板类型
)

函数参数的解释如下：

threshold：阈值是用于确定特征点的强度的参数。如果某个像素与其周围像素的灰度差超过阈值，则该像素被视为特征点。
nonmaxSuppression：非最大值抑制是一个布尔值，指示是否应用非最大值抑制。如果设置为 true，则在检测到特征点后，会根据像素强度进行非最大值抑制，以消除冗余特征点。
type：模板类型是用于计算特征点的模板的类型。OpenCV 提供了几种不同的模板类型，如 FastFeatureDetector::TYPE_5_8、FastFeatureDetector::TYPE_7_12 和 FastFeatureDetector::TYPE_9_16 等。

返回值是一个指向 FastFeatureDetector 对象的智能指针 (Ptr<FastFeatureDetector>)，可以使用该指针来操作和调用 FastFeatureDetector 类的其他函数。

cv::FastFeatureDetector是一种快速的角点检测器，它可以在不同的图像尺度下检测稳定的角点。它对光照和视角变化具有鲁棒性，并且可以检测到角点和边缘等不同类型的特征。它的使用方法如下：

cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

23. cv::StarDetector

cv::StarDetector::create() 是 OpenCV 库中用于创建 STAR 特征检测器的函数。STAR（Scale-invariant Feature Transform）是一种用于在图像中检测关键点的特征描述算法。

函数的完整声明如下：

cv::Ptr<cv::StarDetector> cv::StarDetector::create(
    int maxSize = 45,
    int responseThreshold = 30,
    int lineThresholdProjected = 10,
    int lineThresholdBinarized = 8,
    int suppressNonmaxSize = 5
)

参数说明：

maxSize：关键点的最大尺度。默认值为 45。
responseThreshold：响应阈值，用于过滤关键点。默认值为 30。
lineThresholdProjected：检测线特征的投影阈值。默认值为 10。
lineThresholdBinarized：检测线特征的二值化阈值。默认值为 8。
suppressNonmaxSize：非极大值抑制的邻域尺寸。默认值为 5。

函数返回一个指向 cv::StarDetector 类的智能指针，通过该指针可以使用 STAR 特征检测器。

cv::StarDetector是一种基于灰度图像的特征检测器，它可以快速检测稳定的特征点。它对光照和视角变化具有鲁棒性，并且可以在不同的图像尺度下进行特征检测。它的使用方法如下：

cv::Ptr<cv::StarDetector> detector = cv::StarDetector::create();
std::vector<cv::KeyPoint> keypoints;
detector->detect(image, keypoints);

描述子匹配类

在这里插入图片描述

FLANN,最快邻近区特征匹配方法，是一种快速匹配方法，在进行批量特征匹配时，FLANN速度更快。但是FLANN使用的是邻近近似值，所以精度较差。
如果我们想图像的精确匹配就用BF匹配方法，如果我们想要速度就用FLANN匹配方法。

24. cv::FlannBasedMatcher

cv::FlannBasedMatcher::create()是OpenCV中用于创建基于Flann算法的特征匹配器对象的函数。Flann算法是一种快速的近似最近邻搜索算法，可以用于高效地匹配特征点。

以下是该函数的详细解释：

函数原型：

Ptr<FlannBasedMatcher> cv::FlannBasedMatcher::create(const IndexParams& indexParams = DEFAULT_INDEX_PARAMS, const SearchParams& searchParams = DEFAULT_SEARCH_PARAMS)

参数：

indexParams：一个IndexParams类型的参数，用于指定Flann索引的参数。可以使用默认参数DEFAULT_INDEX_PARAMS，或者根据具体需求自定义参数。
searchParams：一个SearchParams类型的参数，用于指定Flann搜索的参数。同样可以使用默认参数DEFAULT_SEARCH_PARAMS，或者自定义参数。

返回值：

一个指向FlannBasedMatcher对象的智能指针(Ptr)。

使用cv::FlannBasedMatcher::create()函数可以创建一个基于Flann算法的特征匹配器对象，如下所示：

Ptr<FlannBasedMatcher> matcher = FlannBasedMatcher::create();

然后，您可以使用这个特征匹配器对象来进行特征点匹配，例如：

std::vector<std::vector<DMatch>> matches;
matcher->knnMatch(descriptor1, descriptor2, matches, k);

其中，descriptor1和descriptor2是要匹配的特征描述符，matches是一个存储匹配结果的二维向量，k是要匹配的最近邻个数。

总结：cv::FlannBasedMatcher::create()函数用于创建基于Flann算法的特征匹配器对象，可以根据需要自定义索引参数和搜索参数。创建的特征匹配器对象可以用于进行特征点匹配。

cv::FlannBasedMatcher是一种基于快速最近邻搜索（FLANN）算法的特征匹配器，它可以对两幅图像中的特征点进行匹配。它的使用方法如下：

cv::Ptr<cv::FlannBasedMatcher> matcher = cv::FlannBasedMatcher::create();
std::vector<cv::DMatch> matches;
matcher->match(descriptors1, descriptors2, matches);

25. cv::BFMatcher

cv::BFMatcher::create() 是 OpenCV 库中的一个函数，用于创建 Brute-Force 匹配器（BFMatcher）。BFMatcher 是一种基于暴力搜索的特征匹配方法，它可以在给定的特征描述符集合中进行最近邻搜索。

函数原型如下：

Ptr<BFMatcher> cv::BFMatcher::create(int normType = NORM_L2, bool crossCheck = false)

参数说明：

normType：用于计算特征描述符之间距离的规范化类型。默认值为 NORM_L2，表示使用欧氏距离计算特征距离。还可以选择 NORM_L1（曼哈顿距离）和 NORM_HAMMING（汉明距离）。
crossCheck：布尔值，指定是否使用交叉验证。如果为 true，则仅返回相互匹配的最佳匹配对。

返回值：

返回一个指向 BFMatcher 对象的智能指针（Ptr<BFMatcher>）。

使用 BFMatcher 进行特征匹配的一般步骤如下：

提取关键点和计算特征描述符（例如，使用 cv::ORB、cv::SIFT、cv::SURF 等算法）。
创建 BFMatcher 对象，可以通过 cv::BFMatcher::create() 来完成。
使用 BFMatcher 的 match 函数对两组特征描述符进行匹配，得到匹配对。
根据匹配对进行进一步处理或分析。

cv::BFMatcher是一种基于暴力匹配算法的特征匹配器，它可以对两幅图像中的特征点进行匹配。与cv::FlannBasedMatcher相比，cv::BFMatcher的计算速度较慢，但在某些情况下可能会产生更准确的匹配结果。它的使用方法如下：

cv::Ptr<cv::BFMatcher> matcher = cv::BFMatcher::create();
std::vector<cv::DMatch> matches;
matcher->match(descriptors1, descriptors2, matches);

在OpenCV中，NormTypes并不直接与特征点检测算法相关联。NormTypes是用于指定距离度量类型的枚举，主要用于特征匹配和描述符之间的距离计算。
特征点检测算法本身通常不依赖于NormTypes中的距离类型。它们主要关注于检测图像中的关键点或特征，并生成对应的描述符。这些描述符可以与其他特征描述符进行匹配，而匹配时的距离度量可以使用NormTypes中的距离类型。

SIFT（尺度不变特征变换）：
- 描述符距离度量类型：cv::NORM_L1和cv::NORM_L2
SURF（加速稳健特征）：
- 描述符距离度量类型：cv::NORM_L1和cv::NORM_L2
ORB（Oriented FAST and Rotated BRIEF）：
- 描述符距离度量类型：cv::NORM_HAMMING、cv::NORM_HAMMING2
BRISK（Binary Robust Invariant Scalable Keypoints）：
- 描述符距离度量类型：cv::NORM_HAMMING、cv::NORM_HAMMING2
AKAZE（Accelerated-KAZE）：
- 描述符距离度量类型：cv::NORM_HAMMING、cv::NORM_HAMMING2
FREAK（Fast Retina Keypoint）：
- 描述符距离度量类型：cv::NORM_HAMMING、cv::NORM_HAMMING2

这是 OpenCV 中提供的两种主要的特征匹配器。在进行特征匹配时，需要先通过特征检测器和描述子提取器提取出图像中的特征点和描述子，然后再通过特征匹配器进行匹配。匹配结果可以通过一些后处理方法进行筛选和优化，例如 RANSAC 算法和基础矩阵估计算法等。

总的来说，特征检测器和描述子提取器是计算机视觉中非常重要的工具，它们可以帮助我们快速地从图像中提取出关键信息，并用于图像配准、目标跟踪、三维重建、图像检索等多种应用。在实际应用中，需要根据不同的应用和场景选择合适的特征检测器和描述子提取器，并结合一些优化方法进行参数调节和性能评估。

26. drawMatches 绘制匹配的特征点

drawMatches函数是OpenCV中用于绘制两个图像之间匹配特征点的函数。它将两个图像中的特征点连接起来，并在结果图像中绘制这些连接线。

函数原型如下：

void drawMatches(
    InputArray img1, // 第一幅图像
    const std::vector<KeyPoint>& keypoints1, // 第一幅图像的特征点
    InputArray img2, // 第二幅图像
    const std::vector<KeyPoint>& keypoints2, // 第二幅图像的特征点
    const std::vector<DMatch>& matches, // 特征点匹配结果
    OutputArray outImg, // 输出的匹配结果图像
    const Scalar& matchColor = Scalar::all(-1), // 连接线的颜色
    const Scalar& singlePointColor = Scalar::all(-1), // 特征点的颜色
    const std::vector<char>& matchesMask = std::vector<char>(), // 特征点匹配掩码
    int flags = DrawMatchesFlags::DEFAULT // 绘制匹配特征点的标志
);

参数说明：

img1：第一幅图像（可以是灰度图像或彩色图像）
keypoints1：第一幅图像的特征点，类型为std::vector<KeyPoint>，每个特征点包含其坐标和其他属性。
img2：第二幅图像（与img1具有相同的类型）
keypoints2：第二幅图像的特征点，与keypoints1具有相同的类型。
matches：特征点匹配结果，类型为std::vector<DMatch>，表示两幅图像之间的特征点匹配。
outImg：输出的匹配结果图像，类型为OutputArray。
matchColor：连接线的颜色，可以指定为Scalar类型的值，默认为Scalar::all(-1)表示随机颜色。
singlePointColor：特征点的颜色，可以指定为Scalar类型的值，默认为Scalar::all(-1)表示随机颜色。
matchesMask：掩码向量，用于标识哪些匹配是有效的。长度应与matches1to2的长度相同，默认为空。
flags：绘制匹配的标志，可以是以下值的组合：
- DrawMatchesFlags::DEFAULT：默认标志，显示所有匹配。
- DrawMatchesFlags::DRAW_OVER_OUTIMG：在outImg上绘制匹配，默认是在空白图像上绘制。
- DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS：不绘制单个特征点。
- DrawMatchesFlags::DRAW_RICH_KEYPOINTS：绘制特征点的大小和方向。
  = Scalar::all(-1), // 连接线的颜色
  const Scalar& singlePointColor = Scalar::all(-1), // 特征点的颜色
  const std::vector& matchesMask = std::vector(), // 特征点匹配掩码
  int flags = DrawMatchesFlags::DEFAULT // 绘制匹配特征点的标志
  );


参数说明：

- `img1`：第一幅图像（可以是灰度图像或彩色图像）
- `keypoints1`：第一幅图像的特征点，类型为`std::vector<KeyPoint>`，每个特征点包含其坐标和其他属性。
- `img2`：第二幅图像（与`img1`具有相同的类型）
- `keypoints2`：第二幅图像的特征点，与`keypoints1`具有相同的类型。
- `matches`：特征点匹配结果，类型为`std::vector<DMatch>`，表示两幅图像之间的特征点匹配。
- `outImg`：输出的匹配结果图像，类型为`OutputArray`。
- `matchColor`：连接线的颜色，可以指定为`Scalar`类型的值，默认为`Scalar::all(-1)`表示随机颜色。
- `singlePointColor`：特征点的颜色，可以指定为`Scalar`类型的值，默认为`Scalar::all(-1)`表示随机颜色。
- `matchesMask`：掩码向量，用于标识哪些匹配是有效的。长度应与`matches1to2`的长度相同，默认为空。
- `flags`：绘制匹配的标志，可以是以下值的组合：
  - `DrawMatchesFlags::DEFAULT`：默认标志，显示所有匹配。
  - `DrawMatchesFlags::DRAW_OVER_OUTIMG`：在`outImg`上绘制匹配，默认是在空白图像上绘制。
  - `DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS`：不绘制单个特征点。
  - `DrawMatchesFlags::DRAW_RICH_KEYPOINTS`：绘制特征点的大小和方向。
使用`drawMatches`函数可以方便地将特征点匹配结果可视化，帮助我们分析和理解特征点匹配的效果。