2. 程式人生 > >漫水填充演算法

漫水填充演算法

阿新 • • 發佈：2019-01-30

所謂漫水填充演算法，是給定一個聯通域內的一個點，以此為起點找到這個聯通域的其餘所有點並將其填充為指定顏色的一種演算法。 
之所以稱之為漫水填充，是因為這種演算法就是模擬了漲水的過程，從一點開始，水流慢慢加大，直到漫過了全部區域。 
這個演算法的詳細介紹可以參考下面的連結。 
https://en.wikipedia.org/wiki/Flood_fill

這個演算法在我們尋找一片指定區域時非常有用。因此，我就花了點時間寫了個程式。我所實現的演算法類似於下面這張圖片中的方法，不過我是每次填充一行。

這裡寫圖片描述

下面這個 floodFill_Gray 函式用於填充灰度影象，講一個聯通域的灰度填充為 newVal。

static inline bool fillPoint_Gray( QImage &image, QPoint p, uchar val, uchar newVal, QStack<QPoint> &stack)
{
    int x = p.rx();
    int y = p.ry();
    uchar *line = image.scanLine(y);
    if( line[x] != val )
    {
        return false;
    }
    line[x] = newVal;
    if( y > 0 )
    {
        uchar *last = image.scanLine(y - 1
 
);
        if( last[x] == val )
        {
            stack.push(QPoint(x, y - 1));
        }
    }
    if( y < image.height() - 1 )
    {
        uchar *next = image.scanLine(y + 1);
        if( next[x] == val )
        {
            stack.push(QPoint(x, y + 1));
        }
    }
    return true;
}

bool
 
 floodFill_Gray(QImage &image, QPoint seedPoint, uchar newVal )
{
    if(image.format() != QImage::Format_Indexed8)
    {
        return false;
    }
    int width = image.width();
    int height = image.height();
    int x = seedPoint.rx();
    int y = seedPoint.ry();
    if(x < 0 || x >= width || y < 0 || y >= height)
    {
        return false;
    }
    int value = image.scanLine(y)[x];
    QStack<QPoint> stack;
    stack.push(seedPoint);

    while(!stack.isEmpty())
    {
        QPoint p = stack.pop();
        bool ret = fillPoint_Gray(image, p, value, newVal, stack);
        bool ret2 = ret;
        y = p.ry();
        x = p.rx();
        x--;
        while(x >= 0 && ret)
        {
            ret = fillPoint_Gray(image, QPoint(x, y), value, newVal, stack);
            x--;
        }

        x = p.rx();
        x ++;
        while(x < width && ret2)
        {
            ret2 = fillPoint_Gray(image, QPoint(x, y), value, newVal, stack);
            x++;
        }
    }
    return true;
}
  • 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
  • 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

有時，由於有噪聲等影響，我們的待填充區域內的原始顏色並不完全一樣，這時可以採用模糊填充。所謂模糊填充就是我們設定一個顏色範圍，將這個顏色範圍內的點都認為是區域的內點。 
下面的程式碼就實現了這個功能。

static inline bool fillPoint_Gray( QImage &image, QPoint p, uchar low, uchar high, uchar newVal, QStack<QPoint> &stack)
{
    int x = p.rx();
    int y = p.ry();
    uchar *line = image.scanLine(y);
    if( line[x] < low || line[x] > high )
    {
        return false;
    }
    line[x] = newVal;
    if( y > 0 )
    {
        uchar *last = image.scanLine(y - 1);
        if( last[x] >= low && last[x] <= high )
        {
            stack.push(QPoint(x, y - 1));
        }
    }
    if( y < image.height() - 1 )
    {
        uchar *next = image.scanLine(y + 1);
        if( next[x] >= low && next[x] <= high )
        {
            stack.push(QPoint(x, y + 1));
        }
    }
    return true;
}

bool floodFill_Gray(QImage &image, QPoint seedPoint, int low, int high, uchar newVal )
{
    if(image.format() != QImage::Format_Indexed8)
    {
        return false;
    }
    low = qBound(0, low, 255);
    high = qBound(0, high, 255);
    if(low > high)
    {
        return false;
    }

    QStack<QPoint> stack;
    stack.push(seedPoint);

    int width = image.width();
    while(!stack.isEmpty())
    {
        QPoint p = stack.pop();
        bool ret = fillPoint_Gray(image, p, low, high, newVal, stack);
        bool ret2 = ret;
        int y = p.ry();
        int x = p.rx();
        x--;
        while(x >= 0 && ret)
        {
            ret = fillPoint_Gray(image, QPoint(x, y), low, high, newVal, stack);
            x--;
        }

        x = p.rx();
        x ++;
        while(x < width && ret2)
        {
            ret2 = fillPoint_Gray(image, QPoint(x, y), low, high, newVal, stack);
            x++;
        }
    }
    return true;
}
  • 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
  • 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

