Opengl中的gluProject函数认识

1. 从官方说明如下

　　https://www.opengl.org/sdk/docs/man2/xhtml/gluProject.xml

　　Name　　

　　　　gluProject 　　— map object coordinates to window coordinatesC，匹配“物体坐标系”“Win窗口坐标系（坐标原点在左下方）”

　　Specification

　　　　GLint 　gluProject(GLdouble objX,  GLdouble objY,  GLdouble objZ,  const GLdouble * model,  const GLdouble * proj,  const GLint * view,  GLdouble* winX,  GLdouble* winY,  GLdouble* winZ);

　　Parameters　　

　　　　objX, objY, objZ
                    Specify the object coordinates.
                model
                    Specifies the current modelview matrix (as from a glGetDoublev call).
                proj
                    Specifies the current projection matrix (as from a glGetDoublev call).
                view
                    Specifies the current viewport (as from a glGetIntegerv call).
                winX, winY, winZ
                    Return the computed window coordinates.

　　Description
            gluProject transforms the specified object coordinates into window coordinates using model, proj, and view. The result is stored in winX, winY, and winZ. A return value of GLU_TRUE indicates success, a return value of GLU_FALSE indicates failure.

2. 使用介绍

　　把空间中的一个三维坐标转换成二维坐标，用这个gluProject函数

3. 原码分析

　　原码的写法很好 nice， 先通过看代码，来一步一步分析它的数学原理吧！既学习代码，同时也要掌握数学原理， 在这里才是成长的关键所在！

static void transform_point(GLdouble out[4], const GLdouble m[16], const GLdouble in[4])
{
#define M(row,col) m[col*4+row]
    out[0] = M(0, 0) * in[0] + M(0, 1) * in[1] + M(0, 2) * in[2] + M(0, 3) * in[3];
    out[1] = M(1, 0) * in[0] + M(1, 1) * in[1] + M(1, 2) * in[2] + M(1, 3) * in[3];
    out[2] = M(2, 0) * in[0] + M(2, 1) * in[1] + M(2, 2) * in[2] + M(2, 3) * in[3];
    out[3] = M(3, 0) * in[0] + M(3, 1) * in[1] + M(3, 2) * in[2] + M(3, 3) * in[3];
#undef M
}
// gluProject source code (说明见OpenGL API文档)
GLint gluProject(GLdouble objx, GLdouble objy, GLdouble objz,
    const GLdouble  modelMatrix[16], const GLdouble projMatrix[16],
    const GLint viewport[4], GLdouble *winx, GLdouble *winy, GLdouble *winz)
{
    // matrice transformation
    GLdouble in[4], out[4];
    //initialize matrice and column vector as a transformer
    in[0] = objx;
    in[1] = objy;
    in[2] = objz;
    in[3] = 1.0;

    transform_point(out, modelMatrix, in);  //乘以模型视图矩阵
    transform_point(in, projMatrix, out);   //乘以投影矩阵
    //齐次向量的第四项不能为0
    if(in[3] == 0.0)
        return GL_FALSE;
    //向量齐次化标准化
    in[0] /= in[3];
    in[1] /= in[3];
    in[2] /= in[3];

    //视口向量的作用
    *winx = viewport[0] + (1 + in[0]) * viewport[2] / 2;
    *winy = viewport[1] + (1 + in[1]) * viewport[3] / 2;
    *winz = (1 + in[2]) / 2;
    return GL_TRUE;
}

　　上述原码可以看出：

　　（1）观察transform_point函数中矩阵元素和列向量的相乘过程可知，这个矩阵是被转置后再和列向量相乘的。这就是为什么说OpenGL的矩阵相乘是遵循列主元的，而我们使用gluProject函数的时候输入的矩阵参数却是按照行主元的方式。

　　（2）从列向量被变换的顺序可以看出，一个齐次表示的3D点是先经过模型矩阵变换(蕴含照相机的位移、旋转、缩放等几何变换)，在进行投影变换(蕴含照相机的内参数，即本身的参数)，最后使用视口向量将齐次表示的2D点限定在当前的视口内。

　　（3）根据函数的输入输出可以看出，输入的3D点是通过直接将向量的第四个元素in[3]赋值为1而齐次化的，输出的齐次表示其实是（winx,winy,1）。winz并不是投影在视口内的2D坐 标的齐次表示的第三个元素，它携带的含义是多方面的：表面上看来，它表示了在视口上的深度值；实际上，它是由于照相机参数的不精确性（所有照相机模型都是 对实际照相机的模拟，因而不可能完全精确的表达照相机本身）和矩阵相乘过程中的计算误差所造成的；因此假如照相机参数对照相机的建模是完美的，并且计算过 程是没有误差的，那么winz的最终结果应该是0，在实际的计算中此参数所返回的值也应该是一个逼近于0的数，这个数的大小反映了误差的总量。所以我们在使用gluProject时通常不必关心winz返回的参数。

