Merge remote-tracking branch 'origin/Shape_detection-fix_leaks_in_ransac-danston' into Shape_detection-Region_growing_on_spheres-GF

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeTraits_2.h

@@ -6,12 +6,8 @@
 The concept `AlphaShapeTraits_2` describes the requirements for the geometric traits
 class of the underlying Delaunay triangulation of a basic alpha shape.
 
-\cgalRefines `DelaunayTriangulationTraits_2`
+\cgalRefines `DelaunayTriangulationTraits_2`, if the underlying triangulation of the alpha shape is a Delaunay triangulation.
-
+\cgalRefines `Periodic_2DelaunayTriangulationTraits_2`, if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation.
-In addition to the requirements described in the concept
-::DelaunayTriangulationTraits_2, the geometric traits class of a
-Delaunay triangulation plugged in a basic alpha shapes provides the
-following.
 
 \cgalHasModel All models of `Kernel`.
 \cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/WeightedAlphaShapeTraits_2.h

@@ -7,12 +7,7 @@ The concept `WeightedAlphaShapeTraits_2` describes the requirements
 for the geometric traits class
 of the underlying regular triangulation of a weighted alpha shape.
 
-\cgalRefines `RegularTriangulationTraits_2`
+\cgalRefines `RegularTriangulationTraits_2`, if the underlying triangulation of the alpha shape is a regular triangulation.
-
-In addition to the requirements described in the concept
-`RegularTriangulationTraits_2`, the geometric traits class of a
-regular triangulation plugged in a basic alpha shapes provides the
-following.
 
 \cgalHasModel All models of `Kernel`.
 \cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeTraits_3.h

@@ -7,12 +7,8 @@ The concept `AlphaShapeTraits_3` describes the requirements
 for the geometric traits class
 of the underlying Delaunay triangulation of a basic alpha shape.
 
-\cgalRefines `DelaunayTriangulationTraits_3`
+\cgalRefines `DelaunayTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a Delaunay triangulation.
-
+\cgalRefines `Periodic_3DelaunayTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation.
-In addition to the requirements described in the concept
-::DelaunayTriangulationTraits_3, the geometric traits class of a
-Delaunay triangulation plugged in a basic alpha shapes provides the
-following.
 
 \cgalHasModel All models of `Kernel`.
 

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeTraits_3.h

@@ -7,12 +7,8 @@ The concept `FixedAlphaShapeTraits_3` describes the requirements
 for the geometric traits class
 of the underlying Delaunay triangulation of a basic alpha shape with a fixed value alpha.
 
-\cgalRefines `DelaunayTriangulationTraits_3`
+\cgalRefines `DelaunayTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a Delaunay triangulation.
-
+\cgalRefines `Periodic_3DelaunayTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation.
-In addition to the requirements described in the concept
-`DelaunayTriangulationTraits_3`, the geometric traits class of a
-Delaunay triangulation plugged in a basic alpha shape with fixed alpha
-value provides the following.
 
 \cgalHasModel All models of `Kernel`.
 

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedWeightedAlphaShapeTraits_3.h

@@ -6,12 +6,8 @@
 The concept `FixedWeightedAlphaShapeTraits_3` describes the requirements
 for the geometric traits class of the underlying regular triangulation of a weighted alpha shape with fixed alpha value.
 
-\cgalRefines `RegularTriangulationTraits_3`
+\cgalRefines `RegularTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a regular triangulation.
-
+\cgalRefines `Periodic_3RegularTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a periodic regular triangulation.
-In addition to the requirements described in the concept
-::RegularTriangulationTraits_3, the geometric traits class of a
-regular triangulation plugged in a weighted alpha shape with fixed
-alpha value provides the following.
 
 \cgalHasModel All models of `Kernel`.
 

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/WeightedAlphaShapeTraits_3.h

@@ -7,12 +7,8 @@ The concept `WeightedAlphaShapeTraits_3` describes the requirements
 for the geometric traits class
 of the underlying regular triangulation of a weighted alpha shape.
 
-\cgalRefines `RegularTriangulationTraits_3`
+\cgalRefines `RegularTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a regular triangulation.
-
+\cgalRefines `Periodic_3RegularTriangulationTraits_3`, if the underlying triangulation of the alpha shape is a periodic regular triangulation.
-In addition to the requirements described in the concept
-`RegularTriangulationTraits_3`, the geometric traits class of a
-regular triangulation plugged in a basic alpha shapes provides the
-following.
 
 \cgalHasModel All models of `Kernel`.
 

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

@@ -102,6 +102,9 @@ CGAL_add_named_parameter(use_angle_smoothing_t, use_angle_smoothing, use_angle_s
 CGAL_add_named_parameter(use_area_smoothing_t, use_area_smoothing, use_area_smoothing)
 CGAL_add_named_parameter(use_Delaunay_flips_t, use_Delaunay_flips, use_Delaunay_flips)
 CGAL_add_named_parameter(do_project_t, do_project, do_project)
+CGAL_add_named_parameter(do_split_t, do_split, do_split)
+CGAL_add_named_parameter(do_collapse_t, do_collapse, do_collapse)
+CGAL_add_named_parameter(do_flip_t, do_flip, do_flip)
 CGAL_add_named_parameter(do_orientation_tests_t, do_orientation_tests, do_orientation_tests)
 CGAL_add_named_parameter(do_self_intersection_tests_t, do_self_intersection_tests, do_self_intersection_tests)
 CGAL_add_named_parameter(error_codes_t, error_codes, error_codes)

Cartesian_kernel/include/CGAL/Cartesian/function_objects.h

@@ -2741,6 +2741,7 @@ namespace CartesianKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_2   Point_2;
+    typedef typename K::Segment_2 Segment_2;
   public:
     typedef Point_2          result_type;
 
@@ -2752,6 +2753,17 @@ namespace CartesianKernelFunctors {
       midpointC2(p.x(), p.y(), q.x(), q.y(), x, y);
       return construct_point_2(x, y);
     }
+
+    Point_2
+    operator()(const Segment_2& s) const
+    {
+      typename K::Construct_point_2 construct_point_2;
+      FT x, y;
+      const Point_2& p = s.source();
+      const Point_2& q = s.target();
+      midpointC2(p.x(), p.y(), q.x(), q.y(), x, y);
+      return construct_point_2(x, y);
+    }
   };
 
   template <typename K>
@@ -2759,6 +2771,7 @@ namespace CartesianKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_3   Point_3;
+    typedef typename K::Segment_3 Segment_3;
   public:
     typedef Point_3               result_type;
 
@@ -2770,6 +2783,17 @@ namespace CartesianKernelFunctors {
       midpointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x, y, z);
       return construct_point_3(x, y, z);
     }
+
+    Point_3
+    operator()(const Segment_3& s) const
+    {
+      const Point_3& p = s.source();
+      const Point_3& q = s.target();
+      typename K::Construct_point_3 construct_point_3;
+      FT x, y, z;
+      midpointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x, y, z);
+      return construct_point_3(x, y, z);
+    }
   };
 
   template <typename K>

Documentation/doc/Documentation/Getting_started.txt

@@ -16,7 +16,7 @@ The following pages cover advanced installation options:
 - \subpage configurationvariables gives information about which CMake variables can be used to help
 resolve missing dependencies while using the cmake command line tool.
 
-- \subpage installation describes the deprecated process of configuring and building \cgal.
+- \subpage installation describes the process of configuring and installing \cgal.
 
 The following pages cover the structure of the manual and general information about \cgal:
 

Documentation/doc/Documentation/Third_party.txt

@@ -28,7 +28,7 @@ Older versions of the above listed compilers might work, but no guarantee is pro
 In order to configure and build the \cgal examples, demos, or libraries,
 you need <a href="https://cmake.org/">CMake</a>, a cross-platform "makefile generator".
 
-This manual explains only the features of CMake which are needed in order to build \cgal.
+This manual explains only the features of CMake which are needed in order to use \cgal.
 Please refer to the <a href="https://cmake.org/documentation/">CMake documentation</a>
 for further details.
 
@@ -84,7 +84,7 @@ and for multi precision floating point numbers.
 \cgal combines floating point arithmetic with exact arithmetic
 in order to be efficient and reliable. \cgal has a built-in
 number type for that, but \gmp and \mpfr provide a faster
-solution, and we recommend to use them.
+solution, and we recommend using them.
 
 These libraries can be obtained from <A HREF="https://gmplib.org/">`https://gmplib.org/`</A>
 and <A HREF="https://www.mpfr.org/">`https://www.mpfr.org/`</A>.

Documentation/doc/Documentation/Usage.txt

@@ -166,12 +166,17 @@ if no debugging is intended. Users should thus run:
     cd CGAL-\cgalReleaseNumber/examples/Triangulation_2
     cmake -DCGAL_DIR=$HOME/CGAL-\cgalReleaseNumber -DCMAKE_BUILD_TYPE=Release . # we are here using a release tarball
 
-Note that the package Qt on brew is "keg-only", which means it cannot be "linked" with brew.
+The package Qt5 on brew is "keg-only", which means it is not "linked" with brew.
-You will have to specify the Qt5_DIR by hand to cmake, using something like
+In order to link against Qt5, you need to run:
 
-    -DQt5_DIR=/usr/local/opt/qt/lib/cmake/Qt5
+    brew link qt@5
 
