【计算机视觉】基于复杂环境下的车牌识别

在【计算机视觉】车牌分割定位识别-CSDN博客中，有人问道："如何提高车牌图像处理和识别的准确性，特别是在复杂环境下，如光照变化、车牌变形和噪声干扰？"是的，在复杂的环境下车牌识别的准确率显得尤为重要，本文将从图像预处理、车牌定位、字符分割、字符识别四个核心环节进行针对性优化，结合传统算法与深度学习技术，应对光照变化、车牌变形、噪声干扰等挑战，并使用Python代码完整展示。

本文用到的图像样例：

二、针对光照变化的优化

光照变化（逆光、强光、阴影、低照度）会导致车牌区域对比度下降、细节丢失，需通过预处理增强图像质量。

1. 光照归一化

直方图均衡化：对车牌区域的灰度图进行直方图均衡化，增强全局对比度。
- 改进：采用自适应直方图均衡化（CLAHE），限制局部对比度放大，避免噪声被增强。
- 公式：对图像分块，每块进行直方图均衡，通过限制对比度阈值 C 控制增益（如 C=2.0）。
同态滤波 ：分离图像的光照分量 （低频）和反射分量（高频，含车牌细节），抑制光照不均。
- 步骤：对图像取对数→傅里叶变换→设计巴特沃斯高通滤波器→逆变换→指数运算。
颜色空间转换：将 RGB 图像转换为对光照不敏感的颜色空间（如 HSV、YCrCb），分离亮度通道（V 通道 / Y 通道）单独处理，保留颜色通道（H/S 或 Cr/Cb）用于后续车牌颜色定位（如蓝底、黄底）。

三、针对车牌变形的优化

车牌变形包括透视畸变 （拍摄角度倾斜）、物理变形（弯曲、褶皱），需通过几何校正恢复正矩形。

1. 车牌定位与角点检测

边缘与轮廓筛选：
- 用 Canny 边缘检测提取图像边缘，结合形态学操作（腐蚀 + 膨胀）去除噪声，保留车牌的矩形轮廓。
- 根据车牌宽高比（标准车牌宽高比约为 3:1）、面积范围筛选候选区域。
角点精确定位：
- 对候选区域用 Harris 角点检测或 Shi-Tomasi 算法提取角点，筛选出 4 个顶点（排除铆钉、边框干扰）。
- 若角点检测不准，可结合霍夫变换检测车牌的上下左右四条边界线，交点即为角点。

2. 透视校正

根据 4 个角点坐标，通过透视变换 将倾斜车牌矫正为正矩形。
- 原理：设原图角点为，目标矩形为 (0,0),(W,0),(W,H),(0,H)，求解变换矩阵 M 并应用于原图：

四、针对噪声干扰的优化

噪声（椒盐噪声、高斯噪声、运动模糊、雨雾遮挡）会破坏字符完整性，需通过去噪与增强恢复细节。

1. 去噪算法

椒盐噪声 ：采用中值滤波（窗口大小 3×3 或 5×5），用窗口内像素的中值替代中心像素，保留边缘。
高斯噪声 ：采用高斯滤波 （平滑噪声）或双边滤波（保留边缘的同时去噪）。
运动模糊 ：通过盲去卷积 或维纳滤波估计模糊核，恢复清晰图像（适用于已知模糊方向的场景，如车辆行驶中的拍摄）。

2. 雨雾去除

对雨雾天气图像，采用暗通道先验算法 ：利用雾天图像中 "非天空区域的局部最小亮度接近 0" 的特性，估计透射率并去除雾效，公式为：

其中 I(x) 为雾图，A 为大气光，t(x) 为透射率，为最小透射率（避免过暗）。

五、车牌字符分割的优化

复杂环境下字符可能粘连、断裂或倾斜，需精准分割单个字符。

1. 预处理

