线特征教程

本教程将演示如何

• 使用BinaryDescriptor接口提取线段并将其存储在KeyLine对象中
• 使用相同的接口为每个提取的线段计算描述符
• 使用BynaryDescriptorMatcher确定从不同图像获得的描述符之间的匹配

线段提取和描述符计算

以下代码片段演示了如何从图像中检测线段。LSD 提取器使用LSD_REFINE_ADV选项初始化；其余参数保留其默认值。为了接受所有提取的线段，使用了全为一的掩码，最后使用 0 八度音阶的随机颜色显示这些线段。

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：下载、复制、安装或使用前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果你不同意本许可协议，请不要下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 适用于开源计算机视觉库
 //
 // 版权所有 (C) 2014，Biagio Montesano，保留所有权利。
 // 第三方版权属于其各自所有者。
 //
 // 允许重新分发和使用源代码和二进制形式的软件，无论是否修改，
 // 只要满足以下条件：
 //
 // * 源代码的再分发必须保留上述版权声明，
 // 此条件列表和以下免责声明。
 //
 // * 二进制形式的再分发必须在文档中复制上述版权声明，
 // 此条件列表和以下免责声明
 // 和/或与分发一起提供的其他材料。
 //
 // * 未经事先明确的书面许可，不得使用版权所有者的名称来认可或推广
 // 从本软件派生的产品。
 //
 // 本软件由版权持有人和贡献者“按现状”提供，
 // 任何明示或暗示的保证，包括但不限于对适销性和特定用途适用性的暗示保证，均被免除。
 // 英特尔公司或贡献者在任何情况下均不对任何直接的、
 // 间接的、偶然的、特殊的、惩罚性的或间接的损害赔偿负责
 // (包括但不限于替代商品或服务的采购；
 // 使用损失、数据损失或利润损失；或业务中断) 无论其原因如何
 // 并基于任何责任理论，无论是在合同中、严格责任中、
 // 或侵权行为 (包括疏忽或其他) 以任何方式产生于
 // 本软件的使用，即使已被告知此类损害的可能性。
 //
 //
 //M*/
 
#include <iostream>
#include <opencv2/opencv_modules.hpp>
 
#ifdef HAVE_OPENCV_FEATURES2D
 
#include <opencv2/line_descriptor.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/highgui.hpp>
 
using namespace cv;
using namespace cv::line_descriptor;
using namespace std;
 
static const char* keys =
{ "{@image_path | | Image path }" };
 
static void help()
{
 cout << "\n此示例演示了BinaryDescriptor类提供的线段提取功能\n"
 << "请使用以下形式的命令运行此示例：\n" << "./example_line_descriptor_lines_extraction <path_to_input_image>" << endl;
}
 
int main( int argc, char** argv )
{
 /* 从命令行获取参数 */
 CommandLineParser parser( argc, argv, keys );
 String image_path = parser.get<String>( 0 );
 
 if( image_path.empty() )
  {
 help();
 return -1;
  }
 
 /* 加载图像 */
 cv::Mat imageMat = imread( image_path, 1 );
 if( imageMat.data == NULL )
  {
 std::cout << "错误，图像无法加载。请检查其路径" << std::endl;
 return -1;
  }
 
 /* 创建一个随机二值掩码 */
 cv::Mat mask = Mat::ones( imageMat.size(), CV_8UC1 );
 
 /* 使用默认参数创建一个指向BinaryDescriptor对象的指针 */
 Ptr<LSDDetector> bd = LSDDetector::createLSDDetector();
 
 /* 创建一个结构体来存储提取的线段 */
 vector<KeyLine> lines;
 
 /* 提取线段 */
 cv::Mat output = imageMat.clone();
 bd->detect( imageMat, lines, 2, 1, mask );
 
 /* 绘制从第0个octave提取的线段 */
 if( output.channels() == 1 )
 cvtColor( output, output, COLOR_GRAY2BGR );
 for ( size_t i = 0; i < lines.size(); i++ )
  {
 KeyLine kl = lines[i];
 if( kl.octave == 0)
    {
 /* 获取随机颜色 */
 int R = ( rand() % (int) ( 255 + 1 ) );
 int G = ( rand() % (int) ( 255 + 1 ) );
 int B = ( rand() % (int) ( 255 + 1 ) );
 
 /* 获取线段的端点 */
 Point pt1 = Point2f( kl.startPointX, kl.startPointY );
 Point pt2 = Point2f( kl.endPointX, kl.endPointY );
 
 /* 绘制线段 */
 line( output, pt1, pt2, Scalar( B, G, R ), 3 );
    }
 
  }
 
 /* 在图像上显示线段 */
 imshow( "LSD lines", output );
 waitKey();
}
 
