OpenCV_連通區域分析（Connected Component Analysis/Labeling）

OpenCV_連通區域分析（Connected Component Analysis/Labeling）

【摘要】

本文主要介紹在CVPR和圖像處理領域中較爲經常使用的一種圖像區域（Blob）提取的方法——連通性分析法（連通區域標記法）。文中介紹了兩種常見的連通性分析的算法：1）Two-pass；2）Seed-Filling種子填充，並給出了兩個算法的基於OpenCV的C++實現代碼。

1、連通區域分析

連通區域（Connected Component）通常是指圖像中具備相同像素值且位置相鄰的前景像素點組成的圖像區域（Region，Blob）。連通區域分析（Connected Component Analysis,Connected Component Labeling）是指將圖像中的各個連通區域找出並標記。

連通區域分析是一種在CVPR和圖像分析處理的衆多應用領域中較爲經常使用和基本的方法。例如：OCR識別中字符分割提取（車牌識別、文本識別、字幕識別等）、視覺跟蹤中的運動前景目標分割與提取（行人入侵檢測、遺留物體檢測、基於視覺的車輛檢測與跟蹤等）、醫學圖像處理（感興趣目標區域提取）、等等。也就是說，在須要將前景目標提取出來以便後續進行處理的應用場景中都可以用到連通區域分析方法，一般連通區域分析處理的對象是一張二值化後的圖像。

2、連通區域分析的算法

從連通區域的定義能夠知道，一個連通區域是由具備相同像素值的相鄰像素組成像素集合，所以，咱們就能夠經過這兩個條件在圖像中尋找連通區域，對於找到的每一個連通區域，咱們賦予其一個惟一的標識（Label），以區別其餘連通區域。

連通區域分析有基本的算法，也有其改進算法，本文介紹其中的兩種常見算法：

1）Two-Pass法；2）Seed-Filling種子填充法；

Note：

a、這裏的掃描指的是按行或按列訪問以便圖像的全部像素，本文算法採用的是按行掃描方式；

b、圖像記爲B，爲二值圖像：前景像素（pixel value = 1），背景像素（pixel value = 0）

c、label從2開始計數；

d、像素相鄰關係：4-領域、8-領域，本文算法採用4-鄰域；

                                     

4—領域圖例                                                     8—領域圖例

1）Two-Pass（兩遍掃描法）

兩遍掃描法，正如其名，指的就是經過掃描兩遍圖像，就能夠將圖像中存在的全部連通區域找出並標記。思路：第一遍掃描時賦予每一個像素位置一個label，掃描過程當中同一個連通區域內的像素集合中可能會被賦予一個或多個不一樣label，所以須要將這些屬於同一個連通區域但具備不一樣值的label合併，也就是記錄它們之間的相等關係；第二遍掃描就是將具備相等關係的equal_labels所標記的像素歸爲一個連通區域並賦予一個相同的label（一般這個label是equal_labels中的最小值）。

下面給出Two-Pass算法的簡單步驟：

（1）第一次掃描：

訪問當前像素B(x,y)，若是B(x,y) == 1：

a、若是B(x,y)的領域中像素值都爲0，則賦予B(x,y)一個新的label：

label += 1， B(x,y) = label；

b、若是B(x,y)的領域中有像素值 > 1的像素Neighbors：

1）將Neighbors中的最小值賦予給B(x,y):

B(x,y) = min{Neighbors} 

2）記錄Neighbors中各個值（label）之間的相等關係，即這些值（label）同屬同一個連通區域；

 labelSet[i] = { label_m, .., label_n }，labelSet[i]中的全部label都屬於同一個連通區域（注：這裏能夠有多種實現方式，只要可以記錄這些具備相等關係的label之間的關係便可）

（2）第二次掃描：

訪問當前像素B(x,y)，若是B(x,y) > 1：

a、找到與label = B(x,y)同屬相等關係的一個最小label值，賦予給B(x,y)；

完成掃描後，圖像中具備相同label值的像素就組成了同一個連通區域。

下面這張圖動態地演示了Two-pass算法：

2）Seed Filling（種子填充法）

種子填充方法來源於計算機圖形學，經常使用於對某個圖形進行填充。思路：選取一個前景像素點做爲種子，而後根據連通區域的兩個基本條件（像素值相同、位置相鄰）將與種子相鄰的前景像素合併到同一個像素集合中，最後獲得的該像素集合則爲一個連通區域。

下面給出基於種子填充法的連通區域分析方法：

（1）掃描圖像，直到當前像素點B(x,y) == 1：

a、將B(x,y)做爲種子（像素位置），並賦予其一個label，而後將該種子相鄰的全部前景像素都壓入棧中；

b、彈出棧頂像素，賦予其相同的label，而後再將與該棧頂像素相鄰的全部前景像素都壓入棧中；

c、重複b步驟，直到棧爲空；

此時，便找到了圖像B中的一個連通區域，該區域內的像素值被標記爲label；

（2）重複第（1）步，直到掃描結束；

掃描結束後，就能夠獲得圖像B中全部的連通區域；

