Update of Doxygen/qbk documentation

[SVN r65211]

include/boost/geometry/algorithms/area.hpp

@@ -197,24 +197,24 @@ struct area<polygon_tag, Polygon, Strategy>
 
 
 /*!
-\brief Calculate area of a geometry
+\brief \brief_calc{area}
 \ingroup area
-\details The function area returns the area of a polygon, ring, box
-using the default area-calculation strategy. Strategies are
-provided for cartesian and spherical coordinate systems
-The geometries should correct, polygons should be closed
-and according to the specified orientation (clockwise/counter clockwise)
-\tparam Geometry \geometry_concept
-\param geometry \geometry_model
-\return The calculated area
+\details \details_calc{area}. \details_default_strategy
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{area}
 
 \qbk{snippet,area_polygon}
 \qbk{snippet,area_polygon_spherical}
-\qbk{behavior,__0dim__:Returns zero}
-\qbk{behavior,__1dim__:Returns zero}
-\qbk{behavior,__2dim__:Returns the area}
+\qbk{behavior,__0dim__:[qbk_ret 0]}
+\qbk{behavior,__1dim__:[qbk_ret 0]}
+\qbk{behavior,__2dim__:[qbk_ret the area]}
+\qbk{behavior,__cart__:[qbk_ret the area] __cs_units__}
+\qbk{behavior,__sph__:[qbk_ret the area] __sph1__}
+\qbk{behavior,__rev__:[qbk_ret the negative area]}
 \qbk{complexity,Linear}
- */
+\qbk{compliance,__ogc__}
+*/
 template <typename Geometry>
 inline typename area_result<Geometry>::type area(Geometry const& geometry)
 {
@@ -231,18 +231,16 @@ inline typename area_result<Geometry>::type area(Geometry const& geometry)
 }
 
 /*!
-\brief Calculate area of a geometry using a specified strategy
+\brief \brief_calc{area} \brief_strategy
 \ingroup area
-\details This version of area calculation takes a strategy
-\tparam Geometry \geometry_concept
-\tparam Strategy A type fulfilling a AreaStrategy concept
-\param geometry A model of Geometry
-\param strategy A strategy to calculate area.
-    Especially for spherical and geographical area calculations there
-    are various approaches.
-\return The calculated area
+\details \details_calc{area} \brief_strategy. \details_strategy_reasons
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Area}
+\param geometry \param_geometry
+\param strategy \param_strategy{area}
+\return \return_calc{area}
 
-\qbk{complexity,Linear}
+\qbk{snippet,area_polygon_strategy}
  */
 template <typename Geometry, typename Strategy>
 inline typename Strategy::return_type area(

include/boost/geometry/algorithms/buffer.hpp

@@ -94,19 +94,23 @@ struct buffer<box_tag, box_tag, BoxIn, T, BoxOut>
 
 
 /*!
-    \brief Calculate buffer (= new geometry) around specified distance of geometry
-    \ingroup buffer
-    \param geometry_in input geometry
-    \param distance the distance used in buffer
-    \param chord_length length of the chord's in the generated arcs around points or bends
-    \param geometry_out buffered geometry
-    \note Currently only implemented for box, the trivial case, but still useful
-    \par Use case:
-        BOX + distance -> BOX: it is allowed that "geometry_out" the same object as "geometry_in"
+\brief \brief_calc{buffer}
+\ingroup buffer
+\details \details_calc{buffer, \det_buffer}.
+\tparam Input \tparam_geometry
+\tparam Output \tparam_geometry
+\tparam Distance \tparam_numeric
+\param geometry_in \param_geometry
+\param geometry_out \param_geometry
+\param distance The distance to be used for the buffer
+\param chord_length (optional) The length of the chord's in the generated arcs around points or bends
+\note Currently only implemented for box, the trivial case, but still useful
+
+\qbk{behavior,__box__/__box__:Returns a new rectangular box\, enlarged with the specified distance. It is allowed that "geometry_out" the same object as "geometry_in"}
  */
-template <typename Input, typename Output, typename T>
+template <typename Input, typename Output, typename Distance>
 inline void buffer(Input const& geometry_in, Output& geometry_out,
-            T const& distance, T const& chord_length = -1)
+            Distance const& distance, Distance const& chord_length = -1)
 {
     concept::check<Input const>();
     concept::check<Output>();
@@ -116,19 +120,22 @@ inline void buffer(Input const& geometry_in, Output& geometry_out,
             typename tag<Input>::type,
             typename tag<Output>::type,
             Input,
-            T,
+            Distance,
             Output
         >::apply(geometry_in, distance, chord_length, geometry_out);
 }
 
 /*!
-    \brief Calculate and return buffer (= new geometry) around specified distance of geometry
-    \ingroup buffer
-    \param geometry input geometry
-    \param distance the distance used in buffer
-    \param chord_length length of the chord's in the generated arcs around points or bends
-    \return the buffered geometry
-    \note See also: buffer
+\brief \brief_calc{buffer}
+\ingroup buffer
+\details \details_calc{make_buffer, \det_buffer}. \details_make{buffer}.
+\tparam Input \tparam_geometry
+\tparam Output \tparam_geometry
+\tparam Distance \tparam_numeric
+\param geometry \param_geometry
+\param distance The distance to be used for the buffer
+\param chord_length (optional) The length of the chord's in the generated arcs around points or bends
+\return \return_calc{buffer}
  */
 template <typename Output, typename Input, typename T>
 Output make_buffer(Input const& geometry, T const& distance, T const& chord_length = -1)

include/boost/geometry/algorithms/centroid.hpp

@@ -353,15 +353,16 @@ struct centroid<polygon_tag, Polygon, Point, Strategy>
 
 
 /*!
-\brief Calculate centroid using a specified strategy
+\brief \brief_calc{centroid} \brief_strategy
 \ingroup centroid
-\tparam Geometry \geometry_concept
-\tparam Point \point_concept
-\tparam Strategy A type fulfilling a CentroidStrategy concept
-\param geometry \geometry_model
-\param c the calculated centroid will be assigned to this point reference
-\param strategy A strategy to calculate the centroid
- */
+\details \details_calc{centroid,geometric center (or: center of mass)}
+\tparam Geometry \tparam_geometry
+\tparam Point \tparam_point
+\tparam Strategy \tparam_strategy{Centroid}
+\param geometry \param_geometry
+\param c \param_point \param_set{centroid}
+\param strategy \param_strategy{centroid}
+*/
 template<typename Geometry, typename Point, typename Strategy>
 inline void centroid(Geometry const& geometry, Point& c,
         Strategy const& strategy)
@@ -385,11 +386,12 @@ inline void centroid(Geometry const& geometry, Point& c,
 
 
 /*!
-\brief Calculate centroid
+\brief \brief_calc{centroid}
 \ingroup centroid
-\tparam Geometry \geometry_concept
-\tparam Point \point_concept
-\param geometry \geometry_model
+\details \details_calc{centroid,geometric center (or: center of mass)}
+\tparam Geometry \tparam_geometry
+\tparam Point \tparam_point
+\param geometry \param_geometry
 \param c the calculated centroid will be assigned to this point reference
 
 \qbk{behavior,__0dim__:Calculates centroid}
@@ -397,6 +399,7 @@ inline void centroid(Geometry const& geometry, Point& c,
 \qbk{behavior,__2dim__:Calculates centroid}
 \qbk{behavior,__empty__:Throws a centroid_exception}
 \qbk{complexity,Linear}
+\qbk{compliance,__ogc__}
  */
 template<typename Geometry, typename Point>
 inline void centroid(Geometry const& geometry, Point& c)
@@ -417,12 +420,13 @@ inline void centroid(Geometry const& geometry, Point& c)
 
 
 /*!
-\brief Calculate and return centroid
+\brief \brief_calc{centroid}
 \ingroup centroid
-\tparam Point \point_concept
-\tparam Geometry \geometry_concept
-\param geometry \geometry_model
-\return The calculated centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_make{centroid}.
+\tparam Point \tparam_point
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{centroid}
  */
 template<typename Point, typename Geometry>
 inline Point make_centroid(Geometry const& geometry)
@@ -435,13 +439,15 @@ inline Point make_centroid(Geometry const& geometry)
 }
 
 /*!
-\brief Calculate and return centroid, using a specified strategy
+\brief \brief_calc{centroid} \brief_strategy
 \ingroup centroid
-\tparam Point \point_concept
-\tparam Geometry \geometry_concept
-\param geometry \geometry_model
-\param strategy Calculation strategy for centroid
-\return The calculated centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_make{centroid}.
+\tparam Point \tparam_point
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{centroid}
+\param geometry \param_geometry
+\param strategy \param_strategy{centroid}
+\return \return_calc{centroid}
  */
 template<typename Point, typename Geometry, typename Strategy>
 inline Point make_centroid(Geometry const& geometry, Strategy const& strategy)

include/boost/geometry/algorithms/combine.hpp

@@ -287,12 +287,12 @@ inline void combine(Box& box, Geometry const& geometry,
 
 
 /*!
-    \brief Combines a box with another geometry (box, point)
-    \ingroup combine
-    \tparam Box type of the box
-    \tparam Geometry of second geometry, to be combined with the box
-    \param box box to combine another geometry with, might be changed
-    \param geometry other geometry
+\brief Combines a box with another geometry (box, point)
+\ingroup combine
+\tparam Box type of the box
+\tparam Geometry \tparam_geometry
+\param box box to combine another geometry with, might be changed
+\param geometry \param_geometry
  */
 template <typename Box, typename Geometry>
 inline void combine(Box& box, Geometry const& geometry)

include/boost/geometry/algorithms/comparable_distance.hpp

@@ -17,15 +17,15 @@ namespace boost { namespace geometry
 
 
 /*!
-    \brief Calculate comparable distance measurement between two geometries
-    \ingroup distance
-    \details The default strategy is used, belonging to the corresponding coordinate system of the geometries
-        and the comparable strategy is used
-    \tparam G1 first geometry type
-    \tparam G2 second geometry type
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \return the comparable distance
+\brief \brief_calc2{comparable distance measurement}
+\ingroup distance
+\details The default strategy is used, belonging to the corresponding coordinate system of the geometries
+    and the comparable strategy is used
+\tparam Geometry1 first geometry type
+\tparam Geometry2 second geometry type
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_calc{comparable distance}
  */
 template <typename Geometry1, typename Geometry2>
 inline typename distance_result<Geometry1, Geometry2>::type comparable_distance(

include/boost/geometry/algorithms/convert.hpp

@@ -230,14 +230,14 @@ struct convert<polygon_tag, ring_tag, Dimensions, Polygon, Ring>
 #endif // DOXYGEN_NO_DISPATCH
 
 /*!
-    \brief Converts one geometry to another geometry
-    \details The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only
-    if it is possible and applicable.
-    \ingroup convert
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \param geometry1 first geometry (source)
-    \param geometry2 second geometry (target)
+\brief Converts one geometry to another geometry
+\details The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only
+if it is possible and applicable.
+\ingroup convert
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry (source)
+\param geometry2 \param_geometry (target)
  */
 template <typename Geometry1, typename Geometry2>
 inline void convert(Geometry1 const& geometry1, Geometry2& geometry2)

include/boost/geometry/algorithms/convex_hull.hpp

@@ -146,16 +146,17 @@ inline void convex_hull(Geometry1 const& geometry,
 
 
 /*!
-    \brief Calculate the convex hull of a geometry
-    \ingroup convex_hull
-    \tparam Geometry1 the input geometry type
-    \tparam Geometry2: the output geometry type
-    \param geometry the geometry to calculate convex hull from
-    \param out a geometry receiving points of the convex hull
+\brief \brief_calc{convex hull}
+\ingroup convex_hull
+\details \details_calc{convex_hull,convex hull}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry \param_geometry,  used for input
+\param hull \param_geometry \param_set{convex hull}
  */
 template<typename Geometry1, typename Geometry2>
 inline void convex_hull(Geometry1 const& geometry,
-            Geometry2& out)
+            Geometry2& hull)
 {
     concept::check_concepts_and_equal_dimensions
         <
@@ -173,7 +174,7 @@ inline void convex_hull(Geometry1 const& geometry,
             point_type
         >::type strategy_type;
 
-    convex_hull(geometry, out, strategy_type());
+    convex_hull(geometry, hull, strategy_type());
 }
 
 
@@ -198,16 +199,16 @@ inline OutputIterator convex_hull_inserter(Geometry const& geometry,
 
 
 /*!
-    \brief Calculate the convex hull of a geometry, output-iterator version
-    \ingroup convex_hull
-    \tparam Geometry the input geometry type
-    \tparam OutputIterator: an output-iterator
-    \param geometry the geometry to calculate convex hull from
-    \param out an output iterator outputing points of the convex hull
-    \note This overloaded version outputs to an output iterator.
-    In this case, nothing is known about its point-type or
-        about its clockwise order. Therefore, the input point-type
-        and order are copied
+\brief Calculate the convex hull of a geometry, output-iterator version
+\ingroup convex_hull
+\tparam Geometry the input geometry type
+\tparam OutputIterator: an output-iterator
+\param geometry the geometry to calculate convex hull from
+\param out an output iterator outputing points of the convex hull
+\note This overloaded version outputs to an output iterator.
+In this case, nothing is known about its point-type or
+    about its clockwise order. Therefore, the input point-type
+    and order are copied
 
  */
 template<typename Geometry, typename OutputIterator>

include/boost/geometry/algorithms/detail/not.hpp

@@ -19,13 +19,13 @@ namespace detail
 
 
 /*!
-    \brief Structure negating the result of specified policy
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam Policy
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \return Negation of the result of the policy
+\brief Structure negating the result of specified policy
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Policy
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return Negation of the result of the policy
  */
 template <typename Geometry1, typename Geometry2, typename Policy>
 struct not_

include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp

@@ -355,17 +355,17 @@ static inline bool enrich(Container& operations,
 
 
 /*!
-    \brief All intersection points are enriched with successor information
-    \ingroup overlay
-    \tparam TurnPoints type of intersection container
-                (e.g. vector of "intersection/turn point"'s)
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam Strategy point-point-distance strategy type
-    \param turn_points container containing intersectionpoints
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param strategy strategy
+\brief All intersection points are enriched with successor information
+\ingroup overlay
+\tparam TurnPoints type of intersection container
+            (e.g. vector of "intersection/turn point"'s)
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy point-point-distance strategy type
+\param turn_points container containing intersectionpoints
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy strategy
  */
 template
 <

include/boost/geometry/algorithms/distance.hpp

@@ -465,23 +465,27 @@ struct distance_reversed
 #endif // DOXYGEN_NO_DISPATCH
 
 /*!
-    \brief Calculate distance between two geometries with a specified strategy
-    \ingroup distance
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam Strategy point-point-distance strategy type
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param strategy strategy to calculate distance between two points
-    \return the distance
-    \note The strategy can be a point-point strategy. In case of distance point-line/point-polygon
-        it may also be a point-segment strategy.
-    \par Example:
-    Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
-    \dontinclude doxygen_1.cpp
-    \skip example_distance_point_point_strategy
-    \line {
-    \until }
+\brief \brief_calc2{distance} \brief_strategy
+\ingroup distance
+\details
+\details \details_calc{area}. \brief_strategy. \details_strategy_reasons
+
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{distance}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{distance}
+\note The strategy can be a point-point strategy. In case of distance point-line/point-polygon
+    it may also be a point-segment strategy.
+
+\par Example:
+Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
+\dontinclude doxygen_1.cpp
+\skip example_distance_point_point_strategy
+\line {
+\until }
  */
 
 /*
@@ -530,14 +534,14 @@ inline typename strategy::distance::services::return_type<Strategy>::type distan
 
 
 /*!
-    \brief Calculate distance between two geometries
-    \ingroup distance
-    \details The default strategy is used, belonging to the corresponding coordinate system of the geometries
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \return the distance (either a double or a distance result, convertable to double)
+\brief \brief_calc2{distance}
+\ingroup distance
+\details The default strategy is used, belonging to the corresponding coordinate system of the geometries
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_calc{distance}
  */
 template <typename Geometry1, typename Geometry2>
 inline typename distance_result<Geometry1, Geometry2>::type distance(

include/boost/geometry/algorithms/envelope.hpp

@@ -195,10 +195,14 @@ struct envelope
 
 
 /*!
-\brief Calculate envelope of a geometry
+\brief \brief_calc{envelope}
 \ingroup envelope
-\param geometry the geometry
-\param mbr the box receiving the envelope
+\details \details_calc{envelope,\det_envelope}.
+\tparam Geometry \tparam_geometry
+\tparam Box \tparam_box
+\param geometry \param_geometry
+\param mbr \param_box \param_set{envelope}
+
 \par Example:
 Example showing envelope calculation, using point_ll latlong points
 \dontinclude doxygen_1.cpp
@@ -222,9 +226,13 @@ inline void envelope(Geometry const& geometry, Box& mbr)
 
 
 /*!
-\brief Calculate and return envelope of a geometry
+\brief \brief_calc{envelope}
 \ingroup envelope
-\param geometry the geometry
+\details \details_calc{make_envelope,\det_envelope}. \details_make{envelope}
+\tparam Box \tparam_box
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{envelope}
 */
 template<typename Box, typename Geometry>
 inline Box make_envelope(Geometry const& geometry)

include/boost/geometry/algorithms/equals.hpp

@@ -269,13 +269,13 @@ struct equals_reversed
 
 
 /*!
-    \brief Detect if two geometries are spatially equal
-    \ingroup equals
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \return true if geometries are spatially equal, else false
+\brief \brief_check{are spatially equal}
+\ingroup equals
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{are spatially disjoint}
  */
 template <typename Geometry1, typename Geometry2>
 inline bool equals(Geometry1 const& geometry1, Geometry2 const& geometry2)

include/boost/geometry/algorithms/length.hpp

@@ -129,15 +129,15 @@ struct length<segment_tag, Geometry, Strategy>
 
 
 /*!
-\brief Calculate length of a geometry
+\brief \brief_calc{length}
 \ingroup length
 \details The version without a strategy takes the default
     distance-calculation-strategy to calculate distances between
     consecutive points of a geometry, summing them to the length
     of the geometry
-\tparam Geometry \geometry_concept
-\param geometry \geometry_model
-\return The calculated length
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{length}
 
 \par Example:
 Example showing length calculation on a vector
@@ -146,10 +146,11 @@ Example showing length calculation on a vector
 \line {
 \until }
 
-\qbk{behavior,__0dim__:Returns zero}
-\qbk{behavior,__1dim__:Returns the length}
-\qbk{behavior,__2dim__:Returns zero}
+\qbk{behavior,__0dim__:[qbk_ret 0]}
+\qbk{behavior,__1dim__:[qbk_ret the length]}
+\qbk{behavior,__2dim__:[qbk_ret 0]}
 \qbk{complexity,Linear}
+\qbk{compliance,__ogc__}
  */
 template<typename Geometry>
 inline typename length_result<Geometry>::type length(
@@ -172,16 +173,16 @@ inline typename length_result<Geometry>::type length(
 
 
 /*!
-\brief Calculate length of a geometry
+\brief \brief_calc{length} \brief_strategy
 \ingroup length
 \details The version with a specified strategy uses that strategy
     to calculate distances between consecutive points, summing them
-    to the length of the geometry. \strategy_reasons
-\tparam Geometry \geometry_concept
-\tparam Strategy A type fulfilling a DistanceStrategy concept
-\param geometry \geometry_model
-\param strategy A strategy to be used for distance calculations.
-\return The calculated length
+    to the length of the geometry. \details_strategy_reasons
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{distance}
+\param geometry \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{length}
 
 \par Example:
 Example showing length calculation using iterators

include/boost/geometry/algorithms/num_points.hpp

@@ -116,14 +116,19 @@ struct num_points<polygon_tag, false, Geometry>
 
 
 /*!
-    \brief get number of points
-    \ingroup access
-    \tparam Geometry geometry type
-    \param geometry the geometry to get number of points from
-    \return number of points
-    \note For linestrings/rings also boost::size or .size() could be used, however,
-        for polygons this is less obvious. So this function is provided. Besides that
-        it is described by OGC (numPoints)
+\brief \brief_calc{number of points}
+\ingroup num_points
+\details \details_calc{num_points, number of points}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{number of points}
+
+\qbk{behavior,__point__:[qbk_ret 1]}
+\qbk{behavior,__box__:[qbk_ret 1]}
+\qbk{behavior,__range__:[qbk_ret boost::size(geometry)]}
+\qbk{behavior,__other__:[qbk_ret the sum of the number of points of its elements]}
+\qbk{complexity,Constant or Linear}
+\qbk{compliance,__ogc__}
 */
 template <typename Geometry>
 inline std::size_t num_points(Geometry const& geometry)

include/boost/geometry/algorithms/overlaps.hpp

@@ -171,9 +171,9 @@ struct overlaps<box_tag, box_tag, Box1, Box2>
 
 
 /*!
-    \brief Determines overlap between two geometries
-    \ingroup overlaps
-    \return true if there is overlap
+\brief \brief_check2{overlap}
+\ingroup overlaps
+\return \return_check2{overlap}
  */
 template <typename Geometry1, typename Geometry2>
 inline bool overlaps(Geometry1 const& geometry1, Geometry2 const& geometry2)

include/boost/geometry/algorithms/perimeter.hpp

@@ -66,13 +66,13 @@ struct perimeter<polygon_tag, Polygon, Strategy>
 
 
 /*!
-\brief Calculate perimeter of a geometry
+\brief \brief_calc{perimeter}
 \ingroup perimeter
 \details The function perimeter returns the perimeter of a geometry,
     using the default distance-calculation-strategy
-\tparam Geometry \geometry_concept
-\param geometry \geometry_model
-\return The calculated perimeter
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{perimeter}
 
 \qbk{behavior,__0dim__:Returns zero}
 \qbk{behavior,__1dim__:Returns zero}
@@ -100,15 +100,15 @@ inline typename length_result<Geometry>::type perimeter(
 }
 
 /*!
-\brief Calculate perimeter of a geometry
+\brief \brief_calc{perimeter} \brief_strategy
 \ingroup perimeter
 \details The function perimeter returns the perimeter of a geometry,
     using specified strategy
-\tparam Geometry \geometry_concept
-\tparam Strategy A type fulfilling a DistanceStrategy concept
-\param geometry \geometry_model
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{distance}
+\param geometry \param_geometry
 \param strategy strategy to be used for distance calculations.
-\return The calculated perimeter
+\return \return_calc{perimeter}
  */
 template<typename Geometry, typename Strategy>
 inline typename length_result<Geometry>::type perimeter(

include/boost/geometry/algorithms/reverse.hpp

@@ -102,9 +102,10 @@ struct reverse<polygon_tag, Polygon>
 
 
 /*!
-    \ingroup reverse
-    \tparam Geometry geometry type
-    \param geometry the geometry to make reverse
+\brief Reverses a geometry
+\ingroup reverse
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be reversed
 */
 template <typename Geometry>
 inline void reverse(Geometry& geometry)

include/boost/geometry/algorithms/simplify.hpp

@@ -236,7 +236,7 @@ struct simplify_inserter<ring_tag, Ring, Strategy>
 /*!
 \brief Simplify a geometry using a specified strategy
 \ingroup simplify
-\tparam Geometry \geometry_concept
+\tparam Geometry \tparam_geometry
 \tparam Distance A numerical distance measure
 \tparam Strategy A type fulfilling a SimplifyStrategy concept
 \param strategy A strategy to calculate simplification
@@ -274,8 +274,8 @@ inline void simplify(Geometry const& geometry, Geometry& out,
 /*!
 \brief Simplify a geometry
 \ingroup simplify
-\tparam Geometry \geometry_concept
-\tparam Distance \template_numerical
+\tparam Geometry \tparam_geometry
+\tparam Distance \tparam_numeric
 \note This version of simplify simplifies a geometry using the default
     strategy (Douglas Peucker),
 \param geometry input geometry, to be simplified
@@ -318,7 +318,7 @@ inline void simplify(Geometry const& geometry, Geometry& out,
 \brief Simplify a geometry, using an output iterator
     and a specified strategy
 \ingroup simplify
-\tparam Geometry \geometry_concept
+\tparam Geometry \tparam_geometry
 \param geometry input geometry, to be simplified
 \param out output iterator, outputs all simplified points
 \param max_distance distance (in units of input coordinates) of a vertex
@@ -353,7 +353,7 @@ inline void simplify_inserter(Geometry const& geometry, OutputIterator out,
 /*!
 \brief Simplify a geometry, using an output iterator
 \ingroup simplify
-\tparam Geometry \geometry_concept
+\tparam Geometry \tparam_geometry
 \param geometry input geometry, to be simplified
 \param out output iterator, outputs all simplified points
 \param max_distance distance (in units of input coordinates) of a vertex

include/boost/geometry/algorithms/transform.hpp

@@ -252,14 +252,14 @@ struct transform<box_tag, box_tag, Box1, Box2, Strategy>
 
 
 /*!
-    \brief Transforms from one geometry to another geometry using a strategy
-    \ingroup transform
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam Strategy strategy
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param strategy the strategy to be used for transformation
+\brief Transforms from one geometry to another geometry using a strategy
+\ingroup transform
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy strategy
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy the strategy to be used for transformation
  */
 template <typename Geometry1, typename Geometry2, typename Strategy>
 inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2,
@@ -282,13 +282,13 @@ inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2,
 
 
 /*!
-    \brief Transforms from one geometry to another geometry using a strategy
-    \ingroup transform
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \return true if the transformation could be done
+\brief Transforms from one geometry to another geometry using a strategy
+\ingroup transform
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return true if the transformation could be done
  */
 template <typename Geometry1, typename Geometry2>
 inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2)

include/boost/geometry/algorithms/union.hpp

@@ -72,18 +72,18 @@ struct union_inserter_reversed
 
 
 /*!
-    \brief Combines two geometries which each other
-    \ingroup union
-    \tparam GeometryOut output geometry type, must be specified
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam OutputIterator output iterator
-    \tparam Strategy compound strategy for intersection
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param out the output iterator, outputting polygons
-    \param strategy the strategy
-    \return the output iterator
+\brief Combines two geometries which each other
+\ingroup union
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator output iterator
+\tparam Strategy compound strategy for intersection
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out the output iterator, outputting polygons
+\param strategy the strategy
+\return the output iterator
 */
 template
 <
@@ -128,16 +128,16 @@ inline OutputIterator union_inserter(Geometry1 const& geometry1,
 }
 
 /*!
-    \brief Combines two geometries which each other
-    \ingroup union
-    \tparam GeometryOut output geometry type, must be specified
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam OutputIterator output iterator
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param out the output iterator, outputting polygons
-    \return the output iterator
+\brief Combines two geometries which each other
+\ingroup union
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator output iterator
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out the output iterator, outputting polygons
+\return the output iterator
 */
 template
 <
@@ -166,16 +166,16 @@ inline OutputIterator union_inserter(Geometry1 const& geometry1,
 
 
 /*!
-    \brief Combines two geometries which each other
-    \ingroup union
-    \tparam Geometry1 first geometry type
-    \tparam Geometry2 second geometry type
-    \tparam Collection output collection, either a multi-geometry,
-        or a std::vector<Geometry> / std::deque<Geometry> etc
-    \param geometry1 first geometry
-    \param geometry2 second geometry
-    \param output_collection the output collection
-    \note Called union_ because union is a reserved word.
+\brief Combines two geometries which each other
+\ingroup union
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection output collection, either a multi-geometry,
+    or a std::vector<Geometry> / std::deque<Geometry> etc
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+\note Called union_ because union is a reserved word.
 */
 template
 <

include/boost/geometry/algorithms/unique.hpp

@@ -116,9 +116,11 @@ struct unique<polygon_tag, Polygon, ComparePolicy>
 
 
 /*!
-    \ingroup unique
-    \tparam Geometry geometry type
-    \param geometry the geometry to make unique
+\brief \brief_calc{minimal set}
+\ingroup unique
+\details \details_calc{unique,minimal set (where duplicate consecutive points are removed)}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be made unique
 */
 template <typename Geometry>
 inline void unique(Geometry& geometry)

include/boost/geometry/algorithms/within.hpp

@@ -314,14 +314,17 @@ struct within<point_tag, polygon_tag, Point, Polygon, Strategy>
 
 
 /*!
-    \brief Within, examine if a geometry is within another geometry
-    \ingroup within
-    \param geometry1 geometry which might be within the second geometry
-    \param geometry2 geometry which might contain the first geometry
-    \return true if geometry1 is completely contained within geometry2,
-        else false
-    \note The default strategy is used for within detection
-
+\brief \brief_check12{completely inside}
+\ingroup within
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry1 geometry which might be within the second geometry
+\param geometry2 geometry which might contain the first geometry
+\return true if geometry1 is completely contained within geometry2,
+    else false
+\note The default strategy is used for within detection
  */
 template<typename Geometry1, typename Geometry2>
 inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2)
@@ -351,14 +354,18 @@ inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2)
 }
 
 /*!
-    \brief Within, examine if a geometry is within another geometry,
-        using a specified strategy
-    \ingroup within
-    \param geometry1 geometry which might be within the second geometry
-    \param geometry2 geometry which might contain the first geometry
-    \param strategy strategy to be used
-    \return true if geometry1 is completely contained within geometry2,
-        else false
+\brief Within, examine if a geometry is within another geometry,
+    using a specified strategy
+\ingroup within
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry1 \param_geometry geometry which might be within the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\param strategy strategy to be used
+\return true if geometry1 is completely contained within geometry2,
+    else false
  */
 template<typename Geometry1, typename Geometry2, typename Strategy>
 inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2,