#else
 
int main()
{
 std::cerr << "OpenCV 构建时未包含 features2d 模块" << std::endl;
 return 0;
}
 
#endif // HAVE_OPENCV_FEATURES2D

这是从著名的 cameraman 图像中获得的结果

替换文本

另一种提取线的方法是使用 *LSDDetector* 类；此类使用 LSD 提取器来计算线。要获得此结果，只需修改上面的代码片段即可。

// 创建指向 LSDDetector 对象的指针
Ptr<LSDDetector> lsd = LSDDetector::createLSDDetector();
 
// 计算线
std::vector<KeyLine> keylines;
lsd->detect( imageMat, keylines, mask );

这是 LSD 检测器再次在 cameraman 图片上返回的结果

替换文本

检测到关键线后，可以计算它们的描述符，如下所示

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：下载、复制、安装或使用前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果你不同意本许可协议，请不要下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 适用于开源计算机视觉库
 //
 // 版权所有 (C) 2014，Biagio Montesano，保留所有权利。
 // 第三方版权属于其各自所有者。
 //
 // 允许重新分发和使用源代码和二进制形式的软件，无论是否修改，
 // 只要满足以下条件：
 //
 // * 源代码的再分发必须保留上述版权声明，
 // 此条件列表和以下免责声明。
 //
 // * 二进制形式的再分发必须在文档中复制上述版权声明，
 // 此条件列表和以下免责声明
 // 和/或与分发一起提供的其他材料。
 //
 // * 未经事先明确的书面许可，不得使用版权所有者的名称来认可或推广
 // 从本软件派生的产品。
 //
 // 本软件由版权持有人和贡献者“按现状”提供，
 // 任何明示或暗示的保证，包括但不限于对适销性和特定用途适用性的暗示保证，均被免除。
 // 英特尔公司或贡献者在任何情况下均不对任何直接的、
 // 间接的、偶然的、特殊的、惩罚性的或间接的损害赔偿负责
 // (包括但不限于替代商品或服务的采购；
 // 使用损失、数据损失或利润损失；或业务中断) 无论其原因如何
 // 并基于任何责任理论，无论是在合同中、严格责任中、
 // 或侵权行为 (包括疏忽或其他) 以任何方式产生于
 // 本软件的使用，即使已被告知此类损害的可能性。
 //
 //
 //M*/
 
#include <iostream>
#include <opencv2/opencv_modules.hpp>
 
#ifdef HAVE_OPENCV_FEATURES2D
 
#include <opencv2/line_descriptor.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/highgui.hpp>
 
using namespace cv;
using namespace cv::line_descriptor;
 
 
static const char* keys =
{ "{@image_path | | Image path }" };
 
static void help()
{
 std::cout << "\n此示例演示了 BinaryDescriptor 类提供的线提取和描述符计算功能\n"
 << "请使用以下形式的命令运行此示例：\n" << "./example_line_descriptor_compute_descriptors <输入图像路径>"
 << std::endl;
}
 
