BRIEF

最新推荐文章于 2022-10-20 09:00:00 发布
最新推荐文章于 2022-10-20 09:00:00 发布
阅读量1.2k 收藏
点赞数
分类专栏： 图像识别算法


在嵌入式系统内，对图像进行实时匹配，这项任务给特征点的检测与描述提出了更高的要求。这不仅要求运算速度快，而且还要求占用更少的内存。

SIFT和SURF方法性能优异，但它们在实时应用中就力不从心，一个主要的原因就是特征点的描述符结构较复杂，表现形式是第一描述符的维数较多，第二描述符采用浮点型的数据格式。维数多固然可以提高特征点的可区分性，但使描述符的生成和特征点的匹配的效率降低，另一方面采用浮点型的数据格式也必然增加了更大的内存开销。因此改进描述符的形式就成为提高特征点匹配的一个重要手段。

目前改进描述符的方法有降低维数和浮点型用整型替代，而另一种更彻底的方法就是直接把描述符缩短为二值化的位字符串形式。这样用汉明距离（Hamming）就可以更快的测量两个描述符的相似程度，方法是按位进行异或位操作，结果中“1”的数量越多，两个描述符的相似性越差。

Michael Calonder等人基于前人的方法于2010年提出了BRIEF（BinaryRobust Independent Elementary Features）方法。该方法也是二值位字符串的描述符形式，但描述符的创建更简单，更有效。

BRIEF的方法是：首先以特征点为中心定义一个大小为S×S的补丁（patch）区域，在opencn2.4.9中，该区域的大小为48×48。再在该区域内，以某种特定的方式选择nd个像素点对。然后比较像素点对的灰度值：


     (1)


I(pi)和I(qi)分别表示第i个像素点对的两个像素pi和qi的灰度值。最后把补丁区域内所有点对的比较结果串成一个二值位字符串的形式，从而形成了该特征点的描述符。


B = b0b1…bi…bnd          （2）    


通过实验对比可知，nd = 128，256和512时，在运算速度，空间占用和准确性上可以达到最佳的效果。如果用字节型来表示描述符的话，那么


k =nd / 8         （3）


k就表示为描述符的字节数。


BRIEF描述符的创建过程比较简单，但这里还要注意两个问题。第一是为了降低灵敏度，增强描述符的抗干扰程度和可重复性，需要对补丁区域进行平滑处理，也就是在比较点对的两个像素灰度值之前，需要对这两个像素进行平滑处理。采用7×7的高斯模板平滑处理是一种常用的方法，但该方法在速度上与其他的平滑方法比较来看没有优势。因此，Calonder等人又于2011年提出采用盒状滤波器的处理方法来代替高斯平滑处理方法。由于可以采用积分图像的方法，所以盒状滤波器比高斯滤波器更快，而且两者的准确性几乎相同。在opencn2.4.9中，盒状滤波器的大小为9×9。


第二个需要注意的问题是在补丁区域内用什么方式选择像素点对。Calonder比较了5种方法，我们都分别给予介绍，其中我们以补丁区域的中心（即特征点）作为坐标原点，设X和Y是一个点对的两个像素的随机变量，xi和yi为其所对应的像素坐标：


1、X和Y都服从在[-S/2，S/2]范围内的均匀分布，且相互独立；


2、X和Y都服从均值为0，方差为S2/25的高斯分布，且相互独立，即X和Y都以原点为中心，进行同方差的高斯分布；


3、X服从均值为0，方差为S2/25的高斯分布，而Y服从均值为xi，方差为S2/100的高斯分布，即先确定X的高斯分布得到xi，同方法2，然后以xi为中心，进行高斯分布确定yi；


4、在引入了空间量化的不精确极坐标网格的离散位置内，随机采样，得到xi和yi；

5、xi固定在原点处，yi是所有可能的极坐标网格内的值。


通过实验对比可知，前4种方法要好于第5种方法，而在前4种方法中，第2种方法会表现出少许的优势。


在实际应用中，虽然点对都是按一定规则随机选择的，但在确定了补丁区域大小S的情况下，点对的坐标位置一旦随机选定，就不再更改，自始自终都用这些确定下来的点对坐标位置。也就是说这些点对的坐标位置其实是已知的，在编写程序的时候，这些坐标事先存储在系统中，在创建描述符时，只要调用这些坐标即可。另外，不但点对的坐标位置是确定好的，点对的两个像素之间的顺序和点对的顺序也必须是事先确定好的，这样才能保证描述符的一致性。点对的两个像素之间的顺序指的是在公式1中，两个像素哪个是pi，哪个是qi，因为在比较时是pi的灰度值小于qi的灰度值时，bi才等于1。点对的顺序指的是nd个点对之间要排序，这样二值位字符串中的各个位（公式2）就以该顺序排列。


最后需要强调的是，BRIEF仅仅是一种特征点的描述符方法，它不提供特征点的检测方法。Calonder推荐使用CenSurE方法进行特征点的检测，该方法与BRIEF配合使用，效果会略好一些。在Opencv2.4.9中也提供了CenSurE方法，但是使用Star这个别名。

BRIEF是一种更快的特征点描述符的创建和匹配方法，此外只要在平面内没有很大的旋转，则该方法还可以提供很高的识别率。




下面我们就给出BRIEF方法的源码分析。

BRIEF描述符创建的类是BriefDescriptorExtractor，它的构造函数为：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //bytes表示描述符的字节数，即公式3中的k，k只可能为16，32和64，默认为32  
  2. BriefDescriptorExtractor::BriefDescriptorExtractor(int bytes) :  
  3.     bytes_(bytes), test_fn_(NULL)  
  4. {  
  5.     //根据字节数选择不同的函数，字节数不同，则所需要的像素点对的数量就不同，所以要调用不同的函数  
  6.     switch (bytes)  
  7.     {  
  8.         case 16:    //128个点对  
  9.             test_fn_ = pixelTests16;  
  10.             break;  
  11.         case 32:    //256个点对  
  12.             test_fn_ = pixelTests32;  
  13.             break;  
  14.         case 64:    //512个点对  
  15.             test_fn_ = pixelTests64;  
  16.             break;  
  17.         default:    //只可能为以上三种情况  
  18.             CV_Error(CV_StsBadArg, "bytes must be 16, 32, or 64");  
  19.     }  
  20. }  
//bytes表示描述符的字节数，即公式3中的k，k只可能为16，32和64，默认为32
BriefDescriptorExtractor::BriefDescriptorExtractor(int bytes) :
    bytes_(bytes), test_fn_(NULL)
{
    //根据字节数选择不同的函数，字节数不同，则所需要的像素点对的数量就不同，所以要调用不同的函数
    switch (bytes)
    {
        case 16:    //128个点对
            test_fn_ = pixelTests16;
            break;
        case 32:    //256个点对
            test_fn_ = pixelTests32;
            break;
        case 64:    //512个点对
            test_fn_ = pixelTests64;
            break;
        default:    //只可能为以上三种情况
            CV_Error(CV_StsBadArg, "bytes must be 16, 32, or 64");
    }
}

创建BRIEF描述符的函数computeImpl：


[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. void BriefDescriptorExtractor::computeImpl(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const  
  2. {  
  3.     // Construct integral image for fast smoothing (box filter)  
  4.     Mat sum;    //积分图像矩阵  
  5.   
  6.     Mat grayImage = image;    //输入图像  
  7.     //把输入图像转换为灰度图像  
  8.     if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );  
  9.   
  10.     ///TODO allow the user to pass in a precomputed integral image  
  11.     //if(image.type() == CV_32S)  
  12.     //  sum = image;  
  13.     //else  
  14.   
  15.     integral( grayImage, sum, CV_32S);    //得到输入图像的积分图像  
  16.   
  17.     //Remove keypoints very close to the border  
  18.     // PATCH_SIZE = 48;表示补丁区域的边长，KERNEL_SIZE = 9;表示盒状滤波器的边长  
  19.     //根据补丁区域和盒状滤波器的尺寸大小，去掉那些过于靠近图像边界的特征点  
  20.     KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE/2 + KERNEL_SIZE/2);  
  21.     //描述符矩阵变量清零  
  22.     descriptors = Mat::zeros((int)keypoints.size(), bytes_, CV_8U);  
  23.     //调用test_fn_指向的函数，创建BRIEF描述符  
  24.     test_fn_(sum, keypoints, descriptors);  
  25. }  
void BriefDescriptorExtractor::computeImpl(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const
{
    // Construct integral image for fast smoothing (box filter)
    Mat sum;    //积分图像矩阵

    Mat grayImage = image;    //输入图像
    //把输入图像转换为灰度图像
    if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );

    ///TODO allow the user to pass in a precomputed integral image
    //if(image.type() == CV_32S)
    //  sum = image;
    //else

    integral( grayImage, sum, CV_32S);    //得到输入图像的积分图像

    //Remove keypoints very close to the border
    // PATCH_SIZE = 48;表示补丁区域的边长，KERNEL_SIZE = 9;表示盒状滤波器的边长
    //根据补丁区域和盒状滤波器的尺寸大小，去掉那些过于靠近图像边界的特征点
    KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE/2 + KERNEL_SIZE/2);
    //描述符矩阵变量清零
    descriptors = Mat::zeros((int)keypoints.size(), bytes_, CV_8U);
    //调用test_fn_指向的函数，创建BRIEF描述符
    test_fn_(sum, keypoints, descriptors);
}

由构造函数可知，根据描述符字节数的不同，test_fn_指向不同的函数，这些函数的意义相同，区别在于处理的点对数量不同，我们仅以pixelTests16函数为进行讲解。

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. static void pixelTests16(const Mat& sum, const std::vector<KeyPoint>& keypoints, Mat& descriptors)  
  2. {  
  3.     //遍历所有的特征点  
  4.     for (int i = 0; i < (int)keypoints.size(); ++i)  
  5.     {  
  6.         uchar* desc = descriptors.ptr(i);    //描述符的首地址指针  
  7.         const KeyPoint& pt = keypoints[i];    //特征点的首地址指针  
  8. #include "generated_16.i"    //执行generated_16.i预处理文件  
  9.     }  
  10. }  