二值化 ：对矫正后的车牌图像，用自适应阈值分割（如 OTSU 算法）处理光照不均，将字符（深色）与背景（浅色）分离。
倾斜校正：通过水平投影法计算字符行的倾斜角度（投影峰值的分布斜率），旋转图像使字符水平对齐。

2. 字符分割

投影法：对二值化图像做垂直投影，根据投影谷值（字符间隙）确定分割点，适用于字符间距均匀的情况。
粘连字符处理：对粘连区域，结合形态学细化（thinning）或距离变换（distance transform）找到粘连处的 "细颈"，作为分割线。
深度学习辅助：用 U-Net 等语义分割模型直接定位单个字符，避免传统方法对粘连、断裂的敏感。

六、字符识别的优化

字符识别需应对模糊、变形、相似字符（如 "0" 与 "O"、"8" 与 "B"）的干扰。

1. 特征提取与分类

传统方法：提取字符的几何特征（如 aspect ratio、孔洞数）、纹理特征（HOG、LBP），结合 SVM 或随机森林分类。
深度学习方法 ：用轻量级 CNN（如 LeNet-5、MobileNet）直接学习字符特征，对变形和模糊更鲁棒。训练时通过数据增强（旋转 ±10°、缩放 0.8-1.2 倍、加噪、模糊）模拟复杂环境，提升泛化能力。

2. 后处理校验

利用车牌规则约束：
- 长度固定（中国车牌为 7 位：省份简称 + 字母 + 5 位字符）。
- 首字符为省份简称（如 "京""沪"），第 2 位为字母，后 5 位为字母 + 数字。
- 用字典匹配过滤无效组合（如第 2 位出现数字则剔除）。
结合上下文：用 RNN 或 CRF（条件随机场）优化序列识别结果，例如对 "苏 A・12345" 中易混淆的 "1" 和 "I"，根据上下文确定正确字符。

七、系统级优化策略

多模态融合：结合可见光图像与红外图像（夜间补光不足时），或毫米波雷达（辅助定位车辆区域，缩小车牌搜索范围）。
动态参数调整：根据环境光强度自动调节相机曝光参数（快门、ISO），减少原始图像的噪声和过曝。
端到端深度学习：用 YOLO-Lite 等轻量模型同时完成车牌定位 + 字符识别，减少多阶段误差累积，适合实时场景（如高速公路 ETC）。

八、Python代码完整展示

python 复制代码

import cv2
import numpy as np
import os
from skimage import io
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import random

# 设置中文显示
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams["axes.unicode_minus"] = False


# 1. 图像预处理（增强亮度与对比度，避免过暗）
def preprocess_image(img, original_img=None):
    """优化预处理：确保图像亮度适中，为后续二值化提供基础"""
    # 转换为HSV空间调整亮度
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    h, s, v = cv2.split(hsv)

    # 亮度自适应调整
    brightness = np.mean(v)
    if brightness < 60:
        v = cv2.add(v, 60 - brightness)  # 低光场景增亮
    elif brightness > 200:
        v = cv2.subtract(v, brightness - 200)  # 高光场景减亮

    # 对比度拉伸（仅当动态范围足够时执行）
    p1, p99 = np.percentile(v, (1, 99))
    if p99 - p1 > 10:
        v = np.clip((v - p1) * 255 / (p99 - p1), 0, 255).astype(np.uint8)

    # 合并HSV通道并转回BGR
    enhanced_hsv = cv2.merge([h, s, v])
    enhanced_img = cv2.cvtColor(enhanced_hsv, cv2.COLOR_HSV2BGR)

    # 轻度去噪（保留字符细节）
    denoised = cv2.GaussianBlur(enhanced_img, (3, 3), 0)
    denoised = cv2.bilateralFilter(denoised, 7, 50, 50)

    return denoised


