(转)OPENCV特征点提取算法对比

时间:2024-02-16 10:29:37

   转自:OPENCV特征点提取算法对比

   

 

 

   除了我们熟知的SIFT、SURF、ORB等特征点提取算法,OpenCV中还提供了十余种特征点提取算法。最近在整理以往的ppt和报告,看到其中一页ppt,发现已经忘得差不多了,就再写篇博客复习下好了,这篇博客注重对比,技术方面的内容不会太过细致,希望能有帮助。当然,文章末尾会提供这些算法OpenCV调用的实例代码。
  首先,引发内容的就是下面这张ppt:(不要注意Why Surf了,当时根据具体应用场景所做的选择)左边一栏是特征点的数目,右边一栏是检测的速度,数据是在博主自己的测试集(大概四五百张图片)上测试的。

  

SIFT

SIFT的论文在谷歌学术上单片引用超过四万次,算得上那个年代特征提取技术的里程碑了。一改以往特征点提取不稳定,特征不足的弱点,SIFT可以稳定的提取出特征点,并且对旋转平移缩放是鲁棒的。可以说是SIFT开启了鲁棒特征提取研究,下面是SIFT特征提取的主要步骤:

特征点检测:

  1. 构建尺度空间
  2. 在Dog高斯差分空间计算极值点,二次曲线插值获得亚像素精度的特征点
  3. 去除低对比度点,通过计算Hessian矩阵去除边缘响应点

特征描述:

  1. 统计特征点周围16*16区域的直方图,并选取直方图峰值作为改关键点的主方向
  2. 将坐标轴旋转为关键点的方向,保证旋转不变性,根据梯度计算128维特征描述子

SIFT的鲁棒性是有特征点检测和特征描述两个部分决定的,在这页最开始的PPT中,都是只统计了特征点检测算法,没有考虑特征描述(因为有许多算法不具备描述能力)。

这里额外解释下Dog,对不同模糊度的高斯滤波图像相减,得到的Dog,事实上就是不同尺度边缘的Laplace边缘检测,Dog计算比逐个进行Laplace滤波要快。数学推导参见Paper,在高斯滤波sigma计算时需要一定条件,才能近似的得到拉普拉斯滤波图像。

                    

SURF

SURF算法可以看做是对SIFT算法的重要改进,全称Speeded-Up Robust Features,解决了SIFT计算复杂度高、耗时长的确定。SURF算法在光照和形变方面的鲁棒性要逊色于SIFT,但是带来了三倍的速度提升。

特征点检测:

  1. 计算积分图(为了加速Box滤波Harr小波的计算)
  2. 改变Box滤波器的尺度来得到不同的尺度空间
  3. 使用Hessian矩阵行列式的特征值的符号来确定极值

特征点描述:

  1. 根据像素在x,y方向上的Haar小波响应值来确定极值点方向
  2. 采用扇形区域扫描来统计得到64维或128维的直方图特征

FAST:BRISK/ORB/KAZE…

FAST是今年来最成功的特征点提取算法之一,其思想非常精妙。ORB算法、KAZE算法等都是使用FAST作为特征点检测算法,区别在于特征描述部分。

  1. 在图像中任选一点p, 假定其像素(亮度)值为 Ip
  2. 以3为半径画圆,覆盖p点周围的16个像素,如下图所示
  3. 设定阈值t,如果这周围的16个像素中有连续的n个像素的像素值都小于 Ipt 或者有连续的n个像素都大于 Ip+t, 那么这个点就被判断为角点。 在OpenCV的实现中n取值为12(16个像素周长的 3/4).
  4. 一种更加快的改进是: 首先检测p点周围的四个点,即1, 5, 9, 12四个点中是否有三个点满足超过Ip+t, 如果不满足,则直接跳过,如果满足,则继续使用前面的算法,全部判断16个点中是否有12个满足条件。

                                             

 

在OpenCV中提供了一个参数,可以选取三种FAST计算方法。

Brisk、ORB、KAZE等算法都采用了FAST做特征点检测,BRIEF做特征描述,它们的不同之处比较少。

速度大致为:SIFT<SURF<BRISK<FREAK<ORB

 

ORB

ORB速度极快,ORB是SIFT和SURF之外非常好的选择,因为SIFT和SURF是有专利的,在商业软件中使用需要付费(当然,但多数开发者选择无视,但是如果你是巨头,就要避免踩雷)。ORB是采用rBRIEF进行描述的,优点就是速度快。

BRISK

BRISK算法同样是免费的,也是规避SIFT和SURF专业的好选择,同样是采用FAST检测特征点,BRIEF描述。BRISK只是在尺度空间构建的参数和BRIEF描述方式上有所不同。在BRIEF描述时采用均匀采样模式,考虑512个短距离子集,形成64bit的描述符,采用汉明距离来度量相似性。

                                                

KAZE

  日语“风”“かぜ”,KAZE是一种和SIFT很像的方法,今年来收到广泛关注,因为它是近年来效果最好的方法。在构建尺度空间方面,KAZE采用AOS算法来对高斯模糊的图像进行非线性扩散滤波,通过不同的进化时间t来构建非线性尺度空间(与SIFT相似,只不过sigma换成了t)。在特征点检测方面,也是采用和SIFT相似的的方式,26邻域极值点加上海森矩阵检测的方式来检测出特征点。在特征描述方面,和SURF比较相似,采用扇形区域扫描的方式确定主方向,然后对于周围区域划分成4*4的区域,然后每个区域计算4维特征向量,总共得到64维的特征向量。与前面的算法最重要的不同在于,使用了非线性扩散滤波,在滤除噪声的同时保留了边缘和特征点,不会像高斯滤波之类的算法一样无差别的模糊图像,使得特征点检测更为稳定和有效。该算法在尺度鲁棒性上要逊色与SIFT,但是在速度和稳定性方面要强于SIFT,是目前最常用的特征点提取算法。该算法和SIFT算法在时间消耗上是差不多的,可以通过精简KAZE算法来提高速度。

               

 

 

 

