[geos-commits] [SCM] GEOS branch master updated. 8b844facb246eb7eb9ab2791aeb07886eeea4a9d
git at osgeo.org
git at osgeo.org
Mon Aug 10 14:43:12 PDT 2020
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 8b844facb246eb7eb9ab2791aeb07886eeea4a9d (commit)
from 23d172214148f6dc1300d04cedce6dabd4fd7393 (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 8b844facb246eb7eb9ab2791aeb07886eeea4a9d
Author: Paul Ramsey <pramsey at cleverelephant.ca>
Date: Mon Aug 10 14:43:06 2020 -0700
Fix doxygen errors and re-enable CI test
diff --git a/include/geos/algorithm/CGAlgorithmsDD.h b/include/geos/algorithm/CGAlgorithmsDD.h
index e620389..df62696 100644
--- a/include/geos/algorithm/CGAlgorithmsDD.h
+++ b/include/geos/algorithm/CGAlgorithmsDD.h
@@ -73,7 +73,7 @@ public:
double p2x, double p2y,
double qx, double qy);
- /** \brief
+ /**
* A filter for computing the orientation index of three coordinates.
*
* If the orientation can be computed safely using standard DP arithmetic,
@@ -86,13 +86,7 @@ public:
* average performance.
*
* Uses an approach due to Jonathan Shewchuk, which is in the public domain.
- *
- * @param pa a coordinate
- * @param pb a coordinate
- * @param pc a coordinate
- * @return the orientation index if it can be computed safely
- * @return `i > 1` if the orientation index cannot be computed safely
- */
+ */
static int orientationIndexFilter(double pax, double pay,
double pbx, double pby,
double pcx, double pcy);
diff --git a/include/geos/edgegraph/EdgeGraph.h b/include/geos/edgegraph/EdgeGraph.h
index 1e636c3..9edc20f 100644
--- a/include/geos/edgegraph/EdgeGraph.h
+++ b/include/geos/edgegraph/EdgeGraph.h
@@ -43,12 +43,12 @@ namespace edgegraph { // geos.edgegraph
* It supports tracking the vertices in the graph
* via edges incident on them,
* to allow efficient lookup of edges and vertices.
- * <p>
+ *
* This class may be subclassed to use a
* different subclass of HalfEdge,
- * by overriding {@link #createEdge(Coordinate)}.
+ * by overriding {@link createEdge}.
* If additional logic is required to initialize
- * edges then {@link EdgeGraph#addEdge(Coordinate, Coordinate)}
+ * edges then {@link addEdge}
* can be overridden as well.
*
* @author Martin Davis
@@ -104,7 +104,7 @@ public:
* @return the created edge
* @return null if the edge was invalid and not added
*
- * @see #isValidEdge(Coordinate, Coordinate)
+ * @see isValidEdge(Coordinate, Coordinate)
*/
HalfEdge* addEdge(const geom::Coordinate& orig, const geom::Coordinate& dest);
diff --git a/include/geos/edgegraph/EdgeGraphBuilder.h b/include/geos/edgegraph/EdgeGraphBuilder.h
index eafbaec..38fe035 100644
--- a/include/geos/edgegraph/EdgeGraphBuilder.h
+++ b/include/geos/edgegraph/EdgeGraphBuilder.h
@@ -72,7 +72,7 @@ public:
void add(const geom::LineString* linestring);
/**
- * Adds the edges in a collection of {@link Geometry}s to the graph.
+ * Adds the edges in a collection of {@link geom::Geometry} to the graph.
* May be called multiple times.
* Any dimension of Geometry may be added.
*
diff --git a/include/geos/edgegraph/HalfEdge.h b/include/geos/edgegraph/HalfEdge.h
index 9c1df75..ccfa334 100644
--- a/include/geos/edgegraph/HalfEdge.h
+++ b/include/geos/edgegraph/HalfEdge.h
@@ -32,26 +32,26 @@ namespace edgegraph { // geos.edgegraph
/**
* Represents a directed component of an edge in an {@link EdgeGraph}.
- * HalfEdges link vertices whose locations are defined by {@link Coordinate}s.
- * HalfEdges start at an <b>origin</b> vertex,
- * and terminate at a <b>destination</b> vertex.
- * HalfEdges always occur in symmetric pairs, with the {@link #sym()} method
+ * HalfEdges link vertices whose locations are defined by {@link geom::Coordinate}s.
+ * HalfEdges start at an origin vertex,
+ * and terminate at a destination vertex.
+ * HalfEdges always occur in symmetric pairs, with the {@link sym()} method
* giving access to the oppositely-oriented component.
* HalfEdges and the methods on them form an edge algebra,
* which can be used to traverse and query the topology
* of the graph formed by the edges.
- * <p>
+ *
* To support graphs where the edges are sequences of coordinates
* each edge may also have a direction point supplied.
* This is used to determine the ordering
* of the edges around the origin.
* HalfEdges with the same origin are ordered
* so that the ring of edges formed by them is oriented CCW.
- * <p>
+ *
* By design HalfEdges carry minimal information
* about the actual usage of the graph they represent.
* They can be subclassed to carry more information if required.
- * <p>
+ *
* HalfEdges form a complete and consistent data structure by themselves,
* but an {@link EdgeGraph} is useful to allow retrieving edges
* by vertex and edge location, as well as ensuring
@@ -124,7 +124,7 @@ public:
/**
* Creates a half-edge originating from a given coordinate.
*
- * @param orig the origin coordinate
+ * @param p_orig the origin coordinate
*/
HalfEdge(const geom::Coordinate& p_orig) :
m_orig(p_orig)
@@ -144,7 +144,7 @@ public:
* Links this edge with its sym (opposite) edge.
* This must be done for each pair of edges created.
*
- * @param e the sym edge to link.
+ * @param p_sym the sym edge to link.
*/
void link(HalfEdge* p_sym);
@@ -258,26 +258,25 @@ public:
/**
* Implements the total order relation:
- * <p>
+ *
* The angle of edge a is greater than the angle of edge b,
* where the angle of an edge is the angle made by
* the first segment of the edge with the positive x-axis
- * <p>
+ *
* When applied to a list of edges originating at the same point,
* this produces a CCW ordering of the edges around the point.
- * <p>
+ *
* Using the obvious algorithm of computing the angle is not robust,
* since the angle calculation is susceptible to roundoff error.
* A robust algorithm is:
- * <ul>
- * <li>First, compare the quadrants the edge vectors lie in.
- * If the quadrants are different,
- * it is trivial to determine which edge has a greater angle.
*
- * <li>if the vectors lie in the same quadrant, the
- * {@link Orientation#index(Coordinate, Coordinate, Coordinate)} function
- * can be used to determine the relative orientation of the vectors.
- * </ul>
+ * * First, compare the quadrants the edge vectors lie in.
+ * If the quadrants are different,
+ * it is trivial to determine which edge has a greater angle.
+ *
+ * * if the vectors lie in the same quadrant, the
+ * geom::Orientation::index() function
+ * can be used to determine the relative orientation of the vectors.
*/
int compareAngularDirection(const HalfEdge* e) const;
int compareTo(const HalfEdge* e) const { return compareAngularDirection(e); };
diff --git a/include/geos/index/kdtree/KdNode.h b/include/geos/index/kdtree/KdNode.h
index b561c12..e1238ab 100644
--- a/include/geos/index/kdtree/KdNode.h
+++ b/include/geos/index/kdtree/KdNode.h
@@ -24,6 +24,9 @@ namespace geos {
namespace index { // geos::index
namespace kdtree { // geos::index::kdtree
+/**
+ * A node of a {@link KdTree}, which represents one or more points in the same location.
+ */
class GEOS_DLL KdNode {
private:
diff --git a/include/geos/index/kdtree/KdTree.h b/include/geos/index/kdtree/KdTree.h
index c57215a..e160663 100644
--- a/include/geos/index/kdtree/KdTree.h
+++ b/include/geos/index/kdtree/KdTree.h
@@ -119,17 +119,16 @@ private:
public:
/**
- * Converts a collection of {@link KdNode}s to an vector of {@link Coordinate}s.
+ * Converts a collection of {@link KdNode}s to an vector of {@link geom::Coordinate}s.
*
- * @param kdnodes
- * a collection of nodes
+ * @param kdnodes a collection of nodes
* @return an vector of the coordinates represented by the nodes
*/
static std::unique_ptr<std::vector<geom::Coordinate>> toCoordinates(std::vector<KdNode*>& kdnodes);
/**
* Converts a collection of {@link KdNode}s
- * to an vector of {@link Coordinate}s,
+ * to an vector of {@link geom::Coordinate}s,
* specifying whether repeated nodes should be represented
* by multiple coordinates.
*
@@ -177,9 +176,6 @@ public:
/**
* Searches for a given point in the index and returns its node if found.
- *
- * @param queryPt the point to query
- * @return the point node, if it is found in the index, or null if not
*/
KdNode* query(const geom::Coordinate& queryPt);
diff --git a/include/geos/noding/ValidatingNoder.h b/include/geos/noding/ValidatingNoder.h
index 6d9b7ed..ce45c74 100644
--- a/include/geos/noding/ValidatingNoder.h
+++ b/include/geos/noding/ValidatingNoder.h
@@ -33,6 +33,20 @@ class Geometry;
namespace geos {
namespace noding { // geos.noding
+/**
+ * A wrapper for {@link noding::Noder}s which validates
+ * the output arrangement is correctly noded.
+ * An arrangement of line segments is fully noded if
+ * there is no line segment
+ * which has another segment intersecting its interior.
+ * If the noding is not correct, a {@link util::TopologyException} is thrown
+ * with details of the first invalid location found.
+ *
+ * @author mdavis
+ *
+ * @see FastNodingValidator
+ *
+ */
class GEOS_DLL ValidatingNoder : public Noder {
private:
diff --git a/include/geos/noding/snap/SnappingNoder.h b/include/geos/noding/snap/SnappingNoder.h
index 5ee58fa..d8efccc 100644
--- a/include/geos/noding/snap/SnappingNoder.h
+++ b/include/geos/noding/snap/SnappingNoder.h
@@ -61,7 +61,7 @@ namespace snap { // geos::noding::snap
* given a small enough snap tolerance.
*
* The correctness of the output is not verified by this noder.
- * If required this can be done by {@link ValidatingNoder}.
+ * If required this can be done by {@link noding::ValidatingNoder}.
*/
class GEOS_DLL SnappingNoder : public Noder {
diff --git a/include/geos/noding/snapround/HotPixel.h b/include/geos/noding/snapround/HotPixel.h
index d221f12..1121419 100644
--- a/include/geos/noding/snapround/HotPixel.h
+++ b/include/geos/noding/snapround/HotPixel.h
@@ -55,12 +55,10 @@ namespace snapround { // geos::noding::snapround
* Implements a "hot pixel" as used in the Snap Rounding algorithm.
*
* A hot pixel contains the interior of the tolerance square and
- * the boundary
- * <b>minus</b> the top and right segments.
+ * the boundary minus the top and right segments.
*
* The hot pixel operations are all computed in the integer domain
* to avoid rounding problems.
- *
*/
class GEOS_DLL HotPixel {
@@ -112,10 +110,7 @@ public:
*
* @param pt the coordinate at the centre of the pixel.
* Will be kept by reference, so make sure to keep it alive.
- * @param scaleFact the scaleFactor determining the pixel size
- * @param li the intersector to use for testing intersection with
- * line segments
- */
+ * @param scaleFactor the scaleFactor determining the pixel size */
HotPixel(const geom::Coordinate& pt, double scaleFactor);
/*
diff --git a/include/geos/noding/snapround/SnapRoundingNoder.h b/include/geos/noding/snapround/SnapRoundingNoder.h
index 2ceab38..1abd80c 100644
--- a/include/geos/noding/snapround/SnapRoundingNoder.h
+++ b/include/geos/noding/snapround/SnapRoundingNoder.h
@@ -43,13 +43,13 @@ namespace snapround { // geos::noding::snapround
/**
* Uses Snap Rounding to compute a rounded,
- * fully noded arrangement from a set of {@link SegmentString}s,
+ * fully noded arrangement from a set of {@link noding::SegmentString}s,
* in a performant way, and avoiding unnecessary noding.
*
* Implements the Snap Rounding technique described in
* the papers by Hobby, Guibas & Marimont, and Goodrich et al.
* Snap Rounding enforces that all output vertices lie on a uniform grid,
- * which is determined by the provided {@link PrecisionModel}.
+ * which is determined by the provided {@link geom::PrecisionModel}.
*
* Input vertices do not have to be rounded to the grid beforehand;
* this is done during the snap-rounding process.
@@ -66,7 +66,7 @@ namespace snapround { // geos::noding::snapround
* each of the segment vertices will be noded.
* This still provides fully-noded output.
* This is the same behaviour provided by other noders,
- * such as {@link MCIndexNoder} and {@link SnappingNoder}.
+ * such as {@link noding::MCIndexNoder} and {@link noding::snap::SnappingNoder}.
*/
class GEOS_DLL SnapRoundingNoder : public Noder {
diff --git a/include/geos/operation/overlayng/EdgeNodingBuilder.h b/include/geos/operation/overlayng/EdgeNodingBuilder.h
index 05dd09b..725eb29 100644
--- a/include/geos/operation/overlayng/EdgeNodingBuilder.h
+++ b/include/geos/operation/overlayng/EdgeNodingBuilder.h
@@ -66,7 +66,7 @@ namespace overlayng { // geos.operation.overlayng
*
* - Extracts input edges, and attaches topological information
* - if clipping is enabled, handles clipping or limiting input geometry
- * - chooses a {@link Noder} based on provided precision model, unless a custom one is supplied
+ * - chooses a {@link noding::Noder} based on provided precision model, unless a custom one is supplied
* - calls the chosen Noder, with precision model
* - removes any fully collapsed noded edges
* - builds {@link Edge}s and merges them
diff --git a/include/geos/operation/overlayng/OverlayEdge.h b/include/geos/operation/overlayng/OverlayEdge.h
index 3d4882f..243d80e 100644
--- a/include/geos/operation/overlayng/OverlayEdge.h
+++ b/include/geos/operation/overlayng/OverlayEdge.h
@@ -43,7 +43,9 @@ namespace overlayng { // geos.operation.overlayng
using namespace geos::geom;
-
+/**
+* Creates a single OverlayEdge.
+*/
class GEOS_DLL OverlayEdge : public edgegraph::HalfEdge {
private:
diff --git a/include/geos/operation/overlayng/OverlayGraph.h b/include/geos/operation/overlayng/OverlayGraph.h
index e9f8756..4e56a13 100644
--- a/include/geos/operation/overlayng/OverlayGraph.h
+++ b/include/geos/operation/overlayng/OverlayGraph.h
@@ -42,7 +42,7 @@ namespace overlayng { // geos.operation.overlayng
using namespace geos::geom;
/**
- * A planar graph of {@link OverlayEdge}s, representing
+ * A planar graph of {@link OverlayEdge}, representing
* the topology resulting from an overlay operation.
* Each source {@link Edge} is represented
* by two OverlayEdges, with opposite orientation.
diff --git a/include/geos/operation/overlayng/OverlayLabel.h b/include/geos/operation/overlayng/OverlayLabel.h
index 2619b28..a184fcc 100644
--- a/include/geos/operation/overlayng/OverlayLabel.h
+++ b/include/geos/operation/overlayng/OverlayLabel.h
@@ -23,6 +23,11 @@ namespace geos { // geos.
namespace operation { // geos.operation
namespace overlayng { // geos.operation.overlayng
+
+using geos::geom::Location;
+using geos::geom::Position;
+
+
/**
* A label for a pair of {@link OverlayEdge}s which records
* the topological information for the edge
@@ -32,11 +37,11 @@ namespace overlayng { // geos.operation.overlayng
* Accessors for orientation-sensitive information
* require the orientation of the containing OverlayEdge.
*
-* A label contains the topological {@link Location}s for
+* A label contains the topological {@link geom::Location}s for
* the two overlay input geometries.
* A labelled input geometry may be either a Line or an Area.
* In both cases, the label locations are populated
-* with the locations for the edge {@link Position}s
+* with the locations for the edge {@link geom::Position}s
* once they are computed by topological evaluation.
* The label also records the dimension of each geometry,
* and in the case of area boundary edges, the role
@@ -82,11 +87,6 @@ namespace overlayng { // geos.operation.overlayng
*
* @author Martin Davis
*/
-
-using geos::geom::Location;
-using geos::geom::Position;
-
-
class GEOS_DLL OverlayLabel {
private:
diff --git a/include/geos/operation/overlayng/OverlayNG.h b/include/geos/operation/overlayng/OverlayNG.h
index d09485d..aa88b12 100644
--- a/include/geos/operation/overlayng/OverlayNG.h
+++ b/include/geos/operation/overlayng/OverlayNG.h
@@ -41,8 +41,47 @@ namespace geos { // geos.
namespace operation { // geos.operation
namespace overlayng { // geos.operation.overlayng
-
-
+/**
+ * Computes the geometric overlay of two {@link geom::Geometry}s,
+ * using an explicit precision model to allow robust computation.
+ * The overlay can be used to determine any of the
+ * following set-theoretic operations (boolean combinations) of the geometries:
+ *
+ * * INTERSECTION - all points which lie in both geometries
+ * * UNION - all points which lie in at least one geometry
+ * * DIFFERENCE - all points which lie in the first geometry but not the second
+ * * SYMDIFFERENCE - all points which lie in one geometry but not both
+ *
+ * Input geometries may have different dimension.
+ * Collections must be homogeneous
+ * (all elements must have the same dimension).
+ *
+ * The precision model used for the computation can be supplied
+ * independent of the precision model of the input geometry.
+ * The main use for this is to allow using a fixed precision
+ * for geometry with a floating precision model.
+ * This does two things: ensures robust computation;
+ * and forces the output to be validly rounded to the precision model.
+ *
+ * For fixed precision models noding is performed using a {@link noding::snapround::SnapRoundingNoder}.
+ * This provides robust computation (as long as precision is limited to
+ * around 13 decimal digits).
+ *
+ * For floating precision an {@link noding::MCIndexNoder} is used.
+ * This is not fully robust, so can sometimes result in
+ * {@link util::TopologyException}s being thrown.
+ * For robust full-precision overlay see {@link OverlayNGSnapIfNeeded}.
+ *
+ * Note: If a {@link noding::snap::SnappingNoder} is used
+ * it is best to specify a fairly small snap tolerance,
+ * since the intersection clipping optimization can
+ * interact with the snapping to alter the result.
+ *
+ * @author mdavis
+ *
+ * @see OverlayNGSnapIfNeeded
+ *
+ */
class GEOS_DLL OverlayNG {
private:
@@ -117,7 +156,7 @@ public:
* - For {@link PrecisionModel#FLOATING}
* a non-snapping noder is used,
* and this computation may not be robust.
- * If errors occur a {@link TopologyException} is thrown.
+ * If errors occur a {@link util::TopologyException} is thrown.
*/
OverlayNG(const geom::Geometry* geom0, const geom::Geometry* geom1, int p_opCode)
: OverlayNG(geom0, geom1, geom0->getFactory()->getPrecisionModel(), p_opCode)
@@ -133,7 +172,7 @@ public:
* for testing purposes.
* Default is TRUE (optimization enabled).
*
- * @param isOptimized whether to optimize processing
+ * @param p_isOptimized whether to optimize processing
*/
void setOptimized(bool p_isOptimized) { isOptimized = p_isOptimized; }
void setOutputEdges(bool p_isOutputEdges) { isOutputEdges = p_isOutputEdges; }
@@ -149,7 +188,7 @@ public:
std::unique_ptr<Geometry> getResult();
/**
- * Tests whether a point with a given topological {@link Label}
+ * Tests whether a point with a given topological {@link OverlayLabel}
* relative to two geometries is contained in
* the result of overlaying the geometries using
* a given overlay operation.
@@ -159,7 +198,7 @@ public:
static bool isResultOfOpPoint(const OverlayLabel* label, int opCode);
/**
- * Tests whether a point with given {@link Location}s
+ * Tests whether a point with given {@link geom::Location}s
* relative to two geometries would be contained in
* the result of overlaying the geometries using
* a given overlay operation.
@@ -189,7 +228,7 @@ public:
/**
* Computes an overlay operation on the given geometry operands,
- * using a supplied {@link Noder}.
+ * using a supplied {@link noding::Noder}.
*
* @param geom0 the first geometry argument
* @param geom1 the second geometry argument
@@ -205,7 +244,7 @@ public:
/**
* Computes an overlay operation on the given geometry operands,
- * using a supplied {@link Noder}.
+ * using a supplied {@link noding::Noder}.
*
* @param geom0 the first geometry argument
* @param geom1 the second geometry argument
@@ -225,12 +264,12 @@ public:
*
* The noder is chosen according to the precision model specified.
*
- * - For {@link PrecisionModel#FIXED}
+ * - For {@link geom::PrecisionModel#FIXED}
* a snap-rounding noder is used, and the computation is robust.
- * - For {@link PrecisionModel#FLOATING}
+ * - For {@link geom::PrecisionModel#FLOATING}
* a non-snapping noder is used,
* and this computation may not be robust.
- * If errors occur a {@link TopologyException} is thrown.
+ * If errors occur a {@link util::TopologyException} is thrown.
*
* @param geom0 the first argument geometry
* @param geom1 the second argument geometry
@@ -250,11 +289,7 @@ public:
* The input must be a valid geometry.
* Collections must be homogeneous.
*
- * To union an overlapping set of polygons in a more performant way use {@link UnaryUnionNG}.
- * To union a polyonal coverage or linear network in a more performant way,
- * use {@link CoverageUnion}.
- *
- * @param geom0 the geometry
+ * @param geom the geometry
* @param pm the precision model to use
* @return the result of the union operation
*
diff --git a/include/geos/operation/overlayng/OverlayNGSnapIfNeeded.h b/include/geos/operation/overlayng/OverlayNGSnapIfNeeded.h
index 545c34f..1857424 100644
--- a/include/geos/operation/overlayng/OverlayNGSnapIfNeeded.h
+++ b/include/geos/operation/overlayng/OverlayNGSnapIfNeeded.h
@@ -39,20 +39,20 @@ namespace overlayng { // geos.operation.overlayng
* The noding strategies used are:
*
* - A simple, fast noder using FLOATING precision.
- * - A {@link SnappingNoder} using an automatically-determined snap tolerance
+ * - A {@link noding::snap::SnappingNoder} using an automatically-determined snap tolerance
* - First snapping each geometry to itself,
* and then overlaying them using a SnappingNoder.
* - The above two strategies are repeated with increasing snap tolerance, up to a limit.
*
* If the above heuristics still fail to compute a valid overlay,
- * the original {@link TopologyException} is thrown.
+ * the original {@link util::TopologyException} is thrown.
*
* This algorithm relies on each overlay operation execution
- * throwing a {@link TopologyException} if it is unable
+ * throwing a {@link util::TopologyException} if it is unable
* to compute the overlay correctly.
* Generally this occurs because the noding phase does
* not produce a valid noding.
- * This requires the use of a {@link ValidatingNoder}
+ * This requires the use of a {@link noding::ValidatingNoder}
* in order to check the results of using a floating noder.
*
* @author Martin Davis
@@ -141,7 +141,7 @@ public:
/**
* Computes a heuristic snap tolerance distance
- * for overlaying a pair of geometries using a {@link SnappingNoder}.
+ * for overlaying a pair of geometries using a {@link noding::snap::SnappingNoder}.
*/
static double snapTolerance(const Geometry* geom0, const Geometry* geom1);
diff --git a/include/geos/operation/overlayng/OverlayUtil.h b/include/geos/operation/overlayng/OverlayUtil.h
index 58c3595..7d26062 100644
--- a/include/geos/operation/overlayng/OverlayUtil.h
+++ b/include/geos/operation/overlayng/OverlayUtil.h
@@ -111,10 +111,10 @@ public:
* This assumes that complete collapse does not occur.
*
* The result dimension is computed according to the following rules:
- * - {@link OverlayNG#INTERSECTION} - result has the dimension of the lowest input dimension
- * - {@link OverlayNG#UNION} - result has the dimension of the highest input dimension
- * - {@link OverlayNG#DIFFERENCE} - result has the dimension of the left-hand input
- * - {@link OverlayNG#SYMDIFFERENCE} - result has the dimension of the highest input dimension
+ * - OverlayNG::INTERSECTION - result has the dimension of the lowest input dimension
+ * - OverlayNG::UNION - result has the dimension of the highest input dimension
+ * - OverlayNG::DIFFERENCE - result has the dimension of the left-hand input
+ * - OverlayNG::SYMDIFFERENCE - result has the dimension of the highest input dimension
* (since the Symmetric Difference is the Union of the Differences).
*/
static int resultDimension(int opCode, int dim0, int dim1);
diff --git a/include/geos/operation/overlayng/PrecisionReducer.h b/include/geos/operation/overlayng/PrecisionReducer.h
index 77cdbc0..87e7447 100644
--- a/include/geos/operation/overlayng/PrecisionReducer.h
+++ b/include/geos/operation/overlayng/PrecisionReducer.h
@@ -39,7 +39,7 @@ using namespace geos::geom;
/**
* Reduces the precision of a geometry by rounding it to the
-* supplied {@link PrecisionModel}.
+* supplied {@link geom::PrecisionModel}.
*
* The output is always a valid geometry. This implies that input components
* may be merged if they are closer than the grid precision.
@@ -47,7 +47,7 @@ using namespace geos::geom;
* should be processed separately.
*
* The output is fully noded.
-* This provides an effective way to node / snap-round a collection of {@link LineString}s.
+* This provides an effective way to node / snap-round a collection of {@link geom::LineString}s.
*/
class GEOS_DLL PrecisionReducer {
diff --git a/include/geos/operation/overlayng/PrecisionUtil.h b/include/geos/operation/overlayng/PrecisionUtil.h
index 3c5a98d..71def56 100644
--- a/include/geos/operation/overlayng/PrecisionUtil.h
+++ b/include/geos/operation/overlayng/PrecisionUtil.h
@@ -132,7 +132,7 @@ public:
/**
* Computes a safe scale factor for a numeric value.
* A safe scale factor ensures that rounded
- * number has no more than {@link MAX_PRECISION_DIGITS}
+ * number has no more than MAX_PRECISION_DIGITS
* digits of precision.
*/
static double safeScale(double value);
@@ -140,7 +140,7 @@ public:
/**
* Computes a safe scale factor for a geometry.
* A safe scale factor ensures that the rounded
- * ordinates have no more than {@link MAX_PRECISION_DIGITS}
+ * ordinates have no more than MAX_PRECISION_DIGITS
* digits of precision.
*/
static double safeScale(const Geometry* geom);
@@ -148,7 +148,7 @@ public:
/**
* Computes a safe scale factor for two geometries.
* A safe scale factor ensures that the rounded
- * ordinates have no more than {@link MAX_PRECISION_DIGITS}
+ * ordinates have no more than MAX_PRECISION_DIGITS
* digits of precision.
*/
static double safeScale(const Geometry* a, const Geometry* b);
diff --git a/include/geos/operation/union/CascadedPolygonUnion.h b/include/geos/operation/union/CascadedPolygonUnion.h
index b746d0f..bb7db11 100644
--- a/include/geos/operation/union/CascadedPolygonUnion.h
+++ b/include/geos/operation/union/CascadedPolygonUnion.h
@@ -64,7 +64,7 @@ public:
/**
* Computes the union of two geometries.
- * This method may throw a {@link Toppology Exception}
+ * This method may throw a {@link util::TopologyException}
* if one is encountered
*/
std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) override;
@@ -157,17 +157,18 @@ public:
* @tparam T an iterator yelding something castable to const Polygon *
* @param start start iterator
* @param end end iterator
+ * @param unionStrategy strategy to apply
*/
template <class T>
static geom::Geometry*
- Union(T start, T end, UnionStrategy *unionStrat)
+ Union(T start, T end, UnionStrategy *unionStrategy)
{
std::vector<geom::Polygon*> polys;
for(T i = start; i != end; ++i) {
const geom::Polygon* p = dynamic_cast<const geom::Polygon*>(*i);
polys.push_back(const_cast<geom::Polygon*>(p));
}
- return Union(&polys, unionStrat);
+ return Union(&polys, unionStrategy);
}
/** \brief
diff --git a/include/geos/operation/union/OverlapUnion.h b/include/geos/operation/union/OverlapUnion.h
index 533273f..d6d073c 100644
--- a/include/geos/operation/union/OverlapUnion.h
+++ b/include/geos/operation/union/OverlapUnion.h
@@ -54,13 +54,15 @@ namespace geounion { // geos::operation::geounion
* and thus may group disjoint polygons which can lie far apart.
* It may also occur in real world data which contains many disjoint polygons
* (e.g. polygons representing parcels on different street blocks).
- * <h2>Algorithm</h2>
+ *
+ * # Algorithm
+ *
* The overlap region is determined as the common envelope of intersection.
* The input polygons are partitioned into two sets:
- * <ul>
- * <li>Overlapping: Polygons which intersect the overlap region, and thus potentially overlap each other
- * <li>Disjoint: Polygons which are disjoint from (lie wholly outside) the overlap region
- * </ul>
+ *
+ * * Overlapping: Polygons which intersect the overlap region, and thus potentially overlap each other
+ * * Disjoint: Polygons which are disjoint from (lie wholly outside) the overlap region
+ *
* The Overlapping set is fully unioned, and then combined with the Disjoint set.
* Performing a simple combine works because
* the disjoint polygons do not interact with each
@@ -68,7 +70,8 @@ namespace geounion { // geos::operation::geounion
* They also do not interact with the Overlapping polygons,
* since they are outside their envelope.
*
- * <h2>Verification</h2>
+ * # Verification
+ *
* In the general case the Overlapping set of polygons will
* extend beyond the overlap envelope. This means that the union result
* will extend beyond the overlap region.
@@ -80,7 +83,7 @@ namespace geounion { // geos::operation::geounion
* Detection is done by a fairly efficient comparison of edge segments which
* extend beyond the overlap region. If any segments have changed
* then there is a risk of introduced intersections, and full union is performed.
- * <p>
+ *
* This situation has not been observed in JTS using floating precision,
* but it could happen due to snapping. It has been observed
* in other APIs (e.g. GEOS) due to more aggressive snapping.
@@ -89,7 +92,6 @@ namespace geounion { // geos::operation::geounion
* @author mbdavis
*
*/
-
class GEOS_DLL OverlapUnion {
public:
diff --git a/include/geos/operation/union/UnionStrategy.h b/include/geos/operation/union/UnionStrategy.h
index 18040da..b68d090 100644
--- a/include/geos/operation/union/UnionStrategy.h
+++ b/include/geos/operation/union/UnionStrategy.h
@@ -45,7 +45,7 @@ public:
/**
* Computes the union of two geometries.
- * This method may throw a {@link Toppology Exception}
+ * This method may throw a {@link util::TopologyException}
* if one is encountered
*/
virtual std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) = 0;
@@ -54,7 +54,7 @@ public:
* Indicates whether the union function operates using
* a floating (full) precision model.
* If this is the case, then the unary union code
- * can make use of the {@link OverlapUnion} performance optimization,
+ * can make use of the operation::union::OverlapUnion performance optimization,
* and perhaps other optimizations as well.
* Otherwise, the union result extent may not be the same as the extent of the inputs,
* which prevents using some optimizations.
diff --git a/tools/ci/script_cmake.sh b/tools/ci/script_cmake.sh
index b80dda6..b5a173e 100755
--- a/tools/ci/script_cmake.sh
+++ b/tools/ci/script_cmake.sh
@@ -23,9 +23,9 @@ set -e
cmake --version
-cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_DOCUMENTATION=NO ${TRAVIS_BUILD_DIR}
+cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_DOCUMENTATION=YES ${TRAVIS_BUILD_DIR}
run_make
-# cmake --build . --target docs
+cmake --build . --target docs
ctest --output-on-failure .
if [ "${BUILD_TYPE}" = "Coverage" ]; then
-----------------------------------------------------------------------
Summary of changes:
include/geos/algorithm/CGAlgorithmsDD.h | 10 +---
include/geos/edgegraph/EdgeGraph.h | 8 +--
include/geos/edgegraph/EdgeGraphBuilder.h | 2 +-
include/geos/edgegraph/HalfEdge.h | 39 ++++++-------
include/geos/index/kdtree/KdNode.h | 3 +
include/geos/index/kdtree/KdTree.h | 10 +---
include/geos/noding/ValidatingNoder.h | 14 +++++
include/geos/noding/snap/SnappingNoder.h | 2 +-
include/geos/noding/snapround/HotPixel.h | 9 +--
include/geos/noding/snapround/SnapRoundingNoder.h | 6 +-
.../geos/operation/overlayng/EdgeNodingBuilder.h | 2 +-
include/geos/operation/overlayng/OverlayEdge.h | 4 +-
include/geos/operation/overlayng/OverlayGraph.h | 2 +-
include/geos/operation/overlayng/OverlayLabel.h | 14 ++---
include/geos/operation/overlayng/OverlayNG.h | 67 ++++++++++++++++------
.../operation/overlayng/OverlayNGSnapIfNeeded.h | 10 ++--
include/geos/operation/overlayng/OverlayUtil.h | 8 +--
.../geos/operation/overlayng/PrecisionReducer.h | 4 +-
include/geos/operation/overlayng/PrecisionUtil.h | 6 +-
.../geos/operation/union/CascadedPolygonUnion.h | 7 ++-
include/geos/operation/union/OverlapUnion.h | 18 +++---
include/geos/operation/union/UnionStrategy.h | 4 +-
tools/ci/script_cmake.sh | 4 +-
23 files changed, 147 insertions(+), 106 deletions(-)
hooks/post-receive
--
GEOS
More information about the geos-commits
mailing list