【Python】 Python + OpenCV 实现车牌自动识别

于 2025-06-01 23:05:49 发布
阅读量598 收藏 26
点赞数 19
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangjia96/article/details/148371675
版权

Python + OpenCV 实现车牌自动识别

车牌自动识别（Automatic License Plate Recognition, ALPR）或称车牌识别（License Plate Recognition, LPR）系统在智能交通、停车场管理、安防监控等领域有着广泛的应用。其核心任务是从图像或视频中自动检测、定位车牌，并识别出车牌上的字符信息。本系列将详细介绍如何使用Python和OpenCV库来实现一个基本的车牌识别系统。

1 导入相关模块

在开始项目之前，我们需要导入一些必要的Python库。这些库将为我们提供图像处理、数值计算和图像显示等功能。

  • OpenCV (cv2): 开源计算机视觉库，包含了大量的图像处理和计算机视觉算法。它是我们这个项目的核心。如果尚未安装，可以通过 pip install opencv-python opencv-contrib-python (后者包含了一些额外的模块，可选但有时有用) 进行安装。
  • NumPy (numpy): Python中用于科学计算的基础包，尤其擅长处理大型多维数组和矩阵。OpenCV的图像数据通常以NumPy数组的形式存在。如果尚未安装，可以通过 pip install numpy 进行安装。
  • Matplotlib (matplotlib.pyplot): 一个强大的Python绘图库，常用于数据的可视化，包括显示图像。如果尚未安装，可以通过 pip install matplotlib 进行安装。
  • OS (os): Python内置的与操作系统交互的模块，例如用于文件路径操作、列出目录内容等。
  • Glob (glob): Python内置的文件名模式匹配模块，可以方便地查找符合特定规则的文件路径名。
# 基础模块导入
import cv2 # 导入OpenCV库，用于图像处理和计算机视觉任务
import numpy as np # 导入NumPy库，用于进行高效的数值计算，特别是数组操作
import matplotlib.pyplot as plt # 导入Matplotlib的pyplot模块，用于图像显示和绘图

# 文件系统操作相关模块 (根据后续需求可能用到)
import os # 导入OS模块，用于与操作系统进行交互，如路径操作、文件列表等
import glob # 导入Glob模块，用于查找匹配特定模式的文件路径名

# 配置Matplotlib在Jupyter Notebook或类似环境中正确显示图像
# %matplotlib inline 
# 上面这行是Jupyter Notebook中的魔法命令，如果你在IDE如VS Code或PyCharm中运行，
# 并且希望图像在单独的窗口中弹出，则不需要这行，plt.show()会自动处理。
# 如果在Jupyter中，它可以让图像直接嵌入到notebook的输出中。

print("所有基础模块导入成功！") # 打印成功导入模块的消息
print(f"OpenCV 版本: {
     cv2.__version__}") # 打印已安装的OpenCV版本号
print(f"NumPy 版本: {
     np.__version__}") # 打印已安装的NumPy版本号
import matplotlib # 导入matplotlib主模块以获取版本号
print(f"Matplotlib 版本: {
     matplotlib.__version__}") # 打印已安装的Matplotlib版本号

中文解释:
import cv2: 导入OpenCV库，后续代码中将使用 cv2 作为其别名来调用其函数和类。
import numpy as np: 导入NumPy库，并使用 np 作为其别名。这是NumPy社区的通用约定。
import matplotlib.pyplot as plt: 导入Matplotlib库中的 pyplot 子模块，并使用 plt 作为其别名。pyplot 提供了一个类似MATLAB的绘图框架。
import os: 导入Python的 os 模块，它提供了访问操作系统功能的接口，例如文件和目录操作。
import glob: 导入Python的 glob 模块，用于根据Unix shell风格的模式匹配查找文件路径。
# %matplotlib inline: 这是一个Jupyter Notebook的“魔法命令”。如果代码在Jupyter Notebook环境中运行，这条命令会使得Matplotlib生成的图像直接嵌入到Notebook的输出单元格中，而不是弹出新的窗口。如果在标准的Python脚本或IDE中运行，通常不需要这条命令，plt.show() 会负责显示图像。
print("所有基础模块导入成功！"): 打印一条消息，确认模块已成功加载。
print(f"OpenCV 版本: {cv2.__version__}"): 打印当前环境中安装的OpenCV库的版本号。__version__ 是许多Python包中用于存储版本信息的标准属性。
print(f"NumPy 版本: {np.__version__}"): 打印当前环境中安装的NumPy库的版本号。
import matplotlib: 为了获取Matplotlib的版本号，有时需要导入其主模块。
print(f"Matplotlib 版本: {matplotlib.__version__}"): 打印当前环境中安装的Matplotlib库的版本号。

关于模块版本：
了解所使用库的版本是很重要的，因为不同版本之间可能存在API的不兼容性或功能差异。在复现他人代码或进行团队协作时，版本一致性有助于避免不必要的麻烦。

环境配置建议：
为了项目的稳定性和可复现性，强烈建议使用虚拟环境（如 venv、conda）来管理项目的依赖。
例如，使用 venv:

  1. 创建虚拟环境: python -m venv my_lpr_env
  2. 激活虚拟环境:
    • Windows: my_lpr_env\Scripts\activate
    • macOS/Linux: source my_lpr_env/bin/activate
  3. 在激活的环境中安装所需库: pip install opencv-python numpy matplotlib
  4. 当完成工作后，停用虚拟环境: deactivate

