import numpy as np
from PIL import Image
def load_and_grayscale(image_path):
    """加載圖片并轉(zhuǎn)為灰度圖，返回numpy數(shù)組"""
    # 用PIL加載避免依賴OpenCV
    img = Image.open(image_path)
    # 轉(zhuǎn)為灰度（L模式），再轉(zhuǎn)為numpy數(shù)組
    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}, 數(shù)據(jù)類型: {img_array.dtype}")

def simple_denoise_and_enhance(img):
    """簡易去噪與對(duì)比度增強(qiáng)"""
    # 高斯模糊（手動(dòng)實(shí)現(xiàn)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)
    # 手動(dòng)卷積（演示原理，實(shí)際可用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)
# 應(yīng)用預(yù)處理
processed_img = simple_denoise_and_enhance(img_array)

def analyze_directions(img):
    """分析圖像行與列的方向特征"""
    # 計(jì)算每行像素均值（得到長度為height的向量）
    row_means = np.mean(img, axis=1)
    # 計(jì)算每列像素均值（得到長度為width的向量）
    col_means = np.mean(img, axis=0)
    
    # 計(jì)算波動(dòng)程度：方差越大，說明該方向上明暗變化越豐富，越可能是"主方向"
    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
    }

# 對(duì)處理后的圖像分析
stats = analyze_directions(processed_img)
print(f"行方向波動(dòng): {stats['row_variance']:.2f}")
print(f"列方向波動(dòng): {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('行號(hào)')
    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('列號(hào)')
    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實(shí)現(xiàn)圖像旋轉(zhuǎn)（雙線性插值簡化版）"""
    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)
    
    # 創(chuàng)建輸出圖像（尺寸略大，避免裁剪）
    new_h, new_w = int(h * 1.4), int(w * 1.4)
    rotated = np.zeros((new_h, new_w), dtype=img.dtype)
    
    # 逆向映射：對(duì)輸出圖每個(gè)點(diǎn)，找它在原圖的來源
    for y in range(new_h):
        for x in range(new_w):
            # 坐標(biāo)平移至中心
            dx, dy = x - new_w/2, y - new_h/2
            # 逆向旋轉(zhuǎn)
            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:
                # 取最近鄰像素（簡化版，實(shí)際可用雙線性插值）
                x0, y0 = int(src_x), int(src_y)
                if x0 < w-1 and y0 < h-1:
                    # 簡單插值（可選）
                    rotated[y, x] = img[y0, x0]
    
    return rotated

# 測(cè)試旋轉(zhuǎn)
rotated_15 = rotate_image_numpy(processed_img, 15)

def direction_score(img, angle):
    """計(jì)算指定角度下圖像的方向得分（越高越好）"""
    # 先旋轉(zhuǎn)
    rotated = rotate_image_numpy(img, angle)
    # 再分析
    stats = analyze_directions(rotated)
    # 得分 = 行方差 + 列方差（鼓勵(lì)兩個(gè)方向都清晰）
    # 或者用 max(row_var, col_var) 更強(qiáng)調(diào)主方向
    return max(stats['row_variance'], stats['col_variance'])

# 測(cè)試幾個(gè)角度
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):
    """兩階段搜索最優(yōu)旋轉(zhuǎn)角度"""
    if coarse_angles is None:
        coarse_angles = np.arange(0, 180, 15)  # 粗搜：每15度一個(gè)點(diǎn)
    
    # 第一階段：粗粒度搜索
    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]
    
    # 第二階段：在最佳粗角度附近精細(xì)搜索
    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
    }

# 執(zhí)行搜索
result = find_optimal_rotation(processed_img)
print(f"檢測(cè)到最優(yōu)旋轉(zhuǎn)角度: {result['optimal_angle']:.2f}°")

# 模擬一張輕微旋轉(zhuǎn)的發(fā)票（添加人工傾斜）
def create_tilted_invoice():
    """創(chuàng)建測(cè)試用傾斜發(fā)票圖像"""
    # 創(chuàng)建純色背景
    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度旋轉(zhuǎn)（模擬拍攝誤差）
    from scipy.ndimage import rotate
    tilted = rotate(invoice, 5.3, reshape=True, mode='constant', cval=255)
    return tilted.astype(np.uint8)

# 生成測(cè)試圖
test_img = create_tilted_invoice()

# 運(yùn)行完整流程
processed = simple_denoise_and_enhance(test_img)
result = find_optimal_rotation(processed, fine_step=0.5)

print(f"原始圖像：模擬5.3°傾斜")
print(f"算法檢測(cè)：{result['optimal_angle']:.2f}°")
print(f"誤差：{abs(result['optimal_angle'] - 5.3):.2f}°")

# 可視化搜索結(jié)果
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'最優(yōu)角度: {result["optimal_angle"]:.2f}°')
plt.xlabel('旋轉(zhuǎn)角度 (°)')
plt.ylabel('方向得分')
plt.title('角度搜索過程')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def fast_rotation_detection(img, target_size=300):
    """快速版本：先縮放到目標(biāo)尺寸"""
    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)

# 快速檢測(cè)
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)
    
    # 加權(quán)綜合得分
    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)