简单的验证码识别（opecv）

     　　opencv版本： 3.0.0

           处理验证码： 纯数字验证码 （颜色不同，有噪音，和带有较多的划痕）

             测试时间 ：  一天+一晚

                  效果： 比较挫，可能是由于测试的图片是在太小了的缘故.

               原理：

 　　　　　　  验证码识别作为身份证号机器识别的一个衍生，夹杂了很多干扰的噪音，所以加大了二值化的难度。以及轮廓追踪的不好协调。

        操作过程大过程有以下几个：

                  （1） 待测试的图片灰度化并二值化

                  （2）预先装载特征库（这里分为多样，形式不一）

                  （3）物体轮廓检测                  

                  （4）扫描待测图片，并进行特征码比对，匹配优先

       处理图片展示：

                

        代码演示：

         

#include<opencv2/opencv.hpp>

#include <iostream>  
#include <string>

struct DataBase{
   int  value;        //库特征对应的值
   vector<Mat> sample;   //特征库
   DataBase(int var , Mat & sam){
       value = var;
       sample.push_back(sam);
   }
};

typedef struct DataBase dataBase;




//加载图片
bool loadImage(Mat &src , Mat &gray ,String &filename){

    Mat cbgray ; //合成后图像
    int chans;    //bgR分量
    src = imread( filename , true ); 
    if( src.empty() )    return false;
    chans = src.channels();
    vector<Mat> bgR(  chans ) ;
    //分割通道
    split(src,bgR);
    //直方图均衡化
    for(int chan=0 ; chan < chans ; ++chan ){
        equalizeHist(bgR[chan] , bgR[chan]);
    }
    //单通道合并
    merge(bgR , cbgray );
    //灰度化
    cvtColor(cbgray ,gray ,CV_RGB2GRAY);
    return true ;
}

//二值化
bool binImage(Mat& src , Mat& dst , int _size , int lparam  ,int mediansize){
   //采用自适应二值化
    adaptiveThreshold(src,src,255,CV_ADAPTIVE_THRESH_MEAN_C,CV_THRESH_BINARY,_size , lparam);
   //中值滤波
    medianBlur(src,dst,mediansize);
   return true;
}

//装载特征库
/*通常来说这个应该是预先被加载好,以数据库或者其他的形式保存起来
  在这地方由于东西比较少，直接现场处理
*/
int loadProperty(vector<dataBase> &db  ,int index[]
    , int _size = 31 , int lparam = 7 , int mediansize = 3 ){

      //固定路径
     char filename[30];
     
    for(int i=0; i<20 ; ++i){
         sprintf(filename,"D:\yzm\tzk\%d.png",index[i]);
         Mat tmp;
         String path =filename;
         loadImage(tmp,tmp,path);    //装载并灰度化 
         binImage(tmp,tmp,_size,lparam,mediansize);   //二值化
        //imshow("sample",tmp);
        //waitKey(0);
         db.push_back( dataBase( index[i]%10 , tmp ) );         
     }

  return true;
}


//对于模块进行匹配
int StartMatch(Mat src , vector< dataBase > db , Point  &curpx){
 
    int res ;
    double maxValue , minValue ,resValue ;
    Point  minloc , maxloc ,resloc;

    vector< dataBase >::iterator it;
    vector< Mat >::iterator m_it;
    
    Mat sample ,result;
    int curcols , currows;
    resValue =1.;

  for( it = db.begin() ; it !=db.end() ; it++ ){

     for( m_it = it->sample.begin() ; m_it != it->sample.end() ; m_it++ ){

          sample = *m_it;
          int res_rows = src.rows - sample.rows + 1 ;
          int res_cols = src.cols - sample.cols + 1 ;
          if( res_rows < 1 || res_cols< 1 ) break;
          result = cv::cvarrToMat(cvCreateImage(cvSize(res_cols, res_rows), 1, 1)); 
          
          matchTemplate(src, sample , result ,CV_TM_SQDIFF_NORMED);  //模板匹配算法,平方差匹配
          
          minMaxLoc(result, &minValue, &maxValue, &minloc, &maxloc,Mat() );
          if(resValue > minValue){
              resValue = minValue;
              resloc = minloc;
              res = it->value; //记录这个值的大小
              curcols = sample.cols;
              currows = sample.rows;
         }
   }
 }
 
//  rectangle(srcResult, matchLoc, cvPoint(matchLoc.x + curtemplatW, matchLoc.y+ curtemplatH), cvScalar(0,0,255));
  //设定一个阈值
  if(resValue<0.2){
   //++curpx.x;
    curpx.x += resloc.x + curcols/2.; 
    rectangle(src,resloc,cvPoint(resloc.x + curcols , resloc.y + currows ),cvScalar(0,0,255));
  }
  else{
      ++curpx.x;
     res=-1;
   }
  return res;
}

//逐步的扫描
vector< int > ScanImage( Mat &src  , vector< dataBase > db , int window_width=12 ,int  window_height=12 ){
 
    Point srcp;

    window_height = src.rows;
    vector< int > ans ; 
    while(srcp.x<src.cols){

     if(srcp.x + window_width > src.cols)
         window_width = src.cols - srcp.x;
     Mat tmp = src( Rect(srcp.x,srcp.y,window_width,window_height) );

     //轮廓检测
    /* vector< vector <Point> >reg;
     Mat newtmp = tmp.clone();
     findContours(newtmp, reg,CV_RETR_EXTERNAL , CV_CHAIN_APPROX_NONE);
     if( reg.empty() ) break;
     Rect rect = boundingRect(Mat(reg[0]));
     Mat ttmp = tmp(rect);
     imshow("ttmp",ttmp);
     waitKey(0);*/

     int ansvalue =StartMatch(tmp,db,srcp);
     if(ansvalue !=-1){
      ans.push_back( ansvalue);
      printf("%d ",ansvalue);
    }
  }
    puts("");
  return ans;
}

int main()
{

    Mat check;
    vector< dataBase > dblist;
    int dex[20];//{0,1,2,3,4,5,6,7,8,9}; //建立一个索引
    for(int i=0;i<20 ; dex[i]=i++);
    loadProperty(dblist,dex,7,33,3);    

    for(int i=0;i<9;i++)
  {
    char path[30];

    if(i<9)    sprintf(path,"D:/yzm/%d.jpg",i+1);
    else     sprintf(path,"D:/yzm/%d.png",i-8);
    
    loadImage(check,check,String(path));
    imshow("check",check);
    waitKey(0);

    binImage(check,check,17,50,3);

    ScanImage(check,dblist,11,3);
    imshow("final",check);
    waitKey(0);
    }
    waitKey(0);
    return 0;
}

          

                 

   

  

   可能是由于测试的图片太小了，导致二值化的时候，图片很不理想，只好取消轮廓检测，然后改为手动设置窗口大小，虽然比较原始，，但是对于比较清晰的图片多能较好的

识别出来！