SURF特征提取与匹配实践

最新推荐文章于 2022-09-17 15:02:52 发布
最新推荐文章于 2022-09-17 15:02:52 发布
阅读量2.5k 收藏 2
点赞数 1
分类专栏： 今天天气哈哈哈 文章标签： unity3d c# 图像处理 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangxun983323204/article/details/45888785
版权

上回说到，最近看了点算法，也实践了FAST关键点的提取，近来事多了些，所以今天才又有点成果。

依然是C#实现，在Unity3d里面做的，先上J，哦不，上图。。。

这是两张素材，第二个是用PS透视变换了一下，进行匹配的就是它们俩（艹泥马它们俩明明是一只嘛。。。）


下面这个图是代码生成的，先用上文的FAST的代码生成了关键点图，然后合并了两图，最后用匹配得到的pair（点的映射对）在图上画了线，目测大部分是匹配上了的。

当然，也有可能我这野路子哪里没理解到位。。。然而算法有点变异不是大问题，主要是还要优化，现在出结果图要4秒，根本不能用于实时应用，当然，这里面包含了生成三张结果图和画线的时间，这一块也比较占时间的，


听人说现在代码是求人看也没人看，所以我最后上点代码，原理就是提取时算关键点周围的梯度（好像不是梯度，我是算的梯度），匹配时计算向量距离与阈值比较

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// 加速鲁棒_特征
/// </summary>
public class SURF : ADiscript<Color> {

    float Threshold = 0.6f;

    /// <summary>
    /// 关键点的4个8x8块描述符,块内梯度归到8方向
    /// </summary>
    public float[] LT_TR_LB_BR = new float[32];

