From ada75c9e456f5554d4a10e649da37a7e5a510e01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Philipp=20M=C3=B6ller?= Date: Tue, 18 Sep 2012 14:10:54 +0000 Subject: [PATCH] Add BGL doc. --- .gitattributes | 17 + BGL/doc/BGL/BGL.txt | 335 ++++++++++++++++++ .../CGAL/HalfedgeDS_face_max_base_with_id.h | 58 +++ .../HalfedgeDS_halfedge_max_base_with_id.h | 57 +++ .../CGAL/HalfedgeDS_vertex_max_base_with_id.h | 57 +++ BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h | 63 ++++ .../Triangulation_vertex_base_with_id_2.h | 48 +++ .../boost/graph/graph_traits_Arrangement_2.h | 96 +++++ .../boost/graph/graph_traits_Polyhedron_3.h | 98 +++++ .../graph/graph_traits_Triangulation_2.h | 97 +++++ .../halfedge_graph_traits_Polyhedron_3.h | 35 ++ BGL/doc/BGL/CGAL/boost/graph/properties.h | 73 ++++ BGL/doc/BGL/Concepts/HalfedgeGraph.h | 141 ++++++++ BGL/doc/BGL/PackageDescription.txt | 21 ++ BGL/doc/BGL/fig/emst-detail.png | Bin 0 -> 1749 bytes BGL/doc/BGL/fig/emst.jpg | Bin 0 -> 51452 bytes BGL/doc/BGL/fig/ex_bgl.gif | Bin 0 -> 5526 bytes BGL/doc/BGL/fig/ex_bgl.pdf | Bin 0 -> 4317 bytes Documentation/doxyassist.xml | 20 ++ 19 files changed, 1216 insertions(+) create mode 100644 BGL/doc/BGL/BGL.txt create mode 100644 BGL/doc/BGL/CGAL/HalfedgeDS_face_max_base_with_id.h create mode 100644 BGL/doc/BGL/CGAL/HalfedgeDS_halfedge_max_base_with_id.h create mode 100644 BGL/doc/BGL/CGAL/HalfedgeDS_vertex_max_base_with_id.h create mode 100644 BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h create mode 100644 BGL/doc/BGL/CGAL/Triangulation_vertex_base_with_id_2.h create mode 100644 BGL/doc/BGL/CGAL/boost/graph/graph_traits_Arrangement_2.h create mode 100644 BGL/doc/BGL/CGAL/boost/graph/graph_traits_Polyhedron_3.h create mode 100644 BGL/doc/BGL/CGAL/boost/graph/graph_traits_Triangulation_2.h create mode 100644 BGL/doc/BGL/CGAL/boost/graph/halfedge_graph_traits_Polyhedron_3.h create mode 100644 BGL/doc/BGL/CGAL/boost/graph/properties.h create mode 100644 BGL/doc/BGL/Concepts/HalfedgeGraph.h create mode 100644 BGL/doc/BGL/PackageDescription.txt create mode 100644 BGL/doc/BGL/fig/emst-detail.png create mode 100644 BGL/doc/BGL/fig/emst.jpg create mode 100644 BGL/doc/BGL/fig/ex_bgl.gif create mode 100644 BGL/doc/BGL/fig/ex_bgl.pdf diff --git a/.gitattributes b/.gitattributes index 5a3be227975..687327bcc27 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1426,6 +1426,23 @@ Arrangement_on_surface_2/test/Sweep_line_2/cgal_test_with_cmake eol=lf Arrangement_on_surface_2/test/Sweep_line_2/test_sweep.cpp eol=lf Arrangement_on_surface_2/test/Sweep_line_2/test_sweep_conic.cpp eol=lf Arrangement_on_surface_2/todo -text +BGL/doc/BGL/BGL.txt -text +BGL/doc/BGL/CGAL/HalfedgeDS_face_max_base_with_id.h -text +BGL/doc/BGL/CGAL/HalfedgeDS_halfedge_max_base_with_id.h -text +BGL/doc/BGL/CGAL/HalfedgeDS_vertex_max_base_with_id.h -text +BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h -text +BGL/doc/BGL/CGAL/Triangulation_vertex_base_with_id_2.h -text +BGL/doc/BGL/CGAL/boost/graph/graph_traits_Arrangement_2.h -text +BGL/doc/BGL/CGAL/boost/graph/graph_traits_Polyhedron_3.h -text +BGL/doc/BGL/CGAL/boost/graph/graph_traits_Triangulation_2.h -text +BGL/doc/BGL/CGAL/boost/graph/halfedge_graph_traits_Polyhedron_3.h -text +BGL/doc/BGL/CGAL/boost/graph/properties.h -text +BGL/doc/BGL/Concepts/HalfedgeGraph.h -text +BGL/doc/BGL/PackageDescription.txt -text +BGL/doc/BGL/fig/emst-detail.png -text svneol=unset#image/png +BGL/doc/BGL/fig/emst.jpg -text svneol=unset#image/jpeg +BGL/doc/BGL/fig/ex_bgl.gif -text svneol=unset#image/gif +BGL/doc/BGL/fig/ex_bgl.pdf -text svneol=unset#application/pdf BGL/doc_tex/BGL/fig/emst-detail.png -text BGL/doc_tex/BGL/fig/emst.jpg -text BGL/doc_tex/BGL/fig/ex_bgl.fig -text svneol=unset#application/octet-stream diff --git a/BGL/doc/BGL/BGL.txt b/BGL/doc/BGL/BGL.txt new file mode 100644 index 00000000000..f9135ad9e8e --- /dev/null +++ b/BGL/doc/BGL/BGL.txt @@ -0,0 +1,335 @@ + +\page chapterBGL CGAL and the Boost Graph Library + +namespace CGAL { +/*! + +\mainpage CGAL and the Boost Graph Library +\anchor chapterBGL + +\authors Andreas Fabri and Fernando Cacciola and Ron Wein + +Many geometric data structures can be interpreted as graphs, as they consist of +vertices, edges and faces. This is the case for the halfedge data structure, +for the polyhedron, for arrangements and for triangulations. With means of +duality one can also interpret faces as vertices and edges between adjacent +faces as edges of the dual graph. + +As the scope of \cgal is geometry and not graph algorithms, we +provide the necessary classes and functions that allow to use the +algorithms of the Boost Graph Library (sc{Bgl}) \cite cgal:sll-bgl-02 for \cgal data structures. + +# A Short Introduction to the Boost Graph Library # + +The algorithms of the \sc{Bgl} operate on models of the various graph concepts. +The traits class `boost::graph_traits` allows the algorithms to determine the types of vertices and edges. +Free functions that operator on graphs allow the algorithms to obtain, +for example, the source vertex of an edge, or all edges incident to a vertex. The algorithms +use property maps to associate information to vertices and edges. +The algorithms allow visitors to register callbacks that will be called +during the execution of the algorithms. Finally, the graph algorithms use +the named parameter mechanism, which allows to pass the arguments in +arbitrary order. + +## Graph Concepts ## + +The \sc{Bgl} introduces several graph concepts, which have different sets of characteristics and requirements, +as for example whether one can enumerate all vertices or all edges, whether one only can get the outgoing +edges of a vertex, or also the ingoing edges, or whether one can add and remove vertices and edges or not. + +Graph concepts in the \sc{Bgl} manual: http://www.boost.org/libs/graph/doc/graph_concepts.html + +## The Graph Traits Class ## + +The algorithms determine types with the help of the traits class +`boost::graph_traits`. Such types are the `vertex_descriptor` +which is equivalent to a vertex handle in \cgal data structures, the +`vertex_iterator` which is similar to the vertex iterators in +\cgal data structures, and the `out_edge_iterator` which is +similar to edge circulators, which allow to enumerate the edges +incident to a vertex. The latter two are similar and not equivalent, +because their value type is a `vertex_descriptor`, whereas in +\cgal handles, iterators, and cicrulators all have the same value +type, namely the vertex type. Given a graph type `G` the +declaration of a vertex descriptor looks as follows: +`boost::graph_traits::vertex_descriptor vd;`.
+ +The graph traits in the \sc{Bgl} manual: http://www.boost.org/libs/graph/doc/graph_traits.html + +## Free Functions for Exploring a Graph ## + +The algorithms obtain incidence information with the help of global +functions like `pair vertices(const Graph& g);` for getting an iterator range which allows +to enumerate all vertices, or `int num_vertices(const Graph&);` for getting the number of vertices of a graph, or +`vertex_descriptor source(edge_descriptor, const Graph&`, for +getting the source vertex of an edge. Note, that the +way we have written the types is a simplification, that is in reality +the signature of the first of the above functions is +`pair::vertex_iterator,boost::graph_traits::vertex_iterator> vertices(const Graph& g);`.
+ +The free functions required for graph concepts: http://www.boost.org/libs/graph/doc/graph_concepts.html + +## Property Maps ## + +Another feature used heavily in the \sc{Bgl} is the property map +which is offered by the Boost Property Map Library. +Property maps are used to attach information to vertices and edges. It is again +a traits class and some free functions for obtaining the property map from +a graph, and for getting and putting properties. + +The free functions are `get` and `put`. The first one is overloaded. +One version allows to obtain a property map for a given property tag. For example +`m = get(g, boost::vertex_index)` gives us a property map that associates +an index in the range `[0, num_vertices(g))` to each vertex +descriptor of the graph. The second version of the `get` function +allows to read it as follows for a vertex descriptor `vd`: +`int vdi = get(m, vd)`. Just as `get` allows to read data, +`put` allows to write them. For example, the Dijksta's shortest path algorithm writes +the predecessor of each vertex, as well as the distance to the source in such a +property map. + +The data themselves may be stored in the vertex or edge, or they may +be stored in an external data structure, or they may be computed on +the fly. This is an "implementation detail" of the particular property map.
+ +Property maps in the Boost manuals: http://www.boost.org/libs/property_map/doc/property_map.html + +## Visitors ## + +Visitors are ojects that provide functions that get called at +specified event points by the algorithm they visit. The notion of +visitors is a design pattern, and also used in \cgal, e.g., the `Arr_observer` +in the arrangement package. + +The functions as well as the event points are library specific. Event +points in graph algorithms are, for example, when a vertex is traversed the first time, or when +all outgoing edges of a vertex are traversed.
+ +Visitors in the \sc{Bgl} manual: http://www.boost.org/libs/graph/doc/visitor_concepts.html + +## Named Parameters ## + +The algorithms of the \sc{Bgl} often have many parameters. Although the default +value is most often appropriate, one has to write them explicitly, if one only +wants to deviate from the default for the last one. The solution to this problem +is to first write a tag and then the parameter, which for +Dijkstra's shortest path algorithm, might look as follows: + +
 
