Opencv2.4.9原始碼分析——HoughCircles

查志強發表於2016-04-08
OpenCV原始碼

【原文：http://blog.csdn.net/zhaocj/article/details/50454847】

圖形可以用一些引數進行表示，標準霍夫變換的原理就是把影象空間轉換成引數空間（即霍夫空間），例如霍夫變換的直線檢測就是在距離-角度空間內進行檢測。圓可以表示成：

(x-a)2+(y-b)2=r2                   （1）

其中a和b表示圓心座標，r表示圓半徑，因此霍夫變換的圓檢測就是在這三個引數組成的三維空間內進行檢測。

原則上，霍夫變換可以檢測任何形狀。但複雜的形狀需要的引數就多，霍夫空間的維數就多，因此在程式實現上所需的記憶體空間以及執行效率上都不利於把標準霍夫變換應用於實際複雜圖形的檢測中。所以一些改進的霍夫變換就相繼提出，它們的基本原理就是儘可能減小霍夫空間的維數。

HoughCircles函式實現了圓形檢測，它使用的演算法也是改進的霍夫變換——2-1霍夫變換（21HT）。也就是把霍夫變換分為兩個階段，從而減小了霍夫空間的維數。第一階段用於檢測圓心，第二階段從圓心推匯出圓半徑。檢測圓心的原理是圓心是它所在圓周所有法線的交匯處，因此只要找到這個交點，即可確定圓心，該方法所用的霍夫空間與影象空間的性質相同，因此它僅僅是二維空間。檢測圓半徑的方法是從圓心到圓周上的任意一點的距離（即半徑）是相同，只要確定一個閾值，只要相同距離的數量大於該閾值，我們就認為該距離就是該圓心所對應的圓半徑，該方法只需要計算半徑直方圖，不使用霍夫空間。圓心和圓半徑都得到了，那麼通過公式1一個圓形就得到了。從上面的分析可以看出，2-1霍夫變換把標準霍夫變換的三維霍夫空間縮小為二維霍夫空間，因此無論在記憶體的使用上還是在執行效率上，2-1霍夫變換都遠遠優於標準霍夫變換。但該演算法有一個不足之處就是由於圓半徑的檢測完全取決於圓心的檢測，因此如果圓心檢測出現偏差，那麼圓半徑的檢測肯定也是錯誤的。2-1霍夫變換的具體步驟為：

第一階段：檢測圓心

1.1、對輸入影象邊緣檢測；

1.2、計算圖形的梯度，並確定圓周線，其中圓周的梯度就是它的法線；

1.3、在二維霍夫空間內，繪出所有圖形的梯度直線，某座標點上累加和的值越大，說明在該點上直線相交的次數越多，也就是越有可能是圓心；

1.4、在霍夫空間的4鄰域內進行非最大值抑制；

1.5、設定一個閾值，霍夫空間內累加和大於該閾值的點就對應於圓心。

第二階段：檢測圓半徑

2.1、計算某一個圓心到所有圓周線的距離，這些距離中就有該圓心所對應的圓的半徑的值，這些半徑值當然是相等的，並且這些圓半徑的數量要遠遠大於其他距離值相等的數量；

2.2、設定兩個閾值，定義為最大半徑和最小半徑，保留距離在這兩個半徑之間的值，這意味著我們檢測的圓不能太大，也不能太小；

2.3、對保留下來的距離進行排序；

2.4、找到距離相同的那些值，並計算相同值的數量；

2.5、設定一個閾值，只有相同值的數量大於該閾值，才認為該值是該圓心對應的圓半徑；

2.6、對每一個圓心，完成上面的2.1～2.5步驟，得到所有的圓半徑。

HoughCircles函式的原型為：

void HoughCircles(InputArray image,OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0,int maxRadius=0 )

image為輸入影象，要求是灰度影象

circles為輸出圓向量，每個向量包括三個浮點型的元素——圓心橫座標，圓心縱座標和圓半徑