int main( int argc, char** argv )
{
 /* 从命令行获取参数 */
 CommandLineParser parser( argc, argv, keys );
 String image_path = parser.get<String>( 0 );
 
 if( image_path.empty() )
  {
 help();
 return -1;
  }
 
 /* 加载图像 */
 cv::Mat imageMat = imread( image_path, 1 );
 if( imageMat.data == NULL )
  {
 std::cout << "错误，图像无法加载。请检查其路径" << std::endl;
  }
 
 /* 创建二进制掩码 */
 cv::Mat mask = Mat::ones( imageMat.size(), CV_8UC1 );
 
 /* 创建一个指向具有默认参数的 BinaryDescriptor 对象的指针 */
 Ptr<BinaryDescriptor> bd = BinaryDescriptor::createBinaryDescriptor();
 
 /* 计算线 */
 std::vector<KeyLine> keylines;
 bd->detect( imageMat, keylines, mask );
 
 /* 计算描述符 */
 cv::Mat descriptors;
 
 bd->compute( imageMat, keylines, descriptors);
 
}
 
#else
 
int main()
{
 std::cerr << "OpenCV 是没有 features2d 模块构建的" << std::endl;
 return 0;
}
 
#endif // HAVE_OPENCV_FEATURES2D

描述符之间的匹配

如果我们已经从两张不同的图像中提取了描述符，则可以在它们之间搜索匹配项。一种方法是将一个描述符精确地匹配到每个输入查询描述符，选择距离最近的一个

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：下载、复制、安装或使用前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果你不同意本许可协议，请不要下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 适用于开源计算机视觉库
 //
 // 版权所有 (C) 2014，Biagio Montesano，保留所有权利。
 // 第三方版权属于其各自所有者。
 //
 // 允许重新分发和使用源代码和二进制形式的软件，无论是否修改，
 // 只要满足以下条件：
 //
 // * 源代码的再分发必须保留上述版权声明，
 // 此条件列表和以下免责声明。
 //
 // * 二进制形式的再分发必须在文档中复制上述版权声明，
 // 此条件列表和以下免责声明
 // 和/或与分发一起提供的其他材料。
 //
 // * 未经事先明确的书面许可，不得使用版权所有者的名称来认可或推广
 // 从本软件派生的产品。
 //
 // 本软件由版权持有人和贡献者“按现状”提供，
 // 任何明示或暗示的保证，包括但不限于对适销性和特定用途适用性的暗示保证，均被免除。
 // 英特尔公司或贡献者在任何情况下均不对任何直接的、
 // 间接的、偶然的、特殊的、惩罚性的或间接的损害赔偿负责
 // (包括但不限于替代商品或服务的采购；
 // 使用损失、数据损失或利润损失；或业务中断) 无论其原因如何
 // 并基于任何责任理论，无论是在合同中、严格责任中、
 // 或侵权行为 (包括疏忽或其他) 以任何方式产生于
 // 本软件的使用，即使已被告知此类损害的可能性。
 //
 //
 //M*/
 
#include <iostream>
#include <opencv2/opencv_modules.hpp>
 
#ifdef HAVE_OPENCV_FEATURES2D
 
#include <opencv2/line_descriptor.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/highgui.hpp>
 
#define MATCHES_DIST_THRESHOLD 25
 
using namespace cv;
using namespace cv::line_descriptor;
 
static const char* keys =
{ "{@image_path1 | | 图像路径 1 }"
 "{@image_path2 | | 图像路径 2 }" };
 
static void help()
{
 std::cout << "\n此示例演示了 BinaryDescriptor 类提供的线提取和描述符计算功能\n"
 << "请使用以下形式的命令运行此示例：\n" << "./example_line_descriptor_compute_descriptors <输入图像路径 1>"
 << "<输入图像路径 2>" << std::endl;
 
}
 