+std::vector p(num_vertices(g));
+std::vector d(num_vertices(g));
+vertex_descriptor s = vertex(A, g);
+dijkstra_shortest_paths(g, s, predecessor_map(&p[0]).distance_map(&d[0]));
+
+ +The named parameters in the example use the tags `predecessor_map` and `distance_map` and +they are concatenated with the dot operator.
+ +Named parameters in the \sc{Bgl} manual: http://www.boost.org/libs/graph/doc/bgl_named_params.html + +# Extensions of the BGL # + +\cgal provides the partial specializations and free functions such that +several data structures become model of some of the \sc{Bgl} graph concepts. +Furthermore, we define the new graph concept `HalfedgeGraph`, a traits class `halfedge_graph_traits`, +and free functions for accessing opposite edges as well as the clockwise and +counterclockwise neighbor of an edge around a given vertex. + +These extensions are used by the surface simplification algorithms which follow +the design of the \sc{Bgl} as sketched in the previous section. + +# Header Files, Namespaces, and Naming Conventions # + +As we interface two libraries we have to explain what resides in which namespace, +and what naming conventions we apply to what. + +Partial specializations of the `boost::graph_traits` for the \cgal package +`Package` are in the namespace `boost` and in the headerfile ``. + +The `halfedge_graph_traits` class is in the namespace `CGAL`, +but it is not capitalized as the `boost::graph_traits` is not. +The same holds for the types and enums for vertex and edge properties. + +# Polyhedral Surfaces as Model of the Boost Graph Concept # + +The class `Polyhedron_3` is model of the graph concept. Furthermore +this chapter introduces a new graph concept, the `HalfedgeGraph`. + +## Example: Minimum Spanning Tree of a Polyhedral Surface ## + +The example code computes the minimum spanning tree on a polyhedral surface. +More examples can be found in Chapter \ref chaptermeshsimplification on surface mesh simplification. + +\cgalexample{kruskal.cpp} + +## Example: Using Vertices, and Edges with an ID ## + +The following example program shows a call to the \sc{Bgl} +Kruskal's minimum spanning tree algorithm accessing the id() +field stored in a Polyhedron vertex. + +The main function illustrates the access to the id() field. + +\cgalexample{kruskal_with_stored_id.cpp} + +# Triangulations as Models of the Boost Graph Concept # + +Triangulations have vertices and faces. Edges are pairs of a face and the +index of the edge. +Particular care has to be taken with the infinite vertex, and its incident +edges. One can either use a `boost::filtered_graph`, which makes the infinite edges +invisible, or one can have a property map that returns an infinite length +for these edges. + +A classical example for an algorithm that is a combination of +computational geometry and graph theory is the Euclidean Minimum +Spanning Tree for a point set in the plane. It can be computed by +running the minimum spanning tree algorithm on a Delaunay +triangulation of the point set. + +## Example: Euclidean Minimum Spanning Tree ## + +In the following example we create a Delaunay triangulation and run Kruskal's minimum +spanning tree algorithm on it. Because the vertex handles of the triangulation are not indices +in an array, we have to provide a property map that maps vertex handles to +int's in the range `[0, t.number_of_vertices())`. + +\cgalexample{emst.cpp} + +## Example: Storing the Vertex ID in the Vertex ## + +The algorithms of the \sc{Bgl} extensively use of the indices of +vertices. In the previous example we stored the index in a `std::map` +and turned that map in a property map. This property map was then +passed as argument to the shortest path function. + +If the user does not pass explicitly a property map, the graph algorithms +use the property map returned by the call `boost::get(boost::vertex_index,ft)`. +This property map assumes that the vertex has a +member function `id()` that returns a reference to an int. +Therefore \cgal offers a class `Triangulation_vertex_base_with_id_2`. +It is in the users responsibility to set the indices properly. + +The example further illustrates that the graph traits also works +for the Delaunay triangulation. + +\cgalexample{dijkstra_with_internal_properties.cpp} + +# Arrangements as Models of the Boost Graph Concept # + +For the arrangements \cgal offers the graph traits for the arrangement +itself as well as for its dual graph. + +\subsection arr_sssecbgl_primal Example for the Arrangement as Graph + +Arrangement instances are adapted to boost graphs by specializing the +`boost:graph_traits` template for `Arrangement_2` instances. The +graph-traits states the graph concepts that the arrangement class models +(see below) and defines the types required by these concepts. + +In this specialization the `Arrangement_2` vertices correspond to the +graph vertices, where two vertices are adjacent if there is at least one +halfedge connecting them. More precisely, `Arrangement_2::Vertex_handle` +is the graph-vertex type, while `Arrangement_2::Halfedge_handle` is the +graph-edge type. As halfedges are directed, we consider the graph to be +directed as well. Moreover, as several interior-disjoint \f$ x\f$-monotone curves +(say circular arcs) may share two common endpoints, inducing an arrangement +with two vertices that are connected with several edges, we allow parallel +edges in our boost graph. + +Given an `Arrangement_2` instance, we can efficiently traverse its +vertices and halfedges. Thus, the arrangement graph is a model of the concepts +`VertexListGraph` and `EdgeListGraph` introduced by the \sc{bgl}. +At the same time, we use an iterator adapter of the circulator over the +halfedges incident to a vertex (`Halfedge_around_vertex_circulator` - see +Section \ref arr_sssectr_vertex), so it is possible to go over the ingoing +and outgoing edges of a vertex in linear time. Thus, our arrangement graph +is a model of the concept `BidirectionalGraph` (this concept refines +`IncidenceGraph`, which requires only the traversal of outgoing edges). + +It is important to notice that the vertex descriptors we use are +`Vertex_handle` objects and not vertex indices. However, in order +to gain more efficiency in most \sc{Bgl} algorithm, it is better to have them +indexed \f$ 0, 1, \ldots, (n-1)\f$, where \f$ n\f$ is the number of vertices. We +therefore introduce the `Arr_vertex_index_map` class-template, +which maintains a mapping of vertex handles to indices, as required by the +sc{bgl}. An instance of this class must be attached to a valid arrangement +vertex when it is created. It uses the notification mechanism (see +Section \ref arr_secnotif) to automatically maintain the mapping of vertices +to indices, even when new vertices are inserted into the arrangement or +existing vertices are removed. + +In most algorithm provided by the \sc{bgl}, the output is given by +property maps, such that each map entry corresponds to a vertex. +For example, when we compute the shortest paths from a given source vertex +\f$ s\f$ to all other vertices we can obtain a map of distances and a map of +predecessors - namely for each \f$ v\f$ vertex we have its distance from \f$ s\f$ +and a descriptor of the vertex that precedes \f$ v\f$ in the shortest path from \f$ s\f$. +If the vertex descriptors are simply indices, one can use vectors to +efficiently represent the property maps. As this is not the case with the +arrangement graph, we offer the `Arr_vertex_property_map` +template allows for an efficient mapping of `Vertex_handle` objects to +properties of type `Type`. Note however that unlike the +`Arr_vertex_index_map` class, the vertex property-map class is not +kept synchronized with the number of vertices in the arrangement, so it +should not be reused in calls to \sc{Bgl} functions in case the arrangement +is modified in between these calls. + +\anchor arr_figex_bgl +\image html ex_bgl.gif +
+An arrangement of 7 line segments, as constructed by `ex_bgl_primal_adapter.cpp` and `ex_bgl_dual_adapter.cpp`. The breadth-first visit times for the arrangement faces, starting from the unbounded face \f$ f_0\f$, are shown is brackets. +
+ + + +In the following example we construct an arrangement of 7 line segments, +as shown in Figure \ref arr_figex_bgl, +then use Dijkstra's shortest-paths algorithm from the \sc{Bgl} to compute +the graph distance of all vertices from the leftmost vertex in the +arrangement \f$ v_0\f$. Note the usage of the `Arr_vertex_index_map` and +the `Arr_vertex_property_map` classes. The latter one, instantiated by +the type `double` is used to map vertices to their distances from \f$ v_0\f$. + +\cgalexample{primal.cpp} + +\subsection arr_sssecbgl_dual Example for the Dual of an Arrangement as Graph + +It is possible to give a dual graph representation for an arrangement instance, +such that each arrangement face corresponds to a graph vertex and two vertices +are adjacent iff the corresponding faces share a common edge on their +boundaries. This is done by specializing the +`boost:graph_traits` template for `Dual` instances, +where `Dual` is a template specialization that gives a +dual interpretation to an arrangement instance. + +In dual representation, `Arrangement_2::Face_handle` +is the graph-vertex type, while `Arrangement_2::Halfedge_handle` is the +graph-edge type. We treat the graph edges as directed, such that a halfedge +`e` is directed from \f$ f_1\f$, which is its incident face, to \f$ f_2\f$, which +is the incident face of its twin halfedge. As two arrangement faces may +share more than a single edge on their boundary, we allow parallel +edges in our boost graph. As is the case in the primal graph, the dual +arrangement graph is also a model of the concepts `VertexListGraph`, +`EdgeListGraph` and `BidirectionalGraph` (thus also of +`IncidenceGraph`). + +Since we use `Face_handle` objects as the vertex descriptors, we define +the `Arr_face_index_map` class-template, which maintains an +efficient mapping of face handles to indices. We also provide the template +`Arr_face_property_map` for associating arbitrary +data with the arrangement faces. + +In the following example we construct the same arrangement as in +example `ex_bgl_primal_adapter.cpp` (see Figure \ref arr_figex_bgl), +and perform breadth-first search on the graph faces, starting from the +unbounded face. We extend the \sc{Dcel} faces +with an unsigned integer, marking the discover time of the face and use a +breadth-first-search visitor to obtain these times and update the faces +accordingly: + +\cgalexample{dual.cpp} + +*/ +} /* namespace CGAL */ + diff --git a/BGL/doc/BGL/CGAL/HalfedgeDS_face_max_base_with_id.h b/BGL/doc/BGL/CGAL/HalfedgeDS_face_max_base_with_id.h new file mode 100644 index 00000000000..d3884986745 --- /dev/null +++ b/BGL/doc/BGL/CGAL/HalfedgeDS_face_max_base_with_id.h @@ -0,0 +1,58 @@ + +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `HalfedgeDS_face_max_base_with_id` is a model of the `HalfedgeDSFace` +concept. `Refs` is an instantiation of a `HalfedgeDS`. It is +equivalent to `CGAL::HalfedgeDS_face_base< Refs, CGAL::Tag_true>` +with an added integer field which can be used to index faces +in \sc{Bgl} algorithms.. +The class contains support for the incident halfedge pointer +and the required type definitions. +It can be used for deriving own faces. + +Note that the user is in charge to set the index correctly before +running a graph algorithm. + +\models ::HalfedgeDSFace + +\sa `HalfedgeDS` +\sa `HalfedgeDSItems` +\sa `PolyhedronItems_3` +\sa `CGAL::HalfedgeDS_min_items` +\sa `CGAL::HalfedgeDS_vertex_min_base` +\sa `CGAL::HalfedgeDS_halfedge_min_base` +\sa `CGAL::HalfedgeDS_face_base` +\sa `CGAL::HalfedgeDS_vertex_max_base_with_id` +\sa `CGAL::HalfedgeDS_halfedge_max_base_with_id` +\sa `CGAL::Polyhedron_items_with_id_3` + +*/ +template< typename Refs > +class HalfedgeDS_face_max_base_with_id { +public: + +/// \name Creation +/// @{ + +/*! +default constructor. +*/ +HalfedgeDS_face_max_base_with_id(); + +/*! +Returns the index. +*/ +int id() const; + +/*! +Returns a reference to the index stored in the face. +*/ +int& id(); + +/// @} + +}; /* end HalfedgeDS_face_max_base_with_id */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/HalfedgeDS_halfedge_max_base_with_id.h b/BGL/doc/BGL/CGAL/HalfedgeDS_halfedge_max_base_with_id.h new file mode 100644 index 00000000000..d5b19beb94e --- /dev/null +++ b/BGL/doc/BGL/CGAL/HalfedgeDS_halfedge_max_base_with_id.h @@ -0,0 +1,57 @@ + +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `HalfedgeDS_halfedge_max_base_with_id` is a model of the `HalfedgeDSHalfedge` +concept. `Refs` is an instantiation of a `HalfedgeDS`. +It is equivalent to `CGAL::HalfedgeDS_halfedge_base< Refs, CGAL::Tag_true, CGAL::Tag_true, CGAL::Tag_true>` with an added integer +field which can be used to index halfedges in \sc{Bgl} algorithms. +The class contains support for the previous, next, opposite, vertex and +face pointers and the required type definitions. +It can be used for deriving own halfedges. + +Note that the user is in charge to set the index correctly before +running a graph algorithm. + +\models ::HalfedgeDSHalfedge + +\sa `HalfedgeDS` +\sa `HalfedgeDSItems` +\sa `PolyhedronItems_3` +\sa `CGAL::HalfedgeDS_min_items` +\sa `CGAL::HalfedgeDS_vertex_min_base` +\sa `CGAL::HalfedgeDS_face_min_base` +\sa `CGAL::HalfedgeDS_halfedge_base` +\sa `CGAL::HalfedgeDS_vertex_max_base_with_id` +\sa `CGAL::HalfedgeDS_face_max_base_with_id` +\sa `CGAL::Polyhedron_items_with_id_3` + +*/ +template< typename Refs > +class HalfedgeDS_halfedge_max_base_with_id { +public: + +/// \name Creation +/// @{ + +/*! +default constructor. +*/ +HalfedgeDS_halfedge_max_base_with_id(); + +/*! +Returns the index. +*/ +int id() const; + +/*! +Returns a reference to the index stored in the halfedge. +*/ +int& id(); + +/// @} + +}; /* end HalfedgeDS_halfedge_max_base_with_id */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/HalfedgeDS_vertex_max_base_with_id.h b/BGL/doc/BGL/CGAL/HalfedgeDS_vertex_max_base_with_id.h new file mode 100644 index 00000000000..b1e3a54461c --- /dev/null +++ b/BGL/doc/BGL/CGAL/HalfedgeDS_vertex_max_base_with_id.h @@ -0,0 +1,57 @@ + +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `HalfedgeDS_vertex_max_base_with_id` is a model of the `HalfedgeDSVertex` +concept. `Refs` is an instantiation of a `HalfedgeDS`. It is +equivalent to `CGAL::HalfedgeDS_vertex_base< Refs, CGAL::Tag_true>` +with an added integer field which can be used to index vertices +in \sc{Bgl} algorithms.. +The class contains support for the point and the required type definitions. +It can be used for deriving own vertices. + +Note that the user is in charge to set the index correctly before +running a graph algorithm. + +\models ::HalfedgeDSVertex + +\sa `HalfedgeDS` +\sa `HalfedgeDSItems` +\sa `PolyhedronItems_3` +\sa `CGAL::HalfedgeDS_min_items` +\sa `CGAL::HalfedgeDS_halfedge_min_base` +\sa `CGAL::HalfedgeDS_face_min_base` +\sa `CGAL::HalfedgeDS_vertex_base` +\sa `CGAL::HalfedgeDS_halfedge_max_base_with_id` +\sa `CGAL::HalfedgeDS_face_max_base_with_id` +\sa `CGAL::Polyhedron_items_with_id_3` + +*/ +template< typename Refs > +class HalfedgeDS_vertex_max_base_with_id { +public: + +/// \name Creation +/// @{ + +/*! +default constructor. +*/ +HalfedgeDS_vertex_max_base_with_id(); + +/*! +Returns the index. +*/ +int id() const; + +/*! +Returns a reference to the index stored in the vertex. +*/ +int& id(); + +/// @} + +}; /* end HalfedgeDS_vertex_max_base_with_id */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h b/BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h new file mode 100644 index 00000000000..1b630f0fc93 --- /dev/null +++ b/BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h @@ -0,0 +1,63 @@ + +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `Polyhedron_items_with_id_3` is a model of the `PolyhedronItems_3` +concept. It provides definitions for vertices with points, halfedges, +and faces with plane equations, all of them with an additional integer +field which can be used to index the items in a \sc{Bgl} algorithm. +The polyhedron traits class must provide the respective types for +the point and the plane equation. +Vertices and facets both contain a halfedge handle to an incident +halfedge. + +\models PolyhedronItems_3 + +### Operations ### + +Supported as required by the `PolyhedronItems_3` concept. + +### Additional methods in all three items ### + +\code +int id() const; // Returns the index. +int& id(); // Returns a reference to the index stored in the item. +\endcode + +\sa `CGAL::Polyhedron_3` +\sa `CGAL::Polyhedron_min_items_3` +\sa `CGAL::HalfedgeDS_min_items` +\sa `CGAL::HalfedgeDS_items_2` +\sa `CGAL::HalfedgeDS_vertex_max_base_with_id` +\sa `CGAL::HalfedgeDS_halfedge_max_base_with_id` +\sa `CGAL::HalfedgeDS_face_max_base_with_id` + +*/ + +class Polyhedron_items_with_id_3 { +public: + + template < class Refs, class Traits> + struct Vertex_wrapper { + typedef typename Traits::Point_3 Point; + typedef CGAL::Tag_true Supports_vertex_point; + }; + + template < class Refs, class Traits> + struct Face_wrapper { + typedef typename Traits::Plane_3 Plane; + typedef CGAL::Tag_true Supports_face_plane; + }; + /// \name Creation + /// @{ + + /*! + default constructor. + */ + Polyhedron_items_with_id_3(); + + /// @} +}; /* end Polyhedron_items_with_id_3 */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/Triangulation_vertex_base_with_id_2.h b/BGL/doc/BGL/CGAL/Triangulation_vertex_base_with_id_2.h new file mode 100644 index 00000000000..b7fa00bf30d --- /dev/null +++ b/BGL/doc/BGL/CGAL/Triangulation_vertex_base_with_id_2.h @@ -0,0 +1,48 @@ +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `Triangulation_vertex_base_with_id_2` is a model of the +concept `TriangulationVertexBase_2`, the base vertex of a +2D-triangulation. It provides an integer field that can be used to +index vertices for \sc{Bgl} algorithms. + +Note that the user is in charge to set the index correctly before +running a graph algorithm. + +Parameters +-------------- + +The first template argument is the geometric traits class +`TriangulationTraits_2` which provides the `Point_2`. + +The second template argument is a vertex base class from which +`Triangulation_vertex_base_with_id_2` derives. It has the default +value `Triangulation_vertex_base_2`. + +\models ::TriangulationVertexBase_2 + +\sa `CGAL::Triangulation_vertex_base_2` +*/ +template< typename TriangulationTraits_2, typename TriangulationVertexBase_2 > +class Triangulation_vertex_base_with_id_2 : public TriangulationVertexBase_2 { +public: + +/// \name Access Functions +/// @{ + +/*! +Returns the index. +*/ +int id() const; + +/*! +Returns a reference to the index stored in the vertex. +*/ +int& id(); + +/// @} + +}; /* end Triangulation_vertex_base_with_id_2 */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Arrangement_2.h b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Arrangement_2.h new file mode 100644 index 00000000000..a7fe418d074 --- /dev/null +++ b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Arrangement_2.h @@ -0,0 +1,96 @@ +namespace boost { + +/*! +\ingroup PkgBGL + +The class `graph_traits` is a partial specialization of `boost::graph_traits` +for the class `CGAL::Arrangement_2`. It provides the types associated +to the +graph concepts +`BidirectionalGraph` and +`EdgeAndVertexListGraph`. + +The const specialization, `boost::graph_traits< CGAL::Arrangement_2 const>` +is also defined, using the constant handles in the arrangement. + +*/ +template< typename Traits, typename Dcel> > +class graph_traits< CGAL::Arrangement_2 > { +public: + +/// \name Types +/// @{ + +/*! +The vertex descriptor. +*/ +typename CGAL::Arrangement_2::Vertex_handle vertex_descriptor; + +/*! +The edge descriptor. +*/ +typename CGAL::Arrangement_2::Halfedge_handle edge_descriptor; + +/*! +An iterator corresponding to +`CGAL::Arrangement_2::Vertex_iterator`, +with the difference that its value type is a vertex descriptor and not +`CGAL::Arrangement_2::Vertex`. +*/ +typedef Hidden_type vertex_iterator; + +/*! +An iterator corresponding to +`CGAL::Arrangement_2::Halfedge_iterator` +with the difference that its value type is an edge descriptor and not +`CGAL::Arrangement_2::Halfedge`. +*/ +typedef Hidden_type edge_iterator; + +/*! +An edge iterator which only iterates over +the incoming edges around a vertex. It corresponds to a +`CGAL::Arrangement_2::Halfedge_around_vertex_circulator` +with the difference that its value type is an edge descriptor and not +`CGAL::Arrangement_2::Halfedge`. +*/ +typedef Hidden_type in_edge_iterator; + +/*! +An edge iterator which only iterates over +the outgoing halfedges around a vertex. It corresponds to a +`CGAL::Arrangement_2::Halfedge_around_vertex_circulator` +with the difference that its value type is an edge descriptor and not +`CGAL::Arrangement_2::Halfedge`. +*/ +typedef Hidden_type out_edge_iterator; + +/*! +Indicates that this graph does support multiedges. +*/ +boost::sallow_parallel_edge_tag edge_parallel_category; + +/*! +Indicates that this graph is bidirectional. +*/ +boost::bidirectional_graph_tag traversal_category; + +/*! +The size type of the vertex list. +*/ +typename Arrangement_2::size_type vertices_size_type; + +/*! +The size type of the edge list. +*/ +typename Arrangement_2::size_type edges_size_type; + +/*! +The size type of the adjacency list. +*/ +typename Arrangement_2::size_type degree_size_type; + +/// @} + +}; /* end graph_traits */ +} /* end namespace boost */ diff --git a/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Polyhedron_3.h b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Polyhedron_3.h new file mode 100644 index 00000000000..dae729895eb --- /dev/null +++ b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Polyhedron_3.h @@ -0,0 +1,98 @@ +namespace boost { +/*! +\ingroup PkgBGL + +The class `graph_traits` is a partial specialization of `boost::graph_traits` +for the class `Polyhedron_3`. It provides the types associated +to the +graph concepts +`BidirectionalGraph` and +`EdgeAndVertexListGraph`. + +Types +-------------- + +The const specialization, `boost::graph_traits< CGAL::Polyhedron_3 const>` +is also defined, using the constant handles in the polyhedron. + +*/ +template< typename Traits> > +class graph_traits< CGAL::Polyhedron_3 > { +public: + +/// \name Types +/// @{ + +/*! +The vertex descriptor. +*/ +typename CGAL::Polyhedron_3::Vertex_handle vertex_descriptor; + +/*! +The edge descriptor. +*/ +typename CGAL::Polyhedron_3::Halfedge_handle edge_descriptor; + +/*! +An iterator corresponding to +`CGAL::Polyhedron_3::Vertex_iterator`, +with the difference that its value type is a vertex descriptor and not +`CGAL::Polyhedron_3::Vertex`. +*/ +typedef Hidden_type vertex_iterator; + +/*! +An iterator corresponding to +`CGAL::Polyhedron_3::Halfedge_iterator` +with the difference that its value type is an edge descriptor and not +`CGAL::Polyhedron_3::Halfedge`. +*/ +typedef Hidden_type edge_iterator; + +/*! +An edge iterator which only iterates over +the incoming edges around a vertex. It corresponds to a +`CGAL::Polyhedron_3::Halfedge_around_vertex_circulator` +with the difference that its value type is an edge descriptor and not +`CGAL::Polyhedron_3::Halfedge`. +*/ +typedef Hidden_type in_edge_iterator; + +/*! +An edge iterator which only iterates over +the outgoing halfedges around a vertex. It corresponds to a +`CGAL::Polyhedron_3::Halfedge_around_vertex_circulator` +with the difference that its value type is an edge descriptor and not +`CGAL::Polyhedron_3::Halfedge`. +*/ +typedef Hidden_type out_edge_iterator; + +/*! +Indicates that this graph does not support multiedges. +*/ +boost::disallow_parallel_edge_tag edge_parallel_category; + +/*! +Indicates that this graph is bidirectional. +*/ +boost::bidirectional_graph_tag traversal_category; + +/*! +The size type of the vertex list. +*/ +typename Polyhedron_3::size_type vertices_size_type; + +/*! +The size type of the edge list. +*/ +typename Polyhedron_3::size_type edges_size_type; + +/*! +The size type of the adjacency list. +*/ +typename Polyhedron_3::size_type degree_size_type; + +/// @} + +}; /* end graph_traits */ +} /* end namespace boost */ diff --git a/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Triangulation_2.h b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Triangulation_2.h new file mode 100644 index 00000000000..09ba4c4a28b --- /dev/null +++ b/BGL/doc/BGL/CGAL/boost/graph/graph_traits_Triangulation_2.h @@ -0,0 +1,97 @@ +namespace boost { + +/*! +\ingroup PkgBGL + +The triangulations of \cgal are all models of the concepts +`BidirectionalGraph` and `VertexAndEdgeListGraph` of the Boost Graph +Library \cite cgal:sll-bgl-02. + +The class `graph_traits` is a partial specialization of the class +`boost::graph_traits`. + +The mapping between vertices and edges of the triangulation and the +graph is rather straightforward, but there are some subtleties. The +value type of the \sc{Bgl} iterators is the vertex or edge descriptor, +whereas in \cgal all iterators and circulators are also handles and +hence have as value type Vertex or Edge. + +The graph traits class for triangulations does not distinguish between +finite and infinite vertices and edges. As the edge weight computed +with the default property map of \sc{Bgl} algorithms (obtained with +`boost::get(t, boost::edge_weight)`) is the length of the edge, +the edge weight is not well defined for infinite edges. For algorithms +that make use of the edge weight the user must therefore +define a `boost::filtered_graph` or pass a property map to the +algorithm that returns "infinity" for infinite edges. + +Note also that when you derive from the class `CGAL::Triangulation_2` +you must upcast the object in order to use this partial specialization. + +For the user convenience, \cgal provides the partial specializations +for all 2D triangulation classes. + +*/ +template< typename GT, typename TDS> > +class graph_traits< CGAL::Triangulation_2 > { +public: + +/// \name Types +/// @{ + +/*! +The vertex descriptor. +*/ +typedef Triangulation::Vertex_handle vertex_descriptor; + +/*! +The edge descriptor. 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. +*/ +typedef Hidden_type edge_descriptor; + +/*! +The vertex iterator type. Its value type is `vertex_descriptor`. +*/ +typedef Hidden_type vertex_iterator; + +/*! +The edge iterator type, Its value type is `edge_descriptor`. +*/ +typedef Hidden_type edge_iterator; + +/*! +An iterator for the outgoing edges incident to a vertex. +Its value type is `edge_descriptor`. +*/ +typedef Hidden_type out_edge_iterator; + +/*! +An iterator for the incoming edges incident to a vertex. +Its value type is `edge_descriptor`. +*/ +typedef Hidden_type in_edge_iterator; + +/*! +An iterator for the vertices adjacent to a vertex. +Its value type is `vertex_descriptor`. +*/ +typedef Hidden_type adjacency_iterator; + +/*! + +*/ +typedef boost::undirected_tag directed_category; + +/*! + +*/ +typedef boost::disallow_parallel_edge_tag edge_parallel_category; + +/// @} + +}; /* end graph_traits */ +} /* end namespace boost */ diff --git a/BGL/doc/BGL/CGAL/boost/graph/halfedge_graph_traits_Polyhedron_3.h b/BGL/doc/BGL/CGAL/boost/graph/halfedge_graph_traits_Polyhedron_3.h new file mode 100644 index 00000000000..950524df0e7 --- /dev/null +++ b/BGL/doc/BGL/CGAL/boost/graph/halfedge_graph_traits_Polyhedron_3.h @@ -0,0 +1,35 @@ + +namespace CGAL { + +/*! +\ingroup PkgBGL + +The class `halfedge_graph_traits` is a partial specialization of `CGAL::halfedge_graph_traits` +for `Polyhedron_3`. It provides the types associated +to the `HalfedgeGraph` concept. + +*/ +template< typename Traits> > +class halfedge_graph_traits< Polyhedron_3 > { +public: + +/// \name Types +/// @{ + +/*! +An edge iterator that iterates +over one of the two opposite edges forming an undirected edge. + +The value type is `CGAL::Polyhedron_3::Halfedge_const_handle`. +*/ +typedef Hidden_type undirected_edge_iterator; + +/*! +The point type of the vertex. +*/ +typename CGAL::Polyhedron_3::Point_3 Point ; + +/// @} + +}; /* end halfedge_graph_traits */ +} /* end namespace CGAL */ diff --git a/BGL/doc/BGL/CGAL/boost/graph/properties.h b/BGL/doc/BGL/CGAL/boost/graph/properties.h new file mode 100644 index 00000000000..6c89de3e502 --- /dev/null +++ b/BGL/doc/BGL/CGAL/boost/graph/properties.h @@ -0,0 +1,73 @@ +namespace CGAL { + +/*! +\ingroup PkgBGL +The constant `edge_is_border` is a +property tag +which refers to the property of an edge of being a border edge. + +`edge_is_border` is an +interior property. +That is, a +property map +for `edge_is_border` can be extracted from any model of a `HalfedgeGraph` +using the Bgl +PropertyGraph interface: `boost::get(edge_is_border,graph)` + +The Boolean flag that indicates if the edge is a border can be directly accessed via: +`boost::get(edge_is_border,graph,edge)`. +*/ +enum edge_is_border_t { edge_is_border }; +/*! +\ingroup PkgBGL + +The constant `vertex_is_border` is a +property tag which refers to the property +of a vertex of being a border vertex. + +`vertex_is_border` is an +interior property, that is, a +property map +for `vertex_is_border` can be extracted from any model of +a `HalfedgeGraph` using the Bgl +PropertyGraph interface: +`boost::get(vertex_is_border,graph)` + +The Boolean flag that indicates if the vertex is a border can be directly accessed via: +`boost::get(vertex_is_border,graph,edge)` +*/ +enum vertex_is_border_t { vertex_is_border }; + +/*! +\ingroup PkgBGL +The constant `vertex_point` is a property tag which refers to the geometric embedding property of a vertex of a `HalfedgeGraph`. + +A `vertex_point` is an +interior property, +that is, a +property map +for a `vertex_point` can be extracted from any model of a `HalfedgeGraph` +using the Bgl +PropertyGraph interface: +`boost::get(vertex_point,graph)` + +A point of a vertex can be directly accessed via: +- `boost::get(vertex_point,graph,vertex)` +- `boost::put(vertex_point,graph,vertex,newpoint)` +*/ +enum vertex_point_t { vertex_point }; + +} + +namespace boost { + +/*! +\ingroup PkgBGL +The constant `edge_index` is a +property tag which identifies the index property +of an edge of a \sc{Bgl} +Graph. + +*/ +enum edge_index_t { edge_index }; +} diff --git a/BGL/doc/BGL/Concepts/HalfedgeGraph.h b/BGL/doc/BGL/Concepts/HalfedgeGraph.h new file mode 100644 index 00000000000..d0eaf06cdac --- /dev/null +++ b/BGL/doc/BGL/Concepts/HalfedgeGraph.h @@ -0,0 +1,141 @@ + +/*! +\ingroup PkgBGLConcepts +\cgalconcept + +The concept `HalfedgeGraph` describes the requirements for a graph that is +structurally equivalent to a polyhedral surface represented by a +halfedge data structure, and it provides an interface for efficient +access to the opposite edge of an edge, and to the successor and +predecessor of an edge in the iterator range of the incoming edges of +a vertex. Each vertex has a geometric position in space. As in a +halfedge data structure we define the face adjacent to a halfedge to be +to the left of the halfedge. + +Requirements +-------------- + +For each directed edge \f$ e=(v,w)\f$ its opposite edge \f$ e'=(w,v)\f$ +must be part of the graph. + +The incoming edges of a vertex \f$ v\f$ have a fixed order, that is all +calls of `in_edges(v,g)` must return the same iterator range, +modulo a cyclic permutation. The order must be clockwise. + +As the `HalfedgeGraph` is equivalent to a polyhedral surface there must exist an embedding +for the vertices and edges such that the ordered edges do not intersect. + +\refines BidirectionalGraph +\refines PropertyGraph + +A model of `HalfedgeGraph` must have the interior properties +`edge_is_border` attached to its edges, and it must have +`vertex_is_border` and `vertex_point` attached to its vertices. + +Associated Types +-------------- + +Because (directed) edges must come in pairs, there is the +additional notion of an undirected edge +\footnote{The directed edges are not called `halfedges` (as in a `HalfedgeDS`) because from the point of view of this graph, being a refinement of a sc{Bgl} graph, each directed edge is an edge in itself. In other words, the unqualified term edge refers to one and only one directed edge and not to a pair.} +for a pair of opposite directed edges. The number of undirected +edges is exactly half the number of directed edges. Note that the +notion of directed and undirected edges does not imply the +existence of two different types. The type `edge_descriptor` is +used for both. An undirected edge must be implicitly handled, and +there is no requirement on which of the directed edges of the +undirected edge must be used to represent it. + +\code +// The type of the geometric location of a vertex. +typedef Hidden_type halfedge_graph_traits::Point; + +// An iterator that iterates over one and only one of the directed edges +// in each pair of opposite directed edges. The value type of the iterator +// is `boost::graph_traits::edge_descriptor`. +typedef Hidden_type halfedge_graph_traits::undirected_edge_iterator; +\endcode + +Valid Expressions +-------------- + +Following the \sc{Bgl} design, the following graph operations are defined as free +rather than member functions. + +\hasModel `CGAL::Polyhedron_3` +*/ +class HalfedgeGraph { + +}; + +/*! +Returns the undirected edges of `g`. + +\relates HalfedgeGraph +*/ +template +std::pair::undirected_edge_iterator, + typename halfedge_graph_traits::undirected_edge_iterator> +undirected_edges(const Graph& g); + +/*! +Returns the opposite edge of `e`. + +An edge \f$ e=(v,w)\f$ is said to be the opposite edge of edge +\f$ e'=(w,v)\f$. + +\relates HalfedgeGraph +*/ +template +typename boost::graph_traits::edge_descriptor +opposite_edge(typename boost::graph_traits::edge_descriptor e, Graph const& g ); + +/*! +Returns the clockwise neighbor of `e`. + +An edge \f$ e'=(v,w)\f$ is called the clockwise neighbor of +edge \f$ e=(u,w)\f$, and \f$ e\f$ the counterclockwise neighbor +of \f$ e'\f$, iff there exist two iterators \f$ it\f$ and \f$ it'\f$ +in the iterator range `in_edges(w,g)` such that `**it == e` and `**it' +== e'`, and `it' == it++` or `it` is the last and `it'` the first +iterator of the iterator range. + +\relates HalfedgeGraph +*/ +template +typename boost::graph_traits::edge_descriptor +next_edge_cw(typename boost::graph_traits::edge_descriptor e, Graph const& g ); + +/*! +Returns the counterclockwise neighbor of `e`. +\relates HalfedgeGraph +*/ +template +typename boost::graph_traits::edge_descriptor +next_edge_ccw(typename boost::graph_traits::edge_descriptor e, Graph const& g ); + +/*! +Returns the successor of `e`. + +An edge \f$ e'=(v,w)\f$ is called the successor of edge \f$ +e=(u,v)\f$, and \f$ e\f$ the predecessor of \f$ e'\f$, iff \f$ +e'\f$ is the clockwise neighbor of the opposite edge of \f$ e\f$. + +\relates HalfedgeGraph +*/ +template +typename boost::graph_traits::edge_descriptor +next_edge(typename boost::graph_traits::edge_descriptor e, Graph const& g ); + +/*! +Returns the predecessor of `e`. + +An edge \f$ e'=(v,w)\f$ is called the successor of edge \f$ +e=(u,v)\f$, and \f$ e\f$ the predecessor of \f$ e'\f$, iff \f$ +e'\f$ is the clockwise neighbor of the opposite edge of \f$ e\f$. + +\relates HalfedgeGraph +*/ +template +typename boost::graph_traits::edge_descriptor +prev_edge(typename boost::graph_traits::edge_descriptor e, Graph const& g ); diff --git a/BGL/doc/BGL/PackageDescription.txt b/BGL/doc/BGL/PackageDescription.txt new file mode 100644 index 00000000000..19611b629f1 --- /dev/null +++ b/BGL/doc/BGL/PackageDescription.txt @@ -0,0 +1,21 @@ +/// \defgroup PkgBGL CGAL and the Boost Graph Library + +/// \defgroup PkgBGLConcepts Concepts +/// \ingroup PkgBGL + +/*! +\addtogroup PkgBGL +\todo check generated documentation +\PkgDescriptionBegin{CGAL and the Boost Graph Library} +\PkgPicture{emst-detail.png} +\PkgAuthor{Andreas Fabri and Fernando Cacciola and Ron Wein} +\PkgDesc{This package provides a framework for interfacing \cgal data structures with the algorithms of the \sc{BGL}. It allows to run graph algorithms directly on \cgal data structures which are model of the \sc{BGL} graph concepts, for example the shortest path algorithm on a Delaunay triangulation in order to compute the Euclidean minimum spanning tree. Furthermore, it introduces a new graph concept, the `HalfedgeEdgeGraph`. This concept describes graphs which are embedded on surfaces.} +\PkgSince{3.3} +\cgalbib{cgal:cfw-cbgl} +\license{\ref licensesLGPL "LGPL"} +\PkgDescriptionEnd + +This chapter introduces the concepts and classes that allow to interface \cgal data structures +with the algorithms of the \sc{Bgl}, as well as a new graph concept. +*/ + diff --git a/BGL/doc/BGL/fig/emst-detail.png b/BGL/doc/BGL/fig/emst-detail.png new file mode 100644 index 0000000000000000000000000000000000000000..00a5e7d61a9d87df1a1b94019501f9b749ad428f GIT binary patch literal 1749 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

