[转载]验证码识别程序原理及其源码

最新推荐文章于 2022-10-04 18:29:46 发布
最新推荐文章于 2022-10-04 18:29:46 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： java
这两天在写一个验证码识别程序，通过努力终于完成。网上提供的方法和源码都很多，觉得最有帮助的还是这篇：http://www.s110.cn/Files/Faq111.htm
      对作者表示感谢，特别是亮度计算方法，这是非专业人士通过摸索是无论如何也领悟不到的，谢谢！
================================================
简单验证码识别程序(源码) 　 简单验证码是指验证码图片里的字符，固定不变，或者变化很小的验证码，比如：字符上会有一些干扰点干扰线等情况，或者只有少数几种字体变化和字体大小变化。

     这里给出源代码都是非常简单的源代码，学过《C程序设计》的都可以看懂，不会超出书本范围，而且不使用指针，这样VB，Delphi,JAVA 等语言都可以照此写出相应的源代码。

     验证码识别可以分为三个大的步骤：预处理，分割，识别。预处理又可细分为读取图片，二值化，去干扰点，去干扰线等等步骤。

     读 取图片很简单就是把要识别的验证码图片读取到我们的程序里，网络上常见的验证码图片格式有BMP,JPG,GIF,PNG，其中BMP的图片格式种类很 多，但都不复杂，24位BMP格式最简单，除去54字节的文件头，只需要顺序读取BMP文件的字节信息就可以了，256色的也就是8位的BMP格式也很常 见，256色BMP图片在文件头后多一个索引表，后面也是顺序存储图片信息的。JPG,GIF,PNG的格式都复杂一点，不过网上都有这些公司或组织发布 的source code。

     下面以24位BMP格式的源代码进行说明：

#define W 40 //定义验证码图片的宽度
#define H 20 //定义验证码图片的宽度
#define N 4 //定义字符位数,一般是4位
#define BMP_filename "c:\test.bmp"
int x,y,i,s,temp;
int YZM[W][H]={0};
int YZM_red[W][H]={0};
int YZM_green[W][H]={0};
int YZM_blue[W][H]={0};
int rec[W]={0};
int lf[N],rt[N],up[N],dw[N];
char result[N];