method為使用霍夫變換圓檢測的演算法，Opencv2.4.9只實現了2-1霍夫變換，它的引數是CV_HOUGH_GRADIENT

dp為第一階段所使用的霍夫空間的解析度，dp=1時表示霍夫空間與輸入影象空間的大小一致，dp=2時霍夫空間是輸入影象空間的一半，以此類推

minDist為圓心之間的最小距離，如果檢測到的兩個圓心之間距離小於該值，則認為它們是同一個圓心

param1為邊緣檢測時使用Canny運算元的高閾值

param2為步驟1.5和步驟2.5中所共有的閾值

minRadius和maxRadius為所檢測到的圓半徑的最小值和最大值

HoughCircles函式在sources/modules/imgproc/src/hough.cpp檔案內被定義：

[cpp] view plain copy
  1. void cv::HoughCircles( InputArray _image, OutputArray _circles,  
  2.                        int method, double dp, double min_dist,  
  3.                        double param1, double param2,  
  4.                        int minRadius, int maxRadius )  
  5. {  
  6.     //定義一段記憶體  
  7.     Ptr<CvMemStorage> storage = cvCreateMemStorage(STORAGE_SIZE);  
  8.     Mat image = _image.getMat();    //提取輸入影象矩陣  
  9.     CvMat c_image = image;    //矩陣轉換  
  10.     //呼叫cvHoughCircles函式  
  11.     CvSeq* seq = cvHoughCircles( &c_image, storage, method,  
  12.                     dp, min_dist, param1, param2, minRadius, maxRadius );  
  13.     //把序列轉換為矩陣  
  14.     seqToMat(seq, _circles);  
  15. }  
cvHoughCircles函式為：

[cpp] view plain copy
  1. CV_IMPL CvSeq*  
  2. cvHoughCircles( CvArr* src_image, void* circle_storage,  
  3.                 int method, double dp, double min_dist,  
  4.                 double param1, double param2,  
  5.                 int min_radius, int max_radius )  
  6. {  
  7.     CvSeq* result = 0;  
  8.   
  9.     CvMat stub, *img = (CvMat*)src_image;  
  10.     CvMat* mat = 0;  
  11.     CvSeq* circles = 0;  
  12.     CvSeq circles_header;  
  13.     CvSeqBlock circles_block;  
  14.     int circles_max = INT_MAX;    //輸出最多圓形的數量，設為無窮多  
  15.     //canny邊緣檢測中雙閾值中的高閾值  
  16.     int canny_threshold = cvRound(param1);  
  17.     //累加器閾值  
  18.     int acc_threshold = cvRound(param2);  
  19.   
  20.     img = cvGetMat( img, &stub );  
  21.     //確保輸入影象是灰度影象  
  22.     if( !CV_IS_MASK_ARR(img))  
  23.         CV_Error( CV_StsBadArg, "The source image must be 8-bit, single-channel" );  
  24.     //記憶體空間是否存在  
  25.     if( !circle_storage )  
  26.         CV_Error( CV_StsNullPtr, "NULL destination" );  
  27.     //確保引數的正確性  
  28.     if( dp <= 0 || min_dist <= 0 || canny_threshold <= 0 || acc_threshold <= 0 )  
  29.         CV_Error( CV_StsOutOfRange, "dp, min_dist, canny_threshold and acc_threshold must be all positive numbers" );  
  30.     //圓的最小半徑要大於0  
  31.     min_radius = MAX( min_radius, 0 );  
  32.     //圓的最大半徑如果小於0，則設最大半徑為影象寬和長度的最大值，  
  33.     //如果最大半徑小於最小半徑，則設最大半徑為最小半徑加兩個畫素的寬度  
  34.     if( max_radius <= 0 )  
  35.         max_radius = MAX( img->rows, img->cols );  
  36.     else if( max_radius <= min_radius )  
  37.         max_radius = min_radius + 2;  
  38.   
  39.     if( CV_IS_STORAGE( circle_storage ))  
  40.     {  
  41.         circles = cvCreateSeq( CV_32FC3, sizeof(CvSeq),  
  42.             sizeof(float)*3, (CvMemStorage*)circle_storage );  
  43.     }  
  44.     else if( CV_IS_MAT( circle_storage ))  
  45.     {  
  46.         mat = (CvMat*)circle_storage;  
  47.   
  48.         if( !CV_IS_MAT_CONT( mat->type ) || (mat->rows != 1 && mat->cols != 1) ||  
  49.             CV_MAT_TYPE(mat->type) != CV_32FC3 )  
  50.             CV_Error( CV_StsBadArg,  
  51.             "The destination matrix should be continuous and have a single row or a single column" );  
  52.   
  53.         circles = cvMakeSeqHeaderForArray( CV_32FC3, sizeof(CvSeq), sizeof(float)*3,  
  54.                 mat->data.ptr, mat->rows + mat->cols - 1, &circles_header, &circles_block );  
  55.         circles_max = circles->total;  
  56.         cvClearSeq( circles );  
  57.     }  
  58.     else  
  59.         CV_Error( CV_StsBadArg, "Destination is not CvMemStorage* nor CvMat*" );  
  60.     //選擇哪種演算法檢測圓，目前只有2-1霍夫變換  
  61.     switch( method )  
  62.     {  
  63.     case CV_HOUGH_GRADIENT:  
  64.         //呼叫icvHoughCirclesGradient函式  
  65.         icvHoughCirclesGradient( img, (float)dp, (float)min_dist,  
  66.                                 min_radius, max_radius, canny_threshold,  
  67.                                 acc_threshold, circles, circles_max );  
  68.           break;  
  69.     default:  
  70.         CV_Error( CV_StsBadArg, "Unrecognized method id" );  
  71.     }  
  72.   
  73.     if( mat )  
  74.     {  
  75.         if( mat->cols > mat->rows )  
  76.             mat->cols = circles->total;  
  77.         else  
  78.             mat->rows = circles->total;  
  79.     }  
  80.     else  
  81.         result = circles;  
  82.     //輸出圓  
  83.     return result;  
  84. }  
