Lab: use results

## Summary of Changes

Bug-fix for `CGAL::Conforming_constrained_Delaunay_triangulation_3` in
CGAL-6.1.

## Release Management

* Affected package(s): Constrained_triangulation_3
* License and copyright ownership: GeometryFactory

.clang-format

@@ -1,35 +1,63 @@
 ---
+# CGAL clang-format configuration
+# This file defines the code formatting style for C++ files in the CGAL project.
+
 Language:        Cpp
 BasedOnStyle:  LLVM
-AccessModifierOffset: -2
+
-AllowShortFunctionsOnASingleLine: true
+# Indentation
-BinPackParameters: false
+AccessModifierOffset: -2  # Indent public:/private:/protected: 2 spaces to the left
-BreakConstructorInitializers: BeforeComma
+
+# Function formatting
+AllowShortFunctionsOnASingleLine: Inline  # Allow short inline/member functions on one line, but not free functions
+AlwaysBreakAfterReturnType: None  # Don't force return type on separate line
+
+# Parameter and argument formatting
+BinPackParameters: false  # Put each parameter on its own line for better readability
+
+# Constructor formatting
+BreakConstructorInitializers: BeforeComma  # Put comma before each initializer: `MyClass() \n  , member1(val1) \n  , member2(val2)`
+
+# Brace wrapping configuration
 BreakBeforeBraces: Custom
 BraceWrapping:
-  AfterCaseLabel:  false
+  AfterCaseLabel:  false       # Don't put brace on new line after case labels
-  AfterClass:      true
+  AfterClass:      true        # Put opening brace on new line after class definition
-  AfterControlStatement: MultiLine
+  AfterControlStatement: MultiLine  # Only break before braces if the control statement spans multiple lines
-  AfterEnum:       false
+  AfterEnum:       false       # Don't break after enum
-  AfterFunction:   false
+  AfterFunction:   false       # Don't break after function declaration (keep on same line)
-  AfterNamespace:  false
+  AfterNamespace:  false       # Don't break after namespace
-  AfterObjCDeclaration: false
+  AfterObjCDeclaration: false  # Objective-C related (not used in CGAL)
-  AfterStruct:     true
+  AfterStruct:     true        # Put opening brace on new line after struct definition
-  AfterUnion:      false
+  AfterUnion:      false       # Don't break after union
-  AfterExternBlock: false
+  AfterExternBlock: false      # Don't break after extern "C" blocks
-  BeforeCatch:     false
+  BeforeCatch:     false       # Don't put catch on new line
-  BeforeElse:      false
+  BeforeElse:      false       # Don't put else on new line
-  BeforeLambdaBody: false
+  BeforeLambdaBody: false      # Don't break before lambda body
-  BeforeWhile:     false
+  BeforeWhile:     false       # Don't put while on new line (do-while loops)
-  IndentBraces:    false
+  IndentBraces:    false       # Don't indent the braces themselves
-  SplitEmptyFunction: false
+  SplitEmptyFunction: false    # Don't split empty functions across lines
-  SplitEmptyRecord: false
+  SplitEmptyRecord: false      # Don't split empty classes/structs across lines
-  SplitEmptyNamespace: false
+  SplitEmptyNamespace: false   # Don't split empty namespaces across lines
-ColumnLimit:     120
+
-# Force pointers to the type for C++.
+# Line length
+ColumnLimit:     120  # Maximum line length of 120 characters
+
+# Pointer and reference alignment
+# Force pointers and references to align with the type (e.g., `int* ptr` not `int *ptr`)
 DerivePointerAlignment: false
 PointerAlignment: Left
-# Control the spaces around conditionals
+
-SpacesInConditionalStatement: false
+# Spacing in control statements
-SpaceBeforeParens: false
+SpacesInConditionalStatement: false  # No extra spaces inside conditionals: `if(condition)` not `if( condition )`
+SpaceBeforeParens: false  # No space before parentheses: `if(` not `if (`
+
+# Include directive handling
+SortIncludes:    Never  # Preserve the original order of #include statements (don't sort them)
+
+# Preprocessor directive formatting
+IndentPPDirectives: None  # Don't indent preprocessor directives (#ifdef, #include, etc.)
+
+# Blank line handling
+MaxEmptyLinesToKeep: 2  # Keep up to 2 consecutive blank lines
 ...

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

@@ -1543,10 +1543,10 @@ does_satisfy_link_condition(typename boost::graph_traits<Graph>::edge_descriptor
  *
  * After the collapse of edge `e` the following holds:
  *   - The edge `e` is no longer in `g`.
- *   - The faces incident to edge `e` are no longer in `g`.
+ *   - The triangle faces incident to edge `e` are no longer in `g`.
  *   - `v0` is no longer in `g`.
- *   - If `h` is not a border halfedge, `p_h` is no longer in `g` and is replaced by `o_n_h`.
+ *   - If `h` is part of a triangle face, `p_h` is no longer in `g` and is replaced by `o_n_h`.
- *   - If the opposite of `h` is not a border halfedge, `p_o_h` is no longer in `g` and is replaced by `o_n_o_h`.
+ *   - If the opposite of `h` is part of a triangle face, `p_o_h` is no longer in `g` and is replaced by `o_n_o_h`.
  *   - The halfedges kept in `g` that had `v0` as target and source now have `v1` as target and source, respectively.
  *   - No other incidence information is changed in `g`.
  *
@@ -1575,9 +1575,8 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
   bool lBottomFaceExists      = ! is_border(qp,g);
   bool lTopLeftFaceExists     = lTopFaceExists    && ! is_border(pt,g);
   bool lBottomRightFaceExists = lBottomFaceExists && ! is_border(qb,g);
-
+  bool lBottomIsTriangle       = lBottomFaceExists && is_triangle(qp,g);
-  CGAL_precondition( !lTopFaceExists    || (lTopFaceExists    && ( degree(target(pt, g), g) > 2 ) ) ) ;
+  bool lTopIsTriangle          = lTopFaceExists && is_triangle(pq,g);
-  CGAL_precondition( !lBottomFaceExists || (lBottomFaceExists && ( degree(target(qb, g), g) > 2 ) ) ) ;
 
   vertex_descriptor q = target(pq, g);
   vertex_descriptor p = source(pq, g);
@@ -1585,7 +1584,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
 
   bool lP_Erased = false;
 
-  if ( lTopFaceExists )
+  if ( lTopIsTriangle)
   {
     CGAL_precondition( ! is_border(opposite(pt, g),g) ) ; // p-q-t is a face of the mesh
     if ( lTopLeftFaceExists )
@@ -1612,7 +1611,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
     }
   }
 