Dense SIFT

Dense SIFT算法没有特征点提取过程,通过稠密无差别的采集样本点,计算SIFT特征来形成整幅图片的特征描述,这种特征常常在早期目标识别使用,现在已经被淘汰。

GFTT

Good Feature To Track,正式名称是shi_tomasi角点检测算法,这种算法可以提取出大量的特征点。一般在需要大量特征点时,可以使用GFTT。

MSER

最大稳定极值区域(MSER:Maximally Stable Extremal Regions)常被用于提取图像中的斑点,是一种分水岭算法。通过阈值分割,不断提升分割阈值,连通域变化稳定的区域被称为最大稳定极值区域。

综合对比

特征点检测速度:FAST > SURF > SIFT

特征点检测数量:根据阈值调整,博主的结果是: FAST > SURF > SIFT

            

 

 

 

OpenCV Code

bool CVPointLayer::Fast(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    FastFeatureDetector fast(layerparam.fast_param().thresh(), layerparam.fast_param().isnms());
 
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        fast.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::FastX(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    int xtype = 0;
    auto ftype = layerparam.fast_param().ftype();
    switch (ftype)
    {
    case svaf::FastParamCP_FastType_T_9_16:
        xtype = FastFeatureDetector::TYPE_9_16;
        break;
    case svaf::FastParamCP_FastType_T_7_12:
        xtype = FastFeatureDetector::TYPE_7_12;
        break;
    case svaf::FastParamCP_FastType_T_5_8:
        xtype = FastFeatureDetector::TYPE_5_8;
        break;
    default:
        break;
    }
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        cv::FASTX(images[i].image, pt, layerparam.fast_param().thresh(), 
            layerparam.fast_param().isnms(), xtype);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::MSER(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.mser_param();
    cv::MSER mser(param.delta(), param.min_area(), param.max_area(), 
        param.max_varia(), param.min_divers(), param.max_evolution(), 
        param.area_thresh(), param.min_margin(), param.edgeblur_size());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        mser.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::ORB(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.orb_param();
    auto obrtype = param.scoretype();
    int otype = 0;
    switch (obrtype)
    {
    case svaf::ORBParamCP_OBRScoreType_HARRIS_SCORE:
        otype = ORB::HARRIS_SCORE;
        break;
    case svaf::ORBParamCP_OBRScoreType_FAST_SCORE:
        otype = ORB::FAST_SCORE;
        break;
    default:
        break;
    }
    cv::ORB orb(param.nfeatures(), param.scalefactor(), param.nlevels(), param.edgethresh(), 
        param.firstlevel(), param.wta_k(), otype, param.patchsize());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        orb.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Brisk(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.brisk_param();
    BRISK brisk(param.thresh(), param.octaves(), param.ptscale());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        brisk.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Freak(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    FREAK freak;
    LOG(FATAL) << "No Impliment!";
    return false;
}
 
bool CVPointLayer::Star(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.star_param();
    cv::StarDetector star(param.maxsize(), param.response_thresh(), param.projected_thresh(), 
        param.binarized_thresh(), param.nms_size());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        star.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Sift(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.sift_param();
    SIFT sift(param.nfeatures(), param.octaves(), param.contrast_thresh(), 
        param.edge_thresh(), param.sigma());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        sift.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Surf(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.surf_param();
    SURF surf(param.hassian_thresh(), param.octaves(), param.intevals(), 
        param.extended(), param.upright());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        surf.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::GFTT(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.gftt_param();
    GoodFeaturesToTrackDetector gftt(param.maxcornners(), param.quality(), param.mindist(),
        param.blocksize(), param.useharris(), param.k());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        gftt.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Harris(vector<Block>& images, vector<Block>& disp){
    /*vector<KeyPoint> pt;
    Ptr<FeatureDetector> detector = FeatureDetector::create("HARRIS");
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        detector->detect(images[i].image, pt);
        for (int j = 0; j < pt.size(); ++j){
            images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        }
    }
    return true;*/
    vector<KeyPoint> pt;
    auto param = layerparam.gftt_param();
    GoodFeaturesToTrackDetector gftt(param.maxcornners(), param.quality(), param.mindist(),
        param.blocksize(), true, param.k());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        gftt.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Dense(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    auto param = layerparam.dense_param();
    DenseFeatureDetector dense(param.initfeatscale(), param.featscalelevel(), param.featscalemul(),
        param.initxystep(), param.initbound(), param.varyxyscale(), param.varybdscale());
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        dense.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::SimpleBlob(vector<Block>& images, vector<Block>& disp){
    vector<KeyPoint> pt;
    SimpleBlobDetector sb;
    for (int i = 0; i < images.size(); ++i){
        pt.clear();
        sb.detect(images[i].image, pt);
        images[i].keypoint.insert(images[i].keypoint.begin(), pt.begin(), pt.end());
        LOG(INFO) << featname << " Detected <" << pt.size() << "> points";
    }
    return true;
}
 
bool CVPointLayer::Grid(vector<Block>& images, vector<Block>& disp){
    Ptr<FeatureDetector> detector = FeatureDetector::create("Grid");
    return false;
}
 
bool CVPointLayer::Pyramid(vector<Block>& images, vector<Block>& disp){
    Ptr<FeatureDetector> detector = FeatureDetector::create("Pyramid");
    return false;
}