Refactored and commented. Now can also cut along non faux edges

vcg/complex/algorithms/crease_cut.h

@@ -28,68 +28,55 @@
 namespace vcg {
 namespace tri {
 
-/*
+/** \brief Open a mesh cutting all the edges where the two faces make an angle *larger* than the indicated threshold
-Crease Angle
+ */
-Assume che:
-la mesh abbia la topologia ff
-la mesh non abbia complex (o se li aveva fossero stati detached)
-Abbia le normali per faccia normalizzate!!
-
-
-Prende una mesh e duplica tutti gli edge le cui normali nelle facce incidenti formano un angolo maggiore
-di <angle> (espresso in rad).
-foreach face
- foreach unvisited vert vi
-   scan the star of triangles around vi duplicating vi each time we encounter a crease angle.
-
-the new (and old) vertexes are put in a std::vector that is swapped with the original one at the end.
-
-Si tiene un vettore di interi 3 *fn che dice l'indice del vertice puntato da ogni faccia.
-quando si scandisce la stella intorno ad un vertici, per ogni wedge si scrive l'indice del vertice corrsipondente.
-
-
-*/
 
 template<class MESH_TYPE>
 void CreaseCut(MESH_TYPE &m, float angleRad)
 {
-	typedef typename MESH_TYPE::CoordType				CoordType;
+  tri::UpdateFlags<MESH_TYPE>::FaceFauxSignedCrease(m, -angleRad, angleRad);
-	typedef typename MESH_TYPE::ScalarType			ScalarType;
+  CutMeshAlongNonFauxEdges(m);
-	typedef typename MESH_TYPE::VertexType			VertexType;
+}
-	typedef typename MESH_TYPE::VertexPointer		VertexPointer;
+
-	typedef typename MESH_TYPE::VertexIterator	VertexIterator;
+/**
+ * \brief Open a mesh along non-faux edges
+ * 
+ * Duplicate exisiting vertices so that non-faux edges become boundary edges. 
+ * It assume FF topology and manifoldness.
+ * The idea is that we scan faces around each vertex duplicating it each time we encounter a marked edge. 
+ * 
+ */
+template<class MESH_TYPE>
+void CutMeshAlongNonFauxEdges(MESH_TYPE &m)
+{
   typedef typename MESH_TYPE::FaceIterator		FaceIterator;
   typedef typename MESH_TYPE::FaceType				FaceType;
-	typedef typename MESH_TYPE::FacePointer		FacePointer;
   
   tri::Allocator<MESH_TYPE>::CompactVertexVector(m);
   tri::Allocator<MESH_TYPE>::CompactFaceVector(m);    
-
+  tri::RequireFFAdjacency(m);
-	tri::UpdateNormal<MESH_TYPE>::NormalizePerFace(m);
-
-  assert(tri::HasFFAdjacency(m));
-  typename MESH_TYPE::ScalarType cosangle=math::Cos(angleRad);
   
   tri::UpdateFlags<MESH_TYPE>::VertexClearV(m);
   std::vector<int> indVec(m.fn*3,-1);
   int newVertexCounter=m.vn;
   int startVn=m.vn;
   for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
+  {
     for(int j=0;j<3;++j)
       if(!(*fi).V(j)->IsV() )  // foreach unvisited vertex we loop around it searching for creases.
       {
         (*fi).V(j)->SetV();
         
         face::JumpingPos<FaceType> iPos(&*fi,j,(*fi).V(j));
-						size_t vertInd = Index(m,iPos.v);	 //
+        size_t vertInd = Index(m, iPos.V()); 
         bool isBorderVertex = iPos.FindBorder();   // for border vertex we start from the border.
         face::JumpingPos<FaceType> startPos=iPos;
         if(!isBorderVertex)                        // for internal vertex we search the first crease and start from it
         {
           do {
-												ScalarType dotProd = iPos.FFlip()->cN().dot(iPos.f->N());
+              bool creaseFlag = !iPos.IsFaux();
               iPos.NextFE();
-												if(dotProd<cosangle) break;
+              if(creaseFlag) break;
           } while (startPos!=iPos);
           startPos=iPos;                       // the found crease become the new starting pos.
         }
@@ -98,11 +85,10 @@ void CreaseCut(MESH_TYPE &m, float angleRad)
         int curVertexCounter =vertInd;
         
         do { // The real Loop          
-								ScalarType dotProd=iPos.FFlip()->cN().dot(iPos.f->N());			// test normal with the next face (fflip)
+          size_t faceInd = Index(m,iPos.F());
-								size_t faceInd = Index(m,iPos.f);
           indVec[faceInd*3+ iPos.VInd()] = curVertexCounter;
           
-								if(dotProd<cosangle)
+          if(!iPos.IsFaux()) 
           { //qDebug("  Crease FOUND");
             ++locCreaseCounter;
             curVertexCounter=newVertexCounter;
@@ -111,16 +97,17 @@ void CreaseCut(MESH_TYPE &m, float angleRad)
           iPos.NextFE();
         } while (startPos!=iPos);
         if(locCreaseCounter>0 && (!isBorderVertex) ) newVertexCounter--;
+        //printf("For vertex %i found %i creases\n",vertInd,locCreaseCounter);
       }
+  } // end foreach face/vert 
 
-	// A questo punto ho un vettore che mi direbbe per ogni faccia quale vertice devo mettere. Dopo che ho aggiunto i vertici necessari,
+  // Now the indVec vector contains for each the new index of each vertex (duplicated as necessary)
-	// rifaccio il giro delle facce
+  // We do a second loop to copy split vertexes into new positions
-	//qDebug("adding %i vert for %i crease edges ",newVertexCounter-m.vn, creaseCounter);
   tri::Allocator<MESH_TYPE>::AddVertices(m,newVertexCounter-m.vn);
   
   tri::UpdateFlags<MESH_TYPE>::VertexClearV(m);
   for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
-		for(int j=0;j<3;++j) // foreach unvisited vertex
+    for(int j=0;j<3;++j) 
     {
       size_t faceInd = Index(m, *fi);
       size_t vertInd = Index(m, (*fi).V(j));
@@ -134,7 +121,6 @@ void CreaseCut(MESH_TYPE &m, float angleRad)
         (*fi).V(j) = & m.vert[curVertexInd];
       }
     }
-		tri::UpdateNormal<MESH_TYPE>::PerVertexFromCurrentFaceNormal(m);
 }
 
 } // end namespace tri