-  if ( lBottomFaceExists )
+  if ( lBottomIsTriangle)
   {
     CGAL_precondition( ! is_border(opposite(qb, g),g) ) ; // p-q-b is a face of the mesh
     if ( lBottomRightFaceExists )
@@ -1659,7 +1658,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
  * collapses an edge in a graph having non-collapsable edges.
  *
  * Let `h` be the halfedge of `e`, and let `v0` and `v1` be the source and target vertices of `h`.
- * Collapses the edge `e` replacing it with `v1`, as described in the paragraph above
+ * Collapses the edge `e` replacing it with `v1`, as described in the other overload
  * and guarantees that an edge `e2`, for which `get(edge_is_constrained_map, e2)==true`,
  * is not removed after the collapse.
  *
@@ -1669,14 +1668,14 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
  *
  * \returns vertex `v1`.
  * \pre This function requires `g` to be an oriented 2-manifold with or without boundaries.
- *       Furthermore, the edge `v0v1` must satisfy the link condition, which guarantees that the surface mesh is also 2-manifold after the edge collapse.
+ *       Furthermore, the edge `e` must satisfy the link condition, which guarantees that the surface mesh is also 2-manifold after the edge collapse.
- * \pre `get(edge_is_constrained_map, v0v1)==false`.
+ * \pre `get(edge_is_constrained_map, e)==false`.
  * \pre  `v0` and `v1` are not both incident to a constrained edge.
  */
 
 template<typename Graph, typename EdgeIsConstrainedMap>
 typename boost::graph_traits<Graph>::vertex_descriptor
-collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
+collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor e,
               Graph& g,
               EdgeIsConstrainedMap Edge_is_constrained_map)
 {
@@ -1684,11 +1683,11 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
   typedef typename Traits::vertex_descriptor          vertex_descriptor;
   typedef typename Traits::halfedge_descriptor            halfedge_descriptor;
 
-  CGAL_precondition(is_valid_edge_descriptor(v0v1, g));
+  CGAL_precondition(is_valid_edge_descriptor(e, g));
-  CGAL_precondition(does_satisfy_link_condition(v0v1,g));
+  CGAL_precondition(does_satisfy_link_condition(e,g));
-  CGAL_precondition(!get(Edge_is_constrained_map, v0v1));
+  CGAL_precondition(!get(Edge_is_constrained_map, e));
 
-  halfedge_descriptor pq = halfedge(v0v1,g);
+  halfedge_descriptor pq = halfedge(e,g);
 
   halfedge_descriptor qp = opposite(pq,g);
   halfedge_descriptor pt = opposite(prev(pq,g),g);
@@ -1698,6 +1697,8 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
 
   bool lTopFaceExists         = ! is_border(pq,g) ;
   bool lBottomFaceExists      = ! is_border(qp,g) ;
+  bool lTopIsTriangle          = lTopFaceExists && is_triangle(pq,g);
+  bool lBottomIsTriangle       = lBottomFaceExists && is_triangle(qp,g);
 
   vertex_descriptor q = target(pq,g);
   vertex_descriptor p = source(pq,g);
@@ -1708,7 +1709,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
 
   // If the top facet exists, we need to choose one out of the two edges which one disappears:
   //   p-t if it is not constrained and t-q otherwise
-  if ( lTopFaceExists )
+  if ( lTopIsTriangle )
   {
     if ( !get(Edge_is_constrained_map,edge(pt,g)) )
     {
@@ -1722,7 +1723,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
 
   // If the bottom facet exists, we need to choose one out of the two edges which one disappears:
   //   q-b if it is not constrained and b-p otherwise
-  if ( lBottomFaceExists )
+  if ( lBottomIsTriangle )
   {
     if ( !get(Edge_is_constrained_map,edge(qb,g)) )
     {
@@ -1733,7 +1734,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
     }
   }
 
-  if (lTopFaceExists && lBottomFaceExists)
+  if (lTopIsTriangle && lBottomIsTriangle)
   {
     if ( face(edges_to_erase[0],g) == face(edges_to_erase[1],g)
          && (! is_border(edges_to_erase[0],g)) )
@@ -1780,7 +1781,7 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
   }
   else
   {
-    if (lTopFaceExists)
+    if (lTopIsTriangle)
     {
       if (!(is_border(edges_to_erase[0],g))){
         join_face(edges_to_erase[0],g);
@@ -1795,11 +1796,15 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
       remove_face(opposite(edges_to_erase[0],g),g);
       return q;
     }
-
+    else
+    {
+      if (lBottomIsTriangle)
+      {
         if (! (is_border(edges_to_erase[0],g))){
           // q will be removed, swap it with p
           internal::swap_vertices(p, q, g);
           join_face(edges_to_erase[0],g);
+          CGAL_assertion(source(qp,g)==p);
           join_vertex(qp,g);
           return q;
         }
@@ -1811,6 +1816,13 @@ collapse_edge(typename boost::graph_traits<Graph>::edge_descriptor v0v1,
         remove_face(opposite(edges_to_erase[0],g),g);
         return q;
       }
+      else
+      {
+        join_vertex(pq,g);
+        return q;
+      }
+    }
+  }
 }
 
 /// performs an edge flip, rotating the edge pointed by

BGL/test/BGL/data/polygon_mesh_to_collapse.off

@@ -0,0 +1,42 @@
+OFF
+25 13 0
+
+0.39160239696502686 1.3864846229553223 4.8046874923102223e-08
+0.053782559931278229 1.3864846229553223 4.8046874923102223e-08
+-0.94644606113433838 1.6651756763458252 4.8046874923102223e-08
+-1.3082554340362549 1.7385153770446777 4.8046874923102223e-08
+-1.3033660650253296 1.1860226392745972 4.8046874923102223e-08
+1.61628258228302 -0.17601536214351654 4.8046874923102223e-08
+0.55834579467773438 -0.19216139614582062 4.8046874923102223e-08
+0.053782559931278229 -0.17601536214351654 4.8046874923102223e-08
+-0.24240998923778534 -0.22679123282432556 4.8046874923102223e-08
+-0.58168435096740723 -0.25845989584922791 4.8046874923102223e-08
+-1.2915089130401611 -0.17601536214351654 4.8046874923102223e-08
+-1.50871741771698 -0.17601536214351654 4.8046874923102223e-08
+1.61628258228302 -1.7385153770446777 4.8046874923102223e-08
+1.1978726387023926 -1.7385153770446777 4.8046874923102223e-08
+0.71942150592803955 -1.7385153770446777 4.8046874923102223e-08
+0.053782559931278229 -1.7385153770446777 4.8046874923102223e-08
+-0.73973840475082397 -1.7385153770446777 4.8046874923102223e-08
+1.61628258228302 0.36264327168464661 4.8046874923102223e-08
+-0.26156377792358398 0.45463424921035767 4.8046874923102223e-08
+-0.028661971911787987 -0.78840988874435425 4.8046874923102223e-08
+0.053782559931278229 -1.2213115692138672 4.8046874923102223e-08
+-1.5918357372283936 1.5331641435623169 4.8046874923102223e-08
+-1.6162823438644409 0.87338578701019287 4.8046874923102223e-08
+-1.50871741771698 -0.0072435899637639523 4.8046874923102223e-08
+-1.50871741771698 -1.3000825643539429 4.8046874923102223e-08
+7  18 2 3 4 22 9 8
+3  2 18 1
+7  18 7 6 5 17 0 1
+7  12 5 6 7 8 19 13
+6  11 24 16 15 20 10
+3  9 19 8
+4  10 20 19 9
+3  7 18 8
+3  14 20 15
+4  13 19 20 14
+3  3 21 4
+4  9 22 23 10
+3  10 23 11
+

BGL/test/BGL/test_Collapse_edge.cpp

@@ -2,7 +2,6 @@
 
 #include <CGAL/boost/graph/Euler_operations.h>
 #include <CGAL/boost/graph/IO/OFF.h>
-
 #include <boost/range/distance.hpp>
 
 #include <string>
@@ -213,12 +212,30 @@ collapse_edge_test()
     assert(found == 2);
     CGAL::clear(test_mesh);
   }
+  // Case 6 non pure triangle mesh
+  {
+    Mesh ref;
+    if(!CGAL::IO::read_OFF("data/polygon_mesh_to_collapse.off", ref))
+    {
+      std::cout << "Error reading file: data/polygon_mesh_to_collapse.off" << std::endl;
+      exit(1);
+    }
+    std::size_t nbe=halfedges(ref).size();
+    for (std::size_t i=0; i< nbe; ++i)
+    {
+      Mesh m = ref;
+      auto h = *std::next(halfedges(m).begin(), i);
+
+      if (CGAL::Euler::does_satisfy_link_condition(edge(h,m),m))
+        CGAL::Euler::collapse_edge(edge(h,m), m);
+      assert(CGAL::is_valid_polygon_mesh(m));
+    }
+  }
 }
 
 
 int main()
 {
-
   collapse_edge_test<Polyhedron>();
   collapse_edge_test<SM>();
 

Barycentric_coordinates_2/benchmark/Barycentric_coordinates_2/CMakeLists.txt

@@ -1,9 +1,7 @@
 # Created by the script cgal_create_cmake_script.
 # This is the CMake script for compiling a CGAL application.
-
-project(Barycentric_coordinates_2_Benchmarks)
-
 cmake_minimum_required(VERSION 3.12...3.31)
+project(Barycentric_coordinates_2_Benchmarks)
 
 find_package(CGAL REQUIRED COMPONENTS Core)
 
@@ -14,8 +12,9 @@ create_single_source_cgal_program("benchmark_polygon_16_vertices.cpp")
 create_single_source_cgal_program("benchmark_polygon_100_vertices.cpp")
 create_single_source_cgal_program("benchmark_mv_34_vertices.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("benchmark_hm_4_vertices.cpp")
   target_link_libraries(benchmark_hm_4_vertices PRIVATE CGAL::Eigen3_support)

Barycentric_coordinates_2/examples/Barycentric_coordinates_2/CMakeLists.txt

@@ -17,8 +17,9 @@ create_single_source_cgal_program("terrain_height_modeling.cpp")
 # this code is deprecated:
 create_single_source_cgal_program("deprecated_coordinates.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("affine_coordinates.cpp")
   target_link_libraries(affine_coordinates PRIVATE CGAL::Eigen3_support)

Barycentric_coordinates_2/test/Barycentric_coordinates_2/CMakeLists.txt

@@ -42,8 +42,9 @@ create_single_source_cgal_program("test_wp_deprecated_api.cpp")
 create_single_source_cgal_program("test_mv_deprecated_api.cpp")
 create_single_source_cgal_program("test_dh_deprecated_api.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("test_hm_unit_square.cpp")
   target_link_libraries(test_hm_unit_square PRIVATE CGAL::Eigen3_support)

Basic_viewer/examples/Basic_viewer/CMakeLists.txt

@@ -11,7 +11,7 @@ project(Basic_viewer_Examples)
 
 #CGAL_Qt6 is needed for the drawing.
 find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt6)
-find_package(Eigen3 3.1.0)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 create_single_source_cgal_program("draw_lcc.cpp")

Basic_viewer/include/CGAL/Qt/Basic_viewer.h

@@ -1480,10 +1480,15 @@ protected:
     if(!m_scene.empty())
     {
       auto& bbox=m_scene.bounding_box();
-      double d=CGAL::sqrt(CGAL::squared_distance
+      double d=is_two_dimensional()
+              ?2.5
+              : CGAL::sqrt(CGAL::squared_distance
                            (Local_point(bbox.xmin(), bbox.ymin(), bbox.zmin()),
                             Local_point(bbox.xmax(), bbox.ymax(), bbox.zmax())));
       // std::cout<<"Length of the diagonal: "<<d<<std::endl;
+      // std::cout<<"width: "<< this->width() <<std::endl;
+      // std::cout<<"height: "<< this->height() <<std::endl;
+
       m_size_vertices=1.5*d;
       m_size_edges=d;
       m_size_rays=m_size_edges;

Bounding_volumes/examples/Approximate_min_ellipsoid_d/CMakeLists.txt

@@ -4,7 +4,7 @@ project(Approximate_min_ellipsoid_d_Examples)
 find_package(CGAL REQUIRED)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 # create a target per cppfile

Bounding_volumes/test/Bounding_volumes/CMakeLists.txt

@@ -7,7 +7,7 @@ project(Bounding_volumes_Tests)
 find_package(CGAL REQUIRED COMPONENTS Core)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 # create a target per cppfile

CGAL_ipelets/demo/CGAL_ipelets/CMakeLists.txt

@@ -20,8 +20,9 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
 
 find_package(CGAL REQUIRED COMPONENTS Core)
 
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Classification/examples/Classification/CMakeLists.txt

@@ -23,8 +23,9 @@ if(NOT TARGET CGAL::Boost_iostreams_support)
   set(Classification_dependencies_met FALSE)
 endif()
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   set(Classification_dependencies_met FALSE)

Classification/test/Classification/CMakeLists.txt

@@ -23,8 +23,9 @@ if(NOT TARGET CGAL::Boost_iostreams_support)
   set(Classification_dependencies_met FALSE)
 endif()
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   set(Classification_dependencies_met FALSE)

Constrained_triangulation_3/doc/Constrained_triangulation_3/Concepts/ConformingConstrainedDelaunayTriangulationCellBase_3.h

@@ -3,7 +3,7 @@
 \cgalConcept
 
 The concept `ConformingConstrainedDelaunayTriangulationCellBase_3` refines the concept
-`TriangulationCellBase_3` and and describes the requirements for a base cell class of
+`TriangulationCellBase_3` and describes the requirements for a base cell class of
 the `CGAL::Conforming_constrained_Delaunay_triangulation_3` class.
 
 \cgalRefines{TriangulationCellBase_3, BaseWithTimeStamp}

Constrained_triangulation_3/include/CGAL/Conforming_Delaunay_triangulation_3.h

@@ -17,6 +17,7 @@
 #include <CGAL/Constrained_triangulation_3/internal/config.h>
 
 #include <CGAL/Conforming_constrained_Delaunay_triangulation_vertex_data_3.h>
+#include <CGAL/Real_timer.h>
 #include <CGAL/Triangulation_2/internal/Polyline_constraint_hierarchy_2.h>
 #include <CGAL/Triangulation_segment_traverser_3.h>
 #include <CGAL/unordered_flat_set.h>
@@ -34,8 +35,209 @@
 
 #ifndef DOXYGEN_RUNNING
 
+#if CGAL_USE_ITT
+#  include <ittnotify.h>
+#endif
+
 namespace CGAL {
 
+namespace CDT_3 {
+
+struct Debug_options {
+  enum class Flags {
+    Steiner_points = 0,
+    conforming,
+    input_faces,
+    missing_region,
+    regions,
+    copy_triangulation_into_hole,
+    validity,
+    use_older_cavity_algorithm,
+    debug_finite_edges_map,
+    use_finite_edges_map,
+    debug_subconstraints_to_conform,
+    verbose_special_cases,
+    debug_encroaching_vertices,
+    debug_conforming_validation,
+    debug_constraint_hierarchy,
+    debug_geometric_errors,
+    debug_polygon_insertion,
+    display_statistics,
+    nb_of_flags
+  };
+
+  bool Steiner_points() const { return flags[static_cast<int>(Flags::Steiner_points)]; }
+  void Steiner_points(bool b) { flags.set(static_cast<int>(Flags::Steiner_points), b); }
+
+  bool input_faces() const { return flags[static_cast<int>(Flags::input_faces)]; }
+  void input_faces(bool b) { flags.set(static_cast<int>(Flags::input_faces), b); }
+
+  bool missing_region() const { return flags[static_cast<int>(Flags::missing_region)]; }
+  void missing_region(bool b) { flags.set(static_cast<int>(Flags::missing_region), b); }
+
+  bool regions() const { return flags[static_cast<int>(Flags::regions)]; }
+  void regions(bool b) { flags.set(static_cast<int>(Flags::regions), b); }
+
+  bool copy_triangulation_into_hole() const { return flags[static_cast<int>(Flags::copy_triangulation_into_hole)]; }
+  void copy_triangulation_into_hole(bool b) { flags.set(static_cast<int>(Flags::copy_triangulation_into_hole), b); }
+
+  bool validity() const { return flags[static_cast<int>(Flags::validity)]; }
+  void validity(bool b) { flags.set(static_cast<int>(Flags::validity), b); }
+
+  bool use_older_cavity_algorithm() const { return flags[static_cast<int>(Flags::use_older_cavity_algorithm)]; }
+  bool use_newer_cavity_algorithm() const { return !flags[static_cast<int>(Flags::use_older_cavity_algorithm)]; }
+  void use_older_cavity_algorithm(bool b) { flags.set(static_cast<int>(Flags::use_older_cavity_algorithm), b); }
+
+  bool finite_edges_map() const { return flags[static_cast<int>(Flags::debug_finite_edges_map)]; }
+  void finite_edges_map(bool b) { flags.set(static_cast<int>(Flags::debug_finite_edges_map), b); }
+
+  bool subconstraints_to_conform() const { return flags[static_cast<int>(Flags::debug_subconstraints_to_conform)]; }
+  void subconstraints_to_conform(bool b) { flags.set(static_cast<int>(Flags::debug_subconstraints_to_conform), b); }
+
+  bool use_finite_edges_map_flag() const { return flags[static_cast<int>(Flags::use_finite_edges_map)]; }
+  void use_finite_edges_map(bool b) { flags.set(static_cast<int>(Flags::use_finite_edges_map), b); }
+
+  bool verbose_special_cases() const { return flags[static_cast<int>(Flags::verbose_special_cases)]; }
+  void verbose_special_cases(bool b) { flags.set(static_cast<int>(Flags::verbose_special_cases), b); }
+
+  bool encroaching_vertices() const { return flags[static_cast<int>(Flags::debug_encroaching_vertices)]; }
+  void encroaching_vertices(bool b) { flags.set(static_cast<int>(Flags::debug_encroaching_vertices), b); }
+
+  bool conforming_validation() const { return flags[static_cast<int>(Flags::debug_conforming_validation)]; }
+  void conforming_validation(bool b) { flags.set(static_cast<int>(Flags::debug_conforming_validation), b); }
+
+  bool constraint_hierarchy() const { return flags[static_cast<int>(Flags::debug_constraint_hierarchy)]; }
+  void constraint_hierarchy(bool b) { flags.set(static_cast<int>(Flags::debug_constraint_hierarchy), b); }
+
+  bool geometric_errors() const { return flags[static_cast<int>(Flags::debug_geometric_errors)]; }
+  void geometric_errors(bool b) { flags.set(static_cast<int>(Flags::debug_geometric_errors), b); }
+
+  bool polygon_insertion() const { return flags[static_cast<int>(Flags::debug_polygon_insertion)]; }
+  void polygon_insertion(bool b) { flags.set(static_cast<int>(Flags::debug_polygon_insertion), b); }
+
+  bool display_statistics() const { return flags[static_cast<int>(Flags::display_statistics)]; }
+  void display_statistics(bool b) { flags.set(static_cast<int>(Flags::display_statistics), b); }
+
+  double segment_vertex_epsilon() const { return segment_vertex_epsilon_; }
+  void set_segment_vertex_epsilon(double eps) { segment_vertex_epsilon_ = eps; }
+
+  double vertex_vertex_epsilon() const { return vertex_vertex_epsilon_; }
+  void set_vertex_vertex_epsilon(double eps) { vertex_vertex_epsilon_ = eps; }
+
+private:
+  std::bitset<static_cast<int>(Flags::nb_of_flags)> flags{};
+  double segment_vertex_epsilon_ = 0.0;
+  double vertex_vertex_epsilon_  = 0.0;
+}; // end struct Debug_options
+
+namespace internal {
+
+auto& tasks_manager() {
+  struct Tasks_manager {
+    enum {
+      READ_INPUT = 0,
+      MERGE_FACETS,
+      INSERT_VERTICES,
+      COMPUTE_DISTANCES,
+      CONFORMING,
+      CDT,
+      OUTPUT,
+      VALIDATION,
+      NB_TASKS
+    };
+
+  #if CGAL_USE_ITT
+    __itt_domain* cdt_3_domain = __itt_domain_create("org.cgal.CDT_3");
+    const std::array<__itt_string_handle*, NB_TASKS> task_handles = {
+      __itt_string_handle_create("CDT_3: read input file"),
+      __itt_string_handle_create("CDT_3: merge facets"),
+      __itt_string_handle_create("CDT_3: insert vertices"),
+      __itt_string_handle_create("CDT_3: compute distances"),
+      __itt_string_handle_create("CDT_3: conforming"),
+      __itt_string_handle_create("CDT_3: cdt"),
+      __itt_string_handle_create("CDT_3: outputs"),
+      __itt_string_handle_create("CDT_3: validation")
+    };
+  #endif
+    std::array<CGAL::Real_timer, NB_TASKS> timers{};
+    struct Scope_guard {
+      Tasks_manager *instance = nullptr;
+      int task_id;
+      Scope_guard(Tasks_manager *instance, int task_id) : instance(instance), task_id(task_id) {
+        instance->timers[task_id].start();
+#if CGAL_USE_ITT
+        __itt_task_begin(instance->cdt_3_domain, __itt_null, __itt_null, instance->task_handles[task_id]);
+#endif
+      }
+      auto time() const {
+        return instance->timers[task_id].time();
+      }
+      auto time_ms() const {
+        return instance->timers[task_id].time() / 1000.;
+      }
+      ~Scope_guard() {
+        instance->timers[task_id].stop();
+#if CGAL_USE_ITT
+        __itt_task_end(instance->cdt_3_domain);
+#endif
+      }
+    };
+
+    Scope_guard make_task_scope_guard(int task_id) {
+      return Scope_guard(this, task_id);
+    }
+
+    Scope_guard READ_INPUT_TASK_guard() { return make_task_scope_guard(READ_INPUT); }
+    Scope_guard MERGE_FACETS_TASK_guard() { return make_task_scope_guard(MERGE_FACETS); }
+    Scope_guard INSERT_VERTICES_TASK_guard() { return make_task_scope_guard(INSERT_VERTICES); }
+    Scope_guard COMPUTE_DISTANCES_TASK_guard() { return make_task_scope_guard(COMPUTE_DISTANCES); }
+    Scope_guard CONFORMING_TASK_guard() { return make_task_scope_guard(CONFORMING); }
+    Scope_guard CDT_TASK_guard() { return make_task_scope_guard(CDT); }
+    Scope_guard OUTPUT_TASK_guard() { return make_task_scope_guard(OUTPUT); }
+    Scope_guard VALIDATION_TASK_guard() { return make_task_scope_guard(VALIDATION); }
+
+  }; // end struct Intel_OneAPI_ITT_API
+
+  static Tasks_manager instance;
+  return instance;
+} // end auto& tasks_manager()
+
+} // end namespace internal
+
+} // end namespace CDT_3
+
+inline auto CDT_3_READ_INPUT_TASK_guard() {
+  return CDT_3::internal::tasks_manager().READ_INPUT_TASK_guard();
+}
+
+inline auto CDT_3_MERGE_FACETS_TASK_guard() {
+  return CDT_3::internal::tasks_manager().MERGE_FACETS_TASK_guard();
+}
+
+inline auto CDT_3_INSERT_VERTICES_TASK_guard() {
+  return CDT_3::internal::tasks_manager().INSERT_VERTICES_TASK_guard();
+}
+
+inline auto CDT_3_COMPUTE_DISTANCES_TASK_guard() {
+  return CDT_3::internal::tasks_manager().COMPUTE_DISTANCES_TASK_guard();
+}
+
+inline auto CDT_3_CONFORMING_TASK_guard() {
+  return CDT_3::internal::tasks_manager().CONFORMING_TASK_guard();
+}
+
+inline auto CDT_3_CDT_TASK_guard() {
+  return CDT_3::internal::tasks_manager().CDT_TASK_guard();
+}
+
+inline auto CDT_3_OUTPUT_TASK_guard() {
+  return CDT_3::internal::tasks_manager().OUTPUT_TASK_guard();
+}
+
+inline auto CDT_3_VALIDATION_TASK_guard() {
+  return CDT_3::internal::tasks_manager().VALIDATION_TASK_guard();
+}
+
 template <typename T_3>
 class Conforming_Delaunay_triangulation_3 : public T_3 {
 public:
@@ -50,9 +252,9 @@ public:
   using Line = typename T_3::Geom_traits::Line_3;
   using Locate_type = typename T_3::Locate_type;
 
-  inline static With_offset_tag with_offset{};
+  inline static With_offset_tag with_offset{ -1 };
-  inline static With_point_tag with_point{};
+  inline static With_point_tag with_point{ {-1} };
-  inline static With_point_and_info_tag with_point_and_info{};
+  inline static With_point_and_info_tag with_point_and_info{ { {-1} } };
 
   Conforming_Delaunay_triangulation_3(const Geom_traits& gt = Geom_traits())
     : T_3(gt)
@@ -110,7 +312,7 @@ protected:
               if(v1 > v2) std::swap(v1, v2);
               auto v1_index = v1->time_stamp();
               [[maybe_unused]] auto nb_erased = self->all_finite_edges[v1_index].erase(v2);
-              if constexpr (cdt_3_can_use_cxx20_format()) if(self->debug_finite_edges_map() && nb_erased > 0) {
+              if constexpr (cdt_3_can_use_cxx20_format()) if(self->debug().finite_edges_map() && nb_erased > 0) {
                 std::cerr << cdt_3_format("erasing edge {} {}\n", self->display_vert((std::min)(v1, v2)),
                                         self->display_vert((std::max)(v1, v2)));
               }
@@ -169,18 +371,17 @@ protected:
   void add_to_subconstraints_to_conform(Vertex_handle va, Vertex_handle vb,
                                         Constrained_polyline_id id) {
     const auto pair = make_subconstraint(va, vb);
-#if CGAL_DEBUG_CDT_3 & 32
+    if(debug().subconstraints_to_conform()) {
       std::cerr << "tr().subconstraints_to_conform.push("
                 << display_subcstr(pair) << ")\n";
-#endif // CGAL_DEBUG_CDT_3
+    }
     subconstraints_to_conform.push({pair, id});
   }
 
   template <typename Visitor>
-  Constrained_polyline_id insert_constrained_edge_impl(Vertex_handle va, Vertex_handle vb,
+  Constrained_polyline_id insert_constrained_edge_impl(Vertex_handle va, Vertex_handle vb, Visitor&) {
-                                             Visitor&) {
     if(va != vb) {
-      if(segment_vertex_epsilon != 0.) {
+      if(debug().segment_vertex_epsilon() != 0.) {
         auto [min_dist, min_vertex] = min_distance_and_vertex_between_constraint_and_encroaching_vertex(va, vb);
         check_segment_vertex_distance_or_throw(va, vb, min_vertex, CGAL::to_double(min_dist),
                                                Check_distance::NON_SQUARED_DISTANCE);
@@ -217,7 +418,7 @@ protected:
     if(tr().is_infinite(v1) || tr().is_infinite(v2))
       return;
     [[maybe_unused]] auto [_, inserted] = all_finite_edges[v1->time_stamp()].insert(v2);
-    if constexpr (cdt_3_can_use_cxx20_format()) if (debug_finite_edges_map() && inserted) {
+    if constexpr (cdt_3_can_use_cxx20_format()) if (debug().finite_edges_map() && inserted) {
       if(v2 < v1) std::swap(v1, v2);
       std::cerr << cdt_3_format("new_edge({}, {})\n", display_vert(v1), display_vert(v2));
     }
@@ -268,7 +469,7 @@ protected:
       if(use_finite_edges_map()) {
         new_vertex(v);
         all_finite_edges.clear();
-        if (debug_finite_edges_map()) std::cerr << "all_finite_edges.clear()\n";
+        if (debug().finite_edges_map()) std::cerr << "all_finite_edges.clear()\n";
         for(auto e: tr().all_edges()) {
           new_edge(e);
         }
@@ -304,7 +505,7 @@ protected:
     }
   }
 
-  void update_max_bbox_edge_length() {
+  void update_max_bbox_edge_length() const {
     double d_x = bbox.xmax() - bbox.xmin();
     double d_y = bbox.ymax() - bbox.ymin();
     double d_z = bbox.zmax() - bbox.zmin();
@@ -313,81 +514,15 @@ protected:
   }
 
 public:
-  void set_segment_vertex_epsilon(double epsilon) {
+  CDT_3::Debug_options& debug() { return debug_options_; }
-    segment_vertex_epsilon = epsilon;
+  const CDT_3::Debug_options& debug() const { return debug_options_; }
-  }
 
-  bool debug_Steiner_points() const {
+  // Backward compatibility wrappers (deprecated, use debug().method() instead)
-    return debug_flags[static_cast<int>(Debug_flags::Steiner_points)];
+  bool use_older_cavity_algorithm() const { return debug_options_.use_older_cavity_algorithm(); }
-  }
+  bool use_newer_cavity_algorithm() const { return debug_options_.use_newer_cavity_algorithm(); }
-
+  void use_older_cavity_algorithm(bool b) { debug_options_.use_older_cavity_algorithm(b); }
-  void debug_Steiner_points(bool b) {
+  bool use_finite_edges_map() const { return update_all_finite_edges_ && debug_options_.use_finite_edges_map_flag(); }
-    debug_flags.set(static_cast<int>(Debug_flags::Steiner_points), b);
+  void use_finite_edges_map(bool b) { debug_options_.use_finite_edges_map(b); }
-  }
-
-  bool debug_input_faces() const {
-    return debug_flags[static_cast<int>(Debug_flags::input_faces)];
-  }
-
-  void debug_input_faces(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::input_faces), b);
-  }
-
-  bool debug_missing_region() const {
-    return debug_flags[static_cast<int>(Debug_flags::missing_region)];
-  }
-
-  void debug_missing_region(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::missing_region), b);
-  }
-
-  bool debug_regions() const {
-    return debug_flags[static_cast<int>(Debug_flags::regions)];
-  }
-
-  void debug_regions(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::regions), b);
-  }
-
-  bool debug_copy_triangulation_into_hole() const {
-    return debug_flags[static_cast<int>(Debug_flags::copy_triangulation_into_hole)];
-  }
-
-  void debug_copy_triangulation_into_hole(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::copy_triangulation_into_hole), b);
-  }
-
-  bool debug_validity() const {
-    return debug_flags[static_cast<int>(Debug_flags::validity)];
-  }
-
-  void debug_validity(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::validity), b);
-  }
-
-  bool use_older_cavity_algorithm() const {
-    return debug_flags[static_cast<int>(Debug_flags::use_older_cavity_algorithm)];
-  }
-
-  void use_older_cavity_algorithm(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::use_older_cavity_algorithm), b);
-  }
-
-  bool debug_finite_edges_map() const {
-    return debug_flags[static_cast<int>(Debug_flags::debug_finite_edges_map)];
-  }
-
-  void debug_finite_edges_map(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::debug_finite_edges_map), b);
-  }
-
-  bool use_finite_edges_map() const {
-    return update_all_finite_edges_ && debug_flags[static_cast<int>(Debug_flags::use_finite_edges_map)];
-  }
-
-  void use_finite_edges_map(bool b) {
-    debug_flags.set(static_cast<int>(Debug_flags::use_finite_edges_map), b);
-  }
 
   Vertex_handle insert(const Point &p, Locate_type lt, Cell_handle c,
                        int li, int lj)
@@ -415,14 +550,14 @@ public:
 
   bool is_edge(Vertex_handle va, Vertex_handle vb) const {
     const bool is_edge_v1 =
-        ((debug_finite_edges_map() && use_finite_edges_map()) || !use_finite_edges_map()) && tr().tds().is_edge(va, vb);
+        ((debug().finite_edges_map() && use_finite_edges_map()) || !use_finite_edges_map()) && tr().tds().is_edge(va, vb);
 
     if(use_finite_edges_map() && va > vb) std::swap(va, vb);
     const auto va_index = va->time_stamp();
     const bool is_edge_v2 =
         use_finite_edges_map() && all_finite_edges[va_index].find(vb) != all_finite_edges[va_index].end();
 
-    if(debug_finite_edges_map() && use_finite_edges_map() && is_edge_v1 != is_edge_v2) {
+    if(debug().finite_edges_map() && use_finite_edges_map() && is_edge_v1 != is_edge_v2) {
       std::cerr << "!! Inconsistent edge status\n";
       std::cerr << "  -> constraint " << display_vert(va) << "     " << display_vert(vb) << '\n';
       std::cerr << "  ->     edge " << (is_edge_v1 ? "is" : "is not") << " in the triangulation\n";
@@ -442,12 +577,12 @@ public:
                        [this](const auto &sc) {
                          const auto [va, vb] = sc;
                          const auto is_edge = this->is_edge(va, vb);
-#if CGAL_DEBUG_CDT_3 & 128 && CGAL_CAN_USE_CXX20_FORMAT
+                         if constexpr (cdt_3_can_use_cxx20_format()) if(debug().conforming_validation()) {
                            std::cerr << cdt_3_format("is_conforming>> Edge is 3D: {}  ({} , {})\n",
                                                     is_edge,
                                                     CGAL::IO::oformat(va, with_point_and_info),
                                                     CGAL::IO::oformat(vb, with_point_and_info));
-#endif // CGAL_DEBUG_CDT_3
+                         }
                          return is_edge;
                        });
   }
@@ -458,14 +593,15 @@ public:
                                               Vertex_handle vb,
                                               Vertex_handle min_vertex,
                                               double min_dist,
-                                              Check_distance option)
+                                              Check_distance distance_type = Check_distance::NON_SQUARED_DISTANCE) const
   {
     if(!max_bbox_edge_length) {
       update_max_bbox_edge_length();
     }
-    if((option == Check_distance::NON_SQUARED_DISTANCE && min_dist < segment_vertex_epsilon * *max_bbox_edge_length) ||
+    if((distance_type == Check_distance::NON_SQUARED_DISTANCE &&
-       (option == Check_distance::SQUARED_DISTANCE &&
+        min_dist < debug().segment_vertex_epsilon() * *max_bbox_edge_length) ||
-        min_dist < CGAL::square(segment_vertex_epsilon * *max_bbox_edge_length)))
+       (distance_type == Check_distance::SQUARED_DISTANCE &&
+        min_dist < CGAL::square(debug().segment_vertex_epsilon() * *max_bbox_edge_length)))
     {
       std::stringstream ss;
       ss.precision(std::cerr.precision());
@@ -478,6 +614,26 @@ public:
     }
   }
 
+  void check_vertex_vertex_distance_or_throw(Vertex_handle va,
+                                             Vertex_handle vb,
+                                             double min_dist) const
+  {
+    if(!max_bbox_edge_length) {
+      update_max_bbox_edge_length();
+    }
+    if(min_dist < debug_options_.vertex_vertex_epsilon() * *max_bbox_edge_length)
+    {
+      std::stringstream ss;
+      ss.precision(std::cerr.precision());
+      ss << "Two vertices are too close to each other.\n";
+      ss << "  -> vertex " << display_vert(va) << '\n';
+      ss << "  -> vertex " << display_vert(vb) << '\n';
+      ss << "  -> distance = " << min_dist << '\n';
+      ss << "  -> max_bbox_edge_length = " << *max_bbox_edge_length << '\n';
+      CGAL_error_msg(ss.str().c_str());
+    }
+  }
+
   auto ancestors_of_Steiner_vertex_on_edge(Vertex_handle v) const {
     std::pair<Vertex_handle, Vertex_handle> result;
     CGAL_precondition(v->ccdt_3_data().is_Steiner_vertex_on_edge());
@@ -583,10 +739,10 @@ protected:
       if(!constraint_hierarchy.is_subconstraint(va, vb)) {
         continue;
       }
-#if CGAL_DEBUG_CDT_3 & 32
+      if(debug().subconstraints_to_conform()) {
         std::cerr << "tr().subconstraints_to_conform.pop()="
                   << display_subcstr(subconstraint) << "\n";
-#endif // CGAL_DEBUG_CDT_3
+      }
       conform_subconstraint(subconstraint, constrained_polyline_id, visitor);
     }
   }
