From 54d19e3059db1c92b42a7bdc8d2052d450153c0e Mon Sep 17 00:00:00 2001
From: Luigi Malomo <malomo.luigi@gmail.com>
Date: Thu, 5 Apr 2018 18:43:05 +0200
Subject: [PATCH 1/3] added function to compute mesh boundary length

---
 vcg/complex/algorithms/stat.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/vcg/complex/algorithms/stat.h b/vcg/complex/algorithms/stat.h
index 8b3c8d90..ca1f3de5 100644
--- a/vcg/complex/algorithms/stat.h
+++ b/vcg/complex/algorithms/stat.h
@@ -212,6 +212,21 @@ public:
     return area/ScalarType(2.0);
   }
 
+	static ScalarType ComputeBorderLength(MeshType & m)
+	{
+		RequireFFAdjacency(m);
+		ScalarType sum = 0;
+		tri::UpdateTopology<MeshType>::FaceFace(m);
+		ForEachFace(m, [&](FaceType &f) {
+			for (int k=0; k<f.VN(); k++)
+				if (face::IsBorder(f, k))
+				{
+					sum += Distance(f.cP(k), f.cP(1));
+				}
+		});
+		return sum;
+	}
+
   static void ComputePerVertexQualityDistribution( MeshType & m, Distribution<ScalarType> &h, bool selectionOnly = false)    // V1.0
   {
     tri::RequirePerVertexQuality(m);

From 6011f049fc25711480bccff633870396fbc5ce43 Mon Sep 17 00:00:00 2001
From: Luigi Malomo <malomo.luigi@gmail.com>
Date: Thu, 5 Apr 2018 18:43:43 +0200
Subject: [PATCH 2/3] voronoi remesher tweaked

---
 vcg/complex/algorithms/voronoi_remesher.h | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/vcg/complex/algorithms/voronoi_remesher.h b/vcg/complex/algorithms/voronoi_remesher.h
index 54541533..f2521b26 100644
--- a/vcg/complex/algorithms/voronoi_remesher.h
+++ b/vcg/complex/algorithms/voronoi_remesher.h
@@ -133,7 +133,7 @@ protected:
 	}
 
 public:
-	static const int VoroRelaxationStep = 20;
+	static const int VoroRelaxationStep = 30;
 
 	///
 	/// \brief Remesh the main function that remeshes a mesh preserving creases.
@@ -355,7 +355,7 @@ protected:
 
 		// refine to obtain a base mesh
 		VoronoiProcessingParameter vpp;
-		vpp.refinementRatio = 4.0f;
+		vpp.refinementRatio = 5.0f;
 		Voronoi::PreprocessForVoronoi(baseMesh, samplingRadius, vpp);
 
 		// Poisson sampling preserving border
@@ -372,7 +372,15 @@ protected:
 
 		// Montecarlo oversampling
 		Mesh montecarloMesh;
-		int poissonCount = SurfaceSampler::ComputePoissonSampleNum(original, samplingRadius) * 0.7;
+//		const int poissonCount = SurfaceSampler::ComputePoissonSampleNum(original, samplingRadius)/* * 0.7*/;
+		int poissonCount = 0;
+		{
+			const ScalarType meshArea = Stat<Mesh>::ComputeMeshArea(original);
+			const ScalarType meshBoundary = Stat<Mesh>::ComputeBorderLength(original);
+			const double factor = math::Sqrt(3)/2;
+			const ScalarType areaPerSample = samplingRadius*samplingRadius * factor;
+			poissonCount = meshArea / areaPerSample - meshBoundary * samplingRadius * factor * 0.5; // totalArea / (r^2 * sqrt(3)/2) - (totalBoundary * r * sqrt(3)/4)
+		}
 
 //		std::cout << "poisson Count: " << poissonCount << std::endl;
 		if (poissonCount <= 0)