static void pixelTests16(const Mat& sum, const std::vector<KeyPoint>& keypoints, Mat& descriptors)
{
    //遍历所有的特征点
    for (int i = 0; i < (int)keypoints.size(); ++i)
    {
        uchar* desc = descriptors.ptr(i);    //描述符的首地址指针
        const KeyPoint& pt = keypoints[i];    //特征点的首地址指针
#include "generated_16.i"    //执行generated_16.i预处理文件
    }
}

在generated_16.i文件中，用到了smoothedSum函数，它的作用是对点对进行盒状滤波器的平滑处理，我们先给出这个函数：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //sum为积分图像，pt为特征点变量，x和y表示点对中某一个像素相对于特征点的坐标，函数返回滤波的结果  
  2. inline int smoothedSum(const Mat& sum, const KeyPoint& pt, int y, int x)  
  3. {  
  4.     //盒状滤波器边长的一半  
  5.     static const int HALF_KERNEL = BriefDescriptorExtractor::KERNEL_SIZE / 2;  
  6.     //计算点对中某一个像素的绝对坐标  
  7.     int img_y = (int)(pt.pt.y + 0.5) + y;  
  8.     int img_x = (int)(pt.pt.x + 0.5) + x;  
  9.     //计算以该像素为中心，以KERNEL_SIZE为边长的正方形内所有像素灰度值之和，本质上是均值滤波  
  10.     return   sum.at<int>(img_y + HALF_KERNEL + 1, img_x + HALF_KERNEL + 1)  
  11.            - sum.at<int>(img_y + HALF_KERNEL + 1, img_x - HALF_KERNEL)  
  12.            - sum.at<int>(img_y - HALF_KERNEL, img_x + HALF_KERNEL + 1)  
  13.            + sum.at<int>(img_y - HALF_KERNEL, img_x - HALF_KERNEL);  
  14. }  
//sum为积分图像，pt为特征点变量，x和y表示点对中某一个像素相对于特征点的坐标，函数返回滤波的结果
inline int smoothedSum(const Mat& sum, const KeyPoint& pt, int y, int x)
{
    //盒状滤波器边长的一半
    static const int HALF_KERNEL = BriefDescriptorExtractor::KERNEL_SIZE / 2;
    //计算点对中某一个像素的绝对坐标
    int img_y = (int)(pt.pt.y + 0.5) + y;
    int img_x = (int)(pt.pt.x + 0.5) + x;
    //计算以该像素为中心，以KERNEL_SIZE为边长的正方形内所有像素灰度值之和，本质上是均值滤波
    return   sum.at<int>(img_y + HALF_KERNEL + 1, img_x + HALF_KERNEL + 1)
           - sum.at<int>(img_y + HALF_KERNEL + 1, img_x - HALF_KERNEL)
           - sum.at<int>(img_y - HALF_KERNEL, img_x + HALF_KERNEL + 1)
           + sum.at<int>(img_y - HALF_KERNEL, img_x - HALF_KERNEL);
}

我们再回到generated_16.i文件：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //定义宏SMOOTHED，作用就是调用smoothedSum函数，SMOOTHED中的参数y和x表示相对于特征点的坐标  
  2. #define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)  
  3.     //该描述符需要16个字节型变量，所以从desc[0]到desc[15]  
  4.     desc[0] = (uchar)(  
  5.          //每个字节型变量由8位组成  
  6.          //比较平滑处理以后的坐标为(-2, -1)和(7, -1)的两个像素的灰度值，如公式1，并把结果移位到第7位上  
  7.          ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) +   
  8.          ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) +    //第6位  
  9.          ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) +    //第5位  
  10.          ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) +    //第4位  
  11.          ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) +    //第3位  
  12.          ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) +    //第2位  
  13.          ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) +    //第1位  
  14.          ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));    //第0位  
  15.     //以下省略  
  16.     desc[1] = ……  
  17.     ……  
  18.     desc[15] = ……  
  19. #undef SMOOTHED  
//定义宏SMOOTHED，作用就是调用smoothedSum函数，SMOOTHED中的参数y和x表示相对于特征点的坐标
#define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
    //该描述符需要16个字节型变量，所以从desc[0]到desc[15]
    desc[0] = (uchar)(
         //每个字节型变量由8位组成
         //比较平滑处理以后的坐标为(-2, -1)和(7, -1)的两个像素的灰度值，如公式1，并把结果移位到第7位上
         ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + 
         ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) +    //第6位
         ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) +    //第5位
         ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) +    //第4位
         ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) +    //第3位
         ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) +    //第2位
         ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) +    //第1位
         ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));    //第0位
    //以下省略
    desc[1] = ……
    ……
    desc[15] = ……
#undef SMOOTHED


下面给出应用BRIEF方法进行图像匹配的实例，其中我们是STAR方法进行特征点的检测：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include "opencv2/core/core.hpp"  
  2. #include "highgui.h"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4. #include "opencv2/features2d/features2d.hpp"  
  5. #include "opencv2/nonfree/nonfree.hpp"  
  6. #include "opencv2/legacy/legacy.hpp"  
  7.   
  8. using namespace cv;  
  9. using namespace std;  
  10.   
  11. int main(int argc, char** argv)  
  12. {  
  13.    Mat img1 = imread("box_in_scene.png");  
  14.    Mat img2 = imread("box.png");  
  15.   
  16.    vector<KeyPoint> key_points1, key_points2;  
  17.    StarDetector detector;    //特征点检测方法  
  18.    detector.detect(img1, key_points1);   
  19.    detector.detect(img2, key_points2);  
  20.   
  21.    Mat descriptors1, descriptors2;  
  22.    BriefDescriptorExtractor brief;    //BRIEF方法  
  23.    brief.compute(img1, key_points1, descriptors1);   
  24.    brief.compute(img2, key_points2, descriptors2);  
  25.      
  26.    BruteForceMatcher<Hamming> matcher;    
  27.    vector<DMatch>matches;    
  28.    matcher.match(descriptors1,descriptors2,matches);  
  29.   
  30.    std::nth_element(matches.begin(), // initial position  
  31.       matches.begin()+29, // position of the sorted element  
  32.       matches.end()); // end position  
  33.    // remove all elements after the 30th  
  34.    matches.erase(matches.begin()+30, matches.end());  
  35.   
  36.    namedWindow("BRIEF_matches");    
  37.    Mat img_matches;    
  38.    drawMatches(img1,key_points1,  
  39.       img2,key_points2,  
  40.       matches,  
  41.       img_matches,   
  42.       Scalar(255,255,255));    
  43.    imshow("BRIEF_matches",img_matches);    
  44.    waitKey(0);  
  45.   
  46.    return 0;  
  47. }  
#include "opencv2/core/core.hpp"
#include "highgui.h"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/nonfree/nonfree.hpp"
#include "opencv2/legacy/legacy.hpp"

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{
   Mat img1 = imread("box_in_scene.png");
   Mat img2 = imread("box.png");

   vector<KeyPoint> key_points1, key_points2;
   StarDetector detector;    //特征点检测方法
   detector.detect(img1, key_points1); 
   detector.detect(img2, key_points2);

   Mat descriptors1, descriptors2;
   BriefDescriptorExtractor brief;    //BRIEF方法
   brief.compute(img1, key_points1, descriptors1); 
   brief.compute(img2, key_points2, descriptors2);
   
   BruteForceMatcher<Hamming> matcher;  
   vector<DMatch>matches;  
   matcher.match(descriptors1,descriptors2,matches);

   std::nth_element(matches.begin(), // initial position
      matches.begin()+29, // position of the sorted element
      matches.end()); // end position
   // remove all elements after the 30th
   matches.erase(matches.begin()+30, matches.end());

   namedWindow("BRIEF_matches");  
   Mat img_matches;  
   drawMatches(img1,key_points1,
      img2,key_points2,
      matches,
      img_matches, 
      Scalar(255,255,255));  
   imshow("BRIEF_matches",img_matches);  
   waitKey(0);

   return 0;
}




Opencv2.4.9源码分析——MSCR




前面我们介绍了MSER方法，但该方法不适用于对彩色图像的区域检测。为此，Forssen于2007年提出了针对彩色图像的最大稳定极值区域的检测方法——MSCR（Maximally Stable Colour Regions）。


MSCR的检测方法是基于凝聚聚类（AgglomerativeClustering）算法，它把图像中的每个像素作为对象，通过某种相似度准则，依次逐层的进行合并形成簇，即先合并相似度大的对象，再合并相似度小的对象，直到满足某种终止条件为止。这一过程在MSCR中被称为进化过程，即逐步合并图像中的像素，从而形成斑点区域。

MSCR中所使用的相似度准则是卡方距离（Chi-squared distance）：

      （1） 




其中，x和y分别为彩色图像中的两个不同像素，下标k表示不同的通道，例如红、绿、蓝三个颜色通道。因此公式1是一种颜色相似度的度量。


MSCR通过邻域像素之间的颜色相似度来进行聚类合并，邻域关系可以是水平垂直间邻域，也可以是还包括对角线间邻域。Opencv使用的是水平垂直间邻域，即当前像素与其右侧像素通过公式1得到一个相似度值，再与其下面像素通过公式1得到另一个相似度值。所以一般来说，每个像素都有两个相似度值，但图像的最右侧一列和最下面一行只有一个相似度值。因此对于一个大小为L×M的彩色图像来说，一共有2×L×M-L-M个相似度值。我们把这些相似度值放入一个列表中，由于该相似度是邻域之间的相似度，类似于求图像的边缘，所以该列表也称为边缘列表。


