add inside the visitor a function to allow or forbid some triangles

compiles but still some warnings and runtime issue in some test

Author: sloriot

PMP_Mesh_repair/include/CGAL/Polygon_mesh_processing/internal/Hole_filling/Triangulate_hole_polygon_mesh.h

@@ -178,22 +178,24 @@ triangulate_hole_polygon_mesh(PolygonMesh& pmesh,
     } while(++circ_vertex != done_vertex);
   }
 
+  using Is_valid_base = CGAL::internal::Is_valid_existing_edges_and_degenerate_triangle;
+  Is_valid_base is_valid_base(existing_edges);
+  CGAL::internal::Is_valid_compose is_valid(is_valid_base, visitor);
+
 //#define CGAL_USE_WEIGHT_INCOMPLETE
 #ifdef CGAL_USE_WEIGHT_INCOMPLETE
   typedef CGAL::internal::Weight_calculator<CGAL::internal::Weight_incomplete<CGAL::internal::Weight_min_max_dihedral_and_area>,
-        CGAL::internal::Is_valid_existing_edges_and_degenerate_triangle> WC;
+        decltype(is_valid)> WC;
 #else
   typedef CGAL::internal::Weight_calculator<CGAL::internal::Weight_min_max_dihedral_and_area,
-        CGAL::internal::Is_valid_existing_edges_and_degenerate_triangle> WC;
+        decltype(is_valid)> WC;
 #endif
 
-  CGAL::internal::Is_valid_existing_edges_and_degenerate_triangle is_valid(existing_edges);
-
   // fill hole using polyline function, with custom tracer for PolygonMesh
   Tracer_polyhedron<PolygonMesh, OutputIterator> tracer(out, pmesh, P_edges);
 
 #ifndef CGAL_HOLE_FILLING_DO_NOT_USE_CDT2
-  if(use_cdt && triangulate_hole_polyline_with_cdt(P, tracer, visitor, is_valid, k, max_squared_distance))
+  if(use_cdt && triangulate_hole_polyline_with_cdt(P, tracer, visitor, k, max_squared_distance))
     return std::make_pair(tracer.out, CGAL::internal::Weight_min_max_dihedral_and_area(0,0));
 #endif
   CGAL::internal::Weight_min_max_dihedral_and_area weight =

PMP_Mesh_repair/include/CGAL/Polygon_mesh_processing/internal/Hole_filling/Triangulate_hole_polyline.h

