通用的字符分割源代码

最新推荐文章于 2021-08-13 13:46:41 发布
最新推荐文章于 2021-08-13 13:46:41 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： opencv 图像分割 
void FFTGabor::GaborTransform(int * lpDIBBits, LONG lWidth, LONG lHeight, int Orientation, int Frequency, FFTGaborResult * result)
{
        LONG        i;
        LONG        j;

        complex<double> *TD = new complex<double>[complexWidth * complexHeight];
        complex<double> *FD = new complex<double>[complexWidth * complexHeight];
        
        // 行
        for(i = 0; i < lHeight; i++) 
        {
                // 列
                for(j = 0; j < lWidth; j++)
                {
                        // 给时域赋值
                        TD[j + complexWidth * i] = complex<double>(lpDIBBits[j+lWidth * i], 0);
                }
        }
        ::FFT2(TD,complexWidth , complexHeight);
        
        //::IFFT2(TD,256,256);
        //在频域执行卷积
        double scale = 1.0 / (complexWidth * complexHeight); 
        
        for( i=0; i<complexWidth * complexHeight; i++)
                FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
        
        IFFT2(FD,complexWidth , complexHeight);
        
        //计算均值、方差及结果
        //计算均值并找出tmpMag中的最大最小值，以便调整到0～255，用于显示输出。
        double min, max;
        double Sum=0, Avg=0, Deta=0;
        double tmpModulus=0;
        double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
        int x ,y;
        tmpModulus = sqrt(FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() *
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() +
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag() *
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag());
        min = max = tmpModulus;
        for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
                for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
                {
                        tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
                                FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
                        
                        if(min>tmpModulus)
                                min = tmpModulus;
                        if(max<tmpModulus)
                                max = tmpModulus;        
                        
                        Sum += tmpModulus;
                        tmpMag[(y-(GaborHeight/2))* lWidth + (x-(GaborWidth/2))] = tmpModulus;
                }
        }
        Avg = Sum / (lHeight * lWidth);
        //计算方差
        for( y=0; y < lHeight; y++){
                for( x=0; x < lWidth; x++)
                        Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
        }
        Deta = Deta / (lHeight * lWidth);
        
        //计算magShow以及均值
        scale = 255.0/(max-min);
        
        for( y=0; y < lHeight; y++){
                for( x=0; x < lWidth; x++)
                {
                        result->magShow[y * lWidth + x] = (int)(scale*(tmpMag[y* lWidth + x]-min));
                }
        }
        result->Avg = Avg;
        result->Deta = Deta;
        
        delete[] tmpMag;

        delete[] FD;
        delete[] TD;
}

void FFTGabor::intTocomplex(complex<double> * TD,int * lpDIBBits,LONG lWidth, LONG lHeight)
{
        LONG        i;
        LONG        j;

//        complex<double> *TD = new complex<double>[complexWidth * complexHeight];
        
        // 行
        for(i = 0; i < lHeight; i++) 
        {
                // 列
                for(j = 0; j < lWidth; j++)
                {
                        // 给时域赋值
                        TD[j + complexWidth * i] = complex<double>(lpDIBBits[j+lWidth * i], 0);
                }
        }
        ::FFT2(TD,complexWidth , complexHeight);

}
void FFTGabor::GaborTransform(complex<double> *TD, LONG lWidth, LONG lHeight, double * TransformResult)
{
        // 循环变量
        LONG        i;
//        LONG        j;
        int Orientation, Frequency ;
        // 分配内存
        complex<double> *FD = new complex<double>[complexWidth * complexHeight];
        
        double scale = 1.0 / (complexWidth * complexHeight); 
        double Sum=0, Avg=0, Deta=0;
        double tmpModulus=0;
        double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
        int x ,y;
        
        for( Orientation=0; Orientation<8; Orientation++){
                for( Frequency=0; Frequency<4; Frequency++)
                {
                        //在频域执行卷积
                        for( i=0; i<complexWidth * complexHeight; i++)
                                FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
                        
                        IFFT2(FD,complexWidth , complexHeight);
                        
                        //计算均值、方差及结果
                        Sum=0, Avg=0, Deta=0;
                        
                        for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
                                for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
                                {
                                        tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
                                                FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
                                        
                                        Sum += tmpModulus;
                                        tmpMag[(y-(GaborHeight/2)) * lWidth + (x-(GaborWidth/2))] = tmpModulus;
                                }
                        }
                        Avg = Sum / (lHeight * lWidth);
                        //计算方差
                        for( y=0; y < lHeight; y++){
                                for( x=0; x < lWidth; x++)
                                        Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
                        }
                        Deta = Deta / (lHeight * lWidth);
                        

                        TransformResult[(Orientation * 4 + Frequency)*2] = Avg;
                        TransformResult[(Orientation * 4 + Frequency)*2+1] = Deta;
                }
        }
        
        delete[] tmpMag;
        delete[] FD;
}