在凝聚聚类算法中，是需要逐层进行合并的。在MSCR中合并的层次也称为进化步长，用t来表示，t∈[0…T]，根据经验值，T一般为200，即一共进行200步的进化过程。在每一层，都对应一个不同的颜色相似度阈值dthr，在该层只选取那些颜色相似度小于该阈值的像素进行合并。每一层的阈值是不同，并且随着t的增加，阈值也增加，因此达到了合并的区域面积逐步增加的目的。阈值的选取是关键，我们知道，图像像素邻域间的相关性是很大的，也就是通过公式1计算得到的值存在着大量的很小的值，而很大的值少之又少。因此如果我们仍然采用类似于MSER那样，随着t的增加，线性增加dthr的方法，会带来一个严重的后果，就是在进化的开始（t较小的时候），形成斑点区域的速率很快，而在进化的后期（t接近T时），形成斑点区域的速率很慢。为了解决这个问题，即在不同的进化步长下有相同的速率，对于阈值的选取，MSCR采用的是改进型的累积分布函数（CDF）的逆函数的形式。在实际应用中，事先把该函数值存储在表中，使用时通过查表的形式根据不同的t得到不同的dthr。


在每一个进化步长内，MSCR会合并一些颜色相似的像素，相邻像素之间就会组成斑点区域，对这些区域我们就需要判断其是否为最大稳定极值区域。对于所形成的斑点区域，我们需要给定该区域的面积a*和相似度阈值d*这两个参数。虽然随着进化步长t的增加，阈值dt（也就是dthr）也在增加，该区域的面积at也在增加，但只有满足两个步长间面积之比大于一定值的时候，才会重新初始化该区域的a*和d*，即：

     （2）


一般athr=1.01。下面给出MSCR判断稳定区域的公式：

    （3）


自从上一次初始化（即更新a*和d*）以来，如果s达到了最小值，则该区域为稳定区域。在判断稳定区域的过程中，还应该满足另外两个条件：1是公式3中的t不能是更新a*和d*之后的第一个进化步长；2是公式3中的分母部分要大于一定的阈值，即


dt - d* > mmin        （4）


一般mmin设置为0.003。稳定区域通过公式3找到后，那么极值区域的判断与MSER的方法一样，是通过稳定区域的面积变量率来判断的，即上一篇文章里的公式1。


下面给出彩色图像MSCR的步骤：


1、应用公式1计算颜色相似度，得到彩色图像的边缘列表；


2、对边缘列表进行平滑处理；


3、进化处理，由各个进化步长的距离阈值得到稳定极值区域。

在opencv2.4.9中，MSCR和MSER共用一个类：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. class MSER : public CvMSERParams  
  2. {  
  3. public:  
  4. // default constructor  
  5. MSER();  
  6. // constructor that initializes all the algorithm parameters  
  7. MSER( int _delta, int _min_area, int _max_area,  
  8. float _max_variation, float _min_diversity,  
  9. int _max_evolution, double _area_threshold,  
  10. double _min_margin, int _edge_blur_size );  
  11. // runs the extractor on the specified image; returns the MSERs,  
  12. // each encoded as a contour (vector<Point>, see findContours)  
  13. // the optional mask marks the area where MSERs are searched for  
  14. void operator()( const Mat& image, vector<vector<Point> >& msers, const Mat& mask ) const;  
  15. };  
class MSER : public CvMSERParams
{
public:
// default constructor
MSER();
// constructor that initializes all the algorithm parameters
MSER( int _delta, int _min_area, int _max_area,
float _max_variation, float _min_diversity,
int _max_evolution, double _area_threshold,
double _min_margin, int _edge_blur_size );
// runs the extractor on the specified image; returns the MSERs,
// each encoded as a contour (vector<Point>, see findContours)
// the optional mask marks the area where MSERs are searched for
void operator()( const Mat& image, vector<vector<Point> >& msers, const Mat& mask ) const;
};

但MSCR比MSER多用了几个参数：


_max_evolution为进化总步长，就是参数T，一般T = 200；


_area_threshold为重新初始化的面积阈值，就是公式2中的参数athr，一般athr = 1.01；


_min_margin为最小步长距离，就是公式4中mmin，一般mmin = 0.003；


_edge_blur_size为对边缘列表进行平滑处理的孔径大小

上一篇文件已经介绍过，在MSER类中的重载( )运算符中，调用了extractMSER函数，在该函数内通过判断输入图像的类型确定是灰度图像还是彩色图像，如果是彩色图像则调用extractMSER_8UC3函数：



[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. static void  
  2. extractMSER_8UC3( CvMat* src,  
  3.              CvMat* mask,  
  4.              CvSeq* contours,  
  5.              CvMemStorage* storage,  
  6.              MSERParams params )  
  7. {  
  8.     //在应用凝聚聚类算法时，把图像中的每个像素作为一个对象，即一个节点，因此该语句是定义并分配图像节点空间  
  9.     MSCRNode* map = (MSCRNode*)cvAlloc( src->cols*src->rows*sizeof(map[0]) );  
  10.     //定义边缘列表的个数，即2 × L × M – L - M  
  11.     int Ne = src->cols*src->rows*2-src->cols-src->rows;  
  12.     //定义并分配边缘列表空间  
  13.     MSCREdge* edge = (MSCREdge*)cvAlloc( Ne*sizeof(edge[0]) );  
  14.     TempMSCR* mscr = (TempMSCR*)cvAlloc( src->cols*src->rows*sizeof(mscr[0]) );  
  15.     //定义变量，用于由公式1计算图像每个像素颜色相似度的距离均值  
  16.     double emean = 0;  
  17.     //创建水平梯度矩阵，即当前像素与其右侧像素之间的差值  
  18.     CvMat* dx = cvCreateMat( src->rows, src->cols-1, CV_64FC1 );  
  19.     //创建垂直梯度矩阵，即当前像素与其下面像素之间的差值  
  20.     CvMat* dy = cvCreateMat( src->rows-1, src->cols, CV_64FC1 );  
  21.     //MSCR的预处理过程，主要完成步骤1和步骤2，后面会详细讲解  
  22.     Ne = preprocessMSER_8UC3( map, edge, &emean, src, mask, dx, dy, Ne, params.edgeBlurSize );  
  23.     //得到颜色相似度的距离均值  
  24.     emean = emean / (double)Ne;  
  25.     //对边缘列表进行升序排列，便于后面的距离阈值比较  
  26.     QuickSortMSCREdge( edge, Ne, 0 );  
  27.     //定义边缘列表的空间的上限  
  28.     MSCREdge* edge_ub = edge+Ne;  
  29.     //定义边缘列表的地址指针  
  30.     MSCREdge* edgeptr = edge;  
  31.     TempMSCR* mscrptr = mscr;  
  32.     // the evolution process  
  33.     //步骤3，进化处理，在t∈[ 0…T ]中循环，这里的i就是前面文章介绍的进化步长t  
  34.     for ( int i = 0; i < params.maxEvolution; i++ )  
  35.     {  
  36.         //下面的4条语句用于计算当前t下的dthr值，thres为dthr  
  37.         //数组chitab为事先计算好的查询表  
  38.         double k = (double)i/(double)params.maxEvolution*(TABLE_SIZE-1);  
  39.         int ti = cvFloor(k);  
  40.         double reminder = k-ti;  
  41.         double thres = emean*(chitab3[ti]*(1-reminder)+chitab3[ti+1]*reminder);  
  42.         // to process all the edges in the list that chi < thres  
  43.         //处理所有颜色相似度小于阈值的像素  
  44.         //edgeptr < edge_ub的作用是判断边缘列表指针是否超过了列表的上限，即所指向的不是边缘  
  45.         while ( edgeptr < edge_ub && edgeptr->chi < thres )  
  46.         {  
  47.             //由当前像素的左侧像素找到该像素所在的簇的根节点，也就是找到代表该像素所在区域的像素  
  48.             MSCRNode* lr = findMSCR( edgeptr->left );  
  49.             //由当前像素的右侧像素找到该像素所在的簇的根节点，也就是找到代表该像素所在区域的像素  
  50.             //需要注意的是，这里的左侧和右侧并不是真正意义的左侧和右侧，它们是由preprocessMSER_8UC3函数确定的  
  51.             MSCRNode* rr = findMSCR( edgeptr->right );  
  52.             // get the region root (who is responsible)  
  53.             //如果上面得到的两个根节点是一个节点，则不需要进行任何处理  
  54.             //如果这两个根节点不是一个，则需要把它们所代表的两个区域进行合并  
  55.             if ( lr != rr )  
  56.             {  
  57.                 // rank idea take from: N-tree Disjoint-Set Forests for Maximally Stable Extremal Regions  
  58.                 //下面的if语句用于判断是用rr还是用lr来代表合并后的区域，并且最终通过交换来实现lr代表合并后的区域  
  59.                 //rank值大的根节点代表合并后的区域  
  60.                 if ( rr->rank > lr->rank )  
  61.                 {  
  62.                     MSCRNode* tmp;  
  63.                     CV_SWAP( lr, rr, tmp );  
  64.                 } else if ( lr->rank == rr->rank ) {  
  65.                     // at the same rank, we will compare the size  
  66.                     //如果两个根节点的rank值相同，则区域面积大的代表合并后的区域  
  67.                     if ( lr->size > rr->size )  
  68.                     {  
  69.                         MSCRNode* tmp;  
  70.                         CV_SWAP( lr, rr, tmp );  
  71.                     }  
  72.                     lr->rank++;  
  73.                 }  
  74.                 //定义rr所表示的区域的根节点为lr  
  75.                 rr->shortcut = lr;  
  76.                 //合并两个区域，合并后区域面积为两个区域面积之和  
  77.                 lr->size += rr->size;  
  78.                 // join rr to the end of list lr (lr is a endless double-linked list)  
  79.                 //把rr加入lr列表中，组成一个循环双链接列表  
  80.                 lr->prev->next = rr;  
  81.                 lr->prev = rr->prev;  
  82.                 rr->prev->next = lr;  
  83.                 rr->prev = lr;  
  84.                 // area threshold force to reinitialize  
  85.                 //利用公式2计算是否需要区域的重新初始化  
  86.                 //if语句成立，则表示需要重新初始化  
  87.                 if ( lr->size > (lr->size-rr->size)*params.areaThreshold )  
  88.                 {  
  89.                     //更新面积，即a*值  
  90.                     lr->sizei = lr->size;  
  91.                     //更新当前的进化步长，即t值，以区分各个层  
  92.                     lr->reinit = i;  
  93.                     //tmsr保存着上一次计算得到的稳定区域信息  
  94.                     if ( lr->tmsr != NULL )  
  95.                     {  
  96.                         //公式4  
  97.                         lr->tmsr->m = lr->dt-lr->di;  
  98.                         /*tmsr赋值为NULL，表示该区域已经进行了重新初始化，因此在下次进化步长并计算到该节点的时候，需要保存该区域的最大稳定极值区域；还有一个目的是避免重复计算公式4*/  
  99.                         lr->tmsr = NULL;  
  100.                     }  
  101.                     //更新颜色相似度值，即d*值  
  102.                     lr->di = edgeptr->chi;  
  103.                     //为公式3中的s赋予一个极小的值  
  104.                     lr->s = 1e10;  
  105.                 }  
  106.                 //为该区域的颜色相似度赋值  
  107.                 lr->dt = edgeptr->chi;  
  108.                 //在重新初始化以后的进化步长中，当计算到该节点时，需要进入if语句内，以判断最大稳定极值区域  
  109.                 if ( i > lr->reinit )  
  110.                 {  
  111.                     //公式3  
  112.                     double s = (double)(lr->size-lr->sizei)/(lr->dt-lr->di);  
  113.                     //当公式3中的s是最小值时  
  114.                     if ( s < lr->s )  
  115.                     {  
  116.                         // skip the first one and check stablity  
  117.                         // i > lr->reinit+1的目的是避免计算重新初始化后的第一个进化步长  
  118.                         // MSCRStableCheck函数为计算最大稳定机制区域，即计算区域面积的变化率  
  119.                         if ( i > lr->reinit+1 && MSCRStableCheck( lr, params ) )  
  120.                         {  
  121.                             //tmsr为NULL，表示至从上次重新初始化以来，还没有为tmsr赋值，因此这次得到的稳定区域要作为最终输出保存下来  
  122.                             if ( lr->tmsr == NULL )  
  123.                             {  
  124.                                 //gmsr为全局稳定区域，tmsr为暂存稳定区域，mscrptr为mscr的指针变量，它是最终输出的稳定区域  
  125.                                 lr->gmsr = lr->tmsr = mscrptr;  
  126.                                 mscrptr++;    //指向下一个地址  
  127.                             }  
  128.                             //为tmsr赋值  
  129.                             lr->tmsr->size = lr->size;  
  130.                             lr->tmsr->head = lr;  
  131.                             lr->tmsr->tail = lr->prev;  
  132.                             lr->tmsr->m = 0;  
  133.                         }  
  134.                         //保证s为最小值  
  135.                         lr->s = s;  
  136.                     }  
  137.                 }  
  138.             }  
  139.             //指向下一个边缘  
  140.             edgeptr++;  
  141.         }  
  142.         //如果超出了边缘列表的范围，则退出for循环  
  143.         if ( edgeptr >= edge_ub )  
  144.             break;  
  145.     }  
  146.     //对最终得到的稳定区域进行裁剪，并输出  
  147.     for ( TempMSCR* ptr = mscr; ptr < mscrptr; ptr++ )  
  148.         // to prune area with margin less than minMargin  
  149.         //公式4，判断是否满足条件  
  150.         if ( ptr->m > params.minMargin )  
  151.         {  
  152.             //创建序列  
  153.             CvSeq* _contour = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvContour), sizeof(CvPoint), storage );  
  154.             //初始化该序列  
  155.             cvSeqPushMulti( _contour, 0, ptr->size );  
  156.             MSCRNode* lpt = ptr->head;  
  157.             for ( int i = 0; i < ptr->size; i++ )  
  158.             {  
  159.                 CvPoint* pt = CV_GET_SEQ_ELEM( CvPoint, _contour, i );  
  160.                 //得到稳定区域的坐标值  
  161.                 pt->x = (lpt->index)&0xffff;  
  162.                 pt->y = (lpt->index)>>16;  
  163.                 lpt = lpt->next;  
  164.             }  
  165.             CvContour* contour = (CvContour*)_contour;  
  166.             cvBoundingRect( contour );  
  167.             contour->color = 0;  
  168.             //把坐标值压入序列中  
  169.             cvSeqPush( contours, &contour );  
  170.         }  
  171.     //清内存  
  172.     cvReleaseMat( &dx );  
  173.     cvReleaseMat( &dy );  
  174.     cvFree( &mscr );  
  175.     cvFree( &edge );  
  176.     cvFree( &map );  
  177. }  
