车牌识别（七）投影法确定文字所在位置

最新推荐文章于 2021-05-20 01:13:11 发布
最新推荐文章于 2021-05-20 01:13:11 发布
阅读量2.5k 收藏 9
点赞数
分类专栏： 车牌识别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwf888/article/details/81408734
版权

投影法分垂直投影法也水平投影法，水平投影法就是根据每一行白点数，取最大值，去掉小于20%此白点数的上边区域与下边区域。

垂直投影法就是找到连续的白点为1个区域，去掉高度太小的区域，就是每个字的区域，从而可以切出每1个字所在的位置，与模板进行比较

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef unsigned long       DWORD;
typedef int                 BOOL;
typedef unsigned char       BYTE;
typedef unsigned short      WORD;
typedef float               FLOAT;
typedef unsigned char       byte;

#define max(a,b)            (((a) > (b)) ? (a) : (b))
#define min(a,b)            (((a) < (b)) ? (a) : (b))

//BMP图像结构
struct BMP_img
{
    //{BMP头
    BYTE  bfType[2];//类型，判断是否为‘B’,‘M’
    DWORD size;//文件尺寸
    DWORD reser;//保留，为0
    DWORD header_length;//头部长度，也就是数据起始位置
    //}BMP头长度，14字节

    //{信息头40字节
    DWORD infoheader_length;//信息头长度,40
    DWORD width;//图像宽度
    DWORD height;//图像高度
    WORD  biplanes;//颜色平面数，为1
    WORD  bmp_type;/* 8bit 24bit; */
    DWORD compres;//0表示不压缩
    DWORD datasize;//数据长度，size-54
    DWORD bixpm;//水平分辩率
    DWORD biypm;//垂直分辩率
    DWORD clrused;//为0所有颜色，其它的为索引数
    DWORD relclrused;//0表示都重要
    //}信息头结束

    //其它信息
    BYTE *image;//指向一块内存，保存BMP的内容
    DWORD lineBytes;//一行占多少字节
};

//从源BMP图中，剪切车牌所在区域的新结构
struct Bmp1{
    DWORD width;
    DWORD height;
    BYTE *image;
    int left[10];//保存车牌中7个字的左右列
    int right[10];
    int top[10];//保存车牌上下位置
    int bottom[10];
    int up;
    int down;
    byte strr[7][2500];
    byte string[7];//反回已找到的车牌下标
    float ang;//倾斜角度
};

//蓝色车牌
struct HSV{
  float H;//H值范围：190 ~ 245
  float S;//S值范围： 0.35 ~ 1，我理解为黑白灰度
  int V;//V值范围： 0.3 ~ 1
};

//读图片文件到内存中
int read_img(char const *fn, struct BMP_img *img)
{
    FILE *infile;
    if((infile=fopen(fn,"rb"))==NULL)return 0;

    fread(&img->bfType,2,1,infile);//BM
    if(!(img->bfType[0]=='B' && img->bfType[1]=='M'))return 0;
    fread(&img->size,sizeof(DWORD),1,infile);
    printf("\nBMP size             :%d",(int)img->size);
    fread(&img->reser,sizeof(DWORD),1,infile);
    printf("\n保留位:");
    fread(&img->header_length,sizeof(DWORD),1,infile);
    printf("\nheader length    :%d",(int)img->header_length);
    fread(&img->infoheader_length,sizeof(DWORD),1,infile);
    fread(&img->width, sizeof(DWORD), 1, infile);
    fread(&img->height, sizeof(DWORD), 1, infile);
    printf( "\nwidth   :%d\n  height  :%d ", (int)img->width, (int)img->height);
    fread(&img->biplanes, sizeof(WORD), 1, infile);
    fread(&img->bmp_type, sizeof(WORD), 1, infile);
    printf("\nBMP Tpye             :%d ", img->bmp_type);
    fread(&img->compres, sizeof(DWORD), 1, infile);
    if(img->compres==0) {printf("\nbmp图片为非压缩!");}printf(" ");
    fread(&img->datasize, sizeof(DWORD), 1, infile);
    printf("\nBMP Data Size        :%d ",(int)img->datasize);
    fread(&img->bixpm, sizeof(DWORD), 1, infile);
    fread(&img->biypm, sizeof(DWORD), 1, infile);
    fread(&img->clrused, sizeof(DWORD), 1, infile);
    printf("\n实际使用颜色数=%d ",(int)img->clrused);printf(" ");
    fread(&img->relclrused, sizeof(DWORD), 1, infile);

    //计算一行需要多少字节，对齐到4字节
    img->lineBytes=(img->width*img->bmp_type+31)/32*4;//printf("\nLineBytes            :%l\n",img->lineBytes);
    if(img->bmp_type==24)//24位色
    {
        img->image=(unsigned char *)malloc(img->lineBytes*img->height);//分配一块内存，用于保存图像数据
        if(img->image==NULL) fprintf(stderr, "\n Allocation error for temp in read_bmp() \n");
        fseek(infile, img->header_length, SEEK_SET);//跳过头部，也就是跳到图像位置
        if(img->datasize==img->width*3)
            fread(img->image, sizeof(unsigned char), (img->lineBytes)*img->height, infile);//全部读到内存中
        else
        {
            for(int i=0;i<img->height;i++)
            {
                fread(&img->image[i*img->width*3], sizeof(unsigned char), img->lineBytes, infile);//全部读到内存中
            }
        }
    }
    fclose(infile);
    return 1;
}