int main( int argc, char** argv )
{
 /* 从命令行获取参数 */
 CommandLineParser parser( argc, argv, keys );
 String image_path1 = parser.get<String>( 0 );
 String image_path2 = parser.get<String>( 1 );
 
 if( image_path1.empty() || image_path2.empty() )
  {
 help();
 return -1;
  }
 
 /* 加载图像 */
 cv::Mat imageMat1 = imread( image_path1, 1 );
 cv::Mat imageMat2 = imread( image_path2, 1 );
 
 if( imageMat1.data == NULL || imageMat2.data == NULL )
  {
 std::cout << "错误，图像无法加载。请检查路径" << std::endl;
  }
 
 /* 创建二值掩码 */
 cv::Mat mask1 = Mat::ones( imageMat1.size(), CV_8UC1 );
 cv::Mat mask2 = Mat::ones( imageMat2.size(), CV_8UC1 );
 
 /* 创建一个使用默认参数的BinaryDescriptor对象指针 */
 Ptr<BinaryDescriptor> bd = BinaryDescriptor::createBinaryDescriptor( );
 
 /* 计算线段和描述子 */
 std::vector<KeyLine> keylines1, keylines2;
 cv::Mat descr1, descr2;
 
 ( *bd )( imageMat1, mask1, keylines1, descr1, false, false );
 ( *bd )( imageMat2, mask2, keylines2, descr2, false, false );
 
 /* 选择第一组八度中的关键线及其描述子 */
 std::vector<KeyLine> lbd_octave1, lbd_octave2;
 Mat left_lbd, right_lbd;
 for ( int i = 0; i < (int) keylines1.size(); i++ )
  {
 if( keylines1[i].octave == 0 )
    {
 lbd_octave1.push_back( keylines1[i] );
 left_lbd.push_back( descr1.row( i ) );
    }
  }
 
 for ( int j = 0; j < (int) keylines2.size(); j++ )
  {
 if( keylines2[j].octave == 0 )
    {
 lbd_octave2.push_back( keylines2[j] );
 right_lbd.push_back( descr2.row( j ) );
    }
  }
 
 /* 创建一个BinaryDescriptorMatcher对象 */
 Ptr<BinaryDescriptorMatcher> bdm = BinaryDescriptorMatcher::createBinaryDescriptorMatcher();
 
 /* 匹配 */
 std::vector<DMatch> matches;
 bdm->match( left_lbd, right_lbd, matches );
 
 /* 选择最佳匹配 */
 std::vector<DMatch> good_matches;
 for ( int i = 0; i < (int) matches.size(); i++ )
  {
 if( matches[i].distance < MATCHES_DIST_THRESHOLD )
 good_matches.push_back( matches[i] );
  }
 
 /* 绘制匹配结果 */
 cv::Mat outImg;
 cv::Mat scaled1, scaled2;
 std::vector<char> mask( matches.size(), 1 );
 drawLineMatches( imageMat1, lbd_octave1, imageMat2, lbd_octave2, good_matches, outImg, Scalar::all( -1 ), Scalar::all( -1 ), mask,
 DrawLinesMatchesFlags::DEFAULT );
 
 imshow( "Matches", outImg );
 waitKey();
 imwrite("/home/ubisum/Desktop/images/env_match/matches.jpg", outImg);
 /* 创建一个LSD检测器 */
 Ptr<LSDDetector> lsd = LSDDetector::createLSDDetector();
 
 /* 检测线段 */
 `std::vector<KeyLine> klsd1, klsd2;`
 `cv::Mat lsd_descr1, lsd_descr2;`
 `lsd->detect(imageMat1, klsd1, 2, 2, mask1);`
 `lsd->detect(imageMat2, klsd2, 2, 2, mask2);`
 
 /* 计算第一组八度图像的描述符 */
 `bd->compute(imageMat1, klsd1, lsd_descr1);`
 `bd->compute(imageMat2, klsd2, lsd_descr2);`
 
 /* 选择第一组八度图像的线段和描述符 */
 `std::vector<KeyLine> octave0_1, octave0_2;`
 `cv::Mat leftDEscr, rightDescr;`
 `for (int i = 0; i < (int)klsd1.size(); i++)`
  {
 `if (klsd1[i].octave == 1)`
    {
 `octave0_1.push_back(klsd1[i]);`
 `leftDEscr.push_back(lsd_descr1.row(i));`
    }
  }
 
 `for (int j = 0; j < (int)klsd2.size(); j++)`
  {
 `if (klsd2[j].octave == 1)`
    {
 `octave0_2.push_back(klsd2[j]);`
 `rightDescr.push_back(lsd_descr2.row(j));`
    }
  }
 
 /* 计算匹配 */
 `std::vector<DMatch> lsd_matches;`
 `bdm->match(leftDEscr, rightDescr, lsd_matches);`
 
 /* 选择最佳匹配 */
 `good_matches.clear();`
 `for (int i = 0; i < (int)lsd_matches.size(); i++)`
  {
 `if (lsd_matches[i].distance < MATCHES_DIST_THRESHOLD)`
 `good_matches.push_back(lsd_matches[i]);`
  }
 
 /* 绘制匹配结果 */
 `cv::Mat lsd_outImg;`
 `resize(imageMat1, imageMat1, cv::Size(imageMat1.cols / 2, imageMat1.rows / 2), 0, 0, INTER_LINEAR_EXACT);`
 `resize(imageMat2, imageMat2, cv::Size(imageMat2.cols / 2, imageMat2.rows / 2), 0, 0, INTER_LINEAR_EXACT);`
 `std::vector<char> lsd_mask(matches.size(), 1);`
 `drawLineMatches(imageMat1, octave0_1, imageMat2, octave0_2, good_matches, lsd_outImg, cv::Scalar::all(-1), cv::Scalar::all(-1), lsd_mask,`
 `DrawLinesMatchesFlags::DEFAULT);`
 
 `imshow("LSD matches", lsd_outImg);`
 `waitKey();`
 
 
}
 