@@ -629,7 +785,7 @@ protected:
       const auto& [steiner_pt, hint, ref_vertex] = construct_Steiner_point(constraint, subconstraint);
       [[maybe_unused]] const auto v =
           insert_Steiner_point_on_subconstraint(steiner_pt, hint, subconstraint, constraint, visitor);
-      if(debug_Steiner_points()) {
+      if(debug().Steiner_points()) {
         const auto [c_start, c_end] = constraint_extremities(constraint);
         std::cerr << "(" << IO::oformat(va, with_offset) << ", " << IO::oformat(vb, with_offset) << ")";
         std::cerr << ": [ " << display_vert(c_start) << " - " << display_vert(c_end) << " ] ";
@@ -665,10 +821,10 @@ protected:
                                this->constraint_hierarchy.constraints_end(), c_id) != this->constraint_hierarchy.constraints_end());
       CGAL_assertion(this->constraint_hierarchy.vertices_in_constraint_begin(c_id) !=
                      this->constraint_hierarchy.vertices_in_constraint_end(c_id));
-#if CGAL_DEBUG_CDT_3 & 8
+      if(debug().constraint_hierarchy()) {
-      std::cerr << "constraint " << (void*) c_id.vl_ptr() << " has "
+        std::cerr << "constraint " << static_cast<void*>(c_id.vl_ptr()) << " has "
                   << c_id.vl_ptr()->skip_size() << " vertices\n";
-#endif // CGAL_DEBUG_CDT_3
+      }
       const auto begin = this->constraint_hierarchy.vertices_in_constraint_begin(c_id);
       const auto end = this->constraint_hierarchy.vertices_in_constraint_end(c_id);
       const auto c_va = *begin;
@@ -726,9 +882,9 @@ protected:
       encroaching_vertices.insert(v);
     };
     auto fill_encroaching_vertices = [&](const auto simplex) {
-#if CGAL_DEBUG_CDT_3 & 0x10
+      if(debug().encroaching_vertices()) {
         std::cerr << " - " << IO::oformat(simplex, With_point_tag{}) << '\n';
-#endif // CGAL_DEBUG_CDT_3
+      }
       auto visit_cell = [&](Cell_handle cell) {
         for(int i = 0, end = this->tr().dimension() + 1; i < end; ++i) {
           const auto v = cell->vertex(i);
@@ -772,9 +928,9 @@ protected:
           std::cerr << "!! The constraint passes through a vertex!\n";
           std::cerr << "  -> constraint " << display_vert(va) << "     " << display_vert(vb) << '\n';
           std::cerr << "  ->     vertex " << display_vert(v) << '\n';
-#if CGAL_DEBUG_CDT_3
+          if(debug().geometric_errors()) {
             debug_dump("bug-through-vertex");
-#endif
+          }
           CGAL_error();
         }
       } break;
@@ -784,14 +940,14 @@ protected:
     std::for_each(tr().segment_traverser_simplices_begin(va, vb), tr().segment_traverser_simplices_end(),
                   fill_encroaching_vertices);
     auto vector_of_encroaching_vertices = encroaching_vertices.extract_sequence();
-#if CGAL_DEBUG_CDT_3 & 0x10
+    if(debug().encroaching_vertices()) {
       std::cerr << "  -> vector_of_encroaching_vertices (before filter):\n";
       std::for_each(vector_of_encroaching_vertices.begin(),
                     vector_of_encroaching_vertices.end(),
                     [this](Vertex_handle v){
                       std::cerr << "    " << this->display_vert(v) << '\n';
                     });
-#endif // CGAL_DEBUG_CDT_3
+    }
     auto end = std::remove_if(vector_of_encroaching_vertices.begin(),
                               vector_of_encroaching_vertices.end(),
                               [va, vb, pa, pb, &angle_functor, this](Vertex_handle v) {
@@ -800,13 +956,13 @@ protected:
                                                     this->tr().point(v),
                                                     pb) == ACUTE;
                               });
-#if CGAL_DEBUG_CDT_3 & 0x10
+    if(debug().encroaching_vertices()) {
       std::cerr << "  -> vector_of_encroaching_vertices (after filter):\n";
       std::for_each(vector_of_encroaching_vertices.begin(), end, [&](Vertex_handle v) {
         std::cerr << "    " << this->display_vert(v) << "  angle " << approximate_angle(pa, this->tr().point(v), pb)
                   << '\n';
       });
-#endif // CGAL_DEBUG_CDT_3
+    }
     vector_of_encroaching_vertices.erase(end, vector_of_encroaching_vertices.end());
     return vector_of_encroaching_vertices;
   }
@@ -836,10 +992,10 @@ protected:
       return {midpoint_functor(pa, pb), va->cell(), va};
     }
 
-#if CGAL_DEBUG_CDT_3 & 0x10
+    if(debug().encroaching_vertices()) {
       std::cerr << "construct_Steiner_point( " << display_vert(va) << " , "
                 << display_vert(vb) << " )\n";
-#endif // CGAL_DEBUG_CDT_3
+    }
 
     const auto vector_of_encroaching_vertices = encroaching_vertices(va, vb);
     CGAL_assertion(vector_of_encroaching_vertices.size() > 0);
@@ -905,7 +1061,7 @@ protected:
         return return_orig_result_point(lambda, orig_pb, orig_pa);
       }
     } else {
-      if(segment_vertex_epsilon > 0) {
+      if(debug().segment_vertex_epsilon() > 0) {
         if(!max_bbox_edge_length) {
           update_max_bbox_edge_length();
         }
@@ -936,8 +1092,7 @@ protected:
   Constraint_hierarchy constraint_hierarchy = {comp};
   static_assert(CGAL::cdt_3_msvc_2019_or_older() || CGAL::is_nothrow_movable_v<Constraint_hierarchy>);
   Bbox_3 bbox{};
-  double segment_vertex_epsilon = 1e-8;
+  mutable std::optional<double> max_bbox_edge_length;
-  std::optional<double> max_bbox_edge_length;
   using Pair_of_vertex_handles = std::pair<Vertex_handle, Vertex_handle>;
   boost::container::map<Pair_of_vertex_handles, Constrained_polyline_id> pair_of_vertices_to_cid;
   Insert_in_conflict_visitor insert_in_conflict_visitor = {this};
@@ -969,20 +1124,7 @@ protected:
     }
   }
 
-  enum class Debug_flags {
+  CDT_3::Debug_options debug_options_{};
-    Steiner_points = 0,
-    conforming,
-    input_faces,
-    missing_region,
-    regions,
-    copy_triangulation_into_hole,
-    validity,
-    use_older_cavity_algorithm,
-    debug_finite_edges_map,
-    use_finite_edges_map,
-    nb_of_flags
-  };
-  std::bitset<static_cast<int>(Debug_flags::nb_of_flags)> debug_flags{};
   bool is_Delaunay = true;
 };
 
@@ -990,6 +1132,5 @@ protected:
 
 #endif // not DOXYGEN_RUNNING
 
-#
 
 #endif // CGAL_CONFORMING_DELAUNAY_TRIANGULATION_3_H

Constrained_triangulation_3/include/CGAL/Conforming_constrained_Delaunay_triangulation_cell_data_3.h

@@ -52,31 +52,33 @@ class Conforming_constrained_Delaunay_triangulation_cell_data_3 {
   void clear_mark(CDT_3_cell_marker m) { markers.reset(static_cast<unsigned>(m)); }
   void clear_marks() { markers.reset(); }
 
+  static unsigned int uint(int i) { return static_cast<unsigned int>(i); }
+
   template <typename Facet_handle>
   void set_facet_constraint(int i, CDT_3_signed_index face_id,
                             Facet_handle facet_2d)
   {
-    this->face_id[unsigned(i)] = face_id;
+    this->face_id[uint(i)] = face_id;
-    this->facet_2d[unsigned(i)] = static_cast<void*>(facet_2d == Facet_handle{} ?  nullptr : std::addressof(*facet_2d));
+    this->facet_2d[uint(i)] = static_cast<void*>(facet_2d == Facet_handle{} ?  nullptr : std::addressof(*facet_2d));
   }
 
   template <typename CDT_2>
   auto face_2 (const CDT_2& cdt, int i) const {
     using Face = typename CDT_2::Face;
-    auto ptr = static_cast<Face*>(facet_2d[unsigned(i)]);
+    auto ptr = static_cast<Face*>(facet_2d[uint(i)]);
     return cdt.tds().faces().iterator_to(*ptr);
   }
 public:
   /// @{
   // @cond SKIP_IN_MANUAL
-  bool is_facet_constrained(int i) const { return face_id[unsigned(i)] >= 0; }
+  bool is_facet_constrained(int i) const { return face_id[uint(i)] >= 0; }
 
   CDT_3_signed_index face_constraint_index(int i) const {
-    return face_id[unsigned(i)];
+    return face_id[uint(i)];
   }
 
   void set_face_constraint_index(int i, CDT_3_signed_index index) {
-    face_id[unsigned(i)] = index;
+    face_id[uint(i)] = index;
   }
   /// @endcond
 };