static void
extractMSER_8UC3( CvMat* src,
             CvMat* mask,
             CvSeq* contours,
             CvMemStorage* storage,
             MSERParams params )
{
    //在应用凝聚聚类算法时，把图像中的每个像素作为一个对象，即一个节点，因此该语句是定义并分配图像节点空间
    MSCRNode* map = (MSCRNode*)cvAlloc( src->cols*src->rows*sizeof(map[0]) );
    //定义边缘列表的个数，即2 × L × M – L - M
    int Ne = src->cols*src->rows*2-src->cols-src->rows;
    //定义并分配边缘列表空间
    MSCREdge* edge = (MSCREdge*)cvAlloc( Ne*sizeof(edge[0]) );
    TempMSCR* mscr = (TempMSCR*)cvAlloc( src->cols*src->rows*sizeof(mscr[0]) );
    //定义变量，用于由公式1计算图像每个像素颜色相似度的距离均值
    double emean = 0;
    //创建水平梯度矩阵，即当前像素与其右侧像素之间的差值
    CvMat* dx = cvCreateMat( src->rows, src->cols-1, CV_64FC1 );
    //创建垂直梯度矩阵，即当前像素与其下面像素之间的差值
    CvMat* dy = cvCreateMat( src->rows-1, src->cols, CV_64FC1 );
    //MSCR的预处理过程，主要完成步骤1和步骤2，后面会详细讲解
    Ne = preprocessMSER_8UC3( map, edge, &emean, src, mask, dx, dy, Ne, params.edgeBlurSize );
    //得到颜色相似度的距离均值
    emean = emean / (double)Ne;
    //对边缘列表进行升序排列，便于后面的距离阈值比较
    QuickSortMSCREdge( edge, Ne, 0 );
    //定义边缘列表的空间的上限
    MSCREdge* edge_ub = edge+Ne;
    //定义边缘列表的地址指针
    MSCREdge* edgeptr = edge;
    TempMSCR* mscrptr = mscr;
    // the evolution process
    //步骤3，进化处理，在t∈[ 0…T ]中循环，这里的i就是前面文章介绍的进化步长t
    for ( int i = 0; i < params.maxEvolution; i++ )
    {
        //下面的4条语句用于计算当前t下的dthr值，thres为dthr
        //数组chitab为事先计算好的查询表
        double k = (double)i/(double)params.maxEvolution*(TABLE_SIZE-1);
        int ti = cvFloor(k);
        double reminder = k-ti;
        double thres = emean*(chitab3[ti]*(1-reminder)+chitab3[ti+1]*reminder);
        // to process all the edges in the list that chi < thres
        //处理所有颜色相似度小于阈值的像素
        //edgeptr < edge_ub的作用是判断边缘列表指针是否超过了列表的上限，即所指向的不是边缘
        while ( edgeptr < edge_ub && edgeptr->chi < thres )
        {
            //由当前像素的左侧像素找到该像素所在的簇的根节点，也就是找到代表该像素所在区域的像素
            MSCRNode* lr = findMSCR( edgeptr->left );
            //由当前像素的右侧像素找到该像素所在的簇的根节点，也就是找到代表该像素所在区域的像素
            //需要注意的是，这里的左侧和右侧并不是真正意义的左侧和右侧，它们是由preprocessMSER_8UC3函数确定的
            MSCRNode* rr = findMSCR( edgeptr->right );
            // get the region root (who is responsible)
            //如果上面得到的两个根节点是一个节点，则不需要进行任何处理
            //如果这两个根节点不是一个，则需要把它们所代表的两个区域进行合并
            if ( lr != rr )
            {
                // rank idea take from: N-tree Disjoint-Set Forests for Maximally Stable Extremal Regions
                //下面的if语句用于判断是用rr还是用lr来代表合并后的区域，并且最终通过交换来实现lr代表合并后的区域
                //rank值大的根节点代表合并后的区域
                if ( rr->rank > lr->rank )
                {
                    MSCRNode* tmp;
                    CV_SWAP( lr, rr, tmp );
                } else if ( lr->rank == rr->rank ) {
                    // at the same rank, we will compare the size
                    //如果两个根节点的rank值相同，则区域面积大的代表合并后的区域
                    if ( lr->size > rr->size )
                    {
                        MSCRNode* tmp;
                        CV_SWAP( lr, rr, tmp );
                    }
                    lr->rank++;
                }
                //定义rr所表示的区域的根节点为lr
                rr->shortcut = lr;
                //合并两个区域，合并后区域面积为两个区域面积之和
                lr->size += rr->size;
                // join rr to the end of list lr (lr is a endless double-linked list)
                //把rr加入lr列表中，组成一个循环双链接列表
                lr->prev->next = rr;
                lr->prev = rr->prev;
                rr->prev->next = lr;
                rr->prev = lr;
                // area threshold force to reinitialize
                //利用公式2计算是否需要区域的重新初始化
                //if语句成立，则表示需要重新初始化
                if ( lr->size > (lr->size-rr->size)*params.areaThreshold )
                {
                    //更新面积，即a*值
                    lr->sizei = lr->size;
                    //更新当前的进化步长，即t值，以区分各个层
                    lr->reinit = i;
                    //tmsr保存着上一次计算得到的稳定区域信息
                    if ( lr->tmsr != NULL )
                    {
                        //公式4
                        lr->tmsr->m = lr->dt-lr->di;
                        /*tmsr赋值为NULL，表示该区域已经进行了重新初始化，因此在下次进化步长并计算到该节点的时候，需要保存该区域的最大稳定极值区域；还有一个目的是避免重复计算公式4*/
                        lr->tmsr = NULL;
                    }
                    //更新颜色相似度值，即d*值
                    lr->di = edgeptr->chi;
                    //为公式3中的s赋予一个极小的值
                    lr->s = 1e10;
                }
                //为该区域的颜色相似度赋值
                lr->dt = edgeptr->chi;
                //在重新初始化以后的进化步长中，当计算到该节点时，需要进入if语句内，以判断最大稳定极值区域
                if ( i > lr->reinit )
                {
                    //公式3
                    double s = (double)(lr->size-lr->sizei)/(lr->dt-lr->di);
                    //当公式3中的s是最小值时
                    if ( s < lr->s )
                    {
                        // skip the first one and check stablity
                        // i > lr->reinit+1的目的是避免计算重新初始化后的第一个进化步长
                        // MSCRStableCheck函数为计算最大稳定机制区域，即计算区域面积的变化率
                        if ( i > lr->reinit+1 && MSCRStableCheck( lr, params ) )
                        {
                            //tmsr为NULL，表示至从上次重新初始化以来，还没有为tmsr赋值，因此这次得到的稳定区域要作为最终输出保存下来
                            if ( lr->tmsr == NULL )
                            {
                                //gmsr为全局稳定区域，tmsr为暂存稳定区域，mscrptr为mscr的指针变量，它是最终输出的稳定区域
                                lr->gmsr = lr->tmsr = mscrptr;
                                mscrptr++;    //指向下一个地址
                            }
                            //为tmsr赋值
                            lr->tmsr->size = lr->size;
                            lr->tmsr->head = lr;
                            lr->tmsr->tail = lr->prev;
                            lr->tmsr->m = 0;
                        }
                        //保证s为最小值
                        lr->s = s;
                    }
                }
            }
            //指向下一个边缘
            edgeptr++;
        }
        //如果超出了边缘列表的范围，则退出for循环
        if ( edgeptr >= edge_ub )
            break;
    }
    //对最终得到的稳定区域进行裁剪，并输出
    for ( TempMSCR* ptr = mscr; ptr < mscrptr; ptr++ )
        // to prune area with margin less than minMargin
        //公式4，判断是否满足条件
        if ( ptr->m > params.minMargin )
        {
            //创建序列
            CvSeq* _contour = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvContour), sizeof(CvPoint), storage );
            //初始化该序列
            cvSeqPushMulti( _contour, 0, ptr->size );
            MSCRNode* lpt = ptr->head;
            for ( int i = 0; i < ptr->size; i++ )
            {
                CvPoint* pt = CV_GET_SEQ_ELEM( CvPoint, _contour, i );
                //得到稳定区域的坐标值
                pt->x = (lpt->index)&0xffff;
                pt->y = (lpt->index)>>16;
                lpt = lpt->next;
            }
            CvContour* contour = (CvContour*)_contour;
            cvBoundingRect( contour );
            contour->color = 0;
            //把坐标值压入序列中
            cvSeqPush( contours, &contour );
        }
    //清内存
    cvReleaseMat( &dx );
    cvReleaseMat( &dy );
    cvFree( &mscr );
    cvFree( &edge );
    cvFree( &map );
}

