《opencv学习》 之 特征检测与匹配

这几天学习SURF特征检测，直接看的视频和书本有点吃不消，现在是基本看懂了，如果写博客记录没有必要，因为网上都差不多，笔记都在书上了，以下是个人认为比较浅显易懂的文章，当然海有很多好文章我没看到。

看第一篇入门就可以，后面讲的不是很好： http://blog.csdn.net/jwh_bupt/article/details/7621681

harris：  　　　　　　　　　　　　　　  http://www.cnblogs.com/ronny/p/4009425.html

Harr：　　　　　　　　　　　　　　　　 http://blog.csdn.net/zouxy09/article/details/7929570/

Box Filters：　　　　　　　　　　　　  http://blog.csdn.net/lanbing510/article/details/28696833

SIFT：　　　　　　　　　　　　　　　　 http://blog.csdn.net/abcjennifer/article/details/7639681/    　　　　　　　　　　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　  http://blog.csdn.net/pi9nc/article/details/23302075

Harr小波特征：　　　　　　　　　　　　 场合不同这个表示也不同，比如在SURF中表示dx、dy，当然也可以表示成其它样子，得看Harr的内核

SURF：　　　　　　　　　　　　　　　  看一下毛星云的那本书，其实网上说的差不多。

ORB：　　　　　　　　　　　　　　　　 http://www.aiuxian.com/article/p-1728722.html，里面包括FAST特征点、BRIEF描述子

HOG:　　　　　　　　　　　　　　　　　这个算法相对比较上面容易理解。

LBP：　　　　　　　　　　　　　　　　  http://blog.csdn.net/quincuntial/article/details/50541815这个算法可以手写实现，上面基本自己都实现不了（难度很大）

双线性插值：　　　　　　　　　　　　　百度百科有（先有三角函数计算坐标位置，然后用双线性插值计算像素值）

LBP算子

 经典LBP算法：
 1 int main(int argc, char**argv)
{
    Mat input_image, Middle_image,threshold_image;
    input_image = imread("1.jpg");
    if (input_image.data == NULL) {
        return -1; cout << "can't open image.../";
    }
    cvtColor(input_image, input_image, CV_BGR2GRAY);
    Mat output_image;
    output_image.create(Size(input_image.rows - 2, input_image.cols - 2), input_image.type());
    output_image.setTo(0, Mat());
    int width = input_image.cols * input_image.channels();
    int heigth = input_image.rows;
    for (size_t i = 1; i < heigth - 1; i++)
    {
        //uchar *ptr = input_image.ptr<uchar>(i);
        for (size_t j = 1; j < width - 1; j++)
        {
            uchar code = 0;
            uchar center = input_image.at<uchar>(i, j);
            code |= (input_image.at<uchar>(i - 1, j - 1) >= center) << 7;
            code |= (input_image.at<uchar>(i - 1, j ) >= center) << 6;
            code |= (input_image.at<uchar>(i - 1, j + 1) >= center) << 5;
            code |= (input_image.at<uchar>(i , j - 1) >= center) << 4;
            code |= (input_image.at<uchar>(i , j + 1) >= center) << 3;
            code |= (input_image.at<uchar>(i + 1, j - 1) >= center) << 2;
            code |= (input_image.at<uchar>(i + 1, j ) >= center) << 1;
            code |= (input_image.at<uchar>(i + 1, j + 1) >= center) << 0;
            output_image.at<uchar>(i - 1, j - 1) = code;
        }
    }
    imshow("LineImage", input_image);
    imshow("output_image", output_image);

    waitKey(0);
    return 0;
}

 

 

 CLBP：
 1 #include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

const int neighbor = 8;//圆周上共几个像素
const int radius = 3;