Constrained_triangulation_3/include/CGAL/Conforming_constrained_Delaunay_triangulation_vertex_data_3.h

@@ -16,6 +16,7 @@
 
 #include <CGAL/assertions.h>
 #include <CGAL/Constrained_triangulation_3/internal/config.h>
+#include <CGAL/Constrained_triangulation_3_types.h>
 
 #include <bitset>
 
@@ -34,7 +35,7 @@ namespace CGAL {
 struct Conforming_constrained_Delaunay_triangulation_vertex_data_3 {};
 #else // DOXYGEN_RUNNING
 
-enum class CDT_3_vertex_type { FREE, CORNER, STEINER_ON_EDGE, STEINER_IN_FACE };
+enum class CDT_3_vertex_type { FREE, CORNER, INPUT_VERTEX = CORNER, STEINER_ON_EDGE, STEINER_IN_FACE };
 
 enum class CDT_3_vertex_marker {
   CLEAR = 0,
@@ -91,6 +92,8 @@ public:
   }
 
   int number_of_incident_constraints() const {
+    if(vertex_type() == CDT_3_vertex_type::STEINER_IN_FACE)
+      return 0;
     CGAL_assertion(u.on_edge.nb_of_incident_constraints >= 0);
     return u.on_edge.nb_of_incident_constraints;
   }

Constrained_triangulation_3/include/CGAL/Constrained_triangulation_3/internal/config.h

@@ -48,7 +48,7 @@ decltype(auto) cdt_3_format(std::string_view fmt, const Args&... args) {
 
 template <typename... Args>
 constexpr decltype(auto) cdt_3_format(Args&&...) {
-  return "";
+  return std::string{};
 }
 
 constexpr bool cdt_3_can_use_cxx20_format() {

Constrained_triangulation_3/test/Constrained_triangulation_3/CMakeLists.txt

@@ -26,13 +26,6 @@ create_single_source_cgal_program( "cdt_3_from_off_with_Epeck.cpp")
 target_link_libraries(cdt_3_from_off_with_Epeck PRIVATE CDT_3_dependencies)
 create_single_source_cgal_program( "snap_and_cdt3.cpp")
 
-if(cxx_std_20 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
-  add_executable(cdt_3_from_off_CGAL_DEBUG_CDT_3 cdt_3_from_off)
-  target_compile_definitions(cdt_3_from_off_CGAL_DEBUG_CDT_3 PRIVATE CGAL_DEBUG_CDT_3=255)
-  target_link_libraries(cdt_3_from_off_CGAL_DEBUG_CDT_3 PRIVATE CDT_3_dependencies)
-  cgal_add_test(cdt_3_from_off_CGAL_DEBUG_CDT_3)
-endif()
-
 add_executable(test_CDT_3_insert_constrained_edge_from_EDG_file cdt_test_insert_constrained_edge_from_EDG_file.cpp)
 target_link_libraries(test_CDT_3_insert_constrained_edge_from_EDG_file PRIVATE CDT_3_dependencies)
 target_compile_definitions(test_CDT_3_insert_constrained_edge_from_EDG_file PUBLIC CGAL_TEST_CDT_3_USE_CDT)
@@ -85,7 +78,7 @@ function(CGAL_add_cdt3_from_off_test_aux data_name data_dir)
 endfunction()
 
 function(CGAL_add_cdt3_from_off_test data_name)
-  CGAL_add_cdt3_from_off_test_aux(${data_name} ${CGAL_DATA_DIR}/meshes)
+  CGAL_add_cdt3_from_off_test_aux(${data_name} ${CGAL_DATA_DIR}/meshes ${ARGN})
 endfunction()
 
 CGAL_add_cdt3_from_off_test("cube")
@@ -95,9 +88,10 @@ CGAL_add_cdt3_from_off_test("mpi")
 CGAL_add_cdt3_from_off_test("3torus")
 CGAL_add_cdt3_from_off_test("cheese-selection")
 CGAL_add_cdt3_from_off_test("cheese-selection-2")
+CGAL_add_cdt3_from_off_test("non_manifold_face_graph")
 
 function(CGAL_add_cdt3_from_local_off_test data_name)
-  CGAL_add_cdt3_from_off_test_aux(${data_name} ${CMAKE_CURRENT_SOURCE_DIR}/data)
+  CGAL_add_cdt3_from_off_test_aux(${data_name} ${CMAKE_CURRENT_SOURCE_DIR}/data ${ARGN})
 endfunction()
 
 CGAL_add_cdt3_from_local_off_test(cheese18)
@@ -130,17 +124,15 @@ if (CGAL_CDT_TEST_USE_THINGI)
   CGAL_add_cdt3_from_local_off_test(1514904-min8)
   CGAL_add_cdt3_from_local_off_test(1147177-min1)
   CGAL_add_cdt3_from_local_off_test(1452672-min1)
+  CGAL_add_cdt3_from_local_off_test(135777-min3)
+  CGAL_add_cdt3_from_local_off_test(196123-min3)
+  CGAL_add_cdt3_from_local_off_test(200695-min3)
+  CGAL_add_cdt3_from_local_off_test(285604-min8)
   CGAL_add_cdt3_from_local_off_test(error_mesh-p_not_equal_0-min2)
 
   include(./Thingi10k-CDT.cmake)
 endif()
 
-if(cxx_std_20 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
-  add_test(NAME "execution   of  cdt_3_from_off_CGAL_DEBUG_CDT_3 3torus" COMMAND cdt_3_from_off_CGAL_DEBUG_CDT_3 ${CGAL_DATA_DIR}/meshes/3torus.off)
-  cgal_add_compilation_test(cdt_3_from_off_CGAL_DEBUG_CDT_3)
-  cgal_setup_test_properties("execution   of  cdt_3_from_off_CGAL_DEBUG_CDT_3 3torus" cdt_3_from_off_CGAL_DEBUG_CDT_3)
-endif()
-
 get_directory_property(all_tests TESTS)
 foreach(test ${all_tests})
   if(test MATCHES cdt|CDT)

Constrained_triangulation_3/test/Constrained_triangulation_3/Thingi10k-CDT.cmake

@@ -109,6 +109,152 @@ set(thingi10k_FAILED_WITH_MERGE_FACETS_CTest_20240222_2201
 1514904.stl
 )
 
+set(thingi10k_FAILED_WITH_SEGFAULT_CTest_20251002
+1439534.stl
+196123.stl
+200695.stl
+135777.stl
+285604.stl
+822697.stl
+)
+
+set(thingi10k_FAILED_CTest_20251002
+100606.stl
+100644.stl
+101955.stl
+109130.stl
+116873.stl
+116876.stl
+135777.stl
+139737.stl
+1439534.stl
+145329.stl
+145330.stl
+1505036.stl
+1514900.stl
+196121.stl
+196122.stl
+196123.stl
+196126.stl
+196127.stl
+199814.stl
+199818.stl
+200695.stl
+215991.stl
+230152.stl
+230153.stl
+239188.stl
+276937.stl
+285604.stl
+285605.stl
+288352.stl
+288353.stl
+288354.stl
+288355.stl
+39182.stl
+39245.stl
+472050.stl
+55278.stl
+61418.stl
+622000.stl
+669962.stl
+67817.stl
+702204.stl
+723893.stl
+822697.stl
+904476.stl
+91474.stl
+95796.stl
+95797.stl
+97515.stl
+)
+
+set(thingi10k_FAILED_WITH_MERGE_FACETS_CTest_20251028
+139765.stl
+1452677.stl
+1452678.stl
+1452679.stl
+145329.stl
+145330.stl
+145331.stl
+1505036.stl
+1514900.stl
+153100.stl
+1652975.stl
+1652976.stl
+1706457.stl
+186546.stl
+196121.stl
+196122.stl
+196123.stl
+196126.stl
+196127.stl
+196194.stl
+199814.stl
+199818.stl
+206318.stl
+215991.stl
+230152.stl
+230153.stl
+237632.stl
+239188.stl
+255657.stl
+255658.stl
+276937.stl
+285603.stl
+286161.stl
+288352.stl
+288446.stl
+360073.stl
+362398.stl
+37743.stl
+383022.stl
+39182.stl
+39245.stl
+39495.stl
+39499.stl
+40841.stl
+41521.stl
+42040.stl
+44025.stl
+44064.stl
+44901.stl
+472050.stl
+50659.stl
+51797.stl
+57811.stl
+61418.stl
+61431.stl
+622000.stl
+62592.stl
+62593.stl
+65144.stl
+65395.stl
+65402.stl
+669962.stl
+68255.stl
+702204.stl
+70381.stl
+71461.stl
+723893.stl
+72419.stl
+726665.stl
+77343.stl
+84624.stl
+90225.stl
+906183.stl
+91147.stl
+91474.stl
+93702.stl
+93703.stl
+95796.stl
+95797.stl
+97515.stl
+97590.stl
+97593.stl
+99895.stl
+)
+
 function(CGAL_add_cdt3_test_from_Thingi10k data_name data_filename)
   set(options "ONLY_MERGE_FACETS")
   set(oneValueArgs TIMEOUT)
@@ -145,6 +291,15 @@ foreach(thingi_file_name ${thingi10k_max_10k_solid})
   if(thingi_file_name IN_LIST thingi10k_FAILED_WITH_MERGE_FACETS_CTest_20240222_2201)
     list(APPEND LABELS "CTest_20240222_2201_failed_merge_facets")
   endif()
+  if(thingi_file_name IN_LIST thingi10k_FAILED_CTest_20251002)
+    list(APPEND LABELS "CTest_20251002_failed")
+  endif()
+  if(thingi_file_name IN_LIST thingi10k_FAILED_WITH_SEGFAULT_CTest_20251002)
+    list(APPEND LABELS "CTest_20251002_failed_segfault")
+  endif()
+  if(thingi_file_name IN_LIST thingi10k_FAILED_WITH_MERGE_FACETS_CTest_20251028)
+    list(APPEND LABELS "CTest_20251028_failed_merge_facets")
+  endif()
   get_filename_component(thingi_ID "${thingi_file_name}" NAME_WE)
   CGAL_add_cdt3_test_from_Thingi10k(Thingi10K_${thingi_ID} ${thingi_file_name}
       TIMEOUT 600 LABELS ${LABELS} ${MY_ONLY_MERGE_FACETS})

Constrained_triangulation_3/test/Constrained_triangulation_3/cdt_test_insert_constrained_edge_from_EDG_file.cpp

@@ -1,6 +1,3 @@
-#if __has_include(<format>)
-#define CGAL_DEBUG_CDT_3 1
-#endif
 #define CGAL_TRIANGULATION_CHECK_EXPENSIVE 1
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Delaunay_triangulation_3.h>

Constrained_triangulation_3/test/Constrained_triangulation_3/cdt_test_insert_constrained_edge_from_OFF_file.cpp

@@ -1,6 +1,3 @@
-#if __has_include(<format>)
-#define CGAL_DEBUG_CDT_3 1
-#endif
 #define CGAL_TRIANGULATION_CHECK_EXPENSIVE 1
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Delaunay_triangulation_3.h>

Constrained_triangulation_3/test/Constrained_triangulation_3/data/135777-min3.off

@@ -0,0 +1,69 @@
+OFF
+42 23 0
+
+9.4220000000000006 6.265949 1.2926169999999999
+9.4220000000000006 6.4378760000000002 0.4304
+9.4299999999999997 6.3669419999999999 1.3120000000000001
+9.4220000000000006 6.522742 1.2616000000000001
+9.4299999999999997 1.737943 2.867
+9.4299999999999997 1.310943 1.46
+9.4299999999999997 1.167238 0
+9.4299999999999997 5.7969429999999997 6.9269999999999996
+9.4299999999999997 16.167649999999998 0
+9.4299999999999997 4.499943 6.2329999999999997
+9.4299999999999997 3.3639420000000002 5.3010000000000002
+9.4299999999999997 2.4309430000000001 4.1639999999999997
+12.430999999999999 1.167238 0
+12.430999999999999 1.310943 1.46
+-7.2230889999999999 -5.1901419999999998 1.2724260000000001
+-7.2389999999999999 -5.1100570000000003 1.3959999999999999
+3.7330000000000001 -6.7590570000000003 0.79200000000000004
+-7.255185 -4.6623049999999999 0.88247529999999996
+-7.2552779999999997 -4.6682399999999999 0.88692839999999995
+3.7330000000000001 -6.2710569999999999 0.42699999999999999
+-7.262251 -4.5335140000000003 0.78721229999999998
+-7.7199999999999998 -4.2110570000000003 1.929
+-7.6440000000000001 -4.1590579999999999 1.6100000000000001
+-7.5739999999999998 -4.3940570000000001 1.726
+-7.5469999999999997 -3.6850580000000002 1.224
+-7.5369999999999999 -3.8630580000000001 1.3169999999999999
+-7.4050000000000002 -4.4780569999999997 1.4410000000000001
+-7.3220000000000001 -4.3380580000000002 1.022
+-7.4009999999999998 -4.689057 1.677
+-7.2534720000000004 -4.6835990000000001 0.89814380000000005
+9.4299999999999997 10.06494 1.929
+-7.2789999999999999 -4.0440569999999996 0.34699999999999998
+9.4299999999999997 6.3669419999999999 1.3120000000000001
+-7.2230889999999999 -5.1901419999999998 1.2724260000000001
+3.68716 -6.0934090000000003 0
+3.7330000000000001 -6.2710569999999999 0.42699999999999999
+3.7330000000000001 -6.2710569999999999 0.42699999999999999
+-7.262251 -4.5335140000000003 0.78721229999999998
+-7.6029999999999998 -4.5610569999999999 2.0139999999999998
+-7.4050000000000002 -4.4780569999999997 1.4410000000000001
+-7.3220000000000001 -4.3380580000000002 1.022
+-7.2599 -4.5207920000000001 0.75421059999999995
+3  0 1 2
+3  1 3 2
+3  4 32 5
+3  6 5 32
+3  8 32 30
+3  9 7 32
+3  32 7 30
+3  10 32 11
+3  4 11 32
+3  10 9 32
+3  6 32 8
+3  13 5 12
+3  38 23 21
+3  26 25 22
+3  24 25 26
+3  27 39 28
+3  16 19 14
+3  35 34 20
+3  18 29 36
+3  18 28 29
+3  15 33 29
+3  31 40 41
+3  40 17 37
+

Constrained_triangulation_3/test/Constrained_triangulation_3/data/196123-min3.off

@@ -0,0 +1,75 @@
+OFF
+37 34 0
+
+172.45960998535156 327.00732421875 10.000033378601074
+173.35765075683594 327.18472290039062 10.000033378601074
+172.45960998535156 327.00732421875 10
+174.25531005859375 327.36398315429688 10.000033378601074
+175.282470703125 327.571533203125 10
+170.58482360839844 325.87066650390625 10
+170.58482360839844 325.87066650390625 10.000033378601074
+170.58476257324219 326.1373291015625 10
+170.58476257324219 326.1373291015625 10.000033378601074
+170.58488464355469 326.67068481445312 10.000033378601074
+170.58488464355469 326.67068481445312 10
+170.58477783203125 326.40402221679688 10.000033378601074
+170.58477783203125 326.40402221679688 10
+171.21096801757812 326.77630615234375 10
+171.21096801757812 326.77630615234375 10.000033378601074
+171.83589172363281 326.88851928710938 10.000033378601074
+171.83589172363281 326.88851928710938 10
+198.59626770019531 331.45306396484375 10
+171.3594970703125 325.91452026367188 10
+171.3594970703125 325.91452026367188 10.000033378601074
+171.10134887695312 325.89859008789062 10
+171.10134887695312 325.89859008789062 10.000033378601074
+170.84312438964844 325.88397216796875 10.000033378601074
+170.84312438964844 325.88397216796875 10
+173.88740539550781 326.08248901367188 10.000033378601074
+174.88548278808594 326.13330078125 10
+173.12164306640625 326.03756713867188 10
+172.62298583984375 326.00552368164062 10.000033378601074
+176.65058898925781 326.20169067382812 10
+179.54045104980469 326.31793212890625 10
+182.43142700195312 326.40179443359375 10
+192.267333984375 331.10971069335938 10
+197.96424865722656 332.17782592773438 10
+175.15260314941406 328.56558227539062 10.000033378601074
+175.15260314941406 325.1444091796875 10.000033378601074
+161.37049865722656 320.09548950195312 10.000033378601074
+161.37049865722656 332.70773315429688 10.000033378601074
+3  1 3 2
+3  2 3 4
+3  18 26 27
+3  27 26 24
+3  4 30 2
+3  31 32 17
+3  30 29 2
+3  2 29 16
+3  25 10 28
+3  10 25 12
+3  18 7 26
+3  18 20 7
+3  20 23 7
+3  23 5 7
+3  7 12 26
+3  26 12 25
+3  10 13 28
+3  13 16 28
+3  21 19 34
+3  21 34 22
+3  19 27 34
+3  36 11 35
+3  3 1 33
+3  1 0 33
+3  0 15 33
+3  15 14 33
+3  14 9 33
+3  33 9 36
+3  11 8 35
+3  8 6 35
+3  35 6 34
+3  6 22 34
+3  34 27 24
+3  11 36 9
+

Constrained_triangulation_3/test/Constrained_triangulation_3/data/200695-min3.off

@@ -0,0 +1,46 @@
+OFF
+25 17 0
+
+137.05000305175781 47.498001098632812 132.02400207519531
+137.05000305175781 42.498001098632812 132.65000915527344
+137.05000305175781 20 131.40000915527344
+137.05000305175781 14.998001098632812 90.316001892089844
+137.05000305175781 0 133.90000915527344
+137.05000305175781 5 131.40000915527344
+120.80000305175781 0 133.90000915527344
+134.05000305175781 2.9980001449584961 133.90000915527344
+136.67401123046875 15.874000549316406 133.90000915527344
+137.12800598144531 5 132.33399963378906
+137.12800598144531 20 132.33399963378906
+137.36601257324219 5 133.24000549316406
+137.36601257324219 20 133.24000549316406
+137.75401306152344 5 134.09400939941406
+137.05000305175781 31.248001098632812 90.316001892089844
+137.05000305175781 16.248001098632812 133.90000915527344
+118.55000305175781 2.25 133.90000915527344
+104.55000305175781 0 133.90000915527344
+137.05000305175781 32.498001098632812 133.90000915527344
+55.800003051757812 0 133.90000915527344
+54.674003601074219 1.124000072479248 133.90000915527344
+55.050003051757812 0.74800002574920654 133.90000915527344
+136.30000305175781 31.750001907348633 133.90000915527344
+39.550003051757812 0 133.90000915527344
+137.05000305175781 20 118.12000274658203
+3  0 1 2
+3  4 5 2
+3  7 4 8
+3  10 9 11
+3  10 11 12
+3  12 11 13
+3  14 24 3
+3  2 15 4
+3  15 8 4
+3  17 7 16
+3  18 2 1
+3  7 17 6
+3  2 18 15
+3  7 8 22
+3  15 22 8
+3  20 23 21
+3  19 21 23
+

Constrained_triangulation_3/test/Constrained_triangulation_3/data/285604-min8.off

@@ -0,0 +1,119 @@
+OFF
+67 48 0
+
+25.003999710083008 4.125999927520752 5.3249998092651367
+24.648000717163086 4.1110000610351562 5.3020000457763672
+27.875 4.124000072479248 5.3159999847412109
+28.104999542236328 4.0980000495910645 5.3020000457763672
+27.547000885009766 -0.76599997282028198 5.3020000457763672
+24.26300048828125 4.1999998092651367 5.3020000457763672
+24.350000381469727 -1.2070000171661377 5.3020000457763672
+22.61199951171875 -1.2680000066757202 5.3020000457763672
+18.076999664306641 -0.76700001955032349 5.3020000457763672
+20.534172058105469 6.6471333503723145 5.3020000457763672
+21.565000534057617 6.2769999504089355 5.3020000457763672
+21.576999664306641 6.2220001220703125 5.3020000457763672
+24.184999465942383 4.2010002136230469 5.3020000457763672
+24.132999420166016 4.2109999656677246 5.3020000457763672
+23.76099967956543 4.3359999656677246 5.3020000457763672
+23.552000045776367 4.3480663299560547 5.3020000457763672
+23.822000503540039 4.2779998779296875 5.3020000457763672
+23.259000778198242 4.4369997978210449 5.3029999732971191
+22.599832534790039 5.119999885559082 5.3020000457763672
+21.814010620117188 5.7782330513000488 5.3020000457763672
+22.527999877929688 4.9455761909484863 5.3020000457763672
+21.797874450683594 5.8303966522216797 5.3020968437194824
+22.527999877929688 4.6591053009033203 5.3020000457763672
+21.822000503540039 5.8159999847412109 6.0100002288818359
+21.772134780883789 5.687347412109375 5.3039073944091797
+21.657405853271484 5.9652857780456543 5.3020000457763672
+21.655532836914062 5.9393019676208496 5.3023014068603516
+21.794061660766602 5.8427157402038574 5.3020000457763672
+21.660037994384766 5.9280643463134766 5.3023800849914551
+21.660087585449219 5.9279398918151855 5.3023805618286133
+21.820028305053711 5.6319999694824219 5.3020000457763672
+21.659999847412109 5.9279999732971191 5.3020000457763672
+19.494876861572266 4.9111647605895996 5.3020000457763672
+21.641000747680664 5.9800000190734863 5.3020000457763672
+21.624000549316406 6.0019998550415039 5.309999942779541
+-2.1689999103546143 -0.46799999475479126 5.3020000457763672
+20.37629508972168 6.2305684089660645 5.3020000457763672
+-2.2790000438690186 -1.3259999752044678 6.0859999656677246
+-2.1040000915527344 0.082999996840953827 5.320000171661377
+22.329999923706055 5.0479998588562012 5.3020000457763672
+19.238409042358398 4.5272407531738281 5.3020000457763672
+-1.9989999532699585 0.26600000262260437 6.7109999656677246
+18.052036285400391 3.3704285621643066 5.3020000457763672
+20.326999664306641 6.2470002174377441 5.0159997940063477
+19.670000076293945 6.4640002250671387 3.7780001163482666
+18.603000640869141 4.8670001029968262 3.7780001163482666
+-0.6029999852180481 6.8179998397827148 2.6359999179840088
+0.33100000023841858 3.0639998912811279 5.0159997940063477
+-1.143372654914856 4.4346461296081543 5.3020000457763672
+-1.1940000057220459 4.5510001182556152 5.0159997940063477
+0.83399999141693115 3.4670000076293945 3.7780001163482666
+-3.2599999904632568 10 5.0159997940063477
+-2.5490000247955322 10 3.7780001163482666
+-2.3269999027252197 8.1979999542236328 3.7780001163482666
+-1.6699999570846558 6.4640002250671387 3.7780001163482666
+-2.1198277473449707 5.846644401550293 5.3020000457763672
+-3.0250000953674316 8.0860004425048828 5.0159997940063477
+-1.9939999580383301 3.0099999904632568 5.3020000457763672
+-1.2384099960327148 4.5272407531738281 5.3020000457763672
+-2.2780001163482666 3.7369999885559082 5.3020000457763672
+-2.0220000743865967 0.74299997091293335 6.0689997673034668
+-1.9220000505447388 1.1330000162124634 5.3020000457763672
+-1.9739999771118164 0.92799997329711914 5.314000129699707
+-2.1050000190734863 -0.041999999433755875 6.1490001678466797
+-2.3269999027252197 6.2470002174377441 5.0159997940063477
+-0.6029999852180481 4.8670001029968262 3.7780001163482666
+21.659999847412109 5.9279999732971191 5.3020000457763672
+3  2 3 0
+3  5 1 6
+3  3 4 1
+3  4 6 1
+3  12 5 6
+3  13 12 7
+3  25 19 30
+3  19 25 27
+3  24 29 23
+3  31 32 25
+3  25 30 31
+3  34 66 26
+3  33 25 32
+3  66 34 28
+3  10 11 36
+3  11 33 36
+3  27 18 19
+3  17 18 21
+3  39 22 32
+3  20 19 18
+3  40 32 22
+3  8 40 22
+3  16 8 14
+3  6 7 12
+3  15 14 8
+3  8 16 7
+3  36 9 10
+3  30 39 32
+3  31 30 32
+3  36 33 32
+3  43 45 44
+3  22 15 8
+3  8 42 40
+3  16 13 7
+3  49 58 55
+3  57 59 48
+3  51 52 56
+3  64 56 53
+3  65 54 46
+3  65 49 54
+3  49 64 54
+3  47 65 50
+3  47 49 65
+3  38 62 35
+3  62 61 35
+3  38 37 63
+3  41 60 63
+3  63 37 41
+

Constrained_triangulation_3/test/Constrained_triangulation_3/test_ccdt_remeshing.cpp

@@ -40,7 +40,7 @@ int main(int argc, char* argv[])
   auto cdt = CGAL::make_conforming_constrained_Delaunay_triangulation_3<CDT>(mesh);
   static_assert(std::is_same_v<decltype(cdt), CDT>);
   CDT cdt2(mesh);
-  const auto nb_cstr_facets = cdt2.number_of_constrained_facets();
+  [[maybe_unused]] const auto nb_cstr_facets = cdt2.number_of_constrained_facets();
 
   assert(cdt.triangulation().number_of_vertices() == cdt2.triangulation().number_of_vertices());
   assert(cdt.number_of_constrained_facets() == cdt2.number_of_constrained_facets());

Data/data/meshes/non_manifold_face_graph.off

@@ -0,0 +1,39 @@
+OFF
+24 11 0
+
+1.5 0.5 1
+0.5 0.5 0
+0.5 0.5 1
+0 0 0
+0 0.5 0
+0.5 0.5 0
+0.5 1 0
+0 1 0
+0.5 0 0
+1 0 0
+1 0.5 0
+1 1 0
+1.5 1.5 1
+2.5 1.5 1
+2.5 0.5 1
+-0.5 -0.5 1
+2.5 -0.5 1
+0.5 1.5 1
+-0.5 0.5 1
+1.5 0.5 1
+1.5 -0.5 1
+-0.5 1.5 1
+0.5 0.5 1
+0.5 -0.5 1
+3  2 1 0
+4  4 3 8 5
+4  7 4 5 6
+4  5 8 9 10
+4  6 5 10 11
+4  12 19 14 13
+4  19 20 16 14
+4  17 22 19 12
+4  22 23 20 19
+4  21 18 22 17
+4  18 15 23 22
+

Documentation/doc/Documentation/Third_party.txt

@@ -117,14 +117,14 @@ Qt is a cross-platform application and UI framework.
 The component `CGAL_Qt6` is essential to run the \cgal demos and basic viewers.
 It requires \qt6 installed on your system.
 In case \qt is not yet installed on your system, you can download
-it from <A HREF="https://www.qt-project.org/">`https://www.qt-project.org/`</A>.
+it from <A HREF="https://contribute.qt-project.org/">`https://contribute.qt-project.org/`</A>.
 
 The exhaustive list of \qt6 components used in demos is:
 `Core`, `Gui`, `Help`, `OpenGL`, `OpenGLWidgets`, `Qml`, `Svg`, `Widgets`,
 `WebSockets`,  `Network`, and `qcollectiongenerator` (with `sqlite` driver plugin).
 
 \subsection thirdpartyEigen Eigen
-<b>Version 3.3.7 or later</b>
+<b>Version 3.3.7 or later (including Eigen3 5.0.0)</b>
 
 \eigen is a `C++` template library for linear algebra. \eigen supports all
 matrix sizes, various matrix decomposition methods and sparse linear solvers.
@@ -138,7 +138,7 @@ Overview</a> page. In order to use Eigen in \cgal programs, the
 executables should be linked with the CMake imported target
 `CGAL::Eigen3_support` provided in `CGAL_Eigen3_support.cmake`.
 
-The \eigen web site is <A HREF="https://eigen.tuxfamily.org/index.php?title=Main_Page">`https://eigen.tuxfamily.org`</A>.
+The \eigen web site is <A HREF="https://libeigen.gitlab.io/">`https://libeigen.gitlab.io/`</A>.
 
 \subsection thirdpartyOpenGR OpenGR
 
@@ -167,17 +167,6 @@ Alternatively, version 1.3.1 of \libpointmatcher is supported with version 3.3.7
 `https://github.com/ethz-asl/libpointmatcher/blob/master/doc/Compilation.md`:`NABO_INCLUDE_DIR` becomes `libnabo_INCLUDE_DIRS`
 and `NABO_LIBRARY` becomes `libnabo_LIBRARIES` in the "Build libpointmatcher" section.
 
-\subsection thirdpartyLeda LEDA
-<b>Version 6.2 or later</b>
-
-\leda is a library of efficient data structures and
-algorithms. Like \core, \leda offers a real number data type.
-
-In \cgal this library is optional, and its number types can
-be used as an alternative to \gmp, \mpfr, and \core.
-
-Free and commercial editions of \leda are available from <A HREF="https://www.algorithmic-solutions.com">`https://www.algorithmic-solutions.com`</A>.
-
 \subsection thirdpartyMPFI Multiple Precision Floating-point Interval (MPFI)
 <b>Version 1.4 or later</b>
 
@@ -265,7 +254,7 @@ vcpkg install suitesparse
 \subsection thirdpartyMETIS METIS
 <b>Version 5.1 or later</b>
 
-\metis is a library developed by the <A HREF="http://glaros.dtc.umn.edu/gkhome/">Karypis Lab</A>
+\metis is a library developed by the <A HREF="https://github.com/KarypisLab/">Karypis Lab</A>
 and designed to partition graphs and produce fill-reducing matrix orderings.
 
 \cgal offers wrappers around some of the methods of the \metis library
@@ -274,7 +263,7 @@ to allow the partitioning of graphs that are models of the concepts of the
 and, by extension, of surface meshes (see Section \ref BGLPartitioning of the package \ref PkgBGL).
 
 More information is available on the METIS library
-at <A HREF="http://glaros.dtc.umn.edu/gkhome/metis/metis/overview">`http://glaros.dtc.umn.edu/gkhome/metis/metis/overview`</A>.
+at <A HREF="https://github.com/KarypisLab/METIS">`https://github.com/KarypisLab/METIS`</A>.
 
 \subsection thirdpartyzlib zlib
 

Documentation/doc/biblio/geom.bib

@@ -118600,7 +118600,7 @@ both for rendering and for modeling. Contains C code."
 
 @article{ph-ddocs-92
 , author =      "J. P. Pratt and V. P. Heuring"
-, title =       "Designing digital optical computing systems: power and and crosstalk"
+, title =       "Designing digital optical computing systems: power and crosstalk"
 , journal =     "Appl. Optics"
 , volume =      31
 , number =      23

Documentation/doc/resources/1.14.0/menu_version.js

@@ -1,12 +1,12 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(main|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = 'master'
+  var current_version_local = 'main'
   var all_versions = [
-    'master',
+    'main',
-    '6.1-beta2',
+    '6.1',
     '6.0.2',
     'latest',
     '5.6.3',
@@ -31,12 +31,12 @@
 ];
 
   function build_select(current_version) {
-    if( current_version == 'master') {
+    if( current_version == 'main') {
       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.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/main">main</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);
     }

Documentation/doc/resources/1.8.13/menu_version.js

@@ -1,12 +1,12 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(main|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = 'master'
+  var current_version_local = 'main'
   var all_versions = [
-    'master',
+    'main',
-    '6.1-beta2',
+    '6.1',
     '6.0.2',
     'latest',
     '5.6.3',
@@ -31,12 +31,12 @@
 ];
 
   function build_select(current_version) {
-    if( current_version == 'master') {
+    if( current_version == 'main') {
       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.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/main">main</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);
     }

Documentation/doc/resources/1.9.6/menu_version.js

@@ -1,12 +1,12 @@
 (function() {
   'use strict';
 
-  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
+  var url_re =  /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(main|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
   var url_local =  /.*\/doc_output\//;
-  var current_version_local = 'master'
+  var current_version_local = 'main'
   var all_versions = [
-    'master',
+    'main',
-    '6.1-beta2',
+    '6.1',
     '6.0.2',
     'latest',
     '5.6.3',
@@ -31,12 +31,12 @@
 ];
 
   function build_select(current_version) {
-    if( current_version == 'master') {
+    if( current_version == 'main') {
       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.innerHTML = '⚠️ This documentation corresponds to the <a style="font-familly: monospace;" href="https://github.com/CGAL/cgal/tree/main">main</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);
     }

Filtered_kernel/include/CGAL/Epic_converter.h

@@ -66,7 +66,7 @@ public:
     if(fit_in_double(n,d)){
       return std::make_pair(d,true);
     }
-    return std::make_pair(0,false);
+    return {};
   }
 
   std::pair<Bbox_2,bool> operator()(const Bbox_2 b) const
@@ -86,7 +86,7 @@ public:
     if(fit_in_double(p.x(),x) && fit_in_double(p.y(),y)){
       return std::make_pair(Point_2(x,y),true);
     }
-    return std::make_pair(ORIGIN,false);
+    return {};
   }
 
   std::pair<Vector_2,bool> operator()(const typename IK::Vector_2& v) const
@@ -96,7 +96,7 @@ public:
     if(fit_in_double(v.x(),x) && fit_in_double(v.y(),y)){
       return std::make_pair(Vector_2(x,y),true);
     }
-    return std::make_pair(Vector_2(),false);
+    return {};
   }
 
   std::pair<Direction_2,bool> operator()(const typename IK::Direction_2& d) const
@@ -106,7 +106,7 @@ public:
     if(fit_in_double(d.dx(),x) && fit_in_double(d.dy(),y)){
       return std::make_pair(Direction_2(x,y),true);
     }
-    return std::make_pair(Direction_2(),false);
+    return {};
   }
 
   std::pair<Weighted_point_2,bool> operator()(const typename IK::Weighted_point_2& wp) const
@@ -116,18 +116,18 @@ public:
     if(sp.second && w.second){
       return std::make_pair(Weighted_point_2(sp.first,w.first),true);
     }
-    return std::make_pair(Weighted_point_2(),false);
+    return {};
   }
 
   std::pair<Segment_2,bool> operator()(const typename IK::Segment_2& s) const
   {
     std::pair<Point_2,bool> sp = operator()(s.source());
     if(! sp.second){
-      return std::make_pair(Segment_2(),false);
+      return {};
     }
     std::pair<Point_2,bool> tp = operator()(s.target());
     if(! tp.second){
-      return std::make_pair(Segment_2(),false);
+      return {};
     }
     return std::make_pair(Segment_2(sp.first,tp.first), true);
   }
@@ -138,18 +138,18 @@ public:
     if(a.second && b.second && c.second){
       return std::make_pair(Line_2(a.first, b.first, c.first),true);
     }
-    return std::make_pair(Line_2(), false);
+    return {};
   }
 
   std::pair<Ray_2,bool> operator()(const typename IK::Ray_2& r) const
   {
     std::pair<Point_2,bool> sp = operator()(r.source());
     if(! sp.second){
-      return std::make_pair(Ray_2(),false);
+      return {};
     }
     std::pair<Point_2,bool> tp = operator()(r.second_point());
     if(! tp.second){
-      return std::make_pair(Ray_2(),false);
+      return {};
     }
     return std::make_pair(Ray_2(sp.first,tp.first), true);
   }
@@ -158,15 +158,15 @@ public:
   {
     std::pair<Point_2,bool> v0 = operator()(t.vertex(0));
     if(! v0.second){
-      return std::make_pair(Triangle_2(),false);
+      return {};
     }
     std::pair<Point_2,bool> v1 = operator()(t.vertex(1));
     if(! v1.second){
-      return std::make_pair(Triangle_2(),false);
+      return {};
     }
     std::pair<Point_2,bool> v2 = operator()(t.vertex(2));
     if(! v2.second){
-      return std::make_pair(Triangle_2(),false);
+      return {};
     }
     return std::make_pair(Triangle_2(v0.first,v1.first, v2.first), true);
   }
@@ -178,18 +178,18 @@ public:
     if(c.second && sr.second){
       return std::make_pair(Circle_2(c.first, sr.first, ci.orientation()),true);
     }
-    return std::make_pair(Circle_2(), false);
+    return {};
   }
 
   std::pair<Iso_rectangle_2,bool> operator()(const typename IK::Iso_rectangle_2& ir) const
   {
     std::pair<Point_2,bool> sp = operator()((ir.min)());
     if(! sp.second){
-      return std::make_pair(Iso_rectangle_2(),false);
+      return {};
     }
     std::pair<Point_2,bool> tp = operator()((ir.max)());
     if(! tp.second){
-      return std::make_pair(Iso_rectangle_2(),false);
+      return {};
     }
     return std::make_pair(Iso_rectangle_2(sp.first,tp.first), true);
   }
@@ -199,11 +199,11 @@ public:
   {
     std::pair<Point_3,bool> sp = operator()(li.point());
     if(! sp.second){
-      return std::make_pair(Line_3(),false);
+      return {};
     }
     std::pair<Vector_3,bool> tp = operator()(li.to_vector());
     if(! tp.second){
-      return std::make_pair(Line_3(),false);
+      return {};
     }
     return std::make_pair(Line_3(sp.first,tp.first), true);
   }
@@ -214,22 +214,22 @@ public:
     if(a.second && b.second && c.second && d.second){
       return std::make_pair(Plane_3(a.first, b.first, c.first, d.first),true);
     }
-    return std::make_pair(Plane_3(), false);
+    return {};
   }
 
   std::pair<Triangle_3,bool> operator()(const typename IK::Triangle_3& t) const
   {
     std::pair<Point_3,bool> v0 = operator()(t.vertex(0));
     if(! v0.second){
-      return std::make_pair(Triangle_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> v1 = operator()(t.vertex(1));
     if(! v1.second){
-      return std::make_pair(Triangle_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> v2 = operator()(t.vertex(2));
     if(! v2.second){
-      return std::make_pair(Triangle_3(),false);
+      return {};
     }
     return std::make_pair(Triangle_3(v0.first,v1.first, v2.first), true);
   }
@@ -238,19 +238,19 @@ public:
   {
     std::pair<Point_3,bool> v0 = operator()(t.vertex(0));
     if(! v0.second){
-      return std::make_pair(Tetrahedron_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> v1 = operator()(t.vertex(1));
     if(! v1.second){
-      return std::make_pair(Tetrahedron_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> v2 = operator()(t.vertex(2));
     if(! v2.second){
-      return std::make_pair(Tetrahedron_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> v3 = operator()(t.vertex(3));
     if(! v3.second){
-      return std::make_pair(Tetrahedron_3(),false);
+      return {};
     }
     return std::make_pair(Tetrahedron_3(v0.first,v1.first, v2.first, v3.first), true);
   }
@@ -259,11 +259,11 @@ public:
   {
     std::pair<Point_3,bool> sp = operator()(r.source());
     if(! sp.second){
-      return std::make_pair(Ray_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> tp = operator()(r.second_point());
     if(! tp.second){
-      return std::make_pair(Ray_3(),false);
+      return {};
     }
     return std::make_pair(Ray_3(sp.first,tp.first), true);
   }
@@ -275,7 +275,7 @@ public:
     if(fit_in_double(p.x(),x) && fit_in_double(p.y(),y) && fit_in_double(p.z(),z)){
       return std::make_pair(Point_3(x,y,z),true);
     }
-    return std::make_pair(ORIGIN,false);
+    return {};
   }
 
   std::pair<Vector_3,bool> operator()(const typename IK::Vector_3& v) const
@@ -285,7 +285,7 @@ public:
     if(fit_in_double(v.x(),x) && fit_in_double(v.y(),y) && fit_in_double(v.z(),z)){
       return std::make_pair(Vector_3(x,y,z),true);
     }
-    return std::make_pair(Vector_3(),false);
+    return {};
   }
 
   std::pair<Direction_3,bool> operator()(const typename IK::Direction_3& d) const
@@ -295,18 +295,18 @@ public:
     if(fit_in_double(d.dx(),x) && fit_in_double(d.dy(),y) && fit_in_double(d.dz(),z)){
       return std::make_pair(Direction_3(x,y,z),true);
     }
-    return std::make_pair(Direction_3(),false);
+    return {};
   }
 
   std::pair<Segment_3,bool> operator()(const typename IK::Segment_3& s) const
   {
     std::pair<Point_3,bool> sp = operator()(s.source());
     if(! sp.second){
-      return std::make_pair(Segment_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> tp = operator()(s.target());
     if(! tp.second){
-      return std::make_pair(Segment_3(),false);
+      return {};
     }
     return std::make_pair(Segment_3(sp.first,tp.first), true);
   }
@@ -318,7 +318,7 @@ public:
     if(sp.second && w.second){
       return std::make_pair(Weighted_point_3(sp.first,w.first),true);
     }
-    return std::make_pair(Weighted_point_3(),false);
+    return {};
   }
 
   std::pair<Sphere_3,bool> operator()(const typename IK::Sphere_3& s) const
@@ -328,7 +328,7 @@ public:
     if(c.second && sr.second){
       return std::make_pair(Sphere_3(c.first, sr.first, s.orientation()),true);
     }
-    return std::make_pair(Sphere_3(), false);
+    return {};
   }
 
   std::pair<Circle_3,bool> operator()(const typename IK::Circle_3& ci) const
@@ -338,18 +338,18 @@ public:
     if(c.second && sr.second){
       return std::make_pair(Circle_3(sr.first, c.first),true);
     }
-    return std::make_pair(Circle_3(), false);
+    return {};
   }
 
   std::pair<Iso_cuboid_3,bool> operator()(const typename IK::Iso_cuboid_3& ic) const
   {
     std::pair<Point_3,bool> sp = operator()((ic.min)());
     if(! sp.second){
-      return std::make_pair(Iso_cuboid_3(),false);
+      return {};
     }
     std::pair<Point_3,bool> tp = operator()((ic.max)());
     if(! tp.second){
-      return std::make_pair(Iso_cuboid_3(),false);
+      return {};
     }
     return std::make_pair(Iso_cuboid_3(sp.first,tp.first), true);
   }

Frechet_distance/examples/Frechet_distance/CMakeLists.txt

@@ -7,7 +7,7 @@ project( Frechet_distance_Examples )
 find_package(CGAL REQUIRED QUIET OPTIONAL_COMPONENTS Core )
 
 
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 create_single_source_cgal_program( "Frechet_distance_2.cpp" )

Frechet_distance/include/CGAL/Frechet_distance/internal/Frechet_light.h

@@ -514,6 +514,7 @@ inline void FrechetLight<C>::continueQSimpleSearch(QSimpleInterval& qsimple,
         // TODO: uncritical for correctness or speed but unelegant coding style: stripping down information added by getInterval
         CInterval temp_interval = FrechetLight::getInterval<IndexType>(
             fixed_curve, fixed, curve, cur);
+
         Interval interval = Interval(temp_interval.begin.getPoint() == cur
                                          ? temp_interval.begin.getFraction()
                                          : 1,

Frechet_distance/include/CGAL/Frechet_distance/internal/geometry_basics.h

@@ -113,7 +113,10 @@ struct Lambda<Curve<FilteredTraits,true>>
     //     fill_lambda returns a pair and we are only interested in a bound
     bool update_exact() const
     {
-        if (is_exact) {
+        if (is_exact){
+            if (!exact.has_value()){
+                exact = (is_one) ? std::make_optional(Exact(1)) : std::make_optional(Exact(0));
+            }
             return true;
         }
 
@@ -198,7 +201,9 @@ struct Lambda<Curve<FilteredTraits,true>>
     {
         if ((is_zero && other.is_zero) || (is_one && other.is_one))
             return false;
-        if ((is_zero && (!other.is_zero)) || (!is_one && other.is_one))
+        // AF this may be wrong if approx is [0.9,1.1]  and other.is_one:
+        // if ((is_zero && (!other.is_zero)) || (!is_one && other.is_one))
+        if(is_zero && other.is_one)
             return true;
         CGAL::Uncertain<bool> res = approx < other.approx;
         if (CGAL::is_certain(res)) {
@@ -206,7 +211,8 @@ struct Lambda<Curve<FilteredTraits,true>>
         }
         update_exact();
         other.update_exact();
-        return exact < other.exact;
+        bool eres = exact.value() < other.exact.value();
+        return eres;
     }
 };
 

Frechet_distance/test/Frechet_distance/CMakeLists.txt

@@ -6,8 +6,12 @@ project( Frechet_distance_Tests )
 
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
+
 include(CGAL_Eigen3_support)
+
+create_single_source_cgal_program( "Frechet-IssueOct25.cpp" )
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program( "Frechet_distance_test.cpp" )
   target_link_libraries(Frechet_distance_test PRIVATE CGAL::Eigen3_support)

Frechet_distance/test/Frechet_distance/Frechet-IssueOct25.cpp

@@ -0,0 +1,40 @@
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Frechet_distance.h>
+
+#include <fstream>
+
+using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
+using Point = Kernel::Point_2;
+using Segment = Kernel::Segment_2;
+
+bool load_polyline(const std::string &filename, std::vector<Point> &polyline) {
+  polyline.clear();
+  std::ifstream ifs(filename);
+
+  if (!ifs)
+    return false;
+
+  while (ifs.good()) {
+    Point p;
+    ifs >> p;
+    if (ifs.good())
+      polyline.push_back(p);
+  }
+
+  return true;
+}
+
+int main() {
+
+  std::vector<Point> poly1, poly2;
+
+  if (!load_polyline("poly1.txt", poly1) || !load_polyline("poly2.txt", poly2)) {
+    std::cout << "input files could not be loaded" << std::endl;
+    return -1;
+  }
+
+
+  std::pair<double, double> res = CGAL::bounded_error_Frechet_distance(poly1, poly2, 0.000001);
+ std::cout << "Frechet distance: [" << res.first << ", " << res.second << "]" << std::endl;
+  return 0;
+}

Frechet_distance/test/Frechet_distance/data/scripts/CMakeLists.txt

@@ -6,8 +6,7 @@ project( classical_Frechet_distance )
 
 find_package(CGAL REQUIRED)
 
-
+find_package(Eigen3 QUIET)
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
 include(CGAL_Eigen3_support)
 
 create_single_source_cgal_program("Compute_classical_Frechet_distance_3.cpp")

Frechet_distance/test/Frechet_distance/poly1.txt

@@ -0,0 +1,185 @@
+-126 70
+-138 58
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-39 -18
+-42.6 -14
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70

Frechet_distance/test/Frechet_distance/poly2.txt

@@ -0,0 +1,625 @@
+-126 70
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+70 -138
+61.4 -118.4
+61.4 -118
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70
+-126 70

Generator/examples/Generator/CMakeLists.txt

@@ -28,8 +28,9 @@ create_single_source_cgal_program("random_segments1.cpp")
 create_single_source_cgal_program("random_segments2.cpp")
 create_single_source_cgal_program("sphere_d.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("random_points_in_tetrahedral_mesh_3.cpp")
   target_link_libraries(random_points_in_tetrahedral_mesh_3 PRIVATE CGAL::Eigen3_support)

Generator/test/Generator/CMakeLists.txt

@@ -15,8 +15,9 @@ create_single_source_cgal_program("test_tetrahedron_3.cpp")
 create_single_source_cgal_program("test_triangle_2.cpp")
 create_single_source_cgal_program("test_triangle_3.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("generic_random_test.cpp")
   target_link_libraries(generic_random_test PRIVATE CGAL::Eigen3_support)

GraphicsView/demo/Bounding_volumes/CMakeLists.txt

@@ -8,7 +8,7 @@ find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt6)
 
 find_package(Qt6 QUIET COMPONENTS Widgets)
 
-find_package(Eigen3 3.1.91 QUIET) #(requires 3.1.91 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 if(NOT TARGET CGAL::Eigen3_support)

GraphicsView/demo/Polygon/CMakeLists.txt

@@ -6,8 +6,9 @@ project(Polygon_Demo)
 
 find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt6 Core)
 
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This demo requires the Eigen library, and will not be compiled.")
   return()

GraphicsView/include/CGAL/Qt/DemosMainWindow_impl.h

@@ -221,7 +221,10 @@ void
 DemosMainWindow::popupAboutBox(QString title, QString html_resource_name)
 {
   QFile about_CGAL(html_resource_name);
-  about_CGAL.open(QIODevice::ReadOnly);
+  if (!about_CGAL.open(QIODevice::ReadOnly)) {
+    QMessageBox::warning(this, tr("Error"), tr("Could not open resource file: %1").arg(html_resource_name));
+    return;
+  }
   QString about_CGAL_txt = QTextStream(&about_CGAL).readAll();
 #ifdef CGAL_VERSION_STR
   QString cgal_version(CGAL_VERSION_STR);

Heat_method_3/examples/Heat_method_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Heat_method_3_Examples)
 # CGAL and its components
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.3.0 QUIET)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: These examples require the Eigen library (3.3 or greater), and will not be compiled.")
   return()

Heat_method_3/test/Heat_method_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Heat_method_3_Tests)
 # CGAL and its components
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.3.0 QUIET)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: These tests require the  Eigen library (3.3 or greater), and will not be compiled.")
   return()

Installation/cmake/modules/CGAL_Ceres_support.cmake

@@ -3,5 +3,5 @@ if(CERES_FOUND AND NOT TARGET CGAL::Ceres_support)
   set_target_properties(CGAL::Ceres_support PROPERTIES
     INTERFACE_COMPILE_DEFINITIONS "CGAL_PMP_USE_CERES_SOLVER"
     INTERFACE_INCLUDE_DIRECTORIES "${CERES_INCLUDE_DIRS}"
-    INTERFACE_LINK_LIBRARIES "ceres")
+    INTERFACE_LINK_LIBRARIES "Ceres::ceres")
 endif()

Installation/cmake/modules/CGAL_Eigen3_support.cmake

@@ -1,3 +1,10 @@
+if((EIGEN3_FOUND OR Eigen3_FOUND) AND NOT TARGET CGAL::Eigen3_support)
+  if ("${Eigen3_VERSION}" VERSION_LESS "3.3.7")
+    set (EIGEN3_FOUND 0)
+    find_package(Eigen3 3.3.7 QUIET) # (3.3.7 or greater)
+  endif()
+endif()
+
 if((EIGEN3_FOUND OR Eigen3_FOUND) AND NOT TARGET CGAL::Eigen3_support)
   if(NOT TARGET Threads::Threads)
     find_package(Threads REQUIRED)

Installation/include/CGAL/config.h

@@ -462,10 +462,6 @@ namespace CGAL {
 } // end of the temporary compatibility with CGAL-4.14
 #endif // CGAL_NO_DEPRECATED_CODE
 
-#if __has_include(<version>)
-#  include <version>
-#endif
-
 namespace CGAL {
 
 // Typedef for the type of nullptr.

Installation/include/CGAL/use.h

@@ -14,15 +14,15 @@
 
 namespace CGAL { namespace internal {
 
-template < typename T > inline
+template <typename ...T> inline
-void use(const T&) {}
+void use(T&&...) {}
 
 template<typename> void use_type() {}
 
 } }
 
 /// CGAL_USE() is a macro which aims at removing "variable is unused" warnings.
-#define CGAL_USE(x) ::CGAL::internal::use(x)
+#define CGAL_USE(...) ::CGAL::internal::use(__VA_ARGS__)
 
 /// CGAL_USE_TYPE() is a macro which aims at removing "typedef locally
 /// defined but not used" warnings.

Installation/include/CGAL/version.h

@@ -17,10 +17,10 @@
 #define CGAL_VERSION_H
 
 #ifndef SWIG
-#define CGAL_VERSION 6.1
+#define CGAL_VERSION 6.1.1
 #define CGAL_GIT_HASH abcdef
 #endif
-#define CGAL_VERSION_NR 1060100930
+#define CGAL_VERSION_NR 1060111000
 #define CGAL_SVN_REVISION 99999
 #define CGAL_RELEASE_DATE 20250901
 

Installation/lib/cmake/CGAL/CGALConfigVersion.cmake

@@ -1,8 +1,8 @@
 set(CGAL_MAJOR_VERSION 6)
 set(CGAL_MINOR_VERSION 1)
-set(CGAL_BUGFIX_VERSION 0)
+set(CGAL_BUGFIX_VERSION 1)
 include(${CMAKE_CURRENT_LIST_DIR}/CGALConfigBuildVersion.cmake)
-set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "6.1")
+set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "6.1.1")
 set(CGAL_VERSION_PUBLIC_RELEASE_NAME "CGAL-${CGAL_VERSION_PUBLIC_RELEASE_VERSION}")
 
 if (CGAL_BUGFIX_VERSION AND CGAL_BUGFIX_VERSION GREATER 0)

Interval_skip_list/include/CGAL/Interval_skip_list.h

@@ -177,7 +177,7 @@ class Interval_for_container : public Interval_
 
 
     // remove markers for Interval I starting at left, the left endpoint
-    // of I, and and stopping at the right endpoint of I.
+    // of I, and stopping at the right endpoint of I.
     Interval_handle removeMarkers(IntervalSLnode<Interval>* left,
                                   const Interval& I);
 

Isosurfacing_3/benchmark/Isosurfacing_3/CMakeLists.txt

@@ -6,7 +6,7 @@ project( Isosurfacing_3_benchmark )
 
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 find_package(TBB)

Isosurfacing_3/examples/Isosurfacing_3/CMakeLists.txt

@@ -6,7 +6,7 @@ project( Isosurfacing_3_Examples )
 
 find_package(CGAL REQUIRED COMPONENTS ImageIO)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 find_package(TBB QUIET)

Isosurfacing_3/test/Isosurfacing_3/CMakeLists.txt

@@ -4,7 +4,7 @@ project(Isosurfacing_3_Tests)
 
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 find_package(TBB QUIET)

Jet_fitting_3/examples/Jet_fitting_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Jet_fitting_3_Examples)
 find_package(CGAL REQUIRED)
 
 # use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
 
   # Link with Boost.ProgramOptions (optional)

Jet_fitting_3/test/Jet_fitting_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Jet_fitting_3_Tests)
 find_package(CGAL REQUIRED)
 
 # use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("blind_1pt.cpp")
   target_link_libraries(blind_1pt PRIVATE CGAL::Eigen3_support)

Kernel_23/include/CGAL/Kernel/hash_functions.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2019
+// Copyright (c) 2019,2025
 // GeometryFactory (France)
 //
 // This file is part of CGAL (www.cgal.org)
@@ -9,6 +9,8 @@
 //
 //
 // Author(s)     : Simon Giraudot
+//
+// Test file: test/Kernel_23/test_hash_functions.cpp
 
 #ifndef CGAL_KERNEL_HASH_FUNCTIONS_H
 #define CGAL_KERNEL_HASH_FUNCTIONS_H
@@ -16,18 +18,73 @@
 #include <boost/functional/hash.hpp>
 #include <type_traits>
 
+#include <CGAL/representation_tags.h>
+#include <CGAL/Aff_transformation_2.h>
+#include <CGAL/Aff_transformation_3.h>
+#include <CGAL/Bbox_2.h>
+#include <CGAL/Bbox_3.h>
+#include <CGAL/Circle_2.h>
+#include <CGAL/Iso_rectangle_2.h>
+#include <CGAL/Iso_cuboid_3.h>
+#include <CGAL/Point_2.h>
+#include <CGAL/Point_3.h>
+#include <CGAL/Segment_2.h>
+#include <CGAL/Segment_3.h>
+#include <CGAL/Sphere_3.h>
+#include <CGAL/Vector_2.h>
+#include <CGAL/Vector_3.h>
+#include <CGAL/Weighted_point_2.h>
+#include <CGAL/Weighted_point_3.h>
+
+
 namespace CGAL
 {
 
 using boost::hash_value;
 
+template <typename K, typename = void>
+inline constexpr bool has_rep_tag_v = false;
+
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline constexpr bool has_rep_tag_v<K, std::void_t<typename K::Rep_tag>> = true;
+
+template <typename K, typename = void>
+struct Rep_tag {
+  using type = void;
+};
+
+template <typename K>
+struct Rep_tag<K, std::enable_if_t<has_rep_tag_v<K>>> {
+  using type = typename K::Rep_tag;
+};
+
+template <typename K>
+using Rep_tag_t = typename Rep_tag<K>::type;
+
+template <typename K>
+inline constexpr bool is_Cartesian_v = std::is_same<Rep_tag_t<K>, Cartesian_tag>::value;
+
+template <typename K, typename = void>
+struct Is_kernel_hashable : public std::false_type {};
+
+template <typename K>
+struct Is_kernel_hashable<K, std::void_t<decltype(hash_value(std::declval<typename K::FT>()))>> : public std::true_type {};
+
+template <typename K>
+inline constexpr bool is_kernel_hashable_v = Is_kernel_hashable<K>::value;
+
+template <typename K, typename T>
+using enable_if_Cartesian_and_hashable_t =
+    std::enable_if_t<is_Cartesian_v<K> && is_kernel_hashable_v<K>, T>;
+
+template <typename K>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Aff_transformation_2<K>& transform)
 {
   std::size_t result = hash_value(transform.cartesian(0,0));
   for(int i=0; i < 3; ++i)
-    for(int j = 0; j < 3; ++j)
+    for(int j=0; j < 3; ++j)
+      // Skip (0,0) as it was already used to initialize the hash
       if (!(i == 0 && j == 0))
         boost::hash_combine(result, hash_value(transform.cartesian(i,j)));
   return result;
@@ -44,7 +101,7 @@ hash_value (const Bbox_2& bbox)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Circle_2<K>& circle)
 {
   std::size_t result = hash_value(circle.center());
@@ -54,7 +111,7 @@ hash_value (const Circle_2<K>& circle)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Iso_rectangle_2<K>& iso_rectangle)
 {
   std::size_t result = hash_value((iso_rectangle.min)());
@@ -63,7 +120,7 @@ hash_value (const Iso_rectangle_2<K>& iso_rectangle)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Point_2<K>& point)
 {
   std::size_t result = hash_value(point.x());
@@ -72,7 +129,7 @@ hash_value (const Point_2<K>& point)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Segment_2<K>& segment)
 {
   std::size_t result = hash_value(segment.source());
@@ -81,7 +138,7 @@ hash_value (const Segment_2<K>& segment)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Vector_2<K>& vector)
 {
   std::size_t result = hash_value(vector.x());
@@ -90,7 +147,7 @@ hash_value (const Vector_2<K>& vector)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Weighted_point_2<K>& weighed_point)
 {
   std::size_t result = hash_value(weighed_point.point());
@@ -99,13 +156,12 @@ hash_value (const Weighted_point_2<K>& weighed_point)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Aff_transformation_3<K>& transform)
 {
   std::size_t result = hash_value(transform.cartesian(0,0));
   for(int i = 0; i < 3; ++i)
-    for(int j = 0; j < 4; ++j)
+    for(int j = (i == 0 ? 1 : 0); j < 4; ++j)
-      if (!(i == 0 && j == 0))
       boost::hash_combine(result, hash_value(transform.cartesian(i,j)));
   return result;
 }
@@ -123,7 +179,7 @@ hash_value (const Bbox_3& bbox)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Iso_cuboid_3<K>& iso_cuboid)
 {
   std::size_t result = hash_value((iso_cuboid.min)());
@@ -132,7 +188,7 @@ hash_value (const Iso_cuboid_3<K>& iso_cuboid)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Point_3<K>& point)
 {
   std::size_t result = hash_value(point.x());
@@ -142,7 +198,7 @@ hash_value (const Point_3<K>& point)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Segment_3<K>& segment)
 {
   std::size_t result = hash_value(segment.source());
@@ -151,7 +207,7 @@ hash_value (const Segment_3<K>& segment)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Sphere_3<K>& sphere)
 {
   std::size_t result = hash_value(sphere.center());
@@ -161,7 +217,7 @@ hash_value (const Sphere_3<K>& sphere)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Vector_3<K>& vector)
 {
   std::size_t result = hash_value(vector.x());
@@ -171,7 +227,7 @@ hash_value (const Vector_3<K>& vector)
 }
 
 template <typename K>
-inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
+inline enable_if_Cartesian_and_hashable_t<K, std::size_t>
 hash_value (const Weighted_point_3<K>& weighed_point)
 {
   std::size_t result = hash_value(weighed_point.point());
@@ -179,93 +235,46 @@ hash_value (const Weighted_point_3<K>& weighed_point)
   return result;
 }
 
+struct Forward_to_hash_value {
+  template <typename T>
+  std::size_t operator()(T&& t) const {
+    using boost::hash_value;
+    return hash_value(std::forward<T>(t));
+  }
+};
+
+template <typename K, typename = void>
+struct Maybe_forward_to_hash_value {
+  Maybe_forward_to_hash_value() = delete;
+  Maybe_forward_to_hash_value(const Maybe_forward_to_hash_value&) = delete;
+};
+
+template <typename K>
+struct Maybe_forward_to_hash_value<K, std::enable_if_t<is_kernel_hashable_v<K>>>
+    : public Forward_to_hash_value {};
+
+
 } //namespace CGAL
 
 // overloads of std::hash used for using std::unordered_[set/map] on CGAL Kernel objects
-namespace std
+namespace std {
-{
+template <typename K> struct hash<CGAL::Aff_transformation_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Circle_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Iso_rectangle_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Point_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Segment_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Vector_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Weighted_point_2<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <> struct hash<CGAL::Bbox_2> : CGAL::Forward_to_hash_value {};
+template <typename K> struct hash<CGAL::Aff_transformation_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Iso_cuboid_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Point_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Segment_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Sphere_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Vector_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <typename K> struct hash<CGAL::Weighted_point_3<K>> : CGAL::Maybe_forward_to_hash_value<K> {};
+template <> struct hash<CGAL::Bbox_3> : CGAL::Forward_to_hash_value {};
+} // namespace std
 
-template <typename K> struct hash<CGAL::Aff_transformation_2<K> > {
-  std::size_t operator() (const CGAL::Aff_transformation_2<K>& transform) const   {
-    return CGAL::hash_value<K> (transform);
-  }
-};
-template <> struct hash<CGAL::Bbox_2> {
-  std::size_t operator() (const CGAL::Bbox_2& bbox) const   {
-    return CGAL::hash_value (bbox);
-  }
-};
-template <typename K> struct hash<CGAL::Circle_2<K> > {
-  std::size_t operator() (const CGAL::Circle_2<K>& circle) const   {
-    return CGAL::hash_value<K> (circle);
-  }
-};
-template <typename K> struct hash<CGAL::Iso_rectangle_2<K> > {
-  std::size_t operator() (const CGAL::Iso_rectangle_2<K>& iso_rectangle) const   {
-    return CGAL::hash_value<K> (iso_rectangle);
-  }
-};
-template <typename K> struct hash<CGAL::Point_2<K> > {
-  std::size_t operator() (const CGAL::Point_2<K>& point) const   {
-    return CGAL::hash_value<K> (point);
-  }
-};
-template <typename K> struct hash<CGAL::Segment_2<K> > {
-  std::size_t operator() (const CGAL::Segment_2<K>& segment) const   {
-    return CGAL::hash_value<K> (segment);
-  }
-};
-template <typename K> struct hash<CGAL::Vector_2<K> > {
-  std::size_t operator() (const CGAL::Vector_2<K>& vector) const   {
-    return CGAL::hash_value<K> (vector);
-  }
-};
-template <typename K> struct hash<CGAL::Weighted_point_2<K> > {
-  std::size_t operator() (const CGAL::Weighted_point_2<K>& weighted_point) const   {
-    return CGAL::hash_value<K> (weighted_point);
-  }
-};
-template <typename K> struct hash<CGAL::Aff_transformation_3<K> > {
-  std::size_t operator() (const CGAL::Aff_transformation_3<K>& transform) const   {
-    return CGAL::hash_value<K> (transform);
-  }
-};
-template <> struct hash<CGAL::Bbox_3> {
-  std::size_t operator() (const CGAL::Bbox_3& bbox) const   {
-    return CGAL::hash_value (bbox);
-  }
-};
-template <typename K> struct hash<CGAL::Iso_cuboid_3<K> > {
-  std::size_t operator() (const CGAL::Iso_cuboid_3<K>& iso_cuboid) const   {
-    return CGAL::hash_value<K> (iso_cuboid);
-  }
-};
-template <typename K> struct hash<CGAL::Point_3<K> > {
-  std::size_t operator() (const CGAL::Point_3<K>& point) const   {
-    return CGAL::hash_value<K> (point);
-  }
-};
-template <typename K> struct hash<CGAL::Segment_3<K> > {
-  std::size_t operator() (const CGAL::Segment_3<K>& segment) const   {
-    return CGAL::hash_value<K> (segment);
-  }
-};
-template <typename K> struct hash<CGAL::Sphere_3<K> > {
-  std::size_t operator() (const CGAL::Sphere_3<K>& sphere) const   {
-    return CGAL::hash_value<K> (sphere);
-  }
-};
-template <typename K> struct hash<CGAL::Vector_3<K> > {
-  std::size_t operator() (const CGAL::Vector_3<K>& vector) const   {
-    return CGAL::hash_value<K> (vector);
-  }
-};
-template <typename K> struct hash<CGAL::Weighted_point_3<K> > {
-  std::size_t operator() (const CGAL::Weighted_point_3<K>& weighted_point) const   {
-    return CGAL::hash_value<K> (weighted_point);
-  }
-};
-
-}
 
 #endif  // CGAL_KERNEL_HASH_FUNCTIONS_H

Kernel_23/test/Kernel_23/test_hash_functions.cpp

@@ -1,13 +1,18 @@
+// test partially generated by Github Copilot
+
 #include <unordered_set>
 
 #include <CGAL/Simple_cartesian.h>
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
-
 #include <CGAL/Bbox_2.h>
+#include <CGAL/Bbox_3.h>
 
 typedef CGAL::Simple_cartesian<double> SC;
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Epick;
 
+static_assert(CGAL::is_kernel_hashable_v<SC>);
+static_assert(CGAL::is_kernel_hashable_v<Epick>);
+
 template <typename Object>
 void test (const Object& obj)
 {
@@ -67,5 +72,3 @@ int main()
 
   return 0;
 }
-
-

Kinetic_space_partition/examples/Kinetic_space_partition/CMakeLists.txt

@@ -8,7 +8,7 @@ project(Kinetic_space_partition_Examples)
 find_package(CGAL REQUIRED)
 include(CGAL_CreateSingleSourceCGALProgram)
 
-find_package(Eigen3 3.1.0 REQUIRED)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 if(TARGET CGAL::Eigen3_support)

Kinetic_space_partition/test/Kinetic_space_partition/CMakeLists.txt

@@ -8,7 +8,7 @@ project(Kinetic_space_partition_Tests)
 find_package(CGAL REQUIRED)
 include(CGAL_CreateSingleSourceCGALProgram)
 
-find_package(Eigen3 3.1.0 REQUIRED)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 set(targets kinetic_3d_test_all issue_8624)

Kinetic_surface_reconstruction/examples/Kinetic_surface_reconstruction/CMakeLists.txt

@@ -8,7 +8,7 @@ project(Kinetic_surface_reconstruction_Examples)
 find_package(CGAL REQUIRED)
 include(CGAL_CreateSingleSourceCGALProgram)
 
-find_package(Eigen3 3.1.0 REQUIRED)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 if(TARGET CGAL::Eigen3_support)

Kinetic_surface_reconstruction/test/Kinetic_surface_reconstruction/CMakeLists.txt

@@ -8,7 +8,7 @@ project(Kinetic_surface_reconstruction_Tests)
 find_package(CGAL REQUIRED)
 include(CGAL_CreateSingleSourceCGALProgram)
 
-find_package(Eigen3 3.1.0 REQUIRED)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 
 if(TARGET CGAL::Eigen3_support)

Lab/demo/Lab/CMakeLists.txt

@@ -51,12 +51,14 @@ if(Qt6_FOUND)
   add_compile_definitions(QT_NO_KEYWORDS)
 endif(Qt6_FOUND)
 
-find_package(Eigen3 3.2.0 QUIET) #(requires 3.2.0 or greater)
+find_package(Eigen3 QUIET)
+include(CGAL_Eigen3_support)
+
 set_package_properties(
   Eigen3 PROPERTIES
   DESCRIPTION "A library for linear algebra."
   PURPOSE "Required for most plugins (Meshing, Mesh and Point Set Processing, etc.).")
-include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message(STATUS "NOTICE: Eigen was not found.")
 endif()

Lab/demo/Lab/MainWindow.cpp

@@ -1795,8 +1795,8 @@ bool MainWindow::loadScript(QFileInfo info)
   QString program;
   QString filename = info.absoluteFilePath();
   QFile script_file(filename);
-  script_file.open(QIODevice::ReadOnly);
+  bool success = script_file.open(QIODevice::ReadOnly);
-  if(!script_file.isReadable()) {
+  if((! success) || (!script_file.isReadable())) {
     throw std::ios_base::failure(script_file.errorString().toStdString());
   }
   program = script_file.readAll();
@@ -2747,9 +2747,9 @@ void MainWindow::exportStatistics()
   if(filename.isEmpty())
     return;
   QFile output(filename);
-  output.open(QIODevice::WriteOnly | QIODevice::Text);
+  bool success = output.open(QIODevice::WriteOnly | QIODevice::Text);
 
-  if(!output.isOpen()){
+  if((! success) || (!output.isOpen())){
     qDebug() << "- Error, unable to open" << "outputFilename" << "for output";
   }
   QTextStream outStream(&output);

Lab/demo/Lab/Plugins/Camera_position/Camera_positions_list.cpp

@@ -93,7 +93,7 @@ bool Camera_positions_list::save(QString filename) {
   if(m_model->rowCount() <1)
     return false;
   QFile file(filename);
-  file.open(QIODevice::WriteOnly);
+  if(file.open(QIODevice::WriteOnly)){
     QTextStream out(&file);
     for(int i = 0; i < m_model->rowCount(); ++i)
     {
@@ -105,6 +105,8 @@ bool Camera_positions_list::save(QString filename) {
     }
     file.close();
     return true;
+  }
+  return false;
 }
 
 void Camera_positions_list::on_saveButton_pressed()
@@ -129,8 +131,10 @@ void Camera_positions_list::on_openButton_pressed()
 
 void Camera_positions_list::load(QString filename) {
   QFile file(filename);
+
+  if(file.open(QIODevice::ReadOnly)){
     std::clog << "Loading camera positions " << qPrintable(filename) << std::endl;
-  file.open(QIODevice::ReadOnly);
+
     QTextStream input(&file);
     while(!input.atEnd()) {
       QString text = input.readLine(1000);
@@ -143,6 +147,9 @@ void Camera_positions_list::load(QString filename) {
                 Three::activeViewer()->dumpFrame(frame));
       }
     }
+  }else {
+    std::clog << "Loading camera positions " << qPrintable(filename) << " failed" << std::endl;
+  }
 }
 
 void Camera_positions_list::on_frontButton_pressed()

Lab/demo/Lab/Plugins/Mesh_3/CMakeLists.txt

@@ -77,8 +77,9 @@ target_link_libraries(
 CGAL_Lab_target_use_c3t3_type(mesh_3_optimization_plugin)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   target_link_libraries(mesh_3_optimization_plugin PRIVATE CGAL::Eigen3_support)
 else()

Lab/demo/Lab/Plugins/PMP/CMakeLists.txt

@@ -28,7 +28,6 @@ target_link_libraries(extrude_plugin PRIVATE scene_surface_mesh_item
                                              scene_selection_item)
 
 if(TARGET CGAL::Eigen3_support)
-  if("${Eigen3_VERSION}" VERSION_GREATER "3.1.90")
   qt6_wrap_ui( acvd_remeshingUI_FILES ACVD_remeshing_dialog.ui)
   cgal_lab_plugin(acvd_remeshing_plugin ACVD_remeshing_plugin ${acvd_remeshingUI_FILES} KEYWORDS PMP)
   target_link_libraries(acvd_remeshing_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_polygon_soup_item CGAL::Eigen3_support)
@@ -81,9 +80,6 @@ if(TARGET CGAL::Eigen3_support)
       "compilation of  smoothing_plugin"
       PROPERTIES RESOURCE_LOCK Selection_test_resources)
   endif()
-  else()
-    message(STATUS "NOTICE: The hole filling and fairing plugins require Eigen 3.2 (or higher) and will not be available.")
-  endif()
 else()
   message(STATUS "NOTICE: The hole filling and fairing plugins require Eigen 3.2 (or higher) and will not be available.")
 endif()

Lab/demo/Lab/Plugins/Surface_mesh_deformation/CMakeLists.txt

@@ -1,6 +1,6 @@
 include(CGALlab_macros)
 
-if(TARGET CGAL::Eigen3_support AND "${Eigen3_VERSION}" VERSION_GREATER "3.1.90")
+if(TARGET CGAL::Eigen3_support)
 
   qt6_wrap_ui(editionUI_FILES Deform_mesh.ui)
   add_item(scene_edit_item

Lab/demo/Lab/Plugins/Tetrahedral_remeshing/CMakeLists.txt

@@ -14,7 +14,7 @@ cgal_lab_plugin(
 target_link_libraries(tetrahedral_remeshing_plugin PRIVATE scene_c3t3_item
                                                            ${OPENGL_gl_LIBRARY})
 CGAL_Lab_target_use_c3t3_type(tetrahedral_remeshing_plugin)
-find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
 if(TARGET CGAL::Eigen3_support)
   target_link_libraries(tetrahedral_remeshing_plugin PRIVATE CGAL::Eigen3_support)

Maintenance/public_release/scripts/precompiled_demos_zips

@@ -78,6 +78,9 @@ pushd Triangulation_on_sphere_2_Demo_with_dlls; zip -r ../triangulation_on_spher
 pushd Lab_Demo_with_dlls; zip -r ../CGALlab.zip *; popd
 pushd Arrangement_on_surface_2_earth_Demo_with_dlls; zip -r ../arrangements_2_earth.zip *; popd
 
+# CGAL-6.1
+pushd Triangulation_on_hyperbolic_surface_2_Demo_with_dlls; zip -r ../triangulation_on_hyperbolic_surface_2.zip *; popd
+
 # check
 echo CHECK now. The following lines should be empty.
 for f in *zip; do unzip -qql $f; done | awk '{print $4}' >| done

Mesh_3/examples/Mesh_3/CMakeLists.txt

@@ -19,8 +19,9 @@ if(CGAL_ACTIVATE_CONCURRENT_MESH_3 OR "$ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3}")
 endif()
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: All examples require the Eigen3 library, and will not be compiled.")
   return()

Mesh_3/test/Mesh_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project( Mesh_3_Tests )
 find_package(CGAL REQUIRED COMPONENTS ImageIO)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if (NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

NewKernel_d/test/NewKernel_d/CMakeLists.txt

@@ -14,6 +14,7 @@ find_package(CGAL REQUIRED)
 
 find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   file(
     GLOB cppfiles

Number_types/include/CGAL/FPU.h

@@ -476,6 +476,9 @@ typedef int FPU_CW_t;
 #define CGAL_FE_DOWNWARD     FE_DOWNWARD
 #endif
 
+#define CGAL_FE_ROUNDING_MASK ((CGAL_FE_TONEAREST | CGAL_FE_TOWARDZERO | CGAL_FE_UPWARD | CGAL_FE_DOWNWARD) \
+  & ~(CGAL_FE_TONEAREST & CGAL_FE_TOWARDZERO & CGAL_FE_UPWARD & CGAL_FE_DOWNWARD)) // mask for rounding bits
+
 // User interface:
 
 inline
@@ -484,7 +487,8 @@ FPU_get_cw (void)
 {
 #ifdef CGAL_ALWAYS_ROUND_TO_NEAREST
     CGAL_assertion_code(FPU_CW_t cw; CGAL_IA_GETFPCW(cw);)
-    CGAL_assertion(cw == CGAL_FE_TONEAREST);
+    CGAL_assertion_code(FPU_CW_t mask = CGAL_FE_ROUNDING_MASK;)
+    CGAL_assertion((cw & mask) == (CGAL_FE_TONEAREST & mask));
     return CGAL_FE_TONEAREST;
 #else
     FPU_CW_t cw;

Number_types/include/CGAL/NT_wrapper.h

@@ -11,6 +11,11 @@
 #ifndef CGAL_NT_WRAPPER_H
 #define CGAL_NT_WRAPPER_H
 
+
+#include <CGAL/config.h>
+
+#if __cpp_lib_source_location
+
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 #include <CGAL/Coercion_traits.h>
@@ -184,4 +189,6 @@ struct Wrapped_epeck
 
 } // namespace CGAL
 
+#endif // __cpp_lib_source_location
+
 #endif // CGAL_NT_WRAPPER_H

Number_types/test/Number_types/CMakeLists.txt

@@ -80,8 +80,10 @@ if(NOT CGAL_DISABLE_GMP)
   create_single_source_cgal_program( "Gmpfi.cpp" )
   create_single_source_cgal_program( "Gmpfr_bug.cpp" )
   create_single_source_cgal_program( "test_eigen.cpp" )
-  find_package(Eigen3 3.2.0 QUIET) #(requires 3.2.0 or greater)
+
+  find_package(Eigen3 QUIET)
   include(CGAL_Eigen3_support)
+
   if (TARGET CGAL::Eigen3_support)
     target_link_libraries(test_eigen PRIVATE CGAL::Eigen3_support)
   endif()

Optimal_bounding_box/benchmark/Optimal_bounding_box/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Optimal_bounding_box_Benchmark)
 # CGAL and its components
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Optimal_bounding_box/examples/Optimal_bounding_box/CMakeLists.txt

@@ -6,8 +6,9 @@ project(Optimal_bounding_box_Examples)
 
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Optimal_bounding_box/test/Optimal_bounding_box/CMakeLists.txt

@@ -6,8 +6,9 @@ project(Optimal_bounding_box_Tests)
 
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Optimal_transportation_reconstruction_2/include/CGAL/OTR_2/Reconstruction_face_base_2.h

@@ -17,6 +17,8 @@
 
 #include <CGAL/OTR_2/Cost.h>
 #include <CGAL/Triangulation_face_base_2.h>
+#include <CGAL/Has_timestamp.h>
+#include <CGAL/Time_stamper.h>
 
 #include <vector>
 
@@ -62,6 +64,8 @@ private:
 
   FT m_relevance[3];
 
+  std::size_t time_stamp_ = std::size_t(-2);
+
 public:
   Reconstruction_face_base_2()
   {
@@ -190,6 +194,18 @@ public:
     for (int i = 0; i < 3; ++i)
       clean_samples(i);
   }
+
+  /// For the determinism of Compact_container iterators
+  ///@{
+  typedef Tag_true Has_timestamp;
+
+  std::size_t time_stamp() const {
+    return time_stamp_;
+  }
+  void set_time_stamp(const std::size_t& ts) {
+    time_stamp_ = ts;
+  }
+  ///@}
 };
 
 //---------------STRUCT LESS FACE_HANDLE---------------------

Optimal_transportation_reconstruction_2/include/CGAL/OTR_2/Reconstruction_vertex_base_2.h

@@ -16,6 +16,8 @@
 
 
 #include <CGAL/Triangulation_vertex_base_2.h>
+#include <CGAL/Has_timestamp.h>
+#include <CGAL/Time_stamper.h>
 #include <CGAL/OTR_2/Sample.h>
 
 namespace CGAL {
@@ -53,6 +55,7 @@ private:
   int       m_sample;
   Point     m_relocated;
   FT        m_relevance;
+  std::size_t time_stamp_ = std::size_t(-2);
 
 
 public:
@@ -110,6 +113,18 @@ public:
   Point& relocated() { return m_relocated; }
 
   bool  has_sample_assigned() const { return sample() != -1; }
+
+  /// For the determinism of Compact_container iterators
+  ///@{
+  typedef Tag_true Has_timestamp;
+
+  std::size_t time_stamp() const {
+    return time_stamp_;
+  }
+  void set_time_stamp(const std::size_t& ts) {
+    time_stamp_ = ts;
+  }
+  ///@}
 };
 //---------------STRUCT LESS VERTEX_HANDLE---------------------
 template <class T>

Orthtree/examples/Orthtree/CMakeLists.txt

@@ -18,8 +18,9 @@ create_single_source_cgal_program("quadtree_build_from_point_vector.cpp")
 create_single_source_cgal_program("octree_surface_mesh.cpp")
 create_single_source_cgal_program("quadtree_build_manually.cpp")
 
-find_package(Eigen3 3.1.91 QUIET) #(requires 3.1.91 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if (TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("orthtree_build.cpp")
   target_link_libraries(orthtree_build PRIVATE CGAL::Eigen3_support)

Periodic_3_mesh_3/examples/Periodic_3_mesh_3/CMakeLists.txt

@@ -8,8 +8,9 @@ project(Periodic_3_mesh_3_Examples)
 find_package(CGAL REQUIRED)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Periodic_3_mesh_3/test/Periodic_3_mesh_3/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Periodic_3_mesh_3_Tests)
 find_package(CGAL REQUIRED COMPONENTS ImageIO)
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: This project requires the Eigen library, and will not be compiled.")
   return()

Point_set_3/examples/Point_set_3/CMakeLists.txt

@@ -13,8 +13,9 @@ create_single_source_cgal_program("point_set_read_xyz.cpp")
 create_single_source_cgal_program("point_set_advanced.cpp")
 create_single_source_cgal_program("point_set_read_ply.cpp")
 
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("point_set_algo.cpp")
   target_link_libraries(point_set_algo PRIVATE CGAL::Eigen3_support)

Point_set_processing_3/examples/Point_set_processing_3/CMakeLists.txt

@@ -70,8 +70,9 @@ else()
 endif()
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
 
   # Executables that require Eigen

Point_set_processing_3/test/Point_set_processing_3/CMakeLists.txt

@@ -48,8 +48,9 @@ else()
 endif()
 
 # Use Eigen
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   # Executables that require Eigen
   create_single_source_cgal_program( "normal_estimation_test.cpp" )

Poisson_surface_reconstruction_3/examples/Poisson_surface_reconstruction_3/CMakeLists.txt

@@ -21,9 +21,10 @@ endif()
 # Activate Parallelism in Mesh_3
 option(CGAL_ACTIVATE_CONCURRENT_MESH_3 "Activate parallelism in Mesh_3" OFF)
 
-# Find Eigen3 (requires 3.1.0 or greater)
+# Find Eigen3
-find_package(Eigen3 3.1.0 QUIET)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   # Executables that require Eigen 3
   create_single_source_cgal_program("poisson_reconstruction_example.cpp")

Poisson_surface_reconstruction_3/test/Poisson_surface_reconstruction_3/CMakeLists.txt

@@ -20,10 +20,10 @@ if(MSVC)
   message(STATUS "USING RELEASE EXEFLAGS = '${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}'")
 endif()
 
-find_package(Eigen3 3.1.0 QUIET) #(requires 3.1.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
-  # Executables that require Eigen 3.1
   if(TARGET CGAL::TBB_support)
     create_single_source_cgal_program("poisson_reconstruction_test_surface_mesher.cpp")
     target_link_libraries(poisson_reconstruction_test_surface_mesher PRIVATE CGAL::Eigen3_support CGAL::TBB_support)

Polygon_mesh_processing/benchmark/Polygon_mesh_processing/CMakeLists.txt

@@ -7,8 +7,9 @@ project(Polygon_mesh_processing)
 # CGAL and its components
 find_package(CGAL REQUIRED)
 
-find_package(Eigen3 3.2.0 QUIET) #(requires 3.2.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(NOT TARGET CGAL::Eigen3_support)
   message("NOTICE: Benchmarks require Eigen 3.2 (or greater), and will not be compiled")
   return()

Polygon_mesh_processing/examples/Polygon_mesh_processing/CMakeLists.txt

@@ -60,8 +60,9 @@ create_single_source_cgal_program("triangle_mesh_autorefinement.cpp")
 create_single_source_cgal_program("soup_autorefinement.cpp")
 create_single_source_cgal_program("snap_polygon_soup.cpp")
 
-find_package(Eigen3 3.2.0 QUIET) #(requires 3.2.0 or greater)
+find_package(Eigen3 QUIET)
 include(CGAL_Eigen3_support)
+
 if(TARGET CGAL::Eigen3_support)
   create_single_source_cgal_program("acvd_remeshing_example.cpp")
   target_link_libraries(acvd_remeshing_example PUBLIC CGAL::Eigen3_support)

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/autorefinement.h

@@ -475,8 +475,8 @@ bool collect_intersections(const std::array<typename K::Point_3, 3>& t1,
 
 //  #warning TODO get rid of sort and unique calls
   // because we don't handle intersection type and can have edge-edge edge-vertex duplicates
-  std::sort(inter_pts.begin(), inter_pts.end(), [](auto p, auto q){return std::get<0>(p)<std::get<0>(q);});
+  std::sort(inter_pts.begin(), inter_pts.end(), [](const auto& p, const auto& q){return std::get<0>(p)<std::get<0>(q);});
-  auto last = std::unique(inter_pts.begin(), inter_pts.end(), [](auto p, auto q){return std::get<0>(p)==std::get<0>(q);});
+  auto last = std::unique(inter_pts.begin(), inter_pts.end(), [](const auto& p, const auto& q){return std::get<0>(p)==std::get<0>(q);});
   inter_pts.erase(last, inter_pts.end());
 
 #ifdef CGAL_AUTOREF_DEBUG_DEPTH