FILE *fp=fopen(BMP_filename,"rb");//以二进制只读方式打开BMP文件
for(i=0;i<54;i++)temp=fgetc(fp);//跳过54个字节的文件头数据
for(y=H-1;y>=0;y--)//BMP图片数据是倒序存储的，据说是为了下载显示方便，呵呵
{
     for(x=0;x
     //依次读取每个像素的RGB值
}
fclose(fp);//关闭文件 
     好的，通过以上几个语句就可以把图片信息读取到程序的数组里了，然后对其进行二值化，去干扰等工作。
     二值化就是把刚才读取的RGB信息，转换成01数据，0表示空白背景，1表示字符。

for(x=0;x
{
     if(YZM_red[x][y]*0.3+YZM_green[x][y]*0.6+YZM_blue[x][y]*0.1<200)YZM[x][y]=1;else YZM[x][y]=0;
     //red*0.3+green*0.6+blue*0.1 是计算亮度的公式
} 
//如果图片里有干扰点，可以用下面的语句去除。
for(x=1;x
{
     if(YZM[x][y]==1 && YZM[x-1][y-1]==0 && YZM[x][y-1]==0 && YZM[x+1][y-1]==0 && YZM[x-1][y]==0 && YZM[x+1][y]==0 && YZM[x-1][y+1]==0 && YZM[x][y+1]==0 && YZM[x+1][y+1]==0)YZM[x][y]=0;
     //如果一个点的值是1，而且它的周围8个点的值都是0，那么这个点就是干扰点 
} 
     经过这些预处理工作就可以得到一个二进制数组数据了。我们以一组普通的验证码图片为例，

[转载]验证码识别程序原理及其源码    

for(y=0;y
     我们可以用上面的输出语句进行输出，输出语句在最终的程序中可以删除或者注释掉。
     输出结果如下：

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 1 1 1 1 1 1 1 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0
0 0 1 1 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0
0 0 1 1 1 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 1 1 0 1 1 1 0 0 0 1 1 1 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0
0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 1 1 0 0 0 0 1 1 0 0 0
0 0 0 1 1 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 1 0 0 0 1 1 0 0 1 1 0 0 0 0
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

for(x=0;x
{    s=0;
     for(y=0;y
     if(s>0)rec[x]=1;else rec[x]=0;//rec记录数组的断连情况
}
for(i=0,x=1;x
for(i=0,x=1;x
for(i=1;i<=N;i++)for(x=0;x=lf[i] && x<=rt[i] && YZM[x][y]==1)YZM[x][y]=i;
for(y=H-1;y>=0;y--)for(x=0;x<=N;i++)if(YZM[x][y]==i)up[i]=y;//计算每个字符的上边界 
     经过上面的分割语句，我们就完成了分割工作，我们可以用输出语句进行输出，输出结果如下：

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0 0 0 2 2 0 0 0 0 0 0 3 3 3 3 0 0 0 4 4 4 4 4 4 4 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 0 2 2 2 0 0 0 0 0 3 3 0 0 3 3 0 0 4 4 0 0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 2 2 2 2 0 0 0 0 3 3 0 0 0 0 3 0 0 4 4 0 0 0 0 0 0 0 0 0
0 0 1 1 0 1 1 1 0 0 0 0 0 0 2 2 0 0 0 0 3 3 0 0 0 0 0 0 0 4 4 0 4 4 4 0 0 0 0 0
0 0 1 1 1 0 0 1 1 0 0 0 0 0 2 2 0 0 0 0 3 3 0 3 3 3 0 0 0 4 4 4 0 0 4 4 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 2 2 0 0 0 0 3 3 3 0 0 3 3 0 0 0 0 0 0 0 0 4 4 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 2 2 0 0 0 0 3 3 0 0 0 0 3 3 0 0 0 0 0 0 0 4 4 0 0 0
0 0 1 1 0 0 0 0 1 1 0 0 0 0 2 2 0 0 0 0 3 3 0 0 0 0 3 3 0 4 4 0 0 0 0 4 4 0 0 0
0 0 0 1 1 0 0 1 1 0 0 0 0 0 2 2 0 0 0 0 0 3 3 0 0 3 3 0 0 0 4 4 0 0 4 4 0 0 0 0
0 0 0 0 1 1 1 1 0 0 0 0 2 2 2 2 2 2 0 0 0 0 3 3 3 3 0 0 0 0 0 4 4 4 4 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0


     最 后我们就可以进行识别工作，识别的方法有很多，可以进行逐点的精确识别，也可以进行模糊识别等等，甚至也可以不进行去干扰和分割工作直接进行识别（主要用 于粘连的验证码），这都要根据具体情况来具体分析用什么方法最有效，简单验证码的识别则没有那么复杂，用很多方法都可以识别，这里使用的是从每个字符的左 上边界开始，精确判断5行3列15个点来进行识别。

for(i=1;i<=N;i++)
{
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==0 &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==0 && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==0 && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==i &&
         YZM[lf[i]+0][up[i]+3]==i && YZM[lf[i]+1][up[i]+3]==i && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==i && YZM[lf[i]+1][up[i]+4]==i && YZM[lf[i]+2][up[i]+4]==0 )result[i-1]='0';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==i &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==0 && YZM[lf[i]+2][up[i]+3]==i &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==0 && YZM[lf[i]+2][up[i]+4]==i )result[i-1]='1';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==0 && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==0 && YZM[lf[i]+2][up[i]+4]==0 )result[i-1]='2';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==i && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==i && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==0 &&
         YZM[lf[i]+0][up[i]+2]==0 && YZM[lf[i]+1][up[i]+2]==0 && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==0 && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==0 && YZM[lf[i]+2][up[i]+4]==0 )result[i-1]='3';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==0 &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==0 && YZM[lf[i]+2][up[i]+1]==0 &&
         YZM[lf[i]+0][up[i]+2]==0 && YZM[lf[i]+1][up[i]+2]==0 && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==0 && YZM[lf[i]+2][up[i]+3]==i &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==i && YZM[lf[i]+2][up[i]+4]==i )result[i-1]='4';
     if( YZM[lf[i]+0][up[i]+0]==i && YZM[lf[i]+1][up[i]+0]==i && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==i && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==0 &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==i && YZM[lf[i]+1][up[i]+3]==i && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==i && YZM[lf[i]+1][up[i]+4]==i && YZM[lf[i]+2][up[i]+4]==i )result[i-1]='5';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==i && YZM[lf[i]+1][up[i]+3]==i && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==i && YZM[lf[i]+1][up[i]+4]==i && YZM[lf[i]+2][up[i]+4]==0 )result[i-1]='6';
     if( YZM[lf[i]+0][up[i]+0]==i && YZM[lf[i]+1][up[i]+0]==i && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==0 && YZM[lf[i]+2][up[i]+1]==0 &&
         YZM[lf[i]+0][up[i]+2]==0 && YZM[lf[i]+1][up[i]+2]==0 && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==0 && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==0 && YZM[lf[i]+2][up[i]+4]==0 )result[i-1]='7';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==0 && YZM[lf[i]+1][up[i]+3]==i && YZM[lf[i]+2][up[i]+3]==i &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==0 && YZM[lf[i]+2][up[i]+4]==i )result[i-1]='8';
     if( YZM[lf[i]+0][up[i]+0]==0 && YZM[lf[i]+1][up[i]+0]==0 && YZM[lf[i]+2][up[i]+0]==i &&
         YZM[lf[i]+0][up[i]+1]==0 && YZM[lf[i]+1][up[i]+1]==i && YZM[lf[i]+2][up[i]+1]==i &&
         YZM[lf[i]+0][up[i]+2]==i && YZM[lf[i]+1][up[i]+2]==i && YZM[lf[i]+2][up[i]+2]==0 &&
         YZM[lf[i]+0][up[i]+3]==i && YZM[lf[i]+1][up[i]+3]==i && YZM[lf[i]+2][up[i]+3]==0 &&
         YZM[lf[i]+0][up[i]+4]==0 && YZM[lf[i]+1][up[i]+4]==i && YZM[lf[i]+2][up[i]+4]==i )result[i-1]='9';
}
printf("%s",result);//输出识别结果

首先我得承认，关注tesseract-ocr， 是冲着下面这篇文章的噱头去的，26行groovy代码破解网站验证码
http://www.kellyrob99.com/blog/2010/03/14/breaking-weak-captcha-in-slightly-more-than-26-lines-of-groovy-code/

当然，看了之后才知道，原来是调用了三方库tesseract-ocr……
http://code.google.com/p/tesseract-ocr/

尽管如此，本着邓爷爷的“不管白猫黑猫，能抓住老鼠的就是好猫”的原则，趁着假期也开始了“文字识别”的初级研究

HP的tesseract最近被Google支持并开支持英文字母和数字，据说辨识程度是世界排名第三的；更难能可贵的是，提供多国语言包下载（包括中文，精度不咋的倒是真的……），并自带训练工具。

安装完并跑过自带例子之后，首先想到的应用自然是用于验证码分析

[转载]验证码识别程序原理及其源码 

按照说明，送入tesseract的图片的质量直接影响识别的效果，因此，简单的预处理是不可或缺的

1.首先灰度化，灰度值=0.3R+0.59G+0.11B：
Java代码  复制代码  收藏代码
  1.     
  2. for (int y = minY; y < height; y++) {   
  3.     for (int x = minX; x < width; x++) {   
  4.         int rgb = srcImg.getRGB(x, y);   
  5.         Color color = new Color(rgb); // 根据rgb的int值分别取得r,g,b颜色。   
  6.         int gray = (int) (0.3 * color.getRed() + 0.59  
  7.             * color.getGreen() + 0.11 * color.getBlue());   
  8.         Color newColor = new Color(gray, gray, gray);   
  9.         srcImg.setRGB(x, y, newColor.getRGB());   
  10.     }   
  11. }  

结果如图：
[转载]验证码识别程序原理及其源码 

2.其次是灰度反转：
Java代码  复制代码  收藏代码
  1. for (int y = minY; y < height; y++) {   
  2.     for (int x = minX; x < width; x++) {   
  3.         int rgb = buffImg.getRGB(x, y);   
  4.         Color color = new Color(rgb); // 根据rgb的int值分别取得r,g,b颜色。   
  5.         Color newColor = new Color(255 - color.getRed(), 255 - color   
  6.             .getGreen(), 255 - color.getBlue());   
  7.         buffImg.setRGB(x, y, newColor.getRGB());   
  8.     }   
  9. }  

结果如图：
[转载]验证码识别程序原理及其源码 

3.再次是二值化，取图片的平均灰度作为阈值，低于该值的全都为0，高于该值的全都为255：
Java代码  复制代码  收藏代码
  1. for (int y = minY; y < height; y++) {   
  2.     for (int x = minX; x < width; x++) {   
  3.         int rgb = buffImg.getRGB(x, y);   
  4.         Color color = new Color(rgb); // 根据rgb的int值分别取得r,g,b颜色。   
  5.         int value = 255 - color.getBlue();   
  6.         if (value > average) {   
  7.             Color newColor = new Color(0, 0, 0);   
  8.             buffImg.setRGB(x, y, newColor.getRGB());   
  9.         } else {   
  10.             Color newColor = new Color(255, 255, 255);   
  11.             buffImg.setRGB(x, y, newColor.getRGB());   
  12.         }   
  13.     }   
  14. }  

结果如图：
[转载]验证码识别程序原理及其源码 

看看效果还凑合，就省却尺寸调整、中值滤波以及噪点去除等步骤了。

以上完成图片预处理工作；Tesseract没有开放api，纯命令行调用：
Java代码  复制代码  收藏代码
  1. List<String> cmd = new ArrayList<String>(); // 存放命令行参数的数组   
  2. cmd.add(tessPath + "\tesseract");   
  3. cmd.add("");   
  4. cmd.add(outputFile.getName()); // 输出文件位置   
  5. cmd.add(LANG_OPTION); // 字符类别   
  6. cmd.add("eng"); // 英文，找到tessdata里对应的字典文件。   
  7. ProcessBuilder pb = new ProcessBuilder();   
  8. pb.directory(imageFile.getParentFile());   
  9.   
  10. cmd.set(1, tempImage.getName()); // 把图片文件位置放在第一个位置   
  11.   
  12. pb.command(cmd); // 执行命令行   
  13. pb.redirectErrorStream(true); // 通知进程生成器是否合并标准错误和标准输出,把进程错误保存起来。  
  14. Process process = pb.start(); // 开始执行进程   
  15.   
  16. int w = process.waitFor(); // 当前进程停止,直到process停止执行，返回执行结果.  


结果输出表示一切正常

当然，真正要用好tesseract-ocr，还需用到其强大地训练工具，就是后话了……

另外，关于文字识别，除去作为破解验证码的反制手段之外，我们是否也有相关的应用呢？ 

如何识别高级的验证码

一、验证码的基本知识

　　1. 验证码的主要目的是强制人机交互来抵御机器自动化攻击的。

　　2. 大部分的验证码设计者并不得要领，不了解图像处理，机器视觉，模式识别，人工智能的基本概念。

　　3. 利用验证码，可以发财，当然要犯罪：比如招商银行密码只有6位，验证码形同虚设，计算机很快就能破解一个有钱的账户，很多帐户是可以网上交易的。

　　4. 也有设计的比较好的，比如Yahoo,Google,Microsoft等。而国内Tencent的中文验证码虽然难，但算不上好。

　　二、人工智能，模式识别，机器视觉，图像处理的基本知识

　　1)主要流程：

