主要参考博客：https://blog.csdn.net/GK_2014/article/details/84779166
主体算法没有修改，这里添加了通过H（色调）和S（饱和度）来对车牌颜色进行判断，然后使用tkinter搭建了简单的GUI，可以实现打开摄像头拍摄照片然后再对照片进行识别。
界面如下：
carPlateIdentity.py代码如下，添加了一些注释：
1 import cv2 2 import os 3 import sys 4 import numpy as np 5 import tensorflow as tf 6 7 config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)) 8 sess = tf.Session(config=config) 9 10 char_table = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 11 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '川', '鄂', '赣', '甘', '贵', 12 '桂', '黑', '沪', '冀', '津', '京', '吉', '辽', '鲁', '蒙', '闽', '宁', '青', '琼', '陕', '苏', '晋', 13 '皖', '湘', '新', '豫', '渝', '粤', '云', '藏', '浙'] 14 15 def hist_image(img): 16 assert img.ndim==2 17 hist = [0 for i in range(256)] 18 img_h,img_w = img.shape[0],img.shape[1] 19 20 for row in range(img_h): 21 for col in range(img_w): 22 hist[img[row,col]] += 1 23 p = [hist[n]/(img_w*img_h) for n in range(256)] 24 p1 = np.cumsum(p) 25 for row in range(img_h): 26 for col in range(img_w): 27 v = img[row,col] 28 img[row,col] = p1[v]*255 29 return img 30 31 def find_board_area(img): 32 assert img.ndim==2 33 img_h,img_w = img.shape[0],img.shape[1] 34 top,bottom,left,right = 0,img_h,0,img_w 35 flag = False 36 h_proj = [0 for i in range(img_h)] 37 v_proj = [0 for i in range(img_w)] 38 39 for row in range(round(img_h*0.5),round(img_h*0.8),3): 40 for col in range(img_w): 41 if img[row,col]==255: 42 h_proj[row] += 1 43 if flag==False and h_proj[row]>12: 44 flag = True 45 top = row 46 if flag==True and row>top+8 and h_proj[row]<12: 47 bottom = row 48 flag = False 49 50 for col in range(round(img_w*0.3),img_w,1): 51 for row in range(top,bottom,1): 52 if img[row,col]==255: 53 v_proj[col] += 1 54 if flag==False and (v_proj[col]>10 or v_proj[col]-v_proj[col-1]>5): 55 left = col 56 break 57 return left,top,120,bottom-top-10 58 59 def verify_scale(rotate_rect): 60 error = 0.4 61 aspect = 4#4.7272 62 min_area = 10*(10*aspect)#min_area=10*(10*4)=400 63 max_area = 150*(150*aspect)#max_area=150*(150*4)=90000 64 min_aspect = aspect*(1-error)#min_aspect=4*(1-0.4)=2.4 65 max_aspect = aspect*(1+error)#max_aspect=4*(1+0.4)=6.4 66 theta = 30 67 68 # 宽或高为0，不满足矩形直接返回False 69 if rotate_rect[1][0]==0 or rotate_rect[1][1]==0: 70 return False 71 ''' 72 rotate_rect[0]为外接矩形的中心坐标(x,y);[1][0]为宽，[1][1]为高,[2]为旋转角度. 73 旋转角度θ是水平轴（x轴）逆时针旋转，直到碰到矩形的第一条边停住，此时该边与水平轴的夹角。并且这个边的边长是width，另一条边边长是height 74 在opencv中，坐标系原点在左上角，相对于x轴，逆时针旋转角度为负，顺时针旋转角度为正。所以，θ∈（-90度，0] 75 ''' 76 77 r = rotate_rect[1][0]/rotate_rect[1][1]#r=宽除以高 78 r = max(r,1/r) 79 area = rotate_rect[1][0]*rotate_rect[1][1]#area为实际面积 80 if area>min_area and area<max_area and r>min_aspect and r<max_aspect:#如果实际面积大于最小面积且小于最大面积，并且2.4<r<6.4 81 # 矩形的倾斜角度不超过theta 82 if ((rotate_rect[1][0] < rotate_rect[1][1] and rotate_rect[2] >= -90 and rotate_rect[2] < -(90 - theta)) or#旋转角度在[-90,-60) 83 (rotate_rect[1][1] < rotate_rect[1][0] and rotate_rect[2] > -theta and rotate_rect[2] <= 0)):#旋转角度在(-30,0] 84 return True 85 return False 86 87 def img_Transform(car_rect,image):#传入填充掩膜后的最小矩形，原图 88 img_h,img_w = image.shape[:2] 89 rect_w,rect_h = car_rect[1][0],car_rect[1][1] 90 angle = car_rect[2] 91 92 return_flag = False 93 if car_rect[2]==0:#旋转角度为0 94 return_flag = True 95 if car_rect[2]==-90 and rect_w<rect_h:#旋转角度=-90并且矩形的宽<高 96 rect_w, rect_h = rect_h, rect_w 97 return_flag = True 98 if return_flag: 99 car_img = image[int(car_rect[0][1]-rect_h/2):int(car_rect[0][1]+rect_h/2), 100 int(car_rect[0][0]-rect_w/2):int(car_rect[0][0]+rect_w/2)] 101 return car_img 102 103 car_rect = (car_rect[0],(rect_w,rect_h),angle) 104 box = cv2.boxPoints(car_rect)#获取矩形的四个顶点坐标 105 106 heigth_point = right_point = [0,0] 107 left_point = low_point = [car_rect[0][0], car_rect[0][1]]#矩形中心点坐标(x,y) 108 for point in box: 109 if left_point[0] > point[0]: 110 left_point = point 111 if low_point[1] > point[1]: 112 low_point = point 113 if heigth_point[1] < point[1]: 114 heigth_point = point 115 if right_point[0] < point[0]: 116 right_point = point 117 118 if left_point[1] <= right_point[1]: # 正角度 119 new_right_point = [right_point[0], heigth_point[1]] 120 pts1 = np.float32([left_point, heigth_point, right_point]) 121 pts2 = np.float32([left_point, heigth_point, new_right_point]) # 字符只是高度需要改变 122 M = cv2.getAffineTransform(pts1, pts2) 123 print('Mat1',M) 124 print('pts1_1',pts1) 125 print('pts1_2',pts2) 126 ''' 127 仿射变换，其实是将图形在2D平面内做变换，变换前后图片中原来平行的线仍会保持平行，可以想象是将长方形变换为平行四边形 128 M=cv2.getAffineTransform(pos1,pos2),其中两个位置就是变换前后的对应位置关系。输出的就是仿射矩阵M,shape为[2,3] 129 cv.getAffineTransform将创建一个2x3矩阵，该矩阵将传递给cv.warpAffine。 130 ''' 131 dst = cv2.warpAffine(image, M, (round(img_w*2), round(img_h*2))) 132 ''' 133 cv2.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) → dst 134 dsize为输出图像的大小; 135 flags表示插值方式，默认为 flags=cv2.INTER_LINEAR，表示线性插值，此外还有：cv2.INTER_NEAREST(最近邻插值)、cv2.INTER_AREA(区域插值)、cv2.INTER_CUBIC(三次样条插值)、cv2.INTER_LANCZOS4(Lanczos插值) 136 borderMode - 边界像素模式 137 borderValue - 边界填充值; 默认情况下，它为0 138 round() 方法返回浮点数x的四舍五入值。round(x,n) 返回浮点数x的四舍五入的小数点后的n位数值 139 ''' 140 car_img = dst[int(left_point[1]):int(heigth_point[1]), int(left_point[0]):int(new_right_point[0])] 141 142 elif left_point[1] > right_point[1]: # 负角度 143 new_left_point = [left_point[0], heigth_point[1]] 144 pts1 = np.float32([left_point, heigth_point, right_point]) 145 pts2 = np.float32([new_left_point, heigth_point, right_point]) # 字符只是高度需要改变 146 print('pts2_1',pts1) 147 print('pts2_2',pts2) 148 M = cv2.getAffineTransform(pts1, pts2) 149 print('Mat2',M) 150 dst = cv2.warpAffine(image, M, (round(img_w*2), round(img_h*2))) 151 car_img = dst[int(right_point[1]):int(heigth_point[1]), int(new_left_point[0]):int(right_point[0])] 152 153 return car_img 154 155 def pre_process(orig_img): 156 157 gray_img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2GRAY) #将原图转换为灰度图 158 cv2.imwrite('./carIdentityData/opencv_output/gray_img.jpg', gray_img) 159 #cv2.imshow('gray_img', gray_img) 160 161 blur_img = cv2.blur(gray_img, (3, 3)) #均值滤波 162 cv2.imwrite('./carIdentityData/opencv_output/blur.jpg', blur_img) 163 #cv2.imshow('blur', blur_img) 164 165 sobel_img = cv2.Sobel(blur_img, cv2.CV_16S, 1, 0, ksize=3) #沿x轴求导，找边缘 166 sobel_img = cv2.convertScaleAbs(sobel_img) #转换图片格式 167 cv2.imwrite('./carIdentityData/opencv_output/sobel.jpg', sobel_img) 168 #cv2.imshow('sobel', sobel_img) 169 170 hsv_img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2HSV) #将原图的颜色域转到HSV域，色调、饱和度、亮度 171 cv2.imwrite('./carIdentityData/opencv_output/hsv_pic.jpg', hsv_img) 172 #cv2.imshow('hsv_pic',hsv_img) 173 174 h, s, v = hsv_img[:, :, 0], hsv_img[:, :, 1], hsv_img[:, :, 2] #h，s，v分别取矩阵的第一列、第二列、第三列的所有元素 175 # 黄色色调区间[26，34],蓝色色调区间:[100,124]，饱和度和亮度均需要高于70 176 blue_img = (((h > 11) & (h < 34)) | ((h > 35) & (h < 99)) | ((h > 100) & (h < 124))) & (s > 70) & (v > 70) 177 blue_img = blue_img.astype('float32') #将blue_img格式转换为浮点型32位 178 cv2.imwrite('./carIdentityData/opencv_output/blue&yellow.jpg', blue_img) 179 #cv2.imshow('blue&yellow',blue_img) 180 181 mix_img = np.multiply(sobel_img, blue_img) #两个数组或矩阵相乘，对应位置直接相乘 182 cv2.imwrite('./carIdentityData/opencv_output/mix.jpg', mix_img) 183 #cv2.imshow('mix', mix_img) 184 185 mix_img = mix_img.astype(np.uint8) 186 187 ret, binary_img = cv2.threshold(mix_img, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) 188 #ret, binary_img = cv2.threshold(mix_img, 50, 255, cv2.THRESH_BINARY) 189 ''' 190 使用最大类间方差法将图像二值化，cv2.THRESH_OTSU自适应找出最合适的阈值 191 cv2.threshold(src, thresh, maxval, type[, dst]) → retval, dst 192 src：表示的是图片源 193 thresh：表示的是阈值（起始值） 194 maxval：表示的是最大值 195 type：表示的是这里划分的时候使用的是什么类型的算法，常用值为0（cv2.THRESH_BINARY）,超过阈值的设置为最大值255，其他设置为0 196 返回值： 197 ret ：cv2.THRESH_OTSU 求解出的阈值 198 binary_img ：二值图像 199 ''' 200 print('ret',ret) 201 cv2.imwrite('./carIdentityData/opencv_output/binary.jpg', binary_img) 202 #cv2.imshow('binary',binary_img) 203 204 kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(21,5)) #获得结构元素 205 close_img = cv2.morphologyEx(binary_img, cv2.MORPH_CLOSE, kernel) #闭操作，先膨胀再腐蚀，使图像轮廓更光滑（need more） 206 cv2.imwrite('./carIdentityData/opencv_output/close.jpg', close_img) 207 #cv2.imshow('close', close_img) 208 209 return close_img 210 211 # 给候选车牌区域做漫水填充算法，一方面补全上一步求轮廓可能存在轮廓歪曲的问题， 212 # 另一方面也可以将非车牌区排除掉 213 def verify_color(rotate_rect,src_image): 214 img_h,img_w = src_image.shape[:2]#shape[0],shape[1] 215 mask = np.zeros(shape=[img_h+2,img_w+2],dtype=np.uint8) 216 #cv2.imshow('flood_mask',mask) 217 connectivity = 4#0100 218 #种子点上下左右4邻域与种子颜色值在[loDiff,upDiff]的被涂成new_value，也可设置8邻域， 219 #如果设为4，表示填充算法只考虑当前像素水平方向和垂直方向的相邻点；如果设为 8，除上述相邻点外，还会包含对角线方向的相邻点。 220 loDiff,upDiff = 30,30#负差最大值，正差最大值.loDiff表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间的亮度或颜色之负差（lower brightness/color difference）的最大值。 221 new_value = 255 222 flags = connectivity#0100 223 print('flags1',flags) 224 flags |= cv2.FLOODFILL_FIXED_RANGE #按位或，FLOODFILL_FIXED_RANGE=2**16=65536.考虑当前像素与种子象素之间的差，不设置的话则和邻域像素比较,运算结果为01 0000 0000 0000 0100，十进制为65540 225 print('flags2',flags) 226 print('cv2.FLOODFILL_FIXED_RANGE',cv2.FLOODFILL_FIXED_RANGE) 227 ''' 228 flags = flags | cv2.FLOODFILL_FIXED_RANGE 229 cv.FLOODFILL_FIXED_RANGE： 指定颜色填充，二进制为 01 0000 0000 0000 0000.填充时的判断标准是：src(seed.x’, seed.y’) - loDiff <= src(x, y) <= src(seed.x’, seed.y’) +upDiff，此范围内被填充指定的颜色 230 cv.FLOODFILL_MASK_ONLY: 指定位置填充，二进制为 10 0000 0000 0000 0000 231 ''' 232 flags |= new_value << 8 233 #<<左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0. 255左移8位是1111111100000000，运算结果为01 1111 1111 0000 0100，十进制为130820 234 print('flags3',flags) 235 flags |= cv2.FLOODFILL_MASK_ONLY 236 #FLOODFILL_MASK_ONLY=2**17=131072.设置这个标识符则不会去填充改变原始图像，而是去填充掩模图像（mask），运算结果为11 1111 1111 0000 0100，十进制为261892 237 print('flags4',flags) 238 print('FLOODFILL_MASK_ONLY',cv2.FLOODFILL_MASK_ONLY) 239 ''' 240 相当于flags = 4 | cv2.FLOODFILL_FIXED_RANGE | 255 << 8 | cv2.FLOODFILL_MASK_ONLY 241 通俗来讲，就是用4邻域填充，并填充固定像素值范围，填充掩码而不是填充源图像，以及设填充值为255 242 标识符的0-7位为connectivity,8-15位为new_value左移8位的值，16-23位为cv2.FLOODFILL_FIXED_RANGEcv2.FLOODFILL_MASK_ONLY或者0 243 1.低8位用于控制算法的连通性，可取4（填充算法只考虑当前享受水平方向和垂直方向）/8（还考虑对角线方向） 244 2.高8位可为0/FLOODFILL_FIXED_RANGE（考虑当前像素与种子像素之间的差）/FLOODFILL_MASK_ONLY(不填充改变原始图像，去填充掩模图像) 245 3.中间8位制定填充掩码图像的值 246 最终得到的flags为11 1111 1111 0000 0100，十进制为261892 247 ''' 248 rand_seed_num = 5000 #生成多个随机种子 249 valid_seed_num = 200 #从rand_seed_num中随机挑选valid_seed_num个有效种子 250 adjust_param = 0.1 251 box_points = cv2.boxPoints(rotate_rect) 252 ''' 253 cv2.boxPoints根据minAreaRect的返回值rotate_rect计算矩形的四个点 254 旋转的边界矩形,这个边界矩形是面积最小的，因为它考虑了对象的旋转。用到的函数为cv2.minAreaRect()。返回的是一个Box2D结构， 255 其中包含矩形左上角角点的坐标（x，y）,矩形的宽和高（w，h），以及旋转角度。但是要绘制这个矩形需要矩形的4个角点，可以通过函数cv2.boxPoints()获得。 256 返回形式[ [x0,y0], [x1,y1], [x2,y2], [x3,y3] ] 257 ''' 258 box_points_x = [n[0] for n in box_points]#每一个坐标点的x值 259 print('box_points_x1',box_points_x) 260 box_points_x.sort(reverse=False)#list.sort( key=None, reverse=False)，reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认） 261 print('box_points_x2',box_points_x) 262 adjust_x = int((box_points_x[2]-box_points_x[1])*adjust_param)#=(第三个x-第二个x*0.1)，对角点 263 print('adjust_x',adjust_x) 264 col_range = [box_points_x[1]+adjust_x,box_points_x[2]-adjust_x] 265 print('col_range',col_range) 266 box_points_y = [n[1] for n in box_points]#每一个坐标点的y值 267 print('box_points_y1',box_points_y) 268 box_points_y.sort(reverse=False) 269 print('box_points_y2',box_points_y) 270 adjust_y = int((box_points_y[2]-box_points_y[1])*adjust_param) 271 print('adjust_y',adjust_y) 272 row_range = [box_points_y[1]+adjust_y, box_points_y[2]-adjust_y] 273 print('row_range',row_range) 274 # 如果以上方法种子点在水平或垂直方向可移动的范围很小，则采用旋转矩阵对角线来设置随机种子点 275 if (col_range[1]-col_range[0])/(box_points_x[3]-box_points_x[0])<0.4 276 or (row_range[1]-row_range[0])/(box_points_y[3]-box_points_y[0])<0.4:#小于0.4时重新定义 277 points_row = [] 278 points_col = [] 279 for i in range(2): 280 pt1,pt2 = box_points[i],box_points[i+2]#第一个和第三个坐标点，第二个和第四个坐标点 281 x_adjust,y_adjust = int(adjust_param*(abs(pt1[0]-pt2[0]))),int(adjust_param*(abs(pt1[1]-pt2[1]))) 282 if (pt1[0] <= pt2[0]): 283 pt1[0], pt2[0] = pt1[0] + x_adjust, pt2[0] - x_adjust 284 else: 285 pt1[0], pt2[0] = pt1[0] - x_adjust, pt2[0] + x_adjust 286 if (pt1[1] <= pt2[1]): 287 pt1[1], pt2[1] = pt1[1] + adjust_y, pt2[1] - adjust_y 288 else: 289 pt1[1], pt2[1] = pt1[1] - y_adjust, pt2[1] + y_adjust 290 temp_list_x = [int(x) for x in np.linspace(pt1[0],pt2[0],int(rand_seed_num /2))] 291 temp_list_y = [int(y) for y in np.linspace(pt1[1],pt2[1],int(rand_seed_num /2))] 292 points_col.extend(temp_list_x) 293 points_row.extend(temp_list_y) 294 print('in for') 295 else: 296 points_row = np.random.randint(row_range[0],row_range[1],size=rand_seed_num) 297 ''' 298 numpy.random.randint(low, high=None, size=None, dtype='l')返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。如果没有写参数high的值，则返回[0,low)的值。 299 定义rand_seed_num = 5000。size为输出随机数的尺寸，这里输出5000个随机数 300 ''' 301 points_col = np.linspace(col_range[0],col_range[1],num=rand_seed_num).astype(np.int) 302 ''' 303 np.linspace主要用来创建等差数列。np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None),在start和stop之间返回均匀间隔的数据 304 endpoint：True则包含stop；False则不包含stop; retstep如果为True则结果会给出数据间隔 305 在[col_range[0],col_range[1]]之间输出包含5000个数据的等差数列，并将其修改格式为整型 306 ''' 307 print('in else') 308 309 points_row = np.array(points_row) 310 points_col = np.array(points_col) 311 hsv_img = cv2.cvtColor(src_image, cv2.COLOR_BGR2HSV) 312 h,s,v = hsv_img[:,:,0],hsv_img[:,:,1],hsv_img[:,:,2] 313 # 将随机生成的多个种子依次做漫水填充,理想情况是整个车牌被填充 314 flood_img = src_image.copy() 315 seed_cnt = 0 316 for i in range(rand_seed_num): 317 rand_index = np.random.choice(rand_seed_num,1,replace=False)#从[0,5000)之间随机抽取一个数，且不能重复 318 row,col = points_row[rand_index],points_col[rand_index] 319 # 限制随机种子必须是车牌背景色，黄色色调区间[26，34],蓝色色调区间:[100,124] 320 if (((h[row,col]>11)&(h[row,col]<34))|((h[row,col]>35)&(h[row,col]<100))|((h[row,col]>100)&(h[row,col]<124)))&(s[row,col]>70)&(v[row,col]>70): 321 cv2.floodFill(src_image, mask, (col,row), (255, 255, 255), (loDiff,) * 3, (upDiff,) * 3, flags) 322 ''' 323 floodFill(image, mask, seedPoint, newVal, loDiff=None, upDiff=None, flags=None) 324 floodFill( 1.操作的图像, 2.掩模, 3.起始像素值，4.填充的颜色, 5.填充颜色的低值， 6.填充颜色的高值 ,7.填充的方法) (255, 255, 255)是白色 325 mask = np.zeros(shape=[img_h+2,img_w+2],dtype=np.uint8) 326 loDiff,upDiff = 30,30;(loDiff,) * 3=(loDiff,loDiff,loDiff) 327 328 ''' 329 cv2.circle(flood_img,center=(col,row),radius=2,color=(0,0,255),thickness=2) 330 ''' 331 cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]]),根据给定的圆心和半径等画圆 332 center:圆心位置；radius：圆的半径；color：圆的颜色；thickness：圆形轮廓的粗细（如果为正），负厚度表示要绘制实心圆；lineType：圆边界的类型；shift：中心坐标和半径值中的小数位数。 333 ''' 334 seed_cnt += 1 335 if seed_cnt >= valid_seed_num: 336 break 337 #======================调试用======================# 338 show_seed = np.random.uniform(1,100,1).astype(np.uint16) 339 ''' 340 numpy.random.uniform(low,high,size)，从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high. 341 low: 采样下界，float类型，默认值为0； 342 high: 采样上界，float类型，默认值为1； 343 size: 输出样本数目，为int或元组(tuple)类型 344 返回值：ndarray类型，其形状和参数size中描述一致 345 ''' 346 #cv2.imshow('floodfill'+str(show_seed),flood_img) 347 #cv2.imshow('flood_mask'+str(show_seed),mask) 348 349 cv2.imwrite('./carIdentityData/opencv_output/floodfill.jpg', flood_img) 350 cv2.imwrite('./carIdentityData/opencv_output/flood_mask.jpg', mask) 351 #======================调试用======================# 352 # 获取掩模上被填充点的像素点，并求点集的最小外接矩形 353 mask_points = [] 354 for row in range(1,img_h+1): 355 for col in range(1,img_w+1): 356 if mask[row,col] != 0: 357 mask_points.append((col-1,row-1))#把不是黑色的像素点添加进mask_points，把mask被填充成白色的点集添加进去 358 mask_rotateRect = cv2.minAreaRect(np.array(mask_points))#获取点集的最小矩形 359 if verify_scale(mask_rotateRect): 360 return True,mask_rotateRect 361 else: 362 return False,mask_rotateRect 363 364 # 车牌定位 365 def locate_carPlate(orig_img,pred_image): 366 car_plate_w, car_plate_h = 136, 36 #dengjie.tkadd 367 carPlate_list = [] 368 temp1_orig_img = orig_img.copy() #调试用 369 temp2_orig_img = orig_img.copy() #调试用 370 #cloneImg,contours,heriachy = cv2.findContours(pred_image,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) 371 contours, heriachy = cv2.findContours(pred_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) 372 #print(contours) #dengjie 373 # RETR_EXTERNAL找最外层轮廓，CHAIN_APPROX_SIMPLE仅保存轮廓的拐点信息，把所有轮廓拐点处的点保存入contours向量内，拐点与拐点之间直线段上的信息点不予保留。heriachy这里没有用到 374 for i,contour in enumerate(contours): #enumerate同时获得列表或者字符串的索引和值，i是索引，contour是值 375 cv2.drawContours(temp1_orig_img, contours, i, (0, 255, 0), 2)#用绿色线宽为2的线条画出原图的所有轮廓 376 # 获取轮廓最小外接矩形，返回值rotate_rect。rotate_rect是点集数组或向量（里面存放的是点的坐标），并且这个点集中的元素不定个数(中心(x,y), (宽,高), 旋转角度) 377 rotate_rect = cv2.minAreaRect(contour) 378 # 根据矩形面积大小和长宽比判断是否是车牌 379 if verify_scale(rotate_rect):#return True 380 ret,rotate_rect2 = verify_color(rotate_rect,temp2_orig_img)#返回True和mask上被填充点的像素点集的最小矩形 381 if ret == False: 382 continue 383 # 车牌位置矫正 384 car_plate = img_Transform(rotate_rect2, temp2_orig_img)#做仿射变换 385 car_plate = cv2.resize(car_plate,(car_plate_w,car_plate_h)) #调整尺寸为后面CNN车牌识别做准备 386 #========================调试看效果========================# 387 box = cv2.boxPoints(rotate_rect2)#获取矩形顶点坐标 388 for k in range(4): 389 n1,n2 = k%4,(k+1)%4 390 cv2.line(temp1_orig_img,(box[n1][0],box[n1][1]),(box[n2][0],box[n2][1]),(0,0,255),2) 391 ''' 392 cv2.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) → img 393 img:原图 394 pt1：直线起点坐标，(box[n1][0],box[n1][1])；(box[0][0],box[0][1]) 395 pt2，直线终点坐标，(box[n2][0],box[n2][1])；(box[1][0],box[1][1]) 396 color，当前绘画的颜色;如在BGR模式下，传递(255,0,0)表示蓝色画笔。 397 hickness，画笔的粗细，线宽。若是-1表示画封闭图像，如填充的圆。默认值是1 398 lineType，线条的类型 399 ''' 400 #cv2.imshow('opencv_' + str(i), car_plate) 401 cv2.imwrite('./carIdentityData/opencv_output/opencv_%d.jpg'%(i), car_plate) 402 #========================调试看效果========================# 403 carPlate_list.append(car_plate) 404 #print('carPlate_list',carPlate_list) 405 406 cv2.imwrite('./carIdentityData/opencv_output/contour.jpg', temp1_orig_img) 407 #cv2.imshow('contour', temp1_orig_img) 408 return carPlate_list 409 410 # 左右切割 411 def horizontal_cut_chars(plate):#传入车牌二值图像中的字符部分 412 char_addr_list = [] 413 area_left,area_right,char_left,char_right= 0,0,0,0 414 img_h,img_w = plate.shape[:2] 415 416 # 获取车牌每列边缘像素点个数 417 def getColSum(img,col): 418 sum = 0 419 for i in range(img.shape[0]): 420 sum += round(img[i,col]/255)#二值图像，img[i,col]=0或255，获取每一列像素值为255的像素个数 421 return sum; 422 423 sum = 0 424 for col in range(img_w): 425 sum += getColSum(plate,col)#所有列白色像素点的个数总和 426 427 col_limit = 0 428 #col_limit = round(0.3*sum/img_w) # 每列边缘像素点必须超过均值的30%才能判断属于字符区域 429 #print('col_limit',sum,img_w,col_limit)#1344.0,136,6.0 430 # 每个字符宽度也进行限制 431 charWid_limit = [round(img_w/12),round(img_w/5)]#[11,27] 432 is_char_flag = False 433 434 for i in range(img_w): 435 colValue = getColSum(plate,i)#每一列像素值为255的像素个数,ex:i=7时，colValue=3；i=8时，colValue=9；i=9时，colValue=19；i=18时，colValue=16；i=19时，colValue=0 436 #print('colValue'+str(i),colValue) 437 if colValue > col_limit: 438 if is_char_flag == False: 439 area_right = round((i+char_right)/2)#ex:i=8,area_right=4 440 area_width = area_right-area_left#area_width=4 441 char_width = char_right-char_left#char_width=0 442 if (area_width>charWid_limit[0]) and (area_width<charWid_limit[1]): 443 char_addr_list.append((area_left,area_right,char_width)) 444 char_left = i#i=8 445 area_left = round((char_left+char_right) / 2)#area_left=4 446 is_char_flag = True 447 else: 448 if is_char_flag == True: 449 char_right = i-1#19-1=18 450 is_char_flag = False 451 #print('is_char_flag'+str(i),area_left,area_right,char_right,char_left) 452 #print('char_addr_list1',char_addr_list) 453 # 手动结束最后未完成的字符分割 454 if area_right < char_left: 455 area_right,char_right = img_w,img_w#以img_w为右边界 456 #area_right = round((img_w+char_right)/2) 457 area_width = area_right - area_left 458 char_width = char_right - char_left 459 if (area_width > charWid_limit[0]) and (area_width < charWid_limit[1]): 460 char_addr_list.append((area_left, area_right, char_width))#每一个字符区域的左右边界及字符的宽度 461 print('char_addr_list2',char_addr_list)#ex.char_addr_list=[(4, 20, 10), (20, 45, 14), (45, 62, 7), (62, 83, 13), (83, 96, 6), (96, 114, 14), (114, 132, 14)] 462 return char_addr_list 463 464 def get_chars(car_plate):#传入车牌二值化图像 465 char_w, char_h = 20, 20#dengjie.tkadd 466 img_h,img_w = car_plate.shape[:2] 467 h_proj_list = [] # 水平投影长度列表 468 h_temp_len,v_temp_len = 0,0 469 h_startIndex,h_end_index = 0,0 # 水平投影记索引 470 h_proj_limit = [0.2,0.8] # 车牌在水平方向的轮廓长度少于20%或多余80%过滤掉 471 char_imgs = [] 472 473 def getColSum(img,col): 474 sum = 0 475 for i in range(img.shape[0]): 476 sum += round(img[i,col]/255)#二值图像，img[i,col]=0或255，获取每一列像素值为255的像素个数 477 return sum; 478 479 sum = 0 480 for col in range(img_w): 481 sum += getColSum(car_plate,col)#所有列白色像素点的个数总和 482 483 # 将二值化的车牌水平投影到Y轴，计算投影后的连续长度，连续投影长度可能不止一段 484 h_count = [0 for i in range(img_h)] 485 for row in range(img_h): 486 temp_cnt = 0 487 for col in range(img_w): 488 if car_plate[row,col] == 255: 489 temp_cnt += 1 490 h_count[row] = temp_cnt#统计每一行像素值为255的像素个数 491 if temp_cnt/img_w<h_proj_limit[0] or temp_cnt/img_w>h_proj_limit[1]:#每一行像素值为255的像素个数/车牌宽度<0.2 或者 每一行像素值为255的像素个数/车牌宽度>0.8 492 if h_temp_len != 0: 493 h_end_index = row-1 494 h_proj_list.append((h_startIndex,h_end_index)) 495 print('h_proj_list1',h_proj_list) 496 h_temp_len = 0 497 continue 498 if temp_cnt > 0: 499 if h_temp_len == 0: 500 h_startIndex = row#从0.2<(像素值为255的像素个数/img_w)<0.8 的行开始 501 h_temp_len = 1 502 else: 503 h_temp_len += 1 504 else: 505 if h_temp_len > 0: 506 h_end_index = row-1 507 h_proj_list.append((h_startIndex,h_end_index)) 508 print('h_proj_list2',h_proj_list) 509 h_temp_len = 0 510 print('h_temp_len',h_temp_len) 511 # 手动结束最后得水平投影长度累加 512 if h_temp_len != 0: 513 h_end_index = img_h-1 514 h_proj_list.append((h_startIndex, h_end_index))#h_temp_len不等于0时再添加一对值 515 print('h_proj_list',h_proj_list)#ex:[(1, 1), (7, 29), (34, 35)]或者[(2, 2), (7, 28), (34, 34)] 516 # 选出最长的投影，该投影长度占整个截取车牌高度的比值必须大于0.5 517 h_maxIndex,h_maxHeight = 0,0 518 for i,(start,end) in enumerate(h_proj_list): 519 if h_maxHeight < (end-start): 520 h_maxHeight = (end-start) 521 h_maxIndex = i 522 if h_maxHeight/img_h < 0.5: 523 return char_imgs 524 chars_top,chars_bottom = h_proj_list[h_maxIndex][0],h_proj_list[h_maxIndex][1]#chars_top=h_proj_list[1][0],chars_bottom=h_proj_list[1][1] 525 526 if sum > img_h *img_w * 0.5: 527 ret,car_plate = cv2.threshold(car_plate,0,255,cv2.THRESH_BINARY_INV|cv2.THRESH_OTSU) 528 #cv2.imshow('THRESH_BINARY_INV',car_plate) 529 530 plates = car_plate[chars_top:chars_bottom+1,:]#获取车牌二值图像中的字符高度部分，plates比car_plate要窄，然后在进行字符分割 531 cv2.imwrite('./carIdentityData/opencv_output/car_plate.jpg',car_plate) 532 cv2.imwrite('./carIdentityData/opencv_output/plates.jpg', plates) 533 char_addr_list = horizontal_cut_chars(plates)#ex.char_addr_list=[(4, 20, 10), (20, 45, 14), (45, 62, 7), (62, 83, 13), (83, 96, 6), (96, 114, 14), (114, 132, 14)] 534 535 for i,addr in enumerate(char_addr_list): 536 char_img = car_plate[chars_top:chars_bottom+1,addr[0]:addr[1]]#输出单个字符 537 char_img = cv2.resize(char_img,(char_w,char_h))#resize字符 538 char_imgs.append(char_img) 539 #cv2.imshow('22',char_img) #dengjie2 540 cv2.imwrite('./carIdentityData/opencv_output/char_%d.jpg'%(i),char_img) 541 return char_imgs 542 543 def extract_char(car_plate):#传入正确的车牌 544 gray_plate = cv2.cvtColor(car_plate,cv2.COLOR_BGR2GRAY)#转换成灰度图 545 ret,binary_plate = cv2.threshold(gray_plate,0,255,cv2.THRESH_BINARY|cv2.THRESH_OTSU)#使用最大类间方差法将图像二值化，自适应找出最合适的阈值 546 #cv2.imshow('extract_char_binary_plate',binary_plate) 547 cv2.imwrite('./carIdentityData/opencv_output/extract_char_binary_plate.jpg',binary_plate) 548 char_img_list = get_chars(binary_plate) 549 #cv2.imshow('1',binary_plate) #dengjie 550 return char_img_list 551 552 def cnn_select_carPlate(plate_list,model_path): 553 if len(plate_list) == 0: 554 return False,plate_list 555 g1 = tf.Graph() 556 sess1 = tf.Session(graph=g1) 557 ''' 558 Tensorflow中的图（tf.Graph）和会话（tf.Session） 559 tf.Graph()表示实例化一个用于tensorflow计算和表示用的数据流图，不负责运行计算 560 1、使用g = tf.Graph()函数创建新的计算图 561 2、在with g.as_default():语句下定义属于计算图g的张量和操作 562 3、在with tf.Session()中通过参数graph=xxx指定当前会话所运行的计算图 563 4、如果没有显示指定张量和操作所属的计算图，则这些张量和操作属于默认计算图 564 5、一个图可以在多个sess中运行，一个sess也能运行多个图 565 ''' 566 with sess1.as_default(): 567 with sess1.graph.as_default():#使用此图作为默认图的上下文管理器 568 model_dir = os.path.dirname(model_path)# 获取文件的完整目录，得到当前文件的绝对路径 569 saver = tf.train.import_meta_graph(model_path)#用来加载训练模型meta文件中的图,以及图上定义的结点参数包括权重偏置项等需要训练的参数,也包括训练过程生成的中间参数 570 saver.restore(sess1, tf.train.latest_checkpoint(model_dir))#自动找到最近保存的变量文件并载入 571 graph = tf.get_default_graph()#获取当前默认的计算图 572 net1_x_place = graph.get_tensor_by_name('x_place:0')#按tensor名称获取tensor信息，Tensor("x_place:0", shape=(?, 36, 136, 3), dtype=float32) 573 #Once you know the name you can fetch the Tensor using <name>:0 (0 refers to endpoint which is somewhat redundant) 574 #一旦知道名称，就可以使用<name>：0来获取Tensor（0表示冗余的端点） 575 print('net1_x_place',net1_x_place) 576 net1_keep_place = graph.get_tensor_by_name('keep_place:0')#Tensor("keep_place:0", dtype=float32) 577 print('net1_keep_place',net1_keep_place) 578 net1_out = graph.get_tensor_by_name('out_put:0')#Tensor("out_put:0", shape=(?, 2), dtype=float32),获取cnn_construct()的输出 579 print('net1_out',net1_out) 580 581 input_x = np.array(plate_list) 582 net_outs = tf.nn.softmax(net1_out) 583 preds = tf.argmax(net_outs,1) #预测结果，按行取最大值对应的索引 584 probs = tf.reduce_max(net_outs,reduction_indices=[1]) #结果概率值，按行取概率的最大值 585 pred_list,prob_list = sess1.run([preds,probs],feed_dict={net1_x_place:input_x,net1_keep_place:1.0}) 586 print('pred_list',pred_list) 587 print('prob_list',prob_list) 588 # 选出概率最大的车牌 589 result_index,result_prob = -1,0. 590 for i,pred in enumerate(pred_list): 591 if pred==1 and prob_list[i]>result_prob: 592 result_index,result_prob = i,prob_list[i]#0,概率 593 print('in pred') 594 print(result_index,result_prob) 595 if result_index == -1: 596 return False,plate_list[0]#返回第一张车牌 597 else: 598 green = yellow = blue = 0 599 img_hsv = cv2.cvtColor(plate_list[result_index], cv2.COLOR_BGR2HSV) 600 row_num, col_num= img_hsv.shape[:2] 601 # ~ 总共的像素个数 602 card_img_count = row_num * col_num 603 604 for i in range(row_num): 605 for j in range(col_num): 606 H = img_hsv.item(i, j, 0) 607 S = img_hsv.item(i, j, 1) 608 V = img_hsv.item(i, j, 2) 609 # ~ 根据HSV空间的值确定颜色 610 if 11 < H <= 34 and S > 34: 611 yellow += 1 612 elif 35 < H <= 99 and S > 34: 613 green += 1 614 elif 99 < H <= 124 and S > 34: 615 blue += 1 616 color = "no" 617 618 # ~ 若某种颜色的像素个数占一半以上，则判别为该颜色 619 if yellow*2 >= card_img_count: 620 color = "yellow" 621 622 elif green*2 >= card_img_count: 623 color = "green" 624 625 elif blue*2 >= card_img_count: 626 color = "blue" 627 628 return True,plate_list[result_index],color#返回正确的索引对应的车牌 629 630 def cnn_recongnize_char(img_list,model_path): 631 g2 = tf.Graph() 632 sess2 = tf.Session(graph=g2) 633 text_list = [] 634 635 if len(img_list) == 0: 636 return text_list 637 with sess2.as_default(): 638 with sess2.graph.as_default(): 639 model_dir = os.path.dirname(model_path) 640 saver = tf.train.import_meta_graph(model_path) 641 saver.restore(sess2, tf.train.latest_checkpoint(model_dir)) 642 graph = tf.get_default_graph() 643 net2_x_place = graph.get_tensor_by_name('x_place:0') 644 net2_keep_place = graph.get_tensor_by_name('keep_place:0') 645 net2_out = graph.get_tensor_by_name('out_put:0') 646 647 data = np.array(img_list) 648 # 数字、字母、汉字，从67维向量找到概率最大的作为预测结果 649 net_out = tf.nn.softmax(net2_out) 650 preds = tf.argmax(net_out,1) 651 my_preds= sess2.run(preds, feed_dict={net2_x_place: data, net2_keep_place: 1.0}) 652 print('my_preds',my_preds)#ex.my_preds=[49 11 13 8 19 5 3] 653 654 for i in my_preds: 655 text_list.append(char_table[i]) 656 return text_list 657 658 if __name__ == '__main__': 659 cur_dir = sys.path[0] 660 car_plate_w,car_plate_h = 136,36 661 char_w,char_h = 20,20 662 plate_model_path = os.path.join(cur_dir, './carIdentityData/model/plate_recongnize/model.ckpt-1020.meta') 663 char_model_path = os.path.join(cur_dir,'./carIdentityData/model/char_recongnize/model.ckpt-1030.meta') 664 img = cv2.imread('./plate_pic/24.jpg') 665 666 # 预处理 667 pred_img = pre_process(img) 668 669 # 车牌定位 670 car_plate_list = locate_carPlate(img,pred_img) 671 672 # CNN车牌过滤 673 ret,car_plate,color = cnn_select_carPlate(car_plate_list,plate_model_path)#True,正确的车牌 674 if ret == False: 675 print("未检测到车牌") 676 sys.exit(-1)#sys.exit(-1)告诉程序退出。它基本上只是停止继续执行python代码。-1只是传入的状态码。通常0表示成功执行，其他任何数字（通常为1）表示发生故障。 677 #cv2.imshow('cnn_plate',car_plate) 678 cv2.imwrite('./carIdentityData/opencv_output/cnn_plate.jpg', car_plate) 679 680 # 字符提取 681 char_img_list = extract_char(car_plate) 682 683 # CNN字符识别 684 text = cnn_recongnize_char(char_img_list,char_model_path) 685 print('result:',text) 686 print(color) 687 688 cv2.waitKey(0)
GUI代码如下：
1 import tkinter as tk 2 from tkinter.filedialog import * 3 from tkinter import ttk 4 import carPlateIdentity 5 import cv2 6 from PIL import Image, ImageTk 7 #import threading 8 import time 9 import os 10 # video import create_capture 11 import sys 12 import getopt 13 14 15 class Surface(ttk.Frame): 16 pic_path = "" 17 viewhigh = 600 18 viewwide = 600 19 update_time = 0 20 thread = None 21 thread_run = False 22 camera = None 23 color_transform = {"green":("绿牌","#55FF55"), "yello":("黄牌","#FFFF00"), "blue":("蓝牌","#6666FF")} 24 25 def __init__(self, win): 26 ttk.Frame.__init__(self, win) 27 frame_left = ttk.Frame(self) 28 frame_right1 = ttk.Frame(self) 29 frame_right2 = ttk.Frame(self) 30 style=ttk.Style() 31 #style.configure("BW.Tlable",foreground="blue",background="blue") 32 style.configure("TButton",font=("Times",12),foreground="black",background="green") 33 win.title("车牌识别") 34 #win.state("zoomed") 35 self.pack(fill=tk.BOTH, expand=tk.YES, padx="5", pady="5") 36 #fill=tk.BOTH:水平和竖直方向填充;expand=tk.YES:扩展整个空白区;padx:x方向的外边距;pady:y方向的外边距 37 frame_left.pack(side=LEFT,expand=1,fill=BOTH) 38 #side=LEFT:按扭停靠在窗口的左侧 39 frame_right1.pack(side=TOP,expand=1,fill=tk.Y) 40 frame_right2.pack(side=RIGHT,expand=1) 41 ttk.Label(frame_left, text='Original pic：',font=("Times",12)).pack(anchor="nw") #nw表示位置在上左，n是north，w是west 42 ttk.Label(frame_right1, text='Plate Location：',font=("Times",12)).grid(column=0, row=0, sticky=tk.W) 43 #位置在上面 44 from_vedio_ctl = ttk.Button(frame_right2, text="Open camera", width=20, style="TButton",command=self.from_vedio) 45 from_pic_ctl = ttk.Button(frame_right2, text="Open picture",width=20, style="TButton",command=self.from_pic) 46 from_img_pre = ttk.Button(frame_right2, text="Show pre_img",width=20, style="TButton",command=self.show_img_pre) 47 48 self.image_ctl = ttk.Label(frame_left) 49 self.image_ctl.pack(anchor="nw") 50 51 self.roi_ctl = ttk.Label(frame_right1)#车牌 52 self.roi_ctl.grid(column=0, row=1, sticky=tk.W) 53 ttk.Label(frame_right1, text='Recognition result：',font=("Times",12)).grid(column=0, row=2, sticky=tk.W) 54 self.r_ctl = ttk.Label(frame_right1, text="",font=("Times",12))#字符 55 self.r_ctl.grid(column=0, row=3, sticky=tk.W) 56 self.color_ctl = ttk.Label(frame_right1, text="", font=("Times",12),width="20") 57 self.color_ctl.grid(column=0, row=4, sticky=tk.W) 58 from_pic_ctl.pack(anchor="se", pady="5") 59 from_vedio_ctl.pack(anchor="se", pady="5") 60 from_img_pre.pack(anchor="se", pady="5") 61 62 63 def get_imgtk(self, img_bgr): 64 img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB) 65 im = Image.fromarray(img)#array转换成image图片 66 imgtk = ImageTk.PhotoImage(image=im)#显示图片 67 wide = imgtk.width()#图片的宽 68 high = imgtk.height()#图片的高 69 #print('wide',wide) 70 #print('high',high) 71 if wide > self.viewwide or high > self.viewhigh:#前面有定义，viewwide和viewhigh都为600 72 wide_factor = self.viewwide / wide#viewwide除以图片的宽 73 high_factor = self.viewhigh / high#viewhigh除以图片的高 74 factor = min(wide_factor, high_factor)#取两者的最小值 75 wide = int(wide * factor) 76 if wide <= 0 : wide = 1#如果wide<=0,则令wide=1 77 high = int(high * factor) 78 if high <= 0 : high = 1 79 im=im.resize((wide, high), Image.ANTIALIAS)#Image.ANTIALIAS：PIL高质量、抗锯齿 80 imgtk = ImageTk.PhotoImage(image=im) 81 return imgtk 82 #此方法得到resize后且高质量的图片 83 84 def show_roi(self, r, roi,color):#传入字符r与车牌图像roi 85 if r : 86 roi = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB) 87 roi = Image.fromarray(roi) 88 self.imgtk_roi = ImageTk.PhotoImage(image=roi) 89 self.roi_ctl.configure(image=self.imgtk_roi, state='enable') 90 self.r_ctl.configure(text=str(r)) 91 self.update_time = time.time() 92 93 try: 94 c = self.color_transform[color] 95 self.color_ctl.configure(text=c[0], background=c[1], state='enable') 96 except: 97 self.color_ctl.configure(state='disabled') 98 99 if self.update_time + 8 < time.time(): 100 self.roi_ctl.configure(state='disabled') 101 self.r_ctl.configure(text="") 102 self.color_ctl.configure(state='disabled') 103 104 def show_img_pre(self): 105 pre_img1=cv2.imread('./carIdentityData/opencv_output/blur.jpg') 106 pre_img2=cv2.imread('./carIdentityData/opencv_output/sobel.jpg') 107 pre_img3=cv2.imread('./carIdentityData/opencv_output/hsv_pic.jpg') 108 pre_img4=cv2.imread('./carIdentityData/opencv_output/contour.jpg') 109 pre_img5=cv2.imread('./carIdentityData/opencv_output/floodfill.jpg') 110 pre_img6=cv2.imread('./carIdentityData/opencv_output/plates.jpg') 111 pre_img7=cv2.imread('./carIdentityData/opencv_output/cnn_plate.jpg') 112 113 cv2.imshow('blur',pre_img1) 114 cv2.imshow('sobel',pre_img2) 115 cv2.imshow('hsv_pic',pre_img3) 116 cv2.imshow('contour',pre_img4) 117 cv2.imshow('floodfill',pre_img5) 118 cv2.imshow('plates',pre_img6) 119 cv2.imshow('cnn_plate',pre_img7) 120 121 while True: 122 ch = cv2.waitKey(1) 123 if ch == 27: 124 break 125 cv2.destroyAllWindows() 126 127 128 def from_vedio(self): 129 video=[0,"http://admin:admin@192.168.0.13:8081","http://admin:admin@iPhone.local:8081","http://admin:admin@10.119.223.51:8081"] 130 ''' 131 默认情况下用户名和密码都是admin,客户端与IP摄像机服务器需处于同一局域网下,wifi 132 参数为0表示打开内置摄像头，参数是视频文件路径则打开视频 133 video="http://admin:admin@192.168.0.13:8081" 136 video = video[0] 137 capture =cv2.VideoCapture(video) 138 139 # 建个窗口并命名 140 cv2.namedWindow("camera",1) 141 num = 0 142 143 # 用于循环显示图片，达到显示视频的效果 144 while True: 145 ret, frame = capture.read() 146 147 # 在frame上显示test字符 148 image1=cv2.putText(frame,'test', (50,100), 149 cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (255, 0 ,0), 150 thickness = 2, lineType = 2) 151 152 cv2.imshow('camera',frame) 153 154 # 不加waitkey（） 则会图片显示后窗口直接关掉 155 key = cv2.waitKey(1) 156 157 if key == 27: 158 #esc键退出 159 print("esc break...") 160 break 161 162 if key == ord(' '): 163 # 保存一张图像 164 num = num+1 165 filename = "frames_%s.jpg" % num 166 print('已保存图片：%s.jpg' % num) 167 cv2.imwrite(filename,frame) 168 cv2.destroyAllWindows() 169 186 def from_pic(self): 187 self.thread_run = False 188 self.pic_path = askopenfilename(title="选择图片", filetypes=[("jpg", "*.jpg")]) 189 cur_dir = sys.path[0] 190 plate_model_path = os.path.join(cur_dir, './carIdentityData/model/plate_recongnize/model.ckpt-1020.meta') 191 char_model_path = os.path.join(cur_dir,'./carIdentityData/model/char_recongnize/model.ckpt-1030.meta') 192 193 if self.pic_path: 194 img_bgr = cv2.imread(self.pic_path) 195 self.imgtk = self.get_imgtk(img_bgr) 196 self.image_ctl.configure(image=self.imgtk) 197 #预处理 198 pred_img = carPlateIdentity.pre_process(img_bgr) 199 # 车牌定位 200 car_plate_list = carPlateIdentity.locate_carPlate(img_bgr,pred_img) 201 # CNN车牌过滤 202 ret,car_plate,color = carPlateIdentity.cnn_select_carPlate(car_plate_list,plate_model_path) 203 cv2.imwrite('./carIdentityData/opencv_output/cnn_plate.jpg', car_plate) 204 # 字符提取 205 char_img_list = carPlateIdentity.extract_char(car_plate) 206 # CNN字符识别 207 text = carPlateIdentity.cnn_recongnize_char(char_img_list, char_model_path) 208 print('result:', text) 209 #r, roi = self.predictor.predict(img_bgr)#识别到的字符、定位的车牌图像 210 self.show_roi(text, car_plate,color) 211 226 def close_window(): 227 print("destroy") 228 if surface.thread_run : 229 surface.thread_run = False 230 surface.thread.join(2.0) 231 win.destroy() 232 233 234 if __name__ == '__main__': 235 win = tk.Tk() 236 win.geometry('950x500') 237 238 surface = Surface(win) 239 win.protocol('WM_DELETE_WINDOW', close_window) 240 win.mainloop()#进入消息循环