第1次作业答案

习题3.推广本章第一节给出的产生线段的整数Bresenham算法，去掉0<=m<=1和x1

解答：

Bresenham画线算法使用实际直线上点与可选像素点之间的距离差作为判别式。假设要绘制的空间任一直线段的两个端点为(x1, y1)和(x2, y2)，如果保证x1≤x2，则Bresenham画线算法的处理分为图3.1中所示的四种情况。

第(1)种情况，直线的斜率m处于0和1之间，当x增量为1像素时，y增量在0与1之间，此时下一个可选像素点为P1(x p+1, y p)或P2(x p+1,y p+1)。此时在x = x p +1处直线上点的y值是y = m(x p + 1) + b，该点到P1(x p+1, y p)和P2(x p+1,y p+1)的距离分别为d1和d2：d1 = y – y p = m(x p + 1) + b - y p

d2 = (y p + 1) – y = (y p + 1) – m(x p + 1) – b

这两个距离的差为：

d = d1– d2 = 2m(x p + 1) – 2y p + 2b – 1

若d>0，则下一个像素点取P2(x p+1,y p+1)；若d<0，则下一个像素点取P1(x p+1, y p)；若d=0，则下一个像素点可取这两个像素点中任意一个。为了简便d的符号的计算，可引入一个新的判别量p p：

p p = Δxd = Δx(d1– d2) = 2Δy·x p– 2Δx·y p + c

其中，Δx = x2– x1，Δy = y2– y1，c = 2·Δy +Δx(2b – 1)。因为这里Δx>0，故p p与d 同号，可以作为判别量。下面看如何从p p计算p p+1。将上式中的p换成p+1，有：p p+1 = 2Δy·x p+1– 2Δx·y p+1 + c

因为x p+1 = x p + 1，可知：

p p+1– p p = 2Δy – 2Δx (y p+1– y p)

当p<0时，取P1(x p+1, y p)，此时y p+1 = y p，所以p p+1 = p p + 2Δy；否则，取P2(x p+1,y p+1)，此时y p+1 = y p + 1，所以p p+1 = p p + 2(Δy –Δx)。此时还需要看判别量p1的初始值，因为线段上第一个像素点可以取起点(x1, y1)，所以有：

p1 = 2Δy·x1 - 2Δx·y1 + 2·Δy +Δx(2b – 1)

因为y1 = (Δy /Δx)x1 + b，可计算出：

p1 = 2Δy –Δx

其它三种情况都可以用此方法来完成处理。

第(2)种情况，直线的斜率m大于1，当y增量为1像素时，x增量在0与1之间，此时下一个可选像素点为P1(x p, y p+1)或P2(x p+1,y p+1)。在y = y p +1处直线上点的x值是x = (y p + 1 – b)/m，该点到P1(x p+1, y p)和P2(x p+1,y p+1)的距离分别为d1和d2：

d1 = x – x p = (y p + 1 – b)/m - x p

d2 = (x p + 1) – x = (x p + 1) – (y p + 1 – b)/m

则这两个距离的差为：

d = d1– d2 = 2(y p + 1 – b)/m – 2x p– 1

因为Δy>0，为简便运算引入新的判别量p p：

p p = Δyd = Δy(d1– d2) = 2Δx·y p– 2Δy·x p + c

其中，Δx = x2– x1，Δy = y2– y1，c = 2·Δx(1 – b) –Δy。下面看如何从p p计算p p+1。将上式中的p换成p+1，则：

p p+1 = 2Δx·y p+1– 2Δy·x p+1 + c

因为y p+1 = y p + 1，可知：

p p+1– p p = 2Δx – 2Δy (x p+1– x p)

当p<0时，取P1(x p, y p+1)，此时x p+1 = x p，所以p p+1 = p p + 2Δx；否则，取P2(x p+1,y p+1)，此时x p+1 = x p + 1，所以p p+1 = p p + 2(Δx –Δy)。计算判别量p1的初始值时，因为线段上第一个像素点可以取起点(x1, y1)，所以有：

