Sphere.cpp

Go to the documentation of this file.

/**
 *\file         Sphere.cpp
 *
 *\brief        
 *
 *\author       Xianming Chen
 *
 *\date         16 Jul 2004
 */


#include "Sphere.h"
#include "TriangleMesh.h"
#include "xmath.h"


namespace columbia
{

  void TriangulateSphere(TriangleMesh &msh, int depth)
  {
    const float X = .525731112119133606;
    const float Z = .850650808352039932;
    float vdata[12][3] = {    
      {-X, 0.0, Z}, {X, 0.0, Z}, {-X, 0.0, -Z}, {X, 0.0, -Z},    
      {0.0, Z, X}, {0.0, Z, -X}, {0.0, -Z, X}, {0.0, -Z, -X},    
      {Z, X, 0.0}, {-Z, X, 0.0}, {Z, -X, 0.0}, {-Z, -X, 0.0} 
    };
    int tindices[20][3] = { 
      {0,4,1}, {0,9,4}, {9,5,4}, {4,5,8}, {4,8,1},    
      {8,10,1}, {8,3,10}, {5,3,8}, {5,2,3}, {2,7,3},    
      {7,10,3}, {7,6,10}, {7,11,6}, {11,0,6}, {0,1,6}, 
      {6,1,10}, {9,0,11}, {9,11,2}, {9,2,5}, {7,2,11} };

    msh.V.clear(), msh.N.clear(), msh.T.clear(), msh.F.clear();
    
    for(int i=0; i<12; i++)
    {
      msh.V.push_back( Vertex(vdata[i][0], vdata[i][1], vdata[i][2]) );
    }
  
    for(int i=0; i<20; i++)
    {
      msh.F.push_back( TriangleFace(tindices[i][0], tindices[i][1], tindices[i][2],  -1, -1, -1, tindices[i][0], tindices[i][1], tindices[i][2]) );
    }
    for(int d=1; d<depth; d++)  
    {
      int faces = msh.F.size();
      for(int f=0; f < faces; ++f)
      {
        int i = msh.F[0].i, j = msh.F[0].j, k = msh.F[0].k;
        
        Vertex v1 = msh.V[i];
        Vertex v2 = msh.V[j];
        Vertex v3 = msh.V[k];

        Vertex v12 = ((v1 + v2) / 2).GetUnit();
        Vertex v13 = ((v1 + v3) / 2).GetUnit();
        Vertex v23 = ((v3 + v2) / 2).GetUnit();

        int ij = msh.V.size();
        msh.V.push_back(v12);
        
        int ik = msh.V.size();
        msh.V.push_back(v13);
        
        int jk = msh.V.size();
        msh.V.push_back(v23);
        
        msh.F.erase( msh.F.begin() );
        
        msh.F.push_back( TriangleFace(i, ik, ij,  -1, -1, -1, i, ik, ij) );
        msh.F.push_back( TriangleFace(j, jk, ij,  -1, -1, -1, j, jk, ij) );
        msh.F.push_back( TriangleFace(k, ik, jk,  -1, -1, -1, k, ik, jk) );
        msh.F.push_back( TriangleFace(jk, ik,ij,  -1, -1, -1, jk, ik,ij) );
      }
    }
    msh.N = msh.V;
    msh.init();
  }

    
  void ParametrizeSphere(TriangleMesh & msh, int slicesV, int slicesH)
  {
    msh.V.clear(), msh.N.clear(), msh.T.clear(), msh.F.clear();
    
    double theta_step = pi / slicesV, theta = theta_step;
    msh.V.push_back( Vertex(0, -1, 0) );                         // south pole
    for(int i = 1; i < slicesV; ++i, theta += theta_step)
    {
      double phi = 0, phi_step = 2 * pi / slicesH;

      for(int j = 0; j < slicesH; ++j, phi += phi_step)
      {
        msh.V.push_back( Vertex(sin(theta) * sin(phi-pi),  -cos(theta), sin(theta) * cos(phi-pi) ) );
        msh.T.push_back( Vertex(phi / (2*pi), theta / pi) );
      }
      msh.T.push_back( Vertex(1.0, theta / pi) );
    }
    msh.V.push_back( Vertex(0, 1, 0) );                         // north pole


    for(int i=0; i<slicesV; ++i)
    {
      for(int j=0; j<slicesH; ++j)
      {
        int tex0 = i * (slicesH+1) + j;                                     // tex indices
        int tex1 = tex0 + 1;
        int tex2 = tex1 + (slicesH+1);
        int tex3 = tex2 - 1;         

        if(i==0)
        {
          msh.F.push_back( TriangleFace(0,    j,    j+1 == slicesH ? 0 : j+1,
                                        tex0, tex1, tex2,      
                                        0,    j,    j+1 == slicesH ? 0 : j+1) );               // same indices for normals as for vertices.
          continue;
        }

        // cur quad is (i,j) to (i+1, j+1).
        // (i,j) vertex has an index = i * slicesH + j 
        int idx0 = 1 + (i-1) * slicesH + j;
        int idx1 = idx0 + 1;
        int idx2 = idx1 + slicesH;
        int idx3 = idx2 - 1;                                                // idx0, idx1, idx2, idx3: counter clockwise order

        if(i+1 == slicesV)
        {
          msh.F.push_back( TriangleFace(idx0, j+1 == slicesH ? msh.V.size() - slicesH - 1 : idx1,  msh.V.size() - 1,
                                        tex0, tex1,                                                tex2,      
                                        idx0, j+1 == slicesH ? msh.V.size() - slicesH - 1 : idx1,  msh.V.size() - 1) );
          continue;
        }
          
        if(j+1 == slicesH)                                                                     // last vertex == first vertex in each horizontal direction.  
        {
          idx1 = 1 + (i-1) * slicesH, idx2 = 1 + i * slicesH;
        }
        
        msh.F.push_back( TriangleFace(idx0, idx1, idx2,                   // triangle (i,j)->(i, j+1)->(i+1, j+1)       
                                      tex0, tex1, tex2,      
                                      idx0, idx1, idx2) );                // same indices for normals.

        msh.F.push_back( TriangleFace(idx0, idx2, idx3,                   // triangle (i,j)->(i+1, j+1)->(i, j+1)       
                                      tex0, tex2, tex3,      
                                      idx0, idx2, idx3) );                // same indices for normals.
      }
    }

    msh.N = msh.V;

    msh.init();
  }
  

}//end namespace xchen

---