南昌大学信工学院计算机图形学实验报告(附详细代码).doc

实 验 报 告

实验课程： 计算机图形学
学生姓名： XXX
学 号： XXX
专业班级： 计算机科学与技术X班

20XX年XX月XX日

目录

实验一 直线和圆的生成 3

实验二 区域填充 12

实验三 裁剪算法 15

实验四 Bezier曲线的绘制 23

实验五 B样条曲线的绘制 27

南昌大学实验报告
学生姓名： 学 号： 专业班级：
实验类型：□ 验证 □ 综合 □ 设计 □ 创新 实验日期： 实验成绩：
实验一 直线和圆的生成
一、实验项目名称
直线和圆的生成
二、实验目的
1、掌握DDA、Bresenham 直线生成算法；
2、掌握中点画圆生成算法
三、实验要求
1、编程实现DDA、Bresenham算法生成直线
2、编程实现中点画圆的算法
四、实验步骤
1、根据实验要求分析实验，并写出相应算法的实现
2、选择适当语言实现算法；
3、调试程序。
五、实验内容
1、Bresenham画线算法的实现
#include<gl\glut.h>
#include<stdlib.h>
#include<math.h>
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,600.0,0.0,500.0);
}
void setPixel(int x,int y)
{
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}
void lineBres(int x0,int y0,int xEnd,int yEnd)
{
int dx=abs(xEnd-x0),dy=abs(yEnd-y0);
int p=2*dy-dx;

int twoDy=2*dy,twoDyMinusDx=2*(dy-dx);
int x,y;

if(x0>xEnd){
x=xEnd;
y=yEnd;
}
else{
x=x0;
y=y0;
}
setPixel( x, y);
while(x<xEnd){
x++;
if(p<0)
p+=twoDy;
else{
y++;

p+=twoDyMinusDx;
}
setPixel( x, y);
}

}

void lineSegment(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
lineBres(50,50,400,300);
glFlush();
}

void main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(400,300);
glutCreateWindow("An Line OpenGL Program");

init();
glutDisplayFunc(lineSegment);
glutMainLoop();
}

2、DDA算法的实现
#include<gl\glut.h>
#include<math.h>
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,600.0,0.0,500.0);
}

void setPixel(int x,int y)
{
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}

inline int round(const float a)
{
return int(a+0.5);
}
void lineDDA (int x0,int y0,int xEnd,int yEnd)
{
int dx=xEnd-x0,dy=yEnd-y0,steps,k;
float xIncrement,yIncrement,x=x0,y=y0;
if(abs(dx)>abs(dy))
steps=abs(dx);
else
steps=abs(dy);
xIncrement=GLfloat(dx)/GLfloat(steps);
yIncrement=GLfloat(dy)/GLfloat(steps);
setPixel( x, y);

for(k=0;k<steps;k++){
x+=xIncrement;
y+=yIncrement;
setPixel( x, y);
}
}

void lineSegment(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
lineDDA(50,50,400,300);
glFlush();
}

void main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(400,300);
glutCreateWindow("DDA OpenGL Program");

init();
glutDisplayFunc(lineSegment);
glutMainLoop();
}

3、圆的生成
#include<gl\glut.h>
#include <math.h>
const int n = 20;
const GLfloat R = 0.5f;
const GLfloat Pi = 3.1415926536f;
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,200.0,0.0,150.0);
}
void myDisplay(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
for(i=0; i<n; ++i)
glVertex2f(R*cos(2*Pi/n*i), R*sin(2*Pi/n*i));
glEnd();
glFlush();
}
void main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(500,500);
glutCreateWindow("An Circle OpenGL Program");

init();
glutDisplayFunc(myDisplay);
glutMainLoop();
return ;
}

4、修改后的圆的生成
#include <GL/glut.h>
#include <math.h>
const int n = 20;
const GLfloat R = 0.5f;
const GLfloat Pi = 3.1415926536f;
void myDisplay(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
for(i=0; i<n; ++i)
glVertex2f(R*cos(2*Pi/n*i), R*sin(2*Pi/n*i));
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
glutInitWindowPosition(100, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("画圆的程序");
glutDisplayFunc(&myDisplay);
glutMainLoop();
return 0
}

5、中点画圆算法
#include<gl/glut.h>
#include<stdlib.h>
#include<math.h>

void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,200.0,0.0,150.0);
}

