实验2:多边形区域扫描线填充或种子填充
第二章 光栅图形学2--多边形的扫描转换与区域填充

山东科技大学信息学院
区域的连贯性
根据这些性质,实际上只需知道该长方形 区域内任一梯形内一点关于多边形P的内 外关系后,即可确定区域内所有梯形关 于P的内外关系。
山东科技大学信息学院
扫描线的连贯性
设e为一整数,yi0≥e≥yin。若扫描线y=e与多边形P的 Pi-1Pi相交,则记其交点的横坐标为xei。 现设xei1,xei2,xei3,…,xeil 是该扫描线与P的边界各交点 横坐标的递增序列,称此序列为交点序列。由区域的连贯 性可知,此交点序列具有以下性质:
山东科技大学信息学院
三、多边形的扫描转换
山东科技大学信息学院
1 逐点判断法
• 逐个判断绘图窗口内的像素: • 如何判断点在多边形的内外关系?
1)射线法: 2)累计角度法 3)编码法;
山东科技大学信息学院
逐点判断法
1)射线法
• 步骤: 1. 从待判别点v发出射线 2. 求交点个数k 3. K的奇偶性决定了点与多边形的内外关系
山东科技大学信息学院
3 扫描线种子填充算法
• 扫描线种子填充算法
–目标:减少递归层次 –适用于边界表示的4连通区域 算法思想:在任意不间断区间中只取一个种子 像素(不间断区间指在一条扫描线上一组相 邻元素),填充当前扫描线上的该段区间; 然后确定与这一区段相邻的上下两条扫描线 上位于区域内的区段,并依次把它们保存起 来,反复进行这个过程,直到所保存的个区 段都填充完毕。
逐点判断法程序简单, 速度太慢,效率低。
P1
v P2
山东科技大学信息学院
逐点判断法
• 逐点判断的算法虽然程序简单,但不可取。原 因是速度太慢,主要是由于该算法割断了各象 素之间的联系,孤立地考察各象素与多边形的 内外关系,使得几十万甚至几百万个象素都要 一一判别,每次判别又要多次求交点,需要做 大量的乘除运算,花费很多时间。
多边形的扫描转换与区域填充

实验三 多边形的扫描转换与区域填充在计算机图形学中,多边形有两种重要的表示方法:顶点表示和点阵表示。
顶点表示是用多边形的顶点序列来表示多边形,特点直观、几何意义强、占内存少,易于进行几何变换,但由于它没有明确指出哪些像素在多边形内,故不能直接用于面着色。
点阵表示是用位于多边形内的像素集合来刻画多边形。
这种表示丢失了许多几何信息,但便于帧缓冲器表示图形,是面着色所需要的图形表示形式。
光栅图形的一个基本问题是把多边形的顶点表示转换为点阵表示。
这种转换称为多边形的扫描转换。
一 多边形的扫描转换多边形可分为凸多边形、凹多边形、含内环多边形。
(1)凸多边形:任意两顶点间的连线均在多边形内。
(2)凹多边形:任意两顶点间的连线有不在多边形内的部分。
(3)含内环多边形:多边形内包含有封闭多边形。
扫描线多边形区域填充算法是按扫描线顺序,计算扫描线与多边形的相交区间,再用要求的颜色显示这些区间的像素。
区间的端点可以通过计算扫描线与多边形边界线的交点获得。
对于一条扫描线,多边形的填充过程可以分为4个步骤。
(1)求交:计算扫描线与多边形各边的交点。
(2)排序:把所有交点按x 值递增顺序排序。
(3)配对:第一个与第二个,第三个与第四个等,每对交点代表扫描线与多边形的一个相交区间。
(4)填色:把相交区间内的像素置成多边形颜色,把相交区间外的像素置成背景色。
具体实现方法:为多边形的每一条边建立一边表;为了提高效率,在处理一条扫描线时,仅对与它相交的多边形的边进行求交运算。
把与当前扫描线相交的边称为活性边,并把它们按与扫描线交点递增的顺序存放在一个链表中,称此链表为活性边表。
另外使用增量法计算时,需要知道一条边何时不再与下一条扫描线相交,以便及时把它从扫描线循环中删除出去。
为了方便活性边表的建立与更新,为每一条扫描线建立一个新边表(NET ),存放在该扫描线第一次出现的边。
为使程序简单、易读,这里新边表的结构应保存其对应边如下信息:当前边的边号、边的较低端点(x min ,y min )与边的较高端点(x max ,y max )和从当前扫描线到下一条扫描线间x 的增量∆x 。
基于扫描种子线算法的多边形区域填充实现

基于扫描种⼦线算法的多边形区域填充实现 本学期算法课上我们学习了计算⼏何的基础内容,在课后的深⼊了解学习中我发现,计算⼏何仅仅是算法世界⼀个重要分⽀——计算机图形学的基础部分之⼀,计算机图形学还有很多其他⾮常有趣的算法,例如直线⽣成、圆⽣成、椭圆⽣成。
⽽在本学期进⾏java项⽬实践的过程中,我也遇到了⼀个和计算机图形学息息相关的问题,那就是如何实现windows⾃带画图软件中的⼯具油漆桶?⽹上的开源画图代码基本上均只实现了其他简单的绘制⼯具。
为此,在查阅⼤量相关资料后,我学习到,种⼦填充算法可以很好地实现多边形区域填充,并⽤其中效果最好的基于栈的扫描线种⼦填充算法实现了画板中的油漆桶⼯具。
找到特定的算法,搞懂原理并写出算法的程序代码,在这个过程中,我深刻地认识到了算法的⽆处不在,也深切地感受到算法的乐趣,感受到⽤算法解决问题后的成就感。
简要介绍下算法的原理,实现⾮⽮量图形区域填充常⽤的种⼦填充算法根据对图像区域边界定义⽅式以及对点的颜⾊修改⽅式不同可分为注⼊填充算法(Flood Fill Algorithm)和边界填充算法(Boundary Fill Algorithm)。
两者的核⼼都是递归加搜索,即从指定的种⼦点开始,向上、下、左、右、左上、左下、右上和右下全部⼋个⽅向上搜索,逐个像素进⾏处理,直到遇到边界。
两者的区别仅在于Flood Fill Algorithm不强调区域的边界,它只是从指定位置开始,将所有联通区域内某种指定颜⾊的点都替换成另⼀种颜⾊,即实现颜⾊替换的功能;⽽边界填充算法与注⼊填充算法递归的结束条件不⼀样,Boundary Fill Algorithm强调边界的存在,只要是边界内的点,⽆论是什么颜⾊,都替换成指定的颜⾊。
但是在实际项⽬中,使⽤递归算法效率太低,为了消除递归,有⼀种更为常⽤的改进算法,即扫描线种⼦填充算法。
它通过沿竖直扫描线填充像素段,⼀段⼀段地来处理8-联通的相邻点,这样算法处理过程中就只需要将每个竖直像素段的起始点位置压⼊⼀个特殊的栈,⽽不需要像递归算法那样将当前位置周围尚未处理的所有相邻点都压⼊堆栈,从⽽节省了堆栈空间,本实例采⽤的就是结合泛洪填充算法(或者说注⼊填充算法)的扫描线种⼦填充算法。
实验2:多边形区域扫描线填充或种子填充

