二进制图像非暴力匹配方案及Python代码提速方法咨询

现有一段OpenCV/Numpy代码，通过暴力遍历±10度旋转与±10像素平移，可恢复轻微旋转平移后的二进制图像位姿，结果准确但速度慢1000倍。尝试使用findHomography效果极差，需要在Python环境下将代码提速100-1000倍，或找到能恢复图像5度旋转、(5,7)像素平移的替代匹配方案。实际处理的图像类似随机斑点图（示例图：）。

原暴力遍历代码 #

import cv2
import numpy as np
import random
import math
import time

# 创建带64像素黑边的240x224黑色图像（image01），中间为白色方块
image01 = np.zeros((224, 240), dtype=np.uint8)
image01[64:160, 64:176] = 255  

# 复制image01得到image02
image02 = image01.copy()

# 将image02旋转5度并向上平移5像素、向左平移7像素
rows, cols = image02.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 5, 1)
M[0, 2] -= 7
M[1, 2] -= 5
image02 = cv2.warpAffine(image02, M, (cols, rows))

# 创建缩放后的图像副本（当前缩放因子为1）
scaling_factor = 1/1
img1 = cv2.resize(image01, None, fx=scaling_factor, fy=scaling_factor)
img2s = cv2.resize(image02, None, fx=scaling_factor, fy=scaling_factor)

# 定义搜索参数范围
rotation_range = range(-10, 11, 1)
translation_range = range(-10, 11)

# 存储结果列表
results = []

start = time.time()

for rotation_angle in rotation_range:
    # 旋转img2
    img2 = img2s.copy()
    M_rotation = cv2.getRotationMatrix2D((img2.shape[1] / 2, img2.shape[0] / 2), rotation_angle, 1)
    
    img2_rotated = cv2.warpAffine(img2, M_rotation, (img2.shape[1], img2.shape[0]))

    for dx in translation_range:
        for dy in translation_range:
            # 平移旋转后的图像
            M_translation = np.float32([[1, 0, dx], [0, 1, dy]])
            img2_transformed = cv2.warpAffine(img2_rotated, M_translation, (img2.shape[1], img2.shape[0]))

            # 计算差异像素数
            diff = cv2.absdiff(img1, img2_transformed)
            non_zero_pixels = np.sum(diff[diff == 255])
            
            results.append((rotation_angle, (dx, dy), non_zero_pixels))

print(time.time() - start)
# 按非零像素数排序结果
sorted_results = sorted(results, key=lambda x: x[2])

# 展示前10个结果
for i, (rotation_angle, (dx, dy), non_zero_pixels) in enumerate(sorted_results[:10], 1):
    dx = dx/scaling_factor
    dy = dy/scaling_factor
    print(f"Top {i} - 旋转角度: {rotation_angle}°, 平移量: ({dx}, {dy}), 差异像素数: {non_zero_pixels}")

提速方案与替代匹配方案 #

方案一：傅里叶相位相关法（高效处理小角度旋转+平移） #

针对二进制斑点图，相位相关法可通过频域计算快速定位平移与旋转，速度比暴力遍历快几个数量级。核心逻辑是利用FFT互功率谱的相位信息找匹配峰值，结合极坐标变换处理旋转。

示例代码：

import cv2
import numpy as np

def phase_correlation_translation(img1, img2):
    # 傅里叶变换与互功率谱计算
    f1 = np.fft.fft2(img1)
    f2 = np.fft.fft2(img2)
    cross = f1 * np.conj(f2)
    cross /= np.abs(cross)
    # 逆变换得到相位相关图，找峰值位置
    phase = np.fft.ifft2(cross)
    y, x = np.unravel_index(np.argmax(np.abs(phase)), phase.shape)
    # 转换为实际平移量（处理边界循环）
    x = x - img1.shape[1] if x > img1.shape[1]//2 else x
    y = y - img1.shape[0] if y > img1.shape[0]//2 else y
    return x, y

