图形学篇：多边形有效边表填充算法

最新推荐文章于 2024-05-04 21:07:53 发布
最新推荐文章于 2024-05-04 21:07:53 发布
阅读量1.4w 收藏 152
点赞数 38
分类专栏： 计算机图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15020543/article/details/89407057
版权

什么是多边形？

  • 多边形是由折线段组成的封闭图形

多边形的表示方法有哪些？

  • 顶点表示法：使用顶点进行描述，但此时多边形仅仅是一些封闭线段，内部是空的，且不能直接进行填充上色
  • 点阵表示法：使用大量的点进行描述，描述完成之后，得到的就是完整形态的多边形，内部已被填充，可直接针对点来进行上色

多边形的扫描转换就是从顶点表示法转换到点阵表示法的过程。

基础的填充多边形方式：

  • 检查光栅上的每一个像素是否位于多边形内

光栅究竟是什么？

  • 由大量等宽等间距的平行狭缝构成的光学器件称为光栅，这是专业且准确的方法，然而明显不是给人看的（观众：？？？）
  • 光栅是连接帧缓冲和具体的电脑屏幕的桥梁（这是很老的大头显示器上的，现在的液晶显示器不存在光栅，它的成像依靠的是电场，液晶，滤光膜等，所以我们暂且把这里说的的光栅理解为像素）

光栅化究竟是什么？

有效边表填充算法：

  • 基本原理：按照扫描线从小到大的移动顺序，计算当前扫描线与有效边的交点，然后把这些交点按x的值递增顺序进行排序，配对，以确定填充去间，最后用指定颜色填充区间内的所有像素，即完成填充工作
  • 优势：通过维护边表和有效边表，避开了扫描线与多边形所有边求交的复杂运算，性能提升巨大
  • 边界像素处理原则：对于边界像素，采用“左闭右开”和“下闭上开”的原则
  • 有效边：多边形与当前扫描线相交的边
  • 有效边表：把有效边按照与扫描线交点x坐标递增的顺序存放在一个链表中，称为有效边表
  • 桶表：按照扫描线顺序管理边的数据结构

算法实现：

将VC 6.0 调整到ClassView视图

创建有效边表和桶表类

将VC 6.0调整到FileView视图，对两个类进行定义

AET.h

class CAET  
{
public:
	CAET();
	virtual ~CAET();
public:
	double  x;//当前扫描线与有效边交点的x坐标
	int     yMax;//边的最大y值
	double  k;//斜率的倒数(x的增量)
	CAET   *pNext;
};

Bucket.h

#include "AET.h"
#include "Bucket.h"

class CBucket  
{
public:
	CBucket();
	virtual ~CBucket();
public:
	int     ScanLine;     //扫描线
	CAET    *pET;         //桶上的边表指针
	CBucket *pNext;
};

回到ClassView视图，像之前那样创建CFill类，再回到FileView视图，对CFill类进行定义

Fill.h

#include "AET.h"
#include "Bucket.h"

class CFill  
{
public:
	CFill();
	virtual ~CFill();
	void SetPoint(CPoint *p,int);//初始化顶点和顶点数目
	void CreateBucket();//创建桶
	void CreateEdge();//边表
	void AddET(CAET *);//合并ET表
	void ETOrder();//ET表排序
	void Gouraud(CDC *);//填充多边形
 	void ClearMemory();//清理内存
	void DeleteAETChain(CAET* pAET);//删除边表
protected:
	int     PNum;//顶点个数
	CPoint    *P;//顶点坐标动态数组
	CAET    *pHeadE,*pCurrentE,*pEdge; //有效边表结点指针
	CBucket *pHeadB,*pCurrentB;        //桶表结点指针
};

Fill.cpp

// Fill.cpp: implementation of the CFill class.
//
//

#include "stdafx.h"
#include "Study3.h"
#include "Fill.h"
#include "AET.h"
#include "Bucket.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//
// Construction/Destruction
//
CFill::CFill()
{
	PNum=0;
	P=NULL;
	pEdge=NULL;
	pHeadB=NULL;
	pHeadE=NULL;
	pCurrentB = NULL;
	pCurrentE = NULL;
}

