opencv学习系列：连通域参考处理

OpenCV里提取目标轮廓的函数是findContours，它的输入图像是一幅二值图像，输出的是每一个连通区域的轮廓点的集合：vector<vector>。
外层vector的size代表了图像中轮廓的个数，里面vector的size代表了轮廓上点的个数。

hiararchy参数和轮廓个数相同，每个轮廓contours[ i ]对应4个hierarchy元素hierarchy[ i ][ 0 ] ~hierarchy[ i ][ 3 ]，分别表示后一个轮廓、前一个轮廓、父轮廓、内嵌轮廓的索引编号，如果没有对应项，该值设置为负数。
第六个参数传入CV_CHAIN_CODE时，要设置成sizeof(CvChain),其它情况统一设置成sizeof(CvContour)
CV_CHAIN_CODE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。
CV_CHAIN_APPROX_SIMPLE：压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。例如一个矩形轮廓只需4个点来保存轮廓信息
CV_RETR_EXTERNAL：只检索最外面的轮廓；
CV_RETR_LIST：检测的轮廓不建立等级关系，检索所有的轮廓，并将其保存到一条链表当中；
CV_RETR_CCOMP：建立两个等级的轮廓，上面的一层为外边界，里面的一层为内孔的边界信息。检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界；
CV_RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次，可以参见下图。
加滚动条确定阈值化的合适阈值！：http://blog.csdn.net/augusdi/article/details/9021467
****************************************************************************************
//做一下膨胀，x与y方向都做，但系数不同
            var kernal = Cv.CreateStructuringElementEx(5, 2, 1, 1, ElementShape.Rect);
            Cv.Erode(gray, gray, kernal, 2);

            //二值化
            Cv.Threshold(gray, gray, 0, 255, ThresholdType.BinaryInv | ThresholdType.Otsu);

            //检测连通域，每一个连通域以一系列的点表示，FindContours方法只能得到第一个域
            var storage = Cv.CreateMemStorage();
            CvSeq contour = null;
            Cv.FindContours(gray, storage, out contour, CvContour.SizeOf, ContourRetrieval.CComp, ContourChain.ApproxSimple);
            var color = new CvScalar(0, 0, 255);

            //开始遍历
            while (contour != null)
            {
                //得到这个连通区域的外接矩形
                var rect = Cv.BoundingRect(contour);

                //如果高度不足，或者长宽比太小，认为是无效数据，否则把矩形画到原图上
                if(rect.Height > 10 && (rect.Width * 1.0 / rect.Height) > 0.2)
                    Cv.DrawRect(src, rect, color);

                //取下一个连通域
                contour = contour.HNext;
            }

***************************************************************






***********************************************************************************************************
// 移除过小或过大的轮廓  
void getSizeContours(vector<vector> &contours)  
{  
    int cmin = 100;   // 最小轮廓长度  
    int cmax = 1000;   // 最大轮廓长度  
    vector<vector>::const_iterator itc = contours.begin();  
    while(itc != contours.end())  
    {  
        if((itc->size()) < cmin || (itc->size()) > cmax)  
        {  
            itc = contours.erase(itc);  
        }  
        else ++ itc;  
    }  
}  
****************************************************************************
while(contour) {
  /*area = cvContourArea(contour, CV_WHOLE_SEQ);*/
  area = fabs(cvContourArea( contour, CV_WHOLE_SEQ )); //获取当前轮廓面积
  printf("area == %lf\n", area);
  //画轮廓
  //画外接矩形
  CvRect r = ((CvContour*)contour)->rect;
  if (r.height * r.width > size)
  {
   cvRectangle(pimg, cvPoint(r.x, r.y), cvPoint(r.x + r.width, r.y + r.height),CV_RGB(255, 0, 0), 1, CV_AA, 0);


  }
  contour = contour->h_next;

 }

