纯NumPy实现图片旋转检测：从原理到代码详解

import numpy as np
from PIL import Image
def load_and_grayscale(image_path):
    """加载图片并转为灰度图，返回numpy数组"""
    # 用PIL加载避免依赖OpenCV
    img = Image.open(image_path)
    # 转为灰度（L模式），再转为numpy数组
    gray_img = img.convert('L')
    return np.array(gray_img, dtype=np.float64)
# 示例使用
img_array = load_and_grayscale("sample.jpg")
print(f"图像形状: {img_array.shape}, 数据类型: {img_array.dtype}")

def simple_denoise_and_enhance(img):
    """简易去噪与对比度增强"""
    # 高斯模糊（手动实现3x3卷积核）
    kernel = np.array([[1, 2, 1],
                       [2, 4, 2],
                       [1, 2, 1]], dtype=np.float64) / 16
    # 边界填充（避免尺寸变化）
    padded = np.pad(img, pad_width=1, mode='reflect')
    denoised = np.zeros_like(img)
    # 手动卷积（演示原理，实际可用scipy.signal.convolve2d加速）
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            region = padded[i:i+3, j:j+3]
            denoised[i, j] = np.sum(region * kernel)
    # 直方图拉伸：将像素值映射到0-255范围
    p2, p98 = np.percentile(denoised, (2, 98))
    enhanced = np.clip((denoised - p2) / (p98 - p2 + 1e-8) * 255, 0, 255)
    return enhanced.astype(np.uint8)
# 应用预处理
processed_img = simple_denoise_and_enhance(img_array)

def analyze_directions(img):
    """分析图像行与列的方向特征"""
    # 计算每行像素均值（得到长度为height的向量）
    row_means = np.mean(img, axis=1)
    # 计算每列像素均值（得到长度为width的向量）
    col_means = np.mean(img, axis=0)
    
    # 计算波动程度：方差越大，说明该方向上明暗变化越丰富，越可能是"主方向"
    row_variance = np.var(row_means)
    col_variance = np.var(col_means)
    
    return {
        'row_variance': row_variance,
        'col_variance': col_variance,
        'row_means': row_means,
        'col_means': col_means
    }

# 对处理后的图像分析
stats = analyze_directions(processed_img)
print(f"行方向波动: {stats['row_variance']:.2f}")
print(f"列方向波动: {stats['col_variance']:.2f}")

import matplotlib.pyplot as plt