　　比如我们要从一副图片中，识别出验证码;比如我们要从一副图片中，检测并识别出一张人脸。 大概有哪些步骤呢?

　　1.图像采集：验证码呢，就直接通过HTTP抓HTML，然后分析出图片的url，然后下载保存就可以了。 如果是人脸检测识别，一般要通过视屏采集设备，采集回来，通过A/D转操作，存为数字图片或者视频频。

　　2.预处理：检测是正确的图像格式，转换到合适的格式，压缩，剪切出ROI，去除噪音，灰度化，转换色彩空间这些。

　　3.检测：车牌检测识别系统要先找到车牌的大概位置，人脸检测系统要找出图片中所有的人脸(包括疑似人脸);验证码识别呢，主要是找出文字所在的主要区域。

　　4.前处理：人脸检测和识别，会对人脸在识别前作一些校正，比如面内面外的旋转，扭曲等。我这里的验证码识别，“一般”要做文字的切割

　　5.训练：通过各种模式识别，机器学习算法，来挑选和训练合适数量的训练集。不是训练的样本越多越好。过学习，泛化能力差的问题可能在这里出现。这一步不是必须的，有些识别算法是不需要训练的。

　　6.识别：输入待识别的处理后的图片，转换成分类器需要的输入格式，然后通过输出的类和置信度，来判断大概可能是哪个字母。识别本质上就是分类。