//把二值图保存为24位黑白图
void WriteBmp1(char const *fn,byte *bmp,int width,int height)
{
    int w4;
    struct BMP_img img;
    //一行有多少个字节
    img.lineBytes=((width*3+3)>>2)<<2;//对齐到4字节边界
    w4=img.lineBytes*height;//图像尺寸
    img.bfType[0]='B';img.bfType[1]='M';
    img.size=w4+54;
    img.reser=0;
    img.header_length=54;
    img.infoheader_length=40;
    img.width=width;
    img.height=height;
    img.biplanes=1;
    img.bmp_type=24;
    img.compres=0;
    img.datasize=w4;
    img.bixpm=0;
    img.biypm=0;
    img.clrused=0;
    img.relclrused=0;
    
    FILE *infile;
    if((infile=fopen(fn,"wb"))==NULL)
    {
        return;
    }
    fwrite(&img.bfType,2,1,infile);//printf("\n打开的图为 %d",img->bfType);//B M
    fwrite(&img.size,sizeof(DWORD),1,infile);     //        printf("\nBMP size             :%l",img->size);
    fwrite(&img.reser,sizeof(DWORD),1,infile);//printf("\n保留位:");
    fwrite(&img.header_length,sizeof(DWORD),1,infile); //printf("\nheader length    :%l",img->header_length);
    fwrite(&img.infoheader_length,sizeof(DWORD),1,infile);
    fwrite(&img.width, sizeof(DWORD), 1, infile);
    fwrite(&img.height, sizeof(DWORD), 1, infile);     //printf( "\nwidth   :%l\n  height  :%l ", img->width, img->height);
    fwrite(&img.biplanes, sizeof(WORD), 1, infile);
    fwrite(&img.bmp_type, sizeof(WORD), 1, infile);  // printf("\nBMP Tpye             :%l ", img->bmp_type);
    fwrite(&img.compres, sizeof(DWORD), 1, infile);    //if(img->compres==0) {printf("\nbmp图片为非压缩!");}printf(" ");
    fwrite(&img.datasize, sizeof(DWORD), 1, infile);//printf("\nBMP Data Size        :%l ",img->datasize);
    fwrite(&img.bixpm, sizeof(DWORD), 1, infile);
    fwrite(&img.biypm, sizeof(DWORD), 1, infile);
    fwrite(&img.clrused, sizeof(DWORD), 1, infile);    //printf("\n实际使用颜色数=%d ",img->clrused);printf(" ");
    fwrite(&img.relclrused, sizeof(DWORD), 1, infile);
    
    byte *wbmp=(byte*)malloc(w4);//后面多加两个字节，用于4字节对齐
    for(int i=0,s,w;i<height;i++)
    {
        s=i*width;
        w=i*img.lineBytes;
        for(int j=0;j<width;j++)
        {
            if(bmp[s+j]){
                wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=bmp[s+j];
            }
            else wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=0;                
        }
    }
    fwrite(wbmp,img.datasize,1,infile);
    free(wbmp);
    fclose(infile);
}

