0 简介

今天学长向大家介绍一个机器视觉的毕设项目，基于机器视觉的车牌识别

车牌识别系统实现【全网最详细】 - opencv 卷积神经网络 机器学习 深度学习

1 车牌识别原理和流程

车牌识别是基于图像分割和图像识别理论，对含有车辆号牌的图像进行分析处理，从而确定牌照在图像中的位置，并进一步提取和识别出文本字符。

一个典型的车牌识别处理过程包括：图像采集、图像预处理、车牌定位、字符分割、字符识别及结果输出等处理过程。各个处理过程相辅相成，每个处理过程均须保证其高效和较高的抗干扰能力，只有这样才能保证识别功能达到满意的功能品质。

车牌识别系统的实现方式主要分两种，一种为静态图像识别，另一种为动态视频流识别。静态图像识别受限于图像质量、车牌污损度、车牌倾斜度等因素。动态视频流识别则需要更快的识别速度，受限于处理器的性能指标，特别是在移动终端实现车牌实时识别需要更多性能优化。

虽然车牌识别包含6大处理过程，但核心算法主要位于车牌定位、字符分割及字符识别这三个模块中。

1.1 车牌定位

车牌定位的主要工作是从静态图片或视频帧中找到车牌位置，并把车牌从图像中单独分离出来以供后续处理模块处理。车牌定位是影响系统性能的重要因素之一。目前车牌定位的方法很多，但总的来说可以分为两大类：

1.2 基于图形图像学的定位方法。

主要有（1）基于颜色的定位方法，如彩色边缘算法、颜色距离和相似度算法等；（2）基于纹理的定位方法，如小波纹理、水平梯度差分纹理等；（3）基于边缘检测的定位方法；（4）基于数学形态的定位方法。

基于图形图像学的定位方法，容易受到外界干扰信息的干扰而造成定位失败。如基于颜色分析的定位方法中，如果车牌背景颜色与车牌颜色相近，则很难从背景中提取车牌；在基于边缘检测的方法中，车牌边缘的污损也很容易造成定位失败。外界干扰信息的干扰也会欺骗定位算法，使得定位算法生成过多的非车牌候选区域，增大了系统负荷。

1.3 基于机器学习的定位方法。

基于机器学习的方法有基于特征工程的定位方法和基于神经网络的定位方法等。例如我们可以通过opencv提供的基于haar特征的级联分类器，训练一个车牌定位系统。但该方法训练十分费时，分类定位的效率也较低。因此当前在目标定位方面，基于神经网络的方法是主流方法。在基于神经网络的定位方法中，主要采用卷积神经网络学习目标特征。由于卷积神经网络具有平移不变性，在学习过程中可以辅以候选区域，并对候选区域进行分类。正确分类的候选区域即为目标定位的位置。此类方法有较多实现模型，如RCNN、fast erRCNN、SSD等。

1.4 字符分割

字符分割的任务是把多列或多行字符图像中的每个字符从整个图像中切割出来成为单个字符图像。传统字符分割算法可以归纳为以下两类类：直接分割法、基于图像形态学的分割法。直接分割法简单，基于一些先验知识，如车牌字符分布情况等，同时辅助一些基本投影算法实现分割；基于形态学的分割方法使用边缘检测、膨胀腐蚀等处理来确定字符图像位置。传统的字符分割算法同样对外界干扰敏感，如车牌倾斜度、字符污损粘连等。车牌字符的正确分割对字符的识别是很关键的，在分割正确的情况下，才能保证识别的准确率。而随着神经网络理论的不断发展，端到端的图片分类识别技术也有很大突破，因此很多OCR软件逐步摆脱传统字符分割处理，由识别网络对多字符进行直接识别。

1.5 字符识别

字符识别是将包含一个或多个字符的图片中提取字符编码的过程。字符识别的典型方法即基于机器学习的图片分类方法。在图片分类方法中，一幅图片只能输出一个分类，也就是说一幅图片中只能包含一个字符图像。这就要求字符分割有很高的准确率。另一种识别方法即端到端的基于循环神经网络的字符识别方法。该方法将整个车牌图片输入网络，神经网络将直接输出所有字符。端到端的方法直接去除了字符分割过程，免去了字符分割错误带来的稳定性损失，但端到端方法同样对其他干扰如车牌倾斜度比较敏感。

2 基于机器学习的车牌识别

