车牌识别-只用opencv的方式-编程知识

项目简述

本文描述如何只使用opencv将车牌中的车牌号提取出来，整个过程大致分为三个过程：车牌定位，车牌号元素分割，模式匹配。

在做完这个实验后，我感触是，只用opencv的方式能使用的场景有限，不如用模型的方式适用的场景广，推荐还是使用模型去做。

下面我分别介绍这三个流程：

本文借鉴了【OpenCV实战】简洁易懂的车牌号识别Python+OpenCV实现“超详解”（含代码）_车牌识别代码-CSDN博客

车牌定位

先定义一些公用的方法：

import cv2
import numpy as np
from matplotlib import pyplot as plt
import os# plt显示彩色图片
def plt_show0(img):
#cv2与plt的图像通道不同：cv2为[b,g,r];plt为[r, g, b]b,g,r = cv2.split(img)img = cv2.merge([r, g, b])plt.imshow(img)plt.show()# plt显示灰度图片
def plt_show_gray(img):plt.imshow(img, cmap='gray')plt.show()# 图像去噪灰度处理
def gray_guss(image):image = cv2.GaussianBlur(image, (3, 3), 0)image_shape = image.shapeif len(image_shape) == 3:gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)return gray_imageelse:return image

车牌灰度化

我们输入的图片

img_path = r'D:\tmp\cv\plate_number\car_3.jpg'
car = cv2.imread(img_path)
blur_car = gray_guss(car)
plt_show_gray(blur_car)

灰度化是为了后面做sobel检测，灰度化的图片是：

sobel检测

Sobel_x = cv2.Sobel(blur_car, cv2.CV_16S, 1, 0)

将数据类型从CV_16S转化到CV_8U, 之所以sobel方法要用16S，是因为sobel在计算过程会产生负值，并且最大值会超过255。

absX = cv2.convertScaleAbs(Sobel_x)

寻找车牌位置

核心思想就是使用车牌的特征来寻找这牌的位置，比如说车牌是长方形（长>宽），车牌一般不会在图片的边缘上（拍照的习惯）等等，因此我们也看到的opecv方式的弊端，泛化能力比较差。

首先进行二值化

image = absX
ret, image = cv2.threshold(image, 0, 255, cv2.THRESH_OTSU)

然后我们使用闭操作，目的是让车牌形成一个白色的长方形，方便我们用车牌特征来匹配车牌的位置。

kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (30, 10))
image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernelX,iterations = 1)

有点儿意思了，但是长方形内部还有些空隙，我们继续处理:

kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 1))
kernelY = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 20))

我们在x方向上做膨胀操作，目的是让白色填充满车牌

image = cv2.dilate(image, kernelX)

在y方向做腐蚀操作，目的是让车牌和其他白色区域分离开，方便后面的轮廓查找

image = cv2.erode(image, kernelX)

然后来一次中值滤波，去掉白色小块，只保留比较大的区域

image = cv2.medianBlur(image, 21)

我们将所有的轮廓画出来，并计算一下面积：

contours, hierarchy = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
car_operator = car.copy()# 将所有区域取出来
data = {}
for index, item in enumerate(contours):rect = cv2.boundingRect(item)x = rect[0]y = rect[1]weight = rect[2]height = rect[3]# 根据轮廓的形状特点，确定车牌的轮廓位置并截取图像# if (weight > (height * 3.5)) and (weight < (height * 4)):# image = car[y:y + height, x:x + weight]# plt_show0(image)area = cv2.contourArea(item)data[index] = {'area': area, 'x':x, 'y':y, 'w':weight, 'h':height}cv2.putText(car_operator, str(area), (x+10, y+height+30), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 0, 255), 3)cv2.rectangle(car_operator, (x, y), (x+weight, y+height), (0,255,0), 2)

根据车牌的特征过滤一下轮廓，我这里只用了面积和位置，你可以增加一些其他特点，让代码具有更前的泛化能力。

result_key = -1
for k in data:# 车牌在图片的中间位置，而不是边缘位置if data[k]['x'] == 0 or data[k]['y'] == 0:print(f"{k} is  at the top or the left, pass.")continue#  if data[k]['y'] + data[k]['h'] >= car_operator.shape[0]:print(f"{k} is  at hte bottom, pass.")continueif data[k]['x'] + data[k]['w'] >= car_operator.shape[1]:print(f"{k} is  at hte right, pass.")continue# 选取区域面积比较大（这个特点有点局限性，在我这个图片中比较合适）if result_key == -1:result_key = kelse:if data[k]['area'] > data[result_key]['area']:result_key = k
result_keyx,y,h,w = data[result_key]['x'],data[result_key]['y'],data[result_key]['h'], data[result_key]['w']
image =  car[y:y + h, x:x + w]