使用 conda (如果你安装了Anaconda或Miniconda):

  1. 创建虚拟环境并指定Python版本（可选）: conda create -n my_lpr_env python=3.9
  2. 激活虚拟环境: conda activate my_lpr_env
  3. 在激活的环境中安装所需库: conda install opencv numpy matplotlib (conda通常能更好地处理复杂的二进制依赖)
  4. 当完成工作后，停用虚拟环境: conda deactivate

这种做法可以将项目依赖与系统全局的Python环境隔离开，避免版本冲突。

2 相关功能函数定义

在进行复杂的图像处理任务时，定义一些可重用的辅助函数是一个好习惯。这不仅能使主流程代码更简洁，也便于调试和维护。根据您提供的目录，我们来定义以下几个核心的辅助函数。

2.1 彩色图片显示函数（plt_show0）

OpenCV读取彩色图像时，默认的颜色通道顺序是BGR（Blue, Green, Red），而Matplotlib期望的顺序是RGB（Red, Green, Blue）。因此，如果直接用Matplotlib显示OpenCV读取的彩色图像，颜色会出现偏差（例如，蓝色和红色通道会互换）。这个函数将负责处理颜色通道的转换并使用Matplotlib显示彩色图像。

def plt_show0(image_bgr):
    """
    使用 Matplotlib 显示 BGR 顺序的彩色图像。
    OpenCV 读取的彩色图像默认为 BGR 格式，而 Matplotlib 显示时需要 RGB 格式。
    此函数会自动进行颜色空间转换。

    参数:
    image_bgr (numpy.ndarray): OpenCV读取的BGR格式的图像。
    """
    if image_bgr is None: # 检查图像是否为空
        print("错误：输入的图像为 None，无法显示。") # 打印错误信息
        return # 直接返回

    if image_bgr.ndim == 2: # 检查图像是否为灰度图 (二维数组)
        print("提示：输入的是灰度图像，将直接使用灰度色彩映射显示。") # 打印提示信息
        # 对于灰度图，Matplotlib默认处理得很好，但明确指定cmap='gray'更清晰
        plt.imshow(image_bgr, cmap='gray') # 使用灰度色彩映射显示灰度图像
        plt.title("Grayscale Image (via plt_show0)") # 设置图像标题
        plt.axis('off') # 关闭坐标轴显示，使图像更纯粹
        plt.show() # 显示图像
        return # 处理完毕，返回

    elif image_bgr.ndim == 3 and image_bgr.shape[2] == 3: # 检查图像是否为三通道彩色图
        # 将 BGR 转换为 RGB
        image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) # 进行颜色空间转换，从BGR到RGB
        
        plt.figure(figsize=(10, 8)) # 创建一个新的图形窗口，并设置其大小 (可选)
        plt.imshow(image_rgb) # 使用Matplotlib显示RGB图像
        plt.title("Color Image (BGR to RGB)") # 设置图像的标题
        plt.axis('off') # 关闭坐标轴的显示，使图像看起来更干净
        plt.show() # 执行显示操作，弹出图像窗口或在Jupyter中内嵌显示
    
    elif image_bgr.ndim == 3 and image_bgr.shape[2] == 4: # 检查图像是否为BGRA四通道彩色图
        print("提示：输入的是BGRA四通道图像，将转换为RGBA后显示。") # 打印提示信息
        image_rgba = cv2.cvtColor(image_bgr, cv2.COLOR_BGRA2RGBA) # 进行颜色空间转换，从BGRA到RGBA
        
        plt.figure(figsize=(10, 8)) # 创建一个新的图形窗口
        plt.imshow(image_rgba) # 显示RGBA图像
        plt.title("Color Image with Alpha (BGRA to RGBA)") # 设置图像标题
        plt.axis('off') # 关闭坐标轴显示
        plt.show() # 显示图像
    
    else: # 其他未知图像格式
        print(f"错误：输入的图像格式不受支持。图像维度: {
     image_bgr.ndim}, 形状: {
     image_bgr.shape}") # 打印错误信息
        # 可以尝试直接显示，但颜色可能不正确
        # plt.imshow(image_bgr)
        # plt.title("Unsupported Image Format (Raw Display)")
        # plt.axis('off')
        # plt.show()

# 示例：创建一个简单的BGR图像并用 plt_show0 显示
# 假设有一个3x3的蓝色图像 (BGR中B分量最大)
# B=255, G=0, R=0
sample_bgr_image = np.zeros((100, 100, 3), dtype=np.uint8) # 创建一个100x100的黑色图像
sample_bgr_image[:, :, 0] = 255 # 将蓝色通道设置为最大值255，使其变为蓝色

print("\n测试 plt_show0 函数:") # 打印测试信息
# plt_show0(sample_bgr_image) # 调用函数显示示例BGR图像
# 注意：在非Jupyter环境中，plt.show() 会阻塞后续代码执行，直到窗口关闭。
# 在自动生成长文本时，为了避免阻塞，这里暂时注释掉实际的show调用。
# 您可以在自己的环境中取消注释来查看效果。
print("plt_show0 函数定义完成并通过了基本结构测试。") # 打印完成信息