实验2:多边形区域扫描线填充或种子填充计科102 蓝广森 1007300441一、实验目的通过实验,进一步理解和掌握几种常用多边形填充算法的基本原理掌握多边形区域填充算法的基本过程掌握在C/C++环境下用多边形填充算法编程实现指定多边形的填充。
二、实验内容及要求实现多边形区域扫描线填充的有序边表算法,并将实现的算法应用于任意多边形的填充,要求多边形的顶点由键盘输入或鼠标拾取,填充要准确,不能多填也不能少填。
要求掌握边形区域扫描线填充的有序边表算法的基本原理和算法设计,画出算法实现的程序流程图,使用C或者VC++实现算法,并演示。
三、实验原理种子填充算法又称为边界填充算法。
其基本思想是:从多边形区域的一个内点开始,由内向外用给定的颜色画点直到边界为止。
如果边界是以一种颜色指定的,则种子填充算法可逐个像素地处理直到遇到边界颜色为止。
种子填充算法常用四连通域和八连通域技术进行填充操作。
四向连通填充算法:a)种子像素压入栈中;b)如果栈为空,则转e);否则转c);c)弹出一个像素,并将该像素置成填充色;并判断该像素相邻的四连通像素是否为边界色或已经置成多边形的填充色,若不是,则将该像素压入栈;d)转b);e)结束。
扫描线填充算法的基本过程如下:当给定种子点(x,y)时,首先填充种子点所在扫描线上的位于给定区域的一个区段,然后确定与这一区段相连通的上、下两条扫描线上位于给定区域内的区段,并依次保存下来。
反复这个过程,直到填充结束。
区域填充的扫描线算法可由下列四个步骤实现:(1)初始化:堆栈置空。
将种子点(x,y)入栈。
(2)出栈:若栈空则结束。
否则取栈顶元素(x,y),以y作为当前扫描线。
(3)填充并确定种子点所在区段:从种子点(x,y)出发,沿当前扫描线向左、右两个方向填充,直到边界。
分别标记区段的左、右端点坐标为xl和xr。
(4)并确定新的种子点:在区间[xl,xr]中检查与当前扫描线y上、下相邻的两条扫描线上的象素。
用扫描线算法实现多边形填充

用扫描线算法实现多边形填充扫描线算法是一种用于多边形填充的有效方法。
它的思想是遍历扫描线,并在每条扫描线与多边形边界相交时填充相应的像素。
首先,我们需要了解多边形表示的方法。
多边形可以用一系列有序的边来表示,每条边由起点和终点坐标组成。
例如,一个三角形可以表示为三条线段的集合。
接下来,我们将介绍如何使用扫描线算法来实现多边形填充:1.首先,找到多边形的最大和最小y坐标,即多边形的上边界和下边界。
2.从上边界开始,逐条扫描线遍历到下边界。
3.在每条扫描线上,确定与多边形边界相交的线段。
4.根据与多边形边界相交的线段的起点和终点,找到对应的x坐标范围。
5.根据x坐标的范围,填充相应的像素。
下面是一个使用扫描线算法填充多边形的伪代码示例:```ScanLineFill(polygon):ymin = polygon.minYymax = polygon.maxYfor y from ymin to ymax:intersections = FindIntersections(polygon, y)sort(intersections)for i from 0 to length(intersections) - 1 by 2:xstart = intersections[i]xend = intersections[i+1]FillPixels(xstart, xend, y)```此伪代码的`FindIntersections`函数是用来找到多边形边界与当前扫描线相交的点,而`FillPixels`函数则用来填充相应的像素。
在实际实现时,可以使用一些数据结构来存储多边形的边界信息和扫描线与边界相交的点。
例如,可以使用边表来存储多边形的边界,使用活性边表来存储与当前扫描线相交的边界,使用扫描线来表示当前的扫描线位置。
算法的时间复杂度主要取决于扫描线与边界相交点的计算,可以通过使用边表和一些优化技巧来降低时间复杂度。
图形学实验报告四 多边形填充算法