下面我们来介绍一下preprocessMSER_8UC3函数：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. // the preprocess to get the edge list with proper gaussian blur  
  2. static int preprocessMSER_8UC3( MSCRNode* node,    //图像像素节点  
  3.             MSCREdge* edge,    //边缘列表  
  4.             double* total,    //求相似度均值时使用，这里是所有像素相似度之和  
  5.             CvMat* src,    //原始图像  
  6.             CvMat* mask,    //掩码矩阵  
  7.             CvMat* dx,    //水平梯度矩阵  
  8.             CvMat* dy,    //垂直梯度矩阵  
  9.             int Ne,    //边缘列表元素的个数  
  10.             int edgeBlurSize )    //平滑处理的孔径尺寸大小  
  11. {  
  12.     int srccpt = src->step-src->cols*3;  
  13.     uchar* srcptr = src->data.ptr;    //图像当前像素指针  
  14.     uchar* lastptr = src->data.ptr+3;    //右侧像素指针  
  15.     double* dxptr = dx->data.db;    //水平梯度数据指针  
  16.     //计算当前像素与其右侧像素之间的颜色相似度  
  17.     for ( int i = 0; i < src->rows; i++ )  
  18.     {  
  19.         //图像最右侧一列没有该相似度，因此j < src->cols-1  
  20.         for ( int j = 0; j < src->cols-1; j++ )  
  21.         {  
  22.             //公式1，计算卡方距离，保存到dx内  
  23.             *dxptr = ChiSquaredDistance( srcptr, lastptr );  
  24.             //地址递增  
  25.             dxptr++;  
  26.             srcptr += 3;  
  27.             lastptr += 3;  
  28.         }  
  29.         //指向下一行  
  30.         srcptr += srccpt+3;  
  31.         lastptr += srccpt+3;  
  32.     }  
  33.     srcptr = src->data.ptr;    //图像当前像素指针  
  34.     lastptr = src->data.ptr+src->step;    //下一行像素指针  
  35.     double* dyptr = dy->data.db;    //垂直梯度数据指针  
  36.     //计算当前像素与其下面一行像素之间的颜色相似度  
  37.     //图像最下面一行没有该相似度，因此i < src->rows-1  
  38.     for ( int i = 0; i < src->rows-1; i++ )  
  39.     {  
  40.         for ( int j = 0; j < src->cols; j++ )  
  41.         {  
  42.             //保存到dy内  
  43.             *dyptr = ChiSquaredDistance( srcptr, lastptr );  
  44.             dyptr++;  
  45.             srcptr += 3;  
  46.             lastptr += 3;  
  47.         }  
  48.         srcptr += srccpt;  
  49.         lastptr += srccpt;  
  50.     }  
  51.     // get dx and dy and blur it  
  52.     //对颜色相似度值进行高斯平滑处理  
  53.     if ( edgeBlurSize >= 1 )  
  54.     {  
  55.         cvSmooth( dx, dx, CV_GAUSSIAN, edgeBlurSize, edgeBlurSize );  
  56.         cvSmooth( dy, dy, CV_GAUSSIAN, edgeBlurSize, edgeBlurSize );  
  57.     }  
  58.     dxptr = dx->data.db;  
  59.     dyptr = dy->data.db;  
  60.     // assian dx, dy to proper edge list and initialize mscr node  
  61.     // the nasty code here intended to avoid extra loops  
  62.     /*下面的if语句是为边缘列表赋值，如果定义了掩码矩阵，则边缘列表不保存被掩码掉的像素的边缘信息，因此边缘列表的个数Ne需要重新计算并输出。在这里我们以没有定义掩码矩阵为例进行讲解，两者的本质是一样的*/  
  63.     if ( mask )  
  64.     {  
  65.         Ne = 0;  
  66.         int maskcpt = mask->step-mask->cols+1;  
  67.         uchar* maskptr = mask->data.ptr;  
  68.         MSCRNode* nodeptr = node;  
  69.         initMSCRNode( nodeptr );  
  70.         nodeptr->index = 0;  
  71.         *total += edge->chi = *dxptr;  
  72.         if ( maskptr[0] && maskptr[1] )  
  73.         {  
  74.             edge->left = nodeptr;  
  75.             edge->right = nodeptr+1;  
  76.             edge++;  
  77.             Ne++;  
  78.         }  
  79.         dxptr++;  
  80.         nodeptr++;  
  81.         maskptr++;  
  82.         for ( int i = 1; i < src->cols-1; i++ )  
  83.         {  
  84.             initMSCRNode( nodeptr );  
  85.             nodeptr->index = i;  
  86.             if ( maskptr[0] && maskptr[1] )  
  87.             {  
  88.                 *total += edge->chi = *dxptr;  
  89.                 edge->left = nodeptr;  
  90.                 edge->right = nodeptr+1;  
  91.                 edge++;  
  92.                 Ne++;  
  93.             }  
  94.             dxptr++;  
  95.             nodeptr++;  
  96.             maskptr++;  
  97.         }  
  98.         initMSCRNode( nodeptr );  
  99.         nodeptr->index = src->cols-1;  
  100.         nodeptr++;  
  101.         maskptr += maskcpt;  
  102.         for ( int i = 1; i < src->rows-1; i++ )  
  103.         {  
  104.             initMSCRNode( nodeptr );  
  105.             nodeptr->index = i<<16;  
  106.             if ( maskptr[0] )  
  107.             {  
  108.                 if ( maskptr[-mask->step] )  
  109.                 {  
  110.                     *total += edge->chi = *dyptr;  
  111.                     edge->left = nodeptr-src->cols;  
  112.                     edge->right = nodeptr;  
  113.                     edge++;  
  114.                     Ne++;  
  115.                 }  
  116.                 if ( maskptr[1] )  
  117.                 {  
  118.                     *total += edge->chi = *dxptr;  
  119.                     edge->left = nodeptr;  
  120.                     edge->right = nodeptr+1;  
  121.                     edge++;  
  122.                     Ne++;  
  123.                 }  
  124.             }  
  125.             dyptr++;  
  126.             dxptr++;  
  127.             nodeptr++;  
  128.             maskptr++;  
  129.             for ( int j = 1; j < src->cols-1; j++ )  
  130.             {  
  131.                 initMSCRNode( nodeptr );  
  132.                 nodeptr->index = (i<<16)|j;  
  133.                 if ( maskptr[0] )  
  134.                 {  
  135.                     if ( maskptr[-mask->step] )  
  136.                     {  
  137.                         *total += edge->chi = *dyptr;  
  138.                         edge->left = nodeptr-src->cols;  
  139.                         edge->right = nodeptr;  
  140.                         edge++;  
  141.                         Ne++;  
  142.                     }  
  143.                     if ( maskptr[1] )  
  144.                     {  
  145.                         *total += edge->chi = *dxptr;  
  146.                         edge->left = nodeptr;  
  147.                         edge->right = nodeptr+1;  
  148.                         edge++;  
  149.                         Ne++;  
  150.                     }  
  151.                 }  
  152.                 dyptr++;  
  153.                 dxptr++;  
  154.                 nodeptr++;  
  155.                 maskptr++;  
  156.             }  
  157.             initMSCRNode( nodeptr );  
  158.             nodeptr->index = (i<<16)|(src->cols-1);  
  159.             if ( maskptr[0] && maskptr[-mask->step] )  
  160.             {  
  161.                 *total += edge->chi = *dyptr;  
  162.                 edge->left = nodeptr-src->cols;  
  163.                 edge->right = nodeptr;  
  164.                 edge++;  
  165.                 Ne++;  
  166.             }  
  167.             dyptr++;  
  168.             nodeptr++;  
  169.             maskptr += maskcpt;  
  170.         }  
  171.         initMSCRNode( nodeptr );  
  172.         nodeptr->index = (src->rows-1)<<16;  
  173.         if ( maskptr[0] )  
  174.         {  
  175.             if ( maskptr[1] )  
  176.             {  
  177.                 *total += edge->chi = *dxptr;  
  178.                 edge->left = nodeptr;  
  179.                 edge->right = nodeptr+1;  
  180.                 edge++;  
  181.                 Ne++;  
  182.             }  
  183.             if ( maskptr[-mask->step] )  
  184.             {  
  185.                 *total += edge->chi = *dyptr;  
  186.                 edge->left = nodeptr-src->cols;  
  187.                 edge->right = nodeptr;  
  188.                 edge++;  
  189.                 Ne++;  
  190.             }  
  191.         }  
  192.         dxptr++;  
  193.         dyptr++;  
  194.         nodeptr++;  
  195.         maskptr++;  
  196.         for ( int i = 1; i < src->cols-1; i++ )  
  197.         {  
  198.             initMSCRNode( nodeptr );  
  199.             nodeptr->index = ((src->rows-1)<<16)|i;  
  200.             if ( maskptr[0] )  
  201.             {  
  202.                 if ( maskptr[1] )  
  203.                 {  
  204.                     *total += edge->chi = *dxptr;  
  205.                     edge->left = nodeptr;  
  206.                     edge->right = nodeptr+1;  
  207.                     edge++;  
  208.                     Ne++;  
  209.                 }  
  210.                 if ( maskptr[-mask->step] )  
  211.                 {  
  212.                     *total += edge->chi = *dyptr;  
  213.                     edge->left = nodeptr-src->cols;  
  214.                     edge->right = nodeptr;  
  215.                     edge++;  
  216.                     Ne++;  
  217.                 }  
  218.             }  
  219.             dxptr++;  
  220.             dyptr++;  
  221.             nodeptr++;  
  222.             maskptr++;  
  223.         }  
  224.         initMSCRNode( nodeptr );  
  225.         nodeptr->index = ((src->rows-1)<<16)|(src->cols-1);  
  226.         if ( maskptr[0] && maskptr[-mask->step] )  
  227.         {  
  228.             *total += edge->chi = *dyptr;  
  229.             edge->left = nodeptr-src->cols;  
  230.             edge->right = nodeptr;  
  231.             Ne++;  
  232.         }  
  233.     } else {  
  234.         //定义节点指针  
  235.         MSCRNode* nodeptr = node;  
  236.         //下面是计算图像的左上角第一个像素节点  
  237.         initMSCRNode( nodeptr );    //初始化节点  
  238.         //index为对应的序列值，也就是图像的坐标，纵坐标保存在高16位内，横坐标保存在低16位内  
  239.         nodeptr->index = 0;   
  240.         //为边缘列表的卡方距离赋值，并累加该距离值  
  241.         *total += edge->chi = *dxptr;  
  242.         dxptr++;    //递增  
  243.         edge->left = nodeptr;    //边缘列表的左侧指向当前像素节点  
  244.         edge->right = nodeptr+1;    //右侧指向下一个像素节点  
  245.         edge++;    //递增  
  246.         nodeptr++;    //递增  
  247.         //下面的for循环是计算图像的第一行像素，对应的边缘列表的卡方距离保存的是水平梯度  
  248.         for ( int i = 1; i < src->cols-1; i++ )  
  249.         {  
  250.             initMSCRNode( nodeptr );  
  251.             nodeptr->index = i;      
  252.             *total += edge->chi = *dxptr;  
  253.             dxptr++;  
  254.             edge->left = nodeptr;  
  255.             edge->right = nodeptr+1;  
  256.             edge++;  
  257.             nodeptr++;  
  258.         }  
  259.         initMSCRNode( nodeptr );  
  260.         nodeptr->index = src->cols-1;    //图像第一行最后一个像素  
  261.         nodeptr++;    //指向图像的第二行  
  262.         //下面的双重for循环计算的是除了第一行和最后一行以外的像素  
  263.         for ( int i = 1; i < src->rows-1; i++ )  
  264.         {  
  265.             initMSCRNode( nodeptr );  
  266.             nodeptr->index = i<<16;    //图像的第一列  
  267.             *total += edge->chi = *dyptr;    //垂直梯度  
  268.             dyptr++;  
  269.             edge->left = nodeptr-src->cols;    //左侧为上面一行像素节点  
  270.             edge->right = nodeptr;    //右侧为当前像素节点  
  271.             edge++;  
  272.             *total += edge->chi = *dxptr;    //水平梯度  
  273.             dxptr++;  
  274.             edge->left = nodeptr;  
  275.             edge->right = nodeptr+1;  
  276.             edge++;  
  277.             nodeptr++;  
  278.             for ( int j = 1; j < src->cols-1; j++ )  
  279.             {  
  280.                 initMSCRNode( nodeptr );  
  281.                 nodeptr->index = (i<<16)|j;  
  282.                 *total += edge->chi = *dyptr;  
  283.                 dyptr++;  
  284.                 edge->left = nodeptr-src->cols;  
  285.                 edge->right = nodeptr;  
  286.                 edge++;  
  287.                 *total += edge->chi = *dxptr;  
  288.                 dxptr++;  
  289.                 edge->left = nodeptr;  
  290.                 edge->right = nodeptr+1;  
  291.                 edge++;  
  292.                 nodeptr++;  
  293.             }  
  294.             //图像最后一列像素  
  295.             initMSCRNode( nodeptr );  
  296.             nodeptr->index = (i<<16)|(src->cols-1);  
  297.             *total += edge->chi = *dyptr;  
  298.             dyptr++;  
  299.             edge->left = nodeptr-src->cols;  
  300.             edge->right = nodeptr;  
  301.             edge++;  
  302.             nodeptr++;  
  303.         }  
  304.         //图像的最后一行像素  
  305.         initMSCRNode( nodeptr );  
  306.         nodeptr->index = (src->rows-1)<<16;  
  307.         *total += edge->chi = *dxptr;  
  308.         dxptr++;  
  309.         edge->left = nodeptr;  
  310.         edge->right = nodeptr+1;  
  311.         edge++;  
  312.         *total += edge->chi = *dyptr;  
  313.         dyptr++;  
  314.         edge->left = nodeptr-src->cols;  
  315.         edge->right = nodeptr;  
  316.         edge++;  
  317.         nodeptr++;  
  318.         for ( int i = 1; i < src->cols-1; i++ )  
  319.         {  
  320.             initMSCRNode( nodeptr );  
  321.             nodeptr->index = ((src->rows-1)<<16)|i;  
  322.             *total += edge->chi = *dxptr;  
  323.             dxptr++;  
  324.             edge->left = nodeptr;  
  325.             edge->right = nodeptr+1;  
  326.             edge++;  
  327.             *total += edge->chi = *dyptr;  
  328.             dyptr++;  
  329.             edge->left = nodeptr-src->cols;  
  330.             edge->right = nodeptr;  
  331.             edge++;  
  332.             nodeptr++;  
  333.         }  
  334.         initMSCRNode( nodeptr );  
  335.         nodeptr->index = ((src->rows-1)<<16)|(src->cols-1);  
  336.         *total += edge->chi = *dyptr;  
  337.         edge->left = nodeptr-src->cols;  
  338.         edge->right = nodeptr;  
  339.     }  
  340.     return Ne;  
  341. }  