　　2)关键概念：

　　图像处理：一般指针对数字图像的某种数学处理。比如投影，钝化，锐化，细化，边缘检测，二值化，压缩，各种数据变换等等。

　　1.二值化：一般图片都是彩色的，按照逼真程度，可能很多级别。为了降低计算复杂度，方便后续的处理，如果在不损失关键信息的情况下，能将图片处理成黑白两种颜色，那就最好不过了。

　　2.细化：找出图像的骨架，图像线条可能是很宽的，通过细化将宽度将为1，某些地方可能大于1。不同的细化算法，可能有不同的差异，比如是否更靠近线条中间，比如是否保持联通行等。

　　3.边缘检测：主要是理解边缘的概念。边缘实际上是图像中图像像素属性变化剧烈的地方。可能通过一个固定的门限值来判断，也可能是自适应的。门限可能是图像全局的，也可能是局部的。不能说那个就一定好，不过大部分时候，自适应的局部的门限可能要好点。被分析的，可能是颜色，也可能是灰度图像的灰度。

　　机器视觉：利用计算机来模式实现人的视觉。 比如物体检测，定位，识别。按照对图像理解的层次的差别，分高阶和低阶的理解。

　　模式识别：对事物或者现象的某种表示方式(数值，文字，我们这里主要想说的是数值)，通过一些处理和分析，来描述，归类，理解，解释这些事物，现象及其某种抽象。