class screenPt
{
private:
GLint x,y;
public:
screenPt(){
x=y=0;
}
void setCoords(GLint xCoordValue,GLint yCoordValue){
x=xCoordValue;
y= yCoordValue;
}

GLint getx() const{
return x;
}
GLint gety() const{
return y;
}
void incrementx(){
x++;
}
void decrementy(){
y--;
}
};

void setPixel(GLint xCoord,GLint yCoord)
{
glBegin(GL_POINTS);
glVertex2i(xCoord,yCoord);
glEnd();
}

void circleMidpoint(GLint xc,GLint yc,GLint radius)
{
screenPt circPt;
GLint p=1-radius;
circPt.setCoords(0,radius);
void cieclePlotPoints(GLint,GLint,screenPt);
cieclePlotPoints(xc,yc,circPt);
while(circPt.getx()<circPt.gety()){
circPt.incrementx();
if (p < 0)
p += 2 * circPt.getx() + 1;
else {
circPt.decrementy();
p += 2 * (circPt.getx() - circPt.gety()) + 1;
}
cieclePlotPoints(xc,yc,circPt);
}

}

void cieclePlotPoints(GLint xc,GLint yc,screenPt circPt)
{
setPixel(xc+circPt.getx(),yc+circPt.gety());
setPixel(xc-circPt.getx(),yc+circPt.gety());
setPixel(xc+circPt.getx(),yc-circPt.gety());
setPixel(xc-circPt.getx(),yc-circPt.gety());
setPixel(xc+circPt.gety(),yc+circPt.getx());
setPixel(xc-circPt.gety(),yc+circPt.getx());
setPixel(xc+circPt.gety(),yc-circPt.getx());
setPixel(xc-circPt.gety(),yc-circPt.getx());
}

void myDisplay(void)

{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,1.0,0.0);
circleMidpoint(50,50,20);
glFlush();

void main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(400,300);
glutCreateWindow("A Circle OpenGL Program");

init();
glutDisplayFunc(myDisplay);
glutMainLoop();
}

六、实验结果
Bresenham画线算法的实现： DDA算法的实现：

圆的生成： 中点画圆算法：

七、实验心得
课本上有画直线和中点画圆的核心代码，只要加上main函数和窗口定义等的基本函数，稍微修改就可以得到完整的程序，比较简单。

南昌大学实验报告
学生姓名： 学 号： 专业班级：
实验类型：□ 验证 □ 综合 □ 设计 □ 创新 实验日期： 实验成绩：
实验二 区域填充
一、实验项目名称
区域填充
二、实验目的
1、理解区域的表示方法，能正确区分并应用区域的连通性；
2、掌握基于边界、内点的区域填充算法；
3、掌握边界标志算法进行多边形扫描转换的程序实现方法；
4、掌握边界种子填充算法进行区域填充的程序实现方法
三、实验要求
编程实现种子填充算法
四、实验步骤
1、根据实验要求分析实验，并写出相应算法的实现
2、选择适当语言实现算法；
3、调试程序。
五、实验内容
1、输入种子点坐标(x, y)、填充色、边界颜色
2、种子像素入栈；当栈非空时重复执行如下三步操作：
(1)栈顶像素出栈；
(2)将出栈像素置成填充色；
(3)检查出栈像素的4-邻接点，若其中某个像素点不是边界色且未置成多边形色，则把该像素入栈。

实验代码如下：
#include<GL/glut.h>
#include<stdlib.h>
#include<math.h>
#include<windows.h>

void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,400.0,0.0,400.0);//初始化投影窗口，保持与显示的窗口一致
}

void setPixel(int x,int y,long fillColor)//自定义的setPixel函数
{
glColor3f(fillColor<<16,fillColor<<8,fillColor);
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}