扫描线种子填充:
public void FillField(int x, int y, Color newColor, uint oldColor, Graphics g) {
if ("".Equals(txtx.Text) || "".Equals(txty.Text)) { return; } else { x = Convert.ToInt32(txtx.Text); y = Convert.ToInt32(txty.Text); } int xl, xr; bool spanNeedFill; myStack.Clear();
个交点。如右图,对 y=8 的扫描线排序 x 坐标得到的表是(2,4,9,13),然后对交点 2 与 4 之间、9 与 13 之间 的所有象素点进行填充。 边界上的象素:“左闭右开”,“下闭上开”(将左边界和下边界的点算为内部,而将右边界和上边界 算为外部) 顶点:“上开下闭”。
几种特殊情况: 1.扫描线交于一顶点,共享的两条边分另处于扫描线的两边,这时交点只取一个,如扫描线 y=3,该点被填 充一次。2.共享交点的两条边处于扫描线的上方,这时交点取二个,如扫描线 y=1,该点被填充一次。 3.共享交点的两条边处于扫描线的下方,这时交点取 0 个,如扫描线 y=9,无交点,不填充。 4.水平边在算法中不起任何作用,可不考虑。 活性边表(提高效率): 为了减少求交的计算量,要利用一条边与相继的两条扫描线的交点的连贯性。在处理一条扫描线时只对活 性边(与它相交的多边形的边)进行求交运算。把交点按 x 增加方向存在一个链表(活性边表)中。活性边: 与当前扫描线相交的边。 活性边表(AEL) :按交点 x 的增量顺序存放在一个链表中,该链表称作活性边表(AEL) 。
多边形的扫描转换与区域填充

区域填充
区域填充要求区域是连通的 连通性:4连通、8连通
4 4p4
4
888 8p8 888
(a)p的4-邻接点 (b)p的8-邻接点
邻接点的定义
4连通:
8连通
区域填充
4连通与8连通区域的区别
连通性: 4连通可看作8连通区域,但对边界有 要求
(a)以边界表示的4-连通区域 (b)以内点表示的4-连通区域
x:=x+Δx。 5)将当前的扫描线的纵坐标值y累加1,即y:=y+1。
扫描线算法
特点:算法效率较高。 缺点:对各种表的维持和排序开销太大,适
合软件实现而不适合硬件实现。
扫描线算法
问题:
如何处理多边形的水平边? 如何修改扫描线算法,使它能处理边自交的多
边形?
3.4.1.3 边填充法
{ if(象素 x 被打上边标志)
inside = ! (inside);
if(inside!= FALSE)
drawpixel (x, y, color);
else drawpixel (x, y, background);
}
}
边界标志算法
用软件实现时,扫描线算法与边界标志算法 的执行速度几乎相同,
种子填充算法
适合于内点表示区域的填充算法 设G为一内点表示的区域,(x,y)为区域内一点,old_color为G的
原色。现取(x,y)为种子点对区域G进行填充:即先置像素 (x,y)的颜色为new_color,然后逐步将整个区域G都置为同样 的颜色。 步骤如下: 种子象素入栈,当栈非空时,执行如下三步操作: (1)栈顶象素出栈; (2)将出栈象素置成多边形色; (3)按上、下、左、右的顺序检查与出栈象素相邻的四个象素 ,若其中某个象素不在边界上且未置成多边形色,则把该象素 入栈。
多边形扫描线填充算法技巧

多边形扫描线填充算法技巧扫描线填充算法是计算机图形学中常用的一种填充算法,用于对多边形进行填充。
其基本原理是通过扫描线与多边形边界的交点来确定需要填充的像素点。
本文将介绍多边形扫描线填充算法的基本思想以及一些常用的优化技巧。
一、基本思想多边形扫描线填充算法的基本思想是将多边形分解成一系列水平线段,然后对每条水平线段进行扫描,找出与多边形边界相交的点,并进行填充。
具体步骤如下:1. 确定多边形的边界:对于给定的多边形,首先需要确定其边界。
可以使用边界表(edge table)来存储多边形的边界信息,包括每条边的起点和终点坐标以及斜率等。
2. 初始化扫描线:从多边形边界中找出最小的y坐标和最大的y坐标,作为扫描线的起点和终点。
3. 扫描线算法:对于每条扫描线,通过遍历边界表,找出与扫描线相交的边界线段。
根据相交点的x坐标,确定需要填充的像素点范围。
4. 填充像素点:根据上一步确定的像素点范围,将扫描线上的像素点进行填充。
二、技巧和优化1. 边界表的构建:为了提高算法的效率,可以对边界表进行排序,按照扫描线的y坐标来排序。
这样可以减少对边界表的遍历次数,提高算法的执行速度。
2. 边界交点的计算:在扫描线算法中,需要计算扫描线与多边形边界的交点。
可以使用活性边表(active edge table)来存储当前与扫描线相交的边界线段,并根据交点的x坐标进行排序。
这样可以减少计算交点的次数,提高算法的效率。
3. 填充像素点的优化:在填充像素点时,可以使用扫描线种子填充算法来进行优化。
该算法通过选择合适的填充起点,在填充过程中自动推进扫描线,减少不必要的计算和填充操作,提高填充的速度。
4. 填充规则的处理:在实际应用中,可能会遇到一些特殊情况,如多边形内部有孔洞或交叉等。
针对这些情况,可以通过修改填充规则来处理。
常用的填充规则有奇偶填充规则和非零填充规则,可以根据实际情况选择合适的填充规则。
5. 像素点颜色的处理:在多边形填充过程中,可以通过设置填充的颜色或纹理来实现不同的效果。
实验二:图形填充算法实验报告

