扫描线填充算法画多边形
扫描线填充算法讲解
扫描线算法（S c a n-L i n e F i l l i n g）扫描线算法适合对矢量图形进行区域填充，只需要直到多边形区域的几何位置，不需要指定种子点，适合计算机自动进行图形处理的场合使用，比如电脑游戏和三维CAD软件的渲染等等。
对矢量多边形区域填充，算法核心还是求交。
《计算几何与图形学有关的几种常用算法》一文给出了判断点与多边形关系的算法――扫描交点的奇偶数判断算法，利用此算法可以判断一个点是否在多边形内，也就是是否需要填充，但是实际工程中使用的填充算法都是只使用求交的思想，并不直接使用这种求交算法。
究其原因，除了算法效率问题之外，还存在一个光栅图形设备和矢量之间的转换问题。
比如某个点位于非常靠近边界的临界位置，用矢量算法判断这个点应该是在多边形内，但是光栅化后，这个点在光栅图形设备上看就有可能是在多边形外边（矢量点没有大小概念，光栅图形设备的点有大小概念），因此，适用于矢量图形的填充算法必须适应光栅图形设备。
2.1扫描线算法的基本思想扫描线填充算法的基本思想是：用水平扫描线从上到下（或从下到上）扫描由多条首尾相连的线段构成的多边形，每根扫描线与多边形的某些边产生一系列交点。
将这些交点按照x坐标排序，将排序后的点两两成对，作为线段的两个端点，以所填的颜色画水平直线。
多边形被扫描完毕后，颜色填充也就完成了。
扫描线填充算法也可以归纳为以下4个步骤：（1）求交，计算扫描线与多边形的交点（2）交点排序，对第2步得到的交点按照x值从小到大进行排序；（3）颜色填充，对排序后的交点两两组成一个水平线段，以画线段的方式进行颜色填充；（4）是否完成多边形扫描？如果是就结束算法，如果不是就改变扫描线，然后转第1步继续处理；整个算法的关键是第1步，需要用尽量少的计算量求出交点，还要考虑交点是线段端点的特殊情况，最后，交点的步进计算最好是整数，便于光栅设备输出显示。
对于每一条扫描线，如果每次都按照正常的线段求交算法进行计算，则计算量大，而且效率底下，如图（6）所示：图（6）多边形与扫描线示意图观察多边形与扫描线的交点情况，可以得到以下两个特点：（1）每次只有相关的几条边可能与扫描线有交点，不必对所有的边进行求交计算；（2）相邻的扫描线与同一直线段的交点存在步进关系，这个关系与直线段所在直线的斜率有关；第一个特点是显而易见的，为了减少计算量，扫描线算法需要维护一张由“活动边”组成的表，称为“活动边表（AET）”。
广工数媒计算机图形学之5基本图形生成算法-多边形扫描转换及区域填充
计算机图形学基础：基本图形生成算法——多边形扫描转换及区域填充 多边形扫描转换——x-扫描线算法 x-扫描线算法填充多边形基本思路：
扫描线与x轴平行。按照扫描顺序，计算每一条扫描线与多边 形的相交区间，用指定颜色显示区间内的像素。区间的端点 可以通过计算扫描线与多边形边界线的交点获得。 x-扫描线算法可以填充凸、凹多边形，也可填充中间有空的 多边形。
广东工业大学机电学院图学与数字媒体工程系
计算机图形学基础：基本图形生成算法——多边形扫描转换及区域填充
多边形扫描转换——x-扫描线算法
x-扫描线算法涉及的问题： 一、扫描线与多边形边界交点的 有效性判别； 扫描线y=5与AB边有无效交点k， 在做求交运算之前，判断该扫 描线的y坐标不在点A和点B的y 坐标之间，不做求交运算。
广东工业大学机电学院图学与数字媒体工程系
计算机图形学基础：基本图形生成算法——多边形扫描转换及区域填充
区域填充——边界填充算法
栈结构实现4-连通边界填充算法步骤： （1）种子像素入栈； （2）栈顶象素出栈； （3）将出栈象素置成填充色； （4）检查出栈象素的4-邻接点，若其中某个象素点不是边 界色且未置成多边形色，则把该象素入栈。 （5）检查栈是否为空，若非空，则执行步骤（2），若为 空，则结束。 4-连通边界填充.SWF
广东工业大学机电学院图学与数字媒体工程系
计算机图形学基础：基本图形生成算法——多边形扫描转换及区域填充 填充算法——边缘填充算法
“边缘填充算法的过程.SWF”演示了边缘填充算法的实现过 程。 该算法的优点是简单，缺点是对于复杂图形，每一像素可 能要访问多次，效率降低。
广东工业大学机电学院图学与数字媒体工程系
扫描线多边形填充算法
扫描线多边形填充算法扫描线多边形填充算法（Scanline Polygon Fill Algorithm）是一种计算机图形学中广泛使用的算法，用于将一个封闭的多边形形状涂色填充。
它通过扫描线的方式，从上到下将多边形内的像素按照预设的填充颜色来进行填充。
本文将详细介绍扫描线多边形填充算法的原理、流程和实现细节。
1.算法原理：扫描线多边形填充算法基于扫描线的思想，在水平方向上扫描每一行像素，并检测多边形边界与扫描线的交点。
通过将扫描线从上到下扫过整个多边形，对于每一行像素，找出与多边形边界交点的水平线段，然后根据填充颜色将像素点进行填充。
2.算法流程：-找出多边形的最小和最大Y坐标，确定扫描线的范围。
-从最小Y坐标开始，到最大Y坐标结束，逐行进行扫描。
-对于每一行，找出与多边形边界交点的水平线段。
-根据填充颜色，为每个水平线段上的像素点进行填充。
3.算法实现：-首先，需要根据给定的多边形描述边界的顶点坐标，计算出每条边的斜率、最小和最大Y值以及每条边的X坐标交点。
-然后，对于每一扫描线，找出与多边形边界交点的水平线段，即找出交点的X坐标范围。
-最后，根据填充颜色，将该范围内的像素点进行填充。
4.算法优化：- 针对复杂多边形，可以使用活性边表（AET，Active Edge Table）来管理边界信息，加快查找交点的速度。
-可以使用桶排序来排序边界事件点，提高扫描速度。
-根据多边形边的特征，对算法进行优化，减少不必要的计算和内存消耗。
5.算法应用：-扫描线多边形填充算法广泛应用于计算机图形学中的图形渲染、图像处理等领域。
-在游戏开发、CAD绘图、虚拟现实等应用中，扫描线多边形填充算法被用于快速绘制和渲染复杂多边形。
总结：扫描线多边形填充算法是一种经典的计算机图形学算法，通过扫描线的方式对多边形进行填充。
它可以高效地处理各种形状的多边形，包括凸多边形和凹多边形。
算法虽然简单，但在实际应用中具有广泛的用途。
实验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上、下相邻的两条扫描线上的象素。
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;}```四、总结通过扫描线填充算法，我们可以实现对多边形区域的填充，从而提升图形的表现效果。
图形学实验报告四 多边形填充算法
扫描线种子填充：
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） 。
扫描线多边形填充算法例题
扫描线多边形填充算法例题扫描线多边形填充算法是一种常用的计算机图形学算法，用于对多边形进行填充。
下面我将以一个例题来说明该算法的步骤和原理。
假设有一个凸多边形，顶点坐标分别为A(2, 4)，B(6, 6)，C(8, 4)，D(6, 2)，E(4, 2)。
现在我们要使用扫描线多边形填充算法对该多边形进行填充。
步骤如下：1. 首先，确定扫描线的范围。
扫描线的范围由多边形的最高点和最低点决定，即在本例中扫描线的范围为y=2到y=6。
2. 从最高点开始，逐行进行扫描线填充。
在本例中，从y=6开始扫描。
3. 对于每一条扫描线，确定与多边形交点的x坐标。
在本例中，对于y=6，与多边形交点的x坐标为x=2和x=6。
4. 将交点按照升序排列，得到交点序列。
在本例中，交点序列为(2, 6)，(6, 6)。
5. 根据交点序列，对每一对交点进行填充。
在本例中，对于(2,6)和(6, 6)，在扫描线y=6上的像素点进行填充。
6. 继续向下扫描，重复步骤3至步骤5，直到扫描到最低点y=2。
通过以上步骤，我们可以完成对该凸多边形的填充。
需要注意的是，如果多边形是凹多边形，那么在步骤3中，可能会出现多个交点。
此时，需要根据扫描线与多边形的交点个数的奇偶性来确定填充的规则。
扫描线多边形填充算法的原理是通过扫描线与多边形的交点来确定填充的区域。
该算法的优点是简单易懂，适用于凸多边形和简单的凹多边形。
然而，对于复杂的凹多边形，该算法可能会遇到一些困难。
希望以上回答能够满足你的要求。
如果还有其他问题，请随时提出。
python扫描线填充算法详解
python扫描线填充算法详解本⽂实例为⼤家分享了python扫描线填充算法，供⼤家参考，具体内容如下介绍1.⽤⽔平扫描线从上到下扫描由点线段构成的多段构成的多边形。
2.每根扫描线与多边形各边产⽣⼀系列交点。
将这些交点按照x坐标进⾏分类，将分类后的交点成对取出，作为两个端点，以所填的⾊彩画⽔平直线。
3.多边形被扫描完毕后，填⾊也就完成。
数据结构活性边表：新边表：代码（使⽤数组）import numpy as npfrom PIL import Imagefrom PIL import ImageDrawfrom PIL import ImageFontarray = np.ndarray((660, 660, 3), np.uint8)array[:, :, 0] = 255array[:, :, 1] = 255array[:, :, 2] = 255for i in range(0,660,1):array[i,330]=(0,0,0)for j in range(0,660,1):array[330,j]=(0,0,0)def creat_Net(point, row, y_min,y_max ):Net = [([ ] * y_max ) for i in range(y_max )]point_count = point.shape[0]for j in range(0, point_count):x = np.zeros(10)first = int(min(point[(j+1)%point_count][1] , point[j][1]))x[1] = 1/((point[(j+1)%point_count][1]-point[j][1])/(point[(j+1)%point_count][0]-point[j][0])) # x 的增量 x[2] = max(point[(j+1)%point_count][1] , point[j][1])if(point[(j+1)%point_count][1] < point[j][1]):x[0] = point[(j+1)%point_count][0]else:x[0] = point[j][0]Net[first].append(x)return Netdef draw_line(i,x ,y ):for j in range(int(x),int(y)+1):array[330-i,j+330]=(20,20,20)def polygon_fill(point):y_min = np.min(point[:,1])y_max = np.max(point[:,1])Net = creat_Net(point, y_max - y_min + 1, y_min, y_max)x_sort = [] * 3for i in range(y_min, y_max):x = Net[i]if(len(x) != 0):for k in x :x_sort.append(k)x_image = [] * 3for cell in x_sort:x_image.append(cell[0])x_image.sort()if(len(x_image) >= 3 and x_image[0]==x_image[1] and x_image[2]>x_image[1]):x_image[1] = x_image[2]draw_line(i, x_image[0], x_image[1])linshi = [] * 3for cell in x_sort:if cell[2] > i:cell[0] += cell[1]linshi.append(cell)x_sort = linshi[:]x_image = [] * 3for cell in x_sort:x_image.append(cell[0])x_image.sort()draw_line(i, x_image[0],x_image[1])def main():point = [[55,40], [100,80], [100,160],[55,180], [10,160], [10,80]]point = np.array(point)polygon_fill( point )image = Image.fromarray(array)image.save('saomao.jpg')image.show()if __name__ == "__main__":main()实例：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
扫描线填充算法讲解
扫描线算法（Scan-Line F illing）扫描线算法适合对矢量图形进行区域填充，只需要直到多边形区域的几何位置，不需要指定种子点，适合计算机自动进行图形处理的场合使用，比如电脑游戏和三维CAD软件的渲染等等。
对矢量多边形区域填充，算法核心还是求交。
《计算几何与图形学有关的几种常用算法》一文给出了判断点与多边形关系的算法――扫描交点的奇偶数判断算法，利用此算法可以判断一个点是否在多边形内，也就是是否需要填充，但是实际工程中使用的填充算法都是只使用求交的思想，并不直接使用这种求交算法。
究其原因，除了算法效率问题之外，还存在一个光栅图形设备和矢量之间的转换问题。
比如某个点位于非常靠近边界的临界位置，用矢量算法判断这个点应该是在多边形内，但是光栅化后，这个点在光栅图形设备上看就有可能是在多边形外边（矢量点没有大小概念，光栅图形设备的点有大小概念），因此，适用于矢量图形的填充算法必须适应光栅图形设备。
扫描线算法的基本思想扫描线填充算法的基本思想是：用水平扫描线从上到下（或从下到上）扫描由多条首尾相连的线段构成的多边形，每根扫描线与多边形的某些边产生一系列交点。
将这些交点按照x坐标排序，将排序后的点两两成对，作为线段的两个端点，以所填的颜色画水平直线。
多边形被扫描完毕后，颜色填充也就完成了。
扫描线填充算法也可以归纳为以下4个步骤：（1）求交，计算扫描线与多边形的交点（2）交点排序，对第2步得到的交点按照x值从小到大进行排序；（3）颜色填充，对排序后的交点两两组成一个水平线段，以画线段的方式进行颜色填充；（4）是否完成多边形扫描？如果是就结束算法，如果不是就改变扫描线，然后转第1步继续处理；整个算法的关键是第1步，需要用尽量少的计算量求出交点，还要考虑交点是线段端点的特殊情况，最后，交点的步进计算最好是整数，便于光栅设备输出显示。
对于每一条扫描线，如果每次都按照正常的线段求交算法进行计算，则计算量大，而且效率底下，如图（6）所示：图（6）多边形与扫描线示意图观察多边形与扫描线的交点情况，可以得到以下两个特点：（1）每次只有相关的几条边可能与扫描线有交点，不必对所有的边进行求交计算；（2）相邻的扫描线与同一直线段的交点存在步进关系，这个关系与直线段所在直线的斜率有关；第一个特点是显而易见的，为了减少计算量，扫描线算法需要维护一张由“活动边”组成的表，称为“活动边表（AET）”。
计算机图形学5多边形扫描转换和区域填充
多边形分为凸多边形、凹多边形、含内环的多边 形等：
（1）凸多边形 任意两顶点间的连线均在多边形内。
（2）凹多边形
任意两顶点间的连线有不在多边形内的部分。
凸多边形
凹多边形
含内环的多边形
有关概念
1) 区域：一组相邻而且又相连的像素，而且具有 相同属性的封闭区域。 2）种类：①单域 ②复合域
3) 区域填充：以某种属性对整个区域进行设置的过 程。
另外使用增量法计算时，我们需要知道一条边何时不再与下 一条扫描线相交，以便及时把它从有效边表中删除出去，避免 下一步进行无谓的计算。 综上所述，有效边表AET的每个结点存放对应边的有关信息 如下：
x
△x
ymax
next
其中x为当前扫描线与边的交点，ymax是边所在的最大扫描 线值，通过它可以知道何时才能“抛弃”该边，△x表示从 当前扫描线到下一条扫描线之间的x增量即斜率的倒数。 next为指向下一条边的指针
P6(2,7)
P4(11,8) F G B P5(5,5) P3(11,3) C D
A
1
0 1
P1(2,2) P2(5,1) 2 3 4 5 6 7
E
8
9
10
11
一个多边形与若干扫描线
7
把多边形所有 的边全部填成这 样的结构，插到 这个指针数组里 面来。
计算机图形学多边形填充算法
计算机图形学多边形填充算法计算机图形学中的多边形填充算法是指将给定的多边形区域进行颜色填充，以使其完全填充的过程。
在图形学中，多边形是由一系列连续的线段组成的封闭图形。
填充算法可用于渲染图形、绘制图像等应用场景。
多边形填充算法的目标是根据设计要求和用户输入，给定一个多边形的边界，将多边形的内部区域进行颜色填充。
填充算法的实现涉及到图像的扫描线和区域判定，以确定填充的区域和颜色。
在本文中，我们将介绍常见的多边形填充算法，包括扫描线填充算法、边界填充算法等，并讨论它们的优缺点和适用场景。
扫描线填充算法扫描线填充算法是一种常见且简单的多边形填充算法。
该算法将多边形划分为一条条水平扫描线，并通过判断扫描线与多边形边界的交点，确定填充区域。
具体步骤如下：1.找到多边形边界的最上端和最下端。
2.从最上端开始，逐行进行扫描。
3.在每一行，通过求解扫描线与多边形边界的交点，确定填充区域。
4.对于每个填充区域，根据设计要求进行颜色填充。
扫描线填充算法的优点是简单易懂、实现较为容易。
然而，该算法存在一些缺点。
首先，对于具有复杂形状的多边形，扫描线填充算法可能会产生很多不必要的计算，导致效率降低。
其次，该算法需要处理多边形边界相交的情况，可能出现像素重复填充的问题，需要进行额外的处理。
边界填充算法边界填充算法是另一种常见的多边形填充算法。
与扫描线填充算法不同的是，边界填充算法是从多边形的边界出发，向内部填充颜色。
该算法的基本思想是对多边形的每条边进行填充，最终得到多边形的填充区域。
具体步骤如下：1.遍历多边形的每条边，保存每条边的起点和终点。
2.对于每个边，根据设计要求进行颜色填充。
3.对于多边形内部的区域，根据边界的颜色填充。
边界填充算法的优点是适用于复杂形状的多边形，无需处理边界相交的问题。
然而，该算法的实现相对复杂，需要处理边界的细化以及边缘像素重复填充的问题。
适用场景不同的多边形填充算法在不同场景下有不同的适用性。
《计算机图形学教学资料》第6讲-多边形填充
05
多边形填充的未来发展
新型填充算法的研究
基于物理的填充算法
模拟真实世界的物理现象，如流体动 力学、表面张力等，以实现更加自然 的多边形填充效果。
智能优化算法
利用遗传算法、模拟退火等智能优化 技术，自动寻找最优的填充方案，提 高填充效率和准确性。
人工智能在多边形填充中的应用
学习型填充算法
通过机器学习技术，让算法自动学习优秀的人类设计师的填充风格，实现更加 艺术化的多边形填充效果。
优化内存管理
合理分配和释放内存，避免频繁的内 存分配和释放操作，可以提高多边形 填充的性能。
04
多边形填充的实践案例
使用OpenGL实现多边形填充
总结词
使用OpenGL进行多边形填充是一种常见的图形编程实践，它涉及到顶点数据、着色器程序和渲染流程的配置。
详细描述
首先，你需要定义多边形的顶点坐标，并将其存储在一个顶点数组中。然后，你需要编写一个OpenGL着色器程 序，用于处理顶点数据并进行渲染。在渲染过程中，你需要设置正确的顶点属性、着色器程序和渲染流程，以确 保多边形能够正确填充颜色。
填充区域
填充区域指的是多边形的内部区域，即所有被填充 的像素组成的区域。
填充颜色
填充颜色是指用于填充多边形内部的颜色，可以根 据需要选择不同的颜色。
填充算法的分类
扫描线填充算法
扫描线填充算法是一种基于扫 描线的填充算法，通过从左到 右、从上到下扫描多边形的内 部像素，对落在多边形内部的 扫描线进行上色。
在游戏开发中应用多边形填充
总结词
在游戏开发中应用多边形填充技术可以创建 更加逼真的游戏场景和角色模型。
详细描述
游戏开发者通常使用游戏引擎（如Unity或 Unreal Engine）来创建游戏场景和角色模 型。在这些引擎中，多边形填充技术被广泛 应用，以实现更加逼真的场景和角色模型。 通过合理配置顶点数据、着色器程序和渲染 流程，游戏开发者可以创建出令人惊叹的游 戏视觉效果。
扫描线算法
一、扫描线算法基本思想按扫描线顺序，计算扫描线与多边形的相交区间，再用要求的颜色显示这些区间的象素，即完成填充工作。
对于一条扫描线填充过程可以分为四个步骤：(1) 求交：计算扫描线与多边形各边的交点(2) 排序：把所有交点按x 坐标递增顺序来排序(3) 配对：确定扫描线与多边形的相交区间，第一个与第二个，第三个与第四个等等，每对交点代表扫描线与多边形的一个相交区间(4) 填充：显示相交区间的象素存在问题1：当扫描线与多边形顶点相交时，交点的取舍问题解决方法：当扫描线与多边形的顶点相交时，若共享顶点的两条边分别落在扫描线的两边，交点只算一个；若共享顶点的两条边在扫描线的同一边，这时交点作为零个或两个，取决于该点是多边形的局部最高点或局部最低点。
具体实现：只需检查顶点的两条边的另外两个端点的y值，按这两个y值中大于交点y 值的个数是0，1，2 来决定。
存在问题2：多边形边界上象素的取舍解决方法：规定右/上边界的象素不予填充；左/下边界的象素予以填充。
具体实现：对扫描线与多边形的相交区间取左闭右开。
算法的实现求交一条扫描线往往只和少数几条边相交。
与当前扫描线相交的边称为活性边，把它们按与扫描线交点x 坐标递增的顺序存入一个链表中，称为活性边表( AET, Active Edge Table)由边的连贯性（当某条边与当前扫描线相交时，它很可能也与下一条扫描线相交）和扫描线的连贯性（当前扫描线与各边的交点顺序，与下一条扫描线与各边的交点顺序很可能相同或类似），只需对当前扫描线的活性边表作更新，即可得到下一条扫描线的活性边表。
计算下一条扫描线与边的交点设直线方程：a x + b y + c = 0，当前交点坐标：(xi , yi)，下一交点坐标：(xi+1,yi+1)xi+1=((-b yi+1)-c)/a = ((-b yi+1)-c)/a = xi-b/a 增量为-b/a故在活性边表中需要存放的信息： x ：当前扫描线与边的交点△x ＝ -b /a ：从当前扫描线到下一条扫描线之间的 x 增量 ymax ：该边所交的最高扫描线P PA BCD△x y maxP P P P P PFGP 4P 5P 3P 4上图为扫描线 6 的活性边表 左图为扫描线 7 的活性边表 活性边表的更新为方便活性边表的更新，建立另一个表。
(计算机图形学)多边形区域扫描线填充或种子填充
实验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);}实验结果：。
多边形的填充——扫描线算法(原理)
多边形的填充——扫描线算法(原理)2007年10月05日星期五 11:52多边形在计算机中有两种表示：点阵表示和顶点表示。
顶点表示是用多边形的顶点的序列来描述多边形，该表示几何意义强、占内存少，但它不能直观地说明哪些像素在多边形内。
点阵表示是用位于多边形内的象素的集合来刻划多边形，该方法虽然没有多边形的几何信息，但具有面着色所需要的图像表示形式。
多边形填充就是把多边形的顶点表示转换为点阵表示，即从多边形的给定边界出发，求出位于其内部的各个像素，并将帧缓冲器内的各个对应元素设置为相应的灰度或颜色。
多边形填充最常用的方法就是扫描线算法。
下面分两篇文章介绍这种算法的原理和具体实现。
这里所介绍的算法只是针对非自交多边形，这些多边形可以是凸的、凹的或者带有空洞的。
所谓扫描线算法就是找到多边形的最小y值和最大y值，然后用这个范围内的每一条水平线与多边形相交，求得交点，再绘制线段。
所以我们只需要对一条水平线进行分析就可以。
很显然，一条扫描线和多边形有偶数个交点，将这些交点按照x值从小到大排列，然后取第1、2个绘制，第3、4个绘制......直到所有交点都被取完。
所以，对于一条扫描线，我们需要做的工作可以分为三个步骤：1)求出扫描线与多边形边的交点 2)将交点按照x升序排列 3)将排好序的交点两两配对，然后绘制相应线段。
这三个步骤中，后两个步骤很简单，没有特别的内容需要介绍。
但是第一个步骤比较麻烦。
这里有几个问题需要解决。
一是当扫描线与顶点相交时，交点的取舍。
当与那个顶点关联的边在扫描线同侧时，交点自然算两次，当与那个顶点关联的边在扫描线两侧时，交点只能算一次。
我们使用“下闭上开”的办法。
二是多边形边界上的像素取舍，我们采用“左闭右开”的办法。
三是如何减少计算量。
在绘制直线时，有一种DDA算法，它是利用(x,y)直接求出下一个点位于(x+1,y+m)或者(x+1/m, y+1)。
在这里可以利用这一点。
当已经得到y = e和多边形所有边的交点时，对于下一条扫描线y=e+1，如果没有新边与y=e+1相交，就可以推出y = e+1 和多边形所有边的交点。
多边形扫描线填充算法的概念和步骤
多边形扫描线填充算法的概念和步骤嘿，咱今儿个就来聊聊多边形扫描线填充算法。
你知道不，这就像是给多边形这个大拼图上色一样有趣呢！多边形啊，它可不是个乖乖待着的主儿，有好多边和角呢。
那这扫描线填充算法呢，就是来搞定怎么把这些多边形填满颜色的。
想象一下，有一条线就像个小刷子似的，从这头刷到那头，把多边形的每一块都照顾到。
这就是扫描线啦。
它一格一格地走，每到一个地方，就看看和多边形有啥关系。
那具体步骤呢，咱可得好好说说。
首先得确定这个多边形的边啊，知道它们在哪儿，长啥样。
然后呢，这条扫描线就开始工作啦，它会和多边形的边相交，这就像它们在打招呼呢。
接着，就根据这些交点来算出要填充的区域。
这就好比是知道了要给哪块地播种一样。
然后啊，就开开心心地把颜色填上。
你说这神奇不神奇？就这么一步一步的，一个多边形就被漂亮地填满啦。
这可不比画画简单哦，这里面可有大学问呢。
比如说吧，要是交点算错了，那颜色可就填错地方啦，那就成大花脸啦！所以每一步都得仔细着点呢。
而且啊，这算法就像个小魔法师，能让那些奇奇怪怪形状的多边形都变得漂漂亮亮的。
它能让我们在屏幕上看到各种好看的图形，这可都是它的功劳呀。
你再想想，要是没有这个算法，那我们看到的图形不就干巴巴的，一点都不生动啦。
多边形扫描线填充算法，虽然名字听起来有点拗口，但它真的超级重要呢。
它就像一个默默工作的小工匠，为我们打造出美丽的图形世界。
怎么样，现在对这个多边形扫描线填充算法是不是有点感觉啦？它可不简单哦，是计算机图形学里的一个宝贝呢！以后再看到那些好看的图形，可别忘了背后有它的功劳哟！。
计算机图形学实验1------Y-X扫描线填充
实验一 多边形彩色填充一、实验目的学习并掌握Y-X 扫描线算法掌握基于 Win32、Visual C++环境下MFC 编程绘制图形二、实验原理1. 对任一条扫描线，确定该扫描线与多边形边的交点位置，自左向右存储，并对每对内部交点间的帧缓存填写指定颜色2.算法步骤3.扫描线链表123456784. 边表ET ：初始化时建立全局边表（ET）,包含多边形所有边，按边端点的ymin排序存放。
即：若该边的下端点为ymin，则该边就放在扫描线ymin对应的链表中。
每条扫描线交的多边形的边按其下端点的x坐标增序排列。
5. 活跃边表AET：与当前扫描线相交的边称为活性边，按与扫描线交点x坐标递增的顺序存放在一个链表中，称此链表为活性边表(AET)三、实验关键代码CPolyFill::CPolyFill(){m_pEDGEs = NULL;m_pET = NULL;m_pAET = NULL;MinY = 10000;MaxY = -1;MinX = 10000;MaxX = -1;}CPolyFill::~CPolyFill(){if(m_pEDGEs) delete[] m_pEDGEs;if(m_pET) delete[] m_pET;if(m_pAET) delete[] m_pAET;}// 统计多边形各条边的信息，生成Edge结构。
void CPolyFill::BuildEDGEs(){if(m_pEDGEs){delete[] m_pEDGEs; m_pEDGEs = NULL;}m_pEDGEs = new EDGE[m_PtNum];for(int i = 0; i < m_PtNum-1; i++){if (m_Pts[i].y > m_Pts[i+1].y){m_pEDGEs[i].Up = m_Pts[i];m_pEDGEs[i].Down = m_Pts[i+1];}else{m_pEDGEs[i].Up = m_Pts[i+1];m_pEDGEs[i].Down = m_Pts[i];}m_pEDGEs[i].EG.Ymax = m_pEDGEs[i].Up.y ;m_pEDGEs[i].EG.X = m_pEDGEs[i].Down.x;m_pEDGEs[i].EG.Dx = double((m_pEDGEs[i].Up.x - m_pEDGEs[i].Down.x))/(m_pEDGEs[i].Up.y - m_pEDGEs[i].Down.y);}if (m_Pts[0].y > m_Pts[m_PtNum-1].y){m_pEDGEs[m_PtNum-1].Up = m_Pts[0];m_pEDGEs[m_PtNum-1].Down = m_Pts[m_PtNum-1];}else{m_pEDGEs[m_PtNum-1].Up = m_Pts[m_PtNum-1];m_pEDGEs[m_PtNum-1].Down = m_Pts[0];}m_pEDGEs[m_PtNum-1].EG.Ymax = m_pEDGEs[m_PtNum-1].Up.y ;m_pEDGEs[m_PtNum-1].EG.X = m_pEDGEs[m_PtNum-1].Down.x;m_pEDGEs[m_PtNum-1].EG.Dx = double((m_pEDGEs[m_PtNum-1].Up.x - m_pEDGEs[m_PtNum-1].Down.x))/(m_pEDGEs[m_PtNum-1].Up.y - m_pEDGEs[m_PtNum-1].Down.y);}void CPolyFill::Polygon(CPoint *pts, int cnt){m_Pts = pts;m_PtNum = cnt;BuildEDGEs(); // 计算出每条多边形边的斜率，Ymax, Xmin等。
任意多边形区域的快速填充算法
任意多边形区域的快速填充算法一、前言任意多边形区域的快速填充算法是计算机图形学中的一个重要问题，其应用广泛，例如在计算机游戏、数字地图等领域中都有广泛的应用。
本文将介绍几种常见的任意多边形区域的快速填充算法，包括扫描线算法、边界填充算法、种子填充算法等。
二、扫描线算法扫描线算法是一种基于扫描线原理的填充算法，其基本思想是将区域划分为若干个水平方向上的扫描线，然后在每条扫描线上找到交点，并根据交点进行填充。
具体步骤如下：1. 将多边形顶点按照纵坐标从小到大排序；2. 从最小纵坐标开始，依次向上扫描每条水平方向上的线段；3. 对于每条水平方向上的线段，找到与之相交的多边形边界，并记录下所有交点；4. 根据相邻两个交点之间是否为奇数个来确定是否需要进行填充。
三、边界填充算法边界填充算法也是一种常见的任意多边形区域的快速填充算法，其基本思想是通过递归调用来进行填充。
具体步骤如下：1. 对于每个多边形边界上的像素点，将其标记为“边界点”；2. 从任意一个未填充的内部像素点开始，向四周搜索，如果遇到“边界点”则停止搜索，并将搜索路径上的所有像素点标记为已填充；3. 重复步骤2直到所有内部像素点都被填充。
四、种子填充算法种子填充算法也是一种常见的任意多边形区域的快速填充算法，其基本思想是通过找到一个内部像素点作为“种子”，然后向四周扩散进行填充。
具体步骤如下：1. 随机选择一个内部像素点作为“种子”，并将其标记为已填充；2. 向四周搜索，如果遇到未被标记为已填充的像素，则将其标记为已填充，并加入到待处理列表中；3. 重复步骤2直到待处理列表为空。
五、总结以上介绍了几种常见的任意多边形区域的快速填充算法，每种算法都有其特定的优缺点，选择合适的算法需要根据具体的应用场景进行考虑。
在实际应用中，还需要考虑算法的效率、稳定性、可扩展性等方面的问题。
扫描线多边形填充算法
扫描线多边形填充算法扫描线多边形填充算法是计算机图形学中常用的一种算法。
该算法在计算机图形学中的应用非常广泛，主要用于生成3D模型、游戏场景绘制、平面设计和室内设计等领域。
扫描线多边形填充算法是一种基于扫描线的绘制算法，利用扫描线的方法逐行扫描多边形，根据多边形的边界信息实现多边形的填充效果。
该算法能够处理任意形状的多边形，准确率较高且填充速度较快，广泛被应用于图形处理和计算机图形学领域，成为常用的图形算法之一。
扫描线多边形填充算法的基本思路是利用扫描线的思想，从上到下逐行扫描多边形，记录下所有交点，然后分别对相邻的两个交点进行连线，将扫描线与多边形的交点看做是线段的端点，用线段相交的奇偶性来决定颜色的填充，最后形成连续的填充区域。
扫描线多边形填充算法的实现需要经过以下步骤：1. 对多边形边界进行预处理，将所有边界的交点按照从上到下的顺序排列，如果存在重合的交点则去重。
2. 从上到下遍历扫描线，记录扫描线与多边形边界的交点。
3. 将相邻的两个交点之间的线段按照扫描线的方向进行连线。
4. 判断连线与多边形每条边的交点数目，通过判断奇偶性来确定线段的颜色填充方向，奇数填充，偶数不填充。
5. 当扫描线遍历到最后一行时，多边形的填充工作完成。
扫描线多边形填充算法的优点是填充精度高、处理速度快、容易实现、适用于各种形状的图形等，但也存在一些缺点，例如，不能处理自交和孔洞性多边形，所以需要在实际应用中注意多边形的选择。
总的来说，扫描线多边形填充算法具有重要的应用价值，对于计算机图形学领域中的制图、绘制和渲染方面有着广泛的应用，实现算法的关键在于正确处理多边形的交点和判断线段的奇偶性，只有正确理解这些问题才能够在实践中使用扫描线多边形填充算法进行有效的图形填充处理。
多边形填充算法-有序边表法（扫描线算法）
多边形填充算法-有序边表法（扫描线算法）1.算法的基本思想（扫描线连贯性原理）： 对于⼀个给定的多边形，⽤⼀组⽔平(垂直)的扫描线进⾏扫描，对每⼀条扫描线均可求出与多边形边的交点，这些交点将扫描线分割成落在多边形内部的线段和落在多边形外部的线段；并且⼆者相间排列。
于是，将落在多边形内部的线段上的所有象素点赋以给定的⾊彩值。
算法中不需要检验每⼀个象素点，⽽只考虑与多边形边相交的交点分割后的扫描线段。
2.算法求解：对于每⼀条扫描线的处理：1）求交点：⾸先求出扫描线与多边形各边的交点；2）交点排序：将这些交点按X坐标递增顺序排序；3）交点匹配：即从左到右确定落在多边形内部的那些线段；4）区间填充：填充落在多边形内部的线段。
3.求交点的⽅法最简单的办法：将多边形的所有边放在⼀个表中，在处理每条扫描线时，从表中顺序取出所有的边，分别求这些边与扫描线的交点。
不使⽤该⽅法的原因：将做⼀些⽆益的求交点动作，因为扫描线并不⼀定与多边形的边相交，扫描线只与部分甚⾄较少的边相交；因此，在进⾏扫描线与多边形边求交点时，应只求那些与扫描线相交的边的交点。
确定与扫描线相交的边：⽤边表来确定哪些边是下⼀条扫描线求交计算时应该加⼊运算的。
4.边表（ET）：ET的意义在于为扫描线提供待加⼊的新边信息。
建⽴边的分类表ET(Edge Table)，每个结点结构如下：（Ymax ，ΔX ，X Ymin，）Ymax：边的最⼤Y值；ΔX：从当前扫描线到下⼀条扫描线之间的X增量（dX/ dY)；X Ymin：边的下端点的X坐标；next：指针，指向下⼀条边。
边的分类表可以这样建⽴：先按下端点的纵坐标(y值)对所有边作桶分类，再将同⼀组中的边按下端点X坐标递增的顺序进⾏排序, X坐标还相同的按ΔX递增的顺序进⾏排序。
5.活性边表AET把与当前扫描线相交的边称活化边AEL(Active Edge List) 。
组成的表称为活性表AET，其数据域组成如下：Ymax ：存放边的上端点Y坐标；X ：边与当前扫描线交点的X坐标；ΔX ，next指针：同边表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
扫描线填充算法画多边形
///////////////////////////////////////////////////////////////////// /////////////////////////////
// 功能: 填充多边形
//
// 参数: lpPoints: 指向顶点坐标数组的指针，数组类型为POINT，多边形由它们顺次封闭连接得到
// nCount: 顶点的个数
// nColor: 填充的颜色默认为黑色
// pDC: 设备句柄指针
//
// 返回: 无返回值
//
// 说明: 可以是边相交的多边形
//
///////////////////////////////////////////////////////////////////// /////////////////////////////
void FillPolygon(LPPOINT lpPoints,int nCount, CDC *pDC, int
nColor/*=0*/)
{
// 检查参数合法性
ASSERT_VALID(pDC);
ASSERT(lpPoints);
ASSERT(nCount>2);
ASSERT(nColor>=0);
// 边结构数据类型
typedef struct Edge{
int ymax; // 边的最大y坐标
float x; // 与当前扫描线的交点x坐标
float dx; // 边所在直线斜率的倒数
struct Edge * pNext; // 指向下一条边
}Edge, * LPEdge;
int i=0,j=0,k=0;
int y0=0,y1=0; // 扫描线的最大和最小y坐标
LPEdge pAET=NULL; // 活化边表头指针
LPEdge * pET=NULL; // 边表头指针
pAET=new Edge; // 初始化表头指针，第一个元素不用
pAET->pNext=NULL;
// 获取y方向扫描线边界
y0=y1=lpPoints[0].y;
for(i=1;i<nCount;i++)
{
if(lpPoints[i].y<y0)
y0=lpPoints[i].y;
else if(lpPoints[i].y>y1)
y1=lpPoints[i].y;
}
if(y0>=y1) return;
// 初始化边表，第一个元素不用
pET=new LPEdge[y1-y0+1];
for(i=0;i<=y1-y0;i++)
{
pET[i]= new Edge;
pET[i]->pNext=NULL;
}
for(i=0;i<nCount;i++)
{
j=(i+1)%nCount; // 组成边的下一点
if(lpPoints[i].y != lpPoints[j].y)// 如果该边不是水平的则加入边表{
LPEdge peg; // 指向该边的指针
LPEdge ppeg; // 指向边指针的指针
// 构造边
peg =new Edge;
k=(lpPoints[i].y>lpPoints[j].y)?i:j;
peg->ymax=lpPoints[k].y; // 该边最大y坐标
k=(k==j)?i:j;
peg->x=(float)lpPoints[k].x; // 该边与扫描线焦点x坐标
if(lpPoints[i].y != lpPoints[j].y)
peg->dx=(float)(lpPoints[i].x-lpPoints[j].x)/(lpPoints[i].y-lpPoints[ j].y);// 该边斜率的倒数
peg->pNext=NULL;
// 插入边
ppeg=pET[lpPoints[k].y-y0];
while(ppeg->pNext)
ppeg=ppeg->pNext;
ppeg->pNext=peg;
}// end if
}// end for i
// 扫描
for(i=y0;i<=y1;i++)
{
LPEdge peg0=pET[i-y0]->pNext;
LPEdge peg1=pET[i-y0];
if(peg0)// 有新边加入
{
while(peg1->pNext)
peg1=peg1->pNext;
peg1->pNext=pAET->pNext;
pAET->pNext=peg0;
}
// 按照x递增排序pAET
peg0=pAET;
while(peg0->pNext)
{
LPEdge pegmax=peg0;
LPEdge peg1=peg0;
LPEdge pegi=NULL;
while(peg1->pNext)
if(peg1->pNext->x>pegmax->pNext->x)
pegmax=peg1;
peg1=peg1->pNext;
}
pegi=pegmax->pNext;
pegmax->pNext=pegi->pNext;
pegi->pNext=pAET->pNext;
pAET->pNext=pegi;
if(peg0 == pAET)
peg0=pegi;
}
// 遍历活边表，画线
peg0=pAET;
while(peg0->pNext)
{
if(peg0->pNext->pNext)
{
DrawLine((int)peg0->pNext->x,i,(int)peg0->pNext->pNext->x,i,pDC,nColo r);
peg0=peg0->pNext->pNext;
}
else
break;
}
// 把ymax=i的节点从活边表删除并把每个节点的x值递增dx
peg0=pAET;
while(peg0->pNext)
{
if(peg0->pNext->ymax < i+2)
{
peg1=peg0->pNext;
peg0->pNext=peg0->pNext->pNext; //删除
delete peg1;
continue;
peg0->pNext->x+=peg0->pNext->dx; //把每个节点的x值递增dx peg0=peg0->pNext;
}
}
// 删除边表
for(i=0;i<y1-y0;i++)
if(pET[i])
delete pET[i];
if(pAET)
delete pAET;
if(pET)
delete[] pET;
}。