*********************************************************************************************************
// Get the contours of the connected components  
    std::vector<std::vector> contours;  

    cv::findContours(gray,   
        contours, // a vector of contours   
        CV_RETR_EXTERNAL , // retrieve the external contours  
        CV_CHAIN_APPROX_NONE); // retrieve all pixels of each contours  

    // Print contours' length  
    std::cout << "Contours: " << contours.size() << std::endl;  
    std::vector<std::vector>::const_iterator itContours= contours.begin();  
    for ( ; itContours!=contours.end(); ++itContours)   
    {  

        std::cout << "Size: " << itContours->size() << std::endl;  
    }  

    // draw black contours on white image  
    cv::Mat result(image.size(),CV_8U,cv::Scalar(255));  
    cv::drawContours(result,contours,  
        -1, // draw all contours  
        cv::Scalar(0), // in black  
        2); // with a thickness of 2  

************************************************************************
 double maxarea = 0;  
    double minarea = 100;  
    int m = 0;  
    for( ; contour != 0; contour = contour->h_next )    
    {    

        double tmparea = fabs(cvContourArea(contour));  
        if(tmparea < minarea)     
        {    
            cvSeqRemove(contour, 0); // 删除面积小于设定值的轮廓  
            continue;  
        }    
        CvRect aRect = cvBoundingRect( contour, 0 );   
        if ((aRect.width/aRect.height)<1)    
        {    
            cvSeqRemove(contour, 0); //删除宽高比例小于设定值的轮廓  
            continue;  
        }    
        if(tmparea > maxarea)    
        {    
            maxarea = tmparea;  
        }    
        m++;  
        // 创建一个色彩值  
        CvScalar color = CV_RGB( 0, 255, 255 );  

        //max_level 绘制轮廓的最大等级。如果等级为0，绘制单独的轮廓。如果为1，绘制轮廓及在其后的相同的级别下轮廓  
        //如果值为2，所有的轮廓。如果等级为2，绘制所有同级轮廓及所有低一级轮廓，诸此种种  
        //如果值为负数，函数不绘制同级轮廓，但会升序绘制直到级别为abs(max_level)-1的子轮廓  
        cvDrawContours(dst, contour, color, color, -1, 1, 8);   //绘制外部和内部的轮廓  
    }    
    contour = _contour;  
    int count = 0;  
    for(; contour != 0; contour = contour->h_next)  
    {    
        count++;  
        double tmparea = fabs(cvContourArea(contour));  
        if (tmparea == maxarea)    
        {    
            CvScalar color = CV_RGB( 255, 0, 0);  
            cvDrawContours(dst, contour, color, color, -1, 1, 8);  
        }    
    }    
*************************************************************************************
在提取之前还可以调用一个函数：   
         contour = cvApproxPoly( contour, sizeof(CvContour), storage, CV_POLY_APPROX_DP, 3, 1 );   
         可能是拟合，有这一句找出的轮廓线更直。   contour里面包含了很多个轮廓，每个轮廓是单独存放的.  

输出轮廓位置！
 printf(" %d elements:\n", c->total );  
     for( int i=0; itotal; ++i ) {  
     CvPoint* p = CV_GET_SEQ_ELEM( CvPoint, c, i );  
        printf("    (%d,%d)\n", p->x, p->y );  
     }  
输出轮廓面积！
for( ; contour; contour = contour->h_next)  
    {  
        area = fabs(cvContourArea(contour, CV_WHOLE_SEQ)); //获取当前轮廓面积  
        printf("area == %lf\n", area);  
        if(area > maxArea)  
        {  
            contmax = contour;  
            maxArea = area;  
        }  
    }  
