songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
ange-clement 2023-10-10 15:06:02 +02:00
parent 891da07cf4 8a4b492f1c
commit 00514ec7dc
1012 changed files with 5428 additions and 3502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/build_doc.yml vendored
View File

@ -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:

2
.github/workflows/checks.yml vendored
View File

@ -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

4
.github/workflows/cmake-all.yml vendored
View File

@ -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

2
.github/workflows/delete_doc.yml vendored
View File

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

8
.github/workflows/demo.yml vendored
View File

@ -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

2
.github/workflows/list_workflow_last_run.yml vendored
View File

@ -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

2
.github/workflows/reuse.yml vendored
View File

@ -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:

4
AABB_tree/doc/AABB_tree/Concepts/AABBGeomTraits.h
View File

@ -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>`

12
AABB_tree/doc/AABB_tree/Concepts/AABBPrimitive.h
View File

@ -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>`
\cgalHasModel `CGAL::AABB_segment_primitive<Iterator,CacheDatum>`
\cgalHasModel `CGAL::AABB_triangle_primitive<Iterator,CacheDatum>`
\cgalHasModel `CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_false,CacheDatum>`
\cgalHasModel `CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_false,CacheDatum>`
\cgalHasModelsBegin
\cgalHasModels{CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,Tag_false,CacheDatum>}
\cgalHasModels{CGAL::AABB_segment_primitive<Iterator,CacheDatum>}
\cgalHasModels{CGAL::AABB_triangle_primitive<Iterator,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 {

8
AABB_tree/doc/AABB_tree/Concepts/AABBPrimitiveWithSharedData.h
View File

@ -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>`
\cgalHasModel `CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,VertexPointPMap,Tag_true,CacheDatum>`
\cgalHasModel `CGAL::AABB_face_graph_triangle_primitive<FaceGraph,VertexPointPMap,Tag_true,CacheDatum>`
\cgalHasModelsBegin
\cgalHasModels{CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,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 {

4
AABB_tree/doc/AABB_tree/Concepts/AABBRayIntersectionGeomTraits.h
View File

@ -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>`

4
AABB_tree/doc/AABB_tree/Concepts/AABBRayIntersectionTraits.h
View File

@ -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`

4
AABB_tree/doc/AABB_tree/Concepts/AABBTraits.h
View File

@ -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}

2
AABB_tree/include/CGAL/AABB_face_graph_triangle_primitive.h
View File

@ -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`

6
AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h
View File

@ -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`,
* and `AABBPrimitiveWithSharedData` if `OneHalfedgeGraphPerTree` is `CGAL::Tag_true`.
* \cgalModelsBareBegin
* \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.

2
AABB_tree/include/CGAL/AABB_polyhedron_segment_primitive.h
View File

@ -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

2
AABB_tree/include/CGAL/AABB_polyhedron_triangle_primitive.h
View File

@ -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

6
AABB_tree/include/CGAL/AABB_primitive.h
View File

@ -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`.
* \cgalModels `AABBPrimitiveWithSharedData` if `ExternalPropertyMaps` is `CGAL::Tag_true`.
* \cgalModelsBareBegin
* \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`.

2
AABB_tree/include/CGAL/AABB_segment_primitive.h
View File

@ -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`

5
AABB_tree/include/CGAL/AABB_traits.h
View File

@ -149,9 +149,8 @@ class AABB_tree;
/// computations, and it handles points as query type for distance
/// queries.
///
/// \cgalModels AABBTraits
/// \cgalModels AABBRayIntersectionTraits
/// \cgalModels{AABBTraits,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.

2
AABB_tree/include/CGAL/AABB_triangle_primitive.h
View File

@ -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`

2
AABB_tree/include/CGAL/AABB_triangulation_3_triangle_primitive.h
View File

@ -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

4
Advancing_front_surface_reconstruction/doc/Advancing_front_surface_reconstruction/Concepts/AdvancingFrontSurfaceReconstructionTraits_3.h
View File

@ -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
{

5
Algebraic_foundations/doc/Algebraic_foundations/Algebraic_foundations.txt
View File

@ -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
kernels, and the `RingNumberType` for Homogeneous kernels).
from one of these types (the `FieldNumberType` in case of %Cartesian
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 */

18
Algebraic_foundations/doc/Algebraic_foundations/CGAL/Algebraic_structure_traits.h
View File

@ -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`

2
Algebraic_foundations/doc/Algebraic_foundations/CGAL/Fraction_traits.h
View File

@ -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 >

2
Algebraic_foundations/doc/Algebraic_foundations/CGAL/Real_embeddable_traits.h
View File

@ -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 >

4
Algebraic_foundations/doc/Algebraic_foundations/Concepts/AlgebraicStructureTraits.h
View File

@ -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
*/

25
Algebraic_foundations/doc/Algebraic_foundations/Concepts/FieldNumberType.h
View File

@ -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
\cgalHasModel double
\cgalHasModel `CGAL::Gmpq`
\cgalHasModel `CGAL::Interval_nt`
\cgalHasModel `CGAL::Interval_nt_advanced`
\cgalHasModel `CGAL::Lazy_exact_nt<FieldNumberType>`
\cgalHasModel `CGAL::Quotient<RingNumberType>`
\cgalHasModel `leda_rational`
\cgalHasModel `leda_bigfloat`
\cgalHasModel `leda_real`
\cgalHasModelsBegin
\cgalHasModels{float}
\cgalHasModels{double}
\cgalHasModels{CGAL::Gmpq}
\cgalHasModels{CGAL::Interval_nt}
\cgalHasModels{CGAL::Interval_nt_advanced}
\cgalHasModels{CGAL::Lazy_exact_nt<FieldNumberType>}
\cgalHasModels{CGAL::Quotient<RingNumberType>}
\cgalHasModels{leda_rational}
\cgalHasModels{leda_bigfloat}
\cgalHasModels{leda_real}
\cgalHasModelsEnd
\sa `RingNumberType`
\sa `Kernel`
@ -32,4 +34,3 @@ public:
/// @}
}; /* end FieldNumberType */

4
Algebraic_foundations/doc/Algebraic_foundations/Concepts/FractionTraits.h
View File

@ -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`

8
Algebraic_foundations/doc/Algebraic_foundations/Concepts/FromIntConstructible.h
View File

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

4
Algebraic_foundations/doc/Algebraic_foundations/Concepts/RealEmbeddableTraits.h
View File

@ -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 {

31
Algebraic_foundations/doc/Algebraic_foundations/Concepts/RingNumberType.h
View File

@ -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
\cgalHasModel `CGAL::Gmpq`
\cgalHasModel `CGAL::Gmpz`
\cgalHasModel `CGAL::Interval_nt`
\cgalHasModel `CGAL::Interval_nt_advanced`
\cgalHasModel `CGAL::Lazy_exact_nt<RingNumberType>`
\cgalHasModel `CGAL::MP_Float`
\cgalHasModel `CGAL::Gmpzf`
\cgalHasModel `CGAL::Quotient<RingNumberType>`
\cgalHasModel `leda_integer`
\cgalHasModel `leda_rational`
\cgalHasModel `leda_bigfloat`
\cgalHasModel `leda_real`
\cgalHasModelsBegin
\cgalHasModelsBare{\cpp built-in number types}
\cgalHasModels{CGAL::Gmpq}
\cgalHasModels{CGAL::Gmpz}
\cgalHasModels{CGAL::Interval_nt}
\cgalHasModels{CGAL::Interval_nt_advanced}
\cgalHasModels{CGAL::Lazy_exact_nt<RingNumberType>}
\cgalHasModels{CGAL::MP_Float}
\cgalHasModels{CGAL::Gmpzf}
\cgalHasModels{CGAL::Quotient<RingNumberType>}
\cgalHasModels{leda_integer}
\cgalHasModels{leda_rational}
\cgalHasModels{leda_bigfloat}
\cgalHasModels{leda_real}
\cgalHasModelsEnd
\sa `FieldNumberType`
@ -32,4 +34,3 @@ class RingNumberType {
public:
}; /* end RingNumberType */

2
Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_d_1.h
View File

@ -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`

2
Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_d_2.h
View File

@ -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`

2
Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_rs_gmpq_d_1.h
View File

@ -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`

2
Algebraic_kernel_d/doc/Algebraic_kernel_d/CGAL/Algebraic_kernel_rs_gmpz_d_1.h
View File

@ -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`

6
Algebraic_kernel_d/doc/Algebraic_kernel_d/Concepts/AlgebraicKernel_d_1.h
View File

@ -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`
\cgalHasModel `CGAL::Algebraic_kernel_rs_gmpq_d_1`
\cgalHasModelsBegin
\cgalHasModels{CGAL::Algebraic_kernel_rs_gmpz_d_1}
\cgalHasModels{CGAL::Algebraic_kernel_rs_gmpq_d_1}
\cgalHasModelsEnd
\sa `AlgebraicKernel_d_2`

2
Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_face_base_2.h
View File

@ -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`

2
Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_vertex_base_2.h
View File

@ -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`

4
Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeFace_2.h
View File

@ -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 {

6
Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeTraits_2.h
View File

@ -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`.
\cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.
\cgalHasModelsBegin
\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)
*/

4
Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/AlphaShapeVertex_2.h
View File

@ -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:

6
Alpha_shapes_2/doc/Alpha_shapes_2/Concepts/WeightedAlphaShapeTraits_2.h
View File

@ -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`.
\cgalHasModel Projection traits such as `CGAL::Projection_traits_xy_3<K>`.
\cgalHasModelsBegin
\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)
*/

2
Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_cell_base_3.h
View File

@ -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`

2
Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_vertex_base_3.h
View File

@ -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`

2
Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Fixed_alpha_shape_cell_base_3.h
View File

@ -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`

2
Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Fixed_alpha_shape_vertex_base_3.h
View File

@ -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`

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeCell_3.h
View File

@ -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`

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeTraits_3.h
View File

@ -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)
*/

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/AlphaShapeVertex_3.h
View File

@ -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`

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeCell_3.h
View File

@ -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:

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeTraits_3.h
View File

@ -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)
*/

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedAlphaShapeVertex_3.h
View File

