精华内容
下载资源
问答
  • 可以实现金字塔加速处理模板匹配,vs2015+opencv3.30.
  • 金字塔模板匹配算法,模板匹配算法有哪些,C,C++源码.zip
  • 前言 双目立体匹配的原理类似于人类的视觉原理:...双目立体视觉一般是指使用两个摄像机从不同的角度获取同一个场景的左右视图,然后使用双目立体匹配算法来寻找左右视图中的匹配像素点对,最后利用三角测量原理来还

    前言

    双目立体匹配的原理类似于人类的视觉原理:分别单独使用左眼和单独使用右眼去观察一个物体,该物体在两个视角中的相对位置会存在一定的偏移,人类视觉系统可以根据该偏移去判断该物体的距离远近。

    同样的,在双目立体匹配中,只要能在两张图像中正确地找到匹配点,结合相机的内部参数和外部参数,就能精准地计算出空间点距离拍摄相机的距离。

    目录

    一、立体匹配简介

    二、国内外研究现状

    展开全文
  • 6SSD算法,SAD算法,NCC算法,DP算法,DP_5算法,census算法
  • 文章相似度匹配算法

    热门讨论 2012-02-03 16:54:20
    首先把文章进行分词,然后提取关键字。根据比较和判断关键字,来判断文章的内容关联度。
  • 特征匹配算法

    千次阅读 2020-06-03 16:51:21
    看论文《特征匹配算法研究及其在目标跟踪上的应用》,感谢! 特征匹配算法 目前 SIFT 算法和 ORB 算法获得了研究者的青睐,但是因为 SIFT 算法是对图像进行全局的特征点检测耗时较长,造成算法的运行速度慢,达不到...

    看论文《特征匹配算法研究及其在目标跟踪上的应用》,感谢!
    https://blog.csdn.net/qq_17109251/article/details/82722466 感谢!

    特征匹配算法

    目前 SIFT 算法和 ORB 算法获得了研究者的青睐,但是因为 SIFT 算法是对图像进行全局的特征点检测耗时较长,造成算法的运行速度慢,达不到令人满意的匹配效果,难于应用到目标的实时跟踪。

    ORB 算法的运行速度较快,但是因为其描述子不具有尺度不变性,所以匹配效果不理想。

    图像匹配一般分为三个模块:
    1)特征空间。某一类特征提取的一个空间。
    2)相似性度量。相似性是衡量图像之间的一种相似程度,这种相似程度有很多的表示方法。目前,在匹配算法中较为常见的相似性度量准则有相位相关、Hausdorff 距离函数、欧式距离判别方法、归一化积相关等。
    3)搜索策略。搜索策略是在特征空间中,对待匹配特征点寻找与其相似特征点的方法。根据不同的标准,可以将图像匹配方法进行不同的分类。

    目前比较常用的分类:基于灰度的匹配方法和基于特征的匹配方法。
    1)前者一般具有实现简单的优点,比较常见的应用场合是对于一些简单的刚体匹配和图像仿射变化的匹配,该方法能实现较好的匹配效果,例如:序贯相似性检测法。在实际应用中,可能会出现非刚体运动形变、外界环境的干扰等影响,所以基于灰度的匹配方法不能满足这些情况下的匹配需要。
    2)特征匹配相比于灰度匹配,在匹配过程中需要对图像进行特征的提取,根据特征点进行匹配的速度高,更重要的是基于特征点的匹配其匹配精度较高。目前适应性更广泛且匹配性能较好的匹配算法多是采用基于特征匹配的方法。很多经典的算法如:SIFT 算法,SURF 算法,PCA-SIFT 算法,Moravec 算法,以及 Susan 算法等。目前,尺度不变特征变换(SIFT),是性能较好的算法之一。该算法的主要步骤是:构造尺度空间,寻找极值点并从中确定关键点,对关键点周围区域梯度进行计算生成 SIFT 描述子,通过相似性准则进行特征的匹配,该算法对于多数复杂情况的匹配,也表现出较好的鲁棒性。当然
    任何算法都不可能是完全没有缺陷的,好的匹配效果可能需要更多地复杂计算才能获得,该算法存在的问题就是复杂度较高。这种高复杂度的计算换来高鲁棒性的匹配效果,同时产生了算法运行时间耗时较长的问题,无论是在特征点的检测上,还是在最后进行特征匹配时都具有很大的影响。之后,H.Bay 等人提出了加速鲁棒特征(Speeded Up Robust Features,SURF)算法。SURF 算法匹配效果接近 SIFT。该算法采用了对 Harr 求导,使得算法运行速度基本能达到实时处理。但由于 SURF 特征向量是高维向量,其计算量大、匹配正确率低。ORB 算法由 OpenCV 维护和开发的公司 Willowgarage 提出,ORB 采用的是FAST 特征检测方法,所以匹配速度较快。文献利用最小亮度变化(Minimum Intensity
    Change,MIC)角点检测算子提取边缘角点,该算法有一定的稳定性和有效性。BRISK 算法是 2011 年由 S.Leutenegger 和 M.Chli 提出的,采用多尺度角点检测算法,具有尺度不变性和旋转不变性。近年来国内外很多研究学者针对特征匹配意图降低其时间复杂度,如PCA-SIFT 算法,其思想是用主元分析法代替 SIFT 算法中直方图方法,提高算法运行的速度。文献采用了多个描述符进行图像匹配和分类。但是,这些方法在描述符融合时使用固定的权重,并且忽略了图像转换到另一幅图像,同一特征点的最优描述符是不相同的。为了解决上述问题,文献]采用自适应特征融合的算法,在判别能力的基础上,
    提出一种局部变化的数据项,将多个模型合并。

    展开全文
  • 匹配算法

    千次阅读 2017-07-12 16:25:49
    字符串的定位操作通常称为串的模式匹配。模式匹配的应用很常见的函数模式一般是: int index(const string &Tag, const string &Ptn, int pos) 其中,Tag是主字符串,Ptn是子字符串,如果在主串Tag的第pos个位置后...

    字符串的定位操作通常称为串的模式匹配。模式匹配的应用很常见的函数模式一般是:

    int index(const string &Tag, const string &Ptn, int pos)

    其中,Tag是主字符串,Ptn是子字符串,如果在主串Tag的第pos个位置后存在与子字符串Ptn相同的子串,返回它在主串第pos个字符后第一次出现的位置,否则返回-1。


    一、BF算法:

    暴风(Brute Force)算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个字符和T的第一个字符,依次比较下去,直到得出最后的匹配结果。如图所示:







    int index(const string &Tag, const string &Ptn, int pos)
    {
    	int i = pos;//主串当前要比较的位置,初始化为pos
    	int j = 0;//子串当前要比较的位置,初始化为0
    	int Tlen = Tag.size();//主字符串的长度
    	int Plen = Ptn.size();//子字符串的长度
    
    	while (i < Tlen  && j < Plen)
    	{
    		if (Tag[i] == Ptn[j])//如果当前字符串相同,则继续向下比较
    		{
    			i++;
    			j++;
    		}
    		else//如果不同,把i和j退回到初始位置,重新进行比较
    		{
    			i = i - j + 1;
    			j = 0;
    		}
    	}
    	if (j >= Plen)//如果比较的长度已经大于子串长度,说明已经匹配成功
    	{
    		return (i - Plen);
    	}
    	else
    	{
    		return -1;
    	}
    }

    二、KMP算法:

    BF算法的时间复杂度最坏情况是o(Plen*Tlen),而之所以时间复杂度是由于索引指针的回溯引起的,针对以上不足,于是出现了KMP算法。它的时间复杂度为o(Plen+Tlen)。改进之处在于:每一趟比较重出现的字符不等时,不需要回溯索引指针i,而是利用已经得到的部分匹配结果将子串向右滑动尽可能远的距离,继续进行比较。

    如果采用简单的BF算法,则每趟比较i都会要退回,而采用KMP算法,每趟比较时,保持不变,只需要将j向右滑动即可,可即减少了中间一些趟次的比较。

    //求next数组中各元素的值,保存在长为len的next数组中
    void get_next(const string &Ptn, int *next, int len)
    {
    	int j = 0;
    	int k = -1;
    	next[0] = -1;
    
    	while (j<len - 1)
    	{
    		if (k == -1 || Ptn[j] == Ptn[k])
    		{   //如果满足上面分析的Pk = Pj的情况,则继续比较下一个字符,
    			//并得next[j+1]=next[j]+1
    			j++;
    			k++;
    			next[j] = k;
    		}
    		else
    		{   //如果符合上面分析的第2种情况,则依据next[k]继续寻找下一个比较的位置
    			k = next[k];
    		}
    	}
    }
    
    
    //求next数组的改进数组中各元素的值,保存在长为len的nextval数组中
    void get_nextval(const string &Ptn, int *nextval, int len)
    {
    	int j = 0;
    	int k = -1;
    	nextval[0] = -1;
    
    	while (j<len - 1)
    	{
    		if (k == -1 || Ptn[j] == Ptn[k])
    		{   //如果满足上面分析的Pk = Pj的情况,则继续比较下一个字符,
    			//并得next[j+1]=next[j]+1
    			j++;
    			k++;
    			if (Ptn[j] != Ptn[k])
    				nextval[j] = k;
    			else  //Ptn[j]与Ptn[k]相等时,直接跳到netval[k]
    				nextval[j] = nextval[k];
    		}
    		else
    		{   //如果符合上面分析的第2种情况,则依据next[k]继续寻找下一个比较的位置
    			k = nextval[k];
    		}
    	}
    }
    
    /*
    返回子串Ptn在主串Tag的第pos个字符后(含第pos个位置)第一次出现的位置,若不存在,则返回-1
    采用KMP算法,这里的位置全部以从0开始计算为准,其中T非空,0<=pos<=Tlen
    */
    int kmp_index(const string &Tag, const string &Ptn, int pos)
    {
    	int i = pos;  //主串当前正待比较的位置,初始为pos
    	int j = 0;   //子串当前正待比较的位置,初始为0
    	int Tlen = Tag.size();  //主串长度
    	int Plen = Ptn.size();  //子串长度
    
    							//求next数组的值,并逐个输出
    	int *next = (int *)malloc(Plen * sizeof(int));
    	get_next(Ptn, next, Plen);
    	//	get_nextval(Ptn,next,Pln);
    	int t;
    	cout << "子串的next数组中的各元素为:";
    	for (t = 0; t<Plen; t++)
    		cout << next[t] << " ";
    	cout << endl;
    
    	while (i<Tlen && j<Plen)
    	{
    		if (j == -1 || Tag[i] == Ptn[j])
    		{   //如果当前字符相同,或者在子串的第一个字符处失配,则继续向下比较
    			i++;
    			j++;
    		}
    		else   //如果当前字符不同,则i保持不变,j变为下一个开始比较的位置
    		{
    			//next数组时KMP算法的关键,i不回退,
    			//而是继续与子串中的next[j]位置的字符进行比较
    			j = next[j];
    		}
    	}
    
    	if (j >= Plen)
    		return (i - Plen);
    	else
    		return -1;
    }

    (没有写好,有时间再写,未完待续!)



    展开全文
  • 首先对三种基本字符串匹配算法进行了详细分析和说明,再编程实现。创新拓展研究了Boyer-Moore算法,进行了分析和编程实现。让四种算法对数据量极大的文本,进行子串的查询处理,并分析算法运行时间效率,并对所有...
  • 模式匹配算法总结

    千次阅读 2019-05-23 19:43:54
    前言 读书笔记,整理自 [美] Goodrich et al. 所著《Data Structures and Algorithms ...尽管早已可以通过 Python 下的 re 库使用正则表达式高效而简洁地实现模式匹配,但了解相关算法背后机理亦不失其学习的意义。...

    前言

    读书笔记,整理自 [美] Goodrich et al. 所著《Data Structures and Algorithms in Python》

    模式匹配

    模式匹配是数据结构中字符串的一种基本运算场景,给定一个子串,要求在某个字符串中找出与该子串相同的所有子串。尽管早已可以通过 Python 下的 re 库使用正则表达式高效而简洁地实现模式匹配,但了解相关算法背后机理亦不失其学习的意义。

    1. Brute-Force算法

    又称为暴风算法,核心思想在于从 T 的第一个字符开始遍历每一个字符,依次匹配 P。是最简单,也最低效的匹配方法。

    def find_brute(T, P):
      """Return the lowest index of T at which substring P begins (or else -1)."""
      n, m = len(T), len(P)                      # introduce convenient notations
      for i in range(n-m+1):                     # try every potential starting index within T
        k = 0                                    # an index into pattern P
        while k < m and T[i + k] == P[k]:        # kth character of P matches
          k += 1
        if k == m:                               # if we reached the end of pattern,
          return i                               # substring T[i:i+m] matches P
      return -1                                  # failed to find a match starting with any i
    

    2. Boyer-Moore算法

    通过跳跃启发式算法避免大量无用的比较。每次逐字符匹配从 P 最后一个字符开始。

    def find_boyer_moore(T, P):
      """Return the lowest index of T at which substring P begins (or else -1)."""
      n, m = len(T), len(P)                   # introduce convenient notations
      if m == 0: return 0                     # trivial search for empty string
      last = {}                               # build 'last' dictionary
      for k in range(m):
        last[ P[k] ] = k                      # later occurrence overwrites
      # align end of pattern at index m-1 of text
      i = m-1                                 # an index into T
      k = m-1                                 # an index into P
      while i < n:
        if T[i] == P[k]:                      # a matching character
          if k == 0:
            return i                          # pattern begins at index i of text
          else:
            i -= 1                            # examine previous character
            k -= 1                            # of both T and P
        else:
          j = last.get(T[i], -1)              # last(T[i]) is -1 if not found
          i += m - min(k, j + 1)              # case analysis for jump step
          k = m - 1                           # restart at end of pattern
      return -1
    

    3. Knuth-Morris-Pratt算法

    穷举算法和 Boyer-Moore 算法在完全匹配中必然进行 len ( P ) \text{len}(P) len(P) 次匹配,KMP 算法充分利用 P P P 内部的字符串重叠,做进一步优化。

    def find_kmp(T, P):
      """Return the lowest index of T at which substring P begins (or else -1)."""
      n, m = len(T), len(P)            # introduce convenient notations
      if m == 0: return 0              # trivial search for empty string
      fail = compute_kmp_fail(P)       # rely on utility to precompute
      j = 0                            # index into text
      k = 0                            # index into pattern
      while j < n:
        if T[j] == P[k]:               # P[0:1+k] matched thus far
          if k == m - 1:               # match is complete
            return j - m + 1           
          j += 1                       # try to extend match
          k += 1
        elif k > 0:                    
          k = fail[k-1]                # reuse suffix of P[0:k]
        else:
          j += 1
      return -1                        # reached end without match
    def compute_kmp_fail(P):
      """Utility that computes and returns KMP 'fail' list."""
      m = len(P)
      fail = [0] * m                   # by default, presume overlap of 0 everywhere
      j = 1
      k = 0
      while j < m:                     # compute f(j) during this pass, if nonzero
        if P[j] == P[k]:               # k + 1 characters match thus far
          fail[j] = k + 1
          j += 1
          k += 1
        elif k > 0:                    # k follows a matching prefix
          k = fail[k-1]
        else:                          # no match found starting at j
          j += 1
      return fail
    
    展开全文
  • 常见的立体匹配算法介绍

    千次阅读 2019-07-11 18:55:43
    1)根据采用图像表示的基元不同,立体匹配算法分为: A、区域立体匹配算法(可获取稠密视差图。缺点:受图像的仿射畸变和辐射畸变影响较大;像素点约束窗口的大小与形状选择比较困难,选择过大,在深度不连续处,...
  • 局部匹配算法可以大体分为三类:区域匹配算法、特征匹配算法和相位匹配算法. 一:区域匹配算法 本质上, 基于光度测量学不变性原理的区域匹配算法, 常以邻域窗的灰度为匹配基元, 以相关程度作为判别依据, 可以得到...
  • 模板匹配算法

    2017-04-08 15:56:44
    这是模板匹配算法的工程文件,解压即可运行。开发环境为VS2010+opencv
  • 图像匹配 一些基本算法

    万次阅读 多人点赞 2018-08-26 14:28:06
     本文主要介绍几种基于灰度的图像匹配算法:平均绝对差算法(MAD)、绝对误差和算法(SAD)、误差平方和算法(SSD)、平均误差平方和算法(MSD)、归一化积相关算法(NCC)、序贯相似性检测算法(SSDA)、hadamard...
  • 字符串匹配算法综述

    万次阅读 多人点赞 2018-07-22 21:39:23
    字符串匹配算法综述 字符串匹配算法综述:BF、RK、KMP、BM、Sunday 字符串匹配算法,是在实际工程中经常遇到的问题,也是各大公司笔试面试的常考题目。此算法通常输入为原字符串(string)和子串(pattern),要求...
  • 中文文本相似度匹配算法 simHash 海明距离 IK分词 完整的可运行的示例代码 包含simHash 算法,使用IK 对中文文本进行分词处理
  • 字符串匹配算法之Sunday算法C++实现
  • 6SSD算法,SAD算法,NCC算法,DP算法,DP_5算法,census算法
  • os指纹匹配算法

    千次阅读 2019-05-14 09:08:00
    Nmap用于检测匹配算法相对简单。它需要一个受试者指纹,并针对nmap-os-db中的每个参考指纹进行测试。 当针对参考指纹进行测试时,Nmap依次查看来自受试者指纹(例如SEQ或T1)的每个探针class行。跳过参考指纹中不...
  • 特征检测与特征匹配算法简介

    万次阅读 2019-05-20 13:22:17
    特征检测 opencv可以检测图像的主要特征,然后提取这些特征,使其成为图像描述符。 ...大多数特征检测算法都会涉及图像的角点、边和斑点的识别。 Harris可用于识别角点。此函数可以很好的检...
  • python 双向最大匹配算法 双向最大匹配算法 双向最大匹配算法
  • URL路径匹配算法实现

    千次阅读 2018-09-29 14:38:28
    注意:可以看到该算法时间复杂度并不高,367微妙是在初始化各种参数,然后还要对匹配模式(reg)字符串切割的情况下测得的。而实际上在Filter中像reg ( "http*://*.baidu.com/*/landingsuper*" ) 这样的匹配模式是...
  • 图像匹配几种常见算法与实践

    万次阅读 2020-08-07 19:05:18
    奇技 · 指南本文主要内容1.模版匹配2.特征匹配3.深度学习去找目标图像匹配的应用及背景图像匹配是指通过一定的匹配算法在两幅或多幅图像之间识别同名点。应用:遥感(制图更新),计算机视觉...
  • 保护新手不被经验的玩家虐;让高手局中没有新手。 创造竞技和公平的游戏对局,使玩家的游戏乐趣最大化。 无需等待太久就能找到对手进入游戏。 匹配系统尽其所能的匹配水平接近的玩家,玩家的水平是来自他们在此...
  • 1.基于OpenCv的旋转匹配 基于OpenCv实现了模板图像的旋转匹配,此代码基于matchTemplate函数封装实现可以得知旋转角度的模板匹配(vs2013+...带旋转的模板匹配算法,能够匹配带旋转角度的模板。(VS 2015+OPENCV C++)
  • 模板匹配算法初识

    万次阅读 2018-08-07 14:38:48
    模板匹配具有自身的局限性,主要表现在它只能进行平行移动,若原图像中的匹配目标发生旋转或大小变化,该算法无效。 算法 相关法 以8位灰度图像为例,模板T(m,n)叠放在被搜索图S(W,H)上平移,模板覆盖被搜索图的...
  • 多模式匹配算法-AC算法等

    千次阅读 2017-08-21 11:42:30
    问题一:如果一个关键词,然后让你在一段长文本中找出这些关键词,如何做?...问题二中,一段长文本中找N个关键词,那么就是多模式匹配,除了朴素算法外,也一些经典的算法,例如AC算法、BM算法等。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 514,029
精华内容 205,611
关键字:

匹配算法有哪些

友情链接: DAC.rar