#else
 
`int main()`
{
 `std::cerr << "OpenCV was built without features2d module" << std::endl;`
 `return 0;`
}
 
#endif // HAVE_OPENCV_FEATURES2D

有时，我们可能感兴趣的是搜索给定输入描述符后最近的 *k* 个描述符。这需要稍微修改之前的代码

// 准备一个结构来保存匹配结果
`std::vector<std::vector<DMatch> > matches;`
 
// 需要knn匹配
`bdm->knnMatch(descr1, descr2, matches, 6);`

在上面的例子中，对于每个查询，返回最近的6个描述符。在某些情况下，我们可以有一个搜索半径，并查找距离输入查询最多 *r* 的所有描述符。之前的代码必须修改为：

// 准备一个结构来保存匹配结果
`std::vector<std::vector<DMatch> > matches;`
 
// 计算匹配
`bdm->radiusMatch(queries, matches, 30);`

这是一个在从原始cameraman图像及其降采样（和模糊）版本中提取的描述符之间进行匹配的示例

替换文本

查询内部数据库

BynaryDescriptorMatcher 类拥有一个内部数据库，可以填充从不同图像中提取的描述符，并使用上一节中描述的一种模式进行查询。内部数据集的填充可以使用 `add` 函数完成；该函数不会直接向数据库添加新数据，而只是将它们本地存储。当调用 `train` 函数或执行任何查询函数时，实际的更新才会发生，因为它们中的每一个都会在查询之前调用 `train`。查询时，内部数据库不仅返回所需的描述符，而且对于每个返回的匹配项，它都能确定匹配描述符是从哪个图像中提取的。以下代码描述了内部数据集使用的一个示例；在本地添加新的描述符后，将调用半径搜索。这会触发将本地数据传输到数据集，然后对数据集进行查询。

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：下载、复制、安装或使用前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果你不同意本许可协议，请不要下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 适用于开源计算机视觉库
 //
 // 版权所有 (C) 2014，Biagio Montesano，保留所有权利。
 // 第三方版权属于其各自所有者。
 //
 // 允许重新分发和使用源代码和二进制形式的软件，无论是否修改，
 // 只要满足以下条件：
 //
 // * 源代码的再分发必须保留上述版权声明，
 // 此条件列表和以下免责声明。
 //
 // * 二进制形式的再分发必须在文档中复制上述版权声明，
 // 此条件列表和以下免责声明
 // 和/或与分发一起提供的其他材料。
 //
 // * 未经事先明确的书面许可，不得使用版权所有者的名称来认可或推广
 // 从本软件派生的产品。
 //
 // 本软件由版权持有人和贡献者“按现状”提供，
 // 任何明示或暗示的保证，包括但不限于对适销性和特定用途适用性的暗示保证，均被免除。
 // 英特尔公司或贡献者在任何情况下均不对任何直接的、
 // 间接的、偶然的、特殊的、惩罚性的或间接的损害赔偿负责
 // (包括但不限于替代商品或服务的采购；
 // 使用损失、数据损失或利润损失；或业务中断) 无论其原因如何
 // 并基于任何责任理论，无论是在合同中、严格责任中、
 // 或侵权行为 (包括疏忽或其他) 以任何方式产生于
 // 本软件的使用，即使已被告知此类损害的可能性。
 //
 //
 //M*/
 
