交互式计算机图形学实 例 程 序Word格式.docx
《交互式计算机图形学实 例 程 序Word格式.docx》由会员分享，可在线阅读，更多相关《交互式计算机图形学实 例 程 序Word格式.docx（79页珍藏版）》请在冰豆网上搜索。
GLfloatvertices[3][2]={{0.0,0.0},{25.0,50.0},{50.0,0.0}};
inti,j,k;
intrand（）;
/*standardrandomnumbergenerator*/
GLfloatp[2]={7.5,5.0};
/*anarbitraryinitialpointinsidetraingle*/
glClear（GL_COLOR_BUFFER_BIT）;
/*clearthewindow*/
glBegin（GL_POINTS）;
/*computeandplots5000newpoints*/
for（k=0;
k<
5000;
k++）
{
j=rand（）%3;
/*pickavertexatrandom*/
/*Computepointhalfwaybetweenselectedvertexandoldpoint*/
p[0]=（p[0]+vertices[j][0]）/2.0;
p[1]=（p[1]+vertices[j][1]）/2.0;
/*plotnewpoint*/
glVertex2fv（p）;
}
glEnd（）;
glFlush（）;
/*clearbuffers*/
voidmain（intargc,char**argv）
/*StandardGLUTinitialization*/
glutInit（&
argc,argv）;
glutInitDisplayMode（GLUT_SINGLE|GLUT_RGB）;
/*default,notneeded*/
glutInitWindowSize（500,500）;
/*500×
500pixelwindow*/
glutInitWindowPosition（0,0）;
/*placewindowtopleftondisplay*/
glutCreateWindow（"
SierpinskiGasket"
）;
/*windowtitle*/
glutDisplayFunc（display）;
/*displaycallbackinvokedwhenwindowopened*/
myinit（）;
/*setattributes*/
glutMainLoop（）;
/*entereventloop*/
A.2生成Sierpinski镂垫的递归程序
/*RecursivesubdivisionoftriangletoformSierpinskigasket*/
/*numberofrecursivestepsgivenoncommandline*/
#include<
stdlib.h>
/*initialtriangle*/
GLfloatv[3][2]={{-1.0,-0.58},{1.0,-0.58},{0.0,1.15}};
intn;
voidtriangle（GLfloat*a,GLfloat*b,GLfloat*c）
/*displayonetriangle*/
glVertex2fv（a）;
glVertex2fv（b）;
glVertex2fv（c）;
voiddivide_triangle（GLfloat*a,GLfloat*b,GLfloat*c,intm）
/*trianglesubdivisionusingvertexnumbers*/
GLfloatv0[2],v1[2],v2[2];
intj;
if（m>
0）
for（j=0;
j<
2;
j++）v0[j]=（a[j]+b[j]）/2;
j++）v1[j]=（a[j]+c[j]）/2;
j++）v2[j]=（b[j]+c[j]）/2;
divide_triangle（a,v0,v1,m-1）;
divide_triangle（c,v1,v2,m-1）;
divide_triangle（b,v2,v0,m-1）;
elsetriangle（a,b,c）;
/*drawtriangleatendofrecursion*/
glClear（GL_COLOR_BUFFER_BIT）;
glBegin（GL_TRIANGLES）;
divide_triangle（v[0],v[1],v[2],n）;
glEnd（）;
glFlush（）;
voidmyinit（）
glMatrixMode（GL_PROJECTION）;
glLoadIdentity（）;
gluOrtho2D（-2.0,2.0,-2.0,2.0）;
glMatrixMode（GL_MODELVIEW）;
glClearColor（1.0,1.0,1.0,1.0）;
glColor3f（0.0,0.0,0.0）;
voidmain（intargc,char**argv）
n=atoi（argv[1]）;
/*orsetnumberofsubdivisionstepshere*/
glutInit（&
glutInitDisplayMode（GLUT_SINGLE|GLUT_RGB）;
glutInitWindowSize（500,500）;
glutCreateWindow（"
glutDisplayFunc（display）;
myinit（）;
glutMainLoop（）;
A.3三维Sierpinski镂垫的递归程序
/*Recursivesubdivisionofatetrahedrontoform3DSierpinskigasket*/
/*initialtetrahedron*/
GLfloatv[4][3]={{0.0,0.0,1.0},{0.0,0.942809,-0.33333},
{-0.816497,-0.471405,-0.333333},{0.816497,-0.471405,-0.333333}};
GLfloatcolors[4][3]={{1.0,0.0,0.0},{0.0,1.0,0.0},
{0.0,0.0,1.0},{0.0,0.0,0.0}};
voidtriangle（GLfloat*va,GLfloat*vb,GLfloat*vc）
glVertex3fv（va）;
glVertex3fv（vb）;
glVertex3fv（vc）;
voidtetra（GLfloat*a,GLfloat*b,GLfloat*c,GLfloat*d）
glColor3fv（colors[0]）;
triangle（a,b,c）;
glColor3fv（colors[1]）;
triangle（a,c,d）;
glColor3fv（colors[2]）;
triangle（a,d,b）;
glColor3fv（colors[3]）;
triangle（b,d,c）;
voiddivide_tetra（GLfloat*a,GLfloat*b,GLfloat*c,GLfloat*d,intm）
GLfloatmid[6][3];
0）
{
/*computesixmidpoints*/
3;
j++）mid[0][j]=（a[j]+b[j]）/2;
j++）mid[1][j]=（a[j]+c[j]）/2;
j++）mid[2][j]=（a[j]+d[j]）/2;
j++）mid[3][j]=（b[j]+c[j]）/2;
j++）mid[4][j]=（c[j]+d[j]）/2;
j++）mid[5][j]=（b[j]+d[j]）/2;
/*create4tetrahedronsbysubdivision*/
divide_tetra（a,mid[0],mid[1],mid[2],m-1）;
divide_tetra（mid[0],b,mid[3],mid[5],m-1）;
divide_tetra（mid[1],mid[3],c,mid[4],m-1）;
divide_tetra（mid[2],mid[4],d,mid[5],m-1）;
elsetetra（a,b,c,d）;
/*drawtetrahedronatendofrecursion*/
glClear（GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT）;
glBegin（GL_TRIANGLES）;
divide_tetra（v[0],v[1],v[2],v[3],n）;
glEnd（）;
voidmyReshape（intw,inth）
glViewport（0,0,w,h）;
if（w<
=h）
glOrtho（-2.0,2.0,-2.0*（GLfloat）h/（GLfloat）w,
2.0*（GLfloat）h/（GLfloat）w,-10.0,10.0）;
else
glOrtho（-2.0*（GLfloat）w/（GLfloat）h,
2.0*（GLfloat）w/（GLfloat）h,-2.0,2.0,-10.0,10.0）;
glutPostRedisplay（）;
n=atoi（argv[1]）;
/*orenternumberofsubdivisionstepshere*/
glutInitDisplayMode（GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH）;
glutInitWindowSize（500,500）;
3DGasket"
glutReshapeFunc（myReshape）;
glEnable（GL_DEPTH_TEST）;
glClearColor（1.0,1.0,1.0,1.0）;
A.4Marching-Square程序
/*generatescontoursusingmarchingsquares*/
/*regionsize*/
#defineX_MAX1.0
#defineY_MAX1.0
#defineX_MIN-1.0
#defineY_MIN-1.0
/*numberofcells*/
#defineN_X50
#defineN_Y50
/*contourvalue*/
#defineTHRESHOLD0.0
gl/glut.h>
voiddisplay（）
doublef（double,double）;
intcell（double,double,double,double）;
voidlines（int,int,int,double,double,double,double）;
doubledata[N_X][N_Y];
inti,j;
intc;
/*formdataarrayfromfunction*/
for（i=0;
i<
N_X;
i++）
for（j=0;
j<
N_Y;
j++）
data[i][j]=f（X_MIN+i*（X_MAX-X_MIN）/（N_X-1.0）,
Y_MIN+j*（Y_MAX-Y_MIN）/（N_Y-1.0））;
/*processeachcell*/
c=cell（data[i][j],data[i+1][j],data[i+1][j+1],data[i][j+1]）;
lines（c,i,j,data[i][j],data[i+1][j],data[i+1][j+1],data[i][j+1]）;
}
/*definefunctionf（x,y）*/
doublef（doublex,doubley）
doublea=0.49,b=0.5;
/*ovalsofCassini*/
return（x*x+y*y+a*a）*（x*x+y*y+a*a）-4*a*a*x*x-b*b*b*b;
/*definecellvertices*/
intcell（doublea,doubleb,doublec,doubled）
intn=0;
if（a>
THRESHOLD）n+=1;
if（b>
THRESHOLD）n+=8;
if（c>
THRESHOLD）n+=4;
if（d>
THRESHOLD）n+=2;
returnn;
/*drawlinesegmentsforeachcase*/
voidlines（intnum,inti,intj,doublea,doubleb,doublec,doubled）
voiddraw_one（int,int,int,double,double,double,double）;
voiddraw_adjacent（int,int,int,double,double,double,double）;
voiddraw_opposite（int,int,int,double,double,double,double）;
switch（num）
case1:
case2:
case4:
case7:
case8:
case11:
case13:
case14:
draw_one（num,i,j,a,b,c,d）;
break;
case3:
case6:
case9:
case12:
draw_adjacent（num,i,j,a,b,c,d）;
case5:
case10:
draw_opposite（num,i,j,a,b,c,d）;
case0:
case15:
voiddraw_one（intnum,inti,intj,doublea,doubleb,doublec,doubled）
doublex1,y1,x2,y2;
doubleox,oy;
doubledx,dy;
dx=（X_MAX-X_MIN）/（N_X-1.0）;
dy=（Y_MAX-Y_MIN）/（N_Y-1.0）;
ox=X_MIN+i*（X_MAX-X_MIN）/（N_X-1.0）;
oy=Y_MIN+j*（Y_MAX-Y_MIN）/（N_Y-1.0）;
x1=ox;
y1=oy+dy*（THRESHOLD-a）/（d-a）;
x2=ox+dx*（THRESHOLD-a）/（b-a）;
y2=oy;
x2=ox+dx*（THRESHOLD-d）/（c-d）;
y2=oy+dy;
case4:
x1=ox+dx*（THRESHOLD-d）/（c-d）;
y1=oy+dy;
x2=ox+dx;
y2=oy+dy*（THRESHOLD-b）/（c-b）;
x1=ox+dx*（THRESHOLD-a）/（b-a）;
y1=oy;
glBegin（GL_LINES）;
glVertex2d（x1,y1）;
glVertex2d（x2,y2）;
voiddraw_adjacent（intnum,inti,intj,doublea,doubleb,doublec,doubled）
case3:
voiddraw_opposite（intnum,inti,intj,doublea,doubleb,doublec,doubled）
doublex1,y1,x2,y2,x3,y3,x4,y4;
case5:
x3=ox+dx*（THRESHOLD-d）/（c-d）;
y3=oy+dy;
x4=ox+dx;
y4=oy+dy*（THRESHOLD-b）/（c-b）;
升级会员 