前面的车牌检测和字符分割学长这里就不多复述了，这里着重讲解如何使用机器学习中的支持向量机SVM来进行车牌字符识别。

2.1 支持向量机SVM

SVM是支持向量机（Support Vector Machine）的简称，对于解决小样本、非线性、高维的模式识别问题有很多特有的优势。

简单地讲呢，SVM分类算法的实质就是在样本的特征空间中找到一个最优的超平面，使这个超平面离所有的类的样本的距离最小者最大化。

如下图所示，总共有两类，每类的样本数为五，最优超平面即为可以将两类分开，且两类中离分类面最近的样本与分类面的距离最大。

总而言之： SVM实质上是一个类分类器，是一个能够将不同类样本在样本空间分隔的超平面。

2.2 SVM识别字符

定义

class SVM(StatModel):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 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)

车牌字符数据集如下

这些是字母的训练数据，同样的还有我们车牌的省份简写:

核心代码

predict_result = []roi = 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)#查找水平直方图波峰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:print("peak less 0:")continue#认为水平方向，最大的波峰为车牌区域wave = max(wave_peaks, key=lambda x:x[1]-x[0])gray_img = gray_img[wave[0]:wave[1]]#查找垂直直方图波峰row_num, col_num= gray_img.shape[:2]#去掉车牌上下边缘1个像素，避免白边影响阈值判断gray_img = gray_img[1:row_num-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)#for wave in wave_peaks:# cv2.line(card_img, pt1=(wave[0], 5), pt2=(wave[1], 5), color=(0, 0, 255), thickness=2) #车牌字符数应大于6if len(wave_peaks) <= 6:print("peak less 1:", 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)#组合分离汉字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("peak less 2:", len(wave_peaks))continuepart_cards = seperate_card(gray_img, wave_peaks)for i, part_card in enumerate(part_cards):#可能是固定车牌的铆钉if np.mean(part_card) < 255/5:print("a point")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)roi = card_imgcard_color = colorbreakreturn predict_result, roi, card_color#识别到的字符、定位的车牌图像、车牌颜色

识别结果

3 深度学习字符识别

识别阶段是我们的车牌自动检测与识别系统的最后一个环节，识别是基于前面环节得到的单个字符图像。我们的模型将对这些图像进行预测，从而得到最终的车牌号码。

为了尽可能利用训练数据，我们将每个字符单独切割，得到一个车牌字符数据集，该数据集中包含11个类（数字0-9以及阿拉伯单词），每个类包含30~40张字符图像，图像为28X28的PNG格式。

然后，我们就多层感知器MLP和K近邻分类器KNN的比较进行了一些调研，研究结果标明，对于多层感知器而言，如果隐层的神经元增多，那么分类器的性能就会提高；同样，对于KNN而言，性能也是随着近邻数量的增多而提高。不过由于KNN的可调整潜力要远远小于MLP，因此我们最终选择在这个阶段使用多层感知器MLP网络来识别分割后的车牌字符：

网络结构

关键代码

