Merge remote-tracking branch 'cgal/master' into CGAL-CMake_testsuite-maxGimeno

.travis.yml

@@ -1,5 +1,5 @@
 language: cpp
-dist: xenial
+dist: bionic
 sudo: required
 git:
   depth: 3
@@ -58,7 +58,7 @@ install:
   - echo "$PWD"
   - if [ -n "$TRAVIS_PULL_REQUEST_BRANCH" ] && [ "$PACKAGE" != CHECK ]; then  DO_IGNORE=FALSE;  for ARG in $(echo "$PACKAGE");do if [ "$ARG" = "Maintenance" ]; then continue; fi; . $PWD/.travis/test_package.sh "$PWD" "$ARG";  echo "DO_IGNORE is $DO_IGNORE";  if [ "$DO_IGNORE" = "FALSE" ]; then  break; fi; done; if [ "$DO_IGNORE" = "TRUE" ]; then travis_terminate 0; fi;fi
   - /usr/bin/time -f 'Spend time of %C -- %E (real)' bash .travis/install.sh
-  - export CXX=clang++ CC=clang;
+  - export CXX=clang++-10 CC=clang-10;
 before_script:
   - wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
   - sudo mv doxygen_exe /usr/bin/doxygen

.travis/build_package.sh

@@ -11,7 +11,7 @@ function mytime {
 function build_examples {
   mkdir -p build-travis
   cd build-travis
-  mytime cmake -DCGAL_DIR="/usr/local/lib/cmake/CGAL" -DCMAKE_CXX_FLAGS="${CXX_FLAGS}" -DCGAL_BUILD_THREE_DOC=TRUE ..
+  mytime cmake -DCGAL_DIR="/usr/local/lib/cmake/CGAL" -DCMAKE_CXX_FLAGS="${CXX_FLAGS}" ..
   mytime make -j2 VERBOSE=1
 }
 

.travis/install.sh

@@ -2,14 +2,15 @@
 
 [ -n "$CGAL_DEBUG_TRAVIS" ] && set -x
 DONE=0
+sudo add-apt-repository ppa:mikhailnov/pulseeffects -y
 sudo apt-get update
+
 while [ $DONE = 0 ]
 do
-  DONE=1 && sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install clang zsh \
+  DONE=1 && sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install clang-10 zsh \
-flex bison cmake graphviz libgmp-dev libmpfr-dev libmpfi-dev zlib1g-dev libeigen3-dev  libboost-dev \
+flex bison cmake graphviz libgmp-dev libmpfr-dev libmpfi-dev zlib1g-dev libeigen3-dev  \
-libboost-system-dev libboost-program-options-dev libboost-thread-dev libboost-iostreams-dev \
 qtbase5-dev libqt5sql5-sqlite libqt5opengl5-dev qtscript5-dev libqt5svg5-dev qttools5-dev qttools5-dev-tools qml-module-qtgraphicaleffects libopencv-dev mesa-common-dev libmetis-dev libglu1-mesa-dev \
-|| DONE=0 && sudo apt-get update
+libboost1.72-dev || DONE=0 && sudo apt-get update
 done
 exit 0
 

.travis/template.txt

@@ -1,5 +1,5 @@
 language: cpp
-dist: xenial
+dist: bionic
 sudo: required
 git:
   depth: 3
@@ -12,7 +12,7 @@ install:
   - echo "$PWD"
   - if [ -n "$TRAVIS_PULL_REQUEST_BRANCH" ] && [ "$PACKAGE" != CHECK ]; then  DO_IGNORE=FALSE;  for ARG in $(echo "$PACKAGE");do if [ "$ARG" = "Maintenance" ]; then continue; fi; . $PWD/.travis/test_package.sh "$PWD" "$ARG";  echo "DO_IGNORE is $DO_IGNORE";  if [ "$DO_IGNORE" = "FALSE" ]; then  break; fi; done; if [ "$DO_IGNORE" = "TRUE" ]; then travis_terminate 0; fi;fi
   - /usr/bin/time -f 'Spend time of %C -- %E (real)' bash .travis/install.sh
-  - export CXX=clang++ CC=clang;
+  - export CXX=clang++-10 CC=clang-10;
 before_script:
   - wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
   - sudo mv doxygen_exe /usr/bin/doxygen

AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h

@@ -126,7 +126,7 @@ public:
   /*!
   Id type:
   - `boost::graph_traits<HalfedgeGraph>::%edge_descriptor` if `OneHalfedgeGraphPerTree` is `Tag_true`
-  - `std::pair<boost::graph_traits<HalfedgeGraph>::edge_descriptor, const HalfedgeGraph*>` if `OneHalfedgeGraphPerTree` is `Tag_false`
+  - `std::pair<boost::graph_traits<HalfedgeGraph>::%edge_descriptor, const HalfedgeGraph*>` if `OneHalfedgeGraphPerTree` is `Tag_false`
   */
   unspecified_type Id;
   /// @}
@@ -202,4 +202,3 @@ public:
 #include <CGAL/enable_warnings.h>
 
 #endif // CGAL_AABB_HALFEDGE_GRAPH_SEGMENT_PRIMITIVE_H
-

AABB_tree/include/CGAL/AABB_traits.h

@@ -171,9 +171,11 @@ class AABB_tree;
 /// \sa `AABBPrimitiveWithSharedData`
 
   template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default>
-class AABB_traits:
+class AABB_traits
-  public internal::AABB_tree::AABB_traits_base<AABBPrimitive>,
+#ifndef DOXYGEN_RUNNING
+: public internal::AABB_tree::AABB_traits_base<AABBPrimitive>,
   public internal::AABB_tree::AABB_traits_base_2<GeomTraits>
+#endif
 {
   typedef typename CGAL::Object Object;
 public:

Advancing_front_surface_reconstruction/examples/Advancing_front_surface_reconstruction/reconstruction_surface_mesh.cpp

@@ -1,10 +1,10 @@
 #include <iostream>
 #include <fstream>
 #include <algorithm>
+#include <array>
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Advancing_front_surface_reconstruction.h>
 #include <CGAL/Surface_mesh.h>
-#include <CGAL/array.h>
 #include <CGAL/disable_warnings.h>
 
 typedef std::array<std::size_t,3> Facet;

Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_cache.h

@@ -653,7 +653,7 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
   //   II: Y(t) - Y(s) / (t - s) = 0
   //
   Integer                 *coeffs;
-  int                      i, k;
+  int                      i;
 
   // Consruct the bivariate polynomial that corresponds to Equation I.
   // Note that we represent a bivariate polynomial as a vector of univariate
@@ -667,12 +667,11 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
   coeffs = new Integer [degX];
 
   for (i = 0; i < degX; i++)
-  {
+    coeffs[i] = nt_traits.get_coefficient(polyX, i + 1);
-    for (k = i + 1; k < degX; k++)
-      coeffs[k - i - 1] = nt_traits.get_coefficient (polyX, k);
 
-    coeffsX_st[i] = nt_traits.construct_polynomial (coeffs, degX - i - 1);
+  for (i = 0; i < degX; i++)
-  }
+    coeffsX_st[degX - i - 1] =
+        nt_traits.construct_polynomial(coeffs + i, degX - i - 1);
 
   delete[] coeffs;
 
@@ -685,12 +684,11 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
   coeffs = new Integer [degY];
 
   for (i = 0; i < degY; i++)
-  {
+    coeffs[i] = nt_traits.get_coefficient(polyY, i + 1);
-    for (k = i + 1; k < degY; k++)
-      coeffs[k - i - 1] = nt_traits.get_coefficient (polyY, k);
 
-    coeffsY_st[i] = nt_traits.construct_polynomial (coeffs, degY - i - 1);
+  for (i = 0; i < degY; i++)
-  }
+    coeffsY_st[degY - i - 1] =
+        nt_traits.construct_polynomial(coeffs + i, degY - i - 1);
 
   delete[] coeffs;
 

Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_point_2.h

@@ -1641,17 +1641,43 @@ void _Bezier_point_2_rep<RatKer, AlgKer, NtTrt, BndTrt>::_make_exact
   const Algebraic      t_min = nt_traits.convert (orig2.point_bound().t_min);
   const Algebraic      t_max = nt_traits.convert (orig2.point_bound().t_max);
 
+  bool self_intersecting = (org_it1->curve().id() == org_it2->curve().id());
+
   for (intr_it = intr_list.begin(); intr_it != intr_list.end(); ++intr_it)
   {
-    if (CGAL::compare (intr_it->s, s_min) != SMALLER &&
+    auto in_bounding_interval =
-        CGAL::compare (intr_it->s, s_max) != LARGER &&
+      [](const auto& s_, const auto& s_min_, const auto& s_max_) -> bool {
-        CGAL::compare (intr_it->t, t_min) != SMALLER &&
+      return CGAL::compare(s_, s_min_) != SMALLER &&
-        CGAL::compare (intr_it->t, t_max) != LARGER)
+             CGAL::compare(s_, s_max_) != LARGER;
+    };
+
+    bool st_in_st_range = in_bounding_interval(intr_it->s, s_min, s_max) &&
+                          in_bounding_interval(intr_it->t, t_min, t_max);
+    bool ts_in_st_range = false;
+
+    if (st_in_st_range)
     {
       // Update the originators.
-      orig1.set_parameter (intr_it->s);
+      orig1.set_parameter(intr_it->s);
-      orig2.set_parameter (intr_it->t);
+      orig2.set_parameter(intr_it->t);
+    }
+    else if (self_intersecting)
+    {
+      // check whether s is in t range, and t is in s range
+      // s and t can be interchanged in case of self intersections
+      ts_in_st_range = in_bounding_interval(intr_it->t, s_min, s_max) &&
+                       in_bounding_interval(intr_it->s, t_min, t_max);
 
+      if (ts_in_st_range)
+      {
+        // Update the originators.
+        orig1.set_parameter(intr_it->t);
+        orig2.set_parameter(intr_it->s);
+      }
+    }
+
+    if (st_in_st_range || ts_in_st_range)
+    {
       // Set the exact point coordinates.
       p_alg_x = new Algebraic (intr_it->x);
       p_alg_y = new Algebraic (intr_it->y);

Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_x_monotone_2.h

@@ -1139,10 +1139,11 @@ _Bezier_x_monotone_2<RatKer, AlgKer, NtTrt, BndTrt>::compare_to_left
     Originator_iterator  org = p.get_originator(_curve, _xid);
 
     CGAL_assertion(org != p.originators_end());
-    CGAL_assertion(_inc_to_right != cv._inc_to_right);
 
     if (org->point_bound().type == Bez_point_bound::VERTICAL_TANGENCY_PT)
     {
+      CGAL_assertion(_inc_to_right != cv._inc_to_right);
+
       if (! p.is_exact())
       {
         // Comparison based on the control polygon of the bounded vertical

BGL/doc/BGL/Doxyfile.in

@@ -27,18 +27,6 @@ EXAMPLE_PATH               =  ${CGAL_Surface_mesh_skeletonization_EXAMPLE_DIR} \
 
 ALIASES +=  "bgllink{1}=<a href=\"http://www.boost.org/libs/graph/doc/\1.html\"><code>\1</code></a>"
 
-# macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref BGL_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"
-
-#macros for NamedParameters.txt
-ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
-ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
-ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
-ALIASES += "cgalNPEnd=</td></tr>"
-
 EXTRACT_ALL=NO
 HIDE_UNDOC_MEMBERS         =  YES
 HIDE_UNDOC_CLASSES         =  YES

BGL/doc/BGL/NamedParameters.txt

@@ -1,8 +1,8 @@
 /*!
-\defgroup bgl_namedparameters BGL Named Parameters
+\defgroup bgl_namedparameters Named Parameters
 \ingroup PkgBGLRef
 
-The algorithms of the \sc{Bgl} often have many parameters with default
+The algorithms of the Boost Graph Library (\sc{Bgl}) often have many parameters with default
 values that are appropriate for most cases. In general, when no
 special treatment is applied, the values of such parameters are passed
 as a sequence. Deviating from the default for a certain parameter
@@ -20,200 +20,26 @@ dijkstra_shortest_paths(g, s, predecessor_map(&p[0]).distance_map(&d[0]));
 
 In the \sc{Bgl} manual, this is called
 <a href="https://www.boost.org/libs/graph/doc/bgl_named_params.html">named parameters</a>.
-The named parameters in the example use the tags `predecessor_map` and `distance_map`
+The named parameters in the snippet use the tags `predecessor_map` and `distance_map`
-and they are concatenated with the dot operator.<BR>
+and they are concatenated using the dot operator.<BR>
 
-In the following, we assume that `PolygonMesh` is a model of the concept `FaceGraph`.
+A similar mechanism was introduced in \cgal, with the small difference that the named parameters
-Note that for some functions, the type might be more specific:
+tag live in the `CGAL::parameters::` namespace and `CGAL::parameters::all_default()` can be used to indicate
+that default values of optional named parameters must be used.
+As in the \sc{BGL}, named parameters in \cgal are also concatenated using
+the dot operator, and a typical usage is thus:
 
-Here is the list of the named parameters available in this package:
+\code {.cpp}
+Graph g1, g2;
+Vertex_point_map_2 vpm_2; // an hypothetical custom property map assigning a Point to the vertices of g2
 
-\cgalNPTableBegin
+// without any named parameter (default values are used)
-\cgalNPBegin{vertex_point_map} \anchor BGL_vertex_point_map
+CGAL::copy_face_graph(g1, g2);
-is the property map with the points associated to the vertices of the polygon mesh.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
-a \cgal point type as value type. \n
-<b>Default:</b> \code boost::get(CGAL::vertex_point, pmesh) \endcode
-\cgalNPEnd
-
-\cgalNPBegin{vertex_index_map} \anchor BGL_vertex_index_map
-is the property map associating a unique index to each vertex of a polygon mesh `g`,
-between `0` and `num_vertices(g)-1`.
-If this parameter is not passed, internal machinery will create and initialize a vertex index
-property map, either using the internal property map if it exists or using an external map. The latter
-might result in  - slightly - worsened performance in case of non-constant complexity for index access.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and the value type
-\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::vertex_index_t>::type>::value_type \endcode
-<b>Default:</b> an initialized vertex index property map
-\cgalNPEnd
-
-\cgalNPBegin{halfedge_index_map} \anchor BGL_halfedge_index_map
-is the property map associating a unique index to each halfedge of a polygon mesh,
-between `0` and `num_halfedges(g)-1`.
-If this parameter is not passed, internal machinery will create and initialize a halfedge index
-property map, either using the internal property map if it exists or using an external map. The latter
-might result in  - slightly - worsened performance in case of non-constant complexity for index access.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%halfedge_descriptor` as key type and the value type:
-\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::halfedge_index_t>::type>::value_type \endcode
-<b>Default:</b> an initialized halfedge index property map
-\cgalNPEnd
-
-\cgalNPBegin{edge_index_map} \anchor BGL_edge_index_map
-is the property map associating a unique index to each edge of a polygon mesh,
-between `0` and `num_edges(g)-1`.
-If this parameter is not passed, internal machinery will create and initialize a edge index
-property map, either using the internal property map if it exists or using an external map. The latter
-might result in  - slightly - worsened performance in case of non-constant complexity for index access.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%edge_descriptor` as key type and the value type:
-\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::edge_index_t>::type>::value_type \endcode
-<b>Default:</b> an initialized edge index property map
-\cgalNPEnd
-
-\cgalNPBegin{face_index_map} \anchor BGL_face_index_map
-is the property map associating a unique index to each face of a polygon mesh,
-between `0` and `num_faces(g)-1`.
-If this parameter is not passed, internal machinery will create and initialize a face index
-property map, either using the internal property map if it exists or using an external map. The latter
-might result in  - slightly - worsened performance in case of non-constant complexity for index access.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and the value type:
-\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::face_index_t>::type>::value_type \endcode
-<b>Default:</b> an initialized face index property map
-\cgalNPEnd
-
-\cgalNPBegin{edge_is_constrained_map} \anchor BGL_edge_is_constrained_map
-is the property map containing information about edges of the input polygon mesh
-being marked or not.\n
-<b>Type:</b> a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%edge_descriptor` as key type and
-`bool` as value type. It should be default constructible.\n
-<b>Default:</b> a default property map where no edge is constrained
-\cgalNPEnd
-
-\cgalNPBegin{use_binary_mode} \anchor BGL_use_binary_mode
-is a Boolean indicating whether the binary mode or the ASCII mode should be used
-when writing data into a stream.\n
-<b>Type:</b> `bool`\n
-<b>Default:</b> Function specific.
-\cgalNPEnd
-
-\cgalNPBegin{METIS_options} \anchor BGL_METIS_options
-is a parameter used in `partition_graph()` and `partition_dual_graph()`
-to pass options to the METIS graph partitioner. The many options of METIS
-are not described here. Instead, users should refer to METIS'
-<a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>.\n
-<b>Type:</b> an array of size `METIS_NOPTIONS` with value type `idx_t`
-            (an integer type defined by METIS). \n
-<b>Default:</b> an array of size `METIS_NOPTIONS` with value type `idx_t`,
-                initialized using the function `METIS_SetDefaultOptions()`.
-\cgalNPEnd
-
-\cgalNPBegin{vertex_partition_id_map} \anchor BGL_vertex_partition_id_map
-is the property map storing for each vertex of the mesh the id of the subpart
-of the partition that has been assigned to this vertex.\n
-<b>Type:</b> a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
-`int` as value type. \n
-<b>Default:</b> None: this property map is used to store the partition IDs of the vertices
-as result of a partition algorithm; if it is not provided, this information is
-simply inaccessible.
-\cgalNPEnd
-
-\cgalNPBegin{face_partition_id_map} \anchor BGL_face_partition_id_map
-is the property map storing for each face of the mesh the id of the subpart
-of the partition that has been assigned to this face.\n
-<b>Type:</b> a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
-`int` as value type. \n
-<b>Default:</b> None: this property map is used to store the partition IDs of the faces
-as result of a partition algorithm; if it is not provided, this information is
-simply inaccessible.
-\cgalNPEnd
-
-
-\cgalNPBegin{vertex_to_vertex_output_iterator} \anchor BGL_vertex_to_vertex_output_iterator
-is a model of `OutputIterator` accepting `std::pair<vertex_descriptor, vertex_descriptor>`
-A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `OutputIterator` accepting
-`std::pair<`boost::graph_traits<PolygonMesh>::%vertex_descriptor, `boost::graph_traits<PolygonMesh>::%vertex_descriptor>`.\n
-<b>Default:</b> Emptyset_iterator
-\cgalNPEnd
-
-\cgalNPBegin{halfedge_to_halfedge_output_iterator} \anchor BGL_halfedge_to_halfedge_output_iterator
-is a model of `OutputIterator` accepting `std::pair<halfedge_descriptor, halfedge_descriptor>`
-A typical use case is mapping the halfedges from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `OutputIterator` accepting
-`std::pair<`boost::graph_traits<PolygonMesh>::%halfedge_descriptor, `boost::graph_traits<PolygonMesh>::%halfedge_descriptor>`.\n
-<b>Default:</b> Emptyset_iterator
-\cgalNPEnd
-
-
-\cgalNPBegin{face_to_face_output_iterator} \anchor BGL_face_to_face_output_iterator
-is a model of `OutputIterator` accepting `std::pair<face_descriptor, face_descriptor>`
-A typical use case is mapping the faces from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `OutputIterator` accepting
-`std::pair<`boost::graph_traits<PolygonMesh>::%face_descriptor, `boost::graph_traits<PolygonMesh>::%face_descriptor>`.\n
-<b>Default:</b> Emptyset_iterator
-\cgalNPEnd
-
-\cgalNPBegin{vertex_to_vertex_map} \anchor BGL_vertex_to_vertex_map
-is a property map storing for each vertex of a source mesh the corresponding vertex of another mesh.\n
-A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh1>::%vertex_descriptor` as key type and
-`boost::graph_traits<PolygonMesh2>::%vertex_descriptor` as value type.\n
-<b>Default:</b> None.
-\cgalNPEnd
-
-\cgalNPBegin{halfedge_to_halfedge_map} \anchor BGL_halfedge_to_halfedge_map
-is a property map storing for each halfedge of a source mesh the corresponding halfedge of another mesh.\n
-A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh1>::%halfedge_descriptor` as key type and
-`boost::graph_traits<PolygonMesh2>::%halfedge_descriptor` as value type.\n
-<b>Default:</b> None.
-\cgalNPEnd
-
-\cgalNPBegin{face_to_face_map} \anchor BGL_face_to_face_map
-is a property map storing for each face of a source mesh the corresponding face of another mesh.\n
-A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
-operation.\n
-<b>Type:</b>a class model of `ReadWritePropertyMap` with
-`boost::graph_traits<PolygonMesh1>::%face_descriptor` as key type and
-`boost::graph_traits<PolygonMesh2>::%face_descriptor` as value type.\n
-<b>Default:</b> None.
-\cgalNPEnd
-
-\cgalNPBegin{implementation_tag} \anchor BGL_implementation_tag
-tag used to select the implementation to be used among an algorithm-specific list.\n
-<b>Type:</b>a tag class\n
-<b>Default:</b> algorithm-specific.
-\cgalNPEnd
-
-\cgalNPBegin{prevent_unselection} \anchor BGL_prevent_unselection
-Boolean used to indicate if selection can be only extended or if it can also be shrinked.\n
-<b>Type:</b> `bool`\n
-<b>Default:</b> `false`.
-\cgalNPEnd
-
-\cgalNPBegin{geom_traits} \anchor BGL_geom_traits
-is the geometric traits instance used.\n
-<b>Type:</b> a Geometric traits class.\n
-<b>Default</b>:
-\code typename CGAL::Kernel_traits<
-        typename boost::property_traits<
-          typename boost::property_map<FaceGraph, CGAL::vertex_point_t>::type>::value_type>::Kernel \endcode
-\cgalNPEnd
-
-\cgalNPTableEnd
 
+// specifying named parameters for the second graph
+CGAL::copy_face_graph(g1, g2,
+                      CGAL::parameters::all_default(),
+                      CGAL::parameters::vertex_point_map(vpm_2));
+\endcode
 */
+˛

BGL/include/CGAL/boost/graph/Dual.h

@@ -56,18 +56,18 @@ public:
   /*! The underlying primal type. */
   typedef Primal_ Primal;
 
-  /*! Construct a Dual from a given primal. */
+  /*! constructs a Dual from a given primal. */
   Dual(const Primal& primal)
     : primal_(primal) {}
 
-  /*! Returns the underlying primal. */
+  /*! returns the underlying primal. */
   const Primal& primal() const
   { return primal_; }
 };
 
 
 /*!
-  Construct a `Dual` from a given `primal`.
+  constructs a `Dual` from a given `primal`.
   \relates CGAL::Dual
  */
 template<typename Primal>

BGL/include/CGAL/boost/graph/Face_filtered_graph.h

@@ -113,22 +113,44 @@ struct Face_filtered_graph
    * \tparam FacePatchIndexRange a model of `ConstRange` with `boost::property_traits<FacePatchIndexMap>::%value_type` as value type.
    * \tparam NamedParameters a sequence of named parameters
    *
-   * \param graph the underlying graph.
+   * \param graph the underlying graph
-   * \param face_patch_index_map the property_map that assigns a patch index to each face, with
+   * \param face_patch_index_map the property_map that assigns a patch index to each face
-      `face_descriptor` as key type and `boost::graph_traits<Graph>::%faces_size_type` as value type.
+   * \param selected_face_patch_indices a range of the face patch indices to select
-   * \param selected_face_patch_indices a range of the face patch indices to select.
+   * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
-   * \param np optional sequence of named parameters among the ones listed below
    *
    * \cgalNamedParamsBegin
-   *   \cgalParamBegin{face_index_map}
+   *   \cgalParamNBegin{vertex_index_map}
-   *     a property map containing for each face of `graph` a unique index between `0` and `num_faces(graph)-1`
+   *     \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
-   *   \cgalParamEnd
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
-   *   \cgalParamBegin{vertex_index_map}
+   *                    as key type and `std::size_t` as value type}
-   *     a property map containing for each vertex of `graph` a unique index between `0` and `num_vertices(graph)-1`
+   *     \cgalParamDefault{an automatically indexed internal map}
-   *   \cgalParamEnd
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-   *   \cgalParamBegin{halfedge_index_map}
+   *                     a face index property map, either using the internal property map if it exists
-   *     a property map containing for each halfedge of `graph` a unique index between `0` and `num_halfedges(graph)-1`
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
-   *   \cgalParamEnd
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{halfedge_index_map}
+   *     \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{face_index_map}
+   *     \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
    * \cgalNamedParamsEnd
    */
   template <typename FacePatchIndexMap, class FacePatchIndexRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
@@ -172,23 +194,45 @@ struct Face_filtered_graph
       `face_descriptor` as key type and
       `graph_traits<Graph>::%faces_size_type` as value type.
    * \tparam NamedParameters a sequence of named parameters
+   *
    * \param graph the underlying graph.
-   * \param face_patch_index_map the property_map that assigns a patch index to each face, with
+   * \param face_patch_index_map the property_map that assigns a patch index to each face
-      `face_descriptor` as key type and
+   * \param selected_face_patch_index the index of the face patch selected
-      `graph_traits<Graph>::%faces_size_type` as value type.
+   * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
-   * \param selected_face_patch_index the index of the face patch selected.
-   * \param np optional sequence of named parameters among the ones listed below
    *
    * \cgalNamedParamsBegin
-   *   \cgalParamBegin{face_index_map}
+   *   \cgalParamNBegin{vertex_index_map}
-   *     a property map containing for each face of `graph` a unique index between `0` and `num_faces(graph)-1`
+   *     \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
-   *   \cgalParamEnd
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
-   *   \cgalParamBegin{vertex_index_map}
+   *                    as key type and `std::size_t` as value type}
-   *     a property map containing for each vertex of `graph` a unique index between `0` and `num_vertices(graph)-1`
+   *     \cgalParamDefault{an automatically indexed internal map}
-   *   \cgalParamEnd
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-   *   \cgalParamBegin{halfedge_index_map}
+   *                     a face index property map, either using the internal property map if it exists
-   *     a property map containing for each halfedge of `graph` a unique index between `0` and `num_halfedges(graph)-1`
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
-   *   \cgalParamEnd
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{halfedge_index_map}
+   *     \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{face_index_map}
+   *     \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
    * \cgalNamedParamsEnd
    */
   template <typename FacePatchIndexMap, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
@@ -221,20 +265,44 @@ struct Face_filtered_graph
    *
    * \tparam FaceRange a model of `ConstRange` with `face_descriptor` as value type.
    * \tparam NamedParameters a sequence of named parameters
-   * \param graph the graph containing the wanted patch.
+   *
-   * \param selected_faces the set of selected faces.
+   * \param graph the graph containing the wanted patch
-   * \param np optional sequence of named parameters among the ones listed below
+   * \param selected_faces the set of selected faces
+   * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
    *
    * \cgalNamedParamsBegin
-   *   \cgalParamBegin{face_index_map}
+   *   \cgalParamNBegin{vertex_index_map}
-   *     a property map containing an index for each face initialized from 0 to `num_vertices(graph)`
+   *     \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
-   *   \cgalParamEnd
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
-   *   \cgalParamBegin{vertex_index_map}
+   *                    as key type and `std::size_t` as value type}
-   *     a property map containing an index for each vertex initialized 0 to `num_vertices(graph)`
+   *     \cgalParamDefault{an automatically indexed internal map}
-   *   \cgalParamEnd
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-   *   \cgalParamBegin{halfedge_index_map}
+   *                     a face index property map, either using the internal property map if it exists
-   *     a property map containing an index for each halfedge initialized 0 to `num_halfedges(graph)`
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
-   *   \cgalParamEnd
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{halfedge_index_map}
+   *     \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
+   *
+   *   \cgalParamNBegin{face_index_map}
+   *     \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
+   *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
+   *                    as key type and `std::size_t` as value type}
+   *     \cgalParamDefault{an automatically indexed internal map}
+   *     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
+   *                     a face index property map, either using the internal property map if it exists
+   *                     or using an external map. The latter might result in  - slightly - worsened performance
+   *                     in case of non-constant complexity for index access.}
+   *   \cgalParamNEnd
    * \cgalNamedParamsEnd
    */
   template <typename FaceRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>

BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h

@@ -129,35 +129,56 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts,
 
 /// \ingroup PkgBGLPartition
 ///
-/// Computes a partition of the input triangular mesh into `nparts` parts,
+/// computes a partition of the input triangular mesh into `nparts` parts,
 /// based on the mesh's dual graph. The resulting partition is stored in the vertex and/or face
 /// property maps that are passed as parameters using \ref bgl_namedparameters "Named Parameters".
 ///
 /// \param tm a triangle mesh
 /// \param nparts the number of parts in the final partition
-/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
+/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 ///
-/// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
+/// \tparam TriangleMesh is a model of the `FaceListGraph` concept
 /// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
 ///
 /// \cgalNamedParamsBegin
-///   \cgalParamBegin{vertex_index_map}
+///   \cgalParamNBegin{vertex_index_map}
-///     is a property map containing for each vertex of `tm` a unique index between `0` and `num_vertices(tm)-1`.
+///     \cgalParamDescription{a property map associating to each vertex of `tm` a unique index between `0` and `num_vertices(tm) - 1`}
-///   \cgalParamEnd
+///     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
-///   \cgalParamBegin{METIS_options}
+///                    as key type and `std::size_t` as value type}
-///     is a parameter used in to pass options to the METIS mesh
+///     \cgalParamDefault{an automatically indexed internal map}
-///     partitioner. The many options of METIS are not described here. Instead, users
+///     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-///     should refer to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
+///                     a face index property map, either using the internal property map if it exists
-///     of METIS directly.
+///                     or using an external map. The latter might result in  - slightly - worsened performance
-///   \cgalParamEnd
+///                     in case of non-constant complexity for index access.}
-///   \cgalParamBegin{vertex_partition_id_map}
+///   \cgalParamNEnd
-///     is a property map that contains (after the function has been run)
+///
-///     the ID of the subpart for each vertex of `tm`.
+///   \cgalParamNBegin{METIS_options}
-///   \cgalParamEnd
+///     \cgalParamDescription{a parameter used in to pass options to the METIS mesh partitioner}
-///   \cgalParamBegin{face_partition_id_map}
+///     \cgalParamType{an array of size `METIS_NOPTIONS` with value type `idx_t` (an integer type defined by METIS)}
-///     is a property map that contains (after the function has been run)
+///     \cgalParamDefault{an array of size `METIS_NOPTIONS` with value type `idx_t`,
-///     the ID of the subpart for each face of `tm`.
+///                       initialized using the function `METIS_SetDefaultOptions()`}
-///   \cgalParamEnd
+///     \cgalParamExtra{The many options of METIS are not described here. Instead, users should refer
+///                     to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
+///                     of METIS directly.}
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{vertex_partition_id_map}
+///     \cgalParamDescription{a property map that contains (after the function has been run)
+///                           the ID of the subpart for each vertex of `tm`}
+///     \cgalParamType{a class model of `ReadWritePropertyMap` with
+///                    `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and
+///                    `int` as value type}
+///     \cgalParamDefault{unused}
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{face_partition_id_map}
+///     \cgalParamDescription{a property map that contains (after the function has been run)
+///                           the ID of the subpart for each face of `tm`}
+///     \cgalParamType{a class model of `ReadWritePropertyMap` with
+///                    `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
+///                    `int` as value type}
+///     \cgalParamDefault{unused}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 /// \pre `tm` is a pure triangular surface mesh: there are no edges

BGL/include/CGAL/boost/graph/METIS/partition_graph.h

@@ -161,35 +161,56 @@ void partition_graph(const TriangleMesh& tm, int nparts,
 
 /// \ingroup PkgBGLPartition
 ///
-/// Computes a partition of the input triangular mesh into `nparts` parts, based on the
+/// computes a partition of the input triangular mesh into `nparts` parts, based on the
 /// mesh's nodal graph. The resulting partition is stored in the vertex and/or face
 /// property maps that are passed as parameters using \ref bgl_namedparameters "Named Parameters".
 ///
 /// \param tm a triangle mesh
 /// \param nparts the number of parts in the final partition
-/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
+/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 ///
 /// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
 /// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
 ///
 /// \cgalNamedParamsBegin
-///   \cgalParamBegin{vertex_index_map}
+///   \cgalParamNBegin{vertex_index_map}
-///     is a property map containing for each vertex of `tm` a unique index between `0` and `num_vertices(tm)-1`.
+///     \cgalParamDescription{a property map associating to each vertex of `tm` a unique index between `0` and `num_vertices(tm) - 1`}
-///   \cgalParamEnd
+///     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
-///   \cgalParamBegin{METIS_options}
+///                    as key type and `std::size_t` as value type}
-///     is a parameter used in to pass options to the METIS mesh
+///     \cgalParamDefault{an automatically indexed internal map}
-///     partitioner. The many options of METIS are not described here. Instead, users
+///     \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-///     should refer to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
+///                     a face index property map, either using the internal property map if it exists
-///     of METIS directly.
+///                     or using an external map. The latter might result in  - slightly - worsened performance
-///   \cgalParamEnd
+///                     in case of non-constant complexity for index access.}
-///   \cgalParamBegin{vertex_partition_id_map}
+///   \cgalParamNEnd
-///     is a property map that contains (after the function has been run)
+///
-///     the ID of the subpart for each vertex of `tm`.
+///   \cgalParamNBegin{METIS_options}
-///   \cgalParamEnd
+///     \cgalParamDescription{a parameter used in to pass options to the METIS mesh partitioner}
-///   \cgalParamBegin{face_partition_id_map}
+///     \cgalParamType{an array of size `METIS_NOPTIONS` with value type `idx_t` (an integer type defined by METIS)}
-///     is a property map that contains (after the function has been run)
+///     \cgalParamDefault{an array of size `METIS_NOPTIONS` with value type `idx_t`,
-///     the ID of the subpart for each face of `tm`.
+///                       initialized using the function `METIS_SetDefaultOptions()`}
-///   \cgalParamEnd
+///     \cgalParamExtra{The many options of METIS are not described here. Instead, users should refer
+///                     to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
+///                     of METIS directly.}
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{vertex_partition_id_map}
+///     \cgalParamDescription{a property map that contains (after the function has been run)
+///                           the ID of the subpart for each vertex of `tm`}
+///     \cgalParamType{a class model of `ReadWritePropertyMap` with
+///                    `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and
+///                    `int` as value type}
+///     \cgalParamDefault{unused}
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{face_partition_id_map}
+///     \cgalParamDescription{a property map that contains (after the function has been run)
+///                           the ID of the subpart for each face of `tm`}
+///     \cgalParamType{a class model of `ReadWritePropertyMap` with
+///                    `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
+///                    `int` as value type}
+///     \cgalParamDefault{unused}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 /// \pre `tm` is a pure triangular surface mesh: there are no edges

BGL/include/CGAL/boost/graph/Seam_mesh.h

@@ -168,7 +168,7 @@ private:
   mutable vertices_size_type number_of_vertices;
 
 public:
-  /// Returns the underlying mesh.
+  /// returns the underlying mesh.
   const TM& mesh() const
   {
     return tm;
@@ -543,31 +543,31 @@ public:
   /// \name Seam query functions
   /// @{
 
-  /// Returns `true` if the vertex is on the seam.
+  /// returns `true` if the vertex is on the seam.
   bool has_on_seam(TM_vertex_descriptor vd) const
   {
     return get(svm, vd);
   }
 
-  /// Returns `true` if the edge is on the seam.
+  /// returns `true` if the edge is on the seam.
   bool has_on_seam(TM_edge_descriptor ed) const
   {
     return get(sem, ed);
   }
 
-  /// Returns `true` if the halfedge is on the seam.
+  /// returns `true` if the halfedge is on the seam.
   bool has_on_seam(TM_halfedge_descriptor tmhd) const
   {
     return get(sem, CGAL::edge(tmhd, tm));
   }
 
-  /// Returns `true` if the halfedge is on the seam.
+  /// returns `true` if the halfedge is on the seam.
   bool has_on_seam(const halfedge_descriptor& hd) const
   {
     return has_on_seam(CGAL::edge(hd, tm));
   }
 
-  /// Return the number of seam edges in the seam mesh.
+  /// returns the number of seam edges in the seam mesh.
   edges_size_type number_of_seam_edges() const
   {
     return number_of_seams;
@@ -601,7 +601,7 @@ public:
   }
   /// @endcond
 
-  /// Returns the iterator range of the vertices of the mesh.
+  /// returns the iterator range of the vertices of the mesh.
   Iterator_range<vertex_iterator> vertices() const
   {
     Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@@ -627,7 +627,7 @@ public:
   }
   /// @endcond
 
-  /// Returns the iterator range of the halfedges of the mesh.
+  /// returns the iterator range of the halfedges of the mesh.
   Iterator_range<halfedge_iterator> halfedges() const
   {
     Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@@ -652,7 +652,7 @@ public:
   }
   /// @endcond
 
-  /// Returns the iterator range of the edges of the mesh.
+  /// returns the iterator range of the edges of the mesh.
   Iterator_range<edge_iterator> edges() const
   {
     Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@@ -675,7 +675,7 @@ public:
   }
   /// @endcond
 
-  /// Returns the iterator range of the faces of the mesh.
+  /// returns the iterator range of the faces of the mesh.
   Iterator_range<face_iterator> faces() const
   {
     return CGAL::faces(tm);
@@ -686,7 +686,7 @@ public:
   /// \name Memory Management
   /// @{
 
-  /// Returns the number of vertices in the seam mesh.
+  /// returns the number of vertices in the seam mesh.
   vertices_size_type num_vertices() const
   {
     if(number_of_vertices == static_cast<vertices_size_type>(-1)) {
@@ -696,19 +696,19 @@ public:
     return number_of_vertices;
   }
 
-  /// Returns the number of halfedges in the seam mesh.
+  /// returns the number of halfedges in the seam mesh.
   halfedges_size_type num_halfedges() const
   {
     return CGAL::num_halfedges(tm) + 2 * number_of_seams;
   }
 
-  /// Returns the number of edges in the seam mesh.
+  /// returns the number of edges in the seam mesh.
   halfedges_size_type num_edges() const
   {
     return CGAL::num_edges(tm) + number_of_seams;
   }
 
-  /// Returns the number of faces in the seam mesh.
+  /// returns the number of faces in the seam mesh.
   faces_size_type num_faces() const
   {
     return CGAL::num_faces(tm);
@@ -719,7 +719,7 @@ public:
   /// \name Degree Functions
   /// @{
 
-  /// Returns the number of incident halfedges of vertex `v`.
+  /// returns the number of incident halfedges of vertex `v`.
   degree_size_type degree(vertex_descriptor v) const
   {
     degree_size_type count(0);
@@ -743,13 +743,13 @@ public:
 #ifndef DOXYGEN_RUNNING
   ///@{
 
-  /// Returns the edge that contains halfedge `h` as one of its two halfedges.
+  /// returns the edge that contains halfedge `h` as one of its two halfedges.
   edge_descriptor edge(halfedge_descriptor h) const
   {
     return edge_descriptor(h,this);
   }
 
-  /// Returns the halfedge corresponding to the edge `e`.
+  /// returns the halfedge corresponding to the edge `e`.
   halfedge_descriptor halfedge(edge_descriptor e) const
   {
     return e.hd;
@@ -758,7 +758,7 @@ public:
 
   ///@{
 
-  /// Returns an incoming halfedge of vertex `v`.
+  /// returns an incoming halfedge of vertex `v`.
   /// If `v` is a seam vertex, this will be the halfedge whose target is `v` and
   /// whose opposite is a virtual border halfedge.
   /// Otherwise, the rules of the underlying mesh are followed.
@@ -769,7 +769,7 @@ public:
     return halfedge_descriptor(h, false /*not on seam*/);
   }
 
-  /// Finds a halfedge between two vertices. Returns a default constructed
+  /// finds a halfedge between two vertices. Returns a default constructed
   /// `halfedge_descriptor`, if  `source` and  `target` are not connected.
   std::pair<halfedge_descriptor, bool> halfedge(vertex_descriptor u,
                                                 vertex_descriptor v) const
@@ -800,7 +800,7 @@ public:
     return std::make_pair(halfedge_descriptor(), false/*invalid*/);
   }
 
-  /// Finds an edge between two vertices. Returns a default constructed
+  /// finds an edge between two vertices. Returns a default constructed
   /// `edge`, if  `source` and  `target` are not connected.
   std::pair<edge_descriptor, bool> edge(vertex_descriptor u, vertex_descriptor v) const
   {
@@ -815,7 +815,7 @@ public:
     return halfedge_descriptor(hd, false/*not on seam*/);
   }
 
-  /// Returns the face incident to halfedge `h`.
+  /// returns the face incident to halfedge `h`.
   face_descriptor face(halfedge_descriptor h) const
   {
     if(h.seam)
@@ -825,7 +825,7 @@ public:
   }
 
 public:
-  /// Returns the next halfedge within the incident face.
+  /// returns the next halfedge within the incident face.
   halfedge_descriptor next(const halfedge_descriptor& hd) const
   {
     if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@@ -840,7 +840,7 @@ public:
                                !is_border(CGAL::opposite(*hatc, tm), tm));
   }
 
-  /// Returns the previous halfedge within the incident face.
+  /// returns the previous halfedge within the incident face.
   halfedge_descriptor prev(const halfedge_descriptor& hd) const
   {
     if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@@ -855,7 +855,7 @@ public:
                                !is_border(CGAL::opposite(*hatc, tm), tm));
   }
 
-  /// Returns the opposite halfedge of `hd`.
+  /// returns the opposite halfedge of `hd`.
   halfedge_descriptor opposite(const halfedge_descriptor& hd) const
   {
     if(!hd.seam)
@@ -864,7 +864,7 @@ public:
     return halfedge_descriptor(CGAL::opposite(hd.tmhd, tm), false /*not on seam*/);
   }
 
-  /// Returns the vertex the halfedge `h` emanates from.
+  /// returns the vertex the halfedge `h` emanates from.
   vertex_descriptor target(halfedge_descriptor hd) const
   {
     TM_halfedge_descriptor tmhd(hd);
@@ -884,7 +884,7 @@ public:
     return vertex_descriptor(halfedge_descriptor(tmhd));
   }
 
-  /// Returns the vertex the halfedge `h` emanates from.
+  /// returns the vertex the halfedge `h` emanates from.
   vertex_descriptor source(const halfedge_descriptor& hd) const
   {
     return target(opposite(hd));
@@ -922,7 +922,7 @@ public:
   /// \name Seam selection
   /// @{
 
-  /// Mark the edge of the underlying mesh that has extremities the vertices
+  /// marks the edge of the underlying mesh that has extremities the vertices
   /// `tm_vd_s` and `tm_vd_s` as a seam edge.
   ///
   /// \return whether the edge was successfully marked or not.
@@ -963,7 +963,7 @@ public:
     return true;
   }
 
-  /// Create new seams.
+  /// creates new seams.
   ///
   /// The edges to be marked as seams are described by the range [first, last) of
   /// vertices of the underlying mesh. Each edge to be marked is described
@@ -998,7 +998,7 @@ public:
     return tmhd;
   }
 
-  /// Create new seams.
+  /// creates new seams.
   ///
   /// A seam edge is described by a pair of integers. The integer index
   /// of a vertex of the underlying mesh is given by its position
@@ -1024,7 +1024,7 @@ public:
     return add_seams(seam_vertices.begin(), seam_vertices.end());
   }
 
-  /// Create new seams.
+  /// creates new seams.
   ///
   /// A seam edge is described by a pair of integers. The integer
   /// index of a vertex of the underlying mesh is defined as its position when
@@ -1041,7 +1041,7 @@ public:
     return add_seams(in, tm_vds);
   }
 