***********************************************************************************************
内轮廓填充   
// 参数:   
// 1. pBinary: 输入二值图像，单通道，位深IPL_DEPTH_8U。  
// 2. dAreaThre: 面积阈值，当内轮廓面积小于等于dAreaThre时，进行填充。   
void FillInternalContours(IplImage *pBinary, double dAreaThre)   
{   
    double dConArea;   
    CvSeq *pContour = NULL;   
    CvSeq *pConInner = NULL;   
    CvMemStorage *pStorage = NULL;   
    // 执行条件   
    if (pBinary)   
    {   
        // 查找所有轮廓   
        pStorage = cvCreateMemStorage(0);   
        cvFindContours(pBinary, pStorage, &pContour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);   
        // 填充所有轮廓   
        cvDrawContours(pBinary, pContour, CV_RGB(255, 255, 255), CV_RGB(255, 255, 255), 2, CV_FILLED, 8, cvPoint(0, 0));  
        // 外轮廓循环   
        for (; pContour != NULL; pContour = pContour->h_next)   
        {   
            // 内轮廓循环   
            for (pConInner = pContour->v_next; pConInner != NULL; pConInner = pConInner->h_next)   
            {   
                // 内轮廓面积   
                dConArea = fabs(cvContourArea(pConInner, CV_WHOLE_SEQ));   
                if (dConArea <= dAreaThre)   
                {   
                    cvDrawContours(pBinary, pConInner, CV_RGB(255, 255, 255), CV_RGB(255, 255, 255), 0, CV_FILLED, 8, cvPoint(0, 0));  
                }   
            }   
        }   
        cvReleaseMemStorage(&pStorage);   
        pStorage = NULL;   
    }   
}  

******************************************************************* *********************
// Get the contours of the connected components
    std::vector<std::vector> contours;
    cv::findContours(image, 
        contours, // a vector of contours 
        CV_RETR_EXTERNAL, // retrieve the external contours
        CV_CHAIN_APPROX_NONE); // retrieve all pixels of each contours

    // Print contours' length
    std::cout << "Contours: " << contours.size() << std::endl;
    std::vector<std::vector>::const_iterator itContours= contours.begin();
    for ( ; itContours!=contours.end(); ++itContours) 
    {

        std::cout << "Size: " << itContours->size() << std::endl;
    }

***************************************************************************************
// Eliminate too short or too long contours
    int cmin= 100;  // minimum contour length
    int cmax= 1000; // maximum contour length
    std::vector<std::vector>::const_iterator itc= contours.begin();
    while (itc!=contours.end()) {

        if (itc->size() < cmin || itc->size() > cmax)
            itc= contours.erase(itc);
        else 
            ++itc;
    }

输出所有轮廓的旋转角度
CvBox2D     End_Rage2D;

    CvMemStorage *storage = cvCreateMemStorage(0);  //开辟内存空间


    CvSeq*      contour = NULL;     //CvSeq类型 存放检测到的图像轮廓边缘所有的像素值，坐标值特征的结构体以链表形式

    cvFindContours( pSrcImage, storage, &contour, sizeof(CvContour),CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE);//这函数可选参数还有不少
 for(; contour; contour = contour->h_next)   //如果contour不为空，表示找到一个以上轮廓，这样写法只显示一个轮廓
        //如改为for(; contour; contour = contour->h_next) 就可以同时显示多个轮廓
    {  

        End_Rage2D = cvMinAreaRect2(contour);  
        //代入cvMinAreaRect2这个函数得到最小包围矩形  这里已得出被测物体的角度，宽度,高度，和中点坐标点存放在CvBox2D类型的结构体中，
        //主要工作基本结束。

    std::cout <<" angle:\n"<<(float)End_Rage2D.angle << std::endl;      //被测物体旋转角度 

    }
//函数形式画轮廓
void DrawRec(IplImage* pImgFrame,IplImage* pImgProcessed,int MaxArea)  
{  
    //pImgFrame:初始未处理的帧，用于最后标出检测结果的输出;  
    //pImgProcessed:处理完的帧,用于找运动物体的轮廓  

    stor = cvCreateMemStorage(0);  //创建动态结构和序列  
    cont = cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvSeq), sizeof(CvPoint) , stor);  

    // 找到所有轮廓  
    cvFindContours( pImgProcessed, stor, &cont, sizeof(CvContour),   
                    CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0));  

    // 直接使用CONTOUR中的矩形来画轮廓  
    for(;cont;cont = cont->h_next)  
    {  
              CvRect r = ((CvContour*)cont)->rect;  
              if(r.height * r.width > MaxArea) // 面积小的方形抛弃掉  
              {  
                  cvRectangle( pImgFrame, cvPoint(r.x,r.y),   
                          cvPoint(r.x + r.width, r.y + r.height),  
                          CV_RGB(255,0,0), 1, CV_AA,0);  
              }  
    }  
    cvShowImage("video", pImgFrame);  
}  