-where '/usr/local/` is actually your current brew installation directory.
+After that, you will have to specify the Qt5_DIR by hand to cmake, using something like
+
+    -DQt5_DIR=/usr/local/opt/qt5/lib/cmake/Qt5
+
+where '/usr/local/` is actually your current brew installation directory. Check this directory
+to be sure where the Qt5 is placed on your machine.
 
 \subsection usage_configuring_cmake_gui Specifying Missing Dependencies
 

Documentation/doc/Documentation/advanced/Configuration_variables.txt

@@ -19,7 +19,7 @@ summarized below are CMake variables.
 \subsection installation_component_selection Component Selection
 
 The following boolean variables indicate which \cgal components to
-configure and build. Their values can be ON or OFF.
+configure and/or build. Their values can be ON or OFF.
 
 
 | Variable | %Default Value   |

Documentation/doc/Documentation/advanced/Installation.txt

@@ -1,29 +1,29 @@
 /*!
-\page installation Building %CGAL libraries (non header-only mode)
+\page installation Installing %CGAL libraries
 \cgalAutoToc
 
 \cgalAdvancedBegin
-Since \cgal version 5.0, \cgal is header-only be default, which means
+Since \cgal version 5.0, \cgal is header-only, which means
 that there is no need to compile \cgal or its libraries before it can be used.
 
-This page is for advanced users that have a good reason to still use the old way.
+This page is for advanced users that either want to install CGAL on their system, or want to build the examples,
+tests and demos that are shipped in a git branch, for example.
 If this is not your case, head over back to the page \ref general_intro.
 \cgalAdvancedEnd
 
-This page is a step-by-step description of how to configure, build, and (optionally) install \cgal
+This page is a step-by-step description of how to configure and install \cgal, and (optionally)
-in case you do not wish to use the - now enabled by default - header-only mode of \cgal.
+build examples, tests and demos.
 
 It is assumed that you have downloaded a source archive of \cgal, and are using Linux or macOS.
 
 \section installation_idealworld Quick Installation
 
-Ideally, compiling and installing \cgal, as well as compiling some examples shipped by \cgal is as simple as:
+Ideally, installing \cgal, as well as compiling some examples shipped by \cgal is as simple as:
 
     cd $HOME/CGAL-\cgalReleaseNumber
     mkdir build
     cd build
-    cmake -DCGAL_HEADER_ONLY=OFF -DCMAKE_BUILD_TYPE=Release ..                        # configure CGAL
+    cmake ..                                                                          # configure CGAL
-    make                                                                              # build CGAL
     make install                                                                      # install CGAL
     cd examples/Triangulation_2                                                       # go to an example directory
     cmake -DCGAL_DIR=$CMAKE_INSTALLED_PREFIX/lib/CGAL -DCMAKE_BUILD_TYPE=Release .    # configure the examples
@@ -34,12 +34,11 @@ This is what this page is about.
 
 \section installation_configwithcmake Configuring CGAL with CMake
 
-Before building \cgal, or anything using \cgal, you have to choose the compiler/linker,
+Before building anything using \cgal, you have to choose the compiler/linker,
-set compiler and linker flags, specify which
+set compiler and linker flags and specify which
-third-party libraries you want to use and where they can be found, and
+third-party libraries you want to use and where they can be found. Gathering
-which \cgal libraries you want to build. Gathering
 all this information is called <I>configuration</I>.
-The end of the process is marked by the generation of a makefile that you can use to build \cgal.
+The end of the process is marked by the generation of a makefile that you can use to install \cgal.
 
 CMake maintains configuration parameters in so-called <I>cmake variables</I>. Some of the CMake
 variables represent user choices, such as `CMAKE_BUILD_TYPE`, while others
@@ -51,25 +50,19 @@ and finally the configuration and build processes.
 
 \subsection seclibraries CGAL Libraries
 
-\cgal is split into four libraries. During configuration, you can select the libraries that
+\cgal has some optional components. During configuration, you can select the components that
-you would like to build by setting a CMake variable of the form <TT>WITH_<library></TT>. By default all
+you would like to use by setting a CMake variable of the form <TT>WITH_<library></TT>. By default all
-are switched `ON`. All activated libraries are to be built after configuration.
+are switched `ON`, but some have specific dependencies in addition to the essential ones, so if you don't
-
+need those, don't hesitate to switch them `OFF`.
-Note that some libraries have specific dependencies in addition to the essential ones. See the page
+See the page
 \ref secessential3rdpartysoftware for more information.
 
-| Library   | CMake Variable | Functionality | Dependencies |
+| Component   | CMake Variable | Functionality | Dependencies |
 | :-------- | :------------- | :------------ | :----------- |
 |   \cgal   | none           | Main library  | \gmp, \mpfr, \boost (headers) |
-| `CGAL_Core` | `WITH_CGAL_Core`  | The %CORE library for algebraic numbers.\cgalFootnote{CGAL_Core is not part of \cgal, but a custom version of the \core library distributed by \cgal for the user convenience and it has it's own license.}  | \gmp and \mpfr |
 | `CGAL_ImageIO` | `WITH_CGAL_ImageIO` | Utilities to read and write image files  | \zlib, \vtk (optional) |
 | `CGAL_Qt5`  | `WITH_CGAL_Qt5` | `QGraphicsView` support for \qt5-based demos | \qt5 |
 
-Shared libraries, also called <I>dynamic-link libraries</I>, are built by default
-(`.so` on Linux, `.dylib` on macOS). You
-can choose to produce static libraries instead, by setting the CMake
-variable `BUILD_SHARED_LIBS` to `FALSE`.
-
 \subsection installation_examples CGAL Examples and Demos
 
 \cgal is distributed with a large collection of examples and demos. By default, these are <B>not</B> configured along with
@@ -84,7 +77,7 @@ might need these \cgal-libraries and thus their dependencies. See the page
 
 \subsection installation_debugrelease Debug vs. Release
 
-The CMake variable `CMAKE_BUILD_TYPE` indicates how to build the libraries.
+The CMake variable `CMAKE_BUILD_TYPE` indicates how to build the executables.
 It accepts the values `Debug` or `Release`. Note that the default value is `Debug`, since it is
 default value in `CMake`. If you do not plan on debugging, it is important to set the variable
 to `Release` for performance reasons.
@@ -98,7 +91,6 @@ There are many more variables that can be used during configuration. The most im
 <ul>
 <li> `CMAKE_INSTALL_PREFIX=<dir>`         installation directory [/usr/local]</li>
 <li>`CMAKE_BUILD_TYPE=<Debug|Release>`    build type [Release]</li>
-<li>`BUILD_SHARED_LIBS=<TRUE|FALSE>`      shared or static libraries [TRUE]</li>
 <li>`CMAKE_C_COMPILER=<program>`          C compiler [gcc]</li>
 <li>`CMAKE_CXX_COMPILER=<program>`        C++ compiler [g++]</li>
 </ul>
@@ -145,9 +137,6 @@ Providing information and pressing *Configure* goes on until
 all entries are grayed. You are now ready to press *Generate*. Once this is
 done, you can quit `cmake-gui`.
 
-Since you intend to build CGAL libraries, you should also ensure that the variable
-`CGAL_HEADER_ONLY` has not been set.
-
 If you do not need to debug, you should set the variable `CMAKE_BUILD_TYPE` to `Release`.
 
 \subsection installation_configuring_cmd Configuring CGAL with the cmake Command-Line Tool
@@ -184,7 +173,7 @@ building of a program using \cgal, see Section \ref installation_buildprogram.
 
 \section seccmakeoutofsource Multiple Builds
 
-While you can choose between release or debug builds, and shared or static libraries,
+While you can choose between release or debug builds,
 it is not possible to generate different variants during a single configuration. You need to run CMake in a
 different directory for each variant you are interested in, each with its own selection of configuration parameters.
 
@@ -208,38 +197,23 @@ You can, for example, generate subdirectories `CGAL-\cgalReleaseNumber``/build/d
     cd CGAL-\cgalReleaseNumber/build/release
     cmake -DCMAKE_BUILD_TYPE=Release ../..
 
-\section secbuilding Building CGAL
+
+\subsection ssec_installation_build_ex_demos Building Examples and Demos
+
+Let's assume that you have turned on the configuration of examples
+(`-DWITH_examples=ON`) and/or demos (`-DWITH_demos=ON`).
 
 The results of a successful configuration are build files that control the build step.
 The nature of the build files depends on the generator used during configuration, but in all cases they
-contain several <I>targets</I>, one per library, and a default global target corresponding
+contain several <I>targets</I>, one per executable, and a default global target corresponding
-to all the libraries.
+to all of them (called `examples` and/or `demos`).
 
 For example, in a \unix-like environment the default generator produces makefiles.
 You can use the `make` command-line tool for the succeeding build step as follows:
 
-    # build all the selected libraries at once
+    # build all the selected examples at once
-    make
+    make examples
 
-The resulting libraries are placed in the subdirectory `lib` under `<CMAKE_BINARY_DIR>`
-(which is `CGAL-\cgalReleaseNumber` in case you run an in-source-configuration).
-
-\cgalAdvancedBegin
-The build files produced by CMake are autoconfigured. That
-is, if you change any of the dependencies, the build step
-automatically goes all the way back to the configuration step. This
-way, once the target has been configured the very first time by
-invoking cmake, you don't necessarily need to invoke `cmake`
-again. Rebuilding will call itself `cmake` and re-generate the
-build file whenever needed.
-\cgalAdvancedEnd
-
-\subsection ssec_installation_build_ex_demos Building Examples and Demos
-
-If you have turned on the configuration of examples
-(`-DWITH_examples=ON`) and/or demos (`-DWITH_demos=ON`), there will be additional
-targets named `examples` and `demos`, plus one target for
-each example and each demo in the build files.
 None of these targets are included by default, so you need to build them explicitly
 <I>after</I> the \cgal libraries have been successfully built.
 The targets `examples` and `demos` include themselves all the targets
@@ -259,6 +233,15 @@ If you are interested in the demos or examples of just a particular module, you
 When using `UNIX Makefiles`, you can find out the exact name of the example or demo target
 of a particular package by typing `make help | grep <package>`.
 
+\cgalAdvancedBegin
+The build files produced by CMake are autoconfigured. That
+is, if you change any of the dependencies, the build step
+automatically goes all the way back to the configuration step. This
+way, once the target has been configured the very first time by
+invoking cmake, you don't necessarily need to invoke `cmake`
+again. Rebuilding will call itself `cmake` and re-generate the
+build file whenever needed.
+\cgalAdvancedEnd
 \section secinstalling Installing CGAL
 
 On many platforms, library pieces such as headers, docs and binaries
@@ -266,10 +249,10 @@ are expected to be placed in specific locations. A typical example
 being `/usr/include` and `/usr/lib`. The process
 of placing or copying the library elements into its standard location
 is sometimes referred to as <I>Installation</I> and it is a
-postprocessing step after the build step.
+postprocessing step after the configuration step.
 
 CMake carries out the installation by producing a build target named <I>install</I>.
-Assuming you have successfully configured and built \cgal as demonstrated in the previous sections,
+Assuming you have successfully configured \cgal as demonstrated in the previous sections,
 the installation simply amounts to:
 
     # install CGAL
@@ -283,7 +266,7 @@ variable explicitly <I>at the configuration time</I> and not when executing the
 \cgalAdvancedEnd
 
 The file `CGALConfig.cmake` is installed by default in
-`$CMAKE_INSTALLED_PREFIX/lib/``CGAL-\cgalReleaseNumber`.
+`$CMAKE_INSTALLED_PREFIX/lib/cmake/CGAL`.
 
 \section installation_buildprogram Building a Program using CGAL
 
@@ -305,7 +288,7 @@ the process of configuring a user's program called `your_program.cpp` amounts to
 
 In order to configure a program, you need to indicate the location of the \cgal configuration file
 in the CMake variable `CGAL_DIR` (as shown in the example above).
-If you have installed \cgal, `CGAL_DIR` must afterwards be set to `$CMAKE_INSTALLED_PREFIX/lib/CGAL`.
+If you have installed \cgal, `CGAL_DIR` must afterwards be set to `$CMAKE_INSTALLED_PREFIX/lib/cmake/CGAL`.
 
 The variable `CGAL_DIR` can also be an environment variable, but setting it manually makes particular sense
 if you have multiple out-of-source builds of \cgal as in Section \ref seccmakeoutofsource.

Documentation/doc/biblio/geom.bib

@@ -85653,7 +85653,7 @@ fitting method."
 , title =	"The {CORE} Library Project"
 , edition =	"1.2"
 , year =	1999
-, url =	"https://cs.nyu.edu/exact/core/"
+, url =	"https://www.cs.nyu.edu/exact/doc/core.pdf"
 , update =	"00.03 devillers"
 }
 

Documentation/doc/resources/1.8.13/menu_version.js

@@ -6,10 +6,10 @@
   var current_version_local = '5.3-beta1'
   var all_versions = [
       'master',
-      '5.3-beta1',
+      '5.3',
       'latest',
-      '5.2.2',
+      '5.2.3',
-      '5.1.4',
+      '5.1.5',
       '5.0.4',
       '4.14.3',
       '4.13.2',

Documentation/doc/resources/1.8.14/menu_version.js

@@ -6,10 +6,10 @@
   var current_version_local = '5.3-beta1'
   var all_versions = [
       'master',
-      '5.3-beta1',
+      '5.3',
       'latest',
-      '5.2.2',
+      '5.2.3',
-      '5.1.4',
+      '5.1.5',
       '5.0.4',
       '4.14.3',
       '4.13.2',

Documentation/doc/resources/1.8.20/menu_version.js

@@ -6,10 +6,10 @@
   var current_version_local = '5.3-beta1'
   var all_versions = [
       'master',
-      '5.3-beta1',
+      '5.3',
       'latest',
-      '5.2.2',
+      '5.2.3',
-      '5.1.4',
+      '5.1.5',
       '5.0.4',
       '4.14.3',
       '4.13.2',

Documentation/doc/resources/1.8.4/menu_version.js

@@ -6,10 +6,10 @@
   var current_version_local = '5.3-beta1'
   var all_versions = [
       'master',
-      '5.3-beta1',
+      '5.3',
       'latest',
-      '5.2.2',
+      '5.2.3',
-      '5.1.4',
+      '5.1.5',
       '5.0.4',
       '4.14.3',
       '4.13.2',

Filtered_kernel/include/CGAL/Lazy.h

@@ -236,6 +236,7 @@ template <typename AT_, typename ET, typename E2A>
 class Lazy_rep : public Rep, public Depth_base
 {
   Lazy_rep (const Lazy_rep&) = delete; // cannot be copied.
+  Lazy_rep& operator= (const Lazy_rep&) = delete; // cannot be copied.
 
 public:
 
@@ -247,6 +248,28 @@ public:
   Lazy_rep ()
     : at(), et(nullptr){}
 
+  //move-constructor
+  Lazy_rep (Lazy_rep&& other)
+    : at(std::move(other.at)), et(other.et)
+  {
+    other.et = nullptr;
+    this->count = std::move(other.count);
+  }
+
+  //move-assignment
+  Lazy_rep& operator= (Lazy_rep&& other)
+  {
+    if(this->et)
+    {
+      delete this->et;
+    }
+    this->et = other.et;
+    other.et = nullptr;
+    this->at = std::move(other.at);
+    this->count = std::move(other.count);
+    return *this;
+  }
+
   template<class A>
   Lazy_rep (A&& a)
       : at(std::forward<A>(a)), et(nullptr){}

Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h

@@ -2950,6 +2950,7 @@ namespace HomogeneousKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_2   Point_2;
+    typedef typename K::Segment_2 Segment_2;
   public:
     typedef Point_2          result_type;
 
@@ -2963,6 +2964,19 @@ namespace HomogeneousKernelFunctors {
                       p.hy()*qhw + q.hy()*phw,
                       phw * qhw * RT( 2));
     }
+
+    Point_2
+    operator()(const Segment_2& s) const
+    {
+      typedef typename K::RT RT;
+      const Point_2& p = s.source();
+      const Point_2& q = s.target();
+      const RT& phw = p.hw();
+      const RT& qhw = q.hw();
+      return Point_2( p.hx()*qhw + q.hx()*phw,
+                      p.hy()*qhw + q.hy()*phw,
+                      phw * qhw * RT( 2));
+    }
   };
 
   template <typename K>
@@ -2970,6 +2984,7 @@ namespace HomogeneousKernelFunctors {
   {
     typedef typename K::FT        FT;
     typedef typename K::Point_3   Point_3;
+    typedef typename K::Segment_3 Segment_3;
   public:
     typedef Point_3          result_type;
 
@@ -2984,6 +2999,20 @@ namespace HomogeneousKernelFunctors {
                       p.hz()*qhw + q.hz()*phw,
                       RT(2) * phw * qhw );
     }
+
+    Point_3
+    operator()(const Segment_3& s) const
+    {
+      typedef typename K::RT RT;
+      const Point_3& p = s.source();
+      const Point_3& q = s.target();
+      RT phw = p.hw();
+      RT qhw = q.hw();
+      return Point_3( p.hx()*qhw + q.hx()*phw,
+                      p.hy()*qhw + q.hy()*phw,
+                      p.hz()*qhw + q.hz()*phw,
+                      RT(2) * phw * qhw );
+    }
   };
 
   // TODO ...

Installation/CHANGES.md

@@ -12,6 +12,15 @@ Release History
 
 Release date: July 2021
 
+### [General changes](https://doc.cgal.org/5.3/Manual/general_intro.html)
+
+-   The support for the compiled version of CGAL is dropped. Only the header-only version is supported.
+
+-   On Windows, the type used for `Exact_rational`, in `Epick` and indirectly (through `Lazy_exact_nt`)
+   `Epeck` may now be `boost::multiprecision::mpq_rational`, as has been the case on other platforms
+   for several releases. This depends on various options and is added to a list that includes
+   `mpq_class`, `CGAL::Gmpq`, `leda_rational` and `CGAL::Quotient<CGAL::MP_Float>`.
+
 ### [Quadtrees, Octrees, and Orthtrees](https://doc.cgal.org/5.3/Manual/packages.html#PkgOrthtree) (new package)
 
 -   This package implements a tree data structure in which each node encloses a hypercubic section

Installation/include/CGAL/version.h

@@ -17,12 +17,12 @@
 #define CGAL_VERSION_H
 
 #ifndef SWIG
-#define CGAL_VERSION 5.3-beta2
+#define CGAL_VERSION 5.4-dev
 #define CGAL_GIT_HASH abcdef
 #endif
-#define CGAL_VERSION_NR 1050300920
+#define CGAL_VERSION_NR 1050400900
 #define CGAL_SVN_REVISION 99999
-#define CGAL_RELEASE_DATE 20210630
+#define CGAL_RELEASE_DATE 20211206
 
 #include <CGAL/version_macros.h>
 

Installation/lib/cmake/CGAL/CGALConfigVersion.cmake

@@ -1,8 +1,8 @@
 set(CGAL_MAJOR_VERSION 5)
-set(CGAL_MINOR_VERSION 3)
+set(CGAL_MINOR_VERSION 4)
 set(CGAL_BUGFIX_VERSION 0)
 include(${CMAKE_CURRENT_LIST_DIR}/CGALConfigBuildVersion.cmake)
-set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.3-beta2")
+set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.4-dev")
 set(CGAL_VERSION_PUBLIC_RELEASE_NAME "CGAL-${CGAL_VERSION_PUBLIC_RELEASE_VERSION}")
 
 if (CGAL_BUGFIX_VERSION AND CGAL_BUGFIX_VERSION GREATER 0)

Kernel_23/doc/Kernel_23/CGAL/Kernel/global_functions.h

@@ -2242,12 +2242,25 @@ template <typename Kernel>
 CGAL::Point_2<Kernel> midpoint( const CGAL::Point_2<Kernel>& p,
 const CGAL::Point_2<Kernel>& q );
 
+
+  /*!
+computes the midpoint of the segment `s`.
+*/
+template <typename Kernel>
+CGAL::Point_2<Kernel> midpoint( const CGAL::Segment_2<Kernel>& s);
+
 /*!
 computes the midpoint of the segment `pq`.
 */
 template <typename Kernel>
 CGAL::Point_3<Kernel> midpoint( const CGAL::Point_3<Kernel>& p, const CGAL::Point_3<Kernel>& q );
 