@@ -386,7 +394,7 @@ protected:
 		else
 		{
 			// Montecarlo poisson sampling
-			SurfaceSampler::MontecarloPoisson(original, mps, poissonCount * 20);
+			SurfaceSampler::MontecarloPoisson(original, mps, poissonCount * 40);
 			BuildMeshFromCoordVector(montecarloMesh,sampleVec);
 
 #ifdef DEBUG_VORO
@@ -421,6 +429,7 @@ protected:
 		vpp.seedPerturbationProbability = 0.0f;
 		Voronoi::RestrictedVoronoiRelaxing(baseMesh, seedPointVec, seedFixedVec, VoroRelaxationStep, vpp);
 
+
 #ifdef DEBUG_VORO
 		BuildMeshFromCoordVector(poissonMesh,seedPointVec);
 		io::ExporterPLY<MeshType>::Save(poissonMesh, QString("relaxedMesh_%1.ply").arg(idx).toStdString().c_str());

From 6a31fa64baa844fff902f221cff187e59dde1f58 Mon Sep 17 00:00:00 2001
From: nico <nico.pietroni@gmail.com>
Date: Fri, 6 Apr 2018 14:03:39 +1000
Subject: [PATCH 3/3] Refactored ReprojectBorder and  added MergeAlongEdges
 Function

---
 vcg/complex/algorithms/polygonal_algorithms.h | 218 +++++++++++++++---
 1 file changed, 190 insertions(+), 28 deletions(-)

diff --git a/vcg/complex/algorithms/polygonal_algorithms.h b/vcg/complex/algorithms/polygonal_algorithms.h
index e699cd40..a839af28 100644
--- a/vcg/complex/algorithms/polygonal_algorithms.h
+++ b/vcg/complex/algorithms/polygonal_algorithms.h
@@ -471,6 +471,41 @@ public:
         }
     }
 
+    template <class TriMeshType>
+    static void ReprojectBorder(PolyMeshType &poly_m,
+                                TriMeshType &tri_mesh,
+                                bool FixS=true)
+    {
+        //then reproject on border
+        for (size_t i=0;i<poly_m.vert.size();i++)
+        {
+            if (!poly_m.vert[i].IsB())continue;
+            if (FixS && poly_m.vert[i].IsS())continue;
+
+            CoordType testPos=poly_m.vert[i].P();
+            ScalarType minD=std::numeric_limits<ScalarType>::max();
+            CoordType closPos;
+            for (size_t j=0;j<tri_mesh.face.size();j++)
+                for (size_t k=0;k<3;k++)
+                {
+                    //check if border edge
+                    if (tri_mesh.face[j].FFp(k)!=(&tri_mesh.face[j]))continue;
+
+                    CoordType P0,P1;
+                    P0.Import(tri_mesh.face[j].cP0(k));
+                    P1.Import(tri_mesh.face[j].cP1(k));
+                    vcg::Segment3<ScalarType> Seg(P0,P1);
+                    ScalarType testD;
+                    CoordType closTest;
+                    vcg::SegmentPointDistance(Seg,testPos,closTest,testD);
+                    if (testD>minD)continue;
+                    minD=testD;
+                    closPos=closTest;
+                }
+            poly_m.vert[i].P()=closPos;
+        }
+    }
+
     /*! \brief This function smooth the borders of the polygonal mesh and reproject back to the triangolar one
      * except the vertices that are considered as corner wrt the angleDeg threshold
     */
@@ -507,33 +542,34 @@ public:
                         AvVert[i]*(1-Damp);
             }
 
