OpenCV第七篇：车牌识别

╰半夏微凉° 2024-04-08 11:37 117阅读 0赞

**目录**

1.调整图片大小，并获取灰度图

2.双边滤波去除噪音：cv2.bilateralFilter()。

3.边缘检测：cv2.Canny（image，threshold1，threshold2）

4.寻找轮廓：车牌（四边形）

编辑 5.图像位运算进行遮罩

6.图像剪裁

7.字符识别：OCR

--------------------

![e8cc54c058df3c01888760c9654fb8f8.jpeg][]

#### 1.调整图片大小，并获取灰度图 ####

import cv2
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    
    
    
        # 显示效果
        cv2.imshow('original', img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![478e205556af4edf9ab87b67fd90448c.png][]

#### 2.双边滤波去除噪音：cv2.bilateralFilter()。 ####

import cv2
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray1 = cv2.bilateralFilter(gray, 13, 15, 15)
    
        # 显示效果
        cv2.imshow('gray', gray)
        cv2.imshow('bilateralFilter', gray1)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![86a3d6b68d3b4927b308c6b3ad2a0fda.png][]

#### 3.边缘检测：cv2.Canny（image，threshold1，threshold2） ####

仅显示强度梯度大于最小阈值threshold1且小于最大阈值threshold2的边缘。

import cv2
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray = cv2.bilateralFilter(gray, 13, 15, 15)
        # 边缘检测
        edged = cv2.Canny(gray, 30, 200)
    
    
    
    
        # 显示效果
        cv2.imshow('gray', gray)
        cv2.imshow('edged', edged)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![2d0bcadbefd6431a860f6dd949e3da87.png][]

#### 4.寻找轮廓：车牌（四边形） ####

pip install imutils

import cv2
    import imutils
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray = cv2.bilateralFilter(gray, 13, 15, 15)
        # 边缘检测
        edged = cv2.Canny(gray, 30, 200)
    
    
        # 寻找轮廓（图像矩阵，输出模式，近似方法）
        contours = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        # 配合上面一句使用：用来兼容cv2和cv3
        contours = imutils.grab_contours(contours)
        # 根据区域大小排序取前十个
        contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]
        screenCnt = None
        # 遍历轮廓，找到车牌轮廓
        for c in contours:
            # 计算轮廓周长（轮廓，是否闭合）
            peri = cv2.arcLength(c, True)
            # 折线化（轮廓，阈值（越小越接近曲线），是否闭合）返回折线顶点坐标
            approx = cv2.approxPolyDP(c, 0.018 * peri, True)
            # 获取四个顶点（即四边形）
            if len(approx) == 4:
                screenCnt = approx
                break
        # 如果找到了四边形
        if screenCnt is not None:
            # 根据四个顶点坐标对img画线(图像矩阵，轮廓坐标集，轮廓索引，颜色，线条粗细)
            cv2.drawContours(img, [screenCnt], -1, (0, 0, 255), 3)
    
    
    
        # 显示效果
        cv2.imshow('img', img)
        cv2.imshow('gray', gray)
        cv2.imshow('edged', edged)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

#### ![bce3e20b93d24f5fbfe2768f32cf3ecb.png][] 5.图像位运算进行遮罩 ####

import cv2
    import imutils
    import numpy as np
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray = cv2.bilateralFilter(gray, 13, 15, 15)
        # 边缘检测
        edged = cv2.Canny(gray, 30, 200)
    
        """寻找轮廓（图像矩阵，输出模式，近似方法）"""
        contours = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        # 配合上面一句使用：用来兼容cv2和cv3
        contours = imutils.grab_contours(contours)
        # 根据区域大小排序取前十个
        contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]
        screenCnt = None
        # 遍历轮廓，找到车牌轮廓
        for c in contours:
            # 计算轮廓周长（轮廓，是否闭合）
            peri = cv2.arcLength(c, True)
            # 折线化（轮廓，阈值（越小越接近曲线），是否闭合）返回折线顶点坐标
            approx = cv2.approxPolyDP(c, 0.018 * peri, True)
            # 获取四个顶点（即四边形）
            if len(approx) == 4:
                screenCnt = approx
                break
        # 如果找到了四边形
        if screenCnt is not None:
            # 根据四个顶点坐标对img画线(图像矩阵，轮廓坐标集，轮廓索引，颜色，线条粗细)
            cv2.drawContours(img, [screenCnt], -1, (0, 0, 255), 3)
    
        """遮罩"""
        # 创建一个灰度图一样大小的图像矩阵
        mask = np.zeros(gray.shape, np.uint8)
        # 将创建的图像矩阵的车牌区域画成白色
        cv2.drawContours(mask, [screenCnt], 0, 255, -1, )
        # 图像位运算进行遮罩
        new_image = cv2.bitwise_and(img, img, mask=mask)
    
    
        # 显示效果
        cv2.imshow('img', img)
        cv2.imshow('gray', gray)
        cv2.imshow('edged', edged)
        cv2.imshow('new_image', new_image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![4362bdafa785418898b31e028db841be.png][]

#### 6.图像剪裁 ####

import cv2
    import imutils
    import numpy as np
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray = cv2.bilateralFilter(gray, 13, 15, 15)
        # 边缘检测
        edged = cv2.Canny(gray, 30, 200)
    
        """寻找轮廓（图像矩阵，输出模式，近似方法）"""
        contours = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        # 配合上面一句使用：用来兼容cv2和cv3
        contours = imutils.grab_contours(contours)
        # 根据区域大小排序取前十个
        contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]
        screenCnt = None
        # 遍历轮廓，找到车牌轮廓
        for c in contours:
            # 计算轮廓周长（轮廓，是否闭合）
            peri = cv2.arcLength(c, True)
            # 折线化（轮廓，阈值（越小越接近曲线），是否闭合）返回折线顶点坐标
            approx = cv2.approxPolyDP(c, 0.018 * peri, True)
            # 获取四个顶点（即四边形）
            if len(approx) == 4:
                screenCnt = approx
                break
        # 如果找到了四边形
        if screenCnt is not None:
            # 根据四个顶点坐标对img画线(图像矩阵，轮廓坐标集，轮廓索引，颜色，线条粗细)
            cv2.drawContours(img, [screenCnt], -1, (0, 0, 255), 3)
    
        """遮罩"""
        # 创建一个灰度图一样大小的图像矩阵
        mask = np.zeros(gray.shape, np.uint8)
        # 将创建的图像矩阵的车牌区域画成白色
        cv2.drawContours(mask, [screenCnt], 0, 255, -1, )
        # 图像位运算进行遮罩
        new_image = cv2.bitwise_and(img, img, mask=mask)
    
        """图像剪裁"""
        # 获取车牌区域的所有坐标点
        (x, y) = np.where(mask == 255)
        # 获取底部顶点坐标
        (topx, topy) = (np.min(x), np.min(y))
        # 获取底部坐标
        (bottomx, bottomy,) = (np.max(x), np.max(y))
        # 剪裁
        Cropped = gray[topx:bottomx, topy:bottomy]
    
        # 显示效果
        cv2.imshow('img', img)
        cv2.imshow('gray', gray)
        cv2.imshow('edged', edged)
        cv2.imshow('Cropped', Cropped)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![1770c4cbcc424b03a02527fe7d08fd04.png][]