《计算机图形学》实验报告(实验二:图形填充算法)一、实验目的及要求用两种方法做图形的填充算法!二、理论基础1.边填充算法对于每一条扫描线和每条多边形的交点(x1,y1),将该扫描线上的交点右方的所有像素取补。
2.种子填充算法利用栈来实现种子填充算法。
种子像素入栈,当栈非空时重复执行如下步骤:将栈顶像素出栈,将出栈像素置成多边形色,按左,上,右,下顺序检查与出栈像素相邻的四个像素,若其中某个像素不再边界且未置成多边形,则把该像素入栈!三、算法设计与分析1、边填充算法void CEdge_mark_fillView::OnDraw(CDC* pDC){CEdge_mark_fillDoc* pDoc = GetDocument();ASSERT_V ALID(pDoc);int d[500][500]={0};int inside;int x,y;Bresenham(80,101,100,400,d);Bresenham(100,300,290,400,d);Bresenham(292,400,382,50,d);Bresenham(380,50,202,150,d);Bresenham(200,150,82,101,d);for(y=0;y<500;y++){inside=0;for(x=0;x<500;x++){if(d[x][y]==1)if(d[x+1][y]!=1){inside=!(inside);}if(inside!=0)pDC->SetPixel(x,y,12);}}}2、种子填充int x=299,y=51;COLORREF oldcolor;COLORREF newcolor;oldcolor=RGB(256,256,256);newcolor=RGB(123,123,123);pDC->MoveTo (40,40);pDC->LineTo (80,40);pDC->LineTo (70,80);pDC->LineTo (40,40);FloodFill(51,51,RGB(255,255,255),RGB(0,0,255));pDC->LineTo (40,40);void CMyView::FloodFill(int x,int y,COLORREF oldcolor,COLORREF newcolor) {CDC* pDC;pDC=GetDC();if(pDC->GetPixel(x,y)==oldcolor){pDC->SetPixel(x,y,newcolor);FloodFill(x,y-1,oldcolor,newcolor);FloodFill(x,y+1,oldcolor,newcolor);FloodFill(x-1,y,oldcolor,newcolor);FloodFill(x+1,y,oldcolor,newcolor);}四、程序调试及结果的分析1、2、四、实验心得及建议由于很多不会,所以这次没能按时当堂完成,下来花了不少时间才弄出来,第二种尤其比较麻烦,在同学的帮助下才做出来了。
多边形的填充实验经典

试验实验一:图形的区域填充一、实验目的区域填充是指先将区域内的一点(常称为种子点)赋予给定颜色,然后将这种颜色扩展到整个区域内的过程。
区域填充技术广泛应用于交互式图形、动画和美术画的计算机辅助制作中。
本实验采用递归填充算法或打描线算法实现对光栅图形的区域填充。
通过本实验,可以掌握光栅图形编程的基本原理和方法。
实验内容掌握光栅图形的表示方法,实现种子算法或扫描线算法。
通过程序设计实现上述算法。
建议采用VC++实现OpenGL程序设计。
三、实验原理、方法和手段递归算法在要填充的区域内取一点(X, Y)的当前颜色记为oldcoloo用要填充的颜色ne wcolor去取代,递归函数如下:procedure flood-fill(XXoldcoloLnewcolor:integer); beginif getpixel(fiainebufier,x,y)=oldcolorthen beginsetpixel(fiamebuffer,x,y,newcolor); flood-fill(X.Y+1 .oldcoloLiiewcolor);flood-fill(X.Y^ 1 ,oldcoloi;newcolor); flood-fill(X-l,Y;oldcoloi;newcolor); flood-fill(X+l,Yoldcoloi;newcolor);endend扫描线算法扫描线算法的效率明显高于递归算法,其算法的基本思想如下:(1)(初始化)将算法设置的堆栈置为空,将给定的种子点(x,y)压入堆栈。
(2)(出栈)如果堆栈为空,算法结束;否则取栈顶元素(x,y)作为种子点。
(3)(区段填充)从种子点(x,y)开始沿纵坐标为y的当前扫描线向左右两个方向逐个象素进行填色,其值置为newcoloi;直到抵达边界为止。
(4)(定范围)以XleA和Xn血分别表示在步骤3中填充的区段两端点的横坐标。
(5)(进栈)分别在与当前扫描线相邻的上下两条打描线上,确定位于区间[Xldb Xn 曲]内的给定区域的区段。
计算机图形学实验扫描线种子填充算法

实验二4-10一、实验题目扫描线种子填充算法是通过扫描线来填充多边形内的水平像素段,处理每条扫描线时仅需将其最右端像素入栈,可以有效提高填充效率。
请使用MFC编程填充图4-60所示的空心体汉字(四连通),填充效果如图4-61所示。
二、实验思想扫描线种子填充算法:先将种子像素入栈,种子像素为栈底像素,如果栈不为空,执行如下4步操作。
(1)栈顶像素出栈。
(2)沿扫描线对出栈像素的左右像素进行填充,直至遇到边界像素为止。
即每出栈一个像素,就对区域内包含该像素的整个连续区间进行填充。
(3)同时记录该区间,将区间最左端像素记为x left,最右端像素记为x right。
(4)在区间〔x left,x right〕中检查与当前扫描线相邻的上下两条扫描线的有关像素是否全为边界像素或已填充像素,若存在非边界且未填充的像素,则把未填充区间的最右端像素取作种子像素入栈。
三、实验代码void CTestView::OnLButtonDown(UINT nFlags, CPoint point)//左键按下函数{// TODO: Add your message handler code here and/or call defaultSeed=point;//选择种子位置CharFill();//进行填充CView::OnLButtonDown(nFlags, point);}void CTestView::CharFill()//文字填充函数{CRect Rect;GetClientRect(&Rect);CClientDC dc(this);COLORREF BoundColor;//边界色int Width=Rect.right-Rect.left;int Hight=Rect.bottom-Rect.top ;int Flag;int x0,y0,x,y;CPoint Point;std::vector<CPoint> FillBuffle;//定义CPoint类型的数组序列对象FillBuffle.reserve(10);//定义数组序列的大小FillBuffle.push_back(CPoint(Seed)); //把种子结点压入数组序列BoundColor=RGB(0,0,0);//定义边界色为黑色while(!FillBuffle.empty())//如果数组序列非空{Point=FillBuffle.front();//弹出数组序列头元素x=Point.x;y=Point.y;FillBuffle.erase(FillBuffle.begin());//清除数组序列内的元素dc.SetPixel(Point,Fillcolor);//绘制像素//判断像素的位置是否在图形内部x0=x+1;//右方判断while(dc.GetPixel(x0,y)!=BoundColor&&dc.GetPixel(x0,y)!=Fillcolor) {x0=x0+1;if(x0>=Width)//到达屏幕最右端{MessageBox("种子超出范围","警告");RedrawWindow();return;}}y0=y+1;//下方判断while(dc.GetPixel(x,y0)!=BoundColor&&dc.GetPixel(x,y0)!=Fillcolor) {y0=y0+1;if(y0>=Hight)//到达屏幕最下端{MessageBox("种子超出范围","警告");RedrawWindow();return;}}RightPoint.x=x0;//右边界内的左邻点x0=x-1;while(dc.GetPixel(x0,y)!=Fillcolor&&dc.GetPixel(x0,y)!=BoundColor){dc.SetPixel(x0,y,Fillcolor);x0=x0-1;if(x0<=0)//到达屏幕最左端{MessageBox("种子超出范围","警告");RedrawWindow();return;}}y0=y-1;while(dc.GetPixel(x,y0)!=BoundColor&&dc.GetPixel(x,y0)!=Fillcolor){y0=y0-1;if(y0<=0)//到达屏幕最上端{MessageBox("种子超出范围","警告");RedrawWindow();return;}}LeftPoint.x=x0+1;//左边界内的右邻点x0=LeftPoint.x;y=y+1;//下一条扫描线while(x0<RightPoint.x){Flag=0;while((dc.GetPixel(x0,y)!=Fillcolor)&&(dc.GetPixel(x0,y)!=BoundColor)) {if(Flag==0)Flag=1;x0++ ;}if(Flag==1){if((x0==RightPoint.x)&&(dc.GetPixel(x0,y)!=Fillcolor)&&(dc.GetPixel(x0,y)!=BoundColor))FillBuffle.push_back(CPoint(x0,y));//进入数组序列else{FillBuffle.push_back(CPoint(x0-1,y));}Flag=0;}PointNext.x=x0;while(((dc.GetPixel(x0,y)==Fillcolor)&&(x0<RightPoint.x))||((dc.GetPixel(x0,y)==BoundColor) &&(x0<RightPoint.x))){x0 ++;}}x0=LeftPoint.x;y=y-2;while(x0<RightPoint.x){Flag=0;while((dc.GetPixel(x0,y)!=Fillcolor)&&(dc.GetPixel(x0,y)!=BoundColor)&&(x0<RightPoint.x)) {if(Flag==0)Flag=1;x0++ ;}if(Flag==1){if((x0==RightPoint.x)&&(dc.GetPixel(x0,y)!=Fillcolor)&&(dc.GetPixel(x0,y)!=BoundColor))FillBuffle.push_back(CPoint(x0,y));else{FillBuffle.push_back(CPoint(x0-1,y));}Flag=0;}PointNext.x=x0;while((dc.GetPixel(x0,y)==Fillcolor&&x0<RightPoint.x)||(dc.GetPixel(x0,y)==BoundColor&&x 0<RightPoint.x)){x0++;}}}FillBuffle.clear();return;}void CTestView::OnMENUFill(){// TODO: Add your command handler code hereRedrawWindow();MessageBox("请在空心字体内部单击鼠标左键!","提示");}四、实验结果截图。
多边形的扫描转换算法、区域填充算法

贵州大学计算机图形学实验报告学院:计算机科学与信息学院专业:软件工程班级:反映)根据扫描线的连贯性可知:一条扫描线与多边形的交点中,入点和出点之间所有点都是多边形的内部点。
所以,对所有的扫描线填充入点到出点之间的点就可填充多边形。
如何具体实现(如何找到入点、出点)?根据区域的连贯性,分为3个步骤:(1)求出扫描线与多边形所有边的交点;(2)把这些交点按x坐标值以升序排列;(3)对排序后的交点进行奇偶配对,对每一对交点间的区域进行填充。
步骤(3)如上图:对y=8的扫描线,对交点序列按x坐标升序排序得到的交点序列是(2,4,9,13),然后对交点2与4之间、9与13之间的所有象素点进行填充。
求交点、排序、配对、填色利用链表:与当前扫描线相交的边称为活性边(Active Edge),把它们按与扫描线交点x坐标递增的顺序存入一个链表中,称为活性边表AEL (AEL, Active Edge List)。
它记录了多边形边沿扫描线的交点序列。
AEL中每个对象需要存放的信息:ymax:边所交的最高扫描线;x:当前扫描线与边的交点;Δx:从当前扫描线到下一条扫描线之间的x增量next:指向下一对象的指针。
伪码:建立ET,置y为ET中非空桶的最小序号;置AEL表为空,且把y桶中ET表的边加入AEL表中;while AEL表中非空do begin对AEL表中的x、Δx按升序排列;按照AEL表中交点前后次序,在每对奇偶交点间的x段予以填充;计算下一条扫描线:y=y+1;if 扫描线y=ymax then 从AEL表中删除这些边;对在AEL表中的其他边,计算与下一条扫描线的交点:x=x +Δx 按照扫描线y值把ET表中相应桶中的边加入AEL表中;endend of algorithm二、区域填充算法:区域可采用两种表示形式:内点表示枚举区域内部的所有像素;内部的所有像素着同一个颜色;边界像素着不同的颜色。
边界表示:枚举出边界上所有的像素;边界上的所有像素着同一颜色;内部像素着不同的颜色。
多边形填充算法实验报告