-            //then reproject on border
-            for (size_t i=0;i<poly_m.vert.size();i++)
-            {
-                if (!poly_m.vert[i].IsB())continue;
-                if (poly_m.vert[i].IsS())continue;
+//            //then reproject on border
+//            for (size_t i=0;i<poly_m.vert.size();i++)
+//            {
+//                if (!poly_m.vert[i].IsB())continue;
+//                if (poly_m.vert[i].IsS())continue;
 
-                CoordType testPos=poly_m.vert[i].P();
-                ScalarType minD=std::numeric_limits<ScalarType>::max();
-                CoordType closPos;
-                for (size_t j=0;j<tri_mesh.face.size();j++)
-                    for (size_t k=0;k<3;k++)
-                    {
-                        if (tri_mesh.face[j].FFp(k)!=(&tri_mesh.face[j]))continue;
+//                CoordType testPos=poly_m.vert[i].P();
+//                ScalarType minD=std::numeric_limits<ScalarType>::max();
+//                CoordType closPos;
+//                for (size_t j=0;j<tri_mesh.face.size();j++)
+//                    for (size_t k=0;k<3;k++)
+//                    {
+//                        if (tri_mesh.face[j].FFp(k)!=(&tri_mesh.face[j]))continue;
 
-                        CoordType P0,P1;
-                        P0.Import(tri_mesh.face[j].cP0(k));
-                        P1.Import(tri_mesh.face[j].cP1(k));
-                        vcg::Segment3<ScalarType> Seg(P0,P1);
-                        ScalarType testD;
-                        CoordType closTest;
-                        vcg::SegmentPointDistance(Seg,testPos,closTest,testD);
-                        if (testD>minD)continue;
-                        minD=testD;
-                        closPos=closTest;
-                    }
-                poly_m.vert[i].P()=closPos;
-            }
+//                        CoordType P0,P1;
+//                        P0.Import(tri_mesh.face[j].cP0(k));
+//                        P1.Import(tri_mesh.face[j].cP1(k));
+//                        vcg::Segment3<ScalarType> Seg(P0,P1);
+//                        ScalarType testD;
+//                        CoordType closTest;
+//                        vcg::SegmentPointDistance(Seg,testPos,closTest,testD);
+//                        if (testD>minD)continue;
+//                        minD=testD;
+//                        closPos=closTest;
+//                    }
+//                poly_m.vert[i].P()=closPos;
+//            }
+            ReprojectBorder(poly_m,tri_mesh);
         }
     }
 
@@ -797,6 +833,47 @@ public:
         vcg::PolygonalAlgorithm<PolyMeshType>::SmoothReprojectPCA<TempMesh>(poly_m,GuideSurf,relaxStep,fixIrr,Damp,SharpDeg,WeightByQuality);
     }
 
+    static void Reproject(PolyMeshType &poly_m,
+                          PolyMeshType &target)
+    {
+        vcg::tri::UpdateTopology<PolyMeshType>::FaceFace(poly_m);
+        vcg::tri::UpdateFlags<PolyMeshType>::VertexBorderFromFaceAdj(poly_m);
+
+        //transform into triangular
+        TempMesh GuideSurf;
+        //vcg::tri::PolygonSupport<TempMesh,PolyMeshType>:(GuideSurf,poly_m);
+        TriangulateToTriMesh<TempMesh>(target,GuideSurf);
+        vcg::tri::UpdateBounding<TempMesh>::Box(GuideSurf);
+        vcg::tri::UpdateNormal<TempMesh>::PerVertexNormalizedPerFace(GuideSurf);
+        vcg::tri::UpdateTopology<TempMesh>::FaceFace(GuideSurf);
+        vcg::tri::UpdateFlags<TempMesh>::FaceBorderFromFF(GuideSurf);
+
+        //initialize the grid
+        typedef typename TempMesh::FaceType FaceType;
+        typedef vcg::GridStaticPtr<FaceType, typename TempMesh::ScalarType> TriMeshGrid;
+        TriMeshGrid grid;
+        grid.Set(GuideSurf.face.begin(),GuideSurf.face.end());
+
+        ScalarType MaxD=GuideSurf.bbox.Diag();
+
+        for (size_t i=0;i<poly_m.vert.size();i++)
+        {
+            //reproject on border later
+            if (poly_m.vert[i].IsB())continue;
+                typename TempMesh::CoordType testPos;
+                testPos.Import(poly_m.vert[i].P());
+                typename TempMesh::CoordType closestPt;
+                typename TempMesh::ScalarType minDist;
+                typename TempMesh::FaceType *f=NULL;
+                typename TempMesh::CoordType norm,ip;
+                f=vcg::tri::GetClosestFaceBase(GuideSurf,grid,testPos,MaxD,minDist,closestPt,norm,ip);
+                poly_m.vert[i].P()=closestPt;
+        }
+        //then reprojec the border
+        ReprojectBorder(poly_m,GuideSurf);
+    }
+
+
     /*! \brief This function return average edge size
     */
     static ScalarType AverageEdge(const PolyMeshType &poly_m)
@@ -928,18 +1005,20 @@ public:
      * this is sometimes useful to remove small edges coming out from a quadrangulation which is not
      * aligned to boundaries
     */