void FFTGabor::GaborTransform(complex<double> *TD, LONG lWidth, LONG lHeight, int Orientation, int Frequency, FFTGaborResult * result)
{
        LONG        i;
//        LONG        j;

        complex<double> *FD = new complex<double>[complexWidth * complexHeight];
        

        //在频域执行卷积
        double scale = 1.0 / (complexWidth * complexHeight); 
        
        for( i=0; i<complexWidth * complexHeight; i++)
                FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
        
        IFFT2(FD,complexWidth , complexHeight);
        
        //计算均值、方差及结果
        //计算均值并找出tmpMag中的最大最小值，以便调整到0～255，用于显示输出。
        double min, max;
        double Sum=0, Avg=0, Deta=0;
        double tmpModulus=0;
        double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
        int x ,y;
        tmpModulus = sqrt(FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() *
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() +
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag() *
                                                                FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag());
        min = max = tmpModulus;
        for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
                for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
                {
                        tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
                                FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
                        
                        if(min>tmpModulus)
                                min = tmpModulus;
                        if(max<tmpModulus)
                                max = tmpModulus;        
                        
                        Sum += tmpModulus;
                        tmpMag[(y-(GaborHeight/2))* lWidth + (x-(GaborWidth/2))] = tmpModulus;
                }
        }
        Avg = Sum / (lHeight * lWidth);
        //计算方差
        for( y=0; y < lHeight; y++){
                for( x=0; x < lWidth; x++)
                        Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
        }
        Deta = Deta / (lHeight * lWidth);
        
        //计算magShow以及均值
        scale = 255.0/(max-min);
        
        for( y=0; y < lHeight; y++){
                for( x=0; x < lWidth; x++)
                {
                        result->magShow[y * lWidth + x] = (int)(scale*(tmpMag[y* lWidth + x]-min));
                }
        }
        result->Avg = Avg;
        result->Deta = Deta;
        
        delete[] tmpMag;

        delete[] FD;
}


///车牌字符分割

