OpenCV开发笔记六十五红胖子8分钟带你深入了解ORB特征点图文并茂浅显易懂程序源码

65次阅读

共计 8133 个字符，预计需要花费 21 分钟才能阅读完成。

若该文为原创文章，未经允许不得转载
原博主博客地址：https://blog.csdn.net/qq21497936
原博主博客导航：https://blog.csdn.net/qq21497936/article/details/102478062
本文章博客地址：https://blog.csdn.net/qq21497936/article/details/106926496
各位读者，知识无穷而人力有穷，要么改需求，要么找专业人士，要么自己研究
红胖子 (红模仿) 的博文大全：开发技术集合（包含 Qt 实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬结合等等）持续更新中…（点击传送门）

OpenCV 开发专栏（点击传送门）

上一篇：《OpenCV 开发笔记（六十四）：红胖子 8 分钟带你深入了解 SURF 特征点（图文并茂 + 浅显易懂 + 程序源码）》
下一篇：持续补充中…

前言

  红胖子，来也！
  识别除了传统的模板匹配之外就是体征点了，前面介绍了 Suft 特征点，还有一个传统的就会 ORB 特征点了。
  其实识别的特征点多种多样，既可以自己写也可以使用 opencv 为我们提供的，一般来说根据特征点的特性和效率，选择适合我们场景的特征就可以了。
  本篇，介绍 ORB 特征提取。

Demo

  
  
  
  

ORB 特征点

概述

  ORB 是 ORiented Brief 的简称，是 briedf 算法的改进版，于 2011 年在《ORB：an fficient alternative to SIFT or SURF》中提出。
ORB 算法分为两部分，分别是特征点提取和特征点描述：

  • 特征提取：由 FAST（Features from Accelerated Segment Test）算法发展来的；
  • 特征点描述：根据 BRIEF（Binary Robust IndependentElementary Features）特征描述算法改进的。

  ORB 特征是将 FAST 特征点的检测方法与 BRIEF 特征描述子结合起来，并在它们原来的基础上做了改进与优化。据说，ORB 算法的速度是 sift 的 100 倍，是 surf 的 10 倍。

Brief 描述子

  该特征描述子是在特征点附近随机选取若干点对，将这些点对的灰度值的大小，组合成一个二进制串，组合成一个二进制传，并将这个二进制串作为该特征点的特征描述子。
  Brief 的速度快，但是使用灰度值作为描述字计算的源头，毫无疑问会有一些显而易见的问题：

  • 旋转后灰度变了导致无法识别，因其不具备旋转不变形；
  • 由于是计算灰度，噪声灰度化则无法去噪，所以对噪声敏感；
  • 尺度不同影响灰度计算，所以也不具备尺度不变形；

ORB 是试图使其具备旋转不变性和降低噪声敏感度而提出的。

特征检测步骤

步骤一：使用 brief 算子的方式初步提取。

  该步能够提取大量的特征点，但是有很大一部分的特征点的质量不高。从图像中选取一点 P，以 P 为圆心画一个半径为 N 像素半径的圆。圆周上如果有连续 n 个像素点的灰度值比 P 点的灰度值大或者小，则认为 P 为特征点。
  

步骤二：机器学习的方法筛选最优特征点。

  通俗来说就是使用 ID3 算法训练一个决策树，将特征点圆周上的 16 个像素输入决策树中，以此来筛选出最优的 FAST 特征点。

步骤三：非极大值抑制去除局部较密集特征点。

  使用非极大值抑制算法去除临近位置多个特征点的问题。为每一个特征点计算出其响应大小。计算方式是特征点 P 和其周围 16 个特征点偏差的绝对值和。在比较临近的特征点中，保留响应值较大的特征点，删除其余的特征点。

步骤四：使用金字塔来实现多尺度不变形。

步骤五：使用图像的矩判断特征点的旋转不变性

  ORB 算法提出使用矩（moment）法来确定 FAST 特征点的方向。也就是说通过矩来计算特征点以 r 为半径范围内的质心，特征点坐标到质心形成一个向量作为该特征点的方向。

ORB 类的使用

cv::Ptr<cv::ORB> _pOrb = cv::ORB::create();
std::vector<cv::KeyPoint> keyPoints1;
// 特征点检测
_pOrb->detect(srcMat, keyPoints1);

ORB 相关函数原型