    public override void Init(params object[] p) {
        //
    }
    public override IList<CVTools.IntV2> GetKeyPoint(Texture2D src) {
        //未实现SURF关键点
        return null;
    }
    //得到所有关键点的特征描述符
    public override ADiscript<Color>[] GetDiscriptor(IList<CVTools.IntV2> keyPoint, Color[] mat, int w, int h) {
        SURF[] allDis = new SURF[keyPoint.Count];
        for (int i = 0; i < keyPoint.Count;i++ ) {
            allDis[i] = GetDiscript(keyPoint[i], mat, w, h) as SURF;
        }
        return allDis;
    }
    /// <summary>
    /// 计算一个点的特征描述
    /// </summary>
    public override ADiscript<Color> GetDiscript(CVTools.IntV2 keyPoint, Color[] mat, int w, int h) {
        CVTools.IntV2[] LT = CVTools.GetNP(keyPoint, 8, 8, -5, -5);

        CVTools.IntV2[] TR = CVTools.GetNP(keyPoint, 8, 8, 5, -5);

        CVTools.IntV2[] RB = CVTools.GetNP(keyPoint, 8, 8, 5, 5);

        CVTools.IntV2[] BL = CVTools.GetNP(keyPoint, 8, 8, -5, 5);

        CVTools.IntV2[][] enumBlock = new CVTools.IntV2[][] { LT, TR, RB, BL };
        SURF pDis = new SURF();
        pDis.x = keyPoint.x;
        pDis.y = keyPoint.y;
        for (int i = 0; i < enumBlock.Length;i++ ) {
            CVTools.IntV2[] curBlock = enumBlock[i];
            for (int j = 0; j < curBlock.Length;j++ ) {
                CVTools.Grad8Dir d8 = CVTools.NearGrad(CVTools.GetGrad(mat,w,h,curBlock[j]));
                pDis.LT_TR_LB_BR[i * 8 + d8.dir] += d8.len;
            }
            CVTools.NormalizationRotateArray(pDis.LT_TR_LB_BR, i * 8, (i + 1) * 8);
        }
        return pDis;
    }
    public override IList<CVTools.Pair<AKeyPoint>> Match(IList<AKeyPoint> kp1, IList<AKeyPoint> kp2) {
        List<CVTools.Pair<AKeyPoint>> pPair = new List<CVTools.Pair<AKeyPoint>>();
        for (int i = 0; i < kp1.Count;i++ ) {
            for (int j = 0; j < kp2.Count;j++ ) {
                if (CVTools.VectorDis((kp1[i] as SURF).LT_TR_LB_BR, (kp2[j] as SURF).LT_TR_LB_BR) < Threshold) {
                    pPair.Add(new CVTools.Pair<AKeyPoint>() { P1 = kp1[i], P2 = kp2[j] });
                    break;
                }
            }
        }
        return pPair;
    }
}
一些工具函数： 

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
/// <summary>
/// 图像处理工具
/// </summary>
public class CVTools {
    //对
    public class Pair<T>{
        public T P1;
        public T P2;
        public override string ToString() {
            return P1.ToString()+","+P2.ToString();
        }
    }
    /// <summary>
    /// Int型Vector2
    /// </summary>
    public class IntV2 {
        public int x, y;
        public IntV2() { }
        public IntV2(int x,int y) {
            this.x = x;
            this.y = y;
        }
        public IntV2(float x, float y) {
            this.x = (int)x;
            this.y = (int)y;
        }
        public static IntV2 operator +(IntV2 v1, IntV2 v2) {
            return new IntV2(v1.x+v2.x,v1.y+v2.y); ;
        }
        public static IntV2 operator -(IntV2 v1, IntV2 v2) {
            return new IntV2(v1.x - v2.x, v1.y - v2.y); ;
        }
        public static implicit operator IntV2(Vector2 v) {
            return new IntV2((int)(v.x),(int)(v.y));
        }
        public override string ToString() {
            return x + "," + y;
        }
    }
    /// <summary>
    /// 8方向近似梯度,从正右方向0开始，顺时针计算
    /// </summary>
    public class Grad8Dir{
        public int dir;
        public float len;
    }
    /// <summary>
    /// 求对称点
    /// </summary>
    public static IntV2 ReflectByPoint(IntV2 src, IntV2 cent) {
        int x = cent.x * 2 - src.x;
        int y = cent.y * 2 - src.y;
        return new IntV2(x, y);
    }
    //数组越界处理方式
    public enum GetCellType{
        Wrap = 0,
        Repeat = 1,
        Bg = 2,
    }
    /// <summary>
    /// 取数组单元，有越界处理
    /// </summary>
    public static T GetCell<T>(T[] scr, int w, int h, IntV2 pos, GetCellType type, T Bg) {
        int x = pos.x, y = pos.y;
        if ((int)pos.x < 0 || (int)pos.x >= w) { //x is out of range
            if (type == GetCellType.Bg)
                return Bg;
            else if (type == GetCellType.Repeat) {
                x = Mathf.Abs(pos.x) % w;
            } else {
                x = Mathf.Clamp(0, pos.x, w - 1);
            }
        }
        if (pos.y < 0 || pos.y >= h) { //y is out of range
            if (type == GetCellType.Bg)
                return Bg;
            else if (type == GetCellType.Repeat) {
                y = Mathf.Abs(pos.y) % h;
            } else {
                y = Mathf.Clamp(0, pos.y, h - 1);
            }
        }
        return scr[w * y + x];
    }
    /// <summary>
    /// 生成关键点的图像
    /// </summary>
    public static Texture2D ShowKeyPointTex(IList<CVTools.IntV2> kps, int w, int h, Color kpCol, Color bgCol) {
        Texture2D tex = new Texture2D(w,h);
        for (int j = 0; j < h;j++ ) {
            for(int i = 0;i<w;i++){
                tex.SetPixel(i, j, bgCol);
            }
        }
        for (int i = 0; i < kps.Count;i++ ) {
            tex.SetPixel(kps[i].x,kps[i].y,kpCol);
        }
        tex.Apply();
        return tex;
    }
    /// <summary>
    /// 获取某像素点在图中梯度 3x3
    /// </summary>
    public static Vector2 GetGrad(Color[] src,int w,int h,IntV2 point) {
        var NP_33 = GetNP(point, 3, 3);
        float gx = 
            GetCell<Color>(src, w, h, NP_33[2], GetCellType.Repeat, Color.black).grayscale+
            GetCell<Color>(src, w, h, NP_33[5], GetCellType.Repeat, Color.black).grayscale +
            GetCell<Color>(src, w, h, NP_33[8], GetCellType.Repeat, Color.black).grayscale -
            GetCell<Color>(src, w, h, NP_33[0], GetCellType.Repeat, Color.black).grayscale- 
            GetCell<Color>(src, w, h, NP_33[3], GetCellType.Repeat, Color.black).grayscale-
            GetCell<Color>(src, w, h, NP_33[6], GetCellType.Repeat, Color.black).grayscale;
        float gy =
            GetCell<Color>(src, w, h, NP_33[8], GetCellType.Repeat, Color.black).grayscale +
            GetCell<Color>(src, w, h, NP_33[7], GetCellType.Repeat, Color.black).grayscale +
            GetCell<Color>(src, w, h, NP_33[6], GetCellType.Repeat, Color.black).grayscale -
            GetCell<Color>(src, w, h, NP_33[3], GetCellType.Repeat, Color.black).grayscale -
            GetCell<Color>(src, w, h, NP_33[2], GetCellType.Repeat, Color.black).grayscale -
            GetCell<Color>(src, w, h, NP_33[1], GetCellType.Repeat, Color.black).grayscale;
        return new Vector2(gx,gy);
    }
    /// <summary>
    /// 获取整型的梯度
    /// </summary>
    public static IntV2 GetGradInt(Color[] src, int w, int h, IntV2 point) {
        Vector2 fv2 = GetGrad(src,w,h,point);
        return new IntV2((int)fv2.x,(int)fv2.y);
    }
    /// <summary>
    /// 近似梯度值到8方向梯度
    /// </summary>
    public static Grad8Dir NearGrad(Vector2 grad) {
        Grad8Dir g = new Grad8Dir();
        float len = Vector2.SqrMagnitude(grad);
        g.len = len;
        float xyDis = grad.x/(float)grad.y;
        float aDis = Mathf.Abs(xyDis);
        bool xIsPlus;
        bool yIsPlus;
        if(grad.x>=0)
            xIsPlus = true;
        else
            xIsPlus = false;
        if(grad.y>=0)
            yIsPlus = true;
        else
            yIsPlus = false;
        //if (aDis <0.4 || aDis>2.4)
        if (aDis <0.4) {
            if (xIsPlus)
                g.dir = 0;
            else
                g.dir = 4;
        }else if(aDis>2.4){
            if (yIsPlus)
                g.dir = 6;
            else
                g.dir = 2;
        } else if (xIsPlus) {
            if (yIsPlus)
                g.dir = 7;
            else
                g.dir = 1;
        } else {
            if (yIsPlus)
                g.dir = 5;
            else
                g.dir = 3;
        }
        return g;
    }
    /// <summary>
    /// 获取邻近坐标矩阵
    /// </summary>
    public static IntV2[] GetNP(IntV2 point,int rx,int ry) { 
        IntV2[] allPoint = new IntV2[rx*ry];
        int x = point.x;
        int y = point.y;
        int offX = rx / 2;
        int offY = ry / 2;
        for (int h = 0; h < ry;h++ ) {
            for (int w = 0; w < rx;w++ ) {
                allPoint[h * ry + w] = new IntV2(x+w-offX,y+h-offY);
            }
        }
        return allPoint;
    }
    /// <summary>
    /// 获取邻近坐标矩阵(带偏移版)
    /// </summary>
    public static IntV2[] GetNP(IntV2 point,int rx,int ry,int offsetX,int offsetY) {
        IntV2 trueCent = point + new IntV2(offsetX, offsetY);
        return GetNP(trueCent,rx,ry);
    }
    /// <summary>
    /// 归一化N维向量，提供一个float数组，指定区间，将区间内归一化并返回主方向下标
    /// </summary>
    public static int NormalizationArray(float[] array,int start,int end) {
        float max = float.MinValue;
        float min = float.MaxValue;
        int index = start;
        float sum = 0;
        for (int i = start; i < end;i++ ) {
            if (max < array[i]){
                index = i;
            }if(min>array[i]){
                min = array[i];
            }
            sum += array[i];
        }
        for (int i = start; i < end; i++ ) {
            array[i] = (array[i] - min) / sum;
        }
        return index;
    }
    /// <summary>
    /// 归一化N维向量并循环位置使主方向置于首位置，需提供一个float数组，指定区间
    /// </summary>
    public static void NormalizationRotateArray(float[] array, int start, int end) {
        float max = float.MinValue;
        float min = float.MaxValue;
        int index = start;
        float sum = 0;
        for (int i = start; i < end; i++) {
            if (max < array[i]) {
                index = i;
            } if (min > array[i]) {
                min = array[i];
            }
            sum += array[i];
        }
        for (int i = start; i < end; i++) {
            array[i] = (array[i] - min) / sum;
        }
        LeftShiftArray<float>(array,start,end, index);
    }
    /// <summary>
    /// 循环左移一个数组m位(右移以左移值的补来实现)
    /// </summary>
    public static void LeftShiftArray<T>(T[] array,int start,int end,int m) {
        int len = end - start;
        m = m % len;
        ReverseArray<T>(array, start, end - m);
        ReverseArray<T>(array, end - m, end);
        ReverseArray<T>(array,start,end);
    }
    /// <summary>
    /// 反转数组指定区间
    /// </summary>
    public static void ReverseArray<T>(T[] array, int start, int end) {
        T tmp;
        end--;
        for (; start < end;start++,end-- ) {
            tmp = array[end];
            array[end] = array[start];
            array[start] = tmp;
        }
    }
    /// <summary>
    /// 计算两个向量的距离
    /// </summary>
    public static float VectorDis(float[] v1,float[] v2) {
        if (v1.Length != v2.Length)
            return float.MaxValue;
        float t = 0;
        for (int i = 0; i < v1.Length;i++ ) {
            t += Mathf.Pow((v1[i] - v2[i]), 2);
        }
        return Mathf.Sqrt(t);
    }
    /// <summary>
    /// 生成匹配后的映射图
    /// </summary>
    public static Texture2D ShowDisMath(IList<CVTools.Pair<AKeyPoint>> matchedPoints,Texture2D t1,Texture2D t2,Color col) {
        int w = t1.width + t2.width;
        int h = t1.height >= t2.height ? t1.height : t2.height;
        Texture2D showTex = new Texture2D(w,h);
        Rect[] uv = showTex.PackTextures(new Texture2D[] { t1, t2 }, 0);
        IntV2 t1Pos = new IntV2(uv[0].x*w, uv[0].y*h);
        IntV2 t2Pos = new IntV2(uv[1].x*w, uv[1].y*h);
        LogVar.inst.ShowArray<IList<CVTools.Pair<AKeyPoint>>>(matchedPoints);
        Debug.Log("匹配对长度：" + matchedPoints.Count + ",p1起始：" + t1Pos + ",p2起始：" + t2Pos);
        for (int i = 0; i < matchedPoints.Count;i++ ) {
            IntV2 p1, p2;
            p1 = matchedPoints[i].P1 + t1Pos;
            p2 = matchedPoints[i].P2 + t2Pos;
            showTex.SetPixel(p1.x, p1.y, Color.yellow);
            showTex.SetPixel(p2.x, p2.y, Color.yellow);
            DrawLineOnTex(showTex,p1,p2,col);
        }
        showTex.Apply();
        return showTex;
    }
    /// <summary>
    /// 在纹理上画直线
    /// </summary>
    public static void DrawLineOnTex(Texture2D tex,IntV2 start,IntV2 end,Color col) {
        float deltaY = (end.y - start.y) / (float)(end.x - start.x);
        int len = end.x - start.x;
        for (int i = 0; i <= len; i ++) {
            int y = (int)(i* deltaY+start.y);
            var initCol = tex.GetPixel(i + start.x, y);
            if(initCol == Color.black)
                tex.SetPixel(i+start.x, y, col);
        }
    }
}
一个debug工具，用于输出大量数据（需要实现了IEnumerable接口，也就是一般数组链表啥的）不卡顿： 

