opencv：feature2D学习——SIFT和SURF算法实现目标检测

小咪咪 2022-12-08 04:25 385阅读 0赞

> 当前使用版本opencv3.4.0，需要安装opencv\_contrib

# surf特征点检测 #

*  surf算法为每个检测到的特征定义了位置和尺度，尺度值可以用于定义围绕特征点的窗口大小，不论物体的尺度在窗口是怎么样的，都将包含相同的视觉信息，这些信息用于表示特征点以使得它们与众不同。

> SURF 算法，全称是 Speeded-Up Robust Features

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]

## 绘制关键点：drawKeypoints ##

CV_EXPORTS_W void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage,
                                   const Scalar& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT );

# SURF特征描述 #

#include "opencv2/highgui.hpp"
    #include "opencv2/xfeatures2d/nonfree.hpp"
    #include <iostream>
    #include <opencv2/calib3d/calib3d_c.h>
    
    
    using namespace cv;
    using namespace std;
    using namespace cv::xfeatures2d;
    
    int main()
    {
        
        Mat srcImage1 = imread( "/home/oceanstar/桌面/1.png", CV_LOAD_IMAGE_GRAYSCALE );
        Mat srcImage2 = imread( "/home/oceanstar/桌面/2.png", CV_LOAD_IMAGE_GRAYSCALE );
        if( !srcImage1.data || !srcImage2.data )//检测是否读取成功
        {
         printf("读取图片错误，请确定目录下是否有imread函数指定名称的图片存在~！ \n"); return false; }
    
    
        int minHessian = 3000;  //定义SURF中的hessian阈值特征点检测算子
         //定义一个SurfFeatureDetector（SURF） 特征检测类对象
        Ptr<cv::xfeatures2d::SurfFeatureDetector>detector = cv::xfeatures2d::SurfFeatureDetector::create(minHessian);
        std::vector<KeyPoint> keypoints_1, keypoints_2;//vector模板类是能够存放任意类型的动态数组，能够增加和压缩数据
    
        //【3】调用detect函数检测出SURF特征关键点，保存在vector容器中
        detector->detect( srcImage1, keypoints_1 );
        detector->detect( srcImage2, keypoints_2 );
    
        ///【4】 使用SIFT算子提取特征（计算特征向量）
        Ptr<xfeatures2d::SurfDescriptorExtractor> extractor = xfeatures2d::SurfDescriptorExtractor::create();
        Mat descriptors1, descriptors2;
        extractor->compute( srcImage1, keypoints_1, descriptors1 );
        extractor->compute( srcImage2, keypoints_2, descriptors2 );
    
        //【5】使用BruteForce进行匹配
        // 实例化一个匹配器
        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce");
        std::vector< DMatch > matches;
        //匹配两幅图中的描述子（descriptors）
        matcher->match( descriptors1, descriptors2, matches );
    
        //【6】绘制从两个图像中匹配出的关键点
        Mat imgMatches;
        drawMatches( srcImage1, keypoints_1, srcImage2, keypoints_2, matches, imgMatches );//进行绘制
    
        //【7】显示效果图
        imshow("匹配图", imgMatches );
        waitKey(0);
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 1]

# 使用FLANN进行特征点匹配 #