icvHoughCirclesGradient函式為：
[cpp] view plain copy
  1. static void  
  2. icvHoughCirclesGradient( CvMat* img, float dp, float min_dist,  
  3.                          int min_radius, int max_radius,  
  4.                          int canny_threshold, int acc_threshold,  
  5.                          CvSeq* circles, int circles_max )  
  6. {  
  7.     //為了提高運算精度，定義一個數值的位移量  
  8.     const int SHIFT = 10, ONE = 1 << SHIFT;  
  9.     //定義水平梯度和垂直梯度矩陣的地址指標  
  10.     cv::Ptr<CvMat> dx, dy;  
  11.     //定義邊緣影象、累加器矩陣和半徑距離矩陣的地址指標  
  12.     cv::Ptr<CvMat> edges, accum, dist_buf;  
  13.     //定義排序向量  
  14.     std::vector<int> sort_buf;  
  15.     cv::Ptr<CvMemStorage> storage;  
  16.   
  17.     int x, y, i, j, k, center_count, nz_count;  
  18.     //事先計算好最小半徑和最大半徑的平方  
  19.     float min_radius2 = (float)min_radius*min_radius;  
  20.     float max_radius2 = (float)max_radius*max_radius;  
  21.     int rows, cols, arows, acols;  
  22.     int astep, *adata;  
  23.     float* ddata;  
  24.     //nz表示圓周序列，centers表示圓心序列  
  25.     CvSeq *nz, *centers;  
  26.     float idp, dr;  
  27.     CvSeqReader reader;  
  28.     //建立一個邊緣影象矩陣  
  29.     edges = cvCreateMat( img->rows, img->cols, CV_8UC1 );  
  30.     //第一階段  
  31.     //步驟1.1，用canny邊緣檢測演算法得到輸入影象的邊緣影象  
  32.     cvCanny( img, edges, MAX(canny_threshold/2,1), canny_threshold, 3 );  
  33.     //建立輸入影象的水平梯度影象和垂直梯度影象  
  34.     dx = cvCreateMat( img->rows, img->cols, CV_16SC1 );  
  35.     dy = cvCreateMat( img->rows, img->cols, CV_16SC1 );  
  36.     //步驟1.2，用Sobel運算元法計算水平梯度和垂直梯度  
  37.     cvSobel( img, dx, 1, 0, 3 );  
  38.     cvSobel( img, dy, 0, 1, 3 );  
  39.     /確保累加器矩陣的解析度不小於1  
  40.     if( dp < 1.f )  
  41.         dp = 1.f;  
  42.     //解析度的倒數  
  43.     idp = 1.f/dp;  
  44.     //根據解析度，建立累加器矩陣  
  45.     accum = cvCreateMat( cvCeil(img->rows*idp)+2, cvCeil(img->cols*idp)+2, CV_32SC1 );  
  46.     //初始化累加器為0  
  47.     cvZero(accum);  
  48.     //建立兩個序列，  
  49.     storage = cvCreateMemStorage();  
  50.     nz = cvCreateSeq( CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), storage );  
  51.     centers = cvCreateSeq( CV_32SC1, sizeof(CvSeq), sizeof(int), storage );  
  52.   
  53.     rows = img->rows;    //影象的高  
  54.     cols = img->cols;    //影象的寬  
  55.     arows = accum->rows - 2;    //累加器的高  
  56.     acols = accum->cols - 2;    //累加器的寬  
  57.     adata = accum->data.i;    //累加器的地址指標  
  58.     astep = accum->step/sizeof(adata[0]);    /累加器的步長  
  59.     // Accumulate circle evidence for each edge pixel  
  60.     //步驟1.3，對邊緣影象計算累加和  
  61.     for( y = 0; y < rows; y++ )  
  62.     {  
  63.         //提取出邊緣影象、水平梯度影象和垂直梯度影象的每行的首地址  
  64.         const uchar* edges_row = edges->data.ptr + y*edges->step;  
  65.         const short* dx_row = (const short*)(dx->data.ptr + y*dx->step);  
  66.         const short* dy_row = (const short*)(dy->data.ptr + y*dy->step);  
  67.   
  68.         for( x = 0; x < cols; x++ )  
  69.         {  
  70.             float vx, vy;  
  71.             int sx, sy, x0, y0, x1, y1, r;  
  72.             CvPoint pt;  
  73.             //當前的水平梯度值和垂直梯度值  
  74.             vx = dx_row[x];  
  75.             vy = dy_row[x];  
  76.             //如果當前的畫素不是邊緣點，或者水平梯度值和垂直梯度值都為0，則繼續迴圈。因為如果滿足上面條件，該點一定不是圓周上的點  
  77.             if( !edges_row[x] || (vx == 0 && vy == 0) )  
  78.                 continue;  
  79.             //計算當前點的梯度值  
  80.             float mag = sqrt(vx*vx+vy*vy);  
  81.             assert( mag >= 1 );  
  82.             //定義水平和垂直的位移量  
  83.             sx = cvRound((vx*idp)*ONE/mag);  
  84.             sy = cvRound((vy*idp)*ONE/mag);  
  85.             //把當前點的座標定位到累加器的位置上  
  86.             x0 = cvRound((x*idp)*ONE);  
  87.             y0 = cvRound((y*idp)*ONE);  
  88.             // Step from min_radius to max_radius in both directions of the gradient  
  89.             //在梯度的兩個方向上進行位移，並對累加器進行投票累計  
  90.             for(int k1 = 0; k1 < 2; k1++ )  
  91.             {  
  92.                 //初始一個位移的啟動  
  93.                 //位移量乘以最小半徑，從而保證了所檢測的圓的半徑一定是大於最小半徑  
  94.                 x1 = x0 + min_radius * sx;  
  95.                 y1 = y0 + min_radius * sy;  
  96.                 //在梯度的方向上位移  
  97.                 // r <= max_radius保證了所檢測的圓的半徑一定是小於最大半徑  
  98.                 for( r = min_radius; r <= max_radius; x1 += sx, y1 += sy, r++ )  
  99.                 {  
  100.                     int x2 = x1 >> SHIFT, y2 = y1 >> SHIFT;  
  101.                     //如果位移後的點超過了累加器矩陣的範圍，則退出  
  102.                     if( (unsigned)x2 >= (unsigned)acols ||  
  103.                         (unsigned)y2 >= (unsigned)arows )  
  104.                         break;  
  105.                     //在累加器的相應位置上加1  
  106.                     adata[y2*astep + x2]++;  
  107.                 }  
  108.                 //把位移量設定為反方向  
  109.                 sx = -sx; sy = -sy;  
  110.             }  
  111.             //把輸入影象中的當前點（即圓周上的點）的座標壓入序列圓周序列nz中  
  112.             pt.x = x; pt.y = y;  
  113.             cvSeqPush( nz, &pt );  
  114.         }  
  115.     }  
  116.     //計算圓周點的總數  
  117.     nz_count = nz->total;  
  118.     //如果總數為0，說明沒有檢測到圓，則退出該函式  
  119.     if( !nz_count )  
  120.         return;  
  121.     //Find possible circle centers  
  122.     //步驟1.4和1.5，遍歷整個累加器矩陣，找到可能的圓心  
  123.     for( y = 1; y < arows - 1; y++ )  
  124.     {  
  125.         for( x = 1; x < acols - 1; x++ )  
  126.         {  
  127.             int base = y*(acols+2) + x;  
  128.             //如果當前的值大於閾值，並在4鄰域內它是最大值，則該點被認為是圓心  
  129.             if( adata[base] > acc_threshold &&  
  130.                 adata[base] > adata[base-1] && adata[base] > adata[base+1] &&  
  131.                 adata[base] > adata[base-acols-2] && adata[base] > adata[base+acols+2] )  
  132.                 //把當前點的地址壓入圓心序列centers中  
  133.                 cvSeqPush(centers, &base);  
  134.         }  
  135.     }  
  136.     //計算圓心的總數  
  137.     center_count = centers->total;  
  138.     //如果總數為0，說明沒有檢測到圓，則退出該函式  
  139.     if( !center_count )  
  140.         return;  
  141.     //定義排序向量的大小  
  142.     sort_buf.resize( MAX(center_count,nz_count) );  
  143.     //把圓心序列放入排序向量中  
  144.     cvCvtSeqToArray( centers, &sort_buf[0] );  
  145.     //對圓心按照由大到小的順序進行排序  
  146.     //它的原理是經過icvHoughSortDescent32s函式後，以sort_buf中元素作為adata陣列下標，adata中的元素降序排列，即adata[sort_buf[0]]是adata所有元素中最大的，adata[sort_buf[center_count-1]]是所有元素中最小的  
  147.     icvHoughSortDescent32s( &sort_buf[0], center_count, adata );  
  148.     //清空圓心序列  
  149.     cvClearSeq( centers );  
  150.     //把排好序的圓心重新放入圓心序列中  
  151.     cvSeqPushMulti( centers, &sort_buf[0], center_count );  
  152.     //建立半徑距離矩陣  
  153.     dist_buf = cvCreateMat( 1, nz_count, CV_32FC1 );  
  154.     //定義地址指標  
  155.     ddata = dist_buf->data.fl;  
  156.   
  157.     dr = dp;    //定義圓半徑的距離解析度  
  158.     //重新定義圓心之間的最小距離  
  159.     min_dist = MAX( min_dist, dp );  
  160.     //最小距離的平方  
  161.     min_dist *= min_dist;  
  162.     // For each found possible center  
  163.     // Estimate radius and check support  
  164.     //按照由大到小的順序遍歷整個圓心序列  
  165.     for( i = 0; i < centers->total; i++ )  
  166.     {  
  167.         //提取出圓心，得到該點在累加器矩陣中的偏移量  
  168.         int ofs = *(int*)cvGetSeqElem( centers, i );  
  169.         //得到圓心在累加器中的座標位置  
  170.         y = ofs/(acols+2);  
  171.         x = ofs - (y)*(acols+2);  
  172.         //Calculate circle's center in pixels  
  173.         //計算圓心在輸入影象中的座標位置  
  174.         float cx = (float)((x + 0.5f)*dp), cy = (float)(( y + 0.5f )*dp);  
  175.         float start_dist, dist_sum;  
  176.         float r_best = 0;  
  177.         int max_count = 0;  
  178.         // Check distance with previously detected circles  
  179.         //判斷當前的圓心與之前確定作為輸出的圓心是否為同一個圓心  
  180.         for( j = 0; j < circles->total; j++ )  
  181.         {  
  182.             //從序列中提取出圓心  
  183.             float* c = (float*)cvGetSeqElem( circles, j );  
  184.             //計算當前圓心與提取出的圓心之間的距離，如果兩者距離小於所設的閾值，則認為兩個圓心是同一個圓心，退出迴圈  
  185.             if( (c[0] - cx)*(c[0] - cx) + (c[1] - cy)*(c[1] - cy) < min_dist )  
  186.                 break;  
  187.         }  
  188.         //如果j < circles->total，說明當前的圓心已被認為與之前確定作為輸出的圓心是同一個圓心，則拋棄該圓心，返回上面的for迴圈  
  189.         if( j < circles->total )  
  190.             continue;  
  191.         // Estimate best radius  
  192.         //第二階段  
  193.         //開始讀取圓周序列nz  
  194.         cvStartReadSeq( nz, &reader );  
  195.         for( j = k = 0; j < nz_count; j++ )  
  196.         {  
  197.             CvPoint pt;  
  198.             float _dx, _dy, _r2;  
  199.             CV_READ_SEQ_ELEM( pt, reader );  
  200.             _dx = cx - pt.x; _dy = cy - pt.y;  
  201.             //步驟2.1，計算圓周上的點與當前圓心的距離，即半徑  
  202.             _r2 = _dx*_dx + _dy*_dy;  
  203.             //步驟2.2，如果半徑在所設定的最大半徑和最小半徑之間  
  204.             if(min_radius2 <= _r2 && _r2 <= max_radius2 )  
  205.             {  
  206.                 //把半徑存入dist_buf內  
  207.                 ddata[k] = _r2;  
  208.                 sort_buf[k] = k;  
  209.                 k++;  
  210.             }  
  211.         }  
  212.         //k表示一共有多少個圓周上的點  
  213.         int nz_count1 = k, start_idx = nz_count1 - 1;  
  214.         //nz_count1等於0也就是k等於0，說明當前的圓心沒有所對應的圓，意味著當前圓心不是真正的圓心，所以拋棄該圓心，返回上面的for迴圈  
  215.         if( nz_count1 == 0 )  
  216.             continue;  
  217.         dist_buf->cols = nz_count1;    //得到圓周上點的個數  
  218.         cvPow( dist_buf, dist_buf, 0.5 );    //求平方根，得到真正的圓半徑  
  219.         //步驟2.3，對圓半徑進行排序  
  220.         icvHoughSortDescent32s( &sort_buf[0], nz_count1, (int*)ddata );  
  221.   
  222.         dist_sum = start_dist = ddata[sort_buf[nz_count1-1]];  
  223.         //步驟2.4  
  224.         for( j = nz_count1 - 2; j >= 0; j-- )  
  225.         {  
  226.             float d = ddata[sort_buf[j]];  
  227.   
  228.             if( d > max_radius )  
  229.                 break;  
  230.             //d表示當前半徑值，start_dist表示上一次通過下面if語句更新後的半徑值，dr表示半徑距離解析度，如果這兩個半徑距離之差大於距離解析度，說明這兩個半徑一定不屬於同一個圓，而兩次滿足if語句條件之間的那些半徑值可以認為是相等的，即是屬於同一個圓  
  231.             if( d - start_dist > dr )  
  232.             {  
  233.                 //start_idx表示上一次進入if語句時更新的半徑距離排序的序號  
  234.                 // start_idx – j表示當前得到的相同半徑距離的數量  
  235.                 //(j + start_idx)/2表示j和start_idx中間的數  
  236.                 //取中間的數所對應的半徑值作為當前半徑值r_cur，也就是取那些半徑值相同的值  
  237.                 float r_cur = ddata[sort_buf[(j + start_idx)/2]];  
  238.                 //如果當前得到的半徑相同的數量大於最大值max_count，則進入if語句  
  239.                 if( (start_idx - j)*r_best >= max_count*r_cur ||  
  240.                     (r_best < FLT_EPSILON && start_idx - j >= max_count) )  
  241.                 {  
  242.                     r_best = r_cur;    //把當前半徑值作為最佳半徑值  
  243.                     max_count = start_idx - j;    //更新最大值  
  244.                 }  
  245.                 //更新半徑距離和序號  
  246.                 start_dist = d;  
  247.                 start_idx = j;  
  248.                 dist_sum = 0;  
  249.             }  
  250.             dist_sum += d;  
  251.         }  
  252.         // Check if the circle has enough support  
  253.         //步驟2.5，最終確定輸出  
  254.         //如果相同半徑的數量大於所設閾值  
  255.         if( max_count > acc_threshold )  
  256.         {  
  257.             float c[3];  
  258.             c[0] = cx;    //圓心的橫座標  
  259.             c[1] = cy;    //圓心的縱座標  
  260.             c[2] = (float)r_best;    //所對應的圓的半徑  
  261.             cvSeqPush( circles, c );    //壓入序列circles內  
  262.             //如果得到的圓大於閾值，則退出該函式  
  263.             if( circles->total > circles_max )  
  264.                 return;  
  265.         }  
  266.     }  
  267. }  

 

