扫描线种子填充法

[hflyingheart]

"扫描线种子填充法"的基本思想,有些问题不明白.请各位高手帮忙!谢啦!

如下图所示扫描线种子填充法中取新种子点入栈的过程:
1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 . L b . . . . . . . . . . u b1 b2. . . . . . . . . . . v b . . .
3 . b L . . . . . . . . . . s . . . . . . . . . . . . . R b . . . . .
4 . . . . b . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
其中: s(x,y)表示当前种子点,u(x1,y-1)和v(x2,y-1)是新种子点,b表示边界点,L和R分别表示当前区段的最左和最右端点.
我理解的是:首先以第3行的s为种子先向左填充直到左边界L,再向右填充直到右边界R;然后再从从左边开始检查(y-1)这一行，直到遇到边界或者已经填充过的点，记录，作为种子,如上所示u,在这里是遇到边界.
不明白的是:在上面第二行(也就是(y-1)这一行),当遇到边界,记录了种子u,是继续向右扫描吗?若是,那在紧邻u右边的b1和b2之间有两个空格,那是不是没有填充过?且这两个空格也不是边界,为什么在遇到b2时没有再记录种子?怎么知道要再从b2开始向右扫描到最右边的b时才记录种子v?
是否可以帮心讲解一下?

[平凡过客]

中间可能有非填充区域,具体的要根据实际情况而定

[hflyingheart]

怎样区分非填充区与填充区?如上图中的b1和b2之间应为非填充区b2和最后面b之间应为填充区.

[dupengcheng]

每一行（除最初那一行外）都是从Lb向Rb检测，都是把最右的那个点作为新的种子点。
在此图中先记录了u，再扫描上下相邻的两条扫描线。至于v点是以后才记录的。

[dupengcheng]

【扫描线种子填充算法】：单一的像素填充，这是我找到的最优的填充算法，但速数度还是较慢。如果有人又更好的算法，敬请指点。

算法的基本过程如下：当给定种子点(x,y)时，首先填充种子点所在扫描线上的位于给定区域的一个区段，然后检测与这一区段相邻的上、下两条扫描线上位于给定区域内的区段，并依次把新种子保存下来到堆栈。反复这个过程，直到填充结束。
区域填充的扫描线算法可由下列四个步骤实现：
(1)初始化：堆栈置空。将原始种子点(x,y)入栈。
(2)出栈：若栈空则结束。否则取栈顶元素(x,y)，以y作为当前扫描线。
(3)填充并确定种子点所在区段：从种子点(x,y)出发，沿当前扫描线向左、右两个方向填充，直到边界。分别标记区段的左、右端点坐标为xleft和xright。
(4)并确定新的种子点：在区间[xl，xr]中检查与当前扫描线y上、下相邻的两条扫描线上的象素。若存在非边界、未填充的象素，则把每一区间的最右象素作为种子点压入堆栈，返回 - 第（2）步。
扫描线种子填充算法伪代码：
scan line seed fill algorithm
push (x,y)
while(stack not empty)
pop (x,y)
putpixel(x,y)
savex=x
//fill to right
x=x+1
while( color(x,y)<>boundary_color )
putpixel(x,y)
x=x+1
end while
xright=x-1
//fill to left
x=savex-1
while( color(x,y)<>boundary_color )
putpixel(x,y)
x=x-1
end while
xleft=x+1
//upper scan line
x=xleft
y=y+1
while( x <= xright )
pflag=0
//check upper scan line
while( color(x,y)<>boundary_color && x<xright )
if( pflag==0 )
pflag=1
end if
x=x+1
end while
//push the extreme right pixel into stack
if( pflag == 1 )
if( x=xright && color(x,y)<>boundary_color)
push(x,y)
else
push(x-1,y)
end if
pflag=0
end if
//continue check if the polygon has hole
xenter=x
while( color(x,y)==boundary_color && x<xright)
x=x+1
end while
//make sure the pixel coordinate is increaseｄ
if( x==xenter )
x=x+1
end if
end while
//downward scan line，算法和检测上面一条扫描线相同，只是Y=Y-2不同(相对上面的Y=Y+1)。
...
end while
finish

[dupengcheng]

buggycode(风雨寒夜)：
你分析得有道理，我也发现它会多次扫描同一行。程序没问题，不会死机，我用汇编语言写的程序，在硬件上运行正确。只是速度不满意。我现在在做封闭区域的填充，要考虑不同的风格：如方格、斜线、竖线等等。如果您真好也在关注此事，请多讨论相互借鉴。[e-mail]