学生实验报告
实验课名称:计算机图形学
实验项目名称:多边形填充算法
专业名称:计算机科学与技术
班级:
学号:
学生姓名:
教师姓名:
2016年4月30 日
六.运行结果与分析:
图1:扫描线种子填充算法
图2:种子填充算法
七.实验中遇到的问题、解决方法及体会:
多边形的填充对我来说很困难,因为一开始我不知道要输入什么数据,后来我决定要输入五个点来形成一个五边形,但是输入的顺序是一个大问题。
后来我采取顺序输入的方法,但是程序运行时常常崩溃,结果不尽人意。
最后,我在同班同学的帮助之下,找到了自己的问题,完成了填充。
计算机图形学实验报告-多边形的扫描转换与区域填充

计算机科学与技术学院2013-2014学年第一学期《计算机图形学》实验报告班级:学号:姓名:教师:成绩:实验项目(2、多边形的扫描转换与区域填充)一、实验目的与要求(1)了解多边形扫描转换的各种算法,掌握多边形的扫描转换与区域填充算法。
(2)进一步掌握在VC集成环境中实现图形算法的方法与过程。
二、实验内容设计菜单程序,利用消息处理函数,完成以下要求:(1)给出凸多边形的若干顶点(3 ~ 5个),实现多边形的“x扫描算法”。
(2)实现种子填充,泛填充算法(四邻法)。
(3)设计程序,实现判断一个点是否在多边形区域内部。
三、重要算法分析(一)边界表示的四连通区域种子填充算法此方法的基本思想是,从多边形内部任一像素出发,按照“左上右下”的顺序判断相邻像素,若不是边界像素且没有被填充过,则对其填充,并且重复上述过程,直到所有像素填充完毕。
(1)从种子点出发,向左判断多边形内部颜色,如果不是填充颜色并且不是边界颜色,则填充,直到遇到边界为止。
(2)从种子点出发,向右判断多边形内部颜色,如果不是填充颜色并且不是边界颜色,则填充,直到遇到边界为止。
(3)将种子点的坐标y值上移一个像素,重复步骤(1)、(2)直到遇到上面边界为止。
(4)将种子点的坐标y值下移一个像素,重复步骤(1)、(2)直到遇到上面边界为止。
(二)判断一个点是否在多边形内部解决方案是将测试点的y坐标与多边形的每一个点进行比较,我们会得到一个测试点所在的行与多边形边的交点的列表。
如果测试点的两边点的个数都是奇数个则该测试点在多边形内,否则在多边形外。
如图1所示,判断点(红点)y值左边与多边形有5个交点,右边与多边形有3个交点,则该点在多边形内部。
图1如图2所示,判断点(红点)y值左边与多边形有2个交点,右边与多边形有2个交点,则该点在多边形外部。
图2但是有一种特殊情况须特别处理一下,当与多边形顶点相交时,需要将改点计算为两个交点,如图3所示:图3四、程序运行截图1.种子四连通域填充法,如图4所示。
算法系列之十二:多边形区域填充算法--扫描线种子填充算法