void boundaryFill4(int x,int y,long fillColor,long borderColor)//递归的边界填充算法
{
unsigned char params[3];//定义存储颜色的数组
long interiorColor;//定义内部颜色
glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,params);//读取当前像素点的颜色
interiorColor=RGB(params[0],params[1],params[2]);//内部颜色的获取
if(interiorColor!=borderColor&&interiorColor!=fillColor)//递归
{
setPixel(x,y,fillColor);
boundaryFill4(x+1,y,fillColor,borderColor);//右边
boundaryFill4(x-1,y,fillColor,borderColor);//左边
boundaryFill4(x,y+1,fillColor,borderColor);//上边
boundaryFill4(x,y-1,fillColor,borderColor);//下边
}
}

void lineSegment(void)
{
long borderColor=RGB(0,255,0);//定义边界颜色
long fillColor=RGB(0,0,255);//定义填充颜色
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0,255,0);//画填充的多边形，简单起见，画了一个正方形
glBegin(GL_LINE_LOOP);
glVertex2i(50,50);
glVertex2i(80,50);
glVertex2i(80,80);
glVertex2i(50,100);
glEnd();
boundaryFill4(55,55,fillColor,borderColor);//调用递归函数
glFlush();
}

void main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(400,400);//保持与投影窗口尺寸一致
glutCreateWindow("种子填充算法程序");
init();
glutDisplayFunc(lineSegment);
glutMainLoop();
}

六、实验结果

七、实验心得
区域填充指的是在输出平面的闭合区域内完整地填充某种颜色或图案。种子填充在掌握了“栈”这一抽象数据类型的实现方法的前提下，比较容易完成。
南昌大学实验报告
学生姓名： 学 号： 专业班级：
实验类型：□ 验证 □ 综合 □ 设计 □ 创新 实验日期： 实验成绩：
实验三 裁剪算法
一、实验项目名称
裁剪算法
二、实验目的
掌握Sutherland-Cohen 直线裁剪算法
三、实验要求
实现Sutherland-Cohen 直线裁剪算法
四、实验步骤
1、根据实验要求分析实验，并写出相应算法的实现；
2、选择适当语言实现算法；
3、调试程序。
五、实验内容
Cohen-Sutherland 算法：
任意平面线段和矩形窗口的位置关系只会有如下3种：
a.完全落在窗口内。
b.完全落在窗口外。
c.部分落在窗口内，部分落在窗口外。
要想判断线段和窗口的位置关系，只要找到线段的两端点相对于矩形窗口的位置即可.
线段的两端点相对于矩形窗口的位置可能会有如下几种情况:
a.线段的两个端点均在窗口内，这时线段全部落在窗口内，完全可见，应予以保留。
b.线段的两个端点均在窗口边界线外同侧，这时线段全部落在窗口外，完全不可见，应予以舍弃。
c.线段的一个端点在窗口内，另一个端点在窗口外，这时线段部分可见，应求出线段与窗口边界线的交点，从而得到线段在窗口内的可见部分。
d.线段的两个端点均不在窗口内，但不处于窗口边界线外同侧，这时有可能线段是部分可见的，也可能是完全不可见的。
Cohen-Sutherland裁剪算法就是按照上述思路来对线段进行裁剪的，只是在线段的两端点相对于矩形窗口的位置上，巧妙地运用了编码的思想。
首先，如下图所示，延长窗口的四条边界线，将平面划分成9个区域，然后，用四位二进制数C3C2C1C0对这9个区域进行编码，编码规则如下：
1001 1000 1010
0001 0000 0010
0101 0100 0110
第0位C0：当线段的端点在窗口的左边界之左时，该位编码为1，否则，该位编码为0。
第1位C1：当线段的端点在窗口的右边界之右时，该位编码为1，否则，该位编码为0。
第2位C2：当线段的端点在窗口的下边界之下时，该位编码为1，否则，该位编码为0。
第3位C3：当线段的端点在窗口的上边界之上时，该位编码为1，否则，该位编码为0。
于是算法步骤可描述如下：
步骤1：根据上述编码规则，对线段的两个端点进行编码。
步骤2：根据线段的两端点编码判断线段相对于窗口的位置关系，从而决定对线段如何剪。取两端点编码全为0000时，说明线段完全位于窗口内，是完全可见的，于是显示此线段。两端点编码逐位逻辑与不为0时，说明线段的两个端点位于窗口外同侧，即此线段完全位于窗口外，是完全不可见的，于是全部舍弃，不显示此线段。
两端点编码逐位逻辑与为0时，说明此线段或者部分可见，或者完全不可见。此时需要计算出线段与窗口某一边界线或边界线的延长线的交点，若交点在窗口边界线的延长线上，则说明该线段完全位于窗口外，不予以显示；若交点在窗口边界线上，则对以其中一个交点为分割点的两端线段，再分别对其端点进行编码，并按照上述（1）和（2）所示的方法进行测试，从而舍弃完全位于窗口外的一段线段，保留并显示完全位于窗口内的一段线段。

