C语言 球面逼近程序中用户定义的归一化函数的奥秘

Question

下面的程序使用归一化函数将四面体转换为半球体。但是在规范化函数中没有调用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将每个子三角形传递给最后一行的 openGL triangle(a,b,c);这是达到递归深度限制时。低于该深度，三角形被分割。在该深度，它们被传递到图形引擎。