Python OpenCV 角点检测和特征匹配：使用 Harris 角点检测器和归一化互相关

本代码使用 OpenCV 库在两幅图像中进行角点检测和特征匹配。

步骤：

导入必要的库：

import cv2
import numpy as np
from matplotlib import pyplot as plt

加载图像：

img1 = cv2.imread('1.png')
img2 = cv2.imread('4.png')

使用 Harris 角点检测器检测角点：

gray1 = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
gray1 = np.float32(gray1)
dst1 = cv2.cornerHarris(gray1,2,3,0.04)
img1[dst1>0.1*dst1.max()] = [0,0,255]

gray2 = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)
gray2 = np.float32(gray2)
dst2 = cv2.cornerHarris(gray2,2,23,0.04)
img2[dst2>0.1*dst2.max()] = [0,0,255]

定义函数获取 Harris 角点：

# 从一幅Harris响应图像中返回角点，min_dist为分割角点和图像边界的最少像素数目
def get_harris_points(harrisim,min_dist=10,threshold=0.1):
    # 寻找高于阈值的候选角点
    corner_threshold = harrisim.max() * threshold
    harrisim_t = (harrisim > corner_threshold) * 1
    # 得到候选点的坐标
    coords = np.array(harrisim_t.nonzero()).T
    # 以及它们的 Harris 响应值
    candidate_values = [harrisim[c[0],c[1]] for c in coords]
    # 对候选点按照 Harris 响应值进行排序
    index = np.argsort(candidate_values)[::-1]
    # 将可行点的位置保存到数组中
    allowed_locations = np.zeros(harrisim.shape)
    allowed_locations[min_dist:-min_dist,min_dist:-min_dist] = 1
    # 按照 min_distance 原则，选择最佳 Harris 点
    filtered_coords = []
    for i in index:
        if allowed_locations[coords[i,0],coords[i,1]] == 1:
            filtered_coords.append(coords[i])
            allowed_locations[(coords[i,0]-min_dist):(coords[i,0]+min_dist),
                        (coords[i,1]-min_dist):(coords[i,1]+min_dist)] = 0
    return filtered_coords

定义函数获取特征描述子：

#对于每个返回的点，返回点周围2*wid+1个像素的值（假设选取点的min_distance > wid）
def get_descriptors(image, filtered_coords, wid=5):
    desc = []
    for coords in filtered_coords:
        patch = image[coords[0] - wid:coords[0] + wid + 1,
                coords[1] - wid:coords[1] + wid + 1].flatten()
        desc.append(patch)
    return desc

定义函数进行特征匹配：

#对于第一幅图像中的每个角点描述子，使用归一化互相关，选取它在第二幅图像中的匹配角点
def match(desc1, desc2, threshold=0.5):
    n = len(desc1[0])
    # 点对的距离
    d = -np.ones((len(desc1), len(desc2)))
    for i in range(len(desc1)):
        for j in range(len(desc2)):
            d1 = (desc1[i] - np.mean(desc1[i])) / np.std(desc1[i])
            d2 = (desc2[j] - np.mean(desc2[j])) / np.std(desc2[j])
            ncc_value = sum(d1 * d2) / (n -1)
            if ncc_value > threshold:
                d[i, j] = ncc_value
    ndx = np.argsort(-d)   #从大0到小排序
    matchscores = ndx[:, 0]   #最大一个数的位置坐标
    return matchscores

#两边对称版本的match（）
def match_twosided(desc1, desc2, threshold=0.5):
    matches_12 = match(desc1, desc2, threshold)
    matches_21 = match(desc2, desc1, threshold)
    ndx_12 = np.where(matches_12 >= 0)[0]
    # 去除非对称的匹配
    for n in ndx_12:
        if matches_21[matches_12[n]] != n:
            matches_12[n] = -1
    return matches_12

定义函数拼接两幅图像：

# 返回将两幅图像并排拼接成的一幅新图像
def appendimages(im1, im2):
    row1 = im1.shape[0]
    row2 = im2.shape[0]
    if row1 < row2:
        im1 = np.concatenate((im1, np.zeros((row2 - row1, im1.shape[1],im1.shape[2]))), axis=0)
    elif row1 > row2:
        im2 = np.concatenate((im2, np.zeros((row1 - row2, im2.shape[1],im2.shape[2]))), axis=0)
    return np.concatenate((im1, im2), axis=1)

