Merge pull request #6740 from MaelRL/PMP-Fix_stitch_NP

Add proper traits usage to PMP::stitch_borders

Author: sloriot

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h

@@ -1804,7 +1804,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh)
 //                    - `Collinear_3` to check whether 3 points are collinear
 //                    - `Less_xyz_3` to compare lexicographically two points
 //                    - `Equal_3` to check whether 2 points are identical.
-//                    For each functor Foo, a function `Foo foo_object()` must be provided.}
+//                    For each functor `Foo`, a function `Foo foo_object()` must be provided.}
 //     \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
 //     \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
 //   \cgalParamNEnd

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h

@@ -62,29 +62,46 @@ namespace internal {
 ////// Helper structs
 
 // Used to compare halfedges based on their geometry
-template <typename PolygonMesh, typename VertexPointMap>
+template <typename PolygonMesh, typename VertexPointMap, typename GeomTraits>
 struct Less_for_halfedge
 {
+  typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor   vertex_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
   typedef typename boost::property_traits<VertexPointMap>::reference     Point;
 
-  Less_for_halfedge(const PolygonMesh& pmesh_, const VertexPointMap& vpm_)
-    : pmesh(pmesh_), vpm(vpm_)
+  Less_for_halfedge(const PolygonMesh& pmesh_, const VertexPointMap vpm_, const GeomTraits& gt_)
+    : pmesh(pmesh_), vpm(vpm_), gt(gt_)
   {}
 
   bool operator()(const halfedge_descriptor h1, const halfedge_descriptor h2) const
   {
-    Point s1 = get(vpm,target(opposite(h1, pmesh), pmesh));
-    Point t1 = get(vpm,target(h1, pmesh));
-    Point s2 = get(vpm,target(opposite(h2, pmesh), pmesh));
-    Point t2 = get(vpm,target(h2, pmesh));
+    typename GeomTraits::Equal_3 equal = gt.equal_3_object();
+    typename GeomTraits::Less_xyz_3 less = gt.less_xyz_3_object();
 
-    return (s1 < t1 ? std::make_pair(s1,t1) : std::make_pair(t1, s1))
-             < (s2 < t2 ? std::make_pair(s2,t2) : std::make_pair(t2, s2));
+    vertex_descriptor vm1 = source(h1, pmesh);
+    vertex_descriptor vM1 = target(h1, pmesh);
+    vertex_descriptor vm2 = source(h2, pmesh);
+    vertex_descriptor vM2 = target(h2, pmesh);
+
+    if(less(get(vpm, vM1), get(vpm, vm1)))
+      std::swap(vM1, vm1);
+    if(less(get(vpm, vM2), get(vpm, vm2)))
+      std::swap(vM2, vm2);
+
+    Point pm1 = get(vpm, vm1);
+    Point pM1 = get(vpm, vM1);
+    Point pm2 = get(vpm, vm2);
+    Point pM2 = get(vpm, vM2);
+
+    if(equal(pm1, pm2))
+      return less(pM1, pM2);
+
+    return less(pm1, pm2);
   }
 
   const PolygonMesh& pmesh;
-  const VertexPointMap& vpm;
+  const VertexPointMap vpm;
+  const GeomTraits& gt;
 };
 
 // The following structs determine which of the two halfedges is kept when a pair is merged
@@ -320,15 +337,19 @@ template<typename Halfedge,
          typename Border_halfedge_map,
          typename Halfedge_pair,
          typename Manifold_halfedge_pair,
+         typename Mesh,
          typename VPM,
-         typename Mesh>
+         typename GT>
 void fill_pairs(const Halfedge& he,
                 Border_halfedge_map& border_halfedge_map,
                 Halfedge_pair& halfedge_pairs,
                 Manifold_halfedge_pair& manifold_halfedge_pairs,
+                const Mesh& pmesh,
                 VPM vpm,
-                const Mesh& pmesh)
+                const GT& gt)
 {
+  typename GT::Equal_3 equal = gt.equal_3_object();
+
   typename Border_halfedge_map::iterator set_it;
   bool insertion_ok;
   std::tie(set_it, insertion_ok) = border_halfedge_map.emplace(he, std::make_pair(1,0));
@@ -341,8 +362,8 @@ void fill_pairs(const Halfedge& he,
       const Halfedge other_he = set_it->first;
       set_it->second.second = halfedge_pairs.size(); // set the id of the pair in the vector
       halfedge_pairs.emplace_back(other_he, he);
-      if(get(vpm, source(he,pmesh)) == get(vpm, target(other_he, pmesh)) &&
-         get(vpm, target(he,pmesh)) == get(vpm, source(other_he, pmesh)))
+      if(equal(get(vpm, source(he,pmesh)), get(vpm, target(other_he, pmesh))) &&
+         equal(get(vpm, target(he,pmesh)), get(vpm, source(other_he, pmesh))))
       {
         // Even if the halfedges are compatible, refuse to stitch if that would break the graph
         if(face(opposite(he, pmesh), pmesh) == face(opposite(other_he, pmesh), pmesh))
@@ -383,17 +404,20 @@ OutputIterator collect_duplicated_stitchable_boundary_edges(const HalfedgeRange&
   VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
                              get_const_property_map(vertex_point, pmesh));
 
+  typedef typename GetGeomTraits<PolygonMesh, CGAL_PMP_NP_CLASS>::type GT;
+  GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
+
   typedef CGAL::dynamic_face_property_t<int>                                      Face_property_tag;
   typedef typename boost::property_map<PolygonMesh, Face_property_tag>::type      Face_cc_map;
 
   Face_cc_map cc;
   std::size_t num_cc = 0;
   std::vector<std::vector<halfedge_descriptor> > border_edges_per_cc;
 
-  typedef Less_for_halfedge<PolygonMesh, VPM>                                     Less_hedge;
+  typedef Less_for_halfedge<PolygonMesh, VPM, GT>                                 Less_hedge;
   typedef std::map<halfedge_descriptor, std::pair<int, std::size_t>, Less_hedge>  Border_halfedge_map;
 
-  Less_hedge less_hedge(pmesh, vpm);
+  Less_hedge less_hedge(pmesh, vpm, gt);
   Border_halfedge_map border_halfedge_map(less_hedge);
 
   std::vector<std::pair<halfedge_descriptor, halfedge_descriptor> > halfedge_pairs;
@@ -424,7 +448,7 @@ OutputIterator collect_duplicated_stitchable_boundary_edges(const HalfedgeRange&
     if(per_cc)
       border_edges_per_cc[get(cc, face(opposite(he, pmesh), pmesh))].push_back(he);
     else
-      fill_pairs(he, border_halfedge_map, halfedge_pairs, manifold_halfedge_pairs, vpm, pmesh);
+      fill_pairs(he, border_halfedge_map, halfedge_pairs, manifold_halfedge_pairs, pmesh, vpm, gt);
   }
 
   if(per_cc)
@@ -439,7 +463,7 @@ OutputIterator collect_duplicated_stitchable_boundary_edges(const HalfedgeRange&
       {
         halfedge_descriptor he = border_edges_per_cc[i][j];
         fill_pairs(he, border_halfedge_map_in_cc, halfedge_pairs,
-                   manifold_halfedge_pairs, vpm, pmesh);
+                   manifold_halfedge_pairs, pmesh, vpm, gt);
       }
 
       // put in `out` only manifold edges from the set of edges to stitch.
@@ -865,17 +889,21 @@ std::size_t stitch_halfedge_range_dispatcher(const HalfedgePairRange& to_stitch_
 // However, even if non-manifoldness exists within a loop, it is safe choice to stitch consecutive
 // stitchable halfedges
 template <typename HalfedgeRange,
+          typename HalfedgeKeeper,
           typename PolygonMesh,
           typename VPM,
-          typename HalfedgeKeeper>
+          typename GT>
 std::size_t zip_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor& bh,
                                const HalfedgeRange& cycle_halfedges,
+                               const HalfedgeKeeper& hd_kpr,
                                PolygonMesh& pmesh,
                                const VPM vpm,
-                               const HalfedgeKeeper& hd_kpr)
+                               const GT& gt)
 {
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor           halfedge_descriptor;
 
+  typename GT::Equal_3 equal = gt.equal_3_object();
+
   std::size_t stitched_boundary_cycles_n = 0;
 
   // Zipping cannot change the topology of the hole so the maintenance is trivial
@@ -911,10 +939,11 @@ std::size_t zip_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfed
     do
     {
       halfedge_descriptor hnn = next(hn, pmesh);
-      CGAL_assertion(get(vpm, target(hn, pmesh)) == get(vpm, source(hnn, pmesh)));
+      CGAL_assertion(equal(get(vpm, target(hn, pmesh)), get(vpm, source(hnn, pmesh))));
 
-      if(get(vpm, source(hn, pmesh)) == get(vpm, target(hnn, pmesh)) &&
-         !is_degenerate_edge(edge(hn, pmesh), pmesh, parameters::vertex_point_map(vpm)))
+      if(equal(get(vpm, source(hn, pmesh)), get(vpm, target(hnn, pmesh))) &&
+         !is_degenerate_edge(edge(hn, pmesh), pmesh,
+                             parameters::vertex_point_map(vpm).geom_traits(gt)))
       {
         if(unstitchable_halfedges.count(hn) == 0)
         {
@@ -980,8 +1009,9 @@ std::size_t zip_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfed
       curr_hn = next(curr_hn, pmesh);
 
       // check if the next two halfedges are not geometrically compatible
-      if(get(vpm, source(curr_h, pmesh)) != get(vpm, target(curr_hn, pmesh)) ||
-         is_degenerate_edge(edge(curr_hn, pmesh), pmesh, parameters::vertex_point_map(vpm)))
+      if(!equal(get(vpm, source(curr_h, pmesh)), get(vpm, target(curr_hn, pmesh))) ||
+         is_degenerate_edge(edge(curr_hn, pmesh), pmesh,
+                            parameters::vertex_point_map(vpm).geom_traits(gt)))
       {
         bh = curr_hn;
         break;
@@ -1046,6 +1076,9 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
   VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
                              get_const_property_map(vertex_point, pmesh));
 
+  typedef typename GetGeomTraits<PolygonMesh, CGAL_PMP_NP_CLASS>::type GT;
+  GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
+
   typedef typename internal_np::Lookup_named_param_def<internal_np::halfedges_keeper_t,
                                                        CGAL_PMP_NP_CLASS,
                                                        Default_halfedges_keeper<PolygonMesh> >::type  Halfedge_keeper;
@@ -1058,7 +1091,7 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
   for(halfedge_descriptor h : halfedges_around_face(bh, pmesh))
     cycle_halfedges.push_back(h);
 
-  std::size_t res = internal::zip_boundary_cycle(bh, cycle_halfedges, pmesh, vpm, hd_kpr);
+  std::size_t res = internal::zip_boundary_cycle(bh, cycle_halfedges, hd_kpr, pmesh, vpm, gt);
   if(bh == boost::graph_traits<PolygonMesh>::null_halfedge()) // stitched everything
   {
     cycle_reps_maintainer.remove_representative(bh);
@@ -1112,6 +1145,17 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
 ///     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
 ///                     must be available in `PolygonMesh`.}
 ///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{geom_traits}
+///     \cgalParamDescription{an instance of a geometric traits class}
+///     \cgalParamType{The traits class must provide the nested type `Point_3`,
+///                    and the nested functors:
+///                    - `Less_xyz_3` to compare lexicographically two points
+///                    - `Equal_3` to check whether two points are identical.
+///                    For each functor `Foo`, a function `Foo foo_object()` must be provided.}
+///     \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
+///     \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 /// \returns the number of pairs of halfedges that were stitched.
@@ -1180,6 +1224,17 @@ std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_rep
 ///     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
 ///                     must be available in `PolygonMesh`.}
 ///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{geom_traits}
+///     \cgalParamDescription{an instance of a geometric traits class}
+///     \cgalParamType{The traits class must provide the nested type `Point_3`,
+///                    and the nested functors:
+///                    - `Less_xyz_3` to compare lexicographically two points
+///                    - `Equal_3` to check whether two points are identical.
+///                    For each functor `Foo`, a function `Foo foo_object()` must be provided.}
+///     \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
+///     \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 /// \returns the number of pairs of halfedges that were stitched.
@@ -1375,15 +1430,6 @@ std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representat
 /// \param np optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 ///
 /// \cgalNamedParamsBegin
-///   \cgalParamNBegin{vertex_point_map}
-///     \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
-///     \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
-///                    as key type and `%Point_3` as value type}
-///     \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
-///     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
-///                     must be available in `PolygonMesh`.}
-///   \cgalParamNEnd
-///
 ///   \cgalParamNBegin{apply_per_connected_component}
 ///     \cgalParamDescription{specifies if the borders should only be stitched only within their own connected component.}
 ///     \cgalParamType{Boolean}
@@ -1396,6 +1442,26 @@ std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representat
 ///                    as key type and `std::size_t` as value type}
 ///     \cgalParamDefault{an automatically indexed internal map}
 ///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{vertex_point_map}
+///     \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
+///     \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
+///                    as key type and `%Point_3` as value type}
+///     \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
+///     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+///                     must be available in `PolygonMesh`.}
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{geom_traits}
+///     \cgalParamDescription{an instance of a geometric traits class}
+///     \cgalParamType{The traits class must provide the nested type `Point_3`,
+///                    and the nested functors:
+///                    - `Less_xyz_3` to compare lexicographically two points
+///                    - `Equal_3` to check whether two points are identical.
+///                    For each functor `Foo`, a function `Foo foo_object()` must be provided.}
+///     \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
+///     \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 /// \return the number of pairs of halfedges that were stitched.