int main(int argc, char**argv)
{
    Mat input_image, output_image;
    input_image = imread("1.jpg");

    if (input_image.data == NULL) {
        return -1; cout << "can't open image.../";
    }
    cvtColor(input_image, input_image, CV_BGR2GRAY);
    //Mat output_image = Mat::zeros(Size(input_image.cols - 2 * 30, input_image.rows - 2 * 30), CV_8UC1);
    output_image.create(Size(input_image.cols - 2* radius, input_image.rows - 2*radius), CV_8UC1);
    output_image.setTo(0);
     int width = input_image.cols;
     int height = input_image.rows;
    
    
    for (size_t n = 0; n < neighbor; n++)
    {
        //-----计算圆边长点的坐标（这里x、y具体谁用cos和sin的结果一样，看后来计算双线性插值自己怎么理解了）
        float x = static_cast<float>(radius)  * cos(2.0 * CV_PI*n / static_cast<float>(neighbor));
        float y = static_cast<float>(-radius) * sin(2.0 * CV_PI*n / static_cast<float>(neighbor));//这里加不加负号效果一样，因为是点的顺序而已。
        //-----计算圆边上点的像素值，用双线性插值方法
        int fx = static_cast<int>(floor(x));
        int fy = static_cast<int>(floor(y));//上采样
        int cx = static_cast<int>(ceil(x));
        int cy = static_cast<int>(ceil(y));//下采样
        
        float dx = x - fx;
        float dy = y - fy;

        float w1 = (1 - dx)*(1 - dy);
        float w2 = dx*(1 - dy);
        float w3 = (1 - dx)*dy;
        float w4 = dx*dy;

        for (size_t i = radius; i < height - radius; i++)
        {
            for (size_t j = radius; j < width - radius; j++)
            {
                float p1 = input_image.at<uchar>(i + fy, j + fx);
                float p2 = input_image.at<uchar>(i + fy, j + cx);
                float p3 = input_image.at<uchar>(i + cy, j + fx);
                float p4 = input_image.at<uchar>(i + cy, j + cx);

                float Angle_data = p1*w1 + p2*w2 + p3*w3 + p4*w4;
                output_image.at<uchar>(i - radius, j - radius) |= (((input_image.at<uchar>(i, j) >= Angle_data) && (std::abs(Angle_data-input_image.at<uchar>(i,j)) > numeric_limits<float>::epsilon())) << n);
            }

        }
    }
    
    imshow("LineImage", input_image);
    imshow("output_image", output_image);

    waitKey(0);
    return 0;
}

 LBP后面还有很多知识，现在不学习那么深，只是了解一下，以后用到再继续深入。

SIFT算子

#if 1
#include <opencv2/opencv.hpp>
#include <opencv2/xfeatures2d.hpp>
#include <iostream>
#include "math.h"

using namespace cv::xfeatures2d;
using namespace cv;
using namespace std;

void calSIFTFeatureAndCompare(Mat& src1, Mat& src2);

int main(int argc, char**argv)
{
    Mat input_image1, input_image2;
    input_image1 = imread("hand1.jpg");
    input_image2 = imread("hand2.jpg");

    if (!input_image1.data && !input_image2.data) {
        return -1; cout << "can't open image.../";
    }
    calSIFTFeatureAndCompare(input_image1, input_image2);
    /*imshow("input_image1", input_image1);
    imshow("input_image2", input_image2);*/

    waitKey(0);
    return 0;
}
//-------------特征点：如同harris等检测的点一样（当然加了更多的约束）--------------//
//-------------描述子：点形成组织性，有方向和区域等，更能代表整副图像（也就是在特征点上加了更多的约束） --------------//
void calSIFTFeatureAndCompare(Mat& src1,Mat& src2)
{
    Mat grayMat1, grayMat2;
    cvtColor(src1, grayMat1, CV_BGR2GRAY);
    cvtColor(src2, grayMat2, CV_BGR2GRAY);
    normalize(grayMat1, grayMat1, 0, 255, CV_MINMAX);
    normalize(grayMat2, grayMat2, 0, 255, CV_MINMAX);
    /*//---定义SIFT描述子
    SiftFeatureDetector        detector; //计算特征点
    SiftDescriptorExtractor extractor;//计算描述子
    //---特征点检测
    vector<KeyPoint> keypoints1;
    vector<KeyPoint> keypoints2;
    detector.detect(grayMat1, keypoints1, Mat());
    detector.detect(grayMat2, keypoints2, Mat());
    //---计算特征点描述子
    Mat descriptors1, descriptors2;
    extractor.compute(grayMat1, keypoints1, descriptors1);
    extractor.compute(grayMat2, keypoints2, descriptors2);*/
    //SURF* detector = SURF::create(100);//那道理说是可以的，但是奔溃，不知道原因
    Ptr<SURF> detector = SURF::create(500);//这个参数hessianThreshold为海深矩阵的阈值T，看SIFT原理就可
    vector<KeyPoint> keypoints1;
    vector<KeyPoint> keypoints2;
    Mat descriptors1, descriptors2;
    //---特征点和描述子一起检测了
    detector->detectAndCompute(grayMat1, Mat(), keypoints1, descriptors1);
    detector->detectAndCompute(grayMat2, Mat(), keypoints2, descriptors2);
    //---特征点匹配
    vector<DMatch> matches;//存储匹配结果的类，和keypoint类似
    BFMatcher matcher(NORM_L1); //NORM_L1:代表SIFT，NORM_L2:代表SURF，默认SURF
    matcher.match(descriptors1, descriptors2, matches);
    Mat resultMatch;
    drawMatches(grayMat1, keypoints1, grayMat2, keypoints2, matches, resultMatch);
}

