種子填充法原理

大致演算法如下：

設二值化影象A中，畫素值為255的點是前景，為0的點是背景。A(x, y)為座標(x, y)處的畫素值，遍歷影象的每個畫素：

1、 如果畫素值不等於255，則繼續訪問下一個元素。

2、 如果畫素值為A(x, y) = 255，則新建一個新的label，當前值A(x, y) = label，並且

a. 檢查其4個鄰域，如果有屬於前景的畫素也給它賦予label值，並將它的座標壓棧。

b. 彈出棧頂座標，重複a的過程，知道堆疊為空。 
此時，便找到了一個連通區域，該區域內的畫素值被標記為label。

3、 重複1、2的過程，檢測出所有的區域。

廢話少說，上程式碼！

實現程式

該程式基於OpenCV2.4.9 和VS2010平臺：

#include <opencv2\opencv.hpp>
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
using namespace cv;

typedef struct _Feather
{
    int label;              // 連通域的label值
    int area;               // 連通域的面積
    Rect boundingbox;       // 連通域的外接矩形框
 

} Feather;

/* 
Input: 
    src: 待檢測連通域的二值化影象
Output:
    dst: 標記後的影象
    featherList: 連通域特徵的清單
return： 
    連通域數量。
*/
int bwLabel(Mat & src, Mat & dst, vector<Feather> & featherList)
{
    int rows = src.rows;
    int cols = src.cols;

    int labelValue = 0;
    Point seed, neighbor;
    stack
 
<Point> pointStack;    // 堆疊

    int area = 0;               // 用於計算連通域的面積
    int leftBoundary = 0;       // 連通域的左邊界，即外接最小矩形的左邊框，橫座標值，依此類推
    int rightBoundary = 0;
    int topBoundary = 0;
    int bottomBoundary = 0;
    Rect box;                   // 外接矩形框
    Feather feather;

    featherList.clear();    // 清除陣列

    dst.release();
    dst = src.clone();
    for( int i = 0; i < rows; i++)
    {
        uchar *pRow = dst.ptr<uchar>(i);
        for( int j = 0; j < cols; j++)
        {
            if(pRow[j] == 255)
            {
                area = 0;
                labelValue++;           // labelValue最大為254，最小為1.
                seed = Point(j, i);     // Point（橫座標，縱座標）
                dst.at<uchar>(seed) = labelValue;
                pointStack.push(seed);

                area++;
                leftBoundary = seed.x;
                rightBoundary = seed.x;
                topBoundary = seed.y;
                bottomBoundary = seed.y;

                while(!pointStack.empty())
                {
                    neighbor = Point(seed.x+1, seed.y);
                    if((seed.x != (cols-1)) && (dst.at<uchar>(neighbor) == 255))
                    {
                        dst.at<uchar>(neighbor) = labelValue;
                        pointStack.push(neighbor);

                        area++;
                        if(rightBoundary < neighbor.x)
                            rightBoundary = neighbor.x;
                    }

                    neighbor = Point(seed.x, seed.y+1);
                    if((seed.y != (rows-1)) && (dst.at<uchar>(neighbor) == 255))
                    {
                        dst.at<uchar>(neighbor) = labelValue;
                        pointStack.push(neighbor);

                        area++;
                        if(bottomBoundary < neighbor.y)
                            bottomBoundary = neighbor.y;

                    }

                    neighbor = Point(seed.x-1, seed.y);
                    if((seed.x != 0) && (dst.at<uchar>(neighbor) == 255))
                    {
                        dst.at<uchar>(neighbor) = labelValue;
                        pointStack.push(neighbor);

                        area++;
                        if(leftBoundary > neighbor.x)
                            leftBoundary = neighbor.x;
                    }

                    neighbor = Point(seed.x, seed.y-1);
                    if((seed.y != 0) && (dst.at<uchar>(neighbor) == 255))
                    {
                        dst.at<uchar>(neighbor) = labelValue;
                        pointStack.push(neighbor);

                        area++;
                        if(topBoundary > neighbor.y)
                            topBoundary = neighbor.y;
                    }

                    seed = pointStack.top();
                    pointStack.pop();
                }
                box = Rect(leftBoundary, topBoundary, rightBoundary-leftBoundary, bottomBoundary-topBoundary);
                rectangle(src, box, 255);
                feather.area = area;
                feather.boundingbox = box;
                feather.label = labelValue;
                featherList.push_back(feather);
            }
        }
    }
    return labelValue;
}

int main(int argc, char *argv[])
{
    Mat src(imread("shape.jpg", 0));
    if(src.empty())
        exit(-1);
    threshold(src, src, 127, 255, THRESH_BINARY);   // 二值化影象
    vector<Feather> featherList;                    // 存放連通域特徵
    Mat dst;
    cout << "連通域數量： " << bwLabel(src, dst, featherList) << endl;

    // 為了方便觀察，可以將label“放大”
    for( int i = 0; i < dst.rows; i++)
    {
        uchar *p = dst.ptr<uchar>(i);
        for( int j = 0; j < dst.cols; j++)
        {
            p[j] = 30*p[j];
        }
    }

    cout << "標號" << "\t" << "面積" << endl;
    for(vector<Feather>::iterator it = featherList.begin(); it < featherList.end(); it++)
    {
        cout << it->label << "\t" << it->area << endl;
        rectangle(dst, it->boundingbox, 255);
    }

    imshow("src", src);
    imshow("dst", dst);

    waitKey();
    destroyAllWindows();

    system("pause");
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163

執行結果：

原圖： 

檢測結果： 

特徵清單：