#include <iostream>
#include <opencv2/opencv_modules.hpp>
 
#ifdef HAVE_OPENCV_FEATURES2D
 
#include <opencv2/line_descriptor.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/highgui.hpp>
 
#include <vector>
 
using namespace cv;
using namespace cv::line_descriptor;
 
static const std::string images[] =
{ "cameraman.jpg", "church.jpg", "church2.png", "einstein.jpg", "stuff.jpg" };
 
static const char* keys =
{ "{@image_path | | Image path }" };
 
static void help()
{
 std::cout << "\n此示例演示了半径匹配的功能，请使用以下格式的命令运行此示例：\n"
 << "./example_line_descriptor_radius_matching <输入图像路径>/" << std::endl;
}
 
int main( int argc, char** argv )
{
 /* 从命令行获取参数 */
 CommandLineParser parser( argc, argv, keys );
 String pathToImages = parser.get < String > ( 0 );
 
 /* 创建用于存储 KeyLines 和描述符的结构 */
 int num_elements = sizeof ( images ) / sizeof ( images[0] );
 std::vector < Mat > descriptorsMat;
 std::vector < std::vector<KeyLine> > linesMat;
 
 /* 创建指向 BinaryDescriptor 对象的指针 */
 Ptr < BinaryDescriptor > bd = BinaryDescriptor::createBinaryDescriptor();
 
 /* 计算线和描述符 */
 for ( int i = 0; i < num_elements; i++ )
  {
 /* 获取图像路径 */
 std::stringstream image_path;
 image_path << pathToImages << images[i];
 std::cout << image_path.str().c_str() << std::endl;
 
 /* 加载图像 */
 Mat loadedImage = imread( image_path.str().c_str(), 1 );
 if( loadedImage.data == NULL )
    {
 std::cout << "无法加载图像。" << std::endl;
 help();
 exit( -1 );
    }
 
 /* 计算线和描述符 */
 std::vector < KeyLine > lines;
 Mat computedDescr;
 bd->detect( loadedImage, lines );
 bd->compute( loadedImage, lines, computedDescr );
 
 descriptorsMat.push_back( computedDescr );
 linesMat.push_back( lines );
 
  }
 
 /* 组成查询矩阵 */
 Mat queries;
 for ( size_t j = 0; j < descriptorsMat.size(); j++ )
  {
 if( descriptorsMat[j].rows >= 5 )
 queries.push_back( descriptorsMat[j].rowRange( 0, 5 ) );
 
 else if( descriptorsMat[j].rows > 0 && descriptorsMat[j].rows < 5 )
 queries.push_back( descriptorsMat[j] );
  }
 
 std::cout << "已生成一个包含 " << queries.rows << " 个描述符的矩阵" << std::endl;
 
 /* 创建 BinaryDescriptorMatcher 对象 */
 Ptr < BinaryDescriptorMatcher > bdm = BinaryDescriptorMatcher::createBinaryDescriptorMatcher();
 
 /* 填充匹配器 */
 bdm->add( descriptorsMat );
 
 /* 计算匹配项 */
 std::vector < std::vector<DMatch> > matches;
 bdm->radiusMatch( queries, matches, 30 );
 std::cout << "匹配样本大小 " << matches.size() << std::endl;
 
 for ( int i = 0; i < (int) matches.size(); i++ )
  {
 for ( int j = 0; j < (int) matches[i].size(); j++ )
    {
 std::cout << "匹配：" << matches[i][j].queryIdx << " " << matches[i][j].trainIdx << " " << matches[i][j].distance << std::endl;
    }
 
  }
 
}
 
#else
 
int main()
{
 std::cerr << "OpenCV 构建时未包含 features2d 模块" << std::endl;
 return 0;
}
 
#endif // HAVE_OPENCV_FEATURES2D