f%f!Ri|;jOO^1QAjXk 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 literal 0 HcmV?d00001 diff --git a/BGL/doc/BGL/fig/ex_bgl.gif b/BGL/doc/BGL/fig/ex_bgl.gif new file mode 100644 index 0000000000000000000000000000000000000000..534131d680dc01c3c06659b3439bcb18d2bde663 GIT binary patch literal 5526 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 + + CGAL and the Boost Graph Library + ../BGL/doc + + ../BGL/doc/BGL/ + ../BGL/doc/BGL/ + ./tags/BGL.tag + ../BGL/examples + ../BGL/doc/BGL/fig + + ./tags/HalfedgeDS.tag=../../CGAL.CGAL.Halfedge-Data-Structures/html + ./tags/Polyhedron.tag=../../CGAL.CGAL.3D-Polyhedral-Surface/html + ./tags/Arrangement_on_surface_2.tag=../../CGAL.CGAL.2D-Arrangements/html + ./tags/Triangulation_2.tag=../../CGAL.CGAL.2D-Triangulations/html + + + + 3D Polyhedral Surface ../Polyhedron/doc @@ -1134,6 +1152,7 @@ namespace for the XML file to be processed properly. --> ../Geomview/doc/Geomview/fig ../GraphicsView/doc/GraphicsView/fig ../HalfedgeDS/doc/HalfedgeDS/fig + ../BGL/doc/BGL/fig ../Combinatorial_map/doc/Combinatorial_map/fig ../Interval_skip_list/doc/Interval_skip_list/fig ../Nef_2/doc/Nef_2/fig @@ -1206,6 +1225,7 @@ namespace for the XML file to be processed properly. --> ./tags/Geomview.tag=../../CGAL.CGAL.Geomview/html ./tags/GraphicsView.tag=../../CGAL.CGAL.CGAL-and-the-Qt-Graphics-View-Framework/html ./tags/HalfedgeDS.tag=../../CGAL.CGAL.Halfedge-Data-Structures/html + ./tags/BGL.tag=../../CGAL.CGAL.CGAL-and-the-Boost-Graph-Library/html ./tags/Combinatorial_map.tag=../../CGAL.CGAL.Combinatorial-Maps/html ./tags/Interval_skip_list.tag=../../CGAL.CGAL.Interval-Skip-List/html ./tags/Nef_2.tag=../../CGAL.CGAL.2D-Boolean-Operations-on-Nef-Polygons/html