中文解释:
def plt_show0(image_bgr):: 定义名为 plt_show0 的函数，它接受一个参数 image_bgr，预期是OpenCV读取的BGR格式图像。
if image_bgr is None:: 检查传入的图像是否为 None（例如，文件读取失败时可能发生）。如果是，则打印错误并返回。
if image_bgr.ndim == 2:: 检查图像的维度。ndim 是NumPy数组的属性，表示数组的轴数。如果是2维数组，通常表示它是灰度图像。
print("提示：输入的是灰度图像，将直接使用灰度色彩映射显示。"): 打印一条信息。
plt.imshow(image_bgr, cmap='gray'): 对于灰度图像，直接使用 plt.imshow 显示，并通过 cmap='gray' 指定使用灰度颜色映射。
plt.title("Grayscale Image (via plt_show0)"): 设置图像窗口或子图的标题。
plt.axis('off'): 关闭坐标轴的刻度和标签，使图像显示更简洁。
plt.show(): 显示图像。在脚本中运行时，它会打开一个新窗口；在Jupyter Notebook中（如果配置了 %matplotlib inline 或类似后端），它会将图像嵌入输出。
return: 结束函数执行。
elif image_bgr.ndim == 3 and image_bgr.shape[2] == 3:: 检查图像是否为3维数组，并且第三个维度（通道数）是否为3。这对应于标准的BGR或RGB彩色图像。image_bgr.shape 返回一个元组，表示图像在各个维度上的大小 (高度, 宽度, 通道数)。
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB): 使用OpenCV的 cvtColor 函数将图像从BGR颜色空间转换为RGB颜色空间。这是关键步骤，因为Matplotlib期望RGB顺序。
plt.figure(figsize=(10, 8)): (可选) 创建一个新的Matplotlib图形（figure），并可以指定其大小（宽度10英寸，高度8英寸）。这有助于在显示较大图像时获得更好的视觉效果。如果省略，Matplotlib会使用默认大小。
plt.imshow(image_rgb): 使用转换后的RGB图像进行显示。
plt.title("Color Image (BGR to RGB)"): 设置彩色图像的标题。
elif image_bgr.ndim == 3 and image_bgr.shape[2] == 4:: 检查图像是否为4通道图像 (例如 BGRA 或 RGBA，A代表Alpha透明通道)。
print("提示：输入的是BGRA四通道图像，将转换为RGBA后显示。"): 打印信息。
image_rgba = cv2.cvtColor(image_bgr, cv2.COLOR_BGRA2RGBA): 将BGRA图像转换为RGBA图像。Matplotlib的 imshow 可以直接处理RGBA图像。
else:: 如果图像的维度和通道数不符合灰度图、三通道彩色图或四通道彩色图的预期。
print(f"错误：输入的图像格式不受支持..."): 打印错误消息，指出图像的维度和形状。
sample_bgr_image = np.zeros((100, 100, 3), dtype=np.uint8): 创建一个 NumPy 数组，形状为 (100, 100, 3)，数据类型为 np.uint8 (无符号8位整数，常用于表示像素值0-255)。初始时所有像素为0（黑色）。
sample_bgr_image[:, :, 0] = 255: 将这个图像的所有像素的第0个通道（BGR中的B通道）设置为255。这样 sample_bgr_image 就变成了一个纯蓝色的图像。
print("\n测试 plt_show0 函数:"): 打印测试信息。
# plt_show0(sample_bgr_image): 调用 plt_show0 函数来显示这个蓝色的BGR图像。由于 plt.show() 在某些环境下会阻塞，这里注释掉了。
print("plt_show0 函数定义完成并通过了基本结构测试。"): 打印函数定义完成的消息。

2.2 灰度图片显示函数（plt_show）

虽然上面的 plt_show0 函数也能处理灰度图，但有时我们可能希望有一个专门用于显示灰度图的函数，它在调用时更明确，并且可以省去不必要的颜色空间检查。Matplotlib显示灰度图时，使用 cmap='gray' 参数可以确保以灰度方式渲染。