　　人工智能：这种概念比较宽，上面这些都属于人工智能这个大的方向。简单点不要过分学院派的理解就是，把人类的很“智能”的东西给模拟出来协助生物的人来处理问题，特别是在计算机里面。

三、常见的验证码的破解分析

　　以http://libcaca.zoy.org/wiki/PWNtcha这里PWNtcha项目中的资料为例分析，各种验证码的破解。(方法很多，仅仅从我个人乍看之下觉得可行的方法来分析)

　　1)Authimage

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_01.jpg

      使用的反破解技巧：

　　1.不连续的点组成字符

　　2.有一定程度的倾斜

　　设计不好的地方：

　　1.通过纵横的直方图投影，可以找到字幕区域

　　2.通过Hough变换，适当的参数，可以找到近似的横线，可以做倾斜矫正

　　3.字符串的倾斜式面内的，没有太多的破解难度

　　4.字母宽度一定，大小一定

　　2)Clubic

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_02.jpg 

      使用的反破解技巧：

　　1.字符是手写体

　　设计不好的地方：

　　1.检测切割阶段没有任何技术含量，属于设计的比较丑的

　　2.只有数字，而且手写体变化不大

　　3.表面看起来对识别阶段有难度，仔细分析，发现几乎不用任何高级的训练识别算法，就

　　固定的招某些像素点是否有色彩就够了

　　3)linuxfr.org

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_03.jpg

      使用的反破解技巧：

　　1.背景颜色块

　　2.前景的横线或矩形

　　设计不好的地方：

　　1.背景色是单一色块，有形状，通过Region-Growth区域增长来很容易把背景给去掉

　　2.前景色是标准的线条，色彩单一

　　3.字母无粘连

　　4.都是印刷体

　　4)Ourcolony

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_04.jpg 

      使用的反破解技巧：

　　1.设计的太低级，不屑于去评价

　　设计不好的地方：

　　1.这种验证码，设计的最丑，但还是能把菜鸟搞定，毕竟学计算机的少，搞这个破解的更少，正所谓隔行如隔山

　　5)LiveJournal

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_05.jpg

      使用的反破解技巧：

　　1.这个设计略微好点，使用个随机噪音，而且作为前景

　　2.字母位置粗细都有变化

　　设计不好的地方：

　　1.字母没有粘连

　　2.噪音类型单一

　　3.通过在X轴的直方图投影，能准确分割字幕

　　4.然后在Y周作直方图投影,能准确定位高度

　　5.识别阶段，都是印刷体，简单地很

四、网上的一些高级验证码

　　1)ICQ

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_06.jpg

      2)IMDb

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_07.jpg

      3)MS MVPS

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_08.jpg

　　4)MVN Forum

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_09.jpg

　　这些类型是被很多人认为比较难得类型，分析一下可以发现，字符检测，定位和分割都不难。 唯一影响识别率的是IMDBb和MVPS这两类，字体变形略大。

　　总体来说，这些类型的破解也不难，很容易做到50%以上的识别率。

五、高级验证码的破解分析

　　时间关系，我简单介绍如何利用图像处理和模式识别技术，自动识别比较高级的验证码。

