基于Python与OpenCV的车牌识别系统设计与实现

2026年1月5日 互联网

基于Python与OpenCV的车牌识别系统设计与实现

车牌识别（License Plate Recognition, LPR）是计算机视觉领域的重要应用场景，广泛应用于交通管理、停车场系统、智能安防等领域。本文将基于Python与OpenCV库，从零开始构建一个完整的车牌识别系统，涵盖图像预处理、车牌定位、字符分割与识别等核心环节，并提供性能优化建议与实际部署思路。

一、系统架构设计

一个典型的车牌识别系统可分为四个模块：

  1. 图像采集与预处理：获取车辆图像并消除噪声、调整光照
  2. 车牌定位：从复杂背景中定位车牌区域
  3. 字符分割：将车牌区域分割为单个字符
  4. 字符识别：识别分割后的字符并组合成车牌号

系统流程如下图所示：

  1. 原始图像 → 预处理 → 车牌定位 → 字符分割 → 字符识别 → 结果输出

二、环境准备与依赖安装

2.1 开发环境配置

  • Python 3.8+
  • OpenCV 4.5+
  • NumPy 1.20+
  • 其他可选库：scikit-image（图像处理）、Pillow（图像处理）

2.2 依赖安装命令

  1. pip install opencv-python numpy scikit-image pillow

三、核心模块实现

3.1 图像预处理

车牌识别对图像质量要求较高，预处理步骤包括：

  1. 灰度化：减少计算量
  2. 高斯模糊：消除高频噪声
  3. 边缘检测：突出车牌轮廓
  4. 形态学操作：增强车牌区域特征
  1. import cv2
  2. import numpy as np
  4. def preprocess_image(img_path):
  5.     # 读取图像
  6.     img = cv2.imread(img_path)
  7.     if img is None:
  8.         raise ValueError("Image loading failed")
  10.     # 灰度化
  11.     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  13.     # 高斯模糊（核大小5x5）
  14.     blurred = cv2.GaussianBlur(gray, (5, 5), 0)
  16.     # Sobel边缘检测
  17.     sobel = cv2.Sobel(blurred, cv2.CV_8U, 1, 0, ksize=3)
  19.     # 二值化（自适应阈值）
  20.     binary = cv2.threshold(sobel, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)[1]
  22.     # 形态学操作（闭运算连接边缘）
  23.     kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 5))
  24.     closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
  26.     return closed, img

3.2 车牌定位