void CSegmentationView::PlateSegm(BYTE Rt[][MAXWIDTH],BYTE Gt[][MAXWIDTH],BYTE Bt[][MAXWIDTH],int PlateHeight,int PlateWidth)
{
        CDC *pDC=GetDC();
    int i,j;
        BYTE TotalRGB[230][460];
        memset(TotalRGB,0,sizeof(BYTE)*230*460);
        int *HistH;
        HistH=new int[sizeof(int)*PlateHeight];
        memset(HistH,0,sizeof(int)*PlateHeight);
// 显示车牌图像并水平投影
        for(i=0;i<PlateHeight;i++)
        {                for(j=0;j<PlateWidth;j++)
                        {
                            pDC->SetPixel(450+j,100+i,RGB(Rt[i][j],Gt[i][j],Bt[i][j]));
                                TotalRGB[i][j]=Rt[i][j]+Gt[i][j]+Bt[i][j];
                
                                if(Bt[i][j]>Gt[i][j]&&Bt[i][j]>Rt[i][j]&&(Bt[i][j]/(float)TotalRGB[i][j])>0.4)
                                        HistH[i]++;
                        }
                    pDC->MoveTo(800,100+i);
                        pDC->LineTo(800+HistH[i],100+i);
        }
//显示宽度除以10.0的长度
        pDC->MoveTo(800,50);
        pDC->LineTo(800+PlateWidth/10.0,50);
        
//求水平边界
        int flag=1;

        for(i=PlateHeight/2;i>=0;i--)
        {
                if(HistH[i]>0)
                {
                        if(flag)
                        {
                                flag=0;
                        }
                        else
                        {
                            PlateRect.top=i;
                                if(HistH[i]<PlateWidth/10.0)
                               break;
                                
                        }
                }
                else if(HistH[i]==0)
                         break;
        
                
        }

        flag=1;
        for(i=PlateHeight/2;i<PlateHeight;i++)
        {
                if(HistH[i]>0)
                {
                        if(flag)
                        {
                                flag=0;
                        }
                        else
                        {
                                PlateRect.bottom=i;
                                if(HistH[i]<PlateWidth/10.0)
                               break;
                                
                        }
                }
                else if(HistH[i]==0)
                         break;
                                
        }
        delete []HistH;HistH=NULL;
   // PlateHeight=bottom-top+1;

        //垂直投影
        int *HistV;
        HistV=new int[sizeof(int)*PlateWidth];
        memset(HistV,0,sizeof(int)*PlateWidth);
                
        for(i=0;i<PlateWidth;i++)
        {        for(j=PlateRect.top;j<=PlateRect.bottom;j++)
                {
                   
                         if(Bt[j][i]>Gt[j][i] &&Bt[j][i]>Rt[j][i]&&(Bt[j][i]/(float)TotalRGB[j][i])>0.4)
                                        HistV[i]++;
                }
                pDC->MoveTo(450+i,100);                              
                    pDC->LineTo(450+i,100-HistV[i]);
        }

        //显示高度除以8.0的长度
//        pDC->MoveTo(400,50);
//        pDC->LineTo(400,50-PlateHeight/8.0);
//        int left,right;

         flag=1;
        for(i=PlateWidth/2;i>=0;i--)
        {
                if(HistV[i]>0)
                {
                        if(flag)
                        {
                                flag=0;
                        }
                        else
                        {
                                PlateRect.left=i;
                        }
                }
                else if(HistV[i]==0)
                         break;                
        }

        flag=1;
        for(i=PlateWidth/2;i<PlateWidth;i++)
        {
                if(HistV[i]>0)
                {
                        if(flag)
                        {
                                flag=0;
                        }
                        else
                        {
                                PlateRect.right=i;
        
                        }
                }
                else if(HistV[i]==0)
                         break;        
        }

        delete []HistV;HistV=NULL;


    CString str;
        pDC->TextOut(0,180,"缩小范围：");
        str.Format("高=%d",PlateRect.bottom-PlateRect.top+1);
        pDC->TextOut(0,200,str);
        str.Format("宽=%d",PlateRect.right-PlateRect.left+1);
        pDC->TextOut(0,220,str);

           BYTE PlateGray[230][460];
        memset(PlateGray,0,sizeof(BYTE)*230*460);
   
   //灰度化
                for(i=PlateRect.top;i<=PlateRect.bottom;i++)
                        for(j=PlateRect.left;j<=PlateRect.right;j++)
                {
                        PlateGray[i][j]=(Rt[i][j]+Gt[i][j]+Bt[i][j])/3;
                
                        
                }

        
//2显示灰度图像
                for(i=PlateRect.top;i<=PlateRect.bottom;i++)
                        for(j=PlateRect.left;j<=PlateRect.right;j++)
                        {
                                pDC->SetPixel(50+j,200+i,RGB(PlateGray[i][j],PlateGray[i][j],PlateGray[i][j]));
                        }

                //plateThre
           BYTE Data;
                   int Thre=OstuThroldDIB3Out(PlateGray);
         

                           for(i=PlateRect.top;i<=PlateRect.bottom;i++)
                            for(j=PlateRect.left;j<=PlateRect.right;j++)
                                  {
                                          if(PlateGray[i][j]<Thre)
                                          {
                                                 Data=255;

                                          }
                                          else            
                                          {                
                                                  Data=0;
                                          }

         //3显示车牌区域二值化后的图像
                      pDC->SetPixel(50+j,300+i,RGB(Data,Data,Data));
                                  }
            

                           /*------------------------------------------------------
                            
                                     次 函数调用代码添加处

                           -------------------------------------------------------*/
                     StrongObject3Out(PlateGray);//对车牌区域直方图均衡化
                         Thre=OstuThroldDIB3Out(PlateGray);

                            for(i=PlateRect.top;i<=PlateRect.bottom;i++)
                                {
                                     for(j=PlateRect.left;j<=PlateRect.right;j++)
                                         {  
//4显示直方图均衡化的图像
                                                 pDC->SetPixel(50+j,400+i,RGB(PlateGray[i][j],PlateGray[i][j],PlateGray[i][j]));
                                                
                                                 // 对直方图均衡化后的车牌区域再次二值化
                                                if(PlateGray[i][j]<Thre)
                                                 {
                                                         PlateGray[i][j]=255;
                                                         
                                                 }
                                                 else
                                                 {
                                                         PlateGray[i][j]=0;
                                                 }

//5显示二值化的图像
                                                 pDC->SetPixel(50+j,500+i,RGB(PlateGray[i][j],PlateGray[i][j],PlateGray[i][j]));
                                         }
                                 }
                                CPen GreenPen(PS_SOLID,1,RGB(0,255,0));
                                CPen *OldPen;
                    OldPen=pDC->SelectObject(&GreenPen);
                pDC->SelectStockObject(NULL_BRUSH);
                    pDC->Rectangle(50+PlateRect.left,500+PlateRect.top,50+PlateRect.right,500+PlateRect.bottom);



                                         /**--------------------------------------------------
                       
                      调用函数PlateProjection, 对车牌区域的上下边界进行再定位，
                      对车牌区域进行垂直方向的投影，分割出各个单个的字符位置

                     -----------------------------------------------------**/               
    
                                    PlateProjection(PlateGray,PlateHeight,PlateWidth);   
           
         //
        pDC->SelectObject(OldPen);
        ReleaseDC(pDC);

}


 