# 2. 车牌定位与透视校正（优化轮廓筛选，确保ROI有效）
def locate_and_correct_plate(img, original_img=None):
    """车牌定位：通过颜色掩码+轮廓筛选，确保提取有效区域"""
    # 预处理后过暗则回退原始图像
    if np.mean(img) < 30 and original_img is not None:
        print("警告：预处理图像过暗，使用原始图像定位")
        return perspective_correction(original_img)

    # 颜色掩码（蓝/红/黄车牌底色）
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    # 蓝底
    blue_mask = cv2.inRange(hsv, np.array([90, 40, 40]), np.array([140, 255, 255]))
    # 红底（分两段Hue范围）
    red_mask1 = cv2.inRange(hsv, np.array([0, 40, 40]), np.array([15, 255, 255]))
    red_mask2 = cv2.inRange(hsv, np.array([160, 40, 40]), np.array([180, 255, 255]))
    red_mask = cv2.bitwise_or(red_mask1, red_mask2)
    # 黄底
    yellow_mask = cv2.inRange(hsv, np.array([15, 40, 40]), np.array([35, 255, 255]))
    # 合并掩码
    color_mask = cv2.bitwise_or(blue_mask, red_mask)
    color_mask = cv2.bitwise_or(color_mask, yellow_mask)

    # 形态学强化掩码（闭运算填充，开运算去噪）
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_OPEN, kernel, iterations=1)

    # 查找轮廓
    contours, _ = cv2.findContours(color_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if not contours and original_img is not None:
        print("警告：未检测到颜色轮廓，回退原始图像校正")
        return perspective_correction(original_img)

    # 筛选车牌轮廓（宽高比2-5，尺寸>100x40）
    plate_candidates = []
    for cnt in contours:
        x, y, w, h = cv2.boundingRect(cnt)
        aspect_ratio = w / h if h > 0 else 0
        if 2 < aspect_ratio < 5 and w > 100 and h > 40:
            plate_candidates.append((x, y, w, h, aspect_ratio))

    # 无有效候选则回退原始图像
    if not plate_candidates and original_img is not None:
        print("警告：无符合尺寸的车牌，回退原始图像校正")
        return perspective_correction(original_img)

    # 选择最接近3:1宽高比的候选
    if plate_candidates:
        plate_candidates.sort(key=lambda x: abs(x[4] - 3))
        x, y, w, h = plate_candidates[0][:4]
        plate_roi = img[y:y + h, x:x + w]
        return perspective_correction(plate_roi)
    else:
        return perspective_correction(img)


def perspective_correction(img):
    """透视校正：确保输出图像亮度与尺寸合理"""
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (3, 3), 0)
    canny = cv2.Canny(gray, 50, 150)  # 低阈值检测更多边缘

    # 形态学膨胀强化边缘
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
    canny = cv2.morphologyEx(canny, cv2.MORPH_DILATE, kernel, iterations=1)

    # 查找轮廓
    contours, _ = cv2.findContours(canny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if not contours:
        return img

    # 筛选有效轮廓（面积>500，宽高比2-5）
    valid_contours = []
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area > 500:
            x, y, w, h = cv2.boundingRect(cnt)
            aspect_ratio = w / h if h > 0 else 0
            if 2 < aspect_ratio < 5:
                valid_contours.append(cnt)

    if not valid_contours:
        return img

    # 取最大面积轮廓
    largest_contour = max(valid_contours, key=cv2.contourArea)
    perimeter = cv2.arcLength(largest_contour, True)
    approx = cv2.approxPolyDP(largest_contour, 0.03 * perimeter, True)

    # 非四边形则用最小外接矩形
    if len(approx) != 4:
        rect = cv2.minAreaRect(largest_contour)
        box = cv2.boxPoints(rect)
        approx = np.int0(box)
        if len(approx) != 4:
            return img

    # 排序角点（顺时针）
    corners = approx.reshape(4, 2).astype(np.float32)
    sorted_corners = sort_corners(corners)

    # 计算目标尺寸（确保宽高比~3:1，最小尺寸200x60）
    width1 = np.linalg.norm(sorted_corners[0] - sorted_corners[1])
    width2 = np.linalg.norm(sorted_corners[2] - sorted_corners[3])
    max_width = max(int(width1), int(width2))
    height1 = np.linalg.norm(sorted_corners[1] - sorted_corners[2])
    height2 = np.linalg.norm(sorted_corners[3] - sorted_corners[0])
    max_height = max(int(height1), int(height2))

    MIN_WIDTH, MIN_HEIGHT = 200, 60
    target_width = max(MIN_WIDTH, max_width)
    target_height = max(MIN_HEIGHT, max_height)
    # 强制宽高比在2.5-5之间
    if target_width / target_height < 2.5:
        target_width = int(target_height * 3.5)
    elif target_width / target_height > 5:
        target_height = int(target_width / 3.5)

    # 透视变换
    dst = np.array([
        [0, 0],
        [target_width - 1, 0],
        [target_width - 1, target_height - 1],
        [0, target_height - 1]
    ], dtype=np.float32)
    M = cv2.getPerspectiveTransform(sorted_corners, dst)
    corrected = cv2.warpPerspective(img, M, (target_width, target_height))

    # 校正后亮度增强（避免过暗）
    if np.mean(cv2.cvtColor(corrected, cv2.COLOR_BGR2GRAY)) < 50:
        corrected = cv2.add(corrected, 30)

    return corrected


def sort_corners(corners):
    """顺时针排序四边形角点"""
    sorted_sum = sorted(corners, key=lambda p: p[0] + p[1])
    top_left, bottom_right = sorted_sum[0], sorted_sum[-1]
    sorted_diff = sorted(corners, key=lambda p: p[0] - p[1])
    top_right, bottom_left = sorted_diff[-1], sorted_diff[0]
    return np.array([top_left, top_right, bottom_right, bottom_left], dtype=np.float32)


# 3. 字符分割（多重二值化+字符修复，确保无全黑）
def segment_chars(plate_img):
    """字符分割：多策略二值化+修复，保证字符为白色前景"""
    # 转为灰度图
    gray = cv2.cvtColor(plate_img, cv2.COLOR_BGR2GRAY) if len(plate_img.shape) == 3 else plate_img.copy()
    gray = cv2.equalizeHist(gray)  # 增强对比度
    show_image(gray, "增强对比度的灰度图")

    # 多策略二值化（生成6种候选）
    _, otsu_bin = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    _, otsu_bin_inv = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    adap_gauss1 = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                        cv2.THRESH_BINARY, 15, 3)
    adap_gauss1_inv = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                            cv2.THRESH_BINARY_INV, 15, 3)
    adap_gauss2 = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                        cv2.THRESH_BINARY, 21, 4)
    adap_gauss2_inv = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                            cv2.THRESH_BINARY_INV, 21, 4)

    # 评估二值化结果（选择字符最清晰的）
    candidates = [
        (otsu_bin, "OTSU阈值"),
        (otsu_bin_inv, "OTSU阈值反转"),
        (adap_gauss1, "自适应高斯(15,3)"),
        (adap_gauss1_inv, "自适应高斯反转(15,3)"),
        (adap_gauss2, "自适应高斯(21,4)"),
        (adap_gauss2_inv, "自适应高斯反转(21,4)")
    ]

    def evaluate(bin_img):
        """评估二值化质量：白色占比10%-40% + 连通区域5-10个"""
        white_ratio = np.sum(bin_img == 255) / (bin_img.size + 1e-6)
        contours, _ = cv2.findContours(bin_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        valid_cnts = [c for c in contours if cv2.contourArea(c) > 50]
        score = 0
        if 0.1 < white_ratio < 0.4: score += 2
        if 5 <= len(valid_cnts) <= 10: score += 3
        return score

    # 选择得分最高的二值化
    scored = [(evaluate(b), b, name) for b, name in candidates]
    scored.sort(reverse=True, key=lambda x: x[0])
    best_score, binary, bin_method = scored[0]
    show_image(binary, f"最佳二值化（{bin_method}，得分{best_score}）")

    # 强制字符为白色前景
    if np.sum(binary == 255) < binary.size * 0.1:
        binary = cv2.bitwise_not(binary)
        show_image(binary, "反转后二值化（确保字符为白）")

    # 形态学优化（根据字符密度选择操作）
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
    white_ratio = np.sum(binary == 255) / (binary.size + 1e-6)
    if white_ratio < 0.1:
        binary = cv2.morphologyEx(binary, cv2.MORPH_DILATE, kernel, iterations=1)
    elif white_ratio > 0.4:
        binary = cv2.morphologyEx(binary, cv2.MORPH_ERODE, kernel, iterations=1)
    else:
        binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=1)
    show_image(binary, "形态学优化后二值化")

    # 垂直投影分析
    vertical_proj = np.sum(binary, axis=0)
    if np.max(vertical_proj) == 0:
        print("警告：投影无信号，启用备用分割")
        return fallback_segmentation(gray)

    plt.figure(figsize=(10, 3))
    plt.plot(vertical_proj)
    plt.title("垂直投影分布")
    plt.grid(alpha=0.3)
    plt.show()

    # 动态分割阈值
    proj_norm = vertical_proj / np.max(vertical_proj)
    proj_std = np.std(proj_norm)
    threshold = max(0.05, min(0.2, 0.1 + proj_std * 0.3))
    print(f"动态分割阈值: {threshold:.2f}")

    height, width = binary.shape
    chars = []
    start, in_char = 0, False
    min_char_w = max(5, width // 30)
    max_char_w = width // 3
    char_h_thresh = 0.2 * height

    # 滑动窗口分割
    for i in range(width):
        if proj_norm[i] > threshold and not in_char:
            start, in_char = i, True
        elif proj_norm[i] <= threshold and in_char:
            char_w = i - start
            if min_char_w < char_w < max_char_w:
                char_img = binary[:, start:i]
                char_h = np.sum(np.sum(char_img, axis=1) > 0)
                if char_h_thresh < char_h < height:
                    fixed_char = fix_black_char(char_img)  # 修复黑色字符
                    char_img = resize_and_center(fixed_char, (40, 80))
                    chars.append(char_img)
                    show_image(char_img, f"分割字符 {len(chars)}")
            in_char = False
    # 处理最后一个字符
    if in_char:
        char_w = width - start
        if min_char_w < char_w < max_char_w:
            char_img = binary[:, start:]
            char_h = np.sum(np.sum(char_img, axis=1) > 0)
            if char_h_thresh < char_h < height:
                fixed_char = fix_black_char(char_img)
                char_img = resize_and_center(fixed_char, (40, 80))
                chars.append(char_img)

    # 粘连字符分割
    if len(chars) < 7:
        refined = []
        avg_w = width / 7
        for char in chars:
            if char.shape[1] > 1.5 * avg_w:
                dist = cv2.distanceTransform(char, cv2.DIST_L2, 5)
                dist = cv2.normalize(dist, None, 0, 1, cv2.NORM_MINMAX)
                split_pts = np.argsort(np.sum(dist, axis=0))[:2]
                if len(split_pts) > 0 and split_pts[0] > min_char_w and char.shape[1] - split_pts[0] > min_char_w:
                    refined.extend([
                        resize_and_center(char[:, :split_pts[0]], (40, 80)),
                        resize_and_center(char[:, split_pts[0]:], (40, 80))
                    ])
                else:
                    refined.append(char)
            else:
                refined.append(char)
        chars = refined

    # 补全为7个字符
    while len(chars) < 7:
        chars.append(np.zeros((80, 40), dtype=np.uint8))
    if len(chars) > 7:
        chars = chars[:7]

    # 最终修复每个字符
    return [fix_black_char(c) for c in chars]


def fix_black_char(char_img):
    """白色占比<20%则反转"""
    white_pix = np.sum(char_img == 255)
    total_pix = char_img.size
    if white_pix / total_pix < 0.2:
        inverted = cv2.bitwise_not(char_img)
        if np.sum(inverted == 255) / total_pix > 0.2:
            return inverted
    return char_img


def fallback_segmentation(gray_img):
    """备用分割：7等分"""
    print("启用备用分割")
    _, binary = cv2.threshold(gray_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)), iterations=1)
    height, width = binary.shape
    chars = []
    seg_w = max(1, width // 7)
    for i in range(7):
        start = i * seg_w
        end = min((i + 1) * seg_w, width)
        char_img = binary[:, start:end]
        fixed_char = fix_black_char(char_img)
        char_img = resize_and_center(fixed_char, (40, 80))
        chars.append(char_img)
        show_image(char_img, f"备用分割字符 {i + 1}")
    return chars


def resize_and_center(char_img, target_size):
    """字符归一化：统一尺寸并居中，确保白色字符"""
    target_w, target_h = target_size
    h, w = char_img.shape
    if w == 0 or h == 0:
        return np.zeros((target_h, target_w), dtype=np.uint8)

    # 缩放
    scale = min(target_w / w, target_h / h)
    new_w, new_h = int(w * scale), int(h * scale)
    resized = cv2.resize(char_img, (new_w, new_h), interpolation=cv2.INTER_AREA)

    # 居中
    centered = np.zeros((target_h, target_w), dtype=np.uint8)
    x = (target_w - new_w) // 2
    y = (target_h - new_h) // 2
    centered[y:y + new_h, x:x + new_w] = resized

    # 增强过暗字符
    if np.sum(centered == 255) < 50:
        _, centered = cv2.threshold(centered, 100, 255, cv2.THRESH_BINARY)
    return centered


# 4. 字符识别（容错处理：训练失败则用规则识别）
class CharRecognizer:
    def __init__(self):
        self.provinces = '京津冀晋蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼渝川黔云藏陕甘青宁新'
        self.letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        self.digits = '0123456789'
        self.all_chars = self.provinces + self.letters + self.digits
        self.classifier, self.label_encoder = self._train_classifier()

    def _train_classifier(self):
        """训练分类器（容错：失败则返回None）"""
        try:
            X, y = [], []
            for c in self.all_chars:
                for _ in range(50):
                    # 生成随机字符图像（白字黑底）
                    img = np.zeros((64, 32), dtype=np.uint8)
                    pts = random.randint(40, 100)
                    img[np.random.randint(5, 59, pts), np.random.randint(3, 29, pts)] = 255

                    # 加噪声
                    if random.random() < 0.5:
                        noise = np.random.randint(0, 2, (64, 32)) * 255
                        img = np.where(np.random.random((64, 32)) < 0.1, noise, img)

                    # 形态学处理（强制uint8）
                    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, random.choice([(2, 2), (3, 3)]))
                    img = cv2.morphologyEx(img.astype(np.uint8), cv2.MORPH_CLOSE, kernel,
                                           iterations=random.choice([1, 2]))

                    X.append(img.flatten())
                    y.append(c)

            le = LabelEncoder()
            y_encoded = le.fit_transform(y)
            X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)

            clf = SVC(kernel='rbf', C=15, gamma=0.005, probability=True)
            clf.fit(X_train, y_train)
            y_pred = clf.predict(X_test)
            print(f"分类器准确率: {accuracy_score(y_test, y_pred):.2f}")
            return clf, le
        except Exception as e:
            print(f"分类器训练失败: {e}")
            return None, None

    def extract_features(self, char_img):
        """提取HOG+LBP+轮廓特征"""
        resized = cv2.resize(char_img, (32, 64))
        # HOG特征
        hog = cv2.HOGDescriptor((32, 64), (16, 16), (8, 8), (8, 8), 9)
        hog_feat = hog.compute(resized).flatten()
        # LBP特征
        lbp = np.zeros_like(resized)
        h, w = resized.shape
        for i in range(1, h - 1):
            for j in range(1, w - 1):
                center = resized[i, j]
                code = 0
                code |= 1 << 7 if resized[i - 1, j - 1] > center else 0
                code |= 1 << 6 if resized[i - 1, j] > center else 0
                code |= 1 << 5 if resized[i - 1, j + 1] > center else 0
                code |= 1 << 4 if resized[i, j + 1] > center else 0
                code |= 1 << 3 if resized[i + 1, j + 1] > center else 0
                code |= 1 << 2 if resized[i + 1, j] > center else 0
                code |= 1 << 1 if resized[i + 1, j - 1] > center else 0
                code |= 1 << 0 if resized[i, j - 1] > center else 0
                lbp[i, j] = code
        lbp_feat, _ = np.histogram(lbp, bins=256, range=(0, 255), density=True)
        # 轮廓特征
        contours, _ = cv2.findContours(resized, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        cnt_feat = np.zeros(10)
        if contours:
            cnt = max(contours, key=cv2.contourArea)
            area = cv2.contourArea(cnt)
            peri = cv2.arcLength(cnt, True)
            cnt_feat[0] = area / (32 * 64)
            cnt_feat[1] = peri / (2 * (32 + 64)) if peri > 0 else 0
            x, y, w, h = cv2.boundingRect(cnt)
            cnt_feat[2] = w / 32
            cnt_feat[3] = h / 64
        return np.hstack([hog_feat, lbp_feat, cnt_feat])




# 图像显示辅助函数
def show_image(img, title, is_bgr=True, cmap=None):
    plt.figure(figsize=(6, 4))
    if is_bgr and len(img.shape) == 3:
        plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB), cmap=cmap)
    else:
        plt.imshow(img, cmap=cmap if cmap else 'gray')
    plt.title(title)
    plt.axis('off')
    plt.tight_layout()
    plt.show()