作者：丹成学长，q746876041#coding=utf-8
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D,MaxPool2D
from keras.optimizers import SGD
from keras import backend as KK.set_image_dim_ordering('tf')import cv2
import numpy as npindex = {"京": 0, "沪": 1, "津": 2, "渝": 3, "冀": 4, "晋": 5, "蒙": 6, "辽": 7, "吉": 8, "黑": 9, "苏": 10, "浙": 11, "皖": 12,"闽": 13, "赣": 14, "鲁": 15, "豫": 16, "鄂": 17, "湘": 18, "粤": 19, "桂": 20, "琼": 21, "川": 22, "贵": 23, "云": 24,"藏": 25, "陕": 26, "甘": 27, "青": 28, "宁": 29, "新": 30, "0": 31, "1": 32, "2": 33, "3": 34, "4": 35, "5": 36,"6": 37, "7": 38, "8": 39, "9": 40, "A": 41, "B": 42, "C": 43, "D": 44, "E": 45, "F": 46, "G": 47, "H": 48,"J": 49, "K": 50, "L": 51, "M": 52, "N": 53, "P": 54, "Q": 55, "R": 56, "S": 57, "T": 58, "U": 59, "V": 60,"W": 61, "X": 62, "Y": 63, "Z": 64,"港":65,"学":66 ,"O":67 ,"使":68,"警":69,"澳":70,"挂":71};chars = ["京", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙", "皖", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂","琼", "川", "贵", "云", "藏", "陕", "甘", "青", "宁", "新", "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","港","学","O","使","警","澳","挂" ];def Getmodel_tensorflow(nb_classes):# nb_classes = len(charset)img_rows, img_cols = 23, 23# number of convolutional filters to usenb_filters = 32# size of pooling area for max poolingnb_pool = 2# convolution kernel sizenb_conv = 3# x = np.load('x.npy')# y = np_utils.to_categorical(range(3062)*45*5*2, nb_classes)# weight = ((type_class - np.arange(type_class)) / type_class + 1) ** 3# weight = dict(zip(range(3063), weight / weight.mean()))  # 调整权重，高频字优先model = Sequential()model.add(Conv2D(32, (5, 5),input_shape=(img_rows, img_cols,1)))model.add(Activation('relu'))model.add(MaxPool2D(pool_size=(nb_pool, nb_pool)))model.add(Dropout(0.25))model.add(Conv2D(32, (3, 3)))model.add(Activation('relu'))model.add(MaxPool2D(pool_size=(nb_pool, nb_pool)))model.add(Dropout(0.25))model.add(Conv2D(512, (3, 3)))# model.add(Activation('relu'))# model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))# model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(512))model.add(Activation('relu'))model.add(Dropout(0.5))model.add(Dense(nb_classes))model.add(Activation('softmax'))model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])return modeldef Getmodel_ch(nb_classes):# nb_classes = len(charset)img_rows, img_cols = 23, 23# number of convolutional filters to usenb_filters = 32# size of pooling area for max poolingnb_pool = 2# convolution kernel sizenb_conv = 3# x = np.load('x.npy')# y = np_utils.to_categorical(range(3062)*45*5*2, nb_classes)# weight = ((type_class - np.arange(type_class)) / type_class + 1) ** 3# weight = dict(zip(range(3063), weight / weight.mean()))  # 调整权重，高频字优先model = Sequential()model.add(Conv2D(32, (5, 5),input_shape=(img_rows, img_cols,1)))model.add(Activation('relu'))model.add(MaxPool2D(pool_size=(nb_pool, nb_pool)))model.add(Dropout(0.25))model.add(Conv2D(32, (3, 3)))model.add(Activation('relu'))model.add(MaxPool2D(pool_size=(nb_pool, nb_pool)))model.add(Dropout(0.25))model.add(Conv2D(512, (3, 3)))# model.add(Activation('relu'))# model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))# model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(756))model.add(Activation('relu'))model.add(Dropout(0.5))model.add(Dense(nb_classes))model.add(Activation('softmax'))model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])return modelmodel  = Getmodel_tensorflow(65)
#构建网络model_ch = Getmodel_ch(31)model_ch.load_weights("./model/char_chi_sim.h5")
# model_ch.save_weights("./model/char_chi_sim.h5")
model.load_weights("./model/char_rec.h5")
# model.save("./model/char_rec.h5")def SimplePredict(image,pos):image = cv2.resize(image, (23, 23))image = cv2.equalizeHist(image)image = image.astype(np.float) / 255image -= image.mean()image = np.expand_dims(image, 3)if pos!=0:res = np.array(model.predict(np.array([image]))[0])else:res = np.array(model_ch.predict(np.array([image]))[0])zero_add = 0 ;if pos==0:res = res[:31]elif pos==1:res = res[31+10:65]zero_add = 31+10else:res = res[31:]zero_add = 31max_id = res.argmax()return res.max(),chars[max_id+zero_add],max_id+zero_add

识别效果

4 算法优化和创新 (车牌倾斜校正)

在车牌识别系统中， 车牌字符能够正确分割的前提是车牌图像能够水平，以至于水平投影和垂直投影能够正常进行。如果车牌倾斜没有矫正，那么水平投影和垂直投影，甚至铆钉都无法正常处理。所以，当车辆信息中获取车牌的第一步，应该是检查倾斜角度，做倾斜矫正。

原车牌图像为（从车牌图像中，可以看到车牌有倾斜角度）：

获取车牌在车辆中的粗略位置（可以用多种方法，这里暂不分析）

提取车牌整体图片数据， 根据第一步结果，提取出，车牌在辆大体位置信息。

关于车牌定位，我使用两部，第一步粗略定位，然后做一些预处理，比如倾斜矫正，然后第二部才是精确定位，只提取车牌的位置信息图像