liulina603
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符分割代码
04-16
能分割字符,将单个字符分割出来,能运用于图像识别等,是ocr关键技术.
C# 简易文本分割器源代码
09-19
- **自定义分割规则**：源代码可能支持用户自定义分割符或规则，例如按行、按特定字符、按固定长度等。 - **性能优化**：对于大规模文本处理，可能会涉及到内存管理，通过使用`StringBuilder`而非多次连接字符串，...
字符分割算法及代码
aift的专栏
05-07 5130
之前一段时间做了一个少数民族语言的文字检测与识别的项目，一共有6种语言，其中的彝语的识别相对简单，部分彝语文档图片如下。由于印刷体版式工整，加之彝语的结构较为简单，遂采取了单字符分割+识别的流程来进行彝语的识别工作。（其实主要还是因为训练样本不够啊，外加“某局”希望能得到单字符的坐标，不然直接用CRNN来做序列识别可能会更简单一点，卒。。。） 上图所示为彝语打印文档的一张扫描件示例图。由图可见彝...
字符分割源代码（效果还可以）
u012374012的专栏
01-18 1478
void FFTGabor::GaborTransform(int * lpDIBBits, LONG lWidth, LONG lHeight, int Orientation, int Frequency, FFTGaborResult * result) {         LONG        i;         LONG        j;      
字符串字符分割代码
深之JohnChen的专栏
05-02 1227
#include &lt;list&gt; #include &lt;string&gt; #include &lt;vector&gt; using namespace std; //获取两种字符之间的数字 void GeDataListByStartStopSplitFlag(char *pContent,std::list&lt;int&gt; &amp; listId,char cSt...
Linux内核源代码情景分析 (上下册 高清非扫描 )
03-27
### Linux内核源代码情景分析知识点总结 #### 第1章 预备知识 - **1.1 Linux内核简介** - Linux是由Linus Torvalds在1991年开始开发的操作系统内核，其设计思想受到Unix的影响，但并不直接继承Unix的任何代码。 -...
GPS数据解析 示例，源代码
09-01
本文将深入探讨GPS数据解析的原理、方法以及如何通过源代码实现数据的拆分、坐标转换和线路图的绘制。 GPS（全球定位系统）数据通常以NMEA（National Marine Electronics Association）标准格式传输，它是一种串行...
MATLAB实现txt文本数据分离的源程序代码.zip
最新发布
11-14
总的来说，这个MATLAB源代码包提供了一个工具，帮助用户有效地从TXT文件中分离和提取数据，这对于数据预处理和分析至关重要。通过学习和理解这段代码，用户可以提升自己在MATLAB中处理文本数据的能力，从而更好地...
txt文件分割源代码vc6
11-28
标题“txt文件分割源代码vc6”涉及到的是一个利用Visual C++ 6（简称VC6）编写的程序，它的主要功能是对TXT文本文件进行分割。这个程序可能是一个实用工具，帮助用户处理大尺寸的TXT文件，将其拆分成多个小文件以...
字符分割函数
11-05
本代码可以实现车牌识别的字符分割操作，能够实现较为复杂条件下的字符分割
字符分割程序
06-19
字符分割程序，首先对字符文档进行预处理，减少噪声，然后对字符进行分割处理。
复杂背景下文字分割程序_源代码
12-13
基于文档图像的文字识别系统包括两个处理步骤。第一步为文字分割，即确定图像中文字序列的区域，并将逻辑相关的多个字符分割开来。第二步是字符识别，即是利用文字分割的结果，基于字符的图像及上下文信息，生成该字符相应的数字化表现形式，以便后期处理，如显示、翻译等。 由此可见，文字分割是OCR（光学字符识别）系统中的关键技术，正确的文字分割是文字识别成功的前提。目前的OCR系统大多是针对文字排列整齐，前景色与背景色对比明显的理想文档图像而设计，这虽然适用于很多印刷文档的情形，但对于文字排列的方向和大小都很随意的手写体文档、图书封面等复杂文档图像却无法提供可靠的文字分割结果，以下列出几种常见比较常见的文档图像。 本文所介绍的方法，即复杂背景下的文字分割方法，希望利用字符的轮廓信息，通过逐步探测的方法完成对复杂文档图像的文字分割，经实验证明，该方法可以有较地解决文字排列不规则、同组文字大小不等、背景色复杂的文字分割问题。
opencv字符轮廓分割
02-25
字符分割 轮廓 opencv
opencv python车牌定位字符分割
04-19
opencv python车牌定位，字符分割.
构架之美-前传（一）源代码拆分
weixin_34233618的博客
07-07 75
... 正当开发部的人们不知所措的时候，老总进来了，他的脸上没有一点笑容，开发经理和其他人员停止了讨论。 “听说离职的员工可能带走了全套代码？”老总开始发问。 “可能是这样，我们发现了一些代码的压缩文件的碎片，可能绕过安全网关发送到外部，但是由于接收服务器在境外，所以我们基本上不能获得任何线索...” “是所有人都有全部代码吗？”老总显然对追查已经失去兴趣，只希望可以亡羊补牢。 “是的，因...
OpenCV：字符分割——方向投影法
SSS_369
05-07 6101
常见字符分割方法：方向投影分割法和连通域分割法 1. 方向投影法 方向投影法主要思想就是记录每一行或者每一列对应值的像素的个数，然后根据这些个数判断它是不是边界或者是目标物体。其中像素的个数就像是一个阈值，最后可以把每一行点的个数画出来便于直观的观察。 投影法的就是，利用二值化图像素分布直方图进行分析，从而找出相邻字符的分界点进行分割。 以竖直方向投影分割字符为例，程序如下： #...
opencv-字符分割
weixin_52646021的博客
08-13 1120
这是我从别人那学来的，这里在原有的基础上左了一些修改，然后也添加了一些C++的理解知识 #include <opencv2/core/core.hpp> #include <opencv.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/features2d/features2d.hpp> #include <opencv2/imgproc/imgproc.hpp> #inc
opencv实现字符分割
songlipeng的专栏
07-15 9107
opencv字符分割流程是：1、图像单通道化，2、图像二值化；3、获取图像中的轮廓；4、实现分割。 代码如下： void SegmentChar(const string strPic) { Mat img = imread(strPic, 0); if (!img.data) { return; } Mat threshImg; threshold(img, threshI...
购物车源代码实现与解析
这个源代码可以作为一个通用模板，适用于开发者在构建电商网站时参考使用。" 该购物车源代码主要涉及以下几个核心知识点： 1. **前端展示**： - **HTML表格布局**：用于展示购物车中的商品信息，包括商品名称、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值