replacing the usage of section in user man by \cgalHeading macro call

Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_2.h

@@ -27,7 +27,7 @@ kernel. By default the `ExactAlphaComparisonTag` is set to \link Tag_false `Tag_
 overhead. Note that since such a strategy does not make sense if used together with a traits class with exact constructions, 
 the tag `ExactAlphaComparisonTag` is not taken into account if `Dt::Geom_traits::FT` is not a floating point number type. 
 
-### Inherits From ###
+\cgalHeading{Inherits From}
 
 Inherits from `Dt`.
 
@@ -36,12 +36,12 @@ This class is the underlying triangulation class.
 The modifying functions `Alpha_shape_2::insert()` and `Alpha_shape_2::remove()` will overwrite 
 the inherited functions. At the moment, only the static version is implemented. 
 
-### I/O ###
+\cgalHeading{I/O}
 
 The I/O operators are defined for `std::iostream`. The format for the iostream 
 is an internal format. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The set of intervals associated with the 
 \f$ k\f$-dimensional faces of the underlying triangulation are 

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_3.h

@@ -19,7 +19,7 @@ the tag `ExactAlphaComparisonTag` is not taken into account if `Dt::Geom_traits:
 Note that this class is at the same time used for <I>basic</I> and 
 for <I>weighted</I> Alpha Shapes. 
 
-### Inherits From ###
+\cgalHeading{Inherits From}
 
 Inherits from `Dt`.
 
@@ -28,13 +28,13 @@ This class is the underlying triangulation class.
 The modifying functions `insert` and `remove` will overwrite 
 the inherited functions. At the moment, only the static version is implemented. 
 
-### I/O ###
+\cgalHeading{I/O}
 
 The I/O operators are defined for `iostream`, and for 
 the window stream provided by \cgal. The format for the iostream 
 is an internal format. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 In `GENERAL` mode, the alpha intervals of each triangulation 
 face is computed and stored at initialization time. 

Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Fixed_alpha_shape_3.h

@@ -15,7 +15,7 @@ a classification that specifies its status in the alpha complex, alpha being fix
 Note that this class can be used at the same time to build a <I>basic</I> or 
 a <I>weighted</I> Alpha Shape. 
 
-### Inherits From ###
+\cgalHeading{Inherits From}
 
 Inherits from `Dt`.
 
@@ -24,7 +24,7 @@ This class is the underlying triangulation class.
 The modifying functions `insert` and `remove` will overwrite 
 the inherited functions. 
 
-### I/O ###
+\cgalHeading{I/O}
 
 The I/O operators are defined for `iostream`, and for 
 the window stream provided by \cgal. The format for the iostream 

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_2.h

@@ -13,13 +13,13 @@ The second template argument defaults to
 `CGAL::Triangulation_data_structure_2< CGAL::Apollonius_graph_vertex_base_2<Gt,true>, CGAL::Triangulation_face_base_2<Gt> >`.
 \cgalModels `DelaunayGraph_2`
 
-### Traversal of the Apollonius Graph ###
+\cgalHeading{Traversal of the Apollonius Graph}
 
 An Apollonius graph can be seen as a container of faces and vertices.
 Therefore the Apollonius graph provides several iterators and
 circulators that allow to traverse it (completely or partially).
 
-### Traversal of the Convex Hull ###
+\cgalHeading{Traversal of the Convex Hull}
 
 Applied on the `infinite_vertex` the `incident_*` functions allow to
 visit the vertices on the convex hull and the infinite edges and

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_graph_hierarchy_2.h

@@ -35,7 +35,7 @@ The `Apollonius_graph_hierarchy_2` class derives publicly from the
 the same with its base class. In the sequel only the methods 
 overridden are documented. 
 
-### Types ###
+\cgalHeading{Types}
 
 `Apollonius_graph_hierarchy_2` does not introduce other types than those introduced by 
 its base class `Apollonius_graph_2<Gt,Agds>`. 

Apollonius_graph_2/doc/Apollonius_graph_2/CGAL/Apollonius_site_2.h

@@ -10,12 +10,12 @@ The class `Apollonius_site_2` is a model for the concept
 
 \cgalModels `ApolloniusSite_2`
 
-### Types ###
+\cgalHeading{Types}
 
 The class `Apollonius_site_2` does not introduce any types in addition to the 
 concept `ApolloniusSite_2`. 
 
-### I/O ###
+\cgalHeading{I/O}
 
 The I/O operators are defined for `iostream`. 
 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_batched_point_location.h

@@ -14,7 +14,7 @@ pairs in the output sequence are sorted in increasing \f$ xy\f$-lexicographical
 order of the query points. The function returns a past-the-end iterator of 
 the output sequence. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <UL> 
 <LI>`InputIterator::value_type` must be `Traits::Point_2`. 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_conic_traits_2.h

@@ -77,7 +77,7 @@ supports the merging of curves of opposite directions.
 \cgalModels `ArrangementLandmarkTraits_2`
 \cgalModels `ArrangementDirectionalXMonotoneTraits_2`
 
-### Types ###
+\cgalHeading{Types}
 
 
 */

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_iostream.h