-    static void CollapseBorderSmallEdges(PolyMeshType &poly_m,const ScalarType perc_average=0.3)
+    static bool CollapseBorderSmallEdges(PolyMeshType &poly_m,
+                                         const ScalarType perc_average=0.3)
     {
         //compute the average edge
         ScalarType AvEdge=AverageEdge(poly_m);
         ScalarType minLimit=AvEdge*perc_average;
-
-        while(CollapseBorderSmallEdgesStep(poly_m,minLimit)){};
+        bool collapsed=false;
+        while(CollapseBorderSmallEdgesStep(poly_m,minLimit)){collapsed=true;};
 
         RemoveValence2Faces(poly_m);
 
         //RemoveValence2BorderVertices(poly_m);
         RemoveValence2Vertices(poly_m);
+        return collapsed;
     }
 
     /*! \brief This function use a local global approach to flatten polygonal faces
@@ -1133,6 +1212,89 @@ public:
         ToUpdateF.push_back(IndexF);
     }
 
+    static void ReorderFaceVert(FaceType &f,const size_t &StartI)
+    {
+        if (StartI==0)return;
+        size_t sizeN=f.VN();
+        assert(StartI>=0);
+        assert(StartI<sizeN);
+        std::vector<VertexType*> NewV;
+        for (size_t i=0;i<sizeN;i++)
+        {
+            int IndexV=(i+StartI)%sizeN;
+            NewV.push_back(f.V(IndexV));
+        }
+        //then reset all vertices
+        for (size_t i=0;i<sizeN;i++)
+            f.V(i)=NewV[i];
+    }
+
+    static void MergeAlongEdge(PolyMeshType &poly_m,
+                                FaceType &f,
+                                const size_t &EdgeI)
+    {
+        //cannot be a border
+        assert(f.FFp(EdgeI)!=&f);
+        FaceType *f1=f.FFp(EdgeI);
+        int EdgeI1=f.FFi(EdgeI);
+
+        //sort first face
+        int FirstV0=(EdgeI+1) % f.VN();
+        ReorderFaceVert(f,FirstV0);
+        int FirstV1=(EdgeI1+1)%f1->VN();
+        ReorderFaceVert(*f1,FirstV1);
+
+        std::vector<VertexType*> NewV;
+        for (size_t i=0;i<(f.VN()-1);i++)
+            NewV.push_back(f.V(i));
+
+        for (size_t i=0;i<(f1->VN()-1);i++)
+            NewV.push_back(f1->V(i));
+
+        f.Dealloc();
+        f.Alloc(NewV.size());
+        for (size_t i=0;i<NewV.size();i++)
+            f.V(i)=NewV[i];
+
+        vcg::tri::Allocator<PolyMeshType>::DeleteFace(poly_m,*f1);
+    }
+
+    static void MergeAlongEdges(PolyMeshType &poly_m,
+                                const std::vector<FaceType*> &PolyF,
+                                const std::vector<size_t> &EdgeI)
+    {
+        //create a table with all edges that have to be merged
+        std::set<std::pair<CoordType,CoordType> > NeedMerge;
+        for (size_t i=0;i<PolyF.size();i++)
+        {
+            CoordType P0=PolyF[i]->P0(EdgeI[i]);
+            CoordType P1=PolyF[i]->P1(EdgeI[i]);
+            std::pair<CoordType,CoordType> key(std::min(P0,P1),std::max(P0,P1));
+            NeedMerge.insert(key);
+        }
+
+        //then cycle and collapse
+        do{
+        for (size_t i=0;i<poly_m.face.size();i++)
+        {
+            if (poly_m.face[i].IsD())continue;
+            for (size_t j=0;j<poly_m.face[i].VN();j++)
+            {
+                CoordType P0=poly_m.face[i].P0(j);
+                CoordType P1=poly_m.face[i].P1(j);
+                std::pair<CoordType,CoordType> key(std::min(P0,P1),std::max(P0,P1));
+                if (NeedMerge.count(key)==0)continue;
+
+                //do the merge
+                MergeAlongEdge(poly_m,poly_m.face[i],j);
+                //remove it
+                NeedMerge.erase(key);
+                break;
+            }
+         }
+        vcg::tri::Allocator<PolyMeshType>::CompactEveryVector(poly_m);
+        }while (!NeedMerge.empty());
+    }
 
     static void Triangulate(PolyMeshType &poly_m)
     {