Merge branch 'master' of https://github.com/CGAL/cgal into Mesh-3-edge-distance-criterium-aclement

.github/workflows/build_doc.yml

@@ -60,7 +60,7 @@ jobs:
               content: 'rocket'
             })
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         name: "checkout branch"
         if: steps.get_round.outputs.result != 'stop'
         with:

.github/workflows/checks.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: |
         .github/install.sh

.github/workflows/cmake-all.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: sudo apt-get install -y libboost-dev libboost-program-options-dev libmpfr-dev libeigen3-dev
     - name: configure all
@@ -25,7 +25,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: sudo bash -e .github/install.sh
     - name: configure all

.github/workflows/delete_doc.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: delete directory
       run: |
          set -x

.github/workflows/demo.yml

@@ -9,7 +9,7 @@ jobs:
   batch_1:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: .github/install.sh
     - name: run1
@@ -17,7 +17,7 @@ jobs:
   batch_2:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: .github/install.sh
     - name: run2
@@ -25,7 +25,7 @@ jobs:
   batch_3:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: .github/install.sh
     - name: run3
@@ -33,7 +33,7 @@ jobs:
   batch_4:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: .github/install.sh
     - name: run4

.github/workflows/list_workflow_last_run.yml

@@ -12,7 +12,7 @@
         messages: ${{ steps.cat_output.outputs.message }}
       steps:
         - name: checkout
-          uses: actions/checkout@v3
+          uses: actions/checkout@v4
         - name: run script
           run: |
             chmod +x ./Scripts/developer_scripts/list_cgal_workflows_last_run.sh

.github/workflows/reuse.yml

@@ -10,7 +10,7 @@ jobs:
   reuse:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: REUSE version
       uses: fsfe/reuse-action@v2
       with:

AABB_tree/doc/AABB_tree/Concepts/AABBGeomTraits.h

@@ -11,7 +11,9 @@ and the primitives stored in the AABB tree.
 
 \cgalRefines{SearchGeomTraits_3}
 
-\cgalHasModel All models of the concept `Kernel`
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of the concept `Kernel`}
+\cgalHasModelsEnd
 
 \sa `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
 \sa `CGAL::AABB_tree<AABBTraits>`

AABB_tree/doc/AABB_tree/Concepts/AABBPrimitive.h

@@ -12,11 +12,13 @@ The concept `AABBPrimitive` describes the requirements for the primitives stored
 
 The `Primitive` type can be, e.g., a wrapper around a `Handle`. Assume for instance that the input objects are the triangle faces of a mesh stored as a `CGAL::Polyhedron_3`. The `Datum` would be a `Triangle_3` and the `Id` would be a polyhedron `Face_handle`. Method `datum()` can return either a `Triangle_3` constructed on the fly from the face handle or a `Triangle_3` stored internally. This provides a way for the user to trade memory for efficiency.
 
-\cgalHasModel `CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,Tag_false,CacheDatum>`
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::AABB_segment_primitive<Iterator,CacheDatum>`
+\cgalHasModels{CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,Tag_false,CacheDatum>}
-\cgalHasModel `CGAL::AABB_triangle_primitive<Iterator,CacheDatum>`
+\cgalHasModels{CGAL::AABB_segment_primitive<Iterator,CacheDatum>}
-\cgalHasModel `CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_false,CacheDatum>`
+\cgalHasModels{CGAL::AABB_triangle_primitive<Iterator,CacheDatum>}
-\cgalHasModel `CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_false,CacheDatum>`
+\cgalHasModels{CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_false,CacheDatum>}
+\cgalHasModels{CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_false,CacheDatum>}
+\cgalHasModelsEnd
 */
 
 class AABBPrimitive {

AABB_tree/doc/AABB_tree/Concepts/AABBPrimitiveWithSharedData.h

@@ -21,9 +21,11 @@ The `Datum` would be a `Triangle_3` and the `Id` a `std::size_t`. The shared dat
 `std::vector<Triangle_3>`.
 The method `datum(const Shared_data&)` then returns a triangle from the vector.
 
-\cgalHasModel `CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,Tag_true,CacheDatum>`
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_true,CacheDatum>`
+\cgalHasModels{CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,Tag_true,CacheDatum>}
-\cgalHasModel `CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_true,CacheDatum>`
+\cgalHasModels{CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_true,CacheDatum>}
+\cgalHasModels{CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_true,CacheDatum>}
+\cgalHasModelsEnd
 */
 
 class AABBPrimitiveWithSharedData {

AABB_tree/doc/AABB_tree/Concepts/AABBRayIntersectionGeomTraits.h

@@ -9,7 +9,9 @@ define the Intersection_distance functor.
 
 \cgalRefines{AABBGeomTraits}
 
-\cgalHasModel All models of the concept `Kernel`
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of the concept `Kernel`}
+\cgalHasModelsEnd
 
 \sa `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
 \sa `CGAL::AABB_tree<AABBTraits>`

AABB_tree/doc/AABB_tree/Concepts/AABBRayIntersectionTraits.h

@@ -7,7 +7,9 @@ The concept `AABBRayIntersectionTraits` is a refinement of the concept
 `AABBTraits` it also requires function objects to calculate the
 distance of an intersection along a ray.
 
-\cgalHasModel `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>}
+\cgalHasModelsEnd
 
 \sa `CGAL::AABB_tree<AABBTraits>`
 \sa `AABBPrimitive`

AABB_tree/doc/AABB_tree/Concepts/AABBTraits.h

@@ -5,7 +5,9 @@
 
 The concept `AABBTraits` provides the geometric primitive types and methods for the class `CGAL::AABB_tree<AABBTraits>`.
 
-\cgalHasModel `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>}
+\cgalHasModelsEnd
 
 \cgalRefines{SearchGeomTraits_3}
 

AABB_tree/include/CGAL/AABB_face_graph_triangle_primitive.h

