Merge remote-tracking branch 'cgal/master' into CGAL-Improve_NP_doc_presentation-GF

2020-06-18 12:46:46 +02:00 · 2020-06-18 12:46:46 +02:00 · 26eb7903aa
parent f6d4c0ce42 5a02f47c56
commit 26eb7903aa
134 changed files with 1206 additions and 1120 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -4,34 +4,6 @@ sudo: required
 git:
  depth: 3
 env:
-  matrix:
-  PACKAGES_MATRIX
-
-compiler: clang
-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;
-before_script:
-  - wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
-  - sudo mv doxygen_exe /usr/bin/doxygen
-  - sudo chmod +x /usr/bin/doxygen
-  - mkdir -p build
-  - cd build
-  - /usr/bin/time -f 'Spend time of %C -- %E (real)' cmake -DCMAKE_CXX_FLAGS="-std=c++1y" -DCGAL_HEADER_ONLY=ON -DCMAKE_CXX_FLAGS_RELEASE=-DCGAL_NDEBUG -DWITH_examples=ON -DWITH_demos=ON -DWITH_tests=ON ..
-  - /usr/bin/time -f 'Spend time of %C -- %E (real)' make
-  - /usr/bin/time -f 'Spend time of %C -- %E (real)' sudo make install &>/dev/null
-  - cd ..
-script:
-  - cd ./.travis
-  - /usr/bin/time -f 'Spend time of %C -- %E (real)' bash ./build_package.sh $PACKAGE
-notifications:
-  email:
-    on_success: change
-    # default: always
-    on_failure: always
-    # default: always
  matrix:
    - PACKAGE='CHECK'
    - PACKAGE='AABB_tree Advancing_front_surface_reconstruction Algebraic_foundations '
@ -81,3 +53,28 @@ notifications:
    - PACKAGE='Three Triangulation Triangulation_2 '
    - PACKAGE='Triangulation_3 Union_find Visibility_2 '
    - PACKAGE='Voronoi_diagram_2 wininst '
+compiler: clang
+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;
+before_script:
+  - wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
+  - sudo mv doxygen_exe /usr/bin/doxygen
+  - sudo chmod +x /usr/bin/doxygen
+  - mkdir -p build
+  - cd build
+  - /usr/bin/time -f 'Spend time of %C -- %E (real)' cmake -DCMAKE_CXX_FLAGS="-std=c++1y" -DCGAL_HEADER_ONLY=ON -DCMAKE_CXX_FLAGS_RELEASE=-DCGAL_NDEBUG -DWITH_examples=ON -DWITH_demos=ON -DWITH_tests=ON ..
+  - /usr/bin/time -f 'Spend time of %C -- %E (real)' make
+  - /usr/bin/time -f 'Spend time of %C -- %E (real)' sudo make install &>/dev/null
+  - cd ..
+script:
+  - cd ./.travis
+  - /usr/bin/time -f 'Spend time of %C -- %E (real)' bash ./build_package.sh $PACKAGE
+notifications:
+  email:
+    on_success: change
+    # default: always
+    on_failure: always
+    # default: always
--- a/AABB_tree/demo/AABB_tree/Scene.cpp
+++ b/AABB_tree/demo/AABB_tree/Scene.cpp
@ -45,8 +45,7 @@ Scene::Scene()
    m_blue_ramp.build_blue();
    m_max_distance_function = (FT)0.0;
    texture = new Texture(m_grid_size,m_grid_size);
-    startTimer(0);
-    ready_to_cut = false;
+    ready_to_cut = true;
    are_buffers_initialized = false;
    gl_init = false;

@ -519,6 +518,7 @@ void Scene::changed()
        compute_elements(_UNSIGNED);
    else
        compute_elements(_SIGNED);
+    ready_to_cut=false;
    are_buffers_initialized = false;

 }
@ -1226,12 +1226,16 @@ void Scene::cut_segment_plane()
    m_cut_plane = CUT_SEGMENTS;
    changed();
 }
+void Scene::updateCutPlane()
+{
+  ready_to_cut = true;
+       QTimer::singleShot(0,this,SLOT(cutting_plane()));
+}

 void Scene::cutting_plane(bool override)
 {
    if(ready_to_cut || override)
    {
-        ready_to_cut = false;
        switch( m_cut_plane )
        {
        case UNSIGNED_FACETS:
@ -1304,13 +1308,13 @@ void Scene::refine_loop()

 void Scene::activate_cutting_plane()
 {
-    connect(m_frame, SIGNAL(modified()), this, SLOT(cutting_plane()));
+    connect(m_frame, SIGNAL(modified()), this, SLOT(updateCutPlane()));
    m_view_plane = true;
 }

 void Scene::deactivate_cutting_plane()
 {
-    disconnect(m_frame, SIGNAL(modified()), this, SLOT(cutting_plane()));
+    disconnect(m_frame, SIGNAL(modified()), this, SLOT(updateCutPlane()));
    m_view_plane = false;
 }
 void Scene::initGL()
@ -1326,10 +1330,3 @@ void Scene::initGL()
    compile_shaders();
    gl_init = true;
 }
-
-void Scene::timerEvent(QTimerEvent *)
-{
-    if(manipulatedFrame()->isSpinning())
-        set_fast_distance(true);
-    ready_to_cut = true;
-}
--- a/AABB_tree/demo/AABB_tree/Scene.h
+++ b/AABB_tree/demo/AABB_tree/Scene.h
@ -173,6 +173,8 @@ private:
    void attrib_buffers(CGAL::QGLViewer*);
    void compile_shaders();
    void compute_texture(int, int, Color_ramp, Color_ramp);
+private slots:
+    void updateCutPlane();

 public:
    // file menu
@ -251,8 +253,6 @@ public:
    void activate_cutting_plane();
    void deactivate_cutting_plane();

-    //timer sends a top when all the events are finished
-    void timerEvent(QTimerEvent *);


 public slots:
--- a/Bounding_volumes/examples/Approximate_min_ellipsoid_d/CMakeLists.txt
+++ b/Bounding_volumes/examples/Approximate_min_ellipsoid_d/CMakeLists.txt
@ -8,15 +8,18 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
-    if(NOT (${cppfile} STREQUAL "ellipsoid.cpp") OR EIGEN3_FOUND)
-      create_single_source_cgal_program( "${cppfile}" )
-      if (EIGEN3_FOUND)
-        get_filename_component(target ${cppfile} NAME_WE)
-        CGAL_target_use_Eigen(${target})
+    if(NOT (${cppfile} STREQUAL "ellipsoid.cpp") OR TARGET CGAL::Eigen_support)
+      get_filename_component(target ${cppfile} NAME_WE)
+      add_executable(${target} ${cppfile})
+      if (TARGET CGAL::Eigen_support)
+        target_link_libraries(${target} CGAL::CGAL CGAL::Eigen_support)
+      else()
+        target_link_libraries(${target} CGAL::CGAL)
      endif()
    endif()
  endforeach()
@ -26,4 +29,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Bounding_volumes/test/Bounding_volumes/CMakeLists.txt
+++ b/Bounding_volumes/test/Bounding_volumes/CMakeLists.txt
@ -14,15 +14,18 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
-    if(NOT (${cppfile} STREQUAL "Approximate_min_ellipsoid_d.cpp") OR EIGEN3_FOUND)
-      create_single_source_cgal_program( "${cppfile}" )
-      if (EIGEN3_FOUND)
-        get_filename_component(target ${cppfile} NAME_WE)
-        CGAL_target_use_Eigen(${target})
+    if(NOT (${cppfile} STREQUAL "Approximate_min_ellipsoid_d.cpp") OR TARGET CGAL::Eigen_support)
+      get_filename_component(target ${cppfile} NAME_WE)
+      add_executable(${target} ${cppfile})
+      if (TARGET CGAL::Eigen_support)
+        target_link_libraries(${target} CGAL::CGAL CGAL::Eigen_support)
+      else()
+        target_link_libraries(${target} CGAL::CGAL)
      endif()
    endif()
  endforeach()
@ -32,4 +35,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Box_intersection_d/test/Box_intersection_d/CMakeLists.txt
+++ b/Box_intersection_d/test/Box_intersection_d/CMakeLists.txt
@ -8,6 +8,7 @@ project( Box_intersection_d_Tests )
 find_package( CGAL QUIET )

 find_package( TBB )
+include(CGAL_TBB_support)

 if ( CGAL_FOUND )

@ -16,12 +17,11 @@ if ( CGAL_FOUND )
  create_single_source_cgal_program( "random_set_test.cpp" )
  create_single_source_cgal_program( "test_box_grid.cpp" )

-  if( TBB_FOUND )
-    CGAL_target_use_TBB( test_box_grid )
+  if(TARGET CGAL::TBB_support)
+    target_link_libraries(test_box_grid PUBLIC CGAL::TBB_support)
  else()
    message( STATUS "NOTICE: Intel TBB was not found. Sequential code will be used." )
  endif()
 else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")
 endif()
-
--- a/CGAL_ipelets/demo/CGAL_ipelets/CMakeLists.txt
+++ b/CGAL_ipelets/demo/CGAL_ipelets/CMakeLists.txt
@ -27,7 +27,8 @@ if ( CGAL_FOUND )
  include(${CGAL_USE_FILE})

  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (NOT EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (NOT TARGET CGAL::Eigen_support)
    message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
    return()
  endif()
@ -140,8 +141,7 @@ if ( CGAL_FOUND )
    foreach(IPELET ${CGAL_IPELETS})
      add_library(CGAL_${IPELET} MODULE ${IPELET}.cpp)
      add_to_cached_list(CGAL_EXECUTABLE_TARGETS CGAL_${IPELET})
-      target_link_libraries(CGAL_${IPELET} PRIVATE CGAL::CGAL ${IPE_LIBRARIES})
-      CGAL_target_use_Eigen(CGAL_${IPELET})
+      target_link_libraries(CGAL_${IPELET} PRIVATE CGAL::CGAL CGAL::Eigen_support ${IPE_LIBRARIES})
      if ( IPELET_INSTALL_DIR )
        install(TARGETS CGAL_${IPELET} DESTINATION ${IPELET_INSTALL_DIR})
        if (WITH_IPE_7)
@ -151,14 +151,12 @@ if ( CGAL_FOUND )
      cgal_add_compilation_test(CGAL_${IPELET})
    endforeach(IPELET)
    if(CGAL_Core_FOUND)
-      target_link_libraries(CGAL_cone_spanners PRIVATE CGAL::CGAL_Core)
-      CGAL_target_use_Eigen(CGAL_cone_spanners)
+      target_link_libraries(CGAL_cone_spanners PRIVATE CGAL::CGAL_Core CGAL::Eigen_support)
    endif()
    #example in doc not installed
    add_library(simple_triangulation MODULE simple_triangulation.cpp)
    add_to_cached_list(CGAL_EXECUTABLE_TARGETS simple_triangulation)
-    target_link_libraries(simple_triangulation ${IPE_LIBRARIES})
-    CGAL_target_use_Eigen(simple_triangulation)
+    target_link_libraries(simple_triangulation CGAL::Eigen_support ${IPE_LIBRARIES})
    cgal_add_compilation_test(simple_triangulation)

  else()
--- a/Classification/examples/Classification/CMakeLists.txt
+++ b/Classification/examples/Classification/CMakeLists.txt
@ -24,32 +24,39 @@ endif()
 set(Classification_dependencies_met TRUE)

 find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
-if (NOT Boost_SERIALIZATION_FOUND)
+include(CGAL_Boost_serialization_support)
+include(CGAL_Boost_iostreams_support)
+
+if (NOT TARGET CGAL::Boost_serialization_support)
  message(STATUS "NOTICE: This project requires Boost Serialization, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()
-if (NOT Boost_IOSTREAMS_FOUND)
+if (NOT TARGET CGAL::Boost_iostreams_support)
  message(STATUS "NOTICE: This project requires Boost IO Streams, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()

 find_package(OpenCV QUIET COMPONENTS core ml) # Need core + machine learning
-if (NOT OpenCV_FOUND)
+include(CGAL_OpenCV_support)
+if (NOT TARGET CGAL::OpenCV_support)
  message(STATUS "NOTICE: OpenCV was not found. OpenCV random forest predicate for classification won't be available.")
 endif()

 find_package(TensorFlow QUIET)
-if (NOT TensorFlow_FOUND)
+include(CGAL_TensorFlow_support)
+if (NOT TARGET CGAL::TensorFlow_support)
  message(STATUS "NOTICE: TensorFlow was not found. TensorFlow neural network predicate for classification won't be available.")
 endif()

 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()

 find_package(TBB QUIET)
+include(CGAL_TBB_support)

 if (NOT Classification_dependencies_met)
  return()
@ -63,14 +70,14 @@ create_single_source_cgal_program( "example_mesh_classification.cpp" )
 create_single_source_cgal_program( "example_cluster_classification.cpp" )
 create_single_source_cgal_program( "gis_tutorial_example.cpp" )

-if (OpenCV_FOUND)
+if (TARGET CGAL::OpenCV_support)
  create_single_source_cgal_program( "example_opencv_random_forest.cpp" )
-  CGAL_target_use_OpenCV(example_opencv_random_forest)
+  target_link_libraries(example_opencv_random_forest PUBLIC CGAL::OpenCV_support)
 endif()

-if (TensorFlow_FOUND)
+if (TARGET CGAL::TensorFlow_support)
  create_single_source_cgal_program( "example_tensorflow_neural_network.cpp" )
-  CGAL_target_use_TensorFlow(example_tensorflow_neural_network)
+  target_link_libraries(example_opencv_random_forest PUBLIC CGAL::TensorFlow_support)
 endif()

 foreach(target
@ -84,11 +91,12 @@ foreach(target
    example_tensorflow_neural_network
    gis_tutorial_example)
  if(TARGET ${target})
-    CGAL_target_use_Eigen(${target})
-    CGAL_target_use_Boost_IOStreams(${target})
-    CGAL_target_use_Boost_Serialization(${target})
-    if(TBB_FOUND)
-      CGAL_target_use_TBB(${target})
+    target_link_libraries(${target} PUBLIC
+      CGAL::Eigen_support
+      CGAL::Boost_iostreams_support
+      CGAL::Boost_serialization_support)
+    if(TARGET CGAL::TBB_support)
+      target_link_libraries(${target} PUBLIC CGAL::TBB_support)
    endif()
  endif()
 endforeach()
--- a/Classification/test/Classification/CMakeLists.txt
+++ b/Classification/test/Classification/CMakeLists.txt
@ -24,22 +24,27 @@ endif()
 set(Classification_dependencies_met TRUE)

 find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
-if (NOT Boost_SERIALIZATION_FOUND)
+include(CGAL_Boost_serialization_support)
+include(CGAL_Boost_iostreams_support)
+
+if (NOT TARGET CGAL::Boost_serialization_support)
  message(STATUS "NOTICE: This project requires Boost Serialization, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()
-if (NOT Boost_IOSTREAMS_FOUND)
+if (NOT TARGET CGAL::Boost_iostreams_support)
  message(STATUS "NOTICE: This project requires Boost IO Streams, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()

 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  set(Classification_dependencies_met FALSE)
 endif()

 find_package(TBB QUIET)
+include(CGAL_TBB_support)

 if (NOT Classification_dependencies_met)
  return()
@ -49,11 +54,11 @@ create_single_source_cgal_program( "test_classification_point_set.cpp" )
 create_single_source_cgal_program( "test_classification_io.cpp" )

 foreach(target test_classification_point_set test_classification_io)
-  CGAL_target_use_Eigen(${target})
-  CGAL_target_use_Boost_IOStreams(${target})
-  CGAL_target_use_Boost_Serialization(${target})
-  if(TBB_FOUND)
-    CGAL_target_use_TBB(${target})
+  target_link_libraries(${target} PUBLIC
+    CGAL::Eigen_support
+    CGAL::Boost_iostreams_support
+    CGAL::Boost_serialization_support)
+  if(TARGET CGAL::TBB_support)
+    target_link_libraries(${target} PUBLIC CGAL::TBB_support)
  endif()
 endforeach()
-
--- a/Documentation/doc/Documentation/Developer_manual/create_and_use_a_cmakelist.txt
+++ b/Documentation/doc/Documentation/Developer_manual/create_and_use_a_cmakelist.txt
@ -18,7 +18,7 @@ find_package(CGAL REQUIRED COMPONENTS Core)
 target_link_libraries(my_executable CGAL::CGAL CGAL::CGAL_Core)
 \endcode

-There are also some cmake macros to link with \cgal dependencies that can be found in
+There are also imported targets to link with \cgal dependencies that can be found in
 the section \subpage thirdparty.

 \note The \cgal targets define the following compiler flags:
--- a/Documentation/doc/Documentation/Third_party.txt
+++ b/Documentation/doc/Documentation/Third_party.txt
@ -132,8 +132,8 @@ sparse linear solvers and singular value decompositions.  A package
 dependency over \sc{Eigen} is marked on the <a
 href="https://doc.cgal.org/latest/Manual/packages.html">Package
 Overview</a> page. In order to use Eigen in \cgal programs, the
-provided CMake function `CGAL_target_use_Eigen(<target>)` should be
-used.
+executables should be linked with the CMake imported target
+`CGAL::Eigen_support` provided in `CGAL_Eigen_support.cmake`.

 The \sc{Eigen} web site is <A HREF="http://eigen.tuxfamily.org/index.php?title=Main_Page">`http://eigen.tuxfamily.org`</A>.

@ -142,8 +142,7 @@ The \sc{Eigen} web site is <A HREF="http://eigen.tuxfamily.org/index.php?title=M
 \sc{OpenGR} is a set C++ libraries for 3D Global Registration released under the terms of the APACHE V2 licence.

 \cgal provides wrappers for the Super4PCS algorithm of \sc{OpenGR} in the \ref PkgPointSetProcessing3Ref
-packages. In order to use \sc{OpenGR} in \cgal programs, the provided CMake function
-`CGAL_target_use_OpenGR(<target>)` should be used.
+packages. In order to use \sc{OpenGR} in \cgal programs, the executables should be linked with the CMake imported target `CGAL::OpenGR_support` provided in `CGAL_OpenGR_support.cmake`.

 The \sc{OpenGR} web site is <A HREF="https://github.com/STORM-IRIT/OpenGR">`https://github.com/STORM-IRIT/OpenGR`</A>.

@ -152,8 +151,10 @@ The \sc{OpenGR} web site is <A HREF="https://github.com/STORM-IRIT/OpenGR">`http
 \sc{libpointmatcher} is a modular library implementing the Iterative Closest Point (ICP) algorithm for aligning point clouds, released under a permissive BSD license.

 \cgal provides wrappers for the ICP algorithm of \sc{libpointmatcher} in the \ref PkgPointSetProcessing3Ref
-packages. In order to use \sc{libpointmatcher} in \cgal programs, the provided CMake function
-`CGAL_target_use_pointmatcher(<target>)` should be used.
+packages. In order to use \sc{libpointmatcher} in \cgal programs, the
+executables should be linked with the CMake imported target
+`CGAL::pointmatcher_support` provided in
+`CGAL_pointmatcher_support.cmake`.

 The \sc{libpointmatcher} web site is <A
 HREF="https://github.com/ethz-asl/libpointmatcher">`https://github.com/ethz-asl/libpointmatcher`</A>.
@ -220,8 +221,9 @@ It can be downloaded from <A HREF="http://esbtl.sourceforge.net/">`http://esbtl.
 programs that take advantage of multi-core processors.

 In \cgal, \sc{Tbb} is used by the packages that offer parallel
-code. In order to use \sc{Tbb} in \cgal programs, the provided CMake
-function `CGAL_target_use_TBB(<target>)` should be used.
+code. In order to use \sc{Tbb} in \cgal programs, the executables
+should be linked with the CMake imported target `CGAL::TBB_support`
+provided in `CGAL_TBB_support.cmake`.

 The \sc{Tbb} web site is <A HREF="https://www.threadingbuildingblocks.org">`https://www.threadingbuildingblocks.org`</A>.

@ -231,9 +233,10 @@ The \sc{Tbb} web site is <A HREF="https://www.threadingbuildingblocks.org">`http
 the LAS format (or the compressed LAZ format).

 In \cgal, \sc{LASlib} is used to provide input and output functions in
-the \ref PkgPointSetProcessing3 package. In order to use \sc{LASlib} in
-\cgal programs, the provided CMake function
-`CGAL_target_use_LASLIB(<target>)` should be used.
+the \ref PkgPointSetProcessing3 package. In order to use \sc{LASlib}
+in \cgal programs, the executables should be linked with the CMake
+imported target `CGAL::LASLIB_support` provided in
+`CGAL_LASLIB_support.cmake`.

 The \sc{LASlib} web site is <a
 href="https://rapidlasso.com/lastools/">`https://rapidlasso.com/lastools/`</a>. \sc{LASlib}
@ -247,8 +250,9 @@ CMake based install procedure</a>.
 vision, computer graphics and machine learning.

 In \cgal, \sc{OpenCV} is used by the \ref PkgClassification
-package. In order to use \sc{OpenCV} in \cgal programs, the provided
-CMake function `CGAL_target_use_OpenCV(<target>)` should be used.
+package. In order to use \sc{OpenCV} in \cgal programs, the
+executables should be linked with the CMake imported target
+`CGAL::OpenCV_support` provided in `CGAL_OpenCV_support.cmake`.

 The \sc{OpenCV} web site is <A HREF="https://opencv.org/">`https://opencv.org/`</A>.

@ -266,8 +270,10 @@ enable and compile the following targets:
 - `tensorflow_BUILD_PYTHON_BINDINGS`
 - `tensorflow_BUILD_SHARED_LIB`.

-In order to use \sc{TensorFlow} in \cgal programs, the provided CMake
-function `CGAL_target_use_TensorFlow(<target>)` should be used.
+In order to use \sc{TensorFlow} in \cgal programs, the executables
+should be linked with the CMake imported target
+`CGAL::TensorFlow_support` provided in
+`CGAL_TensorFlow_support.cmake`.

 The \sc{TensorFlow} web site is <A HREF="https://www.tensorflow.org/">`https://www.tensorflow.org/`</A>.

@ -310,8 +316,9 @@ for more information.

 In \cgal, \sc{GLPK} provides an optional linear integer program solver
 in the \ref PkgPolygonalSurfaceReconstruction package. In order to use
-\sc{GLPK} in \cgal programs, the provided CMake function
-`CGAL_target_use_GLPK(<target>)` should be used.
+\sc{GLPK} in \cgal programs, the executables should be linked with the
+CMake imported target `CGAL::GLPK_support` provided in
+`CGAL_GLPK_support.cmake`.

 The \sc{GLPK} web site is <A HREF="https://www.gnu.org/software/glpk/">`https://www.gnu.org/software/glpk/`</A>.

@ -321,8 +328,9 @@ The \sc{GLPK} web site is <A HREF="https://www.gnu.org/software/glpk/">`https://

 In \cgal, \sc{SCIP} provides an optional linear integer program solver
 in the \ref PkgPolygonalSurfaceReconstruction package. In order to use
-\sc{SCIP} in \cgal programs, the provided CMake function
-`CGAL_target_use_SCIP(<target>)` should be used.
+\sc{SCIP} in \cgal programs, the executables should be linked with the
+CMake imported target `CGAL::SCIP_support` provided in
+`CGAL_SCIP_support.cmake`.

 The \sc{SCIP} web site is <A HREF="http://scip.zib.de/">`http://scip.zib.de/`</A>.

--- a/Documentation/doc/Documentation/Usage.txt
+++ b/Documentation/doc/Documentation/Usage.txt
@ -60,12 +60,6 @@ On most operating systems, package managers offer \cgal and its essential third
 On macOS, we recommend using of <a href="https://brew.sh/">Homebrew</a> in the following way:

    brew install cgal
-    brew install cgal-qt5   #(only for GUI)
-
-You should check that cgal and cgal-qt5 are correctly "linked", especially when upgrading from an old version. If not, run the following command:
-
-    brew link cgal
-    brew link cgal-qt5  #(if you installed it)

 On Linux distributions such as `Debian`/`Ubuntu`/`Mint`, use `apt-get` in the following way:

--- a/Documentation/doc/resources/1.8.13/menu_version.js
+++ b/Documentation/doc/resources/1.8.13/menu_version.js
@ -3,10 +3,11 @@

  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
  var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-dev'
+  var current_version_local = '5.1-beta1'
  var all_versions = [
      'master',
      'latest',
+      '5.1-beta1',
      '5.0.2',
      '4.14.3',
      '4.13.2',
@ -23,6 +24,15 @@
  ];

  function build_select(current_version) {
+    if( current_version == 'master') {
+      let top_elt = document.getElementById("top");
+
+      let first_element = top_elt.childNodes[0];
+      let new_div = document.createElement("p");
+      new_div.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/master">master</a> development branch of CGAL. It might diverge from the official releases.';
+      new_div.style.cssText = "background-color: #ff9800; margin: 1ex auto 1ex 1em; padding: 1ex; border-radius: 1ex; display: inline-block;"
+      let OK = top_elt.insertBefore(new_div, first_element);
+    }
    var buf = ['<select>'];
    $.each(all_versions, function(id) {
      var version = all_versions[id];
@ -44,7 +54,7 @@
  }

  function patch_url(url, new_version) {
-    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){  
+    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){
      return url.replace(url_re, 'doc.cgal.org/' + new_version + '/');
    }
    else{
@ -65,7 +75,7 @@
      var motherNode=$("#back-nav ul")[0];
      var node = document.createElement("LI");
      var spanNode = document.createElement("SPAN");
-      var titleNode =document.createTextNode("CGAL Version: "); 
+      var titleNode =document.createTextNode("CGAL Version: ");
      var textNode = document.createTextNode("x.y");
      spanNode.setAttribute("class", "version_menu");
      spanNode.appendChild(textNode);
@ -90,4 +100,4 @@
        }
     }
  });
-})(); 
+})();
--- a/Documentation/doc/resources/1.8.14/menu_version.js
+++ b/Documentation/doc/resources/1.8.14/menu_version.js
@ -3,10 +3,11 @@

  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
  var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-dev'
+  var current_version_local = '5.1-beta1'
  var all_versions = [
      'master',
      'latest',
+      '5.1-beta1',
      '5.0.2',
      '4.14.3',
      '4.13.2',
@ -23,6 +24,15 @@
  ];

  function build_select(current_version) {
+    if( current_version == 'master') {
+      let top_elt = document.getElementById("top");
+
+      let first_element = top_elt.childNodes[0];
+      let new_div = document.createElement("p");
+      new_div.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/master">master</a> development branch of CGAL. It might diverge from the official releases.';
+      new_div.style.cssText = "background-color: #ff9800; margin: 1ex auto 1ex 1em; padding: 1ex; border-radius: 1ex; display: inline-block;"
+      let OK = top_elt.insertBefore(new_div, first_element);
+    }
    var buf = ['<select>'];
    $.each(all_versions, function(id) {
      var version = all_versions[id];
@ -44,7 +54,7 @@
  }

  function patch_url(url, new_version) {
-    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){  
+    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){
      return url.replace(url_re, 'doc.cgal.org/' + new_version + '/');
    }
    else{
@ -65,7 +75,7 @@
      var motherNode=$("#back-nav ul")[0];
      var node = document.createElement("LI");
      var spanNode = document.createElement("SPAN");
-      var titleNode =document.createTextNode("CGAL Version: "); 
+      var titleNode =document.createTextNode("CGAL Version: ");
      var textNode = document.createTextNode("x.y");
      spanNode.setAttribute("class", "version_menu");
      spanNode.appendChild(textNode);
@ -90,4 +100,4 @@
        }
     }
  });
-})(); 
+})();
--- a/Documentation/doc/resources/1.8.4/menu_version.js
+++ b/Documentation/doc/resources/1.8.4/menu_version.js
@ -3,10 +3,11 @@

  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
  var url_local =  /.*\/doc_output\//;