@ -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 {

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/FixedWeightedAlphaShapeTraits_3.h
View File

@ -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)
*/

4
Alpha_shapes_3/doc/Alpha_shapes_3/Concepts/WeightedAlphaShapeTraits_3.h
View File

@ -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)
*/

10
Alpha_wrap_3/doc/Alpha_wrap_3/Concepts/AlphaWrapOracle.h
View File

@ -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`
\cgalHasModel `CGAL::Alpha_wraps_3_::Segment_soup_oracle`
\cgalHasModel `CGAL::Alpha_wraps_3_::Triangle_mesh_oracle`
\cgalHasModel `CGAL::Alpha_wraps_3_::Triangle_soup_oracle`
\cgalHasModelsBegin
\cgalHasModels{CGAL::Alpha_wraps_3_::Point_set_oracle}
\cgalHasModels{CGAL::Alpha_wraps_3_::Segment_soup_oracle}
\cgalHasModels{CGAL::Alpha_wraps_3_::Triangle_mesh_oracle}
\cgalHasModels{CGAL::Alpha_wraps_3_::Triangle_soup_oracle}
\cgalHasModelsEnd
*/
template <typename GeomTraits>

4
Alpha_wrap_3/doc/Alpha_wrap_3/Concepts/AlphaWrapTraits_3.h
View File

@ -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

1
Alpha_wrap_3/examples/Alpha_wrap_3/CMakeLists.txt
View File

@ -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")

2
Alpha_wrap_3/examples/Alpha_wrap_3/mixed_inputs_wrap.cpp
View File

@ -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>;

173
Alpha_wrap_3/examples/Alpha_wrap_3/volumetric_wrap.cpp Normal file
View File

@ -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;
}

340
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h
View File

@ -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>
class Cell_base_with_timestamp
: public Cb
{
std::size_t time_stamp_;
namespace {
public:
template <typename... Args>
Cell_base_with_timestamp(const Args&... args) : Cb(args...), time_stamp_(-1) { }
namespace AW3i = ::CGAL::Alpha_wraps_3::internal;
Cell_base_with_timestamp(const Cell_base_with_timestamp& other) : Cb(other), time_stamp_(other.time_stamp_) { }
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;
};
};
} // unnamed namespace
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(); }
Dt& triangulation() { return m_dt; }
const Dt& triangulation() const { return m_dt; }
const Geom_traits& geom_traits() const { return m_tr.geom_traits(); }
Triangulation& triangulation() { return m_tr; }
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),
m_dt.point(c, (inf_index+2)&3),
m_dt.point(c, (inf_index+3)&3)));
geom_traits().construct_circumcenter_3_object()(m_tr.point(c, (inf_index+1)&3),
m_tr.point(c, (inf_index+2)&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);
seed_v->info() = SEED_VERTEX;
Vertex_handle seed_v = m_tr.insert(seed_p);
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*/);
ico_v->info() = SEED_VERTEX;
Vertex_handle ico_v = m_tr.insert(seed_neighbor_p, seed_v /*hint*/);
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;
const int inf_index = ch->index(m_dt.infinite_vertex());
ch->is_outside() = true;
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 + 2)&3)->info() == DEFAULT);
// CGAL_assertion(cell->vertex((fid + 3)&3)->info() == DEFAULT);
// CGAL_assertion(cell->vertex((fid + 1)&3)->type() == AW3i::Vertex_type:: DEFAULT);
// CGAL_assertion(cell->vertex((fid + 2)&3)->type() == AW3i::Vertex_type:: 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_dt.point(cell, Dt::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, 0)));
points.push_back(m_tr.point(cell, Triangulation::vertex_triple_index(fid, 1)));
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)
f = m_dt.mirror_facet(f);
if(!f.first->is_outside())
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));
if(vh->info() == BBOX_VERTEX || vh->info() == SEED_VERTEX)
const Vertex_handle vh = ch->vertex(Triangulation::vertex_triple_index(id, i));
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& p1 = m_dt.point(ch, (id+2)&3);
const Point_3& p2 = m_dt.point(ch, (id+3)&3);
const Point_3& p0 = m_tr.point(ch, (id+1)&3);
const Point_3& p1 = m_tr.point(ch, (id+2)&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"
<< 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;
<< "c = " << &*ch << " (" << m_tr.is_infinite(ch) << "), n = " << &*neighbor << " (" << m_tr.is_infinite(neighbor) << ")" << "\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;
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);
CGAL_assertion(lt != Dt::VERTEX);
const Cell_handle conflict_cell = m_tr.locate(steiner_point, lt, li, lj, neighbor);
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);
vh->info() = DEFAULT;
// We could use TDS functions to avoid recomputing the conflict zone, but in practice
// 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( if(fit->first->info().is_outside == fit->first->neighbor(fit->second)->info().is_outside) continue;)
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->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)),
squared_distance(m_dt.point(c, 0), m_dt.point(c, 2)),
squared_distance(m_dt.point(c, 0), m_dt.point(c, 3)),
squared_distance(m_dt.point(c, 1), m_dt.point(c, 2)),
squared_distance(m_dt.point(c, 3), m_dt.point(c, 3)),
squared_distance(m_dt.point(c, 2), m_dt.point(c, 3)) });
return (std::max)({ squared_distance(m_tr.point(c, 0), m_tr.point(c, 1)),
squared_distance(m_tr.point(c, 0), m_tr.point(c, 2)),
squared_distance(m_tr.point(c, 0), m_tr.point(c, 3)),
squared_distance(m_tr.point(c, 1), m_tr.point(c, 2)),
squared_distance(m_tr.point(c, 3), m_tr.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& p1 = m_dt.point(ch, (id+2)&3);
const Point_3& p2 = m_dt.point(ch, (id+3)&3);
const Point_3& p0 = m_tr.point(ch, (id+1)&3);
const Point_3& p1 = m_tr.point(ch, (id+2)&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;
}

14
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_AABB_geom_traits.h
View File

@ -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(),
ch->vertex(2)->point(), ch->vertex(3)->point());
m_tet = tetrahedron(c->vertex(0)->point(), c->vertex(1)->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(),
ch->vertex((i+2)& 3)->point(),
ch->vertex((i+3)& 3)->point());
m_triangles[i] = triangle(c->vertex((i+1)& 3)->point(),
c->vertex((i+2)& 3)->point(),
c->vertex((i+3)& 3)->point());
m_tbox[i] = bbox(m_triangles[i]);
}
}

97
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_cell_base_3.h Normal file
View File

@ -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

71
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_triangulation_vertex_base_3.h Normal file
View File

@ -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

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_2.h
View File

@ -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>`

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_filtered_traits_2.h
View File