[hflyingheart]

谢谢各位对此问题的关注!

上面的算法确实不会死机.我现在用在项目中的算法和这个基本上类同,是用在单片机中的游戏中,效率还算可以,因要求的精度不是很高,所以点的密度比较大(间隔15个pixel).感谢dupengcheng当时及时的指点.

也希望各位多在此讨论,以便大家都能更深入的理解.到时暂以散分示谢意! ^_^

[hflyingheart]

抱歉!
上面说错了一个地方"点的密度比较大"应为"点的密度比较小".

[buggycode]

dupengcheng：
大概看了一下，
你的算法有可能有些问题。
1。 会不会进入死循环，你好像是利用修改的颜色和种子的颜色不同来防止死循环。当种子点的颜色和需要填充的颜色差在你的颜色范围之内，可能有问题。
2。为什么每次纪录最右边的点，（为什么不是左边）其实不管你纪录那个点都会导致你多一次在这条线上的检测，至少对于已经检测过的部分。
3。可能很多的细节上的处理导致整体的性能变差。比如你的putpixel(x,y)...这样的函数是会导致你的性能非常差。

[buggycode]

不会死循环就好，如果会，考虑一下我说的。
你的另一个问题是如何填充各种不同的模扳，很有可能会要考虑死循环问题。多数做法不是在当时就改变数据，而是用一个方法（自定）来记录搜索到的封闭区域，然后填充，这样的填充就比较容易进行各种模扳得控制。

[suifeng19]

void CScanLineSeedFillView::ScanlineSeedfill(CDC* pDC,int x,int y,COLORREF boundaryvalue,COLORREF newvalue)
{
int x0,xl,xr,y0,xid;
bool flag;//
stack <CPoint> s;//操作数栈
CPoint p;//定义一个点
s.push(CPoint(x,y));//将右键取得点(x,y)入栈

//********************当栈非空时循环
while(!s.empty())
{
p=s.top(); //将栈顶元素传值给p
s.pop(); //弹出栈顶元素
x=p.x; //记录点的x值
y=p.y; //记录点的y值

// TRACE("pop x=%d,y=%d\n",x,y); //其功能相当与c中的printf,仅在MFC调试中有用

pDC->SetPixel(x,y,newvalue);//将点(x,y)填充
x0=x+1; //向右移一个像素

while(pDC->GetPixel(x0,y)!=boundaryvalue)//当点(x0,y)的像素值不等于边界像素值时,循环
{
pDC->SetPixel(x0 ,y ,newvalue); //将点(x0,y)填充
x0++; //向右移一个像素,循环--继续填充,直至到边界点
}


xr=x0-1;//xr为右边界点的左边一个点的x值,记录用
x0=x-1; //x0变成原种子点p左一个点的x值

while(pDC->GetPixel(x0,y)!=boundaryvalue)//当点(x0,y)的像素值不等于边界像素值时,循环
{
pDC->SetPixel(x0 ,y ,newvalue);//将点(x0,y)填充
x0--;//向左移一个像素,循环--继续填充,直至到边界点
}
xl=x0+1; //xl为左边界点的右边一个点的x值,记录用

y0=y; //为y0赋值为y,与种子点的y值相等

for(int i=1;i>=-1;i-=2)//做两次循环,之所以这样定义赋值,因为下面有变量要用到i的值
{
// MessageBox("");
x0=xr; //将右边界左边一点的xr的值传给x0
y=y0+i;//y的值先加1,再减1,表示点下移一行,在下次循环时上移一行

while(x0>=xl)//当x0>=xl时循环
{
flag=false;
while((pDC->GetPixel(x0,y)!=boundaryvalue)
&& (pDC->GetPixel(x0,y)!=newvalue)
&& (x0>=xl)) //当点(x0,y)没被填充且不是边界 且 x0>=xl时 ---循环
{
if(!flag) //如果flag为false
{
flag=true; //将flag改为ture
xid=x0; //xid赋值为x0,xid作为记录x0用
}
x0--; //点(x0,y) 每次循环左移一点
}

if(flag)//当flag为ture时
{
s.push(CPoint(xid,y)); //将点(xid,y)入栈
// TRACE("push x=%d,y=%d\n",xid,y); //其功能相当与c中的printf,仅在MFC调试中有用
flag=false; //然后在将flag置为false
}
while((pDC->GetPixel(x0,y)==boundaryvalue)||(pDC->GetPixel(x0,y)==newvalue))
x0--; //当点(x0,y)是边界 或者 填充过时,(x0,y) 向左移一点
}//end of while(x0>=xl)

}//end of for(int i=1;i>=-1;i-=2)

}//end of while(!s.empty())

//**********************************
}