CFill::~CFill()
{
	if(P!=NULL)
	{
		delete[] P;
		P=NULL;
	}
	ClearMemory();
}

void CFill::SetPoint(CPoint *p,int m)初始化顶点和顶点数目
{
	P=new CPoint[m];//创建一维动态数组，转储CTestView类中P数组中的顶点
	for(int i=0;i<m;i++)
	{
		P[i]=p[i];	
	}
	PNum=m;//记录顶点数量
}

void CFill::CreateBucket()//创建桶表
{
	int yMin,yMax;
	yMin = yMax = P[0].y;
	for(int i = 0;i<PNum;i++)
	{
		if(P[i].y<yMin)
		{
			yMin = P[i].y;

		}
		if(P[i].y>yMax)
		{
			yMax = P[i].y;
		}
	}

	for(int y = yMin;y<=yMax;y++)
	{
		if(yMin == y)
		{
			pHeadB = new CBucket;
			pCurrentB = pHeadB;
			pCurrentB->ScanLine = yMin;
			pCurrentB->pET = NULL;
			pCurrentB->pNext = NULL;
		}
		else
		{
			pCurrentB->pNext = new CBucket;
			pCurrentB=pCurrentB->pNext;
			pCurrentB->ScanLine = y;
			pCurrentB->pET=NULL;
			pCurrentB->pNext=NULL;
		}
	}
}

void CFill::CreateEdge()//创建边表，即将各边链入到相应的桶节点
{
	for(int i = 0;i<PNum;i++)
	{
		pCurrentB=pHeadB;
		int j = (i+1)%PNum;
		if(P[i].y<P[j].y)
		{
			pEdge = new CAET;
			pEdge->x=P[i].x;
			pEdge->yMax=P[j].y;
			pEdge->k = (double)(P[j].x-P[i].x)/((double)(P[j].y-P[i].y));

			pEdge->pNext = NULL;
			while(pCurrentB->ScanLine!=P[i].y)
			{
				pCurrentB=pCurrentB->pNext;
			}
		}

		if(P[j].y<P[i].y)
		{
			pEdge=new CAET;
			pEdge->x=P[j].x;
			pEdge->yMax=P[i].y;
			pEdge->k = (double)(P[i].x-P[j].x)/((double)(P[i].y-P[j].y));
			pEdge->pNext = NULL;
			while(pCurrentB->ScanLine!=P[j].y)
			{
				pCurrentB=pCurrentB->pNext;
			}
		}

		if(P[j].y!=P[i].y)
		{
			pCurrentE=pCurrentB->pET;
			if(pCurrentE==NULL)
			{
				pCurrentE=pEdge;
				pCurrentB->pET=pCurrentE;
			}
			else
			{
				while(NULL!=pCurrentE->pNext)
				{
					pCurrentE=pCurrentE->pNext;
				}
				pCurrentE->pNext=pEdge;
			}
		}
	}
}
void CFill::AddET(CAET *pNewEdge)//合并ET表
{
	CAET *pCE=pHeadE;//边表头结点
	if(pCE==NULL)//若边表为空，则pNewEdge作为边表头结点
	{
		pHeadE=pNewEdge;
		pCE=pHeadE;
	}
	else//将pNewEdge链接到边表末尾（未排序）
	{
		while(pCE->pNext!=NULL)
		{
			pCE=pCE->pNext;
		}
		pCE->pNext=pNewEdge;
	}
}