实验代码如下：
#include<stdlib.h>
#include<math.h>
#include<GL/glut.h>

void init (void){
glClearColor(1.0,1.0,1.0,1.0);
glMatrixMode (GL_PROJECTION);
gluOrtho2D(0.0,200.0,0.0,150.0);
}

void setPixel (GLint xCoord,GLint yCoord){
glBegin(GL_POINTS);
glVertex2i (xCoord,yCoord);
glEnd();
}

void setrect (){//绘制矩形裁剪窗口
glColor3f(1.0,0.0,0.0);
int point1[]={90,20};
int point2[]={150,20};
int point3[]={150,140};
int point4[]={90,140};
glBegin(GL_LINE_STRIP);
glVertex2iv(point1);
glVertex2iv(point2);
glVertex2iv(point3);
glVertex2iv(point4);
glVertex2iv(point1);
glEnd();
glFlush();
}

void lineBres (int x0,int y0,int xEnd,int yEnd){//绘制直线
glColor3f(1.0,0.0,0.0);
int dx=abs(xEnd-x0),dy=abs(yEnd-y0);
int p=2*dy-dx;
int twoDy=2*dy,twoDyMinusDx=2*(dy-dx);
int x,y;
if(x0>xEnd){
x=xEnd;
y=yEnd;
xEnd=x0;
}
else{
x=x0;
y=y0;
}
setPixel(x,y);
while(x<xEnd){
x++;
if(p<0)
p+=twoDy;
else{
y++;
p+=twoDyMinusDx;
}
setPixel(x,y);
}
glFlush();
}

void lineBres2 (int x0,int y0,int xEnd,int yEnd){//绘制裁剪后的直线
glColor3f(1.0,1.0,1.0);
int dx=abs(xEnd-x0),dy=abs(yEnd-y0);
int p=2*dy-dx;
int twoDy=2*dy,twoDyMinusDx=2*(dy-dx);
int x,y;
if(x0>xEnd){
x=xEnd;
y=yEnd;
xEnd=x0;
}
else{
x=x0;
y=y0;
}
setPixel(x,y);
while(x<xEnd){
x++;
if(p<0)
p+=twoDy;
else{
y++;
p+=twoDyMinusDx;
}
setPixel(x,y);
}
glFlush();
}

class wcPt2D
{
public:
GLfloat x,y;
};

inline GLint round(const GLfloat a){return GLint(a+0.5);}
const GLint winleftbitcode=0x1;
const GLint winrightbitcode=0x2;
const GLint winbottombitcode=0x4;
const GLint wintopbitcode=0x8;

inline GLint inside(GLint code){return GLint(!code);}
inline GLint reject(GLint code1,GLint code2)
{return GLint(code1&code2);}
inline GLint accept(GLint code1,GLint code2)
{return GLint(!(code1|code2));}