　　(以风头正劲的Google为例)

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_10.jpg

      1)至少从目前的AI的发展程度看，没有简单的做法能自动处理各种不同的验证码，即使能力很强，那么系统自然也十分复杂强大。所以，要想在很简单的算法实现比较高级的验证码破解，必须分析不同验证码算法的特点：

　　作为一般的图像处理和计算机视觉，会考虑色彩，纹理，形状等直接的特征，同时也考虑直方图，灰度等统计特征，还考虑FFT，Wavelet等各种变换后的特征。但最终目标都是Dimension Reduction(降维)然后利于识别，不仅仅是速度的考虑。从图像的角度看，很多系统都考虑转换为灰度级甚者黑白图片。

　　Google的图片可以看出，颜色变化是虚晃一枪，不存在任何处理难度。难度是字体变形和字符粘连。

　　如果能成功的分割字符，那么后期识别无论是用SVM等分类算法，还是分析笔顺比划走向来硬识别，都相对好做。

　　2)图像处理和粘连分割

　　代码中的part1目录主要完成图像预处理和粘连字符分割

　　001：将图像从jpg等格式转换为位图便于处理

　　002：采用Fix/Adaptive的Threshold门限算法，将图片Bin-Value二值化。(可用003算法)

　　003：采用OSTU分水岭算法，将图片Bin-Value二值化。(更通用，大部分时候效果更好)

　　005：获取ROI感兴趣的区域。

　　006：Edge Trace边缘跟踪。

　　007：Edge Detection边界检测。

　　008：Thin细化去骨架。

　　009：做了一些Tidy整理。(这个一般要根据特定的Captcha算法调整)

　　010：做切割,注意图片中红色的交叉点。

　　011：将边缘检测和骨干交叉点监测的图像合并。(合并过程可以做分析: 比如X坐标偏移门限分析，交叉点区域纹理分析，线条走势分析，等等各种方法，找出更可能的切分点和分离后部件的组合管理。)

　　说明: http://www.icylife.net/pstzine/0x02/html/pstzine_09_11.jpg

      代码：(代码质量不高，从其他项目拷贝过来，简单修改的。)

　　查看代码(./pstzine_09_01.txt)

　　注：在这里，我们可以看到，基本的部件(字母是分割开了，但可以造成统一字母的被切割成多个Component。 一种做法是：利用先验知识，做分割; 另外一种做法是，和第二部分的识别结合起来。 比如按照从左至右，尝试增加component来识别，如果不能识别而且component的总宽度，总面积还比较小，继续增加。 当然不排除拒识的可能性。)

　　3)字符部件组合和识别。

　　part2的代码展示了切割后的字母组合，和基于svm的字符识别的训练和识别过程。

　　Detection.cpp中展示了ImageSpam检测过程中的一些字符分割和组合，layout的分析和利用的简单技术。 而Google的验证码的识别，完全可以不用到，仅做参考。

　　SVM及使用：

　　本质上，SVM是一个分类器，原始的SVM是一个两类分类的分类器。可以通过1:1或者1:n的方式来组合成一个多类分类的分类器。 天生通过核函数的使用支持高维数据的分类。从几何意义上讲，就是找到最能表示类别特征的那些向量(支持向量SV),然后找到一条线，能最大化分类的Margin。

　　libSVM是一个不错的实现。

　　训练间断和识别阶段的数据整理和归一化是一样的。这里的简单做法是：

　　首先：

      #define SVM_MAX +0.999
　　#define SVM_MIN +0.001

　　其次：

　　扫描黑白待识别字幕图片的每个像素，如果为0(黑色，是字母上的像素),那么svm中该位置就SVM_MAX,反之则反。

　　最后：

　　训练阶段，在svm的input的前面，为该类打上标记，即是那一个字母。

　　识别阶段，当然这个类别标记是SVM分类出来。

　　注意：

　　如果是SVM菜鸟，最好找一个在SVM外边做了包装的工具，比如样本选择，交叉验证，核函数选择这些，让程序自动选择和分析。

　　代码：通过ReginGrowth来提取单个单个的字符，然后开始识别。

　　查看代码(./pstzine_09_02.txt)

六、对验证码设计的一些建议

　　1.在噪音等类型的使用上，尽力让字符和用来混淆的前景和背景不容易区分。尽力让坏人(噪音)长得和好人(字母)一样。