-  /// Create new seams.
+  /// creates new seams.
   ///
   /// A seam edge is described by a pair of integers. The integer index
   /// of a vertex of the underlying mesh is given by its position
@@ -1085,7 +1085,7 @@ public:
     return add_seams(in, tm_vds);
   }
 
-  /// Create new seams.
+  /// creates new seams.
   ///
   /// A seam edge is described by a pair of integers. The integer
   /// index of a vertex of the underlying mesh is defined as its position when
@@ -1104,7 +1104,7 @@ public:
 
   /// @}
 
-  /// Constructs a seam mesh for a triangle mesh and an edge and vertex property map
+  /// constructs a seam mesh for a triangle mesh and an edge and vertex property map
   ///
   /// \param tm the underlying mesh
   /// \param sem the edge property map with value `true` for seam edges

BGL/include/CGAL/boost/graph/alpha_expansion_graphcut.h

@@ -505,27 +505,33 @@ class Alpha_expansion_MaxFlow_impl;
    vd)[label_idx]` returns the cost of vertex `vd` to belong to the
    label `label_idx`.
 
-   \param np optional sequence of named parameters among the ones listed below
+   \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 
    \cgalNamedParamsBegin
-     \cgalParamBegin{vertex_index_map}
+     \cgalParamNBegin{vertex_index_map}
-       a property map providing the index of each vertex
+       \cgalParamDescription{a property map associating to each vertex of `input_graph` a unique index between `0` and `num_vertices(input_graph) - 1`}
-     \cgalParamEnd
+       \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<InputGraph>::%vertex_descriptor`
-     \cgalParamBegin{implementation_tag}
+                      as key type and `std::size_t` as value type}
-       tag used to select
+       \cgalParamDefault{an automatically indexed internal map}
-       which implementation of the alpha expansion should be
+       \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
-       used. Available implementation tags are:
+                       a face index property map, either using the internal property map if it exists
-       - `CGAL::Alpha_expansion_boost_adjacency_list` (default)
+                       or using an external map. The latter might result in  - slightly - worsened performance
+                       in case of non-constant complexity for index access.}
+     \cgalParamNEnd
+
+     \cgalParamNBegin{implementation_tag}
+       \cgalParamDescription{a tag used to select which implementation of the alpha expansion should be used.
+                             Available implementation tags are:
+                             - `CGAL::Alpha_expansion_boost_adjacency_list`
                              - `CGAL::Alpha_expansion_boost_compressed_sparse_row_tag`
-       - `CGAL::Alpha_expansion_MaxFlow_tag`
+                             - `CGAL::Alpha_expansion_MaxFlow_tag`}
-     \cgalParamEnd
+       \cgalParamDefault{`CGAL::Alpha_expansion_boost_adjacency_list`}
+     \cgalParamNEnd
    \cgalNamedParamsEnd
 
    \note The `MaxFlow` implementation is provided by the \ref PkgSurfaceMeshSegmentationRef
-   under GPL license. The header
+   under GPL license. The header `<CGAL/boost/graph/Alpha_expansion_MaxFlow_tag.h>`
-   `<CGAL/boost/graph/Alpha_expansion_MaxFlow_tag.h>`
    must be included if users want to use this implementation.
-
 */
 template <typename InputGraph,
           typename EdgeCostMap,

BGL/include/CGAL/boost/graph/copy_face_graph.h

@@ -254,58 +254,97 @@ inline Emptyset_iterator make_functor(const internal_np::Param_not_found&)
           and `boost::graph_traits<SourceMesh>::%face_descriptor` must be
           models of `Hashable`.
   \tparam TargetMesh a model of `FaceListGraph`
-  \tparam NamedParameters1 a sequence of \ref pmp_namedparameters "Named Parameters"
+  \tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
-  \tparam NamedParameters2 a sequence of \ref pmp_namedparameters "Named Parameters"
+  \tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
 
   The types `sm_vertex_descriptor` and `sm_face_descriptor` must be models of the concept `Hashable`.
 
   \param sm the source mesh
   \param tm the target mesh
-  \param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
+  \param np1 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 
   \cgalNamedParamsBegin
-    \cgalParamBegin{vertex_point_map}
+    \cgalParamNBegin{vertex_point_map}
-      the property map with the points associated to the vertices of `sm` .
+      \cgalParamDescription{a property map associating points to the vertices of `sm`}
-      If this parameter is omitted, an internal property map for
+      \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<SourceMesh>::%vertex_descriptor`
-      `CGAL::vertex_point_t` should be available in `SourceMesh`
+                     as key type and `%Point_3` as value type}
-    \cgalParamEnd
+      \cgalParamDefault{`boost::get(CGAL::vertex_point, sm)`}
-    \cgalParamBegin{vertex_to_vertex_output_iterator} an `OutputIterator` containing the
+      \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
-      pairs source-vertex, target-vertex. If this parameter is given, then
+                      must be available in `SourceMesh`.}
-      `vertex_to_vertex_map` cannot be used.
+    \cgalParamNEnd
-    \cgalParamEnd
+
-    \cgalParamBegin{halfedge_to_halfedge_output_iterator} an `OutputIterator` containing the
+    \cgalParamNBegin{vertex_to_vertex_output_iterator}
-      pairs source-halfedge, target-halfedge. If this parameter is given, then
+      \cgalParamDescription{an `OutputIterator` containing the pairs source-vertex, target-vertex.}
-      `halfedge_to_halfedge_map` cannot be used.
+      \cgalParamType{a class model of `OutputIterator` accepting
-    \cgalParamEnd
+                     `std::pair<`boost::graph_traits<SourceMesh>::%vertex_descriptor, `boost::graph_traits<TargetMesh>::%vertex_descriptor>`}
-    \cgalParamBegin{face_to_face_output_iterator} an `OutputIterator` containing the
+      \cgalParamDefault{`Emptyset_iterator`}
-      pairs source-face, target-face. If this parameter is given, then
+      \cgalParamExtra{If this parameter is given, then `vertex_to_vertex_map` cannot be used.}
-      `face_to_face_map` cannot be used.
+    \cgalParamNEnd
-    \cgalParamEnd
+
-    \cgalParamBegin{vertex_to_vertex_map} a `ReadWritePropertyMap` containing the
+    \cgalParamNBegin{halfedge_to_halfedge_output_iterator}
-      pairs source-vertex, target-vertex.
+      \cgalParamDescription{an `OutputIterator` containing the pairs source-halfedge, target-halfedge.}
-    \cgalParamEnd
+      \cgalParamType{a class model of `OutputIterator` accepting
-    \cgalParamBegin{halfedge_to_halfedge_map} a `ReadWritePropertyMap` containing the
+                     `std::pair<`boost::graph_traits<SourceMesh>::%halfedge_descriptor, `boost::graph_traits<TargetMesh>::%halfedge_descriptor>`}
-      pairs source-halfedge, target-halfedge.
+      \cgalParamDefault{`Emptyset_iterator`}
-    \cgalParamEnd
+      \cgalParamExtra{If this parameter is given, then `halfedge_to_halfedge_map` cannot be used.}
-    \cgalParamBegin{face_to_face_map} a `ReadWritePropertyMap` containing the
+    \cgalParamNEnd
-      pairs source-face, target-face.
+
-    \cgalParamEnd
+    \cgalParamNBegin{face_to_face_output_iterator}
+      \cgalParamDescription{an `OutputIterator` containing the pairs source-face, target-face.}
+      \cgalParamType{a class model of `OutputIterator` accepting
+                     `std::pair<`boost::graph_traits<SourceMesh>::%face_descriptor, `boost::graph_traits<TargetMesh>::%face_descriptor>`}
+      \cgalParamDefault{`Emptyset_iterator`}
+      \cgalParamExtra{If this parameter is given, then `face_to_face_map` cannot be used.}
+    \cgalParamNEnd
+
+    \cgalParamNBegin{vertex_to_vertex_map}
+      \cgalParamDescription{a property map storing for each vertex of a source mesh the corresponding vertex of another mesh}
+      \cgalParamType{a class model of `ReadWritePropertyMap` with
+                     `boost::graph_traits<SourceMesh>::%vertex_descriptor` as key type and
+                     `boost::graph_traits<TargetMesh>::%vertex_descriptor` as value type.}
+      \cgalParamDefault{unused}
+      \cgalParamExtra{A typical use case is mapping the vertices from a source mesh
+                      to its copy's after a `copy_face_graph()` operation.}
+    \cgalParamNEnd
+
+    \cgalParamNBegin{halfedge_to_halfedge_map}
+      \cgalParamDescription{a property map storing for each halfedge of a source mesh the corresponding halfedge of another mesh}
+      \cgalParamType{a class model of `ReadWritePropertyMap` with
+                     `boost::graph_traits<SourceMesh>::%halfedge_descriptor` as key type and
+                     `boost::graph_traits<TargetMesh>::%halfedge_descriptor` as value type}
+      \cgalParamDefault{unused}
+      \cgalParamExtra{A typical use case is mapping the halfedges from a source mesh to its copy's
+                      after a `copy_face_graph()`operation.}
+    \cgalParamNEnd
+
+    \cgalParamNBegin{face_to_face_map}
+      \cgalParamDescription{a property map storing for each face of a source mesh the corresponding face of another mesh}
+      \cgalParamType{a class model of `ReadWritePropertyMap` with
+                     `boost::graph_traits<SourceMesh>::%face_descriptor` as key type and
+                     `boost::graph_traits<TargetMesh>::%face_descriptor` as value type}
+      \cgalParamDefault{unused}
+      \cgalParamExtra{A typical use case is mapping the faces from a source mesh to its copy's
+                      after a `copy_face_graph()` operation}
+    \cgalParamNEnd
   \cgalNamedParamsEnd
 
-  \param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
+  \param np2 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 
   \cgalNamedParamsBegin
-    \cgalParamBegin{vertex_point_map}
+    \cgalParamNBegin{vertex_point_map}
-      the property map with the points associated to the vertices of `tm`.
+      \cgalParamDescription{a property map associating points to the vertices of `tm`}
-      If this parameter is omitted, an internal property map for
+      \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TargetMesh>::%vertex_descriptor`
-      `CGAL::vertex_point_t` should be available in `TargetMesh`
+                     as key type and `%Point_3` as value type}
-    \cgalParamEnd
+      \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
+      \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+                      must be available in `TargetMesh`.}
+    \cgalParamNEnd
   \cgalNamedParamsEnd
 
   The points from `sm` to `tm` are converted using
   `CGAL::Cartesian_converter<SourceKernel, TargetKernel>`.
   `SourceKernel` and `TargetKernel` are deduced using `CGAL::Kernel_traits`
-  from the value types of the vertex_point_maps.
+  from the value types of the vertex point maps.
 
   Other properties are not copied.
 */

BGL/include/CGAL/boost/graph/io.h