***********************************************************************************************

绍opencv 的基于面积区域过滤方法，这个对图像处理时去除小区域杂点是很有帮助的。基于区域宽度，高度等其他方式的过滤也可以根据这个方法类推。

# 图片中找到我们需要的目标 一般是最大连通区域
#获取当前轮廓面积
area = abs(cv.cvContourArea( contour ))
# 获取最大区域矩形块
aRect = cv.cvBoundingRect( contmax, 0 )
#原始区域的不加边框
#rcenter = cv.cvPoint2D32f(aRect.x + aRect.width/2.0, aRect.y + aRect.height/2.0)

*****************************************************************************************
//移除过长或过短的轮廓  
    int cmin = 100; //最小轮廓长度  
    int cmax = 1000;    //最大轮廓  
    vector<vector>::const_iterator itc = contours.begin();  
    while (itc!=contours.end())  
    {  
        if (itc->size() < cmin || itc->size() > cmax)  
            itc = contours.erase(itc);  
        else  
            ++itc;  
    }  

    //在白色图像上绘制黑色轮廓  
    Mat result_erase(binaryImage.size(), CV_8U, Scalar(255));  
    drawContours(result_erase, contours,  
        -1, //绘制所有轮廓  
        Scalar(0),  //颜色为黑色  
        2); //轮廓线的绘制宽度为2  

 Rect r0 = boundingRect(Mat(contours[0]));  
    rectangle(result_erase, r0, Scalar(128), 2);  
    Rect r1 = boundingRect(Mat(contours[1]));  
    rectangle(result_erase, r1, Scalar(128), 2);  

*****************************************************************************************************************
 //对前景先进行中值滤波，再进行形态学膨胀操作，以去除伪目标和连接断开的小目标
 69         medianBlur(mask, mask, 5);
 70         //morphologyEx(mask, mask, MORPH_DILATE, getStructuringElement(MORPH_RECT, Size(5, 5)));
 71 
 72         //测试：先开运算再闭运算
 73         morphologyEx(mask, mask, MORPH_CLOSE, getStructuringElement(MORPH_RECT, Size(5, 5)));
 74         morphologyEx(mask, mask, MORPH_OPEN, getStructuringElement(MORPH_RECT, Size(5, 5)));


 //外接矩阵
 93         Rect rct;
 94 
 95         //对轮廓进行外接矩阵之前先对轮廓按面积降序排序，目的为了去除小目标（伪目标）
 96         sort(contours.begin(), contours.end(), descSort);
 97 
 98         for (int i = 0; i < contours.size(); i++)
 99         {
100             //当第i个连通分量的外接矩阵面积小于最大面积的1/6，则认为是伪目标
101             if (contourArea(contours[i]) < contourArea(contours[0]) / 5)
102                 break;
103             //包含轮廓的最小矩阵
104             rct = boundingRect(contours[i]);
105             rectangle(result, rct, Scalar(0, 255, 0), 2);
106 
107         }

**************************************************************************************************************
 Mat element(5,5,CV_8U,Scalar(1));  
 cvMorphologyEx(green, green, NULL, element, CV_MOP_OPEN);       // 开运算,去除比结构元素小的亮点  

cvThreshold(green, green, 0.0, 255.0, CV_THRESH_BINARY | CV_THRESH_OTSU);   // OTSU法二值化  

一般用：findContours(image,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_NONE);  
int cmin=100;  

int cmax=1000;  

vector<std::vector >::iterator itc = contours.begin();  

while(itc!=contours.end())  

{  

    if(itc->size()size()>cmax)  

        itc =contours.erase(itc);  

    else  

        itc++;  

}   
Mat image2=imread("E:\\group.jpg");   
drawContours(image2,contours,-1,Scalar(255,255,255),2);  
imshow("image",image2);