定义函数绘制匹配结果：

# 显示一幅带有连接匹配之间连线的图片
# 输入：im1，im2（数组图像），locs1，locs2（特征位置），matchscores（match的输出），
def plot_matches(img1, img2, locs1, locs2, matchscores, show_below=False):
    img3 = appendimages(img1, img2)
    if show_below:
        img3 = np.vstack((img3, img3))

    plt.imshow(img3)

    cols1 = img1.shape[1]
    for i, m in enumerate(matchscores):
        if m > 0:
            plt.plot([locs1[i][1], locs2[m][1] + cols1], [locs1[i][0], locs2[m][0]], 'c')
    plt.axis('off')

进行特征匹配并绘制匹配结果：

#cv2.imshow('corners-1',img1)
#cv2.imshow('corners-2',img2)
#cv2.waitKey(0)
#cv2.destroyAllWindows()
if '__main__' == __name__:
 wid=9   #比较像素点数目
 filtered_coords1 = get_harris_points(dst1, wid+1,0.1)   #图1大于阈值的坐标
 filtered_coords2 = get_harris_points(dst2, wid+1,0.1)   #图2大于阈值的坐标
 d1 = get_descriptors(img1, filtered_coords1, wid)
 d2 = get_descriptors(img2, filtered_coords2, wid)
 matches = match_twosided(d1, d2,0.8)                 #图1的阈值点与图二哪个阈值点相关度最高，输出与图一相关性最大点的坐标
 plt.figure(figsize=(30, 20));
 plot_matches(img1, img2,filtered_coords1, filtered_coords2, matches)
 cv2.waitKey()
 cv2.destroyAllWindows()

错误解决：

你提到的错误 Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). 是因为 plt.imshow() 函数期望输入图像的像素值在 [0, 1] 或 [0, 255] 范围内。你需要将你的图像数据归一化到这个范围内。

修改代码： 将以下代码：

plt.imshow(img3)

改为：

plt.imshow(cv2.cvtColor(img3, cv2.COLOR_BGR2RGB)/255.0)

这将使用 OpenCV 的 cvtColor() 函数将图像转换为 RGB 格式，并使用 255.0 进行除法，将像素值归一化到 [0, 1] 范围内。

完成的代码：

import cv2
import numpy as np
from matplotlib import pyplot as plt

img1 = cv2.imread('1.png')
img2 = cv2.imread('4.png')

gray1 = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
gray1 = np.float32(gray1)
dst1 = cv2.cornerHarris(gray1,2,3,0.04)
img1[dst1>0.1*dst1.max()] = [0,0,255]

gray2 = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)
gray2 = np.float32(gray2)
dst2 = cv2.cornerHarris(gray2,2,23,0.04)
img2[dst2>0.1*dst2.max()] = [0,0,255]

# 从一幅Harris响应图像中返回角点，min_dist为分割角点和图像边界的最少像素数目
def get_harris_points(harrisim,min_dist=10,threshold=0.1):
    # 寻找高于阈值的候选角点
    corner_threshold = harrisim.max() * threshold
    harrisim_t = (harrisim > corner_threshold) * 1
    # 得到候选点的坐标
    coords = np.array(harrisim_t.nonzero()).T
    # 以及它们的 Harris 响应值
    candidate_values = [harrisim[c[0],c[1]] for c in coords]
    # 对候选点按照 Harris 响应值进行排序
    index = np.argsort(candidate_values)[::-1]
    # 将可行点的位置保存到数组中
    allowed_locations = np.zeros(harrisim.shape)
    allowed_locations[min_dist:-min_dist,min_dist:-min_dist] = 1
    # 按照 min_distance 原则，选择最佳 Harris 点
    filtered_coords = []
    for i in index:
        if allowed_locations[coords[i,0],coords[i,1]] == 1:
            filtered_coords.append(coords[i])
            allowed_locations[(coords[i,0]-min_dist):(coords[i,0]+min_dist),
                        (coords[i,1]-min_dist):(coords[i,1]+min_dist)] = 0
    return filtered_coords