void CFill::ETOrder()//边表的冒泡排序算法
{
	CAET *pT1,*pT2;
	int Count=1;
	pT1=pHeadE;
	if(pT1==NULL)//没有边，不需要排序
	{
		return;
	}
	if(pT1->pNext==NULL)//如果该ET表没有再连ET表
	{
		return;//只有一条边，不需要排序
	}
	while(pT1->pNext!=NULL)//统计边结点的个数
	{
		Count++;
		pT1=pT1->pNext;
	}
	for(int i=0;i<Count-1;i++)//冒泡排序
	{
		CAET **pPre=&pHeadE;//pPre记录当面两个节点的前面一个节点，第一次为头节点
		pT1=pHeadE;
		for (int j=0;j<Count-1-i;j++)
		{
			pT2=pT1->pNext;
			
			if ((pT1->x>pT2->x)||((pT1->x==pT2->x)&&(pT1->k>pT2->k)))//满足条件，则交换当前两个边结点的位置
			{
				pT1->pNext=pT2->pNext;
				pT2->pNext=pT1;
				*pPre=pT2;
				pPre=&(pT2->pNext);//调整位置为下次遍历准备
			}
			else//不交换当前两个边结点的位置，更新pPre和pT1
			{
				pPre=&(pT1->pNext);
				pT1=pT1->pNext;
			}
		}
	}
}

void CFill::Gouraud(CDC *pDC)//填充多边形
{
	CAET *pT1=NULL,*pT2=NULL;
	pHeadE=NULL;
	for(pCurrentB=pHeadB;pCurrentB!=NULL;pCurrentB=pCurrentB->pNext)
	{
		for(pCurrentE=pCurrentB->pET;pCurrentE!=NULL;pCurrentE=pCurrentE->pNext)
		{
			pEdge=new CAET;
			pEdge->x=pCurrentE->x;
			pEdge->yMax=pCurrentE->yMax;
			pEdge->k=pCurrentE->k;
			pEdge->pNext=NULL;
			AddET(pEdge);
		}

		ETOrder();
		pT1=pHeadE;
		if(pT1==NULL)
		{
			return ;
		}
		while(pCurrentB->ScanLine>=pT1->yMax)
		{
			CAET *pAETTEmp = pT1;
			pT1=pT1->pNext;
			delete pAETTEmp;
			pHeadE=pT1;
			if(pHeadE==NULL)
			{
				return;
			}

		}
		if(pT1->pNext!=NULL)
		{
			pT2=pT1;
			pT1=pT2->pNext;
		}

		while(pT1!=NULL)
		{
			if(pCurrentB->ScanLine>=pT1->yMax)
			{
				CAET *pAETTemp=pT1;
				pT2->pNext=pT1->pNext;
				pT1=pT2->pNext;
				delete pAETTemp;
			}
			else
			{
				pT2=pT1;
				pT1=pT2->pNext;
			}
		}
		BOOL In = FALSE;
		int xb,xe;
		for(pT1=pHeadE;pT1!=NULL;pT1=pT1->pNext)
		{
			if(FALSE==In)
			{
				xb = (int)pT1->x;
				In=TRUE;
			}
			else
			{
				xe = (int)pT1->x;
				for(int x = xb;x<xe;x++)
				{
					pDC->SetPixel(x,pCurrentB->ScanLine,RGB(0,0,255));
				}
				In = FALSE;

			}
		}
		for(pT1=pHeadE;pT1!=NULL;pT1=pT1->pNext)
		{
			pT1->x=pT1->x+pT1->k;
		}
	}
}


void CFill::ClearMemory()//安全删除所有桶与桶上连接的边
{
	DeleteAETChain(pHeadE);//删除边表
	CBucket *pBucket=pHeadB;
	while (pBucket!=NULL)//针对每一个桶
	{
		CBucket *pBucketTemp=pBucket->pNext;
		DeleteAETChain(pBucket->pET);//删除桶上面的边
		delete pBucket;
		pBucket=pBucketTemp;
	}
	pHeadB=NULL;
	pHeadE=NULL;
}

void CFill::DeleteAETChain(CAET *pAET)//删除边表
{
	while (pAET!=NULL)
	{
		CAET *pAETTemp=pAET->pNext;
		delete pAET;
		pAET=pAETTemp;
	}
}

一切准备就绪，进入CXXXView.cpp（“XXX”为你项目名称）