// the preprocess to get the edge list with proper gaussian blur
static int preprocessMSER_8UC3( MSCRNode* node,    //图像像素节点
            MSCREdge* edge,    //边缘列表
            double* total,    //求相似度均值时使用，这里是所有像素相似度之和
            CvMat* src,    //原始图像
            CvMat* mask,    //掩码矩阵
            CvMat* dx,    //水平梯度矩阵
            CvMat* dy,    //垂直梯度矩阵
            int Ne,    //边缘列表元素的个数
            int edgeBlurSize )    //平滑处理的孔径尺寸大小
{
    int srccpt = src->step-src->cols*3;
    uchar* srcptr = src->data.ptr;    //图像当前像素指针
    uchar* lastptr = src->data.ptr+3;    //右侧像素指针
    double* dxptr = dx->data.db;    //水平梯度数据指针
    //计算当前像素与其右侧像素之间的颜色相似度
    for ( int i = 0; i < src->rows; i++ )
    {
        //图像最右侧一列没有该相似度，因此j < src->cols-1
        for ( int j = 0; j < src->cols-1; j++ )
        {
            //公式1，计算卡方距离，保存到dx内
            *dxptr = ChiSquaredDistance( srcptr, lastptr );
            //地址递增
            dxptr++;
            srcptr += 3;
            lastptr += 3;
        }
        //指向下一行
        srcptr += srccpt+3;
        lastptr += srccpt+3;
    }
    srcptr = src->data.ptr;    //图像当前像素指针
    lastptr = src->data.ptr+src->step;    //下一行像素指针
    double* dyptr = dy->data.db;    //垂直梯度数据指针
    //计算当前像素与其下面一行像素之间的颜色相似度
    //图像最下面一行没有该相似度，因此i < src->rows-1
    for ( int i = 0; i < src->rows-1; i++ )
    {
        for ( int j = 0; j < src->cols; j++ )
        {
            //保存到dy内
            *dyptr = ChiSquaredDistance( srcptr, lastptr );
            dyptr++;
            srcptr += 3;
            lastptr += 3;
        }
        srcptr += srccpt;
        lastptr += srccpt;
    }
    // get dx and dy and blur it
    //对颜色相似度值进行高斯平滑处理
    if ( edgeBlurSize >= 1 )
    {
        cvSmooth( dx, dx, CV_GAUSSIAN, edgeBlurSize, edgeBlurSize );
        cvSmooth( dy, dy, CV_GAUSSIAN, edgeBlurSize, edgeBlurSize );
    }
    dxptr = dx->data.db;
    dyptr = dy->data.db;
    // assian dx, dy to proper edge list and initialize mscr node
    // the nasty code here intended to avoid extra loops
    /*下面的if语句是为边缘列表赋值，如果定义了掩码矩阵，则边缘列表不保存被掩码掉的像素的边缘信息，因此边缘列表的个数Ne需要重新计算并输出。在这里我们以没有定义掩码矩阵为例进行讲解，两者的本质是一样的*/
    if ( mask )
    {
        Ne = 0;
        int maskcpt = mask->step-mask->cols+1;
        uchar* maskptr = mask->data.ptr;
        MSCRNode* nodeptr = node;
        initMSCRNode( nodeptr );
        nodeptr->index = 0;
        *total += edge->chi = *dxptr;
        if ( maskptr[0] && maskptr[1] )
        {
            edge->left = nodeptr;
            edge->right = nodeptr+1;
            edge++;
            Ne++;
        }
        dxptr++;
        nodeptr++;
        maskptr++;
        for ( int i = 1; i < src->cols-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = i;
            if ( maskptr[0] && maskptr[1] )
            {
                *total += edge->chi = *dxptr;
                edge->left = nodeptr;
                edge->right = nodeptr+1;
                edge++;
                Ne++;
            }
            dxptr++;
            nodeptr++;
            maskptr++;
        }
        initMSCRNode( nodeptr );
        nodeptr->index = src->cols-1;
        nodeptr++;
        maskptr += maskcpt;
        for ( int i = 1; i < src->rows-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = i<<16;
            if ( maskptr[0] )
            {
                if ( maskptr[-mask->step] )
                {
                    *total += edge->chi = *dyptr;
                    edge->left = nodeptr-src->cols;
                    edge->right = nodeptr;
                    edge++;
                    Ne++;
                }
                if ( maskptr[1] )
                {
                    *total += edge->chi = *dxptr;
                    edge->left = nodeptr;
                    edge->right = nodeptr+1;
                    edge++;
                    Ne++;
                }
            }
            dyptr++;
            dxptr++;
            nodeptr++;
            maskptr++;
            for ( int j = 1; j < src->cols-1; j++ )
            {
                initMSCRNode( nodeptr );
                nodeptr->index = (i<<16)|j;
                if ( maskptr[0] )
                {
                    if ( maskptr[-mask->step] )
                    {
                        *total += edge->chi = *dyptr;
                        edge->left = nodeptr-src->cols;
                        edge->right = nodeptr;
                        edge++;
                        Ne++;
                    }
                    if ( maskptr[1] )
                    {
                        *total += edge->chi = *dxptr;
                        edge->left = nodeptr;
                        edge->right = nodeptr+1;
                        edge++;
                        Ne++;
                    }
                }
                dyptr++;
                dxptr++;
                nodeptr++;
                maskptr++;
            }
            initMSCRNode( nodeptr );
            nodeptr->index = (i<<16)|(src->cols-1);
            if ( maskptr[0] && maskptr[-mask->step] )
            {
                *total += edge->chi = *dyptr;
                edge->left = nodeptr-src->cols;
                edge->right = nodeptr;
                edge++;
                Ne++;
            }
            dyptr++;
            nodeptr++;
            maskptr += maskcpt;
        }
        initMSCRNode( nodeptr );
        nodeptr->index = (src->rows-1)<<16;
        if ( maskptr[0] )
        {
            if ( maskptr[1] )
            {
                *total += edge->chi = *dxptr;
                edge->left = nodeptr;
                edge->right = nodeptr+1;
                edge++;
                Ne++;
            }
            if ( maskptr[-mask->step] )
            {
                *total += edge->chi = *dyptr;
                edge->left = nodeptr-src->cols;
                edge->right = nodeptr;
                edge++;
                Ne++;
            }
        }
        dxptr++;
        dyptr++;
        nodeptr++;
        maskptr++;
        for ( int i = 1; i < src->cols-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = ((src->rows-1)<<16)|i;
            if ( maskptr[0] )
            {
                if ( maskptr[1] )
                {
                    *total += edge->chi = *dxptr;
                    edge->left = nodeptr;
                    edge->right = nodeptr+1;
                    edge++;
                    Ne++;
                }
                if ( maskptr[-mask->step] )
                {
                    *total += edge->chi = *dyptr;
                    edge->left = nodeptr-src->cols;
                    edge->right = nodeptr;
                    edge++;
                    Ne++;
                }
            }
            dxptr++;
            dyptr++;
            nodeptr++;
            maskptr++;
        }
        initMSCRNode( nodeptr );
        nodeptr->index = ((src->rows-1)<<16)|(src->cols-1);
        if ( maskptr[0] && maskptr[-mask->step] )
        {
            *total += edge->chi = *dyptr;
            edge->left = nodeptr-src->cols;
            edge->right = nodeptr;
            Ne++;
        }
    } else {
        //定义节点指针
        MSCRNode* nodeptr = node;
        //下面是计算图像的左上角第一个像素节点
        initMSCRNode( nodeptr );    //初始化节点
        //index为对应的序列值，也就是图像的坐标，纵坐标保存在高16位内，横坐标保存在低16位内
        nodeptr->index = 0; 
        //为边缘列表的卡方距离赋值，并累加该距离值
        *total += edge->chi = *dxptr;
        dxptr++;    //递增
        edge->left = nodeptr;    //边缘列表的左侧指向当前像素节点
        edge->right = nodeptr+1;    //右侧指向下一个像素节点
        edge++;    //递增
        nodeptr++;    //递增
        //下面的for循环是计算图像的第一行像素，对应的边缘列表的卡方距离保存的是水平梯度
        for ( int i = 1; i < src->cols-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = i;    
            *total += edge->chi = *dxptr;
            dxptr++;
            edge->left = nodeptr;
            edge->right = nodeptr+1;
            edge++;
            nodeptr++;
        }
        initMSCRNode( nodeptr );
        nodeptr->index = src->cols-1;    //图像第一行最后一个像素
        nodeptr++;    //指向图像的第二行
        //下面的双重for循环计算的是除了第一行和最后一行以外的像素
        for ( int i = 1; i < src->rows-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = i<<16;    //图像的第一列
            *total += edge->chi = *dyptr;    //垂直梯度
            dyptr++;
            edge->left = nodeptr-src->cols;    //左侧为上面一行像素节点
            edge->right = nodeptr;    //右侧为当前像素节点
            edge++;
            *total += edge->chi = *dxptr;    //水平梯度
            dxptr++;
            edge->left = nodeptr;
            edge->right = nodeptr+1;
            edge++;
            nodeptr++;
            for ( int j = 1; j < src->cols-1; j++ )
            {
                initMSCRNode( nodeptr );
                nodeptr->index = (i<<16)|j;
                *total += edge->chi = *dyptr;
                dyptr++;
                edge->left = nodeptr-src->cols;
                edge->right = nodeptr;
                edge++;
                *total += edge->chi = *dxptr;
                dxptr++;
                edge->left = nodeptr;
                edge->right = nodeptr+1;
                edge++;
                nodeptr++;
            }
            //图像最后一列像素
            initMSCRNode( nodeptr );
            nodeptr->index = (i<<16)|(src->cols-1);
            *total += edge->chi = *dyptr;
            dyptr++;
            edge->left = nodeptr-src->cols;
            edge->right = nodeptr;
            edge++;
            nodeptr++;
        }
        //图像的最后一行像素
        initMSCRNode( nodeptr );
        nodeptr->index = (src->rows-1)<<16;
        *total += edge->chi = *dxptr;
        dxptr++;
        edge->left = nodeptr;
        edge->right = nodeptr+1;
        edge++;
        *total += edge->chi = *dyptr;
        dyptr++;
        edge->left = nodeptr-src->cols;
        edge->right = nodeptr;
        edge++;
        nodeptr++;
        for ( int i = 1; i < src->cols-1; i++ )
        {
            initMSCRNode( nodeptr );
            nodeptr->index = ((src->rows-1)<<16)|i;
            *total += edge->chi = *dxptr;
            dxptr++;
            edge->left = nodeptr;
            edge->right = nodeptr+1;
            edge++;
            *total += edge->chi = *dyptr;
            dyptr++;
            edge->left = nodeptr-src->cols;
            edge->right = nodeptr;
            edge++;
            nodeptr++;
        }
        initMSCRNode( nodeptr );
        nodeptr->index = ((src->rows-1)<<16)|(src->cols-1);
        *total += edge->chi = *dyptr;
        edge->left = nodeptr-src->cols;
        edge->right = nodeptr;
    }
    return Ne;
}