利用HSV颜色空间转换，获取车牌背景蓝色区域位置，获取车牌粗略信息图像后，由于车牌背景颜色与周围颜色有很明显的区别，这里采用HSV颜色过滤的方法，过滤绿色背景图像

水平膨胀， 水平膨胀的目的，是为了边缘检测，只要求检测边缘，尽量除去字符信息，也可以降低hough变换的运算量

水平差分运算，相当于 边缘检测，经过上面的处理后，才进行边缘检测

这个时候就可以利用hough变换检测直线了。

由于hough变换运算量十分大，所以，尽量减少图像中的白点，来降低计算量，因此前面才做了这么多步骤。

请看下图的红线，就是检测出来的角度，为177度（Hough代码在下面）。

利用旋转算法，旋转刚才粗略提取的车牌位置，尽管旋转后的车牌有些锯齿，但是已经能够保证水平，就可以使用水平投影和垂直投影了

这是旋转后的车牌，有些锯齿出现，由于图像分辨率较低，就没有用差值运算。

精确提取车牌

正常分割字符

识别结果

5 GUI交互界面代码分享

界面代码展示

# 作者：丹成学长，q746876041
import tkinter as tk
from tkinter.filedialog import *
from tkinter import ttk
import img_function as predict
import cv2
from PIL import Image, ImageTk
import threading
import time
import img_math
import traceback
import debug
import config
from threading import Threadclass ThreadWithReturnValue(Thread):def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None):Thread.__init__(self, group, target, name, args, kwargs, daemon=daemon)self._return1 = Noneself._return2 = Noneself._return3 = Nonedef run(self):if self._target is not None:self._return1,self._return2,self._return3 = self._target(*self._args, **self._kwargs)def join(self):Thread.join(self)return self._return1,self._return2,self._return3class Surface(ttk.Frame):pic_path = ""viewhigh = 600viewwide = 600update_time = 0thread = Nonethread_run = Falsecamera = Nonecolor_transform = {"green": ("绿牌", "#55FF55"), "yello": ("黄牌", "#FFFF00"), "blue": ("蓝牌", "#6666FF")}def __init__(self, win):ttk.Frame.__init__(self, win)frame_left = ttk.Frame(self)frame_right1 = ttk.Frame(self)frame_right2 = ttk.Frame(self)win.title("车牌识别")win.state("zoomed")self.pack(fill=tk.BOTH, expand=tk.YES, padx="10", pady="10")frame_left.pack(side=LEFT, expand=1, fill=BOTH)frame_right1.pack(side=TOP, expand=1, fill=tk.Y)frame_right2.pack(side=RIGHT, expand=0)ttk.Label(frame_left, text='原图：').pack(anchor="nw")ttk.Label(frame_right1, text='形状定位车牌位置：').grid(column=0, row=0, sticky=tk.W)from_pic_ctl = ttk.Button(frame_right2, text="来自图片", width=20, command=self.from_pic)from_vedio_ctl = ttk.Button(frame_right2, text="来自摄像头", width=20, command=self.from_vedio)from_img_pre = ttk.Button(frame_right2, text="查看形状预处理图像", width=20,command = self.show_img_pre)self.image_ctl = ttk.Label(frame_left)self.image_ctl.pack(anchor="nw")self.roi_ctl = ttk.Label(frame_right1)self.roi_ctl.grid(column=0, row=1, sticky=tk.W)ttk.Label(frame_right1, text='形状定位识别结果：').grid(column=0, row=2, sticky=tk.W)self.r_ctl = ttk.Label(frame_right1, text="",font=('Times','20'))self.r_ctl.grid(column=0, row=3, sticky=tk.W)self.color_ctl = ttk.Label(frame_right1, text="", width="20")self.color_ctl.grid(column=0, row=4, sticky=tk.W)from_vedio_ctl.pack(anchor="se", pady="5")from_pic_ctl.pack(anchor="se", pady="5")from_img_pre.pack(anchor="se", pady="5")ttk.Label(frame_right1, text='颜色定位车牌位置：').grid(column=0, row=5, sticky=tk.W)self.roi_ct2 = ttk.Label(frame_right1)self.roi_ct2.grid(column=0, row=6, sticky=tk.W)ttk.Label(frame_right1, text='颜色定位识别结果：').grid(column=0, row=7, sticky=tk.W)self.r_ct2 = ttk.Label(frame_right1, text="",font=('Times','20'))self.r_ct2.grid(column=0, row=8, sticky=tk.W)self.color_ct2 = ttk.Label(frame_right1, text="", width="20")self.color_ct2.grid(column=0, row=9, sticky=tk.W)self.predictor = predict.CardPredictor()self.predictor.train_svm()def get_imgtk(self, img_bgr):img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)im = Image.fromarray(img)imgtk = ImageTk.PhotoImage(image=im)wide = imgtk.width()high = imgtk.height()if wide > self.viewwide or high > self.viewhigh:wide_factor = self.viewwide / widehigh_factor = self.viewhigh / highfactor = min(wide_factor, high_factor)wide = int(wide * factor)if wide <= 0: wide = 1high = int(high * factor)if high <= 0: high = 1im = im.resize((wide, high), Image.ANTIALIAS)imgtk = ImageTk.PhotoImage(image=im)return imgtkdef show_roi1(self, r, roi, color):if r:roi = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB)roi = Image.fromarray(roi)self.imgtk_roi = ImageTk.PhotoImage(image=roi)self.roi_ctl.configure(image=self.imgtk_roi, state='enable')self.r_ctl.configure(text=str(r))self.update_time = time.time()try:c = self.color_transform[color]self.color_ctl.configure(text=c[0], background=c[1], state='enable')except:self.color_ctl.configure(state='disabled')elif self.update_time + 8 < time.time():self.roi_ctl.configure(state='disabled')self.r_ctl.configure(text="")self.color_ctl.configure(state='disabled')def show_roi2(self, r, roi, color):if r:roi = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB)roi = Image.fromarray(roi)self.imgtk_roi = ImageTk.PhotoImage(image=roi)self.roi_ct2.configure(image=self.imgtk_roi, state='enable')self.r_ct2.configure(text=str(r))self.update_time = time.time()try:c = self.color_transform[color]self.color_ct2.configure(text=c[0], background=c[1], state='enable')except:self.color_ct2.configure(state='disabled')elif self.update_time + 8 < time.time():self.roi_ct2.configure(state='disabled')self.r_ct2.configure(text="")self.color_ct2.configure(state='disabled')def show_img_pre(self):filename = config.get_name()if filename.any() == True:debug.img_show(filename)def from_vedio(self):if self.thread_run:returnif self.camera is None:self.camera = cv2.VideoCapture(0)if not self.camera.isOpened():mBox.showwarning('警告', '摄像头打开失败！')self.camera = Nonereturnself.thread = threading.Thread(target=self.vedio_thread, args=(self,))self.thread.setDaemon(True)self.thread.start()self.thread_run = Truedef from_pic(self):self.thread_run = Falseself.pic_path = askopenfilename(title="选择识别图片", filetypes=[("jpg图片", "*.jpg"), ("png图片", "*.png")])if self.pic_path:img_bgr = img_math.img_read(self.pic_path)first_img, oldimg = self.predictor.img_first_pre(img_bgr)self.imgtk = self.get_imgtk(img_bgr)self.image_ctl.configure(image=self.imgtk)th1 = ThreadWithReturnValue(target=self.predictor.img_color_contours,args=(first_img,oldimg))th2 = ThreadWithReturnValue(target=self.predictor.img_only_color,args=(oldimg,oldimg,first_img))th1.start()th2.start()r_c, roi_c, color_c = th1.join()r_color,roi_color,color_color = th2.join()print(r_c,r_color)self.show_roi2(r_color, roi_color, color_color)self.show_roi1(r_c, roi_c, color_c)@staticmethoddef vedio_thread(self):self.thread_run = Truepredict_time = time.time()while self.thread_run:_, img_bgr = self.camera.read()self.imgtk = self.get_imgtk(img_bgr)self.image_ctl.configure(image=self.imgtk)if time.time() - predict_time > 2:r, roi, color = self.predictor(img_bgr)self.show_roi(r, roi, color)predict_time = time.time()print("run end")def close_window():print("destroy")if surface.thread_run:surface.thread_run = Falsesurface.thread.join(2.0)win.destroy()if __name__ == '__main__':win = tk.Tk()surface = Surface(win)# close,退出输出destroywin.protocol('WM_DELETE_WINDOW', close_window)# 进入消息循环win.mainloop()