static Ptr<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);
  • 参数一：int 类型的 nfeatures，用于 ORB 的，保留最大的关键点数，默认值 500；
  • 参数二：float 类型的 scaleFactor，比例因子，大于 1 时为金字塔抽取比。的等于 2 表示经典的金字塔，每一个下一层的像素比上一层少 4 倍，但是比例系数太大了将显著降低特征匹配分数。另一方面，太接近 1 个比例因子这意味着要覆盖一定的范围，你需要更多的金字塔级别，所以速度会受影响的，默认值 1.2f；
  • 参数三：int 类型的 nlevels，nlevels 金字塔级别的数目。最小级别的线性大小等于输入图像线性大小 / 功率（缩放因子，nlevels- 第一级），默认值为 8；
  • 参数四：int 类型的 edgeThreshold，edgeThreshold 这是未检测到功能的边框大小。它应该大致匹配 patchSize 参数。；
  • 参数五：int 类型的 firstLevel，要将源图像放置到的金字塔级别。以前的图层已填充使用放大的源图像；
  • 参数六：int 类型的 WTA_K，生成定向简短描述符的每个元素的点数。这个默认值 2 是指取一个随机点对并比较它们的亮度，所以我们得到 0 / 1 的响应。其他可能的值是 3 和 4。例如，3 表示我们取 3 随机点（当然，这些点坐标是随机的，但是它们是由预定义的种子，因此简短描述符的每个元素都是从像素确定地计算出来的矩形），找到最大亮度点和获胜者的输出索引（0、1 或 2）。如此输出将占用 2 位，因此需要一个特殊的汉明距离变量，表示为 NORM_HAMMING2（每箱 2 位）。当 WTA_K= 4 时，我们取 4 个随机点计算每个点 bin（也将占用可能值为 0、1、2 或 3 的 2 位）。；
  • 参数七：int 类型的 scoreType，HARRIS_SCORES 表示使用 HARRIS 算法对特征进行排序（分数写入 KeyPoint::score，用于保留最佳 nfeatures 功能）；FAST_SCORE 是产生稍微不稳定关键点的参数的替代值，但计算起来要快一点；
  • 参数八：int 类型的 patchSize，定向简短描述符使用的修补程序的大小。当然，在较小的金字塔层特征覆盖的感知图像区域将更大；
  • 参数九：int 类型的 fastThreshold，快速阈值；
void xfeatures2d::SURT::detect( InputArray image,
                                std::vector<KeyPoint>& keypoints,
                                InputArray mask=noArray());
  • 参数一：InputArray 类型的 image，输入 cv::Mat；
  • 参数二：std::Vector<KeyPoint> 类型的 keypoints，检测到的关键点；
  • 参数三：InputArray 类型的 mask，默认为空，指定在何处查找关键点的掩码（可选）。它必须是 8 位整数感兴趣区域中具有非零值的矩阵。；
void xfeatures2d::SURT::compute( InputArray image,
                                 std::vector<KeyPoint>& keypoints,
                                 OutputArray descriptors );
    • 参数一：InputArray 类型的 image，输入 cv::Mat；
    • 参数二：std::Vector<KeyPoint> 类型的 keypoints，描述符不能为其已删除计算的。有时可以添加新的关键点，例如：SIFT duplicates keypoint 有几个主要的方向（每个方向）；
    • 参数三：OutputArray 类型的 descriptors，计算描述符；
    // 该函数结合了 detect 和 compute，参照 detect 和 compute 函数参数
