球体逼近程序中用户定义归一化函数的奥秘

Question

下面的程序使用归一化函数将四面体转换为半球体。但是在 normalize 函数中没有调用 OpenGL 函数。只有少数变量的值被改变，甚至没有传递给其他函数。此功能如何规范化？

    #include<stdio.h>
    #include<GL/glut.h>
    #include<math.h>
    GLfloat v[4][3]={{0.0,0.0,1.0},{0.0,1.0,0.0},{-1.0,-0.5,0.0},{1.0,-0.5,0.0}};
    int n;
    GLfloat theta[3]={0,0,0};
    int axis=2;

    void normalize(GLfloat *pt)
    {
        double d=0;
        int i;
        for(i=0;i<3;i++)
            d+=pt[i]*pt[i];
        d=sqrt(d);
        if(d>0)
            for(i=0;i<3;i++)
                pt[i]/=d;
    }
    void triangle(GLfloat* a,GLfloat* b,GLfloat* c)
    {
    //  glBegin(GL_POLYGON);
        glBegin(GL_LINE_LOOP);
         glVertex3fv(a);
         glVertex3fv(b);
         glVertex3fv(c);
        glEnd( );
    }

    void divide_triangle(GLfloat* a,GLfloat* b,GLfloat* c,int m)
    {
        GLfloat v1[3],v2[3],v3[3];
        int j;

        if(m>0)
        {
            for(j=0;j<3;j++)
            {
                v1[j]=(a[j]+b[j])/2;
                v2[j]=(a[j]+c[j])/2;
                v3[j]=(c[j]+b[j])/2;
            }

            normalize(v1);         // normalize function called from here
            normalize(v2);
            normalize(v3);

            divide_triangle(a,v1,v2,m-1);
            divide_triangle(c,v2,v3,m-1);
            divide_triangle(b,v3,v1,m-1);
            divide_triangle(v1,v2,v3,m-1);
        }
        else
            triangle(a,b,c);
    }

    void tetrahedron(int m)
    {
    //  glColor3f(0,1,0);                       // green
    //  divide_triangle(v[3],v[2],v[1],m);                      // bottom face of semi-sphere
        glColor3f(1,0,0);                       // red
        divide_triangle(v[0],v[1],v[2],m);
        glColor3f(0,0,1);                       // blue
        divide_triangle(v[0],v[3],v[1],m);
        glColor3f(0,0,0);                       // black
        divide_triangle(v[0],v[2],v[3],m);
    }
    void spin()
    {
        theta[axis]=theta[axis]+0.05;
        if(theta[axis]>0.06)
            theta[axis]=0;
        glutPostRedisplay();
    }
    void mouse(int btn,int state, int x,int y)
    {
        if(btn==GLUT_LEFT_BUTTON&&state==GLUT_DOWN)
            axis=0;
        if(btn==GLUT_RIGHT_BUTTON&&state==GLUT_DOWN)
            axis=1;
        if(btn==GLUT_MIDDLE_BUTTON&&state==GLUT_DOWN)
            axis=2;
    }

    void display()
    {
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
        glEnable(GL_DEPTH_TEST);
        glRotatef(theta[0],1,0,0);   // x-axis spin
        glRotatef(theta[1],0,1,0);   // y-axis spin
        glRotatef(theta[2],0,0,1);   // z-axis spin

        tetrahedron(n);
        glFlush( );
    }

    void myinit( )
    {
        glClearColor(1,1,1,1);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity( );
        glOrtho(-2,2,-2,2,-2,2);
        glMatrixMode(GL_MODELVIEW);
    }

    void main()
    {
        printf("No of divisions : ");
        scanf("%d",&n);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
        glutInitWindowSize(500,500);
        glutCreateWindow("3D SEMI SPHERE APPROXIMATION BY SIERPINSKI GASKET ");
        glutDisplayFunc(display);
        glutIdleFunc(spin);
        glutMouseFunc(mouse);
        myinit( );
        glutMainLoop( );
    }

Answer 1

程序有自己的归一化功能。通过找到每条边的中点，将每个三角形面递归地分成四个大小相等的较小三角形。这些中点位于球体表面的错误位置，因此使用归一化函数使每个插值点距球体中心的半径与现有点的半径相等。递归越深，它越接近球体。

我不知道为什么你觉得 normalize 函数很神秘。这是一种完全正常的（请原谅双关语）缩放三个分量的方式，使它们的大小为 1（除非全部为 0）。

递归函数divide_triangle 在最后一行triangle(a,b,c); 中将每个子三角形传递给openGL，这是在达到递归深度限制时。在该深度以下，三角形被分开。在那个深度，它们被传递给图形引擎。

球体逼近程序中用户定义归一化函数的奥秘

The mystery of user defined normalize function in sphere approximation program

c

opengl

graphics

glut