SphereMesh.cc

Go to the documentation of this file.

#include <esg/mesh/SphereMesh.h>
#include <assert.h>

using namespace esg;

/*
 * Topology of initial solid:
 */ 

const Vector3 SphereMesh::INIT_VERTICES [6] = 
{
    Vector3( 0,  1,  0),
    Vector3(-1,  0,  0),
    Vector3( 0,  0,  1),
    Vector3( 1,  0,  0),
    Vector3( 0,  0, -1),
    Vector3( 0, -1,  0)
};

const unsigned SphereMesh::FIRST_FACET_VERTICES   [3] = {0, 1, 2};
const unsigned SphereMesh::SECOND_FACET_VERTICES  [3] = {0, 2, 3};
const unsigned SphereMesh::THIRD_FACET_VERTICES   [3] = {0, 3, 4};
const unsigned SphereMesh::FOURTH_FACET_VERTICES  [3] = {0, 4, 1};
const unsigned SphereMesh::FIFTH_FACET_VERTICES   [3] = {5, 2, 1};
const unsigned SphereMesh::SIXTH_FACET_VERTICES   [3] = {5, 3, 2};
const unsigned SphereMesh::SEVENTH_FACET_VERTICES [3] = {5, 4, 3};
const unsigned SphereMesh::EIGHTH_FACET_VERTICES  [3] = {5, 1, 4};

const Vector3 SphereMesh::FIRST_FACET_NORMALS [3] =
{
    INIT_VERTICES[FIRST_FACET_VERTICES[0]],
    INIT_VERTICES[FIRST_FACET_VERTICES[1]],
    INIT_VERTICES[FIRST_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::SECOND_FACET_NORMALS [3] =
{
    INIT_VERTICES[SECOND_FACET_VERTICES[0]],
    INIT_VERTICES[SECOND_FACET_VERTICES[1]],
    INIT_VERTICES[SECOND_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::THIRD_FACET_NORMALS [3] =
{
    INIT_VERTICES[THIRD_FACET_VERTICES[0]],
    INIT_VERTICES[THIRD_FACET_VERTICES[1]],
    INIT_VERTICES[THIRD_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::FOURTH_FACET_NORMALS [3] =
{
    INIT_VERTICES[FOURTH_FACET_VERTICES[0]],
    INIT_VERTICES[FOURTH_FACET_VERTICES[1]],
    INIT_VERTICES[FOURTH_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::FIFTH_FACET_NORMALS [3] =
{
    INIT_VERTICES[FIFTH_FACET_VERTICES[0]],
    INIT_VERTICES[FIFTH_FACET_VERTICES[1]],
    INIT_VERTICES[FIFTH_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::SIXTH_FACET_NORMALS [3] =
{
    INIT_VERTICES[SIXTH_FACET_VERTICES[0]],
    INIT_VERTICES[SIXTH_FACET_VERTICES[1]],
    INIT_VERTICES[SIXTH_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::SEVENTH_FACET_NORMALS [3] =
{
    INIT_VERTICES[SEVENTH_FACET_VERTICES[0]],
    INIT_VERTICES[SEVENTH_FACET_VERTICES[1]],
    INIT_VERTICES[SEVENTH_FACET_VERTICES[2]]
};

const Vector3 SphereMesh::EIGHTH_FACET_NORMALS [3] =
{
    INIT_VERTICES[EIGHTH_FACET_VERTICES[0]],
    INIT_VERTICES[EIGHTH_FACET_VERTICES[1]],
    INIT_VERTICES[EIGHTH_FACET_VERTICES[2]]
};




/*
 * Methods definition:
 */


void SphereMesh::_mesh(unsigned actDepth, unsigned maxDepth)
{
  if (actDepth == maxDepth) return;

  /*
   * firstly split all edges:
   */
  int         newVert = -1;
  Vector3     v;
  Mesh::Vert* pVert;
  Mesh::Edge* pE = pSolid->first_edge;
  Mesh::Edge* pLastEdge = pSolid->first_edge->previous_edge;
  assert(pE);

  do {
      v.set(pE->V1->x, pE->V1->y, pE->V1->z);
      v.add(Vector3(pE->V2->x, pE->V2->y, pE->V2->z));
      v.scale(.5);
      v.normalize();
      pVert = NewVertex(pSolid, v.x, v.y, v.z);
      _store_vertex(pVert);
      if (newVert == -1) newVert = pVert->jmeno_vrcholu;
      pVert->normal.set(v);
      pVert->normal.set(v);
      (void) _split_edge(pE, pVert);
      pE = pE->next_edge;
  } while (pE->previous_edge != pLastEdge);


  /*
   * then split facets:
   */
  unsigned     vindex[3];
  Vector3      fnormal;
  Vector3      auxv;
  Mesh::Vert*  vin;
  Mesh::Vert*  vout;
  Mesh::Vert*  pV1;
  Mesh::Vert*  pV2;
  Mesh::Plane* pP         = pSolid->first_plane;
  Mesh::Plane* pLastPlane = pP->previous_plane;
  Mesh::Plane* pAuxP;
  do {
      for (int i = 0; i < 3; i++) {
          pE = pP->any_edge;
          Orient_Edge(pE, pP, &vin, &vout);
          while (vout->jmeno_vrcholu < newVert)
              pE = Next_Edge_in_loop(pE,&vin,&vout);
          pV1 = vout;
          vindex[0] = vout->jmeno_vrcholu;
          pE = Next_Edge_in_loop(pE,&vin,&vout);
          vindex[1] = vout->jmeno_vrcholu;
          pE = Next_Edge_in_loop(pE,&vin,&vout);
          vindex[2] = vout->jmeno_vrcholu;
          pV2 = vout;
          pAuxP = _split_plane(pP, pV1, pV2);
          assert(pAuxP);
          fnormal.set(_plane_normal(vindex,0,1,2));
          auxv.set(vout->x, vout->y, vout->z);
          pAuxP->a = fnormal.x;
          pAuxP->b = fnormal.y;
          pAuxP->c = fnormal.z;
          pAuxP->d = -fnormal.dot(auxv);
      }
      pP = pP->next_plane;
  } while (pP->previous_plane != pLastPlane);
  
  _mesh(actDepth+1, maxDepth);
}



//----------------------- public -----------------------------------

SphereMesh::SphereMesh(unsigned recursion)
    : PolygonalMesh(INIT_VERTICES, 6)
{
    bool ok = true;

    if (ok) ok = addFacet(FIRST_FACET_VERTICES,
                          FIRST_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(SECOND_FACET_VERTICES,
                          SECOND_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(THIRD_FACET_VERTICES,
                          THIRD_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(FOURTH_FACET_VERTICES,
                          FOURTH_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(FIFTH_FACET_VERTICES,
                          FIFTH_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(SIXTH_FACET_VERTICES,
                          SIXTH_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(SEVENTH_FACET_VERTICES,
                          SEVENTH_FACET_NORMALS,
                          3);

    if (ok) ok = addFacet(EIGHTH_FACET_VERTICES,
                          EIGHTH_FACET_NORMALS,
                          3);

    if (ok && pSolid) _mesh(0, recursion);
}

---