我還寫了一個用來填充彩色影象的。這個程式碼還比較簡單，暫時還沒實現模糊顏色的判別。之所以沒有寫，主要還是在RGB顏色空間中，不太方便度量兩個顏色值之間的距離。如果簡單的採用歐氏距離，則與我們眼睛對色彩的感受會有些出入。可能我們覺得顏色差別很大的兩個顏色的距離並不遠，而看起來差不多的兩個顏色可能距離挺大的。

static inline bool fillPoint_RGB32( QImage &image, QPoint p, QRgb val, QRgb newVal, QStack<QPoint> &stack)
{
    int x = p.rx();
    int y = p.ry();
    QRgb *line = (QRgb*)image.scanLine(y);
    if( line[x] != val )
    {
        return false;
    }
    line[x] = newVal;
    if( y > 0 )
    {
        QRgb *last = (QRgb*)image.scanLine(y - 1);
        if( last[x] == val )
        {
            stack.push(QPoint(x, y - 1));
        }
    }
    if( y < image.height() - 1 )
    {
        QRgb *next = (QRgb*)image.scanLine(y + 1);
        if( next[x] == val )
        {
            stack.push(QPoint(x, y + 1));
        }
    }
    return true;
}

bool floodFill_RGB32(QImage &image, QPoint seedPoint, QRgb newVal )
{
    qDebug() << image.format();
    if(image.format() != QImage::Format_RGBA8888 && image.format() != QImage::Format_ARGB32 )
    {
        return false;
    }
    int width = image.width();
    int height = image.height();
    int x = seedPoint.rx();
    int y = seedPoint.ry();
    if(x < 0 || x >= width || y < 0 || y >= height)
    {
        return false;
    }
    QRgb value = image.pixel(x, y);
    QStack<QPoint> stack;
    stack.push(seedPoint);

    while(!stack.isEmpty())
    {
        QPoint p = stack.pop();
        bool ret = fillPoint_RGB32(image, p, value, newVal, stack);
        bool ret2 = ret;
        y = p.ry();
        x = p.rx();
        x--;
        while(x >= 0 && ret)
        {
            ret = fillPoint_RGB32(image, QPoint(x, y), value, newVal, stack);
            x--;
        }

        x = p.rx();
        x ++;
        while(x < width && ret2)
        {
            ret2 = fillPoint_RGB32(image, QPoint(x, y), value, newVal, stack);
            x++;
        }
    }
    return true;
}
  • 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
  • 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

下面是一個測試影象。

這裡寫圖片描述

我要將其中最大的紅色的聯通區域填充為藍色。下面是填充後的結果。 
這裡寫圖片描述

但是這個演算法有一個注意事項，就是它只將上下左右相鄰的畫素視為連同，斜向相鄰的畫素認為是不連通的。之所以這樣設計是為了處理下面這種情況。如果斜向也認為是連同的話那麼下圖中所有的白色區域就都是聯通的了，這和我們直觀的感覺是不相同的。

這裡寫圖片描述

當然，這樣處理後，黑色區域中有兩個孤立點就被程式認為不與其他黑色區域聯通了。這個與我們直觀感覺也是有差異的。總之，這兩種情況無法兼顧。

相關推薦

影象形態學 漫水填充演算法