下面這張圖動態地演示了Seed-Filling算法：

3、實驗演示

1）前景二值圖像

2）連通區域分析方法標記後獲得的label圖像

Two-pass算法：

Seed-filling算法：

注：爲了顯示方便，將像素值乘以了一個整數進行放大。

3）color後的label圖像

Two-pass算法：

Seed-filling算法：

注：顏色是隨機生成的。

4、代碼

1）Two-pass算法的一種實現

說明：

基於OpenCV和C++實現，領域：4-領域。實現與算法描述稍有差異（具體爲記錄具備相等關係的label方法實現上）。

<span style="font-size:12px">//  Connected Component Analysis/Labeling By Two-Pass Algorithm
//  Author:  www.icvpr.com
//  Blog  :  http://blog.csdn.net/icvpr
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>


void icvprCcaByTwoPass(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
    // connected component analysis (4-component)
    // use two-pass algorithm
    // 1. first pass: label each foreground pixel with a label
    // 2. second pass: visit each labeled pixel and merge neighbor labels
    //
    // foreground pixel: _binImg(x,y) = 1
    // background pixel: _binImg(x,y) = 0


    if (_binImg.empty() ||
        _binImg.type() != CV_8UC1)
    {
        return ;
    }

    // 1. first pass

    _lableImg.release() ;
    _binImg.convertTo(_lableImg, CV_32SC1) ;

    int label = 1 ;  // start by 2
    std::vector<int> labelSet ;
    labelSet.push_back(0) ;   // background: 0
    labelSet.push_back(1) ;   // foreground: 1

    int rows = _binImg.rows - 1 ;
    int cols = _binImg.cols - 1 ;
    for (int i = 1; i < rows; i++)
    {
        int* data_preRow = _lableImg.ptr<int>(i-1) ;
        int* data_curRow = _lableImg.ptr<int>(i) ;
        for (int j = 1; j < cols; j++)
        {
            if (data_curRow[j] == 1)
            {
                std::vector<int> neighborLabels ;
                neighborLabels.reserve(2) ;
                int leftPixel = data_curRow[j-1] ;
                int upPixel = data_preRow[j] ;
                if ( leftPixel > 1)
                {
                    neighborLabels.push_back(leftPixel) ;
                }
                if (upPixel > 1)
                {
                    neighborLabels.push_back(upPixel) ;
                }

                if (neighborLabels.empty())
                {
                    labelSet.push_back(++label) ;  // assign to a new label
                    data_curRow[j] = label ;
                    labelSet[label] = label ;
                }
                else
                {
                    std::sort(neighborLabels.begin(), neighborLabels.end()) ;
                    int smallestLabel = neighborLabels[0] ;
                    data_curRow[j] = smallestLabel ;

                    // save equivalence
                    for (size_t k = 1; k < neighborLabels.size(); k++)
                    {
                        int tempLabel = neighborLabels[k] ;
                        int& oldSmallestLabel = labelSet[tempLabel] ;
                        if (oldSmallestLabel > smallestLabel)
                        {
                            labelSet[oldSmallestLabel] = smallestLabel ;
                            oldSmallestLabel = smallestLabel ;
                        }
                        else if (oldSmallestLabel < smallestLabel)
                        {
                            labelSet[smallestLabel] = oldSmallestLabel ;
                        }
                    }
                }
            }
        }
    }

    // update equivalent labels
    // assigned with the smallest label in each equivalent label set
    for (size_t i = 2; i < labelSet.size(); i++)
    {
        int curLabel = labelSet[i] ;
        int preLabel = labelSet[curLabel] ;
        while (preLabel != curLabel)
        {
            curLabel = preLabel ;
            preLabel = labelSet[preLabel] ;
        }
        labelSet[i] = curLabel ;
    }


    // 2. second pass
    for (int i = 0; i < rows; i++)
    {
        int* data = _lableImg.ptr<int>(i) ;
        for (int j = 0; j < cols; j++)
        {
            int& pixelLabel = data[j] ;
            pixelLabel = labelSet[pixelLabel] ;
        }
    }
}</span>

2）Seed-Filling種子填充方法

說明：

基於OpenCV和C++實現；領域：4-領域。

<span style="font-size:12px">//  Connected Component Analysis/Labeling By Seed-Filling Algorithm
//  Author:  www.icvpr.com
//  Blog  :  http://blog.csdn.net/icvpr
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>


