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

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

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

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

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

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

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

一、 泛水填充法

泛水填充法在前面降噪的地方就提到过，主要思路还是连通域的思想。对于相互之间没有粘连的字符验证码，直接对图片进行扫描，遇到一个黑的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. int ColorCount[256] = { 0 };
12. for (i = 0; i < nWidth; ++i)
13. {
14. for (j = 0; j < nHeight; ++j)
15. {
16. //caculate the area of each area
17. if (getPixel(i,j) != 255)
18. {
19. ColorCount[getPixel(i,j)]++;
20. }
21. }
22. }
23. //get rid of noise point
24. for (i = 0; i < nWidth; ++i)
25. {
26. for (j = 0; j < nHeight; ++j)
27. {
28. if (ColorCount[getPixel(i,j)] <= nMin_area)
29. {
30. setPixel(i,j,WHITE);
31. }
32. }
33. }
34. int k = 1;
35. int minX,minY,maxX,maxY;
36. vector<Image> vImage;
37. while( ColorCount[k] )
38. {
39. if (ColorCount[k] > nMin_area)
40. {
41. minX = minY = 100;
42. maxX = maxY = -1;
43. //get the rect of each charactor
44. for (i = 0; i < nWidth; ++i)
45. {
46. for (j = 0; j < nHeight; ++j)
47. {
48. if(getPixel(i,j) == k)
49. {
50. if(i < minX)
51. minX = i;
52. else if(i > maxX)
53. maxX = i;
54. if(j < minY)
55. minY = j;
56. else if(j > maxY)
57. maxY = j;
58. }
59. }
60. }
61. //copy to each standard mat
62. Mat *ch = new Mat(HEIGHT,WIDTH,CV_8U,WHITE);
63. int m,n;
64. m = (WIDTH - (maxX-minX))/2;
65. n = (HEIGHT - (maxY-minY))/2;
66. for (i = minX; i <= maxX; ++i)
67. {
68. for (j = minY; j <= maxY; ++j)
69. {
70. if(getPixel(i,j) == k)
71. {
72. *(ch->data+ch->step[0]*(n+j-minY)+m+(i-minX)) = BLACK;
73. }
74. }
75. <span style="white-space:pre">    </span>}

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

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

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