def plt_show(image_gray, title="Grayscale Image"):
    """
    使用 Matplotlib 显示灰度图像。

    参数:
    image_gray (numpy.ndarray): 单通道的灰度图像。
    title (str, 可选): 图像显示的标题，默认为 "Grayscale Image"。
    """
    if image_gray is None: # 检查图像是否为空
        print("错误：输入的图像为 None，无法显示。") # 打印错误信息
        return # 直接返回

    if image_gray.ndim == 3 and image_gray.shape[2] == 1: # 检查是否为 (H, W, 1) 形状的单通道图
        print("提示：输入的是形状为 (H, W, 1) 的单通道图像，将进行压缩以正确显示为灰度图。") # 打印提示信息
        image_gray_squeezed = np.squeeze(image_gray, axis=2) # 移除单维度条目，将其从 (H,W,1) 变为 (H,W)
        # 或者 image_gray_squeezed = image_gray[:, :, 0]
        
        # 检查压缩后的图像是否确实是二维的
        if image_gray_squeezed.ndim != 2:
            print(f"错误：图像压缩后维度不为2，无法按预期显示为灰度图。当前维度: {
     image_gray_squeezed.ndim}")
            return
        
        plt.figure(figsize=(10, 8)) # 创建一个新的图形窗口 (可选)
        plt.imshow(image_gray_squeezed, cmap='gray') # 使用 'gray' 色彩映射显示图像
        plt.title(title + " (Squeezed from 3D)") # 设置图像标题，并注明经过压缩
        plt.axis('off') # 关闭坐标轴
        plt.show() # 显示图像

    elif image_gray.ndim == 2: # 检查图像是否为二维 (标准的灰度图像格式)
        plt.figure(figsize=(10, 8)) # 创建一个新的图形窗口 (可选)
        plt.imshow(image_gray, cmap='gray') # 使用 'gray' 色彩映射显示图像
        plt.title(title) # 设置图像标题
        plt.axis('off') # 关闭坐标轴
        plt.show() # 显示图像
        
    elif image_gray.ndim == 3 and image_gray.shape[2] == 3: # 尝试处理误传的彩色图
        print("警告：输入到 plt_show (灰度图显示函数) 的似乎是彩色图像。") # 打印警告信息
        print("将尝试转换为灰度图后显示。如果这不是预期行为，请检查输入。") # 打印进一步警告
        try:
            # 尝试使用OpenCV的標準方法將BGR彩色圖像轉換為灰度圖像
            # 注意：如果原始彩色圖是RGB，這裡轉換結果可能不是預期的亮度
            # 但既然是灰度显示函数，做一次灰度转换是合理的尝试
            image_converted_gray = cv2.cvtColor(image_gray, cv2.COLOR_BGR2GRAY) # 将BGR图像转为灰度图
            plt.figure(figsize=(10, 8)) # 创建新图形
            plt.imshow(image_converted_gray, cmap='gray') # 显示转换后的灰度图
            plt.title(title + " (Converted from Color)") # 设置标题
            plt.axis('off') # 关闭坐标轴
            plt.show() # 显示图像
        except cv2.error as e: # 捕获OpenCV转换错误
            print(f"错误：尝试将输入图像转换为灰度图时发生OpenCV错误: {
     e}") # 打印OpenCV错误
            print("将尝试按原样显示，颜色可能不正确。") # 打印回退尝试信息
            plt_show0(image_gray) # 回退到使用 plt_show0 显示，它能处理彩色图
            
    else: # 其他未知图像格式
        print(f"错误：输入的图像格式不适合作为灰度图显示。图像维度: {
     image_gray.ndim}, 形状: {
     image_gray.shape}") # 打印格式错误信息
        # 可以考虑调用 plt_show0 尝试显示
        # plt_show0(image_gray)


# 示例：创建一个简单的灰度图像并用 plt_show 显示
# 创建一个从黑到白的渐变灰度图像
sample_gray_image = np.tile(np.arange(256, dtype=np.uint8), (256, 1)) # 创建一个0-255的行向量，并垂直平铺256次

print("\n测试 plt_show 函数:") # 打印测试信息
# plt_show(sample_gray_image, title="Test Gradient Gray Image") # 调用函数显示示例灰度图像
# plt_show(sample_bgr_image) # 测试传入彩色图到灰度显示函数
print("plt_show 函数定义完成并通过了基本结构测试。") # 打印完成信息