-  var current_version_local = '5.1-dev'
+  var current_version_local = '5.1-beta1'
  var all_versions = [
      'master',
      'latest',
+      '5.1-beta1',
      '5.0.2',
      '4.14.3',
      '4.13.2',
@ -23,6 +24,15 @@
  ];

  function build_select(current_version) {
+    if( current_version == 'master') {
+      let top_elt = document.getElementById("top");
+
+      let first_element = top_elt.childNodes[0];
+      let new_div = document.createElement("p");
+      new_div.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/master">master</a> development branch of CGAL. It might diverge from the official releases.';
+      new_div.style.cssText = "background-color: #ff9800; margin: 1ex auto 1ex 1em; padding: 1ex; border-radius: 1ex; display: inline-block;"
+      let OK = top_elt.insertBefore(new_div, first_element);
+    }
    var buf = ['<select>'];
    $.each(all_versions, function(id) {
      var version = all_versions[id];
@ -44,7 +54,7 @@
  }

  function patch_url(url, new_version) {
-    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){  
+    if(url.includes("doc.cgal.org")||url.includes("cgal.geometryfactory.com")){
      return url.replace(url_re, 'doc.cgal.org/' + new_version + '/');
    }
    else{
@ -65,7 +75,7 @@
      var motherNode=$("#back-nav ul")[0];
      var node = document.createElement("LI");
      var spanNode = document.createElement("SPAN");
-      var titleNode =document.createTextNode("CGAL Version: "); 
+      var titleNode =document.createTextNode("CGAL Version: ");
      var textNode = document.createTextNode("x.y");
      spanNode.setAttribute("class", "version_menu");
      spanNode.appendChild(textNode);
@ -90,4 +100,4 @@
        }
     }
  });
-})(); 
+})();
--- a/Generator/examples/Generator/CMakeLists.txt
+++ b/Generator/examples/Generator/CMakeLists.txt
@ -12,17 +12,18 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
    if(NOT (${cppfile} STREQUAL "random_points_in_tetrahedral_mesh_3.cpp")
        OR NOT (${cppfile} STREQUAL "random_points_on_tetrahedral_mesh_3.cpp")
-        OR EIGEN3_FOUND)
+        OR TARGET CGAL::Eigen_support)
      create_single_source_cgal_program( "${cppfile}" )
-      if (EIGEN3_FOUND)
+      if (TARGET CGAL::Eigen_support)
        get_filename_component(target ${cppfile} NAME_WE)
-        CGAL_target_use_Eigen(${target})
+        target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
      endif()
    endif()
  endforeach()
@ -32,4 +33,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Generator/test/Generator/CMakeLists.txt
+++ b/Generator/test/Generator/CMakeLists.txt
@ -12,15 +12,16 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
-    if(NOT (${cppfile} STREQUAL "generic_random_test.cpp") OR EIGEN3_FOUND)
+    if(NOT (${cppfile} STREQUAL "generic_random_test.cpp") OR TARGET CGAL::Eigen_support)
      create_single_source_cgal_program( "${cppfile}" )
-      if (EIGEN3_FOUND)
+      if (TARGET CGAL::Eigen_support)
        get_filename_component(target ${cppfile} NAME_WE)
-        CGAL_target_use_Eigen(${target})
+        target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
      endif()
    endif()
  endforeach()
@ -30,4 +31,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/GraphicsView/demo/Polygon/CMakeLists.txt
+++ b/GraphicsView/demo/Polygon/CMakeLists.txt
@ -16,7 +16,8 @@ endif()
 find_package(CGAL COMPONENTS Qt5 Core)

 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
  return()
 endif()
@ -46,12 +47,11 @@ if ( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND )

  # The executable itself.
  add_executable  ( Polygon_2 Polygon_2.cpp  ${DT_UI_FILES} ${DT_RESOURCE_FILES} ${CGAL_Qt5_RESOURCE_FILES} ${CGAL_Qt5_MOC_FILES} )
-  CGAL_target_use_Eigen(Polygon_2)

  add_to_cached_list( CGAL_EXECUTABLE_TARGETS Polygon_2 )

  target_link_libraries( Polygon_2 PRIVATE
-    CGAL::CGAL CGAL::CGAL_Qt5 Qt5::Gui )
+    CGAL::CGAL CGAL::CGAL_Qt5 CGAL::Eigen_support Qt5::Gui )

  include(${CGAL_MODULES_DIR}/CGAL_add_test.cmake)
  cgal_add_compilation_test(Polygon_2)
--- a/Heat_method_3/examples/Heat_method_3/CMakeLists.txt
+++ b/Heat_method_3/examples/Heat_method_3/CMakeLists.txt
@ -33,8 +33,9 @@ endif()


 find_package(Eigen3 3.3.0)
+include(CGAL_Eigen_support)

-if (NOT EIGEN3_FOUND)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library (3.3 or greater), and will not be compiled.")
  return()
 endif()
@ -51,10 +52,10 @@ include_directories( BEFORE include )
 include( CGAL_CreateSingleSourceCGALProgram )

 create_single_source_cgal_program( "heat_method.cpp" )
-CGAL_target_use_Eigen(heat_method)
+target_link_libraries(heat_method PUBLIC CGAL::Eigen_support)
 create_single_source_cgal_program( "heat_method_polyhedron.cpp" )
-CGAL_target_use_Eigen(heat_method_polyhedron)
+target_link_libraries(heat_method_polyhedron PUBLIC CGAL::Eigen_support)
 create_single_source_cgal_program( "heat_method_surface_mesh.cpp" )
-CGAL_target_use_Eigen(heat_method_surface_mesh)
+target_link_libraries(heat_method_surface_mesh PUBLIC CGAL::Eigen_support)
 create_single_source_cgal_program( "heat_method_surface_mesh_direct.cpp" )
-CGAL_target_use_Eigen(heat_method_surface_mesh_direct)
+target_link_libraries(heat_method_surface_mesh_direct PUBLIC CGAL::Eigen_support)
--- a/Heat_method_3/test/Heat_method_3/CMakeLists.txt
+++ b/Heat_method_3/test/Heat_method_3/CMakeLists.txt
@ -33,8 +33,9 @@ endif()


 find_package(Eigen3 3.3.0)
+include(CGAL_Eigen_support)

-if (NOT EIGEN3_FOUND)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the  Eigen library (3.3 or greater), and will not be compiled.")
  return()
 endif()
@ -49,8 +50,8 @@ include_directories( BEFORE include )
 include( CGAL_CreateSingleSourceCGALProgram )

 create_single_source_cgal_program( "heat_method_concept.cpp" )
-CGAL_target_use_Eigen(heat_method_concept)
+target_link_libraries(heat_method_concept PUBLIC CGAL::Eigen_support)
 create_single_source_cgal_program( "heat_method_surface_mesh_test.cpp" )
-CGAL_target_use_Eigen(heat_method_surface_mesh_test)
+target_link_libraries(heat_method_surface_mesh_test PUBLIC CGAL::Eigen_support)
 create_single_source_cgal_program( "heat_method_surface_mesh_direct_test.cpp" )
-CGAL_target_use_Eigen(heat_method_surface_mesh_direct_test)
+target_link_libraries(heat_method_surface_mesh_direct_test PUBLIC CGAL::Eigen_support)
--- a/Installation/CHANGES.md
+++ b/Installation/CHANGES.md
@ -1,209 +1,252 @@
 Release History
 ===============

-[Release 5.1] (https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1)
-
-### 3D Fast Intersection and Distance Computation
- The introduction of the usage of the search tree by default for all distance queries
-  in the 5.0 release was actually not lazy contrary to what was announced. The behavior of the
-  search tree is now the following: it will be used except if an explicit call to `do_not_accelerate_distance_queries()`
-  is made. The construction of the search tree (once insertion of primitives is done) will be triggered by the first
-  distance query or by an explicit call to `accelerate_distance_queries()`.
- **Breaking change**: `accelerate_distance_queries()` and `do_not_accelerate_distance_queries()` are not longer `const` functions.
-
-### Optimal Bounding Box (new package)
- This package implements an optimization algorithm that aims to 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.
-
-### 2D and 3D Linear Geometry Kernel
- - Add `CompareSignedDistanceToLine_2` in the 2D/3D Kernel concept to compare
-   the signed distance of two points to a line, or the line passing through two given points.
-   Corresponding functors in the model (`Compare_signed_distance_to_line_2`) are also added.
-
-### Point Set Processing
- - Add a function `CGAL::cluster_point_set()` that segments a point
-   cloud into connected components based on a distance threshold.
- - **Breaking change:** `CGAL::remove_outliers()` has been
-   parallelized and thus has a new template parameter
-   `ConcurrencyTag`. To update your code simply add as first template
-   parameter `CGAL::Sequential_tag` or `CGAL::Parallel_tag` when
-   calling this function.
-
-### 2D Triangulations
- - Add function `split_subconstraint_graph_into_constraints()` to
-   `Constrained_triangulation_plus_2` to initialize the constraints
-   from a soup of disconnected segments that should first be split
-   into polylines.
-
-### 3D Convex Hulls
- -   The long-deprecated function `CGAL::convex_hull_3_to_polyhedron_3()` has been removed.
-     The function `CGAL::convex_hull_3_to_face_graph()` should be used instead.
-
-### dD Spatial Searching
-
- - 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).
-
-### Surface Mesh
-
- - **Breaking change**: The function `CGAL::Surface_mesh::clear()` now removes all non-default properties instead of just emptying them. 
-
-Release 5.0
+[Release 5.1](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1)
 -----------

-Release date: June 2020
+Release date: July 2020

