大家好，我是python222_小锋老师，分享一套优质的基于Python的车辆车牌识别系统（PyTorch2卷积神经网络CNN+OpenCV实现） 。
项目简介
本项目提出了一种基于Python的车辆车牌识别系统，利用卷积神经网络（CNN）和OpenCV实现车辆车牌的自动检测与识别。该系统采用PyTorch2框架，通过构建和训练深度学习模型，识别输入图像中的车牌信息。系统主要包括三个模块：车牌检测、字符分割以及字符识别。首先，使用OpenCV对输入图像进行预处理，包括灰度化、去噪、二值化等步骤，增强车牌区域的清晰度与对比度。然后，基于卷积神经网络的深度学习模型对车牌区域进行检测与定位，确保精确地提取出车牌图像。接着，采用字符分割算法将车牌中的字符进行单独提取，并通过CNN模型进行字符识别，最终完成车牌号码的自动输出。该系统通过大量实际图像数据的训练与测试，展示了良好的鲁棒性和较高的识别准确率。实验结果表明，本系统具有较强的适应能力，在复杂背景与不同光照条件下仍能有效识别车牌信息，具有较好的应用前景，尤其在智能交通、车辆管理等领域具有重要的实际意义。
源码下载
链接: pan.baidu.com/s/1eRDoq4b9…
提取码: 1234
相关截图
核心代码
# 车牌字符
import os
import cv2
import numpy as np
import torch
from torchvision import transforms
char_table = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '川', '鄂', '赣', '甘', '贵',
'桂', '黑', '沪', '冀', '津', '京', '吉', '辽', '鲁', '蒙', '闽', '宁', '青', '琼', '陕', '苏', '晋',
'皖', '湘', '新', '豫', '渝', '粤', '云', '藏', '浙']
# 图像预处理
def pre_process(orig_img):
gray_img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2GRAY) # BGR色彩空间转换为灰度图像
cv2.imwrite('process_img/gray_img.jpg', gray_img) # 保存灰度图
blur_img = cv2.blur(gray_img, (3, 3)) # 对灰度图像进行均值模糊，使用3*3的内核来减少图像噪声
cv2.imwrite('process_img/blur_img.jpg', blur_img) # 保存模糊图
# 对模糊图进行sobel算子处理 对模糊图像进行边缘检测处理
# 参数1, 0表示只计算x方向梯度，不计算y方向梯度
# ksize=3表示使用3×3的卷积核进行计算
# cv2.CV_16S表示输出图像的深度为16位有符号整数
sobel_img = cv2.Sobel(blur_img, cv2.CV_16S, 1, 0, ksize=3)
sobel_img = cv2.convertScaleAbs(sobel_img) # 转换为8位图像
cv2.imwrite('process_img/sobel_img.jpg', sobel_img) # 保存sobel图
hsv_img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2HSV) # 获取图像的HSV色彩空间
h, s, v = hsv_img[:, :, 0], hsv_img[:, :, 1], hsv_img[:, :, 2]
# 黄色色调区间[26，34],蓝色色调区间:[100,124]
blue_img = (((h > 26) & (h < 34)) | ((h > 100) & (h < 124))) & (s > 70) & (v > 70)
blue_img = blue_img.astype('float32')
cv2.imwrite('process_img/hsv.jpg', blue_img)
mix_img = np.multiply(sobel_img, blue_img) # 混合图像
cv2.imwrite('process_img/mix.jpg', mix_img)
mix_img = mix_img.astype(np.uint8) # 转换为uint8
ret, binary_img = cv2.threshold(mix_img, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) # 二值化
cv2.imwrite('process_img/binary.jpg', binary_img)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 5)) # 定义一个结构元素 尺寸为21×5
close_img = cv2.morphologyEx(binary_img, cv2.MORPH_CLOSE, kernel) # 对二值图像进行闭运算，可以填充可能的断裂并去除小的物体
cv2.imwrite('process_img/close.jpg', close_img)
return close_img
def list_all_files(root):
files = []
list = os.listdir(root) # 获取目录下的所有文件名
for i in range(len(list)):
path = os.path.join(root, list[i]) # 获取文件绝对路径
if os.path.isfile(path): # 判断是否是文件
files.append(path)
elif os.path.isdir(path): # 递归获取所有文件
files.extend(list_all_files(path))
return files
# 验证检测到的矩阵区域是否符合车牌的尺寸比例和面积特征
def verify_scale(rotate_rect):
error = 0.4 # error为车牌允许的宽高比误差
aspect = 4 # 4.7272 # aspect为期望的车牌宽高比，计算车牌的最小和最大面积。这些值用于过滤掉不符合车牌尺寸的矩形
min_area = 10 * (10 * aspect)
max_area = 150 * (150 * aspect)
# 计算车牌区域的宽高比的最小值和最大值，考虑到了误差范围
min_aspect = aspect * (1 - error)
max_aspect = aspect * (1 + error)
# 宽或高为0，不满足矩形直接返回False
if rotate_rect[1][0] == 0 or rotate_rect[1][1] == 0:
return False
# 计算旋转矩形
r = rotate_rect[1][0] / rotate_rect[1][1]
r = max(r, 1 / r)
area = rotate_rect[1][0] * rotate_rect[1][1] # 计算旋转矩形的面积
if area > min_area and area < max_area and r > min_aspect and r < max_aspect:
return True
return False
# 将检测到的车牌区域从原始图像中正确的裁剪出来，并进行必要的变换以满足后续处理的需求，如车牌矫正
def img_transform(car_rect, image):
img_h, img_w = image.shape[:2] # 获取图片的宽高
rect_w, rect_h = car_rect[1][0], car_rect[1][1] # 获取车牌的宽和高
angle = car_rect[2] # 获取车牌的旋转角度
return_flag = False
if car_rect[2] == 0.0: # 旋转角度为0
return_flag = True
if car_rect[2] == 90.0 and rect_w < rect_h: # 旋转角度为90 并且 宽高比小于1
rect_w, rect_h = rect_h, rect_w
return_flag = True
if return_flag:
"""
从原始图像中裁剪出车牌区域。具体来说：
使用car_rect[0]作为车牌中心点坐标；
根据车牌的宽度rect_w和高度rect_h，计算上下左右边界；
从原图image中截取以该中心点为中心、指定宽高的矩形区域作为车牌图像car_img。
"""
car_img = image[int(car_rect[0][1] - rect_h / 2):int(car_rect[0][1] + rect_h / 2),
int(car_rect[0][0] - rect_w / 2):int(car_rect[0][0] + rect_w / 2)]
return car_img # 将车牌从图片中切割出来
"""
1. 使用`cv2.boxPoints`获取旋转矩形的四个顶点坐标。
2. 初始化四个变量分别用于记录最左、最下、最高和最右的点。
3. 遍历四个顶点，根据坐标更新这四个变量，从而确定矩形的边界点，为后续仿射变换做准备。
"""
car_rect = (car_rect[0], (rect_w, rect_h), angle) # 创建旋转矩阵
box = cv2.boxPoints(car_rect) # 调用函数获取矩形边框的四个点
heigth_point = right_point = [0, 0] # 定义变量保存矩形边框的右上顶点
left_point = low_point = [car_rect[0][0], car_rect[0][1]] # 定义变量保存矩形边框的左下顶点
for point in box:
if left_point[0] > point[0]:
left_point = point
if low_point[1] > point[1]:
low_point = point
if heigth_point[1] < point[1]:
heigth_point = point
if right_point[0] < point[0]:
right_point = point
"""
这段代码用于根据车牌的旋转角度，对图像进行仿射变换以矫正车牌区域。具体步骤如下：
1. 判断角度正负：通过比较左点和右点的纵坐标判断车牌是正角度还是负角度倾斜。
2. 构造目标点：根据倾斜方向调整右上角或左下角点的位置，使车牌变为水平。
3. 生成变换矩阵：使用`cv2.getAffineTransform`计算三点之间的仿射变换矩阵。
4. 执行仿射变换：利用`cv2.warpAffine`将图像展开并裁剪出矫正后的车牌区域。
最终返回的是经过旋转矫正后的车牌图像。
"""
if left_point[1] <= right_point[1]: # 正角度
new_right_point = [right_point[0], heigth_point[1]]
pts1 = np.float32([left_point, heigth_point, right_point])
pts2 = np.float32([left_point, heigth_point, new_right_point]) # 字符只是高度需要改变
M = cv2.getAffineTransform(pts1, pts2)
dst = cv2.warpAffine(image, M, (round(img_w * 2), round(img_h * 2)))
car_img = dst[int(left_point[1]):int(heigth_point[1]), int(left_point[0]):int(new_right_point[0])]
elif left_point[1] > right_point[1]: # 负角度
new_left_point = [left_point[0], heigth_point[1]]
pts1 = np.float32([left_point, heigth_point, right_point])
pts2 = np.float32([new_left_point, heigth_point, right_point]) # 字符只是高度需要改变
M = cv2.getAffineTransform(pts1, pts2)
dst = cv2.warpAffine(image, M, (round(img_w * 2), round(img_h * 2)))
car_img = dst[int(right_point[1]):int(heigth_point[1]), int(new_left_point[0]):int(right_point[0])]
return car_img
def locate_carPlate(orig_img, pred_img):
carPlate_list = []
temp1_orig_copy = orig_img.copy() # 拷贝图片 调试用
temp2_orig_copy = orig_img.copy() # 拷贝图片 调试用
# 从二值图像中查找轮廓的函数
# cv2.RETR_EXTERNAL参数表示只检索最外层轮廓，
# cv2.CHAIN_APPROX_SIMPLE参数表示压缩轮廓的水平、垂直和对角线部分，只保留端点。
# 函数返回轮廓列表contours和层级信息heriachy，用于后续的车牌定位处理。
contours, hierarchy = cv2.findContours(pred_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for i, contour in enumerate(contours):
"""
这段代码的功能是在调试图像上绘制检测到的轮廓。具体来说：
cv2.drawContours()函数用于在temp1_orig_img图像上绘制轮廓
contours是要绘制的轮廓点集
i表示当前绘制第几个轮廓
(0, 255, 255)是绘制的颜色（青色）
2是线条粗细度
这样可以可视化显示所有检测到的车牌候选区域轮廓，便于调试观察。
"""
cv2.drawContours(temp1_orig_copy, contours, i, (0, 0, 255), 2)
"""
获取当前轮廓的最小外接矩形,cv2.minAreaRect()函数会计算能够完全包围轮廓的最小面积矩形，
并返回一个包含矩形中心点坐标、宽度高度和旋转角度的元组，
用于后续的车牌定位和矫正处理。
"""
rotate_rect = cv2.minAreaRect(contour)
if verify_scale(rotate_rect):
# 裁剪车牌并且位置矫正
car_plate = img_transform(rotate_rect, temp2_orig_copy)
cv2.imwrite('process_img/transform_img.jpg', car_plate)
# 调整尺寸为后面CNN车牌识别做准备
car_plate = cv2.resize(car_plate, (car_plate_w, car_plate_h))
cv2.imwrite('process_img/resize_img.jpg', car_plate)
carPlate_list.append(car_plate)
return carPlate_list
# 左右切割
def horizontal_cut_chars(plate):
"""
该函数用于对车牌图像进行水平切割，提取字符区域。主要步骤包括：
1. 计算每列像素点总和；
2. 根据阈值判断字符区域起止位置；
3. 限制字符宽度范围以过滤无效区域；
4. 返回符合条件的字符区域坐标列表。
"""
char_addr_list = []
area_left, area_right, char_left, char_right = 0, 0, 0, 0
img_w = plate.shape[1]
# 获取车牌每列边缘像素点个数
def getColSum(img, col):
sum = 0
for i in range(img.shape[0]):
sum += round(img[i, col] / 255)
return sum;
sum = 0
for col in range(img_w):
sum += getColSum(plate, col)
# 每列边缘像素点必须超过均值的60%才能判断属于字符区域
col_limit = 0 # round(0.6*sum/img_w)
# 每个字符宽度也进行限制
charWid_limit = [round(img_w / 12), round(img_w / 5)]
is_char_flag = False
for i in range(img_w):
colValue = getColSum(plate, i)
if colValue > col_limit:
if is_char_flag == False:
area_right = round((i + char_right) / 2)
area_width = area_right - area_left
char_width = char_right - char_left
if (area_width > charWid_limit[0]) and (area_width < charWid_limit[1]):
char_addr_list.append((area_left, area_right, char_width))
char_left = i
area_left = round((char_left + char_right) / 2)
is_char_flag = True
else:
if is_char_flag == True:
char_right = i - 1
is_char_flag = False
# 手动结束最后未完成的字符分割
if area_right < char_left:
area_right, char_right = img_w, img_w
area_width = area_right - area_left
char_width = char_right - char_left
if (area_width > charWid_limit[0]) and (area_width < charWid_limit[1]):
char_addr_list.append((area_left, area_right, char_width))
return char_addr_list
# 获取字符
def get_chars(car_plate):
img_h, img_w = car_plate.shape[:2]
h_proj_list = [] # 水平投影长度列表
h_temp_len, v_temp_len = 0, 0
h_startIndex, h_end_index = 0, 0 # 水平投影记索引
h_proj_limit = [0.2, 0.8] # 车牌在水平方向得轮廓长度少于20%或多余80%过滤掉
char_imgs = []
"""
这段代码用于对二值化车牌图像进行水平投影分析。
它统计每一行的白色像素数量，记录连续有效投影段，并根据比例过滤掉过短或过长的投影区域，
最终提取出最可能包含字符的水平区域。
"""
# 将二值化的车牌水平投影到Y轴，计算投影后的连续长度，连续投影长度可能不止一段
h_count = [0 for i in range(img_h)]
for row in range(img_h):
temp_cnt = 0
for col in range(img_w):
if car_plate[row, col] == 255:
temp_cnt += 1
h_count[row] = temp_cnt
if temp_cnt / img_w < h_proj_limit[0] or temp_cnt / img_w > h_proj_limit[1]:
if h_temp_len != 0:
h_end_index = row - 1
h_proj_list.append((h_startIndex, h_end_index))
h_temp_len = 0
continue
if temp_cnt > 0:
if h_temp_len == 0:
h_startIndex = row
h_temp_len = 1
else:
h_temp_len += 1
else:
if h_temp_len > 0:
h_end_index = row - 1
h_proj_list.append((h_startIndex, h_end_index))
h_temp_len = 0
# 手动结束最后得水平投影长度累加
if h_temp_len != 0:
h_end_index = img_h - 1
h_proj_list.append((h_startIndex, h_end_index))
"""
这段代码的功能是：
1. 遍历水平投影列表，找出最长的有效投影段（即字符区域）。
2. 若该投影段高度不足图像总高度的50%，则认为未检测到有效车牌字符，直接返回空结果。
3. 否则，截取该区域作为车牌主体部分，并调用[horizontal_cut_chars]函数进一步横向切割出每个字符的边界。
4. 根据字符边界从原图中提取每个字符图像，缩放到统一尺寸后加入结果列表返回。
"""
h_maxIndex, h_maxHeight = 0, 0
for i, (start, end) in enumerate(h_proj_list):
if h_maxHeight < (end - start):
h_maxHeight = (end - start)
h_maxIndex = i
if h_maxHeight / img_h < 0.5:
return char_imgs
chars_top, chars_bottom = h_proj_list[h_maxIndex][0], h_proj_list[h_maxIndex][1]
plates = car_plate[chars_top:chars_bottom + 1, :]
cv2.imwrite('process_img/plate.jpg', plates)
char_addr_list = horizontal_cut_chars(plates)
for i, addr in enumerate(char_addr_list):
char_img = car_plate[chars_top:chars_bottom + 1, addr[0]:addr[1]]
char_img = cv2.resize(char_img, (char_w, char_h))
char_imgs.append(char_img)
return char_imgs
def extract_char(car_plate):
gray_plate = cv2.cvtColor(car_plate, cv2.COLOR_BGR2GRAY) # 转为灰度图
ret, binary_plate = cv2.threshold(gray_plate, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) # 二值化
cv2.imwrite('process_img/binary_plate.jpg', gray_plate)
return get_chars(binary_plate)
# 识别车牌字符
def cnn_recongnize_char(char_img_list, char_model_path):
char_model = torch.load(char_model_path, weights_only=False) # 加载模型
text_list = [] # 识别结果列表
tf = transforms.ToTensor()
for img in char_img_list:
"""
这段代码的功能是：
将图像数据转换为模型输入格式。具体包括：
1. `np.array(img)` - 将PIL图像转换为numpy数组
2. `tf()` - 使用ToTensor变换将numpy数组转换为PyTorch张量
3. `.unsqueeze(0)` - 在第0维添加批次维度，使单张图像变为批次大小为1的张量，符合模型输入要求
"""
input = tf(np.array(img)).unsqueeze(0)
with torch.no_grad(): # 不进行梯度计算
output = char_model(input)
_, predicted = torch.topk(output, 1)
text_list.append(char_table[predicted])
return text_list
if __name__ == '__main__':
car_plate_w, car_plate_h = 136, 36 # 车牌宽高
char_w, char_h = 20, 20 # 字符宽高
char_model_path = "char.pth"
test_images_root = 'images/test/' # 测试图片路径
files = list_all_files(test_images_root)
for file in files:
img = cv2.imread(file) # 读取图片
pred_img = pre_process(img) # 预处理图片
car_plate_list = locate_carPlate(img, pred_img) # 定位车牌
if len(car_plate_list) == 0:
continue
else:
car_plate = car_plate_list[0] # 获取车牌
char_img_list = extract_char(car_plate) # 获取车牌字符
for id in range(len(char_img_list)):
img_name = 'char/char-' + str(id) + '.jpg'
cv2.imwrite(img_name, char_img_list[id])
text = cnn_recongnize_char(char_img_list, char_model_path)
print('识别结果：', text)