//水平投影，从中间往两边计算，从而去掉最上面与最下面的多余部分
void shuipingtouying(struct Bmp1 *img,byte *dst)//得到车牌的上下边缘
{
    byte temp;
    int i,j,m,n;
    int *p=(int*)malloc(img->height*sizeof(int));//申请以行为单位的整型内存数

    for(i=0;i<img->width;i++)//宽度循环
    {
        if((dst[i]==255)||(dst[img->width+i]==255))//如果第一行 或 第二行有白点
        for(j=0;j<img->height;j++)//消除此白点，直到碰到黑点退出
        {
            if(dst[j*img->width+i]==255)
                dst[j*img->width+i]=0;
            else break;
        }
    }
    for(i=0;i<img->width;i++)
    {
        //倒数1，2行中有白点，则消除，否则退出
        if((dst[img->width*(img->height-1)+i]==255)||(dst[img->width*(img->height-2)+i]==255))
            for(j=img->height-1;j>0;j--)
            {
                if(dst[j*img->width+i]==255)
                    dst[j*img->width+i]=0;
                else break;
            }
    }

    //记录每一行的白点数
    for(i=0;i<img->height;i++)
    {
        p[i]=0;
        for(j=0;j<img->width;j++)
        {
            if(dst[i*img->width+j]==255)
                p[i]++;
        }
    }

    //找到白点数最多的行
    temp=0;
    for(i=0;i<img->height;i++)
    {
        if(p[i]>temp)
        {
          temp=p[i];
        }
    }

    n=temp/5;//以20%做为阀值
    img->up=0;
    img->down=img->height;
    m=img->height/2;
    for(i=m-1;i>0;i--)//从中间往上下遍历，如果有一行的白点数小于20%，则做为起点与终点
    {
        if(p[i]<n)
        {
            img->up=i+1;//只有第一次，才赋值
            break;
        }
    }
    for(i=m+1;i<img->height;i++)//从下面往中间遍历
    {
        if(p[i]<n)
        {
            img->down=i-1;
            break;
        }
    }
    free(p);

    //删除起始行之前的白点
    for(i=0;i<img->up;i++)
    {
        for(j=0;j<img->width;j++)
        {
            dst[i*img->width+j]=0;
        }
    }
    
    //删除结束行之后的白点
    for(i=img->down+1;i<img->height;i++)
    {
        for(j=0;j<img->width;j++)
        {
            dst[i*img->width+j]=0;
        }
    }
}

//垂直投影法
void cuizhitouying(struct Bmp1 *img,byte *temp)
{
    DWORD i,j;
    int num,flag;

    int up;
    int down;
    int bd;//当前列白点数

    //计算1个字符的宽度,也就是1块车牌的宽度，把所有字挨紧，空白区域占30%左右
    //然后一块车牌有7个字，所以一个字的宽度大根是width*0.7/7
    num=flag=0;
    up=img->height;//最高一个白点
    down=0;//最低一个白点
    for(i=0;i<img->width;i++)//按宽遍历
    {
        bd=0;
        for(j=0;j<img->height;j++)//按高遍历，也就是1列1列的遍历
        {
            if(temp[j*img->width+i]==255)//记录每列白点数
            {
                bd++;
                if(up>j)up=j;//最高白点
                if(down<j)down=j;//记住最后一个白点的位置
            }
        }

        if(bd)//当前列有白点
        {
            if(flag==0)//还没有记录起点
            {
                flag=1;
                img->left[num]=i;//记录下起点
            }
        }
        else//当前列没白点
        {
            if(flag)//如果已记录了起点
            {
                if((down-up)+1>img->height/2)//找到正确的字符
                {
                    img->right[num]=i-1;//记录结束区域
                    img->top[num]=up;
                    img->bottom[num]=down;
                    num++;//查找下一个字符
                }
                flag=0;//记录下一个记点
                up=img->height;
                down=0;
            }
        }
    }
    //如果最后一个没有结束
    if(flag){
        img->right[num]=img->width-1;
        img->top[num]=up;
        img->bottom[num]=down;
        num++;
    }
        
    if(num<7)//位数不够
    {
        printf("car no min error\n");
    }
    else if(num>7)//如果找到多于7个字符，说明里面有一个“川”字
    {
        printf("car no error\n");
    }
}


