use features available in std instead of boost

Author: sloriot

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

@@ -42,11 +42,9 @@
 #include <vector>
 #include <stack>
 #include <map>
+#include <unordered_set>
 
 #include <CGAL/boost/iterator/transform_iterator.hpp>
-#include <boost/next_prior.hpp>
-#include <boost/unordered_set.hpp>
-#include <boost/next_prior.hpp>
 
 namespace CGAL {
 namespace internal {
@@ -651,7 +649,7 @@ struct Edge_graph
     }
   };
 
-  typedef boost::unordered_set<int> Vertex_container;
+  typedef std::unordered_set<int> Vertex_container;
   // contains edges as key, and each edge contains set of third vertices which denote neighbor facets to that edge
   typedef std::map<std::pair<int, int>, Vertex_container, Edge_comp> Graph;
 
@@ -791,8 +789,8 @@ class Triangulate_hole_polyline_DT
     Triangulation tr;
     std::vector<bool> edge_exist;
     std::pair<int, int> range(0, n-1);
-    boost::tuple<boost::optional<Edge>, bool, bool> res = construct_3D_triangulation(P, range, tr, edge_exist);
-    if(!res.template get<2>()) {
+    std::tuple<boost::optional<Edge>, bool, bool> res = construct_3D_triangulation(P, range, tr, edge_exist);
+    if(!std::get<2>(res)) {
 #ifdef CGAL_HOLE_FILLING_VERBOSE
       #ifndef CGAL_TEST_SUITE
       CGAL_warning_msg(false, "Returning no output. Dimension of 3D Triangulation is below 2!");
@@ -804,12 +802,12 @@ class Triangulate_hole_polyline_DT
     }
 
     // all border edges inside 3D Triangulation
-    if(boost::get<1>(res)) {
+    if(std::get<1>(res)) {
       LookupTable<Weight> W(n, Weight::DEFAULT()); // do not forget that these default values are not changed for [i, i+1]
       LookupTable<int>    lambda(n,-1);
 
       typename Incident_facet_circulator_base<Triangulate_hole_polyline_DT>::Edge_wrapper
-        e_start(*boost::get<0>(res));
+        e_start(*std::get<0>(res));
       if(tr.dimension() == 3) {
         triangulate_DT<IFC_3>(P, Q, W, lambda, e_start, tr, WC, false);
       }
@@ -839,7 +837,7 @@ class Triangulate_hole_polyline_DT
     #else
     // This approach produce better patches when used with Weight_incomplete
     // (which should be arranged in internal::triangulate_hole_Polyhedron, triangulate_polyline)
-    return fill_by_incomplete_patches(tr, res.get<0>(), edge_exist, P, Q, tracer, WC);
+    return fill_by_incomplete_patches(tr, std::get<0>(res), edge_exist, P, Q, tracer, WC);
     #endif
   }
 
@@ -928,7 +926,7 @@ class Triangulate_hole_polyline_DT
   }
 
   // returns [h.first-h.second edge, true if all edges inside 3D triangulation, true if tr.dimension() >= 2]
-  boost::tuple<boost::optional<Edge>, bool, bool>
+  std::tuple<boost::optional<Edge>, bool, bool>
   construct_3D_triangulation(const Polyline_3& P,
                              std::pair<int,int> h,
                              Triangulation& tr,
@@ -937,11 +935,11 @@ class Triangulate_hole_polyline_DT
     // construct 3D tr with P[h.first], P[h.second] also assign ids from h.first to h.second
     boost::optional<Edge> e;
     int n_border = h.second - h.first + 1;
-    tr.insert(boost::make_transform_iterator(boost::next(P.begin(), h.first), Auto_count(h.first)),
-              boost::make_transform_iterator(boost::next(P.begin(), h.second +1), Auto_count(h.first)));
+    tr.insert(boost::make_transform_iterator(std::next(P.begin(), h.first), Auto_count(h.first)),
+              boost::make_transform_iterator(std::next(P.begin(), h.second +1), Auto_count(h.first)));
     tr.infinite_vertex()->info() = -1;
 
-    if(tr.dimension() < 2) { return boost::make_tuple(e, false, false); }
+    if(tr.dimension() < 2) { return std::make_tuple(e, false, false); }
 
     // check whether all edges are included in DT, and get v0-vn-1 edge
     edge_exist.assign(n_border, false);
@@ -972,7 +970,7 @@ class Triangulate_hole_polyline_DT
 
     bool is_3D_T_complete = (nb_exists == n_border);
     if(edge_exist[n_border-1]) { e = *v_first_v_second_edge; }
-    return boost::make_tuple(e, is_3D_T_complete, true);
+    return std::make_tuple(e, is_3D_T_complete, true);
   }
 
   /************************************************************************
@@ -992,7 +990,7 @@ class Triangulate_hole_polyline_DT
   {
     typedef std::pair<int, int> Range;
     typedef std::back_insert_iterator<std::vector<Range> > Output_hole_iterator;
-    typedef Tracer_polyline_incomplete<boost::tuple<int, int, int>, Emptyset_iterator, Output_hole_iterator> Remaining_holes_tracer;
+    typedef Tracer_polyline_incomplete<std::tuple<int, int, int>, Emptyset_iterator, Output_hole_iterator> Remaining_holes_tracer;
 
     std::vector<Range> remaining_holes;
 
@@ -1055,14 +1053,14 @@ class Triangulate_hole_polyline_DT
       // construct tr for next coming hole
       h = remaining_holes.back();
       tr.clear();
-      boost::tuple<boost::optional<Edge>, bool, bool> res = construct_3D_triangulation(P, h, tr, edge_exist);
-      if(!boost::get<0>(res)) {
+      std::tuple<boost::optional<Edge>, bool, bool> res = construct_3D_triangulation(P, h, tr, edge_exist);
+      if(!std::get<0>(res)) {
 #ifdef CGAL_HOLE_FILLING_VERBOSE
         CGAL_warning_msg(false, "Returning no output. Filling hole with incomplete patches is not successful!");
 #endif
         return Weight::NOT_VALID();
       }
-      start_edge = *boost::get<0>(res);
+      start_edge = *std::get<0>(res);
       // clear related regions in W, lambda for next coming hole
       W.set_range_to_default(h.first, h.second);
       lambda.set_range_to_default(h.first, h.second);

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Hole_filling/experimental/experimental_code.h

@@ -121,7 +121,7 @@ triangulate_hole_polyline_incomplete(InputIterator pbegin, InputIterator pend,
   typedef Weight_incomplete<Weight_min_max_dihedral_and_area>      Weight;
   typedef Weight_calculator<Weight, Is_valid_degenerate_triangle>  WC;
 
-  typedef std::vector<boost::tuple<int, int, int> >                   Facet_vector; /* deliberately not OutputIteratorValueType*/
+  typedef std::vector<std::tuple<int, int, int> >                     Facet_vector; /* deliberately not OutputIteratorValueType*/
   typedef std::back_insert_iterator<Facet_vector>                     OutIt;
   typedef Tracer_polyline_incomplete<Facet_vector::value_type, OutIt> Tracer;
   typedef std::pair<int, int> Range;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h

@@ -27,7 +27,7 @@
 
 #include <CGAL/boost/graph/helpers.h>
 
-#include <boost/tuple/tuple.hpp>
+#include <tuple>
 
 #include <vector>
 

Polygon_mesh_processing/test/Polygon_mesh_processing/triangulate_hole_polyline_test.cpp

@@ -5,7 +5,7 @@
 #include <cassert>
 #include <vector>
 #include <fstream>
-#include <boost/tuple/tuple.hpp>
+#include <tuple>
 
 #include <CGAL/Polyhedron_incremental_builder_3.h>
 #include <CGAL/Polyhedron_3.h>
@@ -20,7 +20,7 @@ template<class HDS, class K>
 class Polyhedron_builder : public CGAL::Modifier_base<HDS> {
   typedef typename K::Point_3 Point_3;
 public:
-  Polyhedron_builder(std::vector<boost::tuple<int, int, int> >* triangles,
+  Polyhedron_builder(std::vector<std::tuple<int, int, int> >* triangles,
     std::vector<Point_3>* polyline)
     : triangles(triangles), polyline(polyline)
   { }
@@ -34,20 +34,20 @@ class Polyhedron_builder : public CGAL::Modifier_base<HDS> {
         B.add_vertex(*it);
     }
 
-    for(typename std::vector<boost::tuple<int, int, int> >::iterator it = triangles->begin();
+    for(typename std::vector<std::tuple<int, int, int> >::iterator it = triangles->begin();
       it != triangles->end(); ++it) {
         B.begin_facet();
-        B.add_vertex_to_facet(it->get<0>());
-        B.add_vertex_to_facet(it->get<1>());
-        B.add_vertex_to_facet(it->get<2>());
+        B.add_vertex_to_facet(std::get<0>(*it));
+        B.add_vertex_to_facet(std::get<1>(*it));
+        B.add_vertex_to_facet(std::get<2>(*it));
         B.end_facet();
     }
 
     B.end_surface();
   }
 
 private:
-  std::vector<boost::tuple<int, int, int> >* triangles;
+  std::vector<std::tuple<int, int, int> >* triangles;
   std::vector<Point_3>* polyline;
 };
 
@@ -92,25 +92,25 @@ void read_polyline_with_extra_points(
   }
 }
 
-void check_triangles(std::vector<Point_3>& points, std::vector<boost::tuple<int, int, int> >& tris) {
+void check_triangles(std::vector<Point_3>& points, std::vector<std::tuple<int, int, int> >& tris) {
   if(points.size() - 3 != tris.size()) {
     std::cerr << "  Error: there should be n-2 triangles in generated patch." << std::endl;
     assert(false);
   }
 
   const int max_index = static_cast<int>(points.size())-1;
-  for(std::vector<boost::tuple<int, int, int> >::iterator it = tris.begin(); it != tris.end(); ++it) {
-    if(it->get<0>() == it->get<1>() ||
-      it->get<0>() == it->get<2>() ||
-      it->get<1>() == it->get<2>() )
+  for(std::vector<std::tuple<int, int, int> >::iterator it = tris.begin(); it != tris.end(); ++it) {
+    if(std::get<0>(*it) == std::get<1>(*it) ||
+      std::get<0>(*it) == std::get<2>(*it) ||
+      std::get<1>(*it) == std::get<2>(*it) )
     {
       std::cerr << "Error: indices of triangles should be all different." << std::endl;
       assert(false);
     }
 
-    if(it->get<0>() >= max_index ||
-      it->get<1>() >= max_index ||
-      it->get<2>() >= max_index )
+    if(std::get<0>(*it) >= max_index ||
+      std::get<1>(*it) >= max_index ||
+      std::get<2>(*it) >= max_index )
     {
       std::cerr << "  Error: max possible index check failed." << std::endl;
       assert(false);
@@ -119,7 +119,7 @@ void check_triangles(std::vector<Point_3>& points, std::vector<boost::tuple<int,
 }
 
 void check_constructed_polyhedron(const char* file_name,
-  std::vector<boost::tuple<int, int, int> >* triangles,
+  std::vector<std::tuple<int, int, int> >* triangles,
   std::vector<Point_3>* polyline,
   const bool save_poly)
 {
@@ -147,7 +147,7 @@ void test_1(const char* file_name, bool use_DT, bool save_output) {
   std::vector<Point_3> points; // this will contain n and +1 repeated point
   read_polyline_one_line(file_name, points);
 
-  std::vector<boost::tuple<int, int, int> > tris;
+  std::vector<std::tuple<int, int, int> > tris;
   CGAL::Polygon_mesh_processing::triangulate_hole_polyline(
     points, std::back_inserter(tris),
     CGAL::parameters::use_delaunay_triangulation(use_DT)
@@ -166,7 +166,7 @@ void test_2(const char* file_name, bool use_DT, bool save_output) {
   std::vector<Point_3> extras;
   read_polyline_with_extra_points(file_name, points, extras);
 
-  std::vector<boost::tuple<int, int, int> > tris;
+  std::vector<std::tuple<int, int, int> > tris;
   CGAL::Polygon_mesh_processing::triangulate_hole_polyline(
     points, extras, std::back_inserter(tris),
     CGAL::parameters::use_delaunay_triangulation(use_DT)
@@ -184,7 +184,7 @@ void test_should_be_no_output(const char* file_name, bool use_DT) {
   std::vector<Point_3> points; // this will contain n and +1 repeated point
   read_polyline_one_line(file_name, points);
 
-  std::vector<boost::tuple<int, int, int> > tris;
+  std::vector<std::tuple<int, int, int> > tris;
   CGAL::Polygon_mesh_processing::triangulate_hole_polyline(
     points, std::back_inserter(tris),
     CGAL::parameters::use_delaunay_triangulation(use_DT)