中文解释:
def plt_show(image_gray, title="Grayscale Image"):: 定义名为 plt_show 的函数，接受一个灰度图像 image_gray 和一个可选的标题 title。
if image_gray is None:: 检查输入图像是否为 None。
if image_gray.ndim == 3 and image_gray.shape[2] == 1:: 检查图像是否是 (高度, 宽度, 1) 形状的3维数组。有些OpenCV操作可能会产生这种形式的单通道图像。Matplotlib的 imshow 对于这种形状的图像，如果不指定 cmap，可能会用默认的彩色映射，或者需要将其“压缩”成2D数组。
print("提示：输入的是形状为 (H, W, 1) 的单通道图像，将进行压缩以正确显示为灰度图。"): 打印信息。
image_gray_squeezed = np.squeeze(image_gray, axis=2): 使用 np.squeeze 移除大小为1的维度（在这里是第2轴，即通道轴），将其从 (H,W,1) 变为 (H,W)。
if image_gray_squeezed.ndim != 2:: 进一步检查，确保压缩后是二维的。
plt.imshow(image_gray_squeezed, cmap='gray'): 使用灰度色彩映射显示压缩后的2D图像。
plt.title(title + " (Squeezed from 3D)"): 设置标题，并注明图像经过了压缩处理。
elif image_gray.ndim == 2:: 如果图像本身就是2维的，这是标准的灰度图像格式。
plt.imshow(image_gray, cmap='gray'): 直接使用灰度色彩映射显示。
elif image_gray.ndim == 3 and image_gray.shape[2] == 3:: 这是一个额外的健壮性处理。如果用户错误地将一个三通道彩色图像传递给了这个期望灰度图的函数。
print("警告：输入到 plt_show (灰度图显示函数) 的似乎是彩色图像。"): 打印警告。
image_converted_gray = cv2.cvtColor(image_gray, cv2.COLOR_BGR2GRAY): 尝试将输入的BGR图像转换为灰度图像。这是基于OpenCV的常见行为。
plt.imshow(image_converted_gray, cmap='gray'): 显示转换后的灰度图像。
except cv2.error as e:: 如果 cv2.cvtColor 发生错误（例如，输入的不是有效的BGR图像）。
print(f"错误：尝试将输入图像转换为灰度图时发生OpenCV错误: {e}"): 打印错误。
plt_show0(image_gray): 作为一种回退机制，尝试使用之前定义的 plt_show0 函数来显示图像，因为它能更好地处理彩色图和未知格式。
else:: 如果图像的维度和通道数不符合上述任何一种情况。
print(f"错误：输入的图像格式不适合作为灰度图显示..."): 打印格式不匹配的错误。
sample_gray_image = np.tile(np.arange(256, dtype=np.uint8), (256, 1)): 创建一个测试用的灰度图像。
np.arange(256, dtype=np.uint8): 创建一个从0到255的一维数组（代表灰度级）。
np.tile(..., (256, 1)): 将这个一维数组垂直堆叠256次，形成一个256x256的图像，其每一行都是从0到255的渐变。这将产生一个从左到右由黑变白的水平渐变条纹。为了得到从上到下或从左到右的平滑渐变，可以调整 tile 或使用 np.linspace 和 np.meshgrid。
更正：为了得到一个从左到右的渐变条（每列相同，行不同），应该是 sample_gray_image = np.tile(np.arange(256, dtype=np.uint8).reshape(1, -1), (256, 1))。
或者一个从上到下的渐变（每行相同，列不同）： sample_gray_image = np.tile(np.arange(256, dtype=np.uint8).reshape(-1, 1), (1, 256))。
当前代码 np.tile(np.arange(256, dtype=np.uint8), (256, 1)) 会创建256行，每行都是0-255的序列，即图像最左边一列是0，最右边一列是255，形成水平渐变。
print("\n测试 plt_show 函数:"): 打印测试信息。
# plt_show(sample_gray_image, title="Test Gradient Gray Image"): 调用 plt_show 显示创建的灰度渐变图。
# plt_show(sample_bgr_image): 测试将之前创建的蓝色BGR图像传递给 plt_show 函数，以观察其彩色图处理逻辑。
print("plt_show 函数定义完成并通过了基本结构测试。"): 打印完成信息。

深入探讨 plt.imshow 和 cmap:
plt.imshow() 是Matplotlib中显示图像（或更广义地说，二维栅格数据）的核心函数。

  • 数据类型: imshow 可以处理多种数据类型的NumPy数组。
    • 对于 uint8 (0-255) 或 uint16 (0-65535) 类型的数据，它会直接映射这些值到颜色。
    • 对于浮点型数据（例如，float32 或 float64），imshow 通常期望数据范围在 [0.0, 1.0]（对于RGB/RGBA）或 [min_val, max_val]（对于需要色彩映射的单通道数据）。如果浮点数据超出 [0.0, 1.0]，颜色可能会被裁剪，除非进行了归一化或使用了 vmin, vmax 参数。
  • cmap (Colormap): 这个参数指定了如何将单通道图像（灰度图或伪彩色图）的标量数据值映射到颜色。
    • cmap='gray': 常见的灰度色彩映射，将低值映射为黑色，高值映射为白色。
    • cmap='viridis', 'plasma', 'magma', 'inferno': Perceptually uniform colormaps，推荐用于科学可视化，因为它们能更好地表示数据的真实变化，避免了某些传统彩虹色图（如'jet'）可能引入的视觉误导。
    • cmap='jet': 一种传统的彩虹色图，虽然流行，但因其非均匀的亮度变化而不被推荐用于精确的数据表示。
    • 还有许多其他内置的色彩映射，如 'hot', 'coolwarm', 'Spectral' 等。
  • interpolation: 当显示的图像分辨率与屏幕像素不完全匹配时，imshow 需要进行插值。默认的插值方法（如 'antialiased' 或 'nearest'）可能因Matplotlib版本而异。可以指定不同的插值方法，例如：
    • 'nearest': 最近邻插值，不进行平滑，像素块感强，适合查看原始像素。
    • 'bilinear': 双线性插值，进行平滑。
    • 'bicubic': 双三次插值，更平滑。
    • 还有 'spline16', 'spline36', 'hanning', 'hamming', 'gaussian' 等多种选择。
      例如：plt.imshow(image_gray, cmap='gray', interpolation='nearest')
  • aspect: 控制图像的宽高比。
    • 'equal': 使像素为正方形。如果图像的x和y轴单位相同，这将保持图像的真实形状。
    • 'auto': 自动调整宽高比以适应绘图区域。
    • 一个浮点数：设置y轴与x轴的比例。
  • vmin, vmax: 手动设置色彩映射的数据范围。数据值低于vmin的将被映射到色彩映射的最低端，高于vmax的将被映射到最高端。这对于比较多张图像或突出特定数据范围非常有用。

2.3 图像去噪函数（gray_guss -> 修正为 gray_gaussian_blur 或类似）

高斯模糊（Gaussian Blur）是一种常见的图像平滑技术，用于减少图像噪声和细节。它通过将每个像素的值替换为其邻域像素值的加权平均值来实现，权重由高斯函数确定。函数名 gray_guss 可能是一个笔误，通常会命名为更具描述性的名称，如 apply_gaussian_blur_gray 或 gray_gaussian_blur。这里我们按照用户的命名意图，但内部实现是高斯模糊。