下面我们再总结一下preprocessMSER_8UC3函数，首先根据公式1计算卡方距离，当前像素与其右侧像素之间的距离放在dx中，当前像素与其下面像素之间的距离放在dy中，存放的顺序都是从图像的左上角至图像的右下角。另外图像的最右一列没有dx，图像的最下一行没有dy。然后对dx和dy进行高斯平滑处理。最后创建边缘列表。边缘列表的顺序也是从图像的左上角至图像的右下角，与dx和dy的顺序完全一致，并且个数是dx与dy数量之和。如果边缘列表元素的卡方距离（edge->chi）为dx，则它的左侧（edge->left）和右侧（edge->right）分别指向的是图像的当前像素节点和它的右侧像素节点，因此对于图像的最右侧像素节点，没有dx，只有dy；如果边缘列表元素的卡方距离（edge->chi）为dy，则它的左侧（edge->left）和右侧（edge->right）分别指向的是图像的当前像素上一行像素节点和当前像素节点，因此对于图像的第一行没有dy，只有dx；图像的右上角的一个像素既没有dx，也没有dy；而其余像素节点既有dx，又有dy。


下面给出应用MSCR的应用实例：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/highgui/highgui.hpp"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4. #include <opencv2/features2d/features2d.hpp>  
  5. #include <iostream>  
  6. using namespace cv;  
  7. using namespace std;  
  8.   
  9. int main(int argc, char *argv[])  
  10. {  
  11.     Mat src,yuv;  
  12.     src = imread("puzzle.png");  
  13.     cvtColor(src, yuv, COLOR_BGR2YCrCb);  
  14.   
  15.     MSER ms;  
  16.     vector<vector<Point>> regions;  
  17.     ms(yuv, regions, Mat());  
  18.     for (int i = 0; i < regions.size(); i++)  
  19.     {  
  20.         ellipse(src, fitEllipse(regions[i]), Scalar(255,0,0));  
  21.     }  
  22.     imshow("mscr", src);  
  23.     waitKey(0);  
  24.     return 0;  
  25. }  
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <opencv2/features2d/features2d.hpp>
#include <iostream>
using namespace cv;
using namespace std;

