FillHoles: smoothBd parameter (#4916)

Fedr · web-flow · commit c26183eac0e7 · 2025-08-02T23:38:51.000+03:00
diff --git a/source/MRDotNet/MRMeshFillHole.cs b/source/MRDotNet/MRMeshFillHole.cs
@@ -39,6 +39,13 @@ public struct FillHoleParams
               */
             public FillHoleMetric Metric = new FillHoleMetric();
 
+            /** If true, hole filling will minimize the sum of metrics including boundary edges,
+            *   where one triangle was present before hole filling, and another is added during hole filling.
+            *   This makes boundary edges same smooth as inner edges of the patch.
+            *   If false, edge metric will not be applied to boundary edges, and the patch tends to make a sharper turn there.
+            */
+            public bool SmoothBd = true;
+
             /// If not null accumulate new faces
             public FaceBitSet? OutNewFaces = null;
 
@@ -94,6 +101,7 @@ public FillHoleNicelyParams() { }
         internal struct MRFillHoleParams
         {
             public IntPtr metric = IntPtr.Zero;
+            public byte smoothBd = 1;
             public IntPtr outNewFaces = IntPtr.Zero;
             public MultipleEdgesResolveMode multipleEdgesResolveMode = MultipleEdgesResolveMode.Simple;
             public byte makeDegenerateBand = 0;
@@ -140,6 +148,7 @@ unsafe public static void FillHole(ref Mesh mesh, EdgeId a, FillHoleParams param
         {
             MRFillHoleParams mrParam;
             mrParam.metric = parameters.Metric.mrMetric_;
+            mrParam.smoothBd = parameters.SmoothBd ? (byte)1 : (byte)0;
             mrParam.outNewFaces = parameters.OutNewFaces?.bs_ ?? IntPtr.Zero;
             mrParam.multipleEdgesResolveMode = parameters.MultipleEdgesResolveMode;
             mrParam.makeDegenerateBand = parameters.MakeDegenerateBand ? (byte)1 : (byte)0;
@@ -166,6 +175,7 @@ unsafe public static FaceBitSet FillHoleNicely(ref Mesh mesh, EdgeId holeEdge, F
         {
             MRFillHoleNicelyParams mrParam;
             mrParam.triangulationParams.metric = parameters.triangulationParams.Metric.mrMetric_;
+            mrParam.triangulationParams.smoothBd = parameters.triangulationParams.SmoothBd ? (byte)1 : (byte)0;
             mrParam.triangulationParams.outNewFaces = parameters.triangulationParams.OutNewFaces?.bs_ ?? IntPtr.Zero;
             mrParam.triangulationParams.multipleEdgesResolveMode = parameters.triangulationParams.MultipleEdgesResolveMode;
             mrParam.triangulationParams.makeDegenerateBand = parameters.triangulationParams.MakeDegenerateBand ? (byte)1 : (byte)0;
@@ -200,6 +210,7 @@ unsafe public static void FillHoles(ref Mesh mesh, List<EdgeId> edges, FillHoleP
         {
             MRFillHoleParams mrParam;
             mrParam.metric = parameters.Metric.mrMetric_;
+            mrParam.smoothBd = parameters.SmoothBd ? (byte)1 : (byte)0;
             mrParam.outNewFaces = parameters.OutNewFaces?.bs_ ?? IntPtr.Zero;
             mrParam.multipleEdgesResolveMode = parameters.MultipleEdgesResolveMode;
             mrParam.makeDegenerateBand = parameters.MakeDegenerateBand ? (byte)1 : (byte)0;
diff --git a/source/MRMesh/MRFillHoleNicely.cpp b/source/MRMesh/MRFillHoleNicely.cpp
@@ -111,19 +111,22 @@ FaceBitSet fillHoleNicely( Mesh & mesh,
             // exclude boundary vertices from positionVertsSmoothly(), since it tends to move them inside the mesh
             auto vertsForSmoothing = newVerts - mesh.topology.findBdVerts( nullptr, &newVerts );
             positionVertsSmoothlySharpBd( mesh, vertsForSmoothing );
-            positionVertsSmoothly( mesh, vertsForSmoothing, settings.edgeWeights, settings.vmass );
-            if ( settings.naturalSmooth )
+            if ( settings.triangulateParams.smoothBd )
             {
-                auto undirectedEdgeBitSet = findRegionBoundaryUndirectedEdgesInsideMesh( mesh.topology, newFaces );
-                auto incidentVerts = getIncidentVerts( mesh.topology, undirectedEdgeBitSet );
-                expand( mesh.topology, incidentVerts, 5 );
-                shrink( mesh.topology, incidentVerts, 2 );
-                MeshComponents::excludeFullySelectedComponents( mesh, incidentVerts );
-                if ( incidentVerts.any() )
+                positionVertsSmoothly( mesh, vertsForSmoothing, settings.edgeWeights, settings.vmass );
+                if ( settings.naturalSmooth )
                 {
-                    vertsForSmoothing = incidentVerts - mesh.topology.findBdVerts( nullptr, &incidentVerts );
-                    positionVertsSmoothlySharpBd( mesh, vertsForSmoothing );
-                    positionVertsSmoothly( mesh, vertsForSmoothing, settings.edgeWeights, settings.vmass );
+                    auto undirectedEdgeBitSet = findRegionBoundaryUndirectedEdgesInsideMesh( mesh.topology, newFaces );
+                    auto incidentVerts = getIncidentVerts( mesh.topology, undirectedEdgeBitSet );
+                    expand( mesh.topology, incidentVerts, 5 );
+                    shrink( mesh.topology, incidentVerts, 2 );
+                    MeshComponents::excludeFullySelectedComponents( mesh, incidentVerts );
+                    if ( incidentVerts.any() )
+                    {
+                        vertsForSmoothing = incidentVerts - mesh.topology.findBdVerts( nullptr, &incidentVerts );
+                        positionVertsSmoothlySharpBd( mesh, vertsForSmoothing );
+                        positionVertsSmoothly( mesh, vertsForSmoothing, settings.edgeWeights, settings.vmass );
+                    }
                 }
             }
         }
diff --git a/source/MRMesh/MRMeshFillHole.cpp b/source/MRMesh/MRMeshFillHole.cpp
@@ -111,7 +111,7 @@ void getOptimalSteps( std::vector<unsigned>& optimalSteps, unsigned start, unsig
 
 // finds best candidate among all given steps
 void getTriangulationWeights( const MeshTopology& topology, const NewEdgesMap& map, const EdgePath& loop,
-    const FillHoleMetric& metrics,
+    const FillHoleMetric& metrics, bool smoothBd,
     const std::vector<unsigned>& optimalStepsCache, WeightedConn& processedConn )
 {
     for ( unsigned s = 0; s < optimalStepsCache.size(); ++s )
@@ -139,7 +139,7 @@ void getTriangulationWeights( const MeshTopology& topology, const NewEdgesMap& m
             VertId leftVert;
             if ( abConn.hasPrev() )
                 leftVert = topology.org( loop[abConn.prevA] );
-            else if ( topology.right( loop[processedConn.a] ) )
+            else if ( smoothBd && topology.right( loop[processedConn.a] ) )
                 leftVert = topology.dest( topology.prev( loop[processedConn.a] ) );
 
             if ( leftVert )
@@ -151,7 +151,7 @@ void getTriangulationWeights( const MeshTopology& topology, const NewEdgesMap& m
             VertId rightVert;
             if ( bcConn.hasPrev() )
                 rightVert = topology.org( loop[bcConn.prevA] );
-            else if ( topology.right( loop[v] ) )
+            else if ( smoothBd && topology.right( loop[v] ) )
                 rightVert = topology.dest( topology.prev( loop[v] ) );
 
             if ( rightVert )
@@ -179,7 +179,7 @@ using MapPatch = std::vector<MapPatchElement>;
 
 // this function go backward by given triangulation and tries to fix multiple edges
 // return false if triangulation has multiple edges that cannot be fixed
-bool removeMultipleEdgesFromTriangulation( const MeshTopology& topology, const NewEdgesMap& map, const EdgePath& loop,  const FillHoleMetric& metricRef,
+bool removeMultipleEdgesFromTriangulation( const MeshTopology& topology, const NewEdgesMap& map, const EdgePath& loop, const FillHoleMetric& metricRef, bool smoothBd,
     WeightedConn start, int maxPolygonSubdivisions, MapPatch& mapPatch )
 {
     MR_TIMER;
@@ -232,7 +232,7 @@ bool removeMultipleEdgesFromTriangulation( const MeshTopology& topology, const N
             if ( optimalStepsCache.empty() )
                 return false;
             WeightedConn newPrev{ start.a,start.b,DBL_MAX,0 };
-            getTriangulationWeights( topology, map, loop, metricRef, optimalStepsCache, newPrev ); // find better among steps
+            getTriangulationWeights( topology, map, loop, metricRef, smoothBd, optimalStepsCache, newPrev ); // find better among steps
             if ( !newPrev.hasPrev() || !map[start.a][newPrev.prevA].hasPrev() || !map[start.prevA][newPrev.b].hasPrev() )
                 return false;
             start.prevA = newPrev.prevA;
@@ -659,7 +659,7 @@ HoleFillPlan HoleFillPlanner::run( const Mesh& mesh, EdgeId a0, const FillHolePa
                 sameEdgeExists( mesh.topology, aCur, cCur ) )
                 return;
             getOptimalSteps( optimalSteps, ( i + 1 ) % loopEdgesCounter, steps, loopEdgesCounter, params.maxPolygonSubdivisions );
-            getTriangulationWeights( mesh.topology, newEdgesMap_, edgeMap_, metrics, optimalSteps, current ); // find better among steps
+            getTriangulationWeights( mesh.topology, newEdgesMap_, edgeMap_, metrics, params.smoothBd, optimalSteps, current ); // find better among steps
         };
         if ( parallelProcessing )
         {
@@ -689,13 +689,13 @@ HoleFillPlan HoleFillPlanner::run( const Mesh& mesh, EdgeId a0, const FillHolePa
             VertId leftVert;
             if ( newEdgesMap_[i][cIndex].hasPrev() )
                 leftVert = mesh.topology.org( edgeMap_[newEdgesMap_[i][cIndex].prevA] );
-            else if ( mesh.topology.right( edgeMap_[i] ) )
+            else if ( params.smoothBd && mesh.topology.right( edgeMap_[i] ) )
                 leftVert = mesh.topology.dest( mesh.topology.prev( edgeMap_[i] ) );
 
             VertId rightVert;
             if ( newEdgesMap_[cIndex][i].hasPrev() )
                 rightVert = mesh.topology.org( edgeMap_[newEdgesMap_[cIndex][i].prevA] );
-            else if ( mesh.topology.right( edgeMap_[cIndex] ) )
+            else if ( params.smoothBd && mesh.topology.right( edgeMap_[cIndex] ) )
                 rightVert = mesh.topology.dest( mesh.topology.prev( edgeMap_[cIndex] ) );
 
             if ( leftVert && rightVert )
@@ -706,7 +706,7 @@ HoleFillPlan HoleFillPlanner::run( const Mesh& mesh, EdgeId a0, const FillHolePa
         }
         if ( weight < finConn.weight &&
             ( params.multipleEdgesResolveMode != FillHoleParams::MultipleEdgesResolveMode::Strong || // try to fix multiple if needed
-                removeMultipleEdgesFromTriangulation( mesh.topology, newEdgesMap_, edgeMap_, metrics, newEdgesMap_[cIndex][i], params.maxPolygonSubdivisions, cachedMapPatch_ ) ) )
+                removeMultipleEdgesFromTriangulation( mesh.topology, newEdgesMap_, edgeMap_, metrics, params.smoothBd, newEdgesMap_[cIndex][i], params.maxPolygonSubdivisions, cachedMapPatch_ ) ) )
         {
             savedMapPatch_ = cachedMapPatch_;
             finConn = newEdgesMap_[cIndex][i];
diff --git a/source/MRMesh/MRMeshFillHole.h b/source/MRMesh/MRMeshFillHole.h
@@ -29,8 +29,17 @@ struct FillHoleParams
       * \sa \ref FillHoleMetric
       */
     FillHoleMetric metric;
+
+    /** If true, hole filling will minimize the sum of metrics including boundary edges,
+    *   where one triangle was present before hole filling, and another is added during hole filling.
+    *   This makes boundary edges same smooth as inner edges of the patch.
+    *   If false, edge metric will not be applied to boundary edges, and the patch tends to make a sharper turn there.
+    */
+    bool smoothBd{ true };
+
     /// If not nullptr accumulate new faces
     FaceBitSet* outNewFaces{ nullptr };
+
     /** If Strong makes additional efforts to avoid creating multiple edges, 
       * in some rare cases it is not possible (cases with extremely bad topology), 
       * if you faced one try to use \ref MR::duplicateMultiHoleVertices before \ref MR::fillHole
diff --git a/source/MRMeshC/MRMeshFillHole.cpp b/source/MRMeshC/MRMeshFillHole.cpp
@@ -20,6 +20,7 @@ MRFillHoleParams mrFillHoleParamsNew( void )
     static const FillHoleParams def;
     return {
         .metric = auto_cast( &def.metric ),
+        .smoothBd = def.smoothBd,
         .outNewFaces = auto_cast( def.outNewFaces ),
         .multipleEdgesResolveMode = auto_cast( def.multipleEdgesResolveMode ),
         .makeDegenerateBand = def.makeDegenerateBand,
@@ -37,6 +38,7 @@ void mrFillHole( MRMesh* mesh_, MREdgeId a_, const MRFillHoleParams* params_ )
     {
         params = {
             .metric = params_->metric ? *auto_cast( params_->metric ) : FillHoleMetric {},
+            .smoothBd = params_->smoothBd,
             .outNewFaces = auto_cast( params_->outNewFaces ),
             .multipleEdgesResolveMode = auto_cast( params_->multipleEdgesResolveMode ),
             .makeDegenerateBand = params_->makeDegenerateBand,
diff --git a/source/MRMeshC/MRMeshFillHole.h b/source/MRMeshC/MRMeshFillHole.h
@@ -27,6 +27,13 @@ typedef struct MRFillHoleParams
       */
     const MRFillHoleMetric* metric;
 
+    /** If true, hole filling will minimize the sum of metrics including boundary edges,
+    *   where one triangle was present before hole filling, and another is added during hole filling.
+    *   This makes boundary edges same smooth as inner edges of the patch.
+    *   If false, edge metric will not be applied to boundary edges, and the patch tends to make a sharper turn there.
+    */
+    bool smoothBd;
+
     /// If not nullptr accumulate new faces
     MRFaceBitSet* outNewFaces;
 
