计算机图形学期末编程大作业

完成下列程序的设计、调试与及设计说明书：

一、实现直线、圆的生成

要求：（1）算法不限；（2）直线的端点、圆的圆心、半径由用户实时输入；（3）用所实现的直线、圆的生成程序实现一个任意图形的绘制。

二、实现区域填充（多边形区域）或影线填充

要求：（1）区域自行指定，至少应有一个内环（2）算法：计算机相关专业的要求实现图案填充，机械相关专业的要求实现影线填充。

三、直线段裁剪算法的实现

要求：完成对一个指定图形（见图）的裁剪，先在图形

区显示原始图形及窗口位置，然后将裁剪后图形的显示在图

形区的另一侧。

四、凸多面体消隐的实现（外法线法）

要求：立体数据自定。

五、样条曲线的实现

要求：实现B样条曲线，并能通过交互输入点的形式完成曲

线绘制。

注意：要反求控制点

六、平时成绩（30分）

要求：

1、语言不限，可以是所熟悉的如何一种语言。

2、须提交的内容包括：源程序（电子版）、可执行程序，设计说明书（电子版及打印版）。

3、程序须经教师运行测试通过。

4、设计说明书B5页面打印，内容包括：算法与数据结构，程序流程说明及变量，程序运行情况分析及结果截图，程序使用说明。

题目一：实现直线、圆的生成

要求：（1）算法不限；（2）直线的端点、圆的圆心、半径由用户实时输入；（3）用所实现的直线、圆的生成程序实现一个任意图形的绘制。

1.程序使用说明.

1）概述

该程序以Visual C++6.0作为编程开发工具，利用其中的MFC（Microsoft Foundation Classes）库作为应用程序的框架，进行图形的编程绘制，有良好的用户操作界面和简洁的操作方法。

执行该程序，界面如下图。

图1-1 程序运行界面

图形绘制功能的实现，主要是通过点选菜单栏中的对应菜单项来实现。主要功能有：图形颜色的选择、绘制直线、绘制圆。

2）具体操作说明：

a.颜色的选择.

鼠标左键单击菜单项，便会弹出颜色编辑对话框，如图2。

图1-2 颜色编辑对话框

可以通过鼠标左键点选对话框中的颜色实例，或者是自行编辑颜色值，来确定用户想要生成图形的颜色。下面的绘图过程，我们以黑色为例。

b.直线的绘制

图1-3 直线参数对话框

鼠标左键点选菜单栏中的菜单，会弹出下拉菜单，其中提供2种直线绘制的经典算

法，包括DDA算法和Bresenham算法。我们可随意选择一种，例如Bresenham算法。

说表左键单击选定后，便会弹出参数输入对话框，如图3。

注意：由于在计算机的图形显示时，屏幕坐标默认以屏幕左上角点为（0，0）点，X轴方向水平指向右侧，Y轴方向竖直指向下侧。与我们实际中熟悉的坐标系不同，输入点坐标时要注意。例如直线的起止点坐标分别为（0，0）、（100，100），绘制结果如图5。

图1-5 绘制结果

如果输入的坐标值超出了设定的范围，将弹出提示对话框，如下图所示：

c.圆的绘制

鼠标左键点选菜单栏中的菜单，会弹出下拉菜单，Bresenham算法。

则弹出对话框如图5。

图1-5 圆参数输入界面

根据对话框的要求，填入元的基本参数值：圆心坐标值和半径值。

注意：界面上对输入的数值的要求。程序的默认窗体中，图形显示空间为宽度大小为700个像素值，高为428个像素值。全屏条件下，图形显示空间为宽度大小为1024个像素值，高为644个像素值。

我们选择圆心在（350，220）的位置，半径取200像素值。图形效果如下图6。

图1-6 圆形的绘制

2.程序算法说明.

1) 直线的绘制

a.数值微分法DDA(Digital Differential Analyzer简称DDA)