　　2.特别好的验证码的设计，要尽力发挥人类擅长而AI算法不擅长的。 比如粘连字符的分割和手写体(通过印刷体做特别的变形也可以)。 而不要一味的去加一些看起来比较复杂的噪音或者其他的花哨的东西。即使你做的足够复杂，但如果人也难识别，显然别人认为你是没事找抽型的。

　　3. 从专业的机器视觉的角度说，验证码的设计，一定要让破解者在识别阶段，反复在低阶视觉和高阶视觉之间多反复几次才能识别出来。 这样可以大大降低破解难度和破解的准确率。

　　七、郑重申明

　　1.这个问题，本身是人工智能，计算机视觉，模式识别领域的一个难题。作为破解者来说，是出于劣势地位。要做的很好，是很难得。总体来说，我走的是比较学院派的线路，能真正的破解难度比较高的验证码，不同于网上很多不太入流的破解方法。我能做的只有利用有限的知识，抛砖引玉而已。很多OCR的技术，特别是离线手写体中文等文字识别的技术，个人了解有限的很，都不敢在这里乱写。

转自：http://security.ctocio.com.cn/securitycomment/290/8182290_5.shtml 

JimmyLeung1991
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于惯性大水滴滴水算法和支持向量机的粘连字符验证码识别
yinchuandong2的专栏
10-21 1万+
这几天闲来
基于百度地图实现的定位功能.zip
最新发布
04-19
android 源码学习. 资料部分来源于合法的互联网渠道收集和整理，供大家学习参考与交流。本人不对所涉及的版权问题或内容负法律责任。如有侵权，请通知本人删除。感谢CSDN官方提供大家交流的平台
基于Python语言和支持向量机的字符验证码识别.zip
10-16
基于Python语言和支持向量机的字符验证码识别
字符图片分割研究小结（搬运、整理、分类、汇总）（自用，持续更新中）
Xiaofang_123a的博客
03-14 4414
目录一、定义二、分类按分割场景分传统文档印刷体自然场景验证码按分割对象分汉字分割数字、字母分割其他分割三、分割难点光照角度颜色模糊污损遮挡粘连四、常用算法二级标题滴水算法五、参考文献 一、定义 文字图像识别近年来应用广泛 包括传统OCR和自然场景下的文字识别 关系图 字符定位→字符分割→字符识别 例如车牌识别 车牌识别一般分为车牌检测、字符分割和字符识别三个主要步骤。 字符图片分割是字符识别的基础，也是必要前提，分割的精确度会直接影响到字符识别的准确度。 二、分类 按分割场景分 传统文档印刷体 自然场景 验
OCR文本切割
qq_35608277的博客
11-06 1124
行分割：行扫描计算灰度值和。 ref https://blog.csdn.net/Print_lin/article/details/80143002 https://blog.csdn.net/iamdll/article/details/79216320 单行数字识别 https://blog.csdn.net/ltg01/article/details/50492556 ...
字符粘连切分方法
baidu_34720411的博客
01-23 5110
目的 本方法目的在于解决英文字母OCR中存在的字符粘连问题，使得算法的运算结果更为准确。化学式中存在的粘连问题主要有以下几个特点：一是字符种类较少，大都由常见化学元素的组合和基本的数字构成；二是字符的宽度基本一致，一般不存在一大一小的情况，这方便了我们使用字符宽度这一定界条件而又不影响切分的准确性；最后一个是字符的走向大都是水平方向，因此我们在切割时只需要考虑竖直向的切割即可。 解决对象 ...
易语言源码验证码识别程序.rar
02-23
易语言源码验证码识别程序.rar 易语言源码验证码识别程序.rar 易语言源码验证码识别程序.rar 易语言源码验证码识别程序.rar 易语言源码验证码识别程序.rar 易语言源码验证码识别程序.rar
验证码识别程序.zip易语言项目例子源码下载
03-23
验证码识别程序.zip易语言项目例子源码下载验证码识别程序.zip易语言项目例子源码下载 1.合个人学习技术做项目参考 2.适合学生做毕业设计参考 3.适合小团队开发项目参考
易语言验证码识别程序
08-21
验证码识别程序系统结构:分4分图片,测试,分成高16的4图2,分成高16的4图4,分成高16的4图1,分成高16的4图3,判断点数相等数,初始化点数, ======窗口程序集1 || ||------_按钮1_被单击 || ||------分
易语言验证码源码,易语言验证码识别系统
08-21
易语言验证码识别系统源码系统结构:取相似度, ======窗口程序集1 || ||------_按钮1_被单击 || ||------_按钮2_被单击 || ||------__启动窗口_创建完毕 || ||------_按钮5_被单击 || ||------_按钮3_被单击
易语言源码易语言验证码识别汇总源码.rar
02-22
易语言源码易语言验证码识别汇总源码.rar 易语言源码易语言验证码识别汇总源码.rar 易语言源码易语言验证码识别汇总源码.rar 易语言源码易语言验证码识别汇总源码.rar 易语言源码易语言验证码识别汇总源码.rar ...
验证码识别程序
01-01
采用PIL 和pytesser进行简单的验证码识别 程序包中已经包含了pytesser，但是需要自己安装PIL 使用样例 getverify1('v1.jpg') 返回值为识别出的字符
简单验证码识别程序(只是程序，无源码）
12-06
对一些简单的验证码进行识别 实现语言：C#
【手写数字识别】基于matlab GUI SVM手写数字识别【含Matlab源码 676期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
04-03 2323
SVM手写数字识别 完整代码，直接运行，适合小白！可提供运行操作视频！
基于SVM的字母验证码识别
weixin_30642561的博客
07-10 1115
基于SVM的字母验证码识别 摘要 本文研究的问题是包含数字和字母的字符验证码的识别。我们采用的是传统的字符分割识别方法，首先将图像中的字符分割出来，然后再对单字符进行识别。首先通过图像的初步去噪、滤波、形态学操作等一系列预处理过程，我们能够将图像中的噪点去除掉。为了将字符分割开来，我们利用Kmeans聚类算法对图像中的像素点聚成五类，分别代表五个字符，结果表明Kmeans算法的聚类准确度能够达...
【图像识别】基于支持向量机SVM实现汉字识别matlab源码
m0_60703264的博客
08-24 656
前言 汉字历史悠久，流传四海，是我们书面交流的绝对主体。自蔡 伦改进纸张以来，两千年的时间里，汉字最重要的载体是纤维纸。 毫无疑问，较之前的龟甲竹简而言，纸张更便宜，更轻便，更适合 传播。纤维纸结合印刷术，构成了知识文化传播的主要方式。 然而步入新世纪后，我们有了电脑，有了电子书，有了电子 笔，最重要的，我们有了发达的互联网。技术革命正在快速蚕食纸 张原有的优势地位，纤维纸竟有了淘汰的可能。 但是，至少到目前为止，传统方式下的书籍仍然承载着巨大的 信息流量，纸张对于我们依旧不可或缺，这便需要有能够把信息.
OpenCV C++案例实战三十《中文点选验证码识别》
Zero___Chen的博客
10-04 4285
相信大家在登陆某个网站时或多或少都会经历过需要验证码才能登陆。常见的验证码方式有字符输入验证码、滑动条拼图验证码以及字符点选验证码。本案例要实现的是中文字符点选验证。本案例逻辑算法仅为本人为实现此功能所设计，供大家参考交流。本文使用OpenCV C++ 进行中文点选验证码识别，主要操作有以下几点。1、图像预处理，提取出字符轮廓并进行切割2、使用鼠标响应事件进行字符点选，即三次有效字符点选3、字符匹配，即按点选顺序与模板顺序进行字符比较4、只有鼠标点击字符与点击顺序都符合要求时，才会验证通过。
c 语言 验证码识别算法,基于C/C++的图片验证码识别api调用代码实例
weixin_42299018的博客
05-22 838
基于C/C++的图片验证码识别api调用代码实例首先答题吧官网是会给客户提供相应的接口api，这个是怎么理解的呢？如果现在我们碰到一个验证码，咱们需要对这样的图片进行验证码的识别，那你总主要将这个图片发送出去，而图片肯定是传给识别验证码的平台，系统会把它识别出来了，然后将图片识别出来返回，如果你还想要做得更多，例如你想让传回来的字符直接输入到某个输入框里然后自动提交，api就是完成这些流程的一个工...
验证码识别tensorflow源码资源
05-12
总之，TensorFlow 提供的验证码识别源码资源为想要学习和实践验证码识别的人提供了很好的参考和借鉴，但是需要抓住算法实现和数据处理两个关键点，深入理解和掌握机器学习原理和技术，才能有效地提高验证码的识别...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值