int main(int argc, char **argv)
{
    struct BMP_img img;//定义结构
    struct Bmp1 img1;

    //把当前文件夹下的1.bmp文件内容，读到img结构中，并上下镜像
    if(read_img("1.bmp", &img)==0)
    {
        printf("error");
        return 0;
    }
    
    img1.width=img.width;
    img1.height=img.height;
    byte *temp=(byte*)malloc(img.width*img.height);
    //24位灰度图转单色灰度图
    for(int i=0;i<img.height;i++)
    {
        for(int j=0;j<img.width;j++)
        {
            temp[i*img.width+j]=img.image[i*img.width*3+j*3];
        }
    }
    
    //水平投影，去掉上下非文字区域
    shuipingtouying(&img1,temp);
    
    //垂直投影，去掉车牌中的点，并计算7个字各在什么位置
    cuizhitouying(&img1,temp);//垂直投影，框住每一个字符
   
    //写入镜像后的数据到2.bmp中
    WriteBmp1("2.bmp",temp,img.width,img.height);
    
    free(img.image);//释放动态分配的内存
    free(temp);
    
    printf("请打开2.bmp进行查看\n");
    system("pause");
    return 0;
}

投影之前的图片，上下都有很多噪点

投影之后的图片

可以看到，上下已经很干净了。

