计算机图形学区域填充共34页
计算机图形学--区域填充算法的实现
实验四区域填充算法的实现班级信计2班学号 20080502090 姓名张进分数一、实验目的和要求：1、理解区域的表示和类型，能正确区分四连通和八连通的区域2、了解区域填充的实现原理3、利用TurboC实现区域填充的递归算法二、实验内容：当给定种子点(x,y)时，首先填充种子点所在的扫描线上的位于给定区域的一个区段，然后确定与这一区段连通的上下两条扫描线上位于给定区域的区段依次保存下来。
反复这个过程，直到填充结束.三、实验结果分析1、种子填充算法假设在多边内有一像素已知，由此出发利用连通性找到区域内的所有像素2、设(x,y)为内点表示的四连通区域内的一点，oldcolor为区域的原色。
现取(x,y)为种子点，要将整个区域填充为显得颜色newcolor，递归填充过程如下：先判别像素(x,y)的颜色，若它的值不等于oldcolor，说明该像素或者位于区域之外或者已经被置于newcolor，不需要填充，算法结束，否则置该像素的颜色为newcolor，再对与其相邻上、下、左、右四个相邻像素分别作递归填充。
1、程序代码：#include "Conio.h"#include "graphics.h" /*for initgr()*/#include "stdio.h" /*for NULL */#define closegr closegraphvoid initgr(void) /* BGI初始化*/{int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果*/ registerbgidriver(EGAVGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行*/initgraph(&gd, &gm, "");}enum BOOL{FALSE = 0, TRUE = 1};typedef struct{int y;int xLeft;int xRight;}Span;/*区段*/typedef struct stacknode{Span span;struct stacknode *next;}stacknode;typedef struct{stacknode *top;}linkstack;/*-----------------进栈操作----------------------------------------*/ void PushStack(linkstack *s, Span *span){stacknode *p=(stacknode*)malloc(sizeof(stacknode));p->span.y = span->y;p->span.xLeft = span->xLeft;p->span.xRight = span->xRight;p->next=s->top;s->top=p;}/*-----------------出栈操作------------------------------------------*/ void PopStack(linkstack *s,Span *span){int x;stacknode *p=s->top;span->y = p->span.y;span->xLeft = p->span.xLeft;span->xRight = p->span.xRight;s->top=p->next;free(p);}/*-----------------将栈清空------------------------------------------*/ void SetStackEmpty(linkstack *s){stacknode *p=s->top;while( s->top != NULL){free(p);s->top=p->next;}}/*--------------判断栈是否为空----------------------------------------*/ int IsStackEmpty(linkstack *s){if(s->top == NULL)return 1;elsereturn 0;}/*----------------核心程序开始----------------------------------------*/ void ScanLineFill4(int x,int y,int oldColor,int newColor){int xLeft,xRight;int i;enum BOOL isLeftEndSet, spanNeedFill;Span span;linkstack *s=(linkstack*)malloc(sizeof(linkstack));s->top = NULL;/*填充并确定种子点(x,y)所在的区段*/i = x;while(getpixel(i,y) == oldColor)/*向右填充*/{putpixel(i,y,newColor);i++;}span.xRight = i - 1; /*确定区段右边界*/i = x - 1;while(getpixel(i,y) == oldColor)/*向左填充*/{putpixel(i,y,newColor);i--;}span.xLeft = i + 1; /*确定区段左边界*//*初始化*/SetStackEmpty(s);span.y = y;PushStack(s,&span);/*将前面生成的区段压入堆栈*/while( ! IsStackEmpty(s) )/*终止判断*/{/*出栈*/PopStack(s, &span);/*处理上面扫描线*/y = span.y + 1;xRight = span.xRight;i = span.xLeft - 1;isLeftEndSet = FALSE;while(getpixel(i,y) == oldColor)/*向左填充*/ {putpixel(i, y, newColor);i--;}if( i != span.xLeft - 1)/*确定区段左边界*/{isLeftEndSet = TRUE;xLeft = i + 1;}i = span.xLeft;while( i < xRight){spanNeedFill = FALSE;while(getpixel(i,y) == oldColor) /*向右填充*/{if( ! spanNeedFill){spanNeedFill = TRUE;if( ! isLeftEndSet){isLeftEndSet = TRUE;xLeft = i;}}putpixel(i,y,newColor);i++;}if( spanNeedFill ){span.y = y;span.xLeft = xLeft;span.xRight = i - 1;PushStack(s, &span); /*将区段压入堆栈*/isLeftEndSet = FALSE;spanNeedFill = FALSE;}/* while(getpixel(i,y) != oldColor) */i++;}/*end of while( i < xRight) *//*处理下面一条扫描线,与处理上面一条扫描线完全类似*/ y = y - 2;xRight = span.xRight;i = span.xLeft - 1;isLeftEndSet = FALSE;while(getpixel(i,y) == oldColor)/*向左填充*/{putpixel(i, y, newColor);i--;}if( i != span.xLeft - 1)/*确定区段左边界*/{isLeftEndSet = TRUE;xLeft = i + 1;}i = span.xLeft;while( i < xRight){spanNeedFill = FALSE;while(getpixel(i,y) == oldColor) /*向右填充*/{if( ! spanNeedFill){spanNeedFill = TRUE;if( ! isLeftEndSet){isLeftEndSet = TRUE;xLeft = i;}}putpixel(i,y,newColor);i++;}if( spanNeedFill ){span.y = y;span.xLeft = xLeft;span.xRight = i - 1;PushStack(s, &span); /*将区段压入堆栈*/isLeftEndSet = FALSE;spanNeedFill = FALSE;}/* while(getpixel(i,y) != oldColor) */i++;}/*end of while( i < xRight) */delay(2000); /*延时*/}/*end of while( ! isStackEmpty() ) */}/*end of ScanLineFill4() *//*---------------------main()------------------------------------------*/ int main(){initgr(); /* BGI初始化*/setbkcolor(3);setcolor(5);moveto(50, 50); /*绘制4连通区域*/lineto(400, 50);lineto(400,300);lineto(150,300);lineto(150,400);lineto(50, 400);lineto(50, 50);ScanLineFill4(150,150,0,14); /*相与后oldColor == 0*/getch(); /* 暂停一下，看看前面绘图代码的运行结果*/ closegr(); /* 恢复TEXT屏幕模式*/return 0;}1.运行结果：。
计算机图形学--填充
扫描线多边形填充算法扫描线多边形区域填充算法是按照扫描线顺序，计算扫描线与多边形的相交区间，再用要求的颜色显示这些去区间的像素（即完成填充）。
填充过程：1 求交：计算扫面线与多边形个边的交点。
2 排序: 把所有交点按x值地震顺序排序。
2 配对：两两配对，1,和2,3和4 等等。
每对交点代表扫面线与多边形的一个相交区间。
4 填充：把相交区间内的像素设置成多边形颜色。
相交顶点的数目确定：检查相交顶点的两条边的另外两个定点的y值。
按这两个y值中大于交点y值得个数是0,1,2来决定是取0,1或2个。
边界像素取舍：对扫描线与多边形的相交区间取左闭右开。
水平边界处理：水平边不参与求交计算，跳过。
相交：把多边形的所有边放在一个表中，处理每条扫描线是，按顺序从表中取出所有边，分别与扫面线求交。
改进：效率低，可只求与它相交的多边形的边进行求交运算。
算法思想及实现：活性边：与当前扫描线相交的边。
活性边表：把活性边按与扫描线线交点x坐标递增的顺序存放在一个链表中。
活性边的每个节点的内容：X ，X的变化量，Y的最大值，一个指针。
1 存放当前扫描线与边的交点坐标x值。
2 存放从当前扫描线到下一条扫描线间x的增量3 存放该边所交的最高扫面线号ymax;4 存放指向下一条边的指针。
算法的主要步骤：建立NET(new edge list)从最低扫面线开始到最高扫面线循环。
建立或调整AET(active edge list)按照AET总的接点顺序填充。
算法描述：算法描述：void polyfill (多边形polygon, 颜色color){for (各条扫描线i ){ 初始化新边表头指针NET [i]；把ymin = i 的边放进边表NET [i];}y = 最低扫描线号；初始化活性边表AET为空；for (各条扫描线i ){ 把新边表NET[i]中的边结点用插入排序法插入AET表，使之按x坐标递增顺序排列；遍历AET表，把配对交点区间(左闭右开)上的象素(x,y)，用drawpixel (x, y, color) 改写象素颜色值；遍历AET表，把y max= i +1的结点从AET表中删除，并把y max > i+1结点的x值递增D x；若允许多边形的边自相交，则用冒泡排序法对AET表重新排序；}} /* polyfill */。
计算机图形学图形填充
（2）从y=ymin到y=ymax，每次用一条扫描线进行填充。 （3）对一条扫描线填充的过程可分为四个步骤：
a、求交：计算扫描线与多边形各边的交点； b、排序：把所有交点按递增顺序进行排序；
c、交点配对：第一个与第二个，第三个与第四个 等等，每对交点就
代表扫描线与多边形的一个相交区间；
FloodFill4(x-1,y,oldColor,newColor);
FloodFill4(x+1,y,oldColor,newColor);
}
}/*end of FloodFill4()
*/
现在学习的是第34页，共50页
区域填充—边界填充算法
❖ 该算法也可以填充有孔区域。 ❖ 缺点：
(1) 有些象素会入栈多次，降低算法效率；栈结构占空间。 (2) 递归执行，算法简单，但效率不高，区域内每一象素都引起一次递归， 进/出栈，费时费内存。
下相互交替出现.
现在学习的是第8页，共50页
扫描线连贯性(scan line coherence)：当像素点位于多边形内
(外)的直线段上时,它就位于多边形内(外). 也就是说，与多
边形相交的一条扫描线上总会有一组相互相连的像素点都位于多 边形之内。
每一个像素点—像素点所在的直线段
现在学习的是第9页，共50页
现在学习的是第18页，共50页
这样处理后，极值点仍计算两次，而非极值点的斜边交点只计算一次。
经上述约定及处理后，可保证同一扫描线与多边形的交点成对出 现，因此只要算出交点，填充就可以利用画直线算法快速完成。
现在学习的是第19页，共50页
扫描线算法步骤如下：
（1）确定多边形所占有的最大扫描线数，得到多边形顶点的最小和最大y值（ymin
计算机图形学---多边形填充算法课件
使用更有效的数据结构
使用更有效的数据结构可以减少算法在内存中的访问次数，从而提高算法的性能。例如，可以使用边 界盒（bounding box）来加速多边形的遍历。
还可以使用索引数据结构来加速多边形的遍历，例如使用四叉树（quadtree）或八叉树（octree）。
并行化填充算法以提高性能
并行化填充算法可以将计算任务分配 给多个处理器核心，从而提高算法的 性能。例如，可以使用多线程技术来 并行化填充算法。
CHAPTER 04
填充算法的应用
在游戏开发中的应用
角色和场景渲染
多边形填充算法用于在游戏中创 建逼真的角色和场景，通过填充 多边形来模拟物体的形状和纹理
。
碰撞检测
游戏中的物体需要进行碰撞检测 ，以确保游戏的真实性和玩家的 交互体验。多边形填充算法可以 用于检测多边形之间的重叠，从
而实现碰撞检测。
地表现自然和人造物体的细节，从而丰富图形表现形式。
拓展应用领域
03
随着多边形填充算法的发展，计算机图形学将在虚拟现实、增
强现实、游戏设计、影视制作等领域得到更广泛的应用。
区域增长填充算法
区域增长填充算法是一种基于区域的填 充算法，通过将多边形内部的像素连接 起来形成一个区域，然后对该区域进行
填充。
该算法首先确定多边形的所有像素，然 后从多边形内部的一个像素开始，将其 相邻的像素加入到区域中，直到整个多
边形内部都被填充。
区域增长填充算法的优点是能够处理复 杂的填充需求，如填充不规则形状或多
种子填充算法
种子填充算法是一种基于种子点的填充算法，通过从指定的种子点开始，向周围 扩散填充颜色来实现填充。
该算法适用于任意形状的多边形，具有灵活、易于实现的特点，但可能会在处理 大型多边形时效率较低。
计算机图形学第3讲多边形区域填充算法
40
种子填充算法
栈实现的种子填充算法(四向算法)
void BoundaryFill4(int x, int y, int boundColor, int newColor) { int px = x, py = y; stackPush(px, py); while(!stackEmpty()) { stackPop(&px, &py); SetPixel(x, y, newColor);
扫描转换算法
区域填充算法
34
种子填充算法
区域：点阵表示的图形，像素集合 表示方法
内点表示 区域内的所有像素具有同一颜色，而区域外的所有像素具有另 一种颜色 边界表示 区域边界上的所有像素具有特定的颜色（可以是填充色），在 区域内的所有像素均不能具有这一特定颜色，而且边界外的像 素也不能具有与边界相同的颜色
若低端点y值为ymin，则该边就放在ymin所对应的桶中
桶中的各边：
按下端点的x坐标值排序
27
12 10（2，9） l3 8 6 4 2 l2 l4
（13，11） l5 （13，5） l6
（7，7）
（2，3） （7，1） l1 2 4
9 11 9 3 ∧ ∧
6
8 10 12 14
7 3/2 11
扫描线算法
取整问题
扫描线与多边形边界交点坐标值不为整数 当扫描线与多边形边界交点坐标为小数值时，如果多 边形在此边界右侧，则将该小数值进1作为边界点，否 则舍去小数部分并进行填充，这样可使多边形不扩大
解决方法
16
扫描线算法
水平边问题
计算机图形学实验四 区域填充算法的实现
实验四区域填充算法的实现班级 08信计2班学号 20080502082 姓名分数一、实验目的和要求：1、理解区域的表示和类型。
2、能正确区分四连通和八连通的区域3、了解区域填充的实验原理。
4、利用C++实现区域填充的递归算法。
二、实验内容：1假设在多边形内有一像素已知，由此出发利用连通性找到区域内所有像素。
2 取（x，y）为种子点将整个区域填充为新的颜色。
3 进行递归填充。
三、实验结果分析区域填充属性包括填充样式，填充颜色和填充图案的类型。
C语言中定义了某种图形后，即可调用-floodfill函数，对指定区域进行填充. 程序代码#define pi 3.141592#define MAX(a,b) (a>b)? a:b#define MIN(a,b) (a<b)? a:b#include "graphics.h"#include "math.h"struct edge {int ymax;float x;float delat;struct edge * pedge; };struct point{int x;int y;} ;struct et { struct edge * pedge;int n;};struct edge g_aet[10];struct edge dge[10];struct et g_et[10];struct point point1,point2;int ZUO(float x){ if((int)x==x)return (int)x;return (int)x+1;}int YOU(float x){ if((int)x==x)return (int)x-1;return (int)x;}int k=400,l=0;void draw1(){int i,t,j,a,c,p,z; float b;struct edge temp;for(i=k;i<=l;i++){a=0;for(t=0;t<=9;t++){ if(g_et[t].n==i) break;}for(j=0;j<=9;j++){ if(g_aet[j].ymax==0) break;}if(t!=10){ g_aet[j].ymax=g_et[t].pedge->ymax;g_aet[j].x=g_et[t].pedge->x;g_aet[j].delat=g_et[t].pedge->delat;if(g_et[t].pedge->pedge!=0){g_aet[j+1].ymax=g_et[t].pedge->pedge->ymax;g_aet[j+1].x=g_et[t].pedge->pedge->x;g_aet[j+1].delat=g_et[t].pedge->pedge->delat; }}for(j=0;j<=9;j++){ if(g_aet[j].ymax==0) break; }j--;for(t=0;t<=j;t++){ for(z=0;z<=j-1;z++){if(g_aet[z].x>g_aet[z+1].x){ temp.ymax=g_aet[z].ymax;temp.x=g_aet[z].x;temp.delat=g_aet[z].delat;g_aet[z].ymax=g_aet[z+1].ymax;g_aet[z].x=g_aet[z+1].x;g_aet[z].delat=g_aet[z+1].delat;g_aet[z+1].ymax=temp.ymax;g_aet[z+1].x=temp.x;g_aet[z+1].delat=temp.delat;}}}for(j=0;j<=9;j++){ if(g_aet[j].ymax==0) break; }j--;for(p=0;p<=j;p++){ a++;if(a%2!=0)b=g_aet[p].x;else{for(c=ZUO(b);c<=YOU(g_aet[p].x);c++)putpixel(c,i,2);}}for(t=0;t<=j;t++){ if(g_aet[t].ymax==(i+1)){ g_aet[t].ymax=0;g_aet[t].x=0;g_aet[t].delat=0;}g_aet[t].x+=g_aet[t].delat;}for(t=0;t<=j;t++){ for(z=0;z<=j-1;z++){if(g_aet[z].x<g_aet[z+1].x){ temp.ymax=g_aet[z].ymax;temp.x=g_aet[z].x;temp.delat=g_aet[z].delat;g_aet[z].ymax=g_aet[z+1].ymax;g_aet[z].x=g_aet[z+1].x;g_aet[z].delat=g_aet[z+1].delat;g_aet[z+1].ymax=temp.ymax;g_aet[z+1].x=temp.x;g_aet[z+1].delat=temp.delat;}}}}}void generate(){int i,y,n=1,m,q,p;float x;for(i=0;i<=9;i++){if(n==1){ point2.x=point1.x=300;point2.y=point1.y=200;n++;}else{ if(n%2==0){ x=40*cos(i*pi/5)+200;y=40*sin(i*pi/5)+200;}else{ x=100*cos(i*pi/5)+200;y=100*sin(i*pi/5)+200;}if(point1.y==y) { n++; continue;}m=MIN(point1.y,y);if(x==point1.x){ dge[i-1].delat=0;dge[i-1].ymax=MAX(point1.y,y);dge[i-1].x=x;dge[i-1].pedge=0;for(q=0;q<=9;q++){ if(g_et[q].n==m) break;}if(q==10){g_et[i-1].pedge=&dge[i-1];g_et[i-1].n=m;}else{g_et[q].pedge->pedge=&dge[i-1];g_et[i-1].n=0;}}else{dge[i-1].delat=(float)(x-point1.x)/(y-point1.y);dge[i-1].ymax=MAX(point1.y,y);if(point1.y>y) dge[i-1].x=x;else {dge[i-1].x=point1.x; }dge[i-1].pedge=0;for(q=0;q<=9;q++){ if(g_et[q].n==m) break;}if(q==10){ g_et[i-1].pedge=&dge[i-1];g_et[i-1].n=m;}else{g_et[q].pedge->pedge=&dge[i-1];g_et[i-1].n=0;}}p=MAX(point1.y,y);k=MIN(k,m);l=MAX(l,p);point1.x=x;point1.y=y;n++;}}if(point1.y==point2.y) return;else{if(point2.x==point1.x){dge[i-1].delat=0;dge[i-1].ymax=MAX(point1.y,point2.y);dge[i-1].x=point2.x;}else{ dge[i-1].ymax=MAX(point1.y,point2.y);if(point1.y>point2.y) dge[i-1].x=point2.x;else {dge[i-1].x=point1.x;}dge[i-1].delat=(float)(point2.x-point1.x)/(point2.y-point1.y);}}m=MIN(point1.y,point2.y);k=MIN(k,m);l=MAX(l,dge[i-1].ymax);g_et[i-1].n=m;g_et[i-1].pedge=&dge[i-1];}void main(){ int driver=DETECT,mode; int i; registerbgidriver(EGA VGA_driver);initgraph(&driver,&mode,"\\tc");initgraph(&driver,&mode,"\\tc");for(i=0;i<=9;i++){ g_aet[i].ymax=0; g_aet[i].x=0; g_aet[i].delat=0;g_et[i].pedge=0;}generate();draw1();circle(200,200,100); circle(200,200,40);getch();closegraph();}。
计算机图形学——区域填充算法（基本光栅图形算法）
计算机图形学——区域填充算法（基本光栅图形算法）⼀、区域填充概念区域：指已经表⽰成点阵形式的填充图形，是象素的集合。
区域填充：将区域内的⼀点（常称【种⼦点】）赋予给定颜⾊，然后将这种颜⾊扩展到整个区域内的过程。
区域填充算法要求区域是连通的，因为只有在连通区域中，才可能将种⼦点的颜⾊扩展到区域内的其它点。
1、区域有两种表⽰形式1）内点表⽰：枚举出区域内部的所有象素，内部所有象素着同⼀个颜⾊，边界像素着与内部象素不同的颜⾊。
2）边界表⽰：枚举出区域外部的所有象素，边界上的所有象素着同⼀个颜⾊，内部像素着与边界象素不同的颜⾊。
21）四向连通区域：从区域上⼀点出发可通过【上、下、左、右】四个⽅向移动的组合，在不越出区域的前提下，到达区域内的任意象素。
2）⼋向连通区域：从区域上⼀点出发可通过【上、下、左、右、左上、右上、左下、右下】⼋个⽅向移动的组合，在不越出区域的前提下，到达区域内的任意象素。
⼆、简单种⼦填充算法给定区域G⼀种⼦点（x, y）,⾸先判断该点是否是区域内的⼀点，如果是，则将该点填充为新的颜⾊，然后将该点周围的四个点（四连通）或⼋个点（⼋连通）作为新的种⼦点进⾏同样的处理，通过这种扩散完成对整个区域的填充。
这⾥给出⼀个四连通的种⼦填充算法（区域填充递归算法），使⽤【栈结构】来实现原理算法原理如下：种⼦像素⼊栈，当【栈⾮空】时重复如下三步：这⾥给出⼋连通的种⼦填充算法的代码：void flood_fill_8(int[] pixels, int x, int y, int old_color, int new_color){if(x<w&&x>0&&y<h&&y>0){if (pixels[y*w+x]==old_color){pixels[y*w+x]== new_color);flood_fill_8(pixels, x,y+1,old_color,new_color);flood_fill_8(pixels, x,y-1,old_color,new_color);flood_fill_8(pixels, x-1,y,old_color,new_color);flood_fill_8(pixels, x+1,y,old_color,new_color);flood_fill_8(pixels, x+1,y+1,old_color,new_color);flood_fill_8(pixels, x+1,y-1,old_color,new_color);flood_fill_8(pixels, x-1,y+1,old_color,new_color);flood_fill_8(pixels, x-1,y-1,old_color,new_color);}}}简单种⼦填充算法的不⾜a)有些像素会多次⼊栈，降低算法效率，栈结构占空间b)递归执⾏，算法简单，但效率不⾼，区域内每⼀像素都要进/出栈，费时费内存c)改进算法，减少递归次数，提⾼效率三、扫描线种⼦填充算法基本思想从给定的种⼦点开始，填充当前扫描线上种⼦点所在的⼀区段，然后确定与这⼀段相邻的上下两条扫描线上位于区域内的区段（需要填充的区间），从这些区间上各取⼀个种⼦点依次把它们存起来，作为下次填充的种⼦点。
计算机图形学--第四讲 区域填充算法
任课教师：李陶深教授tshli@12直线生成算法圆与椭圆的绘制算法5图元的概念436区域填充算法裁剪反走样技术4.4 区域填充算法4.4 区域填充算法—基础知识（3）线框多边形物体:只需扫描转换线段填充多边形物体:要扫描转换多边形本质：点阵表示。
特点：面着色，画面明暗自然、色彩丰富。
4.4 区域填充算法4.4 区域填充算法—基础知识（4）图形学中多边形的两种表示方式顶点表示：用多边形的有序顶点序列表示多边形点阵表示：用位于多边形内部的像素集合来表示多边形4.4 区域填充算法多边形边界的矢量形式数据之上，可用于程序填色，也可用于交互填色。
形边界的图像形式数据之上，并还需提供多边形边界内一点的坐标。
概括地说，该算法先画边界，然后对内定义区域填充。
所以，它一般只能用于人机交互填色，而难以用于程序填色。
4.4 区域填充算法—多边形填色算法的问题多边形填色算法面临的一个首要问题，是判断一个像素是在多边形内还是多边形外。
Question1: How to Judge…?Question2: How to improve …?图4.14 射线法图4.15 转角法4.4 区域填充算法4.4 区域填充算法4.4 区域填充算法4.4 区域填充算法4.4 区域填充算法大量的求交、乘除运算4.4 区域填充算法—扫描线填色算法（1）基本思路：扫描线算法按扫描线的顺序计算出扫描线与多边形的相交区间，然后用要求的颜色填充这些区间内的像素。
该算法利用了扫描线的连续性和边的连续性，避免对像素的逐点判断和反复求交运算，减少了计算量，提高了算法速度。
具体处理过程：先求出扫描线与多边形边的交点，利用扫描线的连续性求出多边形与扫描线相交的连续区域，然后利用多边形边的连续性，求出下一条扫描线与多边形的交点，对所有扫描线由上到下依次处理。
4.4 区域填充算法—扫描线填色算法（2） 算法实现的步骤：对每一条扫描线执行如下四步:(1) 求交：求扫描线与多边形各边的交点;(2) 排序：将求得的交点按递增顺序进行排序;(3) 交点配对：确定相交区间;(4) 区间填色：将相交区间内的像素置成多边形色, 相交区间外的像素置成背景色。
计算机图形学 第四讲 区域填充
活化边表
把与当前扫描线 相交的边称为活 化边，并把它们 按与扫描线交点 X坐标递增的顺 序存放在一个链 表中，形成活化 边表。
表结构
算法中采用较灵活的数据结构。它由边的分有序边 表ET（Edge Table）和边的活化边表AEL（Active Edge Table ）两部分组成。 表结构ET和AET中的基本元素为多边形的边。边 的结构由以下四个域组成： ymax 边的上端点的y坐标； x 在ET中表示边的下端点的x坐标，在 AET中则表示边与扫描线的交点的坐标； Δx 边的斜率的倒数； next 指向下一条边的指针。
四个方向运动 八个方向运动
四连通区域
八连通区域
算法原理：
填充区域边界 以一种颜色指 定，从区域的 一个内部点开 始，由内至外 绘制直到填充算法
设(x,y)为内点表示的4连通区域内的一点，oldcolor为区域的 原色，要将整个区域填充为新的颜色newcolor。内点表示的 4连通区域的递归填充算法: void FloodFill4(int x,int y,int oldcolor,int newcolor) { if(GetPixel(x,y)==oldcolor) { SetPixel(x,y,newcolor); FloodFill4(x,y+1,oldcolor,newcolor); FloodFill4(x,y-1,oldcolor,newcolor); FloodFill4(x-1,y,oldcolor,newcolor); FloodFill4(x+1,y,oldcolor,newcolor); } }
i1
a
i1
i
a
其中 x
b 为常数， a
交点数的处理
【免费下载】计算机图形学 区域填充算法的实现
圆中填充蓝色，
2. 出栈，若栈空则结束；否则取栈顶元素（x，y），以 y 作为扫描线。
3. 填充并确定种子点所在区段，从种子点（x，y）出发，沿当前扫描线向左、右两个方
向填充，直到边界。
4. 确定新的种子点，在以上确定的边界中检查与当前扫描线 y 上、下相邻的两条扫描线
上的像素。若存在非边界、未填充的像素，则把每一区间的最右像素作为种子点压入
三、实验内容及步骤：
3.1、实验内容：
1. 利用种子算法实现内点表示的四连通区域的填充。如：设（x，y）为内点表示的四连
通区域内的一点，oldcolor 为区域的原色，要将整个区域填充为新的颜色 newcolor；
2. 利用扫描线算法实现以上区域的填充。如：填充以下图案，
三角形中填充红色；
3.2、实验步骤：
typedef struct{ NhomakorabeaElemType data[MaxSize];
int top;
} SqStack;
//栈顶指针
void InitStack(SqStack *&s) {
s=(SqStack *)malloc(sizeof(SqStack)); s->top=-1; }
int StackEmpty(SqStack *s) {
实验四 区域填充算法的实现
班级 08 信计二 学号 64 姓名 刘辉 分数
一、实验目的和要求：
1、理解区域的表示和类型； 2、能够正确区分四连通、八连通的区域； 3、了解填充函数、区域填充的实现原理； 4、了解掌握区域填充的各种算法（种子填充算法、扫描线算法、边填充
算法等），并实现种子填充算法和扫描线算法； 5、用种子填充算法实现四连同区域和八连通区域的填充，并观察他们之
第06部分_计算机图形学_区域填充_060307
2011-5-11
第6部分 区域填充
第5页
（1）求交（2）排序（3）配对（4）填色
8 7 6 5 4 3 2 P4(11,8) F G A B P5(5,5) P3(11,3) P1(2,2) P2(5,1) 0 1 2 3 4 5 6 7 8 9 10 11 E C D
P6(2,7)
1
2011-5-11
第6部分 区域填充
第6页
顶点问题
– 只需检查顶点的两条边的另外两个端点的y值。按 这两个y值中大于交点y值的个数是0,1,2来决定。
P1 1 P2 P3 P4 2 3
2011-5-11
第6部分 区域填充
第7页
活性边表算法
活性边表(AET)
–把与当前扫描线相交的边称为活性边，并把它们按 与扫描线交点x坐标递增的顺序存放在一个链表中
2011-5-11
第6部分 区域填充
第4页
扫描线填充算法
基本思想
– 用水平扫描线从上到下扫描由点线段构成的多段构 成的多边形。 – 每根扫描线与多边形各边产生一系列交点。将这些 交点按照x坐标进行分类，将分类后的交点成对取 出，作为两个端点，以所填的色彩画水平直线。 – 多边形被扫描完毕后，填色也就完成。
5 -3 P1P2
2011-5-11
第6部分 区域填充
第9页
算法程序
void polyfill (polygon, color) int color; 多边形 polygon; { for (各条扫描线i ) { 初始化新边表头指针NET [i]； 把y min = i 的边放进边表NET [i]; } y = 最低扫描线号； 初始化活性边表AET为空；
2011-5-11
计算机图形学--区域填充算法的实现
计算机图形学--区域填充算法的实现实验四区域填充算法的实现班级 08信计二学号 64 姓名刘辉分数一、实验目的和要求：1、理解区域的表示和类型；2、能够正确区分四连通、八连通的区域；3、了解填充函数、区域填充的实现原理；4、了解掌握区域填充的各种算法（种子填充算法、扫描线算法、边填充算法等），并实现种子填充算法和扫描线算法；5、用种子填充算法实现四连同区域和八连通区域的填充，并观察他们之间的区别；6、分析对比种子填充算法和扫描线算法实现的像素逼近效果和程序执行速度；二、实验原理：用点阵方法表示的多边形区域，如果其内部像素具有同一种颜色，而边界像素具有另一种颜色，可以使用种子填充算法和扫描线算法等填充。
种子填充算法是从区域内任一个种子像素位置（x，y）开始，由内向外将填充色扩散到整个多边形区域的填充过程；扫描线填充算法是当给定种子点（x，y）时，首先填充种子点所在扫描线上位于给定区域的一个区段，然后确定与这一段相连通的上、下两条扫描线上位于给定区域内的区段，并依次保存下来的过程。
三、实验内容及步骤：3.1、实验内容：1.利用种子算法实现内点表示的四连通区域的填充。
如：设（x，y）为内点表示的四连通区域内的一点，oldcolor为区域的原色，要将整个区域填充为新的颜色newcolor；2.利用扫描线算法实现以上区域的填充。
如：填充以下图案，圆中填充蓝色，三角形中填充红色；3.2、实验步骤：种子填充算法的步骤：1.种子入栈；2.当栈非空时，进行下面的操作，否则结束；3.栈顶元素出栈，如果是未填充的内部点，则将其填充，继续考察与其连通的点，若是为填充的内部点，则该点入栈，返回2步。
扫描线填充算法的步骤：1.初始化，置栈为空，将种子点（x，y）入栈。
2.出栈，若栈空则结束；否则取栈顶元素（x，y），以y作为扫描线。
3.填充并确定种子点所在区段，从种子点（x，y）出发，沿当前扫描线向左、右两个方向填充，直到边界。