当前位置：首页 > article >正文

从图像处理到字符识别：基于STM32与C语言的车牌识别系统实现

article 2024/11/13 22:50:54

一、项目概述

本项目旨在通过软硬件结合的方式，设计并实现一个基于STM32的车牌识别系统实验。该系统主要用于自动识别车辆的车牌信息，广泛应用于智能交通管理、停车场管理等领域。

技术栈关键词

硬件：STM32单片机、OV7670摄像头、TFT显示屏
软件：C语言、图像处理算法
识别流程：图像预处理、二值化处理、车牌区域识别、字符分割、字符识别

二、系统架构

系统架构设计

本系统的硬件架构主要包括STM32单片机作为控制核心，OV7670摄像头用于图像采集，TFT显示屏用于结果展示。系统的通信协议采用I2C和SPI，以实现各组件之间的有效数据传输。

以下是系统架构图：

组件选择

STM32单片机：选择STM32F103系列，性能稳定，适合实时图像处理。
OV7670摄像头：具备较好的图像采集能力，支持640x480分辨率。
TFT显示屏：用于显示识别结果，选择适合STM32的SPI接口屏幕。

三、环境搭建和注意事项

环境搭建

硬件连接：
- 将OV7670摄像头与STM32通过I2C接口连接。
- 将TFT显示屏与STM32通过SPI接口连接。
- 确保电源供应稳定，避免因电压不稳造成的硬件损坏。
软件环境：
- 开发环境使用Keil uVision或STM32CubeIDE。
- 安装必要的库文件，如STM32的HAL库和相关图像处理库。

注意事项

确保图像采集环境光线适中，避免强光和阴影影响识别效果。
在进行字符分割时，注意车牌的清洁度，脏污会影响识别准确率。

四、代码实现过程

在本节中，我们将详细介绍基于STM32的车牌识别系统中各个模块的代码实现过程，包括图像预处理、二值化处理、车牌区域识别、字符分割和字符识别。每个模块的代码示例将配以详细的代码说明，以确保逻辑清晰、易于理解和维护。

1. 图像预处理模块

1.1 代码实现

图像预处理的主要目的是通过高斯滤波去除图像中的噪声，从而提高后续处理的准确性。以下是高斯滤波的实现代码。

#include <stdint.h>
#include <math.h>

#define KERNEL_SIZE 5
#define OFFSET (KERNEL_SIZE / 2)

// 高斯滤波核，包含5x5的权重
const float gaussianKernel[KERNEL_SIZE][KERNEL_SIZE] = {
    {1,  4,  6,  4,  1},
    {4, 16, 24, 16,  4},
    {6, 24, 36, 24,  6},
    {4, 16, 24, 16,  4},
    {1,  4,  6,  4,  1}
};

// 高斯滤波函数
void GaussianBlur(uint8_t* inputImage, uint8_t* outputImage, int width, int height) {
    int sum, x, y, i, j;
    int kernelSum = 256; // 高斯核的归一化因子

    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
            sum = 0;
            // 应用高斯滤波核
            for (i = -OFFSET; i <= OFFSET; i++) {
                for (j = -OFFSET; j <= OFFSET; j++) {
                    int pixelX = x + j;
                    int pixelY = y + i;

                    // 确保不超出图像边界
                    if (pixelX >= 0 && pixelX < width && pixelY >= 0 && pixelY < height) {
                        sum += inputImage[pixelY * width + pixelX] * gaussianKernel[i + OFFSET][j + OFFSET];
                    }
                }
            }
            outputImage[y * width + x] = sum / kernelSum; // 除以归一化因子
        }
    }
}

1.2 代码说明

高斯滤波核：定义了一个5x5的高斯核，具体的权重值根据高斯函数的离散化版本计算得出。该核能够有效地平滑图像，去除高频噪声。
边界处理：在计算每个像素的值时，函数确保对输入图像的边界进行有效处理，避免访问越界。
归一化因子：通过将加权和除以一个固定的归一化因子（这里为256），确保输出图像的像素值在合理范围内。

2. 二值化处理模块

2.1 代码实现

二值化处理将图像转换为黑白图像，以便于后续的特征提取。以下是二值化处理的实现代码。

// 二值化处理函数
void BinarizeImage(uint8_t* inputImage, uint8_t* outputImage, int width, int height, int threshold) {
    for (int i = 0; i < width * height; i++) {
        outputImage[i] = (inputImage[i] > threshold) ? 255 : 0; // 大于阈值则为白色，小于则为黑色
    }
}

2.2 代码说明

输入输出：该函数接受三参数：输入图像、输出图像和图像的宽度和高度。阈值是用来区分前景和背景的关键参数。
二值化逻辑：通过比较每个像素值与阈值的大小，实现简单的二值化处理，结果为255（白色）或0（黑色）。

3. 车牌区域识别模块

3.1 代码实现

车牌区域识别通过查找图像中的特定边缘来确定车牌的位置。以下是车牌区域识别的实现代码。

