计算机图形学 区域填充
计算机图形学图形区域填充效果
// Fill.cpp : implementation file
#include "stdafx.h"
#include "FloodFill.h"
#include "Fill.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
（1）种子填充算法原理
在多边形内部找到一个已知的象素点作为种子点，由此开始，利用区域的连通性找到多边形内部的 其它所有象素点进行填充。
（i）四向连通区域
①四向连通区域概念：从区域上任一点出发，在不超出区域边界的前提下，可通过4个方向：上、下、左、右的移动组合到达区域中的任意象素点，称此区域为四向连通区域。
{
//有需要填充的区域
if(spanNeedFill==FALSE)
{
spanNeedFill = TRUE;
}
x++;
}
if(spanNeedFill)
{
CPoint rightp(x-1,y);
stack.Push(x-1);
stack.Push(y);
spanNeedFill = FALSE;
virtual ~CStack();
};
#endif // !defined(AFX_STACK_H__D198F788_4ED1_4C09_98E5_433BAB24D864__INCLUDED_)
CStack.cpp参考代码：
// Stack.cpp: implementation of the CStack class.
#if !defined(AFX_STACK_H__D198F788_4ED1_4C09_98E5_433BAB24D864__INCLUDED_) #define AFX_STACK_H__D198F788_4ED1_4C09_98E5_433BAB24D864__INCLUDED_
c语言多边形区域填充算法
c语言多边形区域填充算法C语言多边形区域填充算法一、介绍多边形区域填充算法是计算机图形学中的一项重要技术，用于将给定的多边形区域进行填充，使其呈现出丰富的颜色或纹理，增强图形的效果和表现力。
本文将介绍一种常用的C语言多边形区域填充算法——扫描线填充算法。
二、扫描线填充算法原理扫描线填充算法是一种基于扫描线的填充方法，其基本思想是将多边形区域按照水平扫描线的顺序，从上到下逐行扫描，通过判断扫描线与多边形边界的交点个数来确定是否进入多边形区域。
具体步骤如下：1. 首先，确定多边形的边界，将其存储为一个边表。
边表中的每个边都包含起点和终点的坐标。
2. 创建一个活性边表（AET），用于存储当前扫描线与多边形边界的交点。
初始时，AET为空。
3. 从上到下逐行扫描多边形区域，对每一条扫描线，从边表中找出与该扫描线相交的边，并将其加入AET中。
4. 对于AET中的每一对交点，按照从左到右的顺序两两配对，形成水平线段，将其填充为指定的颜色或纹理。
5. 在扫描线的下一行，更新AET中的交点的坐标，然后重复步骤4，直到扫描到多边形区域的底部。
三、代码实现下面是一个简单的C语言实现扫描线填充算法的示例代码：```#include <stdio.h>#include <stdlib.h>#include <stdbool.h>typedef struct {int x;int y;} Point;typedef struct {int yMax;float x;float dx;int next;} Edge;void fillPolygon(int n, Point* points, int color) {// 获取多边形的边界int yMin = points[0].y;int yMax = points[0].y;for (int i = 1; i < n; i++) {if (points[i].y < yMin) {yMin = points[i].y;}if (points[i].y > yMax) {yMax = points[i].y;}}// 创建边表Edge* edges = (Edge*)malloc(sizeof(Edge) * n);int k = n - 1;for (int i = 0; i < n; i++) {if (points[i].y < points[k].y) {edges[i].yMax = points[k].y;edges[i].x = points[i].x;edges[i].dx = (float)(points[k].x - points[i].x) / (points[k].y - points[i].y);edges[i].next = k;} else {edges[i].yMax = points[i].y;edges[i].x = points[k].x;edges[i].dx = (float)(points[i].x - points[k].x) / (points[i].y - points[k].y);edges[i].next = i;}k = i;}// 扫描线填充for (int y = yMin; y < yMax; y++) {int xMin = INT_MAX;int xMax = INT_MIN;for (int i = 0; i < n; i++) {if (y >= edges[i].yMax) {continue;}edges[i].x += edges[i].dx;if (edges[i].x < xMin) {xMin = edges[i].x;}if (edges[i].x > xMax) {xMax = edges[i].x;}int j = edges[i].next;while (j != i) {edges[j].x += edges[j].dx; if (edges[j].x < xMin) {xMin = edges[j].x;}if (edges[j].x > xMax) {xMax = edges[j].x;}j = edges[j].next;}}for (int x = xMin; x < xMax; x++) { drawPixel(x, y, color);}}free(edges);}int main() {// 定义多边形的顶点坐标Point points[] = {{100, 100},{200, 200},{300, 150},{250, 100}};// 填充多边形区域为红色fillPolygon(4, points, RED);return 0;}```四、总结通过扫描线填充算法，我们可以实现对多边形区域的填充，从而提升图形的表现效果。
fill相关知识点
填充（Fill）相关知识点填充（Fill）是一种常见的计算机图形学技术，用于在图像或物体的内部或边界区域中填充颜色或纹理。
填充技术在许多领域中被广泛应用，如图像处理、计算机辅助设计（CAD）和计算机游戏开发等。
本文将介绍填充相关的知识点，从基本原理到常见算法，让读者对填充技术有一个全面的了解。
基本原理填充技术的基本原理是通过某种规则或算法，在给定的区域内部或边界上填充颜色或纹理。
这个区域可以是一个简单的几何形状，如矩形或圆形，也可以是一个复杂的多边形。
填充通常从区域内部的某个点开始，按照一定的规则或算法进行扩散，直到填充满整个区域。
基本算法以下是一些常见的填充算法：扫描线填充算法扫描线填充算法是一种基于扫描线的填充方法。
它通过将扫描线与区域的边界进行比较，确定扫描线与区域的交点，并根据规则填充扫描线上的像素。
该算法的优点是简单易懂，并且适用于任意形状的区域。
边界填充算法边界填充算法是一种基于区域边界的填充方法。
它通过检测区域的边界像素，并根据规则填充区域内部的像素。
该算法的优点是填充效果清晰，但对于复杂的区域边界可能会存在一些问题。
种子填充算法种子填充算法是一种基于种子点的填充方法。
它通过选择一个种子点作为起始点，并按照一定的规则或算法进行扩散填充。
种子填充算法适用于复杂的区域填充，但可能存在堆栈溢出的问题。
填充的应用领域填充技术在许多领域中都有广泛的应用，以下是其中一些常见的应用领域：图像处理在图像处理中，填充技术可以用于图像的增强、修复和合成等方面。
例如，可以使用填充技术修复图像中的缺陷、填充图像的边界以及合成多个图像。
计算机辅助设计（CAD）在计算机辅助设计中，填充技术可以用于填充图形对象的内部或边界，以增加图形的真实感和细节。
例如，可以使用填充技术填充建筑物的内部、道路的纹理以及地形的颜色。
计算机游戏开发在计算机游戏开发中，填充技术可以用于填充游戏场景的地形、角色的纹理以及特效的颜色。
通过使用填充技术，可以使游戏画面更加精美和逼真。
计算机图形学四连通区域种子填充算法实验
计算机图形学四连通区域种子填充算法实验————————————————————————————————作者: ————————————————————————————————日期:ﻩ《计算机图形学实验》报告任课教师:钱文华2０16年春季学期实验:四连通区域种子填充算法实验时间：201６年12月8日实验地点：信息学院22０4实验目的：掌握种子填充算法的原理，并会用种子填充算法和opｅｎｇl并结合使用ｃ+＋语言编写程序绘制多边形。
实验原理:种子填充算法又称为边界填充算法。
其基本思想是:从多边形区域的一个内点开始，由内向外用给定的颜色画点直到边界为止。
如果边界是以一种颜色指定的,则种子填充算法可逐个像素地处理直到遇到边界颜色为止。
内点的检测条件：ｉf(iｎｔerｉoｒCｏloｒ!=bo ｒｄerCoｌor&&interｉorColoｒ!＝ｆiｌlCｏlｏr）。
种子填充算法常用四连通域和八连通域技术进行填充操作。
从区域内任意一点出发，通过上、下、左、右四个方向到达区域内的任意像素。
用这种方法填充的区域就称为四连通域;这种填充方法称为四向连通算法。
从区域内任意一点出发,通过上、下、左、右、左上、左下、右上和右下八个方向到达区域内的任意像素。
用这种方法填充的区域就称为八连通域；这种填充方法称为八向连通算法。
一般来说，八向连通算法可以填充四向连通区域,而四向连通算法有时不能填充八向连通区域。
四向连通填充算法:a）种子像素压入栈中;b)如果栈为空,则转e）；否则转c）;c) 弹出一个像素,并将该像素置成填充色;并判断该像素相邻的四连通像素是否为边界色或已经置成多边形的填充色，若不是,则将该像素压入栈;d)转b）;ｅ）结束。
四连通填充算法利用到了递归的思想。
本实验只包括四连通填充算法程序代码:#ｉncludｅ<ｇlut.h>＃ｉｎｃlｕde<ｓtdｌib．h>＃ｉncｌudｅ<math．h>#include<ｗindowｓ.h＞voidｉniｔ（vｏid）{ glCｌearColor(１．０，１.0,1．0,0.０）；glMatrixMoｄｅ（ＧL_PROJＥCTION）;gｌｕOrtho２D（０．0，30０．0，０.0,30０.0);}voｉd setPixel(inｔx，ｉnｔy,lｏｎｇｆillCoｌor）{ ｇlColor3f（fｉllCoｌoｒ<<16,filｌCoｌor<<８,fillCｏloｒ)；ｇlＢｅgin（ＧL_ＰＯINTＳ);ｇlＶｅｒteｘ2i（x,y）;ｇlEnｄ();}ｖｏｉｄboundaryFill４(iｎt x,ｉnｔy,lｏng fillＣolor,lｏng bordeｒColor）{ unｓｉgneｄchａr paｒams[3];loｎg interioｒCoｌoｒ;glRｅaｄPixels(ｘ，y,1,1,GL_RGB,GＬ＿UNSIＧNＥD_BYＴE,par ａms）;interiorCoｌoｒ=RGB(paraｍs[0],ｐarａms[１］,paｒaｍs[2])；ｉf(inteｒiorＣolor!=boｒderCｏloｒ＆＆inteｒiｏrCoｌｏr!=filｌColor){ setＰixeｌ(x，ｙ,fｉｌlCoｌｏr);ｂoundaryFill4（x＋1,y,filｌＣoｌｏr,ｂordeｒCｏlor);ｂｏunｄaｒyＦｉｌl4(ｘ-1，y，fiｌlＣolor,borderColor); boundaryFilｌ４(x,ｙ+1,ｆｉlｌColｏr,borｄeｒCoｌor)；ｂounｄarｙFill4(x，y-1，ｆｉllColｏr，ｂorｄerＣolor);} }voiｄlineＳegment(voｉd) {long bｏrｄerCｏｌoｒ=RGB（255，0,０);lｏngｆiｌlColoｒ=RGB（０，0，255）;glClｅar（ＧL_COＬOR＿BUFFER_BIT); glCｏloｒ３ｆ(２55，0,0); ｇlＢegｉn（GL_ＬINE＿ＬＯＯP);glVeｒtex2ｉ(0,４0);glVｅｒteｘ2i(2０,0);glＶertex２i(６0,0）；glＶeｒtｅx2ｉ(80，4０）;ｇlVｅｒtex2i(６0,80);gｌVertex２i(20,80);gｌＥnd();boundaryＦill4(６０,60，ｆｉllＣolor,ｂorderColｏr)；gｌFlush()；}voｉｄmain(ｉｎt argc,chａr＊*aｒgv）｛ｇlutIｎｉｔ(&ａr ｇc,aｒｇv);glｕtInitDｉsｐｌaｙMode(GLUＴ＿ＳＩNGLE｜GLUT_ＲGB); glutInitＷindowPｏsiｔion（1５0,10０）;gluｔIｎitWinｄoｗSizｅ(300,３0０）;glutＣreateＷｉｎdow（"种子填充"）；init();glutDisｐlayFｕｎｃ(lｉneＳegｍeｎt);gｌｕtMａinＬｏoｐ(）;}上实验课时机房的实验结果:后来的实验结果:glVｅrteｘ2i（0,40);gｌＶerteｘ２i（20，0);glVerｔex2i（60,０);glVerteｘ2i（８0，４０);gｌＶertｅx2ｉ(60，80);ｇlＶerteｘ2i(２0,80)；ｇlEnｄ();ｂｏｕndaryFｉlｌ4(60,60，ｆｉlｌCｏlor,ｂorderＣoｌor）；以上这段程序改成如下glVerｔex2ｉ(９0，40);glVｅrtｅx２i（１2０, １00）;ｇlVertex2i(90,1６0);glVertｅｘ２i(60, 160);ｇlVertex2i(60, ４０);glEnd()；bouｎｄaryFilｌ4(７0,6０,fiｌｌCｏｌoｒ,bｏｒderCoｌor); 改变参数后：再把ｇlVeｒｔｅx2i（9０，40);glVertｅｘ２i(120, 100）；glＶｅrｔex2i(90,160）;glＶerｔex2i(60, １6０）;glVｅrtex２i（６0, 40）;gｌＥnd（);bｏundaryFill4（70,6０,fiｌlCｏloｒ,boｒdｅrCｏlor）；改成glVeｒtex2i(100, １０0)；glVｅrteｘ2i(２00, 100);gｌVｅｒteｘ2ｉ(1５0,150);/／glVｅrteｘ2ｉ(60, 1６0);／/glVertｅx2i(6０, 40)；glＥnd();ｂoundaryFill4(150，1２0,fiｌlCｏlor，borｄerCoｌoｒ);后的结果如下图:实验总结:通过多组数据的测试，知道了上面算法的正确,普适性。
区域填充的扫描线算法
区域填充的扫描线算法区域填充是一种常见的计算机图形学算法，用于将一个封闭区域内的所有像素点填充为指定的颜色。
扫描线算法是区域填充的一种常用方法，本文将介绍扫描线算法的基本原理、实现步骤和一些优化技巧。
扫描线算法的基本原理是利用扫描线从图像的上边界向下扫描，检测每个扫描线与区域的交点。
当遇到一个交点时，根据该交点的左右两侧的交点情况，确定将该交点连接到哪个交点上。
通过不断地扫描和连接交点，最终将整个区域填充为指定的颜色。
下面是扫描线算法的具体实现步骤：1.首先需要确定区域的边界，可以由用户提供或通过其他算法生成。
边界可以用一系列的线段、多边形或曲线表示。
2. 创建一个数据结构来存储每个扫描线与区域的交点。
常用的数据结构是活性边表（Active Edge Table，AET）和扫描线填充表（Scanline Fill Table，SFT）。
AET用于存储当前扫描线与区域边界的交点，SFT用于存储所有扫描线的交点。
3.初始化扫描线的起始位置为图像的上边界，并创建一个空的AET。
4.开始扫描线的循环，直到扫描线到达图像的下边界。
每次循环都进行以下操作：-将扫描线与区域边界进行相交，找出所有与区域相交的线段，并将它们的交点加入到AET中。
-对AET按照交点的x坐标进行排序。
-从AET中取出相邻的两个交点，根据这两个交点之间的像素点是否在区域内来决定是否填充这些像素点。
5.当扫描线到达图像的下边界时，完成填充。
扫描线算法的实现可能会遇到一些边界情况和优化需求。
下面是一些常见的优化技巧：1.边界处理：在AET中存储的交点需要进行边界处理，确保交点处于图像范围内。
2.垂直线段处理：对于垂直线段，可以进行特殊处理，避免在AET中重复存储相同的交点。
3.区域内部边界处理：当区域内部有不连续的边界时，需要对交点进行合并，避免出现多余的像素点填充。
4.使用扫描线填充算法优化：对于大尺寸的区域填充，可以使用扫描线填充算法进行优化。
计算机图形学——区域填充算法（基本光栅图形算法）
计算机图形学——区域填充算法（基本光栅图形算法）⼀、区域填充概念区域：指已经表⽰成点阵形式的填充图形，是象素的集合。
区域填充：将区域内的⼀点（常称【种⼦点】）赋予给定颜⾊，然后将这种颜⾊扩展到整个区域内的过程。
区域填充算法要求区域是连通的，因为只有在连通区域中，才可能将种⼦点的颜⾊扩展到区域内的其它点。
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)改进算法，减少递归次数，提⾼效率三、扫描线种⼦填充算法基本思想从给定的种⼦点开始，填充当前扫描线上种⼦点所在的⼀区段，然后确定与这⼀段相邻的上下两条扫描线上位于区域内的区段（需要填充的区间），从这些区间上各取⼀个种⼦点依次把它们存起来，作为下次填充的种⼦点。
计算机图形学-区域填充的扫描线算法
计算机图形学——区域填充的扫描线算法一．实验名称：区域填充的扫描线算法二．实验目的：1、理解区域填充扫描线算法的原理；2、实现区域填充的扫描线算法并测试；三．算法原理：算法基本思想: 首先填充种子点所在扫描线上位于区域内的区段，然后确定与该区段相邻的上下两条扫描线上位于区域内的区段，并依次将各区段的起始位置保存, 这些区段分别被用区域边界色显示的像素点所包围。
随后,逐步取出一开始点并重复上述过程，直到所保存各区段都填充完毕为止。
借助于栈结构，区域填充的扫描线算法之步骤如下：Step 1. 初始化种子点栈：置种子点栈为空栈，并将给定的种子点入栈；Step 2. 出栈：若种子点栈为空，算法结束；否则，取栈顶元素(x，y)为种子点；Step 3. 区段填充：从种子点(x, y) 开始沿纵坐标为y 的当前扫描线向左右两个方向逐像素点进行填色，其颜色值置为newcolor 直至到达区域边界。
分别以xl 和xr 表示该填充区段两端点的横坐标；Step 4. 新种子点入栈: 分别确定当前扫描线上、下相邻的两条扫描线上位于区段[xl, xr] 内的区域内的区段。
若这些区段内的像素点颜色值为newolor ,则转至Step 2；否则以区段的右端点为种子点入种子点栈，再转至Step 2。
四．原程序代码：/*****************************************//*4-ScanLineFill 区域填充的扫描线算法实现*//*****************************************/#include <stdio.h>#include <conio.h>#include <graphics.h>#include <malloc.h>#define Stack_Size 100 //栈的大小常量//定义结构体,记录种子点typedef struct{int x;int y;}Seed;//定义顺序栈(种子点)typedef struct{Seed Point[Stack_Size];int top;}SeqStack;//初始化栈操作void InitStack(SeqStack *&S){S=(SeqStack *)malloc(sizeof(SeqStack));S->top=-1;}//种子点栈置空；void setstackempty (SeqStack *S){S->top==-1;}//种子点栈状态检测函数int isstackempty (SeqStack *S){if(S->top==-1)return true; //空栈返回trueelsereturn false; //非空栈返回false}//种子点入栈；int stackpush (SeqStack *&S,Seed point){if(S->top==Stack_Size-1)//栈已满，返回false return false;S->top++;//栈未满，栈顶元素加1S->Point[S->top]= point;return true;}//取栈顶元素；int stackpop (SeqStack *&S,Seed &point){if(S->top==-1)//栈为空，返回falsereturn false;point=S->Point[S->top];S->top --;//栈未空，top减1return true;}//画圆void CirclePoints (int xc, int yc, int x, int y, int Color) {putpixel (xc + x, yc + y, Color);putpixel (xc + x, yc - y, Color);putpixel (xc - x, yc + y, Color);putpixel (xc - x, yc - y, Color);putpixel (xc + y, yc + x, Color);putpixel (xc + y, yc - x, Color);putpixel (xc - y, yc + x, Color);putpixel (xc - y, yc - x, Color); }//中点画圆算法void MidpointCircle(int radius, int Color) {int x, y;float d;x=0;y=radius;d=5.0/4-radius;CirclePoints(250,250,x,y,Color);while(x<y){if (d<0){d+=x*2.0+3;}else{d+=(x-y)*2.0+5;y--;}x++;CirclePoints(250,250,x,y,Color);}}//四连通扫描线算法void ScanLineFill4(int x, int y, int oldcolor, int newcolor) {int xl, xr, i;bool SpanNeedFill;Seed pt;//种子点SeqStack *S;//定义顺序栈InitStack(S);//定义了栈之后必须把栈先初始化setstackempty(S);//种子点栈置空；pt.x = x;pt.y = y;stackpush (S,pt); // 种子点(x, y)入栈while (!isstackempty(S)){stackpop (S,pt);//取种子点y = pt.y;x = pt.x;while (getpixel (x,y)==oldcolor) {// 从种子点开始向右填充putpixel (x, y, newcolor);x++;}xr = x -1;x = pt.x -1;while (getpixel (x,y)==oldcolor) { // 从种子点开始向左填充putpixel (x, y, newcolor);x--;}xl = x + 1;x = xl;y = y +1; // 处理上面一条扫描线while (x < xr){SpanNeedFill = false;while (getpixel (x, y)==oldcolor){SpanNeedFill = true;x++ ;} // 待填充区段搜索完毕if (SpanNeedFill){// 将右端点作为种子点入栈pt.x = x - 1;pt.y = y;stackpush (S,pt);SpanNeedFill = false;} //继续向右检查以防遗漏while ((getpixel (x, y)!=oldcolor) && (x< xr)) x++;} //上一条扫描线上检查完毕x = xl;y=y-2; // 处理下面一条扫描线while (x < xr){SpanNeedFill = false;while (getpixel (x, y)==oldcolor){SpanNeedFill=true;x++ ;}if (SpanNeedFill){pt.x= x - 1;pt.y = y;stackpush (S,pt);SpanNeedFill=false;}while ((getpixel (x, y)!=oldcolor) && (x < xr))x++;}}}//主函数检测void main(){int radius,color;int x,y;//种子点int oldcolor,newcolor;//原色与填充色//输入参数值printf("input radius and color:\n");//画圆参数scanf("%d,%d",&radius,&color);printf("input x and y:\n"); //读入内点scanf("%d,%d", &x, &y);printf("input oldcolor and newcolor:\n"); //读入原色与填充色scanf("%d,%d", &oldcolor, &newcolor);int gdriver = DETECT,gmode;initgraph(&gdriver, &gmode, "c:\\tc");// 用背景色清空屏幕cleardevice();// 设置绘图色为红色setcolor(RED);MidpointCircle(radius,color);//用中点画圆算法画圆rectangle(150, 150, 350, 350);//再画一个矩形区域ScanLineFill4 (x,y,oldcolor,newcolor);//扫描线区域填充getch();closegraph();}五．运行结果与讨论：测试结果1：测试结果2：六．实验分析与讨论：1.通过借助栈这一数据结构，完成了区域填充的扫描线算法的实现，并利用以前所学的画圆等算法，进行综合运用，在此基础上进行扩充，设计多种图案，进行扫描线填充算法的检测，都得到了理想的结果，体现了算法的有效性；2.栈的数据结构给种子点的操作带来了极大的方便，为算法的实现提供了便利，同时还提高了算法的复用性和可靠性；3.此扫描线填充算法能够对多种图案进行填充，展现了算法的实用性。
计算机图形学--第四讲 区域填充算法
任课教师：李陶深教授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) 区间填色：将相交区间内的像素置成多边形色, 相交区间外的像素置成背景色。
计算机图形学实验报告-多边形的扫描转换与区域填充
计算机科学与技术学院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.找到多边形边界的最上端和最下端。
2.从最上端开始，逐行进行扫描。
3.在每一行，通过求解扫描线与多边形边界的交点，确定填充区域。
4.对于每个填充区域，根据设计要求进行颜色填充。
扫描线填充算法的优点是简单易懂、实现较为容易。
然而，该算法存在一些缺点。
首先，对于具有复杂形状的多边形，扫描线填充算法可能会产生很多不必要的计算，导致效率降低。
其次，该算法需要处理多边形边界相交的情况，可能出现像素重复填充的问题，需要进行额外的处理。
边界填充算法边界填充算法是另一种常见的多边形填充算法。
与扫描线填充算法不同的是，边界填充算法是从多边形的边界出发，向内部填充颜色。
该算法的基本思想是对多边形的每条边进行填充，最终得到多边形的填充区域。
具体步骤如下：1.遍历多边形的每条边，保存每条边的起点和终点。
2.对于每个边，根据设计要求进行颜色填充。
3.对于多边形内部的区域，根据边界的颜色填充。
边界填充算法的优点是适用于复杂形状的多边形，无需处理边界相交的问题。
然而，该算法的实现相对复杂，需要处理边界的细化以及边缘像素重复填充的问题。
适用场景不同的多边形填充算法在不同场景下有不同的适用性。
《计算机图形学教学资料》第6讲-多边形填充
05
多边形填充的未来发展
新型填充算法的研究
基于物理的填充算法
模拟真实世界的物理现象，如流体动 力学、表面张力等，以实现更加自然 的多边形填充效果。
智能优化算法
利用遗传算法、模拟退火等智能优化 技术，自动寻找最优的填充方案，提 高填充效率和准确性。
人工智能在多边形填充中的应用
学习型填充算法
通过机器学习技术，让算法自动学习优秀的人类设计师的填充风格，实现更加 艺术化的多边形填充效果。
优化内存管理
合理分配和释放内存，避免频繁的内 存分配和释放操作，可以提高多边形 填充的性能。
04
多边形填充的实践案例
使用OpenGL实现多边形填充
总结词
使用OpenGL进行多边形填充是一种常见的图形编程实践，它涉及到顶点数据、着色器程序和渲染流程的配置。
详细描述
首先，你需要定义多边形的顶点坐标，并将其存储在一个顶点数组中。然后，你需要编写一个OpenGL着色器程 序，用于处理顶点数据并进行渲染。在渲染过程中，你需要设置正确的顶点属性、着色器程序和渲染流程，以确 保多边形能够正确填充颜色。
填充区域
填充区域指的是多边形的内部区域，即所有被填充 的像素组成的区域。
填充颜色
填充颜色是指用于填充多边形内部的颜色，可以根 据需要选择不同的颜色。
填充算法的分类
扫描线填充算法
扫描线填充算法是一种基于扫 描线的填充算法，通过从左到 右、从上到下扫描多边形的内 部像素，对落在多边形内部的 扫描线进行上色。
在游戏开发中应用多边形填充
总结词
在游戏开发中应用多边形填充技术可以创建 更加逼真的游戏场景和角色模型。
详细描述
游戏开发者通常使用游戏引擎（如Unity或 Unreal Engine）来创建游戏场景和角色模 型。在这些引擎中，多边形填充技术被广泛 应用，以实现更加逼真的场景和角色模型。 通过合理配置顶点数据、着色器程序和渲染 流程，游戏开发者可以创建出令人惊叹的游 戏视觉效果。
实验三区域填充扫描线算法
实验三区域填充扫描线算法区域填充扫描线算法是一种计算机图形学算法，用于实现区域填充功能。
该算法通过扫描像素的方式，检测封闭区域内的每一条扫描线与区域边界的交点，并根据交点之间的像素颜色进行填充。
算法步骤如下：1.扫描线从画布的最底部开始，逐行向上移动。
2.检测扫描线与区域边界的交点，并记录交点的x坐标。
3.对于每对相邻的交点（称为活动边），按照交点的x坐标从左到右进行遍历。
4.遍历过程中，判断当前像素是否在封闭区域内。
如果在区域内，根据填充颜色进行颜色填充。
5.对于扫描线上的下一条扫描线，根据当前扫描线的活动边情况，更新活动边，即将下一条扫描线上的新交点加入到活动边中。
区域填充扫描线算法的优点在于其适用于任意形状的封闭区域，并且可以处理带有内部孔洞的区域。
相比其他填充算法，如扫描线填充算法，区域填充扫描线算法具有更好的效率和性能。
然而，区域填充扫描线算法也存在一些限制和问题。
首先，该算法要求区域边界是封闭的，并且必须采用逆时针顺序来定义区域内的边界。
其次，算法的实现和性能受到硬件设备的限制，特别是在处理较大尺寸的区域时可能出现性能问题。
为了解决这些问题，可以采用一些优化方法来改进算法的性能。
例如，可以使用空间填充曲线（Space Filling Curves）来加速扫描线的遍历过程。
还可以使用并行计算技术来加速算法的执行，特别是在处理大尺寸区域时。
总之，区域填充扫描线算法是一种常用的图形学算法，用于实现区域填充功能。
虽然具有一些限制和问题，但可以通过一些优化方法来改进算法的效率和性能，满足实际应用的需求。
区域填充算法运行代码
区域填充算法运行代码区域填充算法是一种计算机图形学算法，用于填充封闭区域。
它在渲染二维图形中起着重要作用，常用于涂色、填充多边形等操作。
下面是一个使用C语言实现的区域填充算法的运行代码示例，代码中使用了递归法实现区域填充。
```c#include <graphics.h> // 引入图形库的头文件//递归实现的区域填充算法void fillRegion(int x, int y, int fillColor, int borderColor) int currentColor = getpixel(x, y); // 获取当前像素的颜色if(currentColor != borderColor && currentColor != fillColor) putpixel(x, y, fillColor); // 填充当前像素//向上填充fillRegion(x, y - 1, fillColor, borderColor);//向下填充fillRegion(x, y + 1, fillColor, borderColor);//向左填充fillRegion(x - 1, y, fillColor, borderColor);//向右填充fillRegion(x + 1, y, fillColor, borderColor);}int mainint gd = DETECT, gm; // 图形模式和图形驱动程序检测initgraph(&gd, &gm, ""); // 初始化图形界面//绘制一个闭合多边形作为填充区域int poly[8] = {100, 100, 200, 100, 200, 200, 100, 200};drawpoly(4, poly);//设置填充颜色和边界颜色int fillColor = YELLOW;int borderColor = BLACK;//调用区域填充函数fillRegion(150, 150, fillColor, borderColor);getch(;closegraph(;return 0;```在上面的代码中，我们首先引入了图形库的头文件`graphics.h`，然后使用`initgraph`函数初始化了图形界面。
计算机图形学区域填充
导致部分像素位于多边形之外，从而不可
中大于交点Y值的个数是0，1，2，来决定取0，1，2个交点。
相邻的两梯形必有一个在多边形P内，另一个在P外。
以上性质被称为区域的连贯性
奇点是极值点时，该点按两个交点计算，否则按一个交点计算。
P=(P0P1P2P3P4P5P6P0)；
1）如边分类表ET中的第y类元素非空，则将属于该类的所有边从ET 中取出并插入边的活化链表中，AEL中的各边按照x值（当x值相等时，按Δx值）递增方向排序。
2）若相对于当前扫描线，边的活化链表AEL非空，则将AEL中的边两两依次配对，即1，2边为一对，3，4边为一对，依次类推。
每一对边与当前扫描线的交点所构成的区段位于多边形内，依次对这些区段上的点（象素）按多边形属性着色。
3）将边的活化链表AEL中满足y=y
的边删去。
max
4）将边的活化链表AEL剩下的每一条边的x域累加Δx，即x:=x+Δx。
5）将当前的扫描线的纵坐标值y累加1，即y:=y+1。
计算机图形学
颜色；= 0;i <= m; i++)。
矩形区域填充算法
矩形区域填充算法
矩形区域填充算法是一种常用的计算机图形学算法。
该算法的主要作用是将一定区域内的颜色进行填充。
在计算机可视化技术中，该算法是非常重要的，特别是在制作游戏、动画和画图软件中。
该算法的实现过程较为简单，其主要原理是通过输入一个种子点，向四周扩展填充其颜色。
整个填充过程可以理解为一个递归的过程，即将当前点的颜色变更、修改并递归到四周的点。
这种递归填充算法能够保证填充区域的完整性和准确性。
矩形区域填充算法的实现通常涉及以下步骤：
（1）输入起始点：首先需要用户输入一个起始点，作为要填充的区域的起点。
该点往往是具有特殊颜色的点。
（2）确定填充颜色：用户需要指定要填充的颜色。
该颜色将被用于填充区域。
（3）填充区域：从起始点开始，进行递归填充操作。
如果当前点的颜色与起始点的颜色相同，则修改当前点的颜色为要填充的颜色，递归到当前点的四周点进行相同的操作；否则，递归结束。
（4）显示填充结果：填充完毕后，显示填充的结果图形。
在实际应用中，该算法可能存在一些问题，如内存消耗和填充速度等方面的问题。
此外，一些具有不规则形状或复杂边界的区域可能需要采用其他算法或技术来完成填充。
总之，矩形区域填充算法是一种常用的计算机图形学算法，其实现过程简单，应用广泛。
在可视化技术的应用中扮演着重要角色，可以用于制作游戏、动画和画图软件等。
但在应用时，需考虑应用环境和效率等方面的问题，选择适合的算法或技术完成填充。
计算机图形学四连通区域种子填充算法实验
计算机图形学四连通区域种子填充算法实验《计算机图形学实验》报告任课教师：钱文华2016年春季学期实验:四连通区域种子填充算法实验时间：2016年12月8日实验地点：信息学院2204实验目的：掌握种子填充算法的原理，并会用种子填充算法和opengl并结合使用c++语言编写程序绘制多边形。
实验原理：种子填充算法又称为边界填充算法。
其基本思想是：从多边形区域的一个内点开始，由内向外用给定的颜色画点直到边界为止。
如果边界是以一种颜色指定的，则种子填充算法可逐个像素地处理直到遇到边界颜色为止。
内点的检测条件：if(interiorColor!=borderColor&&interiorColor!=fillColor)。
种子填充算法常用四连通域和八连通域技术进行填充操作。
从区域内任意一点出发，通过上、下、左、右四个方向到达区域内的任意像素。
用这种方法填充的区域就称为四连通域；这种填充方法称为四向连通算法。
从区域内任意一点出发，通过上、下、左、右、左上、左下、右上和右下八个方向到达区域内的任意像素。
用这种方法填充的区域就称为八连通域；这种填充方法称为八向连通算法。
一般来说，八向连通算法可以填充四向连通区域，而四向连通算法有时不能填充八向连通区域。
四向连通填充算法：a）种子像素压入栈中；b）如果栈为空，则转e)；否则转c)；c）弹出一个像素，并将该像素置成填充色；并判断该像素相邻的四连通像素是否为边界色或已经置成多边形的填充色，若不是，则将该像素压入栈；d）转b）；e）结束。
四连通填充算法利用到了递归的思想。
本实验只包括四连通填充算法程序代码：#include<glut.h>#include<stdlib.h>#include<math.h>#include<windows.h>void init(void) { glClearColor(1.0,1.0,1.0,0.0);glMatrixMode(GL_PROJECTION);gluOrtho2D(0.0,300.0,0.0,300.0);}void setPixel(int x,int y,long fillColor){ glColor3f(fillColor<<16,fillColor<<8,fillColor); glBegin(GL_POINTS);glVertex2i(x,y); glEnd();}void boundaryFill4(int x,int y,long fillColor,long borderColor){ unsigned char params[3];long interiorColor;glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,params); interiorColor=RGB(params[0],params[1],params[2]);if(interiorColor!=borderColor&&interiorColor!=fillColor){ setPixel(x,y,fillColor);boundaryFill4(x+1,y,fillColor,borderColor);boundaryFill4(x-1,y,fillColor,borderColor);boundaryFill4(x,y+1,fillColor,borderColor);boundaryFill4(x,y-1,fillColor,borderColor);} }void lineSegment(void) { long borderColor=RGB(255,0,0); long fillColor=RGB(0,0,255);glClear(GL_COLOR_BUFFER_BIT); glColor3f(255,0,0); glBegin(GL_LINE_LOOP);glVertex2i(0,40);glVertex2i(20,0);glVertex2i(60,0);glVertex2i(80,40);glVertex2i(60,80);glVertex2i(20,80);glEnd();boundaryFill4(60,60,fillColor,borderColor);glFlush(); }void main(int argc,char** argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowPosition(150,100);glutInitWindowSize(300,300);glutCreateWindow("种子填充");init();glutDisplayFunc(lineSegment);glutMainLoop();}上实验课时机房的实验结果：后来的实验结果:glVertex2i(0,40); glVertex2i(20,0);glVertex2i(60,0);glVertex2i(80,40);glVertex2i(60,80);glVertex2i(20,80);glEnd();boundaryFill4(60,60,fillColor,borderColor); 以上这段程序改成如下glVertex2i(90, 40);glVertex2i(120, 100);glVertex2i(90, 160);glVertex2i(60, 160);glVertex2i(60, 40);glEnd();boundaryFill4(70,60,fillColor,borderColor); 改变参数后：再把glVertex2i(90, 40);glVertex2i(120, 100);glVertex2i(90, 160);glVertex2i(60, 160);glVertex2i(60, 40);glEnd();boundaryFill4(70,60,fillColor,borderColor); 改成glVertex2i(100, 100);glVertex2i(200, 100);glVertex2i(150, 150);//glVertex2i(60, 160);//glVertex2i(60, 40);glEnd();boundaryFill4(150,120,fillColor,borderColor);后的结果如下图：实验总结：通过多组数据的测试，知道了上面算法的正确，普适性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
程。
.
2
4）区域的建立（定义）方式： ①内定区域：在所定义的区域内所有的像素具有相 同的属性（如颜色等）。 （内部定义方式） ②边界定义区域：以区域的内外属性来划分，区域 内的像素和边界上的像素可具有不同的属性。 （外界定义方式）
.
3
5）连通性：分为四向连通和八向连通。
①四连通：各像素在水平、垂直的上、下、左、 右四个方向上是连通的。
准备工作： typedef struct { int x,y;} seed; typedef struct { seed s[6400];int top;} seedstack;
.
10
VC++程序实现
.
11Βιβλιοθήκη 以直接利用函数的递归调用来实现.设（x,y）为内点表示的4连通区域内的一点， oldcolor为区域的原色，要将整个区域填充为新 的颜色newcolor。
出发，沿当前扫描线向左、右两个方向填充，直 到非内部。分别标记区段的左、右端点坐标为xl 和xr。 (4)并确定新的种子点：在区间[xl，xr]中检查与 当前扫描线y上、下相邻的两条扫描线上的象素。 若存在非边界、未填充的象素，则把每一区间的 最右象素作为种子点压入堆栈，返回第（2）步。
{ int color= Getpixel(x,y); if(color!=newcolor && color!=boundarycolor) { drawpixel(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); }
效率低的原因是没有考虑各象素之间的联系，孤立地考
察象素与区域的关系，使得几十万甚至几百万个象素都要一一 判别，每次判别又要多次求交点，需要做大量的乘除运算，花 费很多时间。
.
6
如何判断点在多边形的内或外？ （包含性检查的方法）
1）射线法； 2）累计角度法； 3）编码法； 4）……..
这些内容在本书第八章几何造型中有 专门介绍。
FloodFill4(x,y-1,oldcolor,newcolor);
FloodFill4(x-1,y,oldcolor,newcolor);
FloodFill4(x+1,y,oldcolor,newcolor);
}
}
.
12
边界表示的4连通区域的递归填充算法:
void BoundaryFill4(int x,int y,int boundarycolor,int newcolor)
上述算法对于每一个待填充区段，只需压栈一次；而在递
归算法中，每个象素都需要压栈。因此，扫描线填充算法提
高了区域填充的效率。
.
14
扫描线区域填充算法 可由下列四个步骤实现：
(1)初始化：堆栈置空。将种子点（x，y）入栈。 (2)出栈：若栈空则结束。否则取栈顶元素（x，
y），以y作为当前扫描线。 (3)填充并确定种子点所在区段：从种子点（x，y）
D
False when x D
.
5
取矩形R(x1≤x≤x2,y1≤y≤y2)，使R包围D，
则逐点判断填充算法如下：
for(y=y1;y<=y2;y++) for(x=x1;x<=x2;x++) if(inside(D,x,y)) drawpixel(x,y,color);
上述算法原理简单、实用，但效率低；
1）深度递归的种子填充算法
2）扫描线种子填充算法
.
9
1）深度递归的种子填充算法(漫水法）
从已知种子点出发，每填充一点，在其周围寻找 新种子点，重复进行，直到再无未填充的点为止。
针对内点表示的4连通区域的递归填充具体步骤: 1.种子入栈. 2.当栈非空时,进行下面的操作,否则结束. 3.栈顶元素出栈,如果是未填充的内部点,则将其填充. 继续考察与其连通的点,若是未填充的内部点,则该点 入栈.返回2.
} 对于内点表示和边界表示的8连通区域的填充，只要
将上述相应代码中递归填充相邻的4个象素增加到递归填 充8个象素即可。
.
13
2）扫描线种子填充算法
▪ 种子填充的递归算法原理和程序都很简单，但由 于多次递归，费时、费内存，效率不高。为了减 少递归次数，提高效率可以采用采用扫描线算法。
▪ 算法的基本过程如下：当给定种子点(x,y)时，首 先填充种子点所在扫描线上的位于给定区域的一 个区段，然后确定与这一区段相连通的上、下两 条扫描线上位于给定区域内的区段，确定新种子 点，并依次保存下来。反复这个过程，直到填充 结束。
内点表示的4连通区域的递归填充算法:
void FloodFill4(int x,int y,int oldcolor,int newcolor)
{ if(getpixel(x,y)==oldcolor)
{ drawpixel(x,y,newcolor);
FloodFill4(x,y+1,oldcolor,newcolor);
第四讲 区域填充
1. 有关概念 2. 逐点判断填充算法 3. 种子填充算法 4. 区域填充图案 5. 扫描线多边形填充算法 6. 边填充算法
.
1
1. 有关概念
1) 区域：一组相邻而且又相连的像素，而且具有 相同属性的封闭区域。 2）种类：①单域 ②复合域
3) 区域填充：以某种属性对整个区域进行设置的过
.
7
这里以射线法为例进行说明：
过被检测点任作一条射线,求其与边界的交点, 若交点数为偶数,则该点在边界之外,否则在边界 之内。
当射线经过顶点时,可通过”左开右闭”,或” 上开下闭”进行处理。
P
P
.
8
3.种子填充算法
种子填充算法假设在多边形内有一象素已知，由此出 发利用连通性找到区域内的所有象素，并进行填充。
②八连通：各像素在上、下、左、右以及四个对 角线方向都是连通的。
.
4
2.逐点判断填充算法
区域填充的基本(初级)方法:逐点判断填充算法
➢ 逐点判断绘图窗口内的每一个像素； ➢ 若在区域的内部：用指定的属性设置该点； ➢ 否则不予处理；
设有如下函数：
True when x D
Inside(D,x,y)=