c#-OpenCvSharp-SURF/SIFT特征匹配（附源码）_opencvsharp surf

目录

前言:

核心函数：

SURF.Create() 创建SURF检测器

 detector.DetectAndCompute() 检测关键点并计算特征描述向量

Cv2.DrawMatches()  绘制特征匹配

KeyPoint 类：

 匹配思路：

代码流程：

 运行结果：

前言:

SURF（Speeded Up Robust Features）是一种用于特征检测和图像匹配的算法，其主要特点是在提供良好特征匹配性能的同时，具有高速性和对图像变换的鲁棒性

核心函数：

SURF.Create() 创建SURF检测器

SURF.Create(hessianThreshold, extended, upright)

• hessianThreshold：Hessian阈值，用于控制关键点检测。通常，较大的值将导致更少但更重要的关键点。
• extended：如果为 true，则使用扩展的SURF描述符。扩展的描述符具有更多信息，但也更大。
• upright：如果为 true，则只检测正立（不旋转）的SURF特征。这在某些情况下可以提高性能。

 detector.DetectAndCompute() 检测关键点并计算特征描述向量

DetectAndCompute(Mat image, Mat mask, out KeyPoint[] keypoints, Mat descriptors)

• DetectAndCompute(Mat image, Mat mask, out KeyPoint[] keypoints, Mat descriptors) 用于检测关键点并计算特征描述向量。
• image：要检测关键点的图像。
• mask：一个可选的掩膜，可用于限制关键点的检测区域。
• keypoints：输出参数，存储检测到的关键点。
• descriptors：输出参数，存储计算的特征描述向量。

Cv2.DrawMatches()  绘制特征匹配

void Cv2.DrawMatches(
    Mat img1, KeyPoint[] keypoints1,
    Mat img2, KeyPoint[] keypoints2,
    DMatch[] matches1to2,
    Mat outImg,
    Scalar matchColor, Scalar singlePointColor,
    MatOfByte mask,
    DrawMatchesFlags flags = DrawMatchesFlags.Default );

• img1 和 img2: 两幅输入图像，用于绘制特征匹配。
• keypoints1 和 keypoints2: 分别是两幅图像的关键点数组。
• matches1to2: 一个包含特征点匹配关系的数组，通常是使用特征匹配算法（如SIFT，SURF，ORB）得出的。
• outImg: 存储输出结果的 Mat 对象，通常是一个空白图像，这个方法会在这个图像上绘制特征匹配。
• matchColor: 用于绘制匹配线的颜色。
• singlePointColor: 用于绘制单个特征点的颜色。
• mask: 可选参数，一个指示哪些匹配有效的掩码图像。如果不使用掩码，可以传递 null。
• flags: 一个可选参数，控制绘制特征匹配的方式。可以是 DrawMatchesFlags.Default 或其他选项。

KeyPoint 类：

• 用于表示检测到的关键点的类，包括位置、尺度、方向等信息。

 匹配思路：

1、创建检测器

2、检测关键点并计算特征描述向量

3、创建特征点匹配器并进行匹配

4、绘制两个图像匹配出得关键点

5、显示匹配图像

代码流程：

注释详细，仔细阅读。SURF匹配增加了筛选优秀匹配点的逻辑，SIFT匹配为主要流程的匹配

using OpenCvSharp;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Point = OpenCvSharp.Point;
 