GLubyte encode(wcPt2D pt,wcPt2D winmin,wcPt2D winmax)
{
GLubyte code=0x00;
if(pt.x<winmin.x)
code=code|winleftbitcode;
if(pt.x>winmax.x)
code=code|winrightbitcode;
if(pt.y<winmin.y)
code=code|winbottombitcode;
if(pt.y>winmax.y)
code=code|wintopbitcode;
return (code);
glFlush();
}

void swapPts(wcPt2D *p1,wcPt2D *p2)
{
wcPt2D tem;
tem=*p1;
*p1=*p2;
*p2=tem;
glFlush();
}

void swapcodes(GLubyte *c1,GLubyte *c2)
{
GLubyte tem;
tem=*c1;
*c1=*c2;
*c2=tem;
glFlush();
}

void lineclipCohSuth()
{
glColor3f(1.0,0.0,0.0);//裁剪线的颜色
wcPt2D winmin,winmax;
winmin.x=90.0;
winmin.y=20.0;
winmax.x=150.0;
winmax.y=140.0;
wcPt2D p1,p2;
p1.x=20.0;
p1.y=50.0;
p2.x=200.0;
p2.y=100.0;
setrect ();
lineBres(round(p1.x),round(p1.y),round(p2.x),round(p2.y));
GLubyte code1,code2;
GLint done=false,plotline=false;
GLfloat m;
while(!done){
code1=encode(p1,winmin,winmax);
code2=encode(p2,winmin,winmax);
if(accept(code1,code2)){
done=true;
plotline=true;
}
else
if(reject(code1,code2))
done=true;
else{
if(inside(code1)){
swapPts(&p1,&p2);
swapcodes(&code1,&code2);
}
if(p2.x!=p1.x)
m=(p2.y-p1.y)/(p2.x-p1.x);
if(code1&winleftbitcode){
p1.y+=(winmin.x-p1.x)*m;
p1.x=winmin.x;
}
else
if(code1&winrightbitcode){
p1.y+=(winmax.x-p1.x)*m;
p1.x=winmax.x;
}
else
if(code1&winbottombitcode){
if(p2.x!=p1.x)
p1.x+=(winmin.y-p1.y)/m;
p1.y=winmin.y;
}
else
if(code1&wintopbitcode){
if(p2.x!=p1.x)
p1.x+=(winmax.y-p1.y)/m;
p1.y=winmax.y;
}

}

}
if(plotline)

lineBres2(round(p1.x),round(p1.y),round(p2.x),round(p2.y));
glFlush();
}

void main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE |GLUT_RGB );
glutInitWindowPosition(50, 100);
glutInitWindowSize(400, 300);
glutCreateWindow("裁剪算法");
init();
glutDisplayFunc(lineclipCohSuth);
glutMainLoop();
}

六、实验结果

七、实验心得
通过这个实验，我掌握了Sutherland-Cohen 直线裁剪算法，希望在以后的实验中能够再接再厉，做得更好！

南昌大学实验报告
学生姓名： 学 号： 专业班级：
实验类型：□ 验证 □ 综合 □ 设计 □ 创新 实验日期： 实验成绩：
实验四 Bezier曲线的绘制
一、实验项目名称
Bezier曲线的绘制
二、实验目的
1、掌握Bezier曲线的定义生成算法；
2、掌握参数化曲线曲面的原理和方法。
3、理解参数化曲线曲面的基本性质，特别是Bezier曲线的基本性质。
4、掌握型值点和控制顶点以及控制多边形的概念，理解控制点对曲线的控制作用。
三、实验要求
实现Bezier曲线的算法
四、实验步骤
1、根据实验要求分析实验，并写出相应算法的实现
2、选择适当语言实现算法；
3、调试程序。
五、实验内容
Bezier曲线的定义：
给定空间n+1个点的位置矢量Pi（i=0,1,2,…,n）
则Bezier曲线可定义为：

其中，Pi构成该Bezier曲线的特征多边形。
实验代码如下：
#include<GL/glut.h>
#include<stdio.h>
#include<math.h>

GLsizei winWidth=700,winHeight=700;
GLfloat xwcMin=-50,xwcMax=50;
GLfloat ywcMin=-50,ywcMax=50;

class wcpt3D
{
public: