Layout.cpp

Go to the documentation of this file.

#include "Layout.h"
#include "Mesh.h"
#include "CirclePattern.h"
#include "util.h"
#include <iomanip>
#include <fstream>

using namespace std;

Layout::Layout(Mesh * _mesh) {
   mesh = _mesh;
}



bool Layout::validCuts() {

   bool result = true;

   // Number of connected components
   int numConnectedComponents = 0;
   Mesh::FaceIterator fIter = mesh->faceIterator();
   for (; !fIter.end(); fIter++) {
      fIter.face()->check = false;
   }
   stack<Edge *> toVisit;
   for (fIter.reset(); !fIter.end(); fIter++) {
      if (!fIter.face()->check) {
          numConnectedComponents++;
          toVisit.push(fIter.face()->edge);
          while (!toVisit.empty()) {
             Face * fIn = toVisit.top()->face; 
             toVisit.pop();
             fIn->check = true;     
             fIn->patchID = numConnectedComponents-1;
             Face::EdgeAroundIterator iter = fIn->iterator();
             for (; !iter.end(); iter++) {
                iter.edge()->patchID       = numConnectedComponents-1;
                iter.edge()->pair->patchID = numConnectedComponents-1;
                iter.vertex()->patchID     = numConnectedComponents-1;
                if (iter.edge()->pair->face && !iter.edge()->pair->face->check)
                    toVisit.push(iter.edge()->pair);
             }
          }
      }
   }

   double * eulerNums = new double[numConnectedComponents+1];
   int i;
   for (i = 0; i < numConnectedComponents; i++)
      eulerNums[i] = 0;

   Mesh::VertexIterator vIter = mesh->vertexIterator();
   for (; !vIter.end(); vIter++)
      eulerNums[vIter.vertex()->patchID] += 1;
   for (fIter.reset(); !fIter.end(); fIter++)
      eulerNums[fIter.face()->patchID] += 1;
   Mesh::EdgeIterator eIter = mesh->edgeIterator();
   for (; !eIter.end(); eIter++) {
      eulerNums[eIter.edge()->patchID] -= 1;
   }

   for (i = 0; i < numConnectedComponents; i++) {
      cout << "Euler number of patch " << (i+1) << ": " << eulerNums[i] << endl;
      check_warn(eulerNums[i] != 1, 
          "Patch is not developable!\nMost probably the result layout will not be correct.");
      result = false;
   }

   delete [] eulerNums;

   for (vIter.reset(); !vIter.end(); vIter++) {
      if (vIter.vertex()->constrained) {
          check_warn(!vIter.vertex()->isBoundary(), 
             "Cone singularity vertex is not on the boundary!\nMost probably the result layout will not be correct.");
          result = false;
      }
   }

   cout << "------------------------------------" << endl;
   cout << "After cutting: ";
   mesh->computeMeshInfo();
   cout << "------------------------------------" << endl;

   return result;
}

void Layout::computeEdgeLengthAndAngles() {
   Mesh::HalfEdgeIterator eIter = mesh->halfEdgeIterator();
   for (; !eIter.end(); eIter++) {
      Edge * e = eIter.half_edge();
      double r;
      double phi;
      double r2 = -1;
      if (!e->isBoundary()) {
          r = e->face->r;
          r2 = e->pair->face->r;
          phi = 0.5*CirclePattern::fTheta2(e->cosTheta(), e->sinTheta(), log(r2) - log(r));

      }
      else {
          if (!e->face)
             e = e->pair;

          r = e->face->r;
          phi = M_PI - e->theta();
      }

      e->length = 2.0*r*sin(phi);
      e->alphaOposite = phi;
      if (!e->pair->face) {
          e->pair->length = e->length;
          e->pair->alphaOposite = 0;
      }
   }
}


void Layout::layoutMesh() {

   Mesh::FaceIterator fIter = mesh->faceIterator();
   for (; !fIter.end(); fIter++) {
      fIter.face()->check = false;
   }

   Mesh::VertexIterator vIter = mesh->vertexIterator();
   for (; !vIter.end(); vIter++) {
      vIter.vertex()->uv = Vector3(0,0,0);
      vIter.vertex()->check = false;
   }

   for (fIter.reset(); !fIter.end(); fIter++) {
      if (!fIter.face()->check) {
          Edge * e = fIter.face()->edge;
          e->vertex->uv = Vector3(0,0,-2);
          e->next->vertex->uv = Vector3(e->length,0,0);
          e->vertex->check = true;
          e->next->vertex->check = true;
          edgesToFacesTodo.push(e);
          while (!edgesToFacesTodo.empty()) {
             Edge * toDo = edgesToFacesTodo.top();
             edgesToFacesTodo.pop();
             putFaceFrom(toDo);
          }
      }
   }

   if (mesh->numConnectedComponents > 1)
      movePatches();
}

void Layout::putFaceFrom(Edge * e) {
   if (e->face->check) return;
   Edge * prev = e->next->next;
 //  if (!prev->vertex->check) {
      Vector3 oposite = e->vertex->uv - e->next->vertex->uv;
      oposite.normalize();
      Vector3 res;
      Vector3 start;
      double angle, length;
      if (fabs(0.5*M_PI - prev->alphaOposite) < fabs(0.5*M_PI - e->next->alphaOposite)) {
          angle = prev->alphaOposite;
          length = e->next->length;
          start = e->next->vertex->uv;
      }
      else {
          angle = -e->next->alphaOposite;
          length = prev->length;
          oposite.negate();
          start = e->vertex->uv;
      }

      res[0] =   cos(angle)*oposite[0] + sin(angle)*oposite[1];
      res[1] =  -sin(angle)*oposite[0] + cos(angle)*oposite[1];

      prev->vertex->uv = start + res*length;
      prev->vertex->check = true;
  // }
   Face::EdgeAroundIterator iter = e->face->iterator();
   for( ; !iter.end(); iter++) {
      if (iter.face() && !iter.face()->check)
          edgesToFacesTodo.push(iter.edge()->pair);
   }
   e->face->check = true;
}

void Layout::movePatches() {
   if (mesh->numConnectedComponents == 1)
      return;

   /* Compute bounding box for each patch and shift them away from each other */
   Vector3 * lowLeftCorner = new Vector3[mesh->numConnectedComponents];
   Vector3 * upRightCorner = new Vector3[mesh->numConnectedComponents];
   bool * started = new bool[mesh->numConnectedComponents];
   for (int i = 0; i < mesh->numConnectedComponents; i++)
      started[i] = false;

   int patchID;
   Vector3 uv;
   Mesh::VertexIterator vIter = mesh->vertexIterator();
   for (vIter.reset(); !vIter.end(); vIter++) {
      patchID = vIter.vertex()->patchID;
      uv = vIter.vertex()->uv;
      if (!started[patchID]) {
          started[patchID] = true;
          lowLeftCorner[patchID] = uv;
          upRightCorner[patchID] = uv;
      }
      else {
          if (lowLeftCorner[patchID].x() > uv.x())
             lowLeftCorner[patchID].x() = uv.x();
          if (lowLeftCorner[patchID].y() > uv.y())
             lowLeftCorner[patchID].y() = uv.y();
          if (upRightCorner[patchID].x() < uv.x())
             upRightCorner[patchID].x() = uv.x();
          if (upRightCorner[patchID].y() < uv.y())
             upRightCorner[patchID].y() = uv.y();
      }
   }

   /* Translate all the patches so that the low left coner of each of them is at (0,0) */
   for (vIter.reset(); !vIter.end(); vIter++)
      vIter.vertex()->uv -= lowLeftCorner[vIter.vertex()->patchID];


   double maxX = upRightCorner[0].x() - lowLeftCorner[0].x(), 
      maxY = upRightCorner[0].y() - lowLeftCorner[0].y();

   for (int i = 1; i < mesh->numConnectedComponents; i++) {
      if ((upRightCorner[i].x() - lowLeftCorner[i].x()) > maxX)
          maxX = upRightCorner[i].x() - lowLeftCorner[i].x();
      if ((upRightCorner[i].y() - lowLeftCorner[i].y()) > maxY)
          maxY = upRightCorner[i].y() - lowLeftCorner[i].y();
   }
   delete [] lowLeftCorner;
   delete [] upRightCorner;
   delete [] started;

   int boxDim = (int)ceil(sqrt((double)mesh->numConnectedComponents));
   Vector3 * shiftPos = new Vector3[mesh->numConnectedComponents];
   for (int i = 0; i < boxDim; i++) {
      for (int j = 0; j < boxDim; j++) {
          patchID = i*boxDim + j;
          if (patchID < mesh->numConnectedComponents) {
             shiftPos[patchID].x() = maxX*(double)i;
             shiftPos[patchID].y() = maxY*(double)j;
          }
      }
   }

   /* Translate all the patches so that the low left coner of each of 
   them is at the correct grid position */
   for (vIter.reset(); !vIter.end(); vIter++)
      vIter.vertex()->uv += shiftPos[vIter.vertex()->patchID];

   delete [] shiftPos;
}




Layout::~Layout(void) {
}

---