某实验报告材料5多边形裁剪与填充要点

《计算机图形学》实验5实验报告

实验题目：多边形裁剪与填充

实验内容：1 阅读理解提供的参考资料。

2编写并调通一个多边形裁剪的java程序。

3编写并调通一个多边形填充的java程序。

参考资料：1fillPolygon.java

2 clipSC2.java

3变换与剪裁.ppt

4多边形的填充.ppt

基本概念：

1变换与裁剪：

（1）计算机处理图形的过程一般分为三个阶段：①图形的数字化；②图形操作；③图形输出。

（2）模型坐标系（局部坐标系）：当构造单个对象的数字模型时，为了方便,可以将其置一个特定的坐标系下，即模型坐标系或局部坐标系。

（3）世界坐标系：为描述图形场景中所有图形之间的空间关系,将它们置于一个统一的坐标系中，该坐标系被称为世界坐标系。

（4）设备坐标系：要输出经过处理后的数字化图形，需要在输出设备上建立一个坐标系，称为设备坐标系。

（5）标准化设备坐标系：有些图形系统，对设备坐标系进行了规范化，将坐标范围限定在区间

{x,y,z | 0≤x≤1, 0≤y≤1, 0≤z≤1}

内，称标准化设备坐标系。

（6）三维图形的显示流程图

（7）裁剪

裁剪作用：选择显示的内容--图形在窗口内的部分被显示出来，窗口外的部分被裁剪掉。图形中每个基本元素都要经过裁剪,因此裁剪直接影响整个图形系统的效率。

裁剪类型：二维裁剪、三维裁剪

裁剪窗口：矩形，凸多边形，任意多边形

视见体:棱台、立方体

裁剪对象：直线段、多边形、文字等

2多边形的填充:

(1)多边形的填充指在给定区域填上所需要的颜色，就是把多边形的顶点表示转换为点阵表示，即从多边形的给定边界出发，求出位于其内部的各个像素，并将帧缓冲器内的各个对应元素设置相应的灰度或颜色。

(2)多边形的表示：

1）顶点表示是用多边形的顶点的序列来描述多边形，该表示几何意义强、占内存少，但它

不能直观地说明哪些像素在多边形内。

2）点阵表示是用位于多边形内的象素的集合来刻划多边形，该方法虽然没有多边形的几何信息，是面着色所需要的图像表示形式。

算法设计：

1 多边形的裁剪：

Sutherland-Cohen 算法:

基本思想：对于每条线段P1P2分为三种情况处理。

（1）若P1P2完全在窗口内，则显示该线段P1P2简称“取”之。

（2）若P1P2明显在窗口外，则丢弃该线段，简称“弃”之。

（3）若线段既不满足“取”的条件，也不满足“弃”的条件，则在交点处把线段分为两段。其中一段完全在窗口外，可弃之。然后对另一段重复上述处理。

具体操作：分为两步

第一步是判定：

1) 完全在窗口内的直线段，称为完全可见的线段；

2) 完全在窗口外的线段，称为完全不可见线段。

第二步处理不能断定为完全可见或完全不可见的线段。

这时需要计算出直线段和窗口边界的一个交点，这个交点把直线分成两段，其中一条为完全不可见的线段,被抛弃。

对余下部分再作第一步的判断，重复上述过程，直到直线段余下的部分可用第一步的判断得出肯定的结论为止。

2多边形的填充:

(1) 多边形填充的扫描线算法

a. 令y = c 为一个常数，扫描整个多边形的边 ，记录横坐标为xi 记为序列1.

b. 设d 为一整数，d =c –1，且yi 0≥y ≥yi n ；设位于扫描线y =d 上的交点序列为 ，记为序列2。

c. 奇点的处理: 多边形P 的顶点可分为两类：极值点和非极值点。如果

，

称顶点Pi 为极值点(P1,P2,P3,P5, P6,P8)；否则称Pi 为非极值点(P0,P4,P7)。若扫描线与多边形相交于多边形的顶点，则该交点(顶点)称为奇点。为了使交点个数保持为偶数，规定当奇点是P 的极值点时，该点按两个交点计算；否则按一个交点计算。

(2) 边缘填充算法: 对多边形P 的每一非水平边上的各像素做向右求反运算即可。

步骤：a. 以值为boundary-color 的特殊颜色勾画多边形P 的边界。设多边形顶点为Pi = (xi , yi ),0≤i ≤n ， xi , yi 均为整数；置Pn +1=P 0。每一条扫描线上着上这种特殊颜色的点的个数必定是偶数(包括零)。

b. 设interior_point 是一布尔变量。对每一条扫描线从左到右进行搜索，如果当前是像素位于多边形P 内，则interior_point=true ，需要填上值为polygon_color 的颜色；否则该像素在多边形P 外，需要填上值为background_color 的颜色。

(3) 区域填充:

a. 区域是指已经表示成点阵形式的像素集合。在光栅图形 中，区域可采用内点表示和边界表示两种形式进行描述。

内点表示法：把位于给定区域内的所有像素一一列举出来的方法称为内点表示法。 边界表示法：把位于给定区域边界上的像素一一列举出来的方法称为边界表示法。 b.区域的连通性:

1) 连通的区域: 取区域内任意两点，在该区域内若从其中一点出发通过上、下、左\右四0))((11≥--+-i i i i y y y y

种运动可到达另一点。

2）连通的区域: 取区域内任意两点，若从其中任一点出发，在该区域内通过沿水平方向、垂直方向和对角线方向的八种运动可到达另一点。

（4）扫描线种子填充算法:从给定的种子点开始，填充当前扫描线上种子点所在的一区段，然后确定与这一段相邻的上下两条扫描线上位于区域内的区段（需要填充的区间），从这些区间上各取一个种子点依次把它们存起来，作为下次填充的种子点。反复进行这过程，直到所保存的各区段都填充完毕。

步骤：

a.（初始化）将算法设置的堆栈置为空。将给定的种子点（x, y）压入堆栈

b.（出栈）如果堆栈为空，算法结束；否则取栈顶元素（x, y）作为种子点

c.（区段填充）从种子点（x, y）开始，沿纵坐标为y的当前扫描线向左右两个方向逐个像素用新的颜色值进行填充，直到边界为止即象素颜色等于边界色。设区间两边界的横坐标分别为xleft 和xright。

d. 在与当前扫描线相邻的上下两条扫描线上，以区间[xleft, xright]为搜索范围，求出需要填充的各小区间，把各小区间中最右边的点并作为种子点压入堆栈，转到步骤2。

代码：

1 多边形的裁剪：

public int code(float x,float y)

{

int c=0;

if(x

else if(x>xR)c=c|2;

if(y

else if(y>yT)c=c|8;

return c; //二进制分别为0 1 10 100 1000

}

//Sutherland_Cohen裁减算法

public void Sutherland_Cohen(Graphics g,float x0,float y0,float x2,float y2)

{

int c1,c2,c;

float x,y,wx,wy;

boolean accept=false,done=false;

c1=code(x0,y0);

c2=code(x2,y2);

do {

if ((c1|c2)==0)//两个编码都为0，表明在窗口内

{

accept=true;

done=true;

}

else if((c1&c2)!=0)done=true;//两个编码的某一位为1，则必然在外侧显然在窗口外

else

{

c=c1;

if(c==0)c=c2;

wx=x2-x0;

wy=y2-y0;

if ((c&8)==8) //求交点

{

x=x0+wx*(yT-y0)/wy;

y=yT;

}

else if ((c&4)==4)

{

x=x0+wx*(yB-y0)/wy;

y=yB;

}

else if ((c&1)==1)

{

y=y0+wy*(xL-x0)/wx;

x=xL;

}else//即(c&2)==2

{

y=y0+wy*(xR-x0)/wx;

x=xR;

}

if (c==c1) //表明c1!=0,起始点不在窗口内，将交点作为新的起点重复判断步骤；

{

x0=x;

y0=y;

c1=code(x0,y0);

}else//终点不在窗口内，交点作为新的终点

{

x2=x;

y2=y;

c2=code(x2,y2);

}

}//else

} while (done==false);

if(accept)g.drawLine((int)x0,(int)y0,(int)x2,(int)y2);

}

2多边形的填充：

class activeEdgeList {

activeEdgeListEntry header=null;

activeEdgeListEntry tailer=null;

public activeEdgeList(activeEdgeListEntry element) {

header=tailer=element; //指向第一个边结点

}

//把新结点插入有序排列的多边形单链表

public void insert(activeEdgeListEntry element) {

activeEdgeListEntry sentinel;

if(element==null || this.header==null) //新结点异常或者链表空

throw new NullPointerException(); //出错，抛出异常

sentinel=this.header; //当前指针指向表头结点

int xt=element.topx; //新结点的topx

int xtold=sentinel.topx;

double oldDelta=sentinel.delta; //当前结点的delta

double newDelta=element.delta;

/* 排序第一关键字结点的topx，第二关键字结点的delta */

/* 两个关键字由小到大*/

if((xtold

while(true){ //在链表头指针之后寻找新结点element的位置

if(sentinel.next==null) {

sentinel.next=element; //追加到表尾

this.tailer=element;

break; //结束while循环

}

activeEdgeListEntry mp=sentinel.next; //下一结点

int xmt=mp.topx;

double midDelta=mp.delta;

if((xmt

sentinel=mp; //新结点仍然大于下一结点，当前结点指针后移，继续循环

}

else { //否则，新结点就应该插入当前位置

sentinel.next=element;

element.next=mp;

break; //结束while循环，尾指针不动

}

}

}

else { //新结点作为单链表头结点

sentinel=this.header;

this.header=element;

element.next=sentinel;

}

} //插入新结点结束

//把新结点作为多边形链表的头结点或者尾结点

public void append(activeEdgeListEntry element) {

if(element==null) throw new NullPointerException();

if(tailer==null) { //如果单链表是空

tailer=element;header=element;

}

else { //否则把新结点作为单链表尾结点

tailer.next=element;tailer=element;

}

}

//两个多边形单链表的合并：自身单链表与list单链表的合并public activeEdgeList merge(activeEdgeList list,int y) {

if(list==null) return this;

activeEdgeListEntry a=this.header; //自身单链表的头指针activeEdgeListEntry b=list.header; //单链表list的头指针

activeEdgeListEntry save=null; //指向链表结点的工作指针activeEdgeListEntry anext,bnext; //指向链表结点的工作指针activeEdgeList result=null; //合并结果链表

while(true) {

if(a==null&&b==null) return result; //两个空表

else if(a==null) { //自身为空表

if(save!=null) {

save.next=b;

result.tailer=list.tailer;

return result;

}

}

else if(b==null){ //list为空表

if(save!=null) {

save.next=a;

result.tailer=this.tailer;

return result;

}

}

/*两个表都不空*/

int xa=(int)(a.topx+(a.topy-y)*a.delta); //自身链表

int xb=b.topx; //list链表头结点的topx

if(xa<=xb) { //决定合并后两个表的先后

anext=a.next;

a.next=null;

if(result==null) { //结果链表为空，则a表在前

result=new activeEdgeList(a);

save=result.tailer;

}

else result.append(a); //结果链表不空，则a表在后

save=a;

a=anext;

}

else {

bnext=b.next;

b.next=null;

if(result==null) { //结果链表为空，则b表在前

result=new activeEdgeList(b);

save=result.tailer;

}

else result.append(b); //结果链表不空，则b表在后

save=b;

b=bnext;

}

} //结束while

} //单链表合并结束

//删除多边形单链表的结点

public void remove(activeEdgeListEntry element) {

activeEdgeListEntry p,q;

if(header==element) { //要删除的是头结点

header=element.next;

if(tailer==element) tailer=header;

return;

}

p=q=header;

while(p!=element) {

q=p;p=p.next;

if(p==null) throw new NullPointerException(); //查无此结点}

if(element==tailer) tailer=q; //要删除的是尾结点

q.next=p.next; //要删除的是非头尾结点

}

//多边形单链表的相邻结点

public void traverse() {

activeEdgeListEntry p,q,r,tmp;

p=r=header;

while(p!=null){

q=p.next;

if(q==null) break; //到达末尾

if(q.x

if(p==header) header=q; else r.next=q;

q.next=p;

p.next=tmp;

}

r=p; //指向尾结点

p=p.next; //下一个结点

} //结束while

tailer=r; //多边形单链表新的尾指针

}

} //结束多边形单链表类

//*****定义直线类

class Line {

public double x1,y1;

public double x2,y2;

public Line(double x1,double y1,double x2,double y2) {

this.x1=x1;this.y1=y1;

this.x2=x2;this.y2=y2;

}

} //结束直线类

//***********定义多边形的填充类*******//

public class fillPolygon extends Applet //继承鼠标事件监听接口implements MouseListener,MouseMotionListener {

protected MyCanvas m; //定义MyCanvas的对象

//扫描行处理用数据

protected activeEdgeListEntry[] edgeData=null; //边结点数组

protected activeEdgeList[] bucket=null; //多边形单链表数组

protected activeEdgeList activeHeader=null; //当前边单链表的头指针protected int numEdge=0; //多边形的边数

//鼠标相关数据

protected boolean isFirstClicked=true; //鼠标最初点击

protected boolean isDoubleClicked=false; //双击标志

protected boolean isSingleClicked=false; //单击标志

//绘图区域

protected int width,height; //Applet绘图区的大小

protected Image image=null; //图像区域

protected MemoryImageSource mis=null; //内存图像

protected int[] pixel=null; //内存图像配色数组

protected int pixelWidth; //图像宽度

protected int pixelHeight; //图像高度

protected int xoffset; //pixel数据的窗口内显示偏移量

protected int yoffset;

protected double leftTopx; //pixel数据的起始点

protected double leftTopy;

//多边形的绘图数据

protected double x0,y0; //边的起点

protected double lastx,lasty; //边的终点位置

protected double movingx,movingy; //用户坐标系下一个点的坐标

protected int numPoints=0; //顶点计数器

protected boolean isPolygonMode=true; //标志

protected Vector lines=new Vector(256,256); //Java的向量类

//APPLET程序的初始化

public void init(){

m=new MyCanvas(this); //本APPLET容器的MyCanvas对象

addMouseListener(this); //定义鼠标按钮监听器

addMouseMotionListener(this); //定义鼠标按钮监听器

Dimension d=getSize(); //本APPLET容器的大小

width=d.width; height=d.height;

}

//成员变量初始化

public void initData(){

isFirstClicked=true; //鼠标最初点击

isPolygonMode=true; //标志描绘多边形

numPoints=0; //多边形顶点计数器

bucket=new activeEdgeList[height+1]; //边的单链表数组

for(int i=0;i

if(lines.size()>0) lines.removeAllElements(); //向量类的对象

}

//APPLET程序的绘图

public void paint(Graphics g) {

if(isFirstClicked) { //初始状态

initData();

Font f=m.MyFont(m.getFont().getName(),Font.BOLD+Font.ITALIC,1.5);

m.setFont(f);

m.drawString("单击画多边形",-0.5,0.2);

m.drawString("双击填充多边形",-0.9,-0.15);

}

m.setBackground(new Color(220,220,220)); //背景色

m.setColor(Color.black); //前景色

for(int i=0;i

Line l=(Line)lines.elementAt(i); //转换第i个向量

m.drawLine(l.x1,l.y1,l.x2,l.y2);

}

if(isPolygonMode&&!isFirstClicked) //画线

m.drawLine(lastx,lasty,movingx,movingy);

if((!isPolygonMode)&&(image!=null)) //填充

m.myDrawImage(image,leftTopx,leftTopy,this);

} //APPLET程序的绘图

//把多边形顶点数据生成边结点

public void registerActiveEdgeEntry() {

numEdge=lines.size(); //多边形边的数量

edgeData=new activeEdgeListEntry[numEdge];

for(int i=0;i

edgeData[i]=new activeEdgeListEntry();

/* 四个极值用于确定显示图像的大小和范围*/

int LARGE=0x0ffffffff;

int xmin=LARGE,xmax=-1,ymin=LARGE,ymax=-1;

double dxmin=LARGE,dxmax=-1,dymin=LARGE,dymax=-1;

for(int i=0;i

int ix1=m.getX(l.x1); //将用户坐标的点转换到Java AWT坐标int iy1=height-m.getY(l.y1);

int ix2=m.getX(l.x2);

int iy2=height-m.getY(l.y2);

edgeData[i].topx=0;

edgeData[i].name=i;

edgeData[i].next=null;

if(iy1>iy2) { //边的斜向

edgeData[i].isHorizontal=false;

edgeData[i].topy=iy1;

edgeData[i].topx=ix1;

edgeData[i].x=ix1;

edgeData[i].boty=iy2;

edgeData[i].delta=(double)(-(ix2-ix1))/(iy2-iy1);

if(iy2

ymin=iy2;

dymin=l.y2;

}

if(iy1>ymax) {

ymax=iy1;

dymax=l.y1;

}

}

else if(iy1

edgeData[i].isHorizontal=false;

edgeData[i].topy=iy2;

edgeData[i].topx=ix2;

edgeData[i].x=ix2;

edgeData[i].boty=iy1;

edgeData[i].delta=(double)(-(ix1-ix2))/(iy1-iy2);

if(iy1

ymin=iy1;

dymin=l.y1;

}

if(iy2>ymax) {

ymax=iy2;

dymax=l.y2;

}

}

else { //水平边y1==iy2

edgeData[i].isHorizontal=true;

if(iy1

dymin=l.y1;

}

if(iy1>ymax) {

ymax=iy1;

dymax=l.y1;

}

}

if(ix1

xmin=ix1;

dxmin=l.x1;

}

if(ix2>xmax) {

xmax=ix2;

dxmax=l.x2;

}

}

else if(ix2

if(ix2

xmin=ix2;

dxmin=l.x2;

}

if(ix1>xmax) {

xmax=ix1;

dxmax=l.x1;

}

}

else { //垂直边ix2==ix1

if(ix1

xmin=ix1;

dxmin=l.x1;

}

if(ix1>xmax) {

xmax=ix1;

dxmax=l.x1;

}

}

} //结束for循环

/*内存图像的数组空间及相关数据*/

pixelWidth=xmax-xmin+1;

pixelHeight=ymax-ymin+1;

pixel=new int[pixelWidth*pixelHeight]; //图像的个点颜色

for(int k=0;k

pixel[k]=0x00000000; //初值透明色

xoffset=xmin;yoffset=ymin;

leftTopx=dxmin; //用于显示图像方法myDrawImage();

leftTopy=dymax;

} //生成边结点registerActiveEdgeEntry()

//多边形单链表数组bucketd初始化

public void bucketSort() {

for(int i=0;i

Line l=(Line)lines.elementAt(i); //转换第i个向量

if(edgeData[i].isHorizontal) continue; //水平边不处理

int yt=edgeData[i].topy;

if(bucket[yt]==null) { //该行未建立链表

bucket[yt]=new activeEdgeList(edgeData[i]);

continue;

}

bucket[yt].insert(edgeData[i]); //该行有链表，按顺序插入到链表i } //结束for循环

}

//多边形的扫描转换

public void scanPolygon() {

activeHeader=null; //当前要处理的单链表

for(int y=height-1;y>=0;y--) {

if(bucket[y]!=null) { //该指针元素存在

makeActiveEdgeList(bucket[y],y); //建立该行的边链表

processActiveEdgeList(y); //处理该行的边链表

}

else if(activeHeader!=null&&activeHeader.header!=null)

processActiveEdgeList(y); //处理该行的边链表

} //结束for循环

} //多边形的扫描转换

//处理给定行的边链表

public void processActiveEdgeList(int y) {

int xleft,xright;

double xl,xr;

activeEdgeListEntry left=activeHeader.header;

activeEdgeListEntry right=left.next;

if(right==null) return;

while(true) {

xl=left.x;

xr=right.x;

xleft=(int)xl;

xright=(int)(xr+0.5);

if(xleft<=xright)

fillScanline(xleft,xright,y); //填充y行像素列left.x+=left.delta; //起终点右移一个步长

right.x+=right.delta;

if(left.boty>=y-1 && right.boty>=y-1) {

xleft=(int)left.x;

xright=(int)(right.x+0.5);

if(xleft<=xright)

fillScanline(xleft,xright,y-1); //填充y-1行像素列}

if(left.boty>=y-1) //将左面的边从当前链表中删去

activeHeader.remove(left);

if(right.boty>=y-1) //将左面的边从当前链表中删去

activeHeader.remove(right);

left=right.next; //选择当前链表中下一对结点

if(left==null) break; //到达链表末尾,退出循环

right=left.next;

if(right==null) //边链表的结点数一定为偶数

throw new NullPointerException(); //出错} //结束while

activeHeader.traverse(); //边封闭后,重新整理单链表

} //处理给定行的边链表

//建立指定行的边链表

public void makeActiveEdgeList(activeEdgeList list,int y) { if(activeHeader==null)

activeHeader=list; //指定为当前单链表

else//把list与当前单链表合并

activeHeader=activeHeader.merge(list,y);

}

//填充何种图案

public boolean isTilePattern(int i,int j) {

if( i%8==0 || j%8==0 || i%8==1 || j%8==1 ||

i%8==2 || j%8==2 ) return true; // 填充图案1 return false; // 填充图案2

}

//设定像素颜色

public void putPixel(int i,int j) {

int r,g,b;

if(isTilePattern(i,j))

r=g=b=0; //黑色

else {

r=(int)(Math.random()*255); //0到255之间的随机数

g=(int)(Math.random()*255);

b=(int)(Math.random()*255);

}

int a=0xff000000|(r<<16)|(g<<8)|b; //像素颜色

/*图像的i行j列处的颜色*/

pixel[(pixelHeight-1-(j-yoffset))*pixelWidth+(i-xoffset)]=a;

}

//填充指定行的像素列

public void fillScanline(int xleft,int xright,int y) {

for(int x=xleft;x<=xright;x++)

putPixel(x,y); //调用putPixel()，设定改点像素颜色

}

//------多边形填充总控程序----

public void scanLineFillPolygon() {

registerActiveEdgeEntry(); //生成边结点

bucketSort(); //单链表数组bucketd初始化

scanPolygon(); //多边形的扫描转换

repaint(); //paint绘图

}

//响应鼠标击键事件

public void mousePressed(MouseEvent e) {

int ix=e.getX(); //鼠标的Jawa AWT坐标

int iy=e.getY();

if(isPolygonMode) { //正在进行多边形填充

double x,y; //鼠标的当前位置

if(e.getClickCount()>=2) { //双击，添加多边形的顶点

isDoubleClicked=true; //标记

/* 给光栅向量表增加一行，这个向量成员方法导致编译

要加上参数-Xlint，会出现警告错误*/

lines.addElement(new Line(lastx,lasty,x0,y0));

isPolygonMode=false;

scanLineFillPolygon(); //多边形填充总控程序

if(numEdge>2) { //内存图像生成

mis=new MemoryImageSource(pixelWidth,

pixelHeight,pixel,0,pixelWidth);

image=createImage(mis);

}

}

else { //单击，准备开始

if(isFirstClicked) { //初次点击

isFirstClicked=false;

/*先按照Jawa AWT坐标ix iy得到视图索引号，

再由视图反向转换得到用户坐标系下的lastx lasty*/

lastx=x0=m.getUserX(ix,m.getViewport(ix,iy));

lasty=y0=m.getUserY(iy,m.getViewport(iy,iy));

movingx=lastx; movingy=lasty;

}

else { //非初次点击

/*ix iy所对应的用户坐标系下的坐标*/

x=m.getUserX(ix,m.getViewport(ix,iy));

y=m.getUserY(iy,m.getViewport(iy,iy));

/* 给光栅向量表增加一行*/

lines.addElement(new Line(lastx,lasty,x,y));

lastx=x; lasty=y;

}

numPoints++;

}

repaint(); //paint绘图

} //结束if(isPolygonMode)语句

} //响应鼠标击键事件

//响应鼠标移动事件

public void mouseMoved(MouseEvent e) {

if(!isFirstClicked && isPolygonMode) {

int ix,iy;

ix=e.getX(); //鼠标的Jawa AWT坐标

iy=e.getY();

/*ix iy所对应的用户坐标系下的坐标*/

movingx=m.getUserX(ix,m.getViewport(ix,iy));

movingy=m.getUserY(iy,m.getViewport(ix,iy));

repaint();

}

} //响应鼠标移动事件

//****java语法列出有关鼠标接口中的虚方法

public void mouseClicked(MouseEvent e){}

public void mouseEntered(MouseEvent e){}

public void mouseExited(MouseEvent e){}

public void mouseReleased(MouseEvent e){}

public void mouseDragged(MouseEvent e){}

} //结束多边形填充类

运行结果：

1 多边形的裁剪：

2 多边形的填充：

实验体会：

通过这次的实习报告的编写，我学习了图形变换与裁剪的知识，学习了Sutherland-Cohen 算法的方法原理。多边形的填充主要是扫描知识。在本次实验中，图形的变换按比例来放大缩小，通过转换完成。应用了大量的数学知识，计算机图形学离不开数学。此次实验让我对多边形的裁剪和填充有了一个更加深入的了解。