给OnDraw函数添加以下语句

	CRect rect;
	GetClientRect(&rect);
	pDC->SetMapMode(MM_ANISOTROPIC);
	pDC->SetWindowExt(rect.Width(),rect.Height());
	pDC->SetViewportExt(rect.Width(),-rect.Height());
	pDC->SetViewportOrg(rect.Width()/2,rect.Height()/2);
	rect.OffsetRect(-rect.Width()/2,-rect.Height()/2);

	//声明Fill类
	CFill *cFill = new CFill;

	//声明多边形的七个顶点
	CPoint points[7] = {CPoint(50,70),CPoint(-150,270),CPoint(-250,20),CPoint(-150,-280),CPoint(0,-80),CPoint(100,-280),CPoint(300,120)};

	//设置顶点
	cFill->SetPoint(points,7);

	//创建桶表
	cFill->CreateBucket();

	//创建边表
	cFill->CreateEdge();

	//填充多边形
	cFill->Gouraud(pDC);

运行结果

大家对于填充算法要多看看，很重要

烟雨迷离半世殇
关注
  • 38
    点赞
  • 踩
  • 152
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
多边形有效边表填充算法
10-16
计算机图形学 有效边表填充算法（6）代码发布在我的博客http://blog.csdn.net/qingdujun/article/details/40154077， 同时这里也传上来了一个Demo，参考别人的改写的。
计算机图形学-多边形有效边表填充算法.rar
10-22
在计算机图形学中，多边形的有效边表填充算法是一项基础而关键的技术，用于在屏幕上描绘出多边形的内部，使图形看起来更加完整和真实。本资源提供了一套详细的PPT教程，旨在帮助学习者深入理解这一算法及其应用。 ...
有效边表填充算法的实现
热门推荐
不怕万人阻挡，只怕自己投降
03-08 1万+
有效边表填充算法实现1. 在当前项目中创建有效边结点类AET和边表中桶结点类Bucket，注意AET中的k代表的是边斜率的倒数（1/K）     2. 在视图类中增加属性Point[7]，是个点数组，用来存储待填充多边形的顶点，同时在视图类的构造函数中为Point[7]赋值                                                       3. 在视图类的...
计算机图形学07：有效边表法的多边形扫描转换
你的问题在于，读书太少而想得太多。
03-03 5397
计算机图形学之有效边表法的多边形扫描转换——附原理及详细代码
Altium Designer入门基础操作
最新发布
prppr_的博客
05-04 1033
AD入门基础操作，原理图、PCB等
有效边表填充算法
言午日月
01-02 1401
按照扫描线从上往下的顺序，依次处理和多边形相交的扫描线，对于当前处理的扫描线找到和它相交的所有边的交点，按照交点横坐标从小到大的顺序，两个两个配对，配对之后填充每对交点之间的像素，所有的扫描线处理完成之后，图形的扫描就结束了。三角形与当前扫描线相交的边称为有效边。在处理一条扫描线时仅对有效边进行求教运算，可以避免与多边形的所有边求交。桶表是一个纵向扫描线链表，链表的长度为多边形所覆盖的最大扫描线数，链表的每个节点称为桶，链接边表。这个图事实上就是 DDA 算法中的。为主轴位移的方向，执行。
计算机图形学——多边形填色（多边形颜色渐变填充）
baotu的博客
01-01 2613
多边形颜色渐变填充，设计实现多边形的填充类，设置顶点序列，调用填充函数。通过建立多边形的桶表和边表的数据，按照算法步骤依次扫描填充。调用设计实现的多边形填充类，对所绘制出来的多边形进行颜色渐变填充。x|yminymax1/knext有效边表填充算法的实现步骤为：1.根据多边形的顶点序列，建立其“桶表和边表”数据。b) 按照扫描线从小到大的移动顺序，取出当前扫描线对应桶的边 表数据。c) 如果“桶表”数据已经取完，则填充结束；否则，继续后续填 充操作。
计算机图形学MFC-多边形有效边表填充算法-c/c++源码
03-08
在本项目中，我们关注的是“多边形有效边表填充算法”（Polygon Edge Flag Algorithm，简称PEFA），它是计算机图形学中用于填充二维多边形内部的一种经典算法。MFC（Microsoft Foundation Classes）是微软提供的一个...
计算机图形学实验二多边形有效边表填充算法
05-05
多边形填充算法通常分为两大类：扫描线算法和边表算法。其中，边表算法是一种常用且高效的算法，尤其适用于复杂的多边形填充。它的基本思想是构建一个边表，记录多边形的所有边界，并在每个扫描线上遍历这个边表，找...
多边形有效边表填充算法.rar
11-24
总之，多边形有效边表填充算法是计算机图形学中的基本技术，对于理解和实现2D和3D图形的绘制至关重要。通过学习和实践这些算法，你可以更深入地掌握计算机图形学的原理，并为将来在游戏开发、可视化、虚拟现实等领域...
多边形有效边表填充算法 c++
04-28
对一个用鼠标左击形成的多边形，画一个最小的矩形，在这个矩形内用有效边表填充算法对多边形填充。 建议 请用VS2008运行。
有效边多边形填充算法
04-19
根据计算机图形学描算的有效边填充算法，来实现，使用vs2013编写。 关键函数用纯C实现，附加本人对此算法的一些理解
计算机图形学边缘填充算法
04-23
边缘填充算法: 思路：利用求余运算代替交点排序、配对、构造填充区间。 原理：象素点颜色值经过偶数次求余运算后保持不变，经过奇数次求余运算后变为其余数 算法： 以扫描线为中心的边缘填充算法 以边为中心的边缘填充算法
改进的有效边表算法，多边形的扫描转换
weixin_30904593的博客
12-04 2309
这里不仔细讲原理，只是把我写的算法发出来，跟大家分享下，如果有错误的话，还请大家告诉我，如果写的不好，也请指出来，一起讨论进步。 边表构造的算法: (1) 首先构造一个纵向链表，链表的长度为多边形所占有的最大扫描线数，链表的每个结点，称为一个桶，则对应多边形覆盖的每一条扫描线。 (2) 将每条边的信息链入与该边最小y坐标相对的桶处。也就是说，若某条边的较低点为ymin，则该边就放在相应的扫描...
计算机图形学-改进的有效边表算法
豆豆豆豆芽的博客
05-14 2017
利用AET表对扫描线进行存储 利用C++实现，VS2019测试通过，使用了glut库 #include<GL/glut.h> #include<iostream> #include<math.h> #include<stdlib.h> using namespace std; #define WINDOW_WIDTH 400 #define WINDOW_HEIGHT 400 //AET表数据结构 typedef struct tEdge { i
多边形扫描线填充算法
10-26
多边形扫描线填充算法是一种用于计算机图形学中的算法，用于对多边形进行填充。该算法的基本思想是，将多边形的填充转换为扫描线从上往下扫描填充，然后对每一条扫描线与图形的交点进行判断，根据扫描线的连贯性，对交点进行排序，最后依照此原理可以对图形进行扫描线算法扫描转换多边形。在判断交点时，还会出现扫描线与边重合、扫描线与边的交点为顶点等现象，需要进行特殊处理。 具体实现步骤如下： 1. 对多边形的边进行排序，按照从上到下的顺序排列。 2. 定义一个交点表，用于存储每一条扫描线与多边形的交点。 3. 从上到下扫描每一条扫描线，对每一条扫描线与多边形的交点进行判断。 4. 如果该边是水平的，并且边的Y值=y，直接将该线画出来。 5. 如果该边与y无交点，跳过。 6. 如果该边与y有交点,求出交点（qx，qy）。 7. 如果该点是顶点，则需要进行特殊处理。 8. 对交点进行排序，依照扫描线的连贯性，对交点进行排序。 9. 对相邻两个交点之间的区域进行填充。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值