算法系列之⼗⼆:多边形区域填充算法--扫描线种⼦填充算法1.3扫描线种⼦填充算法1.1和1.2节介绍的两种种⼦填充算法的优点是⾮常简单,缺点是使⽤了递归算法,这不但需要⼤量栈空间来存储相邻的点,⽽且效率不⾼。
为了减少算法中的递归调⽤,节省栈空间的使⽤,⼈们提出了很多改进算法,其中⼀种就是扫描线种⼦填充算法。
扫描线种⼦填充算法不再采⽤递归的⽅式处理“4-联通”和“8-联通”的相邻点,⽽是通过沿⽔平扫描线填充像素段,⼀段⼀段地来处理“4-联通”和“8-联通”的相邻点。
这样算法处理过程中就只需要将每个⽔平像素段的起始点位置压⼊⼀个特殊的栈,⽽不需要象递归算法那样将当前位置周围尚未处理的所有相邻点都压⼊堆栈,从⽽可以节省堆栈空间。
应该说,扫描线填充算法只是⼀种避免递归,提⾼效率的思想,前⾯提到的注⼊填充算法和边界填充算法都可以改进成扫描线填充算法,下⾯介绍的就是结合了边界填充算法的扫描线种⼦填充算法。
扫描线种⼦填充算法的基本过程如下:当给定种⼦点(x, y)时,⾸先分别向左和向右两个⽅向填充种⼦点所在扫描线上的位于给定区域的⼀个区段,同时记下这个区段的范围[xLeft, xRight],然后确定与这⼀区段相连通的上、下两条扫描线上位于给定区域内的区段,并依次保存下来。
反复这个过程,直到填充结束。
扫描线种⼦填充算法可由下列四个步骤实现:(1) 初始化⼀个空的栈⽤于存放种⼦点,将种⼦点(x, y)⼊栈;(2) 判断栈是否为空,如果栈为空则结束算法,否则取出栈顶元素作为当前扫描线的种⼦点(x, y),y是当前的扫描线;(3) 从种⼦点(x, y)出发,沿当前扫描线向左、右两个⽅向填充,直到边界。
分别标记区段的左、右端点坐标为xLeft和xRight;(4) 分别检查与当前扫描线相邻的y - 1和y + 1两条扫描线在区间[xLeft, xRight]中的像素,从xLeft开始向xRight⽅向搜索,若存在⾮边界且未填充的像素点,则找出这些相邻的像素点中最右边的⼀个,并将其作为种⼦点压⼊栈中,然后返回第(2)步;这个算法中最关键的是第(4)步,就是从当前扫描线的上⼀条扫描线和下⼀条扫描线中寻找新的种⼦点。
多边形区域填充算法--扫描线填充算法(有序边表法)有代码

多边形区域填充算法--扫描线填充算法(有序边表法)有代码⼆、扫描线算法(Scan-Line Filling)转载 https:///u013044116/article/details/49737585扫描线算法适合对⽮量图形进⾏区域填充,只需要直到多边形区域的⼏何位置,不需要指定种⼦点,适合计算机⾃动进⾏图形处理的场合使⽤,⽐如电脑游戏和三维CAD软件的渲染等等。
对⽮量多边形区域填充,算法核⼼还是求交。
⼀⽂给出了判断点与多边形关系的算法――扫描交点的奇偶数判断算法,利⽤此算法可以判断⼀个点是否在多边形内,也就是是否需要填充,但是实际⼯程中使⽤的填充算法都是只使⽤求交的思想,并不直接使⽤这种求交算法。
究其原因,除了算法效率问题之外,还存在⼀个光栅图形设备和⽮量之间的转换问题。
⽐如某个点位于⾮常靠近边界的临界位置,⽤⽮量算法判断这个点应该是在多边形内,但是光栅化后,这个点在光栅图形设备上看就有可能是在多边形外边(⽮量点没有⼤⼩概念,光栅图形设备的点有⼤⼩概念),因此,适⽤于⽮量图形的填充算法必须适应光栅图形设备。
2.1扫描线算法的基本思想扫描线填充算法的基本思想是:⽤⽔平扫描线从上到下(或从下到上)扫描由多条⾸尾相连的线段构成的多边形,每根扫描线与多边形的某些边产⽣⼀系列交点。
将这些交点按照x坐标排序,将排序后的点两两成对,作为线段的两个端点,以所填的颜⾊画⽔平直线。
多边形被扫描完毕后,颜⾊填充也就完成了。
扫描线填充算法也可以归纳为以下4个步骤:(1)求交,计算扫描线与多边形的交点(2)交点排序,对第2步得到的交点按照x值从⼩到⼤进⾏排序;(3)颜⾊填充,对排序后的交点两两组成⼀个⽔平线段,以画线段的⽅式进⾏颜⾊填充;(4)是否完成多边形扫描?如果是就结束算法,如果不是就改变扫描线,然后转第1步继续处理;整个算法的关键是第1步,需要⽤尽量少的计算量求出交点,还要考虑交点是线段端点的特殊情况,最后,交点的步进计算最好是整数,便于光栅设备输出显⽰。
(计算机图形学)多边形区域扫描线填充或种子填充

