OpenCV在字符提取中进行的预处理（转）

OCR简介
熟悉OCR的人都了解，OCR大致分为两个部分：

-文字提取text extractor
-文字识别text recognition

其中，第一部分是属于图像处理部分，涉及到图像分割的知识，而第二部分则大多数利用谷歌的Tesseract来进行字符的识别，设计到的东西不多，当然也不难，难的是要能够做到非常准确的识别率，以及它的识别速率。

文字提取
这一部分工作是很关键的，因为文字提取的好坏，直接影响到最后的识别结果，相当于预处理部分，是非常重要的，其主要目的是为了分割出文字字符。
主要涉及工作有：

1. : -灰度化
2. -锐化
3. -Otsu
4. -处理0和1边界值
5. -如果有必要，还需要进行噪声去除，这里要涉及到找连通分量的相关计算；

 void TextDetector::segmentText(cv::Mat &spineImage, cv::Mat &segSpine, bool removeNoise){

     cv::Mat spineGray;
     cvtColor(spineImage, spineGray, CV_BGR2GRAY);
     imshow("gray source" , spineGray);
     spineGray = spineGray - 0.5;
 //    WriteData("/Users/eternity/Desktop/未命名文件夹/gray1.txt", spineGray);
 //    waitKey();
     cv::Mat spineAhe;
     adaptiveHistEqual(spineGray, spineAhe, 0.01);
     imshow("ahe", spineAhe);
 //    WriteData("/Users/eternity/Desktop/未命名文件夹/gray2.txt", spineAhe);

     int window_num = ;

     double window_h = (spineImage.rows / (double)window_num + 1e-);

     int window_w = spineImage.cols;

     cv::Mat spine_th = cv::Mat::zeros(spineGray.size(), CV_8U);

     for (int i = ; i < window_num; i ++) {
         double cut_from_r = window_h * i;
         double cut_to_r = window_h * (i+);
         cv::Mat window_img = cv::Mat::zeros(Size(cut_to_r-cut_from_r + , window_w), CV_8U);
         cv::Rect rect = cv::Rect(, cut_from_r, window_w-, cut_to_r - cut_from_r + );
         window_img = cv::Mat(spineGray, rect);
         imshow("window section", window_img);

         sharpenImage(window_img, window_img);
         imshow("sharpen", window_img);
 //        waitKey();
 //        WriteData("/Users/eternity/Desktop/未命名文件夹/gray4.txt", window_img);
         double max_local,min_local;
         minMaxLoc(window_img, &min_local, &max_local);
         double color_diff = max_local - min_local;
         double thresh;
         cv::Mat window_tmp;
         if (color_diff > )
             thresh = threshold(window_img, window_tmp, , , THRESH_OTSU);
         else
             thresh = ;
 //        cout<<thresh<<endl;
         cv::Mat seg_window(window_img.size(), CV_64F);
         imgQuantize(window_img, seg_window, thresh);
 //        WriteData("/Users/eternity/Desktop/未命名文件夹/quantize2.txt", seg_window);
         seg_window = seg_window == ;
 //        seg_window = seg_window / 255;
         //处理0边界值
         vector<int> cols1,cols2,rows1,rows2;
         findKEdgeFirst(seg_window, , , rows1, cols1);
         findKEdgeLast (seg_window, , , rows2, cols2);
         float max_zero_dist, max_one_dist;
         if(cols1.empty() || cols2.empty())
             max_zero_dist = 0.0;
         else{
             float avg_right = (rows2[]+rows2[]+rows2[]+rows2[]+rows2[]) / (float)sizeof(rows2);
             float avg_left  = (rows1[]+rows1[]+rows1[]+rows1[]+rows1[]) / (float)sizeof(rows1);
             max_zero_dist = avg_right - avg_left;
         }
         cols1.clear();
         cols2.clear();
         rows1.clear();
         rows2.clear();

         //处理1边界值
         findKEdgeFirst(seg_window, , , rows1, cols1);
         findKEdgeLast (seg_window, , , rows2, cols2);
         if(cols1.empty() || cols2.empty())
             max_one_dist = ;
         else{
             float avg_right = (rows2[]+rows2[]+rows2[]+rows2[]+rows2[]) / (float)sizeof(rows2);
             float avg_left  = (rows1[]+rows1[]+rows1[]+rows1[]+rows1[]) / (float)sizeof(rows1);
             max_one_dist = avg_right - avg_left;
         }
         cols1.clear();
         cols2.clear();
         rows1.clear();
         rows2.clear();

         cv::Mat idx;
         findNonZero(seg_window, idx);
         int one_count = (int)idx.total();
         int zero_count = (int)seg_window.total() - one_count;

         float one_zero_diff = max_one_dist - max_zero_dist;
         float  dist_limit = ;

         if(one_zero_diff > dist_limit)
             seg_window = ~ seg_window;
         else{
             if(one_zero_diff > -dist_limit && one_count > zero_count)
                 seg_window = ~ seg_window;
         }

         seg_window.copyTo(cv::Mat( spine_th, rect));
 //        imshow("spine_th", spine_th);
 //        waitKey();

     }
     //去除噪声
     if (removeNoise) {
         vector<vector<cv::Point>> contours;
         imshow("spine_th", spine_th);
 //        WriteData("/Users/eternity/Desktop/未命名文件夹/quantize1.txt", spine_th);
 //        waitKey();
         findContours(spine_th, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);

         for (int i = ; i < contours.size(); i ++) {
             //compute bounding rect
             cv::Rect rect = boundingRect(contours[i]);
             double bbox_aspect = rect.width / (double)rect.height;
             int bbox_area = rect.width * rect.height;
             //compute solidity
             vector<vector<Point>> hull();
             convexHull( contours[i], hull[] );
             double convex_area = contourArea(hull[]);
             double solidity = bbox_area / convex_area;

             for (int j = ; j < contours[i].size(); j ++) {
                 if ( (rect.width > spineImage.cols / 1.001)
                     || (rect.width > spineImage.cols / 1.4 && bbox_aspect > 5.0)
                     || (rect.height > spineImage.cols / 1.1)
                     || (bbox_area < pow(spineImage.cols/, ))
                     || (bbox_aspect > 0.5 && bbox_aspect < 1.7 && solidity > 0.9) )

                     spine_th.at<int>(contours[i][j].x, contours[i][j].y) = ;
 //                WriteData("/Users/eternity/Desktop/未命名文件夹/quantize2.txt", spine_th);
             }

         }

     }
     segSpine = spine_th;
 //    transpose(segSpine, segSpine);
 //    flip(segSpine, segSpine, 0);
     imshow("segspine", segSpine);
 //    waitKey();
     spine_th.release();

 }
 //对图片进行level量化
 void TextDetector::imgQuantize(cv::Mat &src, cv::Mat &dst, double level){
     dst = cv::Mat::zeros(src.rows, src.cols, CV_8U);
     for (int i = ; i < src.rows; i ++) {
         uchar *data = src.ptr<uchar>(i);
         uchar *data2 = dst.ptr<uchar>(i);
         for (int j = ; j < src.cols; j ++) {
             if(data[j] <= level)
                 data2[j] = ;
             else
                 data2[j] = ;

         }
     }

 }
 //找出最左边界处，前edgeValue个值为k的边界值
 void TextDetector::findKEdgeFirst(cv::Mat &data, int edgeValue,int k,vector<int> &rows,vector<int> &cols){
     int count = ;
     for (int i = ; i < data.cols; i ++) {
         uchar *u = data.ptr<uchar>(i);
         for (int j = ; j < data.rows; j ++) {
             if(edgeValue == (int)u[j]){
                 if(count < k){
                     count ++;
                     cols.push_back(i);
                     rows.push_back(j);
                 }

             }

         }
     }

 }
 //找出最右边界处，倒数edgeValue个值为k的边界值
 void TextDetector::findKEdgeLast(cv::Mat &data, int edgeValue,int k,vector<int> &rows, vector<int> &cols){
     int count = ;
     for (int i = data.cols - ; i >= ; i --) {
         uchar *u = data.ptr<uchar>(i);
         for (int j = data.rows - ; j >= ; j --) {
             if(edgeValue == (int)u[j]){
                 if(count < k){
                     count ++;
                     cols.push_back(i);
                     rows.push_back(j);
                 }

             }
         }

     }

 }
 //直方图均衡
 void TextDetector::adaptiveHistEqual(cv::Mat &src,cv::Mat &dst,double clipLimit)
 {
     Ptr<cv::CLAHE> clahe = createCLAHE();
     clahe->setClipLimit(clipLimit);
     clahe->apply(src, dst);
 }

---------------------
作者：eternity1118_
来源：CSDN
原文：https://blog.csdn.net/eternity1118_/article/details/52575374
版权声明：本文为博主原创文章，转载请附上博文链接！