【树莓派开发】02-基于OpenCV的车牌识别处理(LPR)

【说明】：疫情期间比较闲学习了python。LPR这个东西，基于OpenCV已经做过很多遍了，通过这个小项目利用树莓派来熟悉Python编程，而且通过实际操作可以掌握一些具体的细节与技巧，这里我将整个过程碰到问题时，甄选搜集的比较好的链接也一并放在文中。完整项目在GitHub上已经满多了。有几个开源的基于OpenCV的车牌识别项目像OpenALPR、HyperLPR等可以直接下来演示，这里主要参考了文1，文1使用代码中对于车牌定位、字符分割的做法比较通用，核心是用SVM向量机来做字符识别，此外用了tkinter GUI库来搭建了个窗口交互显示，完整性非常好，本文做了简化，直接取摄像头视频流进行处理后显示在窗口上。
本文环境：python2.7（感觉3问题也不大，可以自己改一改）；opencv 3.4.1；树莓派-4；识别距离最少40厘米，直接手画了车牌进行演示，很low，估计换成标准车牌图像测试会提高准确率，而且直接使用了文1中的SVM训练好后模型数据，应该这块改进也能提高识别概率，最终表现是，中文字符的识别率较差，英文与数字较好，数字可以达到90%以上。
网文引用格式：序号-贴名(标注)——作者
GitHub：点击这里下载本项目代码

1- 树莓派实现车牌识别的智能限高杆——eilot_c
2- 树莓派 + OpenALPR >>> 实现车牌识别——Waao666
3- 树莓派开发和车牌识别(HyperLPR)——专业渡劫修仙
4- 我用Python自制了一个精密的车牌识别器！老板给了我两万？亏了吗——空山老师
5- LPRnet轻量级实时车牌识别——You-wh GitHub链接——LPRnet

1. 安装摄像头与水墨指示屏

一、安装摄像头
对树莓派常见的就是用CSI或USB接口来外接摄像头，对于CSI接口，基本可以和买树莓派时一块带着买，也可以买专门的USB接口的摄像头。

二、安装黑白双色墨水屏
我们的HDMI用来输出图像或视频流，一直想去玩一下水墨屏(1.54英寸e-Paper模块)，这次也就顺便用了一块1.54寸SPI口的屏，用来辅助显示一些调试参数，十分小巧，缺点就是贵一些。水墨屏是微雪的，可以直接下载演示示例程序V2。下面的程序是按照树莓派必须的库，可以参考上面示例程序页面的步骤。这块可有可无，但用的话一定要注意刷新显示的频率，不能太高，否则会造成识别时的卡顿，这块墨水屏的整幅图像刷新貌似要2s以上，确实慢。

图1-1.54寸水墨屏

# python2
sudo apt-get update  # 最近做过就不必了
# 下面一般都已经装好了，可以aptitude search packname 一下
sudo apt-get install python-pip
sudo apt-get install python-pil
sudo apt-get install python-numpy
# pip list 查看是否安装所需的py库
sudo pip install RPi.GPIO
sudo pip install spidev
# 官网上直接给了Demo可以直接运行看看接线正常

6- 摄像头模块安装使用——官方教程
7- 树莓派接入USB摄像头——大鹏1987

8- 树莓派搭载微雪电子墨水屏——过关斩将过程全记录！——SIXMOE
9- 树莓派配置文件config.txt详细介绍——不着调的小男生
10- PIL 中的 Image 模块——way_testlife
11- python安装模块如何通过setup.py安装——鸟kkkk

2. 安装OpenCV(3.4.1)

作为一个跨平台的视觉库，OpenCV提供了Python、Ruby、MATLAB等语言的API接口；这里下载的OpenCV的版本是3.4.1，新版本是opencv-4.3.0（2020年4月6号），建议还是用新版本。首先可以直接用python的pip直接安装opencv-python，我完事后才发现了这样真方便，参考文4。下面是使用传统解压安装的方法，之后再按照下面链接里的文1-3安装，对于其他在安装过程中缺失的文件，也可用步骤3里的方法可以解决，也就是从opencv_contrib拓展包里copy需要的文件，如图所示；而对于编译错误的问题，步骤1的最后给出了解决办法，基本上安装碰到的问题基本都能找到解决方法；附带说明opencv_contrib是基本版的拓展，包含了付费或仍在测试算法。OpenCV是C++写的，所以这种方法需要解压后还需要编译，才可以调用执行。

