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

Documentation for BGL and SMP 

- Fixed the boost::graph_traits tables
- Seam mesh documentation
- Some minor changes to surface_mesh_parameterization's and ARAP's docs
This commit is contained in:
Mael Rouxel-Labbé 2016-11-11 19:00:27 +01:00
parent 7ce8fdf3f6
commit 40655269a2
6 changed files with 360 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
BGL/doc/BGL/PackageDescription.txt
View File

@ -10,8 +10,6 @@
related to it. Models of the concept and their related functions related to it. Models of the concept and their related functions
must be in the same namespace (they will be found by Koenig lookup). must be in the same namespace (they will be found by Koenig lookup).
\dot \dot
digraph example { digraph example {
node [shape=record, fontname=Helvetica, fontsize=10]; node [shape=record, fontname=Helvetica, fontsize=10];
@ -54,8 +52,6 @@ Associated Type | Description
`boost::graph_traits<G>::%vertex_iterator` | %Iterator over all vertices. `boost::graph_traits<G>::%vertex_iterator` | %Iterator over all vertices.
`boost::graph_traits<G>::%vertices_size_type` | Unsigned integer type for number of vertices. `boost::graph_traits<G>::%vertices_size_type` | Unsigned integer type for number of vertices.
Valid Expression | returns | Description Valid Expression | returns | Description
----------------- | --------------- | ----------------------- ----------------- | --------------- | -----------------------
`vertices(g)` | `std::pair<vertex_iterator, vertex_iterator>` | An iterator range over all vertices. `vertices(g)` | `std::pair<vertex_iterator, vertex_iterator>` | An iterator range over all vertices.
@ -71,7 +67,6 @@ Associated Type | Description
`boost::graph_traits<G>::%edge_iterator` | %Iterator over all edges. `boost::graph_traits<G>::%edge_iterator` | %Iterator over all edges.
`boost::graph_traits<G>::%edges_size_type` | Unsigned integer type for number of edges. `boost::graph_traits<G>::%edges_size_type` | Unsigned integer type for number of edges.
Valid Expression | returns | Description Valid Expression | returns | Description
----------------- | --------------- | ----------------------- ----------------- | --------------- | -----------------------
`edges(g)` | `std::pair<edge_iterator, edge_iterator>` | An iterator range over all edges. `edges(g)` | `std::pair<edge_iterator, edge_iterator>` | An iterator range over all edges.
@ -130,7 +125,6 @@ Associated Type | Description
`boost::graph_traits<G>::%halfedge_iterator` | A `BidirectionalIterator` over all halfedges in a graph. Must be `DefaultConstructible`, `Assignable`, `EqualityComparable`. `boost::graph_traits<G>::%halfedge_iterator` | A `BidirectionalIterator` over all halfedges in a graph. Must be `DefaultConstructible`, `Assignable`, `EqualityComparable`.
`boost::graph_traits<G>::%halfedges_size_type` | A size type. `boost::graph_traits<G>::%halfedges_size_type` | A size type.
Valid Expression | Returns | Description Valid Expression | Returns | Description
------------------------------------- | ------------------------------------------| ----------- ------------------------------------- | ------------------------------------------| -----------
`num_halfedges(g)` | `halfedges_size_type` | An upper bound of the number of halfedges of the graph. `num_halfedges(g)` | `halfedges_size_type` | An upper bound of the number of halfedges of the graph.
@ -148,7 +142,6 @@ Associated Type | Description
-------------------------------------------- | ------------ -------------------------------------------- | ------------
`boost::graph_traits<G>::%face_descriptor` | A `face_descriptor` corresponds to a unique face in a graph. Must be `DefaultConstructible`, `Assignable`, `EqualityComparable` and `LessThanComparable`. `boost::graph_traits<G>::%face_descriptor` | A `face_descriptor` corresponds to a unique face in a graph. Must be `DefaultConstructible`, `Assignable`, `EqualityComparable` and `LessThanComparable`.
Valid Expression | Returns | Description Valid Expression | Returns | Description
-------------------------------------- | ------------------------------------------------------------------------ | ------------------------ -------------------------------------- | ------------------------------------------------------------------------ | ------------------------
`face(h, g)` | `face_descriptor` | The face incident to halfedge `h`. `face(h, g)` | `face_descriptor` | The face incident to halfedge `h`.
@ -156,7 +149,6 @@ Valid Expression | Returns
`degree(f,g)` | `degree_size_type` | The number of halfedges incident to face `f`. `degree(f,g)` | `degree_size_type` | The number of halfedges incident to face `f`.
`boost::graph_traits<G>::%null_face()` | `face_descriptor` | A special face that is not equal to any other face. `boost::graph_traits<G>::%null_face()` | `face_descriptor` | A special face that is not equal to any other face.
\cgalHeading{%MutableFaceGraph} \cgalHeading{%MutableFaceGraph}
The concept `MutableFaceGraph` refines the concepts `FaceGraph` and `MutableHalfedgeGraph` and adds The concept `MutableFaceGraph` refines the concepts `FaceGraph` and `MutableHalfedgeGraph` and adds
@ -180,15 +172,11 @@ Associated Type | Description
`boost::graph_traits<G>::%face_iterator` | %Iterator over all faces. `boost::graph_traits<G>::%face_iterator` | %Iterator over all faces.
`boost::graph_traits<G>::%faces_size_type` | Unsigned integer type for number of faces. `boost::graph_traits<G>::%faces_size_type` | Unsigned integer type for number of faces.
Valid Expression | returns | Description Valid Expression | returns | Description
----------------- | --------------- | ----------------------- ----------------- | --------------- | -----------------------
`faces(g)` | `std::pair<face_iterator, face_iterator>` | An iterator range over all faces. `faces(g)` | `std::pair<face_iterator, face_iterator>` | An iterator range over all faces.
`num_faces(g)` | `faces_size_type` | An upper bound of the number of faces of the graph. `num_faces(g)` | `faces_size_type` | An upper bound of the number of faces of the graph.
*/ */
/// The property tags model of the boost concept <a href="http://www.boost.org/libs/graph/doc/PropertyTag.html"><code>PropertyTag</code></a>. /// The property tags model of the boost concept <a href="http://www.boost.org/libs/graph/doc/PropertyTag.html"><code>PropertyTag</code></a>.
@ -297,8 +285,9 @@ adapted types are listed here. The pages document which concepts they
model, the properties they support, and any possible caveats that a model, the properties they support, and any possible caveats that a
user might encounter. user might encounter.
- `boost::graph_traits< CGAL::Surface_mesh<P> >` - \link BGLSMGT `boost::graph_traits< CGAL::Surface_mesh<P> >` \endlink
- \link BGLPolyGT `boost::graph_traits< CGAL::Polyhedron_3<T> >` \endlink - \link BGLPolyGT `boost::graph_traits< CGAL::Polyhedron_3<T> >` \endlink
- \link BGLSeam_meshGT `boost::graph_traits< CGAL::Seam_mesh<T> >` \endlink
- \link BGLT2GT `boost::graph_traits< CGAL::Triangulation_2<GT, TDS> >` \endlink - \link BGLT2GT `boost::graph_traits< CGAL::Triangulation_2<GT, TDS> >` \endlink
- \link BGLArgtGT `boost::graph_traits< CGAL::Arrangement_2<T,DC> >` \endlink - \link BGLArgtGT `boost::graph_traits< CGAL::Arrangement_2<T,DC> >` \endlink
- \link BGLOMPAK `boost::graph_traits<OpenMesh::PolyMesh_ArrayKernelT<K> >` \endlink - \link BGLOMPAK `boost::graph_traits<OpenMesh::PolyMesh_ArrayKernelT<K> >` \endlink

284
BGL/doc/BGL/graph_traits.txt
View File

@ -3,25 +3,13 @@
\ingroup PkgBGL \ingroup PkgBGL
\sc{Bgl} defines the class template The \sc{Bgl} defines the class template
<A HREF="http://www.boost.org/libs/graph/doc/graph_traits.html">`boost::graph_traits`</A> <A HREF="http://www.boost.org/libs/graph/doc/graph_traits.html">`boost::graph_traits`</A>
as a uniform interface to the properties and types of %graph types. as a uniform interface to the properties and types of %graph types.
We provide specializations of this class template for several \cgal data structures. We provide specializations of this class template for several \cgal data structures.
\section BGLSeam_meshGT Specialization for the Seam_mesh Class
The traits class `boost::graph_traits< CGAL::Seam_mesh<T> >` provides the following types:
| Member | Value | Description |
| :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `Surface_mesh::Vertex_index` | The vertex descriptor |
\section BGLSMGT Specialization for the Surface_mesh Class \section BGLSMGT Specialization for the Surface_mesh Class
We provide partial specialization for the class `CGAL::Surface_mesh`, so that it is
model of the graph concept `FaceGraph`.
Defined in `<CGAL/boost/graph/graph_traits_Surface_mesh.h>` Defined in `<CGAL/boost/graph/graph_traits_Surface_mesh.h>`
We provide partial specialization for the class `CGAL::Surface_mesh` so that it is a model We provide partial specialization for the class `CGAL::Surface_mesh` so that it is a model
@ -37,25 +25,23 @@ The traits class `boost::graph_traits< CGAL::Surface_mesh<T> >` provides the fol
| Member | Value | Description | | Member | Value | Description |
| :----------------------- | :----: | :---------- | | :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `Surface_mesh::Vertex_index` | The vertex descriptor | | `vertex_descriptor` | `Surface_mesh::Vertex_index` | Identify vertices in the graph. |
| `edge_descriptor` | `Surface_mesh::Edge_index` | The edge descriptor | | `edge_descriptor` | `Surface_mesh::Edge_index` | Identify edges in the graph. |
| `halfedge_descriptor` | `Surface_mesh::Halfedge_index` | The halfedge descriptor | | `halfedge_descriptor` | `Surface_mesh::Halfedge_index` | Identify halfedges in the graph. |
| `face_descriptor` | `Surface_mesh::Face_index` | The face descriptor | | `face_descriptor` | `Surface_mesh::Face_index` | Identify faces in the graph. |
| `adjacency_iterator` | `CGAL::Vertex_around_target_iterator<Surface_mesh<P> >` | Iterates through adjacent vertices| | `adjacency_iterator` | `CGAL::Vertex_around_target_iterator<Surface_mesh<P> >` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `CGAL::Out_edge_iterator<Surface_mesh<P> >` | Iterate through the out-edges of a vertex. | | `out_edge_iterator` | `CGAL::Out_edge_iterator<Surface_mesh<P> >` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `CGAL::Out_edge_iterator<Surface_mesh<P> >` | Iterate through the in-edges of a vertex. | | `in_edge_iterator` | `CGAL::In_edge_iterator<Surface_mesh<P> >` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `Surface_mesh::Vertex_iterator` | Iterate through the vertices of a polyhedron.| | `vertex_iterator` | `Surface_mesh::Vertex_iterator` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `Surface_mesh::Edge_iterator` | Iterate through the edges of a polyhedron.| | `edge_iterator` | `Surface_mesh::Edge_iterator` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `halfedge_iterator` | `Surface_mesh::Halfedge_iterator` | Iterate through the halfedges of a polyhedron.| | `halfedge_iterator` | `Surface_mesh::Halfedge_iterator` | An iterator to traverse through the halfedges of the graph. Its value type is `halfedge_descriptor`. |
| `face_iterator` | `Surface_mesh::Face_iterator` | Iterate through the faces of a polyhedron.| | `face_iterator` | `Surface_mesh::Face_iterator` | An iterator to traverse through the faces of the graph. Its value type is `face_descriptor`. |
| `directed_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag` and `boost::edge_list_graph_tag` | | | `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does not support multiedges | | `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional | | `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `Surface_mesh::vertices_size_type` | The size type of the vertex list | | `vertices_size_type` | `Surface_mesh::vertices_size_type` | The size type of the vertex list. |
| `edges_size_type` | `Surface_mesh::edges_size_type` | The size type of the edge list | | `edges_size_type` | `Surface_mesh::edges_size_type` | The size type of the edge list. |
| `degree_size_type` | `Surface_mesh::degree_size_type` | The size type of the adjacency list | | `degree_size_type` | `Surface_mesh::degree_size_type` | The size type of the adjacency list. |
\section BGLPolyGT Specialization for the Polyhedron Class \section BGLPolyGT Specialization for the Polyhedron Class
@ -74,94 +60,58 @@ The traits class `boost::graph_traits< CGAL::Polyhedron_3<T> >` provides the fol
| Member | Value | Description | | Member | Value | Description |
| :----------------------- | :----: | :---------- | | :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `Polyhedron_3::Vertex_handle` | The vertex descriptor | | `vertex_descriptor` | `Polyhedron_3::Vertex_handle` | Identify vertices in the graph. |
| `edge_descriptor` | `unspecified_type` | The edge descriptor | | `edge_descriptor` | `unspecified_type` | Identify edges in the graph. |
| `halfedge_descriptor` | `Polyhedron_3::Halfedge_handle` | The halfedge descriptor | | `halfedge_descriptor` | `Polyhedron_3::Halfedge_handle` | Identify halfedges in the graph. |
| `face_descriptor` | `Polyhedron_3::Face_handle` | The face descriptor | | `face_descriptor` | `Polyhedron_3::Face_handle` | Identify faces in the graph. |
| `adjacency_iterator` | `CGAL::Vertex_around_target_iterator<Polyhedron_3<T> >` | Iterates through adjacent vertices| | `adjacency_iterator` | `CGAL::Vertex_around_target_iterator<Polyhedron_3<T> >` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `CGAL::Out_edge_iterator<Polyhedron_3<T> >` | Iterate through the out-edges of a vertex. | | `out_edge_iterator` | `CGAL::Out_edge_iterator<Polyhedron_3<T> >` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `CGAL::Out_edge_iterator<Polyhedron_3<T> >` | Iterate through the in-edges of a vertex. | | `in_edge_iterator` | `CGAL::In_edge_iterator<Polyhedron_3<T> >` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `unspecified_type` | Iterate through the vertices of a polyhedron.| | `vertex_iterator` | `unspecified_type` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `unspecified_type` | Iterate through the edges of a polyhedron.| | `edge_iterator` | `unspecified_type` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `halfedge_iterator` | `unspecified_type` | Iterate through the halfedges of a polyhedron.| | `halfedge_iterator` | `unspecified_type` | An iterator to traverse through the halfedges of the graph. Its value type is `halfedge_descriptor`. |
| `face_iterator` | `unspecified_type` | Iterate through the faces of a polyhedron.| | `face_iterator` | `unspecified_type` | An iterator to traverse through the faces of the graph. Its value type is `face_descriptor`. |
| `directed_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag` and `boost::edge_list_graph_tag` | | | `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does not support multiedges | | `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional | | `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `Polyhedron_3::size_type` | The size type of the vertex list | | `vertices_size_type` | `Polyhedron_3::size_type` | The size type of the vertex list. |
| `edges_size_type` | `Polyhedron_3::size_type` | The size type of the edge list | | `edges_size_type` | `Polyhedron_3::size_type` | The size type of the edge list. |
| `degree_size_type` | `Polyhedron_3::size_type` | The size type of the adjacency list | | `degree_size_type` | `Polyhedron_3::size_type` | The size type of the adjacency list. |
For convenience, the type `edge_descriptor` is hashable using the functor `CGAL::Handle_hash_function` For convenience, the type `edge_descriptor` is hashable using the functor `CGAL::Handle_hash_function`,
that is the default hash functor of `CGAL::Unique_hash_map`. which is the default hash functor of `CGAL::Unique_hash_map`.
\section BGLSeam_meshGT Specialization for the Seam_mesh Class
\section BGLOMPAK Specialization for the OpenMesh::PolyMesh_ArrayKernelT Class Defined in `<CGAL/boost/graph/graph_traits_Seam_mesh.h>`
Defined in `<CGAL/boost/graph/graph_traits_PolyMesh_ArrayKernelT.h>` We provide partial specialization for the class `CGAL::Seam_mesh` so that it is a model
We provide partial specialization for the class `OpenMesh::PolyMesh_ArrayKernelT` so that it is a model
of the graph concepts of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and <A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A> <A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>
and of the concept `MutableFaceGraph`. and of the concept `MutableFaceGraph`.
The traits class `boost::graph_traits<OpenMesh::PolyMesh_ArrayKernelT<K> >` provides the following types: The traits class `boost::graph_traits< CGAL::Seam_mesh<T> >` provides the following types:
| Member | Value | Description | | Member | Value | Description |
| :----------------------- | :----: | :---------- | | :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `OpenMesh::PolyMesh_ArrayKernelT::VertexHandle` | The vertex descriptor | | `vertex_descriptor` | `Seam_mesh::vertex_descriptor` | Identify vertices in the graph. |
| `edge_descriptor` | `unspecified_type` | The edge descriptor | | `edge_descriptor` | `Seam_mesh::edge_descriptor` | Identify edges in the graph. |
| `halfedge_descriptor` | `OpenMesh::PolyMesh_ArrayKernelT::HalfedgeHandle` | The halfedge descriptor | | `halfedge_descriptor` | `Seam_mesh::halfedge_descriptor` | Identify halfedges in the graph. |
| `face_descriptor` | `Surface_mesh::FaceHande` | The face descriptor | | `face_descriptor` | `Seam_mesh::face_descriptor` | Identify faces in the graph. |
| `adjacency_iterator` | `unspecified_type` | Iterates through adjacent vertices| | `adjacency_iterator` | `CGAL::Vertex_around_target_iterator<CGAL::Seam_mesh<T> >` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `unspecified_type` | Iterate through the out-edges of a vertex. | | `out_edge_iterator` | `CGAL::Out_edge_iterator<CGAL::Seam_mesh<T> >` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `unspecified_type` | Iterate through the in-edges of a vertex. | | `in_edge_iterator` | `CGAL::In_edge_iterator<CGAL::Seam_mesh<T> >` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `unspecified_type` | Iterate through the vertices of a polyhedron.| | `vertex_iterator` | `Seam_mesh::vertex_iterator` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `unspecified_type` | Iterate through the edges of a polyhedron.| | `edge_iterator` | `Seam_mesh::edge_iterator` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `halfedge_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::HalfedgeIter` | Iterate through the halfedges of a polyhedron.| | `halfedge_iterator` | `Seam_mesh::halfedge_iterator` | An iterator to traverse through the halfedges of the graph. Its value type is `halfedge_descriptor`. |
| `face_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::FaceIter` | Iterate through the faces of a polyhedron.| | `face_iterator` | `Seam_mesh::face_iterator` | An iterator to traverse through the faces of the graph. Its value type is `face_descriptor`. |
| `directed_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag` and `boost::edge_list_graph_tag` | | | `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does not support multiedges | | `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional | | `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `unsigned int` | The size type of the vertex list | | `vertices_size_type` | `Seam_mesh::vertices_size_type` | The size type of the vertex list. |
| `edges_size_type` | `unsigned int` | The size type of the edge list | | `edges_size_type` | `Seam_mesh::edges_size_type` | The size type of the edge list. |
| `degree_size_type` | `unsigned` | The size type of the adjacency list | | `degree_size_type` | `Seam_mesh::degree_size_type` | The size type of the adjacency list. |
\section BGLOMTMAK Specialization for the OpenMesh::TriMesh_ArrayKernelT Class
Defined in `<CGAL/boost/graph/graph_traits_TriMesh_ArrayKernelT.h>`
We provide partial specialization for the class `OpenMesh::TriMesh_ArrayKernelT` so that it is a model
of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>
and of the concept `MutableFaceGraph`.
The traits class `boost::graph_traits<OpenMesh::TriMesh_ArrayKernelT<K> >` provides the following types:
| Member | Value | Description |
| :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `OpenMesh::TriMesh_ArrayKernelT::VertexHandle` | The vertex descriptor |
| `edge_descriptor` | `unspecified_type` | The edge descriptor |
| `halfedge_descriptor` | `OpenMesh::TriMesh_ArrayKernelT::HalfedgeHandle` | The halfedge descriptor |
| `face_descriptor` | `Surface_mesh::FaceHande` | The face descriptor |
| `adjacency_iterator` | `unspecified_type` | Iterates through adjacent vertices|
| `out_edge_iterator` | `unspecified_type` | Iterate through the out-edges of a vertex. |
| `in_edge_iterator` | `unspecified_type` | Iterate through the in-edges of a vertex. |
| `vertex_iterator` | `unspecified_type` | Iterate through the vertices of a polyhedron.|
| `edge_iterator` | `unspecified_type` | Iterate through the edges of a polyhedron.|
| `halfedge_iterator` | `OpenMesh::TriMesh_ArrayKernelT::HalfedgeIter` | Iterate through the halfedges of a polyhedron.|
| `face_iterator` | `OpenMesh::TriMesh_ArrayKernelT::FaceIter` | Iterate through the faces of a polyhedron.|
| `directed_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag` and `boost::edge_list_graph_tag` | |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does not support multiedges |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional |
| `vertices_size_type` | `unsigned int` | The size type of the vertex list |
| `edges_size_type` | `unsigned int` | The size type of the edge list |
| `degree_size_type` | `unsigned` | The size type of the adjacency list |
\section BGLT2GT Specializations for the 2D Triangulation Classes \section BGLT2GT Specializations for the 2D Triangulation Classes
@ -182,7 +132,6 @@ so that they are model of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and <A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>. <A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>.
The mapping between vertices and edges of the triangulation and the The mapping between vertices and edges of the triangulation and the
graph is rather straightforward, but there are some subtleties. The graph is rather straightforward, but there are some subtleties. The
value type of the \sc{Bgl} iterators is the vertex or edge descriptor, value type of the \sc{Bgl} iterators is the vertex or edge descriptor,
@ -194,41 +143,41 @@ finite and infinite vertices and edges. As the edge weight computed
with the default property map of \sc{Bgl} algorithms (obtained with with the default property map of \sc{Bgl} algorithms (obtained with
`get(t, boost::edge_weight)`) is the length of the edge, `get(t, boost::edge_weight)`) is the length of the edge,
the edge weight is not well defined for infinite edges. For algorithms the edge weight is not well defined for infinite edges. For algorithms
that make use of the edge weight the user must therefore that make use of the edge weight, the user must therefore
define a <A HREF="http://www.boost.org/libs/graph/doc/filtered_graph.html">`boost::filtered_graph`</A> or pass a property map to the define a <A HREF="http://www.boost.org/libs/graph/doc/filtered_graph.html">`boost::filtered_graph`</A> or pass a property map to the
algorithm that returns "infinity" for infinite edges. algorithm that returns "infinity" for infinite edges.
Note also that when you derive from the class `CGAL::Triangulation_2` Note also that when you derive from the class `CGAL::Triangulation_2`,
you must upcast the object in order to use this partial specialization. you must upcast the object in order to use this partial specialization.
For the user convenience, \cgal provides the partial specializations For the user convenience, \cgal provides the partial specializations
for all 2D triangulation classes. for all 2D triangulation classes.
The traits class `boost::graph_traits< CGAL::Triangulation_2<GT, TDS> >` and The traits classes `boost::graph_traits< CGAL::Triangulation_2<GT, TDS> >` and
`boost::graph_traits< CGAL::Delaunay_triangulation_2<GT, TDS> >` `boost::graph_traits< CGAL::Delaunay_triangulation_2<GT, TDS> >`
provide the following types: provide the following types:
| Member | Value | Description | | Member | Value | Description |
| :----------------------- | :----: | :---------- | | :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `Triangulation::Vertex_handle` | The vertex descriptor | | `vertex_descriptor` | `Triangulation::Vertex_handle` | Identify vertices in the graph. |
| `edge_descriptor` | `unspecified_type` | It is constructible from and convertible to `Triangulation::Edge`. The edge descriptor is not a simple typedef, but a proper class, because in an undirected graph the edges `(u,v)` and `(v,u)` must be equal. This is not the case for the Edge type of the triangulation. | | `edge_descriptor` | `unspecified_type` | Identify edges in the graph. It is constructible from and convertible to `Triangulation::Edge`. It is not a simple typedef, but a proper class, because in an undirected graph the edges `(u,v)` and `(v,u)` must be equal. This is not the case for the Edge type of the triangulation. |
| `adjacency_iterator` | `unspecified_type` | An iterator for the vertices adjacent to a vertex. Its value type is `vertex_descriptor` | | `adjacency_iterator` | `unspecified_type` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `unspecified_type` | An iterator for the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. | | `out_edge_iterator` | `unspecified_type` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `unspecified_type` | An iterator for the incoming edges incident to a vertex. Its value type is `edge_descriptor`. | | `in_edge_iterator` | `unspecified_type` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `unspecified_type` | The vertex iterator type. Its value type is `vertex_descriptor` | | `vertex_iterator` | `unspecified_type` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `unspecified_type` | The edge iterator type, Its value type is `edge_descriptor` | | `edge_iterator` | `unspecified_type` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `directed_category` | `boost::undirected_tag` | | | `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does not support multiedges | | `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional | | `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::adjacency_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed.. |
| `vertices_size_type` | `Triangulation::size_type` | The size type of the vertex list | | `vertices_size_type` | `Triangulation::size_type` | The size type of the vertex list. |
| `edges_size_type` | `Triangulation::size_type` | The size type of the edge list | | `edges_size_type` | `Triangulation::size_type` | The size type of the edge list. |
| `degree_size_type` | `Triangulation::size_type` | The size type of the adjacency list | | `degree_size_type` | `Triangulation::size_type` | The size type of the adjacency list. |
\section BGLArgtGT Specialization for the Arrangement Classes \section BGLArgtGT Specialization for the Arrangement Classes
Defined in `<CGAL/boost/graph/graph_traits_Arrangement_2.h>` Defined in `<CGAL/boost/graph/graph_traits_Arrangement_2.h>`
We provide partial specialization for the class `Arrangement_2` We provide partial specialization for the class `CGAL::Arrangement_2`
so that it is model of the graph concepts so that it is model of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and <A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>. <A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>.
@ -236,22 +185,87 @@ so that it is model of the graph concepts
The const specialization, `boost::graph_traits< CGAL::Arrangement_2<Traits, Dcel> const>` The const specialization, `boost::graph_traits< CGAL::Arrangement_2<Traits, Dcel> const>`
is also defined, using the constant handles in the arrangement. is also defined, using the constant handles in the arrangement.
The traits class `boost::graph_traits< CGAL::Arrangement_2<T, DC> >` The traits class `boost::graph_traits< CGAL::Arrangement_2<T, Dcel> >`
provides the following types: provides the following types:
| Member | Value | Description | | Member | Value | Description |
| :----------------------- | :----: | :---------- | | :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `Arrangement_2::Vertex_handle` | The vertex descriptor | | `vertex_descriptor` | `Arrangement_2::Vertex_handle` | Identify vertices in the graph. |
| `edge_descriptor` | `Arrangement_2::Halfedge_handle` | The edge descriptor | | `edge_descriptor` | `Arrangement_2::Halfedge_handle` | Identify edges in the graph. |
| `adjacency_iterator` | Not provided| | | `adjacency_iterator` | Not provided| |
| `out_edge_iterator` | `unspecified_type` | An edge iterator which only iterates over the outgoing halfedges around a vertex. It corresponds to a `Arrangement_2::Halfedge_around_vertex_circulator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`| | `out_edge_iterator` | `unspecified_type` | An edge iterator which only iterates over the outgoing halfedges around a vertex. It corresponds to a `Arrangement_2::Halfedge_around_vertex_circulator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`|
| `in_edge_iterator` | `unspecified_type` | An edge iterator which only iterates over the incoming edges around a vertex. It corresponds to a `Arrangement_2::Halfedge_around_vertex_circulator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`| | `in_edge_iterator` | `unspecified_type` | An edge iterator which only iterates over the incoming edges around a vertex. It corresponds to a `Arrangement_2::Halfedge_around_vertex_circulator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`|
| `vertex_iterator` | `unspecified_type` | An iterator corresponding to `Arrangement_2::Vertex_iterator`, with the difference that its value type is a vertex descriptor and not `Arrangement_2::Vertex` | | `vertex_iterator` | `unspecified_type` | An iterator corresponding to `Arrangement_2::Vertex_iterator`, with the difference that its value type is a vertex descriptor and not `Arrangement_2::Vertex` |
| `edge_iterator` | `unspecified_type` | An iterator corresponding to `Arrangement_2::Halfedge_iterator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`| | `edge_iterator` | `unspecified_type` | An iterator corresponding to `Arrangement_2::Halfedge_iterator` with the difference that its value type is an edge descriptor and not `Arrangement_2::Halfedge`|
| `directed_category` | `boost::directed_tag` | | | `directed_category` | `boost::directed_tag` | This graph is directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | Indicates that this graph does support multiedges | | `edge_parallel_category` | `boost::allow_parallel_edge_tag` | This graph supports multiedges. |
| `traversal_category` | `boost::bidirectional_graph_tag` | Indicates that this graph is bidirectional | | `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `Arrangement_2::size_type` | The size type of the vertex list | | `vertices_size_type` | `Arrangement_2::Size` | The size type of the vertex list. |
| `edges_size_type` | `Arrangement_2::size_type` | The size type of the edge list | | `edges_size_type` | `Arrangement_2::Size` | The size type of the edge list. |
| `degree_size_type` | `Arrangement_2::size_type` | The size type of the adjacency list | | `degree_size_type` | `Arrangement_2::Size` | The size type of the adjacency list. |
\section BGLOMPAK Specialization for the OpenMesh::PolyMesh_ArrayKernelT Class
Defined in `<CGAL/boost/graph/graph_traits_PolyMesh_ArrayKernelT.h>`
We provide partial specialization for the class `OpenMesh::PolyMesh_ArrayKernelT` so that it is a model
of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>
and of the concept `MutableFaceGraph`.
The traits class `boost::graph_traits<OpenMesh::PolyMesh_ArrayKernelT<K> >` provides the following types:
| Member | Value | Description |
| :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `OpenMesh::PolyMesh_ArrayKernelT::VertexHandle` | Identify vertices in the graph. |
| `edge_descriptor` | `unspecified_type` | Identify edges in the graph. |
| `halfedge_descriptor` | `OpenMesh::PolyMesh_ArrayKernelT::HalfedgeHandle` | Identify halfedges in the graph. |
| `face_descriptor` | `OpenMesh::PolyMesh_ArrayKernelT::FaceHandle` | Identify faces in the graph. |
| `adjacency_iterator` | `unspecified_type` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `CGAL::Out_edge_iterator<OpenMesh::PolyMesh_ArrayKernelT<K> >` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `CGAL::In_edge_iterator<OpenMesh::PolyMesh_ArrayKernelT<K> >` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::VertexIter` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `unspecified_type` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `halfedge_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::HalfedgeIter` | An iterator to traverse through the halfedges of the graph. Its value type is `halfedge_descriptor`. |
| `face_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::FaceIter` | An iterator to traverse through the faces of the graph. Its value type is `face_descriptor`. |
| `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `unsigned int` | The size type of the vertex list. |
| `edges_size_type` | `unsigned int` | The size type of the edge list. |
| `degree_size_type` | `unsigned int` | The size type of the adjacency list. |
\section BGLOMTMAK Specialization for the OpenMesh::TriMesh_ArrayKernelT Class
Defined in `<CGAL/boost/graph/graph_traits_TriMesh_ArrayKernelT.h>`
We provide partial specialization for the class `OpenMesh::TriMesh_ArrayKernelT` so that it is a model
of the graph concepts
<A HREF="http://www.boost.org/libs/graph/doc/BidirectionalGraph.html">`BidirectionalGraph`</A> and
<A HREF="http://www.boost.org/libs/graph/doc/VertexAndEdgeListGraph.html">`VertexAndEdgeListGraph`</A>
and of the concept `MutableFaceGraph`.
The traits class `boost::graph_traits<OpenMesh::TriMesh_ArrayKernelT<K> >` provides the following types:
| Member | Value | Description |
| :----------------------- | :----: | :---------- |
| `vertex_descriptor` | `OpenMesh::TriMesh_ArrayKernelT::VertexHandle` | Identify vertices in the graph. |
| `edge_descriptor` | `unspecified_type` | Identify edges in the graph. |
| `halfedge_descriptor` | `OpenMesh::TriMesh_ArrayKernelT::HalfedgeHandle` | Identify halfedges in the graph. |
| `face_descriptor` | `OpenMesh::TriMesh_ArrayKernelT::FaceHandle` | Identify faces in the graph. |
| `adjacency_iterator` | `unspecified_type` | An iterator to traverse through the vertices adjacent to a vertex. Its value type is `vertex_descriptor`. |
| `out_edge_iterator` | `CGAL::Out_edge_iterator<OpenMesh::TriMesh_ArrayKernelT<K> >` | An iterator to traverse through the outgoing edges incident to a vertex. Its value type is `edge_descriptor`. |
| `in_edge_iterator` | `CGAL::In_edge_iterator<OpenMesh::TriMesh_ArrayKernelT<K> >` | An iterator to traverse through the incoming edges incident to a vertex. Its value type is `edge_descriptor`. |
| `vertex_iterator` | `OpenMesh::PolyMesh_ArrayKernelT::VertexIter` | An iterator to traverse through the vertices of the graph. Its value type is `vertex_descriptor`. |
| `edge_iterator` | `unspecified_type` | An iterator to traverse through the edges of the graph. Its value type is `edge_descriptor`. |
| `halfedge_iterator` | `OpenMesh::TriMesh_ArrayKernelT::HalfedgeIter` | An iterator to traverse through the halfedges of the graph. Its value type is `halfedge_descriptor`. |
| `face_iterator` | `OpenMesh::TriMesh_ArrayKernelT::FaceIter` | An iterator to traverse through the faces of the graph. Its value type is `face_descriptor`. |
| `directed_category` | `boost::undirected_tag` | This graph is not directed. |
| `edge_parallel_category` | `boost::disallow_parallel_edge_tag` | This graph does not support multiedges. |
| `traversal_category` | Inherits from `boost::bidirectional_graph_tag`, `boost::vertex_list_graph_tag`, and `boost::edge_list_graph_tag` | The ways in which the vertices in the graph can be traversed. |
| `vertices_size_type` | `unsigned int` | The size type of the vertex list. |
| `edges_size_type` | `unsigned int` | The size type of the edge list. |
| `degree_size_type` | `unsigned int` | The size type of the adjacency list. |
*/ */

224
BGL/include/CGAL/boost/graph/Seam_mesh.h
View File

@ -39,6 +39,7 @@
namespace CGAL { namespace CGAL {
#ifndef DOXYGEN_RUNNING
template <typename HD> template <typename HD>
struct Seam_mesh_halfedge_descriptor struct Seam_mesh_halfedge_descriptor
{ {
@ -91,24 +92,22 @@ struct Seam_mesh_halfedge_descriptor
return 2 * hash_value(hd.tmhd) + static_cast<std::size_t>(hd.seam); return 2 * hash_value(hd.tmhd) + static_cast<std::size_t>(hd.seam);
} }
}; };
#endif
/*! /// \ingroup PkgBGLHelper
\ingroup PkgBGLHelper ///
/// This class is a data structure that takes a triangle mesh, further refered
An adaptor for a triangle mesh which turns some marked edges into /// to as `underlying mesh` and turns some marked edges of that mesh into
boundary edges when exploring the seam mesh with the generic BGL style /// virtual boundary edges.
functions. ///
/// \cgalModels `FaceGraph`
\cgalModels `FaceGraph` ///
/// \tparam TM a model of `FaceGraph`
\tparam TM a model of `FaceGraph` /// \tparam SEM a model of `ReadablePropertyMap` with `boost::graph_traits<TM>::%edge_descriptor` as key type and `bool` as value type.
\tparam SEM a model of `ReadablePropertyMap` with `boost::graph_traits<TM>::%edge_descriptor` as key type and `bool` as value type. /// \tparam SVM a model of `ReadablePropertyMap` with `boost::graph_traits<TM>::%vertex_descriptor` as key type and `bool` as value type.
\tparam SVM a model of `ReadablePropertyMap` with `boost::graph_traits<TM>::%vertex_descriptor` as key type and `bool` as value type. ///
/// \sa \link BGLSeam_meshGT `boost::graph_traits<Seam_mesh<TM> >` \endlink
\sa \link BGLSeam_meshGT `boost::graph_traits<Seam_mesh<TM> >` \endlink ///
*/
template <class TM, class SEM, class SVM> template <class TM, class SEM, class SVM>
class Seam_mesh class Seam_mesh
{ {
@ -125,13 +124,11 @@ class Seam_mesh
typedef boost::associative_property_map<Seam_vertex_uhm> Seam_vertex_pmap; typedef boost::associative_property_map<Seam_vertex_uhm> Seam_vertex_pmap;
public: public:
/// @cond CGAL_DOCUMENT_INTERNALS
typedef typename boost::graph_traits<TM>::degree_size_type degree_size_type; typedef typename boost::graph_traits<TM>::degree_size_type degree_size_type;
typedef typename boost::graph_traits<TM>::vertices_size_type vertices_size_type; typedef typename boost::graph_traits<TM>::vertices_size_type vertices_size_type;
typedef typename boost::graph_traits<TM>::edges_size_type edges_size_type; typedef typename boost::graph_traits<TM>::edges_size_type edges_size_type;
typedef typename boost::graph_traits<TM>::halfedges_size_type halfedges_size_type; typedef typename boost::graph_traits<TM>::halfedges_size_type halfedges_size_type;
typedef typename boost::graph_traits<TM>::faces_size_type faces_size_type; typedef typename boost::graph_traits<TM>::faces_size_type faces_size_type;
/// @endcond
private: private:
const TM& tm; const TM& tm;
@ -145,19 +142,47 @@ private:
mutable vertices_size_type number_of_vertices; mutable vertices_size_type number_of_vertices;
public: public:
/// Return the underlying mesh. /// returns the underlying mesh.
const TM& mesh() const const TM& mesh() const
{ {
return tm; return tm;
} }
/// @cond CGAL_DOCUMENT_INTERNALS #ifdef DOXYGEN_RUNNING
/// This class represents a halfedge of the seam mesh.
///
/// It is composed of a halfedge of the mesh and a boolean to indicate whether
/// this halfedge is on the virtual border or not.
///
/// \cgalModels `descriptor`
/// \cgalModels `LessThanComparable`
/// \cgalModels `Hashable`
///
class halfedge_descriptor
{
public:
TM_halfedge_descriptor tmhd;
bool seam;
/// A halfedge /// %Default constructor
// descriptor halfedge_descriptor() : tmhd(), seam(false) { }
halfedge_descriptor(TM_halfedge_descriptor tmhd, bool seam = false)
: tmhd(tmhd), seam(seam)
{ }
/// Print the halfedge and if it is on a seam.
friend std::ostream& operator<<(std::ostream& os, const halfedge_descriptor& hd)
{
os << hd.tmhd << ((hd.seam)?" on seam":"");
return os;
}
};
#else
typedef Seam_mesh_halfedge_descriptor<TM_halfedge_descriptor> halfedge_descriptor; typedef Seam_mesh_halfedge_descriptor<TM_halfedge_descriptor> halfedge_descriptor;
#endif
// iterator #ifndef DOXYGEN_RUNNING
struct halfedge_iterator struct halfedge_iterator
: public boost::iterator_facade<halfedge_iterator, : public boost::iterator_facade<halfedge_iterator,
halfedge_descriptor, halfedge_descriptor,
@ -212,13 +237,23 @@ public:
return halfedge_descriptor(*hd, seam); return halfedge_descriptor(*hd, seam);
} }
}; };
#endif
/// A vertex /// This class represents a vertex of the seam mesh.
// descriptor ///
/// Implementation note: to properly duplicate vertices that are on seams,
/// a vertex_descriptor is in fact represented as an halfedge of the underlying
/// mesh.
///
/// \cgalModels `descriptor`
/// \cgalModels `LessThanComparable`
/// \cgalModels `Hashable`
///
struct vertex_descriptor struct vertex_descriptor
{ {
halfedge_descriptor hd; halfedge_descriptor hd;
/// %Default constructor
vertex_descriptor() { } vertex_descriptor() { }
vertex_descriptor(const halfedge_descriptor& h) vertex_descriptor(const halfedge_descriptor& h)
@ -262,6 +297,7 @@ public:
}; };
// iterator // iterator
#ifndef DOXYGEN_RUNNING
class vertex_iterator class vertex_iterator
: public boost::iterator_facade<vertex_iterator, : public boost::iterator_facade<vertex_iterator,
vertex_descriptor, vertex_descriptor,
@ -354,9 +390,12 @@ public:
return vertex_descriptor(*hd); return vertex_descriptor(*hd);
} }
}; };
#endif
/// An edge /// This class represents an edge of the seam mesh.
// descriptor ///
/// \cgalModels `descriptor`
///
struct edge_descriptor struct edge_descriptor
{ {
halfedge_descriptor hd; halfedge_descriptor hd;
@ -373,6 +412,7 @@ public:
{ } { }
}; };
#ifndef DOXYGEN_RUNNING
// iterator // iterator
struct edge_iterator struct edge_iterator
: public boost::iterator_facade<edge_iterator, : public boost::iterator_facade<edge_iterator,
@ -452,25 +492,35 @@ public:
return edge_descriptor(halfedge_descriptor(*hd, false)); return edge_descriptor(halfedge_descriptor(*hd, false));
} }
}; };
#endif
/// A face /// This class represents a face of the seam mesh.
// descriptor ///
/// \cgalModels `descriptor`
///
typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor; typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor;
// iterator
#ifndef DOXYGEN_RUNNING
typedef typename boost::graph_traits<TM>::face_iterator face_iterator; typedef typename boost::graph_traits<TM>::face_iterator face_iterator;
#endif
public: public:
/// Seam-related functions /// \name Seam-related functions
/// @{
/// returns `true` if the vertex is on the seam.
bool has_on_seam(TM_vertex_descriptor vd) const bool has_on_seam(TM_vertex_descriptor vd) const
{ {
return get(svm, vd); return get(svm, vd);
} }
/// returns `true` if the edge is on the seam.
bool has_on_seam(TM_edge_descriptor ed) const bool has_on_seam(TM_edge_descriptor ed) const
{ {
return get(sem, ed); return get(sem, ed);
} }
/// returns `true` if the halfedge is on the seam.
bool has_on_seam(TM_halfedge_descriptor tmhd) const bool has_on_seam(TM_halfedge_descriptor tmhd) const
{ {
return get(sem, CGAL::edge(tmhd, tm)); return get(sem, CGAL::edge(tmhd, tm));
@ -482,21 +532,41 @@ public:
return has_on_seam(CGAL::edge(hd, tm)); return has_on_seam(CGAL::edge(hd, tm));
} }
/// Return the number of seam edges in the seam mesh.
edges_size_type number_of_seam_edges() const
{
return number_of_seams;
}
/// Set the number of seam edges.
void set_seam_edges_number(const edges_size_type sn) const
{
number_of_seams = sn;
}
/// @}
public: public:
/// Iterators /// \name Range Types
// vertices() ///
///@{
/// @cond CGAL_BEGIN_END
/// Start iterator for vertices.
vertex_iterator vertices_begin() const vertex_iterator vertices_begin() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return vertex_iterator(ir, this); return vertex_iterator(ir, this);
} }
/// End iterator for vertices.
vertex_iterator vertices_end() const vertex_iterator vertices_end() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return vertex_iterator(ir.second, this); return vertex_iterator(ir.second, this);
} }
/// @endcond
/// returns the iterator range of the vertices of the mesh.
Iterator_range<vertex_iterator> vertices() const Iterator_range<vertex_iterator> vertices() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -505,19 +575,24 @@ public:
return make_range(beg, end); return make_range(beg, end);
} }
// halfedges() /// @cond CGAL_BEGIN_END
/// Start iterator for halfedges.
halfedge_iterator halfedges_begin() const halfedge_iterator halfedges_begin() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return halfedge_iterator(ir, this); return halfedge_iterator(ir, this);
} }
/// End iterator for halfedges.
halfedge_iterator halfedges_end() const halfedge_iterator halfedges_end() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return halfedge_iterator(ir.second, this); return halfedge_iterator(ir.second, this);
} }
/// @endcond
/// returns the iterator range of the halfedges of the mesh.
Iterator_range<halfedge_iterator> halfedges() const Iterator_range<halfedge_iterator> halfedges() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -526,19 +601,23 @@ public:
return make_range(beg, end); return make_range(beg, end);
} }
// edges() /// @cond CGAL_BEGIN_END
/// Start iterator for edges.
edge_iterator edges_begin() const edge_iterator edges_begin() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return edge_iterator(ir, this); return edge_iterator(ir, this);
} }
/// End iterator for edges.
edge_iterator edges_end() const edge_iterator edges_end() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
return edge_iterator(ir.second, this); return edge_iterator(ir.second, this);
} }
/// @endcond
/// returns the iterator range of the edges of the mesh.
Iterator_range<edge_iterator> edges() const Iterator_range<edge_iterator> edges() const
{ {
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm); Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -547,24 +626,32 @@ public:
return make_range(beg, end); return make_range(beg, end);
} }
// faces() /// @cond CGAL_BEGIN_END
/// Start iterator for faces.
face_iterator faces_begin() const face_iterator faces_begin() const
{ {
return CGAL::faces(tm).begin(); return CGAL::faces(tm).begin();
} }
/// End iterator for faces.
face_iterator faces_end() const face_iterator faces_end() const
{ {
return CGAL::faces(tm).end(); return CGAL::faces(tm).end();
} }
/// @endcond
/// returns the iterator range of the faces of the mesh.
Iterator_range<face_iterator> faces() const Iterator_range<face_iterator> faces() const
{ {
return CGAL::faces(tm); return CGAL::faces(tm);
} }
///@}
public: public:
/// Numbering /// \name Memory Management
/// @{
/// returns the number of vertices in the seam mesh.
vertices_size_type num_vertices() const vertices_size_type num_vertices() const
{ {
if(number_of_vertices == static_cast<vertices_size_type>(-1)) { if(number_of_vertices == static_cast<vertices_size_type>(-1)) {
@ -574,22 +661,30 @@ public:
return number_of_vertices; return number_of_vertices;
} }
/// returns the number of halfedges in the seam mesh.
halfedges_size_type num_halfedges() const halfedges_size_type num_halfedges() const
{ {
return CGAL::num_halfedges(tm) + 2 * number_of_seams; return CGAL::num_halfedges(tm) + 2 * number_of_seams;
} }
/// returns the number of edges in the seam mesh.
halfedges_size_type num_edges() const halfedges_size_type num_edges() const
{ {
return CGAL::num_edges(tm) + number_of_seams; return CGAL::num_edges(tm) + number_of_seams;
} }
/// returns the number of faces in the seam mesh.
faces_size_type num_faces() const faces_size_type num_faces() const
{ {
return CGAL::num_faces(tm); return CGAL::num_faces(tm);
} }
/// @}
public: public:
/// \name Degree Functions
/// @{
/// returns the number of incident halfedges of vertex `v`.
degree_size_type degree(vertex_descriptor v) const degree_size_type degree(vertex_descriptor v) const
{ {
degree_size_type count(0); degree_size_type count(0);
@ -604,25 +699,41 @@ public:
return count; return count;
} }
/// @}
public: public:
/// Descriptors /// \name Switching between Halfedges and Edges
///@{
/// returns the edge that contains halfedge `h` as one of its two halfedges.
edge_descriptor edge(halfedge_descriptor h) const edge_descriptor edge(halfedge_descriptor h) const
{ {
return h; return h;
} }
/// returns the halfedge corresponding to the edge `e`.
halfedge_descriptor halfedge(edge_descriptor e) const halfedge_descriptor halfedge(edge_descriptor e) const
{ {
return e.hd; return e.hd;
} }
/// @}
/// \name Low-Level Connectivity Convenience Functions
///@{
/// returns an incoming halfedge of vertex `v`.
/// If `v` is a seam vertex, this will be a halfedge that points to `v` and
/// whose opposite is a seam halfedge.
/// Otherwise, the rules of the underlying meshes are followed.
/// \invariant `target(halfedge(v)) == v`
halfedge_descriptor halfedge(vertex_descriptor v) const halfedge_descriptor halfedge(vertex_descriptor v) const
{ {
TM_halfedge_descriptor h(v); TM_halfedge_descriptor h(v);
return halfedge_descriptor(h, false /*not on seam*/); return halfedge_descriptor(h, false /*not on seam*/);
} }
/// finds a halfedge between two vertices. Returns a default constructed
/// `halfedge_descriptor`, if `source` and `target` are not connected.
std::pair<halfedge_descriptor, bool> halfedge(vertex_descriptor u, std::pair<halfedge_descriptor, bool> halfedge(vertex_descriptor u,
vertex_descriptor v) const vertex_descriptor v) const
{ {
@ -662,18 +773,22 @@ public:
return std::make_pair(halfedge_descriptor(), false/*invalid*/); return std::make_pair(halfedge_descriptor(), false/*invalid*/);
} }
/// finds an edge between two vertices. Returns a default constructed
/// `edge`, if `source` and `target` are not connected.
std::pair<edge_descriptor, bool> edge(vertex_descriptor u, vertex_descriptor v) const std::pair<edge_descriptor, bool> edge(vertex_descriptor u, vertex_descriptor v) const
{ {
std::pair<halfedge_descriptor, bool> he = halfedge(u, v); std::pair<halfedge_descriptor, bool> he = halfedge(u, v);
return std::make_pair(he.first, he.second); return std::make_pair(he.first, he.second);
} }
/// returns a halfedge of face `f`.
halfedge_descriptor halfedge(face_descriptor f) const halfedge_descriptor halfedge(face_descriptor f) const
{ {
TM_halfedge_descriptor hd = CGAL::halfedge(f, tm); TM_halfedge_descriptor hd = CGAL::halfedge(f, tm);
return halfedge_descriptor(hd, false/*not on seam*/); return halfedge_descriptor(hd, false/*not on seam*/);
} }
/// returns the face incident to halfedge `h`.
face_descriptor face(halfedge_descriptor h) const face_descriptor face(halfedge_descriptor h) const
{ {
if(h.seam) if(h.seam)
@ -683,7 +798,7 @@ public:
} }
public: public:
/// halfedge traveling /// returns the next halfedge within the incident face.
halfedge_descriptor next(const halfedge_descriptor& hd) const halfedge_descriptor next(const halfedge_descriptor& hd) const
{ {
if((!hd.seam) && (!is_border(hd.tmhd, tm))) if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@ -698,6 +813,7 @@ public:
!is_border(CGAL::opposite(*hatc, tm), tm)); !is_border(CGAL::opposite(*hatc, tm), tm));
} }
/// returns the previous halfedge within the incident face.
halfedge_descriptor prev(const halfedge_descriptor& hd) const halfedge_descriptor prev(const halfedge_descriptor& hd) const
{ {
if((!hd.seam) && (!is_border(hd.tmhd, tm))) if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@ -712,6 +828,7 @@ public:
!is_border(CGAL::opposite(*hatc, tm), tm)); !is_border(CGAL::opposite(*hatc, tm), tm));
} }
/// returns the opposite halfedge of `hd`.
halfedge_descriptor opposite(const halfedge_descriptor& hd) const halfedge_descriptor opposite(const halfedge_descriptor& hd) const
{ {
if(!hd.seam) if(!hd.seam)
@ -720,6 +837,7 @@ public:
return halfedge_descriptor(CGAL::opposite(hd.tmhd, tm), false /*not on seam*/); return halfedge_descriptor(CGAL::opposite(hd.tmhd, tm), false /*not on seam*/);
} }
/// returns the vertex the halfedge `h` emanates from.
vertex_descriptor target(halfedge_descriptor hd) const vertex_descriptor target(halfedge_descriptor hd) const
{ {
TM_halfedge_descriptor tmhd(hd); TM_halfedge_descriptor tmhd(hd);
@ -739,6 +857,7 @@ public:
return vertex_descriptor(halfedge_descriptor(tmhd)); return vertex_descriptor(halfedge_descriptor(tmhd));
} }
/// returns the vertex the halfedge `h` emanates from.
vertex_descriptor source(const halfedge_descriptor& hd) const vertex_descriptor source(const halfedge_descriptor& hd) const
{ {
return target(opposite(hd)); return target(opposite(hd));
@ -754,29 +873,18 @@ public:
return target(e.hd); return target(e.hd);
} }
/// @endcond /// @}
/// Return the number of seam edges in the seam mesh. /// Add the seams to the property maps of the seam mesh.
edges_size_type number_of_seam_edges() const
{
return number_of_seams;
}
/// Set the number of seam edges.
void set_seam_edges_number(const edges_size_type sn) const
{
number_of_seams = sn;
}
/// Add seams to the property maps of the seam mesh.
/// ///
/// In input, a seam edge is described by the pair of integers that correspond /// In input, a seam edge is described by the pair of integers that correspond
/// to the indices of the extremeties (vertices) of the edge that one wishes /// to the indices of the extremeties (vertices) of the edge that should be
/// to mark as seam edge. /// marked as seam edge.
/// ///
/// @pre filename should be the name of a CGAL selection file: seam edges /// @pre filename should be the name of a CGAL selection file: seam edges
/// are given as pairs of integers, on the third line of the file /// are given as pairs of integers, on the third line of the file.
/// @pre A seam edge must be an edge of the graph /// @pre A seam edge must be an edge of the graph that is not on the boundary
/// of the mesh.
TM_halfedge_descriptor add_seams(const char* filename) TM_halfedge_descriptor add_seams(const char* filename)
{ {
TM_halfedge_descriptor tmhd; TM_halfedge_descriptor tmhd;

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h
View File

@ -230,6 +230,12 @@ namespace Polygon_mesh_processing {
} }
/// Count the number of borders in the mesh.
///
/// @tparam PolygonMesh model of `HalfedgeGraph`.
///
/// @param pmesh the polygon mesh to which `faces` belong
///
template<typename PolygonMesh> template<typename PolygonMesh>
unsigned int number_of_borders(const PolygonMesh& pmesh) unsigned int number_of_borders(const PolygonMesh& pmesh)
{ {

12
Surface_mesh_parameterization/doc/Surface_mesh_parameterization/PackageDescription.txt
View File

@ -89,17 +89,11 @@ The package performs the next checks:
- the border is mapped onto a convex polygon. - the border is mapped onto a convex polygon.
- the input mesh is triangular. - the input mesh is triangular.
- the input mesh is a surface with one connected component. - the input mesh is a surface with one connected component.
- Postconditions:
- one-to-one mapping.
- For <i>free</i> border parameterizations: - For <i>free</i> border parameterizations:
- Preconditions: - Preconditions:
- the input mesh is triangular. - the input mesh is triangular.
- the input mesh is a surface with one connected component. - the input mesh is a surface with one connected component.
- Postconditions:
- one-to-one mapping.
*/ */
/// \defgroup PkgSurfaceParameterizationMainFunction Main Function /// \defgroup PkgSurfaceParameterizationMainFunction Main Function
@ -146,11 +140,5 @@ This package implements all common border parameterization methods:
vertices). vertices).
*/ */
*/ */

11
Surface_mesh_parameterization/doc/Surface_mesh_parameterization/Surface_mesh_parameterization.txt
View File

@ -244,10 +244,13 @@ Left: Julius Cesar mask parameterization with Authalic/circular border. Right: J
All combinations of uniform/arc-length and circle/square are provided by All combinations of uniform/arc-length and circle/square are provided by
the following classes: the following classes:
`Circular_border_arc_length_parameterizer_3<TriangleMesh>`
`Circular_border_uniform_parameterizer_3<TriangleMesh>` <UL>
`Square_border_arc_length_parameterizer_3<TriangleMesh>` <LI>`Circular_border_arc_length_parameterizer_3<TriangleMesh>`
`Square_border_uniform_parameterizer_3<TriangleMesh>` <LI>`Circular_border_uniform_parameterizer_3<TriangleMesh>`
<LI>`Square_border_arc_length_parameterizer_3<TriangleMesh>`
<LI>`Square_border_uniform_parameterizer_3<TriangleMesh>`
</UL>
\subsection Surface_mesh_parameterizationFreeBorderSurface Free Border Surface Parameterizations \subsection Surface_mesh_parameterizationFreeBorderSurface Free Border Surface Parameterizations