void xfeatures2d::SURT::detectAndCompute( InputArray image,
                                          InputArray mask,
                                          std::vector<KeyPoint>& keypoints,
                                          OutputArray descriptors,
                                          bool useProvidedKeypoints=false );

    绘制关键点函数原型

    void drawKeypoints( InputArray image,
                    const std::vector<KeyPoint>& keypoints,
                    InputOutputArray outImage,
                    const Scalar& color=Scalar::all(-1),
                    int flags=DrawMatchesFlags::DEFAULT );
    • 参数一：InputArray 类型的 image，；
    • 参数二：std::Vector<KeyPoint> 类型的 keypoints，原图的关键点；
    • 参数三：InputOutputArray 类型的 outImage，其内容取决于定义在输出图像。请参阅参数五的标志 flag）；
    • 参数四 ：cv::Scalar 类型的 color，绘制关键点的颜色，默认为 Scalar::all(-1) 随机颜色，每个点都是这个颜色，那么随机时，每个点都是随机的；
    • 参数五：int 类型的 flags，默认为 DEFAULT，具体参照 DrawMatchesFlags 枚举如下：

    相关博客

      本源码中包含了“透视变换”，请参照博文《OpenCV 开发笔记（五十一）：红胖子 8 分钟带你深入了解透视变换（图文并茂 + 浅显易懂 + 程序源码）》

    特征点总结

      根据前面连续三篇的特征点，我们其实可以猜到了所有的匹配都是这样提取特征点，然后使用一些算法来匹配，至于使用什么特征点提取就是需要开发者根据实际的经验去选取，单一的特征点 / 多种特征点提取混合 / 自己写特征点等等多种方式去提取特征点，为后一步的特征点匹配做准备，特征点通用的就到此篇，后续会根据实际开发项目中使用的到随时以新的篇章博文去补充。
    《OpenCV 开发笔记（六十三）：红胖子 8 分钟带你深入了解 SIFT 特征点（图文并茂 + 浅显易懂 + 程序源码）》
    《OpenCV 开发笔记（六十四）：红胖子 8 分钟带你深入了解 SURF 特征点（图文并茂 + 浅显易懂 + 程序源码》
    《OpenCV 开发笔记（六十五）：红胖子 8 分钟带你深入了解 ORB 特征点（图文并茂 + 浅显易懂 + 程序源码）》

    Demo 源码

    void OpenCVManager::testOrbFeatureDetector()
{
    QString fileName1 = "13.jpg";
    int width = 400;
    int height = 300;

    cv::Mat srcMat = cv::imread(fileName1.toStdString());
    cv::resize(srcMat, srcMat, cv::Size(width, height));

    cv::String windowName = _windowTitle.toStdString();
    cvui::init(windowName);

    cv::Mat windowMat = cv::Mat(cv::Size(srcMat.cols * 2, srcMat.rows * 3),
                                srcMat.type());
    cv::Ptr<cv::ORB> _pObr = cv::ORB::create();

    int k1x = 0;
    int k1y = 0;
    int k2x = 100;
    int k2y = 0;
    int k3x = 100;
    int k3y = 100;
    int k4x = 0;
    int k4y = 100;
    while(true)
    {windowMat = cv::Scalar(0, 0, 0);

        cv::Mat mat;

        // 原图先 copy 到左边
        mat = windowMat(cv::Range(srcMat.rows * 1, srcMat.rows * 2),
                        cv::Range(srcMat.cols * 0, srcMat.cols * 1));
        cv::addWeighted(mat, 0.0f, srcMat, 1.0f, 0.0f, mat);

        {
            std::vector<cv::KeyPoint> keyPoints1;
            std::vector<cv::KeyPoint> keyPoints2;

            cvui::printf(windowMat, 0 + width * 1, 10 + height * 0, "k1x");
            cvui::trackbar(windowMat, 0 + width * 1, 20 + height * 0, 165, &k1x, 0, 100);
            cvui::printf(windowMat, 0 + width * 1, 70 + height * 0, "k1y");
            cvui::trackbar(windowMat, 0 + width * 1, 80 + height * 0, 165, &k1y, 0, 100);

            cvui::printf(windowMat, width / 2 + width * 1, 10 + height * 0, "k2x");
            cvui::trackbar(windowMat, width / 2 + width * 1, 20 + height * 0, 165, &k2x, 0, 100);
            cvui::printf(windowMat, width / 2 + width * 1, 70 + height * 0, "k2y");
            cvui::trackbar(windowMat, width / 2 + width * 1, 80 + height * 0, 165, &k2y, 0, 100);

            cvui::printf(windowMat, 0 + width * 1, 10 + height * 0 + height / 2, "k3x");
            cvui::trackbar(windowMat, 0 + width * 1, 20 + height * 0 + height / 2, 165, &k3x, 0, 100);
            cvui::printf(windowMat, 0 + width * 1, 70 + height * 0 + height / 2, "k3y");
            cvui::trackbar(windowMat, 0 + width * 1, 80 + height * 0 + height / 2, 165, &k3y, 0, 100);

            cvui::printf(windowMat, width / 2 + width * 1, 10 + height * 0 + height / 2, "k4x");
            cvui::trackbar(windowMat, width / 2 + width * 1, 20 + height * 0 + height / 2, 165, &k4x, 0, 100);
            cvui::printf(windowMat, width / 2 + width * 1, 70 + height * 0 + height / 2, "k4y");
            cvui::trackbar(windowMat, width / 2 + width * 1, 80 + height * 0 + height / 2, 165, &k4y, 0, 100);

            std::vector<cv::Point2f> srcPoints;
            std::vector<cv::Point2f> dstPoints;

            srcPoints.push_back(cv::Point2f(0.0f, 0.0f));
            srcPoints.push_back(cv::Point2f(srcMat.cols - 1, 0.0f));
            srcPoints.push_back(cv::Point2f(srcMat.cols - 1, srcMat.rows - 1));
            srcPoints.push_back(cv::Point2f(0.0f, srcMat.rows - 1));

            dstPoints.push_back(cv::Point2f(srcMat.cols * k1x / 100.0f, srcMat.rows * k1y / 100.0f));
            dstPoints.push_back(cv::Point2f(srcMat.cols * k2x / 100.0f, srcMat.rows * k2y / 100.0f));
            dstPoints.push_back(cv::Point2f(srcMat.cols * k3x / 100.0f, srcMat.rows * k3y / 100.0f));
            dstPoints.push_back(cv::Point2f(srcMat.cols * k4x / 100.0f, srcMat.rows * k4y / 100.0f));

            cv::Mat M = cv::getPerspectiveTransform(srcPoints, dstPoints);
            cv::Mat srcMat2;
            cv::warpPerspective(srcMat,
                                srcMat2,
                                M,
                                cv::Size(srcMat.cols, srcMat.rows),
                                cv::INTER_LINEAR,
                                cv::BORDER_CONSTANT,
                                cv::Scalar::all(0));

            mat = windowMat(cv::Range(srcMat.rows * 1, srcMat.rows * 2),
                            cv::Range(srcMat.cols * 1, srcMat.cols * 2));
            cv::addWeighted(mat, 0.0f, srcMat2, 1.0f, 0.0f, mat);

            // 特征点检测
            _pObr->detect(srcMat, keyPoints1);
            // 绘制特征点(关键点)
            cv::Mat resultShowMat;
            cv::drawKeypoints(srcMat,
                             keyPoints1,
                             resultShowMat,
                             cv::Scalar(0, 0, 255),
                             cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
            mat = windowMat(cv::Range(srcMat.rows * 2, srcMat.rows * 3),
                            cv::Range(srcMat.cols * 0, srcMat.cols * 1));
            cv::addWeighted(mat, 0.0f, resultShowMat, 1.0f, 0.0f, mat);

            // 特征点检测
            _pObr->detect(srcMat2, keyPoints2);
            // 绘制特征点(关键点)
            cv::Mat resultShowMat2;
            cv::drawKeypoints(srcMat2,
                             keyPoints2,
                             resultShowMat2,
                             cv::Scalar(0, 0, 255),
                             cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
            mat = windowMat(cv::Range(srcMat.rows * 2, srcMat.rows * 3),
                           cv::Range(srcMat.cols * 1, srcMat.cols * 2));
            cv::addWeighted(mat, 0.0f, resultShowMat2, 1.0f, 0.0f, mat);

            cv::imshow(windowName, windowMat);
        }
        // 更新
        cvui::update();
        // 显示
        // esc 键退出
        if(cv::waitKey(25) == 27)
        {break;}
    }
}

    工程模板：对应版本号 v1.59.0

      对应版本号 v1.59.0

    上一篇：《OpenCV 开发笔记（六十四）：红胖子 8 分钟带你深入了解 SURF 特征点（图文并茂 + 浅显易懂 + 程序源码）》
    下一篇：持续补充中…

    原博主博客地址：https://blog.csdn.net/qq21497936
    原博主博客导航：https://blog.csdn.net/qq21497936/article/details/102478062
    本文章博客地址：https://blog.csdn.net/qq21497936/article/details/106926496

    正文完
    opencv
    发表至： opencv
    2020-06-23
     0
    关于opencv:OpenCV开发笔记七十一红胖子8分钟带你深入级联分类器训练
    关于opencv:ApacheCN-计算机视觉译文集-20210212-更新
    关于opencv:OpenCV开发笔记六十九红胖子8分钟带你使用传统方法识别已知物体图文并茂浅显易懂程序源码
    关于opencv:经验分享windows-源码编译-opencv