下面是用HoughCircles函式進行霍夫變換圓檢測的例項。由於HoughCircles函式內是呼叫Canny函式進行邊緣檢測，opencv的Canny函式是不包括平滑濾波這一步的，因此為了增強抗干擾能力，在使用HoughCircles函式之前，我們先對原圖進行濾波處理，我們使用的是高斯模糊方法。

[cpp] view plain copy
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/highgui/highgui.hpp"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4.   
  5. #include <iostream>  
  6. using namespace cv;  
  7. using namespace std;  
  8.   
  9. int main( int argc, char** argv )  
  10. {  
  11.     Mat src, gray;  
  12.     src=imread("coins.jpg");  
  13.     if( !src.data )    
  14.         return -1;    
  15.       
  16.     cvtColor( src, gray, CV_BGR2GRAY );  
  17.     //高斯模糊平滑  
  18.     GaussianBlur( gray, gray, Size(9, 9), 2, 2 );  
  19.   
  20.     vector<Vec3f> circles;  
  21.     //霍夫變換  
  22.     HoughCircles( gray, circles, CV_HOUGH_GRADIENT, 1, gray.rows/20, 100, 60, 0, 0 );  
  23.   
  24.     //在原圖中畫出圓心和圓  
  25.     for( size_t i = 0; i < circles.size(); i++ )  
  26.     {  
  27.         //提取出圓心座標  
  28.         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));  
  29.         //提取出圓半徑  
  30.         int radius = cvRound(circles[i][2]);  
  31.         //圓心  
  32.         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );  
  33.         //圓  
  34.         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );  
  35.    }  
  36.   
  37.     namedWindow( "Circle", CV_WINDOW_AUTOSIZE );  
  38.     imshow( "Circle", src );  
  39.   
  40.     waitKey(0);  
  41.     return 0;  
  42. }  
下圖為圓檢測的結果。

從實際執行的結果來看，我們發現HoughCircles函式不足之處是所需要的引數較多，而且每個引數的改變對結果影響都很大，即漏檢和錯檢的機率很大。

相關文章