[dupengcheng]

buggycode(风雨寒夜)，您分析的十分正确。当间隔填充时会出现死循环，因为要记录的种子点太多，堆栈爆满。此算法只适合密集填充。如果您有好的算法，请告知，我正为此发愁。多谢！

[dupengcheng]

suifeng19() ：
我们的算法完全一样，不同的是，你从右向左检测，我是从左向右检测。在记录种子点坐标时，你用变量xid记录，这样更好。
算法都是填充当前行，然后扫描相邻的上下两行寻找新的种子点。
1 -------------------------------- 。。。。。
2 - - - - - - - - - - - - - - - - 。 。
3 - - - - - - - - - - - - - - - - 。 。a 。
4 - - - - - - - - - - - - - - - - 。 。 。 。
5 - - - - - - - - - - - - - - - - 。 。
如上图：
循环1：填充第4行，先检测第5行，记录新种子；然后检测先检测第3行，记录新种子。
循环2：填充第3行，之后检测第4行、第2行
循环3：填充第2行，之后检测第3行、第1行
问题1：
您可以看到多次的检测同一行。我尝试过向单一方向(上或下)检测，但有些地方又记录不到(如上图 a 处)
问题2：
如果用竖线填充，我的做法是：在同一行中，x为偶数画点，奇数不画。这样相当于出现了很多的小洞，当重复扫描时会有很多的种子入栈。更糟糕的是当到达上面或下面边界时不能结束，会出现死循环，无限的压栈，崩溃。
不知大家有没有发现这些问题？

[dupengcheng]

请高手救命啊！

[buggycode]

dupengcheng:
前两天上不来，上来了又发不了言。真是的。

1。死循环应该不难解决。比如每个点用1bit来记录是否检测过。
2。堆栈的问题要改用内存来解决。我在另一个留言中提了。
3。如果你的程序是用在硬件或PDA设备上，可能更复杂，原因就是资源的限制，可能要分块处理。

通过你简单的程序不能看出更多的问题。方法基本类似，可能多一些判断来减少重复运算，比如纪录每段的左右两点。我的方法是分块的。加上这个是基于我自己的底层库，所以非常的复杂。我也不提倡在这里提供代码。 如果你有更具体的问题，我可以尽量回答。

[dupengcheng]

多谢buggycode(风雨寒夜)，新年快乐。The same to all.

[QuickKeyBoard]

扫描线的种子填充算法应该是用队列的吧？我写过一个，填充四连通区域的，楼主看看吧。
#include <fstream>
using namespace std;

#define MAX 2000

struct NODE
{
int i, j;
NODE *next;

NODE()
{
next=NULL;
}
};

NODE *head=NULL, *tail=NULL;
int m, n, p, q;
char map[MAX][MAX+1];
ifstream fin("exam5.in");
ofstream fout("exam5.out");


void getseed(int a, int b, int i)
{
if(i<0 && i>m)
return;

int j;
j=a;
if(map[i][j]=='0')
{
tail->next=new NODE;
tail=tail->next;
tail->i=i;
tail->j=j;
}
j++;
for(;j<=b;j++)
if(map[i][j]=='0' && map[i][j-1]=='1')
{
tail->next=new NODE;
tail=tail->next;
tail->i=i;
tail->j=j;
}
}

void fill()
{
head=new NODE;
head->i=p;
head->j=q;
tail=head;

int i, j, a, b;

while(head!=NULL)
{
// fill a line
i=head->i;
j=head->j;
while(j>=0 && map[i][j]=='0')
{
map[i][j]='_';
j--;
}
a=j+1;
j=head->j+1;
while(map[i][j]=='0')
{
map[i][j]='_';
j++;
}
b=j-1;

// find a new seed
getseed(a, b, i-1);
getseed(a, b, i+1);

// to the next seed
NODE *temp;
temp=head;
head=head->next;
delete temp;
}
}

int main(int argc, char *argv[])
{
int i;

// read in.
fin>>m>>n>>p>>q;
for(i=0;i<m;i++)
fin>>map[i];

p--;
q--;
fill();

// write out.
for(i=0;i<m;i++)
fout<<map[i]<<endl;
return 0;
}

希望对你有用呢。哈哈。