#include "opencv2/highgui.hpp"
    #include "opencv2/xfeatures2d/nonfree.hpp"
    #include <iostream>
    #include <opencv2/calib3d/calib3d_c.h>
    
    
    using namespace cv;
    using namespace std;
    using namespace cv::xfeatures2d;
    
    int main()
    {
        
        //【1】载入源图片
        Mat srcImage_1 = imread( "/home/oceanstar/桌面/1.png", CV_LOAD_IMAGE_GRAYSCALE );
        Mat srcImage_2 = imread( "/home/oceanstar/桌面/2.png", CV_LOAD_IMAGE_GRAYSCALE );
        if( !srcImage_1.data || !srcImage_2.data )//检测是否读取成功
        {
         printf("读取图片错误，请确定目录下是否有imread函数指定名称的图片存在~！ \n"); return false; }
    
    
        //【2】利用SURF检测器检测的关键点
        int minHessian = 3000;
        Ptr<SURF>detector = SURF::create(minHessian);
        std::vector<KeyPoint> keypoints_1, keypoints_2;
        detector->detect( srcImage_1, keypoints_1 );
        detector->detect( srcImage_2, keypoints_2 );
    
        ///【4】 使用SIFT算子提取特征（计算特征向量）
        Ptr<SURF> extractor = SurfDescriptorExtractor::create();
        Mat descriptors_1, descriptors_2;
        extractor->compute( srcImage_1, keypoints_1, descriptors_1 );
        extractor->compute( srcImage_2, keypoints_2, descriptors_2 );
    
        //【4】采用FLANN算法匹配描述符向量
        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
        std::vector< DMatch > matches;
        matcher->match( descriptors_1, descriptors_2, matches );
    
        //【5】快速计算关键点之间的最大和最小距离
        double max_dist = 0; double min_dist = 100;
        for( int i = 0; i < descriptors_1.rows; i++ )
        {
        
            double dist = matches[i].distance;
            if( dist < min_dist ) min_dist = dist;
            if( dist > max_dist ) max_dist = dist;
        }
        printf("> 最大距离（Max dist） : %f \n", max_dist );
        printf("> 最小距离（Min dist） : %f \n", min_dist );
    
        //【6】存下符合条件的匹配结果（即其距离小于2* min_dist的），使用radiusMatch同样可行
        std::vector< DMatch > good_matches;
        for( int i = 0; i < descriptors_1.rows; i++ )
        {
        
            if( matches[i].distance < 2*min_dist )
            {
         good_matches.push_back( matches[i]); }
        }
    
    
    
        //【7】绘制出符合条件的匹配点
        Mat img_matches;
        drawMatches( srcImage_1, keypoints_1, srcImage_2, keypoints_2,
                     good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
                     vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
    
        //【8】输出相关匹配点信息
        for( int i = 0; i < good_matches.size(); i++ )
        {
         printf( ">符合条件的匹配点 [%d] 特征点1: %d  -- 特征点2: %d  \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx ); }
    
    
        //【9】显示效果图
        imshow( "匹配效果图", img_matches );
    
    
        //按任意键退出程序
        waitKey(0);
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 2]

# 寻找已知物体 #

#include "opencv2/highgui.hpp"
    #include "opencv2/xfeatures2d/nonfree.hpp"
    #include <iostream>
    #include <opencv2/calib3d/calib3d_c.h>
    #include <cv.hpp>
    
    
    using namespace cv;
    using namespace std;
    using namespace cv::xfeatures2d;
    
    int main()
    {
        
        //【1】载入源图片
        Mat srcImage_1 = imread( "/home/oceanstar/桌面/1.png", CV_LOAD_IMAGE_GRAYSCALE );
        Mat srcImage_2 = imread( "/home/oceanstar/桌面/2.png", CV_LOAD_IMAGE_GRAYSCALE );
        if( !srcImage_1.data || !srcImage_2.data )//检测是否读取成功
        {
         printf("读取图片错误，请确定目录下是否有imread函数指定名称的图片存在~！ \n"); return false; }
    
    
        //【2】利用SURF检测器检测的关键点
        int minHessian = 300;
        Ptr<SURF>detector = SURF::create(minHessian);
        std::vector<KeyPoint> keypoints_1, keypoints_2;
        detector->detect( srcImage_1, keypoints_1 );
        detector->detect( srcImage_2, keypoints_2 );
    
    
        ///【4】 使用SIFT算子提取特征（计算特征向量）
        Ptr<SURF> extractor = SurfDescriptorExtractor::create();
        Mat descriptors_1, descriptors_2;
        extractor->compute( srcImage_1, keypoints_1, descriptors_1 );
        extractor->compute( srcImage_2, keypoints_2, descriptors_2 );
    
       //【5】使用FLANN匹配算子进行匹配
        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
        std::vector< DMatch > matches;
        matcher->match( descriptors_1, descriptors_2, matches );
    
        //【5】快速计算关键点之间的最大和最小距离
        double max_dist = 0; double min_dist = 100;
        for( int i = 0; i < descriptors_1.rows; i++ )
        {
        
            double dist = matches[i].distance;
            if( dist < min_dist ) min_dist = dist;
            if( dist > max_dist ) max_dist = dist;
        }
        printf("> 最大距离（Max dist） : %f \n", max_dist );
        printf("> 最小距离（Min dist） : %f \n", min_dist );
    
        //【6】存下符合条件的匹配结果（即其距离小于3* min_dist的），使用radiusMatch同样可行
        std::vector< DMatch > good_matches;
        for( int i = 0; i < descriptors_1.rows; i++ )
        {
        
            if( matches[i].distance < 3*min_dist )
            {
         good_matches.push_back( matches[i]); }
        }
    
    
    
        //【7】绘制出符合条件的匹配点
        Mat img_matches;
        drawMatches( srcImage_1, keypoints_1, srcImage_2, keypoints_2,
                     good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
                     vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
    
        //定义两个局部变量
        vector<Point2f> obj;
        vector<Point2f> scene;
    
        //从匹配成功的匹配对中获取关键点
        for( unsigned int i = 0; i < good_matches.size(); i++ )
        {
        
            obj.push_back( keypoints_1[ good_matches[i].queryIdx ].pt );
            scene.push_back( keypoints_2[ good_matches[i].trainIdx ].pt );
        }
    
        Mat H = findHomography( obj, scene, CV_RANSAC );//计算透视变换
    
        //从待测图片中获取角点
        vector<Point2f> obj_corners(4);
        obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( srcImage_1.cols, 0 );
        obj_corners[2] = cvPoint( srcImage_1.cols, srcImage_1.rows ); obj_corners[3] = cvPoint( 0, srcImage_1.rows );
        vector<Point2f> scene_corners(4);
    
        //进行透视变换
        perspectiveTransform( obj_corners, scene_corners, H);
    
        //绘制出角点之间的直线
        line( img_matches, scene_corners[0] + Point2f( static_cast<float>(srcImage_1.cols), 0), scene_corners[1] + Point2f( static_cast<float>(srcImage_1.cols), 0), Scalar(255, 0, 123), 4 );
        line( img_matches, scene_corners[1] + Point2f( static_cast<float>(srcImage_1.cols), 0), scene_corners[2] + Point2f( static_cast<float>(srcImage_1.cols), 0), Scalar( 255, 0, 123), 4 );
        line( img_matches, scene_corners[2] + Point2f( static_cast<float>(srcImage_1.cols), 0), scene_corners[3] + Point2f( static_cast<float>(srcImage_1.cols), 0), Scalar( 255, 0, 123), 4 );
        line( img_matches, scene_corners[3] + Point2f( static_cast<float>(srcImage_1.cols), 0), scene_corners[0] + Point2f( static_cast<float>(srcImage_1.cols), 0), Scalar( 255, 0, 123), 4 );
    
        //显示最终结果
        imshow( "效果图", img_matches );
    
        //按任意键退出程序
        waitKey(0);
        return 0;
    }

# FLANN结合SURF进行关键点的描述和匹配 #

#include "opencv2/highgui.hpp"
    #include "opencv2/xfeatures2d/nonfree.hpp"
    #include <iostream>
    #include <opencv2/calib3d/calib3d_c.h>
    #include <cv.hpp>
    
    
    using namespace cv;
    using namespace std;
    using namespace cv::xfeatures2d;
    
    int main()
    {
        
    
    
        //【1】载入图像、显示并转化为灰度图
        Mat trainingImg = imread("/home/oceanstar/桌面/1.png");
        if(trainingImg.empty()){
        
            cout << "capture_mat capture_mat capture_mat capture_mat" << endl;
            return 0;
        }
        imshow("原始图",trainingImg);
        cvtColor(trainingImg, trainingImg, CV_BGR2GRAY);
    
        //【2】检测SIFT关键点、提取训练图像描述符
        //【2】检测SIFT关键点、提取训练图像描述符
        int minHessian = 700;
        vector<KeyPoint> train_keyPoint;
        Mat trainDescription;
        Ptr<SiftFeatureDetector>featureDetector = SiftFeatureDetector::create(minHessian);
        Ptr<SiftDescriptorExtractor> featureExtractor = SiftDescriptorExtractor::create();
        featureDetector->detect(trainingImg, train_keyPoint);
        featureExtractor->compute(trainingImg, train_keyPoint, trainDescription);
    
        // 【3】进行基于描述符的暴力匹配
        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
        vector<Mat> train_desc_collection(1, trainDescription);
        matcher->add(train_desc_collection);
        matcher->train();
    
        //【4】创建视频对象、定义帧率
        VideoCapture cap(0);
        unsigned int frameCount = 0;//帧数
    
        //【5】不断循环，直到q键被按下
        while(char(waitKey(1)) != 'q')
        {
        
            //<1>参数设置
            auto time0 = static_cast<double>(getTickCount( ));//记录起始时间
            Mat srcFrameImg;
            cap >> srcFrameImg;//采集视频到testImage中
            if(srcFrameImg.empty())
                continue;
    
            //<2>转化图像到灰度
            cvtColor(srcFrameImg, srcFrameImg, CV_BGR2GRAY);
    
            //<3>检测SURF关键点、提取测试图像描述符
            vector<KeyPoint> test_keyPoint;
            Mat testDescriptor;
            featureDetector->detect(srcFrameImg, test_keyPoint);
            featureExtractor->compute(srcFrameImg, test_keyPoint, testDescriptor);
    
            //<4>匹配训练和测试描述符
            vector<vector<DMatch> > matches;
            matcher->knnMatch(testDescriptor, matches, 2);
    
            // <5>根据劳氏算法（Lowe's algorithm），得到优秀的匹配点
            vector<DMatch> goodMatches;
            for(auto & matche : matches)
            {
        
                if(matche[0].distance < 0.6 * matche[1].distance)
                    goodMatches.push_back(matche[0]);
            }
    
    
            //<6>绘制匹配点并显示窗口
            Mat dstImage;
            drawMatches(srcFrameImg, test_keyPoint, trainingImg, train_keyPoint, goodMatches, dstImage);
            imshow("匹配窗口", dstImage);
    
            //<7>输出帧率信息
            cout << "\t>当前帧率为：" << getTickFrequency() / (getTickCount() - time0) << endl;
        }
    
        return 0;
    }

# SIFT配合暴力匹配进行关键点描述和提取 #

> 当前使用版本opencv4.3

#include <opencv2/opencv.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/features2d/features2d.hpp>
    #include <opencv2/xfeatures2d.hpp>
    
    using namespace cv;
    using namespace std;
    
    
    int main()
    {
        
    
        //【1】载入图像、显示并转化为灰度图
        Mat trainImage = imread( "/home/oceanstar/桌面/1.png" ), trainImage_gray;
        imshow("原始图",trainImage);
        cvtColor(trainImage, trainImage_gray, COLOR_BGR2GRAY);
    
        //【2】检测SIFT关键点、提取训练图像描述符
        //【2】检测SIFT关键点、提取训练图像描述符
        int minHessian = 700;
        vector<KeyPoint> train_keyPoint;
        Mat trainDescription;
        Ptr<cv::xfeatures2d::SiftFeatureDetector>featureDetector = cv::xfeatures2d::SiftFeatureDetector::create(minHessian);
        Ptr<xfeatures2d::SiftDescriptorExtractor> featureExtractor = xfeatures2d::SiftDescriptorExtractor::create();
        featureDetector->detect(trainImage, train_keyPoint);
        featureExtractor->compute(trainImage, train_keyPoint, trainDescription);
    
        std::vector<KeyPoint> keypoints_1, keypoints_2;//vector模板类是能够存放任意类型的动态数组，能够增加和压缩数据
    
    
    
        ///【4】 使用SIFT算子提取特征（计算特征向量）
        Mat descriptors1, descriptors2;
        featureExtractor->compute( trainImage, keypoints_1, descriptors1 );
        featureExtractor->compute( trainImage, keypoints_2, descriptors2 );
    
        // 【3】进行基于描述符的暴力匹配
        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
        vector<Mat> train_desc_collection(1, trainDescription);
        matcher->add(train_desc_collection);
        matcher->train();
    
        //【4】创建视频对象、定义帧率
        VideoCapture cap("rtmp://************************");
        unsigned int frameCount = 0;//帧数
    
        //【5】不断循环，直到q键被按下
        while(char(waitKey(1)) != 'q')
        {
        
            //<1>参数设置
            double time0 = static_cast<double>(getTickCount( ));//记录起始时间
            Mat captureImage, captureImage_gray;
            cap >> captureImage;//采集视频到testImage中
            if(captureImage.empty())
                continue;
    
            //<2>转化图像到灰度
            cvtColor(captureImage, captureImage_gray, COLOR_BGR2GRAY);
    
            //<3>检测SURF关键点、提取测试图像描述符
            vector<KeyPoint> test_keyPoint;
            Mat testDescriptor;
            featureDetector->detect(captureImage_gray, test_keyPoint);
            featureExtractor->compute(captureImage_gray, test_keyPoint, testDescriptor);
    
            //<4>匹配训练和测试描述符
            vector<vector<DMatch> > matches;
            matcher->knnMatch(testDescriptor, matches, 2);
    
            // <5>根据劳氏算法（Lowe's algorithm），得到优秀的匹配点
            vector<DMatch> goodMatches;
            for(unsigned int i = 0; i < matches.size(); i++)
            {
        
                if(matches[i][0].distance < 0.6 * matches[i][1].distance) // 0.6
                    goodMatches.push_back(matches[i][0]);
            }
    
            //<6>绘制匹配点并显示窗口
            Mat dstImage;
            drawMatches(captureImage, test_keyPoint, trainImage, train_keyPoint, goodMatches, dstImage);
            resize(dstImage, dstImage, Size(dstImage.cols / 2, dstImage.rows / 2), 0, 0, INTER_LINEAR_EXACT);
            imshow("匹配窗口", dstImage);
    
            //<7>输出帧率信息
            cout << "\t>当前帧率为：" << getTickFrequency() / (getTickCount() - time0) << endl;
        }
    
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/9b26033c29fc404799b22de3f9663e54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/b876bdba70b949f683f895f5b29e9492.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/ea44adef0dd347feb527ce3ed921b7df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/45346ade53714e0f857ca5d4503c26f0.png