精华内容
下载资源
问答
  • harris角点匹配
    2022-08-03 17:56:40


    一、前言

    基于Harris角点实现两幅(不同角度拍摄)的图像匹配,基于RANSAC算法进行鲁棒性估计。算法的流程如下:

    1. 读取图像,进行仿射变换;
    2. 计算两幅图像中的角点(可以类比为其他特征);
    3. 考虑点周围的小空间,使用误差平方加权和计算点之间的对应点;(该度量方法只在两幅图像非常相似的情况下可用)
    4. 前一步中得到的对应点为一组坐标值(两幅不同图像),可以用来估计它们之间的几何变换;
    5. 采用随机抽样一致性算法进行鲁棒性估计。

    二、使用步骤

    1.引入库

    import numpy as np
    from skimage.io import imread
    from skimage.color import rgb2gray
    from skimage.util import img_as_float
    from skimage.exposure import rescale_intensity
    from skimage.transform import AffineTransform, warp
    from skimage.feature import corner_harris, corner_peaks, corner_subpix,plot_matches
    from skimage.measure import ransac
    from matplotlib import pylab
    

    2.基于skimage的仿射变换

    	temple = rgb2gray(img_as_float(imread(r'../../images/building.jpg'))) # 这样写可以读取两级相对路径
        img_orig = np.zeros(list(temple.shape) + [3])
        img_orig[..., 0] = temple
        grad_row, grand_col = (np.mgrid[0:img_orig.shape[0],
                               0:img_orig.shape[1]] / float(img_orig.shape[0]))
        img_orig[..., 1] = grad_row
        img_orig[..., 2] = grand_col
        img_orig = rescale_intensity(img_orig)
        img_orig_gray = rgb2gray(img_orig)
        affine_trans = AffineTransform(scale=(0.8, 0.9), rotation=0.1, translation=(120, -20))
        image_warped = warp(img_orig, affine_trans.inverse, output_shape=img_orig.shape)
        image_warped_gray = rgb2gray(image_warped)
    

    3. 亚像素角点计算

        # 计算图像中的感兴趣点--------------Harris角点
        # harris corners
        coordinates_original = corner_harris(img_orig_gray)
        # threshold for an optimal value, depends on the image
        coordinates_original[coordinates_original > 0.01 * coordinates_original.max()] = 1
        corner_coordinates_original = corner_peaks(coordinates_original, threshold_rel=0.0001, min_distance=5)
    
        # harris corners
        coordinates_warped = corner_harris(image_warped_gray)
        # threshold for an optimal value, depends on the image
        coordinates_warped[coordinates_warped > 0.01 * coordinates_warped.max()] = 1
        corner_coordinates_warped = corner_peaks(coordinates_warped, threshold_rel=0.0001, min_distance=5)
    
        # 确定子像素角点的位置
        coordinates_subpix_original = corner_subpix(img_orig_gray, corner_coordinates_original, window_size=9)
        coordinates_subpix_warped = corner_subpix(image_warped_gray, corner_coordinates_warped, window_size=9)
    

    4. 基于中心像素距离的权重计算

    # 高斯权重:
    def gaussian_weight(window_ext, sigma=1):
        y, x = np.mgrid[-window_ext:window_ext + 1, -window_ext:window_ext + 1]
        g_w = np.zeros(y.shape, dtype=np.double)
        g_w[:] = np.exp(-0.5 * (x ** 2 / sigma ** 2 + y ** 2 / sigma ** 2))
        g_w /= 2 * np.pi * sigma * sigma
        return g_w   
    

    5. 角点匹配

    权重像素取决于到中心像素的距离,计算变形后图像中所有角点的误差平方加权和,用最小误差平方加权和的角点作为对应点

    def match_corner(coord, window_ext=3):
    	row, col = np.round(coord).astype(np.intp)
    	window_original = img_orig[row - window_ext:row + window_ext + 1, col - window_ext:col + window_ext + 1, :]
    	# 基于中心像素距离的权重计算
    	weights = gaussian_weight(window_ext, 3)
    	weights = np.dstack((weights, weights, weights))
    	
    	# 计算所有角点的误差平方加权和
    	SSDs = []
    	for coord_row, coord_col in corner_coordinates_warped:
    	window_warped = image_warped[coord_row - window_ext:coord_row + window_ext + 1,
    	coord_col - window_ext:coord_col + window_ext + 1, :]
    	if window_original.shape == window_warped.shape:
    	SSD = np.sum(weights * (window_original - window_warped) ** 2)  # 加权求和
    	SSDs.append(SSD)
    	
    	min_idx = np.argmin(SSDs) if len(SSDs) > 0 else -1
    	return coordinates_subpix_warped[min_idx] if min_idx >= 0 else [None]
    

    6. 确定匹配对应点

    RANSAC算法进行鲁棒性估计。先将点分为内点和外点,然后在忽略外点的情况下将模型拟合到内点上,寻找与仿射变换一致的匹配。

        src = []
        dst = []
        for coord in coordinates_subpix_original:
            coord1 = match_corner(coord) # 匹配点
            if any(coord1) and len(coord1) > 0 and not all(np.isnan(coord1)):
                src.append(coord)
                dst.append(coord1)
        src = np.array(src)
        dst = np.array(dst)
    
        # 使用全部坐标估计仿射变换模型
        model = AffineTransform()
        model.estimate(src, dst)
    
        # 鲁棒性估计基于RANSAC
        model_robust, inliers = ransac((src, dst), AffineTransform, min_samples=3, residual_threshold=2, max_trials=100)
        outliers = inliers == False
    
        # 比较真实和估计的变换参数
        print(affine_trans.scale, affine_trans.translation, affine_trans.rotation)
        print(model.scale, model.translation, model.rotation)
        print(model_robust.scale, model_robust.translation, model_robust.rotation)
    

    7. 可视化图像匹配结果

    	fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(20, 15))
        plt.gray()
    
        inlier_idxs = np.nonzero(inliers)[0]
        plot_matches(ax[0], img_orig_gray, image_warped_gray, src, dst,
                     np.column_stack((inlier_idxs, inlier_idxs)), matches_color='b')
        ax[0].axis('off')
        ax[0].set_title('Correct correspondences', size=20)
    
        outlier_idxs = np.nonzero(outliers)[0]
        plot_matches(ax[1], img_orig_gray, image_warped_gray, src, dst,
                     np.column_stack((outlier_idxs, outlier_idxs)), matches_color='r')
        ax[1].axis('off')
        ax[1].set_title('Faulty correspondences', size=20)
    
        fig.tight_layout()
    
        plt.show()
    

    在这里插入图片描述


    更多相关内容
  • 首先用Harris算法提取工具模板图像与搜索图像点特征,然后使用归一化互相关匹配算法计算工具模板图像与搜索图像点特征的相关值,进而确定匹配点对,最后采用RANSAC去除错误匹配点对。通过实际数据验证,基于...
  • Harris角点匹配

    2015-03-15 11:02:35
    Harris角点匹配,matlab完整代码
  • Matlab Harris角点匹配

    千次阅读 热门讨论 2019-04-03 12:23:07
    1、自定义Harris函数,寻找图像的Harris角点坐标 (Harris.m) % coords:图像角坐标集合(为了方便后期使用归一化互相关做匹配) function coords=Harris(I) [m,n]=size(I); %imshow(I); %===================...

    图像课程作业,仅供参考
    题目:用Harris算子和归一化互相关实现两幅图的匹配
    在这里插入图片描述
    在这里插入图片描述
    1、自定义Harris函数,寻找图像的Harris角点坐标
    (Harris.m)

    % coords:图像角点坐标集合(为了方便后期使用归一化互相关做匹配)
    function coords=Harris(I)
        [m,n]=size(I);
        %imshow(I);
        %===================================
        % Step 1:计算相关矩阵M
        %===================================
        tmp=zeros(m+2,n+2);
        tmp(2:m+1,2:n+1)=I; % 补零
        Ix=zeros(m+2,n+2);% x方向梯度
        Iy=zeros(m+2,n+2);% y方向梯度
        Ix(:,2:n)=tmp(:,3:n+1)-tmp(:,1:n-1);
        Iy(2:m,:)=tmp(3:m+1,:)-tmp(1:m-1,:);
        Ix2=Ix(2:m+1,2:n+1).^2;
        Iy2=Iy(2:m+1,2:n+1).^2;
        Ixy=Ix(2:m+1,2:n+1).*Iy(2:m+1,2:n+1);
        h=fspecial('gaussian',[7 7],2);
        Ix2=filter2(h,Ix2);
        Iy2=filter2(h,Iy2);
        Ixy=filter2(h,Ixy);
        %===================================
        % Step 2:计算Harris角点响应
        %===================================
        k=0.05; % k常取0.04-0.06
        Rmax=0;
        R=zeros(m,n);
        for i=1:m
            for j=1:n
                M=[Ix2(i,j) Ixy(i,j);Ixy(i,j) Iy2(i,j)];
                R(i,j)=det(M)-k*(trace(M))^2;     
                if R(i,j)>Rmax
                    Rmax=R(i,j);
                end
            end
        end
        %===================================
        % Step 3:寻找Harris角点
        %===================================
        tmp(2:m+1,2:n+1)=R;
        %res=zeros(m+2,n+2);
        %res(2:m+1,2:n+1)=I;
        coords=[];
        for i=2:m+1
            for j=2:n+1
                % 在3*3邻域内非极大值抑制
                if tmp(i,j)>0.01*Rmax &&...
                   tmp(i,j)>tmp(i-1,j-1) && tmp(i,j)>tmp(i-1,j) && tmp(i,j)>tmp(i-1,j+1) &&...
                   tmp(i,j)>tmp(i,j-1) && tmp(i,j)>tmp(i,j+1) &&...
                   tmp(i,j)>tmp(i+1,j-1) && tmp(i,j)>tmp(i+1,j) && tmp(i,j)>tmp(i+1,j+1)
                        %res(i,j)=255; 
                        coords=[coords,[i-1;j-1]];
                end    
            end
        end
        %coords
        %figure,imshow(mat2gray(res(2:m+1,2:n+1)));
    end
    
    

    2、计算互相关矩阵寻找匹配Harris角点对
    (程序入口)

    I1=imread('C:\Users\53121\Desktop\boat1.bmp');  
    I2=imread('C:\Users\53121\Desktop\boat2.bmp');  
    coords1=Harris(I1);  
    coords2=Harris(I2);  
    %===================================  
    % 计算互相关矩阵R  
    %===================================  
    [~,m]=size(coords1);%获取图像1的角度个数  
    [~,n]=size(coords2);%获取图像2的角度个数  
    R=zeros(m,n);%互相关矩阵  
    [r1,c1]=size(I1);  
    [r2,c2]=size(I2);  
    r=2;%角点匹配领域半径  
    I1_tmp=zeros(r1+2*r,c1+2*r);  
    I2_tmp=zeros(r2+2*r,c2+2*r);  
    I1_tmp(r+1:r1+r,r+1:c1+r)=I1;  
    I2_tmp(r+1:r2+r,r+1:c2+r)=I2;  
    for i=1:m  
        x1=coords1(1,i)+r;   
        y1=coords1(2,i)+r;  
        for j=1:n  
            x2=coords2(1,j)+r;  
            y2=coords2(2,j)+r;  
            I1_mean=mean(mean(I1_tmp(x1-r:x1+r,y1-r:y1+r)));  
            I2_mean=mean(mean(I2_tmp(x2-r:x2+r,y2-r:y2+r)));  
            a=I1_tmp(x1-r:x1+r,y1-r:y1+r)-I1_mean;  
            b=I2_tmp(x2-r:x2+r,y2-r:y2+r)-I2_mean;  
            p=sum(sum(a.*b));  
            q=sqrt(sum(sum(a.^2))*sum(sum(b.^2)));  
            R(i,j)=p/q;  
        end  
    end  
    %===================================  
    % 寻找相关性最大的角点对并绘图  
    %===================================  
    % 构造画布  
    canvas=ones(max(r1,r2),c1+c2+100)*255;  
    canvas(1:r1,1:c1)=I1;  
    canvas(1:r2,c1+101:c1+c2+100)=I2;  
    imshow(uint8(canvas));  
    hold on  
    % Harris角点图  
    % for i=1:m  
    %     x=coords1(2,i);  
    %     y=coords1(1,i);  
    %     plot(x,y,'ro');  
    % end  
    % for i=1:n  
    %     x=coords2(2,i);  
    %     y=coords2(1,i);  
    %     plot(x+c1+100,y,'ro');  
    % end  
      
    [m,n]=find(R==max(max(R)));% 选取相关系数最大的匹配点  
    [number,~]=size(m)  
    for i=1:number  
        x1=coords1(2,m(i));  
        x2=coords2(2,n(i));  
        y1=coords1(1,m(i));  
        y2=coords2(1,n(i));  
        line([x1,x2+c1+100],[y1,y2]);%匹配连线  
        plot([x1 x2+c1+100],[y1 y2],'ro');  
    end  
    

    效果图
    在这里插入图片描述

    展开全文
  • python计算机视觉编程(三)——Harris角点SIFT匹配地理标记图像 计算机视觉.pdf
  • Harris角点检测和匹配

    2021-07-05 15:01:21
    Harris角点检测和匹配
  • Harris角点匹配算法,读入两幅图,检测并匹配两幅图的关键
  • Harris 角点检测 特征匹配 C++基于Harris的特征检测与匹配
  • 本文采用Harris角点的方法来进行特征提取和特征匹配两大部分: 1.Harris角点特征提取:分为函数法和机理法(手工复现法) 2.Harris角点特征匹配:先让两张图片进行特征提取,再将图一 import numpy as np import cv...

    Harris角点特征提取和特征匹配(前半部分)

    本文采用Harris角点的方法来进行特征提取和特征匹配两大部分:
    1.Harris角点特征提取:分为函数法和机理法(手工复现法)
    2.Harris角点特征匹配:先让两张图片进行特征提取,再将图一和图二的每一个点进行做相关运算,若两张图角点的相关度都是最大的,则将两张图的角点相匹配。
    在这里插入图片描述

    提示:以下程序是顺序的,要一一复制进行运行,目录需要自己更改,部分参数针对不同的图片,也要做出相应的改变


    Part1. Harris角点特征提取

    Harris角点特征提取基本思想是使用一个固定窗口在图像上进行任意方向上的滑动,比较滑动前与滑动后两种情况,窗口中的像素灰度变化程度,如果存在任意方向上的滑动,都有着较大灰度变化,那么我们可以认为该窗口中存在角点。下面这个图,赶紧很形象的说明了角点提取的机制:
    在这里插入图片描述

    一、函数法

    1.利用OPEN-CV函数库的函数(也可以用PCV,不过此库版本较老没有使用)
    cv2.cornerHarris(img,blocksize,ksize,k)

    a. img 一般时二维的灰度图,float32的输入图像。

    b. blocksize 角点检测中的窗口大小

    c. ksize sobel算子的大小

    d. 取值一般在[0.04,0.06]之间,而其时响应函数R中的一个参数。

    import numpy as np
    import cv2
    import math
    from numpy import *
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    from PIL import Image
    
    # 拿一张示例图可以看出测得出角点
    img_block=cv2.imread('D:/classofmathpicture/house2.png',0)
    img_block_C=cv2.cvtColor(img_block,cv2.COLOR_GRAY2RGB)
    Harris_block = cv2.cornerHarris(img_block, 2, 3, 0.04)
    dst = cv2.dilate(Harris_block, None)   #使检测角点变粗(红色角点更加明显)
    thres = 0.1*dst.max()  # 把阈值设置到这么大都会检测出角点,说明函数法比较精确
    img_block_C[dst > thres] = [255,0,0]
    plt.imshow(img_block_C);plt.axis('off');
    

    在这里插入图片描述

    # 任何在采用一张图片来试验,其中阈值不同的情况下,特征提取的点数是不同的。
    img_house=cv2.imread('D:/classofmathpicture/house1.png',0)
    img_house_C=cv2.imread('D:/classofmathpicture/house1.png',1)
    img_house_C=cv2.cvtColor(img_house_C,cv2.COLOR_BGR2RGB)
    # img_house_C_fuction=img_house_C.copy()
    Harris_house = cv2.cornerHarris(img_house, 3, 3, 0.04)
    dst = cv2.dilate(Harris_house, None)  #将可以标出来的点粗化
    plt.figure(figsize=(30, 20));
    for i in range(9):
        img_house_C_fuction=img_house_C.copy()
        thres = 0.005*dst.max()*(5*i+1)
        img_house_C_fuction[dst > thres] = [255,0,0]
        plt.subplot(3,3,i+1);plt.imshow(img_house_C_fuction);
        plt.title('thres= %1.3f'%(0.005*(5*i+1)));plt.axis('off');
    

    峰值的0.005倍-0.2倍作为阈值的比较图:
    在这里插入图片描述

    二、机理法

    在这里插入图片描述
    我将它分为三步,第一步求出Ix和Iy,同时窗函数乘上高斯窗,也可以用sobel()进行梯度提取;第二步求出R,第三步根据Ix、Iy、R与边角、边缘和平台区域的关系来构建阈值范围;第四步是衡量不同阈值下的角点提取效果。

    第一步:求出IX和IY.

    机理法对应函数法:cv2.cornerHarris(img,blocksize,ksize,k),其中的参数可以得以更好的理解。blocksize就是划窗的范围,也就是划一次检测的窗口是多少,对应的也就是下面的c参数;

    #计算x方向的梯度的函数(Ix)
    def grad_x(h):
        delta_h = np.matrix(h)
        a = int(h.shape[0])
        b = int(h.shape[1])
        for i in range(a):
            for j in range(b):
                if i-1>=0 and i+1<a and j-1>=0 and j+1<b:
                     #注意像素不能直接计算,需要转化为整型 
                    c=abs(int(h[i-1,j-1])-int(h[i+1,j-1]) + 2*(int(h[i-1,j]) -int(h[i+1,j])) + int(h[i-1,j+1]) - int(h[i+1,j+1]))   
                    if c>255:
                        c = 255
                    delta_h[i,j] = c
                else:
                    delta_h[i,j] = 0
        return delta_h
    ##计算y方向的梯度的函数(Ix)
    def grad_y(h):
        delta_h = np.matrix(h)
        a = int(h.shape[0])
        b = int(h.shape[1])
        for i in range(a):
            for j in range(b):
                if i-1>=0 and i+1<a and j-1>=0 and j+1<b:
                    c = abs(int(h[i-1,j-1]) - int(h[i-1,j+1]) + 2*(int(h[i,j-1]) - int(h[i,j+1])) + (int(h[i+1,j-1]) - int(h[i+1,j+1]))) 
                    if c > 255:
                        c = 255
                    delta_h[i,j] = c
                else:
                    delta_h[i,j] = 0
        return delta_h
    

    第二步:求出R

    ksize就是sobel的算子,也就是高斯函数中的A1,B1,C1表达式中的(3,3);k是评判阈值R的表达式中的参数k,机理法表达式写成:

    R[i,j] = np.linalg.det(M) - k * (np.trace(M)) * (np.trace(M))

    def harris_manual(img_house):
        dx = np.array(grad_x(img_house))
        dy = np.array(grad_y(img_house))
        A = dx * dx
        B = dy * dy 
        C = dx * dy
        A1 = cv2.GaussianBlur(A,(3,3),1.5)    #sobel算子取3
        B1 = cv2.GaussianBlur(B,(3,3),1.5)  
        C1 = cv2.GaussianBlur(C,(3,3),1.5)
        a = int(img_house.shape[0])
        b = int(img_house.shape[1])
        R = np.zeros(img_house.shape)
        for i in range(a):
            for j in range(b):
                M = [[A1[i,j],C1[i,j]],[C1[i,j],B1[i,j]]]   #窗函数是2*2的矩形窗
                R[i,j] = np.linalg.det(M) - 0.04 * (np.trace(M)) * (np.trace(M))  #k取0.04,与函数法保持一致
        return R
    

    第三步,根据对应关系来设定阈值

    . 特征值都比较大时,即窗口中含有角点

    . 特征值一个较大,一个较小,窗口中含有边缘

    . 特征值都比较小,窗口处在平坦区域

    程序一是拿方块图做实验,设定了四种情况,第一种R、Ix、Iy三个特征值都较大,画出角点;第二种是Ix远大于Iy,画出横向的边缘;第三种画出竖向的边缘;第四周是三个特征值都较小,画出平坦区域。结果得以验证上面的机理法是正确的

    # 程序一:方块
    img_block_C=cv2.imread('D:/classofmathpicture/house2.png',1)
    img_block_C=cv2.cvtColor(img_block_C,cv2.COLOR_BGR2RGB)
    img_block=cv2.imread('D:/classofmathpicture/house2.png',0)
    R_block=harris_manual(img_block)
    img_block_C_manual_edge_h=img_block_C.copy()
    img_block_C_manual_edge_l=img_block_C.copy()
    img_block_C_manual_flat=img_block_C.copy()
    img_block_C_manual_corner=img_block_C.copy()
    dx_block = np.array(grad_x(img_block))
    dy_block = np.array(grad_y(img_block))
    thres = 0.1*R_block.max()
    dxres = 0.1*dx_block.max()
    dyres = 0.1*dy_block.max()
    a = int(img_block.shape[0])
    b = int(img_block.shape[1])
    for i in range(a):
        for j in range(b):
            if (abs(R_block[i,j]) > thres) and (dx_block[i,j]>dxres) and (dy_block[i,j]>dyres):
                img_block_C_manual_corner[i,j,:] = [255,0,0]
            if (R_block[i,j]<0) and (int(dx_block[i,j])-int(dy_block[i,j]))>4*dxres:
                img_block_C_manual_edge_h[i,j,:] = [255,0,0]
            if (R_block[i,j]<0) and (int(dy_block[i,j])-int(dx_block[i,j]))>4*dxres:
                img_block_C_manual_edge_l[i,j,:] = [255,0,0]
            if abs(R_block[i,j]) <0.5*thres and (dx_block[i,j]<0.5*dxres) and (dy_block[i,j]<0.5*dyres):
                img_block_C_manual_flat[i,j,:] = [255,0,0]
    plt.figure(figsize=(30, 20));
    plt.subplot(221);plt.imshow(img_block_C_manual_corner);plt.title('manual_way_corner');plt.axis('off');
    plt.subplot(222);plt.imshow(img_block_C_manual_edge_h);plt.title('manual_way_edge_h');plt.axis('off');
    plt.subplot(223);plt.imshow(img_block_C_manual_edge_l);plt.title('manual_way_edge_l');plt.axis('off');
    plt.subplot(224);plt.imshow(img_block_C_manual_flat);plt.title('manual_way_flat');plt.axis('off');
    

    下图分别为角点提取,x梯度提取,y梯度提取和平坦区域提取:
    在这里插入图片描述

    # 程序二:房子,把上面程序中的图片换成房子即可
    

    在这里插入图片描述

    第四步:衡量不同阈值下的角点提取效果

    和函数法同理,采取了R最大值的不同系数来作为阈值:0.005*(5*x+1)*R_house.max()
    在采取相同系数效果下,效果与函数法大有不同(可能是函数法的阈值系数与机理法的意思不同),但是总体能得出系数等于0.2最为合适
    在这里插入图片描述
    若想看后半部分-Harris角点特征匹配,点击链接:
    https://blog.csdn.net/QWER306306/article/details/123830827

    展开全文
  • harris角点检测与匹配,能够进行图像的配准
  • C++实现Harris角点检测

    2015-09-10 11:08:27
    利用opencv实现harris算法,进行角点检测,并采用邻域极大值方法对错误的角点进行抑制。可以在VS2010中运行!
  • 一. 图像特征匹配 最近刚入门了计算机视觉这门课程,觉得非常有意思,想象一下如果你能够自己做出一款全景拍照的软件,真实地令人激动,当然这全景图像其中的原理就是...角点Harris算子,SUSAN算子, FAST算子。 ...

    一. 图像特征匹配

    最近刚入门了计算机视觉这门课程,觉得非常有意思,想象一下如果你能够自己做出一款全景拍照的软件,真实地令人激动,当然这全景图像其中的原理就是图像的特征匹配,把不同的图片通过相同的局部特征进行拼接,一张拼一张,最后进行一些平衡化处理后就可以得到全景图了。接下来我们就了解一下这其中的部分原理。

    图像的局部特征主要分为以下几类:

    • 角点。Harris算子,SUSAN算子, FAST算子。
    • 梯度特征点。 SIFT、SURF、GLOH、ASIFT、PSIFT算子 等。
    • 边缘特征(线型)。Canny算子, Marr算子。
    • 纹理特征。灰度共生矩阵,小波Gabor算子。

    今天我们要介绍的就是Harris角点检测和特征匹配。

    二. Harris角点检测

    2.1 何为角点

    通常意义上来说,角点就是极值点,即在某方面属性特别突出的点,是在某些属性上强度最大或者最小的孤立点、线段的终点。而对于图像而言,如图所示红点部分,即为图像的角点,其是物体轮廓线的连接点。

    Alt

    那么对于图像的角点判断,我们假想出一个正方形的小窗口,如果小窗口在图像以任意方向进行移动,导致图像灰度的明显变化,那么我们就可以认为小窗口内部包含了“角点”,或者当窗口足够小时,可以认为该窗口就是角点。下面我们通过一组图来了解一下:

    可以看到:
    当窗口位于平坦区时,任意方向移动都没有灰度变化。
    当窗口位于边缘区时,沿边缘方向移动无灰度变化。
    当窗口位于角点时,沿任意方向移动都会有明显的灰度变化。

    2.2. 如何检测角点—Harris算法

    知道的角点的概念与逻辑判断,那如何转化成计算机能够识别的工具?
    人的视觉是具有先天敏感性的,我们可以一眼判断出图像中的所有角点,可以当电脑要识别图像的时候,它们并没有记忆视觉,只能通过严格计算来寻找角点,可见万物离不开数学,因为数学对电脑来说是最友善的朋友了。那么怎么通过数学推理判断角点呢?

    答案是Harris算法。Harris算法使用微分运算和自相关矩阵来进行角点检测,具有运算简单、提取的角点特征均匀合理、性能稳定等特点。

    假设图像像素点(x,y)的灰度为 I(x,y),以像素点为中心的窗口沿 x 和 y 方向分别移动 u 和 v 的灰度强度变化的表达式为:
    Alt其中 E(u,v)是灰度变化,w(x,y) 是窗口函数,一般是高斯函数,所以可以把w(x,y)看做是高斯滤波器。I(x,y)是图像灰度, I(x+u,y+v)是平移后的图像灰度。
    收到泰勒公式的启发,在这里我们可以将 I(x+u,y+v)函数在(x,y)处泰勒展开,为了提高抗干扰的能力并且简化运算,我们取到了一阶导数部分,后面的无穷小小量O(u2+v2)可以忽略,整理得到表达式如下:Alt
    将[ Ixu+Iyv ]展开后整理可以用矩阵表达为:
    Alt
    最后我们可以近似得到E(x,y)的表达式,将其化为二次型后得到:
    Alt
    其中M是一个2X2的矩阵,称为像素点的自相关矩阵,可以由图像的导数求得。M=窗口函数*偏导矩阵,表达式为:

    Alt
    因为u,v是局部微小的移动变量,所以我们对M进行讨论,M是一个2X2的矩阵,M的表达式中与点的位置(x,y)具体强相关性,记M得特征值为λ1,λ2,关于特征值的意义太过抽象,这里就不展开,但是我们可以简单理解为该点的灰度值变化速度,那么a1和a2可以分别看做是x方向和y方向的灰度变化速率,就可以用a1,a2两者的大小关系来进行分类:

    1. 当两个特征值λ1和λ2都偏小的时候,表示窗口沿任意方向移动都会使灰度变化很细微,该点处于图像的平坦区域。
    2. 当λ1>>λ2或者λ1<<λ2时,说明该点向水平(垂直)方向移动时变化会很明显,而向垂直(水平)方向则变化不明显,该点处于图像的边缘区。
    3. 当两个特征值λ1和λ2都很大的时候,表示窗口沿任意方向移动都会使灰度变化很明显,该点位置就是图像角点的位置。

    Alt
    然而在实际中,经常使用的是角点响应函数CRF这一概念,以此更加准确的计算所需角点,方法如下:

    Alt
    det M是矩阵M的行列式,Trace(M)为矩阵M的迹。k为修正值,是一个常数,经验取值为0.04-0.06。算出响应值之后,根据R与阈值T的比较来判断是否为角点。

    1. 当|R|很小时,R<T , 认为该点处于图像的平坦区域。
    2. 当R<0时,R<T , 认为该点处于图像的边缘区。
    3. 当R>0时,R>T, 认为该点位置就是图像角点。

    Alt

    2.3 实现效果

    以上着重介绍了Harris角点检测的原理,下面将进行Harris角点检测与特征匹配的实际操作,我拍了一张我本科大学(集美大学)里的建筑物—延奎图书馆。用python语言实现,代码如下:

    Harris角点检测代码:

    # -*- coding: utf-8 -*-
    from pylab import *
    from PIL import Image
    from PCV.localdescriptors import harris
    
    # 读入图像
    im = array(Image.open('03.png').convert('L'))
    
    # 检测harris角点
    harrisim = harris.compute_harris_response(im)
    
    # Harris响应函数
    harrisim1 = 255 - harrisim
    
    figure()
    gray()
    
    #画出Harris响应图
    subplot(121)
    suptitle("Harris corners")
    imshow(harrisim1)
    print (harrisim1.shape)
    axis('off')
    axis('equal')
    
    threshold = [0.01, 0.05, 0.1]
    for i, thres in enumerate(threshold):
        filtered_coords = harris.get_harris_points(harrisim, 6, thres)
    
    subplot(1, 2, 2)
    imshow(im)
    print (im.shape)
    plot([p[1] for p in filtered_coords], [p[0] for p in filtered_coords], '+c')
    axis('off')
    show()
    

    Harris角点检测效果图:
    在这里插入图片描述
    Harris特征匹配代码:

    from pylab import *
    from PIL import Image
    
    from PCV.localdescriptors import harris
    from PCV.tools.imtools import imresize
    
    """
    This is the Harris point matching example in Figure 2-2.
    """
    
    # Figure 2-2上面的图
    #im1 = array(Image.open("02.jpg").convert("L"))
    #im2 = array(Image.open("../data/crans_2_small.jpg").convert("L"))
    
    # Figure 2-2下面的图
    im1 = array(Image.open("../pic/.png").convert("L"))
    im2 = array(Image.open("../pic/.png").convert("L"))
    
    # resize to make matching faster
    im1 = imresize(im1, (im1.shape[1]/2, im1.shape[0]/2))
    im2 = imresize(im2, (im2.shape[1]/2, im2.shape[0]/2))
    
    wid = 5
    harrisim = harris.compute_harris_response(im1, 5)
    filtered_coords1 = harris.get_harris_points(harrisim, wid+1)
    d1 = harris.get_descriptors(im1, filtered_coords1, wid)
    
    harrisim = harris.compute_harris_response(im2, 5)
    filtered_coords2 = harris.get_harris_points(harrisim, wid+1)
    d2 = harris.get_descriptors(im2, filtered_coords2, wid)
    
    print ('starting matching')
    matches = harris.match_twosided(d1, d2)
    
    figure()
    suptitle("Harris matching")
    gray() 
    harris.plot_matches(im1, im2, filtered_coords1, filtered_coords2, matches)
    show()
    

    Harris特征匹配效果图:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • harris算法检测匹配点,对图像拼接前做好准备
  • Harris角点检测和图像匹配程序,摄影测量课程作业,利用opencv
  • Harris角点检测和特征匹配

    万次阅读 2018-09-11 14:05:55
    二十通过像素值导出的符号特征(如特征、特征线、特征区域)来实现图像配准,因此可以克服利用灰度信息进行图像配准的缺点,主要体现在以下三个方面:(1)利用特征而不是图像灰度信息,大大减少了在匹配过程中...
  • 该算法把角特征和灰度值特征结合起来,定义了一种基于Harris角点的灰度值特征,并充分利用角灰度值以及角周边灰度值和位置信息,然后依据这些信息进行匹配。实验结果表明,该算法不仅速度快,而且对灰度值分布...
  • 这篇文章整理两个图像处理中非常重要的算法,一个是Harris角点检测算法,另一个是SIFT特征匹配算法,这两个算法本质上还是去找图像里面的关键特征,帮助我们后续更好的理解图像以及做各种各样的分析。 由于这两个...
  • 【Opencv】基于Opencv和PCV两种方法的Harris 角检测与匹配【附代码】理解Harris角点检测代码:Harris角点检测1.【opencv版】Harris角点检测2.【PCV版】Harris角点检测与匹配3.【PCV版】Harris匹配 理解Harris角点...
  • Harris是一种高效的点检测算法,但不具备尺度不变性。...最后利用RANSAC剔除错误匹配点实现精确匹配。实验结果表明,该算法对图像存在旋转、缩放、光照及噪声变化有较强的鲁棒性,同时提高了运行效率。
  • 基于 matlab的Harris角点特征检测,角点是图像中一个重要的局部特征,决定了图像中关键区域的形状,体现了图像中重要的特征信号,在目标识别、图像匹配、图像重构等方面有十分重要的意义
  • 基于harris角点匹配的图像配准程序

    热门讨论 2011-04-08 20:06:25
    基于harris角点匹配的图像配准程序 这个程序挺不错的 可以自己学习学习
  • 对于点匹配算法的研究本文主要采用Harris算法提取图像中的点,通过相似测度得到粗匹配点集,然后简单分析了两种提纯匹配点的简单聚类法和视差梯度约束法。1. Harris算法点检测人...
  • harris角点检测(c++)

    2021-05-06 22:37:18
    harris.h #ifndef HARRIS_H_ #define HARRIS_H_ #include <iostream> #include <windows.h> #include <stdio.h> #include <string> #include <conio.h> #include <easyx.h> #...
  • 文章目录【计算机视觉】局部图像描述子:Harris角点检测及匹配1. Harris角点检测器1.1 检测算法的目标与思想1.2 检测算法的数学表达1.3 检测算法代码2. Harris角点匹配2.1 角点匹配过程2.2 角特征描述2.3 归一化互...
  • 本文采用Harris角点的方法来进行特征提取和特征匹配两大部分: 1.Harris角点特征提取:分为函数法和机理法(手工复现法) 2.Harris角点特征匹配:先让两张图片进行特征提取,再将图一和图二的每一个进行做相关运算...
  • 图像特征-harris角点检测 基本原理 R>0 角 R≈0 平坦区域 R<0 边界 总结一下Harris算法流程 获取数据后,计算Ix 和 Iy 整合矩阵,求特征值 比较特征值大小 非极大值抑制NMS,过滤掉不是那么角的 ...
  • Harris角点检测_PPT

    2019-04-25 10:57:42
    Harris角点检测_PPT, 角是图像重要的特征,对图像图形的理解和分析有很重要的作用。角在保留图像图重要特征的同时,可以有效地减少信息的数据量,使其信息的含量很高,有效地提高了计算的速度,有利于图像的可靠...
  • 对两幅图像进行harris角点提取,特征点匹配,进行图像拼接

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,082
精华内容 1,632
关键字:

harris角点匹配