void icvprCcaBySeedFill(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
    // connected component analysis (4-component)
    // use seed filling algorithm
    // 1. begin with a foreground pixel and push its foreground neighbors into a stack;
    // 2. pop the top pixel on the stack and label it with the same label until the stack is empty
    //
    // foreground pixel: _binImg(x,y) = 1
    // background pixel: _binImg(x,y) = 0


    if (_binImg.empty() ||
        _binImg.type() != CV_8UC1)
    {
        return ;
    }

    _lableImg.release() ;
    _binImg.convertTo(_lableImg, CV_32SC1) ;

    int label = 1 ;  // start by 2

    int rows = _binImg.rows - 1 ;
    int cols = _binImg.cols - 1 ;
    for (int i = 1; i < rows-1; i++)
    {
        int* data= _lableImg.ptr<int>(i) ;
        for (int j = 1; j < cols-1; j++)
        {
            if (data[j] == 1)
            {
                std::stack<std::pair<int,int>> neighborPixels ;
                neighborPixels.push(std::pair<int,int>(i,j)) ;     // pixel position: <i,j>
                ++label ;  // begin with a new label
                while (!neighborPixels.empty())
                {
                    // get the top pixel on the stack and label it with the same label
                    std::pair<int,int> curPixel = neighborPixels.top() ;
                    int curX = curPixel.first ;
                    int curY = curPixel.second ;
                    _lableImg.at<int>(curX, curY) = label ;

                    // pop the top pixel
                    neighborPixels.pop() ;

                    // push the 4-neighbors (foreground pixels)
                    if (_lableImg.at<int>(curX, curY-1) == 1)
                    {// left pixel
                        neighborPixels.push(std::pair<int,int>(curX, curY-1)) ;
                    }
                    if (_lableImg.at<int>(curX, curY+1) == 1)
                    {// right pixel
                        neighborPixels.push(std::pair<int,int>(curX, curY+1)) ;
                    }
                    if (_lableImg.at<int>(curX-1, curY) == 1)
                    {// up pixel
                        neighborPixels.push(std::pair<int,int>(curX-1, curY)) ;
                    }
                    if (_lableImg.at<int>(curX+1, curY) == 1)
                    {// down pixel
                        neighborPixels.push(std::pair<int,int>(curX+1, curY)) ;
                    }
                }
            }
        }
    }
}</span>

3）顏色標記（用於顯示）

<span style="font-size:12px">//  Connected Component Analysis/Labeling -- Color Labeling
//  Author:  www.icvpr.com
//  Blog  :  http://blog.csdn.net/icvpr
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

cv::Scalar icvprGetRandomColor()
{
    uchar r = 255 * (rand()/(1.0 + RAND_MAX));
    uchar g = 255 * (rand()/(1.0 + RAND_MAX));
    uchar b = 255 * (rand()/(1.0 + RAND_MAX));
    return cv::Scalar(b,g,r) ;
}


void icvprLabelColor(const cv::Mat& _labelImg, cv::Mat& _colorLabelImg)
{
    if (_labelImg.empty() ||
        _labelImg.type() != CV_32SC1)
    {
        return ;
    }

    std::map<int, cv::Scalar> colors ;

    int rows = _labelImg.rows ;
    int cols = _labelImg.cols ;

    _colorLabelImg.release() ;
    _colorLabelImg.create(rows, cols, CV_8UC3) ;
    _colorLabelImg = cv::Scalar::all(0) ;

    for (int i = 0; i < rows; i++)
    {
        const int* data_src = (int*)_labelImg.ptr<int>(i) ;
        uchar* data_dst = _colorLabelImg.ptr<uchar>(i) ;
        for (int j = 0; j < cols; j++)
        {
            int pixelValue = data_src[j] ;
            if (pixelValue > 1)
            {
                if (colors.count(pixelValue) <= 0)
                {
                    colors[pixelValue] = icvprGetRandomColor() ;
                }
                cv::Scalar color = colors[pixelValue] ;
                *data_dst++   = color[0] ;
                *data_dst++ = color[1] ;
                *data_dst++ = color[2] ;
            }
            else
            {
                data_dst++ ;
                data_dst++ ;
                data_dst++ ;
            }
        }
    }
}
</span>

4）測試程序

<span style="font-size:12px">//  Connected Component Analysis/Labeling -- Test code
//  Author:  www.icvpr.com
//  Blog  :  http://blog.csdn.net/icvpr
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

int main(int argc, char** argv)
{
    cv::Mat binImage = cv::imread("../icvpr.com.jpg", 0) ;
    cv::threshold(binImage, binImage, 50, 1, CV_THRESH_BINARY_INV) ;

    // connected component labeling
    cv::Mat labelImg ;
    icvprCcaByTwoPass(binImage, labelImg) ;
    //icvprCcaBySeedFill(binImage, labelImg) ;

    // show result
    cv::Mat grayImg ;
    labelImg *= 10 ;
    labelImg.convertTo(grayImg, CV_8UC1) ;
    cv::imshow("labelImg", grayImg) ;

    cv::Mat colorLabelImg ;
    icvprLabelColor(labelImg, colorLabelImg) ;
    cv::imshow("colorImg", colorLabelImg) ;
    cv::waitKey(0) ;

    return 0 ;
}</span>

Reference

[1] http://en.wikipedia.org/wiki/Connected-component_labeling

[2] http://homepages.inf.ed.ac.uk/rbf/HIPR2/label.htm

[3] http://www.codeproject.com/Articles/336915/Connected-Component-Labeling-Algorithm

來源： <http://blog.csdn.net/icvpr/article/details/10259577>

 

來自爲知筆記(Wiz)