6 最后

毕业设计 : 车牌识别系统实现【全网最详细】 - opencv 卷积神经网络 机器学习 深度学习相关推荐

1. 毕业设计 : 基于深度学习的口罩佩戴检测【全网最详细】 - opencv 卷积神经网络 机器视觉 深度学习

   文章目录

2. python模块cv2人脸识别_手把手教你使用OpenCV，Python和深度学习进行人脸识别

   使用OpenCV,Python和深度学习进行人脸识别 在本教程中,你将学习如何使用OpenCV,Python和深度学习进行面部识别.首先,我们将简要讨论基于深度学习的面部识别,包括"深度度量 ...

3. 【毕业设计】深度学习车牌识别系统 - opencv 卷积神经网络 机器学习

   文章目录 0 简介 1 车牌识别原理和流程 1.1 车牌定位 1.2 基于图形图像学的定位方法. 1.3 基于机器学习的定位方法. 1.4 字符分割 1.5 字符识别 2 基于机器学习的车牌识别 2. ...

4. 基于Python tensorflow2.3实现的水果识别系统源码+模型+数据集，卷积神经网络的入门案例

   水果识别-基于tensorflow2.3实现 水果识别是卷积神经网络的入门案例,这里我将模型的训练.测试.保存以及使用整合在了一起,至于原理部分,大家可以参考知乎或者B站上的回答,在这里我就不赘述了 ...