namespace SURF_and_SIFT特征匹配
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        Mat srcImage1;
        Mat srcImage2;
 
        private void button1_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "Image Files(*.jpg;*.png*;*.bmp*)|*.jpg;*.png*;*.bmp";
            if (ofd.ShowDialog() != DialogResult.OK)
                return;
            string imagePath = ofd.FileName;
            srcImage1 = Cv2.ImRead(imagePath, ImreadModes.AnyColor);
            Cv2.ImShow("src image1", srcImage1);
        }
 
 
        private void button2_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "Image Files(*.jpg;*.png*;*.bmp*)|*.jpg;*.png*;*.bmp";
            if (ofd.ShowDialog() != DialogResult.OK)
                return;
            string imagePath = ofd.FileName;
            srcImage2 = Cv2.ImRead(imagePath, ImreadModes.AnyColor);
            Cv2.ImShow("src image2", srcImage2);
        }
 
        private void button3_Click(object sender, EventArgs e)
        {
                     
            // 定义SURF中的hessian阈值特征点检测算子
            int minHessian = 400;
            // 定义一个特征检测类对象
            var MySurf = OpenCvSharp.XFeatures2D.SURF.Create(minHessian, 4, 3, true, true);
 
            Mat descriptors1 = new Mat();
            Mat descriptors2 = new Mat();
 
            // 模板类是能够存放任意类型的动态数组，能够增加和压缩数据
            // 方法1：计算描述符（特征向量），将Detect和Compute操作分开
            //KeyPoint[] keyPoint1 = MySurf.Detect(srcImage1);
            //KeyPoint[] keyPoint2 = MySurf.Detect(srcImage2);
            //MySurf.Compute(srcImage1, ref keyPoint1, descriptors1);
            //MySurf.Compute(srcImage2, ref keyPoint2, descriptors2);
 
            // 方法2：计算描述符（特征向量），将Detect和Compute操作合并
            KeyPoint[] keyPoint1, keyPoint2;
            MySurf.DetectAndCompute(srcImage1, null, out keyPoint1, descriptors1);
            MySurf.DetectAndCompute(srcImage2, null, out keyPoint2, descriptors2);
 
            // 使用BruteForce进行匹配 暴力匹配
            // 创建特征点匹配器
            BFMatcher matcher = new BFMatcher(NormTypes.L2, crossCheck: false);
            // 匹配两幅图中的描述子（descriptors）
            DMatch[] matches = matcher.Match(descriptors1, descriptors2);
            
 
            // 设置比率阈值
            double ratio_thresh = 0.2;
 
            List<DMatch> good_matches = new List<DMatch>();
            for (int i = 0; i < matches.Length; i++)
            {
                if (matches[i].Distance < ratio_thresh)
                {
                    good_matches.Add(matches[i]);
                }
            }
 
            if (good_matches.Count <= 4)
            {
                // 匹配点不足，无法进行透视变换
                MessageBox.Show("合格匹配点数量不足" + good_matches.Count);
            }
           
 
            // 创建一个新的图像以绘制匹配结果
            Mat imgMatches = new Mat();
            // 绘制匹配关键点
            Cv2.DrawMatches(srcImage1, keyPoint1, srcImage2, keyPoint2, good_matches, imgMatches, null, null, null, DrawMatchesFlags.NotDrawSinglePoints);
 
 
            // -------锚定物体------------
            // 创建两个数组来存储匹配成功的特征点，一个用于物体图像（obj），另一个用于场景图像（scene）
            Point2d[] obj = new Point2d[good_matches.Count()], scene = new Point2d[good_matches.Count()];
          
 
            // 遍历匹配成功的特征点
            for (int i = 0; i < good_matches.Count(); i++)
            {
                // 获取查询图像中特征点的坐标，通过good_matches[i].QueryIdx找到对应特征点的索引
                obj[i] = keyPoint1[good_matches[i].QueryIdx].Pt.ToPoint();
 
                // 获取模板图像中对应的特征点坐标，通过good_matches[i].TrainIdx找到对应特征点的索引
                scene[i] = keyPoint2[good_matches[i].TrainIdx].Pt.ToPoint();
            }
            if (obj.Length < 4)
            {
                MessageBox.Show("obj优秀匹配点不足，数量为"+ obj.Length);
               
            }
 
            if (scene.Length < 4)
            {
                MessageBox.Show("匹配点不足,数量为"+ scene.Length);
                return;
            }
            // 使用Cv2.FindHomography方法计算透视变换矩阵H，它可以将物体图像映射到场景图像上
            // HomographyMethods.Ransac表示使用RANSAC算法来估计透视变换矩阵，3表示RANSAC算法的最大迭代次数，null表示不使用掩码
            Mat H = Cv2.FindHomography(obj, scene, HomographyMethods.Ransac, 3, null);
 
 
 
 
 
            // 创建两点，初始值设为最小和最大的浮点数，用于存储最左上角和最右下角的点
            Point2f topLeft = new Point2f(float.MaxValue, float.MaxValue);
            Point2f bottomRight = new Point2f(float.MinValue, float.MinValue);
 
            // 遍历所有匹配点
            foreach (DMatch match in good_matches)
            {
                // 获取当前匹配对中源图像和目标图像的点坐标
                Point2f srcPt = keyPoint1[match.QueryIdx].Pt;
                Point2f dstPt = keyPoint2[match.TrainIdx].Pt;
 
                // 寻找最左上角的点
                topLeft.X = Math.Min(topLeft.X, srcPt.X);
                topLeft.Y = Math.Min(topLeft.Y, srcPt.Y);
 
                // 寻找最右下角的点
                bottomRight.X = Math.Max(bottomRight.X, srcPt.X);
                bottomRight.Y = Math.Max(bottomRight.Y, srcPt.Y);
            }
 
            // 将浮点数坐标转换为整数坐标
            Point topLeftPoint = new Point((int)topLeft.X, (int)topLeft.Y);
            Point bottomRightPoint = new Point((int)bottomRight.X, (int)bottomRight.Y);
 
            // 绘制一个矩形框，框住匹配的区域
            Cv2.Rectangle(imgMatches, topLeftPoint, bottomRightPoint, new Scalar(0, 255, 0), 2);
 
 
 
            // 显示最终的匹配图像
            Cv2.ImShow("匹配图", imgMatches);
        }
 
 
        // SIFT特征匹配
        private void button4_Click(object sender, EventArgs e)
        {
            
            // 创建检测器
            int minHessian = 400;
            var MySift = OpenCvSharp.Features2D.SIFT.Create(minHessian);
 
            Mat descriptors1 = new Mat();
            Mat descriptors2 = new Mat();
 
            
            // 计算描述符（特征向量）
            KeyPoint[] keyPoint1, keyPoint2;
            MySift.DetectAndCompute(srcImage1, null, out keyPoint1, descriptors1);
            MySift.DetectAndCompute(srcImage2, null, out keyPoint2, descriptors2);
 
            // 使用BruteForce进行匹配
            // 创建特征点匹配器
            BFMatcher matcher = new BFMatcher();
            // 匹配两幅图中的描述子（descriptors）
            DMatch[] matches = matcher.Match(descriptors1, descriptors2);
 
            //【6】绘制从两个图像中匹配出的关键点
            Mat imgMatches = new Mat();
            Cv2.DrawMatches(srcImage1, keyPoint1, srcImage2, keyPoint2, matches, imgMatches);//进行绘制
 
 
 
            // 显示最终的匹配图像
            Cv2.ImShow("SIFT匹配", imgMatches);
        }
    }
}

 运行结果：