+/*!
+computes the midpoint of the segment `s`.
+*/
+template <typename Kernel>
+CGAL::Point_3<Kernel> midpoint( const CGAL::Segment_3<Kernel>& s );
+
 /// @}
 
 /// \defgroup min_vertex_grp CGAL::min_vertex()

Kernel_23/doc/Kernel_23/Concepts/FunctionObjectConcepts.h

@@ -4996,6 +4996,10 @@ public:
   */
   Kernel::Point_2 operator()(const Kernel::Point_2& p,
                              const Kernel::Point_2& q );
+  /*!
+    computes the midpoint of the segment `s`.
+  */
+  Kernel::Point_2 operator()(const Kernel::Segment_2& s);
 
   /// @}
 
@@ -5023,6 +5027,11 @@ public:
   Kernel::Point_3 operator()(const Kernel::Point_3& p,
                              const Kernel::Point_3& q );
 
+  /*!
+    computes the midpoint of the segment `s`.
+  */
+  Kernel::Point_3 operator()(const Kernel::Segment_3& s);
+
 
   /// @}
 

Kernel_23/include/CGAL/Bbox_2.h

@@ -61,6 +61,8 @@ public:
   inline double     ymin() const;
   inline double     xmax() const;
   inline double     ymax() const;
+  inline double x_span() const;
+  inline double y_span() const;
 
   inline double     max BOOST_PREVENT_MACRO_SUBSTITUTION (int i) const;
   inline double     min BOOST_PREVENT_MACRO_SUBSTITUTION (int i) const;