@@ -54,6 +54,28 @@
 namespace CGAL {
 namespace internal {
 
+template <class Base, class Visitor>
+struct Is_valid_compose
+{
+  Is_valid_compose(const Base& base, const Visitor& visitor)
+    : base(base)
+    , visitor(visitor)
+  {}
+
+  template<class Point_3>
+  bool operator()(const std::vector<Point_3>& pts,
+                  int v0, int v1, int v2) const
+  {
+    if (visitor.accept_face(v0, v1, v2))
+      return base(pts, v0, v1, v2);
+    return false;
+  }
+
+  const Base& base;
+  const Visitor& visitor;
+};
+
+
 /************************************************************************
  * Lookup tables
  ************************************************************************/
@@ -892,7 +914,7 @@ class Triangulate_hole_polyline_DT
     CGAL_assertion(v0 != -1); // edge can not be incident to infinite vertex
 
     if( v0 + 1 == v1 || // border edge - should not check v0 = 0, v1 = n-1, because it is the initial edge where the algorithm starts
-        W.get(v0, v1) != Weight::DEFAULT() ) // the range is previously processed
+        W.get(v0, v1) != Weight::DEFAULT() ) // the range is previously processed // TODO: try to call accept_face() only here!
     { return; }
 
     visitor.quadratic_step();
@@ -1330,14 +1352,12 @@ template <
   typename PointRange, // need size()
   typename Tracer,
   typename Visitor,
-  typename Validity_checker,
   typename Traits
 >
 bool
 triangulate_hole_polyline_with_cdt(const PointRange& points,
                                    Tracer& tracer,
                                    Visitor& visitor,
-                                   const Validity_checker& is_valid,
                                    const Traits& traits,
                                    const typename Traits::FT max_squared_distance)
 {
@@ -1447,12 +1467,6 @@ triangulate_hole_polyline_with_cdt(const PointRange& points,
     vertices[v->info()] = v;
   }
 
-  if (vertices.size()!=cdt.number_of_vertices())
-  {
-    visitor.end_planar_phase(false);
-    return false;
-  }
-
   try
   {
     for (std::size_t i = 0; i < size; ++i) {
@@ -1510,7 +1524,8 @@ triangulate_hole_polyline_with_cdt(const PointRange& points,
 
       std::sort(is.begin(), is.end());
       lambda.put(is[0], is[2], is[1]);
-      if (!is_valid(P, is[0], is[1], is[2])) {
+      if (!visitor.accept_face(is[0], is[1], is[2]))
+      {
         // std::cerr << "WARNING: validity, cdt 2 falls back to the original solution!" << std::endl;
         visitor.end_planar_phase(false);
         return false;

PMP_Mesh_repair/include/CGAL/Polygon_mesh_processing/triangulate_hole.h

@@ -56,8 +56,23 @@ namespace Polygon_mesh_processing {
       void end_refine_phase() const {}
       void start_fair_phase() const {}
       void end_fair_phase() const {}
+      constexpr bool accept_face(int,int,int) const { return true; }
     #endif
     };
+
+
+#ifndef DOXYGEN_RUNNING
+  // probably not needed if we're using c++17 constexpr
+  struct Default_user_is_face_valid
+  {
+    constexpr
+    bool accept_face( int /* v0 */, int /* v1 */, int /* v2 */) const
+    {
+      return true;
+    }
+  };
+#endif
+
   } // namespace Hole_filling
 
   /*!
@@ -652,9 +667,7 @@ namespace Polygon_mesh_processing {
 
   @pre `third_points.size() == points.size()`
 
-  @tparam PointRange1 range of points, model of `Range`.
-    Its iterator type is `InputIterator`.
-  @tparam PointRange2 range of points, model of `Range`.
+  @tparam PointRange range of points, model of `Range`.
     Its iterator type is `InputIterator`.
   @tparam OutputIterator model of `OutputIterator`, to collect patch faces.
      A specialization for `CGAL::value_type_traits<OutputIterator>` must be available,
@@ -741,9 +754,14 @@ bool use_dt3 =
       choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true);
 #endif
 
+    Hole_filling::Default_visitor default_visitor;
+    auto visitor = choose_parameter(get_parameter_reference(np, internal_np::visitor), default_visitor);
+
+    CGAL::internal::Is_not_degenerate_triangle is_valid_base;
+    CGAL::internal::Is_valid_compose is_valid(is_valid_base, visitor);
+
     typedef CGAL::internal::Weight_min_max_dihedral_and_area      Weight;
-    typedef CGAL::internal::Weight_calculator<Weight,
-                  CGAL::internal::Is_not_degenerate_triangle>  WC;
+    typedef CGAL::internal::Weight_calculator<Weight, decltype(is_valid)>  WC;
     typedef std::vector<std::pair<int, int> > Holes;
     typedef std::back_insert_iterator<Holes>  Holes_out;
 
@@ -757,17 +775,9 @@ bool use_dt3 =
     typedef typename std::iterator_traits<InIterator>::value_type Point;
     typedef typename CGAL::Kernel_traits<Point>::Kernel Kernel;
 
-    Hole_filling::Default_visitor default_visitor;
-
 #ifndef CGAL_HOLE_FILLING_DO_NOT_USE_CDT2
     if (use_cdt)
     {
-      struct Always_valid
-      {
-        bool operator()(const std::vector<Point>&, int,int,int) const { return true; }
-      };
-      Always_valid is_valid;
-
       const typename Kernel::Iso_cuboid_3 bbox = CGAL::bounding_box(points.begin(), points.end());
       typename Kernel::FT default_squared_distance = CGAL::abs(CGAL::squared_distance(bbox.vertex(0), bbox.vertex(5)));
       default_squared_distance /= typename Kernel::FT(16); // one quarter of the bbox height
@@ -782,8 +792,7 @@ bool use_dt3 =
       if (triangulate_hole_polyline_with_cdt(
            points,
            tracer,
-           choose_parameter(get_parameter_reference(np, internal_np::visitor), default_visitor),
-           is_valid,
+           visitor,
            choose_parameter<Kernel>(get_parameter(np, internal_np::geom_traits)),
            max_squared_distance))
       {
@@ -792,8 +801,8 @@ bool use_dt3 =
       }
     }
 #endif
-    triangulate_hole_polyline(points, third_points, tracer, WC(),
-                              choose_parameter(get_parameter_reference(np, internal_np::visitor), default_visitor),
+    triangulate_hole_polyline(points, third_points, tracer, WC(is_valid),
+                              visitor,
                               use_dt3,
                               choose_parameter(get_parameter(np, internal_np::do_not_use_cubic_algorithm), false),
                               choose_parameter<Kernel>(get_parameter(np, internal_np::geom_traits)));