# 主函数
def main():
    plate_path = "car3.png"
    original_img = cv2.imread(plate_path, cv2.IMREAD_COLOR)

    # 1. 显示原始图像
    show_image(original_img, "原始车牌图像")

    # 2. 预处理
    processed = preprocess_image(original_img, original_img)
    show_image(processed, "预处理后图像")

    # 3. 车牌定位与校正
    corrected = locate_and_correct_plate(processed, original_img)
    show_image(corrected, "定位校正后图像")

    # 4. 字符分割
    chars = segment_chars(corrected)
    if not chars:
        print("警告：主分割失败，尝试原始ROI分割")
        gray = cv2.cvtColor(original_img, cv2.COLOR_BGR2GRAY)
        h, w = gray.shape
        roi = gray[int(h * 0.6):int(h * 0.9), int(w * 0.3):int(w * 0.7)]
        chars = fallback_segmentation(roi)
        if not chars:
            print("错误：所有分割策略失败")
            return

    # 显示分割结果
    fig, axes = plt.subplots(1, len(chars), figsize=(15, 3))
    fig.suptitle("分割的字符")
    for i, (char, ax) in enumerate(zip(chars, axes)):
        ax.imshow(char, cmap="gray")
        ax.set_title(f"字符 {i + 1}")
        ax.axis("off")
    plt.tight_layout(rect=[0, 0, 1, 0.95])
    plt.show()

    # 5. 保存字符
    save_dir = "result"
    os.makedirs(save_dir, exist_ok=True)
    for i, char in enumerate(chars):
        io.imsave(os.path.join(save_dir, f"char_{i + 1}.png"), char)
        print(f"已保存字符：result/char_{i + 1}.png")


if __name__ == "__main__":
    main()