@@ -91,6 +93,14 @@ double
 Bbox_2::ymax() const
 { return rep[3]; }
 
+inline double Bbox_2::x_span() const {
+  return xmax() - xmin();
+}
+
+inline double Bbox_2::y_span() const {
+  return ymax() - ymin();
+}
+
 inline
 bool
 Bbox_2::operator==(const Bbox_2 &b) const

Kernel_23/include/CGAL/Bbox_3.h

@@ -63,6 +63,9 @@ public:
   double xmax() const;
   double ymax() const;
   double zmax() const;
+  double x_span() const;
+  double y_span() const;
+  double z_span() const;
 
   inline double min BOOST_PREVENT_MACRO_SUBSTITUTION (int i) const;
   inline double max BOOST_PREVENT_MACRO_SUBSTITUTION (int i) const;
@@ -106,6 +109,18 @@ double
 Bbox_3::zmax() const
 { return rep[5]; }
 
+inline double Bbox_3::x_span() const {
+  return xmax() - xmin();
+}
+
+inline double Bbox_3::y_span() const {
+  return ymax() - ymin();
+}
+
+inline double Bbox_3::z_span() const {
+  return zmax() - zmin();
+}
+
 inline
 bool
 Bbox_3::operator==(const Bbox_3 &b) const

Kernel_23/include/CGAL/Kernel/global_functions_2.h

@@ -754,6 +754,12 @@ midpoint(const Point_2<K> &p, const Point_2<K> &q)
   return internal::midpoint(p, q, K());
 }
 
+template < class K >
+inline typename K::Point_2 midpoint(const Segment_2<K> &s)
+{
+  return internal::midpoint(s, K());
+}
+
 template < class K >
 inline
 typename K::Point_2

Kernel_23/include/CGAL/Kernel/global_functions_3.h

@@ -738,6 +738,12 @@ midpoint(const Point_3<K> &p, const Point_3<K> &q)
   return internal::midpoint(p, q, K());
 }
 
+template < class K >
+inline typename K::Point_3 midpoint(const Segment_3<K> &s)
+{
+  return internal::midpoint(s, K());
+}
+
 template < class K >
 inline
 typename K::Point_3

Kernel_23/include/CGAL/Kernel/global_functions_internal_2.h

@@ -788,6 +788,14 @@ midpoint(const typename K::Point_2 &p,
   return k.construct_midpoint_2_object()(p, q);
 }
 
+template < class K >
+inline
+typename K::Point_2
+midpoint(const typename K::Segment_2 &s, const K &k)
+{
+  return k.construct_midpoint_2_object()(s);
+}
+
 template < class K >
 inline
 typename K::Point_2

Kernel_23/include/CGAL/Kernel/global_functions_internal_3.h

@@ -829,6 +829,14 @@ midpoint(const typename K::Point_3 &p,
   return k.construct_midpoint_3_object()(p, q);
 }
 
+template < class K >
+inline
+typename K::Point_3
+midpoint(const typename K::Segment_3 &s, const K &k)
+{
+  return k.construct_midpoint_3_object()(s);
+}
+
 template < class K >
 inline
 typename K::Point_3

Kernel_23/test/Kernel_23/include/CGAL/_test_fct_constructions_2.h

@@ -24,6 +24,7 @@ _test_fct_constructions_2(const R&)
 {
   typedef typename R::RT              RT;
   typedef CGAL::Point_2<R>            Point;
+  typedef CGAL::Segment_2<R>          Segment;
   typedef CGAL::Weighted_point_2<R>   Weighted_Point;
   typedef CGAL::Triangle_2<R>         Triangle;
   typedef CGAL::Vector_2<R>           Vector;
@@ -52,6 +53,7 @@ _test_fct_constructions_2(const R&)
   // midpoint
   assert( CGAL::midpoint( pne, psw) == p);
   assert( CGAL::midpoint( pnw, pse) == p);
+  assert( CGAL::midpoint( Segment{pnw, pse}) == p);
 
   // circumcenter
   assert( CGAL::circumcenter( pne, pne ) == pne);

Kernel_23/test/Kernel_23/include/CGAL/_test_fct_constructions_3.h

@@ -69,6 +69,7 @@ _test_fct_constructions_3(const R& r)
   assert( CGAL::midpoint( p110, p001) == p);
   assert( CGAL::midpoint( p010, p101) == p);
   assert( CGAL::midpoint( p100, p011) == p);
+  assert( CGAL::midpoint( Segment{p100, p011}) == p);
 
   // circumcenter
   assert( CGAL::circumcenter( p111, p001, p010, p000) == p);

Kernel_23/test/Kernel_23/test_bbox.cpp

@@ -39,6 +39,9 @@ int main()
                              -3000000000000001.,
                              5000000.0000000019,
                              7.0000000000000026e+20) );
+  CGAL::Bbox_2 span{1,2,5,8};
+  assert( span.x_span() == 4);
+  assert( span.y_span() == 6);
   }
 
   {
@@ -70,5 +73,9 @@ int main()
                              5000000.000000014,
                              7.0000000000000197e+20,
                              15.000000000000027) );
+  CGAL::Bbox_3 span{1,2,3,5,8,11};
+  assert( span.x_span() == 4);
+  assert( span.y_span() == 6);
+  assert( span.z_span() == 8);
   }
 }

Maintenance/infrastructure/cgal.geometryfactory.com/crontab

@@ -19,16 +19,18 @@ 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 --public --do-it --beta 2 || 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 || 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 || echo ERROR
+# from branch 5.3
+0 21  *  *  Sat                      cd $HOME/CGAL/create_internal_release-5.3-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.3-branch.git --public --do-it || echo ERROR
 # from branch 5.2
-0 21  *  *  Sat                      cd $HOME/CGAL/create_internal_release-5.2-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.2-branch.git --public --do-it || echo ERROR
+0 21  *  *  Fri                      cd $HOME/CGAL/create_internal_release-5.2-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.2-branch.git --public --do-it || echo ERROR
-# from branch 5.1
-0 21  *  *  Fri                      cd $HOME/CGAL/create_internal_release-5.1-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.1-branch.git --public --do-it || echo ERROR
 
 
 ## Older stuff
+# from branch 5.1
+#0 21  *  *  Fri                      cd $HOME/CGAL/create_internal_release-5.1-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.1-branch.git --public --do-it || echo ERROR
 # from branch 5.0
 #0 21  *  *  Fri                      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/announcement.md

@@ -1,75 +1,93 @@
-The CGAL Open Source Project is pleased to announce the release 5.0
+%The CGAL Open Source Project is pleased to announce the release 5.3 of CGAL, the Computational Geometry Algorithms Library.
-of CGAL, the Computational Geometry Algorithms Library.
 