车牌定位的核心是检测图像中的矩形区域，通常采用以下方法：

  1. 轮廓检测：查找所有闭合轮廓
  2. 长宽比筛选：车牌通常具有固定长宽比（约3:1）
  3. 面积筛选：排除过小或过大的区域
  1. def locate_license_plate(binary_img, original_img):
  2.     # 查找轮廓
  3.     contours, _ = cv2.findContours(binary_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
  5.     candidates = []
  6.     for contour in contours:
  7.         # 计算轮廓最小外接矩形
  8.         rect = cv2.minAreaRect(contour)
  9.         box = cv2.boxPoints(rect)
  10.         box = np.int0(box)
  12.         # 计算矩形宽高比
  13.         width = rect[1][0]
  14.         height = rect[1][1]
  15.         ratio = width / height
  17.         # 筛选条件：长宽比2.5-4，面积>1000像素
  18.         if 2.5 < ratio < 4 and cv2.contourArea(contour) > 1000:
  19.             candidates.append((box, rect))
  21.     if not candidates:
  22.         raise ValueError("No license plate detected")
  24.     # 选择面积最大的候选区域（防止多车牌干扰）
  25.     candidates.sort(key=lambda x: cv2.contourArea(x[0]), reverse=True)
  26.     plate_box, plate_rect = candidates[0]
  28.     # 在原图上绘制定位框
  29.     cv2.drawContours(original_img, [plate_box], -1, (0, 255, 0), 2)
  31.     # 提取车牌区域（旋转校正）
  32.     angle = plate_rect[2]
  33.     if angle < -45:
  34.         angle += 90
  35.     center = plate_rect[0]
  36.     M = cv2.getRotationMatrix2D(center, angle, 1.0)
  37.     rotated = cv2.warpAffine(original_img, M, (original_img.shape[1], original_img.shape[0]))
  39.     # 计算旋转后车牌区域坐标
  40.     box_pts = plate_box.reshape(4, 2)
  41.     rect = cv2.minAreaRect(box_pts)
  42.     width, height = int(rect[1][0]), int(rect[1][1])
  43.     src_pts = box_pts.astype("float32")
  44.     dst_pts = np.array([[0, height-1],
  45.                         [0, 0],
  46.                         [width-1, 0],
  47.                         [width-1, height-1]], dtype="float32")
  49.     M = cv2.getPerspectiveTransform(src_pts, dst_pts)
  50.     warped = cv2.warpPerspective(rotated, M, (width, height))
  52.     return warped, original_img

3.3 字符分割

字符分割的关键是准确找到字符间的间隔，常用方法包括：

  1. 垂直投影法：统计每列的像素值总和
  2. 连通区域分析：检测独立的字符区域
  1. def segment_characters(plate_img):
  2.     # 转换为灰度图并二值化
  3.     gray = cv2.cvtColor(plate_img, cv2.COLOR_BGR2GRAY)
  4.     _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
  6.     # 计算垂直投影
  7.     hist = np.sum(binary, axis=0) / 255
  9.     # 寻找分割点（投影值小于阈值的列）
  10.     threshold = np.mean(hist) * 0.3
  11.     split_points = []
  12.     start = 0
  14.     for i in range(len(hist)):
  15.         if hist[i] < threshold and (i == 0 or hist[i-1] >= threshold):
  16.             start = i
  17.         elif hist[i] >= threshold and (i == 0 or hist[i-1] < threshold):
  18.             if i - start > 5:  # 忽略过小的区域
  19.                 split_points.append((start, i))
  21.     # 提取字符区域
  22.     characters = []
  23.     for (start, end) in split_points:
  24.         char = binary[:, start:end]
  25.         # 调整字符大小（统一为20x20）
  26.         char = cv2.resize(char, (20, 20))
  27.         characters.append(char)
  29.     return characters

3.4 字符识别

字符识别可采用模板匹配或机器学习方法，这里展示基于模板匹配的简单实现：

  1. def recognize_characters(characters):
  2.     # 定义模板字符（需提前准备）
  3.     templates = {
  4.         '0': cv2.imread('templates/0.png', 0),
  5.         '1': cv2.imread('templates/1.png', 0),
  6.         # ... 其他数字和字母模板
  7.     }
  9.     recognized = []
  10.     for char in characters:
  11.         best_score = -1
  12.         best_char = '?'
  14.         for c, template in templates.items():
  15.             # 调整模板大小与字符匹配
  16.             template = cv2.resize(template, (char.shape[1], char.shape[0]))
  17.             res = cv2.matchTemplate(char, template, cv2.TM_CCOEFF_NORMED)
  18.             _, score, _, _ = cv2.minMaxLoc(res)
  20.             if score > best_score:
  21.                 best_score = score
  22.                 best_char = c
  24.         # 设置匹配阈值（0.7）
  25.         if best_score > 0.7:
  26.             recognized.append(best_char)
  27.         else:
  28.             recognized.append('?')
  30.     return ''.join(recognized)

四、完整系统集成

将各模块整合为完整流程：

  1. def license_plate_recognition(img_path):
  2.     try:
  3.         # 1. 图像预处理
  4.         binary_img, original_img = preprocess_image(img_path)
  6.         # 2. 车牌定位
  7.         plate_img, visualized_img = locate_license_plate(binary_img, original_img.copy())
  9.         # 3. 字符分割
  10.         characters = segment_characters(plate_img)
  12.         # 4. 字符识别
  13.         plate_number = recognize_characters(characters)
  15.         # 可视化结果
  16.         cv2.putText(visualized_img, f"Plate: {plate_number}", (10, 30),
  17.                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
  19.         return plate_number, visualized_img
  21.     except Exception as e:
  22.         print(f"Error: {str(e)}")
  23.         return None, None

五、性能优化与实际应用建议

5.1 性能优化方向

  1. 算法优化：

    • 使用更高效的边缘检测算法（如Canny）
    • 替换形态学操作为更轻量的卷积核
    • 采用多线程处理视频流

  2. 硬件加速：

    • 使用GPU加速OpenCV计算
    • 部署到边缘计算设备（如Jetson系列）

  3. 数据增强：

    • 增加训练样本多样性（不同光照、角度）
    • 生成合成车牌数据

5.2 实际应用注意事项

  1. 环境适应性：

    • 夜间场景需增加红外补光
    • 雨雪天气需特殊预处理

  2. 多车牌处理：

    • 修改定位模块以支持多车牌检测
    • 添加车牌跟踪机制减少重复计算

  3. 系统集成：

    • 封装为REST API服务（使用Flask/FastAPI）
    • 部署为Docker容器实现快速扩展

六、进阶方案：结合深度学习

对于更高精度的需求，可替换传统方法为深度学习模型：

  1. 车牌检测：使用YOLOv5/YOLOv8等目标检测模型
  2. 字符识别：采用CRNN（卷积循环神经网络）或Transformer模型
  3. 端到端方案：直接使用LPRNet等专用车牌识别模型

示例（使用预训练模型）：

  1. # 伪代码示例
  2. def deep_learning_lpr(img_path):
  3.     # 加载预训练模型（需提前准备）
  4.     detector = load_yolo_model()
  5.     recognizer = load_crnn_model()
  7.     # 检测车牌位置
  8.     boxes = detector.predict(img_path)
  10.     # 识别字符
  11.     results = []
  12.     for box in boxes:
  13.         plate_img = crop_image(img_path, box)
  14.         text = recognizer.predict(plate_img)
  15.         results.append((box, text))
  17.     return results

七、总结与展望

本文实现的基于Python与OpenCV的车牌识别系统，在标准场景下可达85%以上的识别准确率。实际应用中需根据具体场景调整参数，并考虑结合深度学习模型提升复杂环境下的性能。未来发展方向包括：

  1. 更鲁棒的端到端深度学习模型
  2. 实时视频流处理优化
  3. 与其他交通系统（如ETC）的集成

完整代码与模板数据可在GitHub等平台获取，开发者可根据实际需求进行修改和扩展。

最新文章