直线特征教程

本教程将展示如何

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

直线提取和描述符计算

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

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前请阅读。
 //
 // 通过下载、复制、安装或使用本软件，即表示您同意本许可证。
 // 如果您不同意本许可证，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可证协议
 // 针对开源计算机视觉库
 //
 // 版权所有 (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 | | 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提取的直线 */
 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

这是从著名的摄影师图像中获得的结果

替代文本

另一种提取直线的方法是使用 LSDDetector 类；此类使用 LSD 提取器计算直线。要获得此结果，只需使用上述代码片段，并对其进行如下修改：

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

以下是 LSD 检测器在摄影师图片上再次返回的结果

替代文本

一旦检测到关键直线，就可以计算它们的描述符，如下所示：

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前请阅读。
 //
 // 通过下载、复制、安装或使用本软件，即表示您同意本许可证。
 // 如果您不同意本许可证，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可证协议
 // 针对开源计算机视觉库
 //
 // 版权所有 (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 | | Image path }" };
 
static void help()
{
 std::cout << "\n本示例展示了BinaryDescriptor类提供的直线提取和描述符计算功能。\n"
 << "请使用如下形式的命令运行此示例：\n" << "./example_line_descriptor_compute_descriptors <path_to_input_image>"
 << 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, 保留所有权利。
 // 第三方版权归其各自所有者所有。
 //
 // 只要满足以下条件，就允许以源代码和二进制形式进行再分发和使用，无论是否修改：
 // * 源代码的再分发必须保留上述版权声明、
 //
 // 本条件列表和以下免责声明。
 // * 二进制形式的再分发必须在随分发提供的文档
 //
 // 和/或其他材料中复制上述版权声明、
 // 本条件列表和以下免责声明。
 // * 未经事先书面许可，不得使用版权持有人的名称来认可或推广
 //
 // 源自本软件的产品。
 // 本软件由版权持有人和贡献者“按原样”提供，
 //
 // 并且不提供任何明示或暗示的保证，包括但不限于适销性
 // 和特定用途适用性的暗示保证。
 // 在任何情况下，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 <path_to_input_image 1>"
 << "<path_to_input_image 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( "匹配", 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 匹配", 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 );

这是一个从原始摄影师图像及其下采样（和模糊）版本中提取的描述符匹配示例

替代文本

查询内部数据库

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

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前请阅读。
 //
 // 通过下载、复制、安装或使用本软件，即表示您同意本许可证。
 // 如果您不同意本许可证，请勿下载、安装、
 // 复制或使用本软件。
 //
 //
 // 许可证协议
 // 针对开源计算机视觉库
 //
 // 版权所有 (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本示例展示了半径匹配的功能。请使用如下形式的命令运行此示例：\n"
 << "./example_line_descriptor_radius_matching <path_to_input_images>/" << 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