-### 2D Arrangement on Surface
- -   Changed intersection return type from legacy `CGAL::Object` to modern
-     `boost::variant` in all traits concepts and models.
-     As there is an implicit conversion from `boost::variant` to `CGAL::Object`, the
+### [Tetrahedral Remeshing](https://doc.cgal.org/5.1/Manual/packages.html#PkgTetrahedralRemeshing) (new package)
+
+-   This package implements a tetrahedral isotropic remeshing algorithm,
+    that improves the quality of tetrahedra in terms of dihedral angles,
+    while targeting a given edge length.
+
+### [Surface Mesh Topology](https://doc.cgal.org/5.1/Manual/packages.html#PkgSurfaceMeshTopologySummary) (new package)
+
+-   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](https://www.cgal.org/2020/05/08/Surface_mesh_topology/).
+
+### [Optimal Bounding Box](https://doc.cgal.org/5.1/Manual/packages.html#PkgOptimalBoundingBox) (new package)
+
+-   This package implements an optimization algorithm that aims to 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/).
+
+### [Tutorials](https://doc.cgal.org/5.1/Manual/tutorials.html)
+
+-   Two new, detailed tutorials have been added:
+    - [Surface Reconstruction from Point Clouds](https://doc.cgal.org/5.1/Manual/tuto_reconstruction.html),
+      which goes over a typical full processing pipeline in a CGAL environment.
+    - [Geographic Information Systems (GIS)](https://doc.cgal.org/5.1/Manual/tuto_gis.html),
+      which demonstrates usage of CGAL data structures and algorithms in the context of a typical GIS application.
+
+    Both tutorials provide complete code.
+
+### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.1/Manual/packages.html#PkgKernel23)
+
+-   Added the functor [`CompareSignedDistanceToLine_2`](https://doc.cgal.org/5.1/Kernel_23/classKernel_1_1CompareSignedDistanceToLine__2.html)
+    to the 2D/3D [`Kernel`](https://doc.cgal.org/5.1/Kernel_23/classKernel.html) concept to compare
+    the signed distance of two points to a line, or the line passing through two given points.
+    Corresponding functors in the model ([`Compare_signed_distance_to_line_2`](https://doc.cgal.org/5.1/Kernel_23/classKernel.html#a066d07dd592ac36ba7ee90988abd349f)) are also added.
+
+### [dD Geometry Kernel](https://doc.cgal.org/5.1/Manual/packages.html#PkgKernelD)
+
+-   The kernels [`Epick_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epick__d.html)
+    and [`Epeck_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epeck__d.html) gain two new functors:
+    [`Power_side_of_bounded_power_sphere_d`](https://doc.cgal.org/5.1/Kernel_d/classCGAL_1_1Epeck__d_1_1Power__side__of__bounded__power__sphere__d.html)
+    and [`Compute_squared_radius_smallest_orthogonal_sphere_d`](https://doc.cgal.org/5.1/Kernel_d/classCGAL_1_1Epeck__d_1_1Compute__squared__radius__smallest__orthogonal__sphere__d.html).
+    Those are essential for the computation of weighted alpha-complexes.
+
+### [Surface Mesh](https://doc.cgal.org/5.1/Manual/packages.html#PkgSurfaceMesh)
+
+-   **Breaking change**: The function [`CGAL::Surface_mesh::clear()`](https://doc.cgal.org/5.1/Surface_mesh/classCGAL_1_1Surface__mesh.html#a247d4ad3e6b106ae22e5306203812642)
+    now removes all non-default properties instead of just emptying them.
+
+### [CGAL and the Boost Graph Library (BGL)](https://doc.cgal.org/5.1/Manual/packages.html#PkgBGL)
+
+-   Added the function [`CGAL::alpha_expansion_graphcut()`](https://doc.cgal.org/5.1/BGL/group__PkgBGLPartition.html#ga79c3f58b577af51d1140450729d38f22),
+    which regularizes a multi-label partition over a user-defined graph.
+-   Added the function [`CGAL::regularize_face_selection_borders()`](https://doc.cgal.org/5.1/BGL/group__PkgBGLSelectionFct.html#gac71322b0cc7d7d59447531d5e5e345b6),
+    which uses this alpha expansion graphcut to regularize the borders of a selected faces on a triangle mesh.
+-   Added the function [`CGAL::set_triangulation_ids()`](https://doc.cgal.org/5.1/BGL/group__BGLGraphExternalIndices.html#ga1a22cf8bdde32fcdf1a4a78966eed630),
+    which must be used to initialize vertex, edge, and face indices of a triangulation meant to be used with BGL algorithms.
+
+### [3D Fast Intersection and Distance Computation](https://doc.cgal.org/5.1/Manual/packages.html#PkgAABBTree)
+
+-   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()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#abde62f52ccdf411847151aa5000ba4a4)
+    before the first distance query, and the tree can be built at any moment by calling
+    [`CGAL::AABB_tree::accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#a5d3877d3f2afbd09341eb4b8c230080b).
+-   **Breaking change**: [`CGAL::AABB_tree::accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#a5d3877d3f2afbd09341eb4b8c230080b)
+    and [`CGAL::AABB_tree::do_not_accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#abde62f52ccdf411847151aa5000ba4a4)
+    are no longer `const` functions.
+
+### [2D Arrangements](https://doc.cgal.org/5.1/Manual/packages.html#PkgArrangementOnSurface2)
+
+ -   Changed intersection return type from legacy [`CGAL::Object`](https://doc.cgal.org/5.1/STL_Extension/classCGAL_1_1Object.html)
+     to modern `boost::variant` in all traits concepts and models.
+     As there exists an implicit conversion from `boost::variant` to `CGAL::Object`, the
     new code is backward compatible. However, it is recommended that all calls
     to the intersection functions are fixed to use the new return type.

-### 2D Regularized Boolean Operations
- -   Changed intersection return type from legacy `CGAL::Object` to modern
-     `boost::variant` in the concept `ArrDirectionalTraits::Intersect_2` and
-     its models..
+### [2D Regularized Boolean Set-Operations](https://doc.cgal.org/5.1/Manual/packages.html#PkgBooleanSetOperations2)

-### 2D Minkowski sums
- -   Changed intersection return type from legacy `CGAL::Object` to modern
-     `boost::variant` in the (internally used) model `Arr_labeled_traits_2`.
+ -   Changed intersection return type from legacy [`CGAL::Object`](https://doc.cgal.org/5.1/STL_Extension/classCGAL_1_1Object.html)
+     to modern `boost::variant` in the concept [`ArrDirectionalTraits::Intersect_2`](https://doc.cgal.org/5.1/Boolean_set_operations_2/namespaceArrDirectionalTraits.html)
+     and its models.

-### Surface Mesh Topology (new package)
+### [2D Minkowski Sums](https://doc.cgal.org/5.1/Manual/packages.html#PkgMinkowskiSum2)

- -   This package allows to compute some topological invariants of
-     surfaces:
-     -  test if two (closed) curves on a combinatorial surface are homotopic. The user 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.
+ -   Changed intersection return type from legacy [`CGAL::Object`](https://doc.cgal.org/5.1/STL_Extension/classCGAL_1_1Object.html)
+     to modern `boost::variant` in the (internally used) model `Arr_labeled_traits_2`.

-### 3D Fast Intersection and Distance Computation
-   **Breaking change**: the internal search tree is now lazily constructed. To disable it, one must call
-    the new function `do_not_accelerate_distance_queries()` before the first distance query.
+### [dD Spatial Searching](https://doc.cgal.org/5.1/Manual/packages.html#PkgSpatialSearchingD)

-### Intersecting Sequences of dD Iso-oriented Boxes 
- -   Added parallel versions of the functions `CGAL::box_intersection_d()` and `CGAL::box_self_intersection_d()`.
+-   The kd-tree can now be built in parallel: [`CGAL::Kd_tree::build()`](https://doc.cgal.org/5.1/Spatial_searching/classCGAL_1_1Kd__tree.html#a8559dbe4d7136fbc8ebab5ee290cbe06)
+    is given an optional template parameter `ConcurrencyTag` (default
+    value remains [`CGAL::Sequential_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Sequential__tag.html)
+    for backward compatibility).
+-   Improved the performance of the kd-tree in some cases:
+    - Not storing the points coordinates inside the tree usually
+      generates a lot of cache misses, leading to non-optimal
+      performance. This is the case for example
+      when indices are stored inside the tree, or to a lesser extent when the points
+      coordinates are stored in a dynamically allocated array (e.g., [`Epick_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epick__d.html)
+      with dynamic dimension) &mdash; we says "to a lesser extent" because the points
+      are re-created by the kd-tree in a cache-friendly order after its construction,
+      so the coordinates are more likely to be stored in a near-optimal order
+      on the heap.
+      In these cases, the new `EnablePointsCache` template parameter of the
+      [`CGAL::Kd_tree`](https://doc.cgal.org/5.1/Spatial_searching/classCGAL_1_1Kd__tree.html)
+      class can be set to `CGAL::Tag_true`. The points coordinates
+      will then be cached in an optimal way. This will increase memory
+      consumption but provides better search performance. See the updated
+      [`GeneralDistance`](https://doc.cgal.org/5.1/Spatial_searching/classGeneralDistance.html)
+      and [`FuzzyQueryItem`](https://doc.cgal.org/5.1/Spatial_searching/classFuzzyQueryItem.html)
+      concepts for additional requirements when using such a cache.
+    - In most cases (e.g., Euclidean distance), the distance computation
+      algorithm knows before its end that the distance will be greater
+      than or equal to some given value. This is used in the (orthogonal)
+      k-NN search to interrupt some distance computations before its end,
+      saving precious milliseconds, in particular in medium-to-high dimension.

-### CGAL and the Boost Graph Library (BGL)
- -   Introduced the function `set_triangulation_ids(Triangulation& tr)` which must be used to initialize vertex,
-     edge, and face indices of a triangulation meant to be used with BGL algorithms.
- -   Added function `alpha_expansion_graphcut()` which regularizes a
-     multi-label partition over a user-defined graph.
- -   Added function `regularize_face_selection_borders()` which uses
-     this alpha expansion graphcut to regularize the borders of a
-     selected faces on a triangle mesh.
+### [Intersecting Sequences of dD Iso-oriented Boxes](https://doc.cgal.org/5.1/Manual/packages.html#PkgBoxIntersectionD)

-### Polygon Mesh Processing
+-   Added parallel versions of the functions
+    [`CGAL::box_intersection_d()`](https://doc.cgal.org/5.1/Box_intersection_d/group__PkgBoxIntersectionD__box__intersection__d.html)
+    and [`CGAL::box_self_intersection_d()`](https://doc.cgal.org/5.1/Box_intersection_d/group__PkgBoxIntersectionD__box__self__intersection__d.html).

-   Introduced a new function, `CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`, 
+### [Spatial Sorting](https://doc.cgal.org/5.1/Manual/packages.html#PkgSpatialSorting)
+
+-   Added parallel versions of the functions
+    [`CGAL::hilbert_sort()`](https://doc.cgal.org/5.1/Spatial_sorting/group__PkgSpatialSortingFunctions.html#ga9da67204747ac19dff65f9c9ff2fca9e)
+    and [`CGAL::spatial_sort()`](https://doc.cgal.org/5.1/Spatial_sorting/group__PkgSpatialSortingFunctions.html#ga7c597c11a3b3859234ff68526cead84d)
+    in 2D and 3D when the median policy is used.
+    The parallel versions use up to four threads in 2D, and up to eight threads in 3D.
+
+### [3D Convex Hulls](https://doc.cgal.org/5.1/Manual/packages.html#PkgConvexHull3)
+
+-   A new overload for [`CGAL::convex_hull_3()`](https://doc.cgal.org/5.1/Convex_hull_3/group__PkgConvexHull3Functions.html#gaa02a3013808fc9a2e5e2f42b9fde8e30)
+    that takes a model of [`VertexListGraph`](https://doc.cgal.org/5.1/BGL/classVertexListGraph.html) has been added.
+-   The long-deprecated function `CGAL::convex_hull_3_to_polyhedron_3()` has been removed.
+    The function [`CGAL::convex_hull_3_to_face_graph()`](https://doc.cgal.org/5.1/Convex_hull_3/group__PkgConvexHull3Functions.html#ga2750f7f197588ed643679835c748c671)
+    should be used instead.
+
+### [Polygon Mesh Processing](https://doc.cgal.org/5.1/Manual/packages.html#PkgPolygonMeshProcessing)
+
+-   Added the function [`CGAL::Polygon_mesh_processing::volume_connected_component()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga133e58280959c152770525f27bb42b91),
+    which can be used to get information about the nesting of the connected components of a given triangle mesh and about
+    the volumes defined.
+-   Added the function [`CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#gac544fcaba1d59d330a3a1536caff392a),
    which can be used to remove connected components whose area or volume is under a certain threshold.
    Area and volume thresholds are either specified by the user or deduced from the bounding box of the mesh.
-   Added the function `CGAL::Polygon_mesh_processing::volume_connected_component()` that can be used to
-    get information about the nesting of the connected components of a given triangle mesh and about
-    the volumes defined.
-   Added a new named parameter for `keep_large_connected_components()` and `remove_connected_components_of_negligible_size`
-    that can be used to perform a dry run of the operation, meaning that the function will return the number of connected
+-   Added a new named parameter for [`CGAL::Polygon_mesh_processing::keep_large_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga48e7b3e6922ee78cf8ce801e3e325d9a)
+    and [`CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#gac544fcaba1d59d330a3a1536caff392a),
+    which can be used to perform a dry run of the operation, meaning that the function will return the number of connected
    components that would be removed with the specified threshold, but without actually removing them.
-   The function `CGAL::Polygon_mesh_processing::stitch_borders()` now returns the number
-    of halfedge pairs that were stitched.
-   Introduced the new functions `CGAL::Polygon_mesh_processing::merge_reversible_connected_components()`,
-    `CGAL::Polygon_mesh_processing::duplicate_incompatible_edges_in_polygon_soup()`,
-    and `CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh()` that can be helpful 
-    when repairing a polygon soup.
-   New function to split meshes along a mesh or a plane:
-    `CGAL::Polygon_mesh_processing::split()` 
-   New function to split a single mesh containing several connected components into several meshes containing one connected component:
-    `CGAL::Polygon_mesh_processing::split_connected_components()`
- -   Added parallel versions of the functions `CGAL::Polygon_mesh_processing::does_self_intersect()` 
-     and `CGAL::Polygon_mesh_processing::self_intersections()`.
- -   The function `CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh` now allows passing a point map (for the point range)
-     and a vertex point map (for the polygon mesh) via named parameters.
- -   Added the function `CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()`.
- -   Added a new function `CGAL::Polygon_mesh_processing::sample_triangle_soup()` that generates points on a triangle soup surface.
+-   Added the function [`CGAL::Polygon_mesh_processing::split()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__corefinement__grp.html#gaa491feee9e41f725332bea0ea1215578),
+    which can be used to split meshes along a mesh or a plane.
+-   Added the function [`CGAL::Polygon_mesh_processing::split_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga9ddd1e4b915a4232b1ce5611985302aa)
+    to split a single mesh containing several connected components into several meshes containing one connected component.
+-   Added the functions [`CGAL::Polygon_mesh_processing::merge_reversible_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#gae25c1198a89c53d5df2f29dd57fda5ca),
+    [`CGAL::Polygon_mesh_processing::duplicate_non_manifold_edges_in_polygon_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga2aa4f7b500dc51d1fc4747705a050946),
+    and [`CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga31779672b3afd660664fc9a6c4fdf74d),
+    which can be helpful when repairing a polygon soup.
+-   Added the function [`CGAL::Polygon_mesh_processing::sample_triangle_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__distance__grp.html#gac7af41d13bf1a7c30852be266ac81db5),
+    which generates points on a triangle soup surface.
+-   Added parallel versions of the functions [`CGAL::Polygon_mesh_processing::does_self_intersect()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__intersection__grp.html#gad9fe5d8b433545b69154f43935a11a3b)
+    and [`CGAL::Polygon_mesh_processing::self_intersections()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__intersection__grp.html#gaf19c80ec12cbff7ebe9e69453f1d40b8).
+-   The function [`CGAL::Polygon_mesh_processing::stitch_borders()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga8ae4352e67d2b099994ac8990c13bd41)
+    now returns the number of halfedge pairs that were stitched.
+-   Added the function [`CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga76648a509409ff3c3ad3f71eff8ce9d9).
+-   The function [`CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga0dec58e8a0112791f72ebbe77bac074b)
+    now allows passing a point map (for the point range) and a vertex point map (for the polygon mesh) via named parameters.

-### Point Set Processing
- -   Added wrapper functions for registration:
-     - `CGAL::OpenGR::compute_registration_transformation()` computes the registration transformation
-        for two point sets using Super4PCS algorithm implemented in the third party library OpenGR.
-     - `CGAL::OpenGR::register_point_sets()` computes the registration transformation for two point 
-        sets using Super4PCS algorithm implemented in the third party library OpenGR, and registers
-        the points sets by transforming the data point set using the computed transformation.
-     - `CGAL::pointmatcher::compute_registration_transformation()` computes the registration
-        transformation for two point sets using ICP algorithm implemented in the third party library
-        libpointmatcher.
-     - `CGAL::pointmatcher::register_point_sets()` computes the registration transformation for two point
-        sets using ICP algorithm implemented in the third party library libpointmatcher, and registers 
-        the points sets by transforming the data point set using the computed transformation.
+### [Point Set Processing](https://doc.cgal.org/5.1/Manual/packages.html#PkgPointSetProcessing3)

+-   **Breaking change:** [`CGAL::remove_outliers()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga1ab1dcee59caadde50572c5a504cc41a)
+    has been parallelized and thus has a new template parameter `ConcurrencyTag`.
+    To update your code simply add as first template parameter `CGAL::Sequential_tag` or `CGAL::Parallel_tag`
+    when calling this function.
+-   Add a function [`CGAL::cluster_point_set()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gafee41d60b5a257ae034e9157d0af8e46)
+    that segments a point cloud into connected components based on a distance threshold.
+-   Added wrapper functions for registration:
+    - [`CGAL::OpenGR::compute_registration_transformation()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gab81663c718960780ddb176aad845e8cd),
+      which computes the registration transformation for two point sets using the Super4PCS algorithm
+      implemented in the third party library [OpenGR](https://storm-irit.github.io/OpenGR/index.html).
+    - [`CGAL::OpenGR::register_point_sets()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga6194087f512e4e23dd945a9364d0931d),
+      which computes the registration transformation for two point sets using the Super4PCS algorithm
+      implemented in the third party library [OpenGR](https://storm-irit.github.io/OpenGR/index.html),
+      and registers the points sets by transforming the data point set using the computed transformation.
+    - [`CGAL::pointmatcher::compute_registration_transformation()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gaf75af5c1634fa83fa05a33e95570b127)
+      computes the registration transformation for two point sets using ICP algorithm implemented
+      in the third party library [libpointmatcher](https://github.com/ethz-asl/libpointmatcher).
+    - [`CGAL::pointmatcher::register_point_sets()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gaa222278e20a3ce41930d37326cd54ef9),
+      which computes the registration transformation for two point sets using ICP algorithm implemented
+      in the third party library [libpointmatcher](https://github.com/ethz-asl/libpointmatcher), and registers
+      the points sets by transforming the data point set using the computed transformation.
+
+### [2D Triangulations](https://doc.cgal.org/5.1/Manual/packages.html#PkgTriangulation2)

-### 2D Triangulations
 -   To fix an inconsistency between code and documentation and to clarify which types of intersections
-    are truly allowed in constrained Delaunay triangulations, the tag `CGAL::No_intersection_tag`
-    has been deprecated in favor of two new tags `CGAL::No_constraint_intersection_tag`
-    and `CGAL::No_constraint_intersection_requiring_constructions_tag`.
+    are truly allowed in constrained Delaunay triangulations, the tag [`CGAL::No_intersection_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__intersection__tag.html)
+    has been deprecated in favor of two new tags: [`CGAL::No_constraint_intersection_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__constraint__intersection__tag.html)
+    and [`CGAL::No_constraint_intersection_requiring_constructions_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__constraint__intersection__requiring__constructions__tag.html).
    The latter is equivalent to the now-deprecated `CGAL::No_intersection_tag`, and allows constraints
    to intersect as long as no new point has to be created to represent that intersection (for example,
    the intersection of two constraint segments in a 'T'-like junction is an existing point
-    and does not require any new construction). The former tag, `CGAL::No_constraint_intersection_tag`,
+    and as such does not require any new construction). The former tag, `CGAL::No_constraint_intersection_tag`,
    does not allow any intersection, except for the configuration of two constraints having a single
    common endpoints, for convience.
+-   Added the function [`CGAL::split_subconstraint_graph_into_constraints()`](https://doc.cgal.org/5.1/Triangulation_2/classCGAL_1_1Constrained__triangulation__plus__2.html#adea77f5db5cd4dfae302e4502f1caa85)
+    to [`Constrained_triangulation_plus_2`](https://doc.cgal.org/5.1/Triangulation_2/classCGAL_1_1Constrained__triangulation__plus__2.html) to initialize the constraints
+    from a soup of disconnected segments that should first be split into polylines.

-### 3D Triangulations
-   The free function `CGAL::file_input()` and the member function `CGAL::Triangulation_3::file_input()` 
-    have been added. The first allows to load a `Triangulation_3` from an input stream, using functors to create vertices and cells.
-    The second is simply the member function version of the first one.
+### [3D Triangulations](https://doc.cgal.org/5.1/Manual/packages.html#PkgTriangulation3)

-### 3D Triangulation Data Structure
-   The free function `CGAL::file_input()` and the member function `CGAL::TDS_3::file_input()` 
-    have been added. The first allows to load a `TDS_3` from an input stream, using functors to create vertices and cells.
-    The second is simply the member function version of the first one. 
+-   The member function [`CGAL::Triangulation_3::file_input()`](https://doc.cgal.org/5.1/Triangulation_3/group__PkgIOTriangulation3.html#gadd94d0613e2dd9cdd2e88d2c74d5b1c8)
+    have been added. It allows to load a [`CGAL::Triangulation_3`](https://doc.cgal.org/5.1/Triangulation_3/classCGAL_1_1Triangulation__3.html)
+    from an input stream, using functors to create vertices and cells.

-### dD Spatial Searching
+### [3D Triangulation Data Structure](https://doc.cgal.org/5.1/Manual/packages.html#PkgTDS3)

-   Improved the performance of the kd-tree in some cases:
-    -   Not storing the points coordinates inside the tree usually
-        generates a lot of cache misses, leading to non-optimal
-        performance. This is the case for example
-        when indices are stored inside the tree, or to a lesser extent when the points
-        coordinates are stored in a dynamically allocated array (e.g., `Epick_d`
-        with dynamic dimension) &mdash; we says "to a lesser extent" because the points
-        are re-created by the kd-tree in a cache-friendly order after its construction,
-        so the coordinates are more likely to be stored in a near-optimal order
-        on the heap.
-        In these cases, the new `EnablePointsCache` template parameter of the
-        `CGAL::Kd_tree` class can be set to `CGAL::Tag_true`. The points coordinates
-        will then be cached in an optimal way. This will increase memory
-        consumption but provides better search performance. See the updated
-        `GeneralDistance` and `FuzzyQueryItem`
-        concepts for additional requirements when using such a cache.
-    -   In most cases (e.g., Euclidean distance), the distance computation
-        algorithm knows before its end that the distance will be greater
-        than or equal to some given value. This is used in the (orthogonal)
-        k-NN search to interrupt some distance computations before its end,
-        saving precious milliseconds, in particular in medium-to-high dimension.
+-   The member function [`CGAL::TDS_3::file_input()`](https://doc.cgal.org/5.1/TDS_3/group__PkgIOTDS3.html#ga381446a02a9240cc83e79c48b37cd119)
+    have been added. It allows to load a [`CGAL::Triangulation_data_structure_3`](https://doc.cgal.org/5.1/TDS_3/classCGAL_1_1Triangulation__data__structure__3.html)
+    from an input stream, using functors to create vertices and cells.

-### Spatial Sorting
- -   Added parallel versions of `hilbert_sort()` and `spatial_sort()` in 2D and 3D when the median policy is used.
-     The parallel versions use up to four threads in 2D, and up to eight threads in 3D.
+### [Surface Mesh Simplification](https://doc.cgal.org/5.1/Manual/packages.html#PkgSurfaceMeshSimplification)

-### dD Geometry Kernel
-   Epick\_d and Epeck\_d gain 2 new functors: `Power_side_of_bounded_power_sphere_d` and
-    `Compute_squared_radius_smallest_orthogonal_sphere_d`. Those are
-    essential for the computation of weighted alpha-complexes.
+-   Added a [new simplification method](https://doc.cgal.org/5.1/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1GarlandHeckbert__policies.html)
+    based on the quadric error defined by Garland and Heckbert.
+-   The concept `EdgeProfile` has been removed. This concept was not actually in use as the CGAL-provided model [`CGAL::Edge_profile`](https://doc.cgal.org/5.1/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Edge__profile.html)
+    was imposed to the user. Other concepts have been clarified to reflect the fact that the API uses this particular class.

-### Surface Mesh Simplification
- Added a new simplification method based on the quadric error defined by Garland and Heckbert.
- The concept "EdgeProfile" has been removed. This concept was not actually in use as the CGAL-provided model `CGAL::Edge_profile`
-  was imposed to the user. Other concepts have been clarified to reflect the fact that the API uses this particular class.
+### [STL Extensions for CGAL](https://doc.cgal.org/5.1/Manual/packages.html#PkgSTLExtension)

-### STL Extensions for CGAL
- -   Added a new concurrency tag: `CGAL::Parallel_if_available_tag`. This tag is a convenience typedef to `CGAL::Parallel_tag`
-     if the third party library TBB has been found and linked with, and to `CGAL::Sequential_tag` otherwise.
- 
-### Convex_hull_3
- A new overload for `convex_hull_3()` that takes a model of `VertexListGraph` has been added.
+-   Added a new concurrency tag: [`CGAL::Parallel_if_available_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Parallel__if__available__tag.html).
+    This tag is a convenience typedef to [`CGAL::Parallel_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Parallel__tag.html)
+    if the third party library TBB has been found and linked with, and to
+    [`CGAL::Sequential_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Sequential__tag.html) otherwise.


 [Release 5.0](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.0)
@ -230,13 +273,13 @@ Release date: November 2019

 ### [Polygonal Surface Reconstruction](https://doc.cgal.org/5.0/Manual/packages.html#PkgPolygonalSurfaceReconstruction) (new package)

- -   This package provides a method for piecewise planar object reconstruction from point clouds. 
-     The method takes as input an unordered point set sampled from a piecewise planar object 
-     and outputs a compact and watertight surface mesh interpolating the input point set. 
-     The method assumes that all necessary major planes are provided (or can be extracted from 
-     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 
+ -   This package provides a method for piecewise planar object reconstruction from point clouds.
+     The method takes as input an unordered point set sampled from a piecewise planar object
+     and outputs a compact and watertight surface mesh interpolating the input point set.
+     The method assumes that all necessary major planes are provided (or can be extracted from
+     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)
@ -251,11 +294,11 @@ Release date: November 2019
 ### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.0/Manual/packages.html#PkgKernel23)
 -   Added a new concept, [`ComputeApproximateAngle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel_1_1ComputeApproximateAngle__3.html),
     to the 3D Kernel concepts to compute the approximate angle between two 3D vectors. Corresponding functors
-     in the model ([`Compute_approximate_angle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel.html#a183c9ac358a4ccddc04e680f8ed16c0b)) 
+     in the model ([`Compute_approximate_angle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel.html#a183c9ac358a4ccddc04e680f8ed16c0b))
     and free function ([`approximate_angle`](https://doc.cgal.org/5.0/Kernel_23/group__approximate__angle__grp.html))
     have also been added.
- -   The following objects are now hashable and thus trivially usable 
-     with [`std::unordered_set`](https://en.cppreference.com/w/cpp/container/unordered_set) 
+ -   The following objects are now hashable and thus trivially usable
+     with [`std::unordered_set`](https://en.cppreference.com/w/cpp/container/unordered_set)
     and [`std::unordered_map`](https://en.cppreference.com/w/cpp/header/unordered_map):
     `CGAL::Aff_transformation_2`, `CGAL::Aff_transformation_3`,
     `CGAL::Bbox_2`, `CGAL::Bbox_3`, `CGAL::Circle_2`,
@ -265,11 +308,11 @@ Release date: November 2019
     `CGAL::Weighted_point_2` and `CGAL::Weighted_point_3`.

 ### [Polygon Mesh Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPolygonMeshProcessing)
- -   Introduced a [wide range of new functions](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title36) 
+ -   Introduced a [wide range of new functions](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title36)
     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 
+     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.
@ -292,14 +335,14 @@ Release date: November 2019
     or vertices appearing in multiple umbrellas) of a mesh.

 ### [3D Point Set](https://doc.cgal.org/5.0/Manual/packages.html#PkgPointSet3)
- -   The [PLY IO functions](https://doc.cgal.org/5.0/Point_set_3/group__PkgPointSet3IO.html) now take an additional optional parameter to 
+ -   The [PLY IO functions](https://doc.cgal.org/5.0/Point_set_3/group__PkgPointSet3IO.html) now take an additional optional parameter to
     read/write comments from/in the PLY header.

 ### [Point Set Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPointSetProcessing3)
 -   **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.
 -   Added the possibility to use the named parameter
-     [`neighbor_radius`](https://doc.cgal.org/5.0/Point_set_processing_3/group__psp__namedparameters.html#PSP_neighbor_radius) 
+     [`neighbor_radius`](https://doc.cgal.org/5.0/Point_set_processing_3/group__psp__namedparameters.html#PSP_neighbor_radius)
     to use spherical neighbor queries instead of K-nearest neighbors queries for the following functions:
     [`CGAL::bilateral_smooth_point_set()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga4f82723e2f0bb33f3677e29e0208a256),
     [`CGAL::jet_estimate_normals()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga0cd0f87de690d4edf82740e856efa491),
@ -342,7 +385,7 @@ Release date: November 2019
 ### [3D Triangulations](https://doc.cgal.org/5.0/Manual/packages.html#PkgTriangulation3)
 -   **Breaking change**: The [constructor](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html#a63f67cf6aaadcee14318cf56a36d247a)
     and the [`insert()`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html#ad3353128386bbb51f79d0263e7f67337)
-     function of [`CGAL::Triangulation_3`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html) 
+     function of [`CGAL::Triangulation_3`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html)
     which take a range of points as argument are now guaranteed to
     insert the points following the order of `InputIterator`. Note
     that this change only affects the base class `Triangulation_3`
@ -354,14 +397,14 @@ Release date: November 2019

 ### [Surface Mesh](https://doc.cgal.org/5.0/Manual/packages.html#PkgSurfaceMesh)
 -   Introduced new functions to read and write using the PLY format,
-     [`CGAL::read_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga42f6ad486ddab74e13d3dc53f511c343) 
-     and [`CGAL::write_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga77bbb79d449c981895eedb6c3c23bd14), 
+     [`CGAL::read_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga42f6ad486ddab74e13d3dc53f511c343)
+     and [`CGAL::write_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga77bbb79d449c981895eedb6c3c23bd14),
     enabling users to save and load additional property maps of the surface mesh.

 ###  [CGAL and Solvers](https://doc.cgal.org/5.0/Manual/packages.html#PkgSolverInterface)
 -   Added [concepts](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceConcepts.html)
-     and [models](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceRef.html) 
-     for solving Mixed Integer Programming (MIP) problems with or without constraints. 
+     and [models](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceRef.html)
+     for solving Mixed Integer Programming (MIP) problems with or without constraints.

 ### [3D Boolean Operations on Nef Polyhedra](https://doc.cgal.org/5.0/Manual/packages.html#PkgNef3)
 -   Added a function to convert a Nef_polyhedron_3 to a polygon soup: [`CGAL::convert_nef_polyhedron_to_polygon_soup()`](https://doc.cgal.org/5.0/Nef_3/group__PkgNef3IOFunctions.html#ga28a9eb4da0cd6153f0c16f7f9eaf6665)
@ -390,7 +433,7 @@ Release 4.14
 Release date: March 2019

 ### 2D Periodic Hyperbolic Triangulations (new package)
- 
+
 -   This package allows the computation of Delaunay triangulations of
     the Bolza surface.  The Bolza surface is the most symmetric
     hyperbolic surface of genus 2. Its fundamental domain is the
--- a/Installation/cmake/modules/CGAL_Boost_iostreams_support.cmake
+++ b/Installation/cmake/modules/CGAL_Boost_iostreams_support.cmake
@ -0,0 +1,44 @@
+if(Boost_IOSTREAMS_FOUND AND NOT TARGET CGAL::Boost_iostreams_support)
+
+  if( WIN32 )
+    # to avoid a warning with old cmake
+    set(_Boost_BZIP2_HEADERS             "boost/iostreams/filter/bzip2.hpp")
+    set(_Boost_ZLIB_HEADERS              "boost/iostreams/filter/zlib.hpp")
+    find_package( Boost OPTIONAL_COMPONENTS bzip2 zlib)
+    if (Boost_ZLIB_FOUND AND Boost_BZIP2_FOUND)
+      set(ZLIB_LIBS ${Boost_ZLIB_LIBRARY} ${Boost_BZIP2_LIBRARY})
+    else()
+      message(STATUS "NOTICE: This project requires Boost ZLIB and Boost BZIP2, and will not be compiled.")
+      return()
+    endif()
+
+  else()
+
+    find_package(ZLIB QUIET)
+    if(ZLIB_FOUND)
+      set(ZLIB_LIBS ZLIB::ZLIB)
+    else()
+      message(STATUS "NOTICE: This project requires ZLIB, and will not be compiled.")
+      return()
+    endif()
+
+  endif()
+
+  if(TARGET Boost::iostreams)
+    set(Boost_LIB Boost::iostreams)
+  else()
+    set(Boost_LIB  ${Boost_IOSTREAMS_LIBRARY})
+  endif()
+
+  add_library(CGAL::Boost_iostreams_support INTERFACE IMPORTED)
+
+  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})
+  else()
+    set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
+      INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS")
+    target_link_libraries(CGAL::Boost_iostreams_support INTERFACE ${Boost_LIB} ${ZLIB_LIBS})
+  endif()
+endif()
--- a/Installation/cmake/modules/CGAL_Boost_serialization_support.cmake
+++ b/Installation/cmake/modules/CGAL_Boost_serialization_support.cmake
@ -0,0 +1,12 @@
+if(Boost_SERIALIZATION_FOUND AND NOT TARGET CGAL::Boost_serialization_support)
+  if(TARGET Boost::serialization)
+    set(Boost_LIB Boost::serialization)
+  else()
+    set(Boost_LIB  ${Boost_SERIALIZATION_LIBRARY})
+  endif()
+
+  add_library(CGAL::Boost_serialization_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::Boost_serialization_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_SERIALIZATION"
+    INTERFACE_LINK_LIBRARIES ${Boost_LIB})
+endif()
--- a/Installation/cmake/modules/CGAL_Common.cmake
+++ b/Installation/cmake/modules/CGAL_Common.cmake
@ -23,7 +23,7 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
  else()
    set( CMAKE_2_6_3_OR_ABOVE FALSE )
  endif()
-    
+
  if ( CGAL_BUILDING_LIBS )
    option(BUILD_SHARED_LIBS "Build shared libraries" ON)
    set(CGAL_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
@ -34,7 +34,7 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
      message( STATUS "Building static libraries" )
    endif()
  endif()
-  
+
  if ( WIN32 )
    find_program(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
    if(CMAKE_UNAME)
@ -61,15 +61,4 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
  # set use-file for Eigen3 (needed to have default solvers)
  set(EIGEN3_USE_FILE "UseEigen3")

-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Boost_IOStreams.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Boost_Serialization.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Eigen.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_GLPK.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_LASLIB.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_OpenCV.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_OpenGR.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_pointmatcher.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_SCIP.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_TBB.cmake)
-  include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_TensorFlow.cmake)
 endif()
--- a/Installation/cmake/modules/CGAL_Eigen_support.cmake
+++ b/Installation/cmake/modules/CGAL_Eigen_support.cmake
@ -0,0 +1,9 @@
+if(EIGEN3_FOUND AND NOT TARGET CGAL::Eigen_support)
+  if(NOT TARGET Threads::Threads)
+    find_package(Threads REQUIRED)
+  endif()
+  add_library(CGAL::Eigen_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::Eigen_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_EIGEN3_ENABLED"
+    INTERFACE_INCLUDE_DIRECTORIES "${EIGEN3_INCLUDE_DIR}")
+endif()
--- a/Installation/cmake/modules/CGAL_GLPK_support.cmake
+++ b/Installation/cmake/modules/CGAL_GLPK_support.cmake
@ -0,0 +1,7 @@
+if(GLPK_FOUND AND NOT TARGET CGAL::GLPK_support)
+  add_library(CGAL::GLPK_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::GLPK_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_USE_GLPK"
+    INTERFACE_INCLUDE_DIRECTORIES "${GLPK_INCLUDE_DIR}"
+    INTERFACE_LINK_LIBRARIES "${GLPK_LIBRARIES}")
+endif()
--- a/Installation/cmake/modules/CGAL_LASLIB_support.cmake
+++ b/Installation/cmake/modules/CGAL_LASLIB_support.cmake
@ -0,0 +1,7 @@
+if(LASLIB_FOUND AND NOT TARGET CGAL::LASLIB_support)
+  add_library(CGAL::LASLIB_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::LASLIB_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_LASLIB"
+    INTERFACE_INCLUDE_DIRECTORIES "${LASLIB_INCLUDE_DIR};${LASZIP_INCLUDE_DIR}"
+    INTERFACE_LINK_LIBRARIES "${LASLIB_LIBRARIES}")
+endif()
--- a/Installation/cmake/modules/CGAL_OpenCV_support.cmake
+++ b/Installation/cmake/modules/CGAL_OpenCV_support.cmake
@ -0,0 +1,7 @@
+if(OpenCV_FOUND AND NOT TARGET CGAL::OpenCV_support)
+  add_library(CGAL::OpenCV_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::OpenCV_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_OPENCV"
+    INTERFACE_INCLUDE_DIRECTORIES "${OpenCV_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "${OpenCV_LIBS}")
+endif()
--- a/Installation/cmake/modules/CGAL_OpenGR_support.cmake
+++ b/Installation/cmake/modules/CGAL_OpenGR_support.cmake
@ -0,0 +1,6 @@
+if(OpenGR_FOUND AND NOT TARGET CGAL::OpenGR_support)
+  add_library(CGAL::OpenGR_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::OpenGR_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_OPENGR"
+    INTERFACE_INCLUDE_DIRECTORIES "${OpenGR_INCLUDE_DIR}")
+endif()
--- a/Installation/cmake/modules/CGAL_SCIP_support.cmake
+++ b/Installation/cmake/modules/CGAL_SCIP_support.cmake
@ -0,0 +1,7 @@
+if(SCIP_FOUND AND NOT TARGET CGAL::SCIP_support)
+  add_library(CGAL::SCIP_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::SCIP_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_USE_SCIP"
+    INTERFACE_INCLUDE_DIRECTORIES "${SCIP_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "${SCIP_LIBRARIES}")
+endif()
--- a/Installation/cmake/modules/CGAL_TBB_support.cmake
+++ b/Installation/cmake/modules/CGAL_TBB_support.cmake
@ -0,0 +1,10 @@
+if(TBB_FOUND AND NOT TARGET CGAL::TBB_support)
+  if(NOT TARGET Threads::Threads)
+    find_package(Threads REQUIRED)
+  endif()
+  add_library(CGAL::TBB_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::TBB_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_TBB;NOMINMAX"
+    INTERFACE_INCLUDE_DIRECTORIES "${TBB_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "TBB::tbb;TBB::tbbmalloc;Threads::Threads")
+endif()
--- a/Installation/cmake/modules/CGAL_TensorFlow_support.cmake
+++ b/Installation/cmake/modules/CGAL_TensorFlow_support.cmake
@ -0,0 +1,7 @@
+if(TensorFlow_FOUND AND NOT TARGET CGAL::TensorFlow_support)
+  add_library(CGAL::TensorFlow_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::TensorFlow_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_TENSORFLOW"
+    INTERFACE_INCLUDE_DIRECTORIES "${TensorFlow_INCLUDE_DIR}"
+    INTERFACE_LINK_LIBRARIES "${TensorFlow_LIBRARY}")
+endif()
--- a/Installation/cmake/modules/CGAL_pointmatcher_support.cmake
+++ b/Installation/cmake/modules/CGAL_pointmatcher_support.cmake
@ -0,0 +1,7 @@
+if(libpointmatcher_FOUND AND NOT TARGET CGAL::pointmatcher_support)
+  add_library(CGAL::pointmatcher_support INTERFACE IMPORTED)
+  set_target_properties(CGAL::pointmatcher_support PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_POINTMATCHER"
+    INTERFACE_INCLUDE_DIRECTORIES "${libpointmatcher_INCLUDE_DIR}"
+    INTERFACE_LINK_LIBRARIES "${libpointmatcher_LIBRARIES}")
+endif()
--- a/Installation/cmake/modules/CGAL_target_use_Boost_IOStreams.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_Boost_IOStreams.cmake
@ -1,41 +0,0 @@
-if (CGAL_target_use_Boost_IOStreams_included)
-  return()
-endif()
-set(CGAL_target_use_Boost_IOStreams_included TRUE)
-
-function(CGAL_target_use_Boost_IOStreams target)
-
-  if( WIN32 )
-    # to avoid a warning with old cmake
-    set(_Boost_BZIP2_HEADERS             "boost/iostreams/filter/bzip2.hpp")
-    set(_Boost_ZLIB_HEADERS              "boost/iostreams/filter/zlib.hpp")
-    find_package( Boost OPTIONAL_COMPONENTS bzip2 zlib)
-  else()
-    find_package(ZLIB QUIET)
-  endif()
-
-  if(TARGET Boost::iostreams)
-    target_link_libraries(${target} PUBLIC Boost::iostreams)
-  else()
-    target_link_libraries(${target} PUBLIC ${Boost_IOSTREAMS_LIBRARY})
-  endif()
-
-  if( WIN32 )
-    if (Boost_ZLIB_FOUND AND Boost_BZIP2_FOUND)
-      target_link_libraries(${target} PUBLIC ${Boost_ZLIB_LIBRARY} ${Boost_BZIP2_LIBRARY})
-    else()
-      message(STATUS "NOTICE: This project requires Boost ZLIB and Boost BZIP2, and will not be compiled.")
-      return()
-    endif()
-  else()
-    if(ZLIB_FOUND)
-      target_link_libraries(${target} PUBLIC ZLIB::ZLIB)
-    else()
-      message(STATUS "NOTICE: This project requires ZLIB, and will not be compiled.")
-      return()
-    endif()
-  endif()
-
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_BOOST_IOSTREAMS)
-
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_Boost_Serialization.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_Boost_Serialization.cmake
@ -1,16 +0,0 @@
-if (CGAL_target_use_Boost_Serialization_included)
-  return()
-endif()
-set(CGAL_target_use_Boost_Serialization_included TRUE)
-
-function(CGAL_target_use_Boost_Serialization target)
-
-  if(TARGET Boost::serialization)
-    target_link_libraries(${target} PUBLIC Boost::serialization)
-  else()
-    target_link_libraries(${target} PUBLIC ${Boost_SERIALIZATION_LIBRARY})
-  endif()
-
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_BOOST_SERIALIZATION)
-
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_Eigen.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_Eigen.cmake
@ -1,13 +0,0 @@
-if (CGAL_target_use_Eigen_included)
-  return()
-endif()
-set(CGAL_target_use_Eigen_included TRUE)
-
-set( Eigen3_FIND_VERSION "3.1.0")
-set(EIGEN3_USE_FILE "UseEigen3")
-
-function(CGAL_target_use_Eigen target)
-  target_include_directories(${target} PUBLIC ${EIGEN3_INCLUDE_DIR})
-  target_compile_options( ${target} PUBLIC -DCGAL_EIGEN3_ENABLED)
-endfunction()
-
--- a/Installation/cmake/modules/CGAL_target_use_GLPK.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_GLPK.cmake
@ -1,11 +0,0 @@
-if (CGAL_target_use_GLPK_included)
-  return()
-endif()
-set(CGAL_target_use_GLPK_included TRUE)
-
-function(CGAL_target_use_GLPK target)
-  target_include_directories(${target} PUBLIC ${GLPK_INCLUDE_DIR})
-  target_compile_options(${target} PUBLIC -DCGAL_USE_GLPK)
-  target_link_libraries(${target} PUBLIC ${GLPK_LIBRARIES})
-endfunction()
-
--- a/Installation/cmake/modules/CGAL_target_use_LASLIB.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_LASLIB.cmake
@ -1,11 +0,0 @@
-if (CGAL_target_use_LASLIB_included)
-  return()
-endif()
-set(CGAL_target_use_LASLIB_included TRUE)
-
-function(CGAL_target_use_LASLIB target)
-  target_include_directories(${target} PUBLIC ${LASLIB_INCLUDE_DIR})
-  target_include_directories(${target} PUBLIC ${LASZIP_INCLUDE_DIR})
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_LASLIB)
-  target_link_libraries(${target} PUBLIC ${LASLIB_LIBRARIES})
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_OpenCV.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_OpenCV.cmake
@ -1,10 +0,0 @@
-if (CGAL_target_use_OpenCV_included)
-  return()
-endif()
-set(CGAL_target_use_OpenCV_included TRUE)
-
-function(CGAL_target_use_OpenCV target)
-  target_include_directories(${target} PUBLIC ${OpenCV_INCLUDE_DIRS})
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_OPENCV)
-  target_link_libraries(${target} PUBLIC ${OpenCV_LIBS})
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_OpenGR.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_OpenGR.cmake
@ -1,9 +0,0 @@
-if (CGAL_target_use_OpenGR_included)
-  return()
-endif()
-set(CGAL_target_use_OpenGR_included TRUE)
-
-function(CGAL_target_use_OpenGR target)
-  target_include_directories(${target} PUBLIC ${OpenGR_INCLUDE_DIR})
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_OPENGR)
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_SCIP.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_SCIP.cmake
@ -1,11 +0,0 @@
-if (CGAL_target_use_SCIP_included)
-  return()
-endif()
-set(CGAL_target_use_SCIP_included TRUE)
-
-function(CGAL_target_use_SCIP target)
-  target_include_directories(${target} PUBLIC ${SCIP_INCLUDE_DIRS})
-  target_compile_options(${target} PUBLIC -DCGAL_USE_SCIP)
-  target_link_libraries(${target} PUBLIC ${SCIP_LIBRARIES})
-endfunction()
-
--- a/Installation/cmake/modules/CGAL_target_use_TBB.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_TBB.cmake
@ -6,7 +6,9 @@ set(CGAL_target_use_TBB_included TRUE)
 set(TBB_USE_FILE "UseTBB")

 function(CGAL_target_use_TBB target)
-  if(NOT TARGET Threads::Threads)
+  message(DEPRECATION "This file CGAL_target_use_TBB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_TBB_support.cmake should be used instead.")
+  if(NOT TARGET
+      Threads::Threads)
    find_package(Threads REQUIRED)
  endif()
  target_link_libraries( ${target} PUBLIC TBB::tbb TBB::tbbmalloc Threads::Threads)
--- a/Installation/cmake/modules/CGAL_target_use_TensorFlow.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_TensorFlow.cmake
@ -1,10 +0,0 @@
-if (CGAL_target_use_TensorFlow_included)
-  return()
-endif()
-set(CGAL_target_use_TensorFlow_included TRUE)
-
-function(CGAL_target_use_TensorFlow target)
-  target_include_directories(${target} PUBLIC ${TensorFlow_INCLUDE_DIR})
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_TENSORFLOW)
-  target_link_libraries(${target} PUBLIC ${TensorFlow_LIBRARU})
-endfunction()
--- a/Installation/cmake/modules/CGAL_target_use_pointmatcher.cmake
+++ b/Installation/cmake/modules/CGAL_target_use_pointmatcher.cmake
@ -1,10 +0,0 @@
-if (CGAL_target_use_pointmatcher_included)
-  return()
-endif()
-set(CGAL_target_use_pointmatcher_included TRUE)
-
-function(CGAL_target_use_pointmatcher target)
-  target_include_directories(${target} PUBLIC ${libpointmatcher_INCLUDE_DIR})
-  target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_POINTMATCHER)
-  target_link_libraries(${target} PUBLIC ${libpointmatcher_LIBRARIES})
-endfunction()
--- a/Installation/cmake/modules/UseEigen3.cmake
+++ b/Installation/cmake/modules/UseEigen3.cmake
@ -8,4 +8,4 @@ add_definitions(-DCGAL_EIGEN3_ENABLED)

 set (EIGEN3_SETUP TRUE)

-message(DEPRECATION "This file UseEigen.cmake is deprecated, and the function `CGAL_target_use_Eigen` from CGAL_target_use_Eigen.cmake should be used instead.")
+message(DEPRECATION "This file UseEigen.cmake is deprecated, and the imported target `CGAL::Eigen_support` from CGAL_Eigen_support.cmake should be used instead.")
--- a/Installation/cmake/modules/UseLASLIB.cmake
+++ b/Installation/cmake/modules/UseLASLIB.cmake
@ -3,5 +3,4 @@

 add_definitions(-DCGAL_LINKED_WITH_LASLIB)

-message(DEPRECATION "This file UseLASLIB.cmake is deprecated, and the function `CGAL_target_use_LASLIB` from CGAL_target_use_LASLIB.cmake should be used instead.")
-
+message(DEPRECATION "This file UseLASLIB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_LASLIB_support.cmake should be used instead.")
--- a/Installation/cmake/modules/UseTBB.cmake
+++ b/Installation/cmake/modules/UseTBB.cmake
@ -5,4 +5,4 @@ include_directories ( ${TBB_INCLUDE_DIRS} )
 link_directories( ${TBB_LIBRARY_DIRS} )
 add_definitions( -DNOMINMAX -DCGAL_LINKED_WITH_TBB )

-message(DEPRECATION "This file UseTBB.cmake is deprecated, and the function `CGAL_target_use_TBB` from CGAL_target_use_TBB.cmake should be used instead.")
+message(DEPRECATION "This file UseTBB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_TBB_support.cmake should be used instead.")
--- a/Installation/include/CGAL/config.h
+++ b/Installation/include/CGAL/config.h
@ -105,6 +105,10 @@
 // <boost/type_traits/detail/has_postfix_operator.hpp> fails as well
 #  define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
 #  define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
+//work around for moc bug : https://bugreports.qt.io/browse/QTBUG-80990
+#if defined(CGAL_LINKED_WITH_TBB)
+#undef CGAL_LINKED_WITH_TBB
+#endif
 #endif

 // Macro used by Boost Parameter. Mesh_3 needs at least 12, before the
--- a/Installation/include/CGAL/version.h
+++ b/Installation/include/CGAL/version.h
@ -17,12 +17,12 @@
 #define CGAL_VERSION_H

 #ifndef SWIG
-#define CGAL_VERSION 5.1
+#define CGAL_VERSION 5.1-beta2
 #define CGAL_GIT_HASH abcdef
 #endif
 #define CGAL_VERSION_NR 1050100000
 #define CGAL_SVN_REVISION 99999
-#define CGAL_RELEASE_DATE 20191108
+#define CGAL_RELEASE_DATE 20200609

 #include <CGAL/version_macros.h>

--- a/Installation/lib/cmake/CGAL/CGALConfig.cmake
+++ b/Installation/lib/cmake/CGAL/CGALConfig.cmake
@ -159,17 +159,7 @@ endforeach()
 cgal_setup_module_path()

 set(CGAL_USE_FILE ${CGAL_MODULES_DIR}/UseCGAL.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_Boost_IOStreams.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_Boost_Serialization.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_Eigen.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_GLPK.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_LASLIB.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_OpenCV.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_OpenGR.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_SCIP.cmake)
 include(${CGAL_MODULES_DIR}/CGAL_target_use_TBB.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_TensorFlow.cmake)
-include(${CGAL_MODULES_DIR}/CGAL_target_use_pointmatcher.cmake)

 include("${CGAL_MODULES_DIR}/CGAL_parse_version_h.cmake")
 cgal_parse_version_h( "${CGAL_INSTALLATION_PACKAGE_DIR}/include/CGAL/version.h"
--- a/Installation/lib/cmake/CGAL/CGALConfigVersion.cmake
+++ b/Installation/lib/cmake/CGAL/CGALConfigVersion.cmake
@ -1,7 +1,7 @@
 set(CGAL_MAJOR_VERSION 5)
 set(CGAL_MINOR_VERSION 1)
 set(CGAL_BUGFIX_VERSION 0)
-set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-dev")
+set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-beta2")
 set(CGAL_VERSION_PUBLIC_RELEASE_NAME "CGAL-${CGAL_VERSION_PUBLIC_RELEASE_VERSION}")

 if (CGAL_BUGFIX_VERSION AND CGAL_BUGFIX_VERSION GREATER 0)
--- a/Installation/test/Installation/CMakeLists.txt
+++ b/Installation/test/Installation/CMakeLists.txt
@ -48,9 +48,10 @@ if ( CGAL_FOUND )
  endif()

  find_package( TBB QUIET )
+  include(CGAL_TBB_support)
  create_single_source_cgal_program( "test_TBB.cpp" )
-  if(TBB_FOUND)
-    CGAL_target_use_TBB(test_TBB)
+  if(TARGET CGAl::TBB_support)
+    target_link_libraries(test_TBB PUBLIC CGAL::TBB_support)
  endif()

  create_link_to_program(CGAL)
--- a/Jet_fitting_3/examples/Jet_fitting_3/CMakeLists.txt
+++ b/Jet_fitting_3/examples/Jet_fitting_3/CMakeLists.txt
@ -13,7 +13,8 @@ if ( CGAL_FOUND )

  # use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
    # Link with Boost.ProgramOptions (optional)
    find_package(Boost QUIET COMPONENTS program_options)
    if(Boost_PROGRAM_OPTIONS_FOUND)
@ -30,9 +31,9 @@ if ( CGAL_FOUND )
   endif()

   create_single_source_cgal_program( "Mesh_estimation.cpp" )
-   CGAL_target_use_Eigen(Mesh_estimation)
+   target_link_libraries(Mesh_estimation PUBLIC CGAL::Eigen_support)
   create_single_source_cgal_program( "Single_estimation.cpp" )
-   CGAL_target_use_Eigen(Single_estimation)
+   target_link_libraries(Single_estimation PUBLIC CGAL::Eigen_support)

  else()
    message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
@ -43,4 +44,3 @@ else()
  message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Jet_fitting_3/test/Jet_fitting_3/CMakeLists.txt
+++ b/Jet_fitting_3/test/Jet_fitting_3/CMakeLists.txt
@ -13,9 +13,10 @@ if ( CGAL_FOUND )

  # use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
    create_single_source_cgal_program( "blind_1pt.cpp" )
-    CGAL_target_use_Eigen(blind_1pt)
+    target_link_libraries(blind_1pt PUBLIC CGAL::Eigen_support)
  else()
    message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
  endif()
@ -25,4 +26,3 @@ else()
  message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Maintenance/infrastructure/cgal.geometryfactory.com/crontab
+++ b/Maintenance/infrastructure/cgal.geometryfactory.com/crontab
@ -23,13 +23,13 @@ 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 || 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 2 --public || echo ERROR
 # "integration"
-0 21  *  *  Mon,Tue,Wed,Thu,Fri      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 --public || echo ERROR
+0 21  *  *  Mon,Wed,Thu,Fri      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
 # 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
-#0 21  *  *  Sat                      cd $HOME/CGAL/create_internal_release-4.14-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-4.14-branch.git --public --do-it || echo ERROR
+0 21  *  *  Tue                      cd $HOME/CGAL/create_internal_release-4.14-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-4.14-branch.git --public --do-it || echo ERROR

 ## Older stuff
 # from branch 4.13
--- a/Maintenance/public_release/announcement/mailing-beta.eml
+++ b/Maintenance/public_release/announcement/mailing-beta.eml
@ -1,111 +1,124 @@
-Subject: CGAL 5.0 Beta 2 Released, Computational Geometry Algorithms Library
+Subject: CGAL 5.1 Beta 1 Released, Computational Geometry Algorithms Library
 Content-Type: text/plain; charset="utf-8"
-Body: 
+Body:

-The CGAL Open Source Project is pleased to announce the release 5.0 Beta 2
+The CGAL Open Source Project is pleased to announce the release 5.1 Beta 1
 of CGAL, the Computational Geometry Algorithms Library.


-CGAL version 5.0 Beta 2 is a public testing release. It should provide a
+CGAL version 5.1 Beta 1 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.0 in November.
-
-The important changes since CGAL 5.0 Beta 1 are the fix of CMake
-issues, with header-only installations, and the update of the section
-“Getting Started with CGAL” of the documentation.
+of the final version of CGAL 5.1 in July.


 Besides fixes and general enhancement to existing packages, the following
-has changed since CGAL 4.14:
-
-General changes
-
-   CGAL 5.0 is the first release of CGAL that requires a C++ compiler
-    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.
-
-Polygonal Surface Reconstruction (new package)
-
-   This package provides a method for piecewise planar object
-    reconstruction from point clouds. The method takes as input an
-    unordered point set sampled from a piecewise planar object and
-    outputs a compact and watertight surface mesh interpolating the
-    input point set. The method assumes that all necessary major planes
-    are provided (or can be extracted from 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/
+has changed since CGAL 5.0:


-Shape Detection (major changes)
+Tetrahedral Remeshing (new package)

-   BREAKING CHANGE: The concept ShapeDetectionTraits has been renamed
-    to EfficientRANSACTraits.
-   BREAKING CHANGE: The Shape_detection_3 namespace has been renamed to
-    Shape_detection.
-   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 concept. Learn more about
-    this new algorithm with this blog entry:
-    
-      https://www.cgal.org/2019/07/30/Shape_detection/
+-   This package implements a tetrahedral isotropic remeshing algorithm,
+    that improves the quality of tetrahedra in terms of dihedral angles,
+    while targeting a given edge length.

+Surface Mesh Topology (new package)

-dD Geometry Kernel
+-   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.

-   A new exact kernel, Epeck_d, is now available.
+    See also the associated blog entry:
+      https://www.cgal.org/2020/05/08/Surface_mesh_topology/

+Optimal Bounding Box (new package)

-2D and 3D Triangulations
+-   This package implements an optimization algorithm that aims to
+    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.

-   BREAKING CHANGE: Several deprecated functions and classes have been
-    removed. See the full list of breaking changes in the release notes.
+    See also the associated blog entry:
+      https://www.cgal.org/2020/04/20/Optimal_bounding_box/

-   BREAKING CHANGE: The constructor and the insert() function of
-    CGAL::Triangulation_2 or CGAL::Triangulation_3 which take a range of
-    points as argument are now guaranteed to insert the points following
-    the order of InputIterator. Note that this change only affects the
-    base class CGAL::Triangulation_[23] and not any derived class, such
-    as CGAL::Delaunay_triangulation_[23].
+Tutorials

-Polygon Mesh Processing
+-   Two new, detailed tutorials have been added:
+    -   Surface Reconstruction from Point Clouds, which goes over a
+        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.

-   Introduced a wide range of new functions related to location of
-    queries on a triangle mesh, such as
-    CGAL::Polygon_mesh_processing::locate(Point, Mesh). 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(), which can be used
-    to improve the quality of triangle elements based on various
-    geometric characteristics.
-   Added the shape smoothing function smooth_shape(), which can be used
-    to smooth the surface of a triangle mesh, using the mean curvature
-    flow to perform noise removal.
+    Both tutorials provide complete code.

+    See https://doc.cgal.org/5.1/Manual/tutorials.html

 Point Set Processing

-   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.
+-   Added wrapper functions for registration, using the Super4PCS and
+    ICP algorithms implemented in the third party libraries OpenGR and
+    libpointmatcher.

-See https://www.cgal.org/2019/10/31/cgal50-beta2/ for a complete list of
+
+Surface Mesh Simplification
+
+-   Added a new simplification method based on the quadric error defined
+    by Garland and Heckbert.
+
+dD Spatial Searching
+
+-   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)
+
+-   Added the function CGAL::alpha_expansion_graphcut(), which
+    regularizes a multi-label partition over a user-defined graph.
+-   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/06/09/cgal51-beta1/ for a complete list of
 changes.


--- a/Mesh_3/benchmark/Mesh_3/CMakeLists.txt
+++ b/Mesh_3/benchmark/Mesh_3/CMakeLists.txt
@ -57,12 +57,14 @@ if ( CGAL_FOUND )
  if( CGAL_ACTIVATE_CONCURRENT_MESH_3 )
    add_definitions( -DCGAL_CONCURRENT_MESH_3 )
    find_package( TBB REQUIRED )
+    include(CGAL_TBB_support)
  else()
    option( LINK_WITH_TBB
      "Link with TBB anyway so we can use TBB timers for profiling"
      ON)
    if( LINK_WITH_TBB )
      find_package( TBB )
+      include(CGAL_TBB_support)
    endif( LINK_WITH_TBB )
  endif()

@ -81,11 +83,11 @@ if ( CGAL_FOUND )
  if ( Boost_FOUND AND Boost_VERSION GREATER 103400 )
    # Compilable benchmark
    set (BENCHMARK_SOURCE_FILES "concurrency.cpp")
-    if(TBB_FOUND)
-      CGAL_target_use_TBB(concurrency)
-    endif()
    ADD_MSVC_PRECOMPILED_HEADER("StdAfx.h" "StdAfx.cpp" BENCHMARK_SOURCE_FILES)
    create_single_source_cgal_program( ${BENCHMARK_SOURCE_FILES} )
+    if(TARGET CGAL::TBB_support)
+      target_link_libraries(concurrency PUBLIC CGAL::TBB_support)
+    endif()

  else()
    message(STATUS "NOTICE: This program requires Boost >= 1.34.1, and will not be compiled.")
@ -94,4 +96,3 @@ if ( CGAL_FOUND )
 else()
  message(STATUS "This program requires the CGAL library, and will not be compiled.")
 endif()
-
--- a/Mesh_3/examples/Mesh_3/CMakeLists.txt
+++ b/Mesh_3/examples/Mesh_3/CMakeLists.txt
@ -34,18 +34,21 @@ if ( CGAL_FOUND )
  if( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
    add_definitions( -DCGAL_CONCURRENT_MESH_3 )
    find_package( TBB REQUIRED )
+    include(CGAL_TBB_support)
  else( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
    option( LINK_WITH_TBB
      "Link with TBB anyway so we can use TBB timers for profiling"
      ON)
    if( LINK_WITH_TBB )
      find_package( TBB )
+      include(CGAL_TBB_support)
    endif( LINK_WITH_TBB )
  endif()

  # Use Eigen
  find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-  if (NOT EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (NOT TARGET CGAL::Eigen_support)
    message(STATUS "This project requires the Eigen library, and will not be compiled.")
    return()
  endif()
@ -70,92 +73,91 @@ if ( CGAL_FOUND )

    # Compilable examples
    create_single_source_cgal_program( "mesh_hybrid_mesh_domain.cpp" )
-    CGAL_target_use_Eigen(mesh_hybrid_mesh_domain)
+    target_link_libraries(mesh_hybrid_mesh_domain PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_implicit_sphere.cpp" )
-    CGAL_target_use_Eigen(mesh_implicit_sphere)
+    target_link_libraries(mesh_implicit_sphere PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_implicit_sphere_variable_size.cpp" )
-    CGAL_target_use_Eigen(mesh_implicit_sphere_variable_size)
+    target_link_libraries(mesh_implicit_sphere_variable_size PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_two_implicit_spheres_with_balls.cpp" )
-    CGAL_target_use_Eigen(mesh_two_implicit_spheres_with_balls)
+    target_link_libraries(mesh_two_implicit_spheres_with_balls PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_implicit_domains_2.cpp" "implicit_functions.cpp" )
-    CGAL_target_use_Eigen(mesh_implicit_domains_2)
+    target_link_libraries(mesh_implicit_domains_2 PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_cubes_intersection.cpp" )
-    CGAL_target_use_Eigen(mesh_cubes_intersection)
+    target_link_libraries(mesh_cubes_intersection PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_cubes_intersection_with_features.cpp" )
-    CGAL_target_use_Eigen(mesh_cubes_intersection_with_features)
+    target_link_libraries(mesh_cubes_intersection_with_features PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_implicit_domains.cpp" "implicit_functions.cpp" )
-    CGAL_target_use_Eigen(mesh_implicit_domains)
+    target_link_libraries(mesh_implicit_domains PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain)
+    target_link_libraries(mesh_polyhedral_domain PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain_sm.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain_sm)
+    target_link_libraries(mesh_polyhedral_domain_sm PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain_with_surface_inside.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain_with_surface_inside)
+    target_link_libraries(mesh_polyhedral_domain_with_surface_inside PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "remesh_polyhedral_surface.cpp" )
-    CGAL_target_use_Eigen(remesh_polyhedral_surface)
+    target_link_libraries(remesh_polyhedral_surface PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "remesh_polyhedral_surface_sm.cpp" )
-    CGAL_target_use_Eigen(remesh_polyhedral_surface_sm)
+    target_link_libraries(remesh_polyhedral_surface_sm PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain_with_features.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain_with_features)
+    target_link_libraries(mesh_polyhedral_domain_with_features PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain_with_features_sm.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain_with_features_sm)
+    target_link_libraries(mesh_polyhedral_domain_with_features_sm PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_domain_with_lipschitz_sizing.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_domain_with_lipschitz_sizing)
+    target_link_libraries(mesh_polyhedral_domain_with_lipschitz_sizing PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_complex.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_complex)
+    target_link_libraries(mesh_polyhedral_complex PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "mesh_polyhedral_complex_sm.cpp" )
-    CGAL_target_use_Eigen(mesh_polyhedral_complex_sm)
+    target_link_libraries(mesh_polyhedral_complex_sm PUBLIC CGAL::Eigen_support)

    if( WITH_CGAL_ImageIO )
      if( VTK_FOUND AND ("${VTK_VERSION_MAJOR}" GREATER "5" OR VTK_VERSION VERSION_GREATER 5) )
        add_executable ( mesh_3D_gray_vtk_image mesh_3D_gray_vtk_image.cpp )
-        CGAL_target_use_Eigen(mesh_3D_gray_vtk_image)
-        target_link_libraries(  mesh_3D_gray_vtk_image ${CGAL_LIBRARIES} ${CGAL_3RD_PARTY_LIBRARIES} ${VTK_LIBRARIES})
+        target_link_libraries(  mesh_3D_gray_vtk_image PUBLIC CGAL::Eigen_support ${CGAL_LIBRARIES} ${CGAL_3RD_PARTY_LIBRARIES} ${VTK_LIBRARIES})
        cgal_add_test( mesh_3D_gray_vtk_image )
        add_to_cached_list( CGAL_EXECUTABLE_TARGETS mesh_3D_gray_vtk_image )
      endif()

      create_single_source_cgal_program( "mesh_3D_gray_image.cpp" )
-      CGAL_target_use_Eigen(mesh_3D_gray_image)
+      target_link_libraries(mesh_3D_gray_image PUBLIC CGAL::Eigen_support)

      create_single_source_cgal_program( "mesh_3D_gray_image_multiple_values.cpp" )
-      CGAL_target_use_Eigen(mesh_3D_gray_image_multiple_values)
+      target_link_libraries(mesh_3D_gray_image_multiple_values PUBLIC CGAL::Eigen_support)

      create_single_source_cgal_program( "mesh_3D_image_with_features.cpp" )
-      CGAL_target_use_Eigen(mesh_3D_image_with_features)
+      target_link_libraries(mesh_3D_image_with_features PUBLIC CGAL::Eigen_support)

      if( CGAL_ImageIO_USE_ZLIB )
        create_single_source_cgal_program( "mesh_optimization_example.cpp" )
-        CGAL_target_use_Eigen(mesh_optimization_example)
+        target_link_libraries(mesh_optimization_example PUBLIC CGAL::Eigen_support)

        create_single_source_cgal_program( "mesh_optimization_lloyd_example.cpp" )
-        CGAL_target_use_Eigen(mesh_optimization_lloyd_example)
+        target_link_libraries(mesh_optimization_lloyd_example PUBLIC CGAL::Eigen_support)

        create_single_source_cgal_program( "mesh_3D_image.cpp" )
-        CGAL_target_use_Eigen(mesh_3D_image)
+        target_link_libraries(mesh_3D_image PUBLIC CGAL::Eigen_support)

        create_single_source_cgal_program( "mesh_3D_image_with_custom_initialization.cpp" )
-        CGAL_target_use_Eigen(mesh_3D_image_with_custom_initialization)
+        target_link_libraries(mesh_3D_image_with_custom_initialization PUBLIC CGAL::Eigen_support)

        create_single_source_cgal_program( "mesh_3D_image_variable_size.cpp" )
-        CGAL_target_use_Eigen(mesh_3D_image_variable_size)
+        target_link_libraries(mesh_3D_image_variable_size PUBLIC CGAL::Eigen_support)
      else()
        message( STATUS "NOTICE: The examples mesh_3D_image.cpp, mesh_3D_image_variable_size.cpp, mesh_optimization_example.cpp and mesh_optimization_lloyd_example.cpp need CGAL_ImageIO to be configured with ZLIB support, and will not be compiled." )
      endif()
@ -167,28 +169,27 @@ if ( CGAL_FOUND )
 #    create_single_source_cgal_program( "mesh_polyhedral_surface_tolerance_region.cpp" )
 #    create_single_source_cgal_program( "mesh_polyhedral_edge_tolerance_region.cpp" )

-    if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TBB_FOUND AND TARGET ${target})
+    if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support AND TARGET ${target})
      foreach(target
-        mesh_3D_image_with_features
-        mesh_3D_image
-        mesh_polyhedral_domain
-        mesh_3D_image_with_custom_initialization
-        mesh_two_implicit_spheres_with_balls
-        mesh_optimization_lloyd_example
-        mesh_optimization_example
-        mesh_implicit_sphere
-        mesh_polyhedral_complex_sm
-        mesh_implicit_sphere_variable_size
-        mesh_polyhedral_domain_sm
-        mesh_polyhedral_domain_with_lipschitz_sizing
-        mesh_polyhedral_complex
-        mesh_polyhedral_domain_with_features
-        mesh_3D_image_variable_size)
-        CGAL_target_use_TBB(${target})
+          mesh_3D_image_with_features
+          mesh_3D_image
+          mesh_polyhedral_domain
+          mesh_3D_image_with_custom_initialization
+          mesh_two_implicit_spheres_with_balls
+          mesh_optimization_lloyd_example
+          mesh_optimization_example
+          mesh_implicit_sphere
+          mesh_polyhedral_complex_sm
+          mesh_implicit_sphere_variable_size
+          mesh_polyhedral_domain_sm
+          mesh_polyhedral_domain_with_lipschitz_sizing
+          mesh_polyhedral_complex
+          mesh_polyhedral_domain_with_features
+          mesh_3D_image_variable_size)
+        target_link_libraries(${target} PUBLIC CGAL::TBB_support)
      endforeach()
    endif()

 else()
  message(STATUS "This program requires the CGAL library, and will not be compiled.")
 endif()
-
--- a/Mesh_3/test/Mesh_3/CMakeLists.txt
+++ b/Mesh_3/test/Mesh_3/CMakeLists.txt
@ -16,10 +16,12 @@ if ( CGAL_FOUND )
  include( ${CGAL_USE_FILE} )

  find_package( TBB QUIET )
+  include(CGAL_TBB_support)

  # Use Eigen
  find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-  if (NOT EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (NOT TARGET CGAL::Eigen_support)
    message(STATUS "This project requires the Eigen library, and will not be compiled.")
    return()
  endif()
@ -91,32 +93,33 @@ if ( CGAL_FOUND )
      test_mesh_polyhedral_domain_with_features_deprecated
      test_meshing_with_one_step.cpp)
    if(TARGET ${target})
-      CGAL_target_use_Eigen(${target})
+      target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
    endif()
  endforeach()

-  foreach(target
-      test_meshing_verbose
-      test_meshing_polyhedron_with_features
-      test_meshing_utilities.h
-      test_meshing_implicit_function
-      test_meshing_3D_image
-      test_meshing_3D_gray_image
-      test_meshing_unit_tetrahedron
-      test_meshing_polyhedron
-      test_meshing_polyhedral_complex
-      test_mesh_capsule_var_distance_bound
-      test_mesh_3_issue_1554
-      test_mesh_polyhedral_domain_with_features_deprecated
-      )
-    if(TBB_FOUND AND TARGET ${target})
-      CGAL_target_use_TBB(${target})
-    endif()
-  endforeach()
+  if(TARGET CGAL::TBB_support)
+    foreach(target
+        test_meshing_verbose
+        test_meshing_polyhedron_with_features
+        test_meshing_utilities.h
+        test_meshing_implicit_function
+        test_meshing_3D_image
+        test_meshing_3D_gray_image
+        test_meshing_unit_tetrahedron
+        test_meshing_polyhedron
+        test_meshing_polyhedral_complex
+        test_mesh_capsule_var_distance_bound
+        test_mesh_3_issue_1554
+        test_mesh_polyhedral_domain_with_features_deprecated
+        )
+      if(TARGET ${target})
+        target_link_libraries(${target} PUBLIC CGAL::TBB_support)
+      endif()
+    endforeach()
+  endif()

 else()

    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Nef_3/include/CGAL/Nef_nary_intersection_3.h
+++ b/Nef_3/include/CGAL/Nef_nary_intersection_3.h
@ -52,7 +52,8 @@ class Nef_nary_intersection_3 {
  }

  Polyhedron get_intersection() {
-
+    if (queue.empty())
+      return empty;
    while(queue.size() > 1)
      intersect();
    inserted = 0;
--- a/Nef_3/include/CGAL/Nef_nary_union_3.h
+++ b/Nef_3/include/CGAL/Nef_nary_union_3.h
@ -52,7 +52,8 @@ class Nef_nary_union_3 {
  }

  Polyhedron get_union() {
-
+    if (queue.empty())
+      return empty;
    while(queue.size() > 1)
      unite();
    inserted = 0;
--- a/NewKernel_d/test/NewKernel_d/CMakeLists.txt
+++ b/NewKernel_d/test/NewKernel_d/CMakeLists.txt
@ -17,9 +17,10 @@ find_package(CGAL QUIET)
 if ( CGAL_FOUND )

  find_package(Eigen3)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
    create_single_source_cgal_program( "Epick_d.cpp" )
-    CGAL_target_use_Eigen(Epick_d)
+    target_link_libraries(Epick_d PUBLIC CGAL::Eigen_support)
  else()

    message(STATUS "NOTICE: This program requires the Eigen3 library, and will not be compiled.")
@ -31,4 +32,3 @@ else()
    message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Number_types/test/Number_types/CMakeLists.txt
+++ b/Number_types/test/Number_types/CMakeLists.txt
@ -83,8 +83,9 @@ if ( CGAL_FOUND )

  create_single_source_cgal_program( "eigen.cpp" )
  find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
-  if (EIGEN3_FOUND)
-    cgal_target_use_Eigen(eigen)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
+    target_link_libraries(eigen PUBLIC CGAL::Eigen_support)
  endif()

 else( CGAL_FOUND )
--- a/Optimal_bounding_box/benchmarks/Optimal_bounding_box/CMakeLists.txt
+++ b/Optimal_bounding_box/benchmarks/Optimal_bounding_box/CMakeLists.txt
@ -16,10 +16,11 @@ endif()
 include( ${CGAL_USE_FILE} )

 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  return()
 endif()

 create_single_source_cgal_program("bench_obb.cpp")
-CGAL_target_use_Eigen(bench_obb)
+target_link_libraries(bench_obb PUBLIC CGAL::Eigen_support)
--- a/Optimal_bounding_box/examples/Optimal_bounding_box/CMakeLists.txt
+++ b/Optimal_bounding_box/examples/Optimal_bounding_box/CMakeLists.txt
@ -14,7 +14,8 @@ endif()
 include( ${CGAL_USE_FILE} )

 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  return()
 endif()
@ -27,5 +28,5 @@ foreach(target
        obb_example
        obb_with_point_maps_example
        rotated_aabb_tree_example)
-  CGAL_target_use_Eigen(${target})
+  target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
 endforeach()
--- a/Optimal_bounding_box/test/Optimal_bounding_box/CMakeLists.txt
+++ b/Optimal_bounding_box/test/Optimal_bounding_box/CMakeLists.txt
@ -14,7 +14,8 @@ endif()
 include( ${CGAL_USE_FILE} )

 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  return()
 endif()
@ -27,5 +28,5 @@ foreach(target
        test_OBB_traits
        test_nelder_mead
        test_optimization_algorithms)
-  CGAL_target_use_Eigen(${target})
+  target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
 endforeach()
--- a/Periodic_3_mesh_3/examples/Periodic_3_mesh_3/CMakeLists.txt
+++ b/Periodic_3_mesh_3/examples/Periodic_3_mesh_3/CMakeLists.txt
@ -23,7 +23,8 @@ endif()

 # Use Eigen
 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "This project requires the Eigen library, and will not be compiled.")
  return()
 endif()
@ -52,5 +53,5 @@ foreach(target
    mesh_implicit_shape_with_subdomains
    mesh_implicit_shape_with_optimizers
    mesh_implicit_shape_with_features)
-  CGAL_target_use_Eigen(${target})
+  target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
 endforeach()
--- a/Periodic_3_mesh_3/test/Periodic_3_mesh_3/CMakeLists.txt
+++ b/Periodic_3_mesh_3/test/Periodic_3_mesh_3/CMakeLists.txt
@ -16,21 +16,21 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
-  if (NOT EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (NOT TARGET CGAL::Eigen_support)
    message(STATUS "This project requires the Eigen library, and will not be compiled.")
    return()
  endif()

  create_single_source_cgal_program( "test_implicit_shapes_bunch.cpp" )
-  CGAL_target_use_Eigen(test_implicit_shapes_bunch)
+  target_link_libraries(test_implicit_shapes_bunch PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "test_implicit_shapes_with_features.cpp" )
-  CGAL_target_use_Eigen(test_implicit_shapes_with_features)
+  target_link_libraries(test_implicit_shapes_with_features PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "test_triply_periodic_minimal_surfaces.cpp" )
-  CGAL_target_use_Eigen(test_triply_periodic_minimal_surfaces)
+  target_link_libraries(test_triply_periodic_minimal_surfaces PUBLIC CGAL::Eigen_support)

 else()

  message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Point_set_3/examples/Point_set_3/CMakeLists.txt
+++ b/Point_set_3/examples/Point_set_3/CMakeLists.txt
@ -44,9 +44,10 @@ set(needed_cxx_features cxx_rvalue_references cxx_variadic_templates)
 create_single_source_cgal_program( "point_set_read_ply.cpp" CXX_FEATURES ${needed_cxx_features} )

 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
+include(CGAL_Eigen_support)
 if (EIGEN3_FOUND)
  create_single_source_cgal_program( "point_set_algo.cpp" )
-  CGAL_target_use_Eigen(point_set_algo)
+  target_link_libraries(point_set_algo PUBLIC CGAL::Eigen_support)
 endif()

 create_single_source_cgal_program("draw_point_set_3.cpp" )
--- a/Point_set_processing_3/examples/Point_set_processing_3/CMakeLists.txt
+++ b/Point_set_processing_3/examples/Point_set_processing_3/CMakeLists.txt
@ -31,117 +31,101 @@ if ( CGAL_FOUND )
         "Enable concurrency"
         OFF)

+  set(CGAL_libs CGAL::CGAL)
  if( CGAL_ACTIVATE_CONCURRENT_PSP3 OR ENV{CGAL_ACTIVATE_CONCURRENT_PSP3} )
    find_package( TBB REQUIRED )
+    include(CGAL_TBB_support)
+    if (TARGET CGAL::TBB_support)
+      set(CGAL_TBB_target ${CGAL_libs} CGAL::TBB_support)
+    endif()
  endif()

  # Executables that do *not* require EIGEN
-  create_single_source_cgal_program( "average_spacing_example.cpp" )
-  create_single_source_cgal_program( "bilateral_smooth_point_set_example.cpp" )
-  create_single_source_cgal_program( "grid_simplification_example.cpp" )
-  create_single_source_cgal_program( "grid_simplify_indices.cpp" )
-  create_single_source_cgal_program( "property_map.cpp" )
-  create_single_source_cgal_program( "random_simplification_example.cpp" )
-  create_single_source_cgal_program( "read_write_xyz_point_set_example.cpp" )
-  create_single_source_cgal_program( "remove_outliers_example.cpp" )
-  create_single_source_cgal_program( "wlop_simplify_and_regularize_point_set_example.cpp" )
-  create_single_source_cgal_program( "edge_aware_upsample_point_set_example.cpp" )
-  create_single_source_cgal_program( "structuring_example.cpp" )
-
-  create_single_source_cgal_program( "read_ply_points_with_colors_example.cpp" )
-  create_single_source_cgal_program( "write_ply_points_example.cpp" )
+  foreach(target
+      average_spacing_example
+      bilateral_smooth_point_set_example
+      grid_simplification_example
+      grid_simplify_indices
+      property_map
+      random_simplification_example
+      read_write_xyz_point_set_example
+      remove_outliers_example
+      wlop_simplify_and_regularize_point_set_example
+      edge_aware_upsample_point_set_example
+      structuring_example
+      read_ply_points_with_colors_example
+      write_ply_points_example)
+    add_executable(${target} "${target}.cpp")
+    target_link_libraries(${target} ${CGAL_libs})
+  endforeach()

  find_package(LASLIB)
-  if (LASLIB_FOUND)
-    create_single_source_cgal_program( "read_las_example.cpp" )
-    CGAL_target_use_LASLIB(read_las_example)
+  include(CGAL_LASLIB_support)
+  if (TARGET CGAL::LASLIB_support)
+    add_executable( read_las_example "read_las_example.cpp" )
+    target_link_libraries(read_las_example ${CGAL_libs} CGAL::LASLIB_support)
  else()
    message(STATUS "NOTICE : the LAS reader test requires LASlib and will not be compiled.")
  endif()

  # Use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
+    set(CGAL_libs ${CGAL_libs} CGAL::Eigen_support)
+
    # Executables that require Eigen
-    create_single_source_cgal_program( "jet_smoothing_example.cpp" )
-    CGAL_target_use_Eigen(jet_smoothing_example)
-
-    create_single_source_cgal_program( "normal_estimation.cpp" )
-    CGAL_target_use_Eigen(normal_estimation)
-
-    create_single_source_cgal_program( "clustering_example.cpp" )
-    CGAL_target_use_Eigen(clustering_example)
-
-    create_single_source_cgal_program( "edges_example.cpp" )
-    CGAL_target_use_Eigen(edges_example)
+    foreach(target
+        jet_smoothing_example
+        normal_estimation
+        clustering_example
+        edges_example
+        callback_example
+        scale_estimation_example
+        scale_estimation_2d_example
+        hierarchy_simplification_example
+        normals_example)
+      add_executable(${target} "${target}.cpp")
+      target_link_libraries(${target} ${CGAL_libs})
+    endforeach()

    # Executables that require libpointmatcher
    find_package(libpointmatcher QUIET)
-    if (libpointmatcher_FOUND)
-      create_single_source_cgal_program( "registration_with_pointmatcher.cpp" )
-      CGAL_target_use_pointmatcher(registration_with_pointmatcher)
-      CGAL_target_use_Eigen(registration_with_pointmatcher)
+    include(CGAL_pointmatcher_support)
+    if (TARGET CGAL::pointmatcher_support)
+      add_executable(registration_with_pointmatcher "registration_with_pointmatcher.cpp")
+      target_link_libraries(registration_with_pointmatcher
+        ${CGAL_libs} CGAL::pointmatcher_support)
    else()
      message(STATUS "NOTICE : the registration_with_pointmatcher test requires libpointmatcher and will not be compiled.")
    endif()

    # Executables that require OpenGR
    find_package(OpenGR QUIET)
-    if (OpenGR_FOUND)
-      create_single_source_cgal_program( "registration_with_OpenGR.cpp" )
-      CGAL_target_use_OpenGR(registration_with_OpenGR)
-      CGAL_target_use_Eigen(registration_with_OpenGR)
+    include(CGAL_OpenGR_support)
+    if (TARGET CGAL::OpenGR_support)
+      add_executable(registration_with_OpenGR "registration_with_OpenGR.cpp" )
+      target_link_libraries(registration_with_OpenGR
+        ${CGAL_libs} CGAL::OpenGR_support)
    else()
      message(STATUS "NOTICE : registration_with_OpenGR requires OpenGR, and will not be compiled.")
    endif()

    # Executables that require both libpointmatcher and OpenGR
-    if (libpointmatcher_FOUND AND OpenGR_FOUND)
-      create_single_source_cgal_program( "registration_with_opengr_pointmatcher_pipeline.cpp" )
-      CGAL_target_use_OpenGR(registration_with_opengr_pointmatcher_pipeline)
-      CGAL_target_use_pointmatcher(registration_with_opengr_pointmatcher_pipeline)
-      CGAL_target_use_Eigen(registration_with_opengr_pointmatcher_pipeline)
+    if (TARGET CGAL::pointmatcher_support AND
+        TARGET CGAL::OpenGR_support)
+      add_executable(registration_with_opengr_pointmatcher_pipeline
+        "registration_with_opengr_pointmatcher_pipeline.cpp" )
+      target_link_libraries(registration_with_opengr_pointmatcher_pipeline
+        ${CGAL_libs} CGAL::pointmatcher_support CGAL::OpenGR_support)
    else()
      message(STATUS "NOTICE : registration_with_opengr_pointmatcher_pipeline requires libpointmatcher and OpenGR, and will not be compiled.")
    endif()

-    create_single_source_cgal_program( "callback_example.cpp" )
-    CGAL_target_use_Eigen(callback_example)
-
-    create_single_source_cgal_program( "scale_estimation_example.cpp" )
-    CGAL_target_use_Eigen(scale_estimation_example)
-
-    create_single_source_cgal_program( "scale_estimation_2d_example.cpp" )
-    CGAL_target_use_Eigen(scale_estimation_2d_example)
-
-    create_single_source_cgal_program( "hierarchy_simplification_example.cpp" )
-    CGAL_target_use_Eigen(hierarchy_simplification_example)
-
-    create_single_source_cgal_program( "normals_example.cpp" )
-    CGAL_target_use_Eigen(normals_example)
-
  else()
    message(STATUS "NOTICE: Some of the executables in this directory need Eigen 3.1 (or greater) and will not be compiled.")
  endif()

-  if (TBB_FOUND)
-    foreach(target
-        scale_estimation_example
-        wlop_simplify_and_regularize_point_set_example
-        bilateral_smooth_point_set_example
-        edge_aware_upsample_point_set_example
-        average_spacing_example
-        normals_example
-        jet_smoothing_example
-        normal_estimation
-        callback_example
-        clustering_example)
-      if(TARGET ${target})
-        CGAL_target_use_TBB(${target})
-      endif()
-    endforeach()
-  endif()
-
 else()
    message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
 endif()
--- a/Point_set_processing_3/test/Point_set_processing_3/CMakeLists.txt
+++ b/Point_set_processing_3/test/Point_set_processing_3/CMakeLists.txt
@ -27,6 +27,7 @@ if ( CGAL_FOUND )
  ADD_DEFINITIONS( "-DDEBUG_TRACE" )

  find_package( TBB QUIET )
+  include(CGAL_TBB_support)

  # Executables that do *not* require Eigen
  create_single_source_cgal_program( "read_test.cpp" )
@ -40,30 +41,31 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
+  include(CGAL_Eigen_support)
  if (EIGEN3_FOUND)
    # Executables that require Eigen
    create_single_source_cgal_program( "normal_estimation_test.cpp" )
-    CGAL_target_use_Eigen(normal_estimation_test)
+    target_link_libraries(normal_estimation_test PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "hierarchy_simplification_test.cpp" )
-    CGAL_target_use_Eigen(hierarchy_simplification_test)
+    target_link_libraries(hierarchy_simplification_test PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "smoothing_test.cpp" )
-    CGAL_target_use_Eigen(smoothing_test)
+    target_link_libraries(smoothing_test PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "vcm_plane_test.cpp" )
-    CGAL_target_use_Eigen(vcm_plane_test)
+    target_link_libraries(vcm_plane_test PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "vcm_all_test.cpp" )
-    CGAL_target_use_Eigen(vcm_all_test)
+    target_link_libraries(vcm_all_test PUBLIC CGAL::Eigen_support)

    create_single_source_cgal_program( "jet_pointer_as_property_map.cpp" )
-    CGAL_target_use_Eigen(jet_pointer_as_property_map)
+    target_link_libraries(jet_pointer_as_property_map PUBLIC CGAL::Eigen_support)
  else()
    message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
  endif()

-  if (TBB_FOUND)
+  if (TARGET CGAL::TBB_support)
    foreach(target
        analysis_test
        smoothing_test
@ -72,7 +74,7 @@ if ( CGAL_FOUND )
        edge_aware_upsample_test
        normal_estimation_test)
      if(TARGET ${target})
-        CGAL_target_use_TBB(${target})
+        target_link_libraries(${target} PUBLIC CGAL::TBB_support)
      endif()
    endforeach()
  endif()
@ -82,4 +84,3 @@ else()
    message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Poisson_surface_reconstruction_3/examples/Poisson_surface_reconstruction_3/CMakeLists.txt
+++ b/Poisson_surface_reconstruction_3/examples/Poisson_surface_reconstruction_3/CMakeLists.txt
@ -23,16 +23,17 @@ if ( CGAL_FOUND )

  # Find Eigen3 (requires 3.1.0 or greater)
  find_package(Eigen3 3.1.0)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
    # Executables that require Eigen 3
    create_single_source_cgal_program( "poisson_reconstruction_example.cpp" )
-    CGAL_target_use_Eigen(poisson_reconstruction_example)
+    target_link_libraries(poisson_reconstruction_example PUBLIC CGAL::Eigen_support)
    create_single_source_cgal_program( "poisson_reconstruction.cpp" )
-    CGAL_target_use_Eigen(poisson_reconstruction)
+    target_link_libraries(poisson_reconstruction PUBLIC CGAL::Eigen_support)
    create_single_source_cgal_program( "poisson_reconstruction_function.cpp" )
-    CGAL_target_use_Eigen(poisson_reconstruction_function)
+    target_link_libraries(poisson_reconstruction_function PUBLIC CGAL::Eigen_support)
    create_single_source_cgal_program( "tutorial_example.cpp" )
-    CGAL_target_use_Eigen(tutorial_example)
+    target_link_libraries(tutorial_example PUBLIC CGAL::Eigen_support)
  else()
    message(STATUS "NOTICE: The examples need Eigen 3.1 (or greater) will not be compiled.")
  endif()
@ -43,4 +44,3 @@ else()
    message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Poisson_surface_reconstruction_3/test/Poisson_surface_reconstruction_3/CMakeLists.txt
+++ b/Poisson_surface_reconstruction_3/test/Poisson_surface_reconstruction_3/CMakeLists.txt
@ -24,10 +24,11 @@ if ( CGAL_FOUND )
  # Temporary debugging stuff

  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if(EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if(TARGET CGAL::Eigen_support)
    # Executables that require Eigen 3.1
    create_single_source_cgal_program( "poisson_reconstruction_test.cpp" )
-    CGAL_target_use_Eigen(poisson_reconstruction_test)
+    target_link_libraries(poisson_reconstruction_test PUBLIC CGAL::Eigen_support)
  else()

    message(STATUS "NOTICE: Some of the executables in this directory need Eigen 3.1 (or greater) and will not be compiled.")
@ -39,4 +40,3 @@ else()
    message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Polygon_mesh_processing/benchmark/Polygon_mesh_processing/CMakeLists.txt
+++ b/Polygon_mesh_processing/benchmark/Polygon_mesh_processing/CMakeLists.txt
@ -29,6 +29,7 @@ endif()

 # include for local package
 find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
+include(CGAL_Eigen_support)

 # Creating entries for all .cpp/.C files with "main" routine
 # ##########################################################
@ -37,8 +38,7 @@ create_single_source_cgal_program( "polygon_mesh_slicer.cpp" )

 create_single_source_cgal_program( "hole_filling.cpp" )

-if (EIGEN3_FOUND)
-  CGAL_target_use_Eigen(polygon_mesh_slicer)
-  CGAL_target_use_Eigen(hole_filling)
+if (TARGET CGAL::Eigen_support)
+  target_link_libraries(polygon_mesh_slicer PUBLIC CGAL::Eigen_support)
+  target_link_libraries(hole_filling PUBLIC CGAL::Eigen_support)
 endif()
-
--- a/Polygon_mesh_processing/examples/Polygon_mesh_processing/CMakeLists.txt
+++ b/Polygon_mesh_processing/examples/Polygon_mesh_processing/CMakeLists.txt
@ -38,6 +38,7 @@ endif()

 # include for local package
 find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
+include(CGAL_Eigen_support)


 # Creating entries for all .cpp/.C files with "main" routine
@ -45,18 +46,18 @@ find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)

 create_single_source_cgal_program( "hausdorff_distance_remeshing_example.cpp")

-if (EIGEN3_FOUND)
+if (TARGET CGAL::Eigen_support)
  create_single_source_cgal_program( "hole_filling_example.cpp" )
-  CGAL_target_use_Eigen(hole_filling_example)
+  target_link_libraries(hole_filling_example PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "hole_filling_example_SM.cpp" )
-  CGAL_target_use_Eigen(hole_filling_example_SM)
+  target_link_libraries(hole_filling_example_SM PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "refine_fair_example.cpp")
-  CGAL_target_use_Eigen(refine_fair_example)
+  target_link_libraries(refine_fair_example PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "shape_smoothing_example.cpp")
-  CGAL_target_use_Eigen(shape_smoothing_example)
+  target_link_libraries(shape_smoothing_example PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program( "hole_filling_example_LCC.cpp" )
-  CGAL_target_use_Eigen(hole_filling_example_LCC)
-endif(EIGEN3_FOUND)
+  target_link_libraries(hole_filling_example_LCC PUBLIC CGAL::Eigen_support)
+endif()

 create_single_source_cgal_program( "self_intersections_example.cpp" )
 create_single_source_cgal_program( "stitch_borders_example.cpp" )
@ -98,10 +99,9 @@ if(OpenMesh_FOUND)
 create_single_source_cgal_program( "compute_normals_example_OM.cpp" )
 target_link_libraries( compute_normals_example_OM PRIVATE ${OPENMESH_LIBRARIES} )

-if (EIGEN3_FOUND)
+if (TARGET CGAL::Eigen_support)
  create_single_source_cgal_program( "hole_filling_example_OM.cpp" )
-  target_link_libraries( hole_filling_example_OM PRIVATE ${OPENMESH_LIBRARIES} )
-  CGAL_target_use_Eigen( hole_filling_example_OM )
+  target_link_libraries( hole_filling_example_OM PRIVATE CGAL::Eigen_support ${OPENMESH_LIBRARIES} )
 endif()

 create_single_source_cgal_program( "point_inside_example_OM.cpp")
@ -118,9 +118,10 @@ target_link_libraries( triangulate_faces_example_OM PRIVATE ${OPENMESH_LIBRARIES
 endif(OpenMesh_FOUND)

 find_package( TBB )
-if( TBB_FOUND )
-  CGAL_target_use_TBB(self_intersections_example)
-  CGAL_target_use_TBB(hausdorff_distance_remeshing_example)
+include(CGAL_TBB_support)
+if( TARGET CGAL::TBB_support )
+  target_link_libraries(self_intersections_example PUBLIC CGAL::TBB_support)
+  target_link_libraries(hausdorff_distance_remeshing_example PUBLIC CGAL::TBB_support)
 else()
  message( STATUS "NOTICE: Intel TBB was not found. Sequential code will be used." )
 endif()
--- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
+++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
@ -29,7 +29,7 @@
 #include <CGAL/spatial_sort.h>

 #ifdef CGAL_LINKED_WITH_TBB
-#include "tbb/parallel_reduce.h"
+#include <tbb/parallel_reduce.h>
 #include <tbb/blocked_range.h>
 #include <atomic>
 #endif // CGAL_LINKED_WITH_TBB
@ -82,7 +82,7 @@ struct Distance_computation{
  const PointRange& sample_points;
  Point_3 initial_hint;
  double distance;
-  //constro
+  //constructor
  Distance_computation(
          const AABB_tree& tree,
          const Point_3& p,
@ -92,7 +92,7 @@ struct Distance_computation{
    , initial_hint(p)
    , distance(-1)
  {}
-  //split constro
+  //split constructor
  Distance_computation(Distance_computation& s, tbb::split )
    : tree(s.tree)
    , sample_points(s.sample_points)
@ -117,7 +117,7 @@ struct Distance_computation{
      distance = hdist;
  }

-  void join( Distance_computation& rhs ) {distance = std::max(rhs.distance, distance); }
+  void join( Distance_computation& rhs ) {distance = (std::max)(rhs.distance, distance); }
 };
 #endif

--- a/Polygon_mesh_processing/test/Polygon_mesh_processing/CMakeLists.txt
+++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/CMakeLists.txt
@ -31,22 +31,24 @@ endif()

 # include for local package
 find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
+include(CGAL_Eigen_support)

 find_package( TBB )
+include(CGAL_TBB_support)

-if (EIGEN3_FOUND)
+if (TARGET CGAL::Eigen_support)
  # Creating entries for all .cpp/.C files with "main" routine
  # ##########################################################
  create_single_source_cgal_program("fairing_test.cpp")
-  CGAL_target_use_Eigen(fairing_test)
+  target_link_libraries(fairing_test PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program("triangulate_hole_Polyhedron_3_no_delaunay_test.cpp" )
-  CGAL_target_use_Eigen(triangulate_hole_Polyhedron_3_no_delaunay_test)
+  target_link_libraries(triangulate_hole_Polyhedron_3_no_delaunay_test PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program("triangulate_hole_Polyhedron_3_test.cpp")
-  CGAL_target_use_Eigen(triangulate_hole_Polyhedron_3_test)
+  target_link_libraries(triangulate_hole_Polyhedron_3_test PUBLIC CGAL::Eigen_support)
  create_single_source_cgal_program("test_shape_smoothing.cpp")
-  CGAL_target_use_Eigen(test_shape_smoothing)
+  target_link_libraries(test_shape_smoothing PUBLIC CGAL::Eigen_support)

-endif(EIGEN3_FOUND)
+endif()

 find_package( OpenMesh QUIET )
 if ( OpenMesh_FOUND )
@ -103,11 +105,10 @@ endif()
  create_single_source_cgal_program("test_remove_caps_needles.cpp")
 #  create_single_source_cgal_program("test_pmp_repair_self_intersections.cpp")

-  if( TBB_FOUND )
-    include(CGAL_target_use_TBB)
-    CGAL_target_use_TBB(test_pmp_distance)
-    CGAL_target_use_TBB(orient_polygon_soup_test)
-    CGAL_target_use_TBB(self_intersection_surface_mesh_test)
+  if( TARGET CGAL::TBB_support )
+    target_link_libraries(test_pmp_distance PUBLIC CGAL::TBB_support)
+    target_link_libraries(orient_polygon_soup_test PUBLIC CGAL::TBB_support)
+    target_link_libraries(self_intersection_surface_mesh_test PUBLIC CGAL::TBB_support)
  else()
    message( STATUS "NOTICE: Intel TBB was not found. test_pmp_distance will use sequential code." )
  endif()
--- a/Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/CMakeLists.txt
+++ b/Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/CMakeLists.txt
@ -37,15 +37,18 @@ endif()
 include( CGAL_CreateSingleSourceCGALProgram )

 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-if(NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if(NOT TARGET CGAL::Eigen_support)
  message(STATUS "NOTICE: This project requires Eigen 3.1 (or greater) and will not be compiled.")
  return()
 endif()

 find_package(SCIP QUIET)
-if (NOT SCIP_FOUND )
+include(CGAL_SCIP_support)
+if (NOT TARGET CGAL::SCIP_support )
  find_package( GLPK QUIET)
-  if ( NOT GLPK_FOUND )
+  include(CGAL_GLPK_support)
+  if (NOT TARGET CGAL::GLPK_support )
    message( STATUS "NOTICE: This project requires either SCIP or GLPK, and will not be compiled.")
    return()
  endif()
@ -61,10 +64,10 @@ foreach(target
    polyfit_example_user_provided_planes
    polyfit_example_model_complexty_control
    polyfit_example_with_region_growing)
-  CGAL_target_use_Eigen(${target})
-  if (SCIP_FOUND)
-    CGAL_target_use_SCIP(${target})
+  target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
+  if (TARGET CGAL::SCIP_support)
+    target_link_libraries(${target} PUBLIC CGAL::SCIP_support)
  else()
-    CGAL_target_use_GLPK(${target})
+    target_link_libraries(${target} PUBLIC CGAL::GLPK_support)
  endif()
 endforeach()
--- a/Polygonal_surface_reconstruction/test/Polygonal_surface_reconstruction/CMakeLists.txt
+++ b/Polygonal_surface_reconstruction/test/Polygonal_surface_reconstruction/CMakeLists.txt
@ -38,24 +38,27 @@ include( CGAL_CreateSingleSourceCGALProgram )


 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-if(NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if(NOT TARGET CGAL::Eigen_support)
  message(STATUS "NOTICE: This project requires Eigen 3.1 (or greater) and will not be compiled.")
  return()
 endif()

 find_package(SCIP QUIET)
-if (NOT SCIP_FOUND )
+include(CGAL_SCIP_support)
+if (NOT TARGET CGAL::SCIP_support )
  find_package( GLPK QUIET)
-  if ( NOT GLPK_FOUND )
-    message( STATUS "NOTICE : This project requires either SCIP or GLPK, and will not be compiled.")
+  include(CGAL_GLPK_support)
+  if (NOT TARGET CGAL::GLPK_support )
+    message( STATUS "NOTICE: This project requires either SCIP or GLPK, and will not be compiled.")
    return()
  endif()
 endif()

 create_single_source_cgal_program( "polygonal_surface_reconstruction_test.cpp")
-CGAL_target_use_Eigen(polygonal_surface_reconstruction_test)
-if (SCIP_FOUND)
-  CGAL_target_use_SCIP(polygonal_surface_reconstruction_test)
+target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::Eigen_support)
+if (TARGET CGAL::SCIP_support)
+  target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::SCIP_support)
 else()
-  CGAL_target_use_GLPK(polygonal_surface_reconstruction_test)
+  target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::GLPK_support)
 endif()
--- a/Polyhedron/demo/Polyhedron/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/CMakeLists.txt
@ -73,6 +73,7 @@ if(Qt5_FOUND)
 endif(Qt5_FOUND)

 find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
+include(CGAL_Eigen_support)

 find_package( METIS )

@ -87,7 +88,8 @@ option(POLYHEDRON_DEMO_ACTIVATE_CONCURRENCY

 if( POLYHEDRON_DEMO_ACTIVATE_CONCURRENCY )
  find_package( TBB )
-  if( NOT TBB_FOUND )
+  include(CGAL_TBB_support)
+  if( NOT TARGET CGAL::TBB_support )
    message( STATUS "NOTICE: Intel TBB was not found. Bilateral smoothing and WLOP plugins are faster if TBB is linked." )
  endif()
 endif()
@ -108,7 +110,8 @@ if( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
  add_definitions( -DCGAL_CONCURRENT_MESH_3 )
  if(NOT TBB_FOUND)
    find_package( TBB REQUIRED )
-    if( NOT TBB_FOUND )
+    include( CGAL_TBB_support)
+    if( NOT TARGET CGAL::TBB_support )
      message(STATUS "NOTICE: Intel TBB was not found. Mesh_3 is faster if TBB is linked.")
    endif()
  endif()
@ -119,6 +122,7 @@ else( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
    ON)
  if( LINK_WITH_TBB )
    find_package( TBB )
+    include( CGAL_TBB_support)
  endif( LINK_WITH_TBB )
 endif()

@ -248,8 +252,8 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)

  add_item(scene_c3t3_item Scene_c3t3_item.cpp)
  target_link_libraries(scene_c3t3_item PUBLIC scene_surface_mesh_item scene_polygon_soup_item scene_basic_objects ${TBB_LIBRARIES})
-  if(TBB_FOUND)
-    CGAL_target_use_TBB(scene_c3t3_item)
+  if(TARGET CGAL::TBB_support)
+    target_link_libraries(scene_c3t3_item PUBLIC CGAL::TBB_support)
  endif()
  if(COMMAND target_precompile_headers)
    # Support for precompiled headers, for Mesh_3 (since CMake 3.16)
@ -261,7 +265,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
  add_item(scene_surface_mesh_item Scene_surface_mesh_item.cpp)

  if(TBB_FOUND)
-    CGAL_target_use_TBB(scene_surface_mesh_item)
+    target_link_libraries(scene_surface_mesh_item PUBLIC CGAL::TBB_support)
  endif()
  # special

@ -274,7 +278,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
  add_item(scene_selection_item Scene_polyhedron_selection_item.cpp)
  target_link_libraries(scene_selection_item PUBLIC scene_item_decorator  scene_k_ring_selection)
 if(TBB_FOUND)
-    CGAL_target_use_TBB(scene_selection_item)
+    target_link_libraries(scene_selection_item PUBLIC CGAL::TBB_support)
  endif()

  add_item(scene_shortest_path_item Plugins/Surface_mesh/Scene_polyhedron_shortest_path_item.cpp)
@ -282,17 +286,16 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)

  add_item(scene_movable_sm_item Plugins/AABB_tree/Scene_movable_sm_item.cpp)

-  if(EIGEN3_FOUND )
+  if(TARGET CGAL::Eigen_support )
    add_item(scene_textured_item Scene_textured_surface_mesh_item.cpp texture.cpp)
-    CGAL_target_use_Eigen(scene_textured_item)
+    target_link_libraries(scene_textured_item PUBLIC CGAL::Eigen_support)
    qt5_wrap_ui( editionUI_FILES Plugins/Surface_mesh_deformation/Deform_mesh.ui )
    add_item(scene_edit_item Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.cpp
      ${editionUI_FILES})
-    CGAL_target_use_Eigen(scene_edit_item)
-    target_link_libraries(scene_edit_item PUBLIC scene_surface_mesh_item scene_k_ring_selection
+    target_link_libraries(scene_edit_item PUBLIC CGAL::Eigen_support scene_surface_mesh_item scene_k_ring_selection
      scene_basic_objects)
    add_item(scene_mcf_item Plugins/PMP/Scene_mcf_item.cpp)
-    CGAL_target_use_Eigen(scene_mcf_item)
+    target_link_libraries(scene_mcf_item PUBLIC CGAL::Eigen_support)
  endif()

  add_item(scene_implicit_function_item Scene_implicit_function_item.cpp )
@ -305,20 +308,21 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
  target_link_libraries(scene_nef_polyhedron_item PUBLIC scene_surface_mesh_item)

  add_item(scene_points_with_normal_item Scene_points_with_normal_item.cpp)
-  if (EIGEN3_FOUND)
-    CGAL_target_use_Eigen(scene_points_with_normal_item)
+  if (TARGET CGAL::Eigen_support)
+    target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::Eigen_support)
  endif()

  find_package(LASLIB)
-  if (LASLIB_FOUND)
-    CGAL_target_use_LASLIB(scene_points_with_normal_item)
+  include(CGAL_LASLIB_support)
+  if (TARGET CGAL::LASLIB_support)
+    target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::LASLIB_support)
    if (MSVC)
      target_compile_definitions( scene_points_with_normal_item PUBLIC "-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS")
    endif()
  endif()

  if(TBB_FOUND)
-    CGAL_target_use_TBB(scene_points_with_normal_item)
+    target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::TBB_support)
  endif()

  add_item(scene_polylines_item Scene_polylines_item.cpp)
--- a/Polyhedron/demo/Polyhedron/MainWindow.cpp
+++ b/Polyhedron/demo/Polyhedron/MainWindow.cpp
@ -1027,7 +1027,7 @@ void MainWindow::computeViewerBBox(CGAL::qglviewer::Vec& vmin, CGAL::qglviewer::
  double l_dist = (std::max)((std::abs)(bbox_center.x - viewer->offset().x),
                             (std::max)((std::abs)(bbox_center.y - viewer->offset().y),
                                        (std::abs)(bbox_center.z - viewer->offset().z)));
-  if((std::log2)(l_dist/bbox_diag) > 13.0 )
+  if((std::log2)(l_dist/bbox_diag) > 11.0 )
    for(int i=0; i<3; ++i)
    {
      offset[i] = -bbox_center[i];
--- a/Polyhedron/demo/Polyhedron/Plugins/AABB_tree/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/AABB_tree/CMakeLists.txt
@ -5,6 +5,6 @@ target_link_libraries(do_trees_intersect_plugin PUBLIC scene_surface_mesh_item s

 polyhedron_demo_plugin(cut_plugin Cut_plugin )
 target_link_libraries(cut_plugin PUBLIC scene_surface_mesh_item scene_basic_objects scene_color_ramp)
-if(TBB_FOUND)
-  CGAL_target_use_TBB(cut_plugin)
+if(TARGET CGAL::TBB_support)
+  target_link_libraries(cut_plugin PUBLIC CGAL::TBB_support)
 endif()
--- a/Polyhedron/demo/Polyhedron/Plugins/Classification/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/Classification/CMakeLists.txt
@ -1,54 +1,61 @@
 include( polyhedron_demo_macros )

-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)

  set(Classification_dependencies_met TRUE)

  find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
-  if (NOT Boost_SERIALIZATION_FOUND)
+  include(CGAL_Boost_serialization_support)
+  include(CGAL_Boost_iostreams_support)
+  if (NOT TARGET CGAL::Boost_serialization_support)
    message(STATUS "NOTICE: Boost Serialization not found. Classification plugin won't be available.")
    set(Classification_dependencies_met FALSE)
  endif()

-  if (NOT Boost_IOSTREAMS_FOUND)
+  if (NOT TARGET CGAL::Boost_iostreams_support)
    message(STATUS "NOTICE: Boost IOStreams not found. Classification plugin won't be available.")
    set(Classification_dependencies_met FALSE)
  endif()

  find_package(OpenCV QUIET COMPONENTS core ml) # Need core + machine learning
-  if (NOT OpenCV_FOUND)
+  include(CGAL_OpenCV_support)
+  if (NOT TARGET CGAL::OpenCV_support)
    message(STATUS "NOTICE: OpenCV was not found. OpenCV random forest predicate for classification won't be available.")
  endif()

  find_package(TensorFlow QUIET)
-  if (NOT TensorFlow_FOUND)
+  include(CGAL_TensorFlow_support)
+  if (NOT TARGET CGAL::TensorFlow_support)
    message(STATUS "NOTICE: TensorFlow not found, Neural Network predicate for classification won't be available.")
  endif()

  if (Classification_dependencies_met)
    qt5_wrap_ui( classificationUI_FILES Classification_widget.ui Classification_advanced_widget.ui )
    polyhedron_demo_plugin(classification_plugin Classification_plugin Point_set_item_classification Cluster_classification Surface_mesh_item_classification ${classificationUI_FILES} KEYWORDS Classification)
-    target_link_libraries(classification_plugin PUBLIC scene_points_with_normal_item
-      scene_polylines_item scene_polygon_soup_item scene_surface_mesh_item scene_selection_item scene_color_ramp)
+    target_link_libraries(classification_plugin PUBLIC
+      scene_points_with_normal_item
+      scene_polylines_item
+      scene_polygon_soup_item
+      scene_surface_mesh_item
+      scene_selection_item
+      scene_color_ramp
+      CGAL::Eigen_support
+      CGAL::Boost_serialization_support
+      CGAL::Boost_iostreams_support)

-    CGAL_target_use_Eigen(classification_plugin)
-    CGAL_target_use_Boost_IOStreams(classification_plugin)
-    CGAL_target_use_Boost_Serialization(classification_plugin)
    if(OpenCV_FOUND)
-      CGAL_target_use_OpenCV(classification_plugin)
+      target_link_libraries(classification_plugin PUBLIC CGAL::OpenCV_support)
    endif()
    if(TensorFlow_FOUND)
-      CGAL_target_use_TensorFlow(classification_plugin)
+      target_link_libraries(classification_plugin PUBLIC CGAL::TensorFlow_support)
    endif()
    if(TBB_FOUND)
-      CGAL_target_use_TBB(classification_plugin)
+      target_link_libraries(classification_plugin PUBLIC CGAL::TBB_support)
    endif()

    add_dependencies(classification_plugin point_set_selection_plugin selection_plugin)
  endif()

-else(EIGEN3_FOUND)
+else()
  message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. Classification plugin will not be available.")
 endif()
-
-
--- a/Polyhedron/demo/Polyhedron/Plugins/Display/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/Display/CMakeLists.txt
@ -1,7 +1,6 @@
 include( polyhedron_demo_macros )
-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)
  qt5_wrap_ui( display_propertyUI_FILES Display_property.ui )
  polyhedron_demo_plugin(display_property_plugin Display_property_plugin ${display_propertyUI_FILES})
-  target_link_libraries(display_property_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_color_ramp)
-  CGAL_target_use_Eigen(display_property_plugin)
-endif(EIGEN3_FOUND)
+  target_link_libraries(display_property_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_color_ramp CGAL::Eigen_support)
+endif()
--- a/Polyhedron/demo/Polyhedron/Plugins/IO/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/IO/CMakeLists.txt
@ -72,11 +72,10 @@ else()
  target_link_libraries(ply_plugin PUBLIC scene_points_with_normal_item scene_polygon_soup_item scene_surface_mesh_item scene_textured_item)
  target_compile_features(ply_plugin PRIVATE ${needed_cxx_features})

-  if (LASLIB_FOUND)
+  if (TARGET CGAL::LASLIB_support)
    polyhedron_demo_plugin(las_plugin LAS_io_plugin KEYWORDS IO PointSetProcessing Classification)
-    target_link_libraries(las_plugin PUBLIC scene_points_with_normal_item)
+    target_link_libraries(las_plugin PUBLIC scene_points_with_normal_item CGAL::LASLIB_support)
    target_compile_features(las_plugin PRIVATE ${needed_cxx_features})
-    CGAL_target_use_LASLIB(las_plugin)
  else()
    message(STATUS "NOTICE : the LAS IO plugin needs LAS libraries and will not be compiled.")
  endif()
--- a/Polyhedron/demo/Polyhedron/Plugins/IO/Implicit_function_io_plugin.cpp
+++ b/Polyhedron/demo/Polyhedron/Plugins/IO/Implicit_function_io_plugin.cpp
@ -96,7 +96,7 @@ init(QMainWindow* mainWindow, CGAL::Three::Scene_interface* scene_interface, Mes
  QMenu* menu = menuFile->findChild<QMenu*>("menuGenerateObject");
  if(!menu){
    QAction* actionLoad = mw->findChild<QAction*>("actionLoadPlugin");
-    menu = new QMenu(tr("Generate &Objet"), menuFile);
+    menu = new QMenu(tr("Generate &Object"), menuFile);
    menu->setObjectName("menuGenerateObject");
    menuFile->insertMenu(actionLoad, menu);
  }
--- a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/CMakeLists.txt
@ -54,9 +54,10 @@ target_link_libraries(mesh_3_optimization_plugin PUBLIC scene_c3t3_item scene_su

 # Use Eigen
 find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
+ include(CGAL_Eigen_support)

- if (EIGEN3_FOUND)
-   CGAL_target_use_Eigen(mesh_3_optimization_plugin)
+ if (TARGET CGAL::Eigen_support)
+   target_link_libraries(mesh_3_optimization_plugin PUBLIC CGAL::Eigen_support)
 else() #eigen
   message(STATUS "The Mesh_3_optimization_plugin requires Eigen, which was not found, and will use a deprecated class to replace it. Warnings are to be expected.")
 endif()#eigen
@ -69,8 +70,8 @@ polyhedron_demo_plugin(c3t3_rib_exporter_plugin C3t3_rib_exporter_plugin ${ribUI
 target_link_libraries(c3t3_rib_exporter_plugin PUBLIC scene_c3t3_item)

 if(TBB_FOUND)
-  CGAL_target_use_TBB(mesh_3_plugin)
-  CGAL_target_use_TBB(mesh_3_optimization_plugin)
-  CGAL_target_use_TBB(c3t3_io_plugin)
-  CGAL_target_use_TBB(c3t3_rib_exporter_plugin)
+  target_link_libraries(mesh_3_plugin PUBLIC CGAL::TBB_support)
+  target_link_libraries(mesh_3_optimization_plugin PUBLIC CGAL::TBB_support)
+  target_link_libraries(c3t3_io_plugin PUBLIC CGAL::TBB_support)
+  target_link_libraries(c3t3_rib_exporter_plugin PUBLIC CGAL::TBB_support)
 endif()
--- a/Polyhedron/demo/Polyhedron/Plugins/Operations_on_polyhedra/PartitionDialog.ui
+++ b/Polyhedron/demo/Polyhedron/Plugins/Operations_on_polyhedra/PartitionDialog.ui
@ -67,7 +67,7 @@
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Sans Serif'; font-size:9pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Tip: To split your mesh according to the result of this operation, you can click on &lt;/p&gt;
-&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Operations-&amp;gt;Operations on Polyhedra-&amp;gt;Split Selected Polyhedra&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Operations-&amp;gt;Polygon Mesh Processing-&amp;gt;Split Selected Polyhedra&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
     </property>
    </widget>
   </item>
--- a/Polyhedron/demo/Polyhedron/Plugins/PMP/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/CMakeLists.txt
@ -1,33 +1,29 @@
 include( polyhedron_demo_macros )
-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)

  polyhedron_demo_plugin(jet_fitting_plugin Jet_fitting_plugin)
-  target_link_libraries(jet_fitting_plugin PUBLIC scene_surface_mesh_item scene_polylines_item)
-  CGAL_target_use_Eigen(jet_fitting_plugin)
+  target_link_libraries(jet_fitting_plugin PUBLIC scene_surface_mesh_item scene_polylines_item CGAL::Eigen_support)

-else(EIGEN3_FOUND)
+else()
  message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. Jet fitting plugin will not be available.")
-endif(EIGEN3_FOUND)
+endif()

 polyhedron_demo_plugin(extrude_plugin Extrude_plugin KEYWORDS PMP)
 target_link_libraries(extrude_plugin PUBLIC scene_surface_mesh_item scene_selection_item)

-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)
  if("${EIGEN3_VERSION}" VERSION_GREATER "3.1.90")

    qt5_wrap_ui( hole_fillingUI_FILES Hole_filling_widget.ui)
    polyhedron_demo_plugin(hole_filling_plugin Hole_filling_plugin ${hole_fillingUI_FILES} KEYWORDS PMP)
-    target_link_libraries(hole_filling_plugin PUBLIC scene_surface_mesh_item scene_polylines_item scene_selection_item)
-    CGAL_target_use_Eigen(hole_filling_plugin)
+    target_link_libraries(hole_filling_plugin PUBLIC scene_surface_mesh_item scene_polylines_item scene_selection_item CGAL::Eigen_support)

    qt5_wrap_ui( fairingUI_FILES Fairing_widget.ui)
    polyhedron_demo_plugin(fairing_plugin Fairing_plugin ${fairingUI_FILES} KEYWORDS PMP)
-    target_link_libraries(fairing_plugin PUBLIC scene_selection_item)
-    CGAL_target_use_Eigen(fairing_plugin)
+    target_link_libraries(fairing_plugin PUBLIC scene_selection_item CGAL::Eigen_support)

    polyhedron_demo_plugin(hole_filling_polyline_plugin Hole_filling_polyline_plugin )
-    target_link_libraries(hole_filling_polyline_plugin PUBLIC scene_surface_mesh_item scene_polylines_item)
-    CGAL_target_use_Eigen(hole_filling_polyline_plugin)
+    target_link_libraries(hole_filling_polyline_plugin PUBLIC scene_surface_mesh_item scene_polylines_item CGAL::Eigen_support)

    qt5_wrap_ui( Mean_curvature_flow_skeleton_pluginUI_FILES  Mean_curvature_flow_skeleton_plugin.ui)
    polyhedron_demo_plugin(mean_curvature_flow_skeleton_plugin Mean_curvature_flow_skeleton_plugin ${Mean_curvature_flow_skeleton_pluginUI_FILES})
@ -37,20 +33,19 @@ if(EIGEN3_FOUND)
        scene_points_with_normal_item
        scene_polylines_item
        scene_mcf_item
-        demo_framework)
-      CGAL_target_use_Eigen(mean_curvature_flow_skeleton_plugin)
+        demo_framework
+        CGAL::Eigen_support)
      # The smoothing plugin can still do some things, even if Ceres is not found
      qt5_wrap_ui( smoothingUI_FILES Smoothing_plugin.ui)
      polyhedron_demo_plugin(smoothing_plugin Smoothing_plugin ${smoothingUI_FILES})
-      target_link_libraries(smoothing_plugin PUBLIC scene_surface_mesh_item scene_selection_item)
-      CGAL_target_use_Eigen(smoothing_plugin)
+      target_link_libraries(smoothing_plugin PUBLIC scene_surface_mesh_item scene_selection_item CGAL::Eigen_support)
      find_package(Ceres QUIET)
      if(TARGET ceres)
        target_compile_definitions( smoothing_plugin PRIVATE CGAL_PMP_USE_CERES_SOLVER )
        target_link_libraries(smoothing_plugin PUBLIC ceres)
      endif()

-      CGAL_target_use_Eigen(extrude_plugin)
+      target_link_libraries(extrude_plugin PUBLIC CGAL::Eigen_support)
  else()
    message(STATUS "NOTICE: The hole filling and fairing plugins require Eigen 3.2 (or higher) and will not be available.")
  endif()
@ -106,17 +101,16 @@ qt5_wrap_ui( isotropicRemeshingUI_FILES Isotropic_remeshing_dialog.ui)
 polyhedron_demo_plugin(isotropic_remeshing_plugin Isotropic_remeshing_plugin  ${isotropicRemeshingUI_FILES} KEYWORDS PMP)
 target_link_libraries(isotropic_remeshing_plugin PUBLIC scene_surface_mesh_item scene_selection_item)

-if(TBB_FOUND)
-  CGAL_target_use_TBB(isotropic_remeshing_plugin)
+if(TARGET CGAL::TBB_support)
+  target_link_libraries(isotropic_remeshing_plugin PUBLIC CGAL::TBB_support)
 endif()

 polyhedron_demo_plugin(distance_plugin Distance_plugin KEYWORDS PMP)
 target_link_libraries(distance_plugin PUBLIC scene_surface_mesh_item  scene_color_ramp)
-if(TBB_FOUND)
-  CGAL_target_use_TBB(distance_plugin)
+if(TARGET CGAL::TBB_support)
+  target_link_libraries(distance_plugin PUBLIC CGAL::TBB_support)
 endif()

-
 polyhedron_demo_plugin(detect_sharp_edges_plugin Detect_sharp_edges_plugin KEYWORDS IO Mesh_3 PMP)
 target_link_libraries(detect_sharp_edges_plugin PUBLIC scene_surface_mesh_item)

@ -130,4 +124,3 @@ target_link_libraries(degenerated_faces_plugin PUBLIC scene_surface_mesh_item sc
 qt5_wrap_ui( engravUI_FILES Engrave_dock_widget.ui )
 polyhedron_demo_plugin(engrave_text_plugin Engrave_text_plugin ${engravUI_FILES})
 target_link_libraries(engrave_text_plugin PUBLIC scene_surface_mesh_item scene_selection_item scene_polylines_item)
-
--- a/Polyhedron/demo/Polyhedron/Plugins/Point_set/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/Point_set/CMakeLists.txt
@ -1,62 +1,60 @@
 include( polyhedron_demo_macros )
-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)

  find_package(SCIP QUIET)
-  if(NOT SCIP_FOUND)
+  include(CGAL_SCIP_support)
+  if(NOT TARGET CGAL::SCIP_support)
    find_package(GLPK QUIET)
+    include(CGAL_GLPK_support)
  endif()

-  if(NOT SCIP_FOUND AND NOT GLPK_FOUND)
+  if(NOT TARGET CGAL::SCIP_support AND NOT TARGET CGAL::GLPK_support)
    message(STATUS "NOTICE: SCIP and GLPK were not found. Polygonal surface reconstruction will not be available.")
  endif()

  qt5_wrap_ui( surface_reconstructionUI_FILES Surface_reconstruction_plugin.ui)
  polyhedron_demo_plugin(surface_reconstruction_plugin Surface_reconstruction_plugin Surface_reconstruction_poisson_impl Surface_reconstruction_advancing_front_impl Surface_reconstruction_scale_space_impl Surface_reconstruction_polygonal_impl ${surface_reconstructionUI_FILES} KEYWORDS PointSetProcessing)
-  target_link_libraries(surface_reconstruction_plugin PUBLIC scene_polygon_soup_item scene_surface_mesh_item scene_points_with_normal_item)
-  CGAL_target_use_Eigen(surface_reconstruction_plugin)
+  target_link_libraries(surface_reconstruction_plugin PUBLIC scene_polygon_soup_item scene_surface_mesh_item scene_points_with_normal_item CGAL::Eigen_support)

-  if (SCIP_FOUND)
-    CGAL_target_use_SCIP(surface_reconstruction_plugin)
-  elseif(GLPK_FOUND)
-    CGAL_target_use_GLPK(surface_reconstruction_plugin)
+  if (TARGET CGAL::SCIP_support)
+    target_link_libraries(surface_reconstruction_plugin PUBLIC CGAL::SCIP_support)
+  elseif(TARGET CGAL::GLPK_support)
+    target_link_libraries(surface_reconstruction_plugin PUBLIC CGAL::GLPK_support)
  endif()

  qt5_wrap_ui( point_set_normal_estimationUI_FILES Point_set_normal_estimation_plugin.ui)
  polyhedron_demo_plugin(point_set_normal_estimation_plugin Point_set_normal_estimation_plugin ${point_set_normal_estimationUI_FILES} KEYWORDS PointSetProcessing Classification)
-  target_link_libraries(point_set_normal_estimation_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
-  CGAL_target_use_Eigen(point_set_normal_estimation_plugin)
+  target_link_libraries(point_set_normal_estimation_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)

  qt5_wrap_ui( features_detection_pluginUI_FILES Features_detection_plugin.ui)
  polyhedron_demo_plugin(features_detection_plugin Features_detection_plugin ${features_detection_pluginUI_FILES} KEYWORDS PointSetProcessing)
-  target_link_libraries(features_detection_plugin PUBLIC scene_points_with_normal_item)
-  CGAL_target_use_Eigen(features_detection_plugin)
+  target_link_libraries(features_detection_plugin PUBLIC scene_points_with_normal_item CGAL::Eigen_support)

  polyhedron_demo_plugin(point_set_smoothing_plugin Point_set_smoothing_plugin KEYWORDS PointSetProcessing)
-  target_link_libraries(point_set_smoothing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
-  CGAL_target_use_Eigen(point_set_smoothing_plugin)
+  target_link_libraries(point_set_smoothing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)

  polyhedron_demo_plugin(point_set_average_spacing_plugin Point_set_average_spacing_plugin KEYWORDS PointSetProcessing Classification)
-  target_link_libraries(point_set_average_spacing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
-  CGAL_target_use_Eigen(point_set_average_spacing_plugin)
+  target_link_libraries(point_set_average_spacing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)

  qt5_wrap_ui(point_set_shape_detectionUI_FILES Point_set_shape_detection_plugin.ui)
  polyhedron_demo_plugin(point_set_shape_detection_plugin Point_set_shape_detection_plugin ${point_set_shape_detectionUI_FILES} KEYWORDS PointSetProcessing Classification)
-  target_link_libraries(point_set_shape_detection_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_polygon_soup_item scene_callback_signaler)
-  CGAL_target_use_Eigen(point_set_shape_detection_plugin)
+  target_link_libraries(point_set_shape_detection_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_polygon_soup_item scene_callback_signaler CGAL::Eigen_support)

  find_package(OpenGR QUIET)
+  include(CGAL_OpenGR_support)
  find_package(libpointmatcher QUIET)
+  include(CGAL_pointmatcher_support)

-  if (OpenGR_FOUND OR libpointmatcher_FOUND)
+  if (TARGET CGAL::OpenGR_support OR CGAL::pointmatcher_support)
    qt5_wrap_ui(register_point_setsUI_FILES Register_point_sets_plugin.ui)
    polyhedron_demo_plugin(register_point_sets_plugin Register_point_sets_plugin ${register_point_setsUI_FILES} KEYWORDS PointSetProcessing)
    target_link_libraries(register_point_sets_plugin PUBLIC scene_points_with_normal_item)
-    CGAL_target_use_Eigen(register_point_sets_plugin)
-    if (OpenGR_FOUND)
-      CGAL_target_use_OpenGR(register_point_sets_plugin)
+    target_link_libraries(register_point_sets_plugin PUBLIC CGAL::Eigen_support)
+    if (TARGET CGAL::OpenGR_support)
+      target_link_libraries(register_point_sets_plugin PUBLIC CGAL::OpenGR_support)
    endif()
-    if (libpointmatcher_FOUND)
-      CGAL_target_use_pointmatcher(register_point_sets_plugin)
+    if (TARGET CGAL::pointmatcher_support)
+      target_link_libraries(register_point_sets_plugin PUBLIC CGAL::pointmatcher_support)
    endif()
  else()
    message(STATUS "NOTICE: OpenGR and libpointmatcher were not found. Registration plugin will not be available.")
@ -111,7 +109,7 @@ endif()
  polyhedron_demo_plugin(point_set_to_mesh_distance_plugin Point_set_to_mesh_distance_plugin ${distanceUI_FILES} KEYWORDS PointSetProcessing)
  target_link_libraries(point_set_to_mesh_distance_plugin PUBLIC scene_points_with_normal_item scene_surface_mesh_item scene_color_ramp)

-  if(TBB_FOUND)
+  if(TARGET CGAL::TBB_support)
    foreach(plugin
        surface_reconstruction_plugin
        point_set_normal_estimation_plugin
@ -130,7 +128,7 @@ endif()
        alpha_shape_plugin
        point_set_to_mesh_distance_plugin)
      if(TARGET ${plugin})
-        CGAL_target_use_TBB(${plugin})
+        target_link_libraries(${plugin} PUBLIC CGAL::TBB_support)
      endif()
    endforeach()
  endif()
--- a/Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/CMakeLists.txt
+++ b/Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/CMakeLists.txt
@ -4,18 +4,17 @@ if(POLICY CMP0074)
  cmake_policy(SET CMP0074 NEW)
 endif()

-if(EIGEN3_FOUND)
+if(TARGET CGAL::Eigen_support)
  find_package(CGAL COMPONENTS Core)

  include(${CGAL_USE_FILE})

  qt5_wrap_ui(parameterizationUI_FILES Parameterization_widget.ui OTE_dialog.ui)
  polyhedron_demo_plugin(parameterization_plugin Parameterization_plugin ${parameterizationUI_FILES})
-  target_link_libraries(parameterization_plugin PUBLIC scene_surface_mesh_item scene_textured_item scene_selection_item)
-  CGAL_target_use_Eigen(parameterization_plugin)
-else(EIGEN3_FOUND)
+  target_link_libraries(parameterization_plugin PUBLIC scene_surface_mesh_item scene_textured_item scene_selection_item CGAL::Eigen_support)
+else()
  message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. The Parameterization plugin will not be available.")
-endif(EIGEN3_FOUND)
+endif()

 qt5_wrap_ui( segmentationUI_FILES Mesh_segmentation_widget.ui)
 polyhedron_demo_plugin(mesh_segmentation_plugin Mesh_segmentation_plugin ${segmentationUI_FILES})
@ -32,11 +31,11 @@ target_link_libraries(mesh_simplification_plugin PUBLIC scene_surface_mesh_item
 qt5_wrap_ui( remeshingUI_FILES  Remeshing_dialog.ui)
 polyhedron_demo_plugin(offset_meshing_plugin Offset_meshing_plugin ${remeshingUI_FILES})
 target_link_libraries(offset_meshing_plugin PUBLIC scene_surface_mesh_item scene_polygon_soup_item)
-if(EIGEN3_FOUND)
-  CGAL_target_use_Eigen(offset_meshing_plugin)
+if(TARGET CGAL::Eigen_support)
+  target_link_libraries(offset_meshing_plugin PUBLIC CGAL::Eigen_support)
 endif()
-if(TBB_FOUND)
-  CGAL_target_use_TBB(offset_meshing_plugin)
+if(TARGET CGAL::TBB_support)
+  target_link_libraries(offset_meshing_plugin PUBLIC CGAL::TBB_support)
 endif()

 qt5_wrap_ui( shortestPathUI_FILES Shortest_path_widget.ui )
--- a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
@ -157,7 +157,7 @@ public :
    const EPICK::Plane_3& plane = qobject_cast<Scene_c3t3_item*>(this->parent())->plane();
    float shrink_factor = qobject_cast<Scene_c3t3_item*>(this->parent())->getShrinkFactor();
    QVector4D cp = cgal_plane_to_vector4d(plane);
-    getTriangleContainer(0)->setPlane(cp);
+    getTriangleContainer(0)->setPlane(-cp);
    getTriangleContainer(0)->setShrinkFactor(shrink_factor);
    // positions_poly is also used for the faces in the cut plane
    // and changes when the cut plane is moved
@ -569,8 +569,10 @@ Scene_c3t3_item::Scene_c3t3_item(const C3t3& c3t3, bool is_surface)
  : Scene_group_item("unnamed")
  , d(new Scene_c3t3_item_priv(c3t3, this))
 {
-  d->reset_cut_plane();
  common_constructor(is_surface);
+  d->reset_cut_plane();
+  c3t3_changed();
+  changed();
 }

 Scene_c3t3_item::~Scene_c3t3_item()
@ -2098,5 +2100,11 @@ void Scene_c3t3_item::newViewer(Viewer_interface *viewer)
    d->computeIntersections(viewer);
  }
 }
+
+Scene_c3t3_item* Scene_c3t3_item::clone() const
+{
+  return new Scene_c3t3_item(d->c3t3, d->is_surface);
+}
+
 #include "Scene_c3t3_item.moc"

--- a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
+++ b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
@ -101,9 +101,8 @@ public:
  {
      return Scene_item::bbox();
  }
-  Scene_c3t3_item* clone() const  Q_DECL_OVERRIDE{
-    return 0;
-  }
+
+  Scene_c3t3_item* clone() const  Q_DECL_OVERRIDE;

  bool load_binary(std::istream& is);

--- a/Polyhedron/demo/Polyhedron/Scene_polygon_soup_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_polygon_soup_item.cpp
@ -512,7 +512,7 @@ Scene_polygon_soup_item::toolTip() const
    return QString();

  QString str = QObject::tr("<p><b>%1</b> (mode: %5, color: %6)<br />"
-                     "<i>Polygons soup</i></p>"
+                     "<i>Polygon soup</i></p>"
                     "<p>Number of vertices: %2<br />"
                     "Number of polygons: %3</p>")
    .arg(this->name())
--- a/Principal_component_analysis/demo/Principal_component_analysis/CMakeLists.txt
+++ b/Principal_component_analysis/demo/Principal_component_analysis/CMakeLists.txt
@ -19,7 +19,8 @@ include_directories( ./ )
 find_package(CGAL COMPONENTS Qt5)

 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-if (NOT EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (NOT TARGET CGAL::Eigen_support)
  message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
  return()
 endif()
@ -45,10 +46,9 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND )
  add_file_dependencies( PCA_demo.cpp "${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp"
    "${CMAKE_CURRENT_BINARY_DIR}/Viewer_moc.cpp" )
  add_executable  ( PCA_demo PCA_demo.cpp ${UI_FILES} ${CGAL_Qt5_RESOURCE_FILES} ${CGAL_Qt5_MOC_FILES})
-  CGAL_target_use_Eigen(PCA_demo)

  target_link_libraries( PCA_demo PRIVATE
-    CGAL::CGAL CGAL::CGAL_Qt5 Qt5::Gui)
+    CGAL::CGAL CGAL::CGAL_Qt5 CGAL::Eigen_support Qt5::Gui)

  add_to_cached_list( CGAL_EXECUTABLE_TARGETS PCA_demo )

--- a/Principal_component_analysis/examples/Principal_component_analysis/CMakeLists.txt
+++ b/Principal_component_analysis/examples/Principal_component_analysis/CMakeLists.txt
@ -12,14 +12,15 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
    create_single_source_cgal_program( "${cppfile}" )
-    if (EIGEN3_FOUND)
+    if (TARGET CGAL::Eigen_support)
      get_filename_component(target ${cppfile} NAME_WE)
-      CGAL_target_use_Eigen(${target})
+      target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
    endif()
  endforeach()

@ -28,4 +29,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Principal_component_analysis/test/Principal_component_analysis/CMakeLists.txt
+++ b/Principal_component_analysis/test/Principal_component_analysis/CMakeLists.txt
@ -12,14 +12,15 @@ if ( CGAL_FOUND )

  # Use Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
+  include(CGAL_Eigen_support)

  # create a target per cppfile
  file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
  foreach(cppfile ${cppfiles})
    create_single_source_cgal_program( "${cppfile}" )
-    if (EIGEN3_FOUND)
+    if (TARGET CGAL::Eigen_support)
      get_filename_component(target ${cppfile} NAME_WE)
-      CGAL_target_use_Eigen(${target})
+      target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
    endif()
  endforeach()

@ -28,4 +29,3 @@ else()
    message(STATUS "This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Property_map/examples/Property_map/CMakeLists.txt
+++ b/Property_map/examples/Property_map/CMakeLists.txt
@ -33,9 +33,8 @@ endif()
 create_single_source_cgal_program( "dynamic_properties.cpp" )

 find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-if (EIGEN3_FOUND)
+include(CGAL_Eigen_support)
+if (TARGET CGAL::Eigen_support)
  create_single_source_cgal_program( "custom_property_map.cpp" )
-  CGAL_target_use_Eigen(custom_property_map)
+  target_link_libraries(custom_property_map PUBLIC CGAL::Eigen_support)
 endif()
-
-
--- a/Ridges_3/examples/Ridges_3/CMakeLists.txt
+++ b/Ridges_3/examples/Ridges_3/CMakeLists.txt
@ -10,7 +10,8 @@ if ( CGAL_FOUND )

  # use either Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)

    # Link with Boost.ProgramOptions (optional)
    find_package(Boost QUIET COMPONENTS program_options)
@ -28,11 +29,11 @@ if ( CGAL_FOUND )
   endif()

   create_single_source_cgal_program( Compute_Ridges_Umbilics.cpp)
-   CGAL_target_use_Eigen(Compute_Ridges_Umbilics)
+   target_link_libraries(Compute_Ridges_Umbilics PUBLIC CGAL::Eigen_support)
   create_single_source_cgal_program( Ridges_Umbilics_SM.cpp)
-   CGAL_target_use_Eigen(Ridges_Umbilics_SM)
+   target_link_libraries(Ridges_Umbilics_SM PUBLIC CGAL::Eigen_support)
   create_single_source_cgal_program( Ridges_Umbilics_LCC.cpp)
-   CGAL_target_use_Eigen(Ridges_Umbilics_LCC)
+   target_link_libraries(Ridges_Umbilics_LCC PUBLIC CGAL::Eigen_support)

  else()

--- a/Ridges_3/test/Ridges_3/CMakeLists.txt
+++ b/Ridges_3/test/Ridges_3/CMakeLists.txt
@ -13,9 +13,10 @@ if ( CGAL_FOUND )

  # use either Eigen
  find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
-  if (EIGEN3_FOUND)
+  include(CGAL_Eigen_support)
+  if (TARGET CGAL::Eigen_support)
    create_single_source_cgal_program( "ridge_test.cpp" )
-    CGAL_target_use_Eigen(ridge_test)
+    target_link_libraries(ridge_test PUBLIC CGAL::Eigen_support)
  else()

    message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
@ -27,4 +28,3 @@ else()
  message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")

 endif()
-
--- a/Show More
+++ b/Show More