图2-文件缺失Error

12-【手把手教学—超简单】树莓派安装OpenCV 3——Waao666
13- 安装OpenCV时提示缺少boostdesc_bgm.i文件的问题解决方案（附带资源）——AlexWang30
14- 树莓派3B+编译安装opencv 3.4.0 for Python3.5 and Python2 完整教程——矢里昂
15-opencv安装 pip install opencv-python——Lisa_Ren_123
16- OpenCV 官网Releases

3. 编写脚本

有OpenCV的加持，车牌识别过程代码相当精悍，这里额外注意些版本问题，包括使用的OpenCV版本和python版本，这可能会使一些copy的代码报错，耐心改一下就行。我已经看到几个项目中都使用这样的代码，我能找到的来源来自yinghualuowu。

# filename:predict.py
# author:yinghualuowu , zhenghao
# date:04/25/2020
#!/usr/bin/python
# -*- coding: utf-8 -*-
import cv2
import numpy as np
from numpy.linalg import norm
import os
import json
import copy
from PIL import Image, ImageDraw, ImageFontSZ = 20                # 训练图片长宽
MAX_WIDTH = 1000       # 原始图片最大宽度
Min_Area =  2000       # 车牌区域至少的像素面积，车牌在图像中所占的面积显然与距离有关
PROVINCE_START = 1000def imreadex(filename):return cv2.imdecode(np.fromfile(filename, dtype=np.uint8), cv2.IMREAD_COLOR)def point_limit(point):if point[0] < 0:point[0] = 0if point[1] < 0:point[1] = 0# 根据设定的阈值和图片直方图，找出波峰，用于分隔字符
def find_waves(threshold, histogram):up_point = -1  # 上升点is_peak = Falseif histogram[0] > threshold:up_point = 0is_peak = Truewave_peaks = []for i, x in enumerate(histogram):if is_peak and x < threshold:if i - up_point > 2:is_peak = Falsewave_peaks.append((up_point, i))elif not is_peak and x >= threshold:is_peak = Trueup_point = iif is_peak and up_point != -1 and i - up_point > 4:wave_peaks.append((up_point, i))return wave_peaks# 根据找出的波峰，分隔图片，从而得到逐个字符图片
def seperate_card(img, waves):part_cards = []for wave in waves:part_cards.append(img[:, wave[0]:wave[1]])return part_cards# 返回一个列表中出现次数最多的字符串
def findmaxstr(lt):index1 = 0  # 记录出现次数最多的元素下标max = 0     # 记录最大的元素出现次数for i in range(len(lt)):flag = 0              # 记录每一个元素出现的次数for j in range(i + 1, len(lt)):  # 遍历i之后的元素下标if lt[j] == lt[i]:flag += 1  # 每当发现与自己相同的元素，flag+1if flag > max:     # 如果此时元素出现的次数大于最大值，记录此时元素的下标max = flagindex1 = ireturn lt[index1]      # 返回出现最多的元素# cv2解决绘制中文乱码
def cv2ImgAddText(img, text, left, top, textColor=(0, 255, 0), textSize=20):if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))# 创建一个可以在给定图像上绘图的对象draw = ImageDraw.Draw(img)# 字体的格式fontStyle = ImageFont.truetype("lib_E-ink/pic/Font.ttc", textSize, encoding="utf-8")    # 这里换成自己字体文件的目录# 绘制文本draw.text((left, top), text, textColor, font=fontStyle)# 转换回OpenCV格式return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)#================================================================================
# 来自opencv的sample，用于svm训练
def deskew(img):m = cv2.moments(img)if abs(m['mu02']) < 1e-2:return img.copy()skew = m['mu11'] / m['mu02']M = np.float32([[1, skew, -0.5 * SZ * skew], [0, 1, 0]])img = cv2.warpAffine(img, M, (SZ, SZ), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR)return img# 来自opencv的sample，用于svm训练
def preprocess_hog(digits):samples = []for img in digits:gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)mag, ang = cv2.cartToPolar(gx, gy)bin_n = 16bin = np.int32(bin_n * ang / (2 * np.pi))bin_cells = bin[:10, :10], bin[10:, :10], bin[:10, 10:], bin[10:, 10:]mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]hist = np.hstack(hists)# transform to Hellinger kerneleps = 1e-7hist /= hist.sum() + epshist = np.sqrt(hist)hist /= norm(hist) + epssamples.append(hist)return np.float32(samples)#================================================================================
# 不能保证包括所有省份
provinces = ["zh_cuan", "川","zh_e",    "鄂","zh_gan",  "赣","zh_gan1", "甘","zh_gui",  "贵", "zh_gui1","桂","zh_hei",  "黑","zh_hu",   "沪","zh_ji",   "冀","zh_jin",  "津","zh_jing", "京","zh_jl",   "吉","zh_liao", "辽","zh_lu",   "鲁","zh_meng", "蒙","zh_min",  "闽","zh_ning", "宁","zh_qing", "靑","zh_qiong","琼","zh_shan", "陕","zh_su",   "苏","zh_sx",   "晋","zh_wan",  "皖","zh_xiang","湘","zh_xin",  "新","zh_yu",   "豫","zh_yu1",  "渝","zh_yue",  "粤","zh_yun",  "云","zh_zang", "藏","zh_zhe",  "浙"
]class StatModel(object):def load(self, fn):self.model = self.model.load(fn)def save(self, fn):self.model.save(fn)class SVM(StatModel):       # SVM设置def __init__(self, C=1, gamma=0.5):self.model = cv2.ml.SVM_create()self.model.setGamma(gamma)self.model.setC(C)self.model.setKernel(cv2.ml.SVM_RBF)self.model.setType(cv2.ml.SVM_C_SVC)# 训练svmdef train(self, samples, responses):self.model.train(samples, cv2.ml.ROW_SAMPLE, responses)# 字符识别def predict(self, samples):r = self.model.predict(samples)return r[1].ravel()# 将图片识别的函数与属性封装起来
class CardPredictor:def __init__(self):# 车牌识别的部分参数保存在js中，便于根据图片分辨率做调整f = open('config.js')j = json.load(f)for c in j["config"]:print(c)if c["open"]:self.cfg = c.copy()breakelse:raise RuntimeError('没有设置有效配置参数')def __del__(self):self.save_traindata()def train_svm(self):self.model = SVM(C=1, gamma=0.5)        # 识别英文字母和数字self.modelchinese = SVM(C=1, gamma=0.5) # 识别中文if os.path.exists("svm.dat"):self.model.load("svm.dat")else:chars_train = []chars_label = []for root, dirs, files in os.walk("train\\chars2"):if len(os.path.basename(root)) > 1:continueroot_int = ord(os.path.basename(root))for filename in files:filepath = os.path.join(root, filename)digit_img = cv2.imread(filepath)digit_img = cv2.cvtColor(digit_img, cv2.COLOR_BGR2GRAY)chars_train.append(digit_img)# chars_label.append(1)chars_label.append(root_int)chars_train = list(map(deskew, chars_train))chars_train = preprocess_hog(chars_train)# chars_train = chars_train.reshape(-1, 20, 20).astype(np.float32)chars_label = np.array(chars_label)print(chars_train.shape)self.model.train(chars_train, chars_label)if os.path.exists("svmchinese.dat"):self.modelchinese.load("svmchinese.dat")else:chars_train = []chars_label = []for root, dirs, files in os.walk("train\\charsChinese"):if not os.path.basename(root).startswith("zh_"):continuepinyin = os.path.basename(root)index = provinces.index(pinyin) + PROVINCE_START + 1  # 1是拼音对应的汉字for filename in files:filepath = os.path.join(root, filename)digit_img = cv2.imread(filepath)digit_img = cv2.cvtColor(digit_img, cv2.COLOR_BGR2GRAY)chars_train.append(digit_img)# chars_label.append(1)chars_label.append(index)chars_train = list(map(deskew, chars_train))chars_train = preprocess_hog(chars_train)# chars_train = chars_train.reshape(-1, 20, 20).astype(np.float32)chars_label = np.array(chars_label)print(chars_train.shape)self.modelchinese.train(chars_train, chars_label)def save_traindata(self):if not os.path.exists("svm.dat"):self.model.save("svm.dat")if not os.path.exists("svmchinese.dat"):self.modelchinese.save("svmchinese.dat")def accurate_place(self, card_img_hsv, limit1, limit2, color):row_num, col_num = card_img_hsv.shape[:2]xl = col_numxr = 0yh = 0yl = row_num# col_num_limit = self.cfg["col_num_limit"]row_num_limit = self.cfg["row_num_limit"]col_num_limit = col_num * 0.8 if color != "green" else col_num * 0.5  # 绿色有渐变for i in range(row_num):count = 0for j in range(col_num):H = card_img_hsv.item(i, j, 0)S = card_img_hsv.item(i, j, 1)V = card_img_hsv.item(i, j, 2)if limit1 < H <= limit2 and 34 < S and 46 < V:count += 1if count > col_num_limit:if yl > i:yl = iif yh < i:yh = ifor j in range(col_num):count = 0for i in range(row_num):H = card_img_hsv.item(i, j, 0)S = card_img_hsv.item(i, j, 1)V = card_img_hsv.item(i, j, 2)if limit1 < H <= limit2 and 34 < S and 46 < V:count += 1if count > row_num - row_num_limit:if xl > j:xl = jif xr < j:xr = jreturn xl, xr, yh, yldef predict(self, car_pic):# step1-图像缩放if type(car_pic) == type(''):img = imreadex(car_pic)else:img = car_piccv2.imshow("树莓派车牌识别", img)pic_hight, pic_width = img.shape[:2]if pic_width > MAX_WIDTH:resize_rate = MAX_WIDTH / pic_widthimg = cv2.resize(img, (MAX_WIDTH, int(pic_hight * resize_rate)), interpolation=cv2.INTER_AREA)# step2-高斯去噪 & 除掉图像中不会是车牌的区域blur = self.cfg["blur"]if blur > 0:img = cv2.GaussianBlur(img, (blur, blur), 0)  # 图像分辨率调整oldimg = imgimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)       # 图像转灰度图kernel = np.ones((20, 20), np.uint8)img_opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)  # 图像滤波img_opening = cv2.addWeighted(img, 1, img_opening, -1, 0)    # 图像融合# step3-找到图像边缘ret, img_thresh = cv2.threshold(img_opening, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)img_edge = cv2.Canny(img_thresh, 100, 200)     # 边缘检测# 使用开运算和闭运算让图像边缘成为一个整体kernel = np.ones((self.cfg["morphologyr"], self.cfg["morphologyc"]), np.uint8)img_edge1 = cv2.morphologyEx(img_edge, cv2.MORPH_CLOSE, kernel)img_edge2 = cv2.morphologyEx(img_edge1, cv2.MORPH_OPEN, kernel)# step4-查找图像边缘整体形成的矩形区域，可能有很多，车牌就在其中一个矩形区域中image, contours, hierarchy = cv2.findContours(img_edge2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)contours = [cnt for cnt in contours if cv2.contourArea(cnt) > Min_Area]print(u'检测到可能的车牌区域数目：{0:d}'.format(len(contours)))car_contours = []                          # 保存确定的车牌区域oldimg1 = copy.copy(oldimg)                # 拷贝一份for cnt in contours:                       # 逐一排除不是车牌的矩形区域rect = cv2.minAreaRect(cnt)            # 图像区域的最小外接矩形；rect包含中心点坐标，宽高，旋转角度信息area_width, area_height = rect[1]if area_width < area_height:           # 防止图像中车牌竖放的情况area_width, area_height = area_height, area_widthwh_ratio = area_width / area_height   # 要求矩形区域长宽比在2到5.5之间，2到5.5是车牌的长宽比，其余的矩形排除if wh_ratio > 2 and wh_ratio < 5.5:car_contours.append(rect)box = cv2.boxPoints(rect)          # 获取矩形四个顶点，浮点型box = np.int0(box)                 # 取整oldimg = cv2.drawContours(oldimg, [box], 0, (0, 0, 255), 2)   # 框选出识别的车牌cv2.imshow("树莓派车牌识别", oldimg)print(u'精确定位后车牌区域数目：{0:d}'.format(len(car_contours)))# step5-矩形区域可能是倾斜的矩形，需要进行矫正card_imgs = []for rect in car_contours:if rect[2] > -1 and rect[2] < 1:  # 创造角度，使得左、高、右、低拿到正确的值angle = 1else:angle = rect[2]rect = (rect[0], (rect[1][0] + 5, rect[1][1] + 5), angle)   # 扩大范围，避免车牌边缘被排除box = cv2.boxPoints(rect)heigth_point = right_point = [0, 0]left_point = low_point = [pic_width, pic_hight]for point in box:if left_point[0] > point[0]:left_point = pointif low_point[1] > point[1]:low_point = pointif heigth_point[1] < point[1]:heigth_point = pointif right_point[0] < point[0]:right_point = pointif left_point[1] <= right_point[1]:  # 正角度new_right_point = [right_point[0], heigth_point[1]]pts2 = np.float32([left_point, heigth_point, new_right_point])  # 字符只是高度需要改变pts1 = np.float32([left_point, heigth_point, right_point])M = cv2.getAffineTransform(pts1, pts2)                          # 计算变换矩阵dst = cv2.warpAffine(oldimg1, M, (pic_width, pic_hight))        # 进行仿射变换point_limit(new_right_point)point_limit(heigth_point)point_limit(left_point)card_img = dst[int(left_point[1]):int(heigth_point[1]), int(left_point[0]):int(new_right_point[0])]card_imgs.append(card_img)elif left_point[1] > right_point[1]:  # 负角度new_left_point = [left_point[0], heigth_point[1]]pts2 = np.float32([new_left_point, heigth_point, right_point])  # 字符只是高度需要改变pts1 = np.float32([left_point, heigth_point, right_point])M = cv2.getAffineTransform(pts1, pts2)dst = cv2.warpAffine(oldimg1, M, (pic_width, pic_hight))point_limit(right_point)point_limit(heigth_point)point_limit(new_left_point)card_img = dst[int(right_point[1]):int(heigth_point[1]), int(new_left_point[0]):int(right_point[0])]card_imgs.append(card_img)# step6-1-根据车牌颜色定位，用来排除不是车牌的区域，目前只识别蓝、绿、黄车牌colors = []for card_index, card_img in enumerate(card_imgs):            # 对提取的每个车牌区域进行识别green = yello = blue = black = white = 0card_img_hsv = cv2.cvtColor(card_img, cv2.COLOR_BGR2HSV) # 颜色空间转换，由于上一步矫正矩形的原因，有转换失败的可能，if card_img_hsv is None:continuerow_num, col_num = card_img_hsv.shape[:2]card_img_count = row_num * col_num      # 我猜是整个区域的像素点数，瞎猜的哈哈for i in range(row_num):                # 对该车牌区域的每个像素点进行H色度、S饱和度、V亮度的判断for j in range(col_num):H = card_img_hsv.item(i, j, 0)S = card_img_hsv.item(i, j, 1)V = card_img_hsv.item(i, j, 2)if 11 < H <= 34 and S > 34:     # 图片分辨率调整yello += 1elif 35 < H <= 99 and S > 34:   # 图片分辨率调整green += 1elif 99 < H <= 124 and S > 34:  # 图片分辨率调整blue += 1if 0 < H < 180 and 0 < S < 255 and 0 < V < 46:black += 1elif 0 < H < 180 and 0 < S < 43 and 221 < V < 225:white += 1color = "no"limit1 = limit2 = 0if yello * 2 >= card_img_count:  # 某种颜色成分占50%以上color = "yello"limit1 = 11limit2 = 34      # 黄：有的图片有色偏偏绿elif green * 2 >= card_img_count:color = "green"limit1 = 35limit2 = 99      # 绿：有的图片有色偏偏绿elif blue * 2 >= card_img_count:color = "blue"limit1 = 100limit2 = 124     # 蓝：有的图片有色偏偏紫elif black + white >= card_img_count * 0.7:  # TODOcolor = "bw"     # 黑白if limit1 == 0:      # 未检测出颜色，直接跳过该车牌区域，不做进一部处理continuecolors.append(color) # 保存该车牌区域的识别颜色结果print(u'检测到的车牌(编号{0:d})颜色为{1}'.format(card_index+1,color))print(u'|蓝色：{0:.1%}|绿色：{1:.1%}|黄色：{2:.1%}|黑色：{3:.1%}|白色：{4:.1%}|'.format(float(blue)/card_img_count,float(green)/card_img_count,float(yello)/card_img_count, float(black)/card_img_count,float(white)/card_img_count))# step6-2-以下为根据检测出的车牌颜色再定位，缩小边缘非车牌边界xl, xr, yh, yl = self.accurate_place(card_img_hsv, limit1, limit2, color)if yl == yh and xl == xr:continueneed_accurate = Falseif yl >= yh:yl = 0yh = row_numneed_accurate = Trueif xl >= xr:xl = 0xr = col_numneed_accurate = Truecard_imgs[card_index] = card_img[yl:yh, xl:xr] if color != "green" or yl < (yh - yl) // 4 else card_img[yl - (yh - yl) // 4:yh,xl:xr]if need_accurate:  # 可能x或y方向未缩小，需要再试一次card_img = card_imgs[card_index]card_img_hsv = cv2.cvtColor(card_img, cv2.COLOR_BGR2HSV)xl, xr, yh, yl = self.accurate_place(card_img_hsv, limit1, limit2, color)if yl == yh and xl == xr:continueif yl >= yh:yl = 0yh = row_numif xl >= xr:xl = 0xr = col_numcard_imgs[card_index] = card_img[yl:yh, xl:xr] if color != "green" or yl < (yh - yl) // 4 else card_img[yl - (yh - yl) // 4:yh,xl:xr]# step7-以上为车牌定位，以下为车牌字符识别predict_result = []predict_result_group = []LRPresult = Noneroi = Nonecard_color = Nonefor i, color in enumerate(colors):if color in ("blue", "yello", "green"):card_img = card_imgs[i]gray_img = cv2.cvtColor(card_img, cv2.COLOR_BGR2GRAY)if color == "green" or color == "yello":    # 黄、绿车牌字符比背景暗，与蓝车牌刚好相反，所以黄、绿车牌需要反向gray_img = cv2.bitwise_not(gray_img)ret, gray_img = cv2.threshold(gray_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)# step7-1 查找水平直方图波峰，因为处理后文字区域正常都是白色，那么在直方图上就显示为波峰，波峰数目就是字符数目x_histogram = np.sum(gray_img, axis=1)x_min = np.min(x_histogram)x_average = np.sum(x_histogram) / x_histogram.shape[0]x_threshold = (x_min + x_average) / 2wave_peaks = find_waves(x_threshold, x_histogram)if len(wave_peaks) == 0:                          # 正常应该为1，这里为0不正常跳过print(u'查找水平直方图波峰结果异常：{0:d}处(应为1处\n)'.format(len(wave_peaks)))continuewave = max(wave_peaks, key=lambda x: x[1] - x[0]) # 认为水平方向，最大的波峰为车牌区域gray_img = gray_img[wave[0]:wave[1]]# step7-2 查找垂直直方图波峰row_num, col_num = gray_img.shape[:2]gray_img = gray_img[1:row_num - 1]                # 去掉车牌上下边缘1个像素，避免白边影响阈值判断y_histogram = np.sum(gray_img, axis=0)y_min = np.min(y_histogram)y_average = np.sum(y_histogram) / y_histogram.shape[0]y_threshold = (y_min + y_average) / 5             # U和0要求阈值偏小，否则U和0会被分成两半wave_peaks = find_waves(y_threshold, y_histogram)if len(wave_peaks) <= 6:                          # 车牌字符数应为7  赣A 17544print(u'查找垂直直方图波峰结果异常：{0:d}处(应为7处)\n'.format(len(wave_peaks)))continuewave = max(wave_peaks, key=lambda x: x[1] - x[0])max_wave_dis = wave[1] - wave[0]# 判断是否是左侧车牌边缘if wave_peaks[0][1] - wave_peaks[0][0] < max_wave_dis / 3 and wave_peaks[0][0] == 0:wave_peaks.pop(0)# step7-3 组合分离汉字cur_dis = 0for i, wave in enumerate(wave_peaks):if wave[1] - wave[0] + cur_dis > max_wave_dis * 0.6:breakelse:cur_dis += wave[1] - wave[0]if i > 0:wave = (wave_peaks[0][0], wave_peaks[i][1])wave_peaks = wave_peaks[i + 1:]wave_peaks.insert(0, wave)# 去除车牌上的分隔点point = wave_peaks[2]if point[1] - point[0] < max_wave_dis / 3:point_img = gray_img[:, point[0]:point[1]]if np.mean(point_img) < 255 / 5:wave_peaks.pop(2)if len(wave_peaks) <= 6:print(u'查找垂直直方图波峰结果异常：{0:d}处(应为7处)\n'.format(len(wave_peaks)))continuepart_cards = seperate_card(gray_img, wave_peaks)  # 返回分割后的字符区域图像for k in range(25):      # 取25次中的模态for i, part_card in enumerate(part_cards):        # 字符识别if np.mean(part_card) < 255 / 5:              # 可能是固定车牌的铆钉，都抛弃print(u'识别出点状图像')continuepart_card_old = part_cardw = abs(part_card.shape[1] - SZ) // 2part_card = cv2.copyMakeBorder(part_card, 0, 0, w, w, cv2.BORDER_CONSTANT, value=[0, 0, 0])part_card = cv2.resize(part_card, (SZ, SZ), interpolation=cv2.INTER_AREA)# part_card = deskew(part_card)part_card = preprocess_hog([part_card])if i == 0:  # 第一个字符显然是中文resp = self.modelchinese.predict(part_card)charactor = provinces[int(resp[0]) - PROVINCE_START]else:       # 字母与数字resp = self.model.predict(part_card)charactor = chr(resp[0])# 判断最后一个数是否是车牌边缘，假设车牌边缘被认为是1if charactor == "1" and i == len(part_cards) - 1:if part_card_old.shape[0] / part_card_old.shape[1] >= 7:  # 1太细，认为是边缘continuepredict_result.append(charactor)LRPresult = ''.join(predict_result)predict_result_group.append(LRPresult)LRPresult = findmaxstr(predict_result_group)               # 取出出现最多的识别结果finalimg = cv2ImgAddText(oldimg, LRPresult.decode('utf-8'), 50, 50, (0, 0, 255), 40)cv2.imshow("树莓派车牌识别", finalimg)roi = card_imgcard_color = colorbreakreturn LRPresult, roi, card_color  # 识别到的字符、定位的车牌图像、车牌颜色
##================================== FILE END ===================================

最终实现的效果还是符合预期的，花了一周时间终于完成了。在实际运行时还是会有些bug，但总体不影响运行。

图3-车牌识别结果图4-墨水屏显示车牌识别结果

17- 树莓派+摄像头实现对移动物体的检测，对于OpenCV库函数的使用可以参考这里有直接的认识。
18- Vim编辑器的基本使用
19- 使用PyCharm远程调试树莓派python+tkinter程序
20- putty中文显示乱码解决方法
21- Tkinter全功能参考教程
22- 对opencv读取的图片进行像素调整(1080, 1920)
23- python 解决cv2绘制中文乱码——gmHappy

24- 又一个让树莓派开机运行Python脚本的方法
25- 树莓派用服务方式设置开机启动
26- PyCharm+GitHub 上传/下载项目 + 更新代码