int main(int argc, char *argv[])
{
    Mat src,yuv;
	src = imread("puzzle.png");
	cvtColor(src, yuv, COLOR_BGR2YCrCb);

    MSER ms;
    vector<vector<Point>> regions;
    ms(yuv, regions, Mat());
    for (int i = 0; i < regions.size(); i++)
    {
        ellipse(src, fitEllipse(regions[i]), Scalar(255,0,0));
    }
    imshow("mscr", src);
    waitKey(0);
    return 0;
}


从程序中可以看出，在进行MSCR之前，需要把RGB彩色图像转换为YCrCb形式，如果直接应用RGB彩色空间，则会检测到一些不正确的区域。

bbzz2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv4.2编译扩展模块opencv_contrib缺少的boostdesc_bgm.i，boostdesc_binboost_064.i等文件
12-27
VS编译opencv4.2扩展模块opencv_contrib-master缺失文件，下载失败，手动地址下载也失败的，可以下载本资源，解压后直接放到opencv_contrib-master\modules\xfeatures2d\src文件夹内，文件列表： boostdesc_bgm.i boostdesc_bgm_bi.i boostdesc_bgm_hd.i boostdesc_binboost_064.i boostdesc_binboost_128.i boostdesc_binboost_256.i boostdesc_lbgm.i generated_16.i generated_32.i generated_64.i vgg_generated_48.i vgg_generated_64.i vgg_generated_80.i vgg_generated_120.i
BRIEF 特征描述子
凌风探梅的专栏
03-12 1303
FROM:http://www.cnblogs.com/ronny/p/4081362.html Binary Robust Independent Elementary Features www.cnblogs.com/ronny 1. BRIEF的基本原理 我们已经知道SIFT特征采用了128维的特征描述子，由于描述子用的浮点数，所以它将会占用512 bytes的空间。类似地，
OpenCV中BriefDescriptorExtractor
GarfieldEr007的专栏
02-01 3200
class BriefDescriptorExtractor 计算BRIEF描述子的类.参考 Calonder M., Lepetit V., Strecha C., Fua P. BRIEF: Binary Robust Independent Elementary Features , 11th European Conference on Computer Vision (ECCV
BRIEF 特征点描述算法
奋斗才是年轻该有的状态
07-16 3688
一、BRIEF特征点描述算法简介   BRIEF是Binary Robust Independent Elementary Features的缩写。这个特征描述子是由EPFL的Calonder在ECCV2010上提出的。主要思路就是在特征点附近随机选取若干点对，将这些点对的灰度值的大小，组合成一个二进制串，并将这个二进制串作为该特征点的特征描述子。这种方法摈弃了利用区域灰度直方图描述特征点的传统方
BRIEF描述子原理、 python源码实现及基于opencv实现
xiaohuolong的博客
07-20 2610
BRIEF描述子原理、 python源码实现及基于opencv实现，BRIEF特征点描述
美妆面膜brief.xlsx
07-23
美妆面膜brief
BRIEF描述子 python源码实现及基于opencv实现
07-15
BRIEF描述子 python源码实现及基于opencv实现，BRIEF特征点描述，Bianry Robust Independent Elementary Features
A Brief History of Computing(2nd) epub
12-28
A Brief History of Computing(2nd) 英文epub 第2版 本资源转载自网络，如有侵权，请联系上传者或csdn删除 查看此书详细信息请在美国亚马逊官网搜索此书
Book Brief
06-29
Book Brief 1 20 Psychology in the Schools, January, 1976, Vol. 13, N o . 1. virtually every aspect of behavior cannot be generalized to later times and cul- tures. Also his Victorian attitudes ...
generated_16.i
04-14
generated_16.i
boostdesc_lbgm.i
02-10
opencv3.2编译需要用到的boostdesc_lbgm.i
boostdesc_bgm.i,vgg_generated_48.i等.zip
05-07
编译opencv时出现fatal error: boostdesc_bgm.i: No such file or directory，里面有boostdesc_bgm.i等文件。
【OpenCV 例程 300篇】244. 特征检测之 BRIEF 特征描述
youcans的博客
10-20 1930
BRIEF算子对检测到的特征点构造特征描述子，特点是直接生成二进制字符串作为特征描述符，效率很高。 BRIEF 建立描述子的速度很快，生成的二进制描述子便于高速匹配，且便于在硬件上实现。 BRIEF 算法不涉及特征点检测方法，需要配合 FAST、SURF、CenSurE 等特征点检测算法使用。
OpenCV-Python BRIEF(二进制的鲁棒独立基本特征) | 四十二
TensorFlowNews
02-20 1596
目标 在本章中，我们将看到BRIEF算法的基础知识 理论 我们知道SIFT使用128维矢量作为描述符。由于它使用浮点数，因此基本上需要512个字节。同样，SURF最少也需要256个字节（用于64像素）。为数千个功能部件创建这样的向量会占用大量内存，这对于资源受限的应用程序尤其是嵌入式系统而言是不可行的。内存越大，匹配所需的时间越长。 但是实际匹配可能不需要所有这些尺寸。我们可以使用PCA，LDA等...
【特征检测】BRIEF特征点描述算法
热门推荐
hujingshuang
07-16 3万+
BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度直方图描述特征点的传统方法，大大的加快了特征描述符建立的速度，同时也极大的降低了特征匹配的时间，是一种非常快速，很有潜力的算法。
图像卷积滤波的原理和均值滤波，盒型滤波，高斯滤波，中值滤波 ，双边滤波的Python程序实现
逗创科技——逗创创的博客
03-06 5098
图像卷积滤波的基本原理： 一个二维的滤波器矩阵（也就是卷积核）和一个要处理的二维图像；对于图像的每一个像素点，计算它的邻域像素和滤波器矩阵的对应元素的乘积，然后加起来，作为该像素位置的值，这样就完成了滤波过程。 不难发现，用3×3的核对一副6×6的图像进行卷积，得到的是4×4的图，图片缩小了！那怎么办呢？我们可以把原图扩充一圈，再卷积，这个操作叫padding。 事实上，原图为n×n，卷积核为f...
图像特征描述子之BRIEF
Zachary_Co的博客
12-21 5208
原文站点：https://senitco.github.io/2017/07/05/image-feature-brief/  BRIEF(Binary Robust Independent Elementary Features)是一种对已检测到的特征点进行表示和描述的特征描述方法，和传统的利用图像局部邻域的灰度直方图或梯度直方图提取特征的方式不同，BRIEF是一种二进制编码的特征描述子，既降低了
【特征匹配】BRIEF特征描述子原理及源码解析
steft的博客
08-03 2234
转载出处： http://blog.csdn.net/luoshixian099/article/details/48338273   传统的特征点描述子如SIFT,SURF描述子，每个特征点采用128维(SIFT)或者64维(SURF)向量去描述，每个维度上占用4字节，SIFT需要128×4=512字节内存，SURF则需要256字节。如果对于内存资源有限的情况下，这种描述子方法显然不适应。
brief算法matlab
最新发布
07-25
BRIEF算法是一种特征描述子提取算法，它可以在MATLAB中实现。BRIEF算法的主要思想是以特征点为中心，取一个大小为S x S的区域，并对该区域进行高斯平滑处理。然后，通过计算区域内的像素对的亮度差异，并将结果编码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值