def gray_guss(image_gray, ksize=(5, 5), sigmaX=0, sigmaY=None):
    """
    对输入的灰度图像应用高斯模糊。

    参数:
    image_gray (numpy.ndarray): 输入的单通道灰度图像。
    ksize (tuple of int, 可选): 高斯核的大小，格式为 (width, height)。
                                 宽度和高度必须是正奇数。默认为 (5, 5)。
    sigmaX (float, 可选): X方向的高斯核标准差。如果为0，则根据核大小自动计算。
                          默认为0。
    sigmaY (float, 可选): Y方向的高斯核标准差。如果为None (或0)，则与sigmaX相同。
                          如果sigmaX也为0，则根据核大小自动计算。默认为None。

    返回:
    numpy.ndarray: 应用高斯模糊后的灰度图像。
                   如果输入图像为None，则返回None。
    """
    if image_gray is None: # 检查输入图像是否为空
        print("错误：输入到 gray_guss 的图像为 None。") # 打印错误信息
        return None # 返回None

    if not (isinstance(ksize, tuple) and len(ksize) == 2 and 
            isinstance(ksize[0], int) and isinstance(ksize[1], int) and 
            ksize[0] > 0 and ksize[1] > 0 and 
            ksize[0] % 2 == 1 and ksize[1] % 2 == 1): # 检查ksize的有效性
        print(f"错误：ksize 参数 '{
     ksize}' 无效。它必须是一个包含两个正奇整数的元组 (width, height)。") # 打印ksize错误信息
        print("将使用默认值 (5,5) 代替。") # 打印使用默认值的信息
        ksize_corrected = (5, 5) # 使用修正后的默认ksize
    else:
        ksize_corrected = ksize # 使用用户提供的有效ksize

    if image_gray.ndim == 3 and image_gray.shape[2] == 1: # 处理 (H, W, 1) 格式的灰度图
        print("提示 (gray_guss): 输入的是(H,W,1)形状的灰度图，将进行处理。") # 打印提示信息
        # GaussianBlur 可以直接处理这种格式，但结果也是 (H,W,1)
        blurred_image = cv2.GaussianBlur(image_gray, ksize_corrected, sigmaX, sigmaY=sigmaY) # 应用高斯模糊
        return blurred_image # 返回模糊后的图像

    elif image_gray.ndim == 2: # 标准的二维灰度图
        blurred_image = cv2.GaussianBlur(image_gray, ksize_corrected, sigmaX, sigmaY=sigmaY) # 应用高斯模糊
        return blurred_image # 返回模糊后的图像
        
    elif image_gray.ndim == 3 and image_gray.shape[2] == 3: # 如果传入了彩色图
        print("警告 (gray_guss): 输入到 gray_guss 的是彩色图像。") # 打印彩色图警告
        print("将先转换为灰度图，然后应用高斯模糊。") # 打印转换提示
        try:
            gray_converted = cv2.cvtColor(image_gray, cv2.COLOR_BGR2GRAY) # 转换为灰度图
            blurred_image = cv2.GaussianBlur(gray_converted, ksize_corrected, sigmaX, sigmaY=sigmaY) # 应用高斯模糊
            return blurred_image # 返回模糊后的灰度图
        except cv2.error as e: # 捕获OpenCV错误
            print(f"错误 (gray_guss): 在转换彩色图为灰度图或应用模糊时发生OpenCV错误: {
     e}") # 打印错误信息
            return None # 返回None
    else:
        print(f"错误 (gray_guss): 输入图像格式不支持。维度: {
     image_gray.ndim}, 形状: {
     image_gray.shape}") # 打印格式错误
        return None # 返回None


# 示例：对灰度渐变图像应用高斯模糊
print("\n测试 gray_guss 函数:") # 打印测试信息
if 'sample_gray_image' in locals() and sample_gray_image is not None: # 检查 sample_gray_image 是否已定义且非空
    blurred_gradient = gray_guss(sample_gray_image, ksize=(9, 9), sigmaX=2) # 应用高斯模糊，使用较大的核和sigma
    if blurred_gradient is not None: # 检查模糊结果是否有效
        print("对 sample_gray_image 应用高斯模糊成功。") # 打印成功信息
        # plt_show(blurred_gradient, title="Blurred Gradient Gray Image (9x9, sigmaX=2)") # 显示模糊后的图像
    else:
        print("对 sample_gray_image 应用高斯模糊失败。") # 打印失败信息
        
    # 测试传入彩色图
    # if 'sample_bgr_image' in locals() and sample_bgr_image is not None:
    #     blurred_from_color = gray_guss(sample_bgr_image, ksize=(3,3))
    #     if blurred_from_color is not None:
    #         print("对 sample_bgr_image (先转灰度) 应用高斯模糊成功。")
    #         # plt_show(blurred_from_color, title="Blurred from Color (3x3)")
    #     else:
    #         print("对 sample_bgr_image 应用高斯模糊失败。")
else:
    print("sample_gray_image 未定义或为None，跳过 gray_guss 的部分测试。") # 打印跳过测试的信息

