Sierpinski Gasket分形图的绘制

/**//*two-dimensionalSierpinskigasket*/
/**//*generatedusingrandomlyselectedvertices*/
/**//*andbisection*/

#include<GL/glut.h>

voidmyinit()
{

/**//*attributes*/
glClearColor(1.0,1.0,1.0,1.0);/**//*whitebackground*/
glColor3f(1.0,0.0,0.0);/**//*drawinred*/
}

voidreshape(intw,inth)
{
glViewport(0,0,(GLsizei)w,(GLsizei)h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,50.0,0.0,50.0);/**//*setupviewing50.0x50.0cameracoordinatewindowwithoriginlowerleft*/

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

}

voiddisplay()
{
/**//*Atriangle*/
GLfloatvertices[3][2]={{0.0,0.0},{25.0,50.0},{50.0,0.0}};
intj,k;
intrand();/**//*standardrandomnumbergenerator*/
GLfloatp[2]={7.5,5.0};/**//*arbitraryinitialpointinsidetriangle*/
glClear(GL_COLOR_BUFFER_BIT);/**//*clearthewindow*/
glBegin(GL_POINTS);

/**//*computeandplot5000newpoints*/

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*/
}

intmain(intargc,char**argv)
{

/**//*standardGLUTinitialization*/
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);/**//*default,notneeded*/
glutInitWindowSize(500,500);/**//*500x500pixelwindow*/
glutInitWindowPosition(0,0);/**//*placewindowtopleftondisplay*/
glutCreateWindow("SierpinskiGasket");/**//*windowtitle*/
glutDisplayFunc(display);/**//*displaycallbackinvokedwhenwindowopened*/
glutReshapeFunc(reshape);
myinit();/**//*setattributes*/
glutMainLoop();/**//*entereventloop*/
}

/**//*recursivesubdivisionoftriangletoformSierpinskigasket*/
/**//*numberofrecursivestepsgivenoncommandline*/

#include<GL/glut.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)

/**//*specifyonetriangle*/
{
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;
for(j=0;j<2;j++)v1[j]=(a[j]+c[j])/2;
for(j=0;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*/
}


voiddisplay()
{
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,1.0);
}

intmain(intargc,char**argv)
{
n=3;/**//*orsetnumberofsubdivisionstepshere*/
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutCreateWindow("SierpinskiGasket");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}

/**//*recursivesubdivisionofatetrahedrontoform3DSierpinskigasket*/
/**//*numberofrecursivestepsgivenoncommandline*/

#include<stdlib.h>
#include<GL/glut.h>

/**//*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}};

intn;

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];
intj;
if(m>0)
{
/**//*computesixmidpoints*/

for(j=0;j<3;j++)mid[0][j]=(a[j]+b[j])/2;
for(j=0;j<3;j++)mid[1][j]=(a[j]+c[j])/2;
for(j=0;j<3;j++)mid[2][j]=(a[j]+d[j])/2;
for(j=0;j<3;j++)mid[3][j]=(b[j]+c[j])/2;
for(j=0;j<3;j++)mid[4][j]=(c[j]+d[j])/2;
for(j=0;j<3;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);

}
else(tetra(a,b,c,d));/**//*drawtetrahedronatendofrecursion*/
}


voiddisplay()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glBegin(GL_TRIANGLES);
divide_tetra(v[0],v[1],v[2],v[3],n);
glEnd();
glFlush();
}


voidmyReshape(intw,inth)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
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);
glMatrixMode(GL_MODELVIEW);
glutPostRedisplay();
}


intmain(intargc,char**argv)
{
n=3;/**//*orenternumberofsubdivisionstepshere*/
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutCreateWindow("3DGasket");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glEnable(GL_DEPTH_TEST);
glClearColor(1.0,1.0,1.0,1.0);
glutMainLoop();
}