[geos-commits] [SCM] GEOS branch master updated. e45655ae1cbad6fedb5e8cdd9a00ec9bef399427
git at osgeo.org
git at osgeo.org
Fri Jun 14 03:20:06 PDT 2019
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GEOS".
The branch, master has been updated
via e45655ae1cbad6fedb5e8cdd9a00ec9bef399427 (commit)
from d1556af8cddca70ef7872c9b157907cdf07a1f8a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit e45655ae1cbad6fedb5e8cdd9a00ec9bef399427
Author: nila <n_larsson at yahoo.com>
Date: Mon Jun 3 18:07:30 2019 +0200
[doxygen] fix errors and links
diff --git a/include/geos/algorithm/BoundaryNodeRule.h b/include/geos/algorithm/BoundaryNodeRule.h
index 3a7b294..85e4827 100644
--- a/include/geos/algorithm/BoundaryNodeRule.h
+++ b/include/geos/algorithm/BoundaryNodeRule.h
@@ -28,15 +28,16 @@ namespace geos {
namespace algorithm { // geos::algorithm
-/**
- * An interface for rules which determine whether node points
- * which are in boundaries of {@link Lineal} geometry components
+/** \brief
+ * An interface for rules which determine whether node points which are
+ * in boundaries of [Lineal](@ref geom::Lineal) geometry components
* are in the boundary of the parent geometry collection.
+ *
* The SFS specifies a single kind of boundary node rule,
- * the {@link Mod2BoundaryNodeRule} rule.
+ * the `Mod2BoundaryNodeRule` rule.
* However, other kinds of Boundary Node Rules are appropriate
* in specific situations (for instance, linear network topology
- * usually follows the {@link EndPointBoundaryNodeRule}.)
+ * usually follows the `EndPointBoundaryNodeRule`.)
* Some JTS operations allow the BoundaryNodeRule to be specified,
* and respect this rule when computing the results of the operation.
*
@@ -55,15 +56,15 @@ public:
virtual
~BoundaryNodeRule() {}
- /**
- * Tests whether a point that lies in <tt>boundaryCount</tt>
+ /** \brief
+ * Tests whether a point that lies in `boundaryCount`
* geometry component boundaries is considered to form part of
* the boundary of the parent geometry.
*
* @param boundaryCount the number of component boundaries that
* this point occurs in
- * @return true if points in this number of boundaries lie in
- * the parent boundary
+ * @return `true` if points in this number of boundaries lie in
+ * the parent boundary
*/
virtual bool isInBoundary(int boundaryCount) const = 0;
@@ -71,7 +72,13 @@ public:
* The Mod-2 Boundary Node Rule (which is the rule specified
* in the OGC SFS).
*
- * @see Mod2BoundaryNodeRule
+ * A BoundaryNodeRule specifies that points are in the boundary of
+ * a lineal geometry iff the point lies on the boundary of an odd number
+ * of components. Under this rule LinearRings and closed LineStrings have
+ * an empty boundary.
+ *
+ * This is the rule specified by the OGC SFS, and is the default
+ * rule used in JTS.
*/
//static const BoundaryNodeRule& MOD2_BOUNDARY_RULE;
static const BoundaryNodeRule& getBoundaryRuleMod2();
@@ -79,7 +86,20 @@ public:
/** \brief
* The Endpoint Boundary Node Rule.
*
- * @see EndPointBoundaryNodeRule
+ * A BoundaryNodeRule which specifies that any points which are endpoints
+ * of lineal components are in the boundary of the parent geometry. This
+ * corresponds to the "intuitive" topological definition of boundary. Under
+ * this rule LinearRings have a non-empty boundary (the common endpoint
+ * of the underlying LineString).
+ *
+ * This rule is useful when dealing with linear networks. For example,
+ * it can be used to check whether linear networks are correctly noded.
+ * The usual network topology constraint is that linear segments may
+ * touch only at endpoints. In the case of a segment touching a closed
+ * segment (ring) at one point, the Mod2 rule cannot distinguish between
+ * the permitted case of touching at the node point and the invalid case
+ * of touching at some other interior (non-node) point. The EndPoint rule
+ * does distinguish between these cases, so is more appropriate for use.
*/
//static const BoundaryNodeRule& ENDPOINT_BOUNDARY_RULE;
static const BoundaryNodeRule& getBoundaryEndPoint();
@@ -87,7 +107,10 @@ public:
/** \brief
* The MultiValent Endpoint Boundary Node Rule.
*
- * @see MultiValentEndPointBoundaryNodeRule
+ * A BoundaryNodeRule which determines that only endpoints with valency
+ * greater than 1 are on the boundary. This corresponds to the boundary
+ * of a MultiLineString being all the "attached" endpoints, but not
+ * the "unattached" ones.
*/
//static const BoundaryNodeRule& MULTIVALENT_ENDPOINT_BOUNDARY_RULE;
static const BoundaryNodeRule& getBoundaryMultivalentEndPoint();
@@ -95,7 +118,9 @@ public:
/** \brief
* The Monovalent Endpoint Boundary Node Rule.
*
- * @see MonoValentEndPointBoundaryNodeRule
+ * A BoundaryNodeRule which determines that only endpoints with valency of
+ * exactly 1 are on the boundary. This corresponds to the boundary of
+ * a MultiLineString being all the "unattached" endpoints.
*/
//static const BoundaryNodeRule& MONOVALENT_ENDPOINT_BOUNDARY_RULE;
static const BoundaryNodeRule& getBoundaryMonovalentEndPoint();
@@ -104,7 +129,10 @@ public:
* The Boundary Node Rule specified by the OGC Simple Features
* Specification, which is the same as the Mod-2 rule.
*
- * @see Mod2BoundaryNodeRule
+ * A BoundaryNodeRule which determines that only endpoints with valency
+ * greater than 1 are on the boundary. This corresponds to the boundary
+ * of a MultiLineString being all the "attached" endpoints, but not the
+ * "unattached" ones.
*/
//static const BoundaryNodeRule& OGC_SFS_BOUNDARY_RULE;
static const BoundaryNodeRule& getBoundaryOGCSFS();
diff --git a/include/geos/algorithm/Centroid.h b/include/geos/algorithm/Centroid.h
index e2eae3d..e6d49fc 100644
--- a/include/geos/algorithm/Centroid.h
+++ b/include/geos/algorithm/Centroid.h
@@ -36,44 +36,44 @@ class CoordinateSequence;
namespace geos {
namespace algorithm { // geos::algorithm
-/**
- * Computes the centroid of a {@link Geometry} of any dimension.
- * If the geometry is nomimally of higher dimension, but contains only components
- * having a lower effective dimension (i.e. zero length or area),
+/**\brief
+ * Computes the centroid of a [Geometry](@ref geom::Geometry) of any dimension.
+ *
+ * If the geometry is nomimally of higher dimension, but contains only
+ * components having a lower effective dimension (i.e. zero length or area),
* the centroid will be computed appropriately.
*
- * <h2>Algorithm</h2>
- * <ul>
- * <li><b>Dimension = 2</b> - Based on the usual algorithm for calculating
- * the centroid as a weighted sum of the centroids
- * of a decomposition of the area into (possibly overlapping) triangles.
- * The algorithm has been extended to handle holes and multi-polygons.
- * See <code>http://www.faqs.org/faqs/graphics/algorithms-faq/</code>
- * for further details of the basic approach.
- * <li><b>Dimension = 1</b> - Computes the average of the midpoints
- * of all line segments weighted by the segment length.
- * <li><b>Dimension = 0</b> - Compute the average coordinate over all points.
- * </ul>
- * If the input geometries are empty, a
- * <code>null</code> Coordinate is returned.
+ * ### Algorithm #
+ *
+ * - **Dimension = 2** - Based on the usual algorithm for calculating
+ * the centroid as a weighted sum of the centroids
+ * of a decomposition of the area into (possibly overlapping) triangles.
+ * The algorithm has been extended to handle holes and multi-polygons.
+ * See http://www.faqs.org/faqs/graphics/algorithms-faq/
+ * for further details of the basic approach.
+ * - **Dimension = 1** - Computes the average of the midpoints
+ * of all line segments weighted by the segment length.
+ * - **Dimension = 0** - Compute the average coordinate over all points.
+ *
+ * If the input geometries are empty, a `null` Coordinate is returned.
*
*/
class GEOS_DLL Centroid {
public:
- /**
+ /** \brief
* Computes the centroid point of a geometry.
*
* @param geom the geometry to use
* @param cent will be set to the centroid point, if any
*
- * @return true if a centroid could be computed,
- * false otherwise (empty geom)
+ * @return `true` if a centroid could be computed,
+ * `false` otherwise (empty geom)
*/
static bool getCentroid(const geom::Geometry& geom, geom::Coordinate& cent);
- /**
+ /** \brief
* Creates a new instance for computing the centroid of a geometry
*/
Centroid(const geom::Geometry& geom)
@@ -85,13 +85,13 @@ public:
add(geom);
}
- /**
+ /** \brief
* Gets the computed centroid.
*
* @param cent will be set to the centroid point, if any
*
- * @return true if a centroid could be computed,
- * false otherwise (empty geom)
+ * @return `true` if a centroid could be computed,
+ * `false` otherwise (empty geom)
*/
bool getCentroid(geom::Coordinate& cent) const;
diff --git a/include/geos/algorithm/HCoordinate.h b/include/geos/algorithm/HCoordinate.h
index f2a0fc3..4a90a73 100644
--- a/include/geos/algorithm/HCoordinate.h
+++ b/include/geos/algorithm/HCoordinate.h
@@ -51,11 +51,11 @@ public:
* Computes the (approximate) intersection point between two line
* segments using homogeneous coordinates.
*
- * Note that this algorithm is
- * not numerically stable; i.e. it can produce intersection points which
- * lie outside the envelope of the line segments themselves. In order
- * to increase the precision of the calculation input points should be
- * normalized before passing them to this routine.
+ * @note this algorithm is not numerically stable; i.e. it can
+ * produce intersection points which lie outside the envelope of the
+ * line segments themselves. In order to increase the precision of
+ * the calculation input points should be normalized before
+ * passing them to this routine.
*/
static void intersection(const geom::Coordinate& p1,
const geom::Coordinate& p2,
@@ -74,7 +74,7 @@ public:
/** \brief
* Constructs a homogeneous coordinate which is the intersection
* of the lines define by the homogenous coordinates represented
- * by two {@link Coordinate}s.
+ * by two [Coordinates](@ref geom::Coordinate).
*
* @param p1
* @param p2
diff --git a/include/geos/algorithm/MinimumDiameter.h b/include/geos/algorithm/MinimumDiameter.h
index 7f6bb14..4917f30 100644
--- a/include/geos/algorithm/MinimumDiameter.h
+++ b/include/geos/algorithm/MinimumDiameter.h
@@ -41,24 +41,20 @@ namespace algorithm { // geos::algorithm
/** \brief
* Computes the minimum diameter of a geom::Geometry
*
- * The minimum diameter is defined to be the
- * width of the smallest band that
- * contains the geometry,
- * where a band is a strip of the plane defined
- * by two parallel lines.
- * This can be thought of as the smallest hole that the geometry can be
- * moved through, with a single rotation.
- * <p>
+ * The minimum diameter is defined to be the width of the smallest band that
+ * contains the geometry, where a band is a strip of the plane defined
+ * by two parallel lines. This can be thought of as the smallest hole
+ * that the geometry can be moved through, with a single rotation.
+ *
* The first step in the algorithm is computing the convex hull of the Geometry.
* If the input Geometry is known to be convex, a hint can be supplied to
* avoid this computation.
- * <p>
+ *
* This class can also be used to compute a line segment representing
* the minimum diameter, the supporting line segment of the minimum diameter,
* and a minimum rectangle enclosing the input geometry.
- * This rectangle will
- * have width equal to the minimum diameter, and have one side
- * parallel to the supporting segment.
+ * This rectangle will have width equal to the minimum diameter, and have
+ * one side parallel to the supporting segment.
*
* @see ConvexHull
*
@@ -100,9 +96,9 @@ public:
~MinimumDiameter();
/** \brief
- * Compute a minimum diameter for a giver {@link Geometry}.
+ * Compute a minimum diameter for a given [Geometry](@ref geom::Geometry).
*
- * @param geom a Geometry
+ * @param newInputGeom a Geometry
*/
MinimumDiameter(const geom::Geometry* newInputGeom);
@@ -113,51 +109,53 @@ public:
* or a two-point LineString, or a Point).
*
* @param newInputGeom a Geometry which is convex
- * @param newIsConvex <code>true</code> if the input geometry is convex
+ * @param newIsConvex `true` if the input geometry is convex
*/
MinimumDiameter(const geom::Geometry* newInputGeom,
const bool newIsConvex);
/** \brief
- * Gets the length of the minimum diameter of the input Geometry
+ * Gets the length of the minimum diameter of the input Geometry.
*
* @return the length of the minimum diameter
*/
double getLength();
/** \brief
- * Gets the {@link geom::Coordinate} forming one end of the minimum diameter
+ * Gets the {@link geom::Coordinate} forming one end of the minimum diameter.
*
* @return a coordinate forming one end of the minimum diameter
*/
geom::Coordinate* getWidthCoordinate();
/** \brief
- * Gets the segment forming the base of the minimum diameter
+ * Gets the segment forming the base of the minimum diameter.
*
* @return the segment forming the base of the minimum diameter
*/
geom::LineString* getSupportingSegment();
/** \brief
- * Gets a LineString which is a minimum diameter
+ * Gets a LineString which is a minimum diameter.
*
* @return a LineString which is a minimum diameter
*/
geom::LineString* getDiameter();
- /**
- * Gets the minimum rectangular Polygon which encloses the input geometry. The rectangle has width
- * equal to the minimum diameter, and a longer length. If the convex hill of the input is degenerate
- * (a line or point) a LineString or Point is returned.
- * The minimum rectangle can be used as an extremely generalized representation for the given
- * geometry.
+ /** \brief
+ * Gets the minimum rectangular Polygon which encloses the input geometry.
+ *
+ * The rectangle has width equal to the minimum diameter, and a longer
+ * length. If the convex hill of the input is degenerate (a line or point)
+ * a LineString or Point is returned.
+ * The minimum rectangle can be used as an extremely generalized
+ * representation for the given geometry.
*
* @return the minimum rectangle enclosing the input (or a line or point if degenerate)
*/
geom::Geometry* getMinimumRectangle();
- /**
+ /** \brief
* Gets the minimum rectangle enclosing a geometry.
*
* @param geom the geometry
@@ -165,8 +163,8 @@ public:
*/
static geom::Geometry* getMinimumRectangle(geom::Geometry* geom);
- /**
- * Gets the length of the minimum diameter enclosing a geometry
+ /** \brief
+ * Gets the length of the minimum diameter enclosing a geometry.
* @param geom the geometry
* @return the length of the minimum diameter of the geometry
*/
diff --git a/include/geos/algorithm/Orientation.h b/include/geos/algorithm/Orientation.h
index db9d6e7..bad90c7 100644
--- a/include/geos/algorithm/Orientation.h
+++ b/include/geos/algorithm/Orientation.h
@@ -26,20 +26,20 @@
namespace geos {
namespace algorithm { // geos::algorithm
-/**
-* Functions to compute the orientation of basic geometric structures
-* including point triplets (triangles) and rings.
-* Orientation is a fundamental property of planar geometries
-* (and more generally geometry on two-dimensional manifolds).
-*
-* Orientation is notoriously subject to numerical precision errors
-* in the case of collinear or nearly collinear points.
-* JTS uses extended-precision arithmetic to increase
-* the robustness of the computation.
-*
-* @author Martin Davis
-*
-*/
+/** \brief
+ * Functions to compute the orientation of basic geometric structures
+ * including point triplets (triangles) and rings.
+ *
+ * Orientation is a fundamental property of planar geometries
+ * (and more generally geometry on two-dimensional manifolds).
+ *
+ * Orientation is notoriously subject to numerical precision errors
+ * in the case of collinear or nearly collinear points.
+ * JTS uses extended-precision arithmetic to increase
+ * the robustness of the computation.
+ *
+ * @author Martin Davis
+ */
class GEOS_DLL Orientation {
public:
@@ -53,36 +53,36 @@ public:
STRAIGHT = 0
};
- /*
- * Returns the orientation index of the direction of the point q relative to
- * a directed infinite line specified by p1-p2.
- * The index indicates whether the point lies to the
- * {@link #Orientation::LEFT} or {@link #Orientation::RIGHT}
- * of the line, or lies on it {@link #Orientation::COLLINEAR}.
- * The index also indicates the orientation of the triangle formed
- * by the three points
- * ( {@link #Orientation::COUNTERCLOCKWISE},
- * {@link #Orientation::CLOCKWISE}, or {@link #Orientation::STRAIGHT} )
+ /** \brief
+ * Returns the orientation index of the direction of the point q relative to
+ * a directed infinite line specified by p1-p2.
+ *
+ * The index indicates whether the point lies to the
+ * `Orientation::LEFT` or `Orientation::RIGHT`
+ * of the line, or lies on it `Orientation::COLLINEAR`.
+ * The index also indicates the orientation of the triangle formed
+ * by the three points
+ * ( `Orientation::COUNTERCLOCKWISE`,
+ * `Orientation::CLOCKWISE`, or `Orientation::STRAIGHT` )
*/
static int index(const geom::Coordinate& p1, const geom::Coordinate& p2,
const geom::Coordinate& q);
- /**
- * Computes whether a ring defined by an array of {@link Coordinate}s is
- * oriented counter-clockwise.
- *
- * - The list of points is assumed to have the first and last points equal.
- * - This will handle coordinate lists which contain repeated points.
- *
- * This algorithm is *only<* guaranteed to work with valid rings. If the
- * ring is invalid (e.g. self-crosses or touches), the computed result may not
- * be correct.
- *
- * @param ring
- * an array of Coordinates forming a ring
- * @return true if the ring is oriented counter-clockwise.
- * @throws IllegalArgumentException
- * if there are too few points to determine orientation (< 4)
+ /** \brief
+ * Computes whether a ring defined by an array of
+ * [Coordinates](@ref geom::Coordinate) is oriented counter-clockwise.
+ *
+ * - The list of points is assumed to have the first and last points equal.
+ * - This will handle coordinate lists which contain repeated points.
+ *
+ * This algorithm is *only* guaranteed to work with valid rings. If the
+ * ring is invalid (e.g. self-crosses or touches), the computed result may not
+ * be correct.
+ *
+ * @param ring an array of Coordinates forming a ring
+ * @return `true` if the ring is oriented counter-clockwise.
+ * @throws IllegalArgumentException
+ * if there are too few points to determine orientation (< 4)
*/
static bool isCCW(const geom::CoordinateSequence* ring);
diff --git a/include/geos/algorithm/PointLocation.h b/include/geos/algorithm/PointLocation.h
index 0732d29..fd548da 100644
--- a/include/geos/algorithm/PointLocation.h
+++ b/include/geos/algorithm/PointLocation.h
@@ -26,7 +26,7 @@
namespace geos {
namespace algorithm { // geos::algorithm
-/**
+/** \brief
* Functions for locating points within basic geometric
* structures such as lines and rings.
*
@@ -36,62 +36,59 @@ namespace algorithm { // geos::algorithm
class GEOS_DLL PointLocation {
public:
- /**
- * Tests whether a point lies on the line defined by a list of
- * coordinates.
- *
- * @param p the point to test
- * @param line the line coordinates
- * @return true if the point is a vertex of the line or lies in the interior
- * of a line segment in the line
+ /** \brief
+ * Tests whether a point lies on the line defined by a list of
+ * coordinates.
+ *
+ * @param p the point to test
+ * @param line the line coordinates
+ * @return `true` if the point is a vertex of the line or lies in the interior
+ * of a line segment in the line
*/
//static bool isOnLine(const Coordinate &p, const std::vector<Coordinate> &line);
- /**
- * Tests whether a point lies on the line defined by a
- * {@link CoordinateSequence}.
- *
- * @param p the point to test
- * @param line the line coordinates
- * @return true if the point is a vertex of the line or lies in the interior
- * of a line segment in the line
+ /** \brief
+ * Tests whether a point lies on the line defined by a
+ * [CoordinateSequence](@ref geom::CoordinateSequence).
+ *
+ * @param p the point to test
+ * @param line the line coordinates
+ * @return true if the point is a vertex of the line or lies in the interior
+ * of a line segment in the line
*/
static bool isOnLine(const geom::Coordinate& p, const geom::CoordinateSequence* line);
- /**
- * Tests whether a point lies inside or on a ring. The ring may be oriented in
- * either direction. A point lying exactly on the ring boundary is considered
- * to be inside the ring.
- *
- * This method does *not* first check the point against the envelope of
- * the ring.
- *
- * @param p
- * point to check for ring inclusion
- * @param ring
- * an array of coordinates representing the ring (which must have
- * first point identical to last point)
- * @return true if p is inside ring
- *
- * @see locatePointInRing
- */
+ /** \brief
+ * Tests whether a point lies inside or on a ring.
+ *
+ * The ring may be oriented in either direction. A point lying exactly
+ * on the ring boundary is considered to be inside the ring.
+ *
+ * This method does **not** first check the point against the envelope of
+ * the ring.
+ *
+ * @param p point to check for ring inclusion
+ * @param ring an array of coordinates representing the ring (which must have
+ * first point identical to last point)
+ * @return `true` if p is inside ring
+ *
+ * @see RayCrossingCounter::locatePointInRing()
+ */
static bool isInRing(const geom::Coordinate& p, const std::vector<const geom::Coordinate*>& ring);
static bool isInRing(const geom::Coordinate& p, const geom::CoordinateSequence* ring);
- /**
- * Determines whether a point lies in the interior, on the boundary, or in the
- * exterior of a ring. The ring may be oriented in either direction.
- *
- * This method does *not* first check the point against the envelope of
- * the ring.
- *
- * @param p
- * point to check for ring inclusion
- * @param ring
- * an array of coordinates representing the ring (which must have
- * first point identical to last point)
- * @return the {@link Location} of p relative to the ring
- */
+ /** \brief
+ * Determines whether a point lies in the interior, on the boundary, or in the
+ * exterior of a ring. The ring may be oriented in either direction.
+ *
+ * This method does **not** first check the point against the envelope of
+ * the ring.
+ *
+ * @param p point to check for ring inclusion
+ * @param ring an array of coordinates representing the ring (which must have
+ * first point identical to last point)
+ * @return the [Location](@ref geom::Location) of p relative to the ring
+ */
static int locateInRing(const geom::Coordinate& p, const std::vector<const geom::Coordinate*>& ring);
static int locateInRing(const geom::Coordinate& p, const geom::CoordinateSequence& ring);
diff --git a/include/geos/algorithm/RayCrossingCounter.h b/include/geos/algorithm/RayCrossingCounter.h
index fbbebcc..d0aef85 100644
--- a/include/geos/algorithm/RayCrossingCounter.h
+++ b/include/geos/algorithm/RayCrossingCounter.h
@@ -37,28 +37,29 @@ namespace geos {
namespace algorithm {
/** \brief
- * Counts the number of segments crossed by a horizontal ray extending to the right
- * from a given point, in an incremental fashion.
+ * Counts the number of segments crossed by a horizontal ray extending to the
+ * right from a given point, in an incremental fashion.
*
- * This can be used to determine whether a point lies in a {@link Polygonal} geometry.
- * The class determines the situation where the point lies exactly on a segment.
- * When being used for Point-In-Polygon determination, this case allows short-circuiting
+ * This can be used to determine whether a point lies in a
+ * [Polygonal](@ref geom::Polygonal) geometry. The class determines
+ * the situation where the point lies exactly on a segment. When being
+ * used for Point-In-Polygon determination, this case allows short-circuiting
* the evaluation.
*
* This class handles polygonal geometries with any number of shells and holes.
* The orientation of the shell and hole rings is unimportant.
* In order to compute a correct location for a given polygonal geometry,
- * it is essential that <b>all</b> segments are counted which
- * <ul>
- * <li>touch the ray
- * <li>lie in in any ring which may contain the point
- * </ul>
- * The only exception is when the point-on-segment situation is detected, in which
- * case no further processing is required.
+ * it is essential that **all** segments are counted which
+ *
+ * - touch the ray
+ * - lie in in any ring which may contain the point
+ *
+ * The only exception is when the point-on-segment situation is detected, in
+ * which case no further processing is required.
* The implication of the above rule is that segments
- * which can be a priori determined to <i>not</i> touch the ray
+ * which can be a priori determined to *not* touch the ray
* (i.e. by a test of their bounding box or Y-extent)
- * do not need to be counted. This allows for optimization by indexing.
+ * do not need to be counted. This allows for optimization by indexing.
*
* @author Martin Davis
*
@@ -77,8 +78,9 @@ private:
RayCrossingCounter& operator=(const RayCrossingCounter& rhs) = delete;
public:
- /**
- * Determines the {@link Location} of a point in a ring.
+ /** \brief
+ * Determines the [Location](@ref geom::Location) of a point in a ring.
+ *
* This method is an exemplar of how to use this class.
*
* @param p the point to test
@@ -98,7 +100,7 @@ public:
isPointOnSegment(false)
{ }
- /**
+ /** \brief
* Counts a segment
*
* @param p1 an endpoint of the segment
@@ -107,14 +109,14 @@ public:
void countSegment(const geom::Coordinate& p1,
const geom::Coordinate& p2);
- /**
+ /** \brief
* Reports whether the point lies exactly on one of the supplied segments.
+ *
* This method may be called at any time as segments are processed.
- * If the result of this method is <tt>true</tt>,
- * no further segments need be supplied, since the result
- * will never change again.
+ * If the result of this method is `true`, no further segments need
+ * be supplied, since the result will never change again.
*
- * @return true if the point lies exactly on a segment
+ * @return `true` if the point lies exactly on a segment
*/
bool
isOnSegment()
@@ -122,27 +124,26 @@ public:
return isPointOnSegment;
}
- /**
- * Gets the {@link Location} of the point relative to
- * the ring, polygon
- * or multipolygon from which the processed segments were provided.
- * <p>
+ /** \brief
+ * Gets the [Location](@ref geom::Location) of the point relative to
+ * the ring, polygon or multipolygon from which the processed
+ * segments were provided.
+ *
* This method only determines the correct location
- * if <b>all</b> relevant segments must have been processed.
+ * if **all** relevant segments must have been processed.
*
* @return the Location of the point
*/
int getLocation();
- /**
- * Tests whether the point lies in or on
- * the ring, polygon
- * or multipolygon from which the processed segments were provided.
- * <p>
- * This method only determines the correct location
- * if <b>all</b> relevant segments must have been processed.
+ /** \brief
+ * Tests whether the point lies in or on the ring, polygon or
+ * multipolygon from which the processed segments were provided.
+ *
+ * This method only determines the correct location if **all** relevant
+ * segments must have been processed.
*
- * @return true if the point lies in or on the supplied polygon
+ * @return `true` if the point lies in or on the supplied polygon
*/
bool isPointInPolygon();
diff --git a/include/geos/algorithm/RayCrossingCounterDD.h b/include/geos/algorithm/RayCrossingCounterDD.h
index bc2ddf0..95d7de5 100644
--- a/include/geos/algorithm/RayCrossingCounterDD.h
+++ b/include/geos/algorithm/RayCrossingCounterDD.h
@@ -37,30 +37,31 @@ class CoordinateSequence;
namespace geos {
namespace algorithm {
-/**
- * Counts the number of segments crossed by a horizontal ray extending to the right
- * from a given point, in an incremental fashion.
- * This can be used to determine whether a point lies in a {@link Polygonal} geometry.
- * The class determines the situation where the point lies exactly on a segment.
- * When being used for Point-In-Polygon determination, this case allows short-circuiting
+/** \brief
+ * Counts the number of segments crossed by a horizontal ray extending to
+ * the right from a given point, in an incremental fashion.
+ *
+ * This can be used to determine whether a point lies in a
+ * [Polygonal](@ref geom::Polygonal) geometry. The class determines
+ * the situation where the point lies exactly on a segment. When being used
+ * for Point-In-Polygon determination, this case allows short-circuiting
* the evaluation.
- * <p>
+ *
* This class handles polygonal geometries with any number of shells and holes.
* The orientation of the shell and hole rings is unimportant.
* In order to compute a correct location for a given polygonal geometry,
- * it is essential that <b>all</b> segments are counted which
- * <ul>
- * <li>touch the ray
- * <li>lie in in any ring which may contain the point
- * </ul>
- * The only exception is when the point-on-segment situation is detected, in which
- * case no further processing is required.
- * The implication of the above rule is that segments
- * which can be a priori determined to <i>not</i> touch the ray
- * (i.e. by a test of their bounding box or Y-extent)
- * do not need to be counted. This allows for optimization by indexing.
+ * it is essential that **all** segments are counted which
+ *
+ * - touch the ray
+ * - lie in in any ring which may contain the point
+ *
+ * The only exception is when the point-on-segment situation is detected,
+ * in which case no further processing is required.
+ * The implication of the above rule is that segments which can be a
+ * priori determined to *not* touch the ray (i.e. by a test of their
+ * bounding box or Y-extent) do not need to be counted. This allows
+ * for optimization by indexing.
*/
-
class GEOS_DLL RayCrossingCounterDD {
private:
const geom::Coordinate& point;
@@ -75,8 +76,8 @@ private:
RayCrossingCounterDD& operator=(const RayCrossingCounterDD& rhs) = delete;
public:
- /**
- * Determines the {@link Location} of a point in a ring.
+ /** \brief
+ * Determines the [Location](@ref geom::Location) of a point in a ring.
* This method is an exemplar of how to use this class.
*
* @param p the point to test
@@ -91,8 +92,8 @@ public:
const std::vector<const geom::Coordinate*>& ring);
/** \brief
- * Returns the index of the direction of the point <code>q</code>
- * relative to a vector specified by <code>p1-p2</code>.
+ * Returns the index of the direction of the point `q`
+ * relative to a vector specified by `p1-p2`.
*
* @param p1 the origin point of the vector
* @param p2 the final point of the vector
@@ -112,8 +113,8 @@ public:
isPointOnSegment(false)
{ }
- /**
- * Counts a segment
+ /** \brief
+ * Counts a segment.
*
* @param p1 an endpoint of the segment
* @param p2 another endpoint of the segment
@@ -121,14 +122,14 @@ public:
void countSegment(const geom::Coordinate& p1,
const geom::Coordinate& p2);
- /**
+ /** \brief
* Reports whether the point lies exactly on one of the supplied segments.
+ *
* This method may be called at any time as segments are processed.
- * If the result of this method is <tt>true</tt>,
- * no further segments need be supplied, since the result
- * will never change again.
+ * If the result of this method is `true`, no further segments need be
+ * supplied, since the result will never change again.
*
- * @return true if the point lies exactly on a segment
+ * @return `true` if the point lies exactly on a segment
*/
bool
isOnSegment()
@@ -136,25 +137,23 @@ public:
return isPointOnSegment;
}
- /**
- * Gets the {@link Location} of the point relative to
- * the ring, polygon
- * or multipolygon from which the processed segments were provided.
- * <p>
+ /** \brief
+ * Gets the [Location](@ref geom::Location) of the point relative to the ring,
+ * polygon or multipolygon from which the processed segments were provided.
+ *
* This method only determines the correct location
- * if <b>all</b> relevant segments must have been processed.
+ * if **all** relevant segments must have been processed.
*
* @return the Location of the point
*/
int getLocation();
- /**
- * Tests whether the point lies in or on
- * the ring, polygon
- * or multipolygon from which the processed segments were provided.
- * <p>
+ /** \brief
+ * Tests whether the point lies in or on the ring, polygon or multipolygon
+ * from which the processed segments were provided.
+ *
* This method only determines the correct location
- * if <b>all</b> relevant segments must have been processed.
+ * if **all** relevant segments must have been processed.
*
* @return true if the point lies in or on the supplied polygon
*/
diff --git a/include/geos/algorithm/locate/PointOnGeometryLocator.h b/include/geos/algorithm/locate/PointOnGeometryLocator.h
index c06fd8a..39e0b7f 100644
--- a/include/geos/algorithm/locate/PointOnGeometryLocator.h
+++ b/include/geos/algorithm/locate/PointOnGeometryLocator.h
@@ -27,8 +27,8 @@ namespace algorithm { // geos::algorithm
namespace locate { // geos::algorithm::locate
/** \brief
- * An interface for classes which determine the {@link Location} of
- * points in {@link Polygon} or {@link MultiPolygon} geometries.
+ * An interface for classes which determine the [Location](@ref geom::Location) of
+ * points in [Polygon](@ref geom::Polygon) or [MultiPolygon](@ref geom::MultiPolygon) geometries.
*
* @author Martin Davis
*/
@@ -41,7 +41,7 @@ public:
{ }
/**
- * Determines the {@link Location} of a point in an areal {@link Geometry}.
+ * Determines the [Location](@ref geom::Location) of a point in an areal [Geometry](@ref geom::Geometry).
*
* @param p the point to test
* @return the location of the point in the geometry
diff --git a/include/geos/algorithm/locate/SimplePointInAreaLocator.h b/include/geos/algorithm/locate/SimplePointInAreaLocator.h
index 5a52a06..22d7c8f 100644
--- a/include/geos/algorithm/locate/SimplePointInAreaLocator.h
+++ b/include/geos/algorithm/locate/SimplePointInAreaLocator.h
@@ -32,23 +32,17 @@ namespace algorithm { // geos::algorithm
namespace locate { // geos::algorithm::locate
/** \brief
- * Computes the location of points
- * relative to a {@link Polygonal} {@link Geometry},
- * using a simple <tt>O(n)</tt> algorithm.
+ * Computes the location of points relative to a [Polygonal](@ref geom::Polygonal)
+ * [Geometry](@ref geom::Geometry), using a simple `O(n)` algorithm.
*
- * The algorithm used reports
- * if a point lies in the interior, exterior,
+ * The algorithm used reports if a point lies in the interior, exterior,
* or exactly on the boundary of the Geometry.
*
- * Instance methods are provided to implement
- * the interface {@link PointInAreaLocator}.
- * However, they provide no performance
- * advantage over the class methods.
+ * Instance methods are provided to implement the interface `PointInAreaLocator`.
+ * However, they provide no performance advantage over the class methods.
*
- * This algorithm is suitable for use in cases where
- * only a few points will be tested.
- * If many points will be tested,
- * {@link IndexedPointInAreaLocator} may provide better performance.
+ * This algorithm is suitable for use in cases where only a few points will be tested.
+ * If many points will be tested, IndexedPointInAreaLocator may provide better performance.
*/
class SimplePointInAreaLocator : public PointOnGeometryLocator {
@@ -57,39 +51,41 @@ public:
static int locate(const geom::Coordinate& p,
const geom::Geometry* geom);
- /**
- * Determines the {@link Location} of a point in a {@link Polygon}.
- * The return value is one of:
- *
- * - {@link Location.INTERIOR} if the point is in the geometry interior
- * - {@link Location.BOUNDARY} if the point lies exactly on the boundary
- * - {@link Location.EXTERIOR} if the point is outside the geometry
- *
- * Computes {@link Location::BOUNDARY} if the point lies exactly
- * on the polygon boundary.
- *
- * @param p the point to test
- * @param poly the geometry to test
- * @return the Location of the point in the polygon
- */
+ /** \brief
+ * Determines the Location of a point in a [Polygon](@ref geom::Polygon).
+ *
+ * The return value is one of:
+ *
+ * - [Location::INTERIOR](@ref geom::Location::INTERIOR) if the point is in the geometry interior
+ * - [Location::BOUNDARY](@ref geom::Location::BOUNDARY) if the point lies exactly on the boundary
+ * - [Location::EXTERIOR](@ref geom::Location::EXTERIOR) if the point is outside the geometry
+ *
+ * Computes `Location::BOUNDARY` if the point lies exactly
+ * on the polygon boundary.
+ *
+ * @param p the point to test
+ * @param poly the geometry to test
+ * @return the Location of the point in the polygon
+ */
static int locatePointInPolygon(const geom::Coordinate& p,
const geom::Polygon* poly);
- /**
- * Determines whether a point is contained in a {@link Geometry},
- * or lies on its boundary.
- * This is a convenience method for
- *
- * Location.EXTERIOR != locate(p, geom)
- *
- * @param p the point to test
- * @param geom the geometry to test
- * @return true if the point lies in or on the geometry
- */
+ /** \brief
+ * Determines whether a point is contained in a [Geometry](@ref geom::Geometry),
+ * or lies on its boundary.
+ *
+ * This is a convenience method for
+ *
+ * Location.EXTERIOR != locate(p, geom)
+ *
+ * @param p the point to test
+ * @param geom the geometry to test
+ * @return true if the point lies in or on the geometry
+ */
static bool isContained(const geom::Coordinate& p,
const geom::Geometry* geom);
SimplePointInAreaLocator(const geom::Geometry* p_g)
- : g(p_g)
+ : g(p_g)
{ }
int
diff --git a/include/geos/algorithm/ttmath/ttmathtypes.h b/include/geos/algorithm/ttmath/ttmathtypes.h
index a6e4903..5c4e0b7 100644
--- a/include/geos/algorithm/ttmath/ttmathtypes.h
+++ b/include/geos/algorithm/ttmath/ttmathtypes.h
@@ -46,7 +46,7 @@
As our library is written in header files (templates) we cannot use
constants like 'const int' etc. because we should have some source files
*.cpp to define this variables. Only what we can have are constants
- defined by #define preprocessor macros.
+ defined by \#define preprocessor macros.
All macros are preceded by TTMATH_ prefix
*/
diff --git a/include/geos/geom.h b/include/geos/geom.h
index 6b96d08..9a555b4 100644
--- a/include/geos/geom.h
+++ b/include/geos/geom.h
@@ -37,7 +37,7 @@
/** \page c_iface C wrapper interface
*
- * \section Overview
+ * \section overview_c Overview
*
* This is the preferred access method for GEOS.
*
@@ -53,7 +53,7 @@
/** \page cpp_iface C++ interface
*
- * \section Overview
+ * \section overview_cpp Overview
*
* Main class is geos::geom::Geometry, from which all geometry types
* derive.
diff --git a/include/geos/geom/CoordinateArraySequence.h b/include/geos/geom/CoordinateArraySequence.h
index fce0bc3..a1cdaf6 100644
--- a/include/geos/geom/CoordinateArraySequence.h
+++ b/include/geos/geom/CoordinateArraySequence.h
@@ -104,7 +104,7 @@ public:
* @param allowRepeated if set to false, repeated coordinates are
* collapsed
*
- * NOTE: this is a CoordinateList interface in JTS
+ * @note this is a CoordinateList interface in JTS
*/
void add(std::size_t i, const Coordinate& coord, bool allowRepeated);
diff --git a/include/geos/geom/CoordinateFilter.h b/include/geos/geom/CoordinateFilter.h
index 9ea063b..10f5a5d 100644
--- a/include/geos/geom/CoordinateFilter.h
+++ b/include/geos/geom/CoordinateFilter.h
@@ -25,9 +25,9 @@ namespace geom { // geos::geom
class Coordinate;
-/**
- * <code>Geometry</code> classes support the concept of applying a
- * coordinate filter to every coordinate in the <code>Geometry</code>.
+/** \brief
+ * Geometry classes support the concept of applying a
+ * coordinate filter to every coordinate in the Geometry.
*
* A coordinate filter can either record information about each coordinate or
* change the coordinate in some way. Coordinate filters implement the
@@ -45,10 +45,10 @@ public:
virtual
~CoordinateFilter() {}
- /**
- * Performs an operation on <code>coord</code>.
+ /** \brief
+ * Performs an operation on `coord`.
*
- * @param coord a <code>Coordinate</code> to which the filter is applied.
+ * **param** `coord` a Coordinate to which the filter is applied.
*/
virtual void
filter_rw(Coordinate* /*coord*/) const
@@ -56,10 +56,10 @@ public:
assert(0);
}
- /**
- * Performs an operation with <code>coord</code>.
+ /** \brief
+ * Performs an operation with `coord`.
*
- * @param coord a <code>Coordinate</code> to which the filter is applied.
+ * **param** `coord` a Coordinate to which the filter is applied.
*/
virtual void
filter_ro(const Coordinate* /*coord*/)
diff --git a/include/geos/geom/CoordinateSequenceFilter.h b/include/geos/geom/CoordinateSequenceFilter.h
index 0741328..0574d1e 100644
--- a/include/geos/geom/CoordinateSequenceFilter.h
+++ b/include/geos/geom/CoordinateSequenceFilter.h
@@ -34,24 +34,23 @@ class CoordinateSequence;
namespace geos {
namespace geom { // geos::geom
-/**
- * Interface for classes which provide operations that
- * can be applied to the coordinates in a {@link CoordinateSequence}.
- * A CoordinateSequence filter can either record information about each
- * coordinate or change the coordinate in some way.
- * CoordinateSequence filters can be
- * used to implement such things as coordinate transformations, centroid and
- * envelope computation, and many other functions.
- * For maximum efficiency, the execution of filters can be short-circuited.
- * {@link Geometry} classes support the concept of applying a
- * <code>CoordinateSequenceFilter</code> to each
- * {@link CoordinateSequence}s they contain.
- * <p>
- * <code>CoordinateSequenceFilter</code> is
- * an example of the Gang-of-Four Visitor pattern.
+/** \brief
+ * Interface for classes which provide operations that can be applied to
+ * the coordinates in a CoordinateSequence.
*
- * @see Geometry::apply_ro(CoordinateSequenceFilter)
- * @see Geometry::apply_rw(CoordinateSequenceFilter)
+ * A CoordinateSequence filter can either record information about each
+ * coordinate or change the coordinate in some way.
+ * CoordinateSequence filters can be used to implement such things as
+ * coordinate transformations, centroid and envelope computation, and many
+ * other functions.
+ * For maximum efficiency, the execution of filters can be short-circuited.
+ * Geometry classes support the concept of applying a CoordinateSequenceFilter
+ * to each CoordinateSequences they contain.
+ *
+ * CoordinateSequenceFilter is an example of the Gang-of-Four Visitor pattern.
+ *
+ * @see Geometry::apply_ro(CoordinateSequenceFilter& filter) const
+ * @see Geometry::apply_rw(CoordinateSequenceFilter& filter)
* @author Martin Davis
*
*/
@@ -62,12 +61,11 @@ public:
virtual
~CoordinateSequenceFilter() {}
- /**
- * Performs an operation on a coordinate in a {@link CoordinateSequence}.
+ /** \brief
+ * Performs an operation on a coordinate in a CoordinateSequence.
*
- * @param seq the <code>CoordinateSequence</code> to which the filter
- * is applied
- * @param i the index of the coordinate to apply the filter to
+ * **param** `seq` the CoordinateSequence to which the filter is applied
+ * **param** `i` the index of the coordinate to apply the filter to
*/
virtual void
filter_rw(CoordinateSequence& /*seq*/, std::size_t /*i*/)
@@ -75,12 +73,11 @@ public:
assert(0);
}
- /**
- * Performs an operation on a coordinate in a {@link CoordinateSequence}.
+ /** \brief
+ * Performs an operation on a coordinate in a CoordinateSequence.
*
- * @param seq the <code>CoordinateSequence</code> to which the filter
- * is applied
- * @param i the index of the coordinate to apply the filter to
+ * **param** `seq` the CoordinateSequence to which the filter is applied
+ * **param** `i` the index of the coordinate to apply the filter to
*/
virtual void
filter_ro(const CoordinateSequence& /*seq*/, std::size_t /*i*/)
@@ -88,26 +85,28 @@ public:
assert(0);
}
- /**
+ /** \brief
* Reports whether the application of this filter can be terminated.
- * Once this method returns <tt>false</tt>, it should
- * continue to return <tt>false</tt> on every subsequent call.
*
- * @return true if the application of this filter can be terminated.
+ * Once this method returns `false`, it should continue to return
+ * `false` on every subsequent call.
+ *
+ * @return `true` if the application of this filter can be terminated.
*/
virtual bool isDone() const = 0;
- /**
- * Reports whether the execution of this filter
- * has modified the coordinates of the geometry.
- * If so, {@link Geometry#geometryChanged} will be executed
- * after this filter has finished being executed.
+ /** \brief
+ * Reports whether the execution of this filter has modified
+ * the coordinates of the geometry.
+ *
+ * If so, Geometry::geometryChanged() will be executed after this
+ * filter has finished being executed.
*
- * Most filters can simply return a constant value reflecting
- * whether they are able to change the coordinates.
+ * Most filters can simply return a constant value reflecting whether
+ * they are able to change the coordinates.
*
- * @return true if this filter has changed the coordinates of the geometry
+ * @return `true` if this filter has changed the coordinates of the geometry
*/
virtual bool isGeometryChanged() const = 0;
diff --git a/include/geos/geom/Envelope.h b/include/geos/geom/Envelope.h
index 27c4d1b..8a09d05 100644
--- a/include/geos/geom/Envelope.h
+++ b/include/geos/geom/Envelope.h
@@ -49,11 +49,10 @@ class Coordinate;
* e.g. the minimum and maximum x and y values of the Coordinates.
*
* Note that Envelopes support infinite or half-infinite regions, by using
- * the values of <code>Double_POSITIVE_INFINITY</code> and
- * <code>Double_NEGATIVE_INFINITY</code>.
+ * the values of `Double_POSITIVE_INFINITY` and `Double_NEGATIVE_INFINITY`.
*
- * When Envelope objects are created or initialized,
- * the supplies extent values are automatically sorted into the correct order.
+ * When Envelope objects are created or initialized, the supplies extent
+ * values are automatically sorted into the correct order.
*
*/
class GEOS_DLL Envelope {
@@ -65,13 +64,12 @@ public:
typedef std::unique_ptr<Envelope> Ptr;
/** \brief
- * Creates a null <code>Envelope</code>.
+ * Creates a null Envelope.
*/
Envelope(void);
/** \brief
- * Creates an <code>Envelope</code> for a region defined by
- * maximum and minimum values.
+ * Creates an Envelope for a region defined by maximum and minimum values.
*
* @param x1 the first x-value
* @param x2 the second x-value
@@ -81,8 +79,7 @@ public:
Envelope(double x1, double x2, double y1, double y2);
/** \brief
- * Creates an <code>Envelope</code> for a region defined by
- * two Coordinates.
+ * Creates an Envelope for a region defined by two Coordinates.
*
* @param p1 the first Coordinate
* @param p2 the second Coordinate
@@ -103,57 +100,56 @@ public:
Envelope& operator=(const Envelope& e);
/** \brief
- * Create an <code>Envelope</code> from an Envelope
- * string representation produced by Envelope.toString()
+ * Create an Envelope from an Envelope string representation produced
+ * by Envelope::toString()
*/
Envelope(const std::string& str);
~Envelope(void);
/** \brief
- * Test the point q to see whether it intersects the
- * Envelope defined by p1-p2
+ * Test the point `q` to see whether it intersects the Envelope
+ * defined by `p1-p2`.
*
* @param p1 one extremal point of the envelope
* @param p2 another extremal point of the envelope
* @param q the point to test for intersection
- * @return <code>true</code> if q intersects the envelope p1-p2
+ * @return `true` if q intersects the envelope p1-p2
*/
static bool intersects(const Coordinate& p1, const Coordinate& p2,
const Coordinate& q);
/** \brief
- * Test the envelope defined by p1-p2 for intersection
- * with the envelope defined by q1-q2
+ * Test the envelope defined by `p1-p2` for intersection
+ * with the envelope defined by `q1-q2`.
*
* @param p1 one extremal point of the envelope P
* @param p2 another extremal point of the envelope P
* @param q1 one extremal point of the envelope Q
* @param q2 another extremal point of the envelope Q
*
- * @return <code>true</code> if Q intersects P
+ * @return `true` if Q intersects P
*/
static bool intersects(const Coordinate& p1, const Coordinate& p2,
const Coordinate& q1, const Coordinate& q2);
- /**
- * Check if the extent defined by two extremal points
- * intersects the extent of this <code>Envelope</code>.
- *
- * @param a a point
- * @param b another point
- * @return <code>true</code> if the extents intersect
- */
+ /** \brief
+ * Check if the extent defined by two extremal points intersects
+ * the extent of this Envelope.
+ *
+ * @param a a point
+ * @param b another point
+ * @return `true` if the extents intersect
+ */
bool intersects(const Coordinate& a, const Coordinate& b) const;
/** \brief
- * Initialize to a null <code>Envelope</code>.
+ * Initialize to a null Envelope.
*/
void init(void);
/** \brief
- * Initialize an <code>Envelope</code> for a region defined by
- * maximum and minimum values.
+ * Initialize an Envelope for a region defined by maximum and minimum values.
*
* @param x1 the first x-value
* @param x2 the second x-value
@@ -163,8 +159,7 @@ public:
void init(double x1, double x2, double y1, double y2);
/** \brief
- * Initialize an <code>Envelope</code> to a region defined
- * by two Coordinates.
+ * Initialize an Envelope to a region defined by two Coordinates.
*
* @param p1 the first Coordinate
* @param p2 the second Coordinate
@@ -172,8 +167,7 @@ public:
void init(const Coordinate& p1, const Coordinate& p2);
/** \brief
- * Initialize an <code>Envelope</code> to a region defined
- * by a single Coordinate.
+ * Initialize an Envelope to a region defined by a single Coordinate.
*
* @param p the Coordinate
*/
@@ -183,36 +177,34 @@ public:
//void init(Envelope env);
/** \brief
- * Makes this <code>Envelope</code> a "null" envelope,
- * that is, the envelope of the empty geometry.
+ * Makes this `Envelope` a "null" envelope, that is, the envelope
+ * of the empty geometry.
*/
void setToNull(void);
/** \brief
- * Returns <code>true</code> if this <code>Envelope</code>
- * is a "null" envelope.
+ * Returns `true` if this Envelope is a "null" envelope.
*
- * @return <code>true</code> if this <code>Envelope</code>
- * is uninitialized or is the envelope of the
- * empty geometry.
+ * @return `true` if this Envelope is uninitialized or is the
+ * envelope of the empty geometry.
*/
bool isNull(void) const;
/** \brief
* Returns the difference between the maximum and minimum x values.
*
- * @return max x - min x, or 0 if this is a null Envelope
+ * @return `max x - min x`, or 0 if this is a null Envelope
*/
double getWidth(void) const;
/** \brief
* Returns the difference between the maximum and minimum y values.
*
- * @return max y - min y, or 0 if this is a null Envelope
+ * @return `max y - min y`, or 0 if this is a null Envelope
*/
double getHeight(void) const;
- /**
+ /** \brief
* Gets the area of this envelope.
*
* @return the area of the envelope
@@ -224,42 +216,41 @@ public:
return getWidth() * getHeight();
}
- /**
- * Returns the Envelope maximum y-value. min y > max y
- * indicates that this is a null Envelope.
+ /** \brief
+ * Returns the Envelope maximum y-value. `min y > max y` indicates
+ * that this is a null Envelope.
*/
double getMaxY() const;
- /**
- * Returns the Envelope maximum x-value. min x > max x
- * indicates that this is a null Envelope.
+ /** \brief
+ * Returns the Envelope maximum x-value. `min x > max x` indicates
+ * that this is a null Envelope.
*/
double getMaxX() const;
- /**
- * Returns the Envelope minimum y-value. min y > max y
- * indicates that this is a null Envelope.
+ /** \brief
+ * Returns the Envelope minimum y-value. `min y > max y` indicates
+ * that this is a null Envelope.
*/
double getMinY() const;
- /**
- * Returns the Envelope minimum x-value. min x > max x
- * indicates that this is a null Envelope.
+ /** \brief
+ * Returns the Envelope minimum x-value. `min x > max x` indicates
+ * that this is a null Envelope.
*/
double getMinX() const;
- /**
+ /** \brief
* Computes the coordinate of the centre of this envelope
- * (as long as it is non-null)
+ * (as long as it is non-null).
*
* @param centre The coordinate to write results into
- * @return NULL is the center could not be found
- * (null envelope).
+ * @return `false` if the center could not be found (null envelope).
*/
bool centre(Coordinate& centre) const;
- /**
- * Computes the intersection of two {@link Envelopes}
+ /** \brief
+ * Computes the intersection of two [Envelopes](@ref Envelope).
*
* @param env the envelope to intersect with
* @param result the envelope representing the intersection of
@@ -281,15 +272,14 @@ public:
* Expands this envelope by a given distance in all directions.
* Both positive and negative distances are supported.
*
- * @param deltaX the distance to expand the envelope along
- * the X axis
- * @param deltaY the distance to expand the envelope along
- * the Y axis
+ * @param deltaX the distance to expand the envelope along the X axis
+ * @param deltaY the distance to expand the envelope along the Y axis
*/
void expandBy(double deltaX, double deltaY);
/** \brief
* Expands this envelope by a given distance in all directions.
+ *
* Both positive and negative distances are supported.
*
* @param p_distance the distance to expand the envelope
@@ -302,16 +292,17 @@ public:
/** \brief
- * Enlarges the boundary of the Envelope so that it contains
- * p. Does nothing if p is already on or within the boundaries.
+ * Enlarges the boundary of the Envelope so that it contains p. Does
+ * nothing if p is already on or within the boundaries.
*
- * @param p the Coordinate to include
+ * @param p the Coordinate to include
*/
void expandToInclude(const Coordinate& p);
/** \brief
- * Enlarges the boundary of the Envelope so that it contains
- * (x,y). Does nothing if (x,y) is already on or within the boundaries.
+ * Enlarges the boundary of the Envelope so that it contains (x,y).
+ *
+ * Does nothing if (x,y) is already on or within the boundaries.
*
* @param x the value to lower the minimum x
* to or to raise the maximum x to
@@ -321,24 +312,23 @@ public:
void expandToInclude(double x, double y);
/** \brief
- * Enlarges the boundary of the Envelope so that it contains
- * <code>other</code>. Does nothing if other is wholly on or
- * within the boundaries.
+ * Enlarges the boundary of the Envelope so that it contains `other`.
+ *
+ * Does nothing if other is wholly on or within the boundaries.
*
- * @param other the <code>Envelope</code> to merge with
+ * @param other the Envelope to merge with
*/
void expandToInclude(const Envelope* other);
/** \brief
- * Tests if the <code>Envelope other</code> lies wholely
- * inside this <code>Envelope</code> (inclusive of the boundary).
+ * Tests if the Envelope `other` lies wholly inside this Envelope
+ * (inclusive of the boundary).
*
- * Note that this is <b>not</b> the same definition as the SFS
- * <tt>contains</tt>, which would exclude the envelope boundary.
+ * Note that this is **not** the same definition as the SFS `contains`,
+ * which would exclude the envelope boundary.
*
- * @param other the <code>Envelope</code> to check
- * @return true if <code>other</code> is contained in this
- * <code>Envelope</code>
+ * @param other the Envelope to check
+ * @return `true` if `other` is contained in this Envelope
*
* @see covers(Envelope)
*/
@@ -355,13 +345,11 @@ public:
}
/** \brief
- * Returns <code>true</code> if the given point lies in
- * or on the envelope.
+ * Returns `true` if the given point lies in or on the envelope.
*
- * @param p the point which this <code>Envelope</code> is
- * being checked for containing
- * @return <code>true</code> if the point lies in the interior or
- * on the boundary of this <code>Envelope</code>.
+ * @param p the point which this Envelope is being checked for containing
+ * @return `true` if the point lies in the interior or on the boundary
+ * of this Envelope.
*/
bool
contains(const Coordinate& p) const
@@ -370,19 +358,14 @@ public:
}
/** \brief
- * Returns <code>true</code> if the given point lies in
- * or on the envelope.
- *
- * @param x the x-coordinate of the point which this
- * <code>Envelope</code> is
- * being checked for containing
+ * Returns `true` if the given point lies in or on the envelope.
*
- * @param y the y-coordinate of the point which this
- * <code>Envelope</code> is being checked for containing
- *
- * @return <code>true</code> if <code>(x, y)</code> lies in
- * the interior or on the boundary of this
- * <code>Envelope</code>.
+ * @param x the x-coordinate of the point which this Envelope is
+ * being checked for containing
+ * @param y the y-coordinate of the point which this Envelope is being
+ * checked for containing
+ * @return `true` if `(x, y)` lies in the interior or on the boundary
+ * of this Envelope.
*/
bool
contains(double x, double y) const
@@ -390,67 +373,55 @@ public:
return covers(x, y);
}
- /**
- * Check if the point p
- * intersects (lies inside) the region of this Envelope.
+ /** \brief
+ * Check if the point p intersects (lies inside) the region of this Envelope.
*
* @param p the Coordinate to be tested
* @return true if the point intersects this Envelope
*/
bool intersects(const Coordinate& p) const;
- /**
- * Check if the point (x, y)
- * intersects (lies inside) the region of this Envelope.
+ /** \brief
+ * Check if the point (x, y) intersects (lies inside) the region of this Envelope.
*
- * @param x the x-ordinate of the point
- * @param y the y-ordinate of the point
- * @return <code>true</code> if the point intersects this Envelope
+ * @param x the x-ordinate of the point
+ * @param y the y-ordinate of the point
+ * @return `true` if the point intersects this Envelope
*/
bool intersects(double x, double y) const;
- /**
- * Check if the region defined by other Envelope
- * intersects (intersects) the region of this Envelope.
- *
- * @param other the Envelope which this Envelope is
- * being checked for intersection
+ /** \brief
+ * Check if the region defined by other Envelope intersects the region of this Envelope.
*
- * @return true if the Envelopes intersects
+ * @param other the Envelope which this Envelope is being checked for intersection
+ * @return true if the Envelopes intersects
*/
bool intersects(const Envelope* other) const;
bool intersects(const Envelope& other) const;
- /**
- * Tests if the given point lies in or on the envelope.
- *
- *@param x the x-coordinate of the point which this <code>Envelope</code> is
- * being checked for containing
- *@param y the y-coordinate of the point which this <code>Envelope</code> is
- * being checked for containing
- *@return <code>true</code> if <code>(x, y)</code> lies in the interior or
- * on the boundary of this <code>Envelope</code>.
- */
+ /** \brief
+ * Tests if the given point lies in or on the envelope.
+ *
+ * @param x the x-coordinate of the point which this Envelope is being checked for containing
+ * @param y the y-coordinate of the point which this Envelope is being checked for containing
+ * @return `true` if `(x, y)` lies in the interior or on the boundary of this Envelope.
+ */
bool covers(double x, double y) const;
- /**
- * Tests if the given point lies in or on the envelope.
- *
- *@param p the point which this <code>Envelope</code> is
- * being checked for containing
- *@return <code>true</code> if the point lies in the interior or
- * on the boundary of this <code>Envelope</code>.
- */
+ /** \brief
+ * Tests if the given point lies in or on the envelope.
+ *
+ * @param p the point which this Envelope is being checked for containing
+ * @return `true` if the point lies in the interior or on the boundary of this Envelope.
+ */
bool covers(const Coordinate* p) const;
- /**
- * Tests if the <code>Envelope other</code> lies wholely inside
- * this <code>Envelope</code> (inclusive of the boundary).
+ /** \brief
+ * Tests if the Envelope `other` lies wholly inside this Envelope (inclusive of the boundary).
*
- * @param other the <code>Envelope</code> to check
- * @return true if this <code>Envelope</code> covers the
- * <code>other</code>
+ * @param other the Envelope to check
+ * @return true if this Envelope covers the `other`
*/
bool covers(const Envelope& other) const;
@@ -462,31 +433,24 @@ public:
/** \brief
- * Returns <code>true</code> if the <code>Envelope other</code>
- * spatially equals this <code>Envelope</code>.
- *
- * @param other the <code>Envelope</code> which this
- * <code>Envelope</code> is being checked for equality
+ * Returns `true` if the Envelope `other` spatially equals this Envelope.
*
- * @return <code>true</code> if this and <code>other</code>
- * Envelope objs are spatially equal
+ * @param other the Envelope which this Envelope is being checked for equality
+ * @return `true` if this and `other` Envelope objects are spatially equal
*/
bool equals(const Envelope* other) const;
/** \brief
- * Returns a <code>string</code> of the form
- * <I>Env[minx:maxx,miny:maxy]</I> .
+ * Returns a `string` of the form `Env[minx:maxx,miny:maxy]`.
*
- * @return a <code>string</code> of the form
- * <I>Env[minx:maxx,miny:maxy]</I>
+ * @return a `string` of the form `Env[minx:maxx,miny:maxy]`
*/
std::string toString(void) const;
/** \brief
- * Computes the distance between this and another
- * <code>Envelope</code>.
+ * Computes the distance between this and another Envelope.
*
- * The distance between overlapping Envelopes is 0. Otherwise, the
+ * The distance between overlapping Envelopes is 0. Otherwise, the
* distance is the Euclidean distance between the closest points.
*/
double distance(const Envelope* env) const;
diff --git a/include/geos/geom/Geometry.h b/include/geos/geom/Geometry.h
index b7aef91..f8a82ce 100644
--- a/include/geos/geom/Geometry.h
+++ b/include/geos/geom/Geometry.h
@@ -671,7 +671,7 @@ public:
* - Unioning a set of {@link LineString}s has the effect of fully noding
* and dissolving the linework.
* - Unioning a set of {@link Polygon}s will always
- * return a {@link Polygonal} geometry (unlike {link #union(Geometry)},
+ * return a {@link Polygonal} geometry (unlike Geometry::Union(const Geometry* other) const),
* which may return geometrys of lower dimension if a topology collapse
* occurred.
*
@@ -815,7 +815,7 @@ public:
*/
std::unique_ptr<Point> getInteriorPoint() const;
- /*
+ /**
* \brief
* Notifies this Geometry that its Coordinates have been changed
* by an external party (using a CoordinateFilter, for example).
diff --git a/include/geos/geom/LineString.h b/include/geos/geom/LineString.h
index fd0f51e..10ce548 100644
--- a/include/geos/geom/LineString.h
+++ b/include/geos/geom/LineString.h
@@ -64,7 +64,7 @@ namespace geom { // geos::geom
*
* A linestring must have either 0 or 2 or more points.
* If these conditions are not met, the constructors throw
- * an {@link IllegalArgumentException}.
+ * an {@link util::IllegalArgumentException}.
*/
class GEOS_DLL LineString: public virtual Geometry, public Lineal {
diff --git a/include/geos/geom/LinearRing.h b/include/geos/geom/LinearRing.h
index 4b5a7be..50c9a23 100644
--- a/include/geos/geom/LinearRing.h
+++ b/include/geos/geom/LinearRing.h
@@ -40,24 +40,22 @@ namespace geom { // geos::geom
/**
* \brief
- * Models an OGC SFS <code>LinearRing</code>.
+ * Models an OGC SFS LinearRing. A LinearRing is a LineString which is both
+ * closed and simple.
*
- * A LinearRing is a LineString which is both closed and simple.
- * In other words,
- * the first and last coordinate in the ring must be equal,
- * and the interior of the ring must not self-intersect.
- * Either orientation of the ring is allowed.
+ * In other words, the first and last coordinate in the ring must be equal,
+ * and the interior of the ring must not self-intersect. Either orientation
+ * of the ring is allowed.
*
- * A ring must have either 0 or 4 or more points.
- * The first and last points must be equal (in 2D).
- * If these conditions are not met, the constructors throw
- * an {@link IllegalArgumentException}
+ * A ring must have either 0 or 4 or more points. The first and last points
+ * must be equal (in 2D). If these conditions are not met, the constructors
+ * throw an {@link geos::util::IllegalArgumentException}
*/
class GEOS_DLL LinearRing : public LineString {
public:
- /**
+ /** \brief
* The minimum number of vertices allowed in a valid non-empty ring (= 4).
* Empty rings with 0 vertices are also valid.
*/
@@ -66,7 +64,7 @@ public:
LinearRing(const LinearRing& lr);
/**
- * \brief Constructs a <code>LinearRing</code> with the given points.
+ * \brief Constructs a LinearRing with the given points.
*
* @param points points forming a closed and simple linestring, or
* <code>null</code> or an empty array to create the empty
diff --git a/include/geos/geom/MultiLineString.h b/include/geos/geom/MultiLineString.h
index fcf9e20..181c6ea 100644
--- a/include/geos/geom/MultiLineString.h
+++ b/include/geos/geom/MultiLineString.h
@@ -47,7 +47,7 @@ namespace geom { // geos::geom
#pragma warning(disable:4250) // T1 inherits T2 via dominance
#endif
-/// Models a collection of (@link LineString}s.
+/// Models a collection of [LineStrings](@ref geom::LineString).
class GEOS_DLL MultiLineString: public GeometryCollection, public Lineal {
public:
@@ -61,12 +61,12 @@ public:
/**
* \brief
- * Returns Dimension::False if all LineStrings in the collection
+ * Returns Dimension::False if all [LineStrings](@ref geom::LineString) in the collection
* are closed, 0 otherwise.
*/
int getBoundaryDimension() const override;
- /// Returns a (possibly empty) MultiPoint
+ /// Returns a (possibly empty) [MultiPoint](@ref geom::MultiPoint)
std::unique_ptr<Geometry> getBoundary() const override;
std::string getGeometryType() const override;
@@ -93,22 +93,20 @@ public:
protected:
/**
- * \brief Constructs a <code>MultiLineString</code>.
+ * \brief Constructs a MultiLineString.
*
- * @param newLines
- * The <code>LineStrings</code>s for this
- * <code>MultiLineString</code>, or <code>null</code>
- * or an empty array to create the empty geometry.
- * Elements may be empty <code>LineString</code>s,
- * but not <code>null</code>s.
+ * @param newLines The [LineStrings](@ref geom::LineString) for this
+ * MultiLineString, or `null`
+ * or an empty array to create the empty geometry.
+ * Elements may be empty LineString,
+ * but not `null`s.
*
- * Constructed object will take ownership of
- * the vector and its elements.
+ * @param newFactory The GeometryFactory used to create this geometry.
+ * Caller must keep the factory alive for the life-time
+ * of the constructed MultiLineString.
*
- * @param newFactory
- * The GeometryFactory used to create this geometry.
- * Caller must keep the factory alive for the life-time
- * of the constructed MultiLineString.
+ * @note Constructed object will take ownership of
+ * the vector and its elements.
*
*/
MultiLineString(std::vector<Geometry*>* newLines,
diff --git a/include/geos/geom/PrecisionModel.h b/include/geos/geom/PrecisionModel.h
index e2ee2fd..f196522 100644
--- a/include/geos/geom/PrecisionModel.h
+++ b/include/geos/geom/PrecisionModel.h
@@ -233,9 +233,8 @@ public:
///
double getOffsetY() const;
- /** \brief
- * Sets <code>internal</code> to the precise representation of
- * <code>external</code>.
+ /*
+ * Sets ´internal` to the precise representation of `external`.
*
* @param external the original coordinate
* @param internal the coordinate whose values will be changed to the
diff --git a/include/geos/geom/util/GeometryExtracter.h b/include/geos/geom/util/GeometryExtracter.h
index 3a3c0f0..df2a4ce 100644
--- a/include/geos/geom/util/GeometryExtracter.h
+++ b/include/geos/geom/util/GeometryExtracter.h
@@ -42,7 +42,7 @@ public:
* and adds them to the provided container.
*
* @param geom the geometry from which to extract
- * @param list the list to add the extracted elements to
+ * @param lst the list to add the extracted elements to
*/
template <class ComponentType, class TargetContainer>
static void
diff --git a/include/geos/geom/util/GeometryTransformer.h b/include/geos/geom/util/GeometryTransformer.h
index b596a08..410a22d 100644
--- a/include/geos/geom/util/GeometryTransformer.h
+++ b/include/geos/geom/util/GeometryTransformer.h
@@ -54,34 +54,31 @@ namespace geom { // geos.geom
namespace util { // geos.geom.util
/** \brief
- * A framework for processes which transform an input {@link Geometry} into
- * an output {@link Geometry}, possibly changing its structure and type(s).
+ * A framework for processes which transform an input Geometry into
+ * an output Geometry, possibly changing its structure and type(s).
*
- * This class is a framework for implementing subclasses
- * which perform transformations on
- * various different Geometry subclasses.
+ * This class is a framework for implementing subclasses which perform
+ * transformations on various different Geometry subclasses.
* It provides an easy way of applying specific transformations
* to given geometry types, while allowing unhandled types to be simply copied.
* Also, the framework ensures that if subcomponents change type
* the parent geometries types change appropriately to maintain valid structure.
- * Subclasses will override whichever <code>transformX</code> methods
+ * Subclasses will override whichever `transformX` methods
* they need to to handle particular Geometry types.
*
* A typically usage would be a transformation that may transform Polygons into
- * Polygons, LineStrings
- * or Points. This class would likely need to override the
- * {@link transformMultiPolygon} method to ensure that if input Polygons
- * change type the result is a GeometryCollection,
- * not a MultiPolygon
+ * Polygons, LineStrings or Points. This class would likely need to override the
+ * `GeometryTransformer::transformMultiPolygon(const MultiPolygon* geom,
+ * const Geometry* parent)` method to ensure that if input Polygons change type
+ * the result is a GeometryCollection, not a MultiPolygon
*
* The default behaviour of this class is to simply recursively transform
* each Geometry component into an identical object by copying.
*
- * Note that all <code>transformX</code> methods may return <code>null</code>,
- * to avoid creating empty geometry objects. This will be handled correctly
- * by the transformer.
- * The {@link transform} method itself will always
- * return a geometry object.
+ * Note that all `transformX` methods may return `null`, to avoid creating
+ * empty geometry objects. This will be handled correctly by the transformer.
+ * The `GeometryTransformer::transform(const Geometry* nInputGeom)` method
+ * itself will always return a geometry object.
*
* @see GeometryEditor
*
@@ -105,9 +102,9 @@ protected:
const GeometryFactory* factory;
- /**
+ /** \brief
* Convenience method which provides standard way of
- * creating a {@link CoordinateSequence}
+ * creating a CoordinateSequence.
*
* @param coords the coordinate array to copy
* @return a coordinate sequence for the array
@@ -159,29 +156,29 @@ private:
// these could eventually be exposed to clients
/**
- * <code>true</code> if empty geometries should not be included in the result
+ * `true` if empty geometries should not be included in the result
*/
bool pruneEmptyGeometry;
/**
- * <code>true</code> if a homogenous collection result
+ * `true` if a homogenous collection result
* from a {@link GeometryCollection} should still
* be a general GeometryCollection
*/
bool preserveGeometryCollectionType;
/**
- * <code>true</code> if the output from a collection argument should still be a collection
+ * `true` if the output from a collection argument should still be a collection
*/
// bool preserveCollections;
/**
- * <code>true</code> if the type of the input should be preserved
+ * `true` if the type of the input should be preserved
*/
bool preserveType;
/**
- * <code>true</code> if transformed invalid interior rings should be skipped
+ * `true` if transformed invalid interior rings should be skipped
*/
bool skipTransformedInvalidInteriorRings;
diff --git a/include/geos/geomgraph/DirectedEdgeStar.h b/include/geos/geomgraph/DirectedEdgeStar.h
index c258ff8..bbdd24a 100644
--- a/include/geos/geomgraph/DirectedEdgeStar.h
+++ b/include/geos/geomgraph/DirectedEdgeStar.h
@@ -46,7 +46,7 @@ namespace geomgraph { // geos.geomgraph
/**
* \brief
- * A DirectedEdgeStar is an ordered list of <b>outgoing</b> DirectedEdges around a node.
+ * A DirectedEdgeStar is an ordered list of **outgoing** DirectedEdges around a node.
*
* It supports labelling the edges as well as linking the edges to form both
* MaximalEdgeRings and MinimalEdgeRings.
@@ -84,24 +84,23 @@ public:
DirectedEdge* getRightmostEdge();
/** \brief
- * Compute the labelling for all dirEdges in this star, as well
- * as the overall labelling
+ * Compute the labelling for all dirEdges in this star, as well as the overall labelling
*/
void computeLabelling(std::vector<GeometryGraph*>* geom) override; // throw(TopologyException *);
/** \brief
- * For each dirEdge in the star,
- * merge the label from the sym dirEdge into the label
+ * For each dirEdge in the star, merge the label from the sym dirEdge into the label
*/
void mergeSymLabels();
- /// Update incomplete dirEdge labels from the labelling for the node
+ /// \brief Update incomplete dirEdge labels from the labelling for the node
void updateLabelling(const Label& nodeLabel);
- /**
+ /** \brief
* Traverse the star of DirectedEdges, linking the included edges together.
- * To link two dirEdges, the <next> pointer for an incoming dirEdge
+ *
+ * To link two dirEdges, the `next` pointer for an incoming dirEdge
* is set to the next outgoing edge.
*
* DirEdges are only linked if:
@@ -109,10 +108,9 @@ public:
* - they belong to an area (i.e. they have sides)
* - they are marked as being in the result
*
- * Edges are linked in CCW order (the order they are stored).
- * This means that rings have their face on the Right
- * (in other words,
- * the topological location of the face is given by the RHS label of the DirectedEdge)
+ * Edges are linked in CCW order (the order they are stored). This means
+ * that rings have their face on the Right (in other words, the topological
+ * location of the face is given by the RHS label of the DirectedEdge)
*
* PRECONDITION: No pair of dirEdges are both marked as being in the result
*/
diff --git a/include/geos/geomgraph/EdgeNodingValidator.h b/include/geos/geomgraph/EdgeNodingValidator.h
index a8f0118..2c10245 100644
--- a/include/geos/geomgraph/EdgeNodingValidator.h
+++ b/include/geos/geomgraph/EdgeNodingValidator.h
@@ -76,15 +76,13 @@ private:
public:
/** \brief
- * Checks whether the supplied {@link Edge}s
- * are correctly noded.
+ * Checks whether the supplied {@link Edge}s are correctly noded.
*
- * Throws a {@link TopologyException} if they are not.
+ * Throws a [TopologyException](@ref util::TopologyException) if they are not.
*
* @param edges a collection of Edges.
* @throws TopologyException if the SegmentStrings are not
* correctly noded
- *
*/
static void
checkValid(std::vector<Edge*>& edges)
diff --git a/include/geos/geomgraph/GeometryGraph.h b/include/geos/geomgraph/GeometryGraph.h
index 311b827..a1e70f8 100644
--- a/include/geos/geomgraph/GeometryGraph.h
+++ b/include/geos/geomgraph/GeometryGraph.h
@@ -67,8 +67,8 @@ class EdgeSetIntersector;
namespace geos {
namespace geomgraph { // geos.geomgraph
-/**
- * A GeometryGraph is a graph that models a given Geometry
+/** \brief
+ * A GeometryGraph is a graph that models a given Geometry.
*/
class GEOS_DLL GeometryGraph: public PlanarGraph {
using PlanarGraph::add;
@@ -197,18 +197,17 @@ public:
/**
* \brief
- * Compute self-nodes, taking advantage of the Geometry type to
- * minimize the number of intersection tests. (E.g. rings are
- * not tested for self-intersection, since
- * they are assumed to be valid).
+ * Compute self-nodes, taking advantage of the Geometry type to minimize
+ * the number of intersection tests. (E.g. rings are not tested for
+ * self-intersection, since they are assumed to be valid).
*
* @param li the LineIntersector to use
- *
- * @param computeRingSelfNodes if <false>, intersection checks are
- * optimized to not test rings for self-intersection
+ * @param computeRingSelfNodes if `false`, intersection checks are optimized
+ * to not test rings for self-intersection
+ * @param env an Envelope
*
* @return the SegmentIntersector used, containing information about
- * the intersections found
+ * the intersections found
*/
index::SegmentIntersector*
computeSelfNodes(
diff --git a/include/geos/geomgraph/Position.h b/include/geos/geomgraph/Position.h
index 16df86e..f276013 100644
--- a/include/geos/geomgraph/Position.h
+++ b/include/geos/geomgraph/Position.h
@@ -32,29 +32,33 @@
namespace geos {
namespace geomgraph { // geos.geomgraph
+/** \brief
+ * A Position indicates the position of a Location relative to a graph
+ * component (Node, Edge, or Area).
+ */
class GEOS_DLL Position {
public:
enum {
- /*
- * An indicator that a Location is <i>on</i>
+ /** \brief
+ * An indicator that a Location is *on*
* a GraphComponent
*/
ON = 0,
- /*
+ /** \brief
* An indicator that a Location is to the
- * <i>left</i> of a GraphComponent
+ * *left* of a GraphComponent
*/
LEFT,
- /*
+ /** \brief
* An indicator that a Location is to the
- * <i>right</i> of a GraphComponent
+ * *right* of a GraphComponent
*/
RIGHT
};
- /**
+ /** \brief
* Returns LEFT if the position is RIGHT, RIGHT if
* the position is LEFT, or the position otherwise.
*/
diff --git a/include/geos/index/bintree/Bintree.h b/include/geos/index/bintree/Bintree.h
index 10141a7..3f776d2 100644
--- a/include/geos/index/bintree/Bintree.h
+++ b/include/geos/index/bintree/Bintree.h
@@ -38,34 +38,33 @@ namespace index { // geos::index
namespace bintree { // geos::index::bintree
/** \brief
- * An BinTree (or "Binary Interval Tree")
- * is a 1-dimensional version of a quadtree.
+ * A BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree.
*
- * It indexes 1-dimensional intervals (which of course may
- * be the projection of 2-D objects on an axis).
- * It supports range searching
- * (where the range may be a single point).
+ * It indexes 1-dimensional intervals (which of course may be the projection
+ * of 2-D objects on an axis). It supports range searching (where the range
+ * may be a single point).
*
* This implementation does not require specifying the extent of the inserted
- * items beforehand. It will automatically expand to accomodate any extent
+ * items beforehand. It will automatically expand to accomodate any extent
* of dataset.
*
- * This index is different to the Interval Tree of Edelsbrunner
- * or the Segment Tree of Bentley.
+ * This index is different to the "Interval Tree of Edelsbrunner"
+ * or the "Segment Tree of Bentley".
*/
class GEOS_DLL Bintree {
public:
- /**
+ /** \brief
* Ensure that the Interval for the inserted item has non-zero extents.
- * Use the current minExtent to pad it, if necessary
*
- * NOTE: in GEOS this function always return a newly allocated object
+ * Use the current minExtent to pad it, if necessary.
+ *
+ * @note In GEOS this function always return a newly allocated object
* with ownership transferred to caller. TODO: change this ?
*
- * @param itemInterval
- * Source interval, ownership left to caller, no references hold.
+ * @param itemInterval source interval, ownership left to caller, no references hold
+ * @param minExtent minimal extent
*/
static Interval* ensureExtent(const Interval* itemInterval,
double minExtent);
diff --git a/include/geos/index/chain/MonotoneChainBuilder.h b/include/geos/index/chain/MonotoneChainBuilder.h
index bcd14fe..aa82fcf 100644
--- a/include/geos/index/chain/MonotoneChainBuilder.h
+++ b/include/geos/index/chain/MonotoneChainBuilder.h
@@ -41,8 +41,8 @@ namespace index { // geos::index
namespace chain { // geos::index::chain
/** \brief
- * Constructs {@link MonotoneChain}s
- * for sequences of {@link Coordinate}s.
+ * Constructs [MonotoneChains](@ref index::chain::MonotoneChain)
+ * for sequences of [Coordinates](@ref geom::Coordinate).
*
* TODO: use vector<const Coordinate*> instead ?
*/
@@ -55,7 +55,8 @@ public:
/** \brief
* Return a newly-allocated vector of newly-allocated
* MonotoneChain objects for the given CoordinateSequence.
- * Remember to deep-delete the result.
+ *
+ * @note Remember to deep-delete the result.
*/
static std::unique_ptr<std::vector<std::unique_ptr<MonotoneChain>>> getChains(
const geom::CoordinateSequence* pts,
@@ -64,7 +65,8 @@ public:
/** \brief
* Fill the provided vector with newly-allocated MonotoneChain objects
* for the given CoordinateSequence.
- * Remember to delete vector elements!
+ *
+ * @note Remember to delete vector elements!
*/
static void getChains(const geom::CoordinateSequence* pts,
void* context,
@@ -79,9 +81,9 @@ public:
/** \brief
* Fill the given vector with start/end indexes of the monotone chains
* for the given CoordinateSequence.
+ *
* The last entry in the array points to the end point of the point
- * array,
- * for use as a sentinel.
+ * array, for use as a sentinel.
*/
static void getChainStartIndices(const geom::CoordinateSequence& pts,
std::vector<std::size_t>& startIndexList);
@@ -96,16 +98,17 @@ public:
private:
- /**
+ /** \brief
* Finds the index of the last point in a monotone chain
* starting at a given point.
+ *
* Any repeated points (0-length segments) will be included
* in the monotone chain returned.
*
* @return the index of the last point in the monotone chain
* starting at <code>start</code>.
*
- * NOTE: aborts if 'start' is >= pts.getSize()
+ * @note aborts if 'start' is >= pts.getSize()
*/
static std::size_t findChainEnd(const geom::CoordinateSequence& pts,
std::size_t start);
diff --git a/include/geos/index/chain/MonotoneChainOverlapAction.h b/include/geos/index/chain/MonotoneChainOverlapAction.h
index 893e3be..bfafc82 100644
--- a/include/geos/index/chain/MonotoneChainOverlapAction.h
+++ b/include/geos/index/chain/MonotoneChainOverlapAction.h
@@ -36,9 +36,9 @@ namespace geos {
namespace index { // geos::index
namespace chain { // geos::index::chain
-/**
+/** \brief
* The action for the internal iterator for performing
- * overlap queries on a MonotoneChain
+ * overlap queries on a MonotoneChain.
*/
class GEOS_DLL MonotoneChainOverlapAction {
@@ -55,9 +55,11 @@ public:
virtual
~MonotoneChainOverlapAction() {}
- /**
- * This function can be overridden if the original chains are needed
+ /** \brief
+ * This function can be overridden if the original chains are needed.
*
+ * @param mc1 a MonotoneChain
+ * @param mc2 a MonotoneChain
* @param start1 the index of the start of the overlapping segment
* from mc1
* @param start2 the index of the start of the overlapping segment
@@ -66,11 +68,12 @@ public:
virtual void overlap(MonotoneChain& mc1, std::size_t start1,
MonotoneChain& mc2, std::size_t start2);
- /**
+ /** \brief
* This is a convenience function which can be overridden to
- * obtain the actual line segments which overlap
- * @param seg1
- * @param seg2
+ * obtain the actual line segments which overlap.
+ *
+ * **param** `seg1`
+ * **param** `seg2`
*/
virtual void
overlap(const geom::LineSegment& /*seg1*/,
diff --git a/include/geos/index/strtree/AbstractSTRtree.h b/include/geos/index/strtree/AbstractSTRtree.h
index 589be45..d9dcf24 100644
--- a/include/geos/index/strtree/AbstractSTRtree.h
+++ b/include/geos/index/strtree/AbstractSTRtree.h
@@ -195,7 +195,7 @@ protected:
// Ownership to caller (TODO: return by unique_ptr)
virtual AbstractNode* createNode(int level) = 0;
- /**
+ /** \brief
* Sorts the childBoundables then divides them into groups of size M, where
* M is the node capacity.
*/
@@ -257,9 +257,9 @@ protected:
public:
- /**
+ /** \brief
* Constructs an AbstractSTRtree with the specified maximum number of child
- * nodes that a node may have
+ * nodes that a node may have.
*/
AbstractSTRtree(std::size_t newNodeCapacity)
:
@@ -283,16 +283,18 @@ public:
virtual ~AbstractSTRtree();
- /**
+ /** \brief
* Creates parent nodes, grandparent nodes, and so forth up to the root
- * node, for the data that has been inserted into the tree. Can only be
+ * node, for the data that has been inserted into the tree.
+ *
+ * Can only be
* called once, and thus can be called only after all of the data has been
* inserted into the tree.
*/
virtual void build();
- /**
- * Returns the maximum number of child nodes that a node may have
+ /** \brief
+ * Returns the maximum number of child nodes that a node may have.
*/
virtual std::size_t
getNodeCapacity()
@@ -303,26 +305,28 @@ public:
virtual void query(const void* searchBounds, const AbstractNode* node, std::vector<void*>* matches);
/**
- * Iterate over all items added thus far. Explicitly does not build
- * the tree.
- */
+ * Iterate over all items added thus far. Explicitly does not build
+ * the tree.
+ */
void iterate(ItemVisitor& visitor);
/**
* @param level -1 to get items
+ * @param top an AbstractNode
+ * @param boundables a BoundableList
*/
virtual void boundablesAtLevel(int level, AbstractNode* top,
BoundableList* boundables);
- /**
- * Gets a tree structure (as a nested list)
- * corresponding to the structure of the items and nodes in this tree.
- * <p>
- * The returned {@link List}s contain either {@link Object} items,
- * or Lists which correspond to subtrees of the tree
- * Subtrees which do not contain any items are not included.
- * <p>
+ /** \brief
+ * Gets a tree structure (as a nested list) corresponding to the structure
+ * of the items and nodes in this tree.
+ *
+ * The returned Lists contain either Object items, or Lists which
+ * correspond to subtrees of the tree Subtrees which do not contain
+ * any items are not included.
+ *
* Builds the tree if necessary.
*
* @note The caller is responsible for releasing the list
diff --git a/include/geos/index/strtree/BoundablePair.h b/include/geos/index/strtree/BoundablePair.h
index 5490705..4c7c62c 100644
--- a/include/geos/index/strtree/BoundablePair.h
+++ b/include/geos/index/strtree/BoundablePair.h
@@ -23,9 +23,14 @@
#include <geos/index/strtree/ItemDistance.h>
#include <queue>
+namespace geos {
+namespace index {
+namespace strtree {
+
/**
- * A pair of {@link Boundable}s, whose leaf items
- * support a distance metric between them.
+ * @brief A pair of [Boundables](@ref Boundable), whose
+ * leaf items support a distance metric between them.
+ *
* Used to compute the distance between the members,
* and to expand a member relative to the other
* in order to produce new branches of the
@@ -36,10 +41,6 @@
* @author Martin Davis
*
*/
-namespace geos {
-namespace index {
-namespace strtree {
-
class BoundablePair {
private:
const Boundable* boundable1;
@@ -68,20 +69,22 @@ public:
*/
const Boundable* getBoundable(int i) const;
- /**
+ /** \brief
* Computes the distance between the {@link Boundable}s in this pair.
* The boundables are either composites or leaves.
+ *
* If either is composite, the distance is computed as the minimum distance
* between the bounds.
- * If both are leaves, the distance is computed by {@link #itemDistance(ItemBoundable, ItemBoundable)}.
+ * If both are leaves, the distance is computed by
+ * ItemDistance::distance(const ItemBoundable* item1, const ItemBoundable* item2).
*
- * @return
+ * @return the distance between the items
*/
double distance() const;
- /**
- * Gets the minimum possible distance between the Boundables in
- * this pair.
+ /** \brief
+ * Gets the minimum possible distance between the Boundables in this pair.
+ *
* If the members are both items, this will be the
* exact distance between them.
* Otherwise, this distance will be a lower bound on
@@ -98,7 +101,7 @@ public:
*/
bool isLeaves() const;
- /**
+ /** \brief
* Computes the maximum distance between any
* two items in the pair of nodes.
*
diff --git a/include/geos/index/strtree/ItemDistance.h b/include/geos/index/strtree/ItemDistance.h
index 6a05a12..4c312c3 100644
--- a/include/geos/index/strtree/ItemDistance.h
+++ b/include/geos/index/strtree/ItemDistance.h
@@ -24,9 +24,16 @@
namespace geos {
namespace index {
namespace strtree {
+
+/** \brief
+ * A function method which computes the distance between two [ItemBoundables](\ref ItemBoundable)
+ * in an STRtree. Used for Nearest Neighbour searches.
+ *
+ * \author Martin Davis
+ */
class GEOS_DLL ItemDistance {
public:
- /**
+ /** \brief
* Computes the distance between two items.
*
* @param item1
diff --git a/include/geos/index/strtree/SIRtree.h b/include/geos/index/strtree/SIRtree.h
index 34be136..fc8ba26 100644
--- a/include/geos/index/strtree/SIRtree.h
+++ b/include/geos/index/strtree/SIRtree.h
@@ -62,6 +62,7 @@ public:
/**
* Returns items whose bounds intersect the given bounds.
* @param x1 possibly equal to x2
+ * @param x2
*/
std::vector<void*>*
query(double x1, double x2)
diff --git a/include/geos/linearref/ExtractLineByLocation.h b/include/geos/linearref/ExtractLineByLocation.h
index b278dc1..e9516ec 100644
--- a/include/geos/linearref/ExtractLineByLocation.h
+++ b/include/geos/linearref/ExtractLineByLocation.h
@@ -27,8 +27,8 @@
namespace geos {
namespace linearref { // geos::linearref
-/**
- * Extracts the subline of a linear {@link Geometry} between
+/** \brief
+ * Extracts the subline of a linear [Geometry](@ref geom::Geometry) between
* two {@link LinearLocation}s on the line.
*/
class ExtractLineByLocation {
@@ -56,9 +56,10 @@ private:
std::unique_ptr<geom::Geometry> computeLinear(const LinearLocation& start, const LinearLocation& end);
public:
- /**
- * Computes the subline of a {@link LineString} between
- * two {@link LineStringLocation}s on the line.
+ /** \brief
+ * Computes the subline of a [LineString](@ref geom::LineString) between
+ * two {@link LinearLocation}s on the line.
+ *
* If the start location is after the end location,
* the computed geometry is reversed.
*
@@ -71,9 +72,10 @@ public:
ExtractLineByLocation(const geom::Geometry* line);
- /**
+ /** \brief
* Extracts a subline of the input.
- * If <code>end < start</code> the linear geometry computed will be reversed.
+ *
+ * If `end < start` the linear geometry computed will be reversed.
*
* @param start the start location
* @param end the end location
diff --git a/include/geos/linearref/LengthIndexedLine.h b/include/geos/linearref/LengthIndexedLine.h
index ee0de1a..1516a69 100644
--- a/include/geos/linearref/LengthIndexedLine.h
+++ b/include/geos/linearref/LengthIndexedLine.h
@@ -30,8 +30,9 @@ namespace geos {
namespace linearref { // geos::linearref
/** \brief
- * Supports linear referencing along a linear {@link Geometry}
+ * Supports linear referencing along a linear geom::Geometry
* using the length along the line as the index.
+ *
* Negative length values are taken as measured in the reverse direction
* from the end of the geometry.
* Out-of-range index values are handled by clamping
@@ -50,7 +51,7 @@ private:
public:
/** \brief
- * Constructs an object which allows a linear {@link Geometry}
+ * Constructs an object which allows a linear [Geometry](@ref geom::Geometry)
* to be linearly referenced using length as an index.
*
* @param linearGeom the linear geometry to reference along
@@ -59,8 +60,9 @@ public:
LengthIndexedLine(const geom::Geometry* linearGeom);
/** \brief
- * Computes the {@link Coordinate} for the point
+ * Computes the [Coordinate](@ref geom::Coordinate) for the point
* on the line at the given index.
+ *
* If the index is out of range the first or last point on the
* line will be returned.
* The Z-ordinate of the computed point will be interpolated from
@@ -74,7 +76,7 @@ public:
/**
* \brief
- * Computes the {@link Coordinate} for the point
+ * Computes the [Coordinate](@ref geom::Coordinate) for the point
* on the line at the given index, offset by the given distance.
*
* If the index is out of range the first or last point on the
@@ -87,14 +89,15 @@ public:
*
* @param index the index of the desired point
* @param offsetDistance the distance the point is offset from the segment
- * (positive is to the left, negative is to the right)
+ * (positive is to the left, negative is to the right)
* @return the Coordinate at the given index
*/
geom::Coordinate extractPoint(double index, double offsetDistance) const;
- /**
- * Computes the {@link LineString} for the interval
+ /** \brief
+ * Computes the [LineString](@ref geom::LineString) for the interval
* on the line between the given indices.
+ *
* If the endIndex lies before the startIndex,
* the computed geometry is reversed.
*
@@ -105,13 +108,14 @@ public:
std::unique_ptr<geom::Geometry> extractLine(double startIndex, double endIndex) const;
- /**
+ /** \brief
* Computes the minimum index for a point on the line.
+ *
* If the line is not simple (i.e. loops back on itself)
* a single point may have more than one possible index.
* In this case, the smallest index is returned.
*
- * The supplied point does not <i>necessarily</i> have to lie precisely
+ * The supplied point does not *necessarily* have to lie precisely
* on the line, but if it is far from the line the accuracy and
* performance of this function is not guaranteed.
* Use {@link #project} to compute a guaranteed result for points
@@ -124,17 +128,18 @@ public:
*/
double indexOf(const geom::Coordinate& pt) const;
- /**
- * Finds the index for a point on the line
- * which is greater than the given index.
- * If no such index exists, returns <tt>minIndex</tt>.
+ /** \brief
+ * Finds the index for a point on the line which is
+ * greater than the given index.
+ *
+ * If no such index exists, returns `minIndex`.
* This method can be used to determine all indexes for
* a point which occurs more than once on a non-simple line.
* It can also be used to disambiguate cases where the given point lies
* slightly off the line and is equidistant from two different
* points on the line.
*
- * The supplied point does not <i>necessarily</i> have to lie precisely
+ * The supplied point does not `*necessarily* have to lie precisely
* on the line, but if it is far from the line the accuracy and
* performance of this function is not guaranteed.
* Use {@link #project} to compute a guaranteed result for points
@@ -148,9 +153,10 @@ public:
*/
double indexOfAfter(const geom::Coordinate& pt, double minIndex) const;
- /**
+ /** \brief
* Computes the indices for a subline of the line.
- * (The subline must <b>conform</b> to the line; that is,
+ *
+ * (The subline must **conform** to the line; that is,
* all vertices in the subline (except possibly the first and last)
* must be vertices of the line and occcur in the same order).
*
@@ -160,8 +166,9 @@ public:
double* indicesOf(const geom::Geometry* subLine) const;
- /**
+ /** \brief
* Computes the index for the closest point on the line to the given point.
+ *
* If more than one point has the closest distance the first one along the line
* is returned.
* (The point does not necessarily have to lie precisely on the line.)
@@ -171,30 +178,30 @@ public:
*/
double project(const geom::Coordinate& pt) const;
- /**
+ /** \brief
* Returns the index of the start of the line
* @return the start index
*/
double getStartIndex() const;
- /**
+ /** \brief
* Returns the index of the end of the line
* @return the end index
*/
double getEndIndex() const;
- /**
+ /** \brief
* Tests whether an index is in the valid index range for the line.
*
* @param index the index to test
- * @return <code>true</code> if the index is in the valid range
+ * @return `true` if the index is in the valid range
*/
bool isValidIndex(double index) const;
- /**
- * Computes a valid index for this line
- * by clamping the given index to the valid range of index values
+ /** \brief
+ * Computes a valid index for this line by clamping the given index
+ * to the valid range of index values.
*
* @return a valid index value
*/
diff --git a/include/geos/linearref/LengthLocationMap.h b/include/geos/linearref/LengthLocationMap.h
index cb33543..1b2a92d 100644
--- a/include/geos/linearref/LengthLocationMap.h
+++ b/include/geos/linearref/LengthLocationMap.h
@@ -29,8 +29,8 @@ namespace geos {
namespace linearref { // geos::linearref
/**
- * Computes the {@link LinearLocation} for a given length
- * along a linear {@link Geometry}.
+ * Computes the LinearLocation for a given length
+ * along a linear [Geometry](@ref geom::Geometry).
* Negative lengths are measured in reverse from end of the linear geometry.
* Out-of-range values are clamped.
*/
@@ -52,12 +52,12 @@ public:
/**
* \brief
- * Computes the {@link LinearLocation} for a
- * given length along a linear {@link Geometry}.
+ * Computes the LinearLocation for a
+ * given length along a linear [Geometry](@ref geom::Geometry).
*
- * @param line the linear geometry to use
+ * @param linearGeom the linear geometry to use
* @param length the length index of the location
- * @return the {@link LinearLocation} for the length
+ * @return the LinearLocation for the length
*/
static LinearLocation
getLocation(const geom::Geometry* linearGeom, double length)
@@ -68,14 +68,14 @@ public:
/**
* \brief
- * Computes the {@link LinearLocation} for a
- * given length along a linear {@link Geometry}.
+ * Computes the LinearLocation for a
+ * given length along a linear [Geometry].
*
- * @param line the linear geometry to use
+ * @param linearGeom the linear geometry to use
* @param length the length index of the location
- * @param resolveLower if true lengths are resolved to the
+ * @param resolveLower if `true` lengths are resolved to the
* lowest possible index
- * @return the {@link LinearLocation} for the length
+ * @return the LinearLocation for the length
*/
static LinearLocation
getLocation(const geom::Geometry* linearGeom, double length, bool resolveLower)
@@ -85,12 +85,12 @@ public:
}
/**
- * Computes the length for a given {@link LinearLocation}
- * on a linear {@link Geometry}.
+ * Computes the length for a given LinearLocation
+ * on a linear [Geometry](@ref geom::Geometry).
*
- * @param line the linear geometry to use
- * @param loc the {@link LinearLocation} index of the location
- * @return the length for the {@link LinearLocation}
+ * @param linearGeom the linear geometry to use
+ * @param loc the LinearLocation index of the location
+ * @return the length for the LinearLocation
*/
static double getLength(const geom::Geometry* linearGeom, const LinearLocation& loc);
@@ -98,21 +98,23 @@ public:
/**
* \brief
- * Compute the {@link LinearLocation} corresponding to a length.
+ * Compute the LinearLocation corresponding to a length.
*
* Negative lengths are measured in reverse from end of the linear geometry.
* Out-of-range values are clamped.
* Ambiguous indexes are resolved to the lowest possible location value,
- * depending on the value of <tt>resolveLower</tt>.
+ * depending on the value of `resolveLower`.
*
* @param length the length index
+ * @param resolveLower if `true` lengths are resolved to the
+ * lowest possible index
* @return the corresponding LinearLocation
*/
LinearLocation getLocation(double length, bool resolveLower) const;
/**
* \brief
- * Compute the {@link LinearLocation} corresponding to a length.
+ * Compute the LinearLocation corresponding to a length.
*
* Negative lengths are measured in reverse from end of the linear geometry.
* Out-of-range values are clamped.
diff --git a/include/geos/linearref/LinearGeometryBuilder.h b/include/geos/linearref/LinearGeometryBuilder.h
index b96750a..3201863 100644
--- a/include/geos/linearref/LinearGeometryBuilder.h
+++ b/include/geos/linearref/LinearGeometryBuilder.h
@@ -31,9 +31,9 @@
namespace geos {
namespace linearref { // geos::linearref
-/**
- * Builds a linear geometry ({@link LineString} or {@link MultiLineString})
- * incrementally (point-by-point).
+/** \brief
+ * Builds a linear geometry ([LineString](@ref geom::LineString) or
+ * [MultiLineString](@ref geom::MultiLineString)) incrementally (point-by-point).
*
* @version 1.7
*/
@@ -57,39 +57,43 @@ public:
~LinearGeometryBuilder();
- /**
+ /** \brief
* Allows invalid lines to be ignored rather than causing Exceptions.
+ *
* An invalid line is one which has only one unique point.
*
- * @param ignoreInvalidLines <code>true</code> if short lines are
+ * @param ignoreInvalidLines `true` if short lines are
* to be ignored
*/
void setIgnoreInvalidLines(bool ignoreInvalidLines);
- /**
+ /** \brief
* Allows invalid lines to be ignored rather than causing Exceptions.
+ *
* An invalid line is one which has only one unique point.
*
- * @param fixInvalidLines <code>true</code> if short lines are
+ * @param fixInvalidLines `true` if short lines are
* to be ignored
*/
void setFixInvalidLines(bool fixInvalidLines);
- /**
+ /** \brief
* Adds a point to the current line.
*
* @param pt the Coordinate to add
*/
void add(const geom::Coordinate& pt);
- /**
+ /** \brief
* Adds a point to the current line.
*
* @param pt the Coordinate to add
+ * @param allowRepeatedPoints if set to `false`, repeated coordinates are
+ * collapsed
*/
void add(const geom::Coordinate& pt, bool allowRepeatedPoints);
- /// NOTE strk: why return by value ?
+ // NOTE strk: why return by value ?
geom::Coordinate getLastCoordinate() const;
/// Terminate the current LineString.
diff --git a/include/geos/linearref/LinearIterator.h b/include/geos/linearref/LinearIterator.h
index be4ffe9..ad2318d 100644
--- a/include/geos/linearref/LinearIterator.h
+++ b/include/geos/linearref/LinearIterator.h
@@ -36,38 +36,38 @@ namespace linearref {
*
* The standard usage pattern for a LinearIterator is:
*
- * <pre>
+ * ~~~~~~
* for (LinearIterator it = new LinearIterator(...); it.hasNext(); it.next()) {
* ...
* int ci = it.getComponentIndex(); // for example
* int vi = it.getVertexIndex(); // for example
* ...
* }
- * </pre>
+ * ~~~~~~
*
* @version 1.7
*/
class LinearIterator {
public:
- /**
+ /** \brief
* Creates an iterator initialized to the start of a linear Geometry
*
* @param linear the linear geometry to iterate over
*/
LinearIterator(const geom::Geometry* linear);
- /**
+ /** \brief
* Creates an iterator starting at
- * a {@link LinearLocation} on a linear {@link Geometry}
+ * a LinearLocation on a linear geom::Geometry
*
* @param linear the linear geometry to iterate over
* @param start the location to start at
*/
LinearIterator(const geom::Geometry* linear, const LinearLocation& start);
- /**
- * Creates an iterator starting at
- * a component and vertex in a linear {@link Geometry}
+ /** \brief
+ * Creates an iterator starting at a component and vertex in a
+ * linear geom::Geometry
*
* @param linear the linear geometry to iterate over
* @param componentIndex the component to start at
@@ -75,57 +75,57 @@ public:
*/
LinearIterator(const geom::Geometry* linear, size_t componentIndex, size_t vertexIndex);
- /**
+ /** \brief
* Tests whether there are any vertices left to iterator over.
- * @return <code>true</code> if there are more vertices to scan
+ * @return `true` if there are more vertices to scan
*/
bool hasNext() const;
- /**
+ /** \brief
* Moves the iterator ahead to the next vertex and (possibly) linear component.
*/
void next();
- /**
+ /** \brief
* Checks whether the iterator cursor is pointing to the
- * endpoint of a component {@link LineString}.
+ * endpoint of a component geom::LineString.
*
- * @return <code>true</true> if the iterator is at an endpoint
+ * @return `true` if the iterator is at an endpoint
*/
bool isEndOfLine() const;
- /**
+ /** \brief
* The component index of the vertex the iterator is currently at.
* @return the current component index
*/
size_t getComponentIndex() const;
- /**
+ /** \brief
* The vertex index of the vertex the iterator is currently at.
* @return the current vertex index
*/
size_t getVertexIndex() const;
- /**
- * Gets the {@link LineString} component the iterator is current at.
+ /** \brief
+ * Gets the geom::LineString component the iterator is current at.
* @return a linestring
*/
const geom::LineString* getLine() const;
- /**
- * Gets the first {@link Coordinate} of the current segment.
+ /** \brief
+ * Gets the first geom::Coordinate of the current segment.
* (the coordinate of the current vertex).
- * @return a {@link Coordinate}
+ * @return a Coordinate
*/
geom::Coordinate getSegmentStart() const;
- /**
- * Gets the second {@link Coordinate} of the current segment.
+ /** \brief
+ * Gets the second geom::Coordinate of the current segment.
* (the coordinate of the next vertex).
- * If the iterator is at the end of a line, <code>null</code> is returned.
+ * If the iterator is at the end of a line, `null` is returned.
*
- * @return a {@link Coordinate} or <code>null</code>
+ * @return a Coordinate or `null`
*/
geom::Coordinate getSegmentEnd() const;
diff --git a/include/geos/linearref/LinearLocation.h b/include/geos/linearref/LinearLocation.h
index 3f8f77b..2d78102 100644
--- a/include/geos/linearref/LinearLocation.h
+++ b/include/geos/linearref/LinearLocation.h
@@ -33,12 +33,13 @@ namespace linearref { // geos::linearref
/** \brief
- * Represents a location along a {@link LineString} or {@link MultiLineString}.
+ * Represents a location along a [LineString](@ref geom::LineString)
+ * or [MultiLineString](@ref geom::MultiLineString).
*
- * The referenced geometry is not maintained within
- * this location, but must be provided for operations which require it.
- * Various methods are provided to manipulate the location value
- * and query the geometry it references.
+ * The referenced geometry is not maintained within this location, but
+ * must be provided for operations which require it.
+ * Various methods are provided to manipulate the location value and
+ * query the geometry it references.
*/
class LinearLocation {
private:
@@ -46,9 +47,10 @@ private:
size_t segmentIndex;
double segmentFraction;
- /**
+ /** \brief
* Ensures the individual values are locally valid.
- * Does <b>not</b> ensure that the indexes are valid for
+ *
+ * Does **not** ensure that the indexes are valid for
* a particular linear geometry.
*
* @see clamp
@@ -56,16 +58,19 @@ private:
void normalize();
public:
- /**
- * Gets a location which refers to the end of a linear {@link Geometry}.
+ /** \brief
+ * Gets a location which refers to the end of a linear
+ * [Geometry](@ref geom::Geometry).
+ *
* @param linear the linear geometry
- * @return a new <tt>LinearLocation</tt>
+ * @return a new `LinearLocation`
*/
static LinearLocation getEndLocation(const geom::Geometry* linear);
- /**
- * Computes the {@link Coordinate} of a point a given fraction
- * along the line segment <tt>(p0, p1)</tt>.
+ /** \brief
+ * Computes the [Coordinate](@ref geom::Coordinate) of a point a given
+ * fraction along the line segment `(p0, p1)`.
+ *
* If the fraction is greater than 1.0 the last
* point of the segment is returned.
* If the fraction is less than or equal to 0.0 the first point
@@ -76,37 +81,36 @@ public:
* @param p0 the first point of the line segment
* @param p1 the last point of the line segment
* @param frac the length to the desired point
- * @return the <tt>Coordinate</tt> of the desired point
+ * @return the Coordinate of the desired point
*/
static geom::Coordinate pointAlongSegmentByFraction(const geom::Coordinate& p0, const geom::Coordinate& p1,
double frac);
- /**
+ /** \brief
* Creates a location referring to the start of a linear geometry
*/
LinearLocation(size_t segmentIndex = 0, double segmentFraction = 0.0);
LinearLocation(size_t componentIndex, size_t segmentIndex, double segmentFraction);
- /**
- * Ensures the indexes are valid for a given linear {@link Geometry}.
+ /** \brief
+ * Ensures the indexes are valid for a given linear [Geometry](@ref geom::Geometry).
*
* @param linear a linear geometry
*/
void clamp(const geom::Geometry* linear);
- /**
- * Snaps the value of this location to
- * the nearest vertex on the given linear {@link Geometry},
- * if the vertex is closer than <tt>minDistance</tt>.
+ /** \brief
+ * Snaps the value of this location to the nearest vertex on the given linear
+ * [Geometry](@ref geom::Geometry), if the vertex is closer than `minDistance`.
*
* @param linearGeom a linear geometry
* @param minDistance the minimum allowable distance to a vertex
*/
void snapToVertex(const geom::Geometry* linearGeom, double minDistance);
- /**
+ /** \brief
* Gets the length of the segment in the given
* Geometry containing this location.
*
@@ -115,92 +119,91 @@ public:
*/
double getSegmentLength(const geom::Geometry* linearGeom) const;
- /**
+ /** \brief
* Sets the value of this location to
- * refer the end of a linear geometry
+ * refer the end of a linear geometry.
*
* @param linear the linear geometry to set
*/
void setToEnd(const geom::Geometry* linear);
- /**
+ /** \brief
* Gets the component index for this location.
*
* @return the component index
*/
size_t getComponentIndex() const;
- /**
- * Gets the segment index for this location
+ /** \brief
+ * Gets the segment index for this location.
*
* @return the segment index
*/
size_t getSegmentIndex() const;
- /**
- * Gets the segment fraction for this location
+ /** \brief
+ * Gets the segment fraction for this location.
*
* @return the segment fraction
*/
double getSegmentFraction() const;
- /**
- * Tests whether this location refers to a vertex
+ /** \brief
+ * Tests whether this location refers to a vertex.
*
* @return true if the location is a vertex
*/
bool isVertex() const;
- /**
- * Gets the {@link Coordinate} along the
- * given linear {@link Geometry} which is
- * referenced by this location.
+ /** \brief
+ * Gets the [Coordinate](@ref geom::Coordinate) along the given linear
+ * [Geometry](@ref geom::Geometry) which is referenced by this location.
*
* @param linearGeom the linear geometry referenced by this location
- * @return the <tt>Coordinate</tt> at the location
+ * @return the Coordinate at the location
*/
geom::Coordinate getCoordinate(const geom::Geometry* linearGeom) const;
- /**
- * Gets a {@link LineSegment} representing the segment of the
- * given linear {@link Geometry} which contains this location.
+ /** \brief
+ * Gets a [LineSegment](@ref geom::LineSegment) representing the segment of the
+ * given linear [Geometry](@ref geom::Geometry) which contains this location.
*
* @param linearGeom a linear geometry
- * @return the <tt>LineSegment</tt> containing the location
+ * @return the LineSegment containing the location
*/
std::unique_ptr<geom::LineSegment> getSegment(const geom::Geometry* linearGeom) const;
- /**
+ /** \brief
* Tests whether this location refers to a valid
- * location on the given linear {@link Geometry}.
+ * location on the given linear [Geometry](@ref geom::Geometry).
*
* @param linearGeom a linear geometry
* @return true if this location is valid
*/
bool isValid(const geom::Geometry* linearGeom) const;
- /**
- * Compares this object with the specified object for order.
+ /** \brief
+ * Compares this object with the specified object for order.
*
- *@param other the <code>LineStringLocation</code> with which this <code>Coordinate</code>
- * is being compared
- *@return a negative integer, zero, or a positive integer as this <code>LineStringLocation</code>
- * is less than, equal to, or greater than the specified <code>LineStringLocation</code>
+ * @param other the LinearLocation with which this Coordinate is being compared
+ * @return a negative integer, zero, or a positive integer as this
+ * LinearLocation is less than, equal to, or greater than
+ * the specified LinearLocation
*/
int compareTo(const LinearLocation& other) const;
- /**
+ /** \brief
* Compares this object with the specified index values for order.
*
* @param componentIndex1 a component index
* @param segmentIndex1 a segment index
* @param segmentFraction1 a segment fraction
- * @return a negative integer, zero, or a positive integer as this <code>LineStringLocation</code>
- * is less than, equal to, or greater than the specified locationValues
+ * @return a negative integer, zero, or a positive integer as this LinearLocation
+ * is less than, equal to, or greater than the specified locationValues
*/
int compareLocationValues(size_t componentIndex1, size_t segmentIndex1, double segmentFraction1) const;
- /**
+ /** \brief
* Compares two sets of location values for order.
*
* @param componentIndex0 a component index
@@ -209,17 +212,17 @@ public:
* @param componentIndex1 another component index
* @param segmentIndex1 another segment index
* @param segmentFraction1 another segment fraction
- *@return a negative integer, zero, or a positive integer
- * as the first set of location values
- * is less than, equal to, or greater than the second set of locationValues
+ * @return a negative integer, zero, or a positive integer
+ * as the first set of location values
+ * is less than, equal to, or greater than the second set of locationValues
*/
static int compareLocationValues(
size_t componentIndex0, size_t segmentIndex0, double segmentFraction0,
size_t componentIndex1, size_t segmentIndex1, double segmentFraction1);
- /**
- * Tests whether two locations
- * are on the same segment in the parent {@link Geometry}.
+ /** \brief
+ * Tests whether two locations are on the same
+ * segment in the parent [Geometry](@ref geom::Geometry).
*
* @param loc a location on the same geometry
* @return true if the locations are on the same segment of the parent geometry
diff --git a/include/geos/linearref/LocationIndexOfLine.h b/include/geos/linearref/LocationIndexOfLine.h
index ea179d2..f7a3b3d 100644
--- a/include/geos/linearref/LocationIndexOfLine.h
+++ b/include/geos/linearref/LocationIndexOfLine.h
@@ -27,37 +27,38 @@
namespace geos {
namespace linearref { // geos::linearref
-/**
- * Determines the location of a subline along a linear {@link Geometry}.
+/** \brief
+ * Determines the location of a subline along a linear [Geometry](@ref geom::Geometry).
+ *
* The location is reported as a pair of {@link LinearLocation}s.
- * <p>
- * <b>Note:</b> Currently this algorithm is not guaranteed to
- * return the correct substring in some situations where
- * an endpoint of the test line occurs more than once in the input line.
- * (However, the common case of a ring is always handled correctly).
+ *
+ * @note Currently this algorithm is not guaranteed to
+ * return the correct substring in some situations where
+ * an endpoint of the test line occurs more than once in the input line.
+ * (However, the common case of a ring is always handled correctly).
*/
class LocationIndexOfLine {
/**
- * MD - this algorithm has been extracted into a class
- * because it is intended to validate that the subline truly is a subline,
- * and also to use the internal vertex information to unambiguously locate the subline.
- */
+ * MD - this algorithm has been extracted into a class
+ * because it is intended to validate that the subline truly is a subline,
+ * and also to use the internal vertex information to unambiguously locate the subline.
+ */
private:
const geom::Geometry* linearGeom;
public:
/** \brief
- * Determines the location of a subline along a linear {@link Geometry}.
+ * Determines the location of a subline along a linear [Geometry](@ref geom::Geometry).
*
- * The location is reported as a pair of {@link LinearLocation}s.
+ * The location is reported as a pair of [LinearLocations](@ref LinearLocation).
*
- * <b>Note:</b> Currently this algorithm is not guaranteed to
- * return the correct substring in some situations where
- * an endpoint of the test line occurs more than once in the input line.
- * (However, the common case of a ring is always handled correctly).
+ * @note Currently this algorithm is not guaranteed to
+ * return the correct substring in some situations where
+ * an endpoint of the test line occurs more than once in the input line.
+ * (However, the common case of a ring is always handled correctly).
*
- * Caller must take of releasing with delete[]
+ * @note Caller must take of releasing with delete[]
*
*/
static LinearLocation* indicesOf(const geom::Geometry* linearGeom, const geom::Geometry* subLine);
diff --git a/include/geos/linearref/LocationIndexOfPoint.h b/include/geos/linearref/LocationIndexOfPoint.h
index 330ac85..6036edb 100644
--- a/include/geos/linearref/LocationIndexOfPoint.h
+++ b/include/geos/linearref/LocationIndexOfPoint.h
@@ -28,12 +28,12 @@
namespace geos {
namespace linearref { // geos::linearref
-/**
- * Computes the {@link LinearLocation} of the point
- * on a linear {@link Geometry} nearest a given {@link Coordinate}.
- * The nearest point is not necessarily unique; this class
- * always computes the nearest point closest to
- * the start of the geometry.
+/** \brief
+ * Computes the LinearLocation of the point on a linear [Geometry](@ref geom::Geometry)
+ * nearest a given [Coordinate](@ref geom::Coordinate).
+ *
+ * The nearest point is not necessarily unique; this class always computes
+ * the nearest point closest to the start of the geometry.
*/
class LocationIndexOfPoint {
@@ -50,26 +50,26 @@ public:
LocationIndexOfPoint(const geom::Geometry* linearGeom);
- /**
- * Find the nearest location along a linear {@link Geometry} to a given point.
+ /** \brief
+ * Find the nearest location along a linear [Geometry](@ref geom::Geometry)
+ * to a given point.
*
* @param inputPt the coordinate to locate
* @return the location of the nearest point
*/
LinearLocation indexOf(const geom::Coordinate& inputPt) const;
- /**
- * Find the nearest {@link LinearLocation} along the linear {@link Geometry}
- * to a given {@link Coordinate}
- * after the specified minimum {@link LinearLocation}.
+
+ /** \brief
+ * Find the nearest LinearLocation along the linear [Geometry](@ref geom::Geometry)
+ * to a given [Coordinate](@ref geom::Coordinate) after the specified minimum LinearLocation.
+ *
* If possible the location returned will be strictly greater than the
- * <code>minLocation</code>.
- * If this is not possible, the
- * value returned will equal <code>minLocation</code>.
- * (An example where this is not possible is when
- * minLocation = [end of line] ).
+ * `minLocation`.
+ * If this is not possible, the value returned will equal `minLocation`.
+ * (An example where this is not possible is when `minLocation = [end of line]`).
*
* @param inputPt the coordinate to locate
- * @param minLocation the minimum location for the point location
+ * @param minIndex the minimum location for the point location
* @return the location of the nearest point
*/
LinearLocation indexOfAfter(const geom::Coordinate& inputPt, const LinearLocation* minIndex) const;
diff --git a/include/geos/linearref/LocationIndexedLine.h b/include/geos/linearref/LocationIndexedLine.h
index 1dd90d6..bd65911 100644
--- a/include/geos/linearref/LocationIndexedLine.h
+++ b/include/geos/linearref/LocationIndexedLine.h
@@ -33,9 +33,9 @@ namespace linearref { // geos::linearref
/**
* \brief
- * Supports linear referencing
- * along a linear {@link Geometry}
- * using {@link LinearLocation}s as the index.
+ * Supports linear referencing along a linear
+ * [Geometry](@ref geom::Geometry) using
+ * [LinearLocations](@ref LinearLocation) as the index.
*/
class GEOS_DLL LocationIndexedLine {
private:
@@ -54,9 +54,9 @@ public:
/**
* \brief
* Constructs an object which allows linear referencing along
- * a given linear {@link Geometry}.
+ * a given linear [Geometry](@ref geom::Geometry).
*
- * @param linearGeom the linear geometry to reference along
+ * @param p_linearGeom the linear geometry to reference along
*/
LocationIndexedLine(const geom::Geometry* p_linearGeom)
: linearGeom(p_linearGeom)
@@ -66,7 +66,7 @@ public:
/**
* \brief
- * Computes the {@link Coordinate} for the point
+ * Computes the [Coordinate](@ref geom::Coordinate) for the point
* on the line at the given index.
*
* If the index is out of range the first or last point on the
@@ -86,7 +86,7 @@ public:
/**
* \brief
- * Computes the {@link Coordinate} for the point
+ * Computes the [Coordinate](@ref geom::Coordinate) for the point
* on the line at the given index, offset by the given distance.
*
* If the index is out of range the first or last point on the
@@ -99,7 +99,7 @@ public:
*
* @param index the index of the desired point
* @param offsetDistance the distance the point is offset from the segment
- * (positive is to the left, negative is to the right)
+ * (positive is to the left, negative is to the right)
* @return the Coordinate at the given index
*/
geom::Coordinate
@@ -115,7 +115,7 @@ public:
/**
* \brief
- * Computes the {@link LineString} for the interval
+ * Computes the [LineString](@ref geom::LineString) for the interval
* on the line between the given indices.
*
* If the endIndex lies before the startIndex,
@@ -249,7 +249,7 @@ public:
* Tests whether an index is in the valid index range for the line.
*
* @param index the index to test
- * @return <code>true</code> if the index is in the valid range
+ * @return `true` if the index is in the valid range
*/
bool
isValidIndex(const LinearLocation& index) const
diff --git a/include/geos/noding/BasicSegmentString.h b/include/geos/noding/BasicSegmentString.h
index aad4bc0..f5a5342 100644
--- a/include/geos/noding/BasicSegmentString.h
+++ b/include/geos/noding/BasicSegmentString.h
@@ -37,24 +37,22 @@ namespace algorithm {
namespace geos {
namespace noding { // geos.noding
-/**
- * Represents a list of contiguous line segments,
- * and supports noding the segments.
- * The line segments are represented by an array of {@link Coordinate}s.
- * Intended to optimize the noding of contiguous segments by
- * reducing the number of allocated objects.
- * SegmentStrings can carry a context object, which is useful
- * for preserving topological or parentage information.
+/** \brief
+ * Represents a list of contiguous line segments, and supports noding the segments.
+ *
+ * The line segments are represented by an array of [Coordinates](@ref geom::Coordinate).
+ * Intended to optimize the noding of contiguous segments by reducing the number
+ * of allocated objects. SegmentStrings can carry a context object, which is
+ * useful for preserving topological or parentage information.
* All noded substrings are initialized with the same context object.
*/
class GEOS_DLL BasicSegmentString : public SegmentString {
public:
- /// Construct a BasicSegmentString.
- //
- /// @param newPts CoordinateSequence representing the string,
- /// externally owned
+ /// \brief Construct a BasicSegmentString.
+ ///
+ /// @param newPts CoordinateSequence representing the string, externally owned
/// @param newContext the context associated to this SegmentString
///
BasicSegmentString(geom::CoordinateSequence* newPts,
@@ -67,23 +65,23 @@ public:
~BasicSegmentString() override
{}
- /// see dox in SegmentString.h
+ // see dox in SegmentString.h
size_t
size() const override
{
return pts->size();
}
- /// see dox in SegmentString.h
+ // see dox in SegmentString.h
const geom::Coordinate& getCoordinate(size_t i) const override;
- /// see dox in SegmentString.h
+ /// @see SegmentString::getCoordinates() const
geom::CoordinateSequence* getCoordinates() const override;
- /// see dox in SegmentString.h
+ // see dox in SegmentString.h
bool isClosed() const override;
- /// see dox in SegmentString.h
+ // see dox in SegmentString.h
std::ostream& print(std::ostream& os) const override;
/** \brief
diff --git a/include/geos/noding/FastNodingValidator.h b/include/geos/noding/FastNodingValidator.h
index 9347007..de9184e 100644
--- a/include/geos/noding/FastNodingValidator.h
+++ b/include/geos/noding/FastNodingValidator.h
@@ -42,10 +42,10 @@ namespace noding { // geos.noding
* Indexing is used to improve performance.
* By default validation stops after a single
* non-noded intersection is detected.
- * Alternatively, it can be requested to detect all intersections
- * by using {@link #setFindAllIntersections(boolean)}.
+ * Alternatively, it can be requested to detect all intersections by
+ * using `setFindAllIntersections(boolean)`.
*
-* The validator does not check for topology collapse situations
+ * The validator does not check for topology collapse situations
* (e.g. where two segment strings are fully co-incident).
*
* The validator checks for the following situations which indicated incorrect noding:
@@ -54,7 +54,7 @@ namespace noding { // geos.noding
* - Intersections at an interior vertex (i.e. with an endpoint or another interior vertex)
*
* The client may either test the {@link #isValid()} condition,
- * or request that a suitable {@link TopologyException} be thrown.
+ * or request that a suitable [TopologyException](@ref util::TopologyException) be thrown.
*
*/
class FastNodingValidator {
@@ -70,7 +70,7 @@ public:
{
}
- /**
+ /** \brief
* Checks for an intersection and
* reports if one is found.
*
@@ -83,7 +83,7 @@ public:
return isValidVar;
}
- /**
+ /** \brief
* Returns an error message indicating the segments containing
* the intersection.
*
@@ -91,7 +91,7 @@ public:
*/
std::string getErrorMessage() const;
- /**
+ /** \brief
* Checks for an intersection and throws
* a TopologyException if one is found.
*
diff --git a/include/geos/noding/FastSegmentSetIntersectionFinder.h b/include/geos/noding/FastSegmentSetIntersectionFinder.h
index 6a4770e..91bbb42 100644
--- a/include/geos/noding/FastSegmentSetIntersectionFinder.h
+++ b/include/geos/noding/FastSegmentSetIntersectionFinder.h
@@ -39,7 +39,7 @@ namespace geos {
namespace noding { // geos::noding
/** \brief
- * Finds if two sets of {@link SegmentStrings}s intersect.
+ * Finds if two sets of [SegmentStrings](@ref noding::SegmentString) intersect.
*
* Uses indexing for fast performance and to optimize repeated tests
* against a target set of lines.
diff --git a/include/geos/noding/IntersectionAdder.h b/include/geos/noding/IntersectionAdder.h
index 79cca47..89a2549 100644
--- a/include/geos/noding/IntersectionAdder.h
+++ b/include/geos/noding/IntersectionAdder.h
@@ -46,13 +46,15 @@ class LineIntersector;
namespace geos {
namespace noding { // geos.noding
-/**
+/** \brief
* Computes the intersections between two line segments in SegmentString
* and adds them to each string.
- * The {@link SegmentIntersector} is passed to a {@link Noder}.
- * The {@link addIntersections} method is called whenever the {@link Noder}
- * detects that two SegmentStrings <i>might</i> intersect.
- * This class is an example of the <i>Strategy</i> pattern.
+ *
+ * The SegmentIntersector is passed to a Noder.
+ * The NodedSegmentString::addIntersections(algorithm::LineIntersector* li, size_t segmentIndex, size_t geomIndex)
+ * method is called whenever the Noder
+ * detects that two SegmentStrings *might* intersect.
+ * This class is an example of the *Strategy* pattern.
*
*/
class GEOS_DLL IntersectionAdder: public SegmentIntersector {
@@ -118,7 +120,7 @@ public:
}
/**
- * @return the proper intersection point, or <code>NULL</code>
+ * @return the proper intersection point, or `NULL`
* if none was found
*/
const geom::Coordinate*
@@ -133,13 +135,14 @@ public:
return hasIntersectionVar;
}
- /**
+ /** \brief
* A proper intersection is an intersection which is interior to
- * at least two line segments. Note that a proper intersection
- * is not necessarily in the interior of the entire Geometry,
- * since another edge may have an endpoint equal to the intersection,
- * which according to SFS semantics can result in the point being
- * on the Boundary of the Geometry.
+ * at least two line segments.
+ *
+ * Note that a proper intersection is not necessarily in the interior
+ * of the entire Geometry, since another edge may have an endpoint equal
+ * to the intersection, which according to SFS semantics can result in
+ * the point being on the Boundary of the Geometry.
*/
bool
hasProperIntersection()
@@ -147,10 +150,9 @@ public:
return hasProper;
}
- /**
+ /** \brief
* A proper interior intersection is a proper intersection which is
- * <b>not</b> contained in the set of boundary nodes set for this
- * SegmentIntersector.
+ * *not* contained in the set of boundary nodes set for this SegmentIntersector.
*/
bool
hasProperInteriorIntersection()
@@ -158,7 +160,7 @@ public:
return hasProperInterior;
}
- /**
+ /** \brief
* An interior intersection is an intersection which is
* in the interior of some segment.
*/
@@ -169,11 +171,10 @@ public:
}
- /**
- * This method is called by clients
- * of the {@link SegmentIntersector} class to process
- * intersections for two segments of the SegmentStrings being
- * intersected.
+ /** \brief
+ * This method is called by clients of the SegmentIntersector class to
+ * process intersections for two segments of the SegmentStrings being intersected.
+ *
* Note that some clients (such as MonotoneChains) may optimize away
* this call for segment pairs which they have determined do not
* intersect (e.g. by an disjoint envelope test).
@@ -189,8 +190,8 @@ public:
return (i1 > i2 ? i1 - i2 : i2 - i1) == 1;
}
- /**
- * Always process all intersections
+ /** \brief
+ * Always process all intersections.
*
* @return false always
*/
diff --git a/include/geos/noding/IntersectionFinderAdder.h b/include/geos/noding/IntersectionFinderAdder.h
index f18dec2..198fb4d 100644
--- a/include/geos/noding/IntersectionFinderAdder.h
+++ b/include/geos/noding/IntersectionFinderAdder.h
@@ -54,7 +54,7 @@ class GEOS_DLL IntersectionFinderAdder: public SegmentIntersector {
public:
- /**
+ /** \brief
* Creates an intersection finder which finds all proper intersections
* and stores them in the provided Coordinate array
*
@@ -68,12 +68,12 @@ public:
interiorIntersections(v)
{}
- /**
- * This method is called by clients
- * of the {@link SegmentIntersector} class to process
- * intersections for two segments of the {@link SegmentStrings}
- * being intersected.
- * Note that some clients (such as {@link MonotoneChain}s) may
+ /** \brief
+ * This method is called by clients of the SegmentIntersector
+ * class to process intersections for two segments of the
+ * {@link SegmentString}s being intersected.
+ *
+ * Note that some clients (such as `MonotoneChains`) may
* optimize away this call for segment pairs which they have
* determined do not intersect
* (e.g. by an disjoint envelope test).
diff --git a/include/geos/noding/IteratedNoder.h b/include/geos/noding/IteratedNoder.h
index 90cb2ea..54d0c37 100644
--- a/include/geos/noding/IteratedNoder.h
+++ b/include/geos/noding/IteratedNoder.h
@@ -48,7 +48,7 @@ namespace noding { // geos::noding
* intersections are detected.
*
* Iterated noding using a FLOATING precision model is not guaranteed to converge,
- * due to roundoff error. This problem is detected and an exception is thrown.
+ * due to roundoff error. This problem is detected and an exception is thrown.
* Clients can choose to rerun the noding using a lower precision model.
*
*/
@@ -82,9 +82,10 @@ public:
~IteratedNoder() override {}
- /**
+ /** \brief
* Sets the maximum number of noding iterations performed before
* the noding is aborted.
+ *
* Experience suggests that this should rarely need to be changed
* from the default.
* The default is MAX_ITER.
@@ -104,13 +105,13 @@ public:
}
- /**
- * Fully nodes a list of {@link SegmentStrings}, i.e. peforms noding iteratively
+ /** \brief
+ * Fully nodes a list of {@link SegmentString}s, i.e. peforms noding iteratively
* until no intersections are found between segments.
- * Maintains labelling of edges correctly through
- * the noding.
*
- * @param segStrings a collection of SegmentStrings to be noded
+ * Maintains labelling of edges correctly through the noding.
+ *
+ * @param inputSegmentStrings a collection of SegmentStrings to be noded
* @throws TopologyException if the iterated noding fails to converge.
*/
void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override; // throw(GEOSException);
diff --git a/include/geos/noding/MCIndexNoder.h b/include/geos/noding/MCIndexNoder.h
index d5ba28c..00d2431 100644
--- a/include/geos/noding/MCIndexNoder.h
+++ b/include/geos/noding/MCIndexNoder.h
@@ -52,11 +52,12 @@ namespace noding { // geos.noding
/** \brief
* Nodes a set of SegmentString using a index based
- * on index::chain::MonotoneChain and a index::SpatialIndex.
+ * on [MonotoneChain](@ref index::chain::MonotoneChain)
+ * and a [SpatialIndex](@ref index::SpatialIndex).
*
- * The {@link SpatialIndex} used should be something that supports
- * envelope (range) queries efficiently (such as a index::quadtree::Quadtree
- * or index::strtree::STRtree.
+ * The [SpatialIndex](@ref index::SpatialIndex) used should be something that supports
+ * envelope (range) queries efficiently (such as a [Quadtree](@ref index::quadtree::Quadtree)
+ * or [STRtree](@ref index::strtree::STRtree)).
*
* Last port: noding/MCIndexNoder.java rev. 1.4 (JTS-1.7)
*/
@@ -86,7 +87,7 @@ public:
~MCIndexNoder() override;
- /// Return a reference to this instance's std::vector of MonotoneChains
+ /// \brief Return a reference to this instance's std::vector of MonotoneChains
std::vector<index::chain::MonotoneChain*>&
getMonotoneChains()
{
diff --git a/include/geos/noding/MCIndexSegmentSetMutualIntersector.h b/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
index aed9dc5..888e837 100644
--- a/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
+++ b/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
@@ -46,8 +46,9 @@ namespace geos {
namespace noding { // geos::noding
/** \brief
- * Intersects two sets of {@link SegmentStrings} using a index based
- * on {@link MonotoneChain}s and a {@link SpatialIndex}.
+ * Intersects two sets of [SegmentStrings](@ref SegmentString) using a index based
+ * on [MonotoneChains](@ref index::chain::MonotoneChain) and a
+ * [SpatialIndex](@ref index::SpatialIndex).
*
* @version 1.7
*/
@@ -99,9 +100,9 @@ private:
MonoChains monoChains;
/*
- * The {@link SpatialIndex} used should be something that supports
- * envelope (range) queries efficiently (such as a {@link Quadtree}
- * or {@link STRtree}.
+ * The index::SpatialIndex used should be something that supports
+ * envelope (range) queries efficiently (such as a index::quadtree::Quadtree
+ * or index::strtree::STRtree).
*/
index::SpatialIndex* index;
int indexCounter;
diff --git a/include/geos/noding/NodedSegmentString.h b/include/geos/noding/NodedSegmentString.h
index 55eadc5..6db0d2d 100644
--- a/include/geos/noding/NodedSegmentString.h
+++ b/include/geos/noding/NodedSegmentString.h
@@ -46,7 +46,7 @@ namespace noding { // geos::noding
* Represents a list of contiguous line segments,
* and supports noding the segments.
*
- * The line segments are represented by an array of {@link Coordinate}s.
+ * The line segments are represented by an array of [Coordinates](@ref geom::Coordinate).
* Intended to optimize the noding of contiguous segments by
* reducing the number of allocated objects.
* SegmentStrings can carry a context object, which is useful
@@ -86,14 +86,14 @@ public:
const SegmentString::NonConstVect& segStrings);
- /**
+ /** \brief
* Creates a new segment string from a list of vertices.
*
* @param newPts CoordinateSequence representing the string,
* ownership transferred.
*
* @param newContext the user-defined data of this segment string
- * (may be null)
+ * (may be null)
*/
NodedSegmentString(geom::CoordinateSequence* newPts, const void* newContext)
: NodableSegmentString(newContext)
@@ -106,8 +106,9 @@ public:
delete pts;
}
- /**
+ /** \brief
* Adds an intersection node for a given point and segment to this segment string.
+ *
* If an intersection already exists for this exact location, the existing
* node will be returned.
*
@@ -161,13 +162,13 @@ public:
* Gets the octant of the segment starting at vertex index.
*
* @param index the index of the vertex starting the segment.
- * Must not be the last index in the vertex list
+ * Must not be the last index in the vertex list
* @return the octant of the segment at the vertex
*/
int getSegmentOctant(size_t index) const;
/** \brief
- * Add {SegmentNode}s for one or both
+ * Add {@link SegmentNode}s for one or both
* intersections found for a segment of an edge to the edge
* intersection list.
*/
diff --git a/include/geos/noding/Noder.h b/include/geos/noding/Noder.h
index 41625d0..dd292fd 100644
--- a/include/geos/noding/Noder.h
+++ b/include/geos/noding/Noder.h
@@ -36,8 +36,8 @@ namespace noding { // geos.noding
/** \brief
* Computes all intersections between segments in a set of SegmentString.
*
- * Intersections found are represented as {@link SegmentNode}s and added to the
- * {@link SegmentString}s in which they occur.
+ * Intersections found are represented as [SegmentNodes](@ref SegmentNode) and
+ * added to the [SegmentStrings](@ref SegmentString) in which they occur.
* As a final step in the noding a new set of segment strings split
* at the nodes may be returned.
*
@@ -49,7 +49,7 @@ namespace noding { // geos.noding
class GEOS_DLL Noder {
public:
/** \brief
- * Computes the noding for a collection of {@link SegmentString}s.
+ * Computes the noding for a collection of [SegmentStrings](@ref SegmentString).
*
* Some Noders may add all these nodes to the input SegmentStrings;
* others may only add some or none at all.
@@ -59,7 +59,7 @@ public:
virtual void computeNodes(std::vector<SegmentString*>* segStrings) = 0;
/** \brief
- * Returns a {@link Collection} of fully noded {@link SegmentStrings}.
+ * Returns a collection of fully noded [SegmentStrings](@ref SegmentString).
* The SegmentStrings have the same context as their parent.
*
* @return a newly allocated std::vector of const SegmentStrings.
diff --git a/include/geos/noding/NodingIntersectionFinder.h b/include/geos/noding/NodingIntersectionFinder.h
index dbf9471..a45f7c1 100644
--- a/include/geos/noding/NodingIntersectionFinder.h
+++ b/include/geos/noding/NodingIntersectionFinder.h
@@ -39,7 +39,7 @@ namespace noding { // geos.noding
* Non-noded intersections include:
*
* - intersections which lie in the interior of a segment
- * - intersections at a vertex in the interior of a {@link SegmentString}
+ * - intersections at a vertex in the interior of a SegmentString
* (e.g. with a segment string endpoint or other interior vertex)
*
* @version 1.7
@@ -88,7 +88,7 @@ public:
return interiorIntersection;
}
- /**
+ /** \brief
* Gets the count of intersections found.
*
* @return the intersection count
@@ -99,15 +99,16 @@ public:
return intersectionCount;
}
- /**
- * Sets whether only end segments should be tested for interior intersection.
- * This is a performance optimization that may be used if
- * the segments have been previously noded by an appropriate algorithm.
- * It may be known that any potential noding failures will occur only in
- * end segments.
- *
+ /** \brief
+ * Sets whether only end segments should be tested for interior intersection.
+ *
+ * This is a performance optimization that may be used if the segments
+ * have been previously noded by an appropriate algorithm.
+ * It may be known that any potential noding failures will occur only in
+ * end segments.
+ *
* @param isCESO whether to test only end segments
- */
+ */
void
setCheckEndSegmentsOnly(bool isCESO)
{
@@ -115,15 +116,16 @@ public:
}
- /**
- * Sets whether all intersections should be computed.
- * When this is <code>false</code> (the default value)
- * the value of {@link #isDone()} is <code>true</code> after the first intersection is found.
- * <p>
- * Default is <code>false</code>.
- *
- * @param findAllIntersections whether all intersections should be computed
- */
+ /** \brief
+ * Sets whether all intersections should be computed.
+ *
+ * When this is `false` (the default value) the value of
+ * #isDone() is `true` after the first intersection is found.
+ *
+ * Default is `false`.
+ *
+ * @param fAI whether all intersections should be computed
+ */
void
setFindAllIntersections(bool fAI)
{
@@ -142,11 +144,11 @@ public:
}
/** \brief
- * This method is called by clients
- * of the {@link SegmentIntersector} class to process
- * intersections for two segments of the {@link SegmentStrings} being intersected.
+ * This method is called by clients of the SegmentIntersector class to process
+ * intersections for two segments of the [SegmentStrings](@ref SegmentString)
+ * being intersected.
*
- * Note that some clients (such as {@link MonotoneChain}s) may optimize away
+ * @note Some clients (such as `MonotoneChains`) may optimize away
* this call for segment pairs which they have determined do not intersect
* (e.g. by an disjoint envelope test).
*/
@@ -173,48 +175,49 @@ private:
NodingIntersectionFinder(const NodingIntersectionFinder& other) = delete;
NodingIntersectionFinder& operator=(const NodingIntersectionFinder& rhs) = delete;
- /**
- * Tests if two vertices with at least one in a segmentString interior
- * are equal.
- *
- * @param p0 a segment vertex
- * @param p1 a segment vertex
- * @param isEnd0 true if vertex is a segmentString endpoint
- * @param isEnd1 true if vertex is a segmentString endpoint
- * @return true if an intersection is found
+ /** \brief
+ * Tests if two vertices with at least one in a segmentString interior
+ * are equal.
+ *
+ * @param p0 a segment vertex
+ * @param p1 a segment vertex
+ * @param isEnd0 true if vertex is a segmentString endpoint
+ * @param isEnd1 true if vertex is a segmentString endpoint
+ * @return true if an intersection is found
*/
bool isInteriorVertexIntersection(
const geom::Coordinate& p0, const geom::Coordinate& p1,
bool isEnd0, bool isEnd1);
- /**
- * Tests if an intersection occurs between a segmentString interior vertex and another vertex.
- * Note that intersections between two endpoint vertices are valid noding,
- * and are not flagged.
- *
- * @param p00 a segment vertex
- * @param p01 a segment vertex
- * @param p10 a segment vertex
- * @param p11 a segment vertex
- * @param isEnd00 true if vertex is a segmentString endpoint
- * @param isEnd01 true if vertex is a segmentString endpoint
- * @param isEnd10 true if vertex is a segmentString endpoint
- * @param isEnd11 true if vertex is a segmentString endpoint
- * @return true if an intersection is found
- */
+ /** \brief
+ * Tests if an intersection occurs between a SegmentString interior vertex and another vertex.
+ *
+ * @note intersections between two endpoint vertices are valid noding,
+ * and are not flagged.
+ *
+ * @param p00 a segment vertex
+ * @param p01 a segment vertex
+ * @param p10 a segment vertex
+ * @param p11 a segment vertex
+ * @param isEnd00 true if vertex is a segmentString endpoint
+ * @param isEnd01 true if vertex is a segmentString endpoint
+ * @param isEnd10 true if vertex is a segmentString endpoint
+ * @param isEnd11 true if vertex is a segmentString endpoint
+ * @return true if an intersection is found
+ */
bool isInteriorVertexIntersection(
const geom::Coordinate& p00, const geom::Coordinate& p01,
const geom::Coordinate& p10, const geom::Coordinate& p11,
bool isEnd00, bool isEnd01, bool isEnd10, bool isEnd11);
- /**
- * Tests whether a segment in a {@link SegmentString} is an end segment.
- * (either the first or last).
- *
- * @param segStr a segment string
- * @param index the index of a segment in the segment string
- * @return true if the segment is an end segment
- */
+ /** \brief
+ * Tests whether a segment in a SegmentString is an end segment.
+ * (either the first or last).
+ *
+ * @param segStr a segment string
+ * @param index the index of a segment in the segment string
+ * @return true if the segment is an end segment
+ */
bool isEndSegment(const SegmentString* segStr, size_t index);
diff --git a/include/geos/noding/OrientedCoordinateArray.h b/include/geos/noding/OrientedCoordinateArray.h
index 43eb97f..dead361 100644
--- a/include/geos/noding/OrientedCoordinateArray.h
+++ b/include/geos/noding/OrientedCoordinateArray.h
@@ -50,7 +50,7 @@ public:
* Creates a new {@link OrientedCoordinateArray}
* for the given {@link geom::CoordinateSequence}.
*
- * @param pts the coordinates to orient
+ * @param p_pts the coordinates to orient
*/
OrientedCoordinateArray(const geom::CoordinateSequence& p_pts)
:
diff --git a/include/geos/noding/SegmentIntersectionDetector.h b/include/geos/noding/SegmentIntersectionDetector.h
index c892d83..402f9d5 100644
--- a/include/geos/noding/SegmentIntersectionDetector.h
+++ b/include/geos/noding/SegmentIntersectionDetector.h
@@ -86,7 +86,7 @@ public:
this->findAllTypes = p_findAllTypes;
}
- /**
+ /** \brief
* Tests whether an intersection was found.
*
* @return true if an intersection was found
@@ -97,10 +97,10 @@ public:
return _hasIntersection;
}
- /**
+ /** \brief
* Tests whether a proper intersection was found.
*
- * @return true if a proper intersection was found
+ * @return `true` if a proper intersection was found
*/
bool
hasProperIntersection() const
@@ -108,7 +108,7 @@ public:
return _hasProperIntersection;
}
- /**
+ /** \brief
* Tests whether a non-proper intersection was found.
*
* @return true if a non-proper intersection was found
@@ -119,7 +119,7 @@ public:
return _hasNonProperIntersection;
}
- /**
+ /** \brief
* Gets the computed location of the intersection.
* Due to round-off, the location may not be exact.
*
@@ -132,7 +132,7 @@ public:
}
- /**
+ /** \brief
* Gets the endpoints of the intersecting segments.
*
* @return an array of the segment endpoints (p00, p01, p10, p11)
@@ -160,13 +160,13 @@ public:
return _hasIntersection;
}
- /**
- * This method is called by clients
- * of the {@link SegmentIntersector} class to process
- * intersections for two segments of the {@link SegmentStrings} being intersected.
- * Note that some clients (such as {@link MonotoneChain}s) may optimize away
- * this call for segment pairs which they have determined do not intersect
- * (e.g. by an disjoint envelope test).
+ /** \brief
+ * This method is called by clients of the SegmentIntersector class to process
+ * intersections for two segments of the {@link SegmentString}s being intersected.
+ *
+ * @note Some clients (such as `MonotoneChains`) may optimize away
+ * this call for segment pairs which they have determined do not intersect
+ * (e.g. by an disjoint envelope test).
*/
void processIntersections(noding::SegmentString* e0, size_t segIndex0,
noding::SegmentString* e1, size_t segIndex1) override;
diff --git a/include/geos/noding/SegmentSetMutualIntersector.h b/include/geos/noding/SegmentSetMutualIntersector.h
index 0da42e0..56e9714 100644
--- a/include/geos/noding/SegmentSetMutualIntersector.h
+++ b/include/geos/noding/SegmentSetMutualIntersector.h
@@ -45,11 +45,11 @@ public:
~SegmentSetMutualIntersector() {}
/**
- * Sets the {@link SegmentIntersector} to use with this intersector.
+ * Sets the SegmentIntersector to use with this intersector.
* The SegmentIntersector will either rocord or add intersection nodes
* for the input segment strings.
*
- * @param segInt the segment intersector to use
+ * @param si the segment intersector to use
*/
void
setSegmentIntersector(SegmentIntersector* si)
@@ -59,14 +59,14 @@ public:
/**
*
- * @param segStrings a collection of {@link SegmentString}s to node
+ * @param segStrings a collection of [SegmentStrings](@ref SegmentString) to node
*/
virtual void setBaseSegments(SegmentString::ConstVect* segStrings) = 0;
/**
- * Computes the intersections for two collections of {@link SegmentString}s.
+ * Computes the intersections for two collections of [SegmentStrings](@ref SegmentString).
*
- * @param segStrings1 a collection of {@link SegmentString}s to node
+ * @param segStrings a collection of [SegmentStrings](@ref SegmentString) to node
*/
virtual void process(SegmentString::ConstVect* segStrings) = 0;
diff --git a/include/geos/noding/SegmentString.h b/include/geos/noding/SegmentString.h
index 4b64e72..407efa7 100644
--- a/include/geos/noding/SegmentString.h
+++ b/include/geos/noding/SegmentString.h
@@ -51,8 +51,8 @@ public:
friend std::ostream& operator<< (std::ostream& os,
const SegmentString& ss);
- /// Construct a SegmentString.
- //
+ /// \brief Construct a SegmentString.
+ ///
/// @param newContext the context associated to this SegmentString
///
SegmentString(const void* newContext)
@@ -63,7 +63,7 @@ public:
virtual
~SegmentString() {}
- /**
+ /** \brief
* Gets the user-defined data for this segment string.
*
* @return the user-defined data
@@ -74,7 +74,7 @@ public:
return context;
}
- /**
+ /** \brief
* Sets the user-defined data for this segment string.
*
* @param data an Object containing user-defined data
@@ -94,7 +94,7 @@ public:
/// Return a pointer to the CoordinateSequence associated
/// with this SegmentString.
//
- /// Note that the CoordinateSequence is owned by this SegmentString!
+ /// @note The CoordinateSequence is owned by this SegmentString!
///
virtual geom::CoordinateSequence* getCoordinates() const = 0;
diff --git a/include/geos/noding/SegmentStringUtil.h b/include/geos/noding/SegmentStringUtil.h
index a745817..5dddbce 100644
--- a/include/geos/noding/SegmentStringUtil.h
+++ b/include/geos/noding/SegmentStringUtil.h
@@ -37,12 +37,12 @@ namespace noding { // geos::noding
class SegmentStringUtil {
public:
/** \brief
- * Extracts all linear components from a given {@link Geometry}
- * to {@link SegmentString}s.
+ * Extracts all linear components from a given [Geometry](@ref geom::Geometry)
+ * to [SegmentStrings](@ref SegmentString)
*
* The SegmentString data item is set to be the source Geometry.
*
- * @param geom the geometry to extract from
+ * @param g the geometry to extract from
* @param segStr a List of SegmentStrings (output parameter).
* Ownership of elements pushed to the vector
* is transferred to caller.
diff --git a/include/geos/noding/SinglePassNoder.h b/include/geos/noding/SinglePassNoder.h
index 5a800d5..f185ad0 100644
--- a/include/geos/noding/SinglePassNoder.h
+++ b/include/geos/noding/SinglePassNoder.h
@@ -35,10 +35,11 @@ namespace geos {
namespace noding { // geos.noding
-/**
+/** \brief
* Base class for {@link Noder}s which make a single
* pass to find intersections.
- * This allows using a custom {@link SegmentIntersector}
+ *
+ * This allows using a custom SegmentIntersector
* (which for instance may simply identify intersections, rather than
* insert them).
*
@@ -60,8 +61,9 @@ public:
~SinglePassNoder() override {}
- /**
+ /** \brief
* Sets the SegmentIntersector to use with this noder.
+ *
* A SegmentIntersector will normally add intersection nodes
* to the input segment strings, but it may not - it may
* simply record the presence of intersections.
@@ -75,15 +77,16 @@ public:
segInt = newSegInt;
}
- /**
+ /** \brief
* Computes the noding for a collection of {@link SegmentString}s.
*
* @param segStrings a collection of {@link SegmentString}s to node
*/
void computeNodes(std::vector<SegmentString*>* segStrings) override = 0;
- /**
- * Returns a {@link Collection} of fully noded {@link SegmentStrings}.
+ /** \brief
+ * Returns a Collection of fully noded {@link SegmentString}s.
+ *
* The SegmentStrings have the same context as their parent.
*
* @return a Collection of SegmentStrings
diff --git a/include/geos/noding/snapround/MCIndexPointSnapper.h b/include/geos/noding/snapround/MCIndexPointSnapper.h
index 15dbc30..722ef1a 100644
--- a/include/geos/noding/snapround/MCIndexPointSnapper.h
+++ b/include/geos/noding/snapround/MCIndexPointSnapper.h
@@ -42,8 +42,8 @@ namespace noding { // geos::noding
namespace snapround { // geos::noding::snapround
/** \brief
- * "Snaps" all {@link SegmentString}s in a {@link SpatialIndex} containing
- * {@link MonotoneChain}s to a given {@link HotPixel}.
+ * "Snaps" all [SegmentStrings](@ref SegmentString) in a [SpatialIndex](@ref index::SpatialIndex) containing
+ * [MonotoneChains](@ref index::chain::MonotoneChain) to a given HotPixel.
*
*/
class GEOS_DLL MCIndexPointSnapper {
@@ -56,17 +56,17 @@ public:
index(nIndex)
{}
- /**
+ /** \brief
* Snaps (nodes) all interacting segments to this hot pixel.
- * The hot pixel may represent a vertex of an edge,
- * in which case this routine uses the optimization
- * of not noding the vertex itself
+ *
+ * The hot pixel may represent a vertex of an edge, in which case this
+ * routine uses the optimization of not noding the vertex itself.
*
* @param hotPixel the hot pixel to snap to
* @param parentEdge the edge containing the vertex,
- * if applicable, or <code>null</code>
+ * if applicable, or `null`
* @param vertexIndex the index of the vertex, if applicable, or -1
- * @return <code>true</code> if a node was added for this pixel
+ * @return `true` if a node was added for this pixel
*/
bool snap(HotPixel& hotPixel, SegmentString* parentEdge,
size_t vertexIndex);
diff --git a/include/geos/opOverlay.h b/include/geos/opOverlay.h
index 4aefaae..41a24c2 100644
--- a/include/geos/opOverlay.h
+++ b/include/geos/opOverlay.h
@@ -24,7 +24,8 @@ namespace operation {
* spatial functions.
*
* The Overlay Algorithm is used in spatial analysis methods for computing
- * set-theoretic operations (boolean combinations) of input {@link Geometry}s.
+ * set-theoretic operations (boolean combinations) of input
+ * [Geometrys](@ref geom::Geometry).
* The algorithm for computing the overlay uses the intersection operations
* supported by topology graphs.
* To compute an overlay it is necessary to explicitly compute the resultant
diff --git a/include/geos/operation/IsSimpleOp.h b/include/geos/operation/IsSimpleOp.h
index 0af00d7..2fad86e 100644
--- a/include/geos/operation/IsSimpleOp.h
+++ b/include/geos/operation/IsSimpleOp.h
@@ -69,15 +69,15 @@ namespace operation { // geos.operation
*
* This definition relies on the definition of boundary points.
* The SFS uses the Mod-2 rule to determine which points are on the boundary of
- * lineal geometries, but this class supports
- * using other {@link BoundaryNodeRule}s as well.
+ * lineal geometries, but this class supports using other
+ * [BoundaryNodeRules](@ref algorithm::BoundaryNodeRule) as well.
*
- * Simplicity is defined for each {@link Geometry} subclass as follows:
+ * Simplicity is defined for each [Geometry](@ref geom::Geometry) subclass as follows:
*
* - Valid polygonal geometries are simple by definition, so
- * <code>isSimple</code> trivially returns true.
+ * `isSimple` trivially returns true.
* (Hint: in order to check if a polygonal geometry has self-intersections,
- * use {@link Geometry::isValid}).
+ * use geom::Geometry::isValid()).
*
* - Linear geometries are simple iff they do not self-intersect at points
* other than boundary points.
@@ -88,7 +88,7 @@ namespace operation { // geos.operation
* - Zero-dimensional geometries (points) are simple iff they have no
* repeated points.
*
- * - Empty <code>Geometry</code>s are always simple
+ * - Empty `Geometry`s are always simple
*
* @see algorithm::BoundaryNodeRule
*
@@ -124,21 +124,21 @@ public:
IsSimpleOp(const geom::Geometry& geom,
const algorithm::BoundaryNodeRule& boundaryNodeRule);
- /**
+ /** \brief
* Tests whether the geometry is simple.
*
* @return true if the geometry is simple
*/
bool isSimple();
- /**
+ /** \brief
* Gets a coordinate for the location where the geometry
- * fails to be simple.
- * (i.e. where it has a non-boundary self-intersection).
+ * fails to be simple (i.e. where it has a non-boundary self-intersection).
+ *
* {@link #isSimple} must be called before this method is called.
*
* @return a coordinate for the location of the non-boundary
- * self-intersection. Ownership retained.
+ * self-intersection. Ownership retained.
* @return the null coordinate if the geometry is simple
*/
const geom::Coordinate*
@@ -147,7 +147,7 @@ public:
return nonSimpleLocation.get();
}
- /**
+ /** \brief
* Reports whether a geom::LineString is simple.
*
* @param geom the lineal geometry to test
@@ -157,7 +157,7 @@ public:
*/
bool isSimple(const geom::LineString* geom);
- /**
+ /** \brief
* Reports whether a geom::MultiLineString is simple.
*
* @param geom the lineal geometry to test
@@ -167,7 +167,7 @@ public:
*/
bool isSimple(const geom::MultiLineString* geom);
- /**
+ /** \brief
* A MultiPoint is simple iff it has no repeated points
*
* @deprecated use isSimple()
diff --git a/include/geos/operation/buffer/BufferBuilder.h b/include/geos/operation/buffer/BufferBuilder.h
index 43e3433..3a0174c 100644
--- a/include/geos/operation/buffer/BufferBuilder.h
+++ b/include/geos/operation/buffer/BufferBuilder.h
@@ -132,7 +132,7 @@ public:
* This allows choosing fast but non-robust noding, or slower
* but robust noding.
*
- * @param noder the noder to use
+ * @param newNoder the noder to use
*/
void
setNoder(noding::Noder* newNoder)
diff --git a/include/geos/operation/buffer/BufferOp.h b/include/geos/operation/buffer/BufferOp.h
index 04cefca..b814d81 100644
--- a/include/geos/operation/buffer/BufferOp.h
+++ b/include/geos/operation/buffer/BufferOp.h
@@ -54,9 +54,9 @@ namespace buffer { // geos.operation.buffer
* the Minkowski sum (or difference) of the geometry
* with a circle with radius equal to the absolute value of the buffer
* distance.
- * In the CAD/CAM world buffers are known as <i>offset curves</i>.
+ * In the CAD/CAM world buffers are known as *offset curves*.
* In morphological analysis the operation of positive and negative buffering
- * is referred to as <i>erosion</i> and <i>dilation</i>.
+ * is referred to as *erosion* and *dilation*.
*
* The buffer operation always returns a polygonal result.
* The negative or zero-distance buffer of lines and points is always
@@ -80,7 +80,7 @@ class GEOS_DLL BufferOp {
private:
- /**
+ /** \brief
* A number of digits of precision which leaves some computational "headroom"
* for floating point operations.
*
@@ -145,7 +145,7 @@ public:
CAP_SQUARE = BufferParameters::CAP_SQUARE
};
- /**
+ /** \brief
* Computes the buffer for a geometry for a given buffer distance
* and accuracy of approximation.
*
@@ -153,6 +153,7 @@ public:
* @param distance the buffer distance
* @param quadrantSegments the number of segments used to
* approximate a quarter circle
+ * @param endCapStyle line buffer end cap style (default: BufferParameters::CAP_ROUND)
* @return the buffer of the input geometry
*
*/
@@ -162,8 +163,8 @@ public:
BufferParameters::DEFAULT_QUADRANT_SEGMENTS,
int endCapStyle = BufferParameters::CAP_ROUND);
- /**
- * Initializes a buffer computation for the given geometry
+ /** \brief
+ * Initializes a buffer computation for the given geometry.
*
* @param g the geometry to buffer
*/
@@ -175,9 +176,9 @@ public:
{
}
- /**
+ /** \brief
* Initializes a buffer computation for the given geometry
- * with the given set of parameters
+ * with the given set of parameters.
*
* @param g the geometry to buffer
* @param params the buffer parameters to use. This class will
@@ -191,8 +192,9 @@ public:
{
}
- /**
+ /** \brief
* Specifies the end cap style of the generated buffer.
+ *
* The styles supported are CAP_ROUND, CAP_BUTT, and CAP_SQUARE.
* The default is CAP_ROUND.
*
@@ -200,14 +202,14 @@ public:
*/
inline void setEndCapStyle(int nEndCapStyle);
- /**
+ /** \brief
* Sets the number of segments used to approximate a angle fillet
*
* @param nQuadrantSegments the number of segments in a fillet for a quadrant
*/
inline void setQuadrantSegments(int nQuadrantSegments);
- /**
+ /** \brief
* Sets whether the computed buffer should be single-sided.
*
* A single-sided buffer is constructed on only one side
@@ -222,14 +224,14 @@ public:
*
* The End Cap Style for single-sided buffers is
* always ignored,
- * and forced to the equivalent of <tt>CAP_FLAT</tt>.
+ * and forced to the equivalent of `CAP_FLAT`.
*
- * @param isSingleSided true if a single-sided buffer
+ * @param isSingleSided `true` if a single-sided buffer
* should be constructed
*/
inline void setSingleSided(bool isSingleSided);
- /**
+ /** \brief
* Returns the buffer computed for a geometry for a given buffer
* distance.
*
diff --git a/include/geos/operation/buffer/OffsetCurveBuilder.h b/include/geos/operation/buffer/OffsetCurveBuilder.h
index 7588e98..2d3b424 100644
--- a/include/geos/operation/buffer/OffsetCurveBuilder.h
+++ b/include/geos/operation/buffer/OffsetCurveBuilder.h
@@ -77,7 +77,7 @@ public:
bufParams(nBufParams)
{}
- /**
+ /** \brief
* Gets the buffer parameters being used to generate the curve.
*
* @return the buffer parameters being used
@@ -88,11 +88,14 @@ public:
return bufParams;
}
- /**
+ /** \brief
* This method handles single points as well as lines.
- * Lines are assumed to <b>not</b> be closed (the function will not
+ *
+ * Lines are assumed to **not** be closed (the function will not
* fail for closed lines, but will generate superfluous line caps).
*
+ * @param inputPts input points
+ * @param distance offset distance
* @param lineList the std::vector to which the newly created
* CoordinateSequences will be pushed_back.
* Caller is responsible to delete these new elements.
@@ -101,12 +104,14 @@ public:
double distance,
std::vector<geom::CoordinateSequence*>& lineList);
- /**
+ /** \brief
* This method handles single points as well as lines.
*
- * Lines are assumed to <b>not</b> be closed (the function will not
+ * Lines are assumed to **not** be closed (the function will not
* fail for closed lines, but will generate superfluous line caps).
*
+ * @param inputPts input points
+ * @param distance offset distance
* @param lineList the std::vector to which newly created
* CoordinateSequences will be pushed_back.
* Caller will be responsible to delete them.
@@ -115,16 +120,19 @@ public:
* @param rightSide indicates that the right side buffer will
* be obtained/skipped
*
- * NOTE: this is a GEOS extension
+ * @note This is a GEOS extension.
*/
void getSingleSidedLineCurve(const geom::CoordinateSequence* inputPts,
double distance, std::vector<geom::CoordinateSequence*>& lineList,
bool leftSide, bool rightSide) ;
- /**
+ /** \brief
* This method handles the degenerate cases of single points and lines,
* as well as rings.
*
+ * @param inputPts input points
+ * @param side a [Position](@ref geomgraph::Position)
+ * @param distance offset distance
* @param lineList the std::vector to which CoordinateSequences will
* be pushed_back
*/
@@ -141,10 +149,10 @@ private:
const BufferParameters& bufParams;
- /**
+ /** \brief
* Use a value which results in a potential distance error which is
- * significantly less than the error due to
- * the quadrant segment discretization.
+ * significantly less than the error due to the quadrant segment discretization.
+ *
* For QS = 8 a value of 100 is reasonable.
* This should produce a maximum of 1% distance error.
*/
diff --git a/include/geos/operation/buffer/OffsetCurveSetBuilder.h b/include/geos/operation/buffer/OffsetCurveSetBuilder.h
index 751f6e4..beb8219 100644
--- a/include/geos/operation/buffer/OffsetCurveSetBuilder.h
+++ b/include/geos/operation/buffer/OffsetCurveSetBuilder.h
@@ -188,15 +188,16 @@ public:
* Each offset curve has an attached {@link geomgraph::Label} indicating
* its left and right location.
*
- * @return a Collection of SegmentStrings representing the raw
- * buffer curves
+ * @return a Collection of SegmentStrings representing the raw buffer curves
*/
std::vector<noding::SegmentString*>& getCurves();
- /// Add raw curves for a set of CoordinateSequences
- //
+ /// \brief Add raw curves for a set of CoordinateSequences.
+ ///
/// @param lineList is a list of CoordinateSequence, ownership
- /// of which is transferred here.
+ /// of which is transferred here
+ /// @param leftLoc left location
+ /// @param rightLoc right location
///
void addCurves(const std::vector<geom::CoordinateSequence*>& lineList,
int leftLoc, int rightLoc);
diff --git a/include/geos/operation/distance/ConnectedElementLocationFilter.h b/include/geos/operation/distance/ConnectedElementLocationFilter.h
index 4703cbd..36bff6e 100644
--- a/include/geos/operation/distance/ConnectedElementLocationFilter.h
+++ b/include/geos/operation/distance/ConnectedElementLocationFilter.h
@@ -40,11 +40,11 @@ namespace operation { // geos::operation
namespace distance { // geos::operation::distance
/** \brief
- * A ConnectedElementPointFilter extracts a single point
- * from each connected element in a Geometry
- * (e.g. a polygon, linestring or point)
- * and returns them in a list. The elements of the list are
- * DistanceOp::GeometryLocation.
+ * A ConnectedElementPointFilter extracts a single point from each connected
+ * element in a Geometry (e.g. a polygon, linestring or point) and returns
+ * them in a list.
+ *
+ * The elements of the list are GeometryLocation.
*/
class GEOS_DLL ConnectedElementLocationFilter: public geom::GeometryFilter {
private:
@@ -53,11 +53,13 @@ private:
ConnectedElementLocationFilter() = default;
public:
- /**
- * Returns a list containing a point from each Polygon, LineString, and Point
- * found inside the specified geometry. Thus, if the specified geometry is
- * not a GeometryCollection, an empty list will be returned. The elements of the list
- * are {@link com.vividsolutions.jts.operation.distance.GeometryLocation}s.
+ /** \brief
+ * Returns a list containing a point from each Polygon, LineString, and
+ * Point found inside the specified geometry.
+ *
+ * Thus, if the specified geometry is not a GeometryCollection,
+ * an empty list will be returned. The elements of the list
+ * are [GeometryLocations](@ref operation::distance::GeometryLocation).
*/
static std::vector<std::unique_ptr<GeometryLocation>> getLocations(const geom::Geometry* geom);
diff --git a/include/geos/operation/intersection/Rectangle.h b/include/geos/operation/intersection/Rectangle.h
index 8536581..8f0506c 100644
--- a/include/geos/operation/intersection/Rectangle.h
+++ b/include/geos/operation/intersection/Rectangle.h
@@ -64,7 +64,7 @@ public:
Rectangle(double x1, double y1, double x2, double y2);
/**
- * \@return the minimum x-coordinate of the rectangle
+ * @return the minimum x-coordinate of the rectangle
*/
double
xmin() const
@@ -73,7 +73,7 @@ public:
}
/**
- * \@return the minimum y-coordinate of the rectangle
+ * @return the minimum y-coordinate of the rectangle
*/
double
@@ -84,7 +84,7 @@ public:
/**
- * \@return the maximum x-coordinate of the rectangle
+ * @return the maximum x-coordinate of the rectangle
*/
double
@@ -95,7 +95,7 @@ public:
/**
- * \@return the maximum y-coordinate of the rectangle
+ * @return the maximum y-coordinate of the rectangle
*/
double
@@ -105,9 +105,9 @@ public:
}
/**
- * \@return the rectangle as a polygon geometry
+ * @return the rectangle as a polygon geometry
*
- * Ownership transferred to caller
+ * @note Ownership transferred to caller
*/
geom::Polygon* toPolygon(const geom::GeometryFactory& f) const;
@@ -133,9 +133,9 @@ public:
};
/**
- * @brief Test if the given position is on a {@link Rectangle] edge
- * @param pos {@link Rectangle} {@link Position}
- * @return true, if the position is on an edge
+ * @brief Test if the given position is on a Rectangle edge
+ * @param pos Rectangle::Position
+ * @return `true`, if the position is on an edge
*/
static bool
@@ -145,10 +145,10 @@ public:
}
/**
- * @brief Test if the given positions are on the same {@link Rectangle} edge
- * @param pos1 {@link Rectangle} {@link Position} of first coordinate
- * @param pos2 {@link Rectangle} {@link Position} of second coordinate
- * @return true, if the positions are on the same edge
+ * @brief Test if the given positions are on the same Rectangle edge
+ * @param pos1 [Position](@ref Rectangle::Position) of first coordinate
+ * @param pos2 [Position](@ref Rectangle::Position) of second coordinate
+ * @return `true`, if the positions are on the same edge
*/
static bool
@@ -158,10 +158,10 @@ public:
}
/**
- * @brief Establish position of coordinate with respect to a {@link Rectangle}
+ * @brief Establish position of coordinate with respect to a Rectangle
* @param x x-coordinate
* @param y y-coordinate
- * @return {@link Position} of the coordinate
+ * @return [Position](@ref Rectangle::Position) of the coordinate
*/
Position
@@ -194,8 +194,8 @@ public:
/**
* @brief Next edge in clock-wise direction
- * @param pos {@link Rectangle} {@link Position}
- * @return next {@Rectangle} {@link Position} in clock-wise direction
+ * @param pos [Position](@ref Rectangle::Position)
+ * @return next [Position](@ref Rectangle::Position) in clock-wise direction
*/
static Position
diff --git a/include/geos/operation/intersection/RectangleIntersection.h b/include/geos/operation/intersection/RectangleIntersection.h
index aff9d03..d15920f 100644
--- a/include/geos/operation/intersection/RectangleIntersection.h
+++ b/include/geos/operation/intersection/RectangleIntersection.h
@@ -51,7 +51,8 @@ namespace operation { // geos::operation
namespace intersection { // geos::operation::intersection
/**
- * \brief Speed-optimized clipping of a {@link Geometry} with a rectangle.
+ * \brief
+ * Speed-optimized clipping of a [Geometry](@ref geom::Geometry) with a rectangle.
*
* Two different methods are provided. The first performs normal
* clipping, the second clips the boundaries of polygons, not
@@ -67,35 +68,34 @@ namespace intersection { // geos::operation::intersection
* of the rectangle. Hence clipping may be faster than calculating
* the envelope of the geometry for trivial overlap tests.
*
- * The input geometry must be valid. In particular all {@link LinearRing}s must
- * be properly closed, or the algorithm may not terminate.
+ * The input geometry must be valid. In particular all [LinearRings](@ref geom::LinearRing)
+ * must be properly closed, or the algorithm may not terminate.
*
*/
class GEOS_DLL RectangleIntersection {
public:
/**
- * \brief Clip geometry with a rectangle
+ * \brief Clip geometry with a rectangle.
*
- * @param geom a {@link Geometry}
- * @param rect a {@link Rectangle}
+ * @param geom a [Geometry](@ref geom::Geometry)
+ * @param rect a Rectangle
* @return the clipped geometry
- * @return NULL if the geometry is outside the {@link Rectangle}
+ * @return `NULL` if the geometry is outside the Rectangle
*/
static std::unique_ptr<geom::Geometry> clip(const geom::Geometry& geom,
const Rectangle& rect);
/**
- * \brief Clip boundary of a geometry with a rectangle
- *
+ * \brief Clip boundary of a geometry with a rectangle.
*
* Any polygon which intersects the rectangle will be converted to
* a polyline or a multipolyline - including the holes.
*
- * @param geom a {@link Geometry}
- * @param rect a {@link Rectangle}
+ * @param geom a [Geometry](@ref geom::Geometry)
+ * @param rect a Rectangle
* @return the clipped geometry
- * @return NULL if the geometry is outside the {@link Rectangle}
+ * @return `NULL` if the geometry is outside the Rectangle
*/
static std::unique_ptr<geom::Geometry> clipBoundary(const geom::Geometry& geom,
const Rectangle& rect);
diff --git a/include/geos/operation/intersection/RectangleIntersectionBuilder.h b/include/geos/operation/intersection/RectangleIntersectionBuilder.h
index 47383e0..cb7c909 100644
--- a/include/geos/operation/intersection/RectangleIntersectionBuilder.h
+++ b/include/geos/operation/intersection/RectangleIntersectionBuilder.h
@@ -52,11 +52,11 @@ namespace intersection { // geos::operation::intersection
* \brief Rebuild geometries from subpaths left by clipping with a rectangle
*
* The RectangleIntersectionBuilder is used to maintain lists of polygons,
- * linestrings and points left from clipping a {@link Geometry} with a {@link Rectangle}.
- * Once all clipping has been done, the class builds a valid {@link Geometry} from
+ * linestrings and points left from clipping a geom::Geometry with a Rectangle.
+ * Once all clipping has been done, the class builds a valid geom::Geometry from
* the components.
*
- * This is a utility class needed by {@link RectangleIntersection}, and is not
+ * @note This is a utility class needed by RectangleIntersection, and is not
* intended for public use.
*/
diff --git a/include/geos/operation/linemerge/LineMergeDirectedEdge.h b/include/geos/operation/linemerge/LineMergeDirectedEdge.h
index a19bd22..bdbfd6b 100644
--- a/include/geos/operation/linemerge/LineMergeDirectedEdge.h
+++ b/include/geos/operation/linemerge/LineMergeDirectedEdge.h
@@ -41,34 +41,34 @@ namespace linemerge { // geos::operation::linemerge
/**
* \brief
- * A planargraph::DirectedEdge of a LineMergeGraph.
+ * A [DirectedEdge](@ref planargraph::DirectedEdge) of a LineMergeGraph.
*
*/
class GEOS_DLL LineMergeDirectedEdge: public planargraph::DirectedEdge {
public:
- /**
- * Constructs a LineMergeDirectedEdge connecting the <code>from</code>
- * node to the <code>to</code> node.
+ /** \brief
+ * Constructs a LineMergeDirectedEdge connecting the `from`
+ * node to the `to` node.
*
- * @param directionPt
- * specifies this DirectedEdge's direction (given by an
- * imaginary line from the <code>from</code> node to
- * <code>directionPt</code>)
- *
- * @param edgeDirection
- * whether this DirectedEdge's direction is the same as or
- * opposite to that of the parent Edge (if any)
+ * @param from `from` node
+ * @param to `to` node
+ * @param directionPt specifies this DirectedEdge's direction (given by an
+ * imaginary line from the `from` node to
+ * `directionPt`)
+ * @param edgeDirection whether this DirectedEdge's direction is the same as or
+ * opposite to that of the parent Edge (if any)
*/
LineMergeDirectedEdge(planargraph::Node* from,
planargraph::Node* to,
const geom::Coordinate& directionPt,
bool edgeDirection);
- /**
- * Returns the directed edge that starts at this directed edge's end point, or null
- * if there are zero or multiple directed edges starting there.
- * @return
- */
+ /** \brief
+ * Returns the directed edge that starts at this directed edge's end point, or null
+ * if there are zero or multiple directed edges starting there.
+ * @return the directed edge
+ * @return `null` if there are zero or multiple directed edges starting there
+ */
LineMergeDirectedEdge* getNext();
};
diff --git a/include/geos/operation/linemerge/LineSequencer.h b/include/geos/operation/linemerge/LineSequencer.h
index 5c6a9f0..cba7397 100644
--- a/include/geos/operation/linemerge/LineSequencer.h
+++ b/include/geos/operation/linemerge/LineSequencer.h
@@ -62,10 +62,8 @@ namespace linemerge { // geos::operation::linemerge
* components of the input. Each linestring is oriented
* so that identical endpoints are adjacent in the list.
*
- * A typical use case is to convert a set of
- * unoriented geometric links
- * from a linear network
- * (e.g. such as block faces on a bus route)
+ * A typical use case is to convert a set of unoriented geometric links
+ * from a linear network (e.g. such as block faces on a bus route)
* into a continuous oriented path through the network.
*
* The input linestrings may form one or more connected sets.
@@ -74,12 +72,10 @@ namespace linemerge { // geos::operation::linemerge
* The computed output is a single MultiLineString containing the ordered
* linestrings in the sequence.
*
- * The sequencing employs the classic <b>Eulerian path</b> graph algorithm.
- * Since Eulerian paths are not uniquely determined,
- * further rules are used to
- * make the computed sequence preserve as much as possible of the input
- * ordering.
- * Within a connected subset of lines, the ordering rules are:
+ * The sequencing employs the classic **Eulerian path** graph algorithm.
+ * Since Eulerian paths are not uniquely determined, further rules are used
+ * to make the computed sequence preserve as much as possible of the input
+ * ordering. Within a connected subset of lines, the ordering rules are:
*
* - If there is degree-1 node which is the start
* node of an linestring, use that node as the start of the sequence
@@ -87,13 +83,11 @@ namespace linemerge { // geos::operation::linemerge
* node of an linestring, use that node as the end of the sequence
* - If the sequence has no degree-1 nodes, use any node as the start
*
- * Note that not all arrangements of lines can be sequenced.
- * For a connected set of edges in a graph,
- * <i>Euler's Theorem</i> states that there is a sequence
- * containing each edge once
- * <b>if and only if</b> there are no more than 2 nodes of odd degree.
- * If it is not possible to find a sequence, the isSequenceable method
- * will return <code>false</code>.
+ * @note Not all arrangements of lines can be sequenced. For a connected
+ * set of edges in a graph, *Euler's Theorem* states that there is a sequence
+ * containing each edge once **if and only if** there are no more than
+ * 2 nodes of odd degree. If it is not possible to find a sequence, the
+ * `isSequenceable` method will return `false`.
*
*/
class GEOS_DLL LineSequencer {
@@ -210,23 +204,24 @@ public:
isSequenceableVar(false)
{}
- /**
- * Tests whether a {@link Geometry} is sequenced correctly.
- * {@llink LineString}s are trivially sequenced.
- * {@link MultiLineString}s are checked for correct sequencing.
- * Otherwise, <code>isSequenced</code> is defined
- * to be <code>true</code> for geometries that are not lineal.
+ /** \brief
+ * Tests whether a [Geometry](@ref geom::Geometry) is sequenced correctly.
+ *
+ * [LineStrings](@ref geom::LineString) are trivially sequenced.
+ * [MultiLineStrings](@ref geom::MultiLineString) are checked for
+ * correct sequencing. Otherwise, `isSequenced` is defined
+ * to be `true` for geometries that are not lineal.
*
* @param geom the geometry to test
- * @return true if the geometry is sequenced or is not lineal
+ * @return `true` if the geometry is sequenced or is not lineal
*/
static bool isSequenced(const geom::Geometry* geom);
- /**
+ /** \brief
* Tests whether the arrangement of linestrings has a valid
* sequence.
*
- * @return <code>true</code> if a valid sequence exists.
+ * @return `true` if a valid sequence exists.
*/
bool
isSequenceable()
@@ -235,8 +230,9 @@ public:
return isSequenceableVar;
}
- /**
- * Adds a {@link Geometry} to be sequenced.
+ /** \brief
+ * Adds a [Geometry](@ref geom::Geometry) to be sequenced.
+ *
* May be called multiple times.
* Any dimension of Geometry may be added; the constituent
* linework will be extracted.
@@ -260,7 +256,7 @@ public:
}
}
- /**
+ /** \brief
* Act as a GeometryComponentFilter so to extract
* the linearworks
*/
@@ -272,13 +268,13 @@ public:
}
}
- /**
+ /** \brief
* Returns the LineString or MultiLineString
* built by the sequencing process, if one exists.
*
* @param release release ownership of computed Geometry
* @return the sequenced linestrings,
- * or <code>null</code> if a valid sequence
+ * or `null` if a valid sequence
* does not exist.
*/
geom::Geometry*
diff --git a/include/geos/operation/overlay/MaximalEdgeRing.h b/include/geos/operation/overlay/MaximalEdgeRing.h
index 3a583ac..e3c3772 100644
--- a/include/geos/operation/overlay/MaximalEdgeRing.h
+++ b/include/geos/operation/overlay/MaximalEdgeRing.h
@@ -46,7 +46,7 @@ namespace operation { // geos::operation
namespace overlay { // geos::operation::overlay
/** \brief
- * A ring of {@link edges} which may contain nodes of degree > 2.
+ * A ring of [DirectedEdges](@ref geomgraph::DirectedEdge) which may contain nodes of degree > 2.
*
* A MaximalEdgeRing may represent two different spatial entities:
*
@@ -57,7 +57,7 @@ namespace overlay { // geos::operation::overlay
* the interior of the polygon is strongly connected.
*
* These are the form of rings used to define polygons under some spatial data models.
- * However, under the OGC SFS model, {@link MinimalEdgeRings} are required.
+ * However, under the OGC SFS model, [MinimalEdgeRings](@ref MinimalEdgeRing) are required.
* A MaximalEdgeRing can be converted to a list of MinimalEdgeRings using the
* {@link #buildMinimalRings() } method.
*
diff --git a/include/geos/operation/overlay/MinimalEdgeRing.h b/include/geos/operation/overlay/MinimalEdgeRing.h
index 74f3abd..c7fdfd5 100644
--- a/include/geos/operation/overlay/MinimalEdgeRing.h
+++ b/include/geos/operation/overlay/MinimalEdgeRing.h
@@ -44,11 +44,11 @@ namespace operation { // geos::operation
namespace overlay { // geos::operation::overlay
/** \brief
- * A ring of {@link Edge}s with the property that no node
+ * A ring of [Edges](@ref geomgraph::Edge) with the property that no node
* has degree greater than 2.
*
- * These are the form of rings required
- * to represent polygons under the OGC SFS spatial data model.
+ * These are the form of rings required to represent polygons
+ * under the OGC SFS spatial data model.
*
* @see operation::overlay::MaximalEdgeRing
*
diff --git a/include/geos/operation/overlay/OverlayOp.h b/include/geos/operation/overlay/OverlayOp.h
index 2e2445e..c9ae800 100644
--- a/include/geos/operation/overlay/OverlayOp.h
+++ b/include/geos/operation/overlay/OverlayOp.h
@@ -61,7 +61,7 @@ namespace geos {
namespace operation { // geos::operation
namespace overlay { // geos::operation::overlay
-/// Computes the geometric overlay of two Geometry.
+/// \brief Computes the geometric overlay of two Geometry.
//
/// The overlay can be used to determine any
/// boolean combination of the geometries.
@@ -70,7 +70,7 @@ class GEOS_DLL OverlayOp: public GeometryGraphOperation {
public:
- /// The spatial functions supported by this class.
+ /// \brief The spatial functions supported by this class.
//
/// These operations implement various boolean combinations of
/// the resultants of the overlay.
@@ -86,7 +86,7 @@ public:
opSYMDIFFERENCE = 4
};
- /**
+ /** \brief
* Computes an overlay operation for the given geometry arguments.
*
* @param geom0 the first geometry argument
@@ -100,13 +100,13 @@ public:
OpCode opCode);
//throw(TopologyException *);
- /**
- * Tests whether a point with a given topological {@link Label}
+ /** \brief
+ * Tests whether a point with a given topological [Label](@ref geomgraph::Label)
* relative to two geometries is contained in
* the result of overlaying the geometries using
* a given overlay operation.
*
- * The method handles arguments of {@link Location#NONE} correctly
+ * The method handles arguments of [Location::UNDEF](@ref geom::Location::UNDEF) correctly
*
* @param label the topological label of the point
* @param opCode the code for the overlay operation to test
@@ -114,13 +114,13 @@ public:
*/
static bool isResultOfOp(const geomgraph::Label& label, OpCode opCode);
- /// This method will handle arguments of Location.NULL correctly
+ /// \brief This method will handle arguments of Location.NULL correctly
//
/// @return true if the locations correspond to the opCode
///
static bool isResultOfOp(int loc0, int loc1, OpCode opCode);
- /// Construct an OverlayOp with the given Geometry args.
+ /// \brief Construct an OverlayOp with the given Geometry args.
//
/// Ownership of passed args will remain to caller, and
/// the OverlayOp won't change them in any way.
@@ -129,7 +129,7 @@ public:
~OverlayOp() override; // FIXME: virtual ?
- /**
+ /** \brief
* Gets the result of the overlay for a given overlay operation.
*
* Note: this method can be called once only.
@@ -141,7 +141,7 @@ public:
geom::Geometry* getResultGeometry(OpCode overlayOpCode);
// throw(TopologyException *);
- /**
+ /** \brief
* Gets the graph constructed to compute the overlay.
*
* @return the overlay graph
@@ -156,8 +156,8 @@ public:
* This method is used to decide if a point node should be included
* in the result or not.
*
- * @return true if the coord point is covered by a result Line
- * or Area geometry
+ * @return `true` if the coord point is covered by a result Line
+ * or Area geometry
*/
bool isCoveredByLA(const geom::Coordinate& coord);
@@ -165,7 +165,7 @@ public:
* This method is used to decide if an L edge should be included
* in the result or not.
*
- * @return true if the coord point is covered by a result Area geometry
+ * @return `true` if the coord point is covered by a result Area geometry
*/
bool isCoveredByA(const geom::Coordinate& coord);
diff --git a/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h b/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
index 8bda9bb..4d4843a 100644
--- a/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
+++ b/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
@@ -39,12 +39,10 @@ namespace snap { // geos::operation::overlay::snap
* Performs an overlay operation using snapping and enhanced precision
* to improve the robustness of the result.
*
- * This class only uses snapping
- * if an error is detected when running the standard JTS overlay code.
- * Errors detected include thrown exceptions
- * (in particular, {@link TopologyException})
+ * This class only uses snapping if an error is detected when running
+ * the standard JTS overlay code. Errors detected include thrown exceptions
+ * (in particular, [TopologyException](@ref util::TopologyException))
* and invalid overlay computations.
- *
*/
class SnapIfNeededOverlayOp {
diff --git a/include/geos/operation/predicate/RectangleIntersects.h b/include/geos/operation/predicate/RectangleIntersects.h
index c8831ff..d4d4a45 100644
--- a/include/geos/operation/predicate/RectangleIntersects.h
+++ b/include/geos/operation/predicate/RectangleIntersects.h
@@ -41,7 +41,7 @@ namespace predicate { // geos::operation::predicate
* for cases where one Geometry is a rectangle.
*
* This class works for all input geometries, including
- * {@link GeometryCollection}s.
+ * [GeometryCollections](@ref geom::GeometryCollection).
*
* As a further optimization,
* this class can be used to test
diff --git a/include/geos/operation/relate/RelateOp.h b/include/geos/operation/relate/RelateOp.h
index 9b41950..ed46b08 100644
--- a/include/geos/operation/relate/RelateOp.h
+++ b/include/geos/operation/relate/RelateOp.h
@@ -41,17 +41,17 @@ namespace operation { // geos::operation
namespace relate { // geos::operation::relate
/** \brief
- * Implements the SFS <tt>relate()</tt> operation on two
+ * Implements the SFS `relate()` operation on two
* geom::Geometry objects.
*
* This class supports specifying a custom algorithm::BoundaryNodeRule
* to be used during the relate computation.
*
- * <b>Note:</b> custom Boundary Node Rules do not (currently)
+ * @note Custom Boundary Node Rules do not (currently)
* affect the results of other Geometry methods (such
- * as {@link Geometry::getBoundary}. The results of
- * these methods may not be consistent with the relationship computed by
- * a custom Boundary Node Rule.
+ * as [Geometry::getBoundary()](@ref geom::Geometry::getBoundary() const)).
+ * The results of these methods may not be consistent with the relationship
+ * computed by a custom Boundary Node Rule.
*
*/
class GEOS_DLL RelateOp: public GeometryGraphOperation {
@@ -76,7 +76,7 @@ public:
/** \brief
* Computes the geom::IntersectionMatrix for the spatial relationship
* between two geom::Geometry objects, using a specified
- * Boundary Node Rule
+ * Boundary Node Rule.
*
* @param a a Geometry to test. Ownership left to caller.
* @param b a Geometry to test. Ownership left to caller.
diff --git a/include/geos/operation/union/CascadedPolygonUnion.h b/include/geos/operation/union/CascadedPolygonUnion.h
index dc8cd85..638cd64 100644
--- a/include/geos/operation/union/CascadedPolygonUnion.h
+++ b/include/geos/operation/union/CascadedPolygonUnion.h
@@ -52,21 +52,21 @@ namespace geounion { // geos::operation::geounion
/**
* \brief
* Provides an efficient method of unioning a collection of
- * {@link geom::Polygonal} geometries.
+ * [Polygonal](@ref geom::Polygonal) geometries.
*
* This algorithm is faster and likely more robust than
* the simple iterated approach of
* repeatedly unioning each polygon to a result geometry.
*
- * The <tt>buffer(0)</tt> trick is sometimes faster, but can be less robust and
+ * The `buffer(0)` trick is sometimes faster, but can be less robust and
* can sometimes take an exceptionally long time to complete.
* This is particularly the case where there is a high degree of overlap
- * between the polygons. In this case, <tt>buffer(0)</tt> is forced to compute
- * with <i>all</i> line segments from the outset,
+ * between the polygons. In this case, `buffer(0)` is forced to compute
+ * with *all* line segments from the outset,
* whereas cascading can eliminate many segments
* at each stage of processing.
* The best case for buffer(0) is the trivial case
- * where there is <i>no</i> overlap between the input geometries.
+ * where there is `no` overlap between the input geometries.
* However, this case is likely rare in practice.
*/
class GEOS_DLL CascadedPolygonUnion {
@@ -84,12 +84,12 @@ private:
static int const STRTREE_NODE_CAPACITY = 4;
/**
- * Computes a {@link Geometry} containing only {@link Polygonal} components.
+ * Computes a {@link Geometry} containing only [Polygonal](@ref geom::Polygonal) components.
*
* Extracts the {@link Polygon}s from the input
- * and returns them as an appropriate {@link Polygonal} geometry.
+ * and returns them as an appropriate [Polygonal](@ref geom::Polygonal) geometry.
*
- * If the input is already <tt>Polygonal</tt>, it is returned unchanged.
+ * If the input is already `Polygonal`, it is returned unchanged.
*
* A particular use case is to filter out non-polygonal components
* returned from an overlay operation.
@@ -102,19 +102,19 @@ private:
public:
CascadedPolygonUnion();
- /**
- * Computes the union of
- * a collection of {@link geom::Polygonal} {@link geom::Geometry}s.
+ /** \brief
+ * Computes the union of a collection of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
*
- * @param polys a collection of {@link geom::Polygonal}
- * {@link geom::Geometry}s.
+ * @param polys a collection of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
* ownership of elements _and_ vector are left to caller.
*/
static geom::Geometry* Union(std::vector<geom::Polygon*>* polys);
- /**
- * Computes the union of a set of {@link geom::Polygonal}
- * {@link geom::Geometry}s.
+ /** \brief
+ * Computes the union of a set of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
*
* @tparam T an iterator yelding something castable to const Polygon *
* @param start start iterator
@@ -132,34 +132,34 @@ public:
return Union(&polys);
}
- /**
- * Computes the union of
- * a collection of {@link geom::Polygonal} {@link geom::Geometry}s.
+ /** \brief
+ * Computes the union of a collection of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
*
- * @param polys a collection of {@link geom::Polygonal}
- * {@link geom::Geometry}s.
- * Ownership of elements _and_ vector are left to caller.
+ * @param polys a collection of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
+ * Ownership of elements *and* vector are left to caller.
*/
static geom::Geometry* Union(const geom::MultiPolygon* polys);
- /**
+ /** \brief
* Creates a new instance to union
* the given collection of {@link geom::Geometry}s.
*
- * @param geoms a collection of {@link geom::Polygonal}
- * {@link geom::Geometry}s.
- * Ownership of elements _and_ vector are left to caller.
+ * @param polys a collection of [Polygonal](@ref geom::Polygonal)
+ * [Geometrys](@ref geom::Geometry).
+ * Ownership of elements *and* vector are left to caller.
*/
CascadedPolygonUnion(std::vector<geom::Polygon*>* polys)
: inputPolys(polys),
geomFactory(nullptr)
{}
- /**
+ /** \brief
* Computes the union of the input geometries.
*
* @return the union of the input geometries
- * @return null if no input geometries were provided
+ * @return `null` if no input geometries were provided
*/
geom::Geometry* Union();
diff --git a/include/geos/operation/union/PointGeometryUnion.h b/include/geos/operation/union/PointGeometryUnion.h
index 8ed31c4..3085cd4 100644
--- a/include/geos/operation/union/PointGeometryUnion.h
+++ b/include/geos/operation/union/PointGeometryUnion.h
@@ -38,8 +38,8 @@ namespace geounion { // geos::operation::geounion
/**
* \brief
- * Computes the union of a {@link Puntal} geometry with
- * another arbitrary {@link Geometry}.
+ * Computes the union of a [Puntal](@ref geom::Puntal) geometry with
+ * another arbitrary [Geometry](@ref geom::Geometry).
*
* Does not copy any component geometries.
*
diff --git a/include/geos/operation/union/UnaryUnionOp.h b/include/geos/operation/union/UnaryUnionOp.h
index e44e735..f32631c 100644
--- a/include/geos/operation/union/UnaryUnionOp.h
+++ b/include/geos/operation/union/UnaryUnionOp.h
@@ -49,34 +49,38 @@ namespace geos {
namespace operation { // geos::operation
namespace geounion { // geos::operation::geounion
-/**
+/** \brief
* Unions a collection of Geometry or a single Geometry
* (which may be a collection) together.
+ *
* By using this special-purpose operation over a collection of
* geometries it is possible to take advantage of various optimizations
* to improve performance.
- * Heterogeneous {@link GeometryCollection}s are fully supported.
+ * Heterogeneous [GeometryCollections](@ref geom::GeometryCollection)
+ * are fully supported.
*
* The result obeys the following contract:
*
- * - Unioning a set of overlapping {@link Polygons}s has the effect of
- * merging the areas (i.e. the same effect as
+ * - Unioning a set of overlapping [Polygons](@ref geom::Polygon) has the effect
+ * of merging the areas (i.e. the same effect as
* iteratively unioning all individual polygons together).
- * - Unioning a set of {@link LineString}s has the effect of
- * <b>fully noding</b> and <b>dissolving</b> the input linework.
+ * - Unioning a set of [LineStrings](@ref geom::LineString) has the effect of
+ * **fully noding** and **dissolving** the input linework.
* In this context "fully noded" means that there will be a node or
* endpoint in the output for every endpoint or line segment crossing
* in the input.
* "Dissolved" means that any duplicate (e.g. coincident) line segments
* or portions of line segments will be reduced to a single line segment
- * in the output. * This is consistent with the semantics of the
- * {@link Geometry#union(Geometry)} operation.
- * If <b>merged</b> linework is required, the {@link LineMerger} class
+ * in the output.
+ * This is consistent with the semantics of the
+ * [Geometry::Union(Geometry* )](@ref geom::Geometry::Union(const Geometry* other) const)
+ * operation. If **merged** linework is required, the
+ * [LineMerger](@ref operation::linemerge::LineMerger) class
* can be used.
- * - Unioning a set of {@link Points}s has the effect of merging
+ * - Unioning a set of [Points](@ref geom::Point) has the effect of merging
* al identical points (producing a set with no duplicates).
*
- * <tt>UnaryUnion</tt> always operates on the individual components of
+ * `UnaryUnion` always operates on the individual components of
* MultiGeometries.
* So it is possible to use it to "clean" invalid self-intersecting
* MultiPolygons (although the polygon components must all still be
diff --git a/include/geos/operation/valid/ConsistentAreaTester.h b/include/geos/operation/valid/ConsistentAreaTester.h
index e596e2e..d23dfa4 100644
--- a/include/geos/operation/valid/ConsistentAreaTester.h
+++ b/include/geos/operation/valid/ConsistentAreaTester.h
@@ -90,8 +90,8 @@ public:
/**
* Creates a new tester for consistent areas.
*
- * @param geomGraph the topology graph of the area geometry.
- * Caller keeps responsibility for its deletion
+ * @param newGeomGraph the topology graph of the area geometry.
+ * Caller keeps responsibility for its deletion
*/
ConsistentAreaTester(geomgraph::GeometryGraph* newGeomGraph);
diff --git a/include/geos/operation/valid/IsValidOp.h b/include/geos/operation/valid/IsValidOp.h
index 95795ab..0756870 100644
--- a/include/geos/operation/valid/IsValidOp.h
+++ b/include/geos/operation/valid/IsValidOp.h
@@ -56,7 +56,7 @@ namespace valid { // geos::operation::valid
/** \brief
* Implements the algorithsm required to compute the <code>isValid()</code>
- * method for {@link Geometry}s.
+ * method for [Geometrys](@ref geom::Geometry).
*/
class GEOS_DLL IsValidOp {
friend class Unload;
@@ -192,7 +192,7 @@ private:
bool isSelfTouchingRingFormingHoleValid;
public:
- /**
+ /** \brief
* Find a point from the list of testCoords
* that is NOT a node in the edge for the list of searchCoords
*
@@ -203,21 +203,21 @@ public:
const geom::LinearRing* searchRing,
geomgraph::GeometryGraph* graph);
- /**
+ /** \brief
* Checks whether a coordinate is valid for processing.
* Coordinates are valid iff their x and y coordinates are in the
* range of the floating point representation.
*
* @param coord the coordinate to validate
- * @return <code>true</code> if the coordinate is valid
+ * @return `true` if the coordinate is valid
*/
static bool isValid(const geom::Coordinate& coord);
- /**
- * Tests whether a {@link Geometry} is valid.
+ /** \brief
+ * Tests whether a geom::Geometry is valid.
*
* @param geom the Geometry to test
- * @return true if the geometry is valid
+ * @return `true` if the geometry is valid
*/
static bool isValid(const geom::Geometry& geom);
@@ -241,28 +241,25 @@ public:
TopologyValidationError* getValidationError();
/** \brief
- * Sets whether polygons using <b>Self-Touching Rings</b> to form
+ * Sets whether polygons using **Self-Touching Rings** to form
* holes are reported as valid.
*
* If this flag is set, the following Self-Touching conditions
* are treated as being valid:
- * <ul>
- * <li>the shell ring self-touches to create a hole touching the shell
- * <li>a hole ring self-touches to create two holes touching at a point
- * </ul>
- * <p>
+ *
+ * - the shell ring self-touches to create a hole touching the shell
+ * - a hole ring self-touches to create two holes touching at a point
+ *
* The default (following the OGC SFS standard)
- * is that this condition is <b>not</b> valid (<code>false</code>).
- * <p>
+ * is that this condition is **not** valid (`false`).
+ *
* This does not affect whether Self-Touching Rings
* disconnecting the polygon interior are considered valid
- * (these are considered to be <b>invalid</b> under the SFS,
+ * (these are considered to be **invalid** under the SFS,
* and many other spatial models as well).
- * This includes "bow-tie" shells,
- * which self-touch at a single point causing the interior to
- * be disconnected,
- * and "C-shaped" holes which self-touch at a single point causing
- * an island to be formed.
+ * This includes "bow-tie" shells, which self-touch at a single point
+ * causing the interior to be disconnected, and "C-shaped" holes which
+ * self-touch at a single point causing an island to be formed.
*
* @param p_isValid states whether geometry with this condition is valid
*/
diff --git a/include/geos/operation/valid/QuadtreeNestedRingTester.h b/include/geos/operation/valid/QuadtreeNestedRingTester.h
index 698a64a..a5600b3 100644
--- a/include/geos/operation/valid/QuadtreeNestedRingTester.h
+++ b/include/geos/operation/valid/QuadtreeNestedRingTester.h
@@ -52,8 +52,8 @@ namespace operation { // geos::operation
namespace valid { // geos::operation::valid
/** \brief
- * Tests whether any of a set of {@link LinearRing}s are
- * nested inside another ring in the set, using a {@link Quadtree}
+ * Tests whether any of a set of [LinearRings](@ref geom::LinearRing) are nested
+ * inside another ring in the set, using a [Quadtree](@ref index::quadtree::Quadtree)
* index to speed up the comparisons.
*
*/
diff --git a/include/geos/operation/valid/SimpleNestedRingTester.h b/include/geos/operation/valid/SimpleNestedRingTester.h
index d6d7de1..963c92b 100644
--- a/include/geos/operation/valid/SimpleNestedRingTester.h
+++ b/include/geos/operation/valid/SimpleNestedRingTester.h
@@ -46,7 +46,7 @@ namespace operation { // geos::operation
namespace valid { // geos::operation::valid
/** \brief
- * Tests whether any of a set of {@link LinearRing}s are
+ * Tests whether any of a set of [LinearRings](@ref geom::LinearRing) are
* nested inside another ring in the set, using a simple O(n^2)
* comparison.
*
diff --git a/include/geos/operation/valid/SweeplineNestedRingTester.h b/include/geos/operation/valid/SweeplineNestedRingTester.h
index 71ba081..8f9ac2d 100644
--- a/include/geos/operation/valid/SweeplineNestedRingTester.h
+++ b/include/geos/operation/valid/SweeplineNestedRingTester.h
@@ -55,9 +55,10 @@ namespace operation { // geos::operation
namespace valid { // geos::operation::valid
/** \brief
- * Tests whether any of a set of {@link LinearRing}s are
+ * Tests whether any of a set of [LinearRings](@ref geom::LinearRing) are
* nested inside another ring in the set, using an
- * index::sweepline::SweepLineIndex to speed up the comparisons.
+ * [SweepLineIndex](@ref index::sweepline::SweepLineIndex) to speed up
+ * the comparisons.
*/
class GEOS_DLL SweeplineNestedRingTester {
diff --git a/include/geos/operation/valid/TopologyValidationError.h b/include/geos/operation/valid/TopologyValidationError.h
index f290899..cca3721 100644
--- a/include/geos/operation/valid/TopologyValidationError.h
+++ b/include/geos/operation/valid/TopologyValidationError.h
@@ -33,7 +33,7 @@ namespace operation { // geos::operation
namespace valid { // geos::operation::valid
/** \brief
- * Contains information about the nature and location of a {@link Geometry}
+ * Contains information about the nature and location of a geom::Geometry
* validation error
*
*/
diff --git a/include/geos/planargraph/DirectedEdge.h b/include/geos/planargraph/DirectedEdge.h
index 98db535..ac4911a 100644
--- a/include/geos/planargraph/DirectedEdge.h
+++ b/include/geos/planargraph/DirectedEdge.h
@@ -72,7 +72,7 @@ public:
* Returns a List containing the parent Edge (possibly null)
* for each of the given DirectedEdges.
*
- * NOTE: ownership of the returned vector is left to
+ * @note Ownership of the returned vector is left to
* the caller, see the equivalent function taking a vector
* reference to avoid this.
*/
@@ -84,20 +84,22 @@ public:
* Add parent Edge (possibly null) of each of the given DirectedEdges
* to the given parentEdges vector.
*
- * NOTE: parents are pushed to the parentEdges vector, make sure
+ * @note Parents are pushed to the parentEdges vector, make sure
* it is empty if index-based corrispondence is important.
*/
static void toEdges(std::vector<DirectedEdge*>& dirEdges,
std::vector<Edge*>& parentEdges);
/**
- * \brief Constructs a DirectedEdge connecting the <code>from</code>
- * node to the <code>to</code> node.
+ * \brief Constructs a DirectedEdge connecting the `from`
+ * node to the `to` node.
*
+ * @param newFrom `from` node
+ * @param newTo `to` node
* @param directionPt specifies this DirectedEdge's direction
* (given by an imaginary line from the
- * <code>from</code> node to
- * <code>directionPt</code>)
+ * `from` node to
+ * `directionPt`)
* @param newEdgeDirection whether this DirectedEdge's direction
* is the same as or opposite to that of the
* parent Edge (if any)
diff --git a/include/geos/planargraph/Edge.h b/include/geos/planargraph/Edge.h
index 089b3df..506a744 100644
--- a/include/geos/planargraph/Edge.h
+++ b/include/geos/planargraph/Edge.h
@@ -74,27 +74,20 @@ protected:
/** \brief The two DirectedEdges associated with this Edge */
std::vector<DirectedEdge*> dirEdge;
- /**
- * \brief Constructs an Edge whose DirectedEdges are not yet set.
- *
- * Be sure to call setDirectedEdges(DirectedEdge, DirectedEdge)
- */
-
public:
/** \brief
- * Constructs a Edge whose DirectedEdges are
- * not yet set.
+ * Constructs a Edge whose DirectedEdges are not yet set.
*
* Be sure to call
- * {@link setDirectedEdges(DirectedEdge, DirectedEdge)}
+ * {@link #setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1)}
*/
Edge(): dirEdge() {}
/**
* \brief Constructs an Edge initialized with the given DirectedEdges.
*
- * For each DirectedEdge: sets the Edge, sets the symmetric
+ * For each DirectedEdge: sets the Edge, sets the symmetric
* DirectedEdge, and adds this Edge to its from-Node.
*/
Edge(DirectedEdge* de0, DirectedEdge* de1)
@@ -108,8 +101,8 @@ public:
* \brief Initializes this Edge's two DirectedEdges.
*
* For each DirectedEdge:
- * sets the Edge, sets the symmetric DirectedEdge, and
- * adds this Edge to its from-Node.
+ * - sets the Edge, sets the symmetric DirectedEdge, and
+ * - adds this Edge to its from-Node.
*/
void setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1);
diff --git a/include/geos/planargraph/PlanarGraph.h b/include/geos/planargraph/PlanarGraph.h
index 2001948..f871736 100644
--- a/include/geos/planargraph/PlanarGraph.h
+++ b/include/geos/planargraph/PlanarGraph.h
@@ -219,9 +219,8 @@ public:
}
/**
- * \brief
* Returns the Edges that have been added to this PlanarGraph
- * @see #add(Edge)
+ * @see PlanarGraph::add(Edge* edge)
*/
std::vector<Edge*>*
getEdges()
diff --git a/include/geos/planargraph/Subgraph.h b/include/geos/planargraph/Subgraph.h
index c724f7a..d5a4748 100644
--- a/include/geos/planargraph/Subgraph.h
+++ b/include/geos/planargraph/Subgraph.h
@@ -38,21 +38,21 @@ class Edge;
namespace geos {
namespace planargraph { // geos.planargraph
-/// A subgraph of a PlanarGraph.
+/// \brief A subgraph of a PlanarGraph.
//
-/// A subgraph may contain any subset of geomgraph::Edges
+/// A subgraph may contain any subset of {@link Edge}s
/// from the parent graph.
-/// It will also automatically contain all geomgraph::DirectedEdge
-/// and geomgraph::Node associated with those edges.
+/// It will also automatically contain all {@link DirectedEdge}s
+/// and {@link Node}s associated with those edges.
/// No new objects are created when edges are added -
/// all associated components must already exist in the parent graph.
///
-/// @@ Actually we'll be copying Coordinates in NodeMap.
+/// @note Actually we'll be copying Coordinates in NodeMap.
/// I guess that'll need to be changed soon.
///
class GEOS_DLL Subgraph {
public:
- /**
+ /** \brief
* Creates a new subgraph of the given PlanarGraph
*
* @param parent the parent graph
@@ -62,8 +62,8 @@ public:
parentGraph(parent)
{}
- /**
- * Gets the {@link PlanarGraph} which this subgraph
+ /** \brief
+ * Gets the PlanarGraph which this subgraph
* is part of.
*
* @return the parent PlanarGraph
@@ -74,22 +74,23 @@ public:
return parentGraph;
}
- /**
- * Adds an {@link Edge} to the subgraph.
- * The associated {@link DirectedEdge}s and {@link planarNode}s
+ /** \brief
+ * Adds an Edge to the subgraph.
+ *
+ * The associated {@link DirectedEdge}s and {@link Node}s
* are also added.
*
* @param e the edge to add
*
* @return a pair with first element being an iterator
* to the Edge in set and second element
- * being a boolean value indicating wheter
- * the Edge has been inserted now or was
- * already in the set.
+ * being a boolean value indicating wheter
+ * the Edge has been inserted now or was
+ * already in the set.
*/
std::pair<std::set<Edge*>::iterator, bool> add(Edge* e);
- /**
+ /** \brief
* Returns an iterator over the DirectedEdge in this graph,
* in the order in which they were added.
*
@@ -104,8 +105,8 @@ public:
}
- /**
- * Returns an {@link Iterator} over the {@link Edge}s in this
+ /** \brief
+ * Returns an iterator over the {@link Edge}s in this
* graph, in the order in which they were added.
*
* @return an iterator over the edges
@@ -123,8 +124,8 @@ public:
return edges.end();
}
- /**
- * Returns a iterators over the planarNodesMap::container
+ /** \brief
+ * Returns a iterators over the planar NodeMap::container
* in this graph.
*/
NodeMap::container::iterator
@@ -148,10 +149,11 @@ public:
return nodeMap.begin();
}
- /**
- * Tests whether an {@link Edge} is contained in this subgraph
+ /** \brief
+ * Tests whether an {@link Edge} is contained in this subgraph.
+ *
* @param e the edge to test
- * @return <code>true</code> if the edge is contained in this subgraph
+ * @return `true` if the edge is contained in this subgraph
*/
bool
contains(Edge* e)
diff --git a/include/geos/precision/CommonBitsOp.h b/include/geos/precision/CommonBitsOp.h
index 435c6c9..9a33786 100644
--- a/include/geos/precision/CommonBitsOp.h
+++ b/include/geos/precision/CommonBitsOp.h
@@ -77,20 +77,20 @@ private:
public:
- /**
+ /** \brief
* Creates a new instance of class, which reshifts result Geometry
*/
CommonBitsOp();
- /**
+ /** \brief
* Creates a new instance of class, specifying whether
- * the result {@link Geometry}s should be reshifted.
+ * the result {@link geom::Geometry}s should be reshifted.
*
- * @param returnToOriginalPrecision
+ * @param nReturnToOriginalPrecision
*/
CommonBitsOp(bool nReturnToOriginalPrecision);
- /**
+ /** \brief
* Computes the set-theoretic intersection of two Geometry,
* using enhanced precision.
* @param geom0 the first Geometry
@@ -102,7 +102,7 @@ public:
const geom::Geometry* geom0,
const geom::Geometry* geom1);
- /**
+ /** \brief
* Computes the set-theoretic union of two Geometry,
* using enhanced precision.
* @param geom0 the first Geometry
@@ -114,7 +114,7 @@ public:
const geom::Geometry* geom0,
const geom::Geometry* geom1);
- /**
+ /** \brief
* Computes the set-theoretic difference of two Geometry,
* using enhanced precision.
* @param geom0 the first Geometry
@@ -126,7 +126,7 @@ public:
const geom::Geometry* geom0,
const geom::Geometry* geom1);
- /**
+ /** \brief
* Computes the set-theoretic symmetric difference of two geometries,
* using enhanced precision.
* @param geom0 the first Geometry
@@ -138,7 +138,7 @@ public:
const geom::Geometry* geom0,
const geom::Geometry* geom1);
- /**
+ /** \brief
* Computes the buffer a geometry,
* using enhanced precision.
* @param geom0 the Geometry to buffer
@@ -149,7 +149,7 @@ public:
const geom::Geometry* geom0,
double distance);
- /**
+ /** \brief
* If required, returning the result to the orginal precision
* if required.
*
diff --git a/include/geos/simplify/TaggedLinesSimplifier.h b/include/geos/simplify/TaggedLinesSimplifier.h
index d8fa3f7..4a12e66 100644
--- a/include/geos/simplify/TaggedLinesSimplifier.h
+++ b/include/geos/simplify/TaggedLinesSimplifier.h
@@ -69,18 +69,14 @@ public:
*/
void setDistanceTolerance(double tolerance);
- /**
+ /** \brief
* Simplify a set of {@link TaggedLineString}s
*
- * @param iterator_type
- * an iterator, must support assignment, increment,
- * inequality and dereference operators.
- * Dereference operator must return a TaggedLineString*
- *
- * @param begin iterator to the first element
- * to be simplified.
- * @param end an iterator to one-past-last element
- * to be simplified.
+ * @tparam iterator_type an iterator, must support assignment, increment,
+ * inequality and dereference operators. Dereference
+ * operator must return a `TaggedLineString*`.
+ * @param begin iterator to the first element to be simplified.
+ * @param end an iterator to one-past-last element to be simplified.
*/
template <class iterator_type>
void
diff --git a/include/geos/triangulate/DelaunayTriangulationBuilder.h b/include/geos/triangulate/DelaunayTriangulationBuilder.h
index 3f79bd6..ce53f6c 100644
--- a/include/geos/triangulate/DelaunayTriangulationBuilder.h
+++ b/include/geos/triangulate/DelaunayTriangulationBuilder.h
@@ -105,7 +105,7 @@ public:
* Sets the sites (vertices) which will be triangulated
* from a collection of {@link geom::Coordinate}s.
*
- * @param geom a CoordinateSequence.
+ * @param coords a CoordinateSequence.
*/
void setSites(const geom::CoordinateSequence& coords);
diff --git a/include/geos/triangulate/VoronoiDiagramBuilder.h b/include/geos/triangulate/VoronoiDiagramBuilder.h
index 81f47f4..780d503 100644
--- a/include/geos/triangulate/VoronoiDiagramBuilder.h
+++ b/include/geos/triangulate/VoronoiDiagramBuilder.h
@@ -33,10 +33,10 @@ class GeometryFactory;
}
namespace triangulate { //geos.triangulate
-/**
- * A utility class which creates Voronoi Diagrams
- * from collections of points.
- * The diagram is returned as a {@link GeometryCollection} of {@link Polygon}s,
+/** \brief
+ * A utility class which creates Voronoi Diagrams from collections of points.
+ *
+ * The diagram is returned as a geom::GeometryCollection of {@link geom::Polygon}s,
* clipped to the larger of a supplied envelope or to an envelope determined
* by the input sites.
*
@@ -45,7 +45,7 @@ namespace triangulate { //geos.triangulate
*/
class GEOS_DLL VoronoiDiagramBuilder {
public:
- /**
+ /** \brief
* Creates a new Voronoi diagram builder.
*
*/
@@ -53,7 +53,7 @@ public:
~VoronoiDiagramBuilder();
- /**
+ /** \brief
* Sets the sites (point or vertices) which will be diagrammed.
* All vertices of the given geometry will be used as sites.
*
@@ -61,16 +61,17 @@ public:
*/
void setSites(const geom::Geometry& geom);
- /**
+ /** \brief
* Sets the sites (point or vertices) which will be diagrammed
- * from a collection of {@link Coordinate}s.
+ * from a collection of {@link geom::Coordinate}s.
*
* @param coords a collection of Coordinates.
*/
void setSites(const geom::CoordinateSequence& coords);
- /**
+ /** \brief
* Sets the envelope to clip the diagram to.
+ *
* The diagram will be clipped to the larger
* of this envelope or an envelope surrounding the sites.
*
@@ -80,34 +81,35 @@ public:
*/
void setClipEnvelope(const geom::Envelope* clipEnv);
- /**
+ /** \brief
* Sets the snapping tolerance which will be used
* to improved the robustness of the triangulation computation.
+ *
* A tolerance of 0.0 specifies that no snapping will take place.
*
* @param tolerance the tolerance distance to use
*/
void setTolerance(double tolerance);
- /**
- * Gets the {@link QuadEdgeSubdivision} which models the computed diagram.
+ /** \brief
+ * Gets the quadedge::QuadEdgeSubdivision which models the computed diagram.
*
* @return the subdivision containing the triangulation
*/
std::unique_ptr<quadedge::QuadEdgeSubdivision> getSubdivision();
- /**
- * Gets the faces of the computed diagram as a {@link GeometryCollection}
- * of {@link Polygon}s, clipped as specified.
+ /** \brief
+ * Gets the faces of the computed diagram as a geom::GeometryCollection
+ * of {@link geom::Polygon}s, clipped as specified.
*
* @param geomFact the geometry factory to use to create the output
* @return the faces of the diagram
*/
std::unique_ptr<geom::GeometryCollection> getDiagram(const geom::GeometryFactory& geomFact);
- /**
- * Gets the faces of the computed diagram as a {@link GeometryCollection}
- * of {@link LineString}s, clipped as specified.
+ /** \brief
+ * Gets the faces of the computed diagram as a geom::GeometryCollection
+ * of {@link geom::LineString}s, clipped as specified.
*
* @param geomFact the geometry factory to use to create the output
* @return the faces of the diagram
diff --git a/include/geos/triangulate/quadedge/QuadEdge.h b/include/geos/triangulate/quadedge/QuadEdge.h
index 0ed90b9..20d7da2 100644
--- a/include/geos/triangulate/quadedge/QuadEdge.h
+++ b/include/geos/triangulate/quadedge/QuadEdge.h
@@ -28,21 +28,21 @@ namespace geos {
namespace triangulate { //geos.triangulate
namespace quadedge { //geos.triangulate.quadedge
-/**
+/** \brief
* A class that represents the edge data structure which implements the quadedge algebra.
+ *
* The quadedge algebra was described in a well-known paper by Guibas and Stolfi,
* "Primitives for the manipulation of general subdivisions and the computation of Voronoi diagrams",
- * <i>ACM Transactions on Graphics</i>, 4(2), 1985, 75-123.
+ * *ACM Transactions on Graphics*, 4(2), 1985, 75-123.
*
- * Each edge object is part of a quartet of 4 edges,
- * linked via their <tt>_rot</tt> references.
+ * Each edge object is part of a quartet of 4 edges, linked via their `_rot` references.
* Any edge in the group may be accessed using a series of {@link #rot()} operations.
- * Quadedges in a subdivision are linked together via their <tt>next</tt> references.
+ * Quadedges in a subdivision are linked together via their `next` references.
* The linkage between the quadedge quartets determines the topology
* of the subdivision.
*
* The edge class does not contain separate information for vertice or faces; a vertex is implicitly
- * defined as a ring of edges (created using the <tt>next</tt> field).
+ * defined as a ring of edges (created using the `next` field).
*
* @author JTS: David Skea
* @author JTS: Martin Davis
@@ -50,7 +50,7 @@ namespace quadedge { //geos.triangulate.quadedge
* */
class GEOS_DLL QuadEdge {
public:
- /**
+ /** \brief
* Creates a new QuadEdge quartet from {@link Vertex} o to {@link Vertex} d.
*
* @param o the origin Vertex
@@ -60,21 +60,23 @@ public:
*/
static std::unique_ptr<QuadEdge> makeEdge(const Vertex& o, const Vertex& d);
- /**
+ /** \brief
* Creates a new QuadEdge connecting the destination of a to the origin of
* b, in such a way that all three have the same left face after the
- * connection is complete. Additionally, the data pointers of the new edge
- * are set.
+ * connection is complete.
+ *
+ * Additionally, the data pointers of the new edge are set.
*
* @return the new QuadEdge* The caller is reponsible for
- * freeing the returned pointer
+ * freeing the returned pointer
*/
static std::unique_ptr<QuadEdge> connect(QuadEdge& a, QuadEdge& b);
- /**
+ /** \brief
* Splices two edges together or apart.
+ *
* Splice affects the two edge rings around the origins of a and b, and, independently, the two
- * edge rings around the left faces of <tt>a</tt> and <tt>b</tt>.
+ * edge rings around the left faces of `a` and `b`.
* In each case, (i) if the two rings are distinct,
* Splice will combine them into one, or (ii) if the two are the same ring, Splice will break it
* into two separate pieces. Thus, Splice can be used both to attach the two edges together, and
@@ -86,7 +88,7 @@ public:
*/
static void splice(QuadEdge& a, QuadEdge& b);
- /**
+ /** \brief
* Turns an edge counterclockwise inside its enclosing quadrilateral.
*
* @param e the quadedge to turn
@@ -110,54 +112,57 @@ private:
public:
virtual ~QuadEdge();
- /**
+ /** \brief
* Free the QuadEdge quartet associated with this QuadEdge by a connect()
* or makeEdge() call.
- * DO NOT call this function on a QuadEdge that was not returned
+ *
+ * @note DO NOT call this function on a QuadEdge that was not returned
* by connect() or makeEdge().
*/
virtual void free();
- /**
- * Gets the primary edge of this quadedge and its <tt>sym</tt>.
+ /** \brief
+ * Gets the primary edge of this quadedge and its `sym`.
+ *
* The primary edge is the one for which the origin
* and destination coordinates are ordered
- * according to the standard {@link Coordinate} ordering
+ * according to the standard geom::Coordinate ordering
*
* @return the primary quadedge
*/
const QuadEdge& getPrimary() const;
- /**
+ /** \brief
* Sets the external data value for this edge.
*
* @param data an object containing external data
*/
virtual void setData(void* data);
- /**
+ /** \brief
* Gets the external data value for this edge.
*
* @return the data object
*/
virtual void* getData();
- /**
+ /** \brief
* Marks this quadedge as being deleted.
+ *
* This does not free the memory used by
* this quadedge quartet, but indicates
* that this quadedge quartet no longer participates
* in a subdivision.
*
- * NOTE: called "delete" in JTS
+ * @note called "delete" in JTS
*
*/
void remove();
- /**
+ /** \brief
* Tests whether this edge has been deleted.
*
- * @return true if this edge has not been deleted.
+ * @return `true` if this edge has not been deleted.
*/
inline bool
isLive()
@@ -166,7 +171,7 @@ public:
}
- /**
+ /** \brief
* Sets the connected edge
*
* @param p_next edge
@@ -182,7 +187,7 @@ public:
***************************************************************************
*/
- /**
+ /** \brief
* Gets the dual of this edge, directed from its right to its left.
*
* @return the rotated edge
@@ -193,7 +198,7 @@ public:
return *_rot;
}
- /**
+ /** \brief
* Gets the dual of this edge, directed from its left to its right.
*
* @return the inverse rotated edge.
@@ -204,7 +209,7 @@ public:
return rot().sym();
}
- /**
+ /** \brief
* Gets the edge from the destination to the origin of this edge.
*
* @return the sym of the edge
@@ -215,7 +220,7 @@ public:
return rot().rot();
}
- /**
+ /** \brief
* Gets the next CCW edge around the origin of this edge.
*
* @return the next linked edge.
@@ -226,7 +231,7 @@ public:
return *next;
}
- /**
+ /** \brief
* Gets the next CW edge around (from) the origin of this edge.
*
* @return the previous edge.
@@ -237,7 +242,7 @@ public:
return rot().oNext().rot();
}
- /**
+ /** \brief
* Gets the next CCW edge around (into) the destination of this edge.
*
* @return the next destination edge.
@@ -248,7 +253,7 @@ public:
return sym().oNext().sym();
}
- /**
+ /** \brief
* Gets the next CW edge around (into) the destination of this edge.
*
* @return the previous destination edge.
@@ -259,7 +264,7 @@ public:
return invRot().oNext().invRot();
}
- /**
+ /** \brief
* Gets the CCW edge around the left face following this edge.
*
* @return the next left face edge.
@@ -270,7 +275,7 @@ public:
return invRot().oNext().rot();
}
- /**
+ /** \brief
* Gets the CCW edge around the left face before this edge.
*
* @return the previous left face edge.
@@ -281,7 +286,7 @@ public:
return oNext().sym();
}
- /**
+ /** \brief
* Gets the edge around the right face ccw following this edge.
*
* @return the next right face edge.
@@ -292,7 +297,7 @@ public:
return rot().oNext().invRot();
}
- /**
+ /** \brief
* Gets the edge around the right face ccw before this edge.
*
* @return the previous right face edge.
@@ -306,7 +311,7 @@ public:
/***********************************************************************************************
* Data Access
**********************************************************************************************/
- /**
+ /** \brief
* Sets the vertex for this edge's origin
*
* @param o the origin vertex
@@ -317,7 +322,7 @@ public:
vertex = o;
}
- /**
+ /** \brief
* Sets the vertex for this edge's destination
*
* @param d the destination vertex
@@ -328,7 +333,7 @@ public:
sym().setOrig(d);
}
- /**
+ /** \brief
* Gets the vertex for the edge's origin
*
* @return the origin vertex
@@ -339,7 +344,7 @@ public:
return vertex;
}
- /**
+ /** \brief
* Gets the vertex for the edge's destination
*
* @return the destination vertex
@@ -350,7 +355,7 @@ public:
return sym().orig();
}
- /**
+ /** \brief
* Gets the length of the geometry of this quadedge.
*
* @return the length of the quadedge
@@ -361,26 +366,26 @@ public:
return orig().getCoordinate().distance(dest().getCoordinate());
}
- /**
+ /** \brief
* Tests if this quadedge and another have the same line segment geometry,
* regardless of orientation.
*
* @param qe a quadege
- * @return true if the quadedges are based on the same line segment regardless of orientation
+ * @return `true` if the quadedges are based on the same line segment regardless of orientation
*/
bool equalsNonOriented(const QuadEdge& qe) const;
- /**
+ /** \brief
* Tests if this quadedge and another have the same line segment geometry
* with the same orientation.
*
* @param qe a quadege
- * @return true if the quadedges are based on the same line segment
+ * @return `true` if the quadedges are based on the same line segment
*/
bool equalsOriented(const QuadEdge& qe) const;
- /**
- * Creates a {@link LineSegment} representing the
+ /** \brief
+ * Creates a {@link geom::LineSegment} representing the
* geometry of this edge.
*
* @return a LineSegment
diff --git a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
index eb16295..85a7f08 100644
--- a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
+++ b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
@@ -50,24 +50,23 @@ class TriangleVisitor;
const double EDGE_COINCIDENCE_TOL_FACTOR = 1000;
-/**
- * A class that contains the {@link QuadEdge}s representing a planar
+/** \brief
+ * A class that contains the [QuadEdges](@ref QuadEdge) representing a planar
* subdivision that models a triangulation.
- * The subdivision is constructed using the
- * quadedge algebra defined in the classs {@link QuadEdge}.
- * All metric calculations
- * are done in the {@link Vertex} class.
- * In addition to a triangulation, subdivisions
- * support extraction of Voronoi diagrams.
+ *
+ * The subdivision is constructed using the quadedge algebra defined in the class QuadEdge.
+ *
+ * All metric calculations are done in the Vertex class.
+ * In addition to a triangulation, subdivisions support extraction of Voronoi diagrams.
* This is easily accomplished, since the Voronoi diagram is the dual
* of the Delaunay triangulation.
- * <p>
+ *
* Subdivisions can be provided with a tolerance value. Inserted vertices which
* are closer than this value to vertices already in the subdivision will be
* ignored. Using a suitable tolerance value can prevent robustness failures
* from happening during Delaunay triangulation.
- * <p>
- * Subdivisions maintain a <b>frame</b> triangle around the client-created
+ *
+ * Subdivisions maintain a **frame** triangle around the client-created
* edges. The frame is used to provide a bounded "container" for all edges
* within a TIN. Normally the frame edges, frame connecting edges, and frame
* triangles are not included in client processing.
@@ -80,14 +79,13 @@ class GEOS_DLL QuadEdgeSubdivision {
public:
typedef std::vector<QuadEdge*> QuadEdgeList;
- /**
- * Gets the edges for the triangle to the left of the given {@link QuadEdge}.
+ /** \brief
+ * Gets the edges for the triangle to the left of the given QuadEdge.
*
* @param startQE
* @param triEdge
*
- * @throws IllegalArgumentException
- * if the edges do not form a triangle
+ * @throws IllegalArgumentException if the edges do not form a triangle
*/
static void getTriangleEdges(const QuadEdge& startQE,
const QuadEdge* triEdge[3]);
@@ -103,15 +101,13 @@ private:
std::unique_ptr<QuadEdgeLocator> locator;
public:
- /**
+ /** \brief
* Creates a new instance of a quad-edge subdivision based on a frame triangle
- * that encloses a supplied bounding box. A new super-bounding box that
- * contains the triangle is computed and stored.
+ * that encloses a supplied bounding box.
+ * A new super-bounding box that contains the triangle is computed and stored.
*
- * @param env
- * the bouding box to surround
- * @param tolerance
- * the tolerance value for determining if two sites are equal
+ * @param env the bouding box to surround
+ * @param tolerance the tolerance value for determining if two sites are equal
*/
QuadEdgeSubdivision(const geom::Envelope& env, double tolerance);
@@ -123,9 +119,8 @@ private:
virtual void initSubdiv(QuadEdge* initEdges[3]);
public:
- /**
- * Gets the vertex-equality tolerance value
- * used in this subdivision
+ /** \brief
+ * Gets the vertex-equality tolerance value used in this subdivision
*
* @return the tolerance value
*/
@@ -135,7 +130,7 @@ public:
return tolerance;
}
- /**
+ /** \brief
* Gets the envelope of the Subdivision (including the frame).
*
* @return the envelope
@@ -146,7 +141,7 @@ public:
return frameEnv;
}
- /**
+ /** \brief
* Gets the collection of base {@link QuadEdge}s (one for every pair of
* vertices which is connected).
*
@@ -158,11 +153,11 @@ public:
return quadEdges;
}
- /**
- * Sets the {@link QuadEdgeLocator} to use for locating containing triangles
+ /** \brief
+ * Sets the QuadEdgeLocator to use for locating containing triangles
* in this subdivision.
*
- * @param locator
+ * @param p_locator
* a QuadEdgeLocator
*/
inline void
@@ -171,7 +166,7 @@ public:
this->locator = std::move(p_locator);
}
- /**
+ /** \brief
* Creates a new quadedge, recording it in the edges list.
*
* @param o
@@ -180,10 +175,11 @@ public:
*/
virtual QuadEdge& makeEdge(const Vertex& o, const Vertex& d);
- /**
+ /** \brief
* Creates a new QuadEdge connecting the destination of a to the origin of b,
* in such a way that all three have the same left face after the connection
- * is complete. The quadedge is recorded in the edges list.
+ * is complete.
+ * The quadedge is recorded in the edges list.
*
* @param a
* @param b
@@ -191,7 +187,7 @@ public:
*/
virtual QuadEdge& connect(QuadEdge& a, QuadEdge& b);
- /**
+ /** \brief
* Deletes a quadedge from the subdivision. Linked quadedges are updated to
* reflect the deletion.
*
@@ -200,35 +196,37 @@ public:
*/
void remove(QuadEdge& e);
- /**
+ /** \brief
* Locates an edge of a triangle which contains a location
- * specified by a Vertex v.
- * The edge returned has the
- * property that either v is on e, or e is an edge of a triangle containing v.
- * The search starts from startEdge amd proceeds on the general direction of v.
- * <p>
+ * specified by a Vertex `v`.
+ *
+ * The edge returned has the property that either v is on e,
+ * or e is an edge of a triangle containing v.
+ * The search starts from startEdge and proceeds on the general direction of v.
+ *
* This locate algorithm relies on the subdivision being Delaunay. For
* non-Delaunay subdivisions, this may loop for ever.
*
* @param v the location to search for
* @param startEdge an edge of the subdivision to start searching at
- * @returns a QuadEdge which contains v, or is on the edge of a triangle containing v
- * @throws LocateFailureException
- * if the location algorithm fails to converge in a reasonable
- * number of iterations. The returned pointer should not be
- * freed be the caller.
+ * @return a QuadEdge which contains v, or is on the edge of a triangle containing v
+ * @throws LocateFailureException if the location algorithm fails to converge in a
+ * reasonable number of iterations.
+ *
+ * @note The returned pointer **should not** be freed be the caller.
*/
QuadEdge* locateFromEdge(const Vertex& v,
const QuadEdge& startEdge) const;
- /**
+ /** \brief
* Finds a quadedge of a triangle containing a location
- * specified by a {@link Vertex}, if one exists.
+ * specified by a [Vertex](@ref triangulate::quadedge::Vertex), if one exists.
+ *
+ * @param v the vertex to locate
+ * @return a QuadEdge on the edge of a triangle which touches or contains the location
+ * @return `null` if no such triangle exists.
*
- * @param x the vertex to locate
- * @return a quadedge on the edge of a triangle which touches or contains the location
- * @return null if no such triangle exists. The returned pointer should not be
- * freed be the caller.
+ * @note The returned pointer **should not** be freed be the caller.
*/
inline QuadEdge*
locate(const Vertex& v) const
@@ -236,14 +234,15 @@ public:
return locator->locate(v);
}
- /**
+ /** \brief
* Finds a quadedge of a triangle containing a location
- * specified by a {@link Coordinate}, if one exists.
+ * specified by a geom::Coordinate, if one exists.
*
* @param p the Coordinate to locate
- * @return a quadedge on the edge of a triangle which touches or contains the location
- * @return null if no such triangle exists. The returned pointer should not be
- * freed be the caller.
+ * @return a QuadEdge on the edge of a triangle which touches or contains the location
+ * @return `null` if no such triangle exists.
+ *
+ * @note The returned pointer **should not** be freed be the caller.
*/
inline QuadEdge*
locate(const geom::Coordinate& p)
@@ -251,97 +250,93 @@ public:
return locator->locate(Vertex(p));
}
- /**
+ /** \brief
* Locates the edge between the given vertices, if it exists in the
* subdivision.
*
* @param p0 a coordinate
* @param p1 another coordinate
* @return the edge joining the coordinates, if present
- * @return null if no such edge exists
- * @return the caller _should not_ free the returned pointer
+ * @return `null` if no such edge exists
+ *
+ * @note the caller **should not** free the returned pointer
*/
QuadEdge* locate(const geom::Coordinate& p0, const geom::Coordinate& p1);
- /**
+ /** \brief
* Inserts a new site into the Subdivision, connecting it to the vertices of
* the containing triangle (or quadrilateral, if the split point falls on an
* existing edge).
- * <p>
+ *
* This method does NOT maintain the Delaunay condition. If desired, this must
* be checked and enforced by the caller.
- * <p>
+ *
* This method does NOT check if the inserted vertex falls on an edge. This
* must be checked by the caller, since this situation may cause erroneous
* triangulation
*
- * @param v
- * the vertex to insert
+ * @param v the vertex to insert
* @return a new quad edge terminating in v
*/
QuadEdge& insertSite(const Vertex& v);
- /**
+ /** \brief
* Tests whether a QuadEdge is an edge incident on a frame triangle vertex.
*
- * @param e
- * the edge to test
- * @return true if the edge is connected to the frame triangle
+ * @param e the edge to test
+ * @return `true` if the edge is connected to the frame triangle
*/
bool isFrameEdge(const QuadEdge& e) const;
- /**
+ /** \brief
* Tests whether a QuadEdge is an edge on the border of the frame facets and
* the internal facets. E.g. an edge which does not itself touch a frame
* vertex, but which touches an edge which does.
*
- * @param e
- * the edge to test
- * @return true if the edge is on the border of the frame
+ * @param e the edge to test
+ * @return `true` if the edge is on the border of the frame
*/
bool isFrameBorderEdge(const QuadEdge& e) const;
- /**
+ /** \brief
* Tests whether a vertex is a vertex of the outer triangle.
*
- * @param v
- * the vertex to test
- * @return true if the vertex is an outer triangle vertex
+ * @param v the vertex to test
+ * @return `true` if the vertex is an outer triangle vertex
*/
bool isFrameVertex(const Vertex& v) const;
- /**
- * Tests whether a {@link Coordinate} lies on a {@link QuadEdge}, up to a
- * tolerance determined by the subdivision tolerance.
+ /** \brief
+ * Tests whether a [Coordinate](@ref geom::Coordinate) lies on a QuadEdge,
+ * up to a tolerance determined by the subdivision tolerance.
*
- * @param e
- * a QuadEdge
- * @param p
- * a point
- * @return true if the vertex lies on the edge
+ * @param e a QuadEdge
+ * @param p a point
+ * @return ` true` if the vertex lies on the edge
*/
bool isOnEdge(const QuadEdge& e, const geom::Coordinate& p) const;
- /**
- * Tests whether a {@link Vertex} is the start or end vertex of a
- * {@link QuadEdge}, up to the subdivision tolerance distance.
+ /** \brief
+ * Tests whether a Vertex is the start or end vertex of a
+ * QuadEdge, up to the subdivision tolerance distance.
*
* @param e
* @param v
- * @return true if the vertex is a endpoint of the edge
+ * @return ` true` if the vertex is a endpoint of the edge
*/
bool isVertexOfEdge(const QuadEdge& e, const Vertex& v) const;
- /**
+ /** \brief
* Gets all primary quadedges in the subdivision.
- * A primary edge is a {@link QuadEdge}
- * which occupies the 0'th position in its array of associated quadedges.
- * These provide the unique geometric edges of the triangulation.
*
- * @param includeFrame true if the frame edges are to be included
+ * A primary edge is a QuadEdge which occupies the 0'th position in its
+ * array of associated quadedges. These provide the unique geometric
+ * edges of the triangulation.
+ *
+ * @param includeFrame `true` if the frame edges are to be included
* @return a List of QuadEdges. The caller takes ownership of the returned QuadEdgeList but not the
- * items it contains.
+ * items it contains.
*/
std::unique_ptr<QuadEdgeList> getPrimaryEdges(bool includeFrame);
@@ -356,14 +351,14 @@ private:
typedef std::unordered_set<QuadEdge*> QuadEdgeSet;
typedef std::vector<geom::CoordinateSequence*> TriList;
- /**
+ /** \brief
* The quadedges forming a single triangle.
- * Only one visitor is allowed to be active at a
- * time, so this is safe.
+ *
+ * Only one visitor is allowed to be active at a time, so this is safe.
*/
QuadEdge* triEdges[3];
- /**
+ /** \brief
* Stores the edges for a visited triangle. Also pushes sym (neighbour) edges
* on stack to visit later.
*
@@ -371,17 +366,16 @@ private:
* @param edgeStack
* @param includeFrame
* @return the visited triangle edges
- * @return null if the triangle should not be visited (for instance, if it is
+ * @return `null` if the triangle should not be visited (for instance, if it is
* outer)
*/
QuadEdge** fetchTriangleToVisit(QuadEdge* edge, QuadEdgeStack& edgeStack, bool includeFrame,
QuadEdgeSet& visitedEdges);
- /**
+ /** \brief
* Gets the coordinates for each triangle in the subdivision as an array.
*
- * @param includeFrame
- * true if the frame triangles should be included
+ * @param includeFrame true if the frame triangles should be included
* @param triList a list of Coordinate[4] representing each triangle
*/
void getTriangleCoordinates(TriList* triList, bool includeFrame);
@@ -391,29 +385,35 @@ private:
class TriangleCircumcentreVisitor;
public:
- /**
- * Gets the geometry for the edges in the subdivision as a {@link MultiLineString}
+ /** \brief
+ * Gets the geometry for the edges in the subdivision as a [MultiLineString](@ref geom::MultiLineString)
* containing 2-point lines.
*
* @param geomFact the GeometryFactory to use
- * @return a MultiLineString. The caller takes ownership of the returned object.
+ * @return a MultiLineString
+ * @note The caller takes ownership of the returned object.
*/
std::unique_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory& geomFact);
- /**
- * Gets the geometry for the triangles in a triangulated subdivision as a {@link GeometryCollection}
- * of triangular {@link Polygon}s.
- *
+ /** \brief
+ * Gets the geometry for the triangles in a triangulated subdivision as a
+ * [GeometryCollection](@ref geos::geom::GeometryCollection)
+ * of triangular [Polygons](@ref geos::geom::Polygon).
+
* @param geomFact the GeometryFactory to use
- * @return a GeometryCollection of triangular Polygons. The caller takes ownership of the returned object.
+ * @return a GeometryCollection of triangular polygons.
+
+ * @note The caller takes ownership of the returned object.
*/
std::unique_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory& geomFact);
- /**
+ /** \brief
* Gets the cells in the Voronoi diagram for this triangulation.
- * The cells are returned as a {@link GeometryCollection} of {@link Polygon}s
- * The userData of each polygon is set to be the {@link Coordinate}
- * of the cell site. This allows easily associating external
+ * The cells are returned as a [GeometryCollection](@ref geom::GeometryCollection)
+ * of [Polygons](@ref geom::Polygon).
+ *
+ * The userData of each polygon is set to be the [Coordinate](@ref geom::Coordinate)
+ * of the cell site. This allows easily associating external
* data associated with the sites to the cells.
*
* @param geomFact a geometry factory
@@ -421,11 +421,12 @@ public:
*/
std::unique_ptr<geom::GeometryCollection> getVoronoiDiagram(const geom::GeometryFactory& geomFact);
- /**
+ /** \brief
* Gets the cells in the Voronoi diagram for this triangulation.
- * The cells are returned as a {@link GeometryCollection} of {@link LineString}s
- * The userData of each polygon is set to be the {@link Coordinate}
- * of the cell site. This allows easily associating external
+ *
+ * The cells are returned as a [GeometryCollection](@ref geom::GeometryCollection) of
+ * [LineStrings](@ref geom::LineString). The userData of each polygon is set to be the
+ * [Coordinate](@ref geom::Coordinate) of the cell site. This allows easily associating external
* data associated with the sites to the cells.
*
* @param geomFact a geometry factory
@@ -433,23 +434,25 @@ public:
*/
std::unique_ptr<geom::MultiLineString> getVoronoiDiagramEdges(const geom::GeometryFactory& geomFact);
- /**
- * Gets a List of {@link Polygon}s for the Voronoi cells
+ /** \brief
+ * Gets a List of [Polygons](@ref geom::Polygon) for the Voronoi cells
* of this triangulation.
- * The userData of each polygon is set to be the {@link Coordinate}
- * of the cell site. This allows easily associating external
- * data associated with the sites to the cells.
+ *
+ * The userData of each polygon is set to be the [Coordinate](@ref geom::Coordinate)
+ * of the cell site. This allows easily associating external data associated
+ * with the sites to the cells.
*
* @param geomFact a geometry factory
* @return a List of Polygons
*/
std::vector<std::unique_ptr<geom::Geometry>> getVoronoiCellPolygons(const geom::GeometryFactory& geomFact);
- /**
- * Gets a List of {@link LineString}s for the Voronoi cells
+ /** \brief
+ * Gets a List of [LineStrings](@ref geom::LineString) for the Voronoi cells
* of this triangulation.
- * The userData of each LineString is set to be the {@link Coordinate}
- * of the cell site. This allows easily associating external
+ *
+ * The userData of each LineString is set to be the [Coordinate](@ref geom::Coordinate)
+ * of the cell site. This allows easily associating external
* data associated with the sites to the cells.
*
* @param geomFact a geometry factory
@@ -457,30 +460,27 @@ public:
*/
std::unique_ptr< std::vector<geom::Geometry*> > getVoronoiCellEdges(const geom::GeometryFactory& geomFact);
- /**
- * Gets a collection of {@link QuadEdge}s whose origin
- * vertices are a unique set which includes
- * all vertices in the subdivision.
- * The frame vertices can be included if required.
- * This is useful for algorithms which require traversing the
- * subdivision starting at all vertices.
- * Returning a quadedge for each vertex
- * is more efficient than
- * the alternative of finding the actual vertices
- * using {@link #getVertices} and then locating
+ /** \brief
+ * Gets a collection of [QuadEdges](@ref QuadEdge) whose origin vertices are a unique set
+ * which includes all vertices in the subdivision.
+ *
+ * The frame vertices can be included if required. This is useful for algorithms which require
+ * traversing the subdivision starting at all vertices.
+ * Returning a quadedge for each vertex is more efficient than the alternative
+ * of finding the actual vertices using `getVertices()` and then locating
* quadedges attached to them.
*
- * @param includeFrame true if the frame vertices should be included
+ * @param includeFrame `true` if the frame vertices should be included
* @return a collection of QuadEdge with the vertices of the subdivision as their origins
*/
std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList> getVertexUniqueEdges(bool includeFrame);
- /**
- * Gets the Voronoi cell around a site specified
- * by the origin of a QuadEdge.
- * The userData of the polygon is set to be the {@link Coordinate}
- * of the site. This allows attaching external
- * data associated with the site to this cell polygon.
+ /** \brief
+ * Gets the Voronoi cell around a site specified by the origin of a QuadEdge.
+ *
+ * The userData of the polygon is set to be the [Coordinate](@ref geom::Coordinate)
+ * of the site. This allows attaching external data associated with the site
+ * to this cell polygon.
*
* @param qe a quadedge originating at the cell site
* @param geomFact a factory for building the polygon
@@ -488,12 +488,12 @@ public:
*/
std::unique_ptr<geom::Geometry> getVoronoiCellPolygon(const QuadEdge* qe, const geom::GeometryFactory& geomFact);
- /**
- * Gets the Voronoi cell edge around a site specified
- * by the origin of a QuadEdge.
- * The userData of the LineString is set to be the {@link Coordinate}
- * of the site. This allows attaching external
- * data associated with the site to this cell polygon.
+ /** \brief
+ * Gets the Voronoi cell edge around a site specified by the origin of a QuadEdge.
+ *
+ * The userData of the LineString is set to be the [Coordinate](@ref geom::Coordinate)
+ * of the site. This allows attaching external data associated with
+ * the site to this cell polygon.
*
* @param qe a quadedge originating at the cell site
* @param geomFact a factory for building the polygon
diff --git a/include/geos/triangulate/quadedge/Vertex.h b/include/geos/triangulate/quadedge/Vertex.h
index b9137a3..b08f4dd 100644
--- a/include/geos/triangulate/quadedge/Vertex.h
+++ b/include/geos/triangulate/quadedge/Vertex.h
@@ -39,19 +39,17 @@ namespace geos {
namespace triangulate { //geos.triangulate
namespace quadedge { //geos.triangulate.quadedge
-/**
- * Models a site (node) in a {@link QuadEdgeSubdivision}.
- * The sites can be points on a line string representing a
- * linear site.
+/** \brief
+ * Models a site (node) in a QuadEdgeSubdivision.
+ *
+ * The sites can be points on a line string representing a linear site.
*
* The vertex can be considered as a vector with a norm, length, inner product, cross
* product, etc. Additionally, point relations (e.g., is a point to the left of a line, the circle
* defined by this point and two others, etc.) are also defined in this class.
*
- * It is common to want to attach user-defined data to
- * the vertices of a subdivision.
- * One way to do this is to subclass <tt>Vertex</tt>
- * to carry any desired information (see {@link ConstraintVertex}).
+ * It is common to want to attach user-defined data to the vertices of a subdivision.
+ * One way to do this is to subclass `Vertex` to carry any desired information.
*
* @author JTS: David Skea
* @author JTS: Martin Davis
diff --git a/include/geos/util/CoordinateArrayFilter.h b/include/geos/util/CoordinateArrayFilter.h
index e7c4d12..90ce416 100644
--- a/include/geos/util/CoordinateArrayFilter.h
+++ b/include/geos/util/CoordinateArrayFilter.h
@@ -26,7 +26,7 @@
namespace geos {
namespace util { // geos::util
-/**
+/** \brief
* A CoordinateFilter that adds read-only pointers
* to every Coordinate in a Geometry to a given
* vector.
@@ -37,10 +37,10 @@ class GEOS_DLL CoordinateArrayFilter: public geom::CoordinateFilter {
private:
geom::Coordinate::ConstVect& pts; // target vector reference
public:
- /**
+ /** \brief
* Constructs a CoordinateArrayFilter.
*
- * @param target The destination vector.
+ * @param target The destination vector.
*/
CoordinateArrayFilter(geom::Coordinate::ConstVect& target)
:
diff --git a/src/operation/valid/IndexedNestedRingTester.h b/src/operation/valid/IndexedNestedRingTester.h
index c72e514..f7b8c33 100644
--- a/src/operation/valid/IndexedNestedRingTester.h
+++ b/src/operation/valid/IndexedNestedRingTester.h
@@ -41,7 +41,7 @@ namespace operation { // geos.operation
namespace valid { // geos.operation.valid
/** \brief
- * Tests whether any of a set of {@link LinearRing}s are
+ * Tests whether any of a set of [LinearRings](@ref geom::LinearRing) are
* nested inside another ring in the set, using a spatial
* index to speed up the comparisons.
*
-----------------------------------------------------------------------
Summary of changes:
include/geos/algorithm/BoundaryNodeRule.h | 56 +++-
include/geos/algorithm/Centroid.h | 50 ++--
include/geos/algorithm/HCoordinate.h | 12 +-
include/geos/algorithm/MinimumDiameter.h | 54 ++--
include/geos/algorithm/Orientation.h | 80 +++---
include/geos/algorithm/PointLocation.h | 93 +++----
include/geos/algorithm/RayCrossingCounter.h | 73 ++---
include/geos/algorithm/RayCrossingCounterDD.h | 83 +++---
.../geos/algorithm/locate/PointOnGeometryLocator.h | 6 +-
.../algorithm/locate/SimplePointInAreaLocator.h | 76 +++---
include/geos/algorithm/ttmath/ttmathtypes.h | 2 +-
include/geos/geom.h | 4 +-
include/geos/geom/CoordinateArraySequence.h | 2 +-
include/geos/geom/CoordinateFilter.h | 18 +-
include/geos/geom/CoordinateSequenceFilter.h | 77 +++---
include/geos/geom/Envelope.h | 268 ++++++++----------
include/geos/geom/Geometry.h | 4 +-
include/geos/geom/LineString.h | 2 +-
include/geos/geom/LinearRing.h | 22 +-
include/geos/geom/MultiLineString.h | 30 +-
include/geos/geom/PrecisionModel.h | 5 +-
include/geos/geom/util/GeometryExtracter.h | 2 +-
include/geos/geom/util/GeometryTransformer.h | 43 ++-
include/geos/geomgraph/DirectedEdgeStar.h | 22 +-
include/geos/geomgraph/EdgeNodingValidator.h | 6 +-
include/geos/geomgraph/GeometryGraph.h | 19 +-
include/geos/geomgraph/Position.h | 18 +-
include/geos/index/bintree/Bintree.h | 27 +-
include/geos/index/chain/MonotoneChainBuilder.h | 19 +-
.../geos/index/chain/MonotoneChainOverlapAction.h | 19 +-
include/geos/index/strtree/AbstractSTRtree.h | 40 +--
include/geos/index/strtree/BoundablePair.h | 29 +-
include/geos/index/strtree/ItemDistance.h | 9 +-
include/geos/index/strtree/SIRtree.h | 1 +
include/geos/linearref/ExtractLineByLocation.h | 16 +-
include/geos/linearref/LengthIndexedLine.h | 55 ++--
include/geos/linearref/LengthLocationMap.h | 40 +--
include/geos/linearref/LinearGeometryBuilder.h | 24 +-
include/geos/linearref/LinearIterator.h | 50 ++--
include/geos/linearref/LinearLocation.h | 119 ++++----
include/geos/linearref/LocationIndexOfLine.h | 37 +--
include/geos/linearref/LocationIndexOfPoint.h | 36 +--
include/geos/linearref/LocationIndexedLine.h | 20 +-
include/geos/noding/BasicSegmentString.h | 32 +--
include/geos/noding/FastNodingValidator.h | 14 +-
.../geos/noding/FastSegmentSetIntersectionFinder.h | 2 +-
include/geos/noding/IntersectionAdder.h | 47 ++--
include/geos/noding/IntersectionFinderAdder.h | 14 +-
include/geos/noding/IteratedNoder.h | 15 +-
include/geos/noding/MCIndexNoder.h | 11 +-
.../noding/MCIndexSegmentSetMutualIntersector.h | 11 +-
include/geos/noding/NodedSegmentString.h | 13 +-
include/geos/noding/Noder.h | 8 +-
include/geos/noding/NodingIntersectionFinder.h | 113 ++++----
include/geos/noding/OrientedCoordinateArray.h | 2 +-
include/geos/noding/SegmentIntersectionDetector.h | 26 +-
include/geos/noding/SegmentSetMutualIntersector.h | 10 +-
include/geos/noding/SegmentString.h | 10 +-
include/geos/noding/SegmentStringUtil.h | 6 +-
include/geos/noding/SinglePassNoder.h | 15 +-
.../geos/noding/snapround/MCIndexPointSnapper.h | 16 +-
include/geos/opOverlay.h | 3 +-
include/geos/operation/IsSimpleOp.h | 28 +-
include/geos/operation/buffer/BufferBuilder.h | 2 +-
include/geos/operation/buffer/BufferOp.h | 30 +-
include/geos/operation/buffer/OffsetCurveBuilder.h | 28 +-
.../geos/operation/buffer/OffsetCurveSetBuilder.h | 11 +-
.../distance/ConnectedElementLocationFilter.h | 22 +-
include/geos/operation/intersection/Rectangle.h | 34 +--
.../operation/intersection/RectangleIntersection.h | 24 +-
.../intersection/RectangleIntersectionBuilder.h | 6 +-
.../operation/linemerge/LineMergeDirectedEdge.h | 34 +--
include/geos/operation/linemerge/LineSequencer.h | 58 ++--
include/geos/operation/overlay/MaximalEdgeRing.h | 4 +-
include/geos/operation/overlay/MinimalEdgeRing.h | 6 +-
include/geos/operation/overlay/OverlayOp.h | 26 +-
.../operation/overlay/snap/SnapIfNeededOverlayOp.h | 8 +-
.../geos/operation/predicate/RectangleIntersects.h | 2 +-
include/geos/operation/relate/RelateOp.h | 12 +-
.../geos/operation/union/CascadedPolygonUnion.h | 56 ++--
include/geos/operation/union/PointGeometryUnion.h | 4 +-
include/geos/operation/union/UnaryUnionOp.h | 26 +-
.../geos/operation/valid/ConsistentAreaTester.h | 4 +-
include/geos/operation/valid/IsValidOp.h | 39 ++-
.../operation/valid/QuadtreeNestedRingTester.h | 4 +-
.../geos/operation/valid/SimpleNestedRingTester.h | 2 +-
.../operation/valid/SweeplineNestedRingTester.h | 5 +-
.../geos/operation/valid/TopologyValidationError.h | 2 +-
include/geos/planargraph/DirectedEdge.h | 14 +-
include/geos/planargraph/Edge.h | 17 +-
include/geos/planargraph/PlanarGraph.h | 3 +-
include/geos/planargraph/Subgraph.h | 46 ++--
include/geos/precision/CommonBitsOp.h | 20 +-
include/geos/simplify/TaggedLinesSimplifier.h | 16 +-
.../triangulate/DelaunayTriangulationBuilder.h | 2 +-
include/geos/triangulate/VoronoiDiagramBuilder.h | 38 +--
include/geos/triangulate/quadedge/QuadEdge.h | 101 +++----
.../triangulate/quadedge/QuadEdgeSubdivision.h | 302 ++++++++++-----------
include/geos/triangulate/quadedge/Vertex.h | 14 +-
include/geos/util/CoordinateArrayFilter.h | 6 +-
src/operation/valid/IndexedNestedRingTester.h | 2 +-
101 files changed, 1561 insertions(+), 1533 deletions(-)
hooks/post-receive
--
GEOS
More information about the geos-commits
mailing list