#endif

 

实际图片的匹配与寻找

 

 

 在原图上截取的一个小图片进行测试---->>>>

 　　　　　　　　　　　　　　　　　　　　本文利用SURF算子进行检测，利用FLANN进行匹配！

 

 

 

 上代码：

#if 1
#include <opencv2/opencv.hpp>
#include <opencv2/xfeatures2d.hpp>
#include <iostream>
#include "math.h"

using namespace cv::xfeatures2d;
using namespace cv;
using namespace std;


int main(int argc, char**argv)
{
    Mat input_image1, input_image2;
    input_image1 = imread("2.jpg");
    input_image2 = imread("1.jpg");

    if (!input_image1.data && !input_image2.data) {
        return -1; cout << "can't open image.../";
    }
    //-------------keypoints and descriptor detection
    const int minHessian = 400;
    Ptr<SURF> detector = SURF::create(minHessian);
    vector<KeyPoint> srcKeyPoint, dstKeyPoint;
    Mat srcDescriptor, dstDescriptor;
    detector->detectAndCompute(input_image1, Mat(), srcKeyPoint, srcDescriptor);
    detector->detectAndCompute(input_image2, Mat(), dstKeyPoint, dstDescriptor);
    //------------FLANN algorithm match
    FlannBasedMatcher matcher;
    vector<DMatch> matches;
    matcher.match(srcDescriptor, dstDescriptor, matches);
    Mat matchImage;
    drawMatches(input_image1, srcKeyPoint, input_image2, dstKeyPoint, matches, matchImage);
    //------------calculate best keypoint
    double maxDistance = 0, minDistance = 10000;
    for (size_t i = 0; i < matches.size(); i++)
    {
        maxDistance = maxDistance < matches[i].distance ? matches[i].distance : maxDistance;
        minDistance = minDistance < matches[i].distance ? minDistance : matches[i].distance;
    }
    vector<DMatch> bestMatches;
    for (size_t i = 0; i < matches.size(); i++)
    {
        if (matches[i].distance < 3 * minDistance)
        {
            bestMatches.push_back(matches[i]);
        }
    }
    Mat bestMatchImage;
    drawMatches(input_image1, srcKeyPoint, input_image2, dstKeyPoint, bestMatches, bestMatchImage);
    //-----------Find four corner points from bestMatches
    vector<Point2f> srcPoint;
    vector<Point2f> dstPoint;
    for (size_t i = 0; i < bestMatches.size(); i++)//save coordinate to srcPoint/dstPoint from bestMatches
    {
        srcPoint.push_back(srcKeyPoint[bestMatches[i].queryIdx].pt);
        dstPoint.push_back(dstKeyPoint[bestMatches[i].trainIdx].pt);
    }
    Mat H = findHomography(srcPoint, dstPoint,CV_RANSAC);//detection perspective Mapping（H映射）
    vector<Point2f> srcCorners(4);
    vector<Point2f> dstCorners(4);
    srcCorners[0] = Point(0, 0);
    srcCorners[1] = Point(input_image1.cols, 0);
    srcCorners[2] = Point(0, input_image1.rows);
    srcCorners[3] = Point(input_image1.cols, input_image1.rows);
    perspectiveTransform(srcCorners, dstCorners, H);//detection destination Corners
    line(input_image2, dstCorners[0], dstCorners[1], Scalar(255, 255, 0), 2);
    line(input_image2, dstCorners[0], dstCorners[2], Scalar(255, 255, 0), 2);
    line(input_image2, dstCorners[1], dstCorners[3], Scalar(255, 255, 0), 2);
    line(input_image2, dstCorners[2], dstCorners[3], Scalar(255, 255, 0), 2);
    waitKey(0);
    return 0;
}


#endif