精华内容
下载资源
问答
  • 计算机视觉的实验,Python写的代码,萌新代码,勿喷,仅仅只是方便没时间写实验的朋友,直接用python打开就能运行
  • SAD(Sum of absolute differences)是一种图像匹配算法。基本思想:差的绝对值之和。此算法常用于图像块匹配,将每个像素对应数值之差的绝对值求和,据此评估两个图像块的相似度。该算法快速、但并不精确,通常用于...
  • python 完全匹配字符串

    千次阅读 2020-10-23 02:01:39
    ''' .... # 点可代表一切字符 \ # 起转义作用 [...] # 指代方括号中的任意字符 \d # 指代数字0-9 ...\s # 指代一切空格,包括tab制表符、空格、换行等...* # 匹配前面字符 >=0 次 + # 匹配前面字符1次及以上 ? # 匹..
    '''
    https://www.cnblogs.com/syw20170419/p/9749809.html
    . # 点可代表一切字符
    
    \ # 起转义作用
    
    [...] # 指代方括号中的任意字符
    
    \d # 指代数字0-9
    
    \D # 指代非数字
    
    \s # 指代一切空格,包括tab制表符、空格、换行等
    
    \S # 指代非空格
    
    \w # 指代大小写字母、数字和下划线
    
    \W # 指代非大小写字母、数字和下划线
    
    * # 匹配前面字符 >=0 次
    
    + # 匹配前面字符1次及以上
    
    ? # 匹配前面字符0次或1次
    
    {m} # 匹配m次
    
    {m,n} # 匹配m到n次
    
    {m,} # 至少匹配m次
    '''
    
    
    import re
    
    my_str = "abc .abc .abc1-abc"
    old="abc"
    new = "xxx"
    
    result = re.sub("\\b" + old + "\\b", new, my_str)
    result = re.sub(r"\b%s\b" % (old), new, my_str)
    result = re.sub("\." + "\\b" + "abc" + "\\b", new, my_str)
    result1 = re.findall("\." + "\\b" + "abc" + "\\b",my_str)
    print(result1)
    展开全文
  • SAD进行双目立体视觉匹配Python语言)1 编译环境2 算法原理介绍3 基本流程3.1 步骤3.2 示意图4 代码(Python)5 运行结果6 结论 1 编译环境 编程语言:Python IDE:PyCharm 2017 2 算法原理介绍 SAD(Sum of ...

    1 编译环境

    编程语言:Python
    IDE:PyCharm 2017

    2 算法原理介绍

    SAD(Sum of absolute differences)是一种图像匹配算法。基本思想:差的绝对值之和。此算法常用于图像块匹配,将每个像素对应数值之差的绝对值求和,据此评估两个图像块的相似度。该算法快速、但并不精确,通常用于多级处理的初步筛选。

    3 基本流程

    3.1 步骤

    输入:两幅图像,一般为左相机和右相机得到得左图和右图,分别设置为Left-Image,Right-Image
    遍历左图中得所有像素点,并对每一个像素点执行如下操作:
    (1)构造一个小窗口,类似于卷积核;
    (2)用窗口覆盖左边的图像,选择出窗口覆盖区域内的所有像素点;
    (3)同样用窗口覆盖右边的图像并选择出覆盖区域的像素点;
    (4)左边覆盖区域减去右边覆盖区域,并求出所有像素点灰度差的绝对值之和;
    (5)移动右边图像的窗口,重复(3)-(4)的处理(这里有个搜索范围,超过这个范围跳出);
    (6)找到这个范围内SAD值最小的窗口,即找到了左图锚点的最佳匹配的像素块。

    3.2 示意图

    在这里插入图片描述

    4 代码(Python)

    import cv2
    from pylab import *
    import time
    
    def SAD(Img_L,Img_R,winsize,DSR):       #输入左右图像,窗口尺寸,搜索范围
        width,height=Img_L.shape
        kernel_L=np.zeros((winsize,winsize),dtype='uint8')
        kernel_R = np.zeros((winsize, winsize), dtype='uint8')
        disparity=np.zeros((width, height), dtype='uint8')
        for i in range(width-winsize):
            for j in range(height-winsize):
                kernel_L=Img_L[i:i+winsize,j:j+winsize]
                v=[0]*DSR
                for k in range(DSR):
                    x=i-k
                    if x>=0:
                        kernel_R=Img_R[x:x+winsize,j:j+winsize]
                    for m in range(winsize):
                        for n in range(winsize):
                            v[k]=v[k]+abs(kernel_R[m,n]-kernel_L[m,n])
                disparity[i,j]=min(v)
        return disparity
    start=time.process_time()                   #获取代码运行时间
    img_L=cv2.imread('SAD\\L.bmp',0)
    img_R=cv2.imread('SAD\\R.bmp',0)
    sad=SAD(img_L,img_R,3,30)
    cv2.imshow('Origion_L',img_L)
    cv2.imshow('Origion_R',img_R)
    cv2.imshow('After',sad)
    cv2.waitKey()
    cv2.destroyAllWindows()
    end=time.process_time()
    print('Running time:',end-start)            #显示运行时间

    5 运行结果

    在这里插入图片描述

    6 结论

    处理效果不好得原因应该是与卷积核得大小有关,可设置对照实验验证之。
    csdn中第一篇python语言编写的SAD双目立体匹配文章,多谢阅读,可评论区交流。

    展开全文
  • 使用python3.7实现SGBM算法,通过调用opencv库函数来实现图像匹配,计算出左右图的视差图
  • 立体匹配1.1 概述1.2 主要立体匹配算法分类1.3 立体匹配的基本步骤2. 归一化互相关(NCC)视差匹配法2.1 原理2.2 匹配流程:3. 不同窗口值对匹配结果的影响 实验要求: 从理论角度,分析以窗口代价计算视差的原理 ...

    1. 立体匹配

    1.1 概述

    立体匹配是立体视觉研究中的关键部分。其目标是在两个或多个视点中匹配相应像素点,计算视差。通过建立一个能量代价函数,对其最小化来估计像素点的视差,求得深度
    在这里插入图片描述
    点P和Q,映射到左相机OR像面上的同一点p≡q,只要找到p和q在右相机OT像面上的对应点就可以通过三角计算估计深度找到对应点的过程,即立体匹配

    为了找到对应点,需要增加约束,最常用的是极线约束

    在这里插入图片描述
    P和Q映射到左相机QR像面上的同一点p≡q,直线pq上的点对应点一定位于右像面的直线p’q’上,p’q’即为直线pq的极线,这就是极线约束

    接下来就可以根据视差估计深度,然后通过Graph cuts算法给每一个像素点分配视差从而得到深度图,不再详细说明。

    1.2 主要立体匹配算法分类

    1)根据采用图像表示的基元不同,立体匹配算法分为:
    A、区域立体匹配算法:可获取稠密视差图。缺点:受图像的仿射畸变和辐射畸变影响较大;像素点约束窗口的大小与形状选择比较困难,选择过大,在深度不连续处,视差图中会出现过度平滑现象;选择过小,对像素点的约束比较少,图像信息没有得到充分利用,容易产生误匹配。
    B、基于特征的立体匹配算法:可获得稀疏的视差图,经差值估计可获得稠密视差图。可提取点、线、面等局部特征,也可提取多边形和图像结构等全局特征。缺点:特征提取易受遮挡、光线、重复纹理等影响较大;差值估计计算量大。
    C、基于相位立体匹配算法:假定在图像对应点中,其频率范围内,其局部相位是相等的,在频率范围内进行视差估计。
    2)依据采用最优化理论方法的不同,立体匹配算法可以分为:
    A、局部的立体匹配算法
    B、全局的立体匹配算法

    还有立体匹配算法介绍的更详细内容:参考博客

    1.3 立体匹配的基本步骤

    立体匹配过程:

    1. 匹配代价计算: 一般是通过计算左右两图对应像素3个通道的灰度值差来决定匹配代价的,常用的就是基于像素点匹配代价计算,一般有AD,SD,TAD什么的,基于区域的匹配代价计算一般有SAD,SSD, STAD之类的。匹配代价计算会生成一个disparity space image,也就是DSI。这个DSI是一个三维的空间,也就是每一个视差,得到一张代价图。假如视差范围是0~16,则会得到17幅代价图。视差搜索范围就是MiddleBurry网站上的stereopair值,也就是说在视差范围内(比如0-16)内搜索匹配代价,得到17张匹配代价图,然后找到匹配代价最小的对应的视差值就是此像素对应的视差
    2. 代价聚合:其实就是一个滤波的过程,对每一幅代价图进行聚合,最简单的就是采用boxfilter。第一步代价计算只是得到了图像上所有孤立像素的视差值,但是这些时差值都是孤立的,引入了过多噪声,比如一片区域的视差值都是10,可是引入噪声后就会导致这一片的视差值都不一样,那么就需要一个滤波的过程,也就是我们所说的局部立体匹配方法,即采用窗口卷积达到局部滤波的目的
    3. 计算视差:常用的方法就是WTA算法(局部),对于图像中的同一个点,选出17幅代价图中匹配代价最小的那张图,该幅图对应的视差值就选取为最终的视差。或者在全局立体匹配中采用能量函数的方法,分为数据项和平滑项,数据项其实就是代价计算,平滑项就是代价聚合,只不过窗口大小是整幅图像,也可以试试如果把平滑项前面的系数lamda设为0,那么得到的结果和单纯代价计算的局部立体匹配是一样的。
    4. 视差精化:也就是对得到的视差进行优化的过程,如:左右一致性检测、区域投票等;这步其实是很多立体匹配的遮羞布,比如用遮挡处理,中值滤波,左右一致性检测等,都能使最后的是视差图提升1%左右,它是很多论文的遮羞布。但是不可否认的是,立体匹配最关键的步骤仍然是代价计算和代价聚合步骤。
      在立体匹配方法中,基于全局和局部的算法有些区别。不过基本步骤都差不多。有些时候,基于局部的算法,第一步和第二步是合并在一起进行的,基于全局的算法,会跳过第二步。

    2. 归一化互相关(NCC)视差匹配法

    2.1 原理

    对于原始的图像内任意一个像素点 ( p x , p y ) (px,py) (px,py)构建一个 n × n n×n n×n的邻域作为匹配窗口。然后对于目标相素位置 ( p x + d , p y ) (px+d,py) (px+d,py)同样构建一个 n × n n×n n×n大小的匹配窗口,对两个窗口进行相似度度量,注意这里的dd dd有一个取值范围。对于两幅图像来说,在进行 N C C NCC NCC计算之前要对图像处理,也就是将两帧图像校正到水平位置,即光心处于同一水平线上,此时极线是水平的,否则匹配过程只能在倾斜的极线方向上完成,这将消耗更多的计算资源。

    N C C NCC NCC计算公式如下:
    N C C ( p , d ) = ∑ ( x , y ) ∈ W p ( I 1 ( x , y ) − I 1 ‾ ( P x , P y ) ) ⋅ ( I 1 ( x + d , y ) − I 2 ‾ ( P x + d , P y ) ) ∑ ( x , y ) ∈ W p ( I 1 ( x , y ) − I 1 ‾ ( P x , P y ) ) 2 ⋅ ∑ ( x , y ) ∈ W p ( I 2 ( x + d , y ) − I 2 ‾ ( P x + d , P y ) ) 2 NCC(p,d)=\frac{\sum_{(x,y)\in W_{p}}(I_{1}(x,y)-\overline{I_{1}}(P_{x},P_{y}))\cdot (I_{1}(x+d,y)-\overline{I_{2}}(P_{x}+d,P_{y}))}{\sum_{(x,y)\in W_{p}}(I_{1}(x,y)-\overline{I_{1}}(P_{x},P_{y}))^2\cdot \sum_{(x,y)\in W_{p}}(I_{2}(x+d,y)-\overline{I_{2}}(P_{x}+d,P_{y}))^2} NCC(p,d)=(x,y)Wp(I1(x,y)I1(Px,Py))2(x,y)Wp(I2(x+d,y)I2(Px+d,Py))2(x,y)Wp(I1(x,y)I1(Px,Py))(I1(x+d,y)I2(Px+d,Py))

    其中 N C C ( p , d ) NCC(p,d) NCC(p,d)得到的值的范围将在[−1,1]之间。
    W p Wp Wp为之前提到的匹配窗口
    I 1 ( x , y ) I_{1}(x,y) I1(x,y)原始图像的像素值
    I 1 ‾ ( p x , p y ) \overline{I_{1}}(p_x,p_y) I1(px,py)原始窗口内像素的均值
    I 2 ( x + d , y ) I_{2}(x+d,y) I2(x+d,y)原始图像在目标图像上对应点位置在 x x x方向上偏移 d d d后的像素值
    I 2 ‾ ( p x + d , p y ) \overline{I_{2}}(p_x+d, p_y) I2(px+d,py)目标图像匹配窗口像素均值

    N C C = − 1 NCC=−1 NCC=1,则表示两个匹配窗口完全不相关,相反,若 N C C = 1 NCC=1 NCC=1时,表示两个匹配窗口相关程度非常高。

    2.2 匹配流程

    1. 采集图像:通过标定好的双目相机采集图像,当然也可以用两个单目相机来组合成双目相机。

    2. 极线校正:校正的目的是使两帧图像极线处于水平方向,或者说是使两帧图像的光心处于同一水平线上。通过校正极线可以方便后续的 N C C NCC NCC操作。
      1)由标定得到的内参中畸变信息中可以对图像去除畸变
      2)通过校正函数校正以后得到相机的矫正变换R和新的投影矩阵P,接下来是要对左右视图进行去畸变,并得到重映射矩阵

    3. 特征匹配:这里便是我们利用 N C C NCC NCC做匹配的步骤啦,匹配方法如上所述,右视图中与左视图待测像素同一水平线上相关性最高的即为最优匹配。完成匹配后,我们需要记录其视差 d d d,即待测像素水平方向 x l xl xl与匹配像素水平方向 x r xr xr之间的差值 d = x r − x l d=xr−xl d=xrxl,最终我们可以得到一个与原始图像尺寸相同的视差图 D D D

    4. 深度恢复:通过上述匹配结果得到的视差图 D D D,我们可以很简单的利用相似三角形反推出以左视图为参考系的深度图。计算原理如下图所示:
      在这里插入图片描述

    如图, T x Tx Tx为双目相机基线, f f f为相机焦距,这些可以通过相机标定步骤得到。而 x r − x l xr−xl xrxl就是视差 d d d
    通过公式 z = f × T x d z=\frac{f×Tx}{d} z=df×Tx可以很简单地得到以左视图为参考系的深度图了。
    至此,我们便完成了双目立体匹配。倘若只是用于图像识别,那么到步骤3时已经可以结束了。

    2.3 代码实现

    NCCfaster.py

    import numpy as np
    import cv2
    from PCV.localdescriptors import sift
    
    im1 = 'C://Users//Garfield//PycharmProjects//untitled//NCC-master//im2.ppm'
    im2 = 'C://Users//Garfield//PycharmProjects//untitled//NCC-master//im6.ppm'
    
    img1 = cv2.imread(im1, cv2.CV_8UC1)
    img2 = cv2.imread(im2, cv2.CV_8UC1)
    rows, cols = img1.shape
    print(img1.shape)
    
    def translaton(image, shape):
        step = round((shape[0]-1)/2)
        print(step)
        shifted = []
        for i in range(0, step+1):
            for j in range(0, step+1):
                if i==0 and j==0:
                    M1 = np.float32([[1, 0, i], [0, 1, j]])
                    shifted.append(cv2.warpAffine(image, M1, (image.shape[1], image.shape[0])))
                elif i==0 and j!=0:
                    M1 = np.float32([[1, 0, i], [0, 1, j]])
                    M2 = np.float32([[1, 0, i], [0, 1, -j]])
                    shifted.append(cv2.warpAffine(image, M1, (image.shape[1], image.shape[0])))
                    shifted.append(cv2.warpAffine(image, M2, (image.shape[1], image.shape[0])))
                elif i!=0 and j==0:
                    M1 = np.float32([[1, 0, i], [0, 1, j]])
                    M2 = np.float32([[1, 0, -i], [0, 1, j]])
                    shifted.append(cv2.warpAffine(image, M1, (image.shape[1], image.shape[0])))
                    shifted.append(cv2.warpAffine(image, M2, (image.shape[1], image.shape[0])))
                else:
                    M1 = np.float32([[1, 0, i], [0, 1, j]])
                    M2 = np.float32([[1, 0, -i], [0, 1, -j]])
                    M3 = np.float32([[1, 0, -i], [0, 1, j]])
                    M4 = np.float32([[1, 0, i], [0, 1, -j]])
                    shifted .append(cv2.warpAffine(image, M1, (image.shape[1], image.shape[0])))
                    shifted.append(cv2.warpAffine(image, M2, (image.shape[1], image.shape[0])))
                    shifted.append(cv2.warpAffine(image, M3, (image.shape[1], image.shape[0])))
                    shifted.append(cv2.warpAffine(image, M4, (image.shape[1], image.shape[0])))
    
        print(len(shifted))
        return np.array(shifted)
    
    #I(x,y)-avg(I(x,y))
    def img_sub_avg(img_shifted, avg_img):
        len, height, width = img1_shifted.shape
        tmp_ncc1 = np.zeros([len, height, width])
        for i in range(len):
            tmp_ncc1[i] = img_shifted[i] - avg_img
        print(tmp_ncc1)
        return tmp_ncc1
    
    def NCC(img1_sub_avg,img2_sub_avg, threshold, max_d):
        #设立阈值
        len, height, width = img1_sub_avg.shape
        thershould_shifted = np.zeros([len, height, width])
        ncc_max = np.zeros([height, width])
        ncc_d = np.zeros([height, width])
        for j in range(3, max_d):
            tmp_ncc1 = np.zeros([height, width])
            tmp_ncc2 = np.zeros([height, width])
            tmp_ncc3 = np.zeros([height, width])
            for k in range(len):
                M1 = np.float32([[1, 0, -j - 1], [0, 1, 0]])
                thershould_shifted[k] = cv2.warpAffine(img1_sub_avg[k], M1, (img1_sub_avg.shape[2], img1_sub_avg.shape[1]))
            for i in range(len):
                tmp_ncc1 += (img2_sub_avg[i])*(thershould_shifted[i])
                tmp_ncc2 += pow(img2_sub_avg[i], 2)
                tmp_ncc3 += pow(thershould_shifted[i], 2)
    
            tmp_ncc2 = tmp_ncc2*tmp_ncc3
            tmp_ncc2 = np.sqrt(tmp_ncc2)
            tmp_ncc4 = tmp_ncc1/tmp_ncc2
            for m in range(height):
                for n in range(width):
                    if tmp_ncc4[m, n] > ncc_max[m ,n] and tmp_ncc4[m, n] > threshold:
                        ncc_max[m, n] = tmp_ncc4[m, n]
                        ncc_d[m , n] = j
        for i in ncc_d:
            print(i)
        return ncc_max, ncc_d
    
    if __name__ == "__main__":
        disparity = np.zeros([rows, cols])
        NCC_value = np.zeros([rows, cols])
        deeps = np.zeros([rows, cols])
        # 用3*3卷积核做均值滤波
        avg_img1 = cv2.blur(img1, (7, 7))
        avg_img2 = cv2.blur(img2, (7, 7))
        fimg1 = img1.astype(np.float32)
        fimg2 = img2.astype(np.float32)
        avg_img1 = avg_img1.astype(np.float32)
        avg_img2  = avg_img2.astype(np.float32)
        img1_shifted = translaton(fimg1, [7, 7])
        img2_shifted = translaton(fimg2, [7, 7])
        img1_sub_avg = img_sub_avg(img1_shifted, avg_img1)
        img2_sub_avg = img_sub_avg(img2_shifted, avg_img2)
        ncc_max, ncc_d = NCC(img1_sub_avg,img2_sub_avg, threshold = 0.5, max_d = 64)
        print(img1_shifted.shape)
        disp = cv2.normalize(ncc_d, ncc_d, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX,
                              dtype=cv2.CV_8U)
        cv2.imshow("left", img1)
        cv2.imshow("right", img2)
        cv2.imshow("depth", disp)
        cv2.waitKey(0)  # 等待按键按下
        cv2.destroyAllWindows()#清除所有窗口
    

    原始图像:
    在这里插入图片描述

    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    代码2:

    # -*- coding: utf-8 -*-
    import scipy.misc
    from PIL import Image
    from pylab import *
    import cv2
    from numpy import *
    from numpy.ma import array
    from scipy.ndimage import filters
    def plane_sweep_ncc(im_l,im_r,start,steps,wid):
        """ 使用归一化的互相关计算视差图像 """
        m,n = im_l.shape
        # 保存不同求和值的数组
        mean_l = zeros((m,n))
        mean_r = zeros((m,n))
        s = zeros((m,n))
        s_l = zeros((m,n))
        s_r = zeros((m,n))
        # 保存深度平面的数组
        dmaps = zeros((m,n,steps))
        # 计算图像块的平均值
        filters.uniform_filter(im_l,wid,mean_l)
        filters.uniform_filter(im_r,wid,mean_r)
        # 归一化图像
        norm_l = im_l - mean_l
        norm_r = im_r - mean_r
        # 尝试不同的视差
        for displ in range(steps):
            # 将左边图像移动到右边,计算加和
            filters.uniform_filter(np.roll(norm_l, -displ - start) * norm_r, wid, s) # 和归一化
            filters.uniform_filter(np.roll(norm_l, -displ - start) * np.roll(norm_l, -displ - start), wid, s_l)
            filters.uniform_filter(norm_r*norm_r,wid,s_r) # 和反归一化
            # 保存 ncc 的分数
            dmaps[:,:,displ] = s / sqrt(s_l * s_r)
            # 为每个像素选取最佳深度
        return np.argmax(dmaps, axis=2)
    
    def plane_sweep_gauss(im_l,im_r,start,steps,wid):
     """ 使用带有高斯加权周边的归一化互相关计算视差图像 """
     m,n = im_l.shape
     # 保存不同加和的数组
     mean_l = zeros((m,n))
     mean_r = zeros((m,n))
     s = zeros((m,n))
     s_l = zeros((m,n))
     s_r = zeros((m,n))
     # 保存深度平面的数组
     dmaps = zeros((m,n,steps))
     # 计算平均值
     filters.gaussian_filter(im_l,wid,0,mean_l)
     filters.gaussian_filter(im_r,wid,0,mean_r)
     # 归一化图像
     norm_l = im_l - mean_l
     norm_r = im_r - mean_r
     # 尝试不同的视差
     for displ in range(steps):
         # 将左边图像移动到右边,计算加和
         filters.gaussian_filter(np.roll(norm_l, -displ - start) * norm_r, wid, 0, s) # 和归一化
         filters.gaussian_filter(np.roll(norm_l, -displ - start) * np.roll(norm_l, -displ - start), wid, 0, s_l)
         filters.gaussian_filter(norm_r*norm_r,wid,0,s_r) # 和反归一化
         # 保存 ncc 的分数
         dmaps[:,:,displ] = s / np.sqrt(s_l * s_r)
     # 为每个像素选取最佳深度
     return np.argmax(dmaps, axis=2)
    
    im_l = array(Image.open(r'C://Users//Garfield//Desktop//towelmatch//jidian//1.jpg').convert('L'), 'f')
    im_r = array(Image.open(r'C://Users//Garfield//Desktop//towelmatch//jidian//2.jpg').convert('L'),'f')
    # 开始偏移,并设置步长
    steps = 12
    start = 4
    # ncc 的宽度
    wid = 2000
    res = plane_sweep_ncc(im_l,im_r,start,steps,wid)
    
    imsave('C://Users//Garfield//PycharmProjects//untitled//NCC-master//depth2000.png',res)
    show()
    
    

    此代码可以修改窗口值的大小,具体结果与分析放在下一小节

    3. 不同窗口值对匹配结果的影响

    原图:
    在这里插入图片描述

    以下分别是当窗口值设定为15,20,50,100,200,500,700,1000,2000的运行结果:
    在这里插入图片描述
    在这里插入图片描述

    总的来看,窗口值设置的越大,区域化分得越为明显,而设置的越小噪声越大,区块划分的越不明显。同时,从本次实验结果图来看,wid设置为700时,结果最为理想。
    另外可以看到
    在这里插入图片描述
    瓶身光照最为强烈的地方会与瓶身其他其他地方像素值有较大区分,以及窗口大小设置越大,则会更多的提取出有光照的像素点并连结成块,区分出亮部暗部。

    4. 实验遇到的问题与解决

    问题:

    • ‘NoneType’ object has no attribute ‘shape’

    求解cols,rows = img.shape时出现上述报错,是图片路径不对,程序无法获取到图片。

    解决办法:
    右键下图目录灰色处
    在这里插入图片描述
    —>copypath,再在原本的读取图片路径代码中粘贴
    注意格式改成C://Users//…
    参考博客:立体匹配_数据结构与算法
    参考博客:立体匹配过程
    参考博客:双目立体匹配算法–归一化互相关(NCC)详解和代码实现(python)
    NCC的更详细相关
    延伸学习:真实场景的双目立体匹配(Stereo Matching)获取深度图详解
    原理详解:双目视觉(三)立体匹配算法

    展开全文
  • python 模板匹配

    千次阅读 2019-07-09 23:19:18
    不需要的部分,可以用黑色填充,但是返回的依然是矩形框。 import cv2 target = cv2.imread(r"e:/new/11.jpg") template = cv2.imread(r"e:/new/13.jpg") cv2.imshow("template",template) ...#执行模板匹配,...

    不需要的部分,可以用黑色填充,但是返回的依然是矩形框。

    
    
    import cv2
    
    target = cv2.imread(r"e:/new/11.jpg")
    
    template = cv2.imread(r"e:/new/13.jpg")
    cv2.imshow("template",template)
    theight, twidth = template.shape[:2]
    #执行模板匹配,采用的匹配方式cv2.TM_SQDIFF_NORMED
    result = cv2.matchTemplate(target,template,cv2.TM_SQDIFF_NORMED)
    
    cv2.normalize( result, result, 0, 1, cv2.NORM_MINMAX, -1 )
    #寻找矩阵(一维数组当做向量,用Mat定义)中的最大值和最小值的匹配结果及其位置
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
    #匹配值转换为字符串
    #对于cv2.TM_SQDIFF及cv2.TM_SQDIFF_NORMED方法min_val越趋近与0匹配度越好,匹配位置取min_loc
    #对于其他方法max_val越趋近于1匹配度越好,匹配位置取max_loc
    strmin_val = str(min_val)
    #绘制矩形边框,将匹配区域标注出来
    #min_loc:矩形定点
    #(min_loc[0]+twidth,min_loc[1]+theight):矩形的宽高
    #(0,0,225):矩形的边框颜色;2:矩形边框宽度
    cv2.rectangle(target,min_loc,(min_loc[0]+twidth,min_loc[1]+theight),(0,0,225),2)
    #显示结果,并将匹配值显示在标题栏上
    cv2.imshow("MatchResult--Value"+strmin_val,target)
    
    cv2.waitKey()
    cv2.imwrite(r"e:/new/14.jpg",target)
    cv2.destroyAllWindows()

     

    展开全文
  • 基于双目立体视觉的图像匹配与测距Python代码,可以运行。
  • opencv-python 模板匹配

    千次阅读 2020-05-05 08:40:12
    使用模板匹配查找图像中的对象 函数:cv.matchTemplate(),cv.minMaxLoc() 理论 模板匹配是一种在较大图像中搜索和查找模板图像位置的方法。为此,OpenCV附带了一个函数cv.matchTemplate()。它只是在输入图像上滑动...
  • python 模板匹配对比

    千次阅读 2019-07-10 11:39:54
    平方差匹配CV_TM_SQDIFF:用两者的平方差来匹配,最好的匹配值为0 归一化平方差匹配CV_TM_SQDIFF_NORMED 相关匹配CV_TM_CCORR:用两者的乘积匹配,数值越大表明匹配程度越好 归一化相关匹配CV_TM_CCORR_NO...
  • 简单来说模板匹配就是通过现有的模板去与图片进行比较找出图中所匹配的图像。 首先来看一下效果图: 左图是模板图片,中图是带测试的图片,右图是匹配的结果 程序将在“中图”中匹配“左图”的模板图片,...
  • 该操作不仅经常应用在计算机图形学中,而且经常出现在计算机视觉算法中。 一、仿射变换原理 仿射变换能够保持图像的“平直性”,包括旋转,缩放,平移,错切操作。对于三个点,仿射变换可以将一副图像进行扭曲,使得...
  • 本文我们将使用局部描述子来匹配带有地理标记的图像: • 输入同一场景的序列图像 • 通过SIFT算法对地理标记图像进行两两匹配...1.在python中安装graphviz,用 pip install graphviz 下载。 2.可以去官网 https://...
  • 可在Windows环境中使用,利用opencv和vs软件,环境配置好之后,更改程序中的相应图片,就可以得到双目视觉的视差图
  • 特征检测与匹配的目标是识别一个图像中的关键点与另一个图像中的对应点之间的配对。在此实验中,你将编写代码以检测图像中的特征点(对于平移、旋转和照明具有一定的不变性),并在另一个图像中找到最佳匹配特征。...
  • python 模板匹配多个物体

    千次阅读 2019-07-10 11:43:05
    平方差匹配CV_TM_SQDIFF:用两者的平方差来匹配,最好的匹配值为0 归一化平方差匹配CV_TM_SQDIFF_NORMED 相关匹配CV_TM_CCORR:用两者的乘积匹配,数值越大表明匹配程度越好 归一化相关匹配CV_TM_CCORR_NORMED ...
  • 我们使用一个查询图像,在其中找到一些特征点(关键点),我们又在另一幅图像中也找到了一些特征点,最后对这两幅图像之间的特征点进行匹配。简单来说就是:我们在一张杂乱的图像中找到了一个对象(的某些部分)的...
  • ===================================================== ...==================================================...计算机视觉与深度学习 | ORB特征提取:基于OpenCV+Python(附代码) 2011年Rublee等[12]提出了ORB(Or
  • 我用cv2.matchtemplate无论匹配成功还是失败都会返回一个矩阵,求教如何判定匹配是成功还是失败
  • SAD立体匹配算法的PYTHON实现

    千次阅读 热门讨论 2020-02-09 20:46:54
    这是第一次发CSDN博客,因为在机器视觉的学习中CSDN帮助了我很多,那么我也应该为CSDN社区做一些贡献,所以本文将介绍我用python实现的SAD匹配算法。 1.SAD算法的原理 SAD算法是立体匹配算法中,隶属于局部区域匹配...
  • 它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成,同时提供了Python、Ruby、MATLAB等语言的接口,实现了图像处理和计算机视觉方面的很多通用算法。 今天我们就是用python学习OpenCV。...
  • 这篇博文将实现如何将标准模板匹配扩展到多尺度,从而使其更加健壮。使其可以处理模板和输入图像大小不同的匹配。 我们还发现,在模板图像是刚性和格式良好的情况下,使用边缘映射而不是RGB或灰度表示可以在应用...
  • Python 使用Opencv实现图像特征检测与匹配

    万次阅读 多人点赞 2018-06-13 11:36:58
    本人新书《玩转Python网络爬虫》,可在天猫、京东等商城搜索查阅,项目深入浅出,适合爬虫初学者或者是已经有一些网络爬虫编写经验,但希望更加全面、深入理解Python爬虫的开发人员。 ———-欢迎加入学习交流QQ...
  • matlab匹配滤波代码Python中的视觉Odometry管道 用于移动机器人的视觉算法UZH HS 2020。 作者:EduardČuba 课程网站: 演示版 停车处: KITTI: 安装 需要Python 3.7+。 快速开始: pip3 install virtualenv ...
  • 局部图像描述子Harris角点原理代码实现SIFT原理代码实现匹配地理标记图像 Harris角点 原理 代码实现 from pylab import * from PIL import Image from scipy.ndimage import filters def compute_harris_response...
  • 在进行嵌入式开发的过程中,对于图像特征点的提取及匹配一直是一个重点问题,之前我们通过C++进行对应的orb特征点的匹配提取,本次博客,林君学长将带大家了解如何通过python实现SIFT和ORB两钟方法的特征点提取,...
  • 想法:想使用SIFT和SURF匹配的特征点来当做先验信息加入网络。 需求:需要极可靠的匹配点以及相应坐标以及计算视差 代码: import numpy as np import cv2 from matplotlib import pyplot as plt imgname1 = 'path1...
  • Python OpenCV】基于单应矩阵的视觉里程计算法步骤详解之ORB 特征提取 文章目录1.ORB 特征提取2.BFMatcher特征匹配输出结果示例代码未解决的问题扩展技术英语参考资料 特征匹配解决SLAM中数据关联问题,确定当前...
  • X1X1X1与X2X2X2是两幅图像的一对匹配点,FFF为基础矩阵,基础矩阵为一幅图像上像p1p_1p1​点到另一幅图像上对极线L2L_2L2​的一种映射。所以有如下公式: (2)L2=F∗p1L_2=F*p_1\tag{2}L2​=F∗p1​(2) 此公式为后面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,254
精华内容 6,501
关键字:

python视觉匹配

python 订阅