对任何沿直线给定的x的增量△x，可以从下式中计算出y的增量△y：

同样，可以得出对应于指定的△y的x增量△x：

对斜率绝对值|k|<1的线段，即与水平夹角小于45°时，让x从起点到终点变化，每步递增(或递减)1：令△x=±1，则△y=±k。若前一次的直线上像素点坐标为(x i，y i)，这一次的直线上像素点坐标为(x i+1,y i+1)，则x i+l=x i±1，y i+1=y i±k随后输出该像素的颜色值即可。

对于斜率绝对值|k|>1的线段，让y从起点到终点变化，每步递增(或递减)1，计算对应的x增量，△x=±1/k。若前一次的直线上像素点坐标为(x i，y i)，这一次的直线上像素点坐标为(x i+1，y i+1)，则x i+1=x i±1/k，y i+l=y i±1随后输出该像素的颜色值即可。

b. Bresenham算法

1965年，Bresenham提出了一种更好的直线生成算法，称为Bresenham算法。此算法的一个主要思想是借助于一个决策变量dk，来确定下一个该点亮的像素点。对于直线斜率k在0～1之间的情况，从给定线段的左端点(x1，y1)开始，逐步处理每个后续列(x位置)，并在扫描线y 值最接近线段的像素上绘出一点。

2) Bresenham画圆算法

Bresenham画法与中点画法一样，也考虑从（0，R）到（R/2，R/2）的八分之一圆周。取(0，R)为起点，按顺时针方向生成圆。从这段圆弧的任意一点出发，按顺时针方向生成圆时，为了最佳逼近该圆，下一像素的取法只有三种可能的选择：正右方像素，右下方像素和正下方像素。这三个像素中，与理想圆弧最近者为所求像素。

3.主要程序段

/**********DDA直线算法*************/

void CA View::OnDDALine()

{ // TODO: Add your command handler code here

CClientDC dc(this); CDlg_LinePoint dlgDDAline; int Xs=1; double dx; double e;

int Ys=1; double dy; int Xe=1; double x; int Ye=1; double y;

if(dlgDDAline.DoModal()==IDOK)

{ Xs=dlgDDAline.m_Xs;

Ys=dlgDDAline.m_Ys;

Xe=dlgDDAline.m_Xe;

Ye=dlgDDAline.m_Ye; }

if(Xe>700||Ye>428)

MessageBox("图像超出范围，请在全屏下运行，否则将显示不完全！");

if(Xe>1024||Ye>644)

MessageBox("图像超出范围，将显示不完全！");

dx = Xe - Xs; dy = Ye - Ys; e = (fabs(dx)>fabs(dy)) ? fabs(dx):fabs(dy); dx /= e; dy /= e;

x = Xs; y = Ys;

for(int i=1; i<=e; i++)

{

dc.SetPixel((int)(x+0.5),(int)(y+0.5),m_clr);

x+=dx;

y+=dy;

}

}

/****************算法结束*********************/

/**********Bresenham直线算法**************/

void CA View::OnBresenhamLine()