#对于每个返回的点，返回点周围2*wid+1个像素的值（假设选取点的min_distance > wid）
def get_descriptors(image, filtered_coords, wid=5):
    desc = []
    for coords in filtered_coords:
        patch = image[coords[0] - wid:coords[0] + wid + 1,
                coords[1] - wid:coords[1] + wid + 1].flatten()
        desc.append(patch)
    return desc

#对于第一幅图像中的每个角点描述子，使用归一化互相关，选取它在第二幅图像中的匹配角点
def match(desc1, desc2, threshold=0.5):
    n = len(desc1[0])
    # 点对的距离
    d = -np.ones((len(desc1), len(desc2)))
    for i in range(len(desc1)):
        for j in range(len(desc2)):
            d1 = (desc1[i] - np.mean(desc1[i])) / np.std(desc1[i])
            d2 = (desc2[j] - np.mean(desc2[j])) / np.std(desc2[j])
            ncc_value = sum(d1 * d2) / (n -1)
            if ncc_value > threshold:
                d[i, j] = ncc_value
    ndx = np.argsort(-d)   #从大0到小排序
    matchscores = ndx[:, 0]   #最大一个数的位置坐标
    return matchscores

#两边对称版本的match（）
def match_twosided(desc1, desc2, threshold=0.5):
    matches_12 = match(desc1, desc2, threshold)
    matches_21 = match(desc2, desc1, threshold)
    ndx_12 = np.where(matches_12 >= 0)[0]
    # 去除非对称的匹配
    for n in ndx_12:
        if matches_21[matches_12[n]] != n:
            matches_12[n] = -1
    return matches_12

# 返回将两幅图像并排拼接成的一幅新图像
def appendimages(im1, im2):
    row1 = im1.shape[0]
    row2 = im2.shape[0]
    if row1 < row2:
        im1 = np.concatenate((im1, np.zeros((row2 - row1, im1.shape[1],im1.shape[2]))), axis=0)
    elif row1 > row2:
        im2 = np.concatenate((im2, np.zeros((row1 - row2, im2.shape[1],im2.shape[2]))), axis=0)
    return np.concatenate((im1, im2), axis=1)

# 显示一幅带有连接匹配之间连线的图片
# 输入：im1，im2（数组图像），locs1，locs2（特征位置），matchscores（match的输出），
def plot_matches(img1, img2, locs1, locs2, matchscores, show_below=False):
    img3 = appendimages(img1, img2)
    if show_below:
        img3 = np.vstack((img3, img3))

    plt.imshow(cv2.cvtColor(img3, cv2.COLOR_BGR2RGB)/255.0)  # 归一化像素值

    cols1 = img1.shape[1]
    for i, m in enumerate(matchscores):
        if m > 0:
            plt.plot([locs1[i][1], locs2[m][1] + cols1], [locs1[i][0], locs2[m][0]], 'c')
    plt.axis('off')

#cv2.imshow('corners-1',img1)
#cv2.imshow('corners-2',img2)
#cv2.waitKey(0)
#cv2.destroyAllWindows()
if '__main__' == __name__:
 wid=9   #比较像素点数目
 filtered_coords1 = get_harris_points(dst1, wid+1,0.1)   #图1大于阈值的坐标
 filtered_coords2 = get_harris_points(dst2, wid+1,0.1)   #图2大于阈值的坐标
 d1 = get_descriptors(img1, filtered_coords1, wid)
 d2 = get_descriptors(img2, filtered_coords2, wid)
 matches = match_twosided(d1, d2,0.8)                 #图1的阈值点与图二哪个阈值点相关度最高，输出与图一相关性最大点的坐标
 plt.figure(figsize=(30, 20));
 plot_matches(img1, img2,filtered_coords1, filtered_coords2, matches)
 cv2.waitKey()
 cv2.destroyAllWindows()

现在，代码应该可以正常运行并绘制匹配结果了。

Python OpenCV 角点检测和特征匹配：使用 Harris 角点检测器和归一化互相关