字符分割

字符分割的目的是将车牌中的多个字符分割成单个的字符，这样我们就可以对单个字符做模式匹配或者是用模型来做分类，从而识别单个字符是那个数字或者是那个字符，也或者是那个汉字，我们也就达到了车牌识别的目的。

二值化

首先进行高斯模糊屏蔽掉一些细节，然后再进行二值化

gray_image = gray_guss(image)
ret, gray_image = cv2.threshold(gray_image, 0, 255, cv2.THRESH_OTSU)

找出字符的轮廓

我们对车牌进行开操作，目的让字符和边缘尽可能的分开

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
# gray_image = cv2.dilate(gray_image, kernel)
opening = cv2.morphologyEx(gray_image, cv2.MORPH_OPEN, kernel)

然后进行轮廓查找

img_copy = image.copy()
for item in contours:rect = cv2.boundingRect(item)x = rect[0]y = rect[1]w = rect[2]h = rect[3]cv2.rectangle(img_copy,(x,y),(x+w,y+h),(0,255,0),1)

这里有一个问题，我们可以看到苏被分成两个轮廓了，这样肯定是不能进行匹配的，我试过对车牌进行膨胀操作，但是会导致E和车牌上的螺丝连在一起，最终导致E不能被识别。

这个实验中，我先处理的数字和字母，最后处理的汉字。

把所有的轮廓存储起来：

words = []#对所有轮廓逐一操作
shape = image.shape
for item in contours:word = []rect = cv2.boundingRect(item)x = rect[0]y = rect[1]weight = rect[2]height = rect[3]word.append(x)word.append(y)word.append(weight)word.append(height)words.append(word)
# 排序，车牌号有顺序。words是一个嵌套列表
words = sorted(words,key=lambda s:s[0],reverse=False)

先做一个初步过滤，去掉那些在边缘上的轮廓：

filter_words = []
for item in words:x = item[0]y = item[1]w = item [2]h = item[3]if x == 0:print('x==0', item)continueif y == 0:print('y==0', item)continueif y + h >= shape[0]:print('y+h', item)continueif x + w >= shape[1]:print('x+w', item)continuefilter_words.append(item)
filter_words

查找数字和字母

然后按照字符的长宽比例筛选出字母和数字：

word_images = []
i = 0
success_word = []
#word中存放轮廓的起始点和宽高
for word in filter_words:# 筛选字符的轮廓# 高> 宽*1.5  高< 宽*3.5  高大于25print(word)if (word[3] > (word[2] * 1.5)) and (word[2] > 20 or (word[2] >= 7 and word[3] > 50)):i = i+1print(r'---')splite_image = gray_image[word[1]:word[1] + word[3], word[0]:word[0] + word[2]]word_images.append(splite_image)success_word.append(word)print(i)
# print(words)for i,j in enumerate(word_images):  plt.subplot(1,7,i+1)plt.imshow(word_images[i],cmap='gray')

查找汉字

先切割出汉字

sucess_img = gray_image[:, :x]

然后进行膨胀操作，让苏的两部分连在一起

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
sucess_img = cv2.dilate(sucess_img, kernel)

然后进行轮廓查找