#### 7.字符识别：OCR ####

import cv2
    import imutils
    import numpy as np
    
    if __name__ == '__main__':
        img = cv2.imread('2.jpeg')
        # 调整图片大小
        img = cv2.resize(img, (620, 480))
        # 灰度图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 双边滤波
        gray = cv2.bilateralFilter(gray, 13, 15, 15)
        # 边缘检测
        edged = cv2.Canny(gray, 30, 200)
    
        """寻找轮廓（图像矩阵，输出模式，近似方法）"""
        contours = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        # 配合上面一句使用：用来兼容cv2和cv3
        contours = imutils.grab_contours(contours)
        # 根据区域大小排序取前十个
        contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]
        screenCnt = None
        # 遍历轮廓，找到车牌轮廓
        for c in contours:
            # 计算轮廓周长（轮廓，是否闭合）
            peri = cv2.arcLength(c, True)
            # 折线化（轮廓，阈值（越小越接近曲线），是否闭合）返回折线顶点坐标
            approx = cv2.approxPolyDP(c, 0.018 * peri, True)
            # 获取四个顶点（即四边形）
            if len(approx) == 4:
                screenCnt = approx
                break
        # 如果找到了四边形
        if screenCnt is not None:
            # 根据四个顶点坐标对img画线(图像矩阵，轮廓坐标集，轮廓索引，颜色，线条粗细)
            cv2.drawContours(img, [screenCnt], -1, (0, 0, 255), 3)
    
        """遮罩"""
        # 创建一个灰度图一样大小的图像矩阵
        mask = np.zeros(gray.shape, np.uint8)
        # 将创建的图像矩阵的车牌区域画成白色
        cv2.drawContours(mask, [screenCnt], 0, 255, -1, )
        # 图像位运算进行遮罩
        new_image = cv2.bitwise_and(img, img, mask=mask)
    
        """图像剪裁"""
        # 获取车牌区域的所有坐标点
        (x, y) = np.where(mask == 255)
        # 获取底部顶点坐标
        (topx, topy) = (np.min(x), np.min(y))
        # 获取底部坐标
        (bottomx, bottomy,) = (np.max(x), np.max(y))
        # 剪裁
        Cropped = gray[topx:bottomx, topy:bottomy]
    
        """OCR识别"""
        text = pytesseract.image_to_string(Cropped, config='--psm 11')
        print("车牌结果：", text)
    
        # 显示效果
        cv2.imshow('img', img)
        cv2.imshow('gray', gray)
        cv2.imshow('edged', edged)
        cv2.imshow('new_image', Cropped)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

![f939eef6a965414abf2376265af18c17.png][]

[e8cc54c058df3c01888760c9654fb8f8.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/199f466481bd4446971d51e9abbaf2cc.jpeg
[478e205556af4edf9ab87b67fd90448c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2b509f7e2760435899d9d018d3dfb3aa.png
[86a3d6b68d3b4927b308c6b3ad2a0fda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/7e320681d40c4df6a07f5c4a58ea7f0b.png
[2d0bcadbefd6431a860f6dd949e3da87.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/e380b55984434d668f6722c4065acbc5.png
[bce3e20b93d24f5fbfe2768f32cf3ecb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/41e55e50c5e34e2d919230f5e413f5ba.png
[4362bdafa785418898b31e028db841be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d0bfe7e8626746c5a37e2c95f2b0da09.png
[1770c4cbcc424b03a02527fe7d08fd04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d3d205b6109d49bf8df0f7a23ce0f0d8.png
[f939eef6a965414abf2376265af18c17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/3daeb685d7ec4e1a9978c80bb627689b.png