using UnityEngine;
using System.Collections;
//密集计算型数据debug
public class LogVar : MonoBehaviour {

    public static LogVar inst;
    void Awake() {
        inst = this;
    }

    public void ShowArray<T>(T array) where T : IEnumerable {
        StartCoroutine(showArray<T>(array));
    }
    IEnumerator showArray<T>(T array) where T : IEnumerable {
        if (array != null) {
            foreach(var i in array){
                yield return new WaitForEndOfFrame();
                Debug.Log(i.ToString());
            }
        }
    }
}

嗯，慢慢来吧，这里优化好了下一步就是计算映射矩阵了



阿循
关注
专栏目录
基于PYTHON+OPENCV的SIFT SURF图像特征匹配.rar
06-02
使用SIFT或者SURF特征进行图像匹配，实现语言为python2.7+opencv3.1，代码有注释，有文档说明，并配有测试图像资源
SURF匹配python实现
zhicheng_angle的博客
06-27 7550
# -*- coding: utf-8 -*- """ Created on Thu Jun 20 16:25:27 2019 推荐使用OPENCV 3.1.0及以下版本 两幅png为middlebury上面的示例图片 @author: zhangzhicheng """ import numpy as np import cv2 from matplotlib import pyplot a...
SIFT, ORB, SURF 特征提取
m0_62114628的博客
09-17 1042
SIFT, ORB, SURF 特征提取
python实现SIFT和SURF并输出匹配点坐标
qq_41873079的博客
03-29 2836
想法：想使用SIFT和SURF匹配的特征点来当做先验信息加入网络。 需求：需要极可靠的匹配点以及相应坐标以及计算视差 代码： import numpy as np import cv2 from matplotlib import pyplot as plt imgname1 = 'path1' imgname2 = 'path2' MIN_MATCH_COUNT = 10 #设置最低特征点匹配数量为10 template = cv2.imread(imgname1,0) # queryImage ta
SURF_特征提取.rar_SURF 图像匹配_surf特征匹配_特征点_特征点匹配_特征点提取
07-15
SURF（Speeded Up Robust ...总结来说，这个压缩包提供了学习和实践SURF特征提取与匹配的工具，对于理解这一重要计算机视觉技术及其应用非常有帮助。无论是研究还是开发，掌握SURF都能增强图像处理和分析的能力。
SURF特征点提取与匹配opencv3+vs2017
05-08
这通常会包括读取图像、应用SURF算法提取关键点和描述符，然后可能进行关键点匹配等操作。通过匹配结果，可以评估算法的性能。 总的来说，这个项目提供了学习和实践SURF算法的完整流程，对于理解和掌握计算机视觉中...
基于opencv的SURF特征提取及匹配
05-25
【基于OpenCV的SURF特征提取及匹配】是...总的来说，这个项目涵盖了计算机视觉中的基础概念和技术，通过实践加深了对SURF特征提取和匹配的理解。对于想要学习或研究图像处理和计算机视觉的人来说，这是一个很好的起点。
SURF_SURF图像匹配_surf_surf特征匹配_目标匹配_特征匹配matlab_
10-03
对于初学者，这个程序集是一个很好的学习资源，可以理解SURF特征的提取和匹配过程，同时也适合进阶研究者进行相关算法的实验和优化。通过深入研究和实践，可以掌握图像处理和计算机视觉中的关键步骤，为更复杂的应用...
Surf特征匹配Matlab代码
12-25
SURF特征是Hessian矩阵检测器与快速积分图像相结合的产物，它在保持关键点检测的稳定性和准确性的同时，提高了计算效率。关键点的检测基于图像梯度，而特征描述符则通过在关键点周围创建一个尺度空间来生成，确保了...
main_SURF拼接_surf特征匹配_c++surf实现_VS2019_
09-30
c++，vs2019，surf实现图像拼接
SURF特征点提取及匹配
10-29
使用OPENCV+VS2013实现SURF特征点提取，使用FLANN算法实现特征点匹配
SURF图像匹配算法
11-20
用opencv2.3.1写的SURF算法，能实现两幅图像的特征点匹配。用VS2008+opencv2.3.1调试成功，能直接使用
Surf算法特征点检测与匹配
热门推荐
牧野的博客
09-20 11万+
Speeded Up Robust Features（SURF，加速稳健特征），是一种稳健的局部特征点检测和描述算法。最初由Herbert Bay发表在2006年的欧洲计算机视觉国际会议（Europen Conference on Computer Vision，ECCV）上，并在2008年正式发表在Computer Vision and Image Understanding期刊上。 Surf
图像特征之SURF特征匹配
Zachary_Co的博客
12-19 4155
原文站点：https://senitco.github.io/2017/06/27/image-feature-surf/  加速鲁棒特征(Speed Up Robust Feature, SURF)和SIFT特征类似，同样是一个用于检测、描述、匹配图像局部特征点的特征描述子。SIFT是被广泛应用的特征点提取算法，但其实时性较差，如果不借助于硬件的加速和专用图形处理器(GPUs)的配合，很难达到实时
sift、surf、orb 特征提取及最优特征点匹配
weixin_30466421的博客
08-04 2121
目录 sift sift特征简介 sift特征提取步骤 surf surf特征简介 surf特征提取步骤 orb orb特征简介 orb特征提取算法 ...
SURF特征点检测和匹配
YangYaYan的博客
12-13 573
SURF全称为“加速稳健特征”（Speeded Up Robust Feature），它们不仅是尺度不变特征，而且是具有较高计算效率的特征。 #include "highgui/highgui.hpp" #include "opencv2/nonfree/nonfree.hpp" #include "opencv2/legacy/legacy.hpp" #include &l...
OpenCV第十三讲：SURF特征点的检测与匹配详解
Ian的博客
08-30 8664
Dog算子，SIFT特征点， Fast角点 ，ORB特征点 有时间慢慢再来解析 1. SURF的优势 SURF主要有以下几点优势 SURF是尺度不变特征变换算法（SIFT）的加速版，一般来说它比SIFT要快好几倍，且在多幅图像下具有更好的稳定性； SURF采用了harr特征+积分图像的概念，大大加快了程序的运行时间。 SURF可以应用于计算机视觉的物体识别以及3D重构 ...
opencv4(三)使用SURF进行特征点匹配
z_johnking的博客
05-09 4861
进行特征点匹配的一般步骤： 实例化特征点检测器，进行特征点检测 实例化描述子提取器，对计算得到特征点提取描述子 实例化匹配器，根据描述子进行匹配 筛选优秀匹配结果并绘图 下一篇博客介绍一下feature2d和xfeature2d中的各种特征点检测器和描述子提取器，有时一种算法同时拥有检测器和提取器，比如SURF #include<opencv2/opencv.hpp> #include <opencv2/xfeatures2d.hpp> //SIFT SUR
Matlab图像校准实战：SURF特征提取与仿射变换
在MATLAB中进行图像校准是一项关键任务，尤其对于深度图像与彩色图像的融合和分析。...在实践中，根据具体需求和图像特性，可能需要调整某些步骤的参数或尝试不同的特征提取算法，以达到最佳校准效果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值