print("gray_guss 函数定义完成并通过了基本结构测试。") # 打印完成信息

中文解释:
def gray_guss(image_gray, ksize=(5, 5), sigmaX=0, sigmaY=None):: 定义名为 gray_guss 的函数。
image_gray: 输入的灰度图像。
ksize=(5, 5): 高斯核的大小，默认为5x5。核大小必须是正奇数。
sigmaX=0: X方向的高斯核标准差。如果为0，OpenCV会根据 ksize[0] (宽度) 自动计算一个合适的值。
sigmaY=None: Y方向的高斯核标准差。如果为 None 或0，它会被设置成与 sigmaX 相同。如果 sigmaX 也是0，那么 sigmaY 也会根据 ksize[1] (高度) 自动计算。
if image_gray is None:: 检查输入图像是否为 None。
if not (...):: 对 ksize 参数进行详细的有效性检查：确保它是元组，长度为2，包含两个正奇整数。
print(f"错误：ksize 参数 '{ksize}' 无效..."): 如果 ksize 无效，打印错误信息。
ksize_corrected = (5, 5): 如果提供的 ksize 无效，则使用一个默认的有效值。
else: ksize_corrected = ksize: 如果提供的 ksize 有效，则使用它。
if image_gray.ndim == 3 and image_gray.shape[2] == 1:: 处理 (H, W, 1) 格式的灰度图。cv2.GaussianBlur 可以直接处理这种格式。
blurred_image = cv2.GaussianBlur(image_gray, ksize_corrected, sigmaX, sigmaY=sigmaY): 调用OpenCV的 GaussianBlur 函数。
第一个参数是输入图像。
第二个参数是高斯核大小 ksize。
第三个参数是 sigmaX。
sigmaY=sigmaY 是为了明确传递 sigmaY 参数（如果它是 None，OpenCV会按预期处理）。
elif image_gray.ndim == 2:: 处理标准的二维灰度图像。模糊操作与上述类似。
elif image_gray.ndim == 3 and image_gray.shape[2] == 3:: 如果函数意外地接收到了一个彩色图像。
print("警告 (gray_guss): 输入到 gray_guss 的是彩色图像..."): 打印警告。
gray_converted = cv2.cvtColor(image_gray, cv2.COLOR_BGR2GRAY): 尝试将BGR彩色图像转换为灰度图像。
blurred_image = cv2.GaussianBlur(gray_converted, ksize_corrected, sigmaX, sigmaY=sigmaY): 对转换后的灰度图应用高斯模糊。
except cv2.error as e:: 捕获转换或模糊过程中可能发生的OpenCV错误。
else:: 如果输入图像格式不被支持。
if 'sample_gray_image' in locals() and sample_gray_image is not None:: 在测试部分，先检查 sample_gray_image 是否已经存在并且不是 None，以避免在之前的 plt_show 示例执行时（如果 plt.show() 阻塞了）尚未定义而出错。
blurred_gradient = gray_guss(sample_gray_image, ksize=(9, 9), sigmaX=2): 调用 gray_guss 函数，使用一个9x9的核和 sigmaX=2。sigmaX 值越大，模糊程度越高。
# plt_show(blurred_gradient, title="Blurred Gradient Gray Image (9x9, sigmaX=2)"): 显示模糊后的图像（已注释）。

深入理解高斯模糊 (cv2.GaussianBlur)

  • 高斯核 (Gaussian Kernel):
    高斯模糊的核心是一个二维高斯函数生成的权重矩阵（核）。这个核的中心点权重最大，距离中心越远的像素权重越小。这意味着模糊后的像素值受其近邻影响较大，远邻影响较小。
    一维高斯函数为： (G(x) = \frac{1}{\sqrt{2\pi}\sigma} e{-\frac{x2}{2\sigma^2}})
    二维高斯函数（可分离的）为： (G(x, y) = \frac{1}{2\pi\sigma^2} e{-\frac{x2+y2}{2\sigma2}}) (这里假设 (\sigma_x = \sigma_y = \sigma))
    如果 (\sigma_x) 和 (\sigma_y) 不同，则为： (G(x, y) = \frac{1}{2\pi\sigma_x\sigma_y} e{-(\frac{x2}{2\sigma_x^2} + \frac{y2}{2\sigma_y2})})
    ksize 定义了这个权重矩阵的维度。例如，(5, 5) 的核会考虑每个像素周围5x5邻域内的像素。
  • sigmaX 和 sigmaY (标准差):
    (\sigma) (sigma) 是高斯函数的标准差。它控制了高斯钟形曲线的“胖瘦”。
    • 较小的 (\sigma) 值产生一个尖锐的峰值，权重集中在中心附近，导致较轻微的模糊。
    • 较大的 (\sigma) 值产生一个平缓的峰值，权重分布更广，导致更强烈的模糊。
      如果 sigmaX 为0，OpenCV会根据核宽度 ksize[0] 计算它： sigma = 0.3 * ((ksize[0] - 1) * 0.5 - 1) + 0.8。sigmaY 同理。
      如果同时指定了 ksize 和 sigma，ksize 优先。但通常做法是，要么让OpenCV根据 ksize 自动计算 sigma (通过将 sigmaX 设为0)，要么根据期望的模糊程度选择 sigma 值，然后让OpenCV根据 sigma 选择一个合适的 ksize (通过将 ksize 设为 (0,0))。不过，在 cv2.GaussianBlur 中，ksize 必须是正奇数，所以通常是指定 ksize，然后 sigmaX 可以为0让其自动计算，或者手动指定一个 sigmaX。
  • 边界处理 (borderType):
    当高斯核应用到图像边界时，核的一部分会超出图像范围。OpenCV需要知道如何处理这些边界外的像素。cv2.GaussianBlur 函数有一个可选参数 borderType，默认值是 cv2.BORDER_DEFAULT (通常等价于 cv2.BORDER_REFLECT_101 或 cv2.BORDER_REPLICATE，取决于具体OpenCV版本和编译选项)。
    常见的 borderType 包括：
    • cv2.BORDER_CONSTANT: 用指定的常数值填充边界外的像素 (需要额外提供 value 参数)。
    • cv2.BORDER_REPLICATE: 重复边界像素值 (aaaaaa|abcdefgh|hhhhhhh)。
    • cv2.BORDER_REFLECT: 反射边界像素值，不重复边界本身 (fedcba|abcdefgh|hgfedcb)。
    • cv2.BORDER_REFLECT_101 (或 cv2.BORDER_DEFAULT): 反射边界像素值，重复边界本身 (gfedcb|abcdefgh|gfedcba)。这是很多情况下效果较好的一种。
    • cv2.BORDER_WRAP: 用另一边的像素值进行包裹 (cdefgh|abcdefgh|abcdefg)。
      虽然在我们的 gray_guss 函数中没有显式设置 borderType，但了解它的存在对于高级应用和理解潜在的边界效应是很重要的。在车牌识别的某些预处理步骤中，边界效应可能不那么关键，但对于其他图像处理任务则可能非常重要。