@ -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`

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_hierarchy_vertex_base_2.h
View File

@ -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>`

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_traits_2.h
View File

@ -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>`

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_vertex_base_2.h
View File

@ -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>`

2
Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_site_2.h
View File

@ -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}

4
Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphDataStructure_2.h
View File

@ -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`

4
Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphHierarchyVertexBase_2.h
View File

@ -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>`

6
Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphTraits_2.h
View File

@ -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>`
\cgalHasModel `CGAL::Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
\cgalHasModelsBegin
\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>`

4
Apollonius_graph_2/doc/Apollonius_graph_2/Concepts/ApolloniusGraphVertexBase_2.h
View File

@ -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>`

8
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/Arrangement_on_surface_2.txt
View File

@ -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
Homogeneous), and the geometric or algebraic computation methods
encapsulates the type of coordinate system used (e.g., %Cartesian and
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`.

3
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_Bezier_curve_traits_2.h
View File

@ -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 `ArrangementDirectionalXMonotoneTraits_2`
\cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2}
*/

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_algebraic_segment_traits_2.h
View File

@ -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}
*/

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_bounded_planar_topology_traits_2.h
View File

@ -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>`

5
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circle_segment_traits_2.h
View File

@ -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 `ArrangementDirectionalXMonotoneTraits_2`
* \cgalModels{ArrangementTraits_2,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 {

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circular_arc_traits_2.h
View File

@ -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 >

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circular_line_arc_traits_2.h
View File

@ -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 >

6
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_conic_traits_2.h
View File

@ -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 `ArrangementLandmarkTraits_2`
* \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
* \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,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);:

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_consolidated_curve_data_traits_2.h
View File

@ -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 >

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_curve_data_traits_2.h
View File

@ -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 {

8
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_dcel_base.h
View File

@ -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 >

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_default_dcel.h
View File

@ -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>`
*/

4
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_default_overlay_traits.h
View File

@ -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>`

10
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_extended_dcel.h
View File

@ -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>`

5
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_face_index_map.h
View File

@ -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 CopyConstructible
\cgalModels Assignable
\cgalModels `ReadablePropertyMap`
\cgalModels{DefaultConstructible,CopyConstructible,Assignable,ReadablePropertyMap}
\sa `Arr_observer<Arrangement>`
\sa `Arr_vertex_index_map<Arrangement>`

29
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_geodesic_arc_on_sphere_traits_2.h
View File

@ -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 `ArrangementLandmarkTraits_2`
* \cgalModels `ArrangementSphericalBoundaryTraits_2`
* \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,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 `DefaultConstructible`
* \cgalModels `CopyConstructible`
* \cgalModels{Assignable,DefaultConstructible,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 `DefaultConstructible`
* \cgalModels `CopyConstructible`
* \cgalModels{Assignable,DefaultConstructible,CopyConstructible}
*/
class X_monotone_curve_2 {
public:
@ -287,10 +281,7 @@ namespace CGAL {
/*! Construction functor of a point.
*
* \cgalModels `Assignable`
* \cgalModels `CopyConstructible`
* \cgalModels `AdaptableUnaryFunction`
* \cgalModels `AdaptableTernaryFunction`
* \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableTernaryFunction}
*/
/*!
*/
@ -325,11 +316,7 @@ namespace CGAL {
/*! Construction functor of \f$x\f$-monotone geodesic arcs.
*
* \cgalModels `Assignable`
* \cgalModels `CopyConstructible`
* \cgalModels `AdaptableUnaryFunction`
* \cgalModels `AdaptableBinaryFunction`
* \cgalModels `AdaptableTernaryFunction`
* \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableBinaryFunction,AdaptableTernaryFunction}
*/
class Construct_x_monotone_curve_2 {
public:
@ -393,11 +380,7 @@ namespace CGAL {
/*! Construction functor of geodesic arcs.
*
* \cgalModels `Assignable`
* \cgalModels `CopyConstructible`
* \cgalModels `AdaptableUnaryFunction`
* \cgalModels `AdaptableBinaryFunction`
* \cgalModels `AdaptableTernaryFunction`
* \cgalModels{Assignable,CopyConstructible,AdaptableUnaryFunction,AdaptableBinaryFunction,AdaptableTernaryFunction}
*/
class Construct_curve_2 {
public:

3
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_landmarks_point_location.h
View File

@ -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 `ArrangementVerticalRayShoot_2`
\cgalModels{ArrangementPointLocation_2,ArrangementVerticalRayShoot_2}
\sa `ArrangementPointLocation_2`
\sa `ArrangementVerticalRayShoot_2`

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_line_arc_traits_2.h
View File

@ -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 >

4
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_linear_traits_2.h
View File

@ -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 `ArrangementLandmarkTraits_2`
* \cgalModels `ArrangementOpenBoundaryTraits_2`
* \cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementOpenBoundaryTraits_2}
*/
template< typename Kernel >
class Arr_linear_traits_2 {

3
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_naive_point_location.h
View File

@ -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 `ArrangementVerticalRayShoot_2`
\cgalModels{ArrangementPointLocation_2,ArrangementVerticalRayShoot_2}
\sa `ArrangementPointLocation_2`
\sa `ArrangementVerticalRayShoot_2`

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_non_caching_segment_basic_traits_2.h
View File

@ -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 >

4
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_non_caching_segment_traits_2.h
View File

@ -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 `ArrangementLandmarkTraits_2`
\cgalModels `ArrangementDirectionalXMonotoneTraits_2`
\cgalModels{ArrangementTraits_2,ArrangementLandmarkTraits_2,ArrangementDirectionalXMonotoneTraits_2}
\sa `Arr_segment_traits_2<Kernel>`

7
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_polycurve_traits_2.h
View File

@ -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 `ArrangementDirectionalXMonotoneTraits_2`
* \cgalModels `ArrangementApproximateTraits_2` (if the type that substitutes
* the template parameter `SubcurveTraits_2` models the concept as well)
* \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,
* ArrangementApproximateTraits_2 (if the type that substitutes
* 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>`

9
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_polyline_traits_2.h
View File

@ -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 `ArrangementDirectionalXMonotoneTraits_2`
* \cgalModels `ArrangementConstructXMonotoneCurveTraits_2`
* \cgalModels `ArrangementConstructCurveTraits_2`
* \cgalModels `ArrangementApproximateTraits_2` (if the type that substitutes
* the template parameter `SegmentTraits_2` models the concept as well)
* \cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,`ArrangementConstructXMonotoneCurveTraits_2`
* ArrangementConstructCurveTraits_2,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>`

20
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_rational_function_traits_2.h
View File

@ -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 `ArrangementDirectionalXMonotoneTraits_2`
\cgalModels `ArrangementOpenBoundaryTraits_2`
\cgalModels{ArrangementTraits_2,ArrangementDirectionalXMonotoneTraits_2,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 `CopyConstructible`
\cgalModels `AdaptableBinaryFunction`
\cgalModels `AdaptableUnaryFunction`
\cgalModels{Assignable,CopyConstructible,AdaptableBinaryFunction,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 `CopyConstructible`
\cgalModels `AdaptableBinaryFunction`
\cgalModels `AdaptableUnaryFunction`
\cgalModels{Assignable,CopyConstructible,AdaptableBinaryFunction,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 {

Some files were not shown because too many files have changed in this diff Show More