线特征教程

本教程将展示如何

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

线提取和描述符计算

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

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前务必阅读。
 //
 // 通过下载、复制、安装或使用此软件，即表示您已同意此许可。
 // 如果你不接受此许可，请不要下载、安装、
 // 复制或使用此软件。
 //
 //
 // 许可协议
 // 适用于 OpenCV 库
 //
 // 版权所有 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 << "\nThis example shows the functionalities of lines extraction " << "furnished by BinaryDescriptor class\n"
 << "Please, run this sample using a command in the form\n" << "./example_line_descriptor_lines_extraction <path_to_input_image>" << endl;
}
 
int main( int argc, char** argv )
{
 /* get parameters from comand line */
 CommandLineParser parser( argc, argv, keys );
 String image_path = parser.get<String>( 0 );
 
 if( image_path.empty() )
  {
 help();
 return -1;
  }
 
 /* load image */
 cv::Mat imageMat = imread( image_path, 1 );
 if( imageMat.data == NULL )
  {
 std::cout << "Error, image could not be loaded. Please, check its path" << std::endl;
 返回 -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 倍频程中提取的线段 */
 如果(output.channels() == 1)
 cvtColor(output, output, COLOR_GRAY2BGR);
 对于 (size_t i = 0; i < lines.size(); i++)
  {
 KeyLine kl = lines[i];
 如果(kl.octave == 0)
    {
 /* 获取随机颜色 */
 int R = (rand() % (int)(255 + 1));
 int G = (rand() % (int)(255 + 1));
 int B = (rand() % (int)(255 + 1));
 
 /* 获得线段极值 */
 点 pt1 = Point2f(kl.startPointX, kl.startPointY);
 点 pt2 = Point2f(kl.endPointX, kl.endPointY);
 
 /* 线绘制 */
 线(输出, pt1, pt2, 标量(B, G, R), 3);
    }
 
  }
 
 /* 图像上显示线 */
 imshow("LSD lines", 输出);
 waitKey();
}
 
#else
 
int main()
{
 std::cerr << "OpenCV was built without features2d module" << 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 图像上返回的再次执行结果

替换文本

一旦检测到 keylines，就可以按照以下内容计算它们描述符

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前务必阅读。
 //
 // 通过下载、复制、安装或使用此软件，即表示您已同意此许可。
 // 如果你不接受此许可，请不要下载、安装、
 // 复制或使用此软件。
 //
 //
 // 许可协议
 // 适用于 OpenCV 库
 //
 // 版权所有 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 << "\nThis example shows the functionalities of lines extraction " << "and descriptors computation furnished by BinaryDescriptor class\n"
 << "Please, run this sample using a command in the form\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///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前务必阅读。
 //
 // 通过下载、复制、安装或使用此软件，即表示您已同意此许可。
 // 如果你不接受此许可，请不要下载、安装、
 // 复制或使用此软件。
 //
 //
 // 许可协议
 // 适用于 OpenCV 库
 //
 // 版权所有 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 | | Image path 1 }"
 "{@image_path2 | | Image path 2 }" };
 
static void help()
{
 std::cout << "\nThis example shows the functionalities of lines extraction " << "and descriptors computation furnished by BinaryDescriptor class\n"
 << "Please, run this sample using a command in the form\n" << "./example_line_descriptor_compute_descriptors <path_to_input_image 1>"
 << "<path_to_input_image 2>" << std::endl;
 
}
 
int main( int argc, char** argv )
{
 /* get parameters from command line */
 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();
 返回 -1;
  }
 
 /* 加载图像 */
 cv::Mat imageMat1 = imread( image_path1, 1 );
 cv::Mat imageMat2 = imread( image_path2, 1 );
 
 如果( 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;
 对于 ( int i = 0; i < (int) keylines1.size(); i++ )
  {
 如果( keylines1[i].八度 == 0 )
    {
 lbd_octave1.压回( keylines1[i] );
 left_lbd.压回(descr1.行( i ) );
    }
  }
 
 对于 ( int j = 0; j < (int) keylines2.大小(); j++ )
  {
 如果( keylines2[j].八度 == 0 )
    {
 lbd_octave2.压回( keylines2[j] );
 right_lbd.压回( descr2.行( j ) );
    }
  }
 
 /* 创建一个 BinaryDescriptorMatcher 对象 */
 Ptr<BinaryDescriptorMatcher> bdm = BinaryDescriptorMatcher::createBinaryDescriptorMatcher();
 
 /* 需要匹配 */
 std::vector<DMatch> 匹配;
 bdm->匹配( left_lbd, right_lbd, 匹配 );
 
 /* 选择最佳匹配 */
 std::vector<DMatch> 好_匹配;
 对于 ( int i = 0; i < (int) 匹配.大小(); i++ )
  {
 如果( 匹配[i].距离 < 匹配距离阈值 )
 好_匹配.压回( 匹配[i] );
  }
 
 /* 绘制匹配点 */
 cv::Mat 输出图像;
 cv::Mat 缩放1，缩放2;
 std::vector<char> 掩码( 匹配.大小(), 1 );
 绘制直线匹配( imageMat1, lbd_octave1, imageMat2, lbd_octave2, 好_匹配, 输出图像, Scalar::all( -1 ), Scalar::all( -1 ), 掩码,
 绘制直线匹配标志::默认 );
 
 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 ) );
    }
  }
 
 /* compute matches */
 std::vector<DMatch> lsd_matches;
 bdm->match( leftDEscr, rightDescr, lsd_matches );
 
 /* select best 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] );
  }
 
 /* plot matches */
 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 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///////////////////////////////////////////////////////////////////////////////////////
 //
 // 重要提示：在下载、复制、安装或使用前务必阅读。
 //
 // 通过下载、复制、安装或使用此软件，即表示您已同意此许可。
 // 如果你不接受此许可，请不要下载、安装、
 // 复制或使用此软件。
 //
 //
 // 许可协议
 // 适用于 OpenCV 库
 //
 // 版权所有 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 << "\nThis example shows the functionalities of radius matching " << "\nPlease, run this sample using a command in the form\n"
 << "./example_line_descriptor_radius_matching <path_to_input_images>/" << std::endl;
}
 
int main( int argc, char** argv )
{
 /* get parameters from comand line */
 CommandLineParser parser( argc, argv, keys );
 String pathToImages = parser.get < String > ( 0 );
 
 /* create structures for hosting KeyLines and descriptors */
 int num_elements = sizeof ( images ) / sizeof ( images[0] );
 std::vector < Mat > descriptorsMat;
 std::vector < std::vector<KeyLine> > linesMat;
 
 /*create a pointer to a BinaryDescriptor object */
 Ptr < BinaryDescriptor > bd = BinaryDescriptor::createBinaryDescriptor();
 
 /* compute lines and descriptors */
 for ( int i = 0; i < num_elements; i++ )
  {
 /* get path to image */
 std::stringstream image_path;
 image_path << pathToImages << images[i];
 std::cout << image_path.str().c_str() << std::endl;
 
 /* load image */
 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 << "size matches sample " << matches.size() << std::endl;
 
 对于 ( int i = 0; i < (int) 匹配.大小(); i++ )
  {
 for ( int j = 0; j < (int) matches[i].size(); j++ )
    {
 std::cout << "match: " << matches[i][j].queryIdx << " " << matches[i][j].trainIdx << " " << matches[i][j].distance << std::endl;
    }
 
  }
 
}
 
#else
 
int main()
{
 std::cerr << "OpenCV was built without features2d module" << std::endl;
 return 0;
}
 
#endif // HAVE_OPENCV_FEATURES2D