{ // TODO: Add your command handler code here

CClientDC dc(this);

CDlg_LinePoint dlgBresenhamline;

int Xs=1; int Ys=1; int Xe=1; int Ye=1; int x,y,p; int dx,dy;

if(dlgBresenhamline.DoModal()==IDOK)

{ Xs=dlgBresenhamline.m_Xs;

Ys=dlgBresenhamline.m_Ys;

Xe=dlgBresenhamline.m_Xe;

Ye=dlgBresenhamline.m_Ye; }

//使传入的端点坐标X值相等

if(Xs==Xe)

{ if(Ys

{ for ( int i=Ys; i<=Ye; i++)

dc.SetPixel(Xs,i,m_clr); }

else

{ for ( int i=Ye; i<=Ys; i++)

{dc.SetPixel(Xs,i,m_clr);} }

return;

}

BOOL m=(fabs(Ye-Ys)<=fabs(Xe-Xs));

//如果Xs大于Xe的值，交换坐标值

if(Xs>Xe)

{ p=Xs;Xs=Xe;Xe=p;

p=Ys;Ys=Ye;Ye=p; }

x=Xs; y=Ys;

dx = Xe - Xs;

dy = Ye - Ys;

if(Xe>700||Ye>428)

MessageBox("图像超出范围，请在全屏下运行，否则将显示不完全！");

if(Xe>1024||Ye>644)

MessageBox("图像超出范围，将显示不完全！");

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

if(m)

{ //情况一：Y递增

if(Ys<=Ye)

{ p=(dy<<1)-dx;

while(x<=Xe)

{ dc.SetPixel(x,y,m_clr);

if(p<0)

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

else

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

}

//情况二：Y递减

else

{ p=dx-(dy<<1);

while(x<=Xe)

{ dc.SetPixel(x,y,m_clr);

if(p<0)

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

else

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

}

}

//斜率绝对值大于1

else

{ //情况三：Y递增

if(Ys<=Ye)

{ p=(dx<<1)-dy;

while(y<=Ye)

{ dc.SetPixel(x,y,m_clr);

if(p<0)

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

else

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

}

}

//情况四：Y递减

else

{ p=(dx<<1)+dy;

while(y>=Ye)

{ dc.SetPixel(x,y,m_clr);

if(p<0)

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

else

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

}

}

}

/*************算法结束*****************/

/**************Bresenham画法*************/

void CA View::OnBresenhamCircle()

{ // TODO: Add your command handler code here

int X0=1;

int Y0=1;

int R=1;

int x,y,p;

CClientDC dc(this);

CDlg_SetCircle dlgMidPointcircle;

if(dlgMidPointcircle.DoModal()==IDOK)

{ X0=dlgMidPointcircle.m_X0;

Y0=dlgMidPointcircle.m_Y0;

R=dlgMidPointcircle.m_R ;}

if(X0+R>700||Y0+R>428||X0-R<0||Y0-R<0)

MessageBox("图像超出范围，请在全屏下运行，否则将显示不完全！");

if(X0+R>1024||Y0+R>644||X0-R<0||Y0-R<0)

MessageBox("图像超出范围，将显示不完全！");

x=0;y=R; p=3-(R<<1);

for(;x<=y;x++)

{ dc.SetPixel( x+X0, y+Y0, m_clr);

dc.SetPixel(-x+X0, y+Y0, m_clr);

dc.SetPixel( x+X0,-y+Y0, m_clr);

dc.SetPixel(-x+X0,-y+Y0, m_clr);

dc.SetPixel( y+X0, x+Y0, m_clr);

dc.SetPixel(-y+X0, x+Y0, m_clr);

dc.SetPixel( y+X0,-x+Y0, m_clr);

dc.SetPixel(-y+X0,-x+Y0, m_clr);

if(p<0)

p+=((x<<2)+6);

else

{ p+=(((x-y)<<2)+10);

y--; }

}

}

/**************算法结束*****************/

题目二：实现区域填充（多边形区域）或影线填充

要求：（1）区域自行指定，至少应有一个内环（2）算法：计算机相关专业的要求实现图案填充，机械相关专业的要求实现影线填充。

1.程序使用说明.

1）概述

同样利用VC++6.0的MFC来进行程序编写。与之前所编写的程序所用的方式相同。有绘制直线、矩形和椭圆等单独功能。

按下鼠标左键拖动，我们可以绘制由直线、矩形、椭圆构成的任意复杂图形。默认所绘出的图形边线颜色为黑色。

选择填充方式和颜色：

图2-3 填充方式选择

图2-4 选择填充颜色

填充时，要注意利用鼠标右键点选一个封闭的区域。填充过程中，也可以更换不同的填充颜色。如果点在开放部分或者是不封闭的图形处，程序可能会发生溢出。

图2-5 填充结果

2.程序算法说明.

本程序利用种子填充算法，以像素为基础，依据区域内的连通性进行图形的填充。从指定的填充点（称为种子）出发，遍历光栅像素网格，找出从种子出发可以达到而又不穿过边界的所有像素。

3.主要程序段[仅附阴影线画法

void CTianChongView::ScanlineSeedshadow(CDC *pDC, int x, int y, COLORREF boundaryvalue, COLORREF newvalue)

{ int x0,x1,xr,y0; int flag, xnextspan,xid; CDlg_FillType dlg;

stack s; //定义堆栈CPoint p;

s.push(CPoint(x,y)); //将第一个种子入栈

while(!s.empty()) //如果堆栈不为空

{ p=s.top(); //取栈顶元素并弹出

s.pop();

pDC->SetPixel(p.x,p.y,newvalue);//绘制像素点为指定颜色

x=p.x; y=p.y; x0= x+1;

while(pDC->GetPixel(x0,y)!=boundaryvalue) //填充右方的像素

{ if(x0%m_ndensity==y%m_ndensity)

{pDC->SetPixel(x0,y,newvalue);}

x0=x0+1; }

xr = x0-1; x0= x-1;

while(pDC->GetPixel(x0,y)!=boundaryvalue) //填充左方像素

{ if(x0%m_ndensity==y%m_ndensity)

{pDC->SetPixel(x0,y,newvalue);}

x0=x0-1; }

x1=x0+1; //最左侧的像素值

//检查上一条和下一条扫描线，若存在是边界且未填充的像素

//则选区代表个连续区域的种子像素入栈

y0=y;

for (int i=1; i>=-1;i-=2)

{ x0=xr;

y=y0+i;

while (x0>=x1)

{ flag = 0;

while ((pDC->GetPixel(x0,y)!=boundaryvalue)

&&(pDC->GetPixel(x0,y)!=newvalue)

&&(x0>x1))

{ if(x0%m_ndensity==y%m_ndensity)/**按指定宽度绘制阴影线**/ {if(flag==0)

{ flag=1;

xid=x0; }}

x0=x0--; }

if(flag==1)

{ s.push(CPoint(xid,y)); //新种子入栈

flag=0; }

xnextspan=x0;

while((pDC->GetPixel(x0,y)==boundaryvalue)

||(pDC->GetPixel(x0,y)==newvalue)

&&(x0>=x1))

x0=x0--;

if(xnextspan==x0)

x0=x0--; }

}

}

}

题目三：直线段裁剪算法的实现

要求：完成对一个指定图形（见右图）的裁剪，先在图形区显示原始图形及窗口位置，然后将裁剪后图形的显示在图形区的另一侧。

1. 程序使用说明.

1）概述

同样利用VC++中的MFC编制程序。窗口左侧显示此案件窗口和待裁剪图形，窗口右侧显示此案件结果。

图3-1 指定图形

2）具体操作说明

点选菜单上的剪裁按钮，弹出Cohn-Sutherland算法项，点击确认。按下鼠标左键拖动即可绘制出裁剪窗口，利用鼠标右键绘制指定图形在窗口附近便自动完成剪裁，在右窗口输出。

图3-2 程序界面

图3-3 绘出裁剪窗口

图3-4 裁剪结果

3. 主要程序段

/***********对区域进行编码判断***********/

void CCutOutView::Makecode(CPoint Point, int &Code)

{ int x = Point.x; int y = Point.y; Code = 0;

/***********区域编码判断**********/

//若端点在裁剪窗口左侧，则设置Code区域编码为0001

if(x

Code = 1;

//若端点在裁剪窗口右侧，则设置Code区域编码为0010

else if (x > m_RBPoint.x)

Code = 2;

//若端点在裁剪窗口下侧，则设置Code区域编码为0100

if(y

Code += 4;

//若端点在裁剪窗口上侧，则设置Code区域编码为1000

else if (y>m_LTPoint.y)

Code += 8;}

/*****************Cohen_Sutherland剪裁程序**********************/

void CCutOutView::Cohen_Sutherland(CPoint &BPoint, CPoint &EPoint)

{ CPoint bPoint = BPoint; CPoint ePoint = EPoint; int c, cb, ce; int x,y;

Makecode(bPoint,cb); Makecode(ePoint,ce);

while(cb!=0||ce!=0)

{ if((cb & ce)!=0)

{ BPoint = EPoint ;

return; }

c = cb; /***B、E在四边的同侧***/

if(c==0) c=ce;

/**************逐边进行裁剪并计算交点****************/

/***起点在窗口左侧***/

if(c & 1)

{ y=bPoint.y + (ePoint.y - bPoint.y) * (m_LTPoint.x - bPoint.x)/(ePoint.x - bPoint.x);

x = m_LTPoint.x; }

/***裁剪后的起点若在窗口右侧***/

else if(c & 2)

{ y=bPoint.y+(ePoint.y-bPoint.y) * (m_RBPoint.x - bPoint.x)/(ePoint.x - bPoint.x);

x = m_RBPoint.x; }

/***裁剪后的起点若在窗口上侧***/

else if(c & 4)

{

x=bPoint.x + (ePoint.x - bPoint.x) * (m_RBPoint.y - bPoint.y)/(ePoint.y - bPoint.y);

y = m_RBPoint.y;

}

/***裁剪后的起点若在窗口下侧***/

else if(c & 8)

{

x=bPoint.x + (ePoint.x - bPoint.x) * (m_LTPoint.y - bPoint.y)/(ePoint.y - bPoint.y);

y = m_LTPoint.y;

}

if(c == cb)

{

bPoint = CPoint(x,y);

Makecode(bPoint,cb);

}

else

{ ePoint = CPoint(x,y);

Makecode(ePoint,ce); }

} BPoint = bPoint;

EPoint = ePoint;

}/*******************程序段完毕***********************/

题目四：凸多面体消隐的实现（外法线法）

要求：立体数据自定。

1.程序使用说明

利用MFC编程。运行界面如右图。按照界面上的操作要求即可实现对四方台边线的消隐，视觉上实现四方台的旋转。利用键盘上的“↑”、“↓”、“←”、“→”四个方向键，可以调整视角的位置，从不同角度观察四方台。

图4-1程序界面

图4-2程序运行的效果图

2.外法线法

外法线法的主要思想就是利用立体图形各个面的外法线向量与观察点的坐标向量的夹角做比较，对于简单的凸多面体，如果面得外法线向量与观察点的视向量夹角大于180度，则判定该表面背向观察点，做消隐处理，如果外法线向量与视向量夹角小于180度，则判定该表面可以被看到，显示出来。

3. 主要代码段

void CFirstView::DrawFace(CDC*pDC,int nIndex)

{ int p[4];

for(int k=0;k<4;k++)

{p[k]=Face[nIndex][k]; }

pDC->MoveTo(tmpPt[p[0]][0],tmpPt[p[0]][1]);

pDC->LineTo(tmpPt[p[1]][0],tmpPt[p[1]][1]);

pDC->LineTo(tmpPt[p[2]][0],tmpPt[p[2]][1]);

pDC->LineTo(tmpPt[p[3]][0],tmpPt[p[3]][1]);

pDC->LineTo(tmpPt[p[0]][0],tmpPt[p[0]][1]);

}

void CFirstView::DrawHideCube()

{/*四方台8个顶点坐标值*/

Pt[1][0]=100; Pt[1][1]=100; Pt[1][2]=100;

Pt[2][0]=200; Pt[2][1]=100; Pt[2][2]=100;

Pt[3][0]=180; Pt[3][1]=120; Pt[3][2]=200;

Pt[4][0]=120; Pt[4][1]=120; Pt[4][2]=200;

Pt[5][0]=100; Pt[5][1]=200; Pt[5][2]=100;

Pt[6][0]=200; Pt[6][1]=200; Pt[6][2]=100;

Pt[7][0]=180; Pt[7][1]=180; Pt[7][2]=200;

Pt[8][0]=120; Pt[8][1]=180; Pt[8][2]=200;

int nNumberFaces=6;

/**********定义面表**************/

Face[1][0]=1; Face[1][1]=2; Face[1][2]=3; Face[1][3]=4;

Face[2][0]=2; Face[2][1]=6; Face[2][2]=7; Face[2][3]=3;

Face[3][0]=6; Face[3][1]=2; Face[3][2]=1; Face[3][3]=5;

Face[4][0]=1; Face[4][1]=4; Face[4][2]=8; Face[4][3]=5;

Face[5][0]=5; Face[5][1]=8; Face[5][2]=7; Face[5][3]=6;

Face[6][0]=3; Face[6][1]=7; Face[6][2]=8; Face[6][3]=4;

double alpha= alpha1*PI/180.0;//绕Z轴旋转的角度

double beta = beta1*PI/180.0;//绕X轴旋转的角度

//计算投影变换后的坐标

int tx, ty, tz;

tx=ty=tz=200;

/***将立方体八顶点进行平移变换***/

for(int i=1;i<9;i++)

{

Pt[i][0] -= tx;

Pt[i][1] -= ty;

Pt[i][2] -= tz;

}

for(i=1;i<9;i++)

{

tmpPt[i][0] = Pt[i][0]*cos(alpha) - Pt[i][1]*sin(alpha)+tx;

tmpPt[i][1] = Pt[i][0]*sin(alpha) * cos(beta) + Pt[i][1] * cos(alpha) * cos(beta) - Pt[i][2] * sin(beta) + ty;

tmpPt[i][2] = Pt[i][0]*sin(alpha) * sin(beta) + Pt[i][1] * cos(alpha) * sin(beta) - Pt[i][2] * cos(beta) + tz;

}

int p[4];

double xn,yn,zn,vn;//定义法线矢量

CDC *pDC = this->GetDC();

CPen pen1(PS_SOLID, 5, m_clr);//对于可见面，线宽设定为5个像素

CPen pen2(PS_DOT, 1,m_clr); //对不可见面，线宽设定为1个像素

CPen *pOldPen = pDC->SelectObject(&pen1);

for(i=1;i

{

for(int k=0; k<4; k++)

{

p[k]=Face[i][k];

}

double x1 =tmpPt[p[0]][0];

double y1 =tmpPt[p[0]][1];

double z1 =tmpPt[p[0]][2];

double x2 =tmpPt[p[1]][0];

double y2 =tmpPt[p[1]][1];

double z2 =tmpPt[p[1]][2];

double x3 =tmpPt[p[2]][0];

double y3 =tmpPt[p[2]][1];

double z3 =tmpPt[p[2]][2];

/**计算外法线矢量****/

/* | i j k |

| x2-x1 y2-y1 z2-z1 |

| x3-x2 y3-y2 z3-z2 | */

xn = (y2-y1)*(z3-z2) - (y3-y2)*(z2-z1);

yn = -(x2-x1)*(z3-z2) + (x3-x2)*(z2-z1);

zn = (x2-x1)*(y3-y2) - (x3-x2)*(y2-y1);

vn = sqrt(xn*xn + yn*yn + zn* zn);

xn=xn/vn; yn=yn/vn; zn=zn/vn;//

/****设置视点位置在Z轴无穷远处，此处近似取(0,0,1000)********/ /*当法向矢量Z轴方向的分量大于0且与视线方向的夹角小于90度时，可见*/ if(zn>=0.0)

{

pDC->SelectObject(&pen1);

DrawFace(pDC,i);

}

pDC->SelectObject(pOldPen);

}

this->ReleaseDC(pDC);

}

题目五：样条曲线的实现