@@ -6,7 +6,7 @@ namespace CGAL {
 The function `read` reads a given arrangement from a given input stream
 using a specific input format.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <UL>
 <LI>The instantiated `Formatter` class must model the
@@ -43,7 +43,7 @@ std::istream& read (Arrangement_2<Traits,Dcel>& arr,
 The function `write` writes a given arrangement into a given output stream
 using a specific output format.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <UL>
 <LI>The instantiated `Formatter` class must model the

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_vertical_decomposition_2.h

@@ -42,7 +42,7 @@ is no feature above it.
 </UL> 
 The function returns a past-the-end iterator for its output sequence. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `OutputIterator::value_type` must be 
 `pair<Arrangement_2::Vertex_const_handle, pair<Object, Object> >`. 

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arrangement_2.h

@@ -979,7 +979,7 @@ namespace CGAL {
   into \f$ x\f$-monotone subcurves (and perhaps isolated points), which are
   inserted into the arrangement.
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL>
   <LI>If the curve is \f$ x\f$-monotone curve then The instantiated
@@ -1067,7 +1067,7 @@ void insert (Arrangement_2<Traits,Dcel>& arr,
   edges or vertices of the existing arrangement `arr`. 
   \pre If provided, `pl` must be attached to the given arrangement `arr`. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>If `c` is \f$ x\f$-monotone then the instantiated `GeomTraits` 
@@ -1108,7 +1108,7 @@ bool do_intersect (
 
   \pre If provided, `pl` must be attached to the given arrangement `arr`. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated `Traits` class must model the restricted 
@@ -1135,7 +1135,7 @@ insert_non_intersecting_curve (Arrangement_2<Traits,Dcel>& arr,
   disjoint in their interior and pairwise interior-disjoint from all existing 
   arrangement vertices and edges. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated `Traits` class must model the 
@@ -1166,7 +1166,7 @@ void insert_non_intersecting_curves(Arrangement_2<Traits,Dcel>& arr,
 
   \pre If provided, `pl` must be attached to the given arrangement `arr`. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated `Traits` class must model the 
@@ -1201,7 +1201,7 @@ insert_point (Arrangement_2<Traits,Dcel>& arr,
   function may take a considerable amount of time; it is recommended to be 
   used only for debugging purposes. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   The instantiated traits class must model the concept 
   `ArranagmentXMonotoneTraits_2`. 
@@ -1229,7 +1229,7 @@ bool is_valid (const Arrangement_2<Traits, Dcel>& arr);
   is returned. Otherwise, the face to which the edge was incident before the 
   removal is returned. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated traits class must model the concept 
@@ -1254,7 +1254,7 @@ remove_edge (Arrangement_2<Traits,Dcel>& arr,
   The function returns a boolean value that indicates whether it succeeded 
   removing the vertex from the arrangement. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated `Traits` class must model the 
@@ -1286,7 +1286,7 @@ bool remove_vertex (Arrangement_2<Traits,Dcel>& arr,
   arrangement `arr`. 
   \pre If provided, `pl` must be attached to the given arrangement `arr`. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>The instantiated `GeomTraits` class must model the 

BGL/doc/BGL/CGAL/Polyhedron_items_with_id_3.h

@@ -15,11 +15,11 @@ halfedge.
 
 \cgalModels `PolyhedronItems_3` 
 
-### Operations ###
+\cgalHeading{Operations}
 
 Supported as required by the `PolyhedronItems_3` concept. 
 
-### Additional Methods in All Three Items ###
+\cgalHeading{Additional Methods in All Three Items}
 
 \code
 int id() const; // Returns the index. 

Boolean_set_operations_2/doc/Boolean_set_operations_2/CGAL/Boolean_set_operations_2.h

@@ -73,7 +73,7 @@ The signature of the function is
   OutputIterator difference(const Type1 & p1, const Type2 & p2, OutputIterator oi);
 \endcode
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `difference()` function are any of the following combinations.
 
@@ -192,7 +192,7 @@ The signature of the function is
   bool do_intersect(const Type1 & p1, const Type2 & p2);
 \endcode
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `do_intersect()` function are any of the following combinations.
 
@@ -322,7 +322,7 @@ The signature of the function is
 \endcode
 
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `intersection()` function are any of the following combinations.
 
@@ -481,7 +481,7 @@ The signature of the function is
   bool join(const Type1 & p1, const Type2 & p2, General_polygon_with_holes_2 & res);
 \endcode
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `join()` function are any of the following combinations.
 
@@ -635,7 +635,7 @@ The signature of the function is
   Oriented_side oriented_side(const Type1 & p1, const Type2 & p2);
 \endcode
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `oriented_side()` function are any of the following combinations.
 
@@ -721,7 +721,7 @@ The signature of the function is
   OutputIterator symmetric_difference(const Type1 & p1, const Type2 & p2, OutputIterator oi);
 \endcode
 
-###Parameters###
+\cgalHeading{Parameters}
 
 The types of the paramters of the `symmetric_difference()` function are any of the following combinations.
 

Bounding_volumes/doc/Bounding_volumes/CGAL/Approximate_min_ellipsoid_d.h

@@ -113,7 +113,7 @@ using the \f$ d\f$-dimensional \cgal kernel; the models
 
 \sa `CGAL::Min_ellipse_2<Traits>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We implement Khachyian's algorithm for rounding 
 polytopes \cite cgal:k-rprnm-96. Internally, we use 
@@ -122,7 +122,7 @@ Cholesky-decomposition. The algorithm's running time is
 \f$ {\cal O}(nd^2(\epsilon^{-1}+\ln d + \ln\ln(n)))\f$, where \f$ n=|P|\f$ and 
 \f$ 1+\epsilon\f$ is the desired approximation ratio. 
 
-## Example ###
+\cgalHeading{Example}
 
 To illustrate the usage of `Approximate_min_ellipsoid_d` we give two examples in 2D. The 
 first program generates a random set \f$ P\subset\E^2\f$ and outputs the 

Bounding_volumes/doc/Bounding_volumes/CGAL/Min_annulus_d.h

@@ -36,7 +36,7 @@ two-, three-, and \f$ d\f$-dimensional \cgal kernel, respectively.
 \sa `CGAL::Optimisation_d_traits_d<K,ET,NT>` 
 \sa `OptimisationDTraits` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The problem of finding the smallest enclosing annulus of a finite point set 
 can be formulated as an optimization problem with linear constraints and a 
@@ -268,7 +268,7 @@ FT squared_outer_radius( ) const;
 returns an iterator referring to the first coordinate 
 of the center of `min_annulus`. 
 
-### Note ###
+\cgalHeading{Note}
 
 The coordinates have a rational 
 representation, i.e. the first \f$ d\f$ elements of the iterator 

Bounding_volumes/doc/Bounding_volumes/CGAL/Min_circle_2.h

@@ -50,7 +50,7 @@ two-dimensional \cgal kernel.
 \sa `CGAL::Min_circle_2_traits_2<K>` 
 \sa `MinCircle2Traits` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We implement the incremental algorithm of Welzl, with move-to-front 
 heuristic \cite w-sedbe-91a. The whole implementation is described 
@@ -63,7 +63,7 @@ take up to linear time, but substantially less than computing the new
 smallest enclosing circle from scratch. The clear operation and the check 
 for validity each takes linear time. 
 
-### Example ###
+\cgalHeading{Example}
 
 To illustrate the creation of `Min_circle_2` and to show that 
 randomization can be useful in certain cases, we give an example. 

Bounding_volumes/doc/Bounding_volumes/CGAL/Min_ellipse_2.h

@@ -32,7 +32,7 @@ two-dimensional \cgal kernel.
 \sa `CGAL::Min_ellipse_2_traits_2<K>` 
 \sa `MinEllipse2Traits` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We implement the incremental algorithm of Welzl, with move-to-front 
 heuristic \cite w-sedbe-91a, using the primitives as described 
@@ -46,7 +46,7 @@ take up to linear time, but substantially less than computing the new
 smallest enclosing ellipse from scratch. The clear operation and the check 
 for validity each takes linear time. 
 
-### Example ###
+\cgalHeading{Example}
 
 To illustrate the usage of `Min_ellipse_2` and to show that randomization 
 can be useful in certain cases, we give an example. The example also 

Bounding_volumes/doc/Bounding_volumes/CGAL/Min_sphere_d.h

@@ -53,7 +53,7 @@ for two-, three-, and \f$ d\f$-dimensional points respectively.
 \sa `CGAL::Min_sphere_of_spheres_d<Traits>` 
 \sa `CGAL::Min_annulus_d<Traits>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We implement the algorithm of Welzl with move-to-front 
 heuristic \cite w-sedbe-91a for small point sets, combined with a new 
@@ -66,7 +66,7 @@ but substantially less than computing the new smallest enclosing
 sphere from scratch. The clear operation and the check for validity 
 each take linear time. 
 
-### Example ###
+\cgalHeading{Example}
 
 \cgalExample{Min_sphere_d/min_sphere_d.cpp} 
 

Bounding_volumes/doc/Bounding_volumes/CGAL/Min_sphere_of_spheres_d.h

@@ -70,7 +70,7 @@ might still be an option in case your input number type cannot
 \sa `CGAL::Min_sphere_d<Traits>` 
 \sa `CGAL::Min_circle_2<Traits>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We implement two algorithms, the LP-algorithm and a 
 heuristic \cite msw-sblp-92. As described in the documentation of 
@@ -93,7 +93,7 @@ not supported at this time. Also, the current implementation only
 handles spheres with Cartesian coordinates; homogenous representation 
 is not supported yet. 
 
-### Example ###
+\cgalHeading{Example}
 
 \cgalExample{Min_sphere_of_spheres_d/min_sphere_of_spheres_d_d.cpp} 
 

Bounding_volumes/doc/Bounding_volumes/CGAL/min_quadrilateral_2.h

@@ -42,14 +42,14 @@ type from one the \cgal kernels. In this case, a default traits class
 \sa `MinQuadrilateralTraits_2` 
 \sa `CGAL::Min_quadrilateral_default_traits_2<K>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We use a rotating caliper 
 algorithm 
 \cite stvwe-mepa-95, \cite v-fmep-90 with worst case running time linear 
 in the number of input points. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random convex polygon 
 `P` with 20 vertices and computes the minimum enclosing 
@@ -112,13 +112,13 @@ is `CGAL::Point_2<K>` for some kernel `K`.
 \sa `MinQuadrilateralTraits_2` 
 \sa `CGAL::Min_quadrilateral_default_traits_2<K>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We use a rotating caliper 
 algorithm \cite t-sgprc-83 
 with worst case running time linear in the number of input points. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random convex polygon 
 `P` with 20 vertices and computes the minimum enclosing 
@@ -180,13 +180,13 @@ is `CGAL::Point_2<K>` for some kernel `K`.
 \sa `MinQuadrilateralTraits_2` 
 \sa `CGAL::Min_quadrilateral_default_traits_2<K>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We use a rotating caliper 
 algorithm \cite t-sgprc-83 
 with worst case running time linear in the number of input points. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random convex polygon 
 `P` with 20 vertices and computes the minimum enclosing 

Bounding_volumes/doc/Bounding_volumes/CGAL/rectangular_p_center_2.h

@@ -242,7 +242,7 @@ is a model for `RectangularPCenterTraits_2`.
 \sa `CGAL::Rectangular_p_center_default_traits_2<K>` 
 \sa `CGAL::sorted_matrix_search` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The runtime is linear for \f$ p \in \{2,\,3\}\f$ and 
 \f$ \mathcal{O}(n \cdot \log n)\f$ for \f$ p = 4\f$ where \f$ n\f$ is the number of 
@@ -252,7 +252,7 @@ algorithm uses a prune-and-search technique described in
 search \cite fj-fkppc-83, \cite fj-gsrsm-84 and fast algorithms for 
 piercing rectangles \cite sw-rpppp-96. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random set of ten points 
 and computes its two-centers. 

Box_intersection_d/doc/Box_intersection_d/CGAL/box_intersection_d.h

@@ -56,7 +56,7 @@ namespace CGAL {
   \sa `BoxIntersectionBox_d` 
   \sa `BoxIntersectionTraits_d` 
 
-###   Implementation ###
+\cgalHeading{Implementation}
 
   The algorithm is trivially testing all pairs and runs therefore in time 
   \f$ O(nm)\f$ where \f$ n\f$ is the size of the first sequence and \f$ m\f$ is the 
@@ -130,7 +130,7 @@ namespace CGAL {
   values `Box_intersection_d::COMPLETE` and 
   `Box_intersection_d::BIPARTITE`. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>`RandomAccessIterator1`, and \f$ \ldots\f$ `2`, must be 
@@ -154,7 +154,7 @@ namespace CGAL {
   \sa `BoxIntersectionBox_d` 
   \sa `BoxIntersectionTraits_d` 
 
-  ### Implementation ###
+\cgalHeading{Implementation}
 
   The implemented algorithm is described in \cite cgal:ze-fsbi-02 as 
   version two. Its performance depends on a `cutoff` parameter. 
@@ -186,7 +186,7 @@ namespace CGAL {
   cutoff parameters are recommended. See also 
   Section \ref secboxintersperformance . 
 
-  ### Example ###
+\cgalHeading{Example}
 
   The box implementation provided with 
   `Box_intersection_d::Box_d<double,2>` has a special 
@@ -327,7 +327,7 @@ namespace CGAL {
   concept and that the box handle, i.e., the iterators value type, is 
   identical to the box type or a pointer to the box type. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>`ForwardIterator` must be a forward iterator. We call its 
@@ -351,7 +351,7 @@ namespace CGAL {
   \sa `BoxIntersectionBox_d` 
   \sa `BoxIntersectionTraits_d` 
 
-  ### Implementation ###
+\cgalHeading{Implementation}
 
   The algorithm is trivially testing all pairs and runs therefore in time 
   \f$ O(n^2)\f$ where \f$ n\f$ is the size of the input sequence. This algorithm 
@@ -447,7 +447,7 @@ namespace CGAL {
   concept and that the box handle, i.e., the iterators value type, is 
   identical to the box type or a pointer to the box type. 
 
-  ### Requirements ###
+\cgalHeading{Requirements}
 
   <UL> 
   <LI>`RandomAccessIterator` must be a mutable random-access 
@@ -470,12 +470,12 @@ namespace CGAL {
   \sa `BoxIntersectionBox_d` 
   \sa `BoxIntersectionTraits_d` 
 
-  ### Implementation ###
+\cgalHeading{Implementation}
 
   See the implementation section of the `box_intersection_d()` 
   function.
 
-  ### Example ###
+\cgalHeading{Example}
 
   The box implementation provided with 
   `Box_intersection_d::Box_d<double,2>` has a special 

Circular_kernel_2/doc/Circular_kernel_2/CGAL/Circular_kernel_2.h

@@ -6,7 +6,7 @@ namespace CGAL {
 
 \cgalModels `CircularKernel`
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The first parameter of the circular kernel must be instantiated with a 
 model of the `Kernel` concept. The `Circular_kernel_2` class 

Circular_kernel_2/doc/Circular_kernel_2/CGAL/Line_arc_2.h

@@ -6,7 +6,7 @@ namespace CGAL {
 
 \cgalModels `CircularKernel::LineArc_2`
 
-### I/O ###
+\cgalHeading{I/O}
 
 The format for input/output is, for each line arc: a `Line_2` 
 (the supporting line) and two `Circular_arc_point_2` (the two endpoints), 

Circular_kernel_3/doc/Circular_kernel_3/CGAL/Circular_arc_3.h

@@ -6,7 +6,7 @@ namespace CGAL {
 
 \cgalModels `SphericalKernel::CircularArc_3`
 
-### I/O ###
+\cgalHeading{I/O}
 
 The input/output format of a circular arc consists of the supporting circle 
 represented as a `Circle_3` object followed by the source and target 

Circular_kernel_3/doc/Circular_kernel_3/CGAL/Spherical_kernel_3.h

@@ -6,7 +6,7 @@ namespace CGAL {
 
 \cgalModels `SphericalKernel`
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The first parameter of the spherical kernel must be instantiated with 
 a model of the `Kernel` concept. The `Spherical_kernel_3` 

Circulator/doc/Circulator/CGAL/circulator.h

@@ -121,11 +121,11 @@ requirements for container (i.e.\ to have a `begin()` and an
 `reference`, `const_reference`, `value_type`,
 `size_type`, and `difference_type`).
 
-### Types ###
+\cgalHeading{Types}
 
 All types required for circulators are provided.
 
-### Operations ###
+\cgalHeading{Operations}
 
 The adaptor conforms to the requirements of the corresponding
 circulator category. An additional member function
@@ -136,7 +136,7 @@ the same position as the circulator does.
 \sa `Circulator_from_iterator`
 \sa `Circulator`
 
-### Example ###
+\cgalHeading{Example}
 
 The following program composes two adaptors - from a container to a
 circulator and back to an iterator. It applies an \stl sort algorithm
@@ -192,7 +192,7 @@ category. The circulator will be mutable or non-mutable according to
 the iterator. Iterators provide no `size_type`. This adapter
 assumes `std::size_t` instead.
 
-### Operations ###
+\cgalHeading{Operations}
 
 The adaptor conforms to the requirements of the respective circulator
 category. An additional member function `current_iterator()`
@@ -203,7 +203,7 @@ circulator does.
 \sa `Circulator_from_container`
 \sa `Circulator`
 
-### Example ###
+\cgalHeading{Example}
 
 The following program composes two adaptors - from an iterator to a
 circulator and back to an iterator. It applies an \stl sort algorithm
@@ -313,7 +313,7 @@ circulator category for iterators, i.e.\ one of
 `Forward_circulator_tag`, `Bidirectional_circulator_tag`, or
 `Random_access_circulator_tag`.
 
-### Example ###
+\cgalHeading{Example}
 
 A generic function `bar` that distinguishes between a call with a
 circulator range and a call with an iterator range:
@@ -386,7 +386,7 @@ otherwise.
 \sa `Circulator_from_container`
 \sa `Circulator`
 
-### Example ###
+\cgalHeading{Example}
 
 The generic <TT>reverse()</TT> algorithm from the \stl can be used with an
 adaptor if at least a bidirectional circulator <TT>c</TT> is given.
@@ -399,7 +399,7 @@ reverse( container.begin(), container.end());
 
 \endcode
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The iterator adaptor keeps track of the number of rounds a circulator
 has done around the ring-like data structure (a kind of winding
@@ -552,7 +552,7 @@ the range is empty or not.
 
 \pre `IC` is either a circulator or an iterator type. The range `[i, j)` is valid.
 
-### Example ###
+\cgalHeading{Example}
 
 The following function `process_all` accepts a range `[i, j)` of an iterator or circulator `IC` and processes each
 element in this range:

Circulator/doc/Circulator/CGAL/circulator_bases.h

@@ -18,7 +18,7 @@ To use the tags or base classes only it is sufficient to include:
 \sa `is_empty_range`
 \sa `Circulator`
 
-### Example ###
+\cgalHeading{Example}
 
 The above declarations can be used to distinguish between iterators
 and circulators and between different circulator categories. The
@@ -34,7 +34,7 @@ example program illustrates both.
 /*!
 \addtogroup PkgHandlesAndCirculatorsBaseClasses
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Since not all current compilers can eliminate the space needed for the
 compile time tags even when deriving from them, we implement a variant

Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map.h

@@ -22,7 +22,7 @@ There are two default template arguments:
 `Combinatorial_map_min_items<d>` for `Items` and 
 `CGAL_ALLOCATOR(int)` from the `<CGAL/memory.h>` header file for `Alloc`. 
 
-##Complexity##
+\cgalHeading{Complexity}
 
 
 The complexity of `sew` and `unsew` is in <I>O</I>(\f$ |\f$<I>S</I>\f$ |\f$\f$ \times\f$\f$ |\f$<I>c</I>\f$ |\f$), <I>S</I> 

Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map_min_items.h

@@ -12,7 +12,7 @@ In this class, no attribute is enabled.
 
 \cgalModels `CombinatorialMapItems`
 
-### Example ###
+\cgalHeading{Example}
 
 The following example shows the implementation of the
 `Combinatorial_map_min_items` class.

Combinatorial_map/doc/Combinatorial_map/CGAL/Dart.h

@@ -17,7 +17,7 @@ non void <I>i</I>-attribute.
 
 \tparam CMap must be a model of the `CombinatorialMap` concept. 
 
-###Complexity ###
+\cgalHeading{Complexity }
 
 Each \f$ \beta_i\f$ link is initialized to `CMap::null_dart_handle`, and each 
 attribute handle of non void <I>i</I>-attribute is initialized to `NULL` 

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_akl_toussaint.h

@@ -13,7 +13,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 The default traits class `Default_traits` is the kernel in which the 
 value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `ForwardIterator` and 
@@ -37,7 +37,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_melkman` 
 \sa `CGAL::convex_hull_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function uses the algorithm of Akl and 
 Toussaint \cite at-fcha-78 that requires \f$ O(n \log n)\f$ time for \f$ n\f$ input 

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_bykat.h

@@ -14,7 +14,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 The default traits class `Default_traits` is the kernel in which the 
 value type of  `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and 
@@ -38,7 +38,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_melkman` 
 \sa `CGAL::convex_hull_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function implements the non-recursive variation of 
 Eddy's algorithm \cite e-nchap-77 described in \cite b-chfsp-78. 

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_eddy.h

@@ -14,7 +14,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 The default traits class `Default_traits` is the kernel in which the 
 type value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and 
@@ -38,7 +38,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_melkman` 
 \sa `CGAL::convex_hull_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function implements Eddy's algorithm 
 \cite e-nchap-77, which is the two-dimensional version of the quickhull 

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_graham_andrew.h

@@ -15,7 +15,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 The default traits class `Default_traits` is the kernel in which the 
 value type of  `InputIteratore` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and 
@@ -41,7 +41,7 @@ functions that return instances of these types:
 \sa `CGAL::lower_hull_points_2` 
 \sa `CGAL::upper_hull_points_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function implements Andrew's variant of the Graham 
 scan algorithm \cite a-aeach-79 and follows the presentation of Mehlhorn 
@@ -71,7 +71,7 @@ by the first and last points in this sequence.
 The default traits class `Default_traits` is the kernel in which the 
 type `BidirectionalIterator::value_type` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`BidirectionalIterator::value_type` and 
@@ -90,13 +90,13 @@ functions that return instances of these types:
 \sa `CGAL::lower_hull_points_2` 
 \sa `CGAL::upper_hull_points_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The function uses Andrew's 
 variant of the Graham scan algorithm \cite a-aeach-79. This algorithm 
 requires \f$ O(n \log n)\f$ time in the worst case for \f$ n\f$ input points. 
 
-### Example ###
+\cgalHeading{Example}
 
 In the following example `ch_graham_andrew_scan()` is used to 
 realize Anderson's variant \cite a-readc-78 of the Graham Scan 

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_jarvis.h

@@ -14,7 +14,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 The default traits class `Default_traits` is the kernel in which the 
 value type of `InputIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and 
@@ -38,7 +38,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_melkman` 
 \sa `CGAL::convex_hull_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function uses the Jarvis march (gift-wrapping) 
 algorithm \cite j-ichfs-73. This algorithm requires \f$ O(n h)\f$ time 
@@ -66,7 +66,7 @@ points from a given set of input points that line between two input points.
 The default traits class `Default_traits` is the kernel in which the 
 type `ForwardIterator::value_type` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`ForwardIterator::value_type` and 
@@ -86,7 +86,7 @@ functions that return instances of these types:
 \sa `CGAL::lower_hull_points_2` 
 \sa `CGAL::upper_hull_points_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The function uses the Jarvis march (gift-wrapping) algorithm \cite j-ichfs-73. 
 This algorithm requires \f$ O(n h)\f$ time in the worst

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_melkman.h

@@ -13,7 +13,7 @@ the resulting sequence is returned.
 The default traits class `Default_traits` is the kernel in which the 
 value type of `InputIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and `OutputIterator` 
@@ -37,7 +37,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_melkman` 
 \sa `CGAL::convex_hull_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 It uses an implementation of Melkman's algorithm \cite m-olcch-87. 
 Running time of this is linear.

Convex_hull_2/doc/Convex_hull_2/CGAL/ch_selected_extreme_points_2.h

@@ -14,7 +14,7 @@ After execution, the value of
 The default traits class `Default_traits` is the kernel in which the 
 value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines a type `Traits::Less_xy_2` as described in 
 the concept `ConvexHullTraits_2` and the corresponding member 
@@ -53,7 +53,7 @@ After execution, the value of
 The default traits class `Default_traits` is the kernel in which the type 
 `ForwardIterator::value_type` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines the type `Traits::Less_yx_2` as specified in 
 the concept `ConvexHullTraits_2` and the corresponding member 
@@ -94,7 +94,7 @@ holds for all iterators in the range.
 The default traits class `Default_traits` is the kernel in which the 
 value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines the type `Traits::Less_yx_2` as specified in 
 the concept `ConvexHullTraits_2` and the corresponding member 
@@ -137,7 +137,7 @@ After execution, the value of
 \f$ \ge_{xy}\f$ `*it` hold for all iterators
 `it` in the range.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` contains the following subset of types from 
 the concept `ConvexHullTraits_2` and their corresponding member 
@@ -186,7 +186,7 @@ After execution, the value of
 The default traits class `Default_traits` is the kernel in which the 
 type `ForwardIterator::value_type` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines the type `Traits::Less_yx_2` as specified in 
 the concept `ConvexHullTraits_2` and the corresponding member 
@@ -227,7 +227,7 @@ holds for all iterators in the range.
 The default traits class `Default_traits` is the kernel in which the 
 type `ForwardIterator::value_type` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines the type `Traits::Less_xy_2` as specified in 
 the concept `ConvexHullTraits_2` and the corresponding member 
@@ -264,7 +264,7 @@ After execution, the value of
 `w` is an iterator in the range such that `*w` \f$ \le_{xy}\f$
 `*it` for all iterators `it` in the range.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` defines the type `Traits::Less_xy_2` as specified in 
 the concept `ConvexHullTraits_2` and the corresponding member 

Convex_hull_2/doc/Convex_hull_2/CGAL/convex_hull_2.h

@@ -17,7 +17,7 @@ cyclic sequence of extreme points is cut into a linear sequence.
 
 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and `OutputIterator` 
@@ -42,7 +42,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_jarvis` 
 \sa `CGAL::ch_melkman` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 One of two algorithms is used, 
 depending on the type of iterator used to specify the input points. For 
@@ -103,7 +103,7 @@ The different treatment by `upper_hull_points_2()` of the case that
 all points are equal ensures that concatenation of lower and upper hull 
 points gives the sequence of extreme points. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and `OutputIterator` 
@@ -124,7 +124,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_graham_andrew_scan` 
 \sa `CGAL::upper_hull_points_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function uses Andrew's variant of Graham's scan algorithm 
 \cite a-aeach-79, \cite m-mdscg-84. The algorithm has worst-case running time 
@@ -167,7 +167,7 @@ The different treatment by `lower_hull_points_2()` of the case that
 all points are equal ensures that concatenation of lower and upper hull 
 points gives the sequence of extreme points. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `InputIterator` and `OutputIterator` 
@@ -188,7 +188,7 @@ functions that return instances of these types:
 \sa `CGAL::ch_graham_andrew_scan` 
 \sa `CGAL::lower_hull_points_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function uses Andrew's 
 variant of Graham's scan algorithm \cite a-aeach-79, \cite m-mdscg-84. The algorithm 

Convex_hull_2/doc/Convex_hull_2/CGAL/convexity_check_2.h

@@ -16,7 +16,7 @@ if it consists of only extreme points
 The default traits class `Default_traits` is the kernel in which the 
 value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` contains the following subset of types from 
 the concept `ConvexHullTraits_2` and their corresponding member 
@@ -30,7 +30,7 @@ functions that return instances of these types:
 \sa `CGAL::is_cw_strongly_convex_2` 
 \sa `CGAL::is_strongly_convex_3` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The algorithm requires \f$ O(n)\f$ time for a set of \f$ n\f$ input points. 
 
@@ -65,7 +65,7 @@ if it consists of only extreme points
 The default traits class `Default_traits` is the kernel in which the 
 value type of `ForwardIterator` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 `Traits` contains the following subset of types from 
 the concept `ConvexHullTraits_2` and their corresponding member 
@@ -79,7 +79,7 @@ functions that return instances of these types:
 \sa `CGAL::is_ccw_strongly_convex_2` 
 \sa `CGAL::is_strongly_convex_3` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The algorithm requires \f$ O(n)\f$ time for a set of \f$ n\f$ input points. 
 

Convex_hull_3/doc/Convex_hull_3/CGAL/convex_hull_3.h

@@ -28,7 +28,7 @@ then the default traits class of `::convex_hull_3()` is `Convex_hull_traits_3<R>
 
 \sa `convex_hull_incremental_3()` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The algorithm implemented by these functions is the quickhull algorithm of 
 Barnard <I>et al.</I> \cite bdh-qach-96. 

Convex_hull_3/doc/Convex_hull_3/CGAL/convex_hull_incremental_3.h

@@ -29,7 +29,7 @@ the representation class `R` required by
 \sa `convex_hull_3()` 
 \sa `Convex_hull_d` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function uses the `d`-dimensional convex hull incremental construction 
 algorithm \cite cms-frric-93 

Convex_hull_3/doc/Convex_hull_3/CGAL/convexity_check_3.h

@@ -11,7 +11,7 @@ vertices of the convex hull).
 The default traits class is the kernel in which the type 
 `Polyhedron::Point_3` is defined. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Polyhedron::Point_3` is equivalent to `Traits::Point_3`. 
@@ -34,7 +34,7 @@ the facet type must be `ConvexHullPolyhedronFacet_3`.
 </OL> 
 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function implements the tests described in \cite mnssssu-cgpvg-96 to 
 determine convexity and requires \f$ O(e + f)\f$ time for a polyhedron with 

Convex_hull_d/doc/Convex_hull_d/CGAL/Convex_hull_d.h

@@ -44,7 +44,7 @@ C.index_of_vertex_in_opposite_facet(f,i)`. Then
 
 \tparam R must be a model of the concept `ConvexHullTraits_d`.
 
-### Iteration Statements ###
+\cgalHeading{Iteration Statements}
 
 <B>forall_ch_vertices</B>(\f$ v,C\f$) \f$ \{\f$ the vertices of \f$ C\f$ are
 successively assigned to \f$ v\f$ \f$ \}\f$
@@ -55,7 +55,7 @@ successively assigned to \f$ s\f$ \f$ \}\f$
 <B>forall_ch_facets</B>(\f$ f,C\f$) \f$ \{\f$ the facets of \f$ C\f$ are
 successively assigned to \f$ f\f$ \f$ \}\f$
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation of type `Convex_hull_d` is based on
 \cite cms-frric-93 and \cite bms-dgc-94. The details

Convex_hull_d/doc/Convex_hull_d/CGAL/Delaunay_d.h

@@ -57,7 +57,7 @@ belongs to the furthest site triangulation.
 \tparam R must be a model of the concept `DelaunayTraits_d`.
 \tparam Lifted_R must be a model of the concept `DelaunayLiftedTraits_d`.
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The data type is derived from `Convex_hull_d` via
 the lifting map. For a point `x` in `d`-dimensional space let
@@ -73,7 +73,7 @@ The space requirement is the same as for convex hulls. The time
 requirement for an insert is the time to insert the lifted point
 into the convex hull of the lifted points.
 
-### Example ###
+\cgalHeading{Example}
 
 The abstract data type `Delaunay_d` has a default instantiation by
 means of the `d`-dimensional geometric kernel.
@@ -98,7 +98,7 @@ Vertex_handle v1 = T.insert(Point_d(2,11));
 }
 \endcode
 
-### Traits Requirements ###
+\cgalHeading{Traits Requirements}
 
 `Delaunay_d< R, Lifted_R >` requires the following types from the kernel traits `Lifted_R`:
 

Generator/doc/Generator/CGAL/Random.h

@@ -17,7 +17,7 @@ It can be very useful, e.g. for debugging, to reproduce a sequence of
 random numbers. This can be done by either initialising with a fixed 
 seed, or by using the state functions as described below. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 We use the boost random library function `boost::rand48` to generate the random 
 numbers. 

Generator/doc/Generator/CGAL/point_generators_2.h

@@ -11,7 +11,7 @@ replacing each point with a random point from the `xeps` \f$ \times\f$
 `yeps` rectangle centered at the original point.  Two random numbers
 are needed from `rnd` for each point.
 
-### Requires ###
+\cgalHeading{Requires}
 
 - `Creator` must be a function object accepting two
   `double` values \f$ x\f$ and \f$ y\f$ and returning an initialized point
@@ -72,7 +72,7 @@ The function creates the first \f$ n\f$ points on the regular \f$ \lceil\sqrt{n}
 the \f$ n\f$ points.
 
 
-### Requires ###
+\cgalHeading{Requires}
 
 - `Creator` must be a function object accepting two
   `double` values \f$ x\f$ and \f$ y\f$ and returning an initialized point
@@ -108,7 +108,7 @@ in the range `[first,last)`.
 Three random numbers are needed from `rnd` for each point.
 Returns the value of `first2` after inserting the \f$ n\f$ points.
 
-### Requires ###
+\cgalHeading{Requires}
 
 - `Creator` must be a function object accepting two
   `double` values \f$ x\f$ and \f$ y\f$ and returning an initialized point

Generator/doc/Generator/CGAL/point_generators_3.h

@@ -11,7 +11,7 @@ grid within the cube
 inserting the \f$ n\f$ points.
 
 
-###Requires###
+\cgalHeading{Requires}
 - `Creator` must be a function object accepting three
   `double` values \f$ x\f$, \f$ y\f$, and \f$ z\f$ and returning an initialized
   point `(x,y,z)` of type `P`. Predefined implementations for

Generator/doc/Generator/CGAL/point_generators_d.h

@@ -13,7 +13,7 @@ within the hypercube \f$ [-a,a]^{dim}\f$.
 
 \returns the value of \f$ o\f$ after inserting the \f$ n\f$ points.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <UL>
 <LI>`Creator` must be a functor accepting an integer (the dimension)

Generator/doc/Generator/CGAL/random_convex_set_2.h

@@ -14,7 +14,7 @@ we cannot easily describe the resulting distribution.
 
  
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 - `PointGenerator` is a model of the concept PointGenerator 
 - `Traits` is a model of the concept RandomConvexSetTraits_2 
@@ -28,14 +28,14 @@ R >` for some representation class `R`,
 \sa `CGAL::Random_points_in_square_2<Point_2, Creator>` 
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation uses the centroid method 
 described in \cite cgal:s-zkm-96 and has a worst case running time of \f$ O(r 
 \cdot n + n \cdot \log n)\f$, where \f$ r\f$ is the time needed by `pg` 
 to generate a random point. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following program displays a random convex 500-gon where the 
 points are drawn uniformly from the unit square centered at the 

Generator/doc/Generator/CGAL/random_polygon_2.h

@@ -15,7 +15,7 @@ points has a non-zero probability of being constructed, some polygons may
 have higher probabilities than others. The overall distribution of the 
 generated polygons is not known since it depends on the generated points. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 - `Traits` is a model of the concept RandomPolygonTraits_2 
 - `PointGenerator::value_type` is equivalent to 
@@ -28,7 +28,7 @@ The default traits class `Default_traits` is the kernel in which
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>` 
 \sa `CGAL::Random_points_in_square_2<Point_2, Creator>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation is based on the method of eliminating self-intersections in 
 a polygon by using so-called "2-opt" moves. Such a move eliminates an 
@@ -39,7 +39,7 @@ Intersecting edges are detected using a simple sweep through the vertices
 and then one intersection is chosen at random to eliminate after each sweep. 
 The worse-case running time is therefore \f$ O(n^4 \log n)\f$. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following program displays a random simple polygon with up to 100 
 vertices, where the vertex coordinates are drawn uniformly from the 

Geomview/doc/Geomview/CGAL/IO/Geomview_stream.h

@@ -8,7 +8,7 @@ namespace CGAL {
   from. The constructor starts Geomview either on the local either on
   a remote machine.
 
-  ### Implementation ###
+\cgalHeading{Implementation}
 
   The constructor forks a process and establishes two pipes between the
   processes. The forked process is then overlaid with Geomview. The

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_const_decorator.h

@@ -24,7 +24,7 @@ all halfedge data structures and will not appear here again.
 \tparam HDS must be a model of `HalfedgeDS`
 
 
-### Example ###
+\cgalHeading{Example}
 
 The following program fragment illustrates the implementation of a 
 `is_valid()` member function for a simplified polyhedron class. 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_decorator.h

@@ -23,7 +23,7 @@ all halfedge data structures and will not appear here again.
 \sa `CGAL::HalfedgeDS_items_decorator<HDS>` 
 \sa `CGAL::HalfedgeDS_const_decorator<HDS>` 
 
-### Example ###
+\cgalHeading{Example}
 
 The following program fragment illustrates the implementation of the 
 Euler operator `split_vertex()` for a simplified polyhedron class. 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_default.h

@@ -21,7 +21,7 @@ removal.
 \sa `CGAL::HalfedgeDS_decorator<HDS>` 
 \sa `CGAL::HalfedgeDS_const_decorator<HDS>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Currently, `HalfedgeDS_default` is derived from `CGAL::HalfedgeDS_list<Traits>`. 
 The copy constructor and the assignment operator need \f$ O(n)\f$ time with 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_items_2.h

@@ -19,7 +19,7 @@ is the template argument of the corresponding `HalfedgeDS`.
 \sa `CGAL::HalfedgeDS_halfedge_base<Refs>` 
 \sa `CGAL::HalfedgeDS_face_base<Refs>` 
 
-### Example ###
+\cgalHeading{Example}
 
 The following example shows the canonical implementation of the 
 `HalfedgeDS_items_2` class. It uses the base classes for the item types that 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_items_decorator.h

@@ -23,7 +23,7 @@ all halfedge data structures and will not appear here again.
 \sa `CGAL::HalfedgeDS_decorator<HDS>` 
 \sa `CGAL::HalfedgeDS_const_decorator<HDS>` 
 
-### Example ###
+\cgalHeading{Example}
 
 The following program fragment illustrates how a refined halfedge 
 class for a polyhedron can make use of the `find_prev()` member 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_list.h

@@ -17,7 +17,7 @@ iterators that supports removal.
 \sa `CGAL::HalfedgeDS_decorator<HDS>` 
 \sa `CGAL::HalfedgeDS_const_decorator<HDS>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 `HalfedgeDS_list` uses internally the `CGAL::In_place_list` container class. 
 The copy constructor and the assignment operator need \f$ O(n)\f$ time with 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_min_items.h

@@ -19,7 +19,7 @@ halfedges.
 \sa `CGAL::HalfedgeDS_halfedge_min_base<Refs>` 
 \sa `CGAL::HalfedgeDS_face_min_base<Refs>` 
 
-### Example ###
+\cgalHeading{Example}
 
 The following example shows the canonical implementation of the 
 `CGAL::HalfedgeDS_min_items` class. It uses the base classes for the 

HalfedgeDS/doc/HalfedgeDS/CGAL/HalfedgeDS_vector.h

@@ -17,7 +17,7 @@ access iterators that does not support removal.
 \sa `CGAL::HalfedgeDS_decorator<HDS>` 
 \sa `CGAL::HalfedgeDS_const_decorator<HDS>` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 `HalfedgeDS_vector` uses internally the \stl `std::vector` container 
 class. We require that we can create a `std::vector::iterator` 

Inscribed_areas/doc/Inscribed_areas/CGAL/Largest_empty_iso_rectangle_2.h

@@ -11,7 +11,7 @@ that do not contain any point of the point set.
 
 \tparam T must be a model of the concept `LargestEmptyIsoRectangleTraits_2`.
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The algorithm is an implementation of \cite o-naler-90. The runtime of an 
 insertion or a removal is \f$ O(\log n)\f$. A query takes \f$ O(n^2)\f$ worst 

Inscribed_areas/doc/Inscribed_areas/CGAL/extremal_polygon_2.h

@@ -29,7 +29,7 @@ convex polygon (oriented clock- or counterclockwise).
 \sa `CGAL::maximum_perimeter_inscribed_k_gon_2()`
 \sa `ExtremalPolygonTraits_2` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation uses monotone matrix search 
 \cite akmsw-gamsa-87 and has a worst case running time of \f$ O(k 
@@ -86,14 +86,14 @@ where `K` is a model of `Kernel`.
 \sa `CGAL::Extremal_polygon_perimeter_traits_2<K>`
 \sa `CGAL::extremal_polygon_2()`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation uses monotone matrix search 
 \cite akmsw-gamsa-87 and has a worst case running time of \f$ O(k 
 \cdot n + n \cdot \log n)\f$, where \f$ n\f$ is the number of vertices in 
 \f$ P\f$. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random convex polygon 
 `p` with ten vertices and computes the maximum area inscribed 
@@ -155,14 +155,14 @@ defined that computes the squareroot of a number.
 \sa `CGAL::Extremal_polygon_perimeter_traits_2<K>`
 \sa `CGAL::extremal_polygon_2()`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation uses monotone matrix search 
 \cite akmsw-gamsa-87 and has a worst case running time of \f$ O(k 
 \cdot n + n \cdot \log n)\f$, where \f$ n\f$ is the number of vertices in 
 \f$ P\f$. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code generates a random convex polygon 
 `p` with ten vertices and computes the maximum perimeter inscribed 

Interpolation/doc/Interpolation/CGAL/interpolation_functions.h

@@ -13,7 +13,7 @@ whether the retrieval was successful.
 This class can be used to provide the values and gradients of the 
 interpolation functions. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The class 
 `Data_access` has the container type `Map` as template parameter. 
@@ -68,13 +68,13 @@ generates the interpolated function value computed by Farin's interpolant.
 The function `farin_c1_interpolation()` interpolates the function values and the 
 gradients that are provided by functors using the method described in \cite f-sodt-90. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The value type of `RandomAccessIterator` is a pair 
 associating a point to a (non-normalized) barycentric coordinate. See 
 `sibson_c1_interpolation()` for the other parameters. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 Same requirements as for `sibson_c1_interpolation()` only the 
 iterator must provide random access and `Traits::FT` does not need 
@@ -118,7 +118,7 @@ corresponding to each point of the point/coordinate pairs in the
 range \f$ \left[\right.\f$`first`, `beyond`\f$ \left.\right)\f$.
 \pre `norm` \f$ \neq0\f$. `function_value(p).second == true` for all points `p` of the point/coordinate pairs in the range \f$ \left[\right.\f$`first`, `beyond`\f$ \left.\right)\f$.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `ForwardIterator` is a pair of 
@@ -166,11 +166,11 @@ pairs in the range \f$ \left[\right.\f$ `first`,
 `beyond`\f$ \left.\right)\f$. See also
 `sibson_c1_interpolation`. \pre `norm` \f$ \neq0\f$ `function_value(p).second == true` for all points `p` of the point/coordinate pairs in the range \f$ \left[\right.\f$`first`, `beyond`\f$ \left.\right)\f$.
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 See `sibson_c1_interpolation`. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 Same requirements as for 
 `sibson_c1_interpolation()` only that `Traits::FT` does not need 
@@ -215,7 +215,7 @@ interpolated function value as first and `true` as second value. \pre
 `p` of the point/coordinate pairs in the range \f$\left[\right.\f$`first`, `beyond`\f$ \left.\right)\f$.
 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The template parameter `Traits` is to be 
 instantiated with a model of `InterpolationTraits`. 
@@ -228,7 +228,7 @@ coordinates for the query point `p`. The functor
 function given a point. `function_gradient` allows to access the 
 function gradient given a point. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Traits` is a model of the concept 

Interpolation/doc/Interpolation/CGAL/natural_neighbor_coordinates_2.h

@@ -9,7 +9,7 @@ called Sibson's coordinates, for `2D` points provided a two-dimensional
 triangulation and a query point in the convex hull of the vertices 
 of the triangulation. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Dt` are equivalent to the class 
@@ -30,7 +30,7 @@ the traits class of the `polygon_area_2` function.
 associating a point and its natural neighbor coordinate. 
 </OL> 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function computes the area of the sub-cells 
 stolen from the Voronoi cells of the points in `dt` when inserting 

Interpolation/doc/Interpolation/CGAL/regular_neighbor_coordinates_2.h

@@ -10,7 +10,7 @@ two-dimensional regular triangulation and a (weighted) query point
 inside the convex hull of the vertices of the triangulation. We call these 
 coordinates regular neighbor coordinates. 
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Rt` are equivalent to the class 
@@ -26,7 +26,7 @@ meet the requirements for the traits class of the
 associating a point and its regular neighbor coordinate. 
 </OL> 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function computes the areas stolen from the 
 Voronoi cells of points in `rt` by the insertion of `p`. The 

Interpolation/doc/Interpolation/CGAL/sibson_gradient_fitting.h

@@ -12,7 +12,7 @@ gradient for all data points that lie inside the convex hull of the
 data points. One function exists for each type of natural neighbor
 coordinates.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>The value type of `ForwardIterator` is a pair of point/coordinate 
@@ -38,7 +38,7 @@ provide a multiplication and addition operation with the type
 \sa `CGAL::regular_neighbor_coordinates_2()` 
 \sa `CGAL::surface_neighbor_coordinates_3()` 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This function implements Sibson's gradient 
 estimation method based on natural neighbor coordinates 

Interpolation/doc/Interpolation/CGAL/surface_neighbor_coordinates_3.h

@@ -23,7 +23,7 @@ the range `[first, beyond)`. If the sample points are collected by a
 `k`-nearest neighbor or a range search query, this permits to check
 whether the neighborhood which has been considered is large enough.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Dt` is equivalent to the class 
@@ -40,7 +40,7 @@ associating a point and its natural neighbor coordinate.
 \sa `CGAL::Voronoi_intersection_2_traits_3<K>`
 \sa `CGAL::surface_neighbors_3()`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This functions construct the regular triangulation of the input points 
 instantiated with `Voronoi_intersection_2_traits_3<Kernel>` or `ITraits` if provided. 

Interpolation/doc/Interpolation/CGAL/surface_neighbors_3.h

@@ -25,7 +25,7 @@ points are collected by a \f$ k\f$-nearest neighbor or a range search
 query, this permits to verify that a large enough neighborhood has
 been considered.
 
-### Requirements ###
+\cgalHeading{Requirements}
 
 <OL> 
 <LI>`Dt` is equivalent to the class 
@@ -38,7 +38,7 @@ been considered.
 \sa CGAL::Voronoi_intersection_2_traits_3<K> 
 \sa CGAL::surface_neighbor_coordinates_3 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 These functions compute the regular triangulation of 
 the sample points and the point `p` using a traits class 

Interval_skip_list/doc/Interval_skip_list/CGAL/Interval_skip_list.h

@@ -6,7 +6,7 @@ namespace CGAL {
 The class `Interval_skip_list` is a dynamic data structure that 
 allows to find all members of a set of intervals that overlap a point. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The insertion and deletion of a segment in the interval skip list 
 takes expected time \f$ O(\log^2 n)\f$, if the segment endpoints are 

Interval_skip_list/doc/Interval_skip_list/CGAL/Interval_skip_list_interval.h

@@ -7,7 +7,7 @@ The class `Interval_skip_list_interval` represents intervals with lower and uppe
 bound of type `Value`. These intervals 
 can be open or closed at each endpoint. 
 
-### I/O ###
+\cgalHeading{I/O}
 
 The output operator is defined for `std::ostream`. 
 

Kernel_23/doc/Kernel_23/CGAL/Aff_transformation_2.h

@@ -40,7 +40,7 @@ therefore do not appear in the constructors.
 \sa `Translation` 
 \sa `rational_rotation_approximation` 
 
-### Example ###
+\cgalHeading{Example}
 
 \code
 typedef Cartesian<double> K; 

Kernel_23/doc/Kernel_23/CGAL/Cartesian.h

@@ -16,7 +16,7 @@ the kernel is only an approximation of Euclidean geometry.
 
 \cgalModels `Kernel`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 All geometric objects in `Cartesian` are reference counted. 
 

Kernel_23/doc/Kernel_23/CGAL/Cartesian_converter.h

@@ -17,7 +17,7 @@ provide `K2::FT operator()(K1::FT n)` that converts `n` to an
 
 The default value of this parameter is `CGAL::NT_converter<K1::FT, K2::FT>`. 
 
-### Example ###
+\cgalHeading{Example}
 
 In the following example, we compute exactly 
 the intersection point between a line and a triangle, 

Kernel_23/doc/Kernel_23/CGAL/Dimension.h

@@ -9,11 +9,11 @@ namespace CGAL {
 The class `Ambient_dimension` allows to retrieve the dimension of the ambient space of 
 a type `T` in a kernel `K`. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The parameter `K` has the default value `Kernel_traits<T>::Kernel>`. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following retrieves the dimension of a point type. 
 
@@ -66,7 +66,7 @@ for dispatching functions based on the dimension of an object, as provided
 by the `dim` parameter. It is useful in cases where it is not more 
 practical to pass the dimension as a template parameter directly. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code declares two functions constructing two points at the origin, 
 either in 2D or in 3D. 
@@ -107,7 +107,7 @@ for dispatching functions based on the dimension of an object.
 `Dynamic_dimension_tag` indicates that the dimension is not known at compile-time. 
 `Dimension_tag` is the tag class dealing with compile-time dimensions. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following code declares two functions constructing two points at the origin, 
 either in 2D or in 3D. 
@@ -138,11 +138,11 @@ public:
 The class `Feature_dimension` allows to retrieve the geometric dimension of a type `T` 
 in a kernel `K`. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The parameter `K` has the default value `Kernel_traits<T>::Kernel`. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following retrieves the dimension of a point type. 
 

Kernel_23/doc/Kernel_23/CGAL/Filtered_kernel.h

@@ -15,7 +15,7 @@ the global functions are those of `CK`.
 
 \cgalModels `Kernel`
 
-### Example ###
+\cgalHeading{Example}
 
 The following example shows how to produce a kernel whose geometric 
 objects and constructions are those of `Simple_cartesian<double>` 
@@ -61,7 +61,7 @@ techniques from \cite cgal:mp-fcafg-05.
 The geometric constructions are exactly those 
 of the kernel `CK`, which means that they are not necessarily exact. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The first parameter, `CK`, is the "Construction Kernel", namely the kernel 
 from which are taken the types of the geometric objects as well as the 
@@ -75,7 +75,7 @@ production use for deactivating static filters.
 
 \cgalModels `Kernel`
 
-### Example ###
+\cgalHeading{Example}
 
 The following example shows how to produce a kernel whose geometric 
 objects and constructions are those of `Simple_cartesian<double>` 
@@ -89,7 +89,7 @@ typedef CGAL::Simple_cartesian<double> CK;
 typedef CGAL::Filtered_kernel<CK> K; 
 \endcode
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The implementation uses `CGAL::Filtered_predicate<EP, FP, C2E, C2F>` over 
 each predicate of the kernel traits interface. Additionally, faster static 

Kernel_23/doc/Kernel_23/CGAL/Filtered_predicate.h

@@ -18,7 +18,7 @@ To convert the geometric objects that are the arguments of the predicate,
 we use the function objects `C2E` and `C2F`, which must be of the form 
 `Cartesian_converter` or `Homogeneous_converter`. 
 
-### Example ###
+\cgalHeading{Example}
 
 The following example defines an efficient and exact version of the 
 orientation predicate over three points using the Cartesian representation 

Kernel_23/doc/Kernel_23/CGAL/Homogeneous.h

@@ -16,7 +16,7 @@ the kernel is only an approximation of Euclidean geometry.
 
 \cgalModels `Kernel`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 This model of a kernel uses reference counting. 
 

Kernel_23/doc/Kernel_23/CGAL/Line_2.h

@@ -17,7 +17,7 @@ on the negative side of `l`, iff
 \f$ a\, px + b\, py +c < 0\f$. 
 The positive side is to the left of `l`. 
 
-### Example ###
+\cgalHeading{Example}
 
 Let us first define two %Cartesian two-dimensional points in the Euclidean 
 plane \f$ \E^2\f$. Their 

Kernel_23/doc/Kernel_23/CGAL/Origin.h

@@ -47,7 +47,7 @@ public:
 A symbolic constant which denotes the point at the origin.  This
 constant is used in the conversion between points and vectors.
 
-### Example ###
+\cgalHeading{Example}
 
 \code
 Point_2< Cartesian<Exact_NT> > p(1.0, 1.0), q;

Kernel_23/doc/Kernel_23/CGAL/Point_2.h

@@ -13,11 +13,11 @@ kernel model `Homogeneous<T>`, `Kernel::RT` is equal
 to `T`, and `Kernel::FT` is equal to 
 `Quotient<T>`. 
 
-### Operators ###
+\cgalHeading{Operators}
 
 The following operations can be applied on points: 
 
-### Example ###
+\cgalHeading{Example}
 
 The following declaration creates two points with 
 %Cartesian double coordinates. 

Kernel_23/doc/Kernel_23/CGAL/Point_3.h

@@ -13,7 +13,7 @@ kernel model `Homogeneous<T>`, `Kernel::RT` is equal
 to `T`, and `Kernel::FT` is equal to 
 `Quotient<T>`. 
 
-### Operators ###
+\cgalHeading{Operators}
 
 The following operations can be applied on points: 
 

Kernel_23/doc/Kernel_23/CGAL/Projection_traits_xy_3.h

@@ -13,7 +13,7 @@ deal with projections on the
 `zx`- and the `zy`-plane, 
 respectively. 
 
-### Parameters ###
+\cgalHeading{Parameters}
 
 The template parameter `K` has to 
 be instantiated by a model of the `Kernel` concept. 

Kernel_23/doc/Kernel_23/CGAL/Simple_cartesian.h

@@ -16,7 +16,7 @@ the kernel is only an approximation of Euclidean geometry.
 
 \cgalModels `Kernel`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 In contrast to `Cartesian`, no reference counting 
 is used internally. This eases debugging, but may slow down algorithms 

Kernel_23/doc/Kernel_23/CGAL/Simple_homogeneous.h

@@ -16,7 +16,7 @@ the kernel is only an approximation of Euclidean geometry.
 
 \cgalModels `Kernel`
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 In contrast to `Homogeneous`, no reference counting 
 is used internally. This eases debugging, but may slow down algorithms 

Kernel_23/doc/Kernel_23/CGAL/enum.h

@@ -139,7 +139,7 @@ const CGAL::Null_vector NULL_VECTOR;
 A symbolic constant which denotes the point at the origin.
 This constant is used in the conversion between points and vectors.
 
-### Example ###
+\cgalHeading{Example}
 
 \code
   Point_2< Cartesian<Exact_NT> >  p(1.0, 1.0), q;

Kernel_23/doc/Kernel_23/CGAL/intersections.h

@@ -385,7 +385,7 @@ p    <TD>Point_3, or Segment_3</TD>
 </TABLE>
 </DIV>
 
-### Example ###
+\cgalHeading{Example}
 
 The following example demonstrates the most common use of 
 `intersection` routines with the 2D and 3D Linear %Kernel.

Kernel_23/doc/Kernel_23/CGAL/rational_rotation.h

@@ -14,7 +14,7 @@ that `sin_num`/`denom` approximates the sine of direction
 the approximating rational is bounded by `eps_num`/`eps_den`.
 \pre `eps_num` \f$ \neq0\f$.
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 The approximation is based on Farey sequences as described in 
 the rational rotation method presented by Canny and Ressler at the 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Aff_transformation_d.h

@@ -12,7 +12,7 @@ must be non-zero. A point \f$ p\f$ with homogeneous coordinates \f$ (p[0],
 = \f$ Mp\f$, where `A` is an affine transformation created from `M` 
 by the constructors below. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Affine Transformations are implemented by matrices of number type 
 `RT` as a handle type. All operations like creation, 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Direction_d.h

@@ -13,12 +13,12 @@ which are of type `FT`. Two directions are equal if their
 %Cartesian coordinates are positive multiples of each other. Directions 
 are in one-to-one correspondence to points on the unit sphere. 
 
-### Downward compatibility ###
+\cgalHeading{Downward compatibility}
 
 We provide the operations of the lower dimensional interface `dx()`, 
 `dy()`, `dz()`. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Directions are implemented by arrays of integers as an item type. All 
 operations like creation, initialization, tests, inversion, input and 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Hyperplane_d.h

@@ -22,7 +22,7 @@ coefficient vectors are positive multiples of each other and they are
 (weakly) equal if their coefficient vectors are multiples of each 
 other. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Hyperplanes are implemented by arrays of integers as an item type. 
 All operations like creation, initialization, tests, vector 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Line_d.h

@@ -6,7 +6,7 @@ namespace CGAL {
 An instance of data type `Line_d` is an oriented line in 
 \f$ d\f$-dimensional Euclidean space. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Lines are implemented by a pair of points as an item type. All 
 operations like creation, initialization, tests, direction 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Point_d.h

@@ -14,13 +14,13 @@ We call \f$ p_i\f$, \f$ 0 \leq i < d\f$ the \f$ i\f$-th %Cartesian coordinate an
 \f$ h_i\f$, \f$ 0 \le i \le d\f$, the \f$ i\f$-th homogeneous coordinate. We call \f$ d\f$ 
 the dimension of the point. 
 
-### Downward compatibility ###
+\cgalHeading{Downward compatibility}
 
 We provide operations of the lower 
 dimensional interface `x()`, `y()`, `z()`, `hx()`, 
 `hy()`, `hz()`, `hw()`. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Points are implemented by arrays of `RT` items. All operations 
 like creation, initialization, tests, point - vector arithmetic, input 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Ray_d.h

@@ -7,7 +7,7 @@ An instance of data type `Ray_d` is a ray in \f$ d\f$-dimensional
 Euclidean space. It starts in a point called the source of `r` and 
 it goes to infinity. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Rays are implemented by a pair of points as an item type. All 
 operations like creation, initialization, tests, direction 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Segment_d.h

@@ -9,7 +9,7 @@ two points \f$ p\f$ and \f$ q\f$. \f$ p\f$ is called the source point and \f$ q\
 called the target point of \f$ s\f$, both points are called endpoints of 
 \f$ s\f$. A segment whose endpoints are equal is called <I>degenerate</I>. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Segments are implemented by a pair of points as an item type. All 
 operations like creation, initialization, tests, the calculation of 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Sphere_d.h

@@ -13,7 +13,7 @@ sense and hence many operations on spheres require the set of defining
 points to be legal. The orientation of \f$ S\f$ is equal to the 
 orientation of the defining points, i.e., `orientation(A)`. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Spheres are implemented by a vector of points as a handle type. All 
 operations like creation, initialization, tests, input and output of a 

Kernel_d/doc/Kernel_d/CGAL/Kernel_d/Vector_d.h

@@ -16,13 +16,13 @@ main difference between position vectors and free vectors is their
 behavior under affine transformations, e.g., free vectors are 
 invariant under translations. 
 
-### Downward compatibility ###
+\cgalHeading{Downward compatibility}
 
 We provide all operations of the 
 lower dimensional interface `x()`, `y()`, `z()`, 
 `hx()`, `hy()`, `hz()`, `hw()`. 
 
-### Implementation ###
+\cgalHeading{Implementation}
 
 Vectors are implemented by arrays of variables of type `RT`. All 
 operations like creation, initialization, tests, vector arithmetic, 

Kernel_d/doc/Kernel_d/CGAL/Linear_algebraCd.h

@@ -12,7 +12,7 @@ algebra for field number types `FT`.
 
 \tparam FT must be a field number type. 
 
-### Operations ###
+\cgalHeading{Operations}
 
 Fits all operation requirements of the concept. 
 

Kernel_d/doc/Kernel_d/CGAL/Linear_algebraHd.h

@@ -13,7 +13,7 @@ algebra for Euclidean ring number types `RT`.
 \cgalRequires To make a ring number type `RT` work with this class it has to 
 provide a division `operator/` with remainder. 
 
-### Operations ###
+\cgalHeading{Operations}
 
 Fits all operation requirements of the concept. 
 

Kernel_d/doc/Kernel_d/CGAL/intersections_d.h

@@ -118,7 +118,7 @@ the possible return values wrapped in `Object` are the following:
 </TABLE> 
 </DIV> 
 
-### Example ###
+\cgalHeading{Example}
 
 The following example demonstrates the most common use of 
 `intersection` routines. 

Kinetic_data_structures/doc/Kinetic_data_structures/CGAL/Kinetic/Erase_event.h

@@ -13,7 +13,7 @@ is processed.
 \sa `Kinetic::ActiveObjectsTable`
 \sa `Kinetic::Active_objects_vector<MovingObject>`
 
-### Example ###
+\cgalHeading{Example}
 
 \code{.cpp}