线特征教程

在本教程中，将展示如何：

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

直线提取和描述符计算

在以下代码片段中，展示了如何从图像中检测直线。LSD 提取器使用 LSD_REFINE_ADV 选项进行初始化；其余参数保留其默认值。使用全 1 掩码以接受所有提取的直线，最后，对第 0 层金字塔（octave 0）提取的直线使用随机颜色进行显示。

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用之前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果您不同意本许可协议，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 用于 OpenCV (Open Source Computer Vision Library)
 //
 // Copyright (C) 2014, Biagio Montesano, 保留所有权利。
 // 第三方版权归其各自所有者所有。
 //
 // 在满足以下条件的情况下，允许以源码和二进制形式重新分发和使用，无论是否经过修改：
 // 需满足以下条件：
 //
 // * 源码的再分发必须保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 二进制形式的再分发必须在分发包提供的文档
 // 和/或其他材料中保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 未经事先具体书面许可，不得使用版权持有人的名称来认可或推广
 // 衍生自本软件的产品。
 //
 // 本软件由版权持有人及贡献者“按原样”提供，不提供任何明示或暗示的保证，包括但不限于
 // 对适销性和特定用途适用性的暗示保证。
 // 在任何情况下，Intel 公司或贡献者均不对任何直接、
 // 间接、附带、特殊、典型或后果性损害
 // （包括但不限于替代商品或服务的采购；
 // 使用、数据或利润损失；或业务中断）承担责任，无论其是如何造成的，
 // 且基于任何责任理论，无论是合同、严格责任、
 // 或侵权行为（包括疏忽或其他原因），即使已被告知
 // 存在此类损害的可能性。
 //M*/
 //
 //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 | | 图像路径 }" };
 
static void help()
{
 cout << "\n本示例展示了 BinaryDescriptor 类提供的直线提取功能\n"
 << "请使用如下格式的命令运行本示例：\n" << "./example_line_descriptor_lines_extraction <输入图像路径>" << 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;
  }
 
 /* 创建一个全 1 二进制掩码 */
 cv::Mat mask = Mat::ones( imageMat.size(), CV_8UC1 );
 
 /* 使用默认参数创建 LSDDetector 对象的指针 */
 Ptr<LSDDetector> bd = LSDDetector::createLSDDetector();
 
 /* 创建一个结构来存储提取的直线 */
 vector<KeyLine> lines;
 
 /* 提取直线 */
 cv::Mat output = imageMat.clone();
 bd->detect( imageMat, lines, 2, 1, mask );
 
 /* 绘制从 octave 0 提取的直线 */
 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 检测器在摄影师图片上再次返回的结果

替换文本

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

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用之前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果您不同意本许可协议，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 用于 OpenCV (Open Source Computer Vision Library)
 //
 // Copyright (C) 2014, Biagio Montesano, 保留所有权利。
 // 第三方版权归其各自所有者所有。
 //
 // 在满足以下条件的情况下，允许以源码和二进制形式重新分发和使用，无论是否经过修改：
 // 需满足以下条件：
 //
 // * 源码的再分发必须保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 二进制形式的再分发必须在分发包提供的文档
 // 和/或其他材料中保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 未经事先具体书面许可，不得使用版权持有人的名称来认可或推广
 // 衍生自本软件的产品。
 //
 // 本软件由版权持有人及贡献者“按原样”提供，不提供任何明示或暗示的保证，包括但不限于
 // 对适销性和特定用途适用性的暗示保证。
 // 在任何情况下，Intel 公司或贡献者均不对任何直接、
 // 间接、附带、特殊、典型或后果性损害
 // （包括但不限于替代商品或服务的采购；
 // 使用、数据或利润损失；或业务中断）承担责任，无论其是如何造成的，
 // 且基于任何责任理论，无论是合同、严格责任、
 // 或侵权行为（包括疏忽或其他原因），即使已被告知
 // 存在此类损害的可能性。
 //M*/
 //
 //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 | | 图像路径 }" };
 
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///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用之前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果您不同意本许可协议，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 用于 OpenCV (Open Source Computer Vision Library)
 //
 // Copyright (C) 2014, Biagio Montesano, 保留所有权利。
 // 第三方版权归其各自所有者所有。
 //
 // 在满足以下条件的情况下，允许以源码和二进制形式重新分发和使用，无论是否经过修改：
 // 需满足以下条件：
 //
 // * 源码的再分发必须保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 二进制形式的再分发必须在分发包提供的文档
 // 和/或其他材料中保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 未经事先具体书面许可，不得使用版权持有人的名称来认可或推广
 // 衍生自本软件的产品。
 //
 // 本软件由版权持有人及贡献者“按原样”提供，不提供任何明示或暗示的保证，包括但不限于
 // 对适销性和特定用途适用性的暗示保证。
 // 在任何情况下，Intel 公司或贡献者均不对任何直接、
 // 间接、附带、特殊、典型或后果性损害
 // （包括但不限于替代商品或服务的采购；
 // 使用、数据或利润损失；或业务中断）承担责任，无论其是如何造成的，
 // 且基于任何责任理论，无论是合同、严格责任、
 // 或侵权行为（包括疏忽或其他原因），即使已被告知
 // 存在此类损害的可能性。
 //M*/
 //
 //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;
 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;
 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, Size( imageMat1.cols / 2, imageMat1.rows / 2 ), 0, 0, INTER_LINEAR_EXACT );
 resize( imageMat2, imageMat2, 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, Scalar::all( -1 ), Scalar::all( -1 ), lsd_mask,
 DrawLinesMatchesFlags::DEFAULT );
 
 imshow( "LSD matches", lsd_outImg );
 waitKey();
 
 
}
 
#else
 
int main()
{
 std::cerr << "OpenCV 编译时未包含 features2d 模块" << 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 );

这是一个在从原始摄影师图像提取的描述符与其降采样（并模糊）版本之间进行匹配的示例

替换文本

查询内部数据库

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

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用之前请阅读。
 //
 // 下载、复制、安装或使用本软件即表示您同意本许可协议。
 // 如果您不同意本许可协议，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可协议
 // 用于 OpenCV (Open Source Computer Vision Library)
 //
 // Copyright (C) 2014, Biagio Montesano, 保留所有权利。
 // 第三方版权归其各自所有者所有。
 //
 // 在满足以下条件的情况下，允许以源码和二进制形式重新分发和使用，无论是否经过修改：
 // 需满足以下条件：
 //
 // * 源码的再分发必须保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 二进制形式的再分发必须在分发包提供的文档
 // 和/或其他材料中保留上述版权声明、
 // 此条件列表以及以下免责声明。
 //
 // * 未经事先具体书面许可，不得使用版权持有人的名称来认可或推广
 // 衍生自本软件的产品。
 //
 // 本软件由版权持有人及贡献者“按原样”提供，不提供任何明示或暗示的保证，包括但不限于
 // 对适销性和特定用途适用性的暗示保证。
 // 在任何情况下，Intel 公司或贡献者均不对任何直接、
 // 间接、附带、特殊、典型或后果性损害
 // （包括但不限于替代商品或服务的采购；
 // 使用、数据或利润损失；或业务中断）承担责任，无论其是如何造成的，
 // 且基于任何责任理论，无论是合同、严格责任、
 // 或侵权行为（包括疏忽或其他原因），即使已被告知
 // 存在此类损害的可能性。
 //M*/
 //
 //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 | | 图像路径 }" };
 
static void help()
{
 std::cout << "\n本示例展示了半径匹配（radius matching）的功能 " << "请使用如下格式的命令运行本示例：\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