p1 = 2Δx·y1 - 2Δy·x1 + 2·Δx(1 – b) –Δy

因为y1 = (Δy /Δx)x1 + b，可计算出：

p1 = 2Δx –Δy

第(3)种情况，直线的斜率m处于0和-1之间，当x增量为1像素时，y减量在0与1之间，此时下一个可选像素点为P1(x p+1, y p)或P2(x p+1,y p–1)。在x = x p+1处直线上点的y 值是y = m(x p + 1) + b，该点到P1(x p+1, y p)和P2(x p+1,y p–1)的距离分别为d1和d2：d1 = y p– y = y p– m(x p + 1) – b

d2 = y – (y p - 1) = m(x p + 1) + b – (y p - 1)

则这两个距离的差为：

d = d1– d2 = 2y p– 2m(x p + 1) – 2b + 1

因为Δx>0，为简便运算引入新的判别量p p：

p p = Δxd = Δx(d1– d2) = 2Δx·y p– 2Δy·x p + c

其中，Δx = x2– x1，Δy = y2– y1，c =Δx(1 – 2b) – 2·Δy。下面看如何从p p计算p p+1。将上式中的p换成p+1，有：

p p+1 = 2Δx·y p+1– 2Δy·x p+1 + c

因为x p+1 = x p + 1，可知：

p p+1– p p = 2Δx (y p+1– y p) – 2Δy

当p<0时，取P1(x p+1, y p)，此时y p+1 = y p，所以p p+1 = p p– 2Δy；否则，取P2(x p+1,y p–1)，此时y p+1 = y p– 1，所以p p+1 = p p– 2(Δx + Δy)。计算判别量p1的初始值时，因为线段上第一个像素点可以取起点(x1, y1)，所以有：

p1 = 2Δx·y1 - 2Δy·x1 + Δx(1 – 2b) – 2·Δy

因为y1 = (Δy /Δx)x1 + b，可计算出：

p1 = Δx – 2Δy

第(4)种情况，直线的斜率m小于-1，当y减量为1像素时，x增量在0与1之间，此时

下一个可选像素点为P1(x p, y p–1)或P2(x p+1,y p–1)。在y = y p– 1处直线上点的x值是x = (y p–1 – b)/m，该点到P1(x p, y p–1)和P2(x p+1,y p–1)的距离分别为d1和d2：

d1 = x – x p = (y p– 1 – b)/m - x p

d2 = (x p + 1) – x = (x p + 1) – (y p– 1 – b)/m

则这两个距离的差为：

d = d1– d2 = 2(y p– 1 – b)/m – 2x p– 1

因为这里-Δy>0，为简便运算引入新的判别量p p：

p p = -Δyd = -Δy(d1– d2) = 2Δy·x p– 2Δx·y p + c

其中，Δx = x2– x1，Δy = y2– y1，c = 2·Δx(1 + b) + Δy。下面看如何从p p计算p p+1。将上式中的p换成p+1，有：

p p+1 = 2Δy·x p+1– 2Δx·y p+1 + c

因为y p+1 = y p– 1，可知：

p p+1– p p = 2Δx + 2Δy (x p+1– x p)

当p<0时，取P1(x p, y p–1)，此时x p+1 = x p，所以p p+1 = p p + 2Δx；否则，取P2(x p+1,y p–1)，此时x p+1 = x p + 1，所以p p+1 = p p + 2(Δx + Δy)。计算判别量p1的初始值时，因为线段上第一个像素点可以取起点(x1, y1)，所以有：

p1 = 2Δy·x1 - 2Δx·y1 + 2·Δx(1 + b) + Δy

因为y1 = (Δy /Δx)x1 + b，可计算出：

p1 = 2Δx + Δy

现在我们可以写出Bresenham画线算法的实现函数，在CDraw类中添加如下的成员函数：

public:

//Bresenham画线算法