这些辅助函数为后续的图像预处理、车牌定位和字符分割等步骤奠定了基础。

3 图像预处理

图像预处理是计算机视觉任务中至关重要的一步。其目的是改善图像质量，消除无关信息，突出感兴趣的特征，从而使后续的分析和处理（如车牌定位、字符识别）更加容易和准确。对于车牌识别系统而言，预处理通常包括读取图像、去噪、灰度化（如果需要）、边缘检测、二值化等操作。

3.1 图片读取 (cv2.imread)

在进行任何图像处理之前，我们首先需要将目标图像从磁盘加载到内存中。OpenCV 提供了 cv2.imread() 函数来完成这个任务。

import cv2 # 导入OpenCV库
import numpy as np # 导入NumPy库
import matplotlib.pyplot as plt # 导入Matplotlib的pyplot模块
# 假设之前的辅助函数 plt_show0 和 plt_show 已经定义

# 为了能够运行后续代码，我们先确保辅助函数已定义 (从上一节复制过来)
def plt_show0(image_bgr):
    if image_bgr is None: 
        print("错误：输入的图像为 None，无法显示。")
        return 
    if image_bgr.ndim == 2: 
        # print("提示：输入的是灰度图像，将直接使用灰度色彩映射显示。")
        plt.imshow(image_bgr, cmap='gray') 
        plt.title("Grayscale Image (via plt_show0)") 
        plt.axis('off') 
        plt.show() 
        return 
    elif image_bgr.ndim == 3 and image_bgr.shape[2] == 3: 
        image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) 
        plt.figure(figsize=(10, 8)) 
        plt.imshow(image_rgb) 
        plt.title("Color Image (BGR to RGB)") 
        plt.axis('off') 
        plt.show() 
    elif image_bgr.ndim == 3 and image_bgr.shape[2] == 4: 
        # print("提示：输入的是BGRA四通道图像，将转换为RGBA后显示。")
        image_rgba = cv2.cvtColor(image_bgr, cv2.COLOR_BGRA2RGBA) 
        plt.figure(figsize=(10, 8)) 
        plt.imshow(image_rgba) 
        plt.title("Color Image with Alpha (BGRA to RGBA)") 
        plt.axis('off') 
        plt.show() 
    else: 
        print(f"错误：输入的图像格式不受支持。图像维度: {
     image_bgr.ndim}, 形状: {
     image_bgr.shape}")

def plt_show(image_gray, title="Grayscale Image"):
    if image_gray is None: 
        print("错误：输入的图像为 None，无法显示。") 
        return 
    if image_gray.ndim == 3 and image_gray.shape[2] == 1: 
        # print("提示：输入的是形状为 (H, W, 1) 的单通道图像，将进行压缩以正确显示为灰度图。")
        image_gray_squeezed = np.squeeze(image_gray, axis=2) 
        if image_gray_squeezed.ndim != 2:
            print(f"错误：图像压缩后维度不为2，无法按预期显示为灰度图。当前维度: {
     image_gray_squeezed.ndim}")
            return
        plt.figure(figsize=(10, 8)) 
        plt.imshow(image_gray_squeezed, cmap='gray') 
        plt.title(title + " (Squeezed from 3D)") 
        plt.axis('off') 
        plt.show() 
    elif image_gray.ndim == 2: 
        plt.figure(figsize=(10, 8)) 
        plt.imshow(image_gray, cmap='gray') 
        plt.title(
最低0.47元/天 解锁文章
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宅男很神经

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值