实验2:多边形区域扫描线填充或种子填充实验类型:验证、设计所需时间:3学时主要实验内容及要求:实现多边形区域扫描线填充的有序边表算法,并将实现的算法应用于任意多边形的填充,要求多边形的顶点由键盘输入或鼠标拾取,填充要准确,不能多填也不能少填。
要求掌握边形区域扫描线填充的有序边表算法的基本原理和算法设计,画出算法实现的程序流程图,使用C或者VC++实现算法,并演示。
参考试验步骤:1)分析多边形区域扫描线填充算法的原理,确定算法流程①初始化:构造边表,AET表置空②将第一个不空的ET表中的边插入AET表③由AET表取出交点进行配对(奇偶)获得填充区间,依次对这些填充区间着色④y=y i+1时,根据x=x i+1/k修改AET表所有结点中交点的x坐标。
同时如果相应的ET表不空,则将其中的结点插入AET表,形成新的AET表⑤AET表不空,则转(3),否则结束。
2)编程实现①首先确定多边形顶点和ET/AET表中结点的结构②编写链表相关操作(如链表结点插入、删除和排序等)③根据1)中的算法结合上述已有的链表操作函数实现多边形区域扫描线填充的主体功能④编写主函数,测试该算法源代码:#include<gl/glut.h>#include<iostream>using namespace std;typedef struct dePt{int x;int y;}dePt;void fill(GLint x1,GLint y1,GLint z1){glBegin(GL_POINTS);glVertex3f(x1,y1,0.0f);glEnd();}typedef struct Edge{int yUpper;float xIntersect, dxPerScan;struct Edge *next;}Edge;void insertEdge(Edge *list, Edge *edge){Edge *p,*q=list;p=q->next;while(p!=NULL){if(edge->xIntersect<p->xIntersect)p=NULL;else{q=p;p=p->next;}}edge->next=q->next;q->next=edge;}int yNext(int k, int cnt, dePt*pts){int j;if((k+1)>(cnt-1))j=0;elsej=k+1;while(pts[k].y==pts[j].y)if((j+1)>(cnt-1))j=0;else j++;return (pts[j].y);}void makeEdgeRec(dePt lower, dePt upper,int yComp,Edge *edge,Edge *edges[]) {edge->dxPerScan=(float)(upper.x-lower.x)/(upper.y-lower.y);edge->xIntersect=lower.x;if(upper.y<yComp)edge->yUpper=upper.y-1;elseedge->yUpper=upper.y;insertEdge(edges[lower.y],edge);}void buildEdgeList(int cnt,dePt *pts,Edge *edges[]){Edge *edge;dePt v1,v2;int i,yPrev=pts[cnt-2].y;v1.x=pts[cnt-1].x;v1.y=pts[cnt-1].y;for(i=0;i<cnt;i++){v2=pts[i];if(v1.y!=v2.y){edge=(Edge *)malloc(sizeof(Edge));if(v1.y<v2.y)makeEdgeRec(v1,v2,yNext(i,cnt,pts),edge,edges);elsemakeEdgeRec(v2,v1,yPrev,edge,edges);}yPrev=v1.y;v1=v2;}}void buildActiveList(int scan,Edge *active,Edge *edges[]) {Edge *p,*q;p=edges[scan]->next;while(p){q=p->next;insertEdge(active,p);p=q;}}void fillScan(int scan,Edge *active){Edge *p1,*p2;int i;p1=active->next;while(p1){p2=p1->next;for(i=p1->xIntersect;i<p2->xIntersect;i++)fill((int)i,scan,3);p1=p2->next;}}void deleteAfter(Edge *q){Edge *p=q->next;q->next=p->next;free(p);}void updateActiveList(int scan,Edge *active) {Edge *q=active, *p=active->next;while(p)if(scan>=p->yUpper){p=p->next;deleteAfter(q);}else{p->xIntersect=p->xIntersect+p->dxPerScan; q=p;p=p->next;}}void resortActiveList(Edge *active){Edge *q,*p=active->next;active->next=NULL;while(p){q=p->next;insertEdge(active,p);p=q;}}void scanFill(int cnt,dePt *pts){Edge *edges[1024],*active;int i,scan;for(i=0;i<1024;i++){edges[i]=(Edge *)malloc(sizeof(Edge)); edges[i]->next=NULL;}buildEdgeList(cnt,pts,edges);active=(Edge *)malloc(sizeof(Edge)); active->next=NULL;for(scan=0;scan<1024;scan++)buildActiveList(scan,active,edges);if(active->next){fillScan(scan,active);updateActiveList(scan,active);resortActiveList(active);}}}void ChangeSize(GLsizei w,GLsizei h){GLfloat nRange=400.0f;if(h==0) h=1;glViewport(0,0,w,h);glMatrixMode(GL_PROJECTION);glLoadIdentity();if(w<=h)glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,-nRange,nRange);elseglOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,-nRange,nRange); glMatrixMode(GL_MODELVIEW);glLoadIdentity();}void Display(void){glClear(GL_COLOR_BUFFER_BIT);glLineWidth(5.0);int n,x,y,i;cout<<"请输入多边形顶点数:"<<endl;cin>>n;dePt *t=new dePt[n];for(i=0;i<n;i++){cout<<"请输入第"<<i+1<<"个顶点坐标"<<endl;cin>>x>>y;t[i].x=x;t[i].y=y;glVertex2i(t[i].x,t[i].y);} glEnd();glFlush();scanFill(n,t);glFlush();}void SetupRC()glClearColor(1.0f,1.0f,1.0f,1.0f); glColor3f(1.0f,0.0f,0.0f);}实验结果:。
实验2:多边形区域扫描线填充或种子填充

2007-11-06 16:20 区域填充的扫描线算法(C源程序)-------计算机图形学实验/** 区域填充的扫描线算法* (适合用于内点表示的4连通区域)*算法的基本过程:* 当给定种子点(x,y)时,首先填充种子点所在的扫描线上的位于给定区域的*一个区段,然后确定与这一区段连通的上下两条扫描线上位于给定区域的区段,并*依次保存下来。
反复这个过程,直到填充结束.** 操作系统: Windows XP* 运行环境:Win-TC* 作者:范雷* 时间: 2007.10.27*/#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(EGA VGA_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;。
多边形图形的环状扫描线种子填充算法