-Besides fixes and general enhancement to existing packages, the
+Besides fixes and general enhancement to existing packages, the following has changed since CGAL 5.2:
-following has changed since CGAL 4.14.2:
 
-### General changes
+### [General changes](https://doc.cgal.org/5.3/Manual/general_intro.html)
 
-- CGAL 5.0 is the first release of CGAL that requires a C++ compiler
+-   The support for the compiled version of CGAL is dropped. Only the header-only version is supported.
-  with the support of C++14 or later. The new list of supported
-  compilers is:
-  - Visual C++ 14.0 (from Visual Studio 2015 Update 3) or later,
-  - Gnu g++ 6.3 or later (on Linux or MacOS),
-  - LLVM Clang version 8.0 or later (on Linux or MacOS), and
-  - Apple Clang compiler versions 7.0.2 and 10.0.1 (on MacOS).
-- Since CGAL 4.9, CGAL can be used as a header-only library, with
-  dependencies. Since CGAL 5.0, that is now the default, unless
-  specified differently in the (optional) CMake configuration.
-- The section "Getting Started with CGAL" of the documentation has
-  been updated and reorganized.
-- The minimal version of Boost is now 1.57.0.
 
+-   On Windows, the type used for `Exact_rational`, in `Epick` and indirectly (through `Lazy_exact_nt`)
+   `Epeck` may now be `boost::multiprecision::mpq_rational`, as has been the case on other platforms
+   for several releases. This depends on various options and is added to a list that includes
+   `mpq_class`, `CGAL::Gmpq`, `leda_rational` and `CGAL::Quotient<CGAL::MP_Float>`.
 
-### [Polygonal Surface Reconstruction](https://doc.cgal.org/5.0/Manual/packages.html#PkgPolygonalSurfaceReconstruction) (new package)
+### [Quadtrees, Octrees, and Orthtrees](https://doc.cgal.org/5.3/Manual/packages.html#PkgOrthtree) (new package)
 