def phase_correlation_rotation(img1, img2, max_angle=10):
    height, width = img1.shape
    center = (width//2, height//2)
    max_radius = min(center[0], center[1])
    # 生成极坐标网格并转换为笛卡尔坐标
    theta = np.linspace(0, np.pi, 180)
    r = np.linspace(0, max_radius, max_radius)
    r_grid, theta_grid = np.meshgrid(r, theta)
    x_grid = center[0] + r_grid * np.cos(theta_grid)
    y_grid = center[1] + r_grid * np.sin(theta_grid)
    # 极坐标重采样
    img1_polar = cv2.remap(img1, x_grid.astype(np.float32), y_grid.astype(np.float32), cv2.INTER_LINEAR)
    img2_polar = cv2.remap(img2, x_grid.astype(np.float32), y_grid.astype(np.float32), cv2.INTER_LINEAR)
    # 通过相位相关计算旋转角度
    dx, _ = phase_correlation_translation(img1_polar, img2_polar)
    rotation_angle = dx * (max_angle*2/180) - max_angle
    return rotation_angle

# 使用流程
rot_angle = phase_correlation_rotation(img1, img2s)
# 修正旋转
M_rot = cv2.getRotationMatrix2D((img2s.shape[1]//2, img2s.shape[0]//2), -rot_angle, 1)
img2_rot_corrected = cv2.warpAffine(img2s, M_rot, (img2s.shape[1], img2s.shape[0]))
# 计算平移量
dx, dy = phase_correlation_translation(img1, img2_rot_corrected)
print(f"检测结果：旋转{rot_angle:.1f}°，平移({dx}, {dy})")

方案二：暴力遍历针对性优化 #

若需保留暴力思路，可通过以下手段大幅提速：

1. 降采样预处理：先在低分辨率下快速锁定大致范围，再在原分辨率精细搜索；
2. 切片替代warpAffine：用Numpy切片实现平移，避免OpenCV仿射变换的开销；
3. 缓存旋转结果：旋转操作仅执行一次，避免重复计算。

优化后代码示例：

import cv2
import numpy as np
import time

# 原图像生成部分同原代码...

start = time.time()

# 缓存所有旋转后的图像
rotated_imgs = {}
for rot in rotation_range:
    M_rot = cv2.getRotationMatrix2D((img2s.shape[1]/2, img2s.shape[0]/2), rot, 1)
    rotated_imgs[rot] = cv2.warpAffine(img2s, M_rot, (img2s.shape[1], img2s.shape[0]))

best_score = float('inf')
best_params = (0, (0,0))

for rot, img_rot in rotated_imgs.items():
    h, w = img_rot.shape
    for dx in translation_range:
        for dy in translation_range:
            # 用切片实现平移，比warpAffine快数倍
            img_trans = np.zeros_like(img_rot)
            if dx >=0 and dy >=0:
                img_trans[dy:, dx:] = img_rot[:h-dy, :w-dx]
            elif dx <0 and dy >=0:
                img_trans[dy:, :w+dx] = img_rot[:h-dy, -dx:]
            elif dx >=0 and dy <0:
                img_trans[:h+dy, dx:] = img_rot[-dy:, :w-dx]
            else:
                img_trans[:h+dy, :w+dx] = img_rot[-dy:, -dx:]
            # 向量化计算差异像素数
            diff = np.sum(np.abs(img1 - img_trans) == 255)
            if diff < best_score:
                best_score = diff
                best_params = (rot, (dx, dy))

print(time.time() - start)
print(f"最优参数：旋转{best_params[0]}°，平移{best_params[1]}，差异像素{best_score}")

方案三：改进特征点匹配（适配斑点图） #

findHomography效果差是因为普通特征点在二进制斑点图上匹配度低，改用BRISK特征点+汉明距离匹配，配合仿射变换估计（仅处理旋转平移）可解决问题。

示例代码：

import cv2
import numpy as np

# 初始化BRISK特征检测器
brisk = cv2.BRISK_create()
kp1, des1 = brisk.detectAndCompute(img1, None)
kp2, des2 = brisk.detectAndCompute(img2s, None)

# 汉明距离暴力匹配
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = sorted(bf.match(des1, des2), key=lambda x:x.distance)
good_matches = matches[:50]  # 取前50个优质匹配对

# 提取匹配点坐标
pts1 = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)
pts2 = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)

# 计算仅含旋转平移的仿射变换矩阵
M, mask = cv2.estimateAffinePartial2D(pts2, pts1)
rotation_angle = np.arctan2(M[1,0], M[0,0]) * 180 / np.pi
dx, dy = M[0,2], M[1,2]

print(f"检测结果：旋转{rotation_angle:.1f}°，平移({dx:.1f}, {dy:.1f})")

内容的提问来源于stack exchange，提问作者AwokeKnowing