@@ -33,7 +33,7 @@ namespace CGAL {
  * while the AABB tree holding the primitive is in use.
  * The triangle type of the primitive (`Datum`) is `CGAL::Kernel_traits< boost::property_traits< VertexPointPMap >::%value_type >::%Kernel::Triangle_3`.
  *
- * \cgalModels `AABBPrimitiveWithSharedData`
+ * \cgalModels{AABBPrimitiveWithSharedData}
  *
  *\tparam FaceGraph is a model of the face graph concept.
  *\tparam VertexPointPMap  is a property map with `boost::graph_traits<FaceGraph>::%vertex_descriptor`

AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h

@@ -41,8 +41,10 @@ namespace CGAL {
  * of `VertexPointPMap` (using the `Kernel_traits` mechanism).
  * The segment type of the primitive (`Datum`) is `CGAL::Kernel_traits< boost::property_traits< VertexPointPMap >::%value_type >::%Kernel::Segment_3`.
  *
- * \cgalModels `AABBPrimitive` if `OneHalfedgeGraphPerTree` is `CGAL::Tag_false`,
+ * \cgalModelsBareBegin
- *    and `AABBPrimitiveWithSharedData` if `OneHalfedgeGraphPerTree` is `CGAL::Tag_true`.
+ * \cgalModelsBare{`AABBPrimitive` if `OneHalfedgeGraphPerTree` is `CGAL::Tag_false`}
+ * \cgalModelsBare{`AABBPrimitiveWithSharedData` if `OneHalfedgeGraphPerTree` is `CGAL::Tag_true`}
+ * \cgalModelsBareEnd
  *
  * \tparam HalfedgeGraph is a model of the halfedge graph concept.
  *   as key type and a \cgal Kernel `Point_3` as value type.

AABB_tree/include/CGAL/AABB_polyhedron_segment_primitive.h

@@ -42,7 +42,7 @@ namespace CGAL {
     /// AABB tree is built should not be deleted while the AABB tree
     /// is in use.
     ///
-    /// \cgalModels `AABBPrimitive`
+    /// \cgalModels{AABBPrimitive}
     /// \tparam GeomTraits must provide a \c %Point_3
     /// type, used as \c Point, and a \c %Segment_3 type, used as \c
     /// Datum and constructible from two arguments of type \c

AABB_tree/include/CGAL/AABB_polyhedron_triangle_primitive.h

@@ -35,7 +35,7 @@ namespace CGAL {
     /// the polyhedron from which the AABB tree is built should not be
     /// deleted while the AABB tree is in use.
     ///
-    /// \cgalModels `AABBPrimitive`
+    /// \cgalModels{AABBPrimitive}
     /// \tparam GeomTraits must provides a \c %Point_3
     /// type, used as \c Point, and a \c %Triangle_3 type, used as \c
     /// Datum and constructible from three arguments of type \c

AABB_tree/include/CGAL/AABB_primitive.h

@@ -53,8 +53,10 @@ public:
  * The two property maps which are template parameters of the class enable to get the datum and the reference point of
  * the primitive from the identifier. The last template parameter controls whether the primitive class holds a copy of the datum.
  *
- * \cgalModels `AABBPrimitive` if `ExternalPropertyMaps` is `CGAL::Tag_false`.
+ * \cgalModelsBareBegin
- * \cgalModels `AABBPrimitiveWithSharedData` if `ExternalPropertyMaps` is `CGAL::Tag_true`.
+ * \cgalModelsBare{`AABBPrimitive` if `ExternalPropertyMaps` is `CGAL::Tag_false`}
+ * \cgalModelsBare{`AABBPrimitiveWithSharedData` if `ExternalPropertyMaps` is `CGAL::Tag_true`}
+ * \cgalModelsBareEnd
  *
  * \tparam ObjectPropertyMap is a model of `ReadablePropertyMap` with `Id` as
  *           `key_type`. It must be a model of `CopyConstructible`, `DefaultConstructible`, and `CopyAssignable`.

AABB_tree/include/CGAL/AABB_segment_primitive.h

@@ -54,7 +54,7 @@ namespace internal {
  * The iterator from which the primitive is built should not be invalided
  * while the AABB tree holding the primitive is in use.
  *
- * \cgalModels `AABBPrimitive`
+ * \cgalModels{AABBPrimitive}
  *
  * \tparam GeomTraits is a traits class providing the nested type `Point_3` and `Segment_3`.
  *         It also provides the functor `Construct_source_3` that has an operator taking a `Segment_3`

AABB_tree/include/CGAL/AABB_traits.h

@@ -149,9 +149,8 @@ class AABB_tree;
 /// computations, and it handles points as query type for distance
 /// queries.
 ///
-/// \cgalModels AABBTraits
+/// \cgalModels{AABBTraits,AABBRayIntersectionTraits}
-/// \cgalModels AABBRayIntersectionTraits
+///
-
 /// \tparam GeomTraits must  be a model of the concept \ref AABBGeomTraits,
 /// and provide the geometric types as well as the intersection tests and computations.
 /// \tparam Primitive provide the type of primitives stored in the AABB_tree.

AABB_tree/include/CGAL/AABB_triangle_primitive.h

@@ -55,7 +55,7 @@ namespace internal {
  * The iterator from which the primitive is built should not be invalided
  * while the AABB tree holding the primitive is in use.
  *
- * \cgalModels `AABBPrimitive`
+ * \cgalModels{AABBPrimitive}
  *
  * \tparam GeomTraits is a traits class providing the nested type `Point_3` and `Triangle_3`.
  *         It also provides the functor `Construct_vertex_3` that has an operator taking a `Triangle_3`

AABB_tree/include/CGAL/AABB_triangulation_3_triangle_primitive.h

@@ -28,7 +28,7 @@ namespace CGAL {
     // the TriangleMesh from which the AABB tree is built should not be
     // deleted while the AABB tree is in use.
     //
-    // \cgalModels `AABBPrimitive`
+    // \cgalModels{AABBPrimitive}
     // \tparam GeomTraits must provides a \c %Point_3
     // type, used as \c Point, and a \c %Triangle_3 type, used as \c
     // Datum and constructible from three arguments of type \c

Advancing_front_surface_reconstruction/doc/Advancing_front_surface_reconstruction/Concepts/AdvancingFrontSurfaceReconstructionTraits_3.h

@@ -11,7 +11,9 @@ together with a few geometric predicates and constructions on these objects.
 
 \cgalRefines{DelaunayTriangulationTraits_3}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of the concept `Kernel`}
+\cgalHasModelsEnd
 */
 class AdvancingFrontSurfaceReconstructionTraits_3
 {

Algebraic_foundations/doc/Algebraic_foundations/Algebraic_foundations.txt

@@ -169,8 +169,8 @@ Every \cgal `Kernel` comes with two <I>real number types</I>
 (number types embeddable into the real numbers). One of them is a
 `FieldNumberType`, and the other a `RingNumberType`. The
 coordinates of the basic kernel objects (points, vectors, etc.) come
-from one of these types (the `FieldNumberType` in case of Cartesian
+from one of these types (the `FieldNumberType` in case of %Cartesian
-kernels, and the `RingNumberType` for Homogeneous kernels).
+kernels, and the `RingNumberType` for %Homogeneous kernels).
 
 The concept `FieldNumberType` combines the requirements of the
 concepts `Field` and `RealEmbeddable`, while
@@ -277,4 +277,3 @@ subsequent chapters.
 
 */
 } /* namespace CGAL */
-

Algebraic_foundations/doc/Algebraic_foundations/CGAL/Algebraic_structure_traits.h

@@ -5,7 +5,7 @@ namespace CGAL {
 
 An instance of `Algebraic_structure_traits` is a model of `AlgebraicStructureTraits`, where <span class="textsc">T</span> is the associated type.
 
-\cgalModels `AlgebraicStructureTraits`
+\cgalModels{AlgebraicStructureTraits}
 
 */
 template< typename T >
@@ -22,7 +22,7 @@ namespace CGAL {
 Tag indicating that a type is a model of the
 `EuclideanRing` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `EuclideanRing`
 \sa `AlgebraicStructureTraits`
@@ -38,7 +38,7 @@ struct Euclidean_ring_tag : public Unique_factorization_domain_tag {
 
 Tag indicating that a type is a model of the `Field` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `Field`
 \sa `AlgebraicStructureTraits`
@@ -54,7 +54,7 @@ struct Field_tag : public Integral_domain_tag {
 
 Tag indicating that a type is a model of the `FieldWithKthRoot` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `FieldWithKthRoot`
 \sa `AlgebraicStructureTraits`
@@ -70,7 +70,7 @@ struct Field_with_kth_root_tag : public Field_with_sqrt_tag {
 
 Tag indicating that a type is a model of the `FieldWithRootOf` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `FieldWithRootOf`
 \sa `AlgebraicStructureTraits`
@@ -86,7 +86,7 @@ struct Field_with_root_of_tag : public Field_with_kth_root_tag {
 
 Tag indicating that a type is a model of the `FieldWithSqrt` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `FieldWithSqrt`
 \sa `AlgebraicStructureTraits`
@@ -102,7 +102,7 @@ struct Field_with_sqrt_tag : public Field_tag {
 
 Tag indicating that a type is a model of the `IntegralDomain` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `IntegralDomain`
 \sa `AlgebraicStructureTraits`
@@ -118,7 +118,7 @@ struct Integral_domain_tag : public Integral_domain_without_division_tag {
 
 Tag indicating that a type is a model of the `IntegralDomainWithoutDivision` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `IntegralDomainWithoutDivision`
 
@@ -133,7 +133,7 @@ struct Integral_domain_without_division_tag {
 
 Tag indicating that a type is a model of the `UniqueFactorizationDomain` concept.
 
-\cgalModels `DefaultConstructible`
+\cgalModels{DefaultConstructible}
 
 \sa `UniqueFactorizationDomain`
 \sa `AlgebraicStructureTraits`

Algebraic_foundations/doc/Algebraic_foundations/CGAL/Fraction_traits.h

@@ -6,7 +6,7 @@ namespace CGAL {
 An instance of `Fraction_traits` is a model of `FractionTraits`,
 where `T` is the associated type.
 
-\cgalModels `FractionTraits`
+\cgalModels{FractionTraits}
 
 */
 template< typename T >

Algebraic_foundations/doc/Algebraic_foundations/CGAL/Real_embeddable_traits.h

@@ -6,7 +6,7 @@ namespace CGAL {
 
 An instance of `Real_embeddable_traits` is a model of `RealEmbeddableTraits`, where <span class="textsc">T</span> is the associated type.
 
-\cgalModels `RealEmbeddableTraits`
+\cgalModels{RealEmbeddableTraits}
 
 */
 template< typename T >

Algebraic_foundations/doc/Algebraic_foundations/Concepts/AlgebraicStructureTraits.h

@@ -28,7 +28,9 @@ algebraic operations within that structure.
 \sa `CGAL::Field_with_kth_root_tag`
 \sa `CGAL::Field_with_root_of_tag`
 
-\cgalHasModel `CGAL::Algebraic_structure_traits<T>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Algebraic_structure_traits<T>}
+\cgalHasModelsEnd
 
 */
 

Algebraic_foundations/doc/Algebraic_foundations/Concepts/FieldNumberType.h

@@ -5,20 +5,22 @@
 The concept `FieldNumberType` combines the requirements of the concepts
 `Field` and `RealEmbeddable`.
 A model of `FieldNumberType` can be used as a template parameter
-for Cartesian kernels.
+for %Cartesian kernels.
 
 \cgalRefines{Field,RealEmbeddable}
 
-\cgalHasModel float
+\cgalHasModelsBegin
-\cgalHasModel double
+\cgalHasModels{float}
-\cgalHasModel `CGAL::Gmpq`
+\cgalHasModels{double}
-\cgalHasModel `CGAL::Interval_nt`
+\cgalHasModels{CGAL::Gmpq}
-\cgalHasModel `CGAL::Interval_nt_advanced`
+\cgalHasModels{CGAL::Interval_nt}
-\cgalHasModel `CGAL::Lazy_exact_nt<FieldNumberType>`
+\cgalHasModels{CGAL::Interval_nt_advanced}
-\cgalHasModel `CGAL::Quotient<RingNumberType>`
+\cgalHasModels{CGAL::Lazy_exact_nt<FieldNumberType>}
-\cgalHasModel `leda_rational`
+\cgalHasModels{CGAL::Quotient<RingNumberType>}
-\cgalHasModel `leda_bigfloat`
+\cgalHasModels{leda_rational}
-\cgalHasModel `leda_real`
+\cgalHasModels{leda_bigfloat}
+\cgalHasModels{leda_real}
+\cgalHasModelsEnd
 
 \sa `RingNumberType`
 \sa `Kernel`
@@ -32,4 +34,3 @@ public:
 /// @}
 
 }; /* end FieldNumberType */
-

Algebraic_foundations/doc/Algebraic_foundations/Concepts/FractionTraits.h

@@ -8,7 +8,9 @@ A model of `FractionTraits` is associated with a type `Type`.
 In case the associated type is a `Fraction`, a model of `FractionTraits` provides the relevant functionality for decomposing and re-composing as well
 as the numerator and denominator type.
 
-\cgalHasModel `CGAL::Fraction_traits<T>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Fraction_traits<T>}
+\cgalHasModelsEnd
 
 \sa `FractionTraits_::Decompose`
 \sa `FractionTraits_::Compose`

Algebraic_foundations/doc/Algebraic_foundations/Concepts/FromIntConstructible.h

@@ -6,9 +6,11 @@
 A model of the concept `FromIntConstructible` is required
 to be constructible from int.
 
-\cgalHasModel int
+\cgalHasModelsBegin
-\cgalHasModel long
+\cgalHasModels{int}
-\cgalHasModel double
+\cgalHasModels{long}
+\cgalHasModels{double}
+\cgalHasModelsEnd
 
 */
 

Algebraic_foundations/doc/Algebraic_foundations/Concepts/RealEmbeddableTraits.h

@@ -7,7 +7,9 @@ A model of `RealEmbeddableTraits` is associated to a number type
 `Type` and reflects the properties of this type with respect
 to the concept `RealEmbeddable`.
 
-\cgalHasModel `CGAL::Real_embeddable_traits<T>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Real_embeddable_traits<T>}
+\cgalHasModelsEnd
 */
 
 class RealEmbeddableTraits {

Algebraic_foundations/doc/Algebraic_foundations/Concepts/RingNumberType.h

@@ -6,23 +6,25 @@
 The concept `RingNumberType` combines the requirements of the concepts
 `IntegralDomainWithoutDivision` and `RealEmbeddable`.
 A model of `RingNumberType` can be used as a template parameter
-for Homogeneous kernels.
+for homogeneous kernels.
 
 \cgalRefines{IntegralDomainWithoutDivision,RealEmbeddable}
 
-\cgalHasModel \cpp built-in number types
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::Gmpq`
+\cgalHasModelsBare{\cpp built-in number types}
-\cgalHasModel `CGAL::Gmpz`
+\cgalHasModels{CGAL::Gmpq}
-\cgalHasModel `CGAL::Interval_nt`
+\cgalHasModels{CGAL::Gmpz}
-\cgalHasModel `CGAL::Interval_nt_advanced`
+\cgalHasModels{CGAL::Interval_nt}
-\cgalHasModel `CGAL::Lazy_exact_nt<RingNumberType>`
+\cgalHasModels{CGAL::Interval_nt_advanced}
-\cgalHasModel `CGAL::MP_Float`
+\cgalHasModels{CGAL::Lazy_exact_nt<RingNumberType>}
-\cgalHasModel `CGAL::Gmpzf`
+\cgalHasModels{CGAL::MP_Float}
-\cgalHasModel `CGAL::Quotient<RingNumberType>`
+\cgalHasModels{CGAL::Gmpzf}
-\cgalHasModel `leda_integer`
+\cgalHasModels{CGAL::Quotient<RingNumberType>}
-\cgalHasModel `leda_rational`
+\cgalHasModels{leda_integer}
-\cgalHasModel `leda_bigfloat`
+\cgalHasModels{leda_rational}
-\cgalHasModel `leda_real`
+\cgalHasModels{leda_bigfloat}
+\cgalHasModels{leda_real}
+\cgalHasModelsEnd
 
 \sa `FieldNumberType`
 
@@ -32,4 +34,3 @@ class RingNumberType {
 public:
 
 }; /* end RingNumberType */
-

Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_d_1.h

@@ -27,7 +27,7 @@ approximation of an algebraic real root is a slightly modified
 (filtered) version of the one presented in \cgalCite{abbott-qir-06}. The
 method has quadratic convergence.
 
-\cgalModels `AlgebraicKernel_d_1`
+\cgalModels{AlgebraicKernel_d_1}
 
 \sa `AlgebraicKernel_d_1`
 \sa `Polynomial_d`

Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_d_2.h

@@ -47,7 +47,7 @@ above. `ROOT` should be one of the integer types.  See also the
 documentation of `Sqrt_extension<NT,ROOT>`.
 \cgalAdvancedEnd
 
-\cgalModels `AlgebraicKernel_d_2`
+\cgalModels{AlgebraicKernel_d_2}
 
 \sa `AlgebraicKernel_d_1`
 \sa `AlgebraicKernel_d_2`

Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_rs_gmpq_d_1.h

@@ -12,7 +12,7 @@ rational univariate polynomial root isolation. It is a model of the
 isolate integer polynomials, the operations of this kernel have the
 overhead of converting the polynomials to integer.
 
-\cgalModels `AlgebraicKernel_d_1`
+\cgalModels{AlgebraicKernel_d_1}
 
 \sa `Algebraic_kernel_rs_gmpz_d_1`
 

Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_rs_gmpz_d_1.h

@@ -10,7 +10,7 @@ This univariate algebraic kernel uses the Rs library to perform
 integer univariate polynomial root isolation. It is a model of the
 `AlgebraicKernel_d_1` concept.
 
-\cgalModels `AlgebraicKernel_d_1`
+\cgalModels{AlgebraicKernel_d_1}
 
 \sa `Algebraic_kernel_rs_gmpz_d_1`
 

Algebraic_kernel_d/doc/Algebraic_kernel_d/Concepts/AlgebraicKernel_d_1.h

@@ -8,8 +8,10 @@ algebraic functionalities on univariate polynomials of general degree \f$ d\f$.
 
 \cgalRefines{CopyConstructible,Assignable}
 
-\cgalHasModel `CGAL::Algebraic_kernel_rs_gmpz_d_1`
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::Algebraic_kernel_rs_gmpq_d_1`
+\cgalHasModels{CGAL::Algebraic_kernel_rs_gmpz_d_1}
+\cgalHasModels{CGAL::Algebraic_kernel_rs_gmpq_d_1}
+\cgalHasModelsEnd
 
 \sa `AlgebraicKernel_d_2`
 

Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_face_base_2.h

@@ -16,7 +16,7 @@ if `Alpha_shape_face_base_2` is intended to be used with an alpha-shape class ba
 \link Tag_true `Tag_true`\endlink, triggers exact comparisons between alpha values. See the description
 provided in the documentation of `Alpha_shape_2` for more details. The default value is \link Tag_false `Tag_false`\endlink.
 
-\cgalModels `AlphaShapeFace_2`
+\cgalModels{AlphaShapeFace_2}
 
 \sa `Triangulation_face_base_2`
 \sa `Regular_triangulation_face_base_2`

Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_vertex_base_2.h

@@ -17,7 +17,7 @@ if `Alpha_shape_vertex_base_2` is intended to be used with an alpha-shape class
 \link Tag_true `Tag_true`\endlink, triggers exact comparisons between alpha values. See the description
 provided in the documentation of `Alpha_shape_2` for more details. The default value is \link Tag_false `Tag_false`\endlink.
 
-\cgalModels `AlphaShapeVertex_2`
+\cgalModels{AlphaShapeVertex_2}
 
 \sa `Triangulation_vertex_base_2`
 \sa `Regular_triangulation_vertex_base_2`

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeFace_2.h

@@ -9,7 +9,9 @@ The concept `AlphaShapeFace_2` describes the requirements for the base face of a
   RegularTriangulationFaceBase_2 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_2TriangulationFaceBase_2 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Alpha_shape_face_base_2` (templated with the appropriate triangulation face base class).
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Alpha_shape_face_base_2 (templated with the appropriate triangulation face base class)}
+\cgalHasModelsEnd
 
 */
 class AlphaShapeFace_2 {

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeTraits_2.h

@@ -9,8 +9,10 @@ class of the underlying Delaunay triangulation of a basic alpha shape.
 \cgalRefines{DelaunayTriangulationTraits_2 if the underlying triangulation of the alpha shape is a Delaunay triangulation,
   Periodic_2DelaunayTriangulationTraits_2 if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
-\cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.
+\cgalHasModelsBare{All models of `Kernel`}
+\cgalHasModelsBare{Projection traits such as `CGAL::Projection_traits_xy_3<K>`}
+\cgalHasModelsEnd
 
 \sa `CGAL::Exact_predicates_inexact_constructions_kernel` (recommended kernel)
 */

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeVertex_2.h

@@ -9,7 +9,9 @@ The concept `AlphaShapeVertex_2` describes the requirements for the base vertex
   RegularTriangulationVertexBase_2 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_2TriangulationVertexBase_2 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Alpha_shape_vertex_base_2` (templated with the appropriate triangulation vertex base class).
+\cgalHasModelsBegin
+\cgalHasModelsBare{`CGAL::Alpha_shape_vertex_base_2` (templated with the appropriate triangulation vertex base class)}
+\cgalHasModelsEnd
 */
 class AlphaShapeVertex_2 {
 public:

Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/WeightedAlphaShapeTraits_2.h

@@ -9,8 +9,10 @@ of the underlying regular triangulation of a weighted alpha shape.
 
 \cgalRefines{RegularTriangulationTraits_2 if the underlying triangulation of the alpha shape is a regular triangulation.}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
-\cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.
+\cgalHasModelsBare{All models of `Kernel`,}
+\cgalHasModelsBare{Projection traits such as `CGAL::Projection_traits_xy_3<K>`}
+\cgalHasModelsEnd
 
 \sa `CGAL::Exact_predicates_inexact_constructions_kernel` (recommended kernel)
 */

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_cell_base_3.h

@@ -19,7 +19,7 @@ provided in the documentation of `Alpha_shape_3` for more details. The default v
 must be \link Tag_true `Tag_true`\endlink if the underlying triangulation of the alpha shape to be used is a regular triangulation
 and \link Tag_false `Tag_false`\endlink otherwise. The default is \link Tag_false `Tag_false`\endlink.
 
-\cgalModels `AlphaShapeCell_3`
+\cgalModels{AlphaShapeCell_3}
 
 \sa `Delaunay_triangulation_cell_base_3`
 \sa `Regular_triangulation_cell_base_3`

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_vertex_base_3.h

@@ -19,7 +19,7 @@ provided in the documentation of `Alpha_shape_3` for more details. The default v
 must be \link Tag_true `Tag_true`\endlink if the underlying triangulation of the alpha shape to be used is a regular triangulation
 and \link Tag_false `Tag_false`\endlink otherwise. The default is \link Tag_false `Tag_false`\endlink.
 
-\cgalModels `AlphaShapeVertex_3`
+\cgalModels{AlphaShapeVertex_3}
 
 \sa `Triangulation_vertex_base_3`
 \sa `Regular_triangulation_vertex_base_3`

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Fixed_alpha_shape_cell_base_3.h

@@ -13,7 +13,7 @@ to the `Alpha_shape_3` class.
         By default, it is instantiated with `Delaunay_triangulation_cell_base_3<Traits>`,
         which is appropriate for basic alpha shapes.
 
-\cgalModels `FixedAlphaShapeCell_3`
+\cgalModels{FixedAlphaShapeCell_3}
 
 \sa `Alpha_shape_cell_base_3`
 \sa `Delaunay_triangulation_cell_base_3`

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Fixed_alpha_shape_vertex_base_3.h

@@ -13,7 +13,7 @@ to the `Alpha_shape_3` class.
         By default, it is instantiated with `Triangulation_vertex_base_3<Traits>`,
         which is appropriate for basic alpha shapes.
 
-\cgalModels `FixedAlphaShapeVertex_3`
+\cgalModels{FixedAlphaShapeVertex_3}
 
 \sa `Alpha_shape_vertex_base_3`
 \sa `Triangulation_vertex_base_3`

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeCell_3.h

@@ -9,7 +9,9 @@ The concept `AlphaShapeCell_3` describes the requirements for the base cell of a
   RegularTriangulationCellBase_3 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_3TriangulationDSCellBase_3 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Alpha_shape_cell_base_3` (templated with the appropriate triangulation cell base class).
+\cgalHasModelsBegin
+\cgalHasModelsBare{`CGAL::Alpha_shape_cell_base_3` (templated with the appropriate triangulation cell base class)}
+\cgalHasModelsEnd
 
 \sa `CGAL::Alpha_status`
 

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeTraits_3.h

@@ -10,7 +10,9 @@ of the underlying Delaunay triangulation of a basic alpha shape.
 \cgalRefines{DelaunayTriangulationTraits_3 if the underlying triangulation of the alpha shape is a Delaunay triangulation,
   Periodic_3DelaunayTriangulationTraits_3 if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of `Kernel`}
+\cgalHasModelsEnd
 
 \sa `CGAL::Exact_predicates_inexact_constructions_kernel` (recommended kernel)
 */

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeVertex_3.h

@@ -9,7 +9,9 @@ The concept `AlphaShapeVertex_3` describes the requirements for the base vertex
   RegularTriangulationVertexBase_3 if the underlying triangulation of the alpha shape is a regular triangulation.
   Periodic_3TriangulationDSVertexBase_3 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Alpha_shape_vertex_base_3` (templated with the appropriate triangulation vertex base class).
+\cgalHasModelsBegin
+\cgalHasModelsBare{`CGAL::Alpha_shape_vertex_base_3` (templated with the appropriate triangulation vertex base class)}
+\cgalHasModelsEnd
 
 \sa `CGAL::Alpha_status`
 

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeCell_3.h

@@ -9,7 +9,9 @@ The concept `FixedAlphaShapeCell_3` describes the requirements for the base cell
   RegularTriangulationCellBase_3 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_3TriangulationDSCellBase_3 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Fixed_alpha_shape_cell_base_3` (templated with the appropriate triangulation cell base class).
+\cgalHasModelsBegin
+\cgalHasModelsBare{`CGAL::Fixed_alpha_shape_cell_base_3` (templated with the appropriate triangulation cell base class)}
+\cgalHasModelsEnd
 */
 class FixedAlphaShapeCell_3 {
 public:

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeTraits_3.h

@@ -10,7 +10,9 @@ of the underlying Delaunay triangulation of a basic alpha shape with a fixed val
 \cgalRefines{DelaunayTriangulationTraits_3 if the underlying triangulation of the alpha shape is a Delaunay triangulation,
   Periodic_3DelaunayTriangulationTraits_3 if the underlying triangulation of the alpha shape is a periodic Delaunay triangulation}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of `Kernel`}
+\cgalHasModelsEnd
 
 \sa CGAL::Exact_predicates_inexact_constructions_kernel (recommended kernel)
 */

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeVertex_3.h

@@ -9,7 +9,9 @@ The concept `FixedAlphaShapeVertex_3` describes the requirements for the base ve
   RegularTriangulationVertexBase_3 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_3TriangulationDSVertexBase_3 if the underlying triangulation of the alpha shape is a periodic triangulation}
 
-\cgalHasModel `CGAL::Fixed_alpha_shape_vertex_base_3` (templated with the appropriate triangulation vertex base class).
+\cgalHasModelsBegin
+\cgalHasModelsBare{`CGAL::Fixed_alpha_shape_vertex_base_3` (templated with the appropriate triangulation vertex base class)}
+\cgalHasModelsEnd
 */
 
 class FixedAlphaShapeVertex_3 {

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedWeightedAlphaShapeTraits_3.h

@@ -9,7 +9,9 @@ for the geometric traits class of the underlying regular triangulation of a weig
 \cgalRefines{RegularTriangulationTraits_3 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_3RegularTriangulationTraits_3 if the underlying triangulation of the alpha shape is a periodic regular triangulation}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of `Kernel`}
+\cgalHasModelsEnd
 
 \sa `CGAL::Exact_predicates_inexact_constructions_kernel` (recommended kernel)
 */

Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/WeightedAlphaShapeTraits_3.h

@@ -10,7 +10,9 @@ of the underlying regular triangulation of a weighted alpha shape.
 \cgalRefines{RegularTriangulationTraits_3 if the underlying triangulation of the alpha shape is a regular triangulation,
   Periodic_3RegularTriangulationTraits_3 if the underlying triangulation of the alpha shape is a periodic regular triangulation}
 
-\cgalHasModel All models of `Kernel`.
+\cgalHasModelsBegin
+\cgalHasModelsBare{All models of `Kernel`}
+\cgalHasModelsEnd
 
 \sa `CGAL::Exact_predicates_inexact_constructions_kernel` (recommended kernel)
 */

Alpha_wrap_3/doc/Alpha_wrap_3/Concepts/AlphaWrapOracle.h

@@ -9,10 +9,12 @@ The concept `AlphaWrapOracle` defines the requirements for an Alpha Wrap <em>Ora
 that answers a number of queries over the input of the algorithm.
 The oracle is the template parameter of the class `CGAL::Alpha_wraps_3_::Alpha_wrap_3`.
 
-\cgalHasModel `CGAL::Alpha_wraps_3_::Point_set_oracle`
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::Alpha_wraps_3_::Segment_soup_oracle`
+\cgalHasModels{CGAL::Alpha_wraps_3_::Point_set_oracle}
-\cgalHasModel `CGAL::Alpha_wraps_3_::Triangle_mesh_oracle`
+\cgalHasModels{CGAL::Alpha_wraps_3_::Segment_soup_oracle}
-\cgalHasModel `CGAL::Alpha_wraps_3_::Triangle_soup_oracle`
+\cgalHasModels{CGAL::Alpha_wraps_3_::Triangle_mesh_oracle}
+\cgalHasModels{CGAL::Alpha_wraps_3_::Triangle_soup_oracle}
+\cgalHasModelsEnd
 
 */
 template <typename GeomTraits>

Alpha_wrap_3/doc/Alpha_wrap_3/Concepts/AlphaWrapTraits_3.h

@@ -11,7 +11,9 @@ you require Kernel. Stitch_borders doesn't even have clear geometric traits requ
 The concept `AlphaWrapTraits_3` defines the requirements for the geometric traits class
 of an alpha wrap oracle.
 
-\cgalHasModel Any 3D %kernel is a model of this traits concept.
+\cgalHasModelsBegin
+\cgalHasModelsBare{Any 3D %kernel is a model of this traits concept}
+\cgalHasModelsEnd
 */
 
 class AlphaWrapTraits_3

Alpha_wrap_3/examples/Alpha_wrap_3/CMakeLists.txt

@@ -12,3 +12,4 @@ create_single_source_cgal_program("triangle_soup_wrap.cpp")
 create_single_source_cgal_program("point_set_wrap.cpp")
 create_single_source_cgal_program("wrap_from_cavity.cpp")
 create_single_source_cgal_program("mixed_inputs_wrap.cpp")
+create_single_source_cgal_program("volumetric_wrap.cpp")

Alpha_wrap_3/examples/Alpha_wrap_3/mixed_inputs_wrap.cpp

@@ -16,9 +16,9 @@ using K = CGAL::Exact_predicates_inexact_constructions_kernel;
 using Point_3 = K::Point_3;
 using Segment_3 = K::Segment_3;
 
-using Face = std::array<std::size_t, 3>;
 using Segments = std::vector<Segment_3>;
 using Points = std::vector<Point_3>;
+using Face = std::array<std::size_t, 3>;
 using Faces = std::vector<Face>;
 
 using Mesh = CGAL::Surface_mesh<Point_3>;

Alpha_wrap_3/examples/Alpha_wrap_3/volumetric_wrap.cpp

@@ -0,0 +1,173 @@
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Surface_mesh.h>
+
+#include <CGAL/alpha_wrap_3.h>
+
+#include <CGAL/tetrahedral_remeshing.h>
+#include <CGAL/Tetrahedral_remeshing/Remeshing_cell_base_3.h>
+#include <CGAL/Tetrahedral_remeshing/Remeshing_vertex_base_3.h>
+#include <CGAL/Simplicial_mesh_cell_base_3.h>
+#include <CGAL/Simplicial_mesh_vertex_base_3.h>
+
+#include <CGAL/Polygon_mesh_processing/bbox.h>
+#include <CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h>
+#include <CGAL/property_map.h>
+#include <CGAL/Real_timer.h>
+
+#include <CGAL/Delaunay_triangulation_3.h>
+#include <CGAL/draw_triangulation_3.h>
+
+#include <CGAL/IO/Triangulation_off_ostream_3.h>
+#include <CGAL/IO/File_medit.h>
+
+#include <iostream>
+#include <string>
+
+namespace PMP = CGAL::Polygon_mesh_processing;
+namespace AW3i = CGAL::Alpha_wraps_3::internal;
+
+using K = CGAL::Exact_predicates_inexact_constructions_kernel;
+using Point_3 = K::Point_3;
+
+using Points = std::vector<Point_3>;
+using Face = std::array<std::size_t, 3>;
+using Faces = std::vector<Face>;
+
+using Mesh = CGAL::Surface_mesh<Point_3>;
+
+// If we provide a triangulation, AW3 uses its Gt, so we have to make the Gt stack explicit
+using Gtb = AW3i::Alpha_wrap_AABB_geom_traits<K>; // provides Ball_3
+using Gt = CGAL::Robust_circumcenter_filtered_traits_3<Gtb>; // better inexact constructions (not mandatory)
+
+// Since we are going to use tetrahedral remeshing on the underlying triangulation,
+// we need special vertex and cell base types that meets the requirements of the
+// tetrahedral remeshing concepts
+using Vbbb = AW3i::Alpha_wrap_triangulation_vertex_base_3<K>;
+using Vbb = CGAL::Simplicial_mesh_vertex_base_3<K, int, int, int, int, Vbbb>;
+using Vb = CGAL::Tetrahedral_remeshing::Remeshing_vertex_base_3<K, Vbb>;
+
+using Cbbb = AW3i::Alpha_wrap_triangulation_cell_base_3<K>;
+using Cbb = CGAL::Simplicial_mesh_cell_base_3<K, int, int, Cbbb>;
+using Cb = CGAL::Tetrahedral_remeshing::Remeshing_cell_base_3<K, Cbb>;
+
+using Tds = CGAL::Triangulation_data_structure_3<Vb, Cb>;
+
+using Delaunay_triangulation = CGAL::Delaunay_triangulation_3<Gt, Tds, CGAL::Fast_location>;
+
+// because the Fast_location does all kinds of rebinding shenanigans + T3_hierarchy is in the stack...
+using Triangulation = CGAL::Triangulation_3<typename Delaunay_triangulation::Geom_traits,
+                                            typename Delaunay_triangulation::Triangulation_data_structure>;
+
+using Facet = Triangulation::Facet;
+
+int main(int argc, char** argv)
+{
+  // Read the input
+  const std::string filename = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/bull.off");
+  std::cout << "Reading " << filename << "..." << std::endl;
+
+  Points points;
+  Faces faces;
+  if(!CGAL::IO::read_polygon_soup(filename, points, faces) || faces.empty())
+  {
+    std::cerr << "Invalid input." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "Input: " << points.size() << " vertices, " << faces.size() << " faces" << std::endl;
+
+  // Compute the alpha and offset values
+  const double relative_alpha = (argc > 2) ? std::stod(argv[2]) : 20.;
+  const double relative_offset = (argc > 3) ? std::stod(argv[3]) : 600.;
+
+  CGAL::Bbox_3 bbox;
+  for(const Point_3& p : points)
+    bbox += p.bbox();
+
+  const double diag_length = std::sqrt(CGAL::square(bbox.xmax() - bbox.xmin()) +
+                                       CGAL::square(bbox.ymax() - bbox.ymin()) +
+                                       CGAL::square(bbox.zmax() - bbox.zmin()));
+
+  const double alpha = diag_length / relative_alpha;
+  const double offset = diag_length / relative_offset;
+  std::cout << "alpha: " << alpha << ", offset: " << offset << std::endl;
+
+  // Construct the wrap
+  CGAL::Real_timer t;
+  t.start();
+
+  using Oracle = CGAL::Alpha_wraps_3::internal::Triangle_soup_oracle<K>;
+
+  Oracle oracle(K{});
+  oracle.add_triangle_soup(points, faces, CGAL::parameters::default_values());
+
+  CGAL::Alpha_wraps_3::internal::Alpha_wrap_3<Oracle, Delaunay_triangulation> aw3(oracle);
+  Mesh wrap;
+  aw3(alpha, offset, wrap);
+
+  t.stop();
+  std::cout << "Result: " << num_vertices(wrap) << " vertices, " << num_faces(wrap) << " faces" << std::endl;
+  std::cout << "Took " << t.time() << " s." << std::endl;
+
+  // Get the interior tetrahedrization
+  auto dt = aw3.triangulation();
+
+  // Save the result
+  std::string input_name = std::string(filename);
+  input_name = input_name.substr(input_name.find_last_of("/") + 1, input_name.length() - 1);
+  input_name = input_name.substr(0, input_name.find_last_of("."));
+  std::string output_name = input_name
+                            + "_" + std::to_string(static_cast<int>(relative_alpha))
+                            + "_" + std::to_string(static_cast<int>(relative_offset)) + ".off";
+  std::cout << "Writing to " << output_name << std::endl;
+  CGAL::IO::write_polygon_mesh(output_name, wrap, CGAL::parameters::stream_precision(17));
+
+  // Remesh the interior of the wrap
+  const Delaunay_triangulation& aw3_dt = aw3.triangulation();
+  const Triangulation& aw3_tr = static_cast<const Triangulation&>(aw3_dt);
+  Triangulation tr = aw3_tr; // intentional copy
+
+  std::cout << "BEFORE: " << tr.number_of_vertices() << " vertices, " << tr.number_of_cells() << " cells" << std::endl;
+
+  // Set up the c3t3 information
+  for(auto v : tr.finite_vertex_handles())
+    v->set_dimension(3);
+
+  for(auto c : tr.finite_cell_handles())
+  {
+    if(c->is_outside())
+      c->set_subdomain_index(0);
+    else
+      c->set_subdomain_index(1);
+
+    // if the neighboring cell has a different outside info, put the vertices
+    // of the common face on the surface boundary
+    for(int i=0; i<4; ++i)
+    {
+      if(c->neighbor(i)->is_outside() != c->is_outside())
+      {
+        c->set_surface_patch_index(i, 1);
+        for(int j=1; j<4; ++j)
+          c->vertex((i+j)%4)->set_dimension(2);
+      }
+    }
+  }
+
+  std::ofstream out_before("before_remeshing.mesh");
+  CGAL::IO::write_MEDIT(out_before, tr);
+
+  // edge length of equilateral triangle with circumradius alpha
+  // const double l = 2 * alpha * 0.8660254037844386; // sqrt(3)/2
+
+  // edge length of regular tetrahedron with circumradius alpha
+  const double l = 1.6329931618554521 * alpha; // sqrt(8/3)
+
+  CGAL::tetrahedral_isotropic_remeshing(tr, l, CGAL::parameters::remesh_boundaries(false));
+
+  std::cout << "AFTER: " << tr.number_of_vertices() << " vertices, " << tr.number_of_cells() << " cells" << std::endl;
+
+  std::ofstream out_after("after_remeshing.mesh");
+  CGAL::IO::write_MEDIT(out_after, tr);
+
+  return EXIT_SUCCESS;
+}

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 Google LLC (USA).
+// Copyright (c) 2019-2023 Google LLC (USA).
 // All rights reserved.
 //
 // This file is part of CGAL (www.cgal.org).
@@ -29,16 +29,25 @@
 
 #include <CGAL/license/Alpha_wrap_3.h>
 
+#include <CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_cell_base_3.h>
+#include <CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_vertex_base_3.h>
 #include <CGAL/Alpha_wrap_3/internal/Alpha_wrap_AABB_geom_traits.h>
 #include <CGAL/Alpha_wrap_3/internal/gate_priority_queue.h>
 #include <CGAL/Alpha_wrap_3/internal/geometry_utils.h>
 #include <CGAL/Alpha_wrap_3/internal/oracles.h>
 
+#include <CGAL/Delaunay_triangulation_3.h>
+#include <CGAL/Triangulation_data_structure_3.h>
+#include <CGAL/Delaunay_triangulation_cell_base_3.h>
+#include <CGAL/Delaunay_triangulation_cell_base_with_circumcenter_3.h>
+#include <CGAL/Robust_weighted_circumcenter_filtered_traits_3.h>
+
 #include <CGAL/Cartesian_converter.h>
 #include <CGAL/Simple_cartesian.h>
 
 #include <CGAL/boost/graph/Euler_operations.h>
 #include <CGAL/boost/graph/named_params_helper.h>
+#include <CGAL/Default.h>
 #include <CGAL/Named_function_parameters.h>
 #include <CGAL/Modifiable_priority_queue.h>
 #include <CGAL/Polygon_mesh_processing/bbox.h>
@@ -50,16 +59,9 @@
 #include <CGAL/Polygon_mesh_processing/stitch_borders.h> // only if non-manifoldness is not treated
 #include <CGAL/property_map.h>
 #include <CGAL/Real_timer.h>
-#include <CGAL/Delaunay_triangulation_3.h>
-#include <CGAL/Triangulation_data_structure_3.h>
-#include <CGAL/Delaunay_triangulation_cell_base_3.h>
-#include <CGAL/Triangulation_cell_base_with_info_3.h>
-#include <CGAL/Delaunay_triangulation_cell_base_with_circumcenter_3.h>
-#include <CGAL/Triangulation_vertex_base_with_info_3.h>
-#include <CGAL/Robust_weighted_circumcenter_filtered_traits_3.h>
 
-#include <array>
 #include <algorithm>
+#include <array>
 #include <fstream>
 #include <functional>
 #include <iostream>
@@ -74,30 +76,11 @@ namespace CGAL {
 namespace Alpha_wraps_3 {
 namespace internal {
 
-template <typename Cb>
+namespace {
-class Cell_base_with_timestamp
-  : public Cb
-{
-  std::size_t time_stamp_;
 
-public:
+namespace AW3i = ::CGAL::Alpha_wraps_3::internal;
-  template <typename... Args>
-  Cell_base_with_timestamp(const Args&... args) : Cb(args...), time_stamp_(-1) { }
 
-  Cell_base_with_timestamp(const Cell_base_with_timestamp& other) : Cb(other), time_stamp_(other.time_stamp_) { }
+} // unnamed namespace
-
-  typedef CGAL::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; }
-
-  template <class TDS>
-  struct Rebind_TDS
-  {
-    typedef typename Cb::template Rebind_TDS<TDS>::Other Cb2;
-    typedef Cell_base_with_timestamp<Cb2> Other;
-  };
-};
 
 struct Wrapping_default_visitor
 {
@@ -125,11 +108,34 @@ struct Wrapping_default_visitor
   void on_alpha_wrapping_end(const AlphaWrapper&) { };
 };
 
-template <typename Oracle>
+template <typename Oracle_,
+          typename Triangulation_ = CGAL::Default>
 class Alpha_wrap_3
 {
+  using Oracle = Oracle_;
+
+  // Triangulation
   using Base_GT = typename Oracle::Geom_traits;
-  using Geom_traits = Robust_circumcenter_filtered_traits_3<Base_GT>;
+  using Default_Gt = CGAL::Robust_circumcenter_filtered_traits_3<Base_GT>;
+
+  using Default_Vb = Alpha_wrap_triangulation_vertex_base_3<Default_Gt>;
+  using Default_Cb = Alpha_wrap_triangulation_cell_base_3<Default_Gt>;
+  using Default_Cbt = Cell_base_with_timestamp<Default_Cb>; // determinism
+  using Default_Tds = CGAL::Triangulation_data_structure_3<Default_Vb, Default_Cbt>;
+  using Default_Triangulation = CGAL::Delaunay_triangulation_3<Default_Gt, Default_Tds, Fast_location>;
+
+  using Triangulation = typename Default::Get<Triangulation_, Default_Triangulation>::type;
+
+  using Cell_handle = typename Triangulation::Cell_handle;
+  using Facet = typename Triangulation::Facet;
+  using Vertex_handle = typename Triangulation::Vertex_handle;
+  using Locate_type = typename Triangulation::Locate_type;
+
+  using Gate = internal::Gate<Triangulation>;
+  using Alpha_PQ = Modifiable_priority_queue<Gate, Less_gate, Gate_ID_PM<Triangulation>, CGAL_BOOST_PAIRING_HEAP>;
+
+  // Use the geom traits from the triangulation, and trust the (advanced) user that provided it
+  using Geom_traits = typename Triangulation::Geom_traits;
 
   using FT = typename Geom_traits::FT;
   using Point_3 = typename Geom_traits::Point_3;
@@ -143,34 +149,6 @@ class Alpha_wrap_3
   using SC_Iso_cuboid_3 = SC::Iso_cuboid_3;
   using SC2GT = Cartesian_converter<SC, Geom_traits>;
 
-  struct Cell_info
-  {
-    bool is_outside = false;
-  };
-
-  enum Vertex_info
-  {
-    DEFAULT = 0,
-    BBOX_VERTEX,
-    SEED_VERTEX
-  };
-
-  using Vb = Triangulation_vertex_base_3<Geom_traits>;
-  using Vbi = Triangulation_vertex_base_with_info_3<Vertex_info, Geom_traits, Vb>;
-  using Cbb = Delaunay_triangulation_cell_base_3<Geom_traits>;
-  using Cb = Delaunay_triangulation_cell_base_with_circumcenter_3<Geom_traits, Cbb>;
-  using Cbi = Triangulation_cell_base_with_info_3<Cell_info, Geom_traits, Cb>;
-  using Cbt = Cell_base_with_timestamp<Cbi>;
-  using Tds = Triangulation_data_structure_3<Vbi, Cbt>;
-  using Dt = Delaunay_triangulation_3<Geom_traits, Tds, Fast_location>;
-
-  using Cell_handle = typename Dt::Cell_handle;
-  using Facet = typename Dt::Facet;
-  using Vertex_handle = typename Dt::Vertex_handle;
-  using Locate_type = typename Dt::Locate_type;
-
-  using Gate = internal::Gate<Dt>;
-  using Alpha_PQ = Modifiable_priority_queue<Gate, Less_gate, Gate_ID_PM<Dt>, CGAL_BOOST_PAIRING_HEAP>;
 
 protected:
   const Oracle m_oracle;
@@ -179,7 +157,7 @@ protected:
   FT m_alpha, m_sq_alpha;
   FT m_offset, m_sq_offset;
 
-  Dt m_dt;
+  Triangulation m_tr;
   Alpha_PQ m_queue;
 
 public:
@@ -187,7 +165,7 @@ public:
   Alpha_wrap_3(const Oracle& oracle)
     :
       m_oracle(oracle),
-      m_dt(Geom_traits(oracle.geom_traits())),
+      m_tr(Geom_traits(oracle.geom_traits())),
       // used to set up the initial MPQ, use some arbitrary not-too-small value
       m_queue(4096)
   {
@@ -197,9 +175,9 @@ public:
   }
 
 public:
-  const Geom_traits& geom_traits() const { return m_dt.geom_traits(); }
+  const Geom_traits& geom_traits() const { return m_tr.geom_traits(); }
-  Dt& triangulation() { return m_dt; }
+  Triangulation& triangulation() { return m_tr; }
-  const Dt& triangulation() const { return m_dt; }
+  const Triangulation& triangulation() const { return m_tr; }
   const Alpha_PQ& queue() const { return m_queue; }
 
   double default_alpha() const
@@ -216,13 +194,13 @@ private:
   const Point_3& circumcenter(const Cell_handle c) const
   {
     // We only cross an infinite facet once, so this isn't going to be recomputed many times
-    if(m_dt.is_infinite(c))
+    if(m_tr.is_infinite(c))
     {
-      const int inf_index = c->index(m_dt.infinite_vertex());
+      const int inf_index = c->index(m_tr.infinite_vertex());
       c->set_circumcenter(
-            geom_traits().construct_circumcenter_3_object()(m_dt.point(c, (inf_index+1)&3),
+            geom_traits().construct_circumcenter_3_object()(m_tr.point(c, (inf_index+1)&3),
-                                                            m_dt.point(c, (inf_index+2)&3),
+                                                            m_tr.point(c, (inf_index+2)&3),
-                                                            m_dt.point(c, (inf_index+3)&3)));
+                                                            m_tr.point(c, (inf_index+3)&3)));
     }
 
     return c->circumcenter(geom_traits());
@@ -418,11 +396,11 @@ private:
     for(int i=0; i<8; ++i)
     {
       const Point_3 bp = SC2GT()(m_bbox.vertex(i));
-      Vertex_handle bv = m_dt.insert(bp);
+      Vertex_handle bv = m_tr.insert(bp);
 #ifdef CGAL_AW3_DEBUG_INITIALIZATION
       std::cout << "\t" << bp << std::endl;
 #endif
-      bv->info() = BBOX_VERTEX;
+      bv->type() = AW3i::Vertex_type:: BBOX_VERTEX;
     }
   }
 
@@ -433,7 +411,7 @@ private:
   // that the refinement point is separated from the existing point set.
   bool cavity_cell_outside_tag(const Cell_handle ch)
   {
-    CGAL_precondition(!m_dt.is_infinite(ch));
+    CGAL_precondition(!m_tr.is_infinite(ch));
 
     const Tetrahedron_with_outside_info<Geom_traits> tet(ch, geom_traits());
     if(m_oracle.do_intersect(tet))
@@ -536,8 +514,8 @@ private:
       // This problem only appears when the seed and icosahedron vertices are close to the offset surface,
       // which usually happens for large alpha values.
 
-      Vertex_handle seed_v = m_dt.insert(seed_p);
+      Vertex_handle seed_v = m_tr.insert(seed_p);
-      seed_v->info() = SEED_VERTEX;
+      seed_v->type() = AW3i::Vertex_type:: SEED_VERTEX;
       seed_vs.push_back(seed_v);
 
       // Icosahedron vertices (see also BGL::make_icosahedron())
@@ -573,8 +551,8 @@ private:
         if(bbox.has_on_unbounded_side(seed_neighbor_p))
           continue;
 
-        Vertex_handle ico_v = m_dt.insert(seed_neighbor_p, seed_v /*hint*/);
+        Vertex_handle ico_v = m_tr.insert(seed_neighbor_p, seed_v /*hint*/);
-        ico_v->info() = SEED_VERTEX;
+        ico_v->type() = AW3i::Vertex_type:: SEED_VERTEX;
       }
     }
 
@@ -587,26 +565,26 @@ private:
     }
 
 #ifdef CGAL_AW3_DEBUG_INITIALIZATION
-    std::cout << m_dt.number_of_vertices() - 8 /*bbox*/ << " vertice(s) due to seeds" << std::endl;
+    std::cout << m_tr.number_of_vertices() - 8 /*bbox*/ << " vertice(s) due to seeds" << std::endl;
 #endif
 
     for(Vertex_handle seed_v : seed_vs)
     {
       std::vector<Cell_handle> inc_cells;
       inc_cells.reserve(64);
-      m_dt.incident_cells(seed_v, std::back_inserter(inc_cells));
+      m_tr.incident_cells(seed_v, std::back_inserter(inc_cells));
       for(Cell_handle ch : inc_cells)
-        ch->info().is_outside = cavity_cell_outside_tag(ch);
+        ch->is_outside() = cavity_cell_outside_tag(ch);
     }
 
     // Might as well go through the full triangulation since only seeds should have been inserted
-    for(Cell_handle ch : m_dt.all_cell_handles())
+    for(Cell_handle ch : m_tr.all_cell_handles())
     {
-      if(!ch->info().is_outside)
+      if(!ch->is_outside())
         continue;
 
       // When the algorithm starts from a manually dug hole, infinite cells are tagged "inside"
-      CGAL_assertion(!m_dt.is_infinite(ch));
+      CGAL_assertion(!m_tr.is_infinite(ch));
 
       for(int i=0; i<4; ++i)
         push_facet(std::make_pair(ch, i));
@@ -627,17 +605,17 @@ private:
   // init queue with all convex hull facets
   bool initialize_from_infinity()
   {
-    for(Cell_handle ch : m_dt.all_cell_handles())
+    for(Cell_handle ch : m_tr.all_cell_handles())
     {
-      if(m_dt.is_infinite(ch))
+      if(m_tr.is_infinite(ch))
       {
-        ch->info().is_outside = true;
+        ch->is_outside() = true;
-        const int inf_index = ch->index(m_dt.infinite_vertex());
+        const int inf_index = ch->index(m_tr.infinite_vertex());
         push_facet(std::make_pair(ch, inf_index));
       }
       else
       {
-        ch->info().is_outside = false;
+        ch->is_outside() = false;
       }
     }
 
@@ -659,13 +637,13 @@ public:
 
     clear(output_mesh);
 
-    CGAL_assertion_code(for(auto cit=m_dt.finite_cells_begin(), cend=m_dt.finite_cells_end(); cit!=cend; ++cit))
+    CGAL_assertion_code(for(auto cit=m_tr.finite_cells_begin(), cend=m_tr.finite_cells_end(); cit!=cend; ++cit))
     CGAL_assertion(cit->tds_data().is_clear());
 
-    for(auto cit=m_dt.finite_cells_begin(), cend=m_dt.finite_cells_end(); cit!=cend; ++cit)
+    for(auto cit=m_tr.finite_cells_begin(), cend=m_tr.finite_cells_end(); cit!=cend; ++cit)
     {
       Cell_handle seed = cit;
-      if(seed->info().is_outside || seed->tds_data().processed())
+      if(seed->is_outside() || seed->tds_data().processed())
         continue;
 
       std::queue<Cell_handle> to_visit;
@@ -678,7 +656,7 @@ public:
       while(!to_visit.empty())
       {
         const Cell_handle cell = to_visit.front();
-        CGAL_assertion(!cell->info().is_outside && !m_dt.is_infinite(cell));
+        CGAL_assertion(!cell->is_outside() && !m_tr.is_infinite(cell));
 
         to_visit.pop();
 
@@ -690,17 +668,17 @@ public:
         for(int fid=0; fid<4; ++fid)
         {
           const Cell_handle neighbor = cell->neighbor(fid);
-          if(neighbor->info().is_outside)
+          if(neighbor->is_outside())
           {
             // There shouldn't be any artificial vertex on the inside/outside boundary
             // (past initialization)
-//            CGAL_assertion(cell->vertex((fid + 1)&3)->info() == DEFAULT);
+//            CGAL_assertion(cell->vertex((fid + 1)&3)->type() == AW3i::Vertex_type:: DEFAULT);
-//            CGAL_assertion(cell->vertex((fid + 2)&3)->info() == DEFAULT);
+//            CGAL_assertion(cell->vertex((fid + 2)&3)->type() == AW3i::Vertex_type:: DEFAULT);
-//            CGAL_assertion(cell->vertex((fid + 3)&3)->info() == DEFAULT);
+//            CGAL_assertion(cell->vertex((fid + 3)&3)->type() == AW3i::Vertex_type:: DEFAULT);
 
-            points.push_back(m_dt.point(cell, Dt::vertex_triple_index(fid, 0)));
+            points.push_back(m_tr.point(cell, Triangulation::vertex_triple_index(fid, 0)));
-            points.push_back(m_dt.point(cell, Dt::vertex_triple_index(fid, 1)));
+            points.push_back(m_tr.point(cell, Triangulation::vertex_triple_index(fid, 1)));
-            points.push_back(m_dt.point(cell, Dt::vertex_triple_index(fid, 2)));
+            points.push_back(m_tr.point(cell, Triangulation::vertex_triple_index(fid, 2)));
             faces.push_back({idx, idx + 1, idx + 2});
             idx += 3;
           }
@@ -722,7 +700,7 @@ public:
       CGAL_assertion(is_closed(output_mesh));
     }
 
-    for(auto cit=m_dt.finite_cells_begin(), cend=m_dt.finite_cells_end(); cit!=cend; ++cit)
+    for(auto cit=m_tr.finite_cells_begin(), cend=m_tr.finite_cells_end(); cit!=cend; ++cit)
       cit->tds_data().clear();
 
     CGAL_postcondition(!is_empty(output_mesh));
@@ -742,7 +720,7 @@ public:
     std::cout << "> Extract wrap... ()" << std::endl;
 #endif
 
-    CGAL_assertion_code(for(Vertex_handle v : m_dt.finite_vertex_handles()))
+    CGAL_assertion_code(for(Vertex_handle v : m_tr.finite_vertex_handles()))
     CGAL_assertion(!is_non_manifold(v));
 
     clear(output_mesh);
@@ -754,26 +732,26 @@ public:
     std::unordered_map<Vertex_handle, std::size_t> vertex_to_id;
     std::size_t nv = 0;
 
-    for(auto fit=m_dt.finite_facets_begin(), fend=m_dt.finite_facets_end(); fit!=fend; ++fit)
+    for(auto fit=m_tr.finite_facets_begin(), fend=m_tr.finite_facets_end(); fit!=fend; ++fit)
     {
       Facet f = *fit;
-      if(!f.first->info().is_outside)
+      if(!f.first->is_outside())
-        f = m_dt.mirror_facet(f);
+        f = m_tr.mirror_facet(f);
 
       const Cell_handle c = f.first;
       const int s = f.second;
       const Cell_handle nh = c->neighbor(s);
-      if(c->info().is_outside == nh->info().is_outside)
+      if(c->is_outside() == nh->is_outside())
         continue;
 
       std::array<std::size_t, 3> ids;
       for(int pos=0; pos<3; ++pos)
       {
-        Vertex_handle vh = c->vertex(Dt::vertex_triple_index(s, pos));
+        Vertex_handle vh = c->vertex(Triangulation::vertex_triple_index(s, pos));
         auto insertion_res = vertex_to_id.emplace(vh, nv);
         if(insertion_res.second) // successful insertion, never-seen-before vertex
         {
-          points.push_back(m_dt.point(vh));
+          points.push_back(m_tr.point(vh));
           ++nv;
         }
 
@@ -817,14 +795,14 @@ public:
 private:
   bool is_traversable(const Facet& f) const
   {
-    return less_squared_radius_of_min_empty_sphere(m_sq_alpha, f, m_dt);
+    return less_squared_radius_of_min_empty_sphere(m_sq_alpha, f, m_tr);
   }
 
   bool compute_steiner_point(const Cell_handle ch,
                              const Cell_handle neighbor,
                              Point_3& steiner_point) const
   {
-    CGAL_precondition(!m_dt.is_infinite(neighbor));
+    CGAL_precondition(!m_tr.is_infinite(neighbor));
 
     typename Geom_traits::Construct_ball_3 ball = geom_traits().construct_ball_3_object();
     typename Geom_traits::Construct_vector_3 vector = geom_traits().construct_vector_3_object();
@@ -920,7 +898,7 @@ private:
   // e.g. from DT3
   Facet_queue_status facet_status(const Facet& f) const
   {
-    CGAL_precondition(!m_dt.is_infinite(f));
+    CGAL_precondition(!m_tr.is_infinite(f));
 
 #ifdef CGAL_AW3_DEBUG_FACET_STATUS
     std::cout << "facet status: "
@@ -933,10 +911,10 @@ private:
     const Cell_handle ch = f.first;
     const int id = f.second;
     const Cell_handle nh = ch->neighbor(id);
-    if(m_dt.is_infinite(nh))
+    if(m_tr.is_infinite(nh))
       return TRAVERSABLE;
 
-    if(nh->info().is_outside)
+    if(nh->is_outside())
     {
 #ifdef CGAL_AW3_DEBUG_FACET_STATUS
       std::cout << "Neighbor already outside" << std::endl;
@@ -947,8 +925,9 @@ private:
     // push if facet is connected to artificial vertices
     for(int i=0; i<3; ++i)
     {
-      const Vertex_handle vh = ch->vertex(Dt::vertex_triple_index(id, i));
+      const Vertex_handle vh = ch->vertex(Triangulation::vertex_triple_index(id, i));
-      if(vh->info() == BBOX_VERTEX || vh->info() == SEED_VERTEX)
+      if(vh->type() == AW3i::Vertex_type:: BBOX_VERTEX ||
+         vh->type() == AW3i::Vertex_type:: SEED_VERTEX)
       {
 #ifdef CGAL_AW3_DEBUG_FACET_STATUS
         std::cout << "artificial facet due to artificial vertex #" << i << std::endl;
@@ -974,7 +953,7 @@ private:
 
   bool push_facet(const Facet& f)
   {
-    CGAL_precondition(f.first->info().is_outside);
+    CGAL_precondition(f.first->is_outside());
 
     // skip if f is already in queue
     if(m_queue.contains_with_bounds_check(Gate(f)))
@@ -986,9 +965,9 @@ private:
 
     const Cell_handle ch = f.first;
     const int id = f.second;
-    const Point_3& p0 = m_dt.point(ch, (id+1)&3);
+    const Point_3& p0 = m_tr.point(ch, (id+1)&3);
-    const Point_3& p1 = m_dt.point(ch, (id+2)&3);
+    const Point_3& p1 = m_tr.point(ch, (id+2)&3);
-    const Point_3& p2 = m_dt.point(ch, (id+3)&3);
+    const Point_3& p2 = m_tr.point(ch, (id+3)&3);
 
     // @todo should prob be the real value we compare to alpha instead of squared_radius
     const FT sqr = geom_traits().compute_squared_radius_3_object()(p0, p1, p2);
@@ -1022,7 +1001,7 @@ private:
     m_offset = FT(offset);
     m_sq_offset = square(m_offset);
 
-    m_dt.clear();
+    m_tr.clear();
     m_queue.clear();
 
     insert_bbox_corners();
@@ -1052,7 +1031,7 @@ private:
       // const& to something that will be popped, but safe as `ch` && `id` are extracted before the pop
       const Gate& gate = m_queue.top();
       const Facet& f = gate.facet();
-      CGAL_precondition(!m_dt.is_infinite(f));
+      CGAL_precondition(!m_tr.is_infinite(f));
 
       const Cell_handle ch = f.first;
       const int id = f.second;
@@ -1060,11 +1039,11 @@ private:
 
 #ifdef CGAL_AW3_DEBUG_QUEUE
       static int fid = 0;
-      std::cout << m_dt.number_of_vertices() << " DT vertices" << std::endl;
+      std::cout << m_tr.number_of_vertices() << " DT vertices" << std::endl;
       std::cout << m_queue.size() << " facets in the queue" << std::endl;
       std::cout << "Face " << fid++ << "\n"
-                << "c = " << &*ch << " (" << m_dt.is_infinite(ch) << "), n = " << &*neighbor << " (" << m_dt.is_infinite(neighbor) << ")" << "\n"
+                << "c = " << &*ch << " (" << m_tr.is_infinite(ch) << "), n = " << &*neighbor << " (" << m_tr.is_infinite(neighbor) << ")" << "\n"
-                << m_dt.point(ch, (id+1)&3) << "\n" << m_dt.point(ch, (id+2)&3) << "\n" << m_dt.point(ch, (id+3)&3) << std::endl;
+                << m_tr.point(ch, (id+1)&3) << "\n" << m_tr.point(ch, (id+2)&3) << "\n" << m_tr.point(ch, (id+3)&3) << std::endl;
       std::cout << "Priority: " << gate.priority() << std::endl;
 #endif
 
@@ -1080,13 +1059,13 @@ private:
       std::string face_name = "results/steps/face_" + std::to_string(static_cast<int>(i++)) + ".xyz";
       std::ofstream face_out(face_name);
       face_out.precision(17);
-      face_out << "3\n" << m_dt.point(ch, (id+1)&3) << "\n" << m_dt.point(ch, (id+2)&3) << "\n" << m_dt.point(ch, (id+3)&3) << std::endl;
+      face_out << "3\n" << m_tr.point(ch, (id+1)&3) << "\n" << m_tr.point(ch, (id+2)&3) << "\n" << m_tr.point(ch, (id+3)&3) << std::endl;
       face_out.close();
 #endif
 
-      if(m_dt.is_infinite(neighbor))
+      if(m_tr.is_infinite(neighbor))
       {
-        neighbor->info().is_outside = true;
+        neighbor->is_outside() = true;
         continue;
       }
 
@@ -1100,14 +1079,16 @@ private:
         // locate cells that are going to be destroyed and remove their facet from the queue
         int li, lj = 0;
         Locate_type lt;
-        const Cell_handle conflict_cell = m_dt.locate(steiner_point, lt, li, lj, neighbor);
+        const Cell_handle conflict_cell = m_tr.locate(steiner_point, lt, li, lj, neighbor);
-        CGAL_assertion(lt != Dt::VERTEX);
+        CGAL_assertion(lt != Triangulation::VERTEX);
 
+        // Using small vectors like in Triangulation_3 does not bring any runtime improvement
         std::vector<Facet> boundary_facets;
         std::vector<Cell_handle> conflict_zone;
         boundary_facets.reserve(32);
         conflict_zone.reserve(32);
-        m_dt.find_conflicts(steiner_point, conflict_cell,
+
+        m_tr.find_conflicts(steiner_point, conflict_cell,
                             std::back_inserter(boundary_facets),
                             std::back_inserter(conflict_zone));
 
@@ -1125,7 +1106,7 @@ private:
 
         for(const Facet& f : boundary_facets)
         {
-          const Facet mf = m_dt.mirror_facet(f); // boundary facets have incident cells in the CZ
+          const Facet mf = m_tr.mirror_facet(f); // boundary facets have incident cells in the CZ
           if(m_queue.contains_with_bounds_check(Gate(mf)))
             m_queue.erase(Gate(mf));
         }
@@ -1133,18 +1114,20 @@ private:
         visitor.before_Steiner_point_insertion(*this, steiner_point);
 
         // Actual insertion of the Steiner point
-        Vertex_handle vh = m_dt.insert(steiner_point, lt, conflict_cell, li, lj);
+        // We could use TDS functions to avoid recomputing the conflict zone, but in practice
-        vh->info() = DEFAULT;
+        // it does not bring any runtime improvements
+        Vertex_handle vh = m_tr.insert(steiner_point, lt, conflict_cell, li, lj);
+        vh->type() = AW3i::Vertex_type:: DEFAULT;
 
         visitor.after_Steiner_point_insertion(*this, vh);
 
         std::vector<Cell_handle> new_cells;
         new_cells.reserve(32);
-        m_dt.incident_cells(vh, std::back_inserter(new_cells));
+        m_tr.incident_cells(vh, std::back_inserter(new_cells));
         for(const Cell_handle& ch : new_cells)
         {
           // std::cout << "new cell has time stamp " << ch->time_stamp() << std::endl;
-          ch->info().is_outside = m_dt.is_infinite(ch);
+          ch->is_outside() = m_tr.is_infinite(ch);
         }
 
         // Push all new boundary facets to the queue.
@@ -1156,25 +1139,25 @@ private:
         {
           for(int i=0; i<4; ++i)
           {
-            if(m_dt.is_infinite(ch, i))
+            if(m_tr.is_infinite(ch, i))
               continue;
 
             const Cell_handle nh = ch->neighbor(i);
-            if(nh->info().is_outside == ch->info().is_outside) // not on the boundary
+            if(nh->is_outside() == ch->is_outside()) // not on the boundary
               continue;
 
             const Facet boundary_f = std::make_pair(ch, i);
-            if(ch->info().is_outside)
+            if(ch->is_outside())
               push_facet(boundary_f);
             else
-              push_facet(m_dt.mirror_facet(boundary_f));
+              push_facet(m_tr.mirror_facet(boundary_f));
           }
         }
       }
       else
       {
         // tag neighbor as OUTSIDE
-        neighbor->info().is_outside = true;
+        neighbor->is_outside() = true;
 
         // for each finite facet of neighbor, push it to the queue
         for(int i=0; i<4; ++i)
@@ -1188,10 +1171,10 @@ private:
     visitor.on_flood_fill_end(*this);
 
     // Check that no useful facet has been ignored
-    CGAL_postcondition_code(for(auto fit=m_dt.finite_facets_begin(), fend=m_dt.finite_facets_end(); fit!=fend; ++fit) {)
+    CGAL_postcondition_code(for(auto fit=m_tr.finite_facets_begin(), fend=m_tr.finite_facets_end(); fit!=fend; ++fit) {)
-    CGAL_postcondition_code(  if(fit->first->info().is_outside == fit->first->neighbor(fit->second)->info().is_outside) continue;)
+    CGAL_postcondition_code(  if(fit->first->is_outside() == fit->first->neighbor(fit->second)->is_outside()) continue;)
     CGAL_postcondition_code(  Facet f = *fit;)
-    CGAL_postcondition_code(  if(!fit->first->info().is_outside) f = m_dt.mirror_facet(f);)
+    CGAL_postcondition_code(  if(!fit->first->is_outside()) f = m_tr.mirror_facet(f);)
     CGAL_postcondition(       facet_status(f) == IRRELEVANT);
     CGAL_postcondition_code(})
   }
@@ -1199,13 +1182,13 @@ private:
 private:
   bool is_non_manifold(Vertex_handle v) const
   {
-    CGAL_precondition(!m_dt.is_infinite(v));
+    CGAL_precondition(!m_tr.is_infinite(v));
 
     bool is_non_manifold = false;
 
     std::vector<Cell_handle> inc_cells;
     inc_cells.reserve(64);
-    m_dt.incident_cells(v, std::back_inserter(inc_cells));
+    m_tr.incident_cells(v, std::back_inserter(inc_cells));
 
     // Flood one inside and outside CC.
     // Process both an inside and an outside CC to also detect edge pinching.
@@ -1218,7 +1201,7 @@ private:
     for(Cell_handle ic : inc_cells)
     {
       ic->tds_data().clear();
-      if(ic->info().is_outside)
+      if(ic->is_outside())
         outside_start = ic;
       else if(inside_start == Cell_handle())
         inside_start = ic;
@@ -1253,7 +1236,7 @@ private:
         CGAL_assertion(neigh_c->has_vertex(v));
 
         if(neigh_c->tds_data().processed() ||
-           neigh_c->info().is_outside != curr_c->info().is_outside) // do not cross the boundary
+           neigh_c->is_outside() != curr_c->is_outside()) // do not cross the boundary
           continue;
 
         cells_to_visit.push(neigh_c);
@@ -1278,7 +1261,7 @@ private:
 
   bool is_non_manifold(Cell_handle c) const
   {
-    CGAL_precondition(!m_dt.is_infinite(c));
+    CGAL_precondition(!m_tr.is_infinite(c));
 
     for(int i=0; i<4; ++i)
     {
@@ -1294,7 +1277,7 @@ private:
   {
     // Not the best complexity, but it's not important: this function is purely for information
     // Better complexity --> see PMP::non_manifold_vertices + throw
-    for(const Vertex_handle v : m_dt.finite_vertex_handles())
+    for(const Vertex_handle v : m_tr.finite_vertex_handles())
       if(is_non_manifold(v))
         return true;
 
@@ -1307,18 +1290,18 @@ private:
   bool remove_bbox_vertices()
   {
     bool do_remove = true;
-    auto vit = m_dt.finite_vertices_begin();
+    auto vit = m_tr.finite_vertices_begin();
     for(std::size_t i=0; i<8; ++i)
     {
       Vertex_handle v = vit++;
 
       std::vector<Cell_handle> inc_cells;
       inc_cells.reserve(64);
-      m_dt.finite_incident_cells(v, std::back_inserter(inc_cells));
+      m_tr.finite_incident_cells(v, std::back_inserter(inc_cells));
 
       for(Cell_handle c : inc_cells)
       {
-        if(!c->info().is_outside)
+        if(!c->is_outside())
         {
           do_remove = false;
           break;
@@ -1333,11 +1316,11 @@ private:
     if(!do_remove)
       return false;
 
-    vit = m_dt.finite_vertices_begin();
+    vit = m_tr.finite_vertices_begin();
     for(std::size_t i=0; i<8; ++i)
     {
       Vertex_handle v = vit++;
-      m_dt.remove(v);
+      m_tr.remove(v);
     }
 
     return true;
@@ -1355,7 +1338,7 @@ public:
 //    remove_bbox_vertices();
 
     std::stack<Vertex_handle> non_manifold_vertices; // @todo sort somehow?
-    for(Vertex_handle v : m_dt.finite_vertex_handles())
+    for(Vertex_handle v : m_tr.finite_vertex_handles())
     {
       if(is_non_manifold(v))
         non_manifold_vertices.push(v);
@@ -1365,15 +1348,20 @@ public:
     auto has_artificial_vertex = [](Cell_handle c) -> bool
     {
       for(int i=0; i<4; ++i)
-        if(c->vertex(i)->info() == BBOX_VERTEX || c->vertex(i)->info() == SEED_VERTEX)
+      {
+        if(c->vertex(i)->type() == AW3i::Vertex_type:: BBOX_VERTEX ||
+           c->vertex(i)->type() == AW3i::Vertex_type:: SEED_VERTEX)
+        {
           return true;
+        }
+      }
 
       return false;
     };
 
     auto is_on_boundary = [](Cell_handle c, int i) -> bool
     {
-      return (c->info().is_outside != c->neighbor(i)->info().is_outside);
+      return (c->is_outside() != c->neighbor(i)->is_outside());
     };
 
     auto count_boundary_facets = [&](Cell_handle c, Vertex_handle v) -> int
@@ -1395,17 +1383,17 @@ public:
 //    auto sq_circumradius = [&](Cell_handle c) -> FT
 //    {
 //      const Point_3& cc = circumcenter(c);
-//      return geom_traits().compute_squared_distance_3_object()(m_dt.point(c, 0), cc);
+//      return geom_traits().compute_squared_distance_3_object()(m_tr.point(c, 0), cc);
 //    };
 
     auto sq_longest_edge = [&](Cell_handle c) -> FT
     {
-      return (std::max)({ squared_distance(m_dt.point(c, 0), m_dt.point(c, 1)),
+      return (std::max)({ squared_distance(m_tr.point(c, 0), m_tr.point(c, 1)),
-                          squared_distance(m_dt.point(c, 0), m_dt.point(c, 2)),
+                          squared_distance(m_tr.point(c, 0), m_tr.point(c, 2)),
-                          squared_distance(m_dt.point(c, 0), m_dt.point(c, 3)),
+                          squared_distance(m_tr.point(c, 0), m_tr.point(c, 3)),
-                          squared_distance(m_dt.point(c, 1), m_dt.point(c, 2)),
+                          squared_distance(m_tr.point(c, 1), m_tr.point(c, 2)),
-                          squared_distance(m_dt.point(c, 3), m_dt.point(c, 3)),
+                          squared_distance(m_tr.point(c, 3), m_tr.point(c, 3)),
-                          squared_distance(m_dt.point(c, 2), m_dt.point(c, 3)) });
+                          squared_distance(m_tr.point(c, 2), m_tr.point(c, 3)) });
     };
 
 #ifdef CGAL_AW3_DEBUG_MANIFOLDNESS
@@ -1450,7 +1438,7 @@ public:
 
       std::vector<Cell_handle> inc_cells;
       inc_cells.reserve(64);
-      m_dt.finite_incident_cells(v, std::back_inserter(inc_cells));
+      m_tr.finite_incident_cells(v, std::back_inserter(inc_cells));
 
 #define CGAL_AW3_USE_BRUTE_FORCE_MUTABLE_PRIORITY_QUEUE
 #ifndef CGAL_AW3_USE_BRUTE_FORCE_MUTABLE_PRIORITY_QUEUE
@@ -1464,10 +1452,10 @@ public:
         std::sort(cit, cend, comparer);
 #endif
         Cell_handle ic = *cit;
-        CGAL_assertion(!m_dt.is_infinite(ic));
+        CGAL_assertion(!m_tr.is_infinite(ic));
 
         // This is where new material is added
-        ic->info().is_outside = false;
+        ic->is_outside() = false;
 
 #ifdef CGAL_AW3_DEBUG_DUMP_EVERY_STEP
         static int i = 0;
@@ -1484,14 +1472,14 @@ public:
 
       std::vector<Vertex_handle> adj_vertices;
       adj_vertices.reserve(64);
-      m_dt.finite_adjacent_vertices(v, std::back_inserter(adj_vertices));
+      m_tr.finite_adjacent_vertices(v, std::back_inserter(adj_vertices));
 
       for(Vertex_handle nv : adj_vertices)
         if(is_non_manifold(nv))
           non_manifold_vertices.push(nv);
     }
 
-    CGAL_assertion_code(for(Vertex_handle v : m_dt.finite_vertex_handles()))
+    CGAL_assertion_code(for(Vertex_handle v : m_tr.finite_vertex_handles()))
     CGAL_assertion(!is_non_manifold(v));
   }
 
@@ -1508,12 +1496,12 @@ private:
       const Facet& current_f = current_gate.facet();
       const Cell_handle ch = current_f.first;
       const int id = current_f.second;
-      const Point_3& p0 = m_dt.point(ch, (id+1)&3);
+      const Point_3& p0 = m_tr.point(ch, (id+1)&3);
-      const Point_3& p1 = m_dt.point(ch, (id+2)&3);
+      const Point_3& p1 = m_tr.point(ch, (id+2)&3);
-      const Point_3& p2 = m_dt.point(ch, (id+3)&3);
+      const Point_3& p2 = m_tr.point(ch, (id+3)&3);
       const FT sqr = geom_traits().compute_squared_radius_3_object()(p0, p1, p2);
 
-      std::cout << "At Facet with VID " << get(Gate_ID_PM<Dt>(), current_gate)  << std::endl;
+      std::cout << "At Facet with VID " << get(Gate_ID_PM<Triangulation>(), current_gate)  << std::endl;
 
       if(current_gate.priority() != sqr)
         std::cerr << "Error: facet in queue has wrong priority" << std::endl;
@@ -1546,13 +1534,13 @@ private:
     std::size_t nv = 0;
     std::size_t nf = 0;
 
-    for(auto fit=m_dt.finite_facets_begin(), fend=m_dt.finite_facets_end(); fit!=fend; ++fit)
+    for(auto fit=m_tr.finite_facets_begin(), fend=m_tr.finite_facets_end(); fit!=fend; ++fit)
     {
       Cell_handle c = fit->first;
       int s = fit->second;
 
       Cell_handle nc = c->neighbor(s);
-      if(only_boundary_faces && (c->info().is_outside == nc->info().is_outside))
+      if(only_boundary_faces && (c->is_outside() == nc->is_outside()))
         continue;
 
       std::array<std::size_t, 3> ids;
@@ -1562,7 +1550,7 @@ private:
         auto insertion_res = vertex_to_id.emplace(v, nv);
         if(insertion_res.second)
         {
-          vertices_ss << m_dt.point(v) << "\n";
+          vertices_ss << m_tr.point(v) << "\n";
           ++nv;
         }
 

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_AABB_geom_traits.h

@@ -36,24 +36,24 @@ struct Tetrahedron_with_outside_info
   using Triangle_3 = typename Kernel::Triangle_3;
 
   template <typename CellHandle>
-  Tetrahedron_with_outside_info(const CellHandle ch, const K& k)
+  Tetrahedron_with_outside_info(const CellHandle c, const K& k)
   {
     typename K::Construct_bbox_3 bbox = k.construct_bbox_3_object();
     typename K::Construct_tetrahedron_3 tetrahedron = k.construct_tetrahedron_3_object();
     typename K::Construct_triangle_3 triangle = k.construct_triangle_3_object();
 
-    m_tet = tetrahedron(ch->vertex(0)->point(), ch->vertex(1)->point(),
+    m_tet = tetrahedron(c->vertex(0)->point(), c->vertex(1)->point(),
-                        ch->vertex(2)->point(), ch->vertex(3)->point());
+                        c->vertex(2)->point(), c->vertex(3)->point());
     m_bbox = bbox(m_tet);
 
     for(int i=0; i<4; ++i)
     {
-      if(ch->neighbor(i)->info().is_outside)
+      if(c->neighbor(i)->is_outside())
         m_b.set(i, true);
 
-      m_triangles[i] = triangle(ch->vertex((i+1)& 3)->point(),
+      m_triangles[i] = triangle(c->vertex((i+1)& 3)->point(),
-                                ch->vertex((i+2)& 3)->point(),
+                                c->vertex((i+2)& 3)->point(),
-                                ch->vertex((i+3)& 3)->point());
+                                c->vertex((i+3)& 3)->point());
       m_tbox[i] = bbox(m_triangles[i]);
     }
   }

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_cell_base_3.h

@@ -0,0 +1,97 @@
+// Copyright (c) 2019-2023 Google LLC (USA).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org).
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
+//
+// Author(s)     : Mael Rouxel-Labbé
+
+#ifndef CGAL_ALPHA_WRAP_TRIANGULATION_CELL_BASE_3_H
+#define CGAL_ALPHA_WRAP_TRIANGULATION_CELL_BASE_3_H
+
+#include <CGAL/license/Alpha_wrap_3.h>
+
+#include <CGAL/Delaunay_triangulation_cell_base_with_circumcenter_3.h>
+
+namespace CGAL {
+namespace Alpha_wraps_3 {
+namespace internal {
+
+template < typename GT,
+           typename Cb = CGAL::Delaunay_triangulation_cell_base_with_circumcenter_3<GT> >
+class Alpha_wrap_triangulation_cell_base_3
+  : public Cb
+{
+private:
+  bool outside = false;
+
+public:
+  typedef typename Cb::Vertex_handle                   Vertex_handle;
+  typedef typename Cb::Cell_handle                     Cell_handle;
+
+  template < typename TDS2 >
+  struct Rebind_TDS
+  {
+    using Cb2 = typename Cb::template Rebind_TDS<TDS2>::Other;
+    using Other = Alpha_wrap_triangulation_cell_base_3<GT, Cb2>;
+  };
+
+  Alpha_wrap_triangulation_cell_base_3()
+    : Cb()
+  {}
+
+  Alpha_wrap_triangulation_cell_base_3(Vertex_handle v0, Vertex_handle v1,
+                                       Vertex_handle v2, Vertex_handle v3)
+    : Cb(v0, v1, v2, v3)
+  {}
+
+  Alpha_wrap_triangulation_cell_base_3(Vertex_handle v0, Vertex_handle v1,
+                                       Vertex_handle v2, Vertex_handle v3,
+                                       Cell_handle   n0, Cell_handle   n1,
+                                       Cell_handle   n2, Cell_handle   n3)
+    : Cb(v0, v1, v2, v3, n0, n1, n2, n3)
+  {}
+
+  bool is_outside() const { return outside; }
+  bool& is_outside() { return outside; }
+};
+
+template <typename Cb>
+class Cell_base_with_timestamp
+  : public Cb
+{
+  std::size_t time_stamp_;
+
+public:
+  using Has_timestamp = CGAL::Tag_true;
+
+  template <class TDS>
+  struct Rebind_TDS
+  {
+    using Cb2 = typename Cb::template Rebind_TDS<TDS>::Other;
+    using Other = Cell_base_with_timestamp<Cb2>;
+  };
+
+public:
+  template <typename... Args>
+  Cell_base_with_timestamp(const Args&... args)
+    : Cb(args...), time_stamp_(-1)
+  { }
+
+  Cell_base_with_timestamp(const Cell_base_with_timestamp& other)
+    : Cb(other), time_stamp_(other.time_stamp_)
+  { }
+
+public:
+  std::size_t time_stamp() const { return time_stamp_; }
+  void set_time_stamp(const std::size_t& ts) { time_stamp_ = ts; }
+};
+
+} // namespace internal
+} // namespace Alpha_wraps_3
+} // namespace CGAL
+
+#endif // CGAL_ALPHA_WRAP_TRIANGULATION_CELL_BASE_3_H

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_vertex_base_3.h

@@ -0,0 +1,71 @@
+// Copyright (c) 2019-2023 Google LLC (USA).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org).
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
+//
+// Author(s)     : Mael Rouxel-Labbé
+
+#ifndef CGAL_ALPHA_WRAP_TRIANGULATION_VERTEX_BASE_3_H
+#define CGAL_ALPHA_WRAP_TRIANGULATION_VERTEX_BASE_3_H
+
+#include <CGAL/license/Alpha_wrap_3.h>
+
+#include <CGAL/Triangulation_vertex_base_3.h>
+
+namespace CGAL {
+namespace Alpha_wraps_3 {
+namespace internal {
+
+enum class Vertex_type
+{
+  DEFAULT = 0,
+  BBOX_VERTEX,
+  SEED_VERTEX
+};
+
+template <typename GT,
+          typename Vb = Triangulation_vertex_base_3<GT> >
+class Alpha_wrap_triangulation_vertex_base_3
+  : public Vb
+{
+private:
+  Vertex_type vertex_type = Vertex_type::DEFAULT;
+
+public:
+  using Cell_handle = typename Vb::Cell_handle;
+  using Point = typename Vb::Point;
+
+  template <typename TDS2>
+  struct Rebind_TDS
+  {
+    using Vb2 = typename Vb::template Rebind_TDS<TDS2>::Other;
+    using Other = Alpha_wrap_triangulation_vertex_base_3<GT, Vb2>;
+  };
+
+public:
+  Alpha_wrap_triangulation_vertex_base_3()
+    : Vb() {}
+
+  Alpha_wrap_triangulation_vertex_base_3(const Point& p)
+    : Vb(p) {}
+
+  Alpha_wrap_triangulation_vertex_base_3(const Point& p, Cell_handle c)
+    : Vb(p, c) {}
+
+  Alpha_wrap_triangulation_vertex_base_3(Cell_handle c)
+    : Vb(c) {}
+
+public:
+  const Vertex_type& type() const { return vertex_type; }
+  Vertex_type& type() { return vertex_type; }
+};
+
+} // namespace internal
+} // namespace Alpha_wraps_3
+} // namespace CGAL
+
+#endif // CGAL_ALPHA_WRAP_TRIANGULATION_VERTEX_BASE_3_H

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_2.h

@@ -46,7 +46,7 @@ ag.incident_edges(ag.infinite_vertex());
 ag.incident_edges(ag.infinite_vertex(), f);
 \endcode
 
-\cgalModels `DelaunayGraph_2`
+\cgalModels{DelaunayGraph_2}
 
 \sa `CGAL::Apollonius_graph_traits_2<K,Method_tag>`
 \sa `CGAL::Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_filtered_traits_2.h

@@ -37,7 +37,7 @@ The default values for the template parameters are as follows:
 `FK = CGAL::Simple_cartesian<CGAL::Interval_nt<false> >`,
 `FM = CM`.
 
-\cgalModels `ApolloniusGraphTraits_2`
+\cgalModels{ApolloniusGraphTraits_2}
 
 \sa `Kernel`
 \sa `ApolloniusGraphTraits_2`

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_hierarchy_vertex_base_2.h

@@ -11,7 +11,7 @@ vertex base required by the
 `Apollonius_graph_hierarchy_vertex_base_2` is templated by a class `Agvb` which must be a model
 of the `ApolloniusGraphVertexBase_2` concept.
 
-\cgalModels `ApolloniusGraphHierarchyVertexBase_2`
+\cgalModels{ApolloniusGraphHierarchyVertexBase_2}
 
 \sa `CGAL::Apollonius_graph_vertex_base_2<Gt,StoreHidden>`
 \sa `CGAL::Triangulation_data_structure_2<Vb,Fb>`

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_traits_2.h

@@ -20,7 +20,7 @@ default value for `Method_tag` is `CGAL::Integral_domain_without_division_tag`.
 The way the predicates are evaluated is discussed in
 \cgalCite{cgal:ke-ppawv-02}, \cgalCite{cgal:ke-rctac-03}.
 
-\cgalModels `ApolloniusGraphTraits_2`
+\cgalModels{ApolloniusGraphTraits_2}
 
 \sa `CGAL::Apollonius_graph_2<Gt,Agds>`
 \sa `CGAL::Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_vertex_base_2.h

@@ -24,7 +24,7 @@ discarded. By default `StoreHidden` is set to `true`.
 By default this parameter is
 instantiated by `Triangulation_ds_vertex_base_2<>`.
 
-\cgalModels `ApolloniusGraphVertexBase_2`
+\cgalModels{ApolloniusGraphVertexBase_2}
 
 \sa `CGAL::Triangulation_data_structure_2<Vb,Fb>`
 \sa `CGAL::Apollonius_graph_hierarchy_vertex_base_2<Gt>`

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_site_2.h

@@ -8,7 +8,7 @@ The class `Apollonius_site_2` is a model for the concept
 `ApolloniusSite_2`. It is parametrized by a template parameter
 `K` which must be a model of the `Kernel` concept.
 
-\cgalModels `ApolloniusSite_2`
+\cgalModels{ApolloniusSite_2}
 
 \cgalHeading{Types}
 

Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphDataStructure_2.h

@@ -27,7 +27,9 @@ We only describe the additional requirements with respect to the
 
 \cgalRefines{TriangulationDataStructure_2}
 
-\cgalHasModel `CGAL::Triangulation_data_structure_2<Vb,Fb>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Triangulation_data_structure_2<Vb,Fb>}
+\cgalHasModelsEnd
 
 \sa `TriangulationDataStructure_2`
 \sa `ApolloniusGraphVertexBase_2`

Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphHierarchyVertexBase_2.h

@@ -19,7 +19,9 @@ next and previous level graphs.
 `ApolloniusGraphHierarchyVertexBase_2` does not introduce any
 types in addition to those of `ApolloniusGraphVertexBase_2`.
 
-\cgalHasModel `CGAL::Apollonius_graph_hierarchy_vertex_base_2<CGAL::Apollonius_graph_vertex_base_2<Gt,StoreHidden> >`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Apollonius_graph_hierarchy_vertex_base_2<CGAL::Apollonius_graph_vertex_base_2<Gt,StoreHidden> >}
+\cgalHasModelsEnd
 
 \sa `ApolloniusGraphDataStructure_2`
 \sa `CGAL::Apollonius_graph_hierarchy_2<Gt,Agds>`

Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphTraits_2.h

@@ -12,8 +12,10 @@ it provides a type `Site_2`, which must be a model of the concept
 constructions for sites and several function object
 types for the predicates.
 
-\cgalHasModel `CGAL::Apollonius_graph_traits_2<K,Method_tag>`
+\cgalHasModelsBegin
-\cgalHasModel `CGAL::Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
+\cgalHasModels{CGAL::Apollonius_graph_traits_2<K,Method_tag>}
+\cgalHasModels{CGAL::Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>}
+\cgalHasModelsEnd
 
 \sa `CGAL::Apollonius_graph_2<Gt,Agds>`
 \sa `CGAL::Apollonius_graph_traits_2<K,Method_tag>`

Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphVertexBase_2.h

@@ -12,7 +12,9 @@ sites. The container stores the hidden sites related to the vertex.
 
 \cgalRefines{TriangulationVertexBase_2}
 
-\cgalHasModel `CGAL::Apollonius_graph_vertex_base_2<Gt,StoreHidden>`
+\cgalHasModelsBegin
+\cgalHasModels{CGAL::Apollonius_graph_vertex_base_2<Gt,StoreHidden>}
+\cgalHasModelsEnd
 
 \sa `ApolloniusGraphDataStructure_2`
 \sa `CGAL::Apollonius_graph_2<Gt,Agds>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/Arrangement_on_surface_2.txt

@@ -117,8 +117,8 @@ special type of objects. They must, however, supply the relevant
 traits class, which mainly involves algebraic computations. A traits
 class also encapsulates the number types used to represent coordinates
 of geometric objects and to carry out algebraic operations on them. It
-encapsulates the type of coordinate system used (e.g., Cartesian and
+encapsulates the type of coordinate system used (e.g., %Cartesian and
-Homogeneous), and the geometric or algebraic computation methods
+homogeneous), and the geometric or algebraic computation methods
 themselves. The precise minimal sets of requirements the actual traits
 classes must conform to are organized as a hierarchy of concepts; see
 Section \ref aos_sec-geom_traits.
@@ -4780,7 +4780,7 @@ or line segments. The \link Arr_conic_traits_2::Curve_2
 `Curve_2`\endlink and the derived \link
 Arr_conic_traits_2::X_monotone_curve_2 `X_monotone_curve_2`\endlink
 classes also support basic access functions such as `source()`,
-`target()`, and `orientation()`.
+`target()`, and `%orientation()`.
 
 <!-- ------------------------------------------------------------------------- -->
 \cgalFigureBegin{aos_fig-conics,conics.png}
@@ -5067,7 +5067,7 @@ substitute the template parameters `RatKernel`, `AlgKernel`, and
 the same requirements of the corresponding types used to instantiate
 the `Arr_conic_traits_2` class template. Here, the use of the
 `CORE_algebraic_number_traits` class is also recommended with
-Cartesian kernels instantiated with the `Rational` and `Algebraic`
+%Cartesian kernels instantiated with the `Rational` and `Algebraic`
 number types defined by this class. The examples given in this manual
 use the type definitions listed below. These types are defined in the
 header file `arr_Bezier.h`.

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_Bezier_curve_traits_2.h

@@ -52,8 +52,7 @@ the `Are_mergeable_2` operation does not enforce the input curves
 to have the same direction as a precondition. Moreover, `Arr_Bezier_curve_traits_2`
 supports the merging of curves of opposite directions.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2}
-\cgalModels `ArrangementDirectionalXMonotoneTraits_2`
 
 
 */

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_algebraic_segment_traits_2.h

@@ -22,7 +22,7 @@ the types `leda::integer` and `CORE::BigInt` are supported as well
 as any instance of `CGAL::Sqrt_extension` that is instantiated with
 one of the integral types above.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2}
 
 
 */

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_bounded_planar_topology_traits_2.h

@@ -21,7 +21,7 @@ namespace CGAL {
  * `Arr_default_dcel<Traits>`.
  * </UL>
  *
- * \cgalModels `ArrangementBasicTopologyTraits`
+ * \cgalModels{ArrangementBasicTopologyTraits}
  *
  * \sa `Arr_default_dcel<Traits>`
  * \sa `CGAL::Arr_geodesic_arc_on_sphere_traits_2<Kernel,x,y>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circle_segment_traits_2.h

@@ -32,8 +32,7 @@ namespace CGAL {
  * same direction as a precondition. Moreover, `Arr_circle_segment_traits_2`
  * supports the merging of curves of opposite directions.
  *
- * \cgalModels `ArrangementTraits_2`
+ * \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2}
- * \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
  *
  */
 template< typename Kernel >
@@ -168,7 +167,7 @@ public:
 
 
   /*! The `Point_2` number-type nested within the traits class represents
-   * a Cartesian point whose coordinates are algebraic numbers of type
+   * a %Cartesian point whose coordinates are algebraic numbers of type
    * `CoordNT`.
    */
   class Point_2 {

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circular_arc_traits_2.h

@@ -8,7 +8,7 @@ This class is a traits class for \cgal arrangements, built on top of a model of
 concept `CircularKernel`.
 It provides curves of type `CGAL::Circular_arc_2<CircularKernel>`.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2}
 
 */
 template< typename CircularKernel >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circular_line_arc_traits_2.h

@@ -12,7 +12,7 @@ of both types
 
 It uses the <A HREF="https://www.boost.org/doc/html/variant.html">std::variant</A>.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2}
 
 */
 template< typename CircularKernel >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_conic_traits_2.h

@@ -80,9 +80,7 @@ namespace CGAL {
  * to have the same direction as a precondition. Moreover, `Arr_conic_traits_2`
  * supports the merging of curves of opposite directions.
  *
- * \cgalModels `ArrangementTraits_2`
+ * \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementDirectionalXMonotoneTraits_2}
- * \cgalModels `ArrangementLandmarkTraits_2`
- * \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
  *
  * \cgalHeading{Types}
  */
@@ -274,7 +272,7 @@ public:
      */
     Point_2(const Algebraic& hx, const Algebraic& hy, const Algebraic& hz);
 
-    /*! constructs from Cartesian coordinates.
+    /*! constructs from %Cartesian coordinates.
      */
     Point_2(const Algebraic& x, const Algebraic& y);:
 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_consolidated_curve_data_traits_2.h

@@ -21,7 +21,7 @@ both resulting subcurves. In case two (or more) \f$ x\f$-monotone curves
 overlap, their data sets are consolidated, and are inserted into the set
 of the \f$ x\f$-monotone curve that represents the overlap.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2}
 
 */
 template< typename Traits, typename Data >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_curve_data_traits_2.h

@@ -49,7 +49,7 @@ namespace CGAL {
  * `d1` and `d2`. The \f$ x\f$-monotone curve that represents the overlap is
  * associated with the output of this functor.
  *
- * \cgalModels `ArrangementTraits_2`
+ * \cgalModels{ArrangementTraits_2}
  */
 template <typename Tr, typename XData, typename Mrg, typename CData, typename Cnv>
 class Arr_curve_data_traits_2 : public Tr {

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_dcel_base.h

@@ -16,7 +16,7 @@ must be instantiated with models of the concepts
 `ArrangementDcelVertex`, `ArrangementDcelHalfedge`,
 and `ArrangementDcelFace` respectively.
 
-\cgalModels `ArrangementDcel`
+\cgalModels{ArrangementDcel}
 
 */
 template< typename V, typename H, typename F >
@@ -29,7 +29,7 @@ public:
 The basic \dcel face type. Serves as a basis class for an extended
 face record with auxiliary data fields.
 
-\cgalModels `ArrangementDcelFace`
+\cgalModels{ArrangementDcelFace}
 
 */
 class Arr_face_base {
@@ -43,7 +43,7 @@ The basic \dcel halfedge type. Serves as a basis class for an
 extended halfedge record with auxiliary data fields. The `Curve`
 parameter is the type of \f$ x\f$-monotone curves associated with the vertices.
 
-\cgalModels `ArrangementDcelHalfedge`
+\cgalModels{ArrangementDcelHalfedge}
 
 */
 template< typename Curve >
@@ -58,7 +58,7 @@ The basic \dcel vertex type. Serves as a basis class for an extended
 vertex record with auxiliary data fields. The `Point` parameter is
 the type of points associated with the vertices.
 
-\cgalModels `ArrangementDcelVertex`
+\cgalModels{ArrangementDcelVertex}
 
 */
 template< typename Point >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_default_dcel.h

@@ -12,7 +12,7 @@ the base vertex and halfedge types, respectively. Thus, the default
 \dcel records store no other information, except for the topological
 incidence relations and the geometric data attached to vertices and edges.
 
-\cgalModels `ArrangementDcelWithRebind`
+\cgalModels{ArrangementDcelWithRebind}
 
 \sa `Arr_dcel_base<V,H,F>`
 */

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_default_overlay_traits.h

@@ -10,7 +10,7 @@ of type `Arrangement` that store no auxiliary data with their \dcel records, whe
 \dcel data as well. This class simply gives empty implementation for all
 traits-class functions.
 
-\cgalModels `OverlayTraits`
+\cgalModels{OverlayTraits}
 
 \sa `overlay`
 
@@ -43,7 +43,7 @@ it uses the functor `OvlFaceData`, which accepts a `FaceData_A` object
 and a `FaceData_B` object and computes a corresponding `FaceData_R`
 object, in order to set the auxiliary data of the overlay face.
 
-\cgalModels `OverlayTraits`
+\cgalModels{OverlayTraits}
 
 \sa `overlay`
 \sa `CGAL::Arr_face_extended_dcel<Traits,FData,V,H,F>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_extended_dcel.h

@@ -33,7 +33,7 @@ The default values follow:
 
 </TABLE>
 
-\cgalModels `ArrangementDcelWithRebind`
+\cgalModels{ArrangementDcelWithRebind}
 
 \sa `Arr_dcel_base<V,H,F>`
 
@@ -57,7 +57,7 @@ The `Arr_extended_face` class-template extends the face topological-features of
 \dcel. It is parameterized by a face base-type `FaceBase` and a data type
 `FData` used to extend the face base-type.
 
-\cgalModels `ArrangementDcelFace`
+\cgalModels{ArrangementDcelFace}
 
 \sa `Arr_dcel_base<V,H,F>`
 
@@ -109,7 +109,7 @@ The `Arr_extended_halfedge` class-template extends the halfedge topological-feat
 the \dcel. It is parameterized by a halfedge base-type `HalfedgeBase`
 and a data type `HData` used to extend the halfedge base-type.
 
-\cgalModels `ArrangementDcelHalfedge`
+\cgalModels{ArrangementDcelHalfedge}
 
 \sa `Arr_dcel_base<V,H,F>`
 
@@ -162,7 +162,7 @@ topological-features of the \dcel. It is parameterized by a
 vertex base-type `VertexBase` and a data type `VData` used to extend
 the vertex base-type.
 
-\cgalModels `ArrangementDcelVertex`
+\cgalModels{ArrangementDcelVertex}
 
 \sa `Arr_dcel_base<V,H,F>`
 
@@ -235,7 +235,7 @@ as follows:
 
 </TABLE>
 
-\cgalModels `ArrangementDcelWithRebind`
+\cgalModels{ArrangementDcelWithRebind}
 
 \sa `Arr_dcel_base<V,H,F>`
 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_face_index_map.h

@@ -19,10 +19,7 @@ existing faces might be removed, the notification mechanism is used
 to dynamically maintain the mapping of face handles to indices.
 
 
-\cgalModels DefaultConstructible
+\cgalModels{DefaultConstructible,CopyConstructible,Assignable,ReadablePropertyMap}
-\cgalModels CopyConstructible
-\cgalModels Assignable
-\cgalModels `ReadablePropertyMap`
 
 \sa `Arr_observer<Arrangement>`
 \sa `Arr_vertex_index_map<Arrangement>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_geodesic_arc_on_sphere_traits_2.h

@@ -39,9 +39,7 @@ namespace CGAL {
    * normalized vector \f$(x,y)\f$ in the \f$xy\f$-plane that bisects the
    * identification curve.
 
-   * \cgalModels `ArrangementTraits_2`
+   * \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementSphericalBoundaryTraits_2}
-   * \cgalModels `ArrangementLandmarkTraits_2`
-   * \cgalModels `ArrangementSphericalBoundaryTraits_2`
    */
 
   template <typename Kernel, typename X, typename Y>
@@ -52,9 +50,7 @@ namespace CGAL {
      * not-necessarily normalized 3D direction extended with information that
      * specifies the location of the point pre-image in the parameter space.
      *
-     * \cgalModels `Assignable`
+     * \cgalModels{Assignable,DefaultConstructible,CopyConstructible}
-     * \cgalModels `DefaultConstructible`
-     * \cgalModels `CopyConstructible`
      */
     class Point_2 {
     public:
@@ -118,9 +114,7 @@ namespace CGAL {
      * intersect the identified left and right sides of the boundary of the
      * parameter space.
      *
-     * \cgalModels `Assignable`
+     * \cgalModels{Assignable,DefaultConstructible,CopyConstructible}
-     * \cgalModels `DefaultConstructible`
-     * \cgalModels `CopyConstructible`
      */
     class X_monotone_curve_2 {
     public:
@@ -287,10 +281,7 @@ namespace CGAL {
 
     /*! Construction functor of a point.
      *
-     * \cgalModels `Assignable`
+     * \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableTernaryFunction}
-     * \cgalModels `CopyConstructible`
-     * \cgalModels `AdaptableUnaryFunction`
-     * \cgalModels `AdaptableTernaryFunction`
      */
     /*!
      */
@@ -325,11 +316,7 @@ namespace CGAL {
 
     /*! Construction functor of \f$x\f$-monotone geodesic arcs.
      *
-     * \cgalModels `Assignable`
+     * \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableBinaryFunction,AdaptableTernaryFunction}
-     * \cgalModels `CopyConstructible`
-     * \cgalModels `AdaptableUnaryFunction`
-     * \cgalModels `AdaptableBinaryFunction`
-     * \cgalModels `AdaptableTernaryFunction`
      */
     class Construct_x_monotone_curve_2 {
     public:
@@ -393,11 +380,7 @@ namespace CGAL {
 
     /*! Construction functor of geodesic arcs.
      *
-     * \cgalModels `Assignable`
+     * \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableBinaryFunction,AdaptableTernaryFunction}
-     * \cgalModels `CopyConstructible`
-     * \cgalModels `AdaptableUnaryFunction`
-     * \cgalModels `AdaptableBinaryFunction`
-     * \cgalModels `AdaptableTernaryFunction`
      */
     class Construct_curve_2 {
     public:

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_landmarks_point_location.h

@@ -47,8 +47,7 @@ when the application frequently issues point-location queries on a
 rather static arrangement that the changes applied to it are mainly
 insertions of curves and not deletions of them.
 
-\cgalModels `ArrangementPointLocation_2`
+\cgalModels{ArrangementPointLocation_2,ArrangementVerticalRayShoot_2}
-\cgalModels `ArrangementVerticalRayShoot_2`
 
 \sa `ArrangementPointLocation_2`
 \sa `ArrangementVerticalRayShoot_2`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_line_arc_traits_2.h

@@ -8,7 +8,7 @@ This class is a traits class for \cgal arrangements, built on top of a
 model of concept `CircularKernel`. It provides curves of type
 `CGAL::Line_arc_2<CircularKernel>`.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2}
 
 */
 template< typename CircularKernel >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_linear_traits_2.h

@@ -21,9 +21,7 @@ namespace CGAL {
  * we can find out its actual type and convert it to the respective kernel
  * object (say, to a `Kernel::Ray_2`).
  *
- * \cgalModels `ArrangementTraits_2`
+ * \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementOpenBoundaryTraits_2}
- * \cgalModels `ArrangementLandmarkTraits_2`
- * \cgalModels `ArrangementOpenBoundaryTraits_2`
  */
 template< typename Kernel >
 class Arr_linear_traits_2 {

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_naive_point_location.h

@@ -13,8 +13,7 @@ The query time is therefore linear in the complexity of the arrangement.
 Naturally, this point-location strategy could turn into a heavy
 time-consuming process when applied to dense arrangements.
 
-\cgalModels `ArrangementPointLocation_2`
+\cgalModels{ArrangementPointLocation_2,ArrangementVerticalRayShoot_2}
-\cgalModels `ArrangementVerticalRayShoot_2`
 
 \sa `ArrangementPointLocation_2`
 \sa `ArrangementVerticalRayShoot_2`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_non_caching_segment_basic_traits_2.h

@@ -21,7 +21,7 @@ instantiations for the kernel. Using other (inexact) number types
 `Simple_cartesian<double>`) is also possible, at the user's own
 risk.
 
-\cgalModels `ArrangementLandmarkTraits_2`
+\cgalModels{ArrangementLandmarkTraits_2}
 
 */
 template< typename Kernel >

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_non_caching_segment_traits_2.h

@@ -32,9 +32,7 @@ the `Are_mergeable_2` operation does not enforce the input curves
 to have the same direction as a precondition. Moreover, `Arr_non_caching_segment_traits_2`
 supports the merging of curves of opposite directions.
 
-\cgalModels `ArrangementTraits_2`
+\cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementDirectionalXMonotoneTraits_2}
-\cgalModels `ArrangementLandmarkTraits_2`
-\cgalModels `ArrangementDirectionalXMonotoneTraits_2`
 
 \sa `Arr_segment_traits_2<Kernel>`
 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_polycurve_traits_2.h

@@ -72,10 +72,9 @@ namespace CGAL {
    * set the macro `CGAL_ALWAYS_LEFT_TO_RIGHT` to 1 before any \cgal header is
    * included.
    *
-   * \cgalModels `ArrangementTraits_2`
+   * \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,
-   * \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
+   *             ArrangementApproximateTraits_2 (if the type that substitutes
-   * \cgalModels `ArrangementApproximateTraits_2` (if the type that substitutes
+   *   the template parameter `SubcurveTraits_2` models the concept as well)}
-   *   the template parameter `SubcurveTraits_2` models the concept as well)
    *
    * \sa `Arr_algebraic_segment_traits_2<Coefficient>`
    * \sa `Arr_Bezier_curve_traits_2<RatKernel, AlgKernel, NtTraits>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_polyline_traits_2.h

@@ -77,12 +77,9 @@ namespace CGAL {
  * the macro `CGAL_ALWAYS_LEFT_TO_RIGHT` to 1 before any \cgal header is
  * included.
  *
- * \cgalModels `ArrangementTraits_2`
+ * \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,`ArrangementConstructXMonotoneCurveTraits_2`
- * \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
+ *             ArrangementConstructCurveTraits_2,ArrangementApproximateTraits_2 (if the type that substitutes
- * \cgalModels `ArrangementConstructXMonotoneCurveTraits_2`
+ *   the template parameter `SegmentTraits_2` models the concept as well)}
- * \cgalModels `ArrangementConstructCurveTraits_2`
- * \cgalModels `ArrangementApproximateTraits_2` (if the type that substitutes
- *   the template parameter `SegmentTraits_2` models the concept as well)
  *
  * \sa `Arr_polycurve_traits_2<SubcurveTraits_2>`
  * \sa `Arr_Bezier_curve_traits_2<RatKernel, AlgKernel, NtTraits>`

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_rational_function_traits_2.h

@@ -52,9 +52,7 @@ namespace CGAL {
   to have the same direction as a precondition. Moreover, `Arr_rational_function_traits_2`
   supports the merging of curves of opposite directions.
 
-  \cgalModels `ArrangementTraits_2`
+  \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,ArrangementOpenBoundaryTraits_2}
-  \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
-  \cgalModels `ArrangementOpenBoundaryTraits_2`
 */
 template< typename AlgebraicKernel_d_1 >
 class Arr_rational_function_traits_2 {
@@ -134,10 +132,7 @@ Functor to construct a `Curve_2`. To enable caching the class is not
 default constructible and must be obtained via the function
 `construct_curve_2_object()`, which is a member of the traits.
 
-\cgalModels `Assignable`
+\cgalModels{Assignable,CopyConstructible,AdaptableBinaryFunction,AdaptableUnaryFunction}
-\cgalModels `CopyConstructible`
-\cgalModels `AdaptableBinaryFunction`
-\cgalModels `AdaptableUnaryFunction`
 
 */
 class Construct_curve_2 {
@@ -289,10 +284,7 @@ Functor to construct a `X_monotone_curve_2`. To enable caching the class
 is not default constructible and must be obtained via the function
 `construct_x_monotone_curve_2_object()`, which is a member of the traits.
 
-\cgalModels `Assignable`
+\cgalModels{Assignable,CopyConstructible,AdaptableBinaryFunction,AdaptableUnaryFunction}
-\cgalModels `CopyConstructible`
-\cgalModels `AdaptableBinaryFunction`
-\cgalModels `AdaptableUnaryFunction`
 
 */
 class Construct_x_monotone_curve_2 {
@@ -460,7 +452,7 @@ const Algebraic_real_1& lower, const Algebraic_real_1& upper); const
 The `Curve_2` class nested within the traits is used
 to represent rational functions which may be restricted to a certain x-range.
 
-\cgalModels `ArrTraits::Curve_2`
+\cgalModels{ArrTraits::Curve_2}
 
 */
 class Curve_2 {
@@ -531,7 +523,7 @@ Algebraic_real_1 right_x() const;
 /*!
 
 
-\cgalModels `ArrTraits::Point_2`
+\cgalModels{ArrTraits::Point_2}
 
 */
 class Point_2 {
@@ -633,7 +625,7 @@ The `X_monotone_curve_2` class nested within the traits is used
 to represent \f$ x\f$-monotone parts of rational functions. In particular, such an \f$ x\f$-monotone curve
 may not contain a vertical asymptote in its interior \f$ x\f$-range.
 
-\cgalModels `ArrTraits::XMonotoneCurve_2`
+\cgalModels{ArrTraits::XMonotoneCurve_2}
 
 */
 class X_monotone_curve_2 {