图像验证码识别(七)——字符分割

前面经过各种去除噪点、干扰线,验证码图片现在已经只有两个部分,如果pixel为白就是背景,如果pixel为黑就为字符。正如前面流畅所提到的一样,为了字符的识别,这里需要将图片上的字符一个一个“扣”下来,得到单个的字符,接下来再进行OCR识别。

字符分割可以说是图像验证码识别最关键的一步,因为分割的正确与否直接关系到最后的结果,如果4个字符分割成了3个,即便后面的识别算法识别率达到100%,结果也是错的。当然,前面预处理如果做得够好,干扰因素能够有效的去除,而没有影响到字符的pixel,那么分割来讲要容易得多。反过来,如果前面的干扰因素都没有去除掉,那么分割出来的可能就不是字符了。

字符的粘连是分割的难点,这一点也可以作为验证码安全系数的标准,如果验证码上的几个字符完全是分开的,那么可以保证字符分割成功率百分之百,这样验证码破解的难度就降低了很多,比如下面的字符:

图像验证码识别(七)——字符分割_第1张图片

这个就是CSDN的验证码,经过二值化和降噪得到的图片,可以看到这里图片已经非常干净,没有一点多余的信息,字符之间没有重叠的部分,分割起来毫无难度。

当然,大多数IT巨头的网页验证码里地字符都是粘连在一起的,比如谷歌的验证码:

图像验证码识别(七)——字符分割_第2张图片

谷歌的验证码不仅粘连成都很大,而且字符扭曲地也特别厉害,所以破解起来那是难度非常大了

至于图片分割,我再这里介绍两种简单地方法。

一、 泛水填充法

泛水填充法在前面降噪的地方就提到过,主要思路还是连通域的思想。对于相互之间没有粘连的字符验证码,直接对图片进行扫描,遇到一个黑的pixel就对其进行泛水填充,所有与其连通的字符都被标记出来,因此一个独立的字符就能够找到了。这个方法优点是效率高,时间复杂度是O(N),N为像素的个数;而且不用考虑图片的大小、相邻字符间隔以及字符在图片中得位置等其他任何因素,任何验证码图片只要字符相互是独立的,不需要对其他任何阀值做预处理,直接就操作;用这种方法分割正确率非常高,几乎不会出现分割错误的情况。但是缺点也很致命:那就是字符之间必须完全隔离,没有粘连的部分,否则会将两个字符误认为一个字符。

代码如下:

[cpp]  view plain  copy
  1. for (i = 0; i < nWidth; ++i)  
  2.         for (j = 0; j < nHeight; ++j)  
  3.         {  
  4.             if ( !getPixel(i,j) )  
  5.             {  
  6.                 //FloodFill each point in connect area using different color  
  7.                 floodFill(m_Mat,cvPoint(i,j),cvScalar(color));  
  8.                 color++;  
  9.             }  
  10.         }  
  11.   
  12.     int ColorCount[256] = { 0 };  
  13.     for (i = 0; i < nWidth; ++i)  
  14.     {  
  15.         for (j = 0; j < nHeight; ++j)  
  16.         {  
  17.             //caculate the area of each area  
  18.             if (getPixel(i,j) != 255)  
  19.             {  
  20.                 ColorCount[getPixel(i,j)]++;  
  21.             }  
  22.         }  
  23.     }  
  24.     //get rid of noise point  
  25.     for (i = 0; i < nWidth; ++i)  
  26.     {  
  27.         for (j = 0; j < nHeight; ++j)  
  28.         {  
  29.             if (ColorCount[getPixel(i,j)] <= nMin_area)  
  30.             {  
  31.                 setPixel(i,j,WHITE);  
  32.             }  
  33.         }  
  34.     }  
  35.   
  36.     int k = 1;  
  37.     int minX,minY,maxX,maxY;  
  38.     vector vImage;  
  39.     while( ColorCount[k] )  
  40.     {  
  41.         if (ColorCount[k] > nMin_area)  
  42.         {  
  43.             minX = minY = 100;  
  44.             maxX = maxY = -1;  
  45.             //get the rect of each charactor  
  46.             for (i = 0; i < nWidth; ++i)  
  47.             {  
  48.                 for (j = 0; j < nHeight; ++j)  
  49.                 {  
  50.                     if(getPixel(i,j) == k)  
  51.                     {  
  52.                         if(i < minX)  
  53.                             minX = i;  
  54.                         else if(i > maxX)  
  55.                             maxX = i;  
  56.                         if(j < minY)  
  57.                             minY = j;  
  58.                         else if(j > maxY)  
  59.                             maxY = j;  
  60.                     }  
  61.                 }  
  62.             }  
  63.             //copy to each standard mat  
  64.             Mat *ch = new Mat(HEIGHT,WIDTH,CV_8U,WHITE);  
  65.             int m,n;  
  66.             m = (WIDTH - (maxX-minX))/2;  
  67.             n = (HEIGHT - (maxY-minY))/2;  
  68.             for (i = minX; i <= maxX; ++i)  
  69.             {  
  70.                 for (j = minY; j <= maxY; ++j)  
  71.                 {  
  72.                     if(getPixel(i,j) == k)  
  73.                     {  
  74.                         *(ch->data+ch->step[0]*(n+j-minY)+m+(i-minX)) = BLACK;  
  75.                     }  
  76.                 }  
  77. "white-space:pre">    }  

这段代码就是使用泛水填充法,每次扫到一个连通域就把连通域所有的pixel的灰度值改为0-255之间的一个值,比如第一个是254,下一个是253...接下来再对每一个灰度值(即每一个连通域)的pixel出现的X,Y坐标的最大、最小的值记录下来,这样就得到了每个字符的最小外包矩形,最后将这个最小外包矩形全部复制到固定大小的一个单独的Mat对象中,这个对象存储的就是一个固定分辨率大小的表现为单独字符的图片。

分割的效果可以见下面的图:



可以看到,分割效果非常好。

二、X像素投影法

对于粘连的字符,也并非没有方法分割。一个方法就是将两个粘连的验证码一刀切开,从哪里切?当然是从粘连的薄弱的地方切。前面提到过图片的像素就像一个二维的矩阵,对每一个x值,统计所有x值为这个值的pixel中黑色的数目,直观来讲就是统计每一条竖线上黑色点的数目。显而易见的是,如果这一条线为背景,那么这一条线肯定都是白色的,那么黑色点的数目为0,如果一条竖线经过字符,那么这条竖线上的黑色点数目肯定不少。

对于完全独立的两个字符之间,肯定有黑色点数目为0的竖线,但是如果粘连,那么不会有黑色点数为0的竖线存在,但是字符粘连最薄弱的地方一定是黑色点数目最少的那条竖线,因此切就要从这个地方切。

在代码的实现的过程中,可以先从左到右扫描一遍,统计投影到每个X值的黑色点的数目,然后设定一个阀值范围,这个阀值大概就是一个字符的宽度。从左到右,先找到第一个x黑色点投影不为0的x值,然后在这个x值加上大概一个字符宽度的大小找到x投影数目最小的x值,这两个x值分割出来就是一个字符了。

这个方法的特点就是能够分割粘连的字符,但是缺点就是容易分割不干净,可能会出现分割错误的情况,另外就是需要提供相应的阀值。

代码如下:

[cpp]  view plain  copy
  1. void Image::xProjectDivide(int nMin_thsd,int nMax_thsd)  
  2. {  
  3.     int i,j;  
  4.     int nWidth = getWidth();  
  5.     int nHeight = getHeight();  
  6.     int *xNum = new int[nWidth];  
  7.   
  8.     //inital the x-projection-num  
  9.     memset(xNum,0,nWidth*sizeof(int));  
  10.   
  11.     //compute the black pixel num in X coordinate  
  12.     for (j = 0; j < nHeight; ++j)  
  13.         for (i = 0; i < nWidth; ++i)  
  14.         {  
  15.             if ( getPixel(i,j) == BLACK ) xNum[i]++;  
  16.         }  
  17.     /*-----------------show x project map-------------------*/  
  18.     Mat xProjectResult(nHeight/2,nWidth,CV_8U,Scalar(WHITE));  
  19.   
  20.     for (i = 0; i < xProjectResult.cols-1; ++i)  
  21.     {  
  22.         int begin,end;  
  23.         if(xNum[i] > xNum[i+1])  
  24.         {  
  25.             begin = xNum[i+1];  
  26.             end = xNum[i];  
  27.         }  
  28.         else {  
  29.             begin = xNum[i];  
  30.             end = xNum[i+1];  
  31.         }  
  32.         for (j = begin; j <= end; ++j)  
  33.         {  
  34.             *(xProjectResult.data+xProjectResult.step[0]*(nHeight/2 - j - 1)+i) = BLACK;  
  35.         }  
  36.     }  
  37.   
  38.     std::cout << "The porject of BLACK pixel in X coordinate is in the window" << std::endl;  
  39.     namedWindow("xProjectResult");  
  40.     imshow("xProjectResult",xProjectResult);  
  41.     waitKey();  
  42.     /*-----------------show x project map-------------------*/  
  43.   
  44.     /*-------------------divide the map---------------------*/  
  45.     vector<int> vPoint;  
  46.     int nMin,nIndex;  
  47.     if (xNum[0] > BOUNDRY_NUM) vPoint.push_back(0);  
  48.     for(i = 1;i < nWidth-1 ;)  
  49.     {  
  50.         if( xNum[i] < BOUNDRY_NUM)  
  51.         {  
  52.             i++;  
  53.             continue;  
  54.         }  
  55.         vPoint.push_back(i);  
  56.         //find minimum between the min_thsd and max_thsd  
  57.         nIndex = i+nMin_thsd;  
  58.         nMin = xNum[nIndex];  
  59.         for(j = nIndex;j
  60.         {  
  61.             if (xNum[j] < nMin)  
  62.             {  
  63.                 nMin = xNum[j];  
  64.                 nIndex = j;   
  65.             }  
  66.         }  
  67.         vPoint.push_back(nIndex);  
  68.         i = nIndex + 1;  
  69.     }  
  70.     if (xNum[nWidth-1] > BOUNDRY_NUM) vPoint.push_back(nWidth-1);  
  71.       
  72.     //save the divided characters in map vector  
  73.     int ch_width = nWidth / (vPoint.size()/2) + EXPAND_WIDTH;  
  74.     vector vImage;  
  75.     for (j = 0; j < (int)vPoint.size(); j += 2)  
  76.     {  
  77.         Mat *mCharacter = new Mat(nHeight,ch_width,CV_8U,Scalar(WHITE));  
  78.         for (i = 0; i < nHeight; ++i)  
  79.             memcpy(mCharacter->data+i*ch_width+EXPAND_WIDTH/2,m_Mat.data+i*nWidth+vPoint.at(j),vPoint.at(j+1)-vPoint.at(j));  
  80.         Image::ContoursRemoveNoise(*mCharacter,2.5);  
  81.         Mat *mResized = new Mat(SCALE,SCALE,CV_8U);  
  82.         resize(*mCharacter,*mResized,cv::Size(SCALE,SCALE),0,0,CV_INTER_AREA);  
  83.         Image iCh(*mResized);  
  84.         vImage.push_back(iCh);  
  85.         delete mCharacter;  
  86.     }  
  87.     //show divided characters  
  88.     char window_name[12];  
  89.     for (i = 0; i < (int)vImage.size(); ++i)  
  90.     {  
  91.         sprintf(window_name,"Character%d",i);  
  92.         //vImage.at(i).NaiveRemoveNoise(1.0f);  
  93.         vImage.at(i).ShowInWindow(window_name);  
  94.     }  
  95.   
  96.     delete []xNum;  
  97. }  

代码首先统计每个x坐标对应的黑色点的数目,然后根据参数提供的阀值,找到字符之间的分割点,然后将分割点入栈,如果有4个字符,就入栈8个边界。最后每次出栈两个x值,将这两个x值之间的所有像素都拷贝到一个新的Mat对象中去,这样就得到了一个独立的字符图片。

下面给出X像素投影法的运行结果图:



你可能感兴趣的:(验证码识别)