多边形图形的环状扫描线种子填充算法
邱国清
【期刊名称】《淮北师范大学学报:自然科学版》
【年(卷),期】2017(038)001
【摘要】递归种子填充算法在对多边形区域填充时存在一个点多次进出堆栈且占用大量存储空间,只适合于细小区域填充.为此,基于Morton码原理提出一种改进算法.首先,将填充胚的行列值转换成十进制Morton码,其次将每个填充胚的值与堆栈中的种子点Morton码一一匹配,避免堆栈中出现重复点,最后采用环状扫描线方式按顺时针或逆时针方向对多边形区域进行扫描填充.经过实验数据验证,改进算法能节省较多的存储空间,避免一个点反复多次进出堆栈.
【总页数】4页(P64-67)
【作者】邱国清
【作者单位】闽南师范大学计算机学院,福建漳州363000
【正文语种】中文
【中图分类】TP399
【相关文献】
1.多边形图形的环状扫描线种子填充算法
2.扫描线种子填充算法的改进
3.基于扫描线种子填充算法的铸件孤立域搜索算法
4.一种改进的扫描线种子填充算法
5.基于扫描线种子填充算法的细胞形态参数计算
因版权原因,仅展示原文概要,查看原文内容请购买。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验2:多边形区域扫描线填充或种子填充
一、实验目的
1.通过实验,进一步理解和掌握几种常用多边形填充算法的基本原理
2.掌握多边形区域填充算法的基本过程
3.掌握在C/C++环境下用多边形填充算法编程实现指定多边形的填充。
二、实验内容
用种子填充算法和扫描线填充算法等任意两种算法实现指定多边形的区域填充。
三、实验原理
种子填充算法又称为边界填充算法。
其基本思想是:从多边形区域的一个内点开始,由内向外用给定的颜色画点直到边界为止。
如果边界是以一种颜色指定的,则种子填充算法可逐个像素地处理直到遇到边界颜色为止。
种子填充算法常用四连通域和八连通域技术进行填充操作。
四向连通填充算法:
a)种子像素压入栈中;
b)如果栈为空,则转e);否则转c);
c)弹出一个像素,并将该像素置成填充色;并判断该像素相邻的四连通像素是否为边界色或已经置成多边形的填充色,若不是,则将该像素压入栈;
d)转b);
e)结束。
扫描线填充算法的基本过程如下:当给定种子点(x,y)时,首先填充种子点所在扫描线上的位于给定区域的一个区段,然后确定与这一区段相连通的上、下两条扫描线上位于给定区域内的区段,并依次保存下来。
反复这个过程,直到填充结束。
区域填充的扫描线算法可由下列四个步骤实现:
(1)初始化:堆栈置空。
将种子点(x,y)入栈。
(2)出栈:若栈空则结束。
否则取栈顶元素(x,y),以y作为当前扫描线。
(3)填充并确定种子点所在区段:从种子点(x,y)出发,沿当前扫描线向左、右两个方向填充,直到边界。
分别标记区段的左、右端点坐标为xl和xr。
(4)并确定新的种子点:在区间[xl,xr]中检查与当前扫描线y上、下相邻的两条扫描线上的象素。
若存在非边界、未填充的象素,则把每一区间的最右象素作为种子点压入堆栈,返回第(2)步。
四、实验步骤
1.复习有关算法,明确实验目的和要求;
2.依据算法思想,绘制程序流程图(指定填充多边形);
3.设计程序界面,要求操作方便;
4.用C/C++语言编写源程序并调试、执行(最好能用动画显示填充过程);
5.分析实验结果
6.对程序设计过程中出现的问题进行分析与总结;
7.打印源程序或把源程序以文件的形式提交;
8.按格式要求完成实验报告。
五、实验结果及分析
种子填充算法的优点是非常简单,缺点是需要大量栈空间来存储相邻的点。
扫描线填充算法就是它的改进的方法。
它是通过沿扫描线填充水平像素段,来处理四连通或八连通相邻点,这样就仅仅只需要将每个水平像素段的起始位置压入栈,而不需要将当前位置周围尚未处理的相邻像素都压入栈,从而可以节省大量的栈空间。
六、实验结果
种子填充算法
扫描线填充算法七、实验主要代码
//种子填充算法
void CZhztchView::boundaryfill4(int x, int y, int boundarycolor, int newcolor)
{
int color;
CClientDC dc(this); //获取客户区设备描述表
color=dc.GetPixel(x,y);
if(color!=newcolor&&color!=boundarycolor)
{
dc.SetPixel(x,y,newcolor);
boundaryfill4(x,y+1,boundarycolor,newcolor);
boundaryfill4(x,y-1,boundarycolor,newcolor);
boundaryfill4(x-1,y,boundarycolor,newcolor);
boundaryfill4(x+1,y,boundarycolor,newcolor);
}
}
//////////////////////////////////////////////////////////////////// ////////////
//扫描线填充算法
void CZhztchView::OnScanfill()
{
RedrawWindow();
CDC* pDC=GetDC();
CPen newpen(PS_SOLID,3,RGB(255,0,0));
CPen *old=pDC->SelectObject(&newpen);
spt[0]=CPoint(100,100); //绘制多边形区域
spt[1]=CPoint(300,100);
spt[2]=CPoint(250,250);
spt[3]=CPoint(100,250);
spt[4]=CPoint(150,200);
spt[5]=CPoint(90,180);
spt[6]=CPoint(150,150);
spt[7]=CPoint(100,100);
pDC->Polyline(spt,8);
//pDC->SelectObject(old);
//ReleaseDC(pDC);
// TODO: Add your command handler code here
//CDC* pDC=GetDC();
CPen newpen2(PS_SOLID,1,RGB(0,255,0));
CPen *old2=pDC->SelectObject(&newpen2);
int j,k,s = 0;
int p[5]; //每根扫描线交点
int pmin = 0,pmax = 0;
for(int i=0;i<=6;i++)//建立边表
{
edge[i].dx=(float)(spt[i+1].x-spt[i].x)/(spt[i+1].y-spt[i].y);
if(spt[i].y<=spt[i+1].y){
edge[i].num=i;
edge[i].ymin=spt[i].y;
edge[i].ymax=spt[i+1].y;
edge[i].xmin=(float)spt[i].x;
edge[i].xmax=(float)spt[i+1].x;
if(spt[i+1].y > pmax)
pmax = spt[i+1].y;
if(spt[i].y < pmin)
pmin = spt[i].y;
}
else{
edge[i].num=i;
edge[i].ymin=spt[i+1].y;
edge[i].ymax=spt[i].y;
edge[i].xmax=(float)spt[i].x;
edge[i].xmin=(float)spt[i+1].x;
if(spt[i].y > pmax)
pmax = spt[i].y;
if(spt[i+1].y < pmin)
pmin = spt[i+1].y;
}
}
for(int r=1;r<=6;r++) //排序edge(yUpper,xIntersect),结果为从大到小
{
for(int q=0;q<=6-r;q++)
{
if(edge[q].ymin<edge[q+1].ymin)
{
newedge[0]=edge[q]; edge[q]=edge[q+1];
edge[q+1]=newedge[0];
}
}
}
for(int scan=pmax-1;scan>=pmin+1;scan--)
{
int b=0;
k=s;
for(j=k;j<=6;j++)
{
if((scan>edge[j].ymin)&&(scan<=edge[j].ymax))//判断与线段相交
{
if(scan==edge[j].ymax)
{
if(spt[edge[j].num+1].y<edge[j].ymax)
{
b++;
p[b]=(int)edge[j].xmax;
}
else if(spt[edge[j].num-1].y<edge[j].ymax)
{
b++;
p[b]=(int)edge[j].xmax;
}
}
if((scan>edge[j].ymin)&&(scan<edge[j].ymax))
{
b++;
p[b]=(int)(edge[j].xmax+edge[j].dx*(scan-edge[j].ymax));
}
}
//pDC->LineTo(spt[edge[0].num].x,spt[edge[0].num].y);
if(scan<=edge[j].ymin)//
s=j;
}
if(b>1)
{
for(int u=1;u<b;u++)
{
pDC->MoveTo(p[u]-1,scan);
u++;
pDC->LineTo(p[u],scan);
}
}
}
pDC->SelectObject(old);
pDC->SelectObject(old2); }。