@@ -27,16 +27,27 @@
 #include <CGAL/IO/write_vtk.h>
 
 namespace CGAL {
-  /*!
+
+/*!
  \ingroup PkgBGLIOFct
+
   writes the graph `g` in the wrl format (VRML 2.0).
 
+  \param os the output stream
+  \param g the graph to be written
+  \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
+
   \cgalNamedParamsBegin
-    *    \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
+    \cgalParamNBegin{vertex_point_map}
-    *       If this parameter is omitted, an internal property map for
+      \cgalParamDescription{a property map associating points to the vertices of `g`}
-    *       `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
+      \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
-    * \cgalNamedParamsEnd
+                     as key type and `%Point_3` as value type}
-    */
+      \cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
+      \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+                      must be available in `FaceGraph`.}
+    \cgalParamNEnd
+  \cgalNamedParamsEnd
+*/
 template <typename FaceGraph, typename NamedParameters>
 bool write_wrl(std::ostream& os,
                const FaceGraph& g,
@@ -115,17 +126,26 @@ bool write_wrl(std::ostream& os,
 
 /*!
  \ingroup PkgBGLIOFct
+
   writes the graph `g` in the OFF format.
 
+  \param os the output stream
+  \param g the graph to be written
+  \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
+
   \cgalNamedParamsBegin
-    *    \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
+    \cgalParamNBegin{vertex_point_map}
-    *       If this parameter is omitted, an internal property map for
+      \cgalParamDescription{a property map associating points to the vertices of `g`}
-    *       `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
+      \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
-    * \cgalNamedParamsEnd
+                     as key type and `%Point_3` as value type}
+      \cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
+      \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+                      must be available in `FaceGraph`.}
+    \cgalParamNEnd
+  \cgalNamedParamsEnd
 
   \sa Overloads of this function for specific models of the concept `FaceGraph`.
-
+*/
-  */
 template <typename FaceGraph, typename NamedParameters>
 bool write_off(std::ostream& os,
                const FaceGraph& g,
@@ -237,18 +257,29 @@ inline std::string next_non_comment(std::istream& is)
 
 /*!
  \ingroup PkgBGLIOFct
+
  reads the graph `g` from data in the OFF format. Ignores comment lines which start with a hash, and lines with whitespace.
 
+ \param is the input stream
+ \param g the graph to be read
+ \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
+
  \cgalNamedParamsBegin
-    *    \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
+   \cgalParamNBegin{vertex_point_map}
-    *       If this parameter is omitted, an internal property map for
+     \cgalParamDescription{a property map associating points to the vertices of `g`}
-    *       `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
+     \cgalParamType{a class model of `WritablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
-    * \cgalNamedParamsEnd
+                    as key type and `%Point_3` as value type}
+     \cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
+     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+                     must be available in `FaceGraph`.}
+   \cgalParamNEnd
+ \cgalNamedParamsEnd
+
  \sa Overloads of this function for specific models of the concept `FaceGraph`.
  \pre The data must represent a 2-manifold
-    \attention The graph `g` is not cleared, and the data from the stream are added.
 
-  */
+ \attention The graph `g` is not cleared, and the data from the stream are added.
+*/
 template <typename FaceGraph, typename NamedParameters>
 bool read_off(std::istream& is,
               FaceGraph& g,
@@ -614,24 +645,34 @@ write_polys_points(std::ostream& os,
  * \brief  writes a triangulated surface mesh in the `PolyData` XML format.
  *
  * \tparam TriangleMesh a model of `FaceListGraph` with only triangle faces.
- * \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
+ * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
  *
  * \param os the stream used for writing.
  * \param mesh the triangle mesh to be written.
- * \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the
+ * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
- * ones listed below
  *
  * \cgalNamedParamsBegin
- *    \cgalParamBegin{use_binary_mode} a Boolean indicating if the
+ *   \cgalParamNBegin{use_binary_mode}
- *    data should be written in binary (`true`, the default) or in ASCII (`false`).
+ *     \cgalParamDescription{Boolean indicating if the data should be written in binary (`true`) or in ASCII (`false`)}
- *     \cgalParamEnd
+ *     \cgalParamType{Boolean}
- *    \cgalParamBegin{vertex_point_map} the property map with the points associated to
+ *     \cgalParamDefault{`true`}
- * the vertices of `mesh`. If this parameter is omitted, an internal property map for
+ *   \cgalParamNEnd
- *       `CGAL::vertex_point_t` must be available in `TriangleMesh`.
+ *
- *     \cgalParamEnd
+ *   \cgalParamNBegin{vertex_point_map}
- *    \cgalParamBegin{vertex_index_map} the property map with the indices associated to
+ *     \cgalParamDescription{a property map associating points to the vertices of `mesh`}
- * the vertices of `mesh`.
+ *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
- *     \cgalParamEnd
+ *                    as key type and `%Point_3` as value type}
+ *     \cgalParamDefault{`boost::get(CGAL::vertex_point, mesh)`}
+ *     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+ *                     must be available in `TriangleMesh`.}
+ *   \cgalParamNEnd
+ *
+ *   \cgalParamNBegin{vertex_index_map}
+ *     \cgalParamDescription{a property map associating to each vertex of `mesh` a unique index between `0` and `num_vertices(mesh) - 1`}
+ *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
+ *                    as key type and `std::size_t` as value type}
+ *     \cgalParamDefault{an automatically indexed internal map}
+ *   \cgalParamNEnd
  * \cgalNamedParamsEnd
  */
 template<class TriangleMesh,

BGL/include/CGAL/boost/graph/parameters_interface.h

@@ -172,6 +172,7 @@ CGAL_add_named_parameter(remesh_boundaries_t, remesh_boundaries, remesh_boundari
 CGAL_add_named_parameter(cell_selector_t, cell_selector, cell_selector)
 CGAL_add_named_parameter(facet_is_constrained_t, facet_is_constrained, facet_is_constrained_map)
 CGAL_add_named_parameter(remeshing_visitor_t, remeshing_visitor, remeshing_visitor)
+CGAL_add_named_parameter(smooth_constrained_edges_t, smooth_constrained_edges, smooth_constrained_edges)
 
 // output parameters
 CGAL_add_named_parameter(face_proxy_map_t, face_proxy_map, face_proxy_map)

BGL/include/CGAL/boost/graph/selection.h

@@ -286,7 +286,7 @@ struct Regularization_graph
 
 /*!
 \ingroup PkgBGLSelectionFct
-Augments a selection with faces of `fg` that are adjacent
+augments a selection with faces of `fg` that are adjacent
 to a face in `selection`. This process is applied `k` times considering
 all faces added in the previous steps.
 Two faces are said to be adjacent if they share a vertex or an edge.
@@ -356,7 +356,7 @@ expand_face_selection(
 
 /*!
 \ingroup PkgBGLSelectionFct
-Diminishes a selection of faces from faces adjacent to a non-selected face.
+diminishes a selection of faces from faces adjacent to a non-selected face.
 This process is applied `k` times considering all faces removed in the previous steps.
 Two faces are said to be adjacent if they share a vertex or an edge.
 Each face removed from the selection is added exactly once in `out`.
@@ -464,20 +464,38 @@ reduce_face_selection(
   unselects everything so that the length of the border of the
   selection is 0)
 
-  \param np optional sequence of named parameters among the ones listed below
+  \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 
   \cgalNamedParamsBegin
-    \cgalParamBegin{face_index_map}
+    \cgalParamNBegin{vertex_point_map}
-      the property map with the indices associated to the faces of `mesh`
+      \cgalParamDescription{a property map associating points to the vertices of `tm`}
-    \cgalParamEnd
+      \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
-    \cgalParamBegin{vertex_point_map}
+                     as key type and `%Point_3` as value type}
-      the property map with the points associated to the vertices of `mesh`
+      \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
-    \cgalParamEnd
+      \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
-    \cgalParamBegin{prevent_unselection}
+                      must be available in `TriangleMesh`.}
-      if `true` only new faces can be selected, if `false` (default) some
+    \cgalParamNEnd
-      faces can be unselected
+
-    \cgalParamEnd
+    \cgalParamNBegin{face_index_map}
-    \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
+      \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
+      \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
+                     as key type and `std::size_t` as value type}
+      \cgalParamDefault{an automatically indexed internal map}
+    \cgalParamNEnd
+
+    \cgalParamNBegin{prevent_unselection}
+      \cgalParamDescription{Boolean used to indicate if selection can be only extended or if it can also be shrinked.}
+      \cgalParamType{`bool`}
+      \cgalParamDefault{`false`}
+      \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
+    \cgalParamNEnd
+
+    \cgalParamNBegin{geom_traits}
+      \cgalParamDescription{an instance of a geometric traits class}
+      \cgalParamType{a class model of `Kernel`}
+      \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
 */
 template <typename TriangleMesh, typename IsSelectedMap, typename NamedParameters>
@@ -731,7 +749,7 @@ select_incident_faces(
 
 /*!
 \ingroup PkgBGLSelectionFct
-Augments a selection with edges of `fg` that are adjacent
+augments a selection with edges of `fg` that are adjacent
 to an edge in `selection`. This process is applied `k` times considering
 all edges added in the previous steps.
 Two edges are said to be adjacent if they are incident to the same face or vertex.
@@ -798,7 +816,7 @@ expand_edge_selection(
 
 /*!
 \ingroup PkgBGLSelectionFct
-Diminishes a selection of edges from edges adjacent to a non-selected edge.
+diminishes a selection of edges from edges adjacent to a non-selected edge.
 This process is applied `k` times considering all edges removed in the previous steps.
 Two edges are said to be adjacent if they are incident to the same face or vertex.
 Each edge removed from the selection is added exactly once in `out`.
@@ -884,7 +902,7 @@ reduce_edge_selection(
 
 /*!
 \ingroup PkgBGLSelectionFct
-Augments a selection with vertices of `fg` that are adjacent
+augments a selection with vertices of `fg` that are adjacent
 to a vertex in `selection`. This process is applied `k` times considering
 all vertices added in the previous steps.
 Two vertices are said to be adjacent if they are part of the same face.
@@ -939,7 +957,7 @@ expand_vertex_selection(
 
 /*!
 \ingroup PkgBGLSelectionFct
-Diminishes a selection of vertices from vertices adjacent to a non-selected vertex.
+diminishes a selection of vertices from vertices adjacent to a non-selected vertex.
 This process is applied `k` times considering all vertices removed in the previous steps.
 Two vertices are said to be adjacent if they are part of the same face.
 Each vertex removed from the selection is added exactly once in `out`.

BGL/include/CGAL/boost/graph/split_graph_into_polylines.h

@@ -131,7 +131,7 @@ public:
   }
 }; // end class Less_on_G_copy_vertex_descriptors
 
-// Splits a graph at vertices with degree higher than two and at vertices where `is_terminal` returns `true`
+// splits a graph at vertices with degree higher than two and at vertices where `is_terminal` returns `true`
 // The vertices are duplicated, and new incident edges created.
 // `OrigGraph` must be undirected
 template <typename Graph,

CGAL_Core/include/CGAL/CORE/BigFloat_impl.h

@@ -78,12 +78,14 @@ BigInt FiveTo(unsigned long exp) {
 // ZERO
 CGAL_INLINE_FUNCTION
 const BigFloat& BigFloat::getZero() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE(BigFloat, Zero,0);
   return Zero;
 }
 // ONE
 CGAL_INLINE_FUNCTION
 const BigFloat& BigFloat::getOne() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE(BigFloat, One,1);
   return One;
 }

CGAL_Core/include/CGAL/CORE/Expr_impl.h

@@ -61,11 +61,13 @@ const char* Sub::name = "-";
  ********************************************************/
 CGAL_INLINE_FUNCTION
 const Expr& Expr::getZero() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE(Expr, Zero,0);
   return Zero;
 }
 CGAL_INLINE_FUNCTION
 const Expr& Expr::getOne() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE(Expr, One,1);
   return One;
 }

CGAL_Core/include/CGAL/CORE/MemoryPool.h

@@ -26,14 +26,6 @@
 
 #include <CGAL/config.h>
 #include <CGAL/tss.h>
-#include <boost/config.hpp>
-#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
-// Force the use of Boost.Thread with g++ and C++11, because of the PR66944
-//   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66944
-// See also CGAL PR #1888
-//   https://github.com/CGAL/cgal/pull/1888#issuecomment-278284232
-#  include <boost/thread/tss.hpp>
-#endif
 
 #include <new>           // for placement new
 #include <cassert>
@@ -85,10 +77,7 @@ public:
 
   // Access the corresponding static global allocator.
   static MemoryPool<T,nObjects>& global_allocator() {
-#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
+#if defined(CGAL_HAS_THREADS) // use the C++11 implementation
-    if(memPool_ptr.get() == nullptr) {memPool_ptr.reset(new Self());}
-    Self& memPool =  * memPool_ptr.get();
-#elif defined(CGAL_HAS_THREADS) // use the C++11 implementation
     static thread_local Self memPool;
 #else // not CGAL_HAS_THREADS
     static Self memPool;
@@ -99,18 +88,8 @@ public:
 private:
    Thunk* head; // next available block in the pool
   std::vector<void*> blocks;
-
-#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
-  static boost::thread_specific_ptr<Self> memPool_ptr;
-#endif // not CGAL_HAS_THREADS
 };
 
-#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
-template <class T, int nObjects >
-boost::thread_specific_ptr<MemoryPool<T, nObjects> >
-MemoryPool<T, nObjects>::memPool_ptr;
-#endif
-
 template< class T, int nObjects >
 void* MemoryPool< T, nObjects >::allocate(std::size_t) {
    if ( head == 0 ) { // if no more memory in the pool

CGAL_Core/include/CGAL/CORE/Real.h

@@ -27,7 +27,9 @@
  ***************************************************************************/
 #ifndef _CORE_REAL_H_
 #define _CORE_REAL_H_
+
 #include "RealRep.h"
+#include <CGAL/use.h>
 
 namespace CORE {
 // class Real
@@ -483,6 +485,12 @@ inline Real RealLong::operator-() const {
   return ker < -LONG_MAX ? -BigInt(ker) : -ker;
 }
 
+inline void init_CORE() {
+  using RealRep = CORE::RealDouble;
+  CGAL_STATIC_THREAD_LOCAL_VARIABLE(MemoryPool<RealRep>*, pool_real_rep, &MemoryPool<RealRep>::global_allocator());
+  CGAL_USE(pool_real_rep);
+}
+
 } //namespace CORE
 
 #ifdef CGAL_HEADER_ONLY

CGAL_Core/include/CGAL/CORE/Real_impl.h

@@ -44,6 +44,7 @@ namespace CORE {
 
 CGAL_INLINE_FUNCTION
 const Real& Real::getZero() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE(Real, Zero, 0);
   return Zero;
 }

CGAL_Core/include/CGAL/CORE/poly/Poly.h

@@ -252,6 +252,7 @@ public:
 template < class NT >
 CORE_INLINE
 const Polynomial<NT> & Polynomial<NT>::polyZero() {
+  init_CORE();
   CGAL_STATIC_THREAD_LOCAL_VARIABLE_0(Polynomial<NT>, zeroP);
   return zeroP;
 }
@@ -259,6 +260,7 @@ const Polynomial<NT> & Polynomial<NT>::polyZero() {
 template < class NT >
 CORE_INLINE
 const Polynomial<NT> & Polynomial<NT>::polyUnity() {
+  init_CORE();
   static const NT c[] = {1};
   CGAL_STATIC_THREAD_LOCAL_VARIABLE_2(Polynomial<NT>, unityP, 0, c);
   return unityP;

CGAL_Core/include/CGAL/CORE/poly/Poly.tcc

@@ -670,19 +670,20 @@ Polynomial<NT> Polynomial<NT>::pseudoRemainder (
   contract();         // Let A = (*this).  Contract A.
   Polynomial<NT> tmpB(B);
   tmpB.contract();    // local copy of B
+  int bTrueDegree = tmpB.degree;
   C = NT(1);  // Initialized to C=1.
-  if (B.degree == -1)  {
+  if (bTrueDegree == -1)  {
     core_error("ERROR in Polynomial<NT>::pseudoRemainder :\n    -- divide by zero polynomial", __FILE__, __LINE__, false);
     return Polynomial(0);  // Unit Polynomial (arbitrary!)
   }
-  if (B.degree > degree) {
+  if (bTrueDegree > degree) {
     return Polynomial(); // Zero Polynomial
     // CHECK: 1*THIS = 0*B + THAT,  deg(THAT) < deg(B)
   }
 
   Polynomial<NT> Quo;  // accumulate the return polynomial, Quo
   Polynomial<NT> tmpQuo;
-  while (degree >= B.degree) {  // INVARIANT: C*A = B*Quo + (*this)
+  while (degree >= bTrueDegree) {  // INVARIANT: C*A = B*Quo + (*this)
     tmpQuo = reduceStep(tmpB);  // Let (*this) be (*oldthis), which
                                 // is transformed into (*newthis). Then,
                                 //     c*(*oldthis) = B*m + (*newthis)

Convex_hull_3/doc/Convex_hull_3/CGAL/convex_hull_3.h

@@ -44,19 +44,23 @@ void convex_hull_3(InputIterator first, InputIterator last, PolygonMesh& pm, con
  * if the convex hull is a point or a segment, endpoints will be added in `pm` as isolated vertices.
  *
  * \tparam VertexListGraph a model of `VertexListGraph`.
- * \tparam PolygonMesh must be a model of `MutableFaceGraph`.
+ * \tparam PolygonMesh must be a model of `MutableFaceGraph`. an internal property map for `CGAL::vertex_point_t` must be available.
  * \tparam NamedParameters a sequence of named parameters
  *
  * \param g the graph
  * \param pm the `PolygonMesh` that will contain the convex hull
- * \param np optional sequence of named parameters among the ones listed below
+ * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
  *
  * \cgalNamedParamsBegin
- *    \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
+ *   \cgalParamNBegin{vertex_point_map}
- *   If this parameter is omitted, an internal property map for
+ *     \cgalParamDescription{a property map associating points to the vertices of `g`}
- *   `CGAL::vertex_point_t` must be available in `VertexListGraph`
+ *     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<VertexListGraph>::%vertex_descriptor`
- * \cgalParamEnd
+ *                    as key type and `%Point_3` as value type}
-* \cgalNamedParamsEnd
+ *     \cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
+ *     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
+ *                     must be available in `VertexListGraph`.}
+ *   \cgalParamNEnd
+ * \cgalNamedParamsEnd
  * \attention The user must include the header file of the `PolygonMesh` and `VertexListGraph` types.
  */
 template <class VertexListGraph, class PolygonMesh, class NamedParameters>

Convex_hull_3/doc/Convex_hull_3/Doxyfile.in

@@ -1,9 +1,3 @@
 @INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
 
 PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - 3D Convex Hulls"
-
-\# macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref BGL_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"

Documentation/doc/Documentation/Developer_manual/Chapter_portability.txt

@@ -101,70 +101,70 @@ the following table.
     <TD ALIGN=LEFT NOWRAP>
 GNU 3.2.1
     <TD ALIGN=LEFT NOWRAP>
-<TT>__GNUC__</TT>
+`__GNUC__`
     <TD ALIGN=LEFT NOWRAP>
 3
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 GNU 3.2.1
     <TD ALIGN=LEFT NOWRAP>
-<TT>__GNUC_MINOR__</TT>
+`__GNUC_MINOR__`
     <TD ALIGN=LEFT NOWRAP>
 2
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 GNU 3.2.1
     <TD ALIGN=LEFT NOWRAP>
-<TT>__GNUC_PATCHLEVEL__</TT>
+`__GNUC_PATCHLEVEL__`
     <TD ALIGN=LEFT NOWRAP>
 1
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Microsoft VC7.1
     <TD ALIGN=LEFT NOWRAP>
-<TT>_MSC_VER</TT>
+`_MSC_VER`
     <TD ALIGN=LEFT NOWRAP>
 1310
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Microsoft VC8.0
     <TD ALIGN=LEFT NOWRAP>
-<TT>_MSC_VER</TT>
+`_MSC_VER`
     <TD ALIGN=LEFT NOWRAP>
 1400
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Intel 11.1
     <TD ALIGN=LEFT NOWRAP>
-<TT>__INTEL_COMPILER</TT>
+`__INTEL_COMPILER`
     <TD ALIGN=LEFT NOWRAP>
 1110
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Clang 2.9
     <TD ALIGN=LEFT NOWRAP>
-<TT>__clang_major__</TT>
+`__clang_major__`
     <TD ALIGN=LEFT NOWRAP>
 2
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Clang 2.9
     <TD ALIGN=LEFT NOWRAP>
-<TT>__clang_minor__</TT>
+`__clang_minor__`
     <TD ALIGN=LEFT NOWRAP>
 9
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 SUN 5.3
     <TD ALIGN=LEFT NOWRAP>
-<TT>__SUNPRO_CC</TT>
+`__SUNPRO_CC`
     <TD ALIGN=LEFT NOWRAP>
 0x530
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 SUN 5.10
     <TD ALIGN=LEFT NOWRAP>
-<TT>__SUNPRO_CC</TT>
+`__SUNPRO_CC`
     <TD ALIGN=LEFT NOWRAP>
 0x5100
 </TABLE>
@@ -178,17 +178,17 @@ There are also flags to identify the architecture.
     <TD ALIGN=LEFT NOWRAP>
 SGI
     <TD ALIGN=LEFT NOWRAP>
-<TT>__sgi</TT>
+`__sgi`
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 SUN
     <TD ALIGN=LEFT NOWRAP>
-<TT>__sun</TT>
+`__sun`
   <TR>
     <TD ALIGN=LEFT NOWRAP>
 Linux
     <TD ALIGN=LEFT NOWRAP>
-<TT>__linux</TT>
+`__linux`
 </TABLE>
 </TABLE>
 

Documentation/doc/Documentation/Third_party.txt

@@ -56,7 +56,7 @@ or <A HREF="https://msdn.microsoft.com/en-us/library/1fe2x6kt(v=vs.140).aspx">`h
 The \stl comes with the compiler, and as such no installation is required.
 
 \subsection thirdpartyBoost Boost
-<b>Version 1.62 or later</b>
+<b>Version 1.66 or later</b>
 
 The \sc{Boost} libraries are a set of portable C++ source libraries.
 Most of \sc{Boost} libraries are header-only, but a few of them need to be compiled or
@@ -64,10 +64,6 @@ installed as binaries.
 
 \cgal only requires the headers of the \sc{Boost} libraries, but some demos and examples
 depend on the binary library `Boost.Program_options`.
-As an exception and because of a bug in the \gcc compiler about the \cpp 11
-keyword `thread_local`, the `CGAL_Core` library always requires
-the binary library `Boost.Thread` if the \gcc compiler version 9.0 or
-earlier is used.
 
 In case the \sc{Boost} libraries are not installed on your system already, you
 can obtain them from <A HREF="https://www.boost.org">`https://www.boost.org/`</A>.

Documentation/doc/resources/1.8.13/BaseDoxyfile.in

@@ -299,7 +299,16 @@ ALIASES                = "sc{1}=<span style=\"font-variant: small-caps;\">\1</sp
                          "cgalCRPSection{1}=<h2>\1</h2>" \
                          "cgalCRPSubsection{1}=<h3>\1</h3>" \
                          "cgalCite{1}=<!-- -->\cite \1" \
-                         "cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly[block] </div>\endhtmlonly"
+                         "cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly[block] </div>\endhtmlonly" \
+                         "cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">" \
+                         "cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">" \
+                         "cgalNamedParamsEnd=</table> </dd> </dl>" \
+                         "cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>" \
+                         "cgalParamDescription{1}=<li>\1</li>" \
+                         "cgalParamType{1}=<li><b>Type: </b>\1</li>" \
+                         "cgalParamDefault{1}=<li><b>%Default: </b>\1</li>" \
+                         "cgalParamExtra{1}=<li><b>Extra: </b>\1</li>" \
+                         "cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding "class=itcl::class"

Documentation/doc/resources/1.8.13/cgal_stylesheet.css

@@ -345,3 +345,41 @@ div.summary
 {
   width: auto;
 }
+
+.collapsible {
+  background-color: white;
+  color: #602020;
+  cursor: pointer;
+  padding: 3px;
+  width: 100%;
+  border: none;
+  text-align: left;
+  outline: none;
+  font: 14px Roboto,sans-serif;
+}
+
+.active, .collapsible:hover {
+  background-color: white;
+}
+
+.collapsible:after {
+  content: '\25B6';
+  color: #7A93C5;
+  font-weight: bold;
+  float: left;
+  margin-left: -20px;
+  margin-right: 5px;
+}
+
+.active:after {
+  content: "\25BC";
+}
+
+.content {
+  padding: 0 18px;
+  color: black;
+  max-height: 0;
+  overflow: hidden;
+  transition: max-height 0.2s ease-out;
+  background-color: white;
+}

Documentation/doc/resources/1.8.13/hacks.js

@@ -110,3 +110,19 @@ $(document).ready(function() {
     }
 })();
 
+$(document).ready(function() {
+    var coll = document.getElementsByClassName("collapsible");
+    var i;
+
+    for (i = 0; i < coll.length; i++) {
+        coll[i].addEventListener("click", function() {
+            this.classList.toggle("active");
+            var content = this.nextElementSibling;
+            if (content.style.maxHeight){
+              content.style.maxHeight = null;
+            } else {
+              content.style.maxHeight = content.scrollHeight + "px";
+            }
+        });
+    }
+});

Documentation/doc/resources/1.8.13/menu_version.js

@@ -1,15 +1,15 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-beta1'
+  var current_version_local = '5.0.3'
   var all_versions = [
       'master',
       'latest',
-      '5.1-beta1',
+      '5.1-beta2',
-      '5.0.2',
+      '5.0.3',
-      '4.14.3',
+      '4.14.2',
       '4.13.2',
       '4.12.2',
       '4.11.3',

Documentation/doc/resources/1.8.13/stylesheet.css

@@ -1245,10 +1245,12 @@ dl.citelist dt {
         font-weight:bold;
         margin-right:10px;
         padding:5px;
+        text-align:right;
+        width:52px;
 }
 
 dl.citelist dd {
-        margin:2px 0;
+        margin:2px 0 2px 72px;
         padding:5px 0;
 }
 

Documentation/doc/resources/1.8.14/BaseDoxyfile.in

@@ -300,7 +300,16 @@ ALIASES                = "sc{1}=<span style=\"font-variant: small-caps;\">\1</sp
                          "cgalCRPSection{1}=<h2>\1</h2>" \
                          "cgalCRPSubsection{1}=<h3>\1</h3>" \
                          "cgalCite{1}=<!-- -->\cite \1" \
-                         "cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 ^^ \htmlonly[block] </div>\endhtmlonly"
+                         "cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 ^^ \htmlonly[block] </div>\endhtmlonly" \
+                         "cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">" \
+                         "cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">" \
+                         "cgalNamedParamsEnd=</table> </dd> </dl>" \
+                         "cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>" \
+                         "cgalParamDescription{1}=<li>\1</li>" \
+                         "cgalParamType{1}=<li><b>Type: </b>\1</li>" \
+                         "cgalParamDefault{1}=<li><b>%Default: </b>\1</li>" \
+                         "cgalParamExtra{1}=<li><b>Extra: </b>\1</li>" \
+                         "cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For

Documentation/doc/resources/1.8.14/cgal_stylesheet.css

@@ -345,3 +345,41 @@ div.summary
 {
   width: auto;
 }
+
+.collapsible {
+  background-color: white;
+  color: #602020;
+  cursor: pointer;
+  padding: 3px;
+  width: 100%;
+  border: none;
+  text-align: left;
+  outline: none;
+  font: 14px Roboto,sans-serif;
+}
+
+.active, .collapsible:hover {
+  background-color: white;
+}
+
+.collapsible:after {
+  content: '\25B6';
+  color: #7A93C5;
+  font-weight: bold;
+  float: left;
+  margin-left: -20px;
+  margin-right: 5px;
+}
+
+.active:after {
+  content: "\25BC";
+}
+
+.content {
+  padding: 0 18px;
+  color: black;
+  max-height: 0;
+  overflow: hidden;
+  transition: max-height 0.2s ease-out;
+  background-color: white;
+}

Documentation/doc/resources/1.8.14/hacks.js

@@ -110,3 +110,19 @@ $(document).ready(function() {
     }
 })();
 
+$(document).ready(function() {
+    var coll = document.getElementsByClassName("collapsible");
+    var i;
+
+    for (i = 0; i < coll.length; i++) {
+        coll[i].addEventListener("click", function() {
+            this.classList.toggle("active");
+            var content = this.nextElementSibling;
+            if (content.style.maxHeight){
+              content.style.maxHeight = null;
+            } else {
+              content.style.maxHeight = content.scrollHeight + "px";
+            }
+        });
+    }
+});

Documentation/doc/resources/1.8.14/menu_version.js

@@ -1,15 +1,15 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-beta1'
+  var current_version_local = '5.0.3'
   var all_versions = [
       'master',
       'latest',
-      '5.1-beta1',
+      '5.1-beta2',
-      '5.0.2',
+      '5.0.3',
-      '4.14.3',
+      '4.14.2',
       '4.13.2',
       '4.12.2',
       '4.11.3',

Documentation/doc/resources/1.8.14/stylesheet.css

@@ -1245,10 +1245,12 @@ dl.citelist dt {
         font-weight:bold;
         margin-right:10px;
         padding:5px;
+        text-align:right;
+        width:52px;
 }
 
 dl.citelist dd {
-        margin:2px 0;
+        margin:2px 0 2px 72px;
         padding:5px 0;
 }
 

Documentation/doc/resources/1.8.4/BaseDoxyfile.in

@@ -305,6 +305,16 @@ ALIASES+= "cgalCite{1}=<!-- -->\cite \1"
 
 ALIASES+= "cgalPackageSection{2}=\htmlonly <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly </div>\endhtmlonly"
 
+ALIASES+= "cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">"
+ALIASES+= "cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">"
+ALIASES+= "cgalNamedParamsEnd=</table> </dd> </dl>"
+ALIASES+= "cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>"
+ALIASES+= "cgalParamDescription{1}=<li>\1</li>"
+ALIASES+= "cgalParamType{1}=<li><b>Type: </b>\1</li>"
+ALIASES+= "cgalParamDefault{1}=<li><b>%Default: </b>\1</li>"
+ALIASES+= "cgalParamExtra{1}=<li><b>Extra: </b>\1</li>"
+ALIASES+= "cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
+
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding
 # "class=itcl::class" will allow you to use the command class in the

Documentation/doc/resources/1.8.4/cgal_stylesheet.css

@@ -336,3 +336,41 @@ div.summary
 {
   width: auto;
 }
+
+.collapsible {
+  background-color: white;
+  color: #602020;
+  cursor: pointer;
+  padding: 3px;
+  width: 100%;
+  border: none;
+  text-align: left;
+  outline: none;
+  font: 14px Roboto,sans-serif;
+}
+
+.active, .collapsible:hover {
+  background-color: white;
+}
+
+.collapsible:after {
+  content: '\25B6';
+  color: #7A93C5;
+  font-weight: bold;
+  float: left;
+  margin-left: -20px;
+  margin-right: 5px;
+}
+
+.active:after {
+  content: "\25BC";
+}
+
+.content {
+  padding: 0 18px;
+  color: black;
+  max-height: 0;
+  overflow: hidden;
+  transition: max-height 0.2s ease-out;
+  background-color: white;
+}

Documentation/doc/resources/1.8.4/hacks.js

@@ -106,3 +106,19 @@ $(document).ready(function() {
     }
 })();
 
+$(document).ready(function() {
+    var coll = document.getElementsByClassName("collapsible");
+    var i;
+
+    for (i = 0; i < coll.length; i++) {
+        coll[i].addEventListener("click", function() {
+            this.classList.toggle("active");
+            var content = this.nextElementSibling;
+            if (content.style.maxHeight){
+              content.style.maxHeight = null;
+            } else {
+              content.style.maxHeight = content.scrollHeight + "px";
+            }
+        });
+    }
+});

Documentation/doc/resources/1.8.4/menu_version.js

@@ -1,15 +1,15 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-beta1'
+  var current_version_local = '5.0.3'
   var all_versions = [
       'master',
       'latest',
-      '5.1-beta1',
+      '5.1-beta2',
-      '5.0.2',
+      '5.0.3',
-      '4.14.3',
+      '4.14.2',
       '4.13.2',
       '4.12.2',
       '4.11.3',

Documentation/doc/resources/1.8.4/stylesheet.css

@@ -1079,10 +1079,12 @@ dl.citelist dt {
         font-weight:bold;
         margin-right:10px;
         padding:5px;
+        text-align:right;
+        width:52px;
 }
 
 dl.citelist dd {
-        margin:2px 0;
+        margin:2px 0 2px 72px;
         padding:5px 0;
 }
 

Documentation/doc/scripts/pkglist_filter

@@ -1,9 +1,3 @@
 #!/bin/sh
 
-if which python2 2>/dev/null >/dev/null; then 
+exec ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
-    exec python2 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
-elif which python2.7 2>/dev/null >/dev/null; then 
-    exec python2.7 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
-elif which python2.6 2>/dev/null >/dev/null; then 
-    exec python2.6 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
-fi

Documentation/doc/scripts/pkglist_filter.bat

@@ -1,18 +1,6 @@
 @echo off
 
-@where /q python
-if not errorlevel 1 ( set python=python )
-
-@where /q python2
-if not errorlevel 1 ( set python=python2 )
-
-@where /q python2.6
-if not errorlevel 1 ( set python=python2.6 )
-
-@where /q python2.7
-if not errorlevel 1 ( set python=python2.7 )
-
 :go
-%python% ${CMAKE_BINARY_DIR}/pkglist_filter.py %1
+${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/pkglist_filter.py %1
 
 @echo on

Documentation/doc/scripts/pkglist_filter.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 
 import codecs
 import re
@@ -28,10 +28,16 @@ def main(argv):
             for l in pkgdesc:
                 do_print = do_print or re.match(".*cgalPkgDescriptionBegin.*", l)
                 if(do_print):
-                    sys.stdout.write(l.encode('utf-8'))
+                  if hasattr(sys.stdout, 'buffer'):
+                    sys.stdout.buffer.write(l.encode('utf-8')) #python3
+                  else:
+                    sys.stdout.write(l.encode('utf-8')) #python2
                 do_print = do_print and (not re.match(".*cgalPkgDescriptionEnd.*", l))
         else:
-            sys.stdout.write(line.encode('utf-8'))
+          if hasattr(sys.stdout, 'buffer'):
+            sys.stdout.buffer.write(line.encode('utf-8')) #python3
+          else:
+            sys.stdout.write(line.encode('utf-8')) #python2
 
 if __name__ == "__main__":
     main(sys.argv)

GraphicsView/include/CGAL/Qt/camera_impl.h

@@ -1725,6 +1725,11 @@ CGAL_INLINE_FUNCTION
    MAT(out, 3, 3) = r3[7];
    return 1;
   }
+
+#undef MAT
+#undef SWAP_ROWS_GLdouble
+#undef SWAP_ROWS_DOUBLE
+
 CGAL_INLINE_FUNCTION
 int unProject(GLdouble winx, GLdouble winy, GLdouble winz, GLdouble *modelview, GLdouble *projection, int *viewport,
               GLdouble *objX,GLdouble *objY,GLdouble *objZ)

Installation/CHANGES.md

@@ -4,7 +4,7 @@ Release History
 [Release 5.1](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1)
 -----------
 
-Release date: July 2020
+Release date: September 2020
 
 ### [Tetrahedral Remeshing](https://doc.cgal.org/5.1/Manual/packages.html#PkgTetrahedralRemeshing) (new package)
 
@@ -30,6 +30,11 @@ Release date: July 2020
 
     See also the associated [blog entry](https://www.cgal.org/2020/04/20/Optimal_bounding_box/).
 
+### Installation
+
+-   The CGAL\_Core library no longer requires `Boost.Thread`, even if the g++ compiler is used.
+-   The minimal supported version of Boost is now 1.66.0.
+
 ### [Tutorials](https://doc.cgal.org/5.1/Manual/tutorials.html)
 
 -   Two new, detailed tutorials have been added:

Installation/CMakeLists.txt

@@ -382,8 +382,6 @@ include(${CGAL_MODULES_DIR}/CGAL_Macros.cmake)
 include(${CGAL_MODULES_DIR}/CGAL_enable_end_of_configuration_hook.cmake)
 cgal_setup_module_path()
 
-message( STATUS "CGAL_REFERENCE_CACHE_DIR=${CGAL_REFERENCE_CACHE_DIR}" )
-
 if ( RUNNING_CGAL_AUTO_TEST )
   message(STATUS "Operating system:")
   execute_process(COMMAND uname -a
@@ -392,41 +390,6 @@ if ( RUNNING_CGAL_AUTO_TEST )
     ERROR_VARIABLE uname_a)
   message(STATUS "${uname_a}")
   CGAL_display_compiler_version()
-  if ( NOT "${CGAL_REFERENCE_CACHE_DIR}" STREQUAL "" )
-    if ( EXISTS ${CGAL_REFERENCE_CACHE_DIR} )
-      if ( EXISTS ${CGAL_REFERENCE_CACHE_DIR}/CMakeCache.txt )
-        message( STATUS "Loading reference cache from ${CGAL_REFERENCE_CACHE_DIR}" )
-        load_cache( ${CGAL_REFERENCE_CACHE_DIR}
-          EXCLUDE CGAL_Core_LIBRARY
-                  CGAL_CORE_PACKAGE_DIR
-                  WITH_CGAL_Core
-                  CGAL_INSTALLATION_PACKAGE_DIR
-                  CGAL_MAINTENANCE_PACKAGE_DIR
-                  CGAL_PDB_BINARY_DIR
-                  CGAL_PDB_SOURCE_DIR
-                  CGAL_BINARY_DIR
-                  CGAL_SOURCE_DIR)
-#        message("List of cache variables:")
-
-        ## The following lines removes nasty loaded cache values. We do not
-        ## want that the current build tree depends on binaries that were
-        ## build in the reference build tree.
-        get_property(cache_variables DIRECTORY PROPERTY CACHE_VARIABLES)
-        foreach(var ${cache_variables})
-#          get_property(var_value CACHE ${var} PROPERTY VALUE)
-#          get_property(type CACHE ${var} PROPERTY TYPE)
-          string(REGEX MATCH "^CGAL(_.*_(DEPENDS|BINARY_DIR)|_.*LIBRARY)$" var_name_matches ${var})
-          if(var_name_matches)
-            unset(${var} CACHE)
-#          else()
-#            message("${var}:${var_type}=${var_value}")
-          endif()
-        endforeach()
-
-
-      endif()
-    endif()
-  endif()
 endif()
 
 include(CGAL_Common)
@@ -916,6 +879,7 @@ if(NOT CGAL_HEADER_ONLY)
 else()
   install(FILES
     ${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfig.cmake
+    ${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfigBuildVersion.cmake
     ${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfigVersion.cmake
     DESTINATION ${CGAL_INSTALL_CMAKE_DIR})
   if(NOT CGAL_INSTALL_CMAKE_DIR STREQUAL "${CGAL_INSTALL_LIB_DIR}/cmake/CGAL")

Installation/cmake/modules/CGAL_Boost_iostreams_support.cmake

@@ -35,7 +35,7 @@ if(Boost_IOSTREAMS_FOUND AND NOT TARGET CGAL::Boost_iostreams_support)
   if(CMAKE_VERSION VERSION_LESS 3.11)
     set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
       INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS"
-      INTERFACE_LINK_LIBRARIES ${Boost_LIB} ${ZLIB_LIBS})
+      INTERFACE_LINK_LIBRARIES "${Boost_LIB};${ZLIB_LIBS}")
   else()
     set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
       INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS")

Installation/cmake/modules/CGAL_SetupCGAL_CoreDependencies.cmake

@@ -53,13 +53,6 @@ endif()
 #   keyword, or ``PUBLIC`` otherwise.
 #
 
-# See the release notes of CGAL-4.10: CGAL_Core now requires
-# Boost.Thread, with GNU G++ < 9.1.
-if (CMAKE_CXX_COMPILER_ID STREQUAL GNU AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.1)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_TweakFindBoost.cmake)
-  find_package( Boost 1.48 REQUIRED COMPONENTS thread system )
-endif()
-
 function(CGAL_setup_CGAL_Core_dependencies target)
   if(ARGV1 STREQUAL INTERFACE)
     set(keyword INTERFACE)
@@ -71,20 +64,4 @@ function(CGAL_setup_CGAL_Core_dependencies target)
   target_compile_definitions(${target} ${keyword} CGAL_USE_CORE=1)
   target_link_libraries( CGAL_Core ${keyword} CGAL::CGAL )
 
-  # See the release notes of CGAL-4.10: CGAL_Core now requires
-  # Boost.Thread, with GNU G++.
-  if (CMAKE_CXX_COMPILER_ID STREQUAL GNU AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.1)
-    if(TARGET Boost::thread)
-      target_link_libraries( CGAL_Core ${keyword} Boost::thread)
-    else()
-      # Note that `find_package( Boost...)` must be called in the
-      # function `CGAL_setup_CGAL_Core_dependencies()` because the
-      # calling `CMakeLists.txt` may also call `find_package(Boost)`
-      # between the inclusion of this module, and the call to this
-      # function. That resets `Boost_LIBRARIES`.
-      find_package( Boost 1.48 REQUIRED thread system )
-      target_link_libraries( CGAL_Core ${keyword} ${Boost_LIBRARIES})
-    endif()
-  endif()
-
 endfunction()

Installation/cmake/modules/CGAL_add_test.cmake

@@ -16,6 +16,9 @@ if(NOT POLICY CMP0064)
   # Add a fake function to avoid CMake errors
   function(cgal_add_compilation_test)
   endfunction()
+  # Add a fake function to avoid CMake errors
+  function(cgal_setup_test_properties)
+  endfunction()
 
   # Then return, to exit the file
   return()

Installation/cmake/modules/CGAL_parse_version_h.cmake

@@ -14,5 +14,6 @@ function(cgal_parse_version_h version_h_file name)
   MATH(EXPR ${ARGV3} "${CMAKE_MATCH_5}")        # minor version without leading 0
   set(${ARGV3} "${${ARGV3}}" PARENT_SCOPE)
   set(${ARGV4} "${CMAKE_MATCH_6}" PARENT_SCOPE)                 # patch number
-  set(${ARGV5} "${CMAKE_MATCH_7}" PARENT_SCOPE)                 # build number
+  MATH(EXPR ${ARGV5} "${CMAKE_MATCH_7}")        # build number version without leading 0
+  set(${ARGV5} "${${ARGV5}}" PARENT_SCOPE)                      # build number
 endfunction()

Installation/cmake/modules/FindMPFI.cmake

@@ -1,4 +1,5 @@
 find_package( GMP QUIET )
+find_package( MPFR QUIET )
 
 if( GMP_FOUND AND MPFR_FOUND )
 

Installation/include/CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h

@@ -0,0 +1,34 @@
+// Copyright (C) 2020  GeometryFactory Sarl
+//
+// This file is part of CGAL (www.cgal.org)
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
+//
+
+#ifndef CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H
+#define CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H
+
+/// \file Mesh_complex_3_in_triangulation_3_fwd.h
+/// Forward declarations of the Mesh_3 package.
+
+#ifndef DOXYGEN_RUNNING
+namespace CGAL {
+
+// fwdS for the public interface
+template <typename Tr,
+          typename CornerIndex = int,
+          typename CurveIndex = int>
+class Mesh_complex_3_in_triangulation_3;
+
+template<class Tr, bool c3t3_loader_failed>
+bool build_triangulation_from_file(std::istream& is,
+                                   Tr& tr);
+
+} // CGAL
+#endif
+
+#endif /* CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H */
+
+

Installation/include/CGAL/config.h

@@ -36,8 +36,9 @@
 #  define WIN64
 #endif
 
-#ifdef BOOST_MSVC
+#ifdef _MSC_VER
 #define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING 1
+#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING 1
 #endif
 
 #ifdef CGAL_INCLUDE_WINDOWS_DOT_H
@@ -296,6 +297,10 @@
 #if __cplusplus >= 201402L || _MSVC_LANG >= 201402L
 #  define CGAL_CXX14 1
 #endif
+// Same for C++17
+#if __cplusplus >= 201703L || _MSVC_LANG >= 201703L
+#  define CGAL_CXX17 1
+#endif
 
 #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) || BOOST_VERSION < 105000
 #define CGAL_CFG_NO_STD_HASH 1
@@ -559,7 +564,7 @@ using std::max;
 #define CGAL_NORETURN  [[noreturn]]
 
 // Macro to specify [[no_unique_address]] if supported
-#if __has_cpp_attribute(no_unique_address)
+#if CGAL_CXX11 && __has_cpp_attribute(no_unique_address)
 #  define CGAL_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #else
 #  define CGAL_NO_UNIQUE_ADDRESS

Installation/include/CGAL/version.h

@@ -17,7 +17,7 @@
 #define CGAL_VERSION_H
 
 #ifndef SWIG
-#define CGAL_VERSION 5.1-beta2
+#define CGAL_VERSION 5.1-beta3
 #define CGAL_GIT_HASH abcdef
 #endif
 #define CGAL_VERSION_NR 1050100000

Installation/lib/cmake/CGAL/CGALConfig.cmake

@@ -150,6 +150,7 @@ foreach(cgal_lib ${CGAL_LIBRARIES})
   endif()
 endforeach()
 
+include(${CGAL_CONFIG_DIR}/CGALConfigVersion.cmake)
 
 #
 #
@@ -161,15 +162,6 @@ cgal_setup_module_path()
 set(CGAL_USE_FILE ${CGAL_MODULES_DIR}/UseCGAL.cmake)
 include(${CGAL_MODULES_DIR}/CGAL_target_use_TBB.cmake)
 
-include("${CGAL_MODULES_DIR}/CGAL_parse_version_h.cmake")
-cgal_parse_version_h( "${CGAL_INSTALLATION_PACKAGE_DIR}/include/CGAL/version.h"
-  "CGAL_VERSION_NAME"
-  "CGAL_MAJOR_VERSION"
-  "CGAL_MINOR_VERSION"
-  "CGAL_BUGFIX_VERSION"
-  "CGAL_BUILD_VERSION")
-set(CGAL_VERSION "${CGAL_MAJOR_VERSION}.${CGAL_MINOR_VERSION}.${CGAL_BUGFIX_VERSION}.${CGAL_BUILD_VERSION}")
-
 if( CGAL_DEV_MODE OR RUNNING_CGAL_AUTO_TEST )
   # Do not use -isystem for CGAL include paths
   set(CMAKE_NO_SYSTEM_FROM_IMPORTED TRUE)

Installation/lib/cmake/CGAL/CGALConfigBuildVersion.cmake

@@ -0,0 +1 @@
+set(CGAL_BUILD_VERSION 0)

Installation/lib/cmake/CGAL/CGALConfigVersion.cmake

@@ -1,7 +1,8 @@
 set(CGAL_MAJOR_VERSION 5)
 set(CGAL_MINOR_VERSION 1)
 set(CGAL_BUGFIX_VERSION 0)
-set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-beta2")
+include(${CMAKE_CURRENT_LIST_DIR}/CGALConfigBuildVersion.cmake)
+set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-beta3")
 set(CGAL_VERSION_PUBLIC_RELEASE_NAME "CGAL-${CGAL_VERSION_PUBLIC_RELEASE_VERSION}")
 
 if (CGAL_BUGFIX_VERSION AND CGAL_BUGFIX_VERSION GREATER 0)

Intersections_3/include/CGAL/Intersections_3/internal/Tetrahedron_3_Bounded_3_do_intersect.h

@@ -153,31 +153,49 @@ do_intersect(const typename K::Sphere_3 &sp,
 template <class K>
 inline
 typename K::Boolean
-do_intersect(const typename K::Tetrahedron_3 &tet,
+do_intersect(const typename K::Tetrahedron_3 &lh_tet,
-             const typename K::Tetrahedron_3 &sp,
+             const typename K::Tetrahedron_3 &rh_tet,
              const K & k)
 {
-  return do_intersect_tetrahedron_bounded(sp, tet, tet[0], k);
+  return do_intersect_tetrahedron_bounded(lh_tet, rh_tet, lh_tet[0], k);
 }
 
+// BBox_3 specific code since it is ok for BBox_3 to degenerate.
+template <class K>
+inline typename K::Boolean do_intersect(const CGAL::Bbox_3 &aabb,
+                                        const typename K::Tetrahedron_3 &tet,
+                                        const K &k) {
+  typename K::Construct_triangle_3 tr = k.construct_triangle_3_object();
+  typename K::Boolean result = false;
+  typename K::Boolean b = false;
+
+  b = do_intersect(aabb, tr(tet[0], tet[1], tet[2]), k);
+  if (certainly(b)) return b;
+  if (is_indeterminate(b)) result = b;
+  b = do_intersect(aabb, tr(tet[1], tet[2], tet[3]), k);
+  if (certainly(b)) return b;
+  if (is_indeterminate(b)) result = b;
+  b = do_intersect(aabb, tr(tet[2], tet[3], tet[0]), k);
+  if (certainly(b)) return b;
+  if (is_indeterminate(b)) result = b;
+  b = do_intersect(aabb, tr(tet[3], tet[0], tet[1]), k);
+  if (certainly(b)) return b;
+  if (is_indeterminate(b)) result = b;
+
+  b = k.has_on_bounded_side_3_object()(
+      tet, k.construct_point_3_object()(aabb.xmin(), aabb.ymin(), aabb.zmin()));
+  if (certainly(b)) return b;
+  if (is_indeterminate(b)) result = b;
+
+  return result;
+}
+
+
 template <class K>
-inline
+inline typename K::Boolean do_intersect(const typename K::Tetrahedron_3 &tet,
-typename K::Boolean
+                                        const CGAL::Bbox_3 &bb, const K &k) {
-do_intersect(const typename K::Tetrahedron_3 &tet,
+  // Swap arguments.
-             const CGAL::Bbox_3 &bb,
+  return do_intersect(bb, tet, k);
-             const K & k)
-{
-  return do_intersect_tetrahedron_bounded(bb, tet, typename K::Point_3(bb.xmin(), bb.ymin(), bb.zmin()), k);
-}
-
-  template <class K>
-inline
-typename K::Boolean
-do_intersect(const CGAL::Bbox_3 &bb,
-             const typename K::Tetrahedron_3 &tet,
-             const K & k)
-{
-  return do_intersect_tetrahedron_bounded(bb, tet, typename K::Point_3(bb.xmin(), bb.ymin(), bb.zmin()), k);
 }
 
 } // namespace internal

Kernel_23/test/Kernel_23/test_approximate_dihedral_angle_3.cpp

@@ -0,0 +1,36 @@
+#include <CGAL/Simple_cartesian.h>
+#include <CGAL/Kernel/global_functions_3.h>
+#include <iostream>
+#include <utility>
+using K = CGAL::Simple_cartesian<double>;
+using Point_3 = K::Point_3;
+
+struct query {
+  Point_3 p;
+  double expected_angle;
+};
+
+int main() {
+  Point_3 a = {0, 0, 0};
+  Point_3 b = {0, 1, 0};
+  Point_3 c = {1, 0, 0};
+
+  const query queries[] = {
+    { {  1, 0,  0},    0.},
+    { {  1, 0,  1},   45.},
+    { {  0, 0,  1},   90.},
+    { { -1, 0,  1},  135.},
+    { { -1, 0,  0},  180.},
+    { { -1, 0, -1}, -135.},
+    { {  0, 0, -1},  -90.},
+    { {  1, 0, -1},  -45.},
+  };
+
+  for(auto query: queries) {
+    const auto& expected = query.expected_angle;
+    const auto& p = query.p;
+    auto approx = CGAL::approximate_dihedral_angle(a, b, c, p);
+    std::cout << approx << "  -- " << expected << '\n';
+    assert( std::abs(approx - expected) < 0.1 );
+  }
+};

Maintenance/infrastructure/cgal.geometryfactory.com/crontab

@@ -23,9 +23,9 @@ LC_CTYPE=en_US.UTF-8
 # The script also updates the manual tools.
 
 # "master" alone
-0 21  *  *  Sun                      cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/master.git --do-it --beta 2 --public || echo ERROR
+0 21  *  *  Sun                      cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/master.git --do-it --beta 3 --public || echo ERROR
 # "integration"
-0 21  *  *  Mon,Tue,Wed,Thu          cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/integration.git $HOME/CGAL/branches/empty-dir --do-it --beta 2 --public || echo ERROR
+0 21  *  *  Mon,Tue,Wed,Thu          cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/integration.git $HOME/CGAL/branches/empty-dir --do-it --beta 3 --public || echo ERROR
 # from branch 5.0
 0 21  *  *  Sat                      cd $HOME/CGAL/create_internal_release-5.0-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.0-branch.git --public --do-it || echo ERROR
 # from branch 4.14

Maintenance/public_release/announcement/mailing-beta.eml

@@ -1,14 +1,14 @@
-Subject: CGAL 5.1 Beta 1 Released, Computational Geometry Algorithms Library
+Subject: CGAL 5.1 Beta 2 Released, Computational Geometry Algorithms Library
 Content-Type: text/plain; charset="utf-8"
 Body:
 
-The CGAL Open Source Project is pleased to announce the release 5.1 Beta 1
+The CGAL Open Source Project is pleased to announce the release 5.1 Beta 2
 of CGAL, the Computational Geometry Algorithms Library.
 
 
-CGAL version 5.1 Beta 1 is a public testing release. It should provide a
+CGAL version 5.1 Beta 2 is a public testing release. It should provide a
 solid ground to report bugs that need to be tackled before the release
-of the final version of CGAL 5.1 in July.
+of the final version of CGAL 5.1 in September.
 
 
 Besides fixes and general enhancement to existing packages, the following
@@ -45,6 +45,11 @@ Optimal Bounding Box (new package)
     See also the associated blog entry:
       https://www.cgal.org/2020/04/20/Optimal_bounding_box/
 
+Installation
+
+-   The CGAL_Core library no longer requires Boost.Thread, even if the
+    g++ compiler is used.
+
 Tutorials
 
 -   Two new, detailed tutorials have been added:
@@ -118,7 +123,7 @@ CGAL and the Boost Graph Library (BGL)
     uses this alpha expansion graphcut to regularize the borders of a
     selected faces on a triangle mesh.
 
-See https://www.cgal.org/2020/06/09/cgal51-beta1/ for a complete list of
+See https://www.cgal.org/2020/07/28/cgal51-beta2/ for a complete list of
 changes.
 
 

Mesh_3/doc/Mesh_3/Doxyfile.in

@@ -1,19 +1,8 @@
 @INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
 
 # macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PMP_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"
 ALIASES += "cgalDescribePolylineType=A polyline is defined as a sequence of points, each pair of contiguous points defines a segment of the polyline. If the first and last points of the polyline are identical, the polyline is closed."
 
-#macros for NamedParameters.txt
-ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
-ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
-ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
-ALIASES += "cgalNPEnd=</td></tr>"
-
-
 INPUT += \
       ${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Polyhedral_complex_mesh_domain_3.h \
       ${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Mesh_domain_with_polyline_features_3.h

Mesh_3/examples/Mesh_3/CMakeLists.txt

@@ -133,23 +133,26 @@ else()
   message( STATUS "NOTICE: Some examples need the CGAL_ImageIO library, and will not be compiled." )
 endif()
 
-if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support AND TARGET ${target})
+if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support)
   foreach(target
-      mesh_3D_image_with_features
       mesh_3D_image
-      mesh_polyhedral_domain
+      mesh_3D_image_variable_size
       mesh_3D_image_with_custom_initialization
-      mesh_two_implicit_spheres_with_balls
+      mesh_3D_image_with_features
-      mesh_optimization_lloyd_example
-      mesh_optimization_example
       mesh_implicit_sphere
-      mesh_polyhedral_complex_sm
       mesh_implicit_sphere_variable_size
-      mesh_polyhedral_domain_sm
+      mesh_optimization_example
-      mesh_polyhedral_domain_with_lipschitz_sizing
+      mesh_optimization_lloyd_example
       mesh_polyhedral_complex
+      mesh_polyhedral_complex_sm
+      mesh_polyhedral_domain
+      mesh_polyhedral_domain_sm
       mesh_polyhedral_domain_with_features
-      mesh_3D_image_variable_size)
+      mesh_polyhedral_domain_with_features_sm
+      mesh_polyhedral_domain_with_lipschitz_sizing
+      mesh_two_implicit_spheres_with_balls)
+    if(TARGET ${target})
       target_link_libraries(${target} PUBLIC CGAL::TBB_support)
+    endif()
   endforeach()
 endif()

Mesh_3/include/CGAL/IO/File_medit.h

@@ -17,6 +17,7 @@
 #include <CGAL/license/Triangulation_3.h>
 
 #include <CGAL/Mesh_3/config.h>
+#include <CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h>
 
 #include <CGAL/utility.h>
 #include <CGAL/basic.h>
@@ -893,6 +894,23 @@ output_to_medit(std::ostream& os,
   }
 }
 
+
+template<typename T3>
+void write_MEDIT(std::ostream& os, const T3& t3)
+{
+  CGAL::Mesh_complex_3_in_triangulation_3<T3, int, int> c3t3;
+  c3t3.triangulation() = t3;
+  c3t3.rescan_after_load_of_triangulation();
+  output_to_medit(os, c3t3);
+}
+
+template<typename T3>
+bool read_MEDIT(std::istream& in, T3& t3)
+{
+  CGAL_assertion(!(!in));
+  return CGAL::build_triangulation_from_file<T3, true>(in, t3);
+}
+
 } // end namespace CGAL
 
 #endif // CGAL_IO_FILE_MEDIT_H

Mesh_3/include/CGAL/Mesh_3/C3T3_helpers.h

@@ -1224,8 +1224,8 @@ private:
       if(update_c3t3)
       {
         // Update status in c3t3
-        if(surface != boost::none)
+        if((bool)surface)
-          c3t3_.add_to_complex(facet, surface.get());
+          c3t3_.add_to_complex(facet, *surface);
         else
           c3t3_.remove_from_complex(facet);
       }
@@ -1246,7 +1246,7 @@ private:
         }
       }
 
-      return surface;
+      return surface ? surface : Surface_patch();
     }
 
 
@@ -1572,10 +1572,17 @@ private:
   Cell_vector c3t3_cells(const Cell_vector& cells) const
   {
     Cell_vector c3t3_cells;
+#ifdef CGAL_CXX17
+    std::remove_copy_if(cells.begin(),
+                        cells.end(),
+                        std::back_inserter(c3t3_cells),
+                        std::not_fn(Is_in_c3t3<Cell_handle>(c3t3_)));
+#else
     std::remove_copy_if(cells.begin(),
                         cells.end(),
                         std::back_inserter(c3t3_cells),
                         std::not1(Is_in_c3t3<Cell_handle>(c3t3_)) );
+#endif
     return c3t3_cells;
   }
 
@@ -2047,7 +2054,7 @@ private:
                                        true); /* update surface centers */
       // false means "do not update the c3t3"
       if ( c3t3_.is_in_complex(*fit) != (bool)sp ||
-           ((bool)sp && !(c3t3_.surface_patch_index(*fit) == sp.get()) ) )
+           ((bool)sp && !(c3t3_.surface_patch_index(*fit) == *sp) ) )
         return false;
     }
 

Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h

@@ -1155,6 +1155,7 @@ insert_balls(const Vertex_handle& vp,
   //   n = 2(d-sq) / (sp+sq)
   // =======================
 
+  const FT d_signF = static_cast<FT>(d_sign);
   int n = static_cast<int>(std::floor(FT(2)*(d-sq) / (sp+sq))+.5);
   // if( minimal_weight_ != 0 && n == 0 ) return;
 
@@ -1180,7 +1181,7 @@ insert_balls(const Vertex_handle& vp,
       const Bare_point new_point =
         domain_.construct_point_on_curve(cp(vp_wp),
                                          curve_index,
-                                         d_sign * d / 2);
+                                         d_signF * d / 2);
       const int dim = 1; // new_point is on edge
       const Index index = domain_.index_from_curve_index(curve_index);
       const FT point_weight = CGAL::square(size_(new_point, dim, index));
@@ -1230,7 +1231,6 @@ insert_balls(const Vertex_handle& vp,
   FT norm_step_size = dleft_frac * step_size;
 
   // Initial distance
-  FT d_signF = static_cast<FT>(d_sign);
   FT pt_dist = d_signF * norm_step_size;
   Vertex_handle prev = vp;
   const Bare_point& p = cp(c3t3_.triangulation().point(vp));

Mesh_3/include/CGAL/Mesh_3/tet_soup_to_c3t3.h

@@ -105,13 +105,14 @@ bool build_finite_cells(Tr& tr,
     const std::vector<typename Tr::Vertex_handle>& vertex_handle_vector,
     boost::unordered_map<std::array<typename Tr::Vertex_handle, 3>,
                         std::vector<std::pair<typename Tr::Cell_handle, int> > >& incident_cells_map,
-    const std::map<std::array<int,3>, int>& border_facets,
+    const std::map<std::array<int,3>, typename Tr::Cell::Surface_patch_index>& border_facets,
     const bool verbose)
 {
   typedef std::array<int, 5>              Tet_with_ref; // 4 ids + 1 reference
 
   typedef typename Tr::Vertex_handle                            Vertex_handle;
   typedef typename Tr::Cell_handle                              Cell_handle;
+  typedef typename Tr::Cell::Surface_patch_index                Surface_patch_index;
 
   CGAL_assertion_code(
     typename Tr::Geom_traits::Construct_point_3 cp =
@@ -171,7 +172,8 @@ bool build_finite_cells(Tr& tr,
           ++k;
         } while(f[0] != n0);
 
-        typename std::map<std::array<int,3>, int>::const_iterator it = border_facets.find(f);
+        typename std::map<std::array<int,3>, Surface_patch_index>::const_iterator
+          it = border_facets.find(f);
         if(it != border_facets.end())
         {
           c->set_surface_patch_index(j, it->second);
@@ -186,7 +188,7 @@ bool build_finite_cells(Tr& tr,
           if(it != border_facets.end())
             c->set_surface_patch_index(j, it->second);
           else
-            c->set_surface_patch_index(j, 0);
+            c->set_surface_patch_index(j, Surface_patch_index());
         }
       }
     }
@@ -259,6 +261,8 @@ bool build_infinite_cells(Tr& tr,
     // the only finite facet
     it->second.push_back(std::make_pair(opp_c, 0));
     CGAL_assertion(it->second.size() == 2);
+
+    opp_c->set_surface_patch_index(0, c->surface_patch_index(i));
   }
 
 #ifdef CGAL_TET_SOUP_TO_C3T3_DEBUG
@@ -322,7 +326,7 @@ template<class Tr, bool c3t3_loader_failed>
 bool build_triangulation(Tr& tr,
                          const std::vector<typename Tr::Point>& points,
                          const std::vector<std::array<int,5> >& finite_cells,
-                         const std::map<std::array<int,3>, int>& border_facets,
+                         const std::map<std::array<int,3>, typename Tr::Cell::Surface_patch_index>& border_facets,
                          std::vector<typename Tr::Vertex_handle>& vertex_handle_vector,
                          const bool verbose = false)
 {
@@ -389,7 +393,7 @@ bool build_triangulation_from_file(std::istream& is,
 
   std::vector<Tet_with_ref> finite_cells;
   std::vector<Point_3> points;
-  std::map<Facet, int> border_facets;
+  std::map<Facet, typename Tr::Cell::Surface_patch_index> border_facets;
 
   // grab the vertices
   int dim;
@@ -420,7 +424,8 @@ bool build_triangulation_from_file(std::istream& is,
       is >> nf;
       for(int i=0; i<nf; ++i)
       {
-        int n1, n2, n3, surface_patch_id;
+        int n1, n2, n3;
+        typename Tr::Cell::Surface_patch_index surface_patch_id;
         is >> n1 >> n2 >> n3 >> surface_patch_id;
         Facet facet;
         facet[0] = n1 - 1;

Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h

@@ -20,6 +20,7 @@
 
 #include <CGAL/license/Triangulation_3.h>
 
+#include <CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h>
 #include <CGAL/disable_warnings.h>
 #include <CGAL/iterator.h>
 #include <CGAL/Mesh_3/utilities.h>
@@ -38,8 +39,8 @@ namespace CGAL {
 
 
 template <typename Tr,
-          typename CornerIndex = int,
+          typename CornerIndex,
-          typename CurveIndex = int>
+          typename CurveIndex>
 class Mesh_complex_3_in_triangulation_3 :
   public Mesh_3::Mesh_complex_3_in_triangulation_3_base<
     Tr, typename Tr::Concurrency_tag>

Nef_3/include/CGAL/Nef_3/Bounding_box_3.h

@@ -73,17 +73,13 @@ public:
   }
 
   void extend(const Point_3& p) {
-    FT q[3];
+    FT q[3] = { p.x(), p.y(), p.z() };
-    q[0] = p.x();
-    q[1] = p.y();
-    q[2] = p.z();
 
     if(initialized)
       Base::extend(q);
     else {
       initialized = true;
-      std::copy( q, q + 3, Base::lo );
+      *this = Bounding_box_3(q);
-      std::copy( q, q + 3, Base::hi );
     }
   }
 };

Nef_3/include/CGAL/Nef_3/SNC_constructor.h

@@ -229,9 +229,10 @@ public:
     Vertex_handle v = this->sncp()->new_vertex(p , boundary);
     CGAL_NEF_TRACEN( v->point());
     SM_decorator SD(&*v);
-    Sphere_point sp[] = { Sphere_point(NT(-x), 0, 0),
+    const NT zero(0);
-                          Sphere_point(0, NT(-y), 0),
+    Sphere_point sp[] = { Sphere_point(NT(-x), zero, zero),
-                          Sphere_point(0, 0, NT(-z)) };
+                          Sphere_point(zero, NT(-y), zero),
+                          Sphere_point(zero, zero, NT(-z)) };
 
   /* create box vertices */
     SVertex_handle sv[3];

Nef_3/include/CGAL/Nef_3/SNC_io_parser.h

@@ -56,7 +56,8 @@ namespace Nef_3_internal{
 
 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(Has_nested_Exact_kernel,Exact_kernel,false)
 
-template <class R,bool has_exact_kernel=Has_nested_Exact_kernel<R>::value, class FT = typename R::RT, class Kernel_tag=typename R::Kernel_tag>
+template <class R,bool has_exact_kernel=Has_nested_Exact_kernel<R>::value &&
+                                        !std::is_floating_point<typename R::RT>::value, class FT = typename R::RT, class Kernel_tag=typename R::Kernel_tag>
 struct Type_converter{
   typedef const CGAL::Point_3<R>& Point_3;
   typedef const CGAL::Vector_3<R>& Vector_3;
@@ -670,8 +671,9 @@ template<typename Tag, typename Kernel> class Geometry_io;
 template<typename Kernel>
 class Geometry_io<Cartesian_tag, Kernel> {
  public:
-  template <typename EK, typename K> static
+
-  typename EK::Point_3 read_point(std::istream& in) {
+  template <typename EK, typename K, typename Compose_> static
+  typename EK::Point_3 read_point_impl(std::istream& in, Compose_) {
     typedef Fraction_traits<typename K::FT> FracTraits;
     typename FracTraits::Type hx, hy, hz, hw;
     typename FracTraits::Numerator_type num;
@@ -688,8 +690,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
     return typename EK::Point_3(hx,hy,hz,hw);
   }
 
-  template <typename EK, typename K> static
+  template <typename EK, typename K, typename Compose_> static
-  typename EK::Plane_3 read_plane(std::istream& in) {
+  typename EK::Plane_3 read_plane_impl(std::istream& in, Compose_) {
     typedef Fraction_traits<typename K::FT> FracTraits;
     typename FracTraits::Type a, b, c, d;
     typename FracTraits::Numerator_type num;
@@ -706,8 +708,32 @@ class Geometry_io<Cartesian_tag, Kernel> {
     return typename EK::Plane_3(a,b,c,d);
   }
 
-  template <typename R> static
+  template <typename EK, typename K> static
-    void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p) {
+  typename EK::Point_3 read_point_impl(std::istream& in, Null_functor) {
+    typename K::FT hx, hy, hz, hw;
+    in >> hx >> hy >> hz >> hw;
+    return typename EK::Point_3(hx,hy,hz,hw);
+  }
+
+  template <typename EK, typename K> static
+  typename EK::Plane_3 read_plane_impl(std::istream& in, Null_functor) {
+    typename K::FT a, b, c, d;
+    in >> a >> b >> c >> d;
+    return typename EK::Plane_3(a,b,c,d);
+  }
+
+  template <typename EK, typename K> static
+  typename EK::Point_3 read_point(std::istream& in) {
+    return read_point_impl<EK,K>(in, typename Fraction_traits<typename K::FT>::Compose());
+  }
+
+  template <typename EK, typename K> static
+  typename EK::Plane_3 read_plane(std::istream& in) {
+    return read_plane_impl<EK,K>(in, typename Fraction_traits<typename K::FT>::Compose());
+  }
+
+  template <typename R, typename Decompose_> static
+  void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p, Decompose_) {
     typedef Fraction_traits<typename R::FT> FracTraits;
     typedef std::vector<typename FracTraits::Numerator_type> NV;
 
@@ -737,8 +763,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
         << vec[2] << " " << vec[3];
   }
 
-  template <typename R> static
+  template <typename R, typename Decompose_> static
-    void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> p) {
+  void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> p, Decompose_) {
     typedef Fraction_traits<typename R::FT> FracTraits;
     typedef typename FracTraits::Numerator_type NumType;
     typedef std::vector<NumType> NV;
@@ -766,8 +792,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
         << vec[2] << " " << NumType(1);
   }
 
-  template <typename R> static
+  template <typename R, typename Decompose_> static
-  void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p) {
+  void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p, Decompose_) {
     typedef Fraction_traits<typename R::FT> FracTraits;
     typedef std::vector<typename FracTraits::Numerator_type> NV;
 
@@ -803,19 +829,37 @@ class Geometry_io<Cartesian_tag, Kernel> {
         << vec[2] << " " << vec[3];
   }
 
+  template <typename R> static
+  void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p, Null_functor)
+  {
+    out << p.x() << " " << p.y() << " " << p.z() << " " << 1;
+  }
+
+  template <typename R> static
+  void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> v, Null_functor)
+  {
+    out << v.x() << " " << v.y() << " " << v.z() << " " << 1;
+  }
+
+  template <typename R> static
+  void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p, Null_functor)
+  {
+    out << p.a() << " " << p.b() << " " << p.c() << " " << p.d();
+  }
+
   template <class R> static
   void print_point(std::ostream& out, const CGAL::Point_3<R>& p) {
-    print_point_impl(out, Nef_3_internal::get_point(p) );
+    print_point_impl(out, Nef_3_internal::get_point(p), typename Fraction_traits<typename R::FT>::Decompose() );
   }
 
   template <class R> static
   void print_vector(std::ostream& out, const CGAL::Vector_3<R>& v) {
-    print_vector_impl(out, Nef_3_internal::get_vector(v) );
+    print_vector_impl(out, Nef_3_internal::get_vector(v), typename Fraction_traits<typename R::FT>::Decompose() );
   }
 
   template <class R> static
   void print_plane(std::ostream& out, const CGAL::Plane_3<R>& p) {
-    print_plane_impl(out, Nef_3_internal::get_plane(p) );
+    print_plane_impl(out, Nef_3_internal::get_plane(p), typename Fraction_traits<typename R::FT>::Decompose() );
   }
 
 };

Nef_3/include/CGAL/Nef_3/SNC_point_locator.h

@@ -563,7 +563,7 @@ public:
     Partial_facet pf;
 #endif
     bool hit = false;
-    Point_3 eor; // 'end of ray', the latest ray's hit point
+    Point_3 eor = CGAL::ORIGIN; // 'end of ray', the latest ray's hit point
     Objects_along_ray objects = candidate_provider->objects_along_ray(ray);
     Objects_along_ray_iterator objects_iterator = objects.begin();
     while( !hit && objects_iterator != objects.end()) {

Nef_3/test/Nef_3/CMakeLists.txt

@@ -24,6 +24,7 @@ if ( CGAL_FOUND )
         execution___of__test_nef_3_io_Cartesian
         execution___of__test_nef_3_io_Cartesian_Lazy
         execution___of__test_nef_3_io_EPEC
+        execution___of__test_nef_3_io_EPIC
         execution___of__test_nef_3_io_Homogeneous
         execution___of__test_nef_3_io_Homogenoeus_Lazy
         execution___of__test_with_extended_homogeneous

Nef_3/test/Nef_3/test_nef_3_io_EPIC.cpp

@@ -0,0 +1,57 @@
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+
+#include <CGAL/Nef_polyhedron_3.h>
+#include <CGAL/Polyhedron_3.h>
+#include <CGAL/IO/Nef_polyhedron_iostream_3.h>
+
+#include <fstream>
+
+typedef CGAL::Exact_predicates_inexact_constructions_kernel EPEC;
+
+template <class Kernel>
+void test_write_read()
+{
+  typedef CGAL::Nef_polyhedron_3< Kernel > Nef_polyhedron;
+  typedef CGAL::Polyhedron_3< Kernel >     Polyhedron;
+  typedef typename Kernel::Point_3         Point;
+
+  typename Kernel::RT n, d;
+  std::istringstream str_n("5");
+  str_n >> n;
+  std::istringstream str_d("1");
+  str_d >> d;
+
+  Point p(n, 0, 0, d);
+  Point q(0, n, 0, d);
+  Point r(0, 0, n, d);
+  Point s(0, 0, 0, 1);
+
+  std::cout << "    build...\n";
+  Polyhedron P;
+  P.make_tetrahedron( p, q, r, s);
+  Nef_polyhedron nef_1( P );
+
+  std::cout << "    write...\n";
+  std::ofstream out ("temp.nef");
+  out << std::setprecision(17) << nef_1;
+  out.close();
+
+  std::cout << "    read...\n";
+  std::ifstream in ("temp.nef");
+  Nef_polyhedron nef_2;
+  in >> nef_2;
+  in.close();
+
+  std::cout << "    check...\n";
+  assert( nef_1 == nef_2);
+}
+
+int main()
+{
+  std::cout << "Testing Exact_predicates_inexact_constructions_kernel\n";
+  test_write_read<EPEC>();
+  std::cout << "Testing Simple_cartesian<double>\n";
+  test_write_read<CGAL::Simple_cartesian<double>>();
+
+  return 0;
+}

Number_types/include/CGAL/Exact_algebraic.h

@@ -49,12 +49,10 @@ typedef unspecified_type Exact_algebraic;
 
 #else // not DOXYGEN_RUNNING
 
-#ifdef CGAL_USE_CORE
-  typedef CORE::Expr Exact_algebraic;
-#endif
-
 #ifdef CGAL_USE_LEDA
 typedef leda_real Exact_algebraic;
+#elif defined CGAL_USE_CORE
+  typedef CORE::Expr Exact_algebraic;
 #endif
 
 #endif

Number_types/test/Number_types/CMakeLists.txt

@@ -68,6 +68,7 @@ if ( CGAL_FOUND )
   create_single_source_cgal_program( "to_interval_test.cpp" )
   create_single_source_cgal_program( "unsigned.cpp" )
   create_single_source_cgal_program( "utilities.cpp" )
+  find_package( GMP )
   if( GMP_FOUND )
     create_single_source_cgal_program( "CORE_Expr_ticket_4296.cpp" )
     find_package( MPFI )

Number_types/test/Number_types/Lazy_exact_nt_new.cpp

@@ -98,7 +98,8 @@ void test_lazy_exact_nt() {
 #ifdef CGAL_USE_CORE
         CGAL_assertion_code(typedef CGAL::Lazy_exact_nt<leda_integer> T1;)
         CGAL_assertion_code(typedef CGAL::Lazy_exact_nt<CORE::Expr> T2;)
-        CGAL_assertion_code(typedef CGAL::Coercion_traits<T1, T2> CT;)
+        typedef CGAL::Coercion_traits<T1, T2> CT;
+        CGAL_USE_TYPE(CT);
         CGAL_static_assertion((boost::is_same< typename CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
         CGAL_static_assertion((boost::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
 #endif
@@ -115,4 +116,3 @@ int main() {
 #endif
   return 0;
 }
-

Optimal_bounding_box/doc/Optimal_bounding_box/Doxyfile.in

@@ -5,18 +5,6 @@ EXTRACT_ALL                =  false
 HIDE_UNDOC_CLASSES         =  true
 WARN_IF_UNDOCUMENTED       =  true
 
-# macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref OBB_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"
-
-#macros for NamedParameters.txt
-ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
-ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
-ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
-ALIASES += "cgalNPEnd=</td></tr>"
-
 MACRO_EXPANSION        = YES
 EXPAND_ONLY_PREDEF     = YES
 EXPAND_AS_DEFINED      = CGAL_BGL_NP_TEMPLATE_PARAMETERS \

Optimal_bounding_box/doc/Optimal_bounding_box/NamedParameters.txt

@@ -1,65 +0,0 @@
-/*!
-\defgroup obb_namedparameters Named Parameters for the package Optimal Bounding Box
-\ingroup PkgOptimalBoundingBoxRef
-
-In this package, the optional parameters of all functions are implemented as BGL optional
-named parameters (see \ref BGLNamedParameters for more information on how to use them).
-Since the parameters of the various functions defined in this package are redundant,
-their long descriptions are centralized below.
-The sequence of named parameters should start with `CGAL::parameters::`.
-`CGAL::parameters::all_default()` can be used to indicate
-that default values of optional named parameters must be used.
-
-In the following, we assume that the following types are provided as template parameters
-of functions and classes. Note that, for some of these functions,
-the type is more specific:
-<ul>
-<li>`PolygonMesh` is a model of the concept `FaceGraph`</li>.
-<li>`GeomTraits` a geometric traits class in which constructions are performed and
-     predicates evaluated. Everywhere in this package, a \cgal `Kernel` fulfills the requirements.</li>
-</ul>
-
-The following named parameters, offered by the package \ref PkgBGL
-(see \ref bgl_namedparameters), are used in this package:
-
-\cgalNPTableBegin
-\cgalNPBegin{vertex_point_map} \anchor OBB_vertex_point_map
-is the property map with the points associated to the vertices of the polygon mesh `pmesh`.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with
-`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
-`GeomTraits::Point_3` as value type. \n
-<b>Default:</b> \code boost::get(CGAL::vertex_point, pmesh) \endcode
-\cgalNPEnd
-
-\cgalNPBegin{point_map} \anchor OBB_point_map
- is the property map containing the points associated to the elements of the point range `points`.\n
-<b>Type:</b> a class model of `ReadablePropertyMap` with `PointRange::iterator::value_type` as key type
-         and `geom_traits::Point_3` as value type. \n
-<b>Default:</b> \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
-\cgalNPEnd
-\cgalNPTableEnd
-
-In addition to these named parameters, this package offers the following named parameters:
-
-\cgalNPTableBegin
-\cgalNPBegin{geom_traits} \anchor OBB_geom_traits
-is the geometric traits instance in which the mesh processing operation should be performed.\n
-<b>Type:</b> a Geometric traits class.\n
-<b>Default:</b>
-\code typename CGAL::Kernel_traits<
-        typename boost::property_traits<
-          typename boost::property_map<PolygonMesh, CGAL::vertex_point_t>::type>::value_type>::Kernel \endcode
-\cgalNPEnd
-
-\cgalNPBegin{use_convex_hull} \anchor OBB_use_convex_hull
-Parameter used in the construction of oriented bounding box to indicate whether the algorithm should
-first extract the extreme points (points that are on the 3D convex hull) of the input data range
-to accelerate the computation of the bounding box.
-\n
-<b>Type:</b> `bool` \n
-<b>Default:</b> `true`
-\cgalNPEnd
-
-\cgalNPTableEnd
-
-*/

Optimal_bounding_box/doc/Optimal_bounding_box/Optimal_bounding_box.txt

@@ -94,7 +94,7 @@ and is enabled by default.
 
 \subsection OBBInnOut Input and Output
 
-The input can be a range of 3D points, or a mesh, with a variety of \ref obb_namedparameters "Named Parameters"
+The input can be a range of 3D points, or a mesh, with a variety of \ref bgl_namedparameters "Named Parameters"
 enabling using further custom inputs.
 
 The result of the algorithm can be retrieved as:
@@ -177,7 +177,7 @@ from the eight points.
 
 \subsection OBBExampleNP Using Named Parameters
 
-The following example illustrates how to use \ref obb_namedparameters "Named Parameters"
+The following example illustrates how to use \ref bgl_namedparameters "Named Parameters"
 to efficiently compute the oriented bounding box of a mesh whose vertices' positions are
 modified on the fly.
 

Optimal_bounding_box/doc/Optimal_bounding_box/PackageDescription.txt

@@ -35,7 +35,7 @@
 \cgalCRPSection{Parameters}
 
 Optional parameters of the functions of this package are implemented as \ref BGLNamedParameters.
-The page \ref obb_namedparameters describes their usage and provides a list of the parameters
+The page \ref bgl_namedparameters describes their usage and provides a list of the parameters
 that are used in this package.
 
 \cgalCRPSection{Concepts}

Optimal_bounding_box/include/CGAL/Optimal_bounding_box/oriented_bounding_box.h

@@ -288,27 +288,34 @@ void construct_oriented_bounding_box(const PointRange& points,
 /// \tparam Output either the type `Aff_transformation_3` of the traits class,
 ///                or `std::array<Point, 8>` with `Point` being equivalent to the type `%Point_3` of the traits class,
 ///                or a model of `MutableFaceGraph`
-/// \tparam NamedParameters a sequence of \ref obb_namedparameters "Named Parameters"
+/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
 ///
 /// \param points the input range
 /// \param out the resulting array of points or affine transformation
-/// \param np an optional sequence of \ref obb_namedparameters "Named Parameters" among the ones listed below:
+/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 ///
 /// \cgalNamedParamsBegin
-///   \cgalParamBegin{point_map}
+///   \cgalParamNBegin{point_map}
-///     a model of `ReadablePropertyMap` with value type the type `%Point_3` of the traits class.
+///     \cgalParamDescription{a property map associating points to the elements of the point range}
-///     If this parameter is omitted, `CGAL::Identity_property_map<%Point_3>` is used.
+///     \cgalParamType{a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`}
-///   \cgalParamEnd
+///     \cgalParamDefault{`CGAL::Identity_property_map<geom_traits::Point_3>`}
-///   \cgalParamBegin{geom_traits}
+///   \cgalParamNEnd
-///     a geometric traits class instance, model of the concept `OrientedBoundingBoxTraits_3`.
+///
-///     %Default is a default construction object of type `CGAL::Oriented_bounding_box_traits_3<K>`
+///   \cgalParamNBegin{geom_traits}
-///     where `K` is a kernel type deduced from the point type.
+///     \cgalParamDescription{an instance of a geometric traits class}
-///   \cgalParamEnd
+///     \cgalParamType{a model of `OrientedBoundingBoxTraits_3`}
-///   \cgalParamBegin{use_convex_hull}
+///     \cgalParamDefault{a default-constructed object of type `CGAL::Oriented_bounding_box_traits_3<K>`,
-///     a Boolean value to indicate whether the algorithm should first extract the so-called extreme
+///                       where `K` is a kernel type deduced from the point type.}
-///     points of the data range (i.e. construct the convex hull) to reduce the input data range
+///   \cgalParamNEnd
-///     and accelerate the algorithm. %Default is `true`.
+///
-///   \cgalParamEnd
+///   \cgalParamNBegin{use_convex_hull}
+///     \cgalParamDescription{Parameter used in the construction of oriented bounding box to indicate
+///                           whether the algorithm should first extract the extreme points (points
+///                           that are on the 3D convex hull) of the input data range
+///                           to accelerate the computation of the bounding box.}
+///     \cgalParamType{Boolean}
+///     \cgalParamDefault{`true`}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 template <typename PointRange,
@@ -379,28 +386,37 @@ void oriented_bounding_box(const PointRange& points,
 /// \tparam Output either the type `Aff_transformation_3` of the traits class,
 ///                or `std::array<Point, 8>` with `Point` being equivalent to the type `%Point_3` of the traits class,
 ///                or a model of `MutableFaceGraph`
-/// \tparam NamedParameters a sequence of \ref obb_namedparameters "Named Parameters"
+/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
 ///
 /// \param pmesh the input mesh
 /// \param out the resulting array of points or affine transformation
-/// \param np an optional sequence of \ref obb_namedparameters "Named Parameters" among the ones listed below:
+/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 ///
 /// \cgalNamedParamsBegin
-///   \cgalParamBegin{vertex_point_map}
+///   \cgalParamNBegin{vertex_point_map}
-///     the property map with the points associated to the vertices of `pmesh`.
+///     \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
-///     If this parameter is omitted, an internal property map for
+///     \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
-///     `CGAL::vertex_point_t` must be available in `PolygonMesh`.
+///                    as key type and `%Point_3` as value type}
-///   \cgalParamEnd
+///     \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
-///   \cgalParamBegin{geom_traits}
+///     \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
-///     a geometric traits class instance, model of the concept `OrientedBoundingBoxTraits_3`.
+///                     should be available for the vertices of `pmesh`.}
-///     %Default is a default construction object of type `CGAL::Oriented_bounding_box_traits_3<K>`
+///   \cgalParamNEnd
-///     where `K` is a kernel type deduced from the point type.
+///
-///   \cgalParamEnd
+///   \cgalParamNBegin{geom_traits}
-///   \cgalParamBegin{use_convex_hull}
+///     \cgalParamDescription{an instance of a geometric traits class}
-///     a Boolean value to indicate whether the algorithm should first extract the so-called extreme
+///     \cgalParamType{a model of `OrientedBoundingBoxTraits_3`}
-///     points of the data range (i.e. construct the convex hull) to reduce the input data range
+///     \cgalParamDefault{a default-constructed object of type `CGAL::Oriented_bounding_box_traits_3<K>`,
-///     and accelerate the algorithm. %Default is `true`.
+///                       where `K` is a kernel type deduced from the point type.}
-///   \cgalParamEnd
+///   \cgalParamNEnd
+///
+///   \cgalParamNBegin{use_convex_hull}
+///     \cgalParamDescription{Parameter used in the construction of oriented bounding box to indicate
+///                           whether the algorithm should first extract the extreme points (points
+///                           that are on the 3D convex hull) of the input data range
+///                           to accelerate the computation of the bounding box.}
+///     \cgalParamType{Boolean}
+///     \cgalParamDefault{`true`}
+///   \cgalParamNEnd
 /// \cgalNamedParamsEnd
 ///
 template <typename PolygonMesh,

Partition_2/include/CGAL/Partition_2/Triangulation_indirect_traits_2.h

@@ -113,6 +113,7 @@ template <class Circulator>
 class Construct_circulator_2
 {
 public:
+   typedef Circulator result_type;
    Circulator operator()(Circulator p1) const { return p1; }
 };
 

Periodic_3_triangulation_3/include/CGAL/internal/Periodic_3_Delaunay_triangulation_remove_traits_3.h

@@ -40,6 +40,14 @@ public:
 
   using Base::operator();
 
+  template<typename F>
+  struct result : Base::template result<F> {};
+
+  template<typename F>
+  struct result<F(Point_3)> {
+    typedef const Point_3& type;
+  };
+
   const Point_3& operator()(const Point_3& p) const { return p; }
 };
 

Periodic_3_triangulation_3/include/CGAL/internal/Periodic_3_regular_triangulation_remove_traits_3.h

@@ -49,6 +49,14 @@ public:
 
   using Base::operator(); // for K::Weighted_point_3 to Point_3
 
+  template<typename F>
+  struct result : Base::template result<F> {};
+
+  template<typename F>
+  struct result<F(Weighted_point_3)> {
+    typedef Point_3 type;
+  };
+
   Point_3 operator()(const Weighted_point_3& wp) const {
     return std::make_pair(operator()(wp.first), wp.second /* offset */);
   }

Point_set_3/doc/Point_set_3/Doxyfile.in

@@ -1,14 +1,2 @@
 @INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
 PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - 3D Point Set"
-
-# macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PSP_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"
-
-#macros for NamedParameters.txt
-ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
-ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
-ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
-ALIASES += "cgalNPEnd=</td></tr>"

Point_set_3/include/CGAL/Point_set_3.h

@@ -947,13 +947,12 @@ public:
 
 
   /*!
-    \brief Returns a sequence of \ref psp_namedparameters "Named Parameters" for Point Set Processing algorithms.
+    \brief Returns a sequence of \ref bgl_namedparameters "Named Parameters" to be used in Point Set Processing algorithms.
 
-    \cgalNamedParamsBegin
+    The following named parameters are used:
-      \cgalParamBegin{point_map} contains the point map (see `point_map()`)\cgalParamEnd
+    - `point_map`: contains the point property map (see `point_map()`)
-      \cgalParamBegin{normal_map} contains the normal map (see `normal_map()`)\cgalParamEnd
+    - `normal_map`: contains the normal map (see `normal_map()`)
-      \cgalParamBegin{geom_traits} contains the kernel `typename Kernel_traits<Point>`::`Kernel`\cgalParamEnd
+    - `geom_traits`: contains the kernel `typename Kernel_traits<Point>`::`Kernel`
-    \cgalNamedParamsEnd
 
     \warning this method does not check if the normal map was
     instanciated or not. The normal map named parameter should not be

Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in

@@ -3,17 +3,5 @@
 PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - Point Set Processing"
 EXCLUDE_PATTERNS          +=  property_map.h
 
-# macros to be used inside the code
-ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
-ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
-ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PSP_\1 \"\1\"</td><td>"
-ALIASES += "cgalParamEnd=</td></tr>"
-
-#macros for NamedParameters.txt
-ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
-ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
-ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
-ALIASES += "cgalNPEnd=</td></tr>"
-
 EXPAND_AS_DEFINED      = CGAL_BGL_NP_TEMPLATE_PARAMETERS \
                          CGAL_BGL_NP_CLASS

Point_set_processing_3/doc/Point_set_processing_3/NamedParameters.txt

@@ -1,280 +0,0 @@
-/*!
-\defgroup psp_namedparameters Named Parameters for Point Set Processing
-\ingroup PkgPointSetProcessing3Ref
-
-In this package, all functions optional parameters are implemented as BGL optional named parameters (see \ref BGLNamedParameters for more information on how to use them).
-
-Since the parameters of the various point set processing functions defined in this
-package are redundant, their long descriptions are centralized below.
-
-In the following, we assume that the following types are provided as template parameters of point set processing functions and classes. Note that, for some of these functions, the type is more specific.
-
-<ul>
-<li>`PointRange` is a model of `Range`. The value type of its iterator is the key type of the related property maps (see below).</li>
-<li>`GeomTraits` a geometric traits class in which constructions are performed and predicates evaluated. Everywhere in this package, a \cgal `Kernel` fulfills the requirements.</li>
-</ul>
-
-`CGAL::parameters::all_default()` can be used to indicate
-that default values of optional named parameters must be used.
-
-Here is the list of the named parameters available in this package:
-
-
-\cgalNPTableBegin
-\cgalNPBegin{geom_traits} \anchor PSP_geom_traits
- the geometric traits instance in which the point set processing operation should be performed.\n
-\b Type: a Geometric traits class.\n
-\b Default \b type: is
-\code
-typename CGAL::Kernel_traits<point_map::value_type>::Kernel
-\endcode
-\cgalNPEnd
-
-\cgalNPBegin{point_map} \anchor PSP_point_map
- is the property map containing the points associated to the elements of the point range `points`.\n
-\b Type: a class model of `ReadablePropertyMap` with
-`PointRange::iterator::value_type` as key type and
-`geom_traits::Point_3` as value type. \n
-<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
-\cgalNPEnd
-
-\cgalNPBegin{normal_map} \anchor PSP_normal_map
- is the property map containing the normal vectors associated to the elements of the point range `points`.\n
-\b Type: a class model of `ReadablePropertyMap` with
-`PointRange::iterator::value_type` as key type and
-`geom_traits::Vector_3` as value type. \n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{diagonalize_traits} \anchor PSP_diagonalize_traits
- is the solver used for diagonalizing covariance matrices.\n
-\b Type: a class model of `DiagonalizeTraits`.\n
-\b Default: `CGAL::Eigen_diagonalize_traits` if \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and `CGAL_EIGEN3_ENABLED` is defined.\n
-\cgalNPEnd
-
-\cgalNPBegin{svd_traits} \anchor PSP_svd_traits
- is the linear algebra algorithm required by the jet fitting method. For more information, please refer to the documentation of `CGAL::Monge_via_jet_fitting`.\n
-\b Type: a class fitting the requirements of `CGAL::Monge_via_jet_fitting`.\n
-\b Default: if \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and `CGAL_EIGEN3_ENABLED` is defined, then `CGAL::Eigen_svd` is used.\n
-\cgalNPEnd
-
-\cgalNPBegin{callback} \anchor PSP_callback
-is a mechanism to get feedback on the advancement of the algorithm while it's running and to interrupt it if needed. It is called regularly when the algorithm is running: the current advancement (between 0. and 1.) is passed as parameter. If it returns `true`, then the algorithm continues its execution normally; if it returns `false`, the algorithm is stopped.\n
-The callback will be copied and therefore needs to be lightweight.\n
-Note that when a callback is run on a parallelized algorithm with `CGAL::Parallel_tag`, it is called asynchronously on a separate thread and shouldn't access or modify the variables that are parameters of the algorithm.\n
-\b Type: `std::function<bool(double)>`.\n
-\b Default: empty function.\n
-\cgalNPEnd
-
-\cgalNPBegin{query_point_map} \anchor PSP_query_point_map
- is the property map containing the points associated to the elements of the point range `queries`.\n
-\b Type: a class model of `ReadablePropertyMap` with
-`PointRange::iterator::value_type` as key type and
-`geom_traits::Point_3` as value type. \n
-<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
-\cgalNPEnd
-
-
-\cgalNPBegin{sharpness_angle} \anchor PSP_sharpness_angle
- controls the sharpness of the result. The larger the value is, the smoother the result will be.
-The range of possible value is [0, 90].\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `30.`
-\cgalNPEnd
-
-\cgalNPBegin{edge_sensitivity} \anchor PSP_edge_sensitivity
-controls the priority of points inserted along sharp features. Larger
-values of edge-sensitivity give higher priority to inserting points
-along sharp features. The range of possible values is `[0, 1]`.  \n
-\b Type: floating scalar value\n
-<b>Default value</b>: `1`.
-\cgalNPEnd
-
-\cgalNPBegin{neighbor_radius} \anchor PSP_neighbor_radius
-is the spherical neighborhood radius.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `-1`, in which case it is not used.
-\cgalNPEnd
-
-\cgalNPBegin{number_of_output_points} \anchor PSP_number_of_output_points
-is the number of output points to generate.\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `1000`
-\cgalNPEnd
-
-\cgalNPBegin{size} \anchor PSP_size
-maximum cluster size for hierarchical clustering. Must be strictly greather than 0.\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `10`
-\cgalNPEnd
-
-\cgalNPBegin{maximum_variation} \anchor PSP_maximum_variation
-maximum cluster size for hierarchical clustering. Must be strictly greather than 0.\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `10`
-\cgalNPEnd
-
-\cgalNPBegin{degree_fitting} \anchor PSP_degree_fitting
- is the degree of fitting (see `CGAL::Monge_via_jet_fitting`).\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `2`
-\cgalNPEnd
-
-\cgalNPBegin{degree_monge} \anchor PSP_degree_monge
- is the Monge degree (see `CGAL::Monge_via_jet_fitting`).\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `2`
-\cgalNPEnd
-
-\cgalNPBegin{threshold_distance} \anchor PSP_threshold_distance
-is the minimum distance for a point to be considered as outlier
-(distance here is the square root of the average squared distance to K nearest neighbors).\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `0`
-\cgalNPEnd
-
-\cgalNPBegin{threshold_percent} \anchor PSP_threshold_percent
- is the maximum percentage (between 0 and 100) of points to remove in `remove_outliers()`.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `10`
-\cgalNPEnd
-
-\cgalNPBegin{attraction_factor} \anchor PSP_attraction_factor
-multiplication factor used for adjacency computations.
-\b Type: floating scalar value\n
-<b>Default value</b>: `3`
-\cgalNPEnd
-
-\cgalNPBegin{plane_map} \anchor PSP_plane_map
- is the property map containing the planes associated to the elements of the plane range `planes`.\n
-\b Type: a class model of `ReadablePropertyMap` with
-`PlaneRange::iterator::value_type` as key type and
-`geom_traits::Plane_3` as value type. \n
-<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Plane_3>\endcode
-\cgalNPEnd
-
-\cgalNPBegin{plane_index_map} \anchor PSP_plane_index_map
-is the property map that associates the index of a point in the input range to the index of plane (-1 if
-point is not assigned to a plane).\n
-\b Type: a class model of `ReadablePropertyMap` with
-`std::size_t` as key type and
-`int` as value type. \n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{select_percentage} \anchor PSP_select_percentage
-percentage of points to retain (between 0 and 100) in `wlop_simplify_and_regularize_point_set()`.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: 5.
-\cgalNPEnd
-
-
-\cgalNPBegin{number_of_iterations} \anchor PSP_number_of_iterations
-number of iterations to solve the optimsation problem in `wlop_simplify_and_regularize_point_set()`.\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: 35.
-\cgalNPEnd
-
-\cgalNPBegin{require_uniform_sampling} \anchor PSP_require_uniform_sampling
-turn on or off an optional preprocessing of `wlop_simplify_and_regularize_point_set()`, which will
-give better result if the distribution of the input points is highly non-uniform.\n
-\b Type: `bool`\n
-<b>Default value</b>: `false`
-\cgalNPEnd
-
-\cgalNPBegin{point_is_constrained_map} \anchor PSP_point_is_constrained_map
-is the property map containing information about points being constrained or not.
-Constrained points are left unaltered and are used as seeds in `mst_orient_normals()`.\n
-\b Type: a class model of `ReadablePropertyMap` with
-`PointRange::iterator::value_type` as key type and
-`bool` as value type. \n
-<b>Default value</b>: a property map with only the highest point constrained.
-\cgalNPEnd
-
-\cgalNPBegin{number_of_samples} \anchor PSP_number_of_samples
-is the number of input points used for computation.\n
-\b Type: \c unsigned \c int \n
-<b>Default value</b>: `200`
-\cgalNPEnd
-
-\cgalNPBegin{accuracy} \anchor PSP_accuracy
-is the wanted output accuracy, expressed in scene units.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `5.00`
-\cgalNPEnd
-
-\cgalNPBegin{maximum_normal_deviation} \anchor PSP_maximum_normal_deviation
-is the maximum angle between the normals of a pair of points, expressed in degrees.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `90.00`
-\cgalNPEnd
-
-\cgalNPBegin{overlap} \anchor PSP_overlap
-is the expected overlap ratio (between 0 and 1) between two points sets to register.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `0.20`
-\cgalNPEnd
-
-\cgalNPBegin{maximum_running_time} \anchor PSP_maximum_running_time
-is the maximum time (in seconds) allowed to the function before ending and returning the best solution found so far.\n
-\b Type: floating scalar value\n
-<b>Default value</b>: `1000`
-\cgalNPEnd
-
-\cgalNPBegin{transformation} \anchor PSP_transformation
-is the transformation to be applied to the point set before the function starts to further process.\n
-\b Type: Aff_transformation_3\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{point_set_filters} \anchor PSP_point_set_filters
-is the chain of filters to be applied to the point set.\n
-\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{matcher} \anchor PSP_matcher
-is the method used for matching (linking) the point set to the reference point set.\n
-\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{outlier_filters} \anchor PSP_outlier_filters
-is the chain of filters to be applied to the matched (linked) point set after each processing iteration of the registration to reject the outliers for the next iteration.\n
-\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{error_minimizer} \anchor PSP_error_minimizer
-is the error minimizer that computes a transformation matrix such as to minimize the error between the point sets in registration process.\n
-\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{transformation_checkers} \anchor PSP_transformation_checkers
-is the chain of transformation checkers that can stop the iteration depending on the conditions it defines.\n
-\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{inspector} \anchor PSP_inspector
-is the inspector that allows to log data at different steps of the running algorithm to allow analysis.\n
-\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
-No default value.
-\cgalNPEnd
-
-\cgalNPBegin{logger} \anchor PSP_logger
-is for logging information regarding the process.\n
-\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
-No default value.
-
-\cgalNPBegin{adjacencies} \anchor PSP_adjacencies
-is an output iterator used to store adjacencies.\n
-\b Type: a class model of `OutputIterator` that accepts objects of
-type `std::pair<std::size_t, std::size_t>`. \n
-<b>Default value</b>: `CGAL::Emptyset_iterator`.
-\cgalNPEnd
-
-\cgalNPTableEnd
-
-*/

Point_set_processing_3/doc/Point_set_processing_3/Point_set_processing_3.txt

@@ -68,8 +68,7 @@ on how to upgrade from the outdated API.
 
 Named parameters are used to deal with optional parameters. The page
 \ref BGLNamedParameters explains the rationale and API in general.
-The page \ref psp_namedparameters describes their usage
+The page \ref bgl_namedparameters describes their usage.
-and provides a list of the parameters that are used in this package.
 
 \subsection Point_set_processing_3PropertyMaps Property Maps
 
@@ -172,8 +171,7 @@ The following functions are available:
 
 All of these functions (with the exception of the LAS format) can read
 and write either points alone or points with normals (depending on
-whether the [normal_map](@ref PSP_normal_map) is provided by the user
+whether the `normal_map` named parameter is used by the user or not).
-or not).
 
 Note that the %PLY format handles both ASCII and binary formats. In
 addition, %PLY and %LAS are extensible formats that can embed additional

Point_set_processing_3/include/CGAL/IO/read_las_points.h

@@ -428,12 +428,20 @@ bool read_las_points_with_properties (std::istream& stream,
    \param stream input stream.
    \param output output iterator over points.
 
-   \param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
+   \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
 
    \cgalNamedParamsBegin
-     \cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.
+     \cgalParamNBegin{point_map}
-     If this parameter is omitted, `CGAL::Identity_property_map<geom_traits::Point_3>` is used.\cgalParamEnd
+       \cgalParamDescription{a property map associating points to the elements of the point range}
-     \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
+       \cgalParamType{a model of `WritablePropertyMap` with value type `geom_traits::Point_3`}
+       \cgalParamDefault{`CGAL::Identity_property_map<geom_traits::Point_3>`}
+     \cgalParamNEnd
+
+     \cgalParamNBegin{geom_traits}
+       \cgalParamDescription{an instance of a geometric traits class}
+       \cgalParamType{a model of `Kernel`}
+       \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
+     \cgalParamNEnd
    \cgalNamedParamsEnd
 
    \return true on success.