EasyPR--开发详解（4）形态学操作、尺寸验证、旋转等操作

  1 //! 定位车牌图像
  2 //! src 原始图像
  3 //! resultVec 一个Mat的向量，存储所有抓取到的图像
  4 //! 成功返回0，否则返回-1
  5 int CPlateLocate::plateLocate(Mat src, vector<Mat>& resultVec)
  6 {
  7     Mat src_blur, src_gray;
  8     Mat grad;
  9 
 10     int scale = SOBEL_SCALE;
 11     int delta = SOBEL_DELTA;
 12     int ddepth = SOBEL_DDEPTH;
 13 
 14     if( !src.data )
 15     { return -1; }
 16 
 17     //高斯模糊。Size中的数字影响车牌定位的效果。
 18     GaussianBlur( src, src_blur, Size(m_GaussianBlurSize, m_GaussianBlurSize), 
 19         0, 0, BORDER_DEFAULT );
 20 
 21     if(m_debug)
 22     { 
 23         stringstream ss(stringstream::in | stringstream::out);
 24         ss << "tmp/debug_GaussianBlur" << ".jpg";
 25         imwrite(ss.str(), src_blur);
 26     }
 27 
 28     /// Convert it to gray
 29     cvtColor( src_blur, src_gray, CV_RGB2GRAY );
 30 
 31     if(m_debug)
 32     { 
 33         stringstream ss(stringstream::in | stringstream::out);
 34         ss << "tmp/debug_gray" << ".jpg";
 35         imwrite(ss.str(), src_gray);
 36     }
 37 
 38     /// Generate grad_x and grad_y
 39     Mat grad_x, grad_y;
 40     Mat abs_grad_x, abs_grad_y;
 41 
 42     /// Gradient X
 43     //Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
 44     Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
 45     convertScaleAbs( grad_x, abs_grad_x );
 46 
 47     /// Gradient Y
 48     //Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
 49     Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
 50     convertScaleAbs( grad_y, abs_grad_y );
 51 
 52     /// Total Gradient (approximate)
 53     addWeighted( abs_grad_x, SOBEL_X_WEIGHT, abs_grad_y, SOBEL_Y_WEIGHT, 0, grad );
 54 
 55     //Laplacian( src_gray, grad_x, ddepth, 3, scale, delta, BORDER_DEFAULT );  
 56     //convertScaleAbs( grad_x, grad );  
 57 
 58 
 59     if(m_debug)
 60     { 
 61         stringstream ss(stringstream::in | stringstream::out);
 62         ss << "tmp/debug_Sobel" << ".jpg";
 63         imwrite(ss.str(), grad);
 64     }
 65 
 66     Mat img_threshold;
 67     threshold(grad, img_threshold, 0, 255, CV_THRESH_OTSU+CV_THRESH_BINARY);
 68     //threshold(grad, img_threshold, 75, 255, CV_THRESH_BINARY);
 69 
 70     if(m_debug)
 71     { 
 72         stringstream ss(stringstream::in | stringstream::out);
 73         ss << "tmp/debug_threshold" << ".jpg";
 74         imwrite(ss.str(), img_threshold);
 75     }
 76 
 77     Mat element = getStructuringElement(MORPH_RECT, Size(m_MorphSizeWidth, m_MorphSizeHeight) );
 78     morphologyEx(img_threshold, img_threshold, MORPH_CLOSE, element);
 79     
 80     if(m_debug)
 81     { 
 82         stringstream ss(stringstream::in | stringstream::out);
 83         ss << "tmp/debug_morphology" << ".jpg";
 84         imwrite(ss.str(), img_threshold);
 85     }
 86 
 87     //Find 轮廓 of possibles plates
 88     vector< vector< Point> > contours;
 89     findContours(img_threshold,
 90         contours, // a vector of contours
 91         CV_RETR_EXTERNAL, // 提取外部轮廓
 92         CV_CHAIN_APPROX_NONE); // all pixels of each contours
 93 
 94     Mat result;
 95     if(m_debug)
 96     { 
 97         //// Draw blue contours on a white image
 98         src.copyTo(result);
 99         drawContours(result, contours,
100             -1, // draw all contours
101             Scalar(0,0,255), // in blue
102             1); // with a thickness of 1
103         stringstream ss(stringstream::in | stringstream::out);
104         ss << "tmp/debug_Contours" << ".jpg";
105         imwrite(ss.str(), result);
106     }
107 
108 
109     //Start to iterate to each contour founded
110     vector<vector<Point> >::iterator itc = contours.begin();
111     
112     vector<RotatedRect> rects;
113     //Remove patch that are no inside limits of aspect ratio and area.
114     int t = 0;
115     while (itc != contours.end())
116     {
117         //Create bounding rect of object
118         RotatedRect mr = minAreaRect(Mat(*itc));
119 
120         //large the rect for more
121         if( !verifySizes(mr))
122         {
123             itc = contours.erase(itc);
124         }
125         else
126         {
127             ++itc;
128             rects.push_back(mr);
129         }
130     }
131 
132     int k = 1;
133     for(int i=0; i< rects.size(); i++)
134     {
135         RotatedRect minRect = rects[i];
136         if(verifySizes(minRect))
137         {    
138             // rotated rectangle drawing 
139             // Get rotation matrix
140             // 旋转这部分代码确实可以将某些倾斜的车牌调整正，
141             // 但是它也会误将更多正的车牌搞成倾斜！所以综合考虑，还是不使用这段代码。
142             // 2014-08-14,由于新到的一批图片中发现有很多车牌是倾斜的，因此决定再次尝试
143             // 这段代码。
144             if(m_debug)
145             { 
146                 Point2f rect_points[4]; 
147                 minRect.points( rect_points );
148                 for( int j = 0; j < 4; j++ )
149                     line( result, rect_points[j], rect_points[(j+1)%4], Scalar(0,255,255), 1, 8 );
150             }
151 
152             float r = (float)minRect.size.width / (float)minRect.size.height;
153             float angle = minRect.angle;
154             Size rect_size = minRect.size;
155             if (r < 1)
156             {
157                 angle = 90 + angle;
158                 swap(rect_size.width, rect_size.height);
159             }
160             //如果抓取的方块旋转超过m_angle角度，则不是车牌，放弃处理
161             if (angle - m_angle < 0 && angle + m_angle > 0)
162             {
163                 //Create and rotate image
164                 Mat rotmat = getRotationMatrix2D(minRect.center, angle, 1);
165                 Mat img_rotated;
166                 warpAffine(src, img_rotated, rotmat, src.size(), CV_INTER_CUBIC);
167 
168                 Mat resultMat;
169                 resultMat = showResultMat(img_rotated, rect_size, minRect.center, k++);
170 
171                 resultVec.push_back(resultMat);
172             }
173         }
174     }
175 
176     if(m_debug)
177     { 
178         stringstream ss(stringstream::in | stringstream::out);
179         ss << "tmp/debug_result" << ".jpg";
180         imwrite(ss.str(), result);
181     }
182 
183     return 0;
184 }

 1 //! 对minAreaRect获得的最小外接矩形，用纵横比进行判断
 2 bool CPlateLocate::verifySizes(RotatedRect mr)
 3 {
 4     float error = m_error;
 5     //Spain car plate size: 52x11 aspect 4,7272
 6     //China car plate size: 440mm*140mm，aspect 3.142857
 7     float aspect = m_aspect;
 8     //Set a min and max area. All other patchs are discarded
 9     //int min= 1*aspect*1; // minimum area
10     //int max= 2000*aspect*2000; // maximum area
11     int min= 44*14*m_verifyMin; // minimum area
12     int max= 44*14*m_verifyMax; // maximum area
13     //Get only patchs that match to a respect ratio.
14     float rmin= aspect-aspect*error;
15     float rmax= aspect+aspect*error;
16 
17     int area= mr.size.height * mr.size.width;
18     float r = (float)mr.size.width / (float)mr.size.height;
19     if(r < 1)
20     {
21         r= (float)mr.size.height / (float)mr.size.width;
22     }
23 
24     if(( area < min || area > max ) || ( r < rmin || r > rmax ))
25     {
26         return false;
27     }
28     else
29     {
30         return true;
31     }
32 }

 1 int k = 1;
 2     for(int i=0; i< rects.size(); i++)
 3     {
 4         RotatedRect minRect = rects[i];
 5         if(verifySizes(minRect))
 6         {    
 7             // rotated rectangle drawing 
 8             // Get rotation matrix
 9             // 旋转这部分代码确实可以将某些倾斜的车牌调整正，
10             // 但是它也会误将更多正的车牌搞成倾斜！所以综合考虑，还是不使用这段代码。
11             // 2014-08-14,由于新到的一批图片中发现有很多车牌是倾斜的，因此决定再次尝试
12             // 这段代码。
13             if(m_debug)
14             { 
15                 Point2f rect_points[4]; 
16                 minRect.points( rect_points );
17                 for( int j = 0; j < 4; j++ )
18                     line( result, rect_points[j], rect_points[(j+1)%4], Scalar(0,255,255), 1, 8 );
19             }
20 
21             float r = (float)minRect.size.width / (float)minRect.size.height;
22             float angle = minRect.angle;
23             Size rect_size = minRect.size;
24             if (r < 1)
25             {
26                 angle = 90 + angle;
27                 swap(rect_size.width, rect_size.height);
28             }
29             //如果抓取的方块旋转超过m_angle角度，则不是车牌，放弃处理
30             if (angle - m_angle < 0 && angle + m_angle > 0)
31             {
32                 //Create and rotate image
33                 Mat rotmat = getRotationMatrix2D(minRect.center, angle, 1);
34                 Mat img_rotated;
35                 warpAffine(src, img_rotated, rotmat, src.size(), CV_INTER_CUBIC);
36 
37                 Mat resultMat;
38                 resultMat = showResultMat(img_rotated, rect_size, minRect.center, k++);
39 
40                 resultVec.push_back(resultMat);
41             }
42         }

 1 //! 显示最终生成的车牌图像，便于判断是否成功进行了旋转。
 2 Mat CPlateLocate::showResultMat(Mat src, Size rect_size, Point2f center, int index)
 3 {
 4     Mat img_crop;
 5     getRectSubPix(src, rect_size, center, img_crop);
 6 
 7     if(m_debug)
 8     { 
 9         stringstream ss(stringstream::in | stringstream::out);
10         ss << "tmp/debug_crop_" << index << ".jpg";
11         imwrite(ss.str(), img_crop);
12     }
13 
14     Mat resultResized;
15     resultResized.create(HEIGHT, WIDTH, TYPE);
16 
17     resize(img_crop, resultResized, resultResized.size(), 0, 0, INTER_CUBIC);
18 
19     if(m_debug)
20     { 
21         stringstream ss(stringstream::in | stringstream::out);
22         ss << "tmp/debug_resize_" << index << ".jpg";
23         imwrite(ss.str(), resultResized);
24     }
25 
26     return resultResized;
27 }