　　（4）对于返回的（winx,winy），论坛上曾有朋友发问说为什么得到的投影点和实际的点是关于图像上下倒置的。这个是因为OpenGL窗口坐标系统默认（0,0）点是窗口的左下角，而通常Windows窗口和一般图像坐标系的（0,0）点默认在左上角，因此，当我们在这种不一致的坐标系之间进行点的运算时，要先进行一步winy = height – winy; 的转换。

 

　　另一种原码解释

GLint gluProject(GLdouble objx, GLdouble objy, GLdouble objz  
                 , const GLdouble model[16], const GLdouble proj[16], const GLint viewport[4]  
                   , GLdouble * winx, GLdouble * winy, GLdouble * winz)  
  {  
       /* transformation matrix */  
      GLdouble objCoor[4];  
     GLdouble objProj[4], objModel[4];  
   
       /* initilise matrix and vector transform */  
       // 4x4 matrix must be multi to a 4 dimension vector( it a 1 x 4 matrix)  
      // so we need to put the original vertex to a 4D vector  
      objCoor[0] = objx;  
       objCoor[1] = objy;  
       objCoor[2] = objz;  
      objCoor[3] = 1.0;  
     
      // 由于原来的向量位于标准基向量(1, 0, 0), (0, 1, 0), (0, 0, 1)中，所以需要先转换到当前的模型矩阵中  
      transform_point(objModel, model, objCoor);  
     
      // 然后将模型矩阵中的顶点转换到投影矩阵所在坐标系的矩阵中  
      transform_point(objProj, proj, objModel);  
    
      // scale matrix  
     /* 
      GLdouble scaleMat[4][4] =  
      { 
           {0.5, 0, 0, objPr0j[3]}, 
          {0, 0.5, 0, objProj[3]}, 
          {0, 0, 0.5, objProj[3]}, 
          {1, 1, 1,   1} 
      }; 
   
      GLdouble objProjTemp[4]; 
       memcpy(objProjTemp, objProj, sizeof(objProjTemp); 
       transfrom_point(objProj, scaleMat, objProjTemp); 
       */  
    
      /* or the result of normalized between -1 and 1 */  
      if (objProj[3] == 0.0)  
          return GL_FALSE;  
     
      objProj[0] /= objProj[3];  
      objProj[1] /= objProj[3];  
      objProj[2] /= objProj[3];  
    
      /* in screen coordinates */  
       // 由于投影矩阵投影在[-1, 1]之间，所以需要将转换后的投影坐标放置到[0, 1]之间  
      // 最后再在一个offset 矩形中转换为屏幕坐标就可以了（viewport[4]可以简单的认为一个offset矩形）  
    
   #define SCALE_FROM_0_TO_1(_pt)  (((_pt) + 1)/2)  
       objProj[0] = SCALE_FROM_0_TO_1(objProj[0]);  
      objProj[1] = SCALE_FROM_0_TO_1(objProj[1]);  
      objProj[2] = SCALE_FROM_0_TO_1(objProj[2]);  
  #undef SCALE_FROM_0_TO_1  
    
      *winx = viewport[0] + objProj[0] * viewport[2];  
      *winy = viewport[1] + objProj[1] * viewport[3];  
    
     /* between 0 and 1 */  
      *winz = objProj[2];  
       return GL_TRUE;  
}

基本的思路就是：

　　（1）将输入的顶点，通过模型视图矩阵，变换到模型视图矩阵的坐标系中；

　　（2）将模型视图矩阵中的顶点，再变换到投影矩阵中；

　　（3）将顶点缩放到[0, 1]的映射区间中；应该是[-1, 1]。

　　（4）通过视口的位置和大小，计算出当前3D顶点中的屏幕坐标（2D坐标）；

　　其中，因为顶点缩放到[0, 1]映射后，(1 + in[0]) * viewport[2] / 2; 计算出窗口坐标中的宽度的像素，一种可能的解释是：顶点坐标缩放到[-1, 1]的范围。

　　其实gluUnproject和gluProject是非常类似的， 其实就是gluPorject反过来的过程，只是有一些数学运算要注意一下：

　　（1）首先，需要将输入的顶点，通过视口变换到[0, 1]之间；

　　（2）然后将顶点缩放到[-1, 1]之间，就是上面代码中的scaleMat矩阵的逆矩阵

　　（3）然后乘上投影矩阵的逆矩阵；

　　（4）最后就是乘上模型视图矩阵的逆矩阵；