精华内容
下载资源
问答
  • 综合了灰度与几何特征匹配方法,依据局部纹理能量分布选取特征点集,...该特征点集算法与传统图像匹配算法相比较,在保证精度的基础上能提高匹配速度,且具有一定的旋转不变性和抗噪性。仿真实验证明了该算法的可行性。
  • 在计算机科学领域,串的模式匹配算法一直都是研究焦点之一。在拼写检查、语言翻译、数据压缩、搜索引擎、网络入侵检测、计算机病毒特征码匹配以及DNA序列匹配应用中,都需要进行串匹配。串匹配就是在主串中查找...
  • 《数据结构(C语言版 第2版)》严蔚敏 实验四 基于字符串模式匹配算法的病毒感染检测问题,含实验报告
  • 全面综述了应用于入侵检测系统的经典的模式匹配算法,包括单模式匹配算法中的KMP算法、BM算法、RK算法和多模式匹配算法中的AC算法、AC—BM算法,并对各种算法的执行效率进行了总结。通过分析算法的思想,提出了未来...
  • 主要介绍了Java栈的应用之括号匹配算法,结合实例形式分析了Java使用栈实现括号匹配算法的相关原理、操作技巧与注意事项,需要的朋友可以参考下
  • 串的应用--模式匹配算法

    千次阅读 2016-07-12 10:23:15
    朴素的模式匹配算法,简单来说,就是对主串的每个字符作为子串开头,与要匹配的字符串进行匹配。对主串做大循环,每个字符开头做T的长度的小循环,知道匹配成功或全部遍历完成为止。朴素的模式匹配中有很多重复的...

    朴素的模式匹配算法

    子串的定位操作通常称为串的模式匹配,是串中最重要的操作之一。

    假设要从下面的主串S=”goodgoogle”中,找到T=”google”这个子串的位置,通常通过以下几个步骤:

    1. 主串S第一位开始,S和T前三个字母都匹配成功,但S第四个字母是d而T的是g。第一位匹配失败。
    2. 主串S第二位开始,主串S首字母是o,要匹配的T首字母是g,匹配失败。
    3. 主串S第三位开始,主串首字母是o,要匹配的T首字母是g,匹配失败。
    4. 主串S第四位开始,主串S首字母是d,要匹配的T首字母是g,匹配失败。
    5. 主串S第五位开始,S与T,6个字母全匹配,匹配成功。

    简单来说,就是对主串的每个字符作为子串开头,与要匹配的字符串进行匹配。对主串做大循环,每个字符开头做T的长度的小循环,知道匹配成功或全部遍历完成为止。之前使用串其他操作实现模式匹配(Index方法),现不用串其他操作,使用基本的数组实现,假设主串S和要匹配的子串T的长度均保存在S[0]和T[0]中,具体代码如下:

    /*返回子串T和主串S中第pos个字符之后的位置。若不存在,则函数返回值为0*/
    /*T非空,1<=pos<=StrLength(S)*/
    int Index(String S,String T,int pos){
       int i=pos; //i-主串S中当前位置下标,若pos不为1,从pos位置开始匹配
       int j=1; //j用于子串T中当前位置的下标值
       while(i <= S[0] && j <= T[0]){ //i小于S长度且j小于T长度时循环
          if(S[i]==S[j]){ //两字母相同时,继续循环,向后移动
             ++i;
             ++j;
          }else{ //俩字母不同时,i退回到上次匹配首位的下一位,j重置为1
             i=i-j+2;
             j=1;
          }
       }
       if(j>T[0]) return i-T[0];  //若j比T的长度大时,返回首位,否则返回0
       else return 0;
    }

    小结:最好情况的时间复杂度为 O(n+m) ,最坏情况的时间复杂度为 O[(nm+1)m] 。所以,这个算法太低效了。

    KMP模式匹配算法

    算法原理

    对于所有在子串中有与首字符相等的字符,是可以省略一部分不必要的判断步骤。朴素的模式匹配中有很多重复的遍历步骤,主串的i是需要不断回溯来完成,而分析发现,这种回溯可以是不需要的,而KMP模式匹配算法就是避免这种不必要的回溯发生。

    既然i值不回溯,也就是不能变小,要考虑的变化就是j值,观察发现,T串的首字符与自身后面字符比较,发现如果有相等字符,j值的变化会不同,即,j值的变化与主串没什么关系,关键取决于T串的结构是否有重复的问题。

    j值得多少取决于当前字符之前的串的前后缀的相似度。

    T串各位置的j值变化定义为一个数组next,那么next的长度就是T串的长度,函数定义如下:

    next[j]=0 ,当 j=1 时;
    next[j] =Max { k|1<k<jp1...pk1=pjk+1...pj1 } 当此集合不为空时;(有重复子串)
    next[j]=1 ,其他情况

    next数组值推导

    举一些具体的例子:

    eg1:T=”abcdex“

    j123456
    模式串Tabcdex
    next[j]011111

    1)当j=1时,next[1]=0;
    2)当j=2时,j由1到j-1就只有字符’a’,属于其他情况 next[2]=1;
    3)当j=3时,j由1到j-1串是’ab’,显然’a’与’b’不相等,属于其他情况,next[3]=1;
    4)以后同理,所以最终T串的next[j]为011111。

    eg2:T=”abcabx“

    j123456
    模式串Tabcabx
    next[j]011123

    1)当j=1时,next[1]=0;当j=2时,同上例说明, next[2]=1;当j=3时,同上,next[3]=1;当j=4时,同上,next[4]=1;
    2)当j=5时,此时j由1到j-1的串是’abca’,前缀字符’a’与后缀字符’a’相等,所以k值为2,因此next[5]=2;
    3)当j=6时,此时j由1到j-1的串是’abcab’,前缀字符’ab’与后缀字符’ab’相等,所以next[6]=3。

    eg3:T=”ababaaaba“

    j123456789
    模式串Tababaaaba
    next[j]011123

    1)当j=1时,next[1]=0;当j=2时,同上next[2]=1;当j=3时,同上,next[3]=1;
    2)当j=4时,j由1到j-1的串是’aba’,前缀字符’a’与后缀字符’a’相等,所以next[4]=2;
    3)当j=5时,此时j由1到j-1的串是’abab’,前缀字符’ab’与后缀字符’ab’相等,所以k值为3,因此next[5]=3;
    4)当j=6时,此时j由1到j-1的串是’ababa’,前缀字符’aba’与后缀字符’aba’相等,所以next[6]=4;
    5)当j=7时,此时j由1到j-1的串是’ababaa’,前缀字符’a’与后缀字符’a’相等,所以next[7]=2;
    6)当j=8时,此时j由1到j-1的串是’ababaaa’,前缀字符’a’与后缀字符’a’相等,所以next[8]=2;
    7)当j=9时,此时j由1到j-1的串是’ababaaab’,前缀字符’ab’与后缀字符’ab’相等,所以next[9]=3。

    KMP模式匹配算法实现

    具体代码如下:

    /*通过计算返回子串Tnext数组,计算出当前要匹配的串Tnext数组*/
    void get_next(String T,int *next){
       int i=1,j=0;
       next[1]=0;
       while(i<T[0]){ /*此处T[0]表示串T的长度,遍历子串T*/
          if(j==0 ||T[i]==T[j]){  
             /*T[i]表示后缀的单个字符;T[j]表示前缀的单个字符*/
             ++i;++j;next[i]=j;
          }else  j=next[j];  //若字符不相同,则j值回溯
       }
    }
    
    /*返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0*/
    /*T非空,1<=pos<=StrLength(S)*/
    int Index_KMP(String S,String T,int pos){
       int i=pos;  //i用于指示主串S当前位置下标,若pos不为1,从pos位置开始
       int j=1;  //用于指示子串T中当前位置下标
       int next[255];  //定义next数组
       get_next(T,next); //对串T进行分析,得到next数组
       while(i<=S[0] && j<=T[0]){ //i小于S长度,j小于T长度
          if(j==0 || S[i]==T[j]){
             //相对于朴素算法增加j=0判断,俩字母相等继续
             ++i;++j;
          }else{  //匹配失败,指针退回,重新匹配,i值不变,j值由next[j]确定
             j=next[j];  //j退回合适位置,i值不变
          }
       }
       if(j>T[0]) return j-T[0];
       else return 0;
    }

    相比较于朴素匹配算法,改动不算大,关键在于去掉i值回溯部分。因为只涉及简单的单循环,时间复杂度为 O(m) ,由于i值不回溯,KMP效率得到提升,相比较朴素模式匹配是要好的。

    注意:KMP算法仅在模式与主串之间存在很多”部分匹配”的情况下才有优势,否则量算法差异不明显。

    KMP模式匹配算法改进

    原理

    例如当主串S=”aaaabcde”,子串T=”aaaaax”,其next数组值分别为012345。开始时,当i=5,j=5时,b与a不相等,为步骤1;因此j=next[5]=4,i=5,为步骤2;此时b与a依旧不等,j=next[4]=3,为步骤3;此时b与a依旧不等,j=next[3]=2,为步骤4;此时b与a依旧不等,j=next[2]=1,为步骤5;此时b与a依旧不等,j=next[1]=0,根据算法,i++,j++,得到i=6,j=1,为步骤6。

    分析发现,其中步骤2,3,4,5是多余的判断。由于T串的第二、三、四、五位的字符均和首位”a”相等,那么可以用首位next[1]来取代与它相等的字符后续next[j]的值,所以对next函数进行改进。

    假设取代的数组为nextval,具体代码如下:

    /*求模式串T的next函数修正值并存入数组nextval*/
    void get_nextval(String T,int *nextval){
       int i=1,j=0;
       nextval[0]=1;
          if(j==0 || T[i]==T[j]){
             ++i;++j;
             if(T[i] !=T[j]){ //若当前字符与前缀字符不同
                nextval[i]=j;  //则当前的j为nextval在i位置的值
             }else{  
                //若字符相同,则将前缀字符的nextval值赋值给nextval在i上的值
                nextval[i]=nextval[j];
             }
          }
          else  j=nextval[j]; /*若字符不相同,则j值回溯*/
       }
    }

    至于匹配算法,只要将“get_next(T,next)”改为“get_nextval(T,next)”即可,就不再重复讲述。

    nextval数组值推导

    和next值求导一样,举几个具体的例子来说明,如下:

    eg1:T=”ababaaaba”,

    j123456789
    模式串ababaaaba
    next[j]011234223
    nextval[j]010104210

    1)当j=1时,nextval[1]=0;
    2)当j=2时,因第二字符’b’的next值为1,第一位是’a’,l两个字符不相等,所以nextval[2]=next[2]=1;
    3)当j=3时,因为第三字符’a’的next值为1,所以和第一位的’a’比较得知二者相等,所以,nextval[3]=nextval[1]=0;
    4)当j=4时,第四字符’b’的next值为2,所以和第二位的’b’比较得知二者相等,所以,nextval[4]=nextval[2]=1;
    5)当j=5时,第五字符’a’的next值为3,第五个字符’a’和第三位的’a’相等,所以,nextval[5]=nextval[3]=0;
    6)当j=6时,第六字符’a’的next值为4,第六个字符’a’和第四位的’b’不相等,所以,nextval[6]=4;
    7)当j=7时,第七字符’a’的next值为2,第七个字符’a’和第二位的’b’不相等,所以,nextval[7]=2;
    8)当j=8时,第八字符’b’的next值为2,第八个字符’b’和第二位的’b’相等,所以,nextval[8]=nextval[2]=1;
    9)当j=9时,第九字符’a’的next值为3,第九个字符’a’和第三位的’a’相等,所以,nextval[9]=nextval[3]=0。

    eg2:T=”aaaaaaaab”,

    j123456789
    模式串aaaaaaaab
    next[j]012345678
    nextval[j]000000008

    1)当j=1时,nextval[1]=0;
    2)当j=2时,因第二字符’a’的next值为1,第一位是’a’,l两个字符相等,所以nextval[2]=next[1]=0;
    3)同理,其后均为0 ……;
    9)当j=9时,第九字符’b’的next值为8,第九个字符’b’和第八位的’a’不相等,所以,nextval[9]=nextl[9]=8。

    小结:改进的KMP算法,在计算next值得同时,若a位字符与它next值指向的b位字符相等,则该a位的nextval就指向b位的nextval值,如果不等,则该a位的nextval值就是它自己a位的next值。

    展开全文
  • 模式匹配算法总结

    千次阅读 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
    
    展开全文
  • 经典的多模式串匹配算法AC的内存开销巨大,已经无法满足当前高速网络环境下大规模特征串实时匹配的应用需求。针对这一问题,提出一种空间高效的多模式串匹配算法—HashTrie。该算法运用递归散列函数,将模式串集合的...
  • 在众多匹配算法中,归一化互相关(NCC)算法由于具有精度高、鲁棒性强等优点得到广泛应用,但其计算量大、运算速度较慢,使其难以在线应用。为此,本文提出一种改进的NCC立体匹配算法,通过引入积分图像和平方积分...
  • 对于基于深度学习的立体匹配而言,模型的网络结构对算法精度的影响很大,而算法运行效率也是实际应用中需要考虑的重要因素。提出一种在视差维度上使用稀疏损失体进行立体匹配的方法。采用宽步长平移右视角特征图构建...
  • 针对Android恶意应用泛滥的问题,提出了一种基于恶意应用样本库的多级签名匹配算法来进行Android恶意应用的检测。以MD5哈希算法与反编译生成的smali文件为基础,生成API签名、Method签名、Class签名、APK签名。利用...
  • 摘要:介绍一种优化的快速模板的匹配算法,可实现目标实时提取、识别和跟踪,并成功应用于红外热成像跟踪技术的研究,解决了复杂背景条件下目标跟踪稳定度差的技术难点。该算法用Visual C++编写,可方便地移植到其它...
  • 模板匹配算法

    千次阅读 2018-07-27 11:13:59
    模板匹配(Template Matching)算法 模板匹配(Template Matching)是图像识别中最具代表性的方法之一。它从待识别图像中提取若干特征向量与模板对应的特征向量进行比较,计算图像与模板特征向量之间的距离,用最小...

    from:https://blog.csdn.net/zhi_neng_zhi_fu/article/details/51029864

    模板匹配(Template Matching)算法

    模板匹配(Template Matching)是图像识别中最具代表性的方法之一。它从待识别图像中提取若干特征向量与模板对应的特征向量进行比较,计算图像与模板特征向量之间的距离,用最小距离法判定所属类别。模板匹配通常事先建立好标准模板库。

    一、简单计算样本之间距离的方法

    在工作过程中遇到一个判断样本距离的方法,先把他记录如下: 

    循环计算待测样本和训练集中已知样本之间的距离,比较所有的距离值,找出与待测样本最近的已知样品,其中所对应的样本所属的类别就是待测样本X所属的类别。

    c实现代码如下:

    <span style="color:#000000"><code>/****************************************
    *参数:
    *   src:待匹配特征向量
    *   template:模板向量
    *返回值:
    *   int:返回匹配结果;-1:无匹配项
    *意义:
    *   输入待匹配特征向量,输出匹配结果
        *****************************************/
    #define NFeature 25 //特征个数
    #define NSample  10 //样本个数
    int templateMatching(double src[], double template[][NFeature])
    {
       double d[11] = {0.0}, temp, mind = 10.0; //匹配度
       int flag = -1, i, j;
    
       for(j = 0; j < NSample; j++) {
            for(i = 0; i < NFeature; i++) {
                    temp = pow(src[i] - template[j][i], 2);
                    d[j] += temp;
            }
            d[j] = sqrt(d[j]);
    
            if(mind > d[j]) {
                mind = d[j];
                flag = j;            
            }
       }
    
       return flag;
    }
    </code></span>

    不足之处

    以上算法有一个很大的问题,就是当特征向量值顺序改变之后,计算结果有很大的变化。例如: 
    B = {1, 2, 3, 4}; A1 = {4, 3, 2, 1}; A2 = {1,2,3,4}。A1与B匹配,结果为{3*3+1*1+1*1+3*3} = 20;A2与B匹配,结果为{0+0+0+0} = 0;很明显特征向量A1与A2是相同的,在实际图像识别过程中有可能造成:一个图像旋转了一定角度,就无法识别出来。所以,这个算法只适合同方向的物体匹配,例如车牌字符识别等。

    总结:

    1. 只适合恒定方向特征匹配,例如车牌中的字符特征匹配

    二、Hausdorff距离匹配

    Hausdorff是描述两组点之间相似程度的一种度量,它是集合和集合之间距离的一种定义形式。下面我们慢慢讲解Hausdorff算法的过程。

    - 点到点集的距离

    - A集合到B集合的直接Hausdorff距离

    还是以上面的例子为例来说明。例如:B = {1, 2, 3, 4}, A1 = {4, 3, 2, 1}, A2 = {1 ,2, 3, 4};A1与B匹配:Max{0, 0} = 0; A2与B的匹配:Max{0, 0} = 0;可以看到匹配的结果是:A1与A2是相同的,即使他们特征元素的顺序打乱了。一样可以把他们都正确匹配出来。 
    这里写图片描述 
    如图所示,X1、X2与T是一样的特征向量,只是顺序打乱了,但是匹配都是0;匹配效果还是很好的。X3是随机生成的其他的特征向量。 
    代码:

    下面按照最一般的情况,计算待测特征向量X与某一样本T的匹配度。特征元素为有理数。

    <span style="color:#000000"><code>/*******************************************************
     *参数:
        X:输入特征向量数组
        T:模板库中某一样本特征向量
        n: 特征向量个数
      返回值:
        返回匹配结果
      函数意义:
        通过输入待测特征向量和模板特征向量,计算出待测特征向量
      的匹配度,数值越小,匹配程度越高。式中的距离范式是特征元素
      之间的差值绝对值。    
        ***************************************************/
    double charrecognize(double X[], double T[], int n) 
    {
        int i,j;
        double d[2] = {0.0};//存储X-->T的Hausdorff和T-->X的Hausdorff值
        double minTemp = 1000.0, sum;
    
        //计算X-->T的Hausdoff值
        for(i = 0; i < n; i++) {
            minTemp = 1000.0;
            for(j = 0; j < n; j++) {
                sum = fabs(X[i] - T[j]);
                if(sum < minTemp)
                    minTemp = sum;      
            }
            d[0] += minTemp;        
        }
    
        //计算T-->X的Hausdorff值
        for(j = 0; j < n; j++) {
            minTemp = 1000.0;
            for(i = 0; i < n; i++) {
                sum = fabs(T[j] - X[i]);
                if(sum < minTemp)
                    minTemp = sum;
            }
            d[1] += minTemp;        
        }
    
        //返回较大值
        if(d[0] > d[1])
            return d[0];
        return d[1];
    }
    </code></span>

    当我们匹配要求特定方向、特定位置的图片时,其实也可以用Hausdorff距离进行特征匹配。 
    这里写图片描述

    如图所示,第一幅图是模板图片,后面都是要与模板进行匹配的图像。

    1. 第一幅图像是模板的copy,计算出的数值为:50500.
    2. 第二幅图像在模板的基础之上进行向左向右移动了一个像素:80254.
    3. 第三幅图像是把模板旋转了45°,计算出来的结果是:195405.

    三幅图像虽然是一样的,只是位置和角度偏移了一些,出现的结果偏差却很大。这并非说明Hausdorff距离算法性能不佳,只是上述实验中的“特征选择”限定了Hausdorff距离算法对偏移和旋转过于敏感,也正是因为有了这种敏感,也更容易区分“非匹配项”。当我们图像特征限定在某一方向和位置时,Hausdorff将表现出优异的区分性能。例如:字符模板限定在“字符重心在图片重心,不旋转”,待测样本也如此限定。

    代码流程

    1. 待测样本为二值化特征向量X, 模板为二值化特征向量T;
    2. 从上到下,从左到右,逐个像素扫描样本。如果为255(特征点),记录坐标P(x, y);如果为0,跳过。
    3. 在模板上,以P(x, y)为中心的3*3的邻域内,搜索255(特征点),寻找与P(x, y)最近的点,并计算最近距离;如果3*3域内没有255(特征点),就认为距离为一个设定的较大点(例如:5.0)。
    4. 把所有计算的距离累加到样本至模板的距离D(X, T);
    5. 以同样的方法计算模板至样本的距离D(T, D);
    6. 取D = Max{D(X, T), D(T, X)},作为匹配的结果。

      <span style="color:#000000"><code>/****************************************
      参数:
         X:样本二值图,只包含特征信息
         T:模板二值图,只包含特征信息
      返回值:
         double:返回匹配度,越低越匹配
      意义:
         以样本二值图特征像素坐标作为特征点进行
      匹配。
      *****************************************/
      double charrecognise(Mat X, Mat T) 
      {
         int i, j, m, n;
         double distemp = 5.0, distemp1, distsum, distsum1;
      
         //样本到模板的距离
         distsum = 0.0;
         for(i = 0; i < X.cols; i++) {
            for(j = 0; j < X.rows; j++) {
              if(X.at<uchar>(i, j) == 255) {
                  distemp = 5.0;
                  for(m = i - 3; m <= i + 3; m++) {
                      for(n = j - 3; n <= j + 3; n++) {
                          if(m < 0) m = 0;
                          if(m > X.cols) m = X.cols;
                          if(n < 0) n = 0;
                          if(n > X.rows) n = X.rows;
                          if(T.at<uchar>(m, n) == 255) {
                              distemp1 = sqrt(pow((double)m - i, 2) + pow((double)n - j, 2));
                              if(distemp1 < distemp) distemp = distemp1;
                          }
                      }
                  }
              }
              distsum += distemp;
            }
         }
      
         //模板到样本的距离
         distsum1 = 0.0;
         for(i = 0; i < T.cols; i++) {
            for(j = 0; j < T.rows; j++) {
                 if(T.at<uchar>(i, j) == 255) {
                    distemp = 5.0;
                    for(m = i - 3; m <= i + 3; m++) {
                       for(n = j - 3; n <= j + 3; n++) {
                          if(m < 0) m = 0;
                          if(m > T.cols) m = T.cols;
                          if(n < 0) n = 0;
                          if(n > T.rows) n = T.rows;
                          if(X.at<uchar>(m, n) == 255) {
                              distemp1 = sqrt(pow((double)m - i, 2) + pow((double)n - j, 2));
                              if(distemp1 < distemp) distemp = distemp1;
                          }
                      }
                  }
                  distsum1 += distemp;
              }
            }
         }
      
         if(distsum > distsum1)
            return distsum;
         return distsum1;
      }
      </code></span>

    总结

    1. Hausdorff距离算法能无视特征元素的顺序进行匹配。
    2. Hausdorff距离算法对以位置为特征元素的特征向量进行匹配时,效果很差,但是对匹配条件加以限定还是可以达到很好的区分效果。
    展开全文
  • 这是重庆大学数据结构实验报告,题目是串的操作与KMP模式匹配算法。里面有完整的实验流程,包括源码及结果截屏
  •  BF算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配,若相等,则继续比较S的第二个字符和P的第二个字符;若不相等,则比较S的第二个字符和P的第一个字符,依次比较...
  • 文本中关键字匹配算法的实现
  • 为了降低弹性噪声、提高图像质量, 对...实验结果表明, 将直方图匹配算法应用至弹性成像后, 弹性信噪比和对比度噪声比得到了显著的提高; 最佳匹配窗口宽度与横向分辨率一致, 长度与互相关计算窗口大小及中心频率成正比。
  • 匹配系统的目的例如以下,优先级从高到低: 保护新手不被有经验的玩家虐;让高手局中没有新手。 创造竞技和公平的游戏对局,使玩家的游戏乐趣最大化。 无需等待太久就能找到对手进入游戏。 匹配系统尽其所能的...

    目前主流游戏的匹配算法介绍

    皇室战争

    对战模式:1v1
    匹配机制:主要是通过奖杯数去匹配对手的,对战胜利的玩家将赢得失利玩家损失的奖杯数,在正常情况下,游戏会优先匹配杯数相差100以内的玩家进行对战。如果没有匹配的,则顺延选择相差较小的玩家进行对战。
    如何防止刷分?
    1v1由于需要的玩家数量较小(2名),就造成了刷分门槛低的情况。supercell的规则是:两个账号在完成与其他至少三名玩家对战之前,是无法相互匹配到的。这也就强制了你必须通过对战才能够涨杯数。

    炉石传说

    对战模式:1v1
    匹配机制:
    炉石的匹配机制在休闲玩法和天梯玩法上各有不同。同时系统会引入隐藏的玩家水平判断参数MMR(Matchmaking Ranking),以保证匹配玩家之间水平旗鼓相当。
    据官方透露,MMR值是随时变动的数值,玩家每赢得一局比赛就会获得一定的MMR分数,打击败对手越强获得分数越高,击败对手越弱则获得分数越少。当玩家对局数量越多的时候,系统通过MMR值判断出来的玩家实力也就越精确。同时卡牌的强弱、稀有程度并不会影响MMR值。

    1:休闲玩法
    系统会优先给玩家匹配匹配到同水平段位的对手(1~60级)
    2:天梯玩法
    在天梯模式中,匹配机制分两种情况,如果天梯等级在25级~1级之内,系统会尽可能给玩家匹配同天梯等级的对手。当天梯等级到达1级以上的传说等级时,系统会再次引入MMR值,给玩家寻找同为传说等级且实力相当的对手。

    这两种玩法在匹配人数较少的时间段,系统也会根据匹配时间来安排与玩家水平相近的不同等级的对手。

    王者荣耀

    对战模式:排位赛,匹配赛,人机对战等,里面都有1v1, 3v3, 5v5。
    匹配机制:
    基于ELO等级分的模式(根据玩家对战中各方面数据计算出的综合实力积分,该积分适用于个人也适用于多人团队),即尽可能安排双方胜率都最接近50%的对局,并在特定条件下做出匹配时间和玩家实力上一定程度的扩宽。
    王者最近的更新加入了玩家的详细对局数据,并以此计算战力值和能力示意图,包括KDA(KDA就是:杀人(Kill)死亡(Death)助攻(Assist)按照一定比率来算的一个数值 其公式为(K+A)/ D 一般3为正常)、参战率、每分钟获得金币数、每分钟造成的英雄伤害、每局承受伤害、每局对建筑伤害。这些数据就是对玩家当前实力的综合计算结果,很有可能也会给匹配结果带来一定程度的影响。

    匹配系统设计概述,目标,总结

    匹配系统的目的例如以下,优先级从高到低:

    • 保护新手不被有经验的玩家虐;让高手局中没有新手。

    • 创造竞技和公平的游戏对局,使玩家的游戏乐趣最大化。

    • 无需等待太久就能找到对手进入游戏。

    匹配系统尽其所能的匹配水平接近的玩家,玩家的水平是来自他们在此之前赢了谁以及他们对手的水平。当你战胜对手,系统会觉得你更强,当你输给对手,系统会觉得你更弱。尽管这对于某一局游戏并非那么的公平,可是长期来看,对于多局游戏是相当的公平:由于好的玩家总会对游戏结果造成正面的、积极的影响。

    匹配是怎么完成的?

    首先,系统将你放进适当的匹配池里——依据游戏模式(匹配模式、排位solo/双人、排位5人、其它模式等等)
    然后,系统会尝试将匹配池里的人分到更细的匹配池里——5人组队 VS 5人组队,低等级新手 vs 其它一些低等级新手,如此这般。

    当你在匹配池中,系统会开始尝试找到合适的配对,目标是撮合一个两方获胜机会都为50%的游戏。

    第1步:确定你的实力:

    假设你是solo,就直接使用你的个人匹配分(也就是elo值)
    假设你是预先组队的,你的匹配分是你队伍的平均分。

    第2步:确定你合适匹配对手:

    首先,系统会基于你的rating值,给你匹配跟你很相近的玩家(设置一个正负偏差值)。系统会尝试平衡这个队伍,尽量使两方的获胜机会都为50%。在绝大多数时间,误差会在3%之内——类似50/50,49/51,48/52。如果匹配不到,系统会放宽匹配的条件,给你一些不是那么完美的匹配。

    新手会得到一些特殊的保护,通常新手仅仅会匹配到其它新手(在成熟的server里,这个比例达到了99%+。除非这个新手和一个高级玩家朋友预先组队)

    第3步:结果计算:

    可以采用elo算法去计算你和对手的下一次积分。

    假设你想知道ELO系统的理论,以及很多其它细节,你能够看看这:

    http://en.wikipedia.org/wiki/Elo_rating_system

    http://zh.wikipedia.org/wiki/ELO

    https://www.zhihu.com/question/41011877

    elo介绍
    http://bbs.gameres.com/thread_228018_1_1.html

    TrueSkill 介绍

    http://www.cnblogs.com/baiting/p/5591614.html

    展开全文
  • 图像匹配几种常见算法与实践

    万次阅读 2020-08-07 19:05:18
    奇技 · 指南本文主要内容1.模版匹配2.特征匹配3.深度学习去找目标图像匹配的应用及背景图像匹配是指通过一定的匹配算法在两幅或多幅图像之间识别同名点。应用:遥感(制图更新),计算机视觉...
  • 模式匹配算法

    万次阅读 多人点赞 2018-06-29 17:33:01
    算法一:朴素的模式匹配算法 假设我们要从主串s="goodgoogle"找到t="google"这个子串的位置,我们需要下列步骤 1、主串s的第1位开始,s与t前三个字符都匹配成功,第四个字符不匹配(竖线表示...
  • 基于CUDA的并行立体匹配算法的设计与应用
  • 提出了一种基于高斯混合模型的语音模板匹配算法。该算法采用快速傅立叶变换、平均过零率分析和高斯混合模型3种方法的加权平均来生成判决门限值。通过比较门限值误差的大小,根据“最大似然准则”给出模板匹配的结果...
  • 图像特征匹配算法评价框架,石波,索春宝,图像特征匹配技术在图像拼接、数字摄影测量等领域有着广泛的应用,因各类应用对其需求的多样化而快速发展,不同的图像特征匹配算
  • 应用于Web服务器匹配算法的FPGA实现
  • 但是在实际应用中 , 用户的查询输入与检索系统数 据库的构建都不可能完全正确 用户对于搜索主 题所处的领域不了解 , 采用不合适的查询词 , 会导致 查询词的覆盖范围大大缩小 在中文信息检索系 统中 , 用户还常会输入...
  • 本篇文章是对串的模式匹配算法(普通算法和KMP算法)的应用进行了详细的分析介绍,需要的朋友参考下
  • 为了解决传统的基于光谱特征的图像匹配算法的问题,提出了一种基于双曲线马哈拉诺比斯度量的光谱匹配算法。 该算法首先引入双曲线度量,该度量对样本数据具有更好的适应性。... 该算法扩展了光谱匹配算法应用范围。
  • 记录一下串里面的模式匹配,模式匹配,顾名思义就是给定一个被匹配的字符串,然后用一个字符串模式(模型)去匹配上面说的字符串,看后者是否在前者里面出现。常用的有2种算法可以实现,下面我们来具体探讨下
  • 针对光度曲线的特点将光谱领域曲线匹配算法应用至光度学领域,解决了基于光度曲线特征规律卫星形状反演方法的算法需求。介绍了反演方法的主要原理,通过融合角匹配(SAM)算法和信息散度(SID)算法,设计了联合信息匹配...
  • 本文针对低采样率GPS轨迹提出了一种新的全局地图匹配算法ST-Matching.ST-Matching考虑(1)道路网络的空间几何和拓扑结构以及(2)时空轨迹的速度限制。 基于时空分析,构造候选图,从中识别出最佳匹配路径序列。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,801
精华内容 111,120
关键字:

匹配算法的应用