5. python车牌识别系统开源代码_汽车牌照识别系统【YOLO+MLP】

   车牌识别系统可以自动检测并识别图像中的车辆牌照,其算法主要包括牌照定位.牌照分割.字符识别等步骤.本文将给出一种基于深度学习的车牌识别系统方案. 要快速掌握开发人工智能系统的技能,推荐汇智网的 机器学 ...

6. 车牌识别系统-tensorflow项目

   介绍 车牌识别项目,基于tensorflow,使用卷积神经网络实现对车牌地区,字母,数字的识别. 通过13675张图片作为数据集,训练生成模型.使用django框架将数据结果进行显示,并增加后台管理系 ...

7. python车牌识别系统+车辆管理+计费系统（图像识别）django框架 计算机毕业设计

   python车牌识别系统+车辆管理+计费系统(图像识别)django框架 计算机毕业设计 一.开发技术 技术栈:基于Django框架,涉及停车费计算,用户管理,车牌识别(百度云) 功能: [1]用户管 ...

8. 毕业设计-基于深度学习的智能车牌识别系统

   目录 前言 课题背景和意义 实现技术思路 一.车牌识别的一般流程 二.智能车牌识别系统的设计思路 三.基于深度学习的智能车牌识别系统的实现 四.智能车牌识别系统的训练与测试 五.总结 实现效果图样例 ...

9. 你不知道的车牌识别系统

   点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达 有小伙伴后台和小白说,能不能推荐几个适合入门的开源视觉项目,因为根 ...

最新文章

1. HTML5的viewport使用
2. 解决Linux中java.net.UnknownHostException: oracledb.sys.iflashbuy.com问题
3. 快应用 - 应用签名校验失败
4. 客户端码农学习ML —— Numpy基本用法
5. Spring与Rails的jQuery UJS
6. maven 对于java的要求_如何在Maven中表达对Java EE功能的依赖以过渡到Java 9？
7. latex目录标题中间空一个字符
8. XTU 1252 Defense Tower
9. 微服务分布式学到这种程度，稳了！
10. 百搭手绘卡通牛年吉祥生肖素材，萌到心里的小牛
11. FD.io VPP 使用场景-用例
12. 看单片机原理图-最小系统
13. 复杂网络研究机构与大牛（不断更新）
14. python 城市代号数据的保存及读取
15. matlab 画 带虚部,MATLAB1：求实部、虚部、模和幅角的运算
16. 爬虫速成（一）：前言
17. java缺少方法主体_Java开发网 - 总是报错(缺少方法主体，或声明抽象)
18. 版本控制系统工作模式_繁星漫天_新浪博客
19. Android_Mms源代码接受短信流程
20. MSN今天遭遇脱机怪病 网友出招解决

热门文章

1. ubuntu如何修改文件夹的权限
2. Ural 1009 K-based Numbers
3. 图片版权保护工具ImageCopyRight
4. 登录微软账号时无法连接到网络
5. Kotlin-简约之美-基础篇（四）：类与继承
6. Tsai笔记：C++学习随性笔记（2）—— 数据结构：顺序表的基本操作
7. 宜搭小技巧｜巧用审批按钮，流程随心流转
8. canvas画图并下载图片
9. 云计算ACP云服务器ECS实例题库（三）
10. OpenGL基本概念入门——纹理贴图