def plot_direction_analysis(stats, img):
    """可视化行/列均值分布"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
    
    # 绘制行均值曲线
    ax1.plot(stats['row_means'], label='行均值', color='blue')
    ax1.set_title(f'行方向分析 (方差: {stats["row_variance"]:.2f})')
    ax1.set_xlabel('行号')
    ax1.set_ylabel('平均亮度')
    ax1.grid(True, alpha=0.3)
    
    # 绘制列均值曲线
    ax2.plot(stats['col_means'], label='列均值', color='green')
    ax2.set_title(f'列方向分析 (方差: {stats["col_variance"]:.2f})')
    ax2.set_xlabel('列号')
    ax2.set_ylabel('平均亮度')
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()

# plot_direction_analysis(stats, processed_img)

x' = (x - cx) * cosθ - (y - cy) * sinθ + cx
y' = (x - cx) * sinθ + (y - cy) * cosθ + cy

def rotate_image_numpy(img, angle_deg):
    """用NumPy实现图像旋转（双线性插值简化版）"""
    h, w = img.shape
    center_y, center_x = h / 2, w / 2
    angle_rad = np.radians(angle_deg)
    cos_a, sin_a = np.cos(angle_rad), np.sin(angle_rad)
    
    # 创建输出图像（尺寸略大，避免裁剪）
    new_h, new_w = int(h * 1.4), int(w * 1.4)
    rotated = np.zeros((new_h, new_w), dtype=img.dtype)
    
    # 逆向映射：对输出图每个点，找它在原图的来源
    for y in range(new_h):
        for x in range(new_w):
            # 坐标平移至中心
            dx, dy = x - new_w/2, y - new_h/2
            # 逆向旋转
            src_x = dx * cos_a + dy * sin_a + center_x
            src_y = -dx * sin_a + dy * cos_a + center_y
            
            # 边界检查
            if 0 <= src_x < w and 0 <= src_y < h:
                # 取最近邻像素（简化版，实际可用双线性插值）
                x0, y0 = int(src_x), int(src_y)
                if x0 < w-1 and y0 < h-1:
                    # 简单插值（可选）
                    rotated[y, x] = img[y0, x0]
    
    return rotated

# 测试旋转
rotated_15 = rotate_image_numpy(processed_img, 15)

def direction_score(img, angle):
    """计算指定角度下图像的方向得分（越高越好）"""
    # 先旋转
    rotated = rotate_image_numpy(img, angle)
    # 再分析
    stats = analyze_directions(rotated)
    # 得分 = 行方差 + 列方差（鼓励两个方向都清晰）
    # 或者用 max(row_var, col_var) 更强调主方向
    return max(stats['row_variance'], stats['col_variance'])

# 测试几个角度
angles_to_test = [0, 15, 30, 45, 60, 75, 90]
scores = [direction_score(processed_img, a) for a in angles_to_test]

print("角度 vs 得分:")
for a, s in zip(angles_to_test, scores):
    print(f"{a:2d}° -> {s:.2f}")

def find_optimal_rotation(img, coarse_angles=None, fine_step=1.0):
    """两阶段搜索最优旋转角度"""
    if coarse_angles is None:
        coarse_angles = np.arange(0, 180, 15)  # 粗搜：每15度一个点
    
    # 第一阶段：粗粒度搜索
    coarse_scores = [direction_score(img, a) for a in coarse_angles]
    best_coarse_idx = np.argmax(coarse_scores)
    best_coarse_angle = coarse_angles[best_coarse_idx]
    
    # 第二阶段：在最佳粗角度附近精细搜索
    fine_range = np.arange(
        max(0, best_coarse_angle - 15),
        min(180, best_coarse_angle + 15),
        fine_step
    )
    fine_scores = [direction_score(img, a) for a in fine_range]
    best_fine_idx = np.argmax(fine_scores)
    optimal_angle = fine_range[best_fine_idx]
    
    return {
        'coarse_angle': best_coarse_angle,
        'optimal_angle': optimal_angle,
        'max_score': fine_scores[best_fine_idx],
        'all_angles': fine_range.tolist(),
        'all_scores': fine_scores
    }

# 执行搜索
result = find_optimal_rotation(processed_img)
print(f"检测到最优旋转角度: {result['optimal_angle']:.2f}°")

# 模拟一张轻微旋转的发票（添加人工倾斜）
def create_tilted_invoice():
    """创建测试用倾斜发票图像"""
    # 创建纯色背景
    h, w = 400, 600
    invoice = np.ones((h, w), dtype=np.uint8) * 255
    
    # 添加几行文字（用矩形模拟）
    for i, y in enumerate([100, 150, 200, 250, 300]):
        # 文字行：深色矩形
        cv2.rectangle(invoice, (100, y), (500, y+20), 0, -1)
        # 添加一些干扰线条
        if i % 2 == 0:
            cv2.line(invoice, (50, y+10), (550, y+10), 128, 1)
    
    # 人为添加5.3度旋转（模拟拍摄误差）
    from scipy.ndimage import rotate
    tilted = rotate(invoice, 5.3, reshape=True, mode='constant', cval=255)
    return tilted.astype(np.uint8)

# 生成测试图
test_img = create_tilted_invoice()

# 运行完整流程
processed = simple_denoise_and_enhance(test_img)
result = find_optimal_rotation(processed, fine_step=0.5)

print(f"原始图像：模拟5.3°倾斜")
print(f"算法检测：{result['optimal_angle']:.2f}°")
print(f"误差：{abs(result['optimal_angle'] - 5.3):.2f}°")

# 可视化搜索结果
plt.figure(figsize=(10, 4))
plt.plot(result['all_angles'], result['all_scores'], 'b-o', markersize=3)
plt.axvline(x=result['optimal_angle'], color='r', linestyle='--', 
           label=f'最优角度: {result["optimal_angle"]:.2f}°')
plt.xlabel('旋转角度 (°)')
plt.ylabel('方向得分')
plt.title('角度搜索过程')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def fast_rotation_detection(img, target_size=300):
    """快速版本：先缩放到目标尺寸"""
    h, w = img.shape
    scale = target_size / max(h, w)
    if scale < 1.0:
        new_h, new_w = int(h * scale), int(w * scale)
        # 最近邻缩放（快）
        resized = np.array(Image.fromarray(img).resize((new_w, new_h), Image.NEAREST))
        return find_optimal_rotation(resized, fine_step=2.0)
    else:
        return find_optimal_rotation(img, fine_step=2.0)

# 快速检测
fast_result = fast_rotation_detection(test_img)

def classify_orientation(img):
    """四方向分类：0/90/180/270度"""
    angles = [0, 90, 180, 270]
    scores = [direction_score(img, a) for a in angles]
    best_idx = np.argmax(scores)
    return angles[best_idx], scores[best_idx]

orientation, score = classify_orientation(test_img)
print(f"方向分类：{orientation}° (置信度: {score:.2f})")

def robust_direction_score(img, angle):
    """融合多种特征的鲁棒得分"""
    rotated = rotate_image_numpy(img, angle)
    
    # 特征1：行/列方差比
    stats = analyze_directions(rotated)
    var_ratio = max(stats['row_variance'], stats['col_variance']) / \
                (min(stats['row_variance'], stats['col_variance']) + 1e-8)
    
    # 特征2：梯度能量（简单版）
    grad_x = np.abs(np.diff(rotated, axis=1))
    grad_y = np.abs(np.diff(rotated, axis=0))
    grad_energy = np.mean(grad_x) + np.mean(grad_y)
    
    # 加权综合得分
    return var_ratio * 0.7 + grad_energy * 0.3

# 使用鲁棒得分
robust_result = find_optimal_rotation(test_img, 
                                    fine_step=0.5, 
                                    score_func=robust_direction_score)