FloodFill用指定顏色填充一個連線域 void cvFloodFill( CvArr* image, CvPoint seed_point, CvScalar new_val,CvScalar lo_diff=cvScalarAll(0), CvScalar up_d

opencv漫水填充演算法cvFloodFill()

CVAPI(void)  cvFloodFill(    CvArr* image,//輸入影象   CvPoint seed_point,//輸入種子點的座標   CvScalar new_val,//輸入畫素點被染為什麼顏色   CvScalar lo_diff CV_

cvFloodFill() 漫水填充演算法

感性認識為：畫圖板的填充工具和photoshop的容差索套工具混合而成的一個工具 函式原型： CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,                           CvS

漫水填充演算法

所謂漫水填充演算法，是給定一個聯通域內的一個點，以此為起點找到這個聯通域的其餘所有點並將其填充為指定顏色的一種演算法。  之所以稱之為漫水填充，是因為這種演算法就是模擬了漲水的過程，從一點開始，水流慢慢加大，直到漫過了全部區域。  這個演算法的詳細介紹可以參考下面的連結。

OpenCV學習筆記-漫水填充演算法

滿水填充演算法需要使用的函式為：void cvFloodFill( IplImage* src, CvPoint seedPoint, //漫水法從點seedPoint開始實行演算法 CvScalar newVal, //畫素點被染色的值 CvScalar loDiff =

Oil Deposits DFS FloodFill漫水填充法求連通塊問題

with this ron reg row led one 個數 ret Oil Deposits The GeoSurvComp geologic survey company is responsible for detecting underground

【opencv入門】漫水填充算法（Floodfill）

部件 tro 分享圖片 函數的原型 過程 輪詢 output 輸入 通用 一、引言 · 漫水填充的定義 　　漫水填充法是一種用特定的顏色填充聯通區域，通過設置可連通像素的上下限以及連通方式來達到不同的填充效果的方法。漫水填充經常被用來標記或分離圖像的一部分以便對其進行進一步

opencv floodFill 漫水填充

可以看到，回撥函式通常和應用處於同一抽象層（因為傳入什麼樣的回撥函式是在應用級別決定的）。而回調就成了一個高層呼叫底層，底層再回過頭來調用高層的過程。（我認為）這應該是回撥最早的應用之處，也是其得名如此的原因。回撥機制的優勢 從上面的例子可以看出，回撥機制提供了非常大的靈活性。請注意，從現在開始，我們把圖中的

OpenCv形態學操作和漫水填充

OpenCv形態學操作 函式介紹 在常用的腐蝕和膨脹基礎上，常使用**morphology()**函式. 該方法支援常用的灰度圖或是彩色影象(會分單通道處理)。 " morphologyEx函式的引數宣告 " void morpholo

Opencv影象識別從零到精通（24）------漫水填充，種子填充，區域生長、孔洞填充

         可以說從這篇文章開始，就結束了影象識別的入門基礎，來到了第二階段的學習。在平時處理二值影象的時候，除了要進行形態學的一些操作，還有有上一節講到的輪廓連通區域的面積周長標記等，還有一個最常見的就是孔洞的填充，opencv這裡成為漫水填充，其實也可以叫種子填

Opencv Python版學習筆記（二）漫水填充

漫水填充：也就是用一定顏色填充聯通區域，通過設定可連通畫素的上下限以及連通方式來達到不同的填充效果; 程式說明依舊以註釋的形式寫出，在Python例程的基礎上修改為隨機顏色填充： #decoding:utf-8 import numpy as np import cv2

opencv 漫水填充

一、話說漫水填充漫水填充是一種用特定的顏色填充連通區域，通過設定可連通畫素的上下限以及連通方式達到不同的填充效果的方法。漫水填充經常用來標記或者是分離影象的一部分，以便對其進行進一步處理貨分析，也可以用來從輸入影象獲取掩碼區域，掩碼會加速處理過程，或者只處理指定的畫素點，操作

OpenCV—漫水填充floodFill之區域資訊統計

本文的主要參考為 2、《Learning OpenCV 3》page361-364 OpenCV中提供的直線擬合API如下： int floodFill(InputOutputArray image, Point seedPoint, Scalar newVal, Re

學習opencv 漫水填充法

函式: CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,                           CvScalar new_val, CvScalar lo_diff CV_DEFAULT(c

OpenCV漫水填充

引言 漫水填充是用一定顏色填充聯通區域，通過設定可連通畫素的上下限以及連通方式來達到不同的填充效果;漫水填充經常被用來標記或分離影象的一部分以便對其進行進一步處理或分析，也可以用來從輸入影象獲取掩碼區域，掩碼會加速處理過程，或只處理掩碼指定的畫素點，操作的結果總是某個連續的

opencv筆記(3):漫水填充法和影象金字塔

int main( ) { //載入原始圖 Mat srcImage = imread("1.jpg"); //工程目錄下應該有一張名為1.jpg的素材圖 Mat tmpImage,dstImage1,dstImage2;//臨時變數和目標圖的定義

漫水填充例項詳解

思想 漫水填充：就是將與種子點相連線的區域換成特定的顏色，通過設定連通方式或畫素的範圍可以控制填充的效果。通常是用來標記或分離影象的一部分對其進行處理或分析，或者通過掩碼來加速處理過程。可以只處理掩碼指定的部分或者對掩碼上的區域進行遮蔽不處理。 主要作用就是

opencv 漫水填充運用

第二個引數， InputOutputArray型別的mask，這是第二個版本的floodFill獨享的引數，表示操作掩模,。它應該為單通道、8位、長和寬上都比輸入影象 image 大兩個畫素點的影象。第二個版本的floodFill需要使用以及更新掩膜，所以這個mask引數我們一定要將其準備好並填在此處。需要注

opencv學習（9）漫水填充、影象金字塔、閾值化的介紹

1、漫水填充 漫水填充法的基本思想： 簡單來說，就是自動選中了和種子點相連的區域，接著將該區域替換成指定的顏色，這是個非常有用的功能,經常用來標記或者分離影象的一部分進行處理或分析.漫水填充也可以用來從輸入影象獲取掩碼區域,掩碼會加速處理過程,或者只處理掩碼

Opencv學習筆記之十二——漫水填充法（floodFill）

首先感謝@淺墨_毛星雲，本篇博文是小武通過學習@淺墨_毛星雲的部落格以及書籍《opencv3.0程式設計入門》整理的筆記及疑問心得，小武水平有限，歡迎交流。定義：漫水填充法是一種用特定的顏色填充聯通區域，通過設定可連通畫素的上下限以及連通方式來達到不同的填充效果的方法。漫水填