From 9b0bf9f07c8c1964912ffb34956a7892159b40cb Mon Sep 17 00:00:00 2001 From: Barend Gehrels Date: Fri, 3 Sep 2010 10:22:14 +0000 Subject: [PATCH] Update of Doxygen/qbk documentation [SVN r65211] --- include/boost/geometry/algorithms/area.hpp | 44 ++++++------- include/boost/geometry/algorithms/buffer.hpp | 45 +++++++------ .../boost/geometry/algorithms/centroid.hpp | 52 ++++++++------- include/boost/geometry/algorithms/combine.hpp | 12 ++-- .../algorithms/comparable_distance.hpp | 18 +++--- include/boost/geometry/algorithms/convert.hpp | 16 ++--- .../boost/geometry/algorithms/convex_hull.hpp | 37 +++++------ .../boost/geometry/algorithms/detail/not.hpp | 14 ++-- .../overlay/enrich_intersection_points.hpp | 22 +++---- .../boost/geometry/algorithms/distance.hpp | 54 ++++++++-------- .../boost/geometry/algorithms/envelope.hpp | 18 ++++-- include/boost/geometry/algorithms/equals.hpp | 14 ++-- include/boost/geometry/algorithms/length.hpp | 29 +++++---- .../boost/geometry/algorithms/num_points.hpp | 21 +++--- .../boost/geometry/algorithms/overlaps.hpp | 6 +- .../boost/geometry/algorithms/perimeter.hpp | 18 +++--- include/boost/geometry/algorithms/reverse.hpp | 7 +- .../boost/geometry/algorithms/simplify.hpp | 10 +-- .../boost/geometry/algorithms/transform.hpp | 30 ++++----- include/boost/geometry/algorithms/union.hpp | 64 +++++++++---------- include/boost/geometry/algorithms/unique.hpp | 8 ++- include/boost/geometry/algorithms/within.hpp | 39 ++++++----- 22 files changed, 309 insertions(+), 269 deletions(-) diff --git a/include/boost/geometry/algorithms/area.hpp b/include/boost/geometry/algorithms/area.hpp index bb9d16e96..618582920 100644 --- a/include/boost/geometry/algorithms/area.hpp +++ b/include/boost/geometry/algorithms/area.hpp @@ -197,24 +197,24 @@ struct area /*! -\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 inline typename area_result::type area(Geometry const& geometry) { @@ -231,18 +231,16 @@ inline typename area_result::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 inline typename Strategy::return_type area( diff --git a/include/boost/geometry/algorithms/buffer.hpp b/include/boost/geometry/algorithms/buffer.hpp index 243e063f5..637cd63f2 100644 --- a/include/boost/geometry/algorithms/buffer.hpp +++ b/include/boost/geometry/algorithms/buffer.hpp @@ -94,19 +94,23 @@ struct buffer /*! - \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 +template 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(); concept::check(); @@ -116,19 +120,22 @@ inline void buffer(Input const& geometry_in, Output& geometry_out, typename tag::type, typename tag::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 Output make_buffer(Input const& geometry, T const& distance, T const& chord_length = -1) diff --git a/include/boost/geometry/algorithms/centroid.hpp b/include/boost/geometry/algorithms/centroid.hpp index f3df509ba..4295943a1 100644 --- a/include/boost/geometry/algorithms/centroid.hpp +++ b/include/boost/geometry/algorithms/centroid.hpp @@ -353,15 +353,16 @@ struct centroid /*! -\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 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 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 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 inline Point make_centroid(Geometry const& geometry, Strategy const& strategy) diff --git a/include/boost/geometry/algorithms/combine.hpp b/include/boost/geometry/algorithms/combine.hpp index cf6e94d80..96c1e6629 100644 --- a/include/boost/geometry/algorithms/combine.hpp +++ b/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 inline void combine(Box& box, Geometry const& geometry) diff --git a/include/boost/geometry/algorithms/comparable_distance.hpp b/include/boost/geometry/algorithms/comparable_distance.hpp index 02741a162..82e1de4ac 100644 --- a/include/boost/geometry/algorithms/comparable_distance.hpp +++ b/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 inline typename distance_result::type comparable_distance( diff --git a/include/boost/geometry/algorithms/convert.hpp b/include/boost/geometry/algorithms/convert.hpp index afd05dfbb..346506a84 100644 --- a/include/boost/geometry/algorithms/convert.hpp +++ b/include/boost/geometry/algorithms/convert.hpp @@ -230,14 +230,14 @@ struct convert #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 inline void convert(Geometry1 const& geometry1, Geometry2& geometry2) diff --git a/include/boost/geometry/algorithms/convex_hull.hpp b/include/boost/geometry/algorithms/convex_hull.hpp index 9220bebd4..7924d90e8 100644 --- a/include/boost/geometry/algorithms/convex_hull.hpp +++ b/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 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 diff --git a/include/boost/geometry/algorithms/detail/not.hpp b/include/boost/geometry/algorithms/detail/not.hpp index 35f877df5..1b63167a7 100644 --- a/include/boost/geometry/algorithms/detail/not.hpp +++ b/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 struct not_ diff --git a/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp b/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp index fcb2e2fdb..24f534762 100644 --- a/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp +++ b/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 < diff --git a/include/boost/geometry/algorithms/distance.hpp b/include/boost/geometry/algorithms/distance.hpp index 03169ffe0..22a4739d3 100644 --- a/include/boost/geometry/algorithms/distance.hpp +++ b/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::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 inline typename distance_result::type distance( diff --git a/include/boost/geometry/algorithms/envelope.hpp b/include/boost/geometry/algorithms/envelope.hpp index fbfe6a1c5..3f40760ee 100644 --- a/include/boost/geometry/algorithms/envelope.hpp +++ b/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 inline Box make_envelope(Geometry const& geometry) diff --git a/include/boost/geometry/algorithms/equals.hpp b/include/boost/geometry/algorithms/equals.hpp index 42e5c7361..cc75d5dcb 100644 --- a/include/boost/geometry/algorithms/equals.hpp +++ b/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 inline bool equals(Geometry1 const& geometry1, Geometry2 const& geometry2) diff --git a/include/boost/geometry/algorithms/length.hpp b/include/boost/geometry/algorithms/length.hpp index dadd950f4..a1ee49d82 100644 --- a/include/boost/geometry/algorithms/length.hpp +++ b/include/boost/geometry/algorithms/length.hpp @@ -129,15 +129,15 @@ struct length /*! -\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 inline typename length_result::type length( @@ -172,16 +173,16 @@ inline typename length_result::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 diff --git a/include/boost/geometry/algorithms/num_points.hpp b/include/boost/geometry/algorithms/num_points.hpp index 971447ef4..cd335fdaf 100644 --- a/include/boost/geometry/algorithms/num_points.hpp +++ b/include/boost/geometry/algorithms/num_points.hpp @@ -116,14 +116,19 @@ struct num_points /*! - \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 inline std::size_t num_points(Geometry const& geometry) diff --git a/include/boost/geometry/algorithms/overlaps.hpp b/include/boost/geometry/algorithms/overlaps.hpp index 34f36fb26..338a867c1 100644 --- a/include/boost/geometry/algorithms/overlaps.hpp +++ b/include/boost/geometry/algorithms/overlaps.hpp @@ -171,9 +171,9 @@ struct overlaps /*! - \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 inline bool overlaps(Geometry1 const& geometry1, Geometry2 const& geometry2) diff --git a/include/boost/geometry/algorithms/perimeter.hpp b/include/boost/geometry/algorithms/perimeter.hpp index d16662227..42be8c5ae 100644 --- a/include/boost/geometry/algorithms/perimeter.hpp +++ b/include/boost/geometry/algorithms/perimeter.hpp @@ -66,13 +66,13 @@ struct perimeter /*! -\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::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 inline typename length_result::type perimeter( diff --git a/include/boost/geometry/algorithms/reverse.hpp b/include/boost/geometry/algorithms/reverse.hpp index c70b41c2e..3910dc2d6 100644 --- a/include/boost/geometry/algorithms/reverse.hpp +++ b/include/boost/geometry/algorithms/reverse.hpp @@ -102,9 +102,10 @@ struct reverse /*! - \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 inline void reverse(Geometry& geometry) diff --git a/include/boost/geometry/algorithms/simplify.hpp b/include/boost/geometry/algorithms/simplify.hpp index 5c088237c..f438867e4 100644 --- a/include/boost/geometry/algorithms/simplify.hpp +++ b/include/boost/geometry/algorithms/simplify.hpp @@ -236,7 +236,7 @@ struct simplify_inserter /*! \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 diff --git a/include/boost/geometry/algorithms/transform.hpp b/include/boost/geometry/algorithms/transform.hpp index 0c5a15a5e..a913d5ba5 100644 --- a/include/boost/geometry/algorithms/transform.hpp +++ b/include/boost/geometry/algorithms/transform.hpp @@ -252,14 +252,14 @@ struct transform /*! - \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 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 inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2) diff --git a/include/boost/geometry/algorithms/union.hpp b/include/boost/geometry/algorithms/union.hpp index d911b398d..5b95778a2 100644 --- a/include/boost/geometry/algorithms/union.hpp +++ b/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 / std::deque 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 / std::deque 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 < diff --git a/include/boost/geometry/algorithms/unique.hpp b/include/boost/geometry/algorithms/unique.hpp index 5b427d1e1..35379431e 100644 --- a/include/boost/geometry/algorithms/unique.hpp +++ b/include/boost/geometry/algorithms/unique.hpp @@ -116,9 +116,11 @@ struct unique /*! - \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 inline void unique(Geometry& geometry) diff --git a/include/boost/geometry/algorithms/within.hpp b/include/boost/geometry/algorithms/within.hpp index b4ea6642c..313ac39e4 100644 --- a/include/boost/geometry/algorithms/within.hpp +++ b/include/boost/geometry/algorithms/within.hpp @@ -314,14 +314,17 @@ struct within /*! - \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 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 inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2,