- -   This package provides a method for piecewise planar object reconstruction from point clouds. 
+-   This package implements a tree data structure in which each node encloses a hypercubic section
-     The method takes as input an unordered point set sampled from a piecewise planar object 
+    of space and each non-leave node has hypercubic children whose edge lengths are half its edge length.
-     and outputs a compact and watertight surface mesh interpolating the input point set. 
+    Such a data structure is known as a quadtree in 2D, an octree in 3D, and is generalized
-     The method assumes that all necessary major planes are provided (or can be extracted from 
+    as an "orthtree" in higher dimensions.
-     the input point set using the shape detection method described in Point Set Shape Detection, 
-     or any other alternative methods).The method can handle arbitrary piecewise planar objects 
-     and is capable of recovering sharp features and is robust to noise and outliers. See also 
-     the associated [blog entry](https://www.cgal.org/2019/08/05/Polygonal_surface_reconstruction/).
 
-### [Shape Detection](https://doc.cgal.org/5.0/Manual/packages.html#PkgShapeDetection) (major changes)
+### [Triangulations on the Sphere](https://doc.cgal.org/5.3/Manual/packages.html#PkgTriangulationOnSphere2) (new package)
- -   **Breaking change:** The concept `ShapeDetectionTraits` has been renamed to [`EfficientRANSACTraits`](https://doc.cgal.org/5.0/Shape_detection/classEfficientRANSACTraits.html).
- -   **Breaking change:** The `Shape_detection_3` namespace has been renamed to [`Shape_detection`](https://doc.cgal.org/5.0/Shape_detection/annotated.html).
- -   Added a new, generic implementation of region growing. This enables for example applying region growing to inputs such as 2D and 3D point sets,
-     or models of the [`FaceGraph`](https://doc.cgal.org/5.0/BGL/classFaceGraph.html) concept. Learn more about this new algorithm with this [blog entry](https://www.cgal.org/2019/07/30/Shape_detection/).
 
-### [dD Geometry Kernel](https://doc.cgal.org/5.0/Manual/packages.html#PkgKernelD)
+-   This package enables the construction and manipulation of Delaunay triangulations on the 2-sphere.
- -   A new exact kernel, [`Epeck_d`](https://doc.cgal.org/5.0/Kernel_d/structCGAL_1_1Epeck__d.html), is now available.
+    Triangulations are built incrementally and can be modified by insertion or removal of vertices.
+    Point location querying and primitives to build the dual Voronoi diagram are provided.
 
-### 2D and 3D Triangulations
+### File Input / Output
 
--   **Breaking change:** Several deprecated functions and classes have been
+-   Point set, polygon soup, and polygon mesh file I/O functions have been harmonized and documented:
-    removed. See the full list of breaking changes in the release
+    -   Point set I/O functions can be found in the packages [Point_set_processing_3](https://doc.cgal.org/5.3/Manual/packages.html#PkgPolygonMeshProcessing), and [Point_set_3](https://doc.cgal.org/5.3/Manual/packages.html#PkgPointSet3).
-    notes.
+    -   Polygon mesh I/O functions can be found in the package [BGL](https://doc.cgal.org/5.3/Manual/packages.html#PkgBGL).
+    -   Polygon soup I/O can be found in the package [Stream_support](https://doc.cgal.org/5.3/Manual/packages.html#PkgStreamSupport).
 
--   **Breaking change:** The constructor and the `insert()` function of
+A comprehensive list of the supported file formats is available in the Stream_support package
-    `CGAL::Triangulation_2` or `CGAL::Triangulation_3` which take a range
+[here](https://doc.cgal.org/5.3/Stream_support/index.html#IOstreamSupportedFormats);
-    of points as argument are now guaranteed to insert the points
+inversely, the following [page](https://doc.cgal.org/5.3/Stream_support/IOStreamSupportedFileFormats.html)
-    following the order of `InputIterator`.  Note that this change only
+can be used to find out which CGAL data structures can be used given a specific file format.
-    affects the base class `CGAL::Triangulation_[23]` and not any
-    derived class, such as `CGAL::Delaunay_triangulation_[23]`.
 
+### [Requirements](https://doc.cgal.org/5.3/Manual/thirdparty.html)
 
-### [Polygon Mesh Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPolygonMeshProcessing)
+-   The CMake minimal version is now `3.14`.
- -   Introduced a [wide range of new functions](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title36) 
+-   The GNU compiler g++ versions 6 and 7 are no longer tested. Only version 8.3 or later are supported
-     related to location of queries on a triangle mesh,
-     such as [`CGAL::Polygon_mesh_processing::locate(Point, Mesh)`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__locate__grp.html#gada09bd8740ba69ead9deca597d53cf15).
-     The location of a point on a triangle mesh is expressed as the pair of a face and the barycentric
-     coordinates of the point in this face, enabling robust manipulation of locations 
-     (for example, intersections of two 3D segments living within the same face).
- -   Added the mesh smoothing function [`smooth_mesh()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__meshing__grp.html#gaa0551d546f6ab2cd9402bea12d8332a3),
-     which can be used to improve the quality of triangle elements based on various geometric characteristics.
- -   Added the shape smoothing function [`smooth_shape()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__meshing__grp.html#gaaa083ec78bcecf351e04d1bbf460b4a2),
-     which can be used to smooth the surface of a triangle mesh, using the mean curvature flow to perform noise removal.
-     (See also the new entry in the [User Manual](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title8))
 
-### [Point Set Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPointSetProcessing3)
+### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.3/Manual/packages.html#PkgKernel23)
- -   **Breaking change**: the API using iterators and overloads for optional parameters (deprecated since
-     CGAL 4.12) has been removed. The current (and now only) API uses ranges and Named Parameters.
 
-See https://www.cgal.org/2019/11/08/cgal50/ for a complete list of changes.
+-   Added `is_translation()`, `is_scaling()`, `is_reflection()`, and `is_rotation()` to the classes
+    [`Aff_transformation_2`](https://doc.cgal.org/5.3/Kernel_23/classCGAL_1_1Aff__transformation__2.html)
+    and [`Aff_transformation_3`](https://doc.cgal.org/5.3/Kernel_23/classCGAL_1_1Aff__transformation__3.html),
+    which enable determining if the transformations use a specialized representation internally.
+
+### [2D Regularized Boolean Set-Operations](https://doc.cgal.org/5.3/Manual/packages.html#PkgBooleanSetOperations2)
+-   Added documentation for the free functions [`oriented_side(const Point_2& p, ....)`](https://doc.cgal.org/5.3/Boolean_set_operations_2/group__boolean__oriented__side.html)
+    that accept a point and a polygon.
+-   Documentation has been improved across the whole package.
+
+### [Polygon Mesh Processing](https://doc.cgal.org/5.3/Manual/packages.html#PkgPolygonMeshProcessing)
+
+-   Added the class [`CGAL::Polyhedral_envelope`](https://doc.cgal.org/5.3/Polygon_mesh_processing/structCGAL_1_1Polyhedral__envelope.html),
+    providing a way to quickly check if a primitive (point, segment, or triangle)
+    is within a polyhedral envelope around a set of triangles. It is based on the work of
+    Bolun Wang, Teseo Schneider, Yixin Hu, Marco Attene, and Daniele Panozzo.
+    "Exact and efficient polyhedral envelope containment check." (ACM Trans. Graph., 39-4, July 2020).
+-   Added more functions in the [visitor of the corefinement based methods](https://doc.cgal.org/5.3/Polygon_mesh_processing/classPMPCorefinementVisitor.html)
+    to track all edge creations.
+
+### [Surface Mesh Topology](https://doc.cgal.org/5.3/Manual/packages.html#PkgSurfaceMeshTopologySummary)
+-   Added the function [`CGAL::Surface_mesh_topology::Curves_on_surface_topology::is_homotopic_to_simple_cycle()`](https://doc.cgal.org/5.3/Surface_mesh_topology/classCGAL_1_1Surface__mesh__topology_1_1Curves__on__surface__topology.html#a8d7c4cba2cf2cff542f5cd93117233db),
+    which can be used to determine whehter a closed path on a surface mesh can be continously
+    transformed to a cycle without self intersection.
+
+### [Surface Mesh Simplification](https://doc.cgal.org/5.3/Manual/packages.html#PkgSurfaceMeshSimplification)
+-   Added a filtering mechanism so that costly tests get only applied to the next candidate for the edge collapse.
+-   Added the class [`Polyhedral_envelope_filter`](https://doc.cgal.org/5.3/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Polyhedral__envelope__filter.html),
+    which enables to perform mesh simplification  inside a polyhedral envelope of the input mesh.
+
+### [2D Polyline Simplification](https://doc.cgal.org/5.3/Manual/packages.html#PkgPolylineSimplification2)
+-   When polylines have common subsequences of vertices, these subsequences may now be simplifified simultaneously.
+
+### [dD Triangulations](https://doc.cgal.org/5.3/Manual/packages.html#PkgTriangulations)
+-   Added the function [`insert_if_in_star()`](https://doc.cgal.org/5.3/Triangulation/classCGAL_1_1Regular__triangulation.html#aa8df2d138f341939e834bcdd7cb6c71a)
+    to the class [`CGAL::Regular_triangulation`](https://doc.cgal.org/5.3/Triangulation/classCGAL_1_1Regular__triangulation.html),
+    which enables users to insert a point `p` in a regular triangulation on the condition that `p`
+    appears post-insertion in the star of a user-specified, existing vertex.
+
+### [2D and 3D Alpha Shapes](https://doc.cgal.org/5.3/Manual/packages.html#PkgAlphaShapes2)
+-   **Breaking change**: The following deprecated classes have been removed: `Alpha_shape_euclidean_traits_2`,
+    `Weighted_alpha_shape_euclidean_traits_2`, `Alpha_shape_euclidean_traits_3`, and
+    `Weighted_alpha_shape_euclidean_traits_3`. All CGAL kernel can be used directly as models
+    of the concepts of the 2D and 3D Alpha Shape packages.
+
+### [Classification](https://doc.cgal.org/5.3/Manual/packages.html#PkgClassification)
+-   **Breaking change**: the support for TensorFlow has been dropped; the
+    classifier `CGAL::TensorFlow::Neural_network_classifier` has been removed.

Maintenance/public_release/announcement/mailing.eml

@@ -1,130 +1,158 @@
-Subject: CGAL 5.1 Released, Computational Geometry Algorithms Library
+Subject: CGAL 5.3 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
+The CGAL Open Source Project is pleased to announce the release 5.3
 of CGAL, the Computational Geometry Algorithms Library.
 
 
 Besides fixes and general enhancement to existing packages, the following
-has changed since CGAL 5.0:
+has changed since CGAL 5.2:
+
+General changes
+
+-   The support for the compiled version of CGAL is dropped. Only the
+    header-only version is supported.
+
+-   On Windows, the type used for Exact_rational, in Epick and
+    indirectly (through Lazy_exact_nt) Epeck may now be
+    boost::multiprecision::mpq_rational, as has been the case on other
+    platforms for several releases. This depends on various options and
+    is added to a list that includes mpq_class, CGAL::Gmpq,
+    leda_rational and CGAL::Quotient<CGAL::MP_Float>.
 
 
-Tetrahedral Remeshing (new package)
+Quadtrees, Octrees, and Orthtrees (new package)
 
--   This package implements a tetrahedral isotropic remeshing algorithm,
+-   This package implements a tree data structure in which each node
-    that improves the quality of tetrahedra in terms of dihedral angles,
+    encloses a hypercubic section of space and each non-leave node has
-    while targeting a given edge length.
+    hypercubic children whose edge lengths are half its edge length.
+    Such a data structure is known as a quadtree in 2D, an octree in 3D,
+    and is generalized as an “orthtree” in higher dimensions.
 
-    See also the associated blog entry:
+      https://www.cgal.org/2021/04/27/Orthtree/
-      https://www.cgal.org/2020/08/07/Tetrahedral-remeshing/
 
-Surface Mesh Topology (new package)
+      https://doc.cgal.org/5.3/Manual/packages.html#PkgOrthtree
 
--   This package enables the computation of some topological invariants
-    of surfaces, such as:
-    -   test if two (closed) curves on a combinatorial surface are
-        homotopic. Users can choose between free homotopy and homotopy
-        with fixed endpoints;
-    -   test is a curve is contractible;
-    -   compute shortest non-contractible cycles on a surface, with or
-        without weights on edges.
 
-    See also the associated blog entry:
+Triangulations on the Sphere (new package)
-      https://www.cgal.org/2020/05/08/Surface_mesh_topology/
 
-Optimal Bounding Box (new package)
+-   This package enables the construction and manipulation of Delaunay
+    triangulations on the 2-sphere. Triangulations are built
+    incrementally and can be modified by insertion or removal of
+    vertices. Point location querying and primitives to build the dual
+    Voronoi diagram are provided.
 
--   This package implements an optimization algorithm that aims to
+      https://doc.cgal.org/5.3/Manual/packages.html#PkgTriangulationOnSphere2
-    construct a close approximation of the _optimal bounding box_ of a
-    mesh or a point set, which is defined as the smallest (in terms of
-    volume) bounding box that contains a given mesh or point set.
 
-    See also the associated blog entry:
-      https://www.cgal.org/2020/04/20/Optimal_bounding_box/
 
-Installation
+File Input / Output
 
--   The CGAL_Core library no longer requires Boost.Thread, even if the
+-   Point set, polygon soup, and polygon mesh file I/O functions have
-    g++ compiler is used.
+    been harmonized and documented:
+    -   Point set I/O functions can be found in the packages
+        Point_set_processing_3, and Point_set_3.
+    -   Polygon mesh I/O functions can be found in the package BGL.
+    -   Polygon soup I/O can be found in the package Stream_support.
 
--   The minimal supported version of Boost is now 1.66.0.
+A comprehensive list of the supported file formats is available in the
+Stream_support package:
 
-Tutorials
+    https://doc.cgal.org/5.3/Stream_support/index.html#IOstreamSupportedFormats
 
--   Two new, detailed tutorials have been added:
+Inversely, the following page can be used to find out which CGAL data
-    -   Surface Reconstruction from Point Clouds, which goes over a
+structures can be used given a specific file format.
-        typical full processing pipeline in a CGAL environment.
-    -   Geographic Information Systems (GIS), which demonstrates usage
-        of CGAL data structures and algorithms in the context of a
-        typical GIS application.
 
-    Both tutorials provide complete code.
+    https://doc.cgal.org/5.3/Stream_support/IOStreamSupportedFileFormats.html
 
-    See https://doc.cgal.org/5.1/Manual/tutorials.html
 
-Point Set Processing
+Requirements
 
--   Added wrapper functions for registration, using the Super4PCS and
+-   The CMake minimal version is now 3.14.
-    ICP algorithms implemented in the third party libraries OpenGR and
+
-    libpointmatcher.
+-   The GNU compiler g++ versions 6 and 7 are no longer tested. Only
+    version 8.3 or later are supported
+
+
+2D and 3D Linear Geometry Kernel
+
+-   Added is_translation(), is_scaling(), is_reflection(), and
+    is_rotation() to the classes Aff_transformation_2 and
+    Aff_transformation_3, which enable determining if the
+    transformations use a specialized representation internally.
+
+
+2D Regularized Boolean Set-Operations
+
+-   Added documentation for the free functions
+    oriented_side(const Point_2& p, ....) that accept a point and a
+    polygon.
+-   Documentation has been improved across the whole package.
+
+
+Polygon Mesh Processing
+
+-   Added the class CGAL::Polyhedral_envelope, providing a way to
+    quickly check if a primitive (point, segment, or triangle) is within
+    a polyhedral envelope around a set of triangles. It is based on the
+    work of Bolun Wang, Teseo Schneider, Yixin Hu, Marco Attene, and
+    Daniele Panozzo. “Exact and efficient polyhedral envelope
+    containment check.” (ACM Trans. Graph., 39-4, July 2020).
+-   Added more functions in the visitor of the corefinement based
+    methods to track all edge creations.
+
+
+Surface Mesh Topology
+
+-   Added the function
+    CGAL::Surface_mesh_topology::Curves_on_surface_topology::is_homotopic_to_simple_cycle(),
+    which can be used to determine whehter a closed path on a surface
+    mesh can be continously transformed to a cycle without self
+    intersection.
 
 
 Surface Mesh Simplification
 
--   Added a new simplification method based on the quadric error defined
+-   Added a filtering mechanism so that costly tests get only applied to
-    by Garland and Heckbert.
+    the next candidate for the edge collapse.
-
+-   Added the class Polyhedral_envelope_filter, which enables to perform
-dD Spatial Searching
+    mesh simplification inside a polyhedral envelope of the input mesh.
-
--   The kd-tree can now be built in parallel: CGAL::Kd_tree::build() is
-    given an optional template parameter ConcurrencyTag (default value
-    remains CGAL::Sequential_tag for backward compatibility).
-
-Intersecting Sequences of dD Iso-oriented Boxes
-
--   Added parallel versions of the functions CGAL::box_intersection_d()
-    and CGAL::box_self_intersection_d().
-
-Polygon Mesh Processing
-
--   Added the function CGAL::Polygon_mesh_processing::split(), which can
-    be used to split meshes along a mesh or a plane.
--   Added the function
-    CGAL::Polygon_mesh_processing::split_connected_components() to split
-    a single mesh containing several connected components into several
-    meshes containing one connected component.
--   Added parallel versions of the functions
-    CGAL::Polygon_mesh_processing::does_self_intersect() and
-    CGAL::Polygon_mesh_processing::self_intersections().
--   Added several mesh repair functions (see the complete changelog for
-    more information).
-
-3D Fast Intersection and Distance Computation
-
--   The behavior of the internal search tree used to accelerate distance
-    queries has changed: usage of the internal search tree will now be
-    enabled by default, and its construction will be triggered by the
-    first distance query. Automatic construction and usage can be
-    disabled by calling
-    CGAL::AABB_tree::do_not_accelerate_distance_queries() before the
-    first distance query, and the tree can be built at any moment by
-    calling CGAL::AABB_tree::accelerate_distance_queries().
--   BREAKING CHANGE: CGAL::AABB_tree::accelerate_distance_queries() and
-    CGAL::AABB_tree::do_not_accelerate_distance_queries() are no longer
-    const functions.
 
 
-CGAL and the Boost Graph Library (BGL)
+2D Polyline Simplification
 
--   Added the function CGAL::alpha_expansion_graphcut(), which
+-   When polylines have common subsequences of vertices, these
-    regularizes a multi-label partition over a user-defined graph.
+    subsequences may now be simplifified simultaneously.
--   Added the function CGAL::regularize_face_selection_borders(), which
-    uses this alpha expansion graphcut to regularize the borders of a
-    selected faces on a triangle mesh.
 
-See https://www.cgal.org/2020/09/08/cgal51/ for a complete list of
+
-changes.
+dD Triangulations
+
+-   Added the function insert_if_in_star() to the class
+    CGAL::Regular_triangulation, which enables users to insert a point p
+    in a regular triangulation on the condition that p appears
+    post-insertion in the star of a user-specified, existing vertex.
+
+
+2D and 3D Alpha Shapes
+
+-   Breaking change: The following deprecated classes have been removed:
+    Alpha_shape_euclidean_traits_2,
+    Weighted_alpha_shape_euclidean_traits_2,
+    Alpha_shape_euclidean_traits_3, and
+    Weighted_alpha_shape_euclidean_traits_3. All CGAL kernel can be used
+    directly as models of the concepts of the 2D and 3D Alpha Shape
+    packages.
+
+
+Classification
+
+-   Breaking change: the support for TensorFlow has been dropped; the
+    classifier CGAL::TensorFlow::Neural_network_classifier has been
+    removed.
+
+
+See https://www.cgal.org/2021/07/06/cgal53/ for a
+complete list of changes.
 
 
 The CGAL project is a collaborative effort to develop a robust,

Maintenance/test_handling/testresult.css

@@ -25,16 +25,16 @@ TD.os64bits {font-style:italic}
 .cmaketag {font-weight: bold; color: rgb(100%,20%,20%);}
 
 
-TD.ok {background-color: rgb(50%,100%,50%)}
+TD.ok {background-color: rgb(44%,88%,44%)}
 TD.warning {background-color: rgb(100%,100%,50%)}
-TD.third_party_warning {background-color: rgb(93%,65%,0%)}
+TD.third_party_warning {background-color: rgb(75%,100%,50%)}
 TD.error {background-color: rgb(100%,50%,50%)}
 TD.na {background-color: white;}
 TD.requirements { background-color: rgb(65%,65%,100%) }
 
-TH.ok {background-color: rgb(50%,100%,50%)}
+TD.ok {background-color: rgb(44%,88%,44%)}
 TH.warning {background-color: rgb(100%,100%,50%)}
-TH.third_party_warning {background-color: rgb(93%,65%,0%)}
+TH.third_party_warning {background-color: rgb(75%,100%,50%)}
 TH.error {background-color: rgb(100%,50%,50%)}
 TH.requirements { background-color: rgb(65%,65%,100%) }
 

Number_types/include/CGAL/Gmpq.h

@@ -26,6 +26,15 @@ template <> class Algebraic_structure_traits< Gmpq >
     typedef Tag_true            Is_exact;
     typedef Tag_false            Is_numerical_sensitive;
 
+    class Is_zero
+      : public CGAL::cpp98::unary_function< Type, bool > {
+      public:
+        bool operator()( const Type& x_) const {
+          return mpq_sgn(x_.mpq()) == 0;
+        }
+    };
+
+
     class Is_square
       : public CGAL::cpp98::binary_function< Type, Type&,
                                 bool > {
@@ -60,6 +69,22 @@ template <> class Real_embeddable_traits< Gmpq >
   : public INTERN_RET::Real_embeddable_traits_base< Gmpq , CGAL::Tag_true > {
   public:
 
+    class Is_positive
+      : public CGAL::cpp98::unary_function< Type, bool > {
+      public:
+        bool operator()( const Type& x_) const {
+          return mpq_sgn(x_.mpq()) > 0;
+        }
+    };
+
+    class Is_negative
+      : public CGAL::cpp98::unary_function< Type, bool > {
+      public:
+        bool operator()( const Type& x_) const {
+          return mpq_sgn(x_.mpq()) < 0;
+        }
+    };
+
     class Sgn
       : public CGAL::cpp98::unary_function< Type, ::CGAL::Sign > {
       public:

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap_vertices.h

@@ -44,6 +44,7 @@
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/member.hpp>
+#include <boost/iterator/transform_iterator.hpp>
 
 #ifdef CGAL_LINKED_WITH_TBB
 # include <tbb/blocked_range.h>
@@ -934,6 +935,27 @@ std::size_t snap_border_vertices(PolygonMesh& tm)
   return snap_border_vertices(tm, tm);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Other convenience overloads
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PolygonMesh, typename ToleranceMap>
+std::size_t snap_all_vertices(PolygonMesh& tm, ToleranceMap tolerance_map)
+{
+  typedef boost::graph_traits<PolygonMesh> GT;
+
+  auto get_halfedge = [&tm](typename GT::vertex_descriptor v)
+  {
+    return halfedge(v, tm);
+  };
+
+  auto hedges = make_range(
+                 boost::make_transform_iterator(vertices(tm).begin(), get_halfedge),
+                 boost::make_transform_iterator(vertices(tm).end(), get_halfedge) );
+
+  return snap_vertices(hedges, tm, tolerance_map, hedges, tm, tolerance_map);
+}
+
+
 } // namespace experimental
 } // namespace Polygon_mesh_processing
 } // namespace CGAL

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h

@@ -278,6 +278,9 @@ void isotropic_remeshing(const FaceRange& faces
   unsigned int nb_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
   bool smoothing_1d = choose_parameter(get_parameter(np, internal_np::relax_constraints), false);
   unsigned int nb_laplacian = choose_parameter(get_parameter(np, internal_np::number_of_relaxation_steps), 1);
+  bool do_collapse = choose_parameter(get_parameter(np, internal_np::do_collapse), true);
+  bool do_split = choose_parameter(get_parameter(np, internal_np::do_split), true);
+  bool do_flip = choose_parameter(get_parameter(np, internal_np::do_flip), true);
 
 #ifdef CGAL_PMP_REMESHING_VERBOSE
   std::cout << std::endl;
@@ -293,9 +296,12 @@ void isotropic_remeshing(const FaceRange& faces
 #endif
     if (target_edge_length>0)
     {
+      if(do_split)
         remesher.split_long_edges(high);
+      if(do_collapse)
         remesher.collapse_short_edges(low, high, collapse_constraints);
     }
+    if(do_flip)
       remesher.flip_edges_for_valence_and_shape();
     remesher.tangential_relaxation(smoothing_1d, nb_laplacian);
     if ( choose_parameter(get_parameter(np, internal_np::do_project), true) )

Scripts/developer_scripts/run_testsuite_with_ctest

@@ -318,6 +318,7 @@ run_test_on_platform()
   else
     echo "CGAL_VERSION ${CGAL_GIT_VERSION}">> "$RESULT_FILE"
   fi
+  sed -n '/The CXX compiler/s/-- The CXX compiler identification is/COMPILER_VERSION =/p' < "${CGAL_BINARY_DIR}/installation.log" |sed -E "s/ = (.*)/\ = '\1\'/">> "$RESULT_FILE"
   echo "TESTER ${CGAL_TESTER}" >> "$RESULT_FILE"
   echo "TESTER_NAME ${CGAL_TESTER}" >> "$RESULT_FILE"
   echo "TESTER_ADDRESS ${TESTER_ADDRESS}" >> "$RESULT_FILE"

Scripts/developer_scripts/tag_pr_per_release.sh

@@ -34,16 +34,18 @@ git fetch --tags "${REMOTE}" `git config --get-all "remote.${REMOTE}.fetch"` '+r
 
 PR_LIST=`git log --pretty='%D' v${PREVIOUS_MAJOR_RELEASE}..v${CURRENT_RELEASE} | awk 'match($0, /refs\/pull\/([0-9]+)\/head/, a) {print a[1]}' | sort -u`
 
+echo gh api repos/CGAL/cgal/labels -F name=Merged_in_${CURRENT_RELEASE}
 for i in ${PR_LIST}; do
-  echo ghi label $i -a Merged_in_${CURRENT_RELEASE} -- CGAL/cgal
+  echo gh pr edit  $i --add-label Merged_in_${CURRENT_RELEASE}
 done
 
 read -p "Please confirm operation by typing YES? " -n 4 -r
 echo
 if [[ $REPLY =~ ^YES$ ]]; then
 
+  gh api repos/CGAL/cgal/labels -F name=Merged_in_${CURRENT_RELEASE}
   for i in ${PR_LIST}; do
-    ghi label $i -a Merged_in_${CURRENT_RELEASE} -- CGAL/cgal
+    gh pr edit  $i --add-label Merged_in_${CURRENT_RELEASE}
   done
 
 else

Shape_detection/examples/Shape_detection/efficient_RANSAC_with_callback.cpp

@@ -82,6 +82,7 @@ int main (int argc, char** argv) {
 
   // Detect registered shapes with the default parameters.
   ransac.detect(Efficient_ransac::Parameters(), timeout_callback);
+  assert(ransac.shapes().size() > 0);
 
   return EXIT_SUCCESS;
 }

Shape_detection/include/CGAL/Shape_detection/Efficient_RANSAC/Efficient_RANSAC.h

@@ -480,8 +480,11 @@ public:
         return false;
     }
 
-    if (callback && !callback(0.))
+    if (callback && !callback(0.)) {
+      clear_octrees();
+      clear_shape_factories();
       return false;
+    }
 
     // Reset data structures possibly used by former search
     m_extracted_shapes =
@@ -580,8 +583,13 @@ public:
                    m_shape_index,
                    m_required_samples);
 
-                if (callback && !callback(num_invalid / double(m_num_total_points)))
+                if (callback && !callback(num_invalid / double(m_num_total_points))) {
+                  clear_octrees();
+                  clear_shape_factories();
+                  clear_candidates(candidates);
+                  m_num_available_points -= num_invalid;
                   return false;
+                }
 
               } while (m_shape_index[first_sample] != -1 || !done);
 
@@ -591,8 +599,13 @@ public:
               bool candidate_success = false;
               for(typename std::vector<Shape *(*)()>::iterator it =
                     m_shape_factories.begin(); it != m_shape_factories.end(); it++)        {
-                if (callback && !callback(num_invalid / double(m_num_total_points)))
+                if (callback && !callback(num_invalid / double(m_num_total_points))) {
+                  clear_octrees();
+                  clear_shape_factories();
+                  clear_candidates(candidates);
+                  m_num_available_points -= num_invalid;
                   return false;
+                }
                 Shape *p = (Shape *) (*it)();
                 //compute the primitive and says if the candidate is valid
                 p->compute(indices,
@@ -659,8 +672,13 @@ public:
       Shape *best_candidate =
               get_best_candidate(candidates, m_num_available_points - num_invalid);
 
-      if (callback && !callback(num_invalid / double(m_num_total_points)))
+      if (callback && !callback(num_invalid / double(m_num_total_points))) {
+        clear_octrees();
+        clear_shape_factories();
+        clear_candidates(candidates);
+        m_num_available_points -= num_invalid;
         return false;
+      }
 
       // If search is done and the best candidate is too small, we are done.
       if (!keep_searching && best_candidate->m_score < m_options.min_points)
@@ -683,8 +701,13 @@ public:
       best_candidate->connected_component(best_candidate->m_indices,
                                           m_options.cluster_epsilon);
 
-      if (callback && !callback(num_invalid / double(m_num_total_points)))
+      if (callback && !callback(num_invalid / double(m_num_total_points))) {
+        clear_octrees();
+        clear_shape_factories();
+        clear_candidates(candidates);
+        m_num_available_points -= num_invalid;
         return false;
+      }
       // check score against min_points and clear out candidates if too low
       if (best_candidate->indices_of_assigned_points().size() <
           m_options.min_points) {
@@ -700,8 +723,13 @@ public:
         delete best_candidate;
         best_candidate = nullptr;
 
-        if (callback && !callback(num_invalid / double(m_num_total_points)))
+        if (callback && !callback(num_invalid / double(m_num_total_points))) {
+          clear_octrees();
+          clear_shape_factories();
+          clear_candidates(candidates);
+          m_num_available_points -= num_invalid;
           return false;
+        }
 
         // Trimming candidates list
         std::size_t empty = 0, occupied = 0;
@@ -727,8 +755,13 @@ public:
 
         candidates.resize(empty);
 
-        if (callback && !callback(num_invalid / double(m_num_total_points)))
+        if (callback && !callback(num_invalid / double(m_num_total_points))) {
+          clear_octrees();
+          clear_shape_factories();
+          clear_candidates(candidates);
+          m_num_available_points -= num_invalid;
           return false;
+        }
       } else if (stop_probability((std::size_t) best_candidate->expected_value(),
                                   (m_num_available_points - num_invalid),
                                   generated_candidates,
@@ -742,8 +775,13 @@ public:
         m_extracted_shapes->push_back(
                 boost::shared_ptr<Shape>(best_candidate));
 
-        if (callback && !callback(num_invalid / double(m_num_total_points)))
+        if (callback && !callback(num_invalid / double(m_num_total_points))) {
+          clear_octrees();
+          clear_shape_factories();
+          clear_candidates(candidates);
+          m_num_available_points -= num_invalid;
           return false;
+        }
 
         //2. remove the points
         const std::vector<std::size_t> &indices_points_best_candidate =
@@ -777,8 +815,13 @@ public:
         failed_candidates = 0;
         best_expected = 0;
 
-        if (callback && !callback(num_invalid / double(m_num_total_points)))
+        if (callback && !callback(num_invalid / double(m_num_total_points))) {
+          clear_octrees();
+          clear_shape_factories();
+          clear_candidates(candidates);
+          m_num_available_points -= num_invalid;
           return false;
+        }
 
         std::vector<std::size_t> subset_sizes(m_num_subsets);
         subset_sizes[0] = m_available_octree_sizes[0];
@@ -807,8 +850,13 @@ public:
           }
         }
 
-        if (callback && !callback(num_invalid / double(m_num_total_points)))
+        if (callback && !callback(num_invalid / double(m_num_total_points))) {
+          clear_octrees();
+          clear_shape_factories();
+          clear_candidates(candidates);
+          m_num_available_points -= num_invalid;
           return false;
+        }
 
         std::size_t start = 0, end = candidates.size() - 1;
         while (start < end) {
@@ -828,8 +876,13 @@ public:
       } else if (!keep_searching)
         ++generated_candidates;
 
-      if (callback && !callback(num_invalid / double(m_num_total_points)))
+      if (callback && !callback(num_invalid / double(m_num_total_points))) {
+        clear_octrees();
+        clear_shape_factories();
+        clear_candidates(candidates);
+        m_num_available_points -= num_invalid;
         return false;
+      }
 
       keep_searching = (stop_probability(m_options.min_points,
                                          m_num_available_points - num_invalid,
@@ -841,11 +894,7 @@ public:
              || best_expected >= m_options.min_points);
 
     // Clean up remaining candidates.
-    for (std::size_t i = 0; i < candidates.size(); i++)
+    clear_candidates(candidates);
-      delete candidates[i];
-
-    candidates.resize(0);
-
     m_num_available_points -= num_invalid;
 
     return true;
@@ -912,6 +961,13 @@ public:
   /// @}
 
 private:
+  void clear_candidates(std::vector<Shape *>& candidates) {
+    for (std::size_t i = 0; i < candidates.size(); i++) {
+      delete candidates[i];
+    }
+    candidates.resize(0);
+  }
+
   int select_random_octree_level() {
     auto upper_bound = static_cast<unsigned int>(m_global_octree->maxLevel() + 1);
     return (int) get_default_random()(upper_bound);

Testsuite/test/parse-ctest-dashboard-xml.py

@@ -76,6 +76,9 @@ for t_id in range(0, len(tests)):
             labels.add(label)
             tests_per_label[label].append(t)
 
+warning_pattern=re.compile(r'(.*([^a-zA-Z_,:-])([^\d]\s)warning).*?(\[|\n)', flags=re.IGNORECASE)
+w_det=re.compile("warning");
+filter_pattern=re.compile(r'cmake|cgal', flags=re.IGNORECASE);
 with open_file_create_dir(result_file_name.format(dir=os.getcwd(),
                                                   tester=tester_name,
                                                   platform=platform_name), 'a+') as results:
@@ -86,9 +89,12 @@ with open_file_create_dir(result_file_name.format(dir=os.getcwd(),
                 print("   {result} {name} in {time} s : {value} ".format(result = "successful " if (t['Status'] == 'passed') else "ERROR:     ", name = t['Name'], value = t['ExitValue'] if(t['ExitValue'] != "") else "SUCCESS" , time = t['ExecutionTime']), file=error)
                 if t['Status'] != 'passed':
                     result_for_label='n'
-                elif t['Output'] != None:
+                elif t['Output'] != None and w_det.search(t['Output']):
-                  for m in re.finditer(r'(.*([^a-zA-Z_,:-])([^\d]\s)warning).*?(\[|\n)', t['Output'], flags=re.IGNORECASE):
+                    entries = re.split("\n+", t['Output'])
-                        n = re.search(r'cmake|cgal', m.group(0), flags=re.IGNORECASE)
+                    for entry in entries:
+                        m=warning_pattern.search(entry)
+                        if m:
+                            n = filter_pattern.search(m.group(0))
                             if n:
                                 result_for_label='w'
                                 break;