乘简
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
车牌字符分割—投影法
lcy597692327的博客
01-31 7016
车牌字符的分割—投影 1.首先，定义一个数组用来储存每一列像素中白色像素的个数。 int perPixelValue;//每个像素的值 int* projectValArry = new int[width];//创建一个用于储存每列白色像素个数的数组 memset(projectValArry, 0, width*4);//必须初始化数组123 2.然后，遍
图像处理之定位
yishuihanq的博客
04-26 8398
图像处理之定位 图像处理中常用的定位方法 opencv halcon c++
车牌识别技术
Jjn_csdn的博客
10-04 2383
车牌识别技术（Vehicle License Plate Recognition，VLPR）是指能够检测到受监控路面的车辆并自动提取车辆牌照信息（含汉字字符、英文字母、阿拉伯数字及号牌颜色）并进行处理的技术，利用车辆的动态视频或静态图像进行牌照号码、牌照颜色进行自动识别。 通常进行车牌识别需要经历下面3个步骤： 首先是__车牌定位__，需要在自然背景中准确地确定车牌区域。首先对采集到的视频图像进行大范围的搜索，找到符合汽车车牌特征的若干区域作为候选区，然后对这些侯选区域做进一步分析、评判，最后选定一个最佳的
基于C语言的字符切割方法
Jaken5213的博客
03-11 2699
最近在用主控STM32H743与摄像头MT9V034做数字识别，今天刚解决数字识别中的字符切割。效果能用，但还需完善。 原理：主要用了投影法，先进行垂直投影，找出多个字符的左右边框，再对每个字符单独水平投影，捕获该字符的上下边框。原理很简单，下面是程序流程图： 下面是程序源码： typedef struct{ uint16_t UpLine; uint16_t DownLine; uint16_t LeftLine; uint16_t RightLine; }CharPosInfTy...
【OCR技术系列之二】基于投影的文字定位与切割（python版）
sinat_29950703的博客
08-20 3425
本篇文字&思路转自 https://www.cnblogs.com/skyfsm/p/8029668.html 代码参考https://blog.csdn.net/Tuzi294/article/details/79959199，以及自己整理的 要做文字识别，第一步要考虑的就是怎么将每一个字符从图片中切割下来，然后才可以送入我们设计好的模型进行字符识别。现在就以下面这张图片为例，说一说最一般的字符切割的步骤是哪些。 实际上要识别的图片很可能没上面那张图片如此整洁，很可能是倾斜的，或者是带噪声的，又
利用图像在垂直方向上的投影找寻字符在图像中的大概位置的原理和C++代码(利用离散序列一阶差分找寻序列下降沿)
昊虹AI笔记
06-14 8281
利用图像在垂直方向上的投影找寻字符在图像中的大概位置的原理和C++代码(利用离散序列一阶差分找寻序列下降沿)
first.rar_bp 车牌识别_投影法分割_神经网络匹配_车牌识别卷积
07-15
车牌定位 车牌分割 字符识别 正如上面所讲,车牌识别主要分为3个部分,其中第一部分车牌定位,一般采用颜色定位,特征定位等,这方面...分割一般采用投影法.识别的话方法就比较多了,有模板匹配,bp神经网络,卷积神经网络等.
文字识别_行字切分_投影法_水平投影_垂直投影代码
06-27
文字识别中的行字切分，使用了投影法，先对图像进行水平投影找出行位置，再对每一行进行垂直投影。
chap12.zip_C 图片裁剪_图像定位_图像文字定位_车牌 投影法
07-14
使用说明 使用时打开此例题目录下pic中的图片，然后依次单击按钮“转”、“1”、“2”、“3”、“4”和...6.牌照搜索:利用水平投影法检测车牌水平位置,利用垂直投影法检测车牌垂直位置。 7.区域裁剪,截取车牌图像。
车牌识别matlab实现（蓝色车牌和新能源车牌）
12-30
使用matlab编程，模板匹配法识别字符，可以判断出新能源车牌（绿牌）和蓝牌并识别字符，理论上调整参数后可以识别黄牌（卡车车牌）。
车牌字符分割垂直投影切分matlab程序
05-18
车牌字符分割算法的垂直投影切分matlab程序
垂直投影算法，垂直投影
07-23
Untitled3.m
车牌识别及分割算法
11-18
垂直投影法及分割法，车牌识别代码，用于车牌的识别及分割
垂直投影法字符分割C语言,字符分割——投影法
weixin_30418225的博客
05-20 984
import cv2import numpy as npdef getHProjection(image):hProjection = np.zeros(image.shape,np.uint8)#图像高与宽(h,w)=image.shape#长度与图像高度一致的数组h_ = [0]*h#循环统计每一行白色像素的个数for y in range(h):for x in range(w):if im...
车牌号图像的垂直投影
HHCCWWlxy的博客
01-26 3177
//垂直投影   vector verticalProjectionMat(Mat Image) { int perPixelValue;//每个像素的值   int width = Image.cols; int height = Image.rows; printf("图片的宽%d图片的高%d", width, height); int* projectValArry = new
c#垂直投影法_投影学
weixin_42333411的博客
12-06 2271
投影学题解：本文命名《投影学》，是由于本文讨论投影的一些最基础的问题。1投影法1.1投影的基本概念投影，是一种通过降维的方法在平面上表示空间形体的办法。在工程上，投影是一种光线照射下形体在地面或墙面上产生影子的模拟和抽象，通过形体轮廓点的一系列投射线与投影面交点的集合。19世纪发展出投影几何(projective geometry)，是以综合法得到一些定性的关系，由此图示和图解空间形体...
[机器视觉]gocv图像水平投影和垂直投影
m0_55708805的博客
04-06 3512
文章目录1. 水平投影和垂直投影2. 投影原理3. 代码实现 1. 水平投影和垂直投影 图像水平投影和垂直投影效果如下图所示： 原图： 水平投影： 垂直投影： 2. 投影原理 投影原理很简单，比如水平投影，就是水平方向，把每一行的像素累加起来，然后绘制成图像。 垂直投影就是，垂直方向，把每一列的像素累加起来，然后绘制成图像。 投影的感觉有点像就是把图片水平方向或者垂直方向压缩了一样。 3. 代码实现 代码实现就是先把图像转成数组，然后遍历数组，如果是水平投影，需要计算每一行的像素累加，如果是垂直投影，
机械制图符号_第一章：基础知识“机械制图简介”第一角法与第三角法
weixin_39850152的博客
11-21 4495
1. 图样:是工程语言和语言文字一样是人类在生产实践活动中用来表达和交流技术思想的有力且必不可少的工具.2. 图学:是进入工程的阶梯熟悉制图的基本知识,基本方法和基本技能,培养绘图,识图和空间想像能力及空间分析能力.3. 工程图:产品(设备)在设计﹑制造﹑检验﹑安装等过程中所使用的图面.4. 工程图种类(1) 按内容分: 总装图, 部件图, 零件图, 工艺图, 流程图.(2) 按方法分: 原图, ...
python车牌字符分割利用直方图_结合垂直投影法与固定边界分割的车牌字符分割算法2（附源码和详细解析）...
weixin_27012987的博客
12-23 2695
水平(上下)边框处理。第三步，作垂直方向投影，获得直方图，分析直方图，计算出水平摆放时牌照上字符间的最大中心距，确定分割阈值的选取间距(字符分割宽度)。下面章节将对以上3个步骤做详细的论述。(1)水平投影分析二值牌照图像做水平投影分析的主要任务是从获取的投影直方图上计算出每个牌照上字符的开始(上升点)、结束(下降点)位置以及字符高度(峰宽度)、字符的中心距离(峰中心位置)、字符间距(谷底宽度)、字...
基于matlab的车牌识别系统的设计附程序详解注释样本.doc
最新发布
12-06
接下来是车牌定位，这一过程旨在确定车牌在图像中的精确位置。文档中提到利用数学形态学的方法来定位车牌。数学形态学是一组基于集合论的操作，如腐蚀、膨胀、开运算和闭运算，可以用来去除噪声、连接断开的线条或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值