contours, hierarchy = cv2.findContours(sucess_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
img_copy = image.copy()
for item in contours:rect = cv2.boundingRect(item)x = rect[0]y = rect[1]w = rect[2]h = rect[3]cv2.rectangle(img_copy,(x,y),(x+w,y+h),(0,255,0),1)

然后和上文一样，利用长宽特征过滤出有用的轮廓

s_words = []#对所有轮廓逐一操作
shape = image.shape
for item in contours:word = []rect = cv2.boundingRect(item)x = rect[0]y = rect[1]weight = rect[2]height = rect[3]word.append(x)word.append(y)word.append(weight)word.append(height)s_words.append(word)
# 排序，车牌号有顺序。words是一个嵌套列表
s_words = sorted(s_words,key=lambda s:s[0],reverse=False)filter_words = []
for item in s_words:x = item[0]y = item[1]w = item [2]h = item[3]if x == 0:print('x==0', item)continueif y == 0:print('y==0', item)continueif y + h >= shape[0]:print('y+h', item)continueif x + w >= shape[1]:print('x+w', item)continuefilter_words.append(item)

splite_image = gray_image[filter_words[-1][1]:filter_words[-1][1] + filter_words[-1][3], filter_words[-1][0]:filter_words[-1][0] + filter_words[-1][2]]
word_images.insert(0, splite_image)for i,j in enumerate(word_images):  plt.subplot(1,7,i+1)plt.imshow(word_images[i],cmap='gray')
plt.show()

模式匹配

这里需要先获取待匹配的图片，也就是代码中的refer1文件夹，有需要的可以到QQ群中找我要，QQ群地址在文章的最后。

#模版匹配
# 准备模板(template[0-9]为数字模板；)
template = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z','藏','川','鄂','甘','赣','贵','桂','黑','沪','吉','冀','津','晋','京','辽','鲁','蒙','闽','宁','青','琼','陕','苏','皖','湘','新','渝','豫','粤','云','浙']# 读取一个文件夹下的所有图片，输入参数是文件名，返回模板文件地址列表
def read_directory(directory_name):referImg_list = []for filename in os.listdir(directory_name):referImg_list.append(directory_name + "/" + filename)return referImg_list# 获得中文模板列表（只匹配车牌的第一个字符）
def get_chinese_words_list():chinese_words_list = []for i in range(34,64):#将模板存放在字典中c_word = read_directory('./refer1/'+ template[i])chinese_words_list.append(c_word)return chinese_words_list
chinese_words_list = get_chinese_words_list()# 获得英文模板列表（只匹配车牌的第二个字符）
def get_eng_words_list():eng_words_list = []for i in range(10,34):e_word = read_directory('./refer1/'+ template[i])eng_words_list.append(e_word)return eng_words_list
eng_words_list = get_eng_words_list()# 获得英文和数字模板列表（匹配车牌后面的字符）
def get_eng_num_words_list():eng_num_words_list = []for i in range(0,34):word = read_directory('./refer1/'+ template[i])eng_num_words_list.append(word)return eng_num_words_list
eng_num_words_list = get_eng_num_words_list()# 读取一个模板地址与图片进行匹配，返回得分
def template_score(template,image):#将模板进行格式转换template_img=cv2.imdecode(np.fromfile(template,dtype=np.uint8),1)template_img = cv2.cvtColor(template_img, cv2.COLOR_RGB2GRAY)#模板图像阈值化处理——获得黑白图ret, template_img = cv2.threshold(template_img, 0, 255, cv2.THRESH_OTSU)
#     height, width = template_img.shape
#     image_ = image.copy()
#     image_ = cv2.resize(image_, (width, height))image_ = image.copy()#获得待检测图片的尺寸height, width = image_.shape# 将模板resize至与图像一样大小template_img = cv2.resize(template_img, (width, height))# 模板匹配，返回匹配得分result = cv2.matchTemplate(image_, template_img, cv2.TM_CCOEFF)return result[0][0]# 对分割得到的字符逐一匹配
def template_matching(word_images):results = []for index,word_image in enumerate(word_images):if index==0:best_score = []for chinese_words in chinese_words_list:score = []for chinese_word in chinese_words:result = template_score(chinese_word,word_image)score.append(result)best_score.append(max(score))i = best_score.index(max(best_score))# print(template[34+i])r = template[34+i]results.append(r)continueif index==1:best_score = []for eng_word_list in eng_words_list:score = []for eng_word in eng_word_list:result = template_score(eng_word,word_image)score.append(result)best_score.append(max(score))i = best_score.index(max(best_score))# print(template[10+i])r = template[10+i]results.append(r)continueelse:best_score = []for eng_num_word_list in eng_num_words_list:score = []for eng_num_word in eng_num_word_list:result = template_score(eng_num_word,word_image)score.append(result)best_score.append(max(score))i = best_score.index(max(best_score))# print(template[i])r = template[i]results.append(r)continuereturn results

输出结果

word_images_ = word_images.copy()
# 调用函数获得结果
%time result = template_matching(word_images_)
print(result)
# "".join(result)函数将列表转换为拼接好的字符串，方便结果显示
print( "".join(result))