// 车牌区域识别函数
void FindLicensePlateRegion(uint8_t* binaryImage, Rect* plateRegion, int width, int height) {
    int left = width, right = 0, top = height, bottom = 0;
    bool found = false;

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            // 如果找到白色像素（车牌）
            if (binaryImage[y * width + x] == 255) {
                found = true;
                if (x < left) left = x;       // 更新最左边界
                if (x > right) right = x;     // 更新最右边界
                if (y < top) top = y;          // 更新最上边界
                if (y > bottom) bottom = y;    // 更新最下边界
            }
        }
    }

    // 如果找到车牌区域，更新车牌的矩形区域
    if (found) {
        plateRegion->x = left;
        plateRegion->y = top;
        plateRegion->width = right - left + 1;
        plateRegion->height = bottom - top + 1;
    } else {
        // 如果没有找到车牌区域，设置为无效值
        plateRegion->x = -1;
        plateRegion->y = -1;
        plateRegion->width = 0;
        plateRegion->height = 0;
    }
}

3.2 代码说明

矩形结构体：定义了一个 Rect 结构体来存储车牌区域的坐标和大小。
区域查找逻辑：通过遍历二值化图像，查找所有的白色像素（255），并根据这些像素更新车牌的边界（left、right、top、bottom）。
结果更新：找到车牌区域后，将其坐标和尺寸填入 plateRegion 结构体。如果未找到车牌，设置区域为无效值。

4. 字符分割模块

4.1 代码实现

字符分割的目的是从车牌区域中提取出单个字符。采用上下边缘投影法来完成这一任务。以下是字符分割的实现代码。

#define MAX_CHARACTERS 10

// 字符结构体
typedef struct {
    Rect boundingBox;
} Character;

// 字符分割函数
void SegmentCharacters(uint8_t* binaryImage, Rect plateRegion, Character* characters, int* charCount, int width) {
    int topProjection[plateRegion.height];
    int bottomProjection[plateRegion.height];
    memset(topProjection, 0, sizeof(topProjection));
    memset(bottomProjection, 0, sizeof(bottomProjection));

    // 计算上下边缘投影
    for (int y = plateRegion.y; y < plateRegion.y + plateRegion.height; y++) {
        for (int x = plateRegion.x; x < plateRegion.x + plateRegion.width; x++) {
            if (binaryImage[y * width + x] == 255) {
                topProjection[y - plateRegion.y]++;
                bottomProjection[y - plateRegion.y] = 1; // 标记字符存在
            }
        }
    }

    // 根据投影信息分割字符
    *charCount = 0; // 初始化字符计数
    for (int i = 0; i < plateRegion.height; i++) {
        if (bottomProjection[i] == 1) {
            if (*charCount < MAX_CHARACTERS) {
                characters[*charCount].boundingBox.x = plateRegion.x; // 设定x坐标
                characters[*charCount].boundingBox.y = plateRegion.y + i; // 设定y坐标
                characters[*charCount].boundingBox.width = plateRegion.width; // 设定宽度
                characters[*charCount].boundingBox.height = 1; // 设定高度为1
                (*charCount)++;
            }
        }
    }
}

4.2 代码说明

字符结构体：定义了一个 Character 结构体，包含一个 boundingBox，用于存储每个字符的边界框。
边缘投影：通过遍历车牌区域的每一行，统计每行中白色像素的数量（即字符的存在），将结果存储在 topProjection 和 bottomProjection 数组中。这里的 topProjection 记录每行的白色像素数，而 bottomProjection 标记字符的存在。
字符分割逻辑：在遍历结束后，依据 bottomProjection 数组的信息，确定字符的边界。若某行存在字符（即值为1），则将该行的边界信息填入 characters 数组，并增加字符计数。

5. 字符识别模块

5.1 代码实现

字符识别模块负责识别分割出来的字符。为了简化实现，这里我们采用模板匹配法作为字符识别的基本算法。以下是字符识别的实现代码。

#include <string.h>

#define NUM_CHARACTERS 36 // 假设我们只识别数字和字母

// 假设模板字符
const uint8_t characterTemplates[NUM_CHARACTERS][CHARACTER_HEIGHT][CHARACTER_WIDTH] = {
    // '0'到'9'和'A'到'Z'的字符模板
    // 这里省略具体模板数据
};

// 字符识别函数
char RecognizeCharacter(uint8_t* characterImage, int width, int height) {
    int bestMatchIndex = -1;
    int bestMatchScore = 0;

    // 遍历所有模板进行匹配
    for (int i = 0; i < NUM_CHARACTERS; i++) {
        int matchScore = 0;

        // 逐像素比较
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                if (characterImage[y * width + x] == characterTemplates[i][y][x]) {
                    matchScore++; // 匹配得分
                }
            }
        }

        // 更新最佳匹配
        if (matchScore > bestMatchScore) {
            bestMatchScore = matchScore;
            bestMatchIndex = i;
        }
    }

    // 返回识别的字符
    if (bestMatchIndex >= 0) {
        return (bestMatchIndex < 10) ? '0' + bestMatchIndex : 'A' + (bestMatchIndex - 10);
    }
    return '?'; // 如果没有匹配，返回未知字符
}

5.2 代码说明

字符模板：定义了一个二维数组 characterTemplates，存储了所有待识别字符的模板。模板的维度为 CHARACTER_HEIGHT x CHARACTER_WIDTH，这里应根据实际字符的大小定义。
匹配逻辑：使用双重循环遍历每个模板，逐像素与待识别字符图像进行比较。每次匹配成功则得分加一，最终得到最佳匹配的字符索引。
返回识别结果：根据匹配的索引返回对应的字符，若无匹配结果则返回 ‘?’ 作为未知字符标识。