void BresenhamLine(CDC* pDC, int x1, int y1, int x2, int y2, COLORREF color);

参数x1、y1、x2、y2为直线段的两个端点的坐标；参数pDC是设备环境对象指针；参数color为绘制直线段的颜色。实现代码如下：

//Bresenham画线算法

void CDraw::BresenhamLine(CDC *pDC, int x1, int y1, int x2, int y2, COLORREF color) {

int x,y,dx,dy,p;

//传入端点坐标x值相等

if (x1 == x2)

{

if (y1 < y2)

{

for (int i=y1;i<=y2;i++)

pDC->SetPixel(x1,i,color);

}

else

{

for (int i=y2;i<=y1;i++)

pDC->SetPixel(x1,i,color);

}

return;

//斜率判断，斜率绝对值大于1，则m为false，否则为true BOOL m = (fabs(y2-y1)<=fabs(x2-x1));

//如果x1大于x2，交换坐标值

if (x1 > x2)

{

p=x1;x1=x2;x2=p;

p=y1;y1=y2;y2=p;

}

x = x1;

y = y1;

dx = x2 - x1;

dy = y2 - y1;

//斜率绝对值小于等于1

if (m)

{

//第一种情况，y递增

if (y1 <= y2)

{

p = (dy<<1) - dx;

while (x <= x2)

{

pDC->SetPixel(x,y,color);

if (p < 0)

{x++;p=p+ (dy<<1);}

else

{x++;y++;p=p+((dy-dx)<<1);}

}

}

//第三种情况，y递减

else

{

p = dx – (dy<<1);

while (x <= x2)

{

pDC->SetPixel(x,y,color);

if (p < 0)

{x++;p=p-(dy<<1);}

else

{x++;y--;p=p-((dy+dx)<<1);}

}

}

}

//斜率绝对值大于1

{

//第二种情况，y递增

if (y1 <= y2)

{

p = (dx<<1) - dy;

while (y <= y2)

{

pDC->SetPixel(x,y,color);

if (p < 0)

{y++;p=p+(dx<<1);}

else

{x++;y++;p=p+((dx-dy)<<1);}

}

}

//第四种情况，y递减

else

{

p = (dx<<1) + dy;

while (y >= y2)

{

pDC->SetPixel(x,y,color);

if (p < 0)

{y--;p=p+(dx<<1);}

else

{x++;y--;p=p+((dx+dy)<<1);}

}

}

}

}

此算法也需要注意四种情况的循环条件。其四种情况下循环条件的设置和中点画线法的设置相同，只是因为本函数实现时，没有先绘制起点，而是所有点都在函数中绘制，所以其循环条件都需要加上“等于”。同时函数在计算p值时，乘2运算采用了向左移1位的方法。以上代码实现体现了4种情况下的不同处理，下面将代码整合，如下：

void BresenhamLine(int x1, int y1, int x2, int y2,CDC* dc)

{

int x,y,dx,dy,p,xmin,ymin,xmax,ymax,ly,lx,deltax,deltay;

dx=x2-x1;dy=y2-y1;

xmin=fmin(x1,x2);xmax=fmax(x1,x2);

ymin=fmin(y1,y2);ymax=fmax(y1,y2);

lx=xmax-xmin;ly=ymax-ymin;

deltax=(dx==0)?0:(dx>0?1:-1);

deltay=(dy==0)?0:(dy>0?1:-1);

x=x1;y=y1;

if (lx>ly){

if (dy>=0 && dx>=0)

p=2*dy-dx;

else if (dy<0 && dx>=0)

p=dx-2*dy;

else if (dy>=0 && dx<0)

p=2*dy+dx;

else

p=-2*dy+dx;

for (;x!=x2;x+=deltax){

dc->SetPixel(x,y,RGB(0,0,0));

if (p>=0){

y+=deltay;p+=2*(ly-lx);

}

else{

p+=2*ly;

}

}

}

else{

if (dy>=0 && dx>=0)

p=2*dx-dy;

else if (dy<0 && dx>=0)

p=2*dx+dy;

else if (dy>=0 && dx<0)

p=-2*dx-dy;

else

p=-2*dx+dy;

for (;y!=y2;y+=deltay){

dc->SetPixel(x,y,RGB(0,0,0));

if (p>=0){

x+=deltax;

p+=2*(lx-ly);

}

else{

p+=2*lx;

}

}

}

}

其中用到的fmax和fmin函数如下：

int fmin(int x, int y)

{

if (x<=y) return x;

return y;

}

int fmax(int x, int y)

{

if (x

return x;

}

习题4. 在本章第一节说明Bresenham算法如何选择下一个像素点位置的图2-3中，其实是假定了在当前选择的点是(x,y)时，真正直线与横坐标为x+1的直线的交点是在y和y+1之间。如果不是这样，而是下面两种情况：

(1)在y到y-1之间。例如从(0,0)到(7,2)的直线，在点(2,1)处向后。

(2)在y+1到y+2之间。例如从(0,0)到(7,5)的直线，在点(2,1)处向后。

试说明为什么对所列两种情况算法仍能正确地工作。

解答：

在给出两种情况下，Bresenham算法仍然能够正确工作的原因是判别式d保证了在这两种总情况下，仍然能正确的取到最接近真正直线的像素点。

在Bresenham算法中，按照判别式d的正负来决定选择哪一点作为下一个像素点，判别式d 如下计算：

d = d1– d2。

其中

d1 = y p– y，

d2= y + 1 – y p，

y是当前选中点(x,y)的纵坐标，y p是真正直线与横坐标为x+1的直线的交点的纵坐标。

当d>0时，取上点，即(x+1,y+1)作为下一个像素点，当d<0时，取下点，即(x+1,y)作为下一个像素点。

这里还要说明一下，因为此处是按照书上给出的Bresenham算法来进行像素选择的，所以实际上有一个先决条件，即直线的斜率处于0和1之间。只要保证斜率满足条件，在当前选择的点是(x,y)时，真正直线与横坐标为x+1的直线的交点即使不在y和y+1之间，书上所给的Bresenham都可以正确工作。题目所给两种情况中的直线斜率都满足算法的先决条件。

在第(1)种情况下，如下图所示：

当前选择点为(x,y)，下一点实际为P点，该点处于(x+1,y-1)和(x+1,y)两点之间，实际应取(x+1,y)点作为下一个像素点。现在来看一下为什么一定会取(x+1,y)点作为下一个像素点，而不是取(x+1,y-1)点作为下一个像素点。设Q点为选择(x,y)点作为显示像素点时实际的直线上的点，根据Bresenham算法的特点Q点的纵坐标y q一定满足y-0,5≤y q≤y+0.5，否则不会选择(x,y)点作为显示像素点，因为P点的纵坐标处于y和y-1之间，所以y-0.5≤y q≤y，否则该直线斜率将不满足条件（直线斜率将小于0）。当y-0,5≤y q≤y时，则一定有y-0,5≤y p≤y，因为如果y p0，由此可得d=d1-d2<0，所以要取下点(x+1,y)作为下一个像素点，跟实际应取的点是一致的，所以在这种情况下Bresenham算法仍然可以正确工作。

在第(2)种情况下，如下图所示：

当前选择点为(x,y)，下一点实际为P点，该点处于(x+1,y+1)和(x+1,y+2)两点之间，实际应取(x+1,y+1)点作为下一个像素点。现在来看一下为什么一定会取(x+1,y+1)点作为下一个像素点，而不是取(x+1,y+2)点作为下一个像素点。设Q点为选择(x,y)点作为显示像素点时实际的直线上的点，根据Bresenham算法的特点Q点的纵坐标y q一定满足y-0,5≤y q≤y+0.5，否则不会选择(x,y)点作为显示像素点，因为P点的纵坐标处于y+1和y+2之间，所以y≤y q

≤y+0.5，否则该直线斜率将不满足条件（直线斜率将大于1，因已知y p>y+1，而如果y q1，所以直线斜率大于1）。当y≤y q≤y+0.5时，则一定有y+1≤y p≤y+1+0.5，因为如果y p>y+1+0.5，同时又有y q≤y+0.5，则y p-y q>1，这时直线的斜率大于1，不满足先决条件。所以因为直线斜率先决条件的限制，当真正直线与横坐标为x+1的直线的交点是在y+1和y+2之间时，该实际交点一定更靠近(x+1,y+1)点，所以一定会取(x+1,y+1)点作为下一个像素点。再来看一下按照Bresenham算法计算会取哪一点。从图可知，因为P点纵坐标y p在y+1和y+2之间，所以有y p>y，y p>y+1，所以有d1=y p-y>0，d2=y+1-y p<0，由此可得d=d1-d2>0，所以要取上点(x+1,y+1)作为下一个像素点，跟实际应取的点是一致的，所以在这种情况下Bresenham算法仍然可以正确工作。

综上所述，虽然书中所说算法在当前选择的点是(x,y)时，假定了真正直线与横坐标为x+1的直线的交点是在y和y+1之间，但只要要绘制的直线斜率满足处于0与1之间的先决条件，那么即使真正直线与横坐标为x+1的直线的交点不是在y和y+1之间，书上所介绍的Bresenham算法仍然可以正确工作。

习题8. 本章第三节叙述了使用活跃边表的多边形扫描转换算法中ET表的填写方法。试写一个算法，输入多边形顶点坐标的逆时针序列，输出正确填写的ET表。

解答：

下面直接给出获得ET表的实现代码，为了构造书中所给样式的ET表，需要定义如下两个结构：

struct EdgeNode{//边节点

int ymax;//最大y值，吊桶数据

double xmin;//小y值端点的x值，吊桶数据

double fm;//斜率倒数，吊桶数据

EdgeNode* next;//连接下一个边

};

struct HeadNode{//头节点

int ymin;//最小y值，ET表中登记项的y值

EdgeNode* link;//连接边节点

HeadNode* next;//连接下一个头节点

};

下面的实现代码用户获得构造完成的ET的头节点的头指针。

其中参数points存放多边形的顶点的逆时针序列。

HeadNode* CTestA View::GetET(CArray* points)

{

HeadNode* pHead= NULL;

int ymin;//记录正在处理的当前边的最小y值

int nymin,nymax;//记录与正在处理的当前边连接的下一边的最小y值和最大y值

//循环点列表构造最初的边链表

for (int i=0;iGetSize();i++)

{

//获得当前点和下一点，构成一条边

CPoint point1 = (CPoint)points->GetAt(i);

CPoint point2;

//如果当前点已经是最后一个点，则和第一点构成一条边

if (i == points->GetSize() -1)

point2 = (CPoint)points->GetAt(0);

else

point2 = (CPoint)points->GetAt(i+1);

//边平行于x轴，舍弃

if (point1.y == point2.y)

continue;

//构造边结构

EdgeNode* edge = new EdgeNode();

edge->next = NULL;

//计算斜率倒数

edge->fm = (double)(point2.x - point1.x)/(point2.y - point1.y);

//设置ymin，ymax和xmin

if (point1.y > point2.y)

{

edge->ymax = point1.y;ymin = point2.y;

edge->xmin = point2.x;

}

else

{

edge->ymax = point2.y;ymin = point1.y;

edge->xmin = point1.x;

}

CPoint point3;//获得比较局部极大极小的第三点，该点和第二点够成一条边//如果前两点已经取到顶点序列尾部，则顺序从头取点作为第三点

int j = i+2;

do{

if (jGetSize())

point3 = (CPoint)points->GetAt(j);

else

point3 = (CPoint)points->GetAt(j-points->GetSize());

j++;

}while(point2.y == point3.y);

if (point2.y > point3.y){//计算point2和point3点对应的ymin和ymax nymax = point2.y;nymin= point3.y;

}

else{

nymax = point3.y;nymin= point2.y;

}

//下面判断局部极大极小并缩短相应的边

//如果连续的两条边的ymin值和ymax值都不同

//表示连接两边的节点不为局部极大或极小

if (ymin != nymin && edge->ymax != nymax)

{

//缩短当前边

//如果当前边的ymax值较大，则缩短当前边的ymin值

if (edge->ymax > nymax){

ymin++;

edge->xmin += edge->fm;

}

else//否则，缩短当前边的ymax值

edge->ymax--;

}

//以下处理将当前边加入ET表

if (pHead == NULL){//当前没有头节点

pHead = new HeadNode();

pHead->ymin = ymin;

pHead->link = edge;

pHead->next = NULL;

}

else

AddEdge(pHead,ymin,edge);

}

//返回获得的ET表头指针

return pHead;

}

在上面的实现代码中用到了一个添加边函数，该函数作用是将处理完成的一条边加入到当前已有的ET表中，该函数的实现代码如下：

void CTestA View::AddEdge(HeadNode* head, int ymin, EdgeNode* edge)

{

HeadNode* temphead;

while (head != NULL){//循环头节点

if (head->ymin == ymin){//找到了对应的头节点

EdgeNode* p = head->link;//获得头节点对应的第一条边节点

if (p->xmin > edge->xmin){//新加入边的xmin值较小

head->link = edge;

edge->next = p;

return;

}

while (p->next != NULL){//循环当前头节点下所有边节点

if (p->next->xmin > edge->xmin){

edge->next = p->next;

p->next = edge;

return;

}

p = p->next;

}

//到这里说明新加入的边的xmin值比原有的都大

p->next = edge;

return;

}

else if (head->ymin > ymin){//当前头节点的ymin值大于新加入的边的ymin //下面处理新加入头节点

HeadNode* newhead = new HeadNode();

newhead->ymin = head->ymin;

newhead->link = head->link;

newhead->next = head->next;

head->ymin = ymin;

head->link = edge;

head->next = newhead;

return;

}

temphead = head;

head = head->next;

}

//到这里说明新加入的边的ymin值比原有的头节点的ymin值都大

HeadNode* newhead = new HeadNode();

newhead->ymin = ymin;

newhead->link = edge;

newhead->next = NULL;

temphead->next = newhead;

}

获得ET的实现函数中有两处需要说明：

1、判断局部极大极小时，是用多边形顶点序列中相邻的3个点所构成的两条边进行判断，

这是要求这两个边不能存在平行于x轴的边，因为当取得point1和point2点时已经判断了确定的边是否平行于x轴，所以主要处理在于确保获得的point3点，不会和point2点同时在一条平行于x轴的直线上，如果获得的point3点与point2点的y坐标相同，就按顶点序列继续取下一点作为point3点，直到point2点的y坐标与取得的point3点的y坐标不同为止。

2、在判断不是局部极大或极小后，缩短的都是当前处理的边，这样做可以保证边一次处理

完毕，否则就会有处理当前边时，却需要去缩短以前处理的边或者还没有处理的边的情况存在。对当前边处理的方式就是如果当前边的ymax最大，则在ymin方向上缩短当前边，否则就在ymax方向上缩短当前边。

为了检测以上构造的ET表是否正确，下面编写实现了使用上面方法构造的ET表完成多边形扫描转换算法。代码如下：

void CTestA View::Polygonfill(CDC *pDC, CArray* points, COLORREF color) {

//获得ET表

HeadNode* pET = GetHEET(points);

//AET表

EdgeNode* pAET = NULL;

//最小y值

int y = pET->ymin;

//最大y值

int ymax = y;

//有需要处理的扫描线

while (y <= ymax)

{

//ET表不为空，并且当前的边的ymin和当前扫描线相等

if (pET != NULL && pET->ymin == y)

{

//将当前头节点对应的边合并到AET表中

//获得当前要合并的头节点下边链表的头指针

EdgeNode* p = pET->link;

if (pAET == NULL) pAET = p;

else{

EdgeNode* q = pAET;

while (q->next != NULL) q = q->next;

q->next = p;

}

//清除已经处理过的头节点，并释放空间

HeadNode* deletehead = pET;

pET = pET->next;

delete deletehead;

//根据移动过来的边，修改ymax值

while (p!=NULL){

if (ymax < p->ymax)

ymax = p->ymax;

p=p->next;

}

//排序

SortAET(pAET);

}

EdgeNode* pFill = pAET;

//填充AET表中的区间

while (pFill != NULL)

{

//填充当前边和下一条边之间的区间

for (int i=(int)pFill->xmin;i<=(int)pFill->next->xmin;i++) pDC->SetPixel(i,y,color);

//AET表中的边应成对出现

pFill = pFill->next->next;

}

//将AET表中ymax为当前扫描线的边清除出表

pFill = pAET;

EdgeNode* pFore = NULL;

while (pFill != NULL)

{

//当前边ymax等于扫描线

if (pFill->ymax == y)

{

if (pFore != NULL)//说明要删除的不是第一个节点

pFore->next = pFill->next;//修改上一条边的指向

else//说明要删除的是第一个节点

pAET = pFill->next;//需要修改AET表头指针指向下一条边//销毁已经清除出链表的边对象

EdgeNode* deleteedge = pFill;

//移动到下一条边

pFill = pFill->next;

delete deleteedge;

}

else{

//记录当前边作为下次处理时的上一边

pFore = pFill;

//移动到下一条边

pFill = pFill->next;

}

}

//AET表中仍然有边

if (pAET != NULL)

{

//重新计算AET中各边的xmin值

pFill = pAET;

while (pFill != NULL)

{

pFill->xmin+=pFill->fm;

pFill = pFill->next;

}

//重新排序

SortAET(pAET);

}

//处理下一条扫描线

y++;

}

}

上面代码中使用到对AET表进行排序的函数，其代码如下：

void CTestA View::SortAET(EdgeNode *pEDGE)

{

//要排序的边链表中第一个边

EdgeNode* p1 = pEDGE;

//第一个边的下一个边

EdgeNode* p2 = NULL;

while (p1 != NULL)

{

p2 = p1->next;//获得下一条边

while (p2 != NULL)

{

//如果前一条边的xmin大于后一条边

if (p1->xmin > p2->xmin)

{

//交换数据

int cid;double cdd;

cid = p1->ymax;p1->ymax = p2->ymax;p2->ymax = cid;

cdd = p1->xmin;p1->xmin = p2->xmin;p2->xmin = cdd;

cdd = p1->fm;p1->fm = p2->fm;p2->fm = cdd;

}

//下一条边

p2 = p2->next;

}

//下一条边

p1 = p1->next;

}

}

以上代码均测试通过。

习题10. 设五边形的五个顶点是（10.5，10.5）、（15，5）、（12，5）、（8，2.5）、（4，5.5），要利用使用活跃边表的扫描算法进行填充，写出应填写的ET表，写出活跃边表的变化情况。解答：

五边形如下图

根据五边形的坐标特点，并且为了尽可能的保证精度，将扫描线的步长改为0.5。相应的，在处理活跃边表的时候，计算1+i x 时应改为m i i x x 21

1+

=+。为了计算活跃边表时简便，

将ET 表中每一登记项下的“吊桶”中第三项改为m 21

。根据如上设定获得ET 表如下：

1

3

5

7

9

11

13

15

1 3 5 7

9

其中4e 和5e 进行了缩短，采用的方法是将它们的max y 减小一个步长，即0.5。所以4

e 和5e 的

max y 值分别由5和5.5变成4.5和5。根据此ET 表得到活跃边表AET 有如下变化。

5

e 4

e e e e e e e e e

e e