diff --git a/doxygen/AdjacentEdgeLocator_8h_source.html b/doxygen/AdjacentEdgeLocator_8h_source.html new file mode 100644 index 0000000000..cd44659bae --- /dev/null +++ b/doxygen/AdjacentEdgeLocator_8h_source.html @@ -0,0 +1,171 @@ + + + + + + + +GEOS: AdjacentEdgeLocator.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
AdjacentEdgeLocator.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/CoordinateSequence.h>
+
19 #include <geos/geom/Location.h>
+
20 #include <geos/export.h>
+
21 
+
22 
+
23 // Forward declarations
+
24 namespace geos {
+
25 namespace operation {
+
26 namespace relateng {
+
27  class NodeSections;
+
28  class NodeSection;
+
29 }
+
30 }
+
31 namespace geom {
+
32  class CoordinateXY;
+
33  class Geometry;
+
34  class LinearRing;
+
35  class Polygon;
+
36 }
+
37 }
+
38 
+
39 
+
40 using geos::geom::CoordinateXY;
+
41 using geos::geom::CoordinateSequence;
+
42 using geos::geom::Geometry;
+
43 using geos::geom::LinearRing;
+
44 using geos::geom::Polygon;
+
45 using geos::geom::Location;
+
46 
+
47 
+
48 
+
49 namespace geos { // geos.
+
50 namespace operation { // geos.operation
+
51 namespace relateng { // geos.operation.relateng
+
52 
+
67 class GEOS_DLL AdjacentEdgeLocator {
+
68 
+
69 public:
+
70 
+
71  AdjacentEdgeLocator(const Geometry* geom)
+
72  {
+
73  init(geom);
+
74  }
+
75 
+
76  Location locate(const CoordinateXY* p);
+
77 
+
82  AdjacentEdgeLocator(const AdjacentEdgeLocator&) = delete;
+
83  AdjacentEdgeLocator& operator=(const AdjacentEdgeLocator&) = delete;
+
84 
+
85 
+
86 private:
+
87 
+
88  // Members
+
89 
+
90  std::vector<const CoordinateSequence*> ringList;
+
91 
+
92  /*
+
93  * When we have to reorient rings, we end up allocating new
+
94  * rings, since we cannot reorient the rings of the input
+
95  * geometry, so this is where we store those "local" rings.
+
96  */
+
97  std::vector<std::unique_ptr<CoordinateSequence>> localRingList;
+
98 
+
99 
+
100  // Methods
+
101 
+
102  void addSections(
+
103  const CoordinateXY* p,
+
104  const CoordinateSequence* ring,
+
105  NodeSections& sections);
+
106 
+
107  NodeSection* createSection(
+
108  const CoordinateXY* p,
+
109  const CoordinateXY* prev,
+
110  const CoordinateXY* next);
+
111 
+
112  void init(const Geometry* geom);
+
113 
+
114  void addRings(const Geometry* geom);
+
115 
+
116  void addRing(const LinearRing* ring, bool requireCW);
+
117 
+
118 
+
119 };
+
120 
+
121 } // namespace geos.operation.relateng
+
122 } // namespace geos.operation
+
123 } // namespace geos
+
124 
+
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
+
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition: Polygon.h:61
+
geos::operation::relateng::AdjacentEdgeLocator
Definition: AdjacentEdgeLocator.h:67
+
geos::operation::relateng::AdjacentEdgeLocator::AdjacentEdgeLocator
AdjacentEdgeLocator(const AdjacentEdgeLocator &)=delete
+
geos::operation::relateng::NodeSection
Definition: NodeSection.h:55
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/Angle_8h_source.html b/doxygen/Angle_8h_source.html index fde52e11b0..ed7be29380 100644 --- a/doxygen/Angle_8h_source.html +++ b/doxygen/Angle_8h_source.html @@ -164,7 +164,7 @@
geos::algorithm::Angle::isAcute
static bool isAcute(const geom::CoordinateXY &p0, const geom::CoordinateXY &p1, const geom::CoordinateXY &p2)
geos::algorithm::Angle::toRadians
static double toRadians(double angleDegrees)
geos::algorithm::Angle::angleBetweenOriented
static double angleBetweenOriented(const geom::CoordinateXY &tip1, const geom::CoordinateXY &tail, const geom::CoordinateXY &tip2)
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/BasicPredicate_8h_source.html b/doxygen/BasicPredicate_8h_source.html new file mode 100644 index 0000000000..dc0d24a651 --- /dev/null +++ b/doxygen/BasicPredicate_8h_source.html @@ -0,0 +1,150 @@ + + + + + + + +GEOS: BasicPredicate.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
BasicPredicate.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/operation/relateng/TopologyPredicate.h>
+
20 #include <geos/export.h>
+
21 
+
22 #include <memory>
+
23 #include <vector>
+
24 
+
25 // Forward declarations
+
26 namespace geos {
+
27 namespace geom {
+
28  class Envelope;
+
29 }
+
30 }
+
31 
+
32 
+
33 using geos::geom::Envelope;
+
34 using geos::geom::Location;
+
35 
+
36 
+
37 namespace geos { // geos.
+
38 namespace operation { // geos.operation.
+
39 namespace relateng { // geos.operation.relateng
+
40 
+
41 
+
42 class GEOS_DLL BasicPredicate : public TopologyPredicate {
+
43 
+
44 private:
+
45 
+
46  static constexpr int UNKNOWN = -1;
+
47  static constexpr int FALSE = 0;
+
48  static constexpr int TRUE = 1;
+
49 
+
50  int m_value = UNKNOWN;
+
51 
+
52  static bool isKnown(int val);
+
53 
+
54  static bool toBoolean(int val);
+
55 
+
56  static int toValue(bool val);
+
57 
+
58 
+
59 protected:
+
60 
+
67  void setValue(bool val);
+
68 
+
69  void setValue(int val);
+
70 
+
71  void setValueIf(bool val, bool cond);
+
72 
+
73  void require(bool cond);
+
74 
+
75  using TopologyPredicate::requireCovers;
+
76  void requireCovers(const Envelope& a, const Envelope& b);
+
77 
+
78 
+
79 public:
+
80 
+
89  static bool isIntersection(Location locA, Location locB);
+
90 
+
91  std::string name() const override = 0;
+
92 
+
93  void finish() override = 0;
+
94 
+
95  bool isKnown() const override;
+
96 
+
97  bool value() const override;
+
98 
+
99 
+
100 };
+
101 
+
102 } // namespace geos.operation.relateng
+
103 } // namespace geos.operation
+
104 } // namespace geos
+
105 
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/BasicPreparedGeometry_8h_source.html b/doxygen/BasicPreparedGeometry_8h_source.html index ef5b8bf191..8051d8beac 100644 --- a/doxygen/BasicPreparedGeometry_8h_source.html +++ b/doxygen/BasicPreparedGeometry_8h_source.html @@ -69,25 +69,25 @@
20 #pragma once
21 
22 #include <geos/geom/prep/PreparedGeometry.h> // for inheritance
-
23 //#include <geos/algorithm/PointLocator.h>
-
24 //#include <geos/geom/util/ComponentCoordinateExtracter.h>
-
25 #include <geos/geom/Coordinate.h>
-
26 //#include <geos/geom/Location.h>
-
27 
-
28 #include <vector>
-
29 #include <string>
-
30 
-
31 namespace geos {
-
32 namespace geom {
-
33 class Geometry;
-
34 class Coordinate;
-
35 }
-
36 }
-
37 
-
38 
-
39 namespace geos {
-
40 namespace geom { // geos::geom
-
41 namespace prep { // geos::geom::prep
+
23 #include <geos/geom/Coordinate.h>
+
24 #include <geos/operation/relateng/RelateNG.h>
+
25 
+
26 #include <vector>
+
27 #include <string>
+
28 
+
29 namespace geos {
+
30 namespace geom {
+
31 class Geometry;
+
32 class Coordinate;
+
33 }
+
34 }
+
35 
+
36 
+
37 namespace geos {
+
38 namespace geom { // geos::geom
+
39 namespace prep { // geos::geom::prep
+
40 
+
41 using geos::operation::relateng::RelateNG;
42 
43 // * \class BasicPreparedGeometry
44 
@@ -95,73 +95,88 @@
59 private:
60  const geom::Geometry* baseGeom;
61  std::vector<const CoordinateXY*> representativePts;
-
62 
-
63 protected:
-
67  void setGeometry(const geom::Geometry* geom);
+
62  mutable std::unique_ptr<RelateNG> relate_ng;
+
63 
+
64  std::unique_ptr<RelateNG>& getRelateNG() const
+
65  {
+
66  if (relate_ng == nullptr)
+
67  relate_ng = RelateNG::prepare(baseGeom);
68 
-
76  bool envelopesIntersect(const geom::Geometry* g) const;
+
69  return relate_ng;
+
70  }
+
71 
+
72 protected:
+
76  void setGeometry(const geom::Geometry* geom);
77 
-
86  bool envelopeCovers(const geom::Geometry* g) const;
-
87 
-
88 public:
-
89  BasicPreparedGeometry(const Geometry* geom);
-
90 
-
91  ~BasicPreparedGeometry() override = default;
-
92 
-
93  const geom::Geometry&
-
94  getGeometry() const override
-
95  {
-
96  return *baseGeom;
-
97  }
-
98 
-
106  const std::vector<const CoordinateXY*>*
-
107  getRepresentativePoints() const
-
108  {
-
109  return &representativePts;
-
110  }
-
111 
-
120  bool isAnyTargetComponentInTest(const geom::Geometry* testGeom) const;
-
121 
-
125  bool contains(const geom::Geometry* g) const override;
-
126 
-
130  bool containsProperly(const geom::Geometry* g) const override;
-
131 
-
135  bool coveredBy(const geom::Geometry* g) const override;
-
136 
-
140  bool covers(const geom::Geometry* g) const override;
-
141 
-
145  bool crosses(const geom::Geometry* g) const override;
-
146 
-
151  bool disjoint(const geom::Geometry* g) const override;
-
152 
-
156  bool intersects(const geom::Geometry* g) const override;
-
157 
-
161  bool overlaps(const geom::Geometry* g) const override;
-
162 
-
166  bool touches(const geom::Geometry* g) const override;
-
167 
-
171  bool within(const geom::Geometry* g) const override;
-
172 
-
176  std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const override;
-
177 
-
181  double distance(const geom::Geometry* g) const override;
-
182 
-
186  bool isWithinDistance(const geom::Geometry* geom, double dist) const override;
-
187 
-
188  std::string toString();
-
189 
-
190 };
+
85  bool envelopesIntersect(const geom::Geometry* g) const;
+
86 
+
95  bool envelopeCovers(const geom::Geometry* g) const;
+
96 
+
97 public:
+
98  BasicPreparedGeometry(const Geometry* geom);
+
99 
+
100  ~BasicPreparedGeometry() override = default;
+
101 
+
102  const geom::Geometry&
+
103  getGeometry() const override
+
104  {
+
105  return *baseGeom;
+
106  }
+
107 
+
115  const std::vector<const CoordinateXY*>*
+
116  getRepresentativePoints() const
+
117  {
+
118  return &representativePts;
+
119  }
+
120 
+
129  bool isAnyTargetComponentInTest(const geom::Geometry* testGeom) const;
+
130 
+
134  bool within(const geom::Geometry* g) const override;
+
135 
+
139  bool contains(const geom::Geometry* g) const override;
+
140 
+
144  bool containsProperly(const geom::Geometry* g) const override;
+
145 
+
149  bool coveredBy(const geom::Geometry* g) const override;
+
150 
+
154  bool covers(const geom::Geometry* g) const override;
+
155 
+
159  bool crosses(const geom::Geometry* g) const override;
+
160 
+
165  bool disjoint(const geom::Geometry* g) const override;
+
166 
+
170  bool intersects(const geom::Geometry* g) const override;
+
171 
+
175  bool overlaps(const geom::Geometry* g) const override;
+
176 
+
180  bool touches(const geom::Geometry* g) const override;
+
181 
+
185  std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* g) const override;
+
186 
+
190  bool relate(const geom::Geometry* g, const std::string& pat) const override;
191 
-
192 } // namespace geos::geom::prep
-
193 } // namespace geos::geom
-
194 } // namespace geos
-
195 
+
195  std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const override;
+
196 
+
200  double distance(const geom::Geometry* g) const override;
+
201 
+
205  bool isWithinDistance(const geom::Geometry* geom, double dist) const override;
+
206 
+
207  std::string toString();
+
208 
+
209 };
+
210 
+
211 } // namespace geos::geom::prep
+
212 } // namespace geos::geom
+
213 } // namespace geos
+
214 
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::prep::BasicPreparedGeometry
A base class for PreparedGeometry subclasses.
Definition: BasicPreparedGeometry.h:58
-
geos::geom::prep::BasicPreparedGeometry::getGeometry
const geom::Geometry & getGeometry() const override
Gets the original Geometry which has been prepared.
Definition: BasicPreparedGeometry.h:94
+
geos::geom::prep::BasicPreparedGeometry::getGeometry
const geom::Geometry & getGeometry() const override
Gets the original Geometry which has been prepared.
Definition: BasicPreparedGeometry.h:103
geos::geom::prep::BasicPreparedGeometry::covers
bool covers(const geom::Geometry *g) const override
geos::geom::prep::BasicPreparedGeometry::envelopeCovers
bool envelopeCovers(const geom::Geometry *g) const
-
geos::geom::prep::BasicPreparedGeometry::getRepresentativePoints
const std::vector< const CoordinateXY * > * getRepresentativePoints() const
Definition: BasicPreparedGeometry.h:107
+
geos::geom::prep::BasicPreparedGeometry::getRepresentativePoints
const std::vector< const CoordinateXY * > * getRepresentativePoints() const
Definition: BasicPreparedGeometry.h:116
+
geos::geom::prep::BasicPreparedGeometry::relate
bool relate(const geom::Geometry *g, const std::string &pat) const override
geos::geom::prep::BasicPreparedGeometry::coveredBy
bool coveredBy(const geom::Geometry *g) const override
geos::geom::prep::BasicPreparedGeometry::isWithinDistance
bool isWithinDistance(const geom::Geometry *geom, double dist) const override
geos::geom::prep::BasicPreparedGeometry::intersects
bool intersects(const geom::Geometry *g) const override
@@ -175,9 +190,12 @@
geos::geom::prep::BasicPreparedGeometry::overlaps
bool overlaps(const geom::Geometry *g) const override
geos::geom::prep::BasicPreparedGeometry::setGeometry
void setGeometry(const geom::Geometry *geom)
geos::geom::prep::BasicPreparedGeometry::within
bool within(const geom::Geometry *g) const override
+
geos::geom::prep::BasicPreparedGeometry::relate
std::unique_ptr< IntersectionMatrix > relate(const geom::Geometry *g) const override
geos::geom::prep::BasicPreparedGeometry::disjoint
bool disjoint(const geom::Geometry *g) const override
geos::geom::prep::BasicPreparedGeometry::containsProperly
bool containsProperly(const geom::Geometry *g) const override
-
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:56
+
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:58
+
geos::operation::relateng::RelateNG
Definition: RelateNG.h:93
+
geos::operation::relateng::RelateNG::prepare
static std::unique_ptr< RelateNG > prepare(const Geometry *a)
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/BoundaryChainNoder_8h_source.html b/doxygen/BoundaryChainNoder_8h_source.html index dd5a67e7fa..01d49743e4 100644 --- a/doxygen/BoundaryChainNoder_8h_source.html +++ b/doxygen/BoundaryChainNoder_8h_source.html @@ -201,7 +201,7 @@
170 
171 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::BoundaryChainNoder
Definition: BoundaryChainNoder.h:57
geos::noding::BoundaryChainNoder::getNodedSubstrings
std::vector< SegmentString * > * getNodedSubstrings() const override
Returns a collection of fully noded SegmentStrings. The SegmentStrings have the same context as their...
geos::noding::BoundaryChainNoder::computeNodes
void computeNodes(std::vector< SegmentString * > *inputSegStrings) override
Computes the noding for a collection of SegmentStrings.
diff --git a/doxygen/BufferInputLineSimplifier_8h_source.html b/doxygen/BufferInputLineSimplifier_8h_source.html index d1e5e721aa..d8393be1ac 100644 --- a/doxygen/BufferInputLineSimplifier_8h_source.html +++ b/doxygen/BufferInputLineSimplifier_8h_source.html @@ -147,7 +147,7 @@
179 } // namespace geos
180 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::buffer::BufferInputLineSimplifier
Simplifies a buffer input line to remove concavities with shallow depth.
Definition: BufferInputLineSimplifier.h:71
geos::operation::buffer::BufferInputLineSimplifier::simplify
std::unique_ptr< geom::CoordinateSequence > simplify(double distanceTol)
geos::operation::buffer::BufferInputLineSimplifier::simplify
static std::unique_ptr< geom::CoordinateSequence > simplify(const geom::CoordinateSequence &inputLine, double distanceTol)
diff --git a/doxygen/BufferSubgraph_8h_source.html b/doxygen/BufferSubgraph_8h_source.html index a3d5ca56aa..afd4ae8204 100644 --- a/doxygen/BufferSubgraph_8h_source.html +++ b/doxygen/BufferSubgraph_8h_source.html @@ -181,7 +181,7 @@
200 #pragma warning(pop)
201 #endif
202 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geomgraph::DirectedEdge
A directed EdgeEnd.
Definition: geomgraph/DirectedEdge.h:42
geos::geomgraph::Node
The node component of a geometry graph.
Definition: geomgraph/Node.h:59
diff --git a/doxygen/CentralEndpointIntersector_8h_source.html b/doxygen/CentralEndpointIntersector_8h_source.html index 1fdf729e97..9caaad9b06 100644 --- a/doxygen/CentralEndpointIntersector_8h_source.html +++ b/doxygen/CentralEndpointIntersector_8h_source.html @@ -180,7 +180,7 @@
160 #endif
161 
geos::algorithm::CentralEndpointIntersector
Computes an approximate intersection of two line segments by taking the most central of the endpoints...
Definition: CentralEndpointIntersector.h:61
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CommonBitsRemover_8h_source.html b/doxygen/CommonBitsRemover_8h_source.html index 09aae9f825..89f0278424 100644 --- a/doxygen/CommonBitsRemover_8h_source.html +++ b/doxygen/CommonBitsRemover_8h_source.html @@ -109,7 +109,7 @@
90 } // namespace geos.precision
91 } // namespace geos
92 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::precision::CommonBitsRemover
Allow computing and removing common mantissa bits from one or more Geometries.
Definition: CommonBitsRemover.h:39
geos::precision::CommonBitsRemover::getCommonCoordinate
geom::Coordinate & getCommonCoordinate()
diff --git a/doxygen/ComponentJumpChecker_8h_source.html b/doxygen/ComponentJumpChecker_8h_source.html index eb55fc03e9..0d35b720ae 100644 --- a/doxygen/ComponentJumpChecker_8h_source.html +++ b/doxygen/ComponentJumpChecker_8h_source.html @@ -155,7 +155,7 @@
118 
119 
120 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::LineSegment
Definition: LineSegment.h:61
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/ConcaveHullOfPolygons_8h_source.html b/doxygen/ConcaveHullOfPolygons_8h_source.html index a9f80fa1df..bd6851cb0a 100644 --- a/doxygen/ConcaveHullOfPolygons_8h_source.html +++ b/doxygen/ConcaveHullOfPolygons_8h_source.html @@ -249,7 +249,7 @@
geos::algorithm::hull::ConcaveHullOfPolygons::setHolesAllowed
void setHolesAllowed(bool p_isHolesAllowed)
geos::algorithm::hull::ConcaveHullOfPolygons::setMaximumEdgeLengthRatio
void setMaximumEdgeLengthRatio(double edgeLengthRatio)
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryCollection
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:51
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
diff --git a/doxygen/ConcaveHull_8h_source.html b/doxygen/ConcaveHull_8h_source.html index 743df8d7ea..4332a026d3 100644 --- a/doxygen/ConcaveHull_8h_source.html +++ b/doxygen/ConcaveHull_8h_source.html @@ -205,7 +205,7 @@
geos::algorithm::hull::ConcaveHull::setMaximumEdgeLength
void setMaximumEdgeLength(double edgeLength)
geos::algorithm::hull::ConcaveHull::concaveHullByLength
static std::unique_ptr< Geometry > concaveHullByLength(const Geometry *geom, double maxLength)
geos::algorithm::hull::ConcaveHull::setMaximumEdgeLengthRatio
void setMaximumEdgeLengthRatio(double edgeLengthRatio)
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::Triangle
Represents a planar triangle, and provides methods for calculating various properties of triangles.
Definition: Triangle.h:28
diff --git a/doxygen/ConsistentAreaTester_8h_source.html b/doxygen/ConsistentAreaTester_8h_source.html index 5a0ad7135c..3427916644 100644 --- a/doxygen/ConsistentAreaTester_8h_source.html +++ b/doxygen/ConsistentAreaTester_8h_source.html @@ -126,7 +126,7 @@
136 } // namespace geos
137 
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::GeometryGraph
A GeometryGraph is a graph that models a given Geometry.
Definition: GeometryGraph.h:71
geos::operation::relate::RelateNodeGraph
Implements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is required to determin...
Definition: RelateNodeGraph.h:67
geos::operation::valid::ConsistentAreaTester
Checks that a geomgraph::GeometryGraph representing an area (a geom::Polygon or geom::MultiPolygon) h...
Definition: ConsistentAreaTester.h:68
diff --git a/doxygen/ConvexHull_8h_source.html b/doxygen/ConvexHull_8h_source.html index bf8850da79..3afc6db5a0 100644 --- a/doxygen/ConvexHull_8h_source.html +++ b/doxygen/ConvexHull_8h_source.html @@ -171,8 +171,8 @@
geos::algorithm::ConvexHull
Computes the convex hull of a Geometry.
Definition: ConvexHull.h:64
geos::algorithm::ConvexHull::getConvexHull
std::unique_ptr< geom::Geometry > getConvexHull()
geos::algorithm::ConvexHull::ConvexHull
ConvexHull(const geom::Geometry *newGeometry)
Definition: ConvexHull.h:180
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
-
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:227
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:229
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoordinateFilter_8h_source.html b/doxygen/CoordinateFilter_8h_source.html index bcdea0a604..1945e1303b 100644 --- a/doxygen/CoordinateFilter_8h_source.html +++ b/doxygen/CoordinateFilter_8h_source.html @@ -156,7 +156,7 @@
geos::geom::CoordinateFilter
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
geos::geom::CoordinateFilter::filter_ro
virtual void filter_ro(const CoordinateXY *)
Performs an operation with coord.
Definition: CoordinateFilter.h:70
geos::geom::CoordinateFilter::filter_rw
virtual void filter_rw(CoordinateXY *) const
Performs an operation on coord.
Definition: CoordinateFilter.h:59
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoordinateList_8h_source.html b/doxygen/CoordinateList_8h_source.html index 33dc52f8d2..6f861cf6f0 100644 --- a/doxygen/CoordinateList_8h_source.html +++ b/doxygen/CoordinateList_8h_source.html @@ -264,8 +264,8 @@
geos::geom::CoordinateList::insert
iterator insert(iterator pos, const Coordinate &c, bool allowRepeated)
Inserts the specified coordinate at the specified position in this list.
Definition: CoordinateList.h:143
geos::geom::CoordinateList::CoordinateList
CoordinateList(const T &v)
Constructs a new list from an array of Coordinates, allowing repeated points.
Definition: CoordinateList.h:76
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
-
geos::geom::Coordinate::Vect
std::vector< Coordinate > Vect
A vector of Coordinate objects (real object, not pointers)
Definition: Coordinate.h:233
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::Vect
std::vector< Coordinate > Vect
A vector of Coordinate objects (real object, not pointers)
Definition: Coordinate.h:235
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoordinateSequenceIterator_8h_source.html b/doxygen/CoordinateSequenceIterator_8h_source.html index 9b28f99ec9..bf53fe83d6 100644 --- a/doxygen/CoordinateSequenceIterator_8h_source.html +++ b/doxygen/CoordinateSequenceIterator_8h_source.html @@ -173,7 +173,7 @@
124 
125 }
126 }
-
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:453
+
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:458
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoordinateSequence_8h_source.html b/doxygen/CoordinateSequence_8h_source.html index f8c505ffaa..f072953e4f 100644 --- a/doxygen/CoordinateSequence_8h_source.html +++ b/doxygen/CoordinateSequence_8h_source.html @@ -605,7 +605,7 @@
806 } // namespace geos
807 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::CoordinateSequence::toVector
void toVector(std::vector< Coordinate > &coords) const
Pushes all Coordinates of this sequence into the provided vector.
geos::geom::CoordinateSequence::getAt
T & getAt(std::size_t i)
Returns a reference to Coordinate at position i.
Definition: CoordinateSequence.h:261
diff --git a/doxygen/CoordinateSequences_8h_source.html b/doxygen/CoordinateSequences_8h_source.html index ba7cc30980..670dd4cd6f 100644 --- a/doxygen/CoordinateSequences_8h_source.html +++ b/doxygen/CoordinateSequences_8h_source.html @@ -117,7 +117,7 @@
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
geos::geom::CoordinateSequences
The CoordinateSequences class provides utility methods to operate on CoordinateSequences....
Definition: CoordinateSequences.h:28
geos::geom::CoordinateSequences::binaryDispatch
static void binaryDispatch(const CoordinateSequence &seq1, const CoordinateSequence &seq2, F &fun, Args... args)
binaryDispatch calls a functor template, explicitly providing the backing types of two CoordinateSequ...
Definition: CoordinateSequences.h:43
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::CoordinateSequence::getCoordinateType
CoordinateType getCoordinateType() const
Definition: CoordinateSequence.h:233
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/Coordinate_8h_source.html b/doxygen/Coordinate_8h_source.html index 166f9f570d..11a3386394 100644 --- a/doxygen/Coordinate_8h_source.html +++ b/doxygen/Coordinate_8h_source.html @@ -71,547 +71,546 @@
22 #include <vector> // for typedefs
23 #include <string>
24 #include <limits>
-
25 
-
26 #ifdef _MSC_VER
-
27 #pragma warning(push)
-
28 #pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
-
29 #endif
-
30 
-
31 namespace geos {
-
32 namespace geom { // geos.geom
-
33 
-
34 // Forward declarations
-
35 struct CoordinateLessThan;
-
36 class CoordinateXYZM;
-
37 class CoordinateXYM;
-
38 class Coordinate;
-
39 
-
40 enum class CoordinateType : std::uint8_t {
-
41  XY,
-
42  XYZ,
-
43  XYZM,
-
44  XYM,
-
45 };
-
46 
-
47 enum class Ordinate : std::uint8_t {
-
48  X,
-
49  Y,
-
50  Z,
-
51  M
-
52 };
-
53 
-
54 GEOS_DLL std::ostream& operator<< (std::ostream&, const CoordinateType);
-
55 
-
56 class GEOS_DLL CoordinateXY {
-
57 
-
58  const static CoordinateXY _nullCoord;
-
59 
-
60 protected:
-
61  constexpr const static double DEFAULT_X = 0.0;
-
62  constexpr const static double DEFAULT_Y = 0.0;
-
63  constexpr const static double DEFAULT_Z = DoubleNotANumber;
-
64  constexpr const static double DEFAULT_M = DoubleNotANumber;
-
65 
-
66 public:
-
67  CoordinateXY()
-
68  : x(DEFAULT_X)
-
69  , y(DEFAULT_Y)
-
70  {}
-
71 
-
72  CoordinateXY(double xNew, double yNew)
-
73  : x(xNew)
-
74  , y(yNew)
-
75  {}
-
76 
-
77  template<Ordinate>
-
78  double get() const;
-
79 
-
81  double x;
-
82 
-
84  double y;
-
85 
-
87  GEOS_DLL friend bool operator==(const CoordinateXY& a, const CoordinateXY& b)
-
88  {
-
89  return a.equals2D(b);
-
90  };
-
91 
-
93  GEOS_DLL friend bool operator!=(const CoordinateXY& a, const CoordinateXY& b)
-
94  {
-
95  return ! a.equals2D(b);
-
96  };
-
97 
-
98  bool isValid() const
-
99  {
-
100  return std::isfinite(x) && std::isfinite(y);
-
101  };
-
102 
-
103  bool equals2D(const CoordinateXY& other) const
-
104  {
-
105  if(x != other.x) {
-
106  return false;
-
107  }
-
108  if(y != other.y) {
-
109  return false;
-
110  }
-
111  return true;
-
112  };
-
113 
-
114  bool equals2D(const CoordinateXY& other, double tolerance) const
-
115  {
-
116  if (std::abs(x - other.x) > tolerance) {
-
117  return false;
-
118  }
-
119  if (std::abs(y - other.y) > tolerance) {
-
120  return false;
-
121  }
-
122  return true;
-
123  };
-
124 
-
126  bool equals(const CoordinateXY& other) const
-
127  {
-
128  return equals2D(other);
-
129  };
-
130 
-
132  inline int compareTo(const CoordinateXY& other) const
-
133  {
-
134  if(x < other.x) {
-
135  return -1;
-
136  }
-
137  if(x > other.x) {
-
138  return 1;
-
139  }
-
140  if(y < other.y) {
-
141  return -1;
-
142  }
-
143  if(y > other.y) {
-
144  return 1;
-
145  }
-
146  return 0;
-
147  };
-
148 
-
149  static const CoordinateXY& getNull();
-
150 
-
151  double distance(const CoordinateXY& p) const
-
152  {
-
153  double dx = x - p.x;
-
154  double dy = y - p.y;
-
155  return std::sqrt(dx * dx + dy * dy);
-
156  };
-
157 
-
158  double distanceSquared(const CoordinateXY& p) const
-
159  {
-
160  double dx = x - p.x;
-
161  double dy = y - p.y;
-
162  return dx * dx + dy * dy;
-
163  };
-
164 
-
165  bool isNull() const
-
166  {
-
167  return (std::isnan(x) && std::isnan(y));
-
168  };
-
169 
-
170  void setNull()
-
171  {
-
172  x = DoubleNotANumber;
-
173  y = DoubleNotANumber;
-
174  };
-
175 
-
176  struct GEOS_DLL HashCode
-
177  {
-
178  inline std::size_t operator()(const CoordinateXY& c) const
-
179  {
-
180  size_t h = std::hash<double>{}(c.x);
-
181  h ^= std::hash<double>{}(c.y) << 1;
-
182  // z ordinate ignored for consistency with operator==
-
183  return h;
-
184  };
-
185  };
-
186 
-
187  using UnorderedSet = std::unordered_set<Coordinate, HashCode>;
-
188 
-
190  std::string toString() const;
-
191 };
-
192 
-
213 // Define the following to make assignments and copy constructions
-
214 // NON-(will let profilers report usages)
-
215 //#define PROFILE_COORDINATE_COPIES 1
-
216 class GEOS_DLL Coordinate : public CoordinateXY {
-
217 
-
218 private:
-
219 
-
220  static const Coordinate _nullCoord;
-
221 
-
222 public:
-
224  typedef std::set<const Coordinate*, CoordinateLessThan> ConstSet;
-
225 
-
227  typedef std::vector<const Coordinate*> ConstVect;
-
228 
-
230  typedef std::stack<const Coordinate*> ConstStack;
-
231 
-
233  typedef std::vector<Coordinate> Vect;
-
234 
-
236  double z;
-
237 
-
238  Coordinate()
-
239  : CoordinateXY()
-
240  , z(DEFAULT_Z)
-
241  {};
+
25 #include <map>
+
26 
+
27 #ifdef _MSC_VER
+
28 #pragma warning(push)
+
29 #pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+
30 #endif
+
31 
+
32 namespace geos {
+
33 namespace geom { // geos.geom
+
34 
+
35 // Forward declarations
+
36 struct CoordinateLessThan;
+
37 class CoordinateXYZM;
+
38 class CoordinateXYM;
+
39 class Coordinate;
+
40 
+
41 enum class CoordinateType : std::uint8_t {
+
42  XY,
+
43  XYZ,
+
44  XYZM,
+
45  XYM,
+
46 };
+
47 
+
48 enum class Ordinate : std::uint8_t {
+
49  X,
+
50  Y,
+
51  Z,
+
52  M
+
53 };
+
54 
+
55 GEOS_DLL std::ostream& operator<< (std::ostream&, const CoordinateType);
+
56 
+
57 class GEOS_DLL CoordinateXY {
+
58 
+
59  const static CoordinateXY _nullCoord;
+
60 
+
61 protected:
+
62  constexpr const static double DEFAULT_X = 0.0;
+
63  constexpr const static double DEFAULT_Y = 0.0;
+
64  constexpr const static double DEFAULT_Z = DoubleNotANumber;
+
65  constexpr const static double DEFAULT_M = DoubleNotANumber;
+
66 
+
67 public:
+
68  CoordinateXY()
+
69  : x(DEFAULT_X)
+
70  , y(DEFAULT_Y)
+
71  {}
+
72 
+
73  CoordinateXY(double xNew, double yNew)
+
74  : x(xNew)
+
75  , y(yNew)
+
76  {}
+
77 
+
78  template<Ordinate>
+
79  double get() const;
+
80 
+
82  double x;
+
83 
+
85  double y;
+
86 
+
88  GEOS_DLL friend bool operator==(const CoordinateXY& a, const CoordinateXY& b)
+
89  {
+
90  return a.equals2D(b);
+
91  };
+
92 
+
94  GEOS_DLL friend bool operator!=(const CoordinateXY& a, const CoordinateXY& b)
+
95  {
+
96  return ! a.equals2D(b);
+
97  };
+
98 
+
99  bool isValid() const
+
100  {
+
101  return std::isfinite(x) && std::isfinite(y);
+
102  };
+
103 
+
104  bool equals2D(const CoordinateXY& other) const
+
105  {
+
106  if(x != other.x) {
+
107  return false;
+
108  }
+
109  if(y != other.y) {
+
110  return false;
+
111  }
+
112  return true;
+
113  };
+
114 
+
115  bool equals2D(const CoordinateXY& other, double tolerance) const
+
116  {
+
117  if (std::abs(x - other.x) > tolerance) {
+
118  return false;
+
119  }
+
120  if (std::abs(y - other.y) > tolerance) {
+
121  return false;
+
122  }
+
123  return true;
+
124  };
+
125 
+
127  bool equals(const CoordinateXY& other) const
+
128  {
+
129  return equals2D(other);
+
130  };
+
131 
+
133  inline int compareTo(const CoordinateXY& other) const
+
134  {
+
135  if(x < other.x) {
+
136  return -1;
+
137  }
+
138  if(x > other.x) {
+
139  return 1;
+
140  }
+
141  if(y < other.y) {
+
142  return -1;
+
143  }
+
144  if(y > other.y) {
+
145  return 1;
+
146  }
+
147  return 0;
+
148  };
+
149 
+
150  static const CoordinateXY& getNull();
+
151 
+
152  double distance(const CoordinateXY& p) const
+
153  {
+
154  double dx = x - p.x;
+
155  double dy = y - p.y;
+
156  return std::sqrt(dx * dx + dy * dy);
+
157  };
+
158 
+
159  double distanceSquared(const CoordinateXY& p) const
+
160  {
+
161  double dx = x - p.x;
+
162  double dy = y - p.y;
+
163  return dx * dx + dy * dy;
+
164  };
+
165 
+
166  bool isNull() const
+
167  {
+
168  return (std::isnan(x) && std::isnan(y));
+
169  };
+
170 
+
171  void setNull()
+
172  {
+
173  x = DoubleNotANumber;
+
174  y = DoubleNotANumber;
+
175  };
+
176 
+
177  struct GEOS_DLL HashCode
+
178  {
+
179  inline std::size_t operator()(const CoordinateXY& c) const
+
180  {
+
181  size_t h = std::hash<double>{}(c.x);
+
182  h ^= std::hash<double>{}(c.y) << 1;
+
183  // z ordinate ignored for consistency with operator==
+
184  return h;
+
185  };
+
186  };
+
187 
+
188  using UnorderedSet = std::unordered_set<Coordinate, HashCode>;
+
189 
+
191  std::string toString() const;
+
192 };
+
193 
+
214 // Define the following to make assignments and copy constructions
+
215 // NON-(will let profilers report usages)
+
216 //#define PROFILE_COORDINATE_COPIES 1
+
217 class GEOS_DLL Coordinate : public CoordinateXY {
+
218 
+
219 private:
+
220 
+
221  static const Coordinate _nullCoord;
+
222 
+
223 public:
+
225  typedef std::set<const Coordinate*, CoordinateLessThan> ConstSet;
+
226  typedef std::set<const CoordinateXY*, CoordinateLessThan> ConstXYSet;
+
227 
+
229  typedef std::vector<const Coordinate*> ConstVect;
+
230 
+
232  typedef std::stack<const Coordinate*> ConstStack;
+
233 
+
235  typedef std::vector<Coordinate> Vect;
+
236 
+
238  typedef std::map<const CoordinateXY*, int, CoordinateLessThan> ConstIntMap;
+
239 
+
241  double z;
242 
-
243  Coordinate(double xNew, double yNew, double zNew = DEFAULT_Z)
-
244  : CoordinateXY(xNew, yNew)
-
245  , z(zNew)
+
243  Coordinate()
+
244  : CoordinateXY()
+
245  , z(DEFAULT_Z)
246  {};
247 
-
248  explicit Coordinate(const CoordinateXY& other)
-
249  : CoordinateXY(other)
-
250  , z(DEFAULT_Z)
+
248  Coordinate(double xNew, double yNew, double zNew = DEFAULT_Z)
+
249  : CoordinateXY(xNew, yNew)
+
250  , z(zNew)
251  {};
252 
-
253  template<Ordinate>
-
254  double get() const;
-
255 
-
256  void setNull()
-
257  {
-
258  CoordinateXY::setNull();
-
259  z = DoubleNotANumber;
-
260  };
-
261 
-
262  static const Coordinate& getNull();
-
263 
-
264  bool isNull() const
-
265  {
-
266  return CoordinateXY::isNull() && std::isnan(z);
-
267  };
+
253  explicit Coordinate(const CoordinateXY& other)
+
254  : CoordinateXY(other)
+
255  , z(DEFAULT_Z)
+
256  {};
+
257 
+
258  template<Ordinate>
+
259  double get() const;
+
260 
+
261  void setNull()
+
262  {
+
263  CoordinateXY::setNull();
+
264  z = DoubleNotANumber;
+
265  };
+
266 
+
267  static const Coordinate& getNull();
268 
-
270  bool equals3D(const Coordinate& other) const
-
271  {
-
272  return (x == other.x) && (y == other.y) &&
-
273  ((z == other.z) || (std::isnan(z) && std::isnan(other.z)));
-
274  };
-
275 
-
277  std::string toString() const;
-
278 
-
279  Coordinate& operator=(const CoordinateXY& other){
-
280  x = other.x;
-
281  y = other.y;
-
282  z = DEFAULT_Z;
+
269  bool isNull() const
+
270  {
+
271  return CoordinateXY::isNull() && std::isnan(z);
+
272  };
+
273 
+
275  bool equals3D(const Coordinate& other) const
+
276  {
+
277  return (x == other.x) && (y == other.y) &&
+
278  ((z == other.z) || (std::isnan(z) && std::isnan(other.z)));
+
279  };
+
280 
+
282  std::string toString() const;
283 
-
284  return *this;
-
285  }
-
286 };
-
287 
+
284  Coordinate& operator=(const CoordinateXY& other){
+
285  x = other.x;
+
286  y = other.y;
+
287  z = DEFAULT_Z;
288 
-
289 class GEOS_DLL CoordinateXYM : public CoordinateXY {
-
290 private:
-
291  static const CoordinateXYM _nullCoord;
+
289  return *this;
+
290  }
+
291 };
292 
-
293 public:
-
294  CoordinateXYM() : CoordinateXYM(DEFAULT_X, DEFAULT_Y, DEFAULT_M) {}
-
295 
-
296  explicit CoordinateXYM(const CoordinateXY& c)
-
297  : CoordinateXY(c)
-
298  , m(DEFAULT_M) {}
-
299 
-
300  CoordinateXYM(double x_, double y_, double m_)
-
301  : CoordinateXY(x_, y_)
-
302  , m(m_) {}
-
303 
-
304  double m;
-
305 
-
306  template<Ordinate>
-
307  double get() const;
+
293 
+
294 class GEOS_DLL CoordinateXYM : public CoordinateXY {
+
295 private:
+
296  static const CoordinateXYM _nullCoord;
+
297 
+
298 public:
+
299  CoordinateXYM() : CoordinateXYM(DEFAULT_X, DEFAULT_Y, DEFAULT_M) {}
+
300 
+
301  explicit CoordinateXYM(const CoordinateXY& c)
+
302  : CoordinateXY(c)
+
303  , m(DEFAULT_M) {}
+
304 
+
305  CoordinateXYM(double x_, double y_, double m_)
+
306  : CoordinateXY(x_, y_)
+
307  , m(m_) {}
308 
-
309  static const CoordinateXYM& getNull();
+
309  double m;
310 
-
311  void setNull()
-
312  {
-
313  CoordinateXY::setNull();
-
314  m = DoubleNotANumber;
-
315  };
-
316 
-
317  bool isNull() const
-
318  {
-
319  return CoordinateXY::isNull() && std::isnan(m);
-
320  }
-
321  bool equals3D(const CoordinateXYM& other) const {
-
322  return x == other.x && y == other.y && (m == other.m || (std::isnan(m) && std::isnan(other.m)));
-
323  }
-
324 
-
325  CoordinateXYM& operator=(const CoordinateXYZM& other);
-
326 
-
327  CoordinateXYM& operator=(const CoordinateXY& other) {
-
328  x = other.x;
-
329  y = other.y;
-
330  m = DEFAULT_M;
+
311  template<Ordinate>
+
312  double get() const;
+
313 
+
314  static const CoordinateXYM& getNull();
+
315 
+
316  void setNull()
+
317  {
+
318  CoordinateXY::setNull();
+
319  m = DoubleNotANumber;
+
320  };
+
321 
+
322  bool isNull() const
+
323  {
+
324  return CoordinateXY::isNull() && std::isnan(m);
+
325  }
+
326  bool equals3D(const CoordinateXYM& other) const {
+
327  return x == other.x && y == other.y && (m == other.m || (std::isnan(m) && std::isnan(other.m)));
+
328  }
+
329 
+
330  CoordinateXYM& operator=(const CoordinateXYZM& other);
331 
-
332  return *this;
-
333  }
-
334 
-
335  std::string toString() const;
-
336 };
-
337 
-
338 
-
339 class GEOS_DLL CoordinateXYZM : public Coordinate {
-
340 private:
-
341  static const CoordinateXYZM _nullCoord;
+
332  CoordinateXYM& operator=(const CoordinateXY& other) {
+
333  x = other.x;
+
334  y = other.y;
+
335  m = DEFAULT_M;
+
336 
+
337  return *this;
+
338  }
+
339 
+
340  std::string toString() const;
+
341 };
342 
-
343 public:
-
344  CoordinateXYZM() : CoordinateXYZM(DEFAULT_X, DEFAULT_Y, DEFAULT_Z, DEFAULT_M) {}
-
345 
-
346  explicit CoordinateXYZM(const CoordinateXY& c)
-
347  : Coordinate(c)
-
348  , m(DEFAULT_M) {}
-
349 
-
350  explicit CoordinateXYZM(const CoordinateXYM& c)
-
351  : Coordinate(c)
-
352  , m(c.m) {}
-
353 
-
354  explicit CoordinateXYZM(const Coordinate& c)
-
355  : Coordinate(c)
-
356  , m(DEFAULT_M) {}
-
357 
-
358  CoordinateXYZM(double x_, double y_, double z_, double m_)
-
359  : Coordinate(x_, y_, z_)
-
360  , m(m_) {}
-
361 
-
362  double m;
-
363 
-
364  template<Ordinate>
-
365  double get() const;
+
343 
+
344 class GEOS_DLL CoordinateXYZM : public Coordinate {
+
345 private:
+
346  static const CoordinateXYZM _nullCoord;
+
347 
+
348 public:
+
349  CoordinateXYZM() : CoordinateXYZM(DEFAULT_X, DEFAULT_Y, DEFAULT_Z, DEFAULT_M) {}
+
350 
+
351  explicit CoordinateXYZM(const CoordinateXY& c)
+
352  : Coordinate(c)
+
353  , m(DEFAULT_M) {}
+
354 
+
355  explicit CoordinateXYZM(const CoordinateXYM& c)
+
356  : Coordinate(c)
+
357  , m(c.m) {}
+
358 
+
359  explicit CoordinateXYZM(const Coordinate& c)
+
360  : Coordinate(c)
+
361  , m(DEFAULT_M) {}
+
362 
+
363  CoordinateXYZM(double x_, double y_, double z_, double m_)
+
364  : Coordinate(x_, y_, z_)
+
365  , m(m_) {}
366 
-
367  static const CoordinateXYZM& getNull();
+
367  double m;
368 
-
369  void setNull()
-
370  {
-
371  Coordinate::setNull();
-
372  m = DoubleNotANumber;
-
373  };
-
374 
-
375 
-
376  bool isNull() const
-
377  {
-
378  return Coordinate::isNull() && std::isnan(m);
-
379  }
+
369  template<Ordinate>
+
370  double get() const;
+
371 
+
372  static const CoordinateXYZM& getNull();
+
373 
+
374  void setNull()
+
375  {
+
376  Coordinate::setNull();
+
377  m = DoubleNotANumber;
+
378  };
+
379 
380 
-
381  bool equals4D(const CoordinateXYZM& other) const {
-
382  return x == other.x && y == other.y &&
-
383  (z == other.z || (std::isnan(z) && std::isnan(other.z))) &&
-
384  (m == other.m || (std::isnan(m) && std::isnan(other.m)));
-
385  }
-
386 
-
387  CoordinateXYZM& operator=(const CoordinateXY& other) {
-
388  x = other.x;
-
389  y = other.y;
-
390  z = DEFAULT_Z;
-
391  m = DEFAULT_M;
-
392 
-
393  return *this;
-
394  }
-
395 
-
396  CoordinateXYZM& operator=(const Coordinate& other) {
-
397  x = other.x;
-
398  y = other.y;
-
399  z = other.z;
-
400  m = DEFAULT_M;
-
401 
-
402  return *this;
-
403  }
-
404 
-
405  CoordinateXYZM& operator=(const CoordinateXYM& other) {
-
406  x = other.x;
-
407  y = other.y;
-
408  z = DEFAULT_Z;
-
409  m = other.m;
-
410 
-
411  return *this;
-
412  }
-
413 
-
414  std::string toString() const;
-
415 };
-
416 
-
417 inline CoordinateXYM&
-
418 CoordinateXYM::operator=(const CoordinateXYZM& other) {
-
419  x = other.x;
-
420  y = other.y;
-
421  m = other.m;
-
422 
-
423  return *this;
-
424 }
-
425 
-
426 
-
428 struct GEOS_DLL CoordinateLessThan {
-
429 
-
430  bool operator()(const CoordinateXY* a, const CoordinateXY* b) const
-
431  {
-
432  if(a->compareTo(*b) < 0) {
-
433  return true;
-
434  }
-
435  else {
-
436  return false;
-
437  }
-
438  };
-
439 
-
440  bool operator()(const CoordinateXY& a, const CoordinateXY& b) const
-
441  {
-
442  if(a.compareTo(b) < 0) {
-
443  return true;
-
444  }
-
445  else {
-
446  return false;
-
447  }
-
448  };
-
449 
-
450 };
-
451 
-
453 inline bool operator<(const CoordinateXY& a, const CoordinateXY& b)
-
454 {
-
455  return CoordinateLessThan()(a, b);
-
456 }
-
457 
-
458 
-
459 // Generic accessors, XY
-
460 
-
461 template<>
-
462 inline double CoordinateXY::get<Ordinate::X>() const
-
463 {
-
464  return x;
-
465 }
-
466 
-
467 template<>
-
468 inline double CoordinateXY::get<Ordinate::Y>() const
-
469 {
-
470  return y;
-
471 }
-
472 
-
473 template<>
-
474 inline double CoordinateXY::get<Ordinate::Z>() const
-
475 {
-
476  return DEFAULT_Z;
-
477 }
-
478 
-
479 template<>
-
480 inline double CoordinateXY::get<Ordinate::M>() const
-
481 {
-
482  return DEFAULT_M;
-
483 }
-
484 
-
485 // Generic accessors, XYZ
-
486 
-
487 template<>
-
488 inline double Coordinate::get<Ordinate::X>() const
-
489 {
-
490  return x;
-
491 }
-
492 
-
493 template<>
-
494 inline double Coordinate::get<Ordinate::Y>() const
-
495 {
-
496  return y;
-
497 }
-
498 
-
499 template<>
-
500 inline double Coordinate::get<Ordinate::Z>() const
-
501 {
-
502  return z;
-
503 }
-
504 
-
505 template<>
-
506 inline double Coordinate::get<Ordinate::M>() const
-
507 {
-
508  return DEFAULT_M;
-
509 }
-
510 
-
511 // Generic accessors, XYM
-
512 
-
513 template<>
-
514 inline double CoordinateXYM::get<Ordinate::X>() const
-
515 {
-
516  return x;
-
517 }
-
518 
-
519 template<>
-
520 inline double CoordinateXYM::get<Ordinate::Y>() const
-
521 {
-
522  return y;
-
523 }
-
524 
-
525 template<>
-
526 inline double CoordinateXYM::get<Ordinate::Z>() const
-
527 {
-
528  return DEFAULT_Z;
-
529 }
-
530 
-
531 template<>
-
532 inline double CoordinateXYM::get<Ordinate::M>() const
-
533 {
-
534  return m;
-
535 }
-
536 
-
537 // Generic accessors, XYZM
-
538 
-
539 template<>
-
540 inline double CoordinateXYZM::get<Ordinate::X>() const
-
541 {
-
542  return x;
-
543 }
-
544 
-
545 template<>
-
546 inline double CoordinateXYZM::get<Ordinate::Y>() const
-
547 {
-
548  return y;
-
549 }
-
550 
-
551 template<>
-
552 inline double CoordinateXYZM::get<Ordinate::Z>() const
-
553 {
-
554  return z;
-
555 }
-
556 
-
557 template<>
-
558 inline double CoordinateXYZM::get<Ordinate::M>() const
-
559 {
-
560  return m;
-
561 }
-
562 
-
563 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXY& c);
-
564 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Coordinate& c);
-
565 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXYM& c);
-
566 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXYZM& c);
+
381  bool isNull() const
+
382  {
+
383  return Coordinate::isNull() && std::isnan(m);
+
384  }
+
385 
+
386  bool equals4D(const CoordinateXYZM& other) const {
+
387  return x == other.x && y == other.y &&
+
388  (z == other.z || (std::isnan(z) && std::isnan(other.z))) &&
+
389  (m == other.m || (std::isnan(m) && std::isnan(other.m)));
+
390  }
+
391 
+
392  CoordinateXYZM& operator=(const CoordinateXY& other) {
+
393  x = other.x;
+
394  y = other.y;
+
395  z = DEFAULT_Z;
+
396  m = DEFAULT_M;
+
397 
+
398  return *this;
+
399  }
+
400 
+
401  CoordinateXYZM& operator=(const Coordinate& other) {
+
402  x = other.x;
+
403  y = other.y;
+
404  z = other.z;
+
405  m = DEFAULT_M;
+
406 
+
407  return *this;
+
408  }
+
409 
+
410  CoordinateXYZM& operator=(const CoordinateXYM& other) {
+
411  x = other.x;
+
412  y = other.y;
+
413  z = DEFAULT_Z;
+
414  m = other.m;
+
415 
+
416  return *this;
+
417  }
+
418 
+
419  std::string toString() const;
+
420 };
+
421 
+
422 inline CoordinateXYM&
+
423 CoordinateXYM::operator=(const CoordinateXYZM& other) {
+
424  x = other.x;
+
425  y = other.y;
+
426  m = other.m;
+
427 
+
428  return *this;
+
429 }
+
430 
+
431 
+
433 struct GEOS_DLL CoordinateLessThan {
+
434 
+
435  bool operator()(const CoordinateXY* a, const CoordinateXY* b) const
+
436  {
+
437  if(a->compareTo(*b) < 0) {
+
438  return true;
+
439  }
+
440  else {
+
441  return false;
+
442  }
+
443  };
+
444 
+
445  bool operator()(const CoordinateXY& a, const CoordinateXY& b) const
+
446  {
+
447  if(a.compareTo(b) < 0) {
+
448  return true;
+
449  }
+
450  else {
+
451  return false;
+
452  }
+
453  };
+
454 
+
455 };
+
456 
+
458 inline bool operator<(const CoordinateXY& a, const CoordinateXY& b)
+
459 {
+
460  return CoordinateLessThan()(a, b);
+
461 }
+
462 
+
463 
+
464 // Generic accessors, XY
+
465 
+
466 template<>
+
467 inline double CoordinateXY::get<Ordinate::X>() const
+
468 {
+
469  return x;
+
470 }
+
471 
+
472 template<>
+
473 inline double CoordinateXY::get<Ordinate::Y>() const
+
474 {
+
475  return y;
+
476 }
+
477 
+
478 template<>
+
479 inline double CoordinateXY::get<Ordinate::Z>() const
+
480 {
+
481  return DEFAULT_Z;
+
482 }
+
483 
+
484 template<>
+
485 inline double CoordinateXY::get<Ordinate::M>() const
+
486 {
+
487  return DEFAULT_M;
+
488 }
+
489 
+
490 // Generic accessors, XYZ
+
491 
+
492 template<>
+
493 inline double Coordinate::get<Ordinate::X>() const
+
494 {
+
495  return x;
+
496 }
+
497 
+
498 template<>
+
499 inline double Coordinate::get<Ordinate::Y>() const
+
500 {
+
501  return y;
+
502 }
+
503 
+
504 template<>
+
505 inline double Coordinate::get<Ordinate::Z>() const
+
506 {
+
507  return z;
+
508 }
+
509 
+
510 template<>
+
511 inline double Coordinate::get<Ordinate::M>() const
+
512 {
+
513  return DEFAULT_M;
+
514 }
+
515 
+
516 // Generic accessors, XYM
+
517 
+
518 template<>
+
519 inline double CoordinateXYM::get<Ordinate::X>() const
+
520 {
+
521  return x;
+
522 }
+
523 
+
524 template<>
+
525 inline double CoordinateXYM::get<Ordinate::Y>() const
+
526 {
+
527  return y;
+
528 }
+
529 
+
530 template<>
+
531 inline double CoordinateXYM::get<Ordinate::Z>() const
+
532 {
+
533  return DEFAULT_Z;
+
534 }
+
535 
+
536 template<>
+
537 inline double CoordinateXYM::get<Ordinate::M>() const
+
538 {
+
539  return m;
+
540 }
+
541 
+
542 // Generic accessors, XYZM
+
543 
+
544 template<>
+
545 inline double CoordinateXYZM::get<Ordinate::X>() const
+
546 {
+
547  return x;
+
548 }
+
549 
+
550 template<>
+
551 inline double CoordinateXYZM::get<Ordinate::Y>() const
+
552 {
+
553  return y;
+
554 }
+
555 
+
556 template<>
+
557 inline double CoordinateXYZM::get<Ordinate::Z>() const
+
558 {
+
559  return z;
+
560 }
+
561 
+
562 template<>
+
563 inline double CoordinateXYZM::get<Ordinate::M>() const
+
564 {
+
565  return m;
+
566 }
567 
-
568 } // namespace geos.geom
-
569 } // namespace geos
-
570 
-
571 // Add specializations of std::common_type for Coordinate types
-
572 namespace std {
-
573  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXY; };
-
574  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::Coordinate> { using type = geos::geom::Coordinate; };
-
575  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYM; };
-
576  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
-
577 
-
578  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXY> { using type = geos::geom::Coordinate; };
-
579  template<> struct common_type<geos::geom::Coordinate, geos::geom::Coordinate> { using type = geos::geom::Coordinate; };
-
580  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYZM; };
-
581  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
+
568 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXY& c);
+
569 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Coordinate& c);
+
570 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXYM& c);
+
571 GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateXYZM& c);
+
572 
+
573 } // namespace geos.geom
+
574 } // namespace geos
+
575 
+
576 // Add specializations of std::common_type for Coordinate types
+
577 namespace std {
+
578  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXY; };
+
579  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::Coordinate> { using type = geos::geom::Coordinate; };
+
580  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYM; };
+
581  template<> struct common_type<geos::geom::CoordinateXY, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
582 
-
583  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXYM; };
-
584  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::Coordinate> { using type = geos::geom::CoordinateXYZM; };
-
585  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYM; };
-
586  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
+
583  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXY> { using type = geos::geom::Coordinate; };
+
584  template<> struct common_type<geos::geom::Coordinate, geos::geom::Coordinate> { using type = geos::geom::Coordinate; };
+
585  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYZM; };
+
586  template<> struct common_type<geos::geom::Coordinate, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
587 
-
588  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXYZM; };
-
589  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::Coordinate> { using type = geos::geom::CoordinateXYZM; };
-
590  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYZM; };
-
591  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
-
592 }
-
593 
-
594 #ifdef _MSC_VER
-
595 #pragma warning(pop)
-
596 #endif
-
597 
+
588  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXYM; };
+
589  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::Coordinate> { using type = geos::geom::CoordinateXYZM; };
+
590  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYM; };
+
591  template<> struct common_type<geos::geom::CoordinateXYM, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
+
592 
+
593  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXY> { using type = geos::geom::CoordinateXYZM; };
+
594  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::Coordinate> { using type = geos::geom::CoordinateXYZM; };
+
595  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXYM> { using type = geos::geom::CoordinateXYZM; };
+
596  template<> struct common_type<geos::geom::CoordinateXYZM, geos::geom::CoordinateXYZM> { using type = geos::geom::CoordinateXYZM; };
+
597 }
598 
-
599 
-
600 
-
601 
+
599 #ifdef _MSC_VER
+
600 #pragma warning(pop)
+
601 #endif
602 
603 
604 
@@ -633,17 +632,23 @@
620 
621 
622 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
623 
+
624 
+
625 
+
626 
+
627 
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Coordinate::toString
std::string toString() const
Returns a string of the form (x,y,z) .
-
geos::geom::Coordinate::ConstSet
std::set< const Coordinate *, CoordinateLessThan > ConstSet
A set of const Coordinate pointers.
Definition: Coordinate.h:224
-
geos::geom::Coordinate::Vect
std::vector< Coordinate > Vect
A vector of Coordinate objects (real object, not pointers)
Definition: Coordinate.h:233
-
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:227
-
geos::geom::Coordinate::ConstStack
std::stack< const Coordinate * > ConstStack
A stack of const Coordinate pointers.
Definition: Coordinate.h:230
-
geos::geom::Coordinate::equals3D
bool equals3D(const Coordinate &other) const
3D comparison
Definition: Coordinate.h:270
-
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:236
-
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:453
+
geos::geom::Coordinate::ConstIntMap
std::map< const CoordinateXY *, int, CoordinateLessThan > ConstIntMap
A map of const Coordinate pointers to integers.
Definition: Coordinate.h:238
+
geos::geom::Coordinate::ConstSet
std::set< const Coordinate *, CoordinateLessThan > ConstSet
A set of const Coordinate pointers.
Definition: Coordinate.h:225
+
geos::geom::Coordinate::Vect
std::vector< Coordinate > Vect
A vector of Coordinate objects (real object, not pointers)
Definition: Coordinate.h:235
+
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:229
+
geos::geom::Coordinate::ConstStack
std::stack< const Coordinate * > ConstStack
A stack of const Coordinate pointers.
Definition: Coordinate.h:232
+
geos::geom::Coordinate::equals3D
bool equals3D(const Coordinate &other) const
3D comparison
Definition: Coordinate.h:275
+
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:241
+
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:458
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
-
geos::geom::CoordinateLessThan
Strict weak ordering Functor for Coordinate.
Definition: Coordinate.h:428
+
geos::geom::CoordinateLessThan
Strict weak ordering Functor for Coordinate.
Definition: Coordinate.h:433
diff --git a/doxygen/Corner_8h_source.html b/doxygen/Corner_8h_source.html index 9a6a42cde7..9430d9acc0 100644 --- a/doxygen/Corner_8h_source.html +++ b/doxygen/Corner_8h_source.html @@ -184,7 +184,7 @@
135 
136 } // geos::coverage
137 } // geos
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::LineString
Definition: LineString.h:66
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoverageBoundarySegmentFinder_8h_source.html b/doxygen/CoverageBoundarySegmentFinder_8h_source.html index 3021eac6ca..e99973d1b6 100644 --- a/doxygen/CoverageBoundarySegmentFinder_8h_source.html +++ b/doxygen/CoverageBoundarySegmentFinder_8h_source.html @@ -132,7 +132,7 @@
83 } // geos
geos::geom::CoordinateSequenceFilter
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineSegment
Definition: LineSegment.h:61
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CoverageEdge_8h_source.html b/doxygen/CoverageEdge_8h_source.html index 4f76d84e9e..6eaa26c468 100644 --- a/doxygen/CoverageEdge_8h_source.html +++ b/doxygen/CoverageEdge_8h_source.html @@ -193,7 +193,7 @@
geos::coverage::CoverageEdge::isFreeRing
bool isFreeRing() const
Definition: CoverageEdge.h:142
geos::coverage::CoverageEdge::key
static LineSegment key(const CoordinateSequence &ring, std::size_t start, std::size_t end)
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::geom::LineString
Definition: LineString.h:66
diff --git a/doxygen/CoveragePolygonValidator_8h_source.html b/doxygen/CoveragePolygonValidator_8h_source.html index 5711ad121c..5b41bd7bd5 100644 --- a/doxygen/CoveragePolygonValidator_8h_source.html +++ b/doxygen/CoveragePolygonValidator_8h_source.html @@ -291,7 +291,7 @@
geos::coverage::CoveragePolygonValidator::validate
static std::unique_ptr< Geometry > validate(const Geometry *targetPolygon, std::vector< const Geometry * > &adjPolygons)
geos::coverage::CoveragePolygonValidator::CoveragePolygonValidator
CoveragePolygonValidator(const Geometry *targetPolygon, std::vector< const Geometry * > &adjPolygons)
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/CoverageRingEdges_8h_source.html b/doxygen/CoverageRingEdges_8h_source.html index 6b70ac0e4c..c3798ca6c0 100644 --- a/doxygen/CoverageRingEdges_8h_source.html +++ b/doxygen/CoverageRingEdges_8h_source.html @@ -201,7 +201,7 @@
geos::coverage::CoverageRingEdges::selectEdges
std::vector< CoverageEdge * > selectEdges(std::size_t ringCount) const
geos::coverage::CoverageRingEdges::buildCoverage
std::vector< std::unique_ptr< Geometry > > buildCoverage() const
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
diff --git a/doxygen/CoverageRing_8h_source.html b/doxygen/CoverageRing_8h_source.html index 2023db88fa..d0446611ac 100644 --- a/doxygen/CoverageRing_8h_source.html +++ b/doxygen/CoverageRing_8h_source.html @@ -165,7 +165,7 @@
204 
205 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
diff --git a/doxygen/DimensionLocation_8h_source.html b/doxygen/DimensionLocation_8h_source.html new file mode 100644 index 0000000000..90b765737e --- /dev/null +++ b/doxygen/DimensionLocation_8h_source.html @@ -0,0 +1,119 @@ + + + + + + + +GEOS: DimensionLocation.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
DimensionLocation.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/export.h>
+
20 
+
21 
+
22 using geos::geom::Location;
+
23 
+
24 
+
25 namespace geos { // geos.
+
26 namespace operation { // geos.operation
+
27 namespace relateng { // geos.operation.relateng
+
28 
+
29 
+
30 class GEOS_DLL DimensionLocation {
+
31 
+
32 public:
+
33 
+
34  enum DimensionLocationType {
+
35  EXTERIOR = 2, // == Location.EXTERIOR
+
36  POINT_INTERIOR = 103,
+
37  LINE_INTERIOR = 110,
+
38  LINE_BOUNDARY = 111,
+
39  AREA_INTERIOR = 120,
+
40  AREA_BOUNDARY = 121
+
41  };
+
42 
+
43  static int locationArea(Location loc);
+
44 
+
45  static int locationLine(Location loc);
+
46 
+
47  static int locationPoint(Location loc);
+
48 
+
49  static Location location(int dimLoc);
+
50 
+
51  static int dimension(int dimLoc);
+
52 
+
53  static int dimension(int dimLoc, int exteriorDim);
+
54 
+
55 };
+
56 
+
57 } // namespace geos.operation.relateng
+
58 } // namespace geos.operation
+
59 } // namespace geos
+
60 
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+ +
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/DiscreteFrechetDistance_8h_source.html b/doxygen/DiscreteFrechetDistance_8h_source.html index 5a79d17d93..6e1b458921 100644 --- a/doxygen/DiscreteFrechetDistance_8h_source.html +++ b/doxygen/DiscreteFrechetDistance_8h_source.html @@ -172,7 +172,7 @@
geos::algorithm::distance::DiscreteFrechetDistance
An algorithm for computing a distance metric which is an approximation to the Frechet Distance based ...
Definition: DiscreteFrechetDistance.h:105
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/EdgeEndStar_8h_source.html b/doxygen/EdgeEndStar_8h_source.html index 0cadcf158e..72351d84dd 100644 --- a/doxygen/EdgeEndStar_8h_source.html +++ b/doxygen/EdgeEndStar_8h_source.html @@ -236,7 +236,7 @@
216 #endif
217 
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::EdgeEndStar
A EdgeEndStar is an ordered list of EdgeEnds around a node.
Definition: EdgeEndStar.h:63
geos::geomgraph::EdgeEndStar::getCoordinate
virtual geom::Coordinate & getCoordinate()
geos::geomgraph::EdgeEndStar::edgeMap
EdgeEndStar::container edgeMap
A map which maintains the edges in sorted order around the node.
Definition: EdgeEndStar.h:138
diff --git a/doxygen/EdgeEnd_8h_source.html b/doxygen/EdgeEnd_8h_source.html index a2c571d781..92639594ed 100644 --- a/doxygen/EdgeEnd_8h_source.html +++ b/doxygen/EdgeEnd_8h_source.html @@ -193,7 +193,7 @@
186 } // namespace geos
187 
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::EdgeEnd
Models the end of an edge incident on a node.
Definition: EdgeEnd.h:54
geos::geomgraph::EdgeEnd::EdgeEnd
EdgeEnd(Edge *newEdge, const geom::Coordinate &newP0, const geom::Coordinate &newP1, const Label &newLabel)
geos::geomgraph::EdgeEnd::compareDirection
virtual int compareDirection(const EdgeEnd *e) const
diff --git a/doxygen/EdgeIntersectionList_8h_source.html b/doxygen/EdgeIntersectionList_8h_source.html index b26d2fb693..503c255cfa 100644 --- a/doxygen/EdgeIntersectionList_8h_source.html +++ b/doxygen/EdgeIntersectionList_8h_source.html @@ -162,7 +162,7 @@
127 #pragma warning(pop)
128 #endif
129 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::EdgeIntersectionList
A list of edge intersections along an Edge.
Definition: EdgeIntersectionList.h:57
geos::geomgraph::EdgeIntersectionList::addSplitEdges
void addSplitEdges(std::vector< Edge * > *edgeList)
geos::geomgraph::EdgeIntersection
Represents a point on an edge which intersects with another edge.
Definition: EdgeIntersection.h:42
diff --git a/doxygen/EdgeIntersection_8h_source.html b/doxygen/EdgeIntersection_8h_source.html index d9c3b0fa32..d1c3c9c103 100644 --- a/doxygen/EdgeIntersection_8h_source.html +++ b/doxygen/EdgeIntersection_8h_source.html @@ -184,7 +184,7 @@
147 } // namespace geos.geomgraph
148 } // namespace geos
149 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::EdgeIntersection
Represents a point on an edge which intersects with another edge.
Definition: EdgeIntersection.h:42
geos::geomgraph::operator<
bool operator<(const EdgeIntersection &ei1, const EdgeIntersection &ei2)
Definition: EdgeIntersection.h:105
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/EdgeKey_8h_source.html b/doxygen/EdgeKey_8h_source.html index fc87889b5b..dc8127447b 100644 --- a/doxygen/EdgeKey_8h_source.html +++ b/doxygen/EdgeKey_8h_source.html @@ -158,10 +158,10 @@
118 } // namespace geos.operation
119 } // namespace geos
120 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::overlayng::EdgeKey
Definition: EdgeKey.h:41
geos::operation::overlayng::Edge
Definition: operation/overlayng/Edge.h:55
-
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:453
+
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:458
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/EdgeMerger_8h_source.html b/doxygen/EdgeMerger_8h_source.html index 14a26c93c3..70e6a4fda4 100644 --- a/doxygen/EdgeMerger_8h_source.html +++ b/doxygen/EdgeMerger_8h_source.html @@ -101,7 +101,7 @@
79 } // namespace geos.operation.overlayng
80 } // namespace geos.operation
81 } // namespace geos
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::overlayng::EdgeMerger
Definition: EdgeMerger.h:70
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/EdgeSegmentIntersector_8h_source.html b/doxygen/EdgeSegmentIntersector_8h_source.html new file mode 100644 index 0000000000..78bf09af27 --- /dev/null +++ b/doxygen/EdgeSegmentIntersector_8h_source.html @@ -0,0 +1,140 @@ + + + + + + + +GEOS: EdgeSegmentIntersector.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
EdgeSegmentIntersector.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 
+
19 #include <geos/noding/SegmentIntersector.h>
+
20 #include <geos/algorithm/LineIntersector.h>
+
21 #include <geos/export.h>
+
22 
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace noding {
+
27  class SegmentString;
+
28 }
+
29 namespace operation {
+
30 namespace relateng {
+
31  class RelateSegmentString;
+
32  class TopologyComputer;
+
33 }
+
34 }
+
35 }
+
36 
+
37 
+
38 using geos::noding::SegmentIntersector;
+
39 using geos::noding::SegmentString;
+
40 using geos::algorithm::LineIntersector;
+
41 
+
42 
+
43 namespace geos { // geos.
+
44 namespace operation { // geos.operation
+
45 namespace relateng { // geos.operation.relateng
+
46 
+
47 class GEOS_DLL EdgeSegmentIntersector : public SegmentIntersector {
+
48 
+
49 private:
+
50 
+
51  // Members
+
52  LineIntersector li;
+
53  TopologyComputer& topoComputer;
+
54 
+
55  // Methods
+
56 
+
57 
+
58  void addIntersections(
+
59  RelateSegmentString* ssA, std::size_t segIndexA,
+
60  RelateSegmentString* ssB, std::size_t segIndexB);
+
61 
+
62 
+
63 public:
+
64 
+
65  EdgeSegmentIntersector(TopologyComputer& p_topoComputer)
+
66  : topoComputer(p_topoComputer)
+
67  {};
+
68 
+
69  void processIntersections(
+
70  SegmentString* ss0, std::size_t segIndex0,
+
71  SegmentString* ss1, std::size_t segIndex1) override;
+
72 
+
73  bool isDone() const override;
+
74 
+
75 };
+
76 
+
77 } // namespace geos.operation.relateng
+
78 } // namespace geos.operation
+
79 } // namespace geos
+
80 
+
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
+
geos::noding::SegmentIntersector
Processes possible intersections detected by a Noder.
Definition: noding/SegmentIntersector.h:45
+
geos::noding::SegmentString
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:47
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/EdgeSegmentOverlapAction_8h_source.html b/doxygen/EdgeSegmentOverlapAction_8h_source.html new file mode 100644 index 0000000000..3a986dbfbb --- /dev/null +++ b/doxygen/EdgeSegmentOverlapAction_8h_source.html @@ -0,0 +1,133 @@ + + + + + + + +GEOS: EdgeSegmentOverlapAction.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
EdgeSegmentOverlapAction.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (C) 2001-2002 Vivid Solutions Inc.
+
7  *
+
8  * This is free software; you can redistribute and/or modify it under
+
9  * the terms of the GNU Lesser General Public Licence as published
+
10  * by the Free Software Foundation.
+
11  * See the COPYING file for more information.
+
12  *
+
13  **********************************************************************
+
14  *
+
15  * Last port: index/chain/MonotoneChainOverlapAction.java rev. 1.6 (JTS-1.10)
+
16  *
+
17  **********************************************************************/
+
18 
+
19 #pragma once
+
20 
+
21 #include <geos/export.h>
+
22 #include <geos/geom/LineSegment.h>
+
23 #include <geos/index/chain/MonotoneChainOverlapAction.h>
+
24 
+
25 
+
26 // Forward declarations
+
27 namespace geos {
+
28 namespace index {
+
29 namespace chain {
+
30  class MonotoneChain;
+
31 }
+
32 }
+
33 namespace noding {
+
34  class SegmentIntersector;
+
35 }
+
36 }
+
37 
+
38 
+
39 using geos::index::chain::MonotoneChain;
+
40 using geos::index::chain::MonotoneChainOverlapAction;
+
41 using geos::noding::SegmentIntersector;
+
42 
+
43 
+
44 namespace geos {
+
45 namespace operation { // geos::operation
+
46 namespace relateng { // geos::operation::relateng
+
47 
+
52 class GEOS_DLL EdgeSegmentOverlapAction : public MonotoneChainOverlapAction {
+
53 
+
54 private:
+
55 
+
56  SegmentIntersector& si;
+
57 
+
58 
+
59 public:
+
60 
+
61  EdgeSegmentOverlapAction(SegmentIntersector& p_si)
+
62  : si(p_si)
+
63  {}
+
64 
+
65  void overlap(
+
66  const MonotoneChain& mc1, std::size_t start1,
+
67  const MonotoneChain& mc2, std::size_t start2) override;
+
68 
+
69 
+
70 };
+
71 
+
72 } // namespace geos::index::chain
+
73 } // namespace geos::index
+
74 } // namespace geos
+
75 
+
geos::index::chain::MonotoneChainOverlapAction
The action for the internal iterator for performing overlap queries on a MonotoneChain.
Definition: MonotoneChainOverlapAction.h:42
+
geos::index::chain::MonotoneChain
Monotone Chains are a way of partitioning the segments of a linestring to allow for fast searching of...
Definition: index/chain/MonotoneChain.h:85
+
geos::noding::SegmentIntersector
Processes possible intersections detected by a Noder.
Definition: noding/SegmentIntersector.h:45
+
geos::operation::relateng::EdgeSegmentOverlapAction
The action for the internal iterator for performing overlap queries on a MonotoneChain.
Definition: EdgeSegmentOverlapAction.h:52
+
geos::operation::relateng::EdgeSegmentOverlapAction::overlap
void overlap(const MonotoneChain &mc1, std::size_t start1, const MonotoneChain &mc2, std::size_t start2) override
This function can be overridden if the original chains are needed.
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/Envelope_8h_source.html b/doxygen/Envelope_8h_source.html index 1e5a44400c..38da007e52 100644 --- a/doxygen/Envelope_8h_source.html +++ b/doxygen/Envelope_8h_source.html @@ -534,7 +534,7 @@
824 
825 } // namespace geos::geom
826 } // namespace geos
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::Envelope::getMinX
double getMinX() const
Returns the Envelope minimum x-value. Null envelopes do not have maximum values.
Definition: Envelope.h:338
geos::geom::Envelope::expandToInclude
void expandToInclude(const CoordinateXY &p)
Enlarges the boundary of the Envelope so that it contains p. Does nothing if p is already on or withi...
Definition: Envelope.h:415
@@ -586,7 +586,7 @@
geos::geom::Envelope::getMinY
double getMinY() const
Returns the Envelope minimum y-value. Null envelopes do not have maximum values.
Definition: Envelope.h:328
geos::geom::Envelope::Envelope
Envelope(double x1, double x2, double y1, double y2)
Creates an Envelope for a region defined by maximum and minimum values.
Definition: Envelope.h:85
geos::geom::Envelope::maxDistance
double maxDistance(const Envelope &other) const
Computes the maximum distance between points in this and another Envelope.
Definition: Envelope.h:682
-
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:453
+
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:458
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/FuzzyPointLocator_8h_source.html b/doxygen/FuzzyPointLocator_8h_source.html index 62edb4f415..6c4bfa4114 100644 --- a/doxygen/FuzzyPointLocator_8h_source.html +++ b/doxygen/FuzzyPointLocator_8h_source.html @@ -131,7 +131,7 @@
96 #endif
97 
geos::algorithm::PointLocator
Computes the topological relationship (Location) of a single point to a Geometry.
Definition: PointLocator.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::operation::overlay::validate::FuzzyPointLocator
Finds the most likely Location of a point relative to the polygonal components of a geometry,...
Definition: FuzzyPointLocator.h:57
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
diff --git a/doxygen/GeoJSONReader_8h_source.html b/doxygen/GeoJSONReader_8h_source.html index 47b7034bdd..2306c4e25e 100644 --- a/doxygen/GeoJSONReader_8h_source.html +++ b/doxygen/GeoJSONReader_8h_source.html @@ -155,7 +155,7 @@
123 } // namespace io
124 } // namespace geos
125 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::io::GeoJSONReader
GeoJSON reader class; see also GeoJSONWriter.
Definition: GeoJSONReader.h:49
geos::io::GeoJSONReader::GeoJSONReader
GeoJSONReader(const geom::GeometryFactory &gf)
Initialize parser with given GeometryFactory.
diff --git a/doxygen/GeometryCollection_8h_source.html b/doxygen/GeometryCollection_8h_source.html index 70a2a91d2f..506f6c2be8 100644 --- a/doxygen/GeometryCollection_8h_source.html +++ b/doxygen/GeometryCollection_8h_source.html @@ -220,11 +220,12 @@
248 
249  bool hasCurvedComponents() const override;
250 
-
251 };
-
252 
-
253 } // namespace geos::geom
-
254 } // namespace geos
-
255 
+
251 
+
252 };
+
253 
+
254 } // namespace geos::geom
+
255 } // namespace geos
+
256 
geos::geom::CoordinateFilter
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
geos::geom::CoordinateSequenceFilter
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
geos::geom::Dimension::DimensionType
DimensionType
Definition: Dimension.h:29
diff --git a/doxygen/GeometryFactory_8h_source.html b/doxygen/GeometryFactory_8h_source.html index dbaeb6f582..0212553058 100644 --- a/doxygen/GeometryFactory_8h_source.html +++ b/doxygen/GeometryFactory_8h_source.html @@ -405,7 +405,7 @@
541 
542 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Dimension::A
@ A
Dimension value of a surface (2).
Definition: Dimension.h:46
geos::geom::Dimension::L
@ L
Dimension value of a curve (1).
Definition: Dimension.h:43
geos::geom::Dimension::P
@ P
Dimension value of a point (0).
Definition: Dimension.h:40
diff --git a/doxygen/GeometryGraph_8h_source.html b/doxygen/GeometryGraph_8h_source.html index 89d3edf485..063fad3b23 100644 --- a/doxygen/GeometryGraph_8h_source.html +++ b/doxygen/GeometryGraph_8h_source.html @@ -250,7 +250,7 @@
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryCollection
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:51
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
@@ -265,7 +265,7 @@
geos::geomgraph::GeometryGraph::computeSelfNodes
std::unique_ptr< index::SegmentIntersector > computeSelfNodes(algorithm::LineIntersector *li, bool computeRingSelfNodes, const geom::Envelope *env=nullptr)
Compute self-nodes, taking advantage of the Geometry type to minimize the number of intersection test...
Definition: GeometryGraph.h:213
geos::geomgraph::PlanarGraph
Represents a directed graph which is embeddable in a planar surface.
Definition: geomgraph/PlanarGraph.h:72
geos::geomgraph::PlanarGraph::findEdge
virtual Edge * findEdge(const geom::Coordinate &p0, const geom::Coordinate &p1)
Returns the edge whose first two coordinates are p0 and p1.
-
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: EdgeSetIntersector.h:40
+
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: geomgraph/index/EdgeSetIntersector.h:40
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/GeometryLister_8h_source.html b/doxygen/GeometryLister_8h_source.html new file mode 100644 index 0000000000..4a46e82590 --- /dev/null +++ b/doxygen/GeometryLister_8h_source.html @@ -0,0 +1,135 @@ + + + + + + + +GEOS: GeometryLister.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
GeometryLister.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+
7  * Copyright (C) 2001-2002 Vivid Solutions Inc.
+
8  * Copyright (C) 2006 Refractions Research Inc.
+
9  *
+
10  * This is free software; you can redistribute and/or modify it under
+
11  * the terms of the GNU Lesser General Public Licence as published
+
12  * by the Free Software Foundation.
+
13  * See the COPYING file for more information.
+
14  *
+
15  **********************************************************************
+
16  *
+
17  * Last port: geom/util/GeometryExtracter.java r320 (JTS-1.12)
+
18  *
+
19  **********************************************************************/
+
20 
+
21 #pragma once
+
22 
+
23 #include <geos/export.h>
+
24 #include <geos/geom/GeometryFilter.h>
+
25 #include <geos/geom/GeometryCollection.h>
+
26 #include <vector>
+
27 
+
28 namespace geos {
+
29 namespace geom { // geos.geom
+
30 namespace util { // geos.geom.util
+
31 
+
36 class GEOS_DLL GeometryLister {
+
37 
+
38 public:
+
39 
+
49  static void
+
50  list(const Geometry* geom, std::vector<const Geometry*>& lst)
+
51  {
+
52  if(geom->isCollection()) {
+
53  GeometryLister::Lister lister(lst);
+
54  geom->apply_ro(&lister);
+
55  }
+
56  else {
+
57  lst.push_back(geom);
+
58  }
+
59  }
+
60 
+
61 private:
+
62 
+
63  struct Lister : public GeometryFilter {
+
64 
+
70  Lister(std::vector<const Geometry*>& p_geoms) : geoms(p_geoms) {}
+
71 
+
72  std::vector<const Geometry*>& geoms;
+
73 
+
74  void
+
75  filter_ro(const Geometry* geom) override
+
76  {
+
77  if(!geom->isCollection()) {
+
78  geoms.push_back(geom);
+
79  }
+
80  }
+
81 
+
82  // // Declare type as noncopyable
+
83  // Lister(const Lister& other);
+
84  // Lister& operator=(const Lister& rhs);
+
85  };
+
86 };
+
87 
+
88 
+
89 } // namespace geos.geom.util
+
90 } // namespace geos.geom
+
91 } // namespace geos
+
92 
+
geos::geom::GeometryFilter
Geometry classes support the concept of applying a Geometry filter to the Geometry.
Definition: GeometryFilter.h:45
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::util::GeometryLister
Definition: GeometryLister.h:36
+
geos::geom::util::GeometryLister::list
static void list(const Geometry *geom, std::vector< const Geometry * > &lst)
Definition: GeometryLister.h:50
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/Geometry_8h_source.html b/doxygen/Geometry_8h_source.html index 4ecaf41d80..55440182db 100644 --- a/doxygen/Geometry_8h_source.html +++ b/doxygen/Geometry_8h_source.html @@ -323,215 +323,211 @@
544 
583  bool covers(const Geometry* g) const;
584 
-
615  bool
-
616  coveredBy(const Geometry* g) const
-
617  {
-
618  return g->covers(this);
-
619  }
+
615  bool coveredBy(const Geometry* g) const;
+
616 
+
617 
+
619  virtual std::string toString() const;
620 
-
621 
-
623  virtual std::string toString() const;
-
624 
-
625  virtual std::string toText() const;
-
626 
-
631  std::unique_ptr<Geometry> buffer(double distance) const;
-
632 
-
640  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
-
641 
-
678  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
-
679  int endCapStyle) const;
-
680 
-
684  virtual std::unique_ptr<Geometry> convexHull() const;
-
685 
-
692  std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
-
693 
-
703  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
-
704 
-
714  std::unique_ptr<Geometry> Union(const Geometry* other) const;
-
715  // throw(IllegalArgumentException *, TopologyException *);
-
716 
-
734  Ptr Union() const;
-
735  // throw(IllegalArgumentException *, TopologyException *);
-
736 
-
747  std::unique_ptr<Geometry> difference(const Geometry* other) const;
-
748 
-
758  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
-
759 
-
766  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
-
767  const = 0; // Abstract
-
768 
-
773  virtual bool equalsIdentical(const Geometry* other) const = 0;
-
774 
-
775  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
-
776  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
-
777  virtual void apply_rw(GeometryFilter* filter);
-
778  virtual void apply_ro(GeometryFilter* filter) const;
-
779  virtual void apply_rw(GeometryComponentFilter* filter);
-
780  virtual void apply_ro(GeometryComponentFilter* filter) const;
-
781 
-
790  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
-
791 
-
798  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
-
799 
-
809  template <class T>
-
810  void
-
811  applyComponentFilter(T& f) const
-
812  {
-
813  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
-
814  f.filter(getGeometryN(i));
-
815  }
-
816  }
-
817 
-
823  virtual void normalize() = 0; //Abstract
-
824 
-
826  virtual int compareTo(const Geometry* geom) const;
-
827 
-
829  virtual double getArea() const;
-
830 
-
832  virtual double getLength() const;
-
833 
-
839  virtual double distance(const Geometry* g) const;
-
840 
-
841 
-
853  virtual bool isWithinDistance(const Geometry* geom,
-
854  double cDistance) const;
-
855 
-
865  virtual std::unique_ptr<Point> getCentroid() const;
-
866 
-
868  //
-
871  virtual bool getCentroid(CoordinateXY& ret) const;
-
872 
-
883  std::unique_ptr<Point> getInteriorPoint() const;
-
884 
-
890  virtual void geometryChanged();
-
891 
-
897  virtual void geometryChangedAction() = 0;
+
621  virtual std::string toText() const;
+
622 
+
627  std::unique_ptr<Geometry> buffer(double distance) const;
+
628 
+
636  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
+
637 
+
674  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
+
675  int endCapStyle) const;
+
676 
+
680  virtual std::unique_ptr<Geometry> convexHull() const;
+
681 
+
688  std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
+
689 
+
699  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
+
700 
+
710  std::unique_ptr<Geometry> Union(const Geometry* other) const;
+
711  // throw(IllegalArgumentException *, TopologyException *);
+
712 
+
730  Ptr Union() const;
+
731  // throw(IllegalArgumentException *, TopologyException *);
+
732 
+
743  std::unique_ptr<Geometry> difference(const Geometry* other) const;
+
744 
+
754  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
+
755 
+
762  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
+
763  const = 0; // Abstract
+
764 
+
769  virtual bool equalsIdentical(const Geometry* other) const = 0;
+
770 
+
771  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
+
772  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
+
773  virtual void apply_rw(GeometryFilter* filter);
+
774  virtual void apply_ro(GeometryFilter* filter) const;
+
775  virtual void apply_rw(GeometryComponentFilter* filter);
+
776  virtual void apply_ro(GeometryComponentFilter* filter) const;
+
777 
+
786  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
+
787 
+
794  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
+
795 
+
805  template <class T>
+
806  void
+
807  applyComponentFilter(T& f) const
+
808  {
+
809  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
+
810  f.filter(getGeometryN(i));
+
811  }
+
812  }
+
813 
+
819  virtual void normalize() = 0; //Abstract
+
820 
+
822  virtual int compareTo(const Geometry* geom) const;
+
823 
+
825  virtual double getArea() const;
+
826 
+
828  virtual double getLength() const;
+
829 
+
835  virtual double distance(const Geometry* g) const;
+
836 
+
837 
+
849  virtual bool isWithinDistance(const Geometry* geom,
+
850  double cDistance) const;
+
851 
+
861  virtual std::unique_ptr<Point> getCentroid() const;
+
862 
+
864  //
+
867  virtual bool getCentroid(CoordinateXY& ret) const;
+
868 
+
879  std::unique_ptr<Point> getInteriorPoint() const;
+
880 
+
886  virtual void geometryChanged();
+
887 
+
893  virtual void geometryChangedAction() = 0;
+
894 
+
895 protected:
+
897  virtual Geometry* cloneImpl() const = 0;
898 
-
899 protected:
-
901  virtual Geometry* cloneImpl() const = 0;
-
902 
-
904  virtual Geometry* reverseImpl() const = 0;
-
905 
-
907  template<typename T>
-
908  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
-
909  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
-
910  }
-
911 
-
913  static bool hasNullElements(const CoordinateSequence* list);
-
914 
-
916  template<typename T>
-
917  static bool hasNullElements(const std::vector<T>* geometries) {
-
918  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
-
919  }
-
920 
-
921 // static void reversePointOrder(CoordinateSequence* coordinates);
-
922 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
-
923 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
-
924 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
-
925 //
-
930  virtual bool isEquivalentClass(const Geometry* other) const;
+
900  virtual Geometry* reverseImpl() const = 0;
+
901 
+
903  template<typename T>
+
904  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
+
905  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
+
906  }
+
907 
+
909  static bool hasNullElements(const CoordinateSequence* list);
+
910 
+
912  template<typename T>
+
913  static bool hasNullElements(const std::vector<T>* geometries) {
+
914  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
+
915  }
+
916 
+
917 // static void reversePointOrder(CoordinateSequence* coordinates);
+
918 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
+
919 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
+
920 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
+
921 //
+
926  virtual bool isEquivalentClass(const Geometry* other) const;
+
927 
+
928  static void checkNotGeometryCollection(const Geometry* g);
+
929 
+
930  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
931 
-
932  static void checkNotGeometryCollection(const Geometry* g);
-
933 
-
934  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
-
935 
-
936  template<typename T>
-
937  static int compare(const T& a, const T& b)
-
938  {
-
939  std::size_t i = 0;
-
940  std::size_t j = 0;
-
941  while(i < a.size() && j < b.size()) {
-
942  const auto& aGeom = *a[i];
-
943  const auto& bGeom = *b[j];
-
944 
-
945  int comparison = aGeom.compareTo(&bGeom);
-
946  if(comparison != 0) {
-
947  return comparison;
-
948  }
+
932  template<typename T>
+
933  static int compare(const T& a, const T& b)
+
934  {
+
935  std::size_t i = 0;
+
936  std::size_t j = 0;
+
937  while(i < a.size() && j < b.size()) {
+
938  const auto& aGeom = *a[i];
+
939  const auto& bGeom = *b[j];
+
940 
+
941  int comparison = aGeom.compareTo(&bGeom);
+
942  if(comparison != 0) {
+
943  return comparison;
+
944  }
+
945 
+
946  i++;
+
947  j++;
+
948  }
949 
-
950  i++;
-
951  j++;
+
950  if(i < a.size()) {
+
951  return 1;
952  }
953 
-
954  if(i < a.size()) {
-
955  return 1;
+
954  if(j < b.size()) {
+
955  return -1;
956  }
957 
-
958  if(j < b.size()) {
-
959  return -1;
-
960  }
-
961 
-
962  return 0;
-
963  }
+
958  return 0;
+
959  }
+
960 
+
961  bool equal(const CoordinateXY& a, const CoordinateXY& b,
+
962  double tolerance) const;
+
963  int SRID;
964 
-
965  bool equal(const CoordinateXY& a, const CoordinateXY& b,
-
966  double tolerance) const;
-
967  int SRID;
-
968 
-
969  Geometry(const Geometry& geom);
-
970 
-
980  Geometry(const GeometryFactory* factory);
-
981 
-
982  template<typename T>
-
983  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
-
984  static_assert(std::is_base_of<Geometry, T>::value, "");
-
985  std::vector<std::unique_ptr<Geometry>> gv(v.size());
-
986  for (std::size_t i = 0; i < v.size(); i++) {
-
987  gv[i] = std::move(v[i]);
-
988  }
-
989  return gv;
+
965  Geometry(const Geometry& geom);
+
966 
+
976  Geometry(const GeometryFactory* factory);
+
977 
+
978  template<typename T>
+
979  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
+
980  static_assert(std::is_base_of<Geometry, T>::value, "");
+
981  std::vector<std::unique_ptr<Geometry>> gv(v.size());
+
982  for (std::size_t i = 0; i < v.size(); i++) {
+
983  gv[i] = std::move(v[i]);
+
984  }
+
985  return gv;
+
986  }
+
987 
+
988  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
+
989  return std::move(v);
990  }
991 
-
992  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
-
993  return std::move(v);
-
994  }
+
992 protected:
+
993 
+
994  virtual int getSortIndex() const = 0;
995 
-
996 protected:
-
997 
-
998  virtual int getSortIndex() const = 0;
-
999 
-
1000 
-
1001 private:
-
1002 
-
1003  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
-
1004  public:
-
1005  void filter_rw(Geometry* geom) override;
-
1006  };
-
1007 
-
1008  static GeometryChangedFilter geometryChangedFilter;
-
1009 
-
1014  const GeometryFactory* _factory;
-
1015 
-
1016  void* _userData;
-
1017 };
-
1018 
-
1023 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
+
996 
+
997 private:
+
998 
+
999  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
+
1000  public:
+
1001  void filter_rw(Geometry* geom) override;
+
1002  };
+
1003 
+
1004  static GeometryChangedFilter geometryChangedFilter;
+
1005 
+
1010  const GeometryFactory* _factory;
+
1011 
+
1012  void* _userData;
+
1013 };
+
1014 
+
1019 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
+
1020 
+
1021 struct GEOS_DLL GeometryGreaterThen {
+
1022  bool operator()(const Geometry* first, const Geometry* second);
+
1023 };
1024 
-
1025 struct GEOS_DLL GeometryGreaterThen {
-
1026  bool operator()(const Geometry* first, const Geometry* second);
-
1027 };
+
1025 
+
1027 GEOS_DLL std::string geosversion();
1028 
-
1029 
-
1031 GEOS_DLL std::string geosversion();
-
1032 
-
1038 GEOS_DLL std::string jtsport();
-
1039 
-
1040 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
-
1041 // forbids that construct:
-
1042 // http://lwg.github.com/issues/lwg-closed.html#2068
-
1043 struct GeomPtrPair {
-
1044  typedef std::unique_ptr<Geometry> GeomPtr;
-
1045  GeomPtr first;
-
1046  GeomPtr second;
-
1047 };
-
1048 
-
1049 } // namespace geos::geom
-
1050 } // namespace geos
+
1034 GEOS_DLL std::string jtsport();
+
1035 
+
1036 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
+
1037 // forbids that construct:
+
1038 // http://lwg.github.com/issues/lwg-closed.html#2068
+
1039 struct GeomPtrPair {
+
1040  typedef std::unique_ptr<Geometry> GeomPtr;
+
1041  GeomPtr first;
+
1042  GeomPtr second;
+
1043 };
+
1044 
+
1045 } // namespace geos::geom
+
1046 } // namespace geos
+
1047 
+
1048 #ifdef _MSC_VER
+
1049 #pragma warning(pop)
+
1050 #endif
1051 
-
1052 #ifdef _MSC_VER
-
1053 #pragma warning(pop)
-
1054 #endif
-
1055 
geos::geom::CoordinateFilter
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
geos::geom::CoordinateSequenceFilter
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
@@ -549,7 +545,7 @@
geos::geom::Geometry::cloneImpl
virtual Geometry * cloneImpl() const =0
Make a deep-copy of this Geometry.
geos::geom::Geometry::equalsIdentical
virtual bool equalsIdentical(const Geometry *other) const =0
Returns true if the two geometries are of the same type and their vertices corresponding by index are...
geos::geom::Geometry::NonConstVect
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:207
-
geos::geom::Geometry::applyComponentFilter
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:811
+
geos::geom::Geometry::applyComponentFilter
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:807
geos::geom::Geometry::compareTo
virtual int compareTo(const Geometry *geom) const
Comparator for sorting geometry.
geos::geom::Geometry::~Geometry
virtual ~Geometry()
Destroy Geometry and all components.
geos::geom::Geometry::equals
virtual bool equals(const Geometry *g) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**FFF*.
@@ -598,14 +594,14 @@
geos::geom::Geometry::toString
virtual std::string toString() const
Returns the Well-known Text representation of this Geometry.
geos::geom::Geometry::isValid
virtual bool isValid() const
Tests the validity of this Geometry.
geos::geom::Geometry::isSimple
virtual bool isSimple() const
Returns false if the Geometry not simple.
-
geos::geom::Geometry::hasNonEmptyElements
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:908
+
geos::geom::Geometry::hasNonEmptyElements
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:904
geos::geom::Geometry::Union
Ptr Union() const
Computes the union of all the elements of this geometry. Heterogeneous GeometryCollections are fully ...
-
geos::geom::Geometry::reverse
std::unique_ptr< Geometry > reverse() const
Computes a new geometry which has all component coordinate sequences in reverse order (opposite orien...
Definition: Geometry.h:692
+
geos::geom::Geometry::reverse
std::unique_ptr< Geometry > reverse() const
Computes a new geometry which has all component coordinate sequences in reverse order (opposite orien...
Definition: Geometry.h:688
geos::geom::Geometry::disjoint
virtual bool disjoint(const Geometry *other) const
geos::geom::Geometry::buffer
std::unique_ptr< Geometry > buffer(double distance, int quadrantSegments, int endCapStyle) const
Computes a buffer area around this geometry having the given width and with a specified accuracy of a...
geos::geom::Geometry::contains
virtual bool contains(const Geometry *g) const
Returns true if other.within(this) returns true.
geos::geom::Geometry::isEquivalentClass
virtual bool isEquivalentClass(const Geometry *other) const
Returns whether the two Geometrys are equal, from the point of view of the equalsExact method.
-
geos::geom::Geometry::coveredBy
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition: Geometry.h:616
+
geos::geom::Geometry::coveredBy
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
geos::geom::Geometry::difference
std::unique_ptr< Geometry > difference(const Geometry *other) const
Returns a Geometry representing the points making up this Geometry that do not make up other.
geos::geom::Geometry::clone
std::unique_ptr< Geometry > clone() const
Make a deep-copy of this Geometry.
Definition: Geometry.h:213
geos::geom::Geometry::getNumGeometries
virtual std::size_t getNumGeometries() const
Returns the number of geometries in this collection, or 1 if this is not a collection.
Definition: Geometry.h:327
@@ -619,7 +615,7 @@
geos::geom::Geometry::getDimension
virtual Dimension::DimensionType getDimension() const =0
Returns the dimension of this Geometry (0=point, 1=line, 2=surface)
geos::geom::Geometry::geometryChanged
virtual void geometryChanged()
Notifies this Geometry that its Coordinates have been changed by an external party (using a Coordinat...
geos::geom::Geometry::convexHull
virtual std::unique_ptr< Geometry > convexHull() const
Returns the smallest convex Polygon that contains all the points in the Geometry.
-
geos::geom::Geometry::hasNullElements
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition: Geometry.h:917
+
geos::geom::Geometry::hasNullElements
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition: Geometry.h:913
geos::geom::Geometry::setSRID
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:283
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
geos::geom::jtsport
std::string jtsport()
Return the version of JTS this GEOS release has been ported from.
diff --git a/doxygen/HCoordinate_8h_source.html b/doxygen/HCoordinate_8h_source.html index 51324dc200..ac38b8b42b 100644 --- a/doxygen/HCoordinate_8h_source.html +++ b/doxygen/HCoordinate_8h_source.html @@ -126,7 +126,7 @@
geos::algorithm::HCoordinate
Represents a homogeneous coordinate in a 2-D coordinate space.
Definition: HCoordinate.h:43
geos::algorithm::HCoordinate::HCoordinate
HCoordinate(const geom::Coordinate &p1, const geom::Coordinate &p2)
Constructs a homogeneous coordinate which is the intersection of the lines define by the homogeneous ...
geos::algorithm::HCoordinate::intersection
static void intersection(const geom::Coordinate &p1, const geom::Coordinate &p2, const geom::Coordinate &q1, const geom::Coordinate &q2, geom::Coordinate &ret)
Computes the (approximate) intersection point between two line segments using homogeneous coordinates...
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/HilbertCode_8h_source.html b/doxygen/HilbertCode_8h_source.html index fecbccc84e..d2d1e56f93 100644 --- a/doxygen/HilbertCode_8h_source.html +++ b/doxygen/HilbertCode_8h_source.html @@ -118,7 +118,7 @@
126 
127 
128 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::shape::fractal::HilbertCode
Definition: HilbertCode.h:65
geos::shape::fractal::HilbertCode::maxOrdinate
static uint32_t maxOrdinate(uint32_t level)
geos::shape::fractal::HilbertCode::level
static uint32_t level(uint32_t numPoints)
diff --git a/doxygen/HotPixel_8h_source.html b/doxygen/HotPixel_8h_source.html index b8f459dcd7..45407719b7 100644 --- a/doxygen/HotPixel_8h_source.html +++ b/doxygen/HotPixel_8h_source.html @@ -188,7 +188,7 @@
169 #pragma warning(pop)
170 #endif
171 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::snapround::HotPixel
Implements a "hot pixel" as used in the Snap Rounding algorithm.
Definition: HotPixel.h:60
geos::noding::snapround::HotPixel::intersects
bool intersects(const geom::CoordinateXY &p) const
geos::noding::snapround::HotPixel::HotPixel
HotPixel(const CoordType &pt, double scaleFact)
Definition: HotPixel.h:117
diff --git a/doxygen/HullTri_8h_source.html b/doxygen/HullTri_8h_source.html index 21f19e705a..778522d189 100644 --- a/doxygen/HullTri_8h_source.html +++ b/doxygen/HullTri_8h_source.html @@ -172,7 +172,7 @@
154 } // geos::algorithm
155 } // geos
156 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Triangle
Represents a planar triangle, and provides methods for calculating various properties of triangles.
Definition: Triangle.h:28
geos::triangulate::tri::TriList
Definition: TriList.h:54
geos::triangulate::tri::Tri
Definition: Tri.h:49
diff --git a/doxygen/HullTriangulation_8h_source.html b/doxygen/HullTriangulation_8h_source.html index c8c7aaa59a..d378bfeaf3 100644 --- a/doxygen/HullTriangulation_8h_source.html +++ b/doxygen/HullTriangulation_8h_source.html @@ -160,7 +160,7 @@
137 } // geos::algorithm
138 } // geos
139 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::triangulate::quadedge::QuadEdgeSubdivision
A class that contains the QuadEdges representing a planar subdivision that models a triangulation.
Definition: QuadEdgeSubdivision.h:78
diff --git a/doxygen/IMPatternMatcher_8h_source.html b/doxygen/IMPatternMatcher_8h_source.html new file mode 100644 index 0000000000..f5c1175452 --- /dev/null +++ b/doxygen/IMPatternMatcher_8h_source.html @@ -0,0 +1,148 @@ + + + + + + + +GEOS: IMPatternMatcher.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
IMPatternMatcher.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/geom/Dimension.h>
+
20 #include <geos/geom/IntersectionMatrix.h>
+
21 #include <geos/operation/relateng/IMPredicate.h>
+
22 #include <geos/export.h>
+
23 
+
24 #include <memory>
+
25 #include <vector>
+
26 
+
27 // Forward declarations
+
28 namespace geos {
+
29 namespace geom {
+
30  class Envelope;
+
31 }
+
32 }
+
33 
+
34 
+
35 using geos::geom::Envelope;
+
36 using geos::geom::Location;
+
37 using geos::geom::Dimension;
+
38 using geos::geom::IntersectionMatrix;
+
39 
+
40 
+
41 namespace geos { // geos.
+
42 namespace operation { // geos.operation.
+
43 namespace relateng { // geos.operation.relateng
+
44 
+
45 
+
46 class GEOS_DLL IMPatternMatcher : public IMPredicate {
+
47 
+
48 
+
49 private:
+
50 
+
51  std::string imPattern;
+
52  IntersectionMatrix patternMatrix;
+
53 
+
54  static bool requireInteraction(const IntersectionMatrix& im);
+
55 
+
56  static bool isInteraction(int imDim);
+
57 
+
58 
+
59 public:
+
60 
+
61  IMPatternMatcher(std::string p_imPattern)
+
62  : imPattern(p_imPattern)
+
63  , patternMatrix(p_imPattern)
+
64  {};
+
65 
+
66  std::string name() const override;
+
67 
+
68  using IMPredicate::init;
+
69  void init(const Envelope& envA, const Envelope& envB) override;
+
70 
+
71  bool requireInteraction() const override;
+
72 
+
73  bool isDetermined() const override;
+
74 
+
75  bool valueIM() override;
+
76 
+
77  std::string toString() const;
+
78 
+
79  friend std::ostream& operator<<(std::ostream& os, const IMPatternMatcher& imp);
+
80 
+
81 };
+
82 
+
83 
+
84 } // namespace geos.operation.relateng
+
85 } // namespace geos.operation
+
86 } // namespace geos
+
87 
+
geos::geom::Dimension
Definition: Dimension.h:27
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::IntersectionMatrix
Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
Definition: IntersectionMatrix.h:51
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/IMPredicate_8h_source.html b/doxygen/IMPredicate_8h_source.html new file mode 100644 index 0000000000..4580f868ed --- /dev/null +++ b/doxygen/IMPredicate_8h_source.html @@ -0,0 +1,170 @@ + + + + + + + +GEOS: IMPredicate.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
IMPredicate.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/geom/Dimension.h>
+
20 #include <geos/geom/IntersectionMatrix.h>
+
21 #include <geos/operation/relateng/BasicPredicate.h>
+
22 #include <geos/export.h>
+
23 
+
24 #include <memory>
+
25 #include <vector>
+
26 
+
27 // Forward declarations
+
28 namespace geos {
+
29 namespace geom {
+
30  class Envelope;
+
31 }
+
32 }
+
33 
+
34 
+
35 using geos::geom::Envelope;
+
36 using geos::geom::Location;
+
37 using geos::geom::Dimension;
+
38 using geos::geom::IntersectionMatrix;
+
39 
+
40 
+
41 namespace geos { // geos.
+
42 namespace operation { // geos.operation.
+
43 namespace relateng { // geos.operation.relateng
+
44 
+
45 
+
46 class GEOS_DLL IMPredicate : public BasicPredicate {
+
47 
+
48 private:
+
49 
+
50 
+
51 
+
52 protected:
+
53 
+
54  static constexpr int DIM_UNKNOWN = Dimension::DONTCARE;
+
55 
+
56  int dimA;
+
57  int dimB;
+
58  IntersectionMatrix intMatrix;
+
59 
+
66  virtual bool valueIM() = 0;
+
67 
+
78  virtual bool isDetermined() const = 0;
+
79 
+
87  bool intersectsExteriorOf(bool isA) const;
+
88 
+
89  bool isIntersects(Location locA, Location locB) const;
+
90 
+
91 
+
92 public:
+
93 
+
94  IMPredicate()
+
95  {
+
96  // intMatrix = new IntersectionMatrix();
+
97  //-- E/E is always dim = 2
+
98  intMatrix.set(Location::EXTERIOR, Location::EXTERIOR, Dimension::A);
+
99  }
+
100 
+
101  static bool isDimsCompatibleWithCovers(int dim0, int dim1);
+
102 
+
103  void init(int dA, int dB) override;
+
104 
+
105  void updateDimension(Location locA, Location locB, int dimension) override;
+
106 
+
107  bool isDimChanged(Location locA, Location locB, int dimension) const;
+
108 
+
109  using TopologyPredicate::isKnown;
+
110  bool isKnown(Location locA, Location locB) const;
+
111 
+
112  bool isDimension(Location locA, Location locB, int dimension) const;
+
113 
+
114  int getDimension(Location locA, Location locB) const;
+
115 
+
119  void finish() override;
+
120 
+
121  std::string toString() const;
+
122 
+
123  friend std::ostream& operator<<(std::ostream& os, const IMPredicate& imp);
+
124 
+
125 
+
126 };
+
127 
+
128 } // namespace geos.operation.relateng
+
129 } // namespace geos.operation
+
130 } // namespace geos
+
131 
+
geos::geom::Dimension
Definition: Dimension.h:27
+
geos::geom::Dimension::A
@ A
Dimension value of a surface (2).
Definition: Dimension.h:46
+
geos::geom::Dimension::DONTCARE
@ DONTCARE
Dimension value for any dimension (= {FALSE, TRUE}).
Definition: Dimension.h:31
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::IntersectionMatrix
Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
Definition: IntersectionMatrix.h:51
+
geos::geom::IntersectionMatrix::set
void set(Location row, Location column, int dimensionValue)
Changes the value of one of this IntersectionMatrixs elements.
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+ +
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/InputGeometry_8h_source.html b/doxygen/InputGeometry_8h_source.html index 7a271e505f..63bbed3e17 100644 --- a/doxygen/InputGeometry_8h_source.html +++ b/doxygen/InputGeometry_8h_source.html @@ -124,7 +124,7 @@
102 } // namespace geos
103 
geos::algorithm::locate::PointOnGeometryLocator
An interface for classes which determine the Location of points in Polygon or MultiPolygon geometries...
Definition: PointOnGeometryLocator.h:36
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::algorithm::locate
Classes which determine the Location of points in geometries.
Definition: IndexedPointInAreaLocator.h:40
diff --git a/doxygen/InteriorPointArea_8h_source.html b/doxygen/InteriorPointArea_8h_source.html index 8692a863ed..17da6552a8 100644 --- a/doxygen/InteriorPointArea_8h_source.html +++ b/doxygen/InteriorPointArea_8h_source.html @@ -105,7 +105,7 @@
geos::algorithm::InteriorPointArea
Computes a point in the interior of an areal geometry. The point will lie in the geometry interior in...
Definition: InteriorPointArea.h:79
geos::algorithm::InteriorPointArea::getInteriorPoint
bool getInteriorPoint(geom::Coordinate &ret) const
geos::algorithm::InteriorPointArea::InteriorPointArea
InteriorPointArea(const geom::Geometry *g)
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition: Polygon.h:61
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/InteriorPointLine_8h_source.html b/doxygen/InteriorPointLine_8h_source.html index 3f7aa74436..67cd983e71 100644 --- a/doxygen/InteriorPointLine_8h_source.html +++ b/doxygen/InteriorPointLine_8h_source.html @@ -118,7 +118,7 @@
79 
geos::algorithm::InteriorPointLine
Computes a point in the interior of an linear geometry.
Definition: InteriorPointLine.h:47
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/InteriorPointPoint_8h_source.html b/doxygen/InteriorPointPoint_8h_source.html index 6f43362272..3ae693eb19 100644 --- a/doxygen/InteriorPointPoint_8h_source.html +++ b/doxygen/InteriorPointPoint_8h_source.html @@ -107,7 +107,7 @@
72 
73 
geos::algorithm::InteriorPointPoint
Computes a point in the interior of an point geometry.
Definition: InteriorPointPoint.h:40
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/IntersectionMatrixPattern_8h_source.html b/doxygen/IntersectionMatrixPattern_8h_source.html new file mode 100644 index 0000000000..f3ef54cafa --- /dev/null +++ b/doxygen/IntersectionMatrixPattern_8h_source.html @@ -0,0 +1,106 @@ + + + + + + + +GEOS: IntersectionMatrixPattern.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
IntersectionMatrixPattern.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/export.h>
+
19 
+
20 #include <string>
+
21 
+
22 
+
23 namespace geos { // geos.
+
24 namespace operation { // geos.operation
+
25 namespace relateng { // geos.operation.relateng
+
26 
+
27 
+
28 class GEOS_DLL IntersectionMatrixPattern {
+
29 
+
30 private:
+
31 
+
35  IntersectionMatrixPattern() {};
+
36 
+
37 
+
38 public:
+
39 
+
44  static constexpr const char* ADJACENT = "F***1****";
+
45 
+
50  static constexpr const char* CONTAINS_PROPERLY = "T**FF*FF*";
+
51 
+
57  static constexpr const char* INTERIOR_INTERSECTS = "T********";
+
58 
+
59 
+
60 };
+
61 
+
62 } // namespace geos.operation.relateng
+
63 } // namespace geos.operation
+
64 } // namespace geos
+
65 
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/IntersectionMatrix_8h_source.html b/doxygen/IntersectionMatrix_8h_source.html index bf6854b959..6d953ccaf6 100644 --- a/doxygen/IntersectionMatrix_8h_source.html +++ b/doxygen/IntersectionMatrix_8h_source.html @@ -108,7 +108,7 @@
205 
214  void setAll(int dimensionValue);
215 
-
229  int get(geom::Location row, geom::Location column) const {
+
229  int get(Location row, Location column) const {
230  return matrix[static_cast<size_t>(row)][static_cast<size_t>(column)];
231  }
232 
@@ -141,25 +141,27 @@
356 
364  std::string toString() const;
365 
-
366 private:
-
367 
-
368  static const int firstDim; // = 3;
-
369 
-
370  static const int secondDim; // = 3;
-
371 
-
372  // Internal buffer for 3x3 matrix.
-
373  std::array<std::array<int, 3>, 3> matrix;
-
374 
-
375 }; // class IntersectionMatrix
-
376 
-
377 GEOS_DLL std::ostream& operator<< (std::ostream& os, const IntersectionMatrix& im);
-
378 
+
366 
+
367 private:
+
368 
+
369  static const int firstDim; // = 3;
+
370 
+
371  static const int secondDim; // = 3;
+
372 
+
373  // Internal buffer for 3x3 matrix.
+
374  std::array<std::array<int, 3>, 3> matrix;
+
375 
+
376 }; // class IntersectionMatrix
+
377 
+
378 GEOS_DLL std::ostream& operator<< (std::ostream& os, const IntersectionMatrix& im);
379 
-
380 } // namespace geos::geom
-
381 } // namespace geos
-
382 
+
380 
+
381 } // namespace geos::geom
+
382 } // namespace geos
+
383 
geos::geom::IntersectionMatrix
Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
Definition: IntersectionMatrix.h:51
geos::geom::IntersectionMatrix::setAll
void setAll(int dimensionValue)
Changes the elements of this IntersectionMatrix to dimensionValue.
+
geos::geom::IntersectionMatrix::get
int get(Location row, Location column) const
Returns the value of one of this IntersectionMatrixs elements.
Definition: IntersectionMatrix.h:229
geos::geom::IntersectionMatrix::isCovers
bool isCovers() const
Returns true if this IntersectionMatrix is T*****FF* or T****FF or ***T**FF* or ****T*FF*
geos::geom::IntersectionMatrix::isWithin
bool isWithin() const
Returns true if this IntersectionMatrix is T*F**F***.
geos::geom::IntersectionMatrix::isCoveredBy
bool isCoveredBy() const
Returns true if this IntersectionMatrix is T*F**F*** *TF**F*** or **FT*F*** or **F*TF***
@@ -170,7 +172,6 @@
geos::geom::IntersectionMatrix::isCrosses
bool isCrosses(int dimensionOfGeometryA, int dimensionOfGeometryB) const
Returns true if this IntersectionMatrix is:
geos::geom::IntersectionMatrix::setAtLeast
void setAtLeast(std::string minimumDimensionSymbols)
For each element in this IntersectionMatrix, changes the element to the corresponding minimum dimensi...
geos::geom::IntersectionMatrix::setAtLeastIfValid
void setAtLeastIfValid(Location row, Location column, int minimumDimensionValue)
If row >= 0 and column >= 0, changes the specified element to minimumDimensionValue if the element is...
-
geos::geom::IntersectionMatrix::get
int get(geom::Location row, geom::Location column) const
Returns the value of one of this IntersectionMatrixs elements.
Definition: IntersectionMatrix.h:229
geos::geom::IntersectionMatrix::set
void set(const std::string &dimensionSymbols)
Changes the elements of this IntersectionMatrix to the dimension symbols in dimensionSymbols.
geos::geom::IntersectionMatrix::add
void add(IntersectionMatrix *other)
Adds one matrix to another.
geos::geom::IntersectionMatrix::IntersectionMatrix
IntersectionMatrix()
Default constructor.
diff --git a/doxygen/InvalidSegmentDetector_8h_source.html b/doxygen/InvalidSegmentDetector_8h_source.html index 299dd6e443..67d655761c 100644 --- a/doxygen/InvalidSegmentDetector_8h_source.html +++ b/doxygen/InvalidSegmentDetector_8h_source.html @@ -149,7 +149,7 @@
geos::coverage::InvalidSegmentDetector::processIntersections
void processIntersections(SegmentString *ssAdj, std::size_t iAdj, SegmentString *ssTarget, std::size_t iTarget) override
geos::coverage::InvalidSegmentDetector::isDone
bool isDone() const override
Reports whether the client of this class needs to continue testing all intersections in an arrangemen...
Definition: InvalidSegmentDetector.h:111
geos::coverage::InvalidSegmentDetector::InvalidSegmentDetector
InvalidSegmentDetector()
Definition: InvalidSegmentDetector.h:105
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::SegmentIntersector
Processes possible intersections detected by a Noder.
Definition: noding/SegmentIntersector.h:45
geos::noding::SegmentString
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:47
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/IsSimpleOp_8h_source.html b/doxygen/IsSimpleOp_8h_source.html index c50b541caa..b7cafaa4e0 100644 --- a/doxygen/IsSimpleOp_8h_source.html +++ b/doxygen/IsSimpleOp_8h_source.html @@ -78,9 +78,9 @@
29 class SegmentString;
30 class BasicSegmentString;
31 }
-
32 namespace algorithm {
-
33 class BoundaryNodeRule;
-
34 }
+
32 // namespace algorithm {
+
33 // class BoundaryNodeRule;
+
34 // }
35 namespace geom {
36 class LineString;
37 class LinearRing;
diff --git a/doxygen/KdNode_8h_source.html b/doxygen/KdNode_8h_source.html index 3fa62ef65a..c8b5db760b 100644 --- a/doxygen/KdNode_8h_source.html +++ b/doxygen/KdNode_8h_source.html @@ -108,7 +108,7 @@
62 
63 
64 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::index::kdtree::KdNode
Definition: KdNode.h:30
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/KdTree_8h_source.html b/doxygen/KdTree_8h_source.html index 240b872c12..6bb45f911f 100644 --- a/doxygen/KdTree_8h_source.html +++ b/doxygen/KdTree_8h_source.html @@ -176,7 +176,7 @@
189 #pragma warning(pop)
190 #endif
191 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::index::kdtree::KdNode
Definition: KdNode.h:30
geos::index::kdtree::KdTree
Definition: KdTree.h:55
diff --git a/doxygen/LargestEmptyCircle_8h_source.html b/doxygen/LargestEmptyCircle_8h_source.html index 3ca08d25bd..2d4cae534e 100644 --- a/doxygen/LargestEmptyCircle_8h_source.html +++ b/doxygen/LargestEmptyCircle_8h_source.html @@ -217,7 +217,7 @@
geos::algorithm::construct::LargestEmptyCircle::LargestEmptyCircle
LargestEmptyCircle(const geom::Geometry *p_obstacles, const geom::Geometry *p_boundary, double p_tolerance)
geos::algorithm::construct::LargestEmptyCircle::getRadiusLine
static std::unique_ptr< geom::LineString > getRadiusLine(const geom::Geometry *p_obstacles, double p_tolerance)
geos::algorithm::construct::LargestEmptyCircle::LargestEmptyCircle
LargestEmptyCircle(const geom::Geometry *p_obstacles, double p_tolerance)
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/LengthIndexOfPoint_8h_source.html b/doxygen/LengthIndexOfPoint_8h_source.html index 61a9fd561e..1e1a2d78b8 100644 --- a/doxygen/LengthIndexOfPoint_8h_source.html +++ b/doxygen/LengthIndexOfPoint_8h_source.html @@ -104,7 +104,7 @@
85 
86 }
87 }
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::linearref::LengthIndexOfPoint
Computes the length index of the point on a linear Geometry nearest a given Coordinate.
Definition: LengthIndexOfPoint.h:42
diff --git a/doxygen/LengthIndexedLine_8h_source.html b/doxygen/LengthIndexedLine_8h_source.html index 5581848913..c2749adfe9 100644 --- a/doxygen/LengthIndexedLine_8h_source.html +++ b/doxygen/LengthIndexedLine_8h_source.html @@ -117,7 +117,7 @@
209 
210 }
211 }
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::linearref::LengthIndexedLine
Supports linear referencing along a linear geom::Geometry using the length along the line as the inde...
Definition: LengthIndexedLine.h:43
geos::linearref::LengthIndexedLine::indicesOf
double * indicesOf(const geom::Geometry *subLine) const
Computes the indices for a subline of the line.
diff --git a/doxygen/LineIntersector_8h_source.html b/doxygen/LineIntersector_8h_source.html index 41ec14baa8..3f365c7701 100644 --- a/doxygen/LineIntersector_8h_source.html +++ b/doxygen/LineIntersector_8h_source.html @@ -538,7 +538,7 @@
geos::algorithm::LineIntersector::isIntersection
bool isIntersection(const geom::Coordinate &pt) const
Test whether a point is a intersection point of two line segments.
Definition: LineIntersector.h:230
geos::algorithm::Orientation::index
static int index(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &q)
Returns the orientation index of the direction of the point q relative to a directed infinite line sp...
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope::intersects
static bool intersects(const CoordinateXY &p1, const CoordinateXY &p2, const CoordinateXY &q)
Test the point q to see whether it intersects the Envelope defined by p1-p2.
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
geos::geom::PrecisionModel::makePrecise
double makePrecise(double val) const
Rounds a numeric value to the PrecisionModel grid.
diff --git a/doxygen/LineLimiter_8h_source.html b/doxygen/LineLimiter_8h_source.html index ae808f8744..e165ff0552 100644 --- a/doxygen/LineLimiter_8h_source.html +++ b/doxygen/LineLimiter_8h_source.html @@ -122,7 +122,7 @@
90 } // namespace geos
91 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::operation::overlayng::LineLimiter
Definition: LineLimiter.h:56
geos::geom
Definition: Angle.h:26
diff --git a/doxygen/LineMergeDirectedEdge_8h_source.html b/doxygen/LineMergeDirectedEdge_8h_source.html index 2941795cf6..92a8755821 100644 --- a/doxygen/LineMergeDirectedEdge_8h_source.html +++ b/doxygen/LineMergeDirectedEdge_8h_source.html @@ -101,7 +101,7 @@
76 } // namespace geos::operation
77 } // namespace geos
78 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::linemerge::LineMergeDirectedEdge
A DirectedEdge of a LineMergeGraph.
Definition: LineMergeDirectedEdge.h:46
geos::operation::linemerge::LineMergeDirectedEdge::LineMergeDirectedEdge
LineMergeDirectedEdge(planargraph::Node *from, planargraph::Node *to, const geom::Coordinate &directionPt, bool edgeDirection)
Constructs a LineMergeDirectedEdge connecting the from node to the to node.
geos::operation::linemerge::LineMergeDirectedEdge::getNext
LineMergeDirectedEdge * getNext(bool checkDirection=false)
Returns the directed edge that starts at this directed edge's end point, or null if there are zero or...
diff --git a/doxygen/LineMergeGraph_8h_source.html b/doxygen/LineMergeGraph_8h_source.html index 4ca26441bc..9f7279b889 100644 --- a/doxygen/LineMergeGraph_8h_source.html +++ b/doxygen/LineMergeGraph_8h_source.html @@ -123,7 +123,7 @@
89 #pragma warning(pop)
90 #endif
91 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LineString
Definition: LineString.h:66
geos::operation::linemerge::LineMergeGraph
A planar graph of edges that is analyzed to sew the edges together.
Definition: LineMergeGraph.h:58
geos::operation::linemerge::LineMergeGraph::addEdge
void addEdge(const geom::LineString *lineString)
Adds an Edge, DirectedEdges, and Nodes for the given LineString representation of an edge.
diff --git a/doxygen/LineSegment_8h_source.html b/doxygen/LineSegment_8h_source.html index 498d3ad4a4..6c82a56938 100644 --- a/doxygen/LineSegment_8h_source.html +++ b/doxygen/LineSegment_8h_source.html @@ -350,8 +350,8 @@
geos::algorithm::Distance::segmentToSegment
static double segmentToSegment(const geom::CoordinateXY &A, const geom::CoordinateXY &B, const geom::CoordinateXY &C, const geom::CoordinateXY &D)
geos::algorithm::Distance::pointToLinePerpendicular
static double pointToLinePerpendicular(const geom::CoordinateXY &p, const geom::CoordinateXY &A, const geom::CoordinateXY &B)
geos::algorithm::Orientation::index
static int index(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &q)
Returns the orientation index of the direction of the point q relative to a directed infinite line sp...
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
-
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:236
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:241
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::geom::LineSegment::isVertical
bool isVertical() const
Definition: LineSegment.h:156
@@ -388,7 +388,7 @@
geos::geom::LineSegment::distancePerpendicularOriented
double distancePerpendicularOriented(const CoordinateXY &p) const
geos::geom::LineSegment::segmentFraction
double segmentFraction(const CoordinateXY &inputPt) const
Computes the fraction of distance (in [0.0, 1.0]) that the projection of a point occurs along this li...
geos::geom::LineSegment::projectionFactor
double projectionFactor(const CoordinateXY &p) const
Compute the projection factor for the projection of the point p onto this LineSegment.
-
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:453
+
geos::geom::operator<
bool operator<(const CoordinateXY &a, const CoordinateXY &b)
Strict weak ordering operator for Coordinate.
Definition: Coordinate.h:458
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/LineSequencer_8h_source.html b/doxygen/LineSequencer_8h_source.html index 242a248ccb..3db1b541e8 100644 --- a/doxygen/LineSequencer_8h_source.html +++ b/doxygen/LineSequencer_8h_source.html @@ -216,7 +216,7 @@
295 #endif
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
-
geos::geom::Geometry::applyComponentFilter
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:811
+
geos::geom::Geometry::applyComponentFilter
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:807
geos::geom::LineString
Definition: LineString.h:66
geos::operation::linemerge::LineMergeGraph
A planar graph of edges that is analyzed to sew the edges together.
Definition: LineMergeGraph.h:58
geos::operation::linemerge::LineSequencer
Builds a sequence from a set of LineStrings so that they are ordered end to end.
Definition: LineSequencer.h:92
diff --git a/doxygen/LineStringExtracter_8h_source.html b/doxygen/LineStringExtracter_8h_source.html new file mode 100644 index 0000000000..3f11deb2de --- /dev/null +++ b/doxygen/LineStringExtracter_8h_source.html @@ -0,0 +1,130 @@ + + + + + + + +GEOS: LineStringExtracter.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
LineStringExtracter.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/GeometryFilter.h>
+
19 #include <geos/export.h>
+
20 
+
21 #include <memory>
+
22 #include <vector>
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace geom {
+
27  class LineString;
+
28  class Geometry;
+
29 }
+
30 }
+
31 
+
32 
+
33 using geos::geom::LineString;
+
34 using geos::geom::Geometry;
+
35 using geos::geom::GeometryFilter;
+
36 
+
37 
+
38 namespace geos { // geos.
+
39 namespace operation { // geos.operation
+
40 namespace relateng { // geos.operation.relateng
+
41 
+
42 
+
43 class GEOS_DLL LineStringExtracter : public GeometryFilter {
+
44 
+
45 private:
+
46 
+
47  std::vector<const LineString*>& comps;
+
48 
+
49 
+
50 public:
+
51 
+
52  LineStringExtracter(std::vector<const LineString*>& p_comps)
+
53  : comps(p_comps)
+
54  {}
+
55 
+
56  void filter_ro(const geom::Geometry* geom) override;
+
57 
+
58  static void getLines(const Geometry* geom, std::vector<const LineString*>& lines);
+
59 
+
60  static std::vector<const LineString*> getLines(const Geometry* geom);
+
61 
+
69  // static std::unique_ptr<Geometry> getGeometry(const Geometry* geom);
+
70 
+
71 };
+
72 
+
73 
+
74 } // namespace geos.operation.relateng
+
75 } // namespace geos.operation
+
76 } // namespace geos
+
77 
+
geos::geom::GeometryFilter
Geometry classes support the concept of applying a Geometry filter to the Geometry.
Definition: GeometryFilter.h:45
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::LineString
Definition: LineString.h:66
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/LineStringSnapper_8h_source.html b/doxygen/LineStringSnapper_8h_source.html index a22b52430d..d86169a735 100644 --- a/doxygen/LineStringSnapper_8h_source.html +++ b/doxygen/LineStringSnapper_8h_source.html @@ -158,8 +158,8 @@
165 
geos::geom::CoordinateList
A list of Coordinates, which may be set to prevent repeated coordinates from occurring in the list.
Definition: CoordinateList.h:56
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
-
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:227
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::ConstVect
std::vector< const Coordinate * > ConstVect
A vector of const Coordinate pointers.
Definition: Coordinate.h:229
geos::operation::overlay::snap::LineStringSnapper
Snaps the vertices and segments of a LineString to a set of target snap vertices.
Definition: LineStringSnapper.h:50
geos::operation::overlay::snap::LineStringSnapper::LineStringSnapper
LineStringSnapper(const geom::CoordinateSequence &nSrcPts, double nSnapTol)
Definition: LineStringSnapper.h:61
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/LinearBoundary_8h_source.html b/doxygen/LinearBoundary_8h_source.html new file mode 100644 index 0000000000..8e1c6b724f --- /dev/null +++ b/doxygen/LinearBoundary_8h_source.html @@ -0,0 +1,149 @@ + + + + + + + +GEOS: LinearBoundary.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
LinearBoundary.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Coordinate.h>
+
19 #include <geos/export.h>
+
20 
+
21 #include <memory>
+
22 #include <vector>
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace algorithm {
+
27  class BoundaryNodeRule;
+
28 }
+
29 namespace geom {
+
30  class CoordinateXY;
+
31  class LineString;
+
32 }
+
33 }
+
34 
+
35 
+
36 using geos::algorithm::BoundaryNodeRule;
+
37 using geos::geom::Coordinate;
+
38 using geos::geom::CoordinateXY;
+
39 using geos::geom::LineString;
+
40 
+
41 
+
42 namespace geos { // geos.
+
43 namespace operation { // geos.operation
+
44 namespace relateng { // geos.operation.relateng
+
45 
+
46 class GEOS_DLL LinearBoundary {
+
47 
+
48 private:
+
49 
+
50  // Members
+
51 
+
52  Coordinate::ConstIntMap m_vertexDegree;
+
53  bool m_hasBoundary;
+
54  const BoundaryNodeRule& m_boundaryNodeRule;
+
55 
+
56 
+
57 public:
+
58 
+
59  // Constructors
+
60 
+
61  LinearBoundary(std::vector<const LineString*>& lines, const BoundaryNodeRule& bnRule);
+
62 
+
63  bool hasBoundary() const;
+
64 
+
65  bool isBoundary(const CoordinateXY* pt) const;
+
66 
+
67 
+
68 private:
+
69 
+
70  // Methods
+
71 
+
72  bool checkBoundary(Coordinate::ConstIntMap& vertexDegree) const;
+
73 
+
74  static void computeBoundaryPoints(
+
75  std::vector<const LineString*>& lines,
+
76  Coordinate::ConstIntMap& vertexDegree);
+
77 
+
78  static void addEndpoint(
+
79  const CoordinateXY *p,
+
80  Coordinate::ConstIntMap& vertexDegree);
+
81 
+
82 
+
83 };
+
84 
+
85 } // namespace geos.operation.relateng
+
86 } // namespace geos.operation
+
87 } // namespace geos
+
88 
+
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::ConstIntMap
std::map< const CoordinateXY *, int, CoordinateLessThan > ConstIntMap
A map of const Coordinate pointers to integers.
Definition: Coordinate.h:238
+
geos::geom::LineString
Definition: LineString.h:66
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/LinearGeometryBuilder_8h_source.html b/doxygen/LinearGeometryBuilder_8h_source.html index fd707ca47c..baf2a0b9c9 100644 --- a/doxygen/LinearGeometryBuilder_8h_source.html +++ b/doxygen/LinearGeometryBuilder_8h_source.html @@ -118,7 +118,7 @@
104 } // namespace geos.linearref
105 } // namespace geos
106 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::linearref::LinearGeometryBuilder
Builds a linear geometry (LineString or MultiLineString) incrementally (point-by-point).
Definition: LinearGeometryBuilder.h:39
geos::linearref::LinearGeometryBuilder::setIgnoreInvalidLines
void setIgnoreInvalidLines(bool ignoreInvalidLines)
Allows invalid lines to be ignored rather than causing Exceptions.
diff --git a/doxygen/LinearIterator_8h_source.html b/doxygen/LinearIterator_8h_source.html index a2e452fc7b..6639a63101 100644 --- a/doxygen/LinearIterator_8h_source.html +++ b/doxygen/LinearIterator_8h_source.html @@ -123,7 +123,7 @@
154 }
155 } // namespace geos::linearref
156 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
geos::linearref::LinearIterator
An iterator over the components and coordinates of a linear geometry (LineString or MultiLineString).
Definition: LinearIterator.h:49
diff --git a/doxygen/LinearLocation_8h_source.html b/doxygen/LinearLocation_8h_source.html index 377172ad92..14eda071ae 100644 --- a/doxygen/LinearLocation_8h_source.html +++ b/doxygen/LinearLocation_8h_source.html @@ -141,7 +141,7 @@
246 } // namespace geos.linearref
247 } // namespace geos
248 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::linearref::LinearLocation
Represents a location along a LineString or MultiLineString.
Definition: LinearLocation.h:43
geos::linearref::LinearLocation::getEndLocation
static LinearLocation getEndLocation(const geom::Geometry *linear)
Gets a location which refers to the end of a linear Geometry.
diff --git a/doxygen/LinkedLine_8h_source.html b/doxygen/LinkedLine_8h_source.html index 46548c62b9..85a1977bbc 100644 --- a/doxygen/LinkedLine_8h_source.html +++ b/doxygen/LinkedLine_8h_source.html @@ -132,7 +132,7 @@
83 } // geos::simplify
84 } // geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/LinkedRing_8h_source.html b/doxygen/LinkedRing_8h_source.html index 75e8e74144..8d15e883f4 100644 --- a/doxygen/LinkedRing_8h_source.html +++ b/doxygen/LinkedRing_8h_source.html @@ -117,7 +117,7 @@
68 } // geos
69 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/LocationIndexedLine_8h_source.html b/doxygen/LocationIndexedLine_8h_source.html index 8f2f604853..98020d6128 100644 --- a/doxygen/LocationIndexedLine_8h_source.html +++ b/doxygen/LocationIndexedLine_8h_source.html @@ -180,7 +180,7 @@
274 
275 } // geos::linearref
276 } // geos
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::linearref::ExtractLineByLocation::extract
static std::unique_ptr< geom::Geometry > extract(const geom::Geometry *line, const LinearLocation &start, const LinearLocation &end)
Computes the subline of a LineString between two LinearLocations on the line.
geos::linearref::LinearLocation
Represents a location along a LineString or MultiLineString.
Definition: LinearLocation.h:43
diff --git a/doxygen/MCIndexSegmentSetMutualIntersector_8h_source.html b/doxygen/MCIndexSegmentSetMutualIntersector_8h_source.html index 0ef80d236d..d4ce5d854e 100644 --- a/doxygen/MCIndexSegmentSetMutualIntersector_8h_source.html +++ b/doxygen/MCIndexSegmentSetMutualIntersector_8h_source.html @@ -86,7 +86,7 @@
37 namespace geos {
38 namespace noding { // geos::noding
39 
-
47 class MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
+
47 class GEOS_DLL MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
48 public:
49 
50  MCIndexSegmentSetMutualIntersector(double p_tolerance)
diff --git a/doxygen/MaximumInscribedCircle_8h_source.html b/doxygen/MaximumInscribedCircle_8h_source.html index bde2b1120d..480786e476 100644 --- a/doxygen/MaximumInscribedCircle_8h_source.html +++ b/doxygen/MaximumInscribedCircle_8h_source.html @@ -215,7 +215,7 @@
geos::algorithm::construct::MaximumInscribedCircle::getRadiusPoint
std::unique_ptr< geom::Point > getRadiusPoint()
geos::algorithm::construct::MaximumInscribedCircle::computeMaximumIterations
static std::size_t computeMaximumIterations(const geom::Geometry *geom, double toleranceDist)
geos::algorithm::locate::IndexedPointInAreaLocator
Determines the location of Coordinates relative to an areal geometry, using indexing for efficiency.
Definition: IndexedPointInAreaLocator.h:54
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/MinimumDiameter_8h_source.html b/doxygen/MinimumDiameter_8h_source.html index 329b107f9a..0516c2c606 100644 --- a/doxygen/MinimumDiameter_8h_source.html +++ b/doxygen/MinimumDiameter_8h_source.html @@ -152,7 +152,7 @@
geos::algorithm::MinimumDiameter::MinimumDiameter
MinimumDiameter(const geom::Geometry *newInputGeom, const bool newIsConvex)
Compute a minimum diameter for a given Geometry, with a hint if the Geometry is convex (e....
geos::algorithm::MinimumDiameter::getDiameter
std::unique_ptr< geom::LineString > getDiameter()
Gets a LineString which is a minimum diameter.
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineSegment
Definition: LineSegment.h:61
diff --git a/doxygen/MortonCode_8h_source.html b/doxygen/MortonCode_8h_source.html index 2f770f104f..90a0f6feb3 100644 --- a/doxygen/MortonCode_8h_source.html +++ b/doxygen/MortonCode_8h_source.html @@ -114,7 +114,7 @@
138 
139 
140 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::shape::fractal::MortonCode
Definition: MortonCode.h:67
geos::shape::fractal::MortonCode::encode
static uint32_t encode(int x, int y)
geos::shape::fractal::MortonCode::maxOrdinate
static uint32_t maxOrdinate(uint32_t level)
diff --git a/doxygen/NodeSection_8h_source.html b/doxygen/NodeSection_8h_source.html new file mode 100644 index 0000000000..a16e15860b --- /dev/null +++ b/doxygen/NodeSection_8h_source.html @@ -0,0 +1,201 @@ + + + + + + + +GEOS: NodeSection.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
NodeSection.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/export.h>
+
19 #include <geos/geom/Coordinate.h>
+
20 
+
21 #include <string>
+
22 #include <sstream>
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace geom {
+
27  class Geometry;
+
28 }
+
29 }
+
30 
+
31 
+
32 using geos::geom::CoordinateXY;
+
33 using geos::geom::Geometry;
+
34 
+
35 
+
36 namespace geos { // geos.
+
37 namespace operation { // geos.operation
+
38 namespace relateng { // geos.operation.relateng
+
39 
+
55 class GEOS_DLL NodeSection {
+
56 
+
57 private:
+
58 
+
59  // Members
+
60  bool m_isA;
+
61  int m_dim;
+
62  int m_id;
+
63  int m_ringId;
+
64  const Geometry* m_poly;
+
65  bool m_isNodeAtVertex;
+
66  const CoordinateXY* m_v0;
+
67  const CoordinateXY m_nodePt;
+
68  const CoordinateXY* m_v1;
+
69 
+
70  // Methods
+
71 
+
72  static int compareWithNull(const CoordinateXY* v0, const CoordinateXY* v1);
+
73 
+
74  static int compare(int a, int b);
+
75 
+
76 public:
+
77 
+
78  NodeSection(
+
79  bool isA,
+
80  int dim,
+
81  int id,
+
82  int ringId,
+
83  const Geometry* poly,
+
84  bool isNodeAtVertex,
+
85  const CoordinateXY* v0,
+
86  const CoordinateXY nodePt,
+
87  const CoordinateXY* v1)
+
88  : m_isA(isA)
+
89  , m_dim(dim)
+
90  , m_id(id)
+
91  , m_ringId(ringId)
+
92  , m_poly(poly)
+
93  , m_isNodeAtVertex(isNodeAtVertex)
+
94  , m_v0(v0)
+
95  , m_nodePt(nodePt)
+
96  , m_v1(v1)
+
97  {};
+
98 
+
99  NodeSection(const NodeSection* ns)
+
100  : m_isA(ns->isA())
+
101  , m_dim(ns->dimension())
+
102  , m_id(ns->id())
+
103  , m_ringId(ns->ringId())
+
104  , m_poly(ns->getPolygonal())
+
105  , m_isNodeAtVertex(ns->isNodeAtVertex())
+
106  , m_v0(ns->getVertex(0))
+
107  , m_nodePt(ns->nodePt())
+
108  , m_v1(ns->getVertex(1))
+
109  {};
+
110 
+
111  const CoordinateXY* getVertex(int i) const;
+
112 
+
113  const CoordinateXY& nodePt() const;
+
114 
+
115  int dimension() const;
+
116 
+
117  int id() const;
+
118 
+
119  int ringId() const;
+
120 
+
127  const Geometry* getPolygonal() const;
+
128 
+
129  bool isShell() const;
+
130 
+
131  bool isArea() const;
+
132 
+
133  static bool isAreaArea(const NodeSection& a, const NodeSection& b);
+
134 
+
135  bool isA() const;
+
136 
+
137  bool isSameGeometry(const NodeSection& ns) const;
+
138 
+
139  bool isSamePolygon(const NodeSection& ns) const;
+
140 
+
141  bool isNodeAtVertex() const;
+
142 
+
143  bool isProper() const;
+
144 
+
145  static bool isProper(const NodeSection& a, const NodeSection& b);
+
146 
+
147  std::string toString() const;
+
148 
+
149  static std::string edgeRep(const CoordinateXY* p0, const CoordinateXY* p1);
+
150 
+
151  friend std::ostream& operator<<(std::ostream& os, const NodeSection& ns);
+
152 
+
158  int compareTo(const NodeSection& o) const;
+
159 
+
160 
+
161 };
+
162 
+
163 } // namespace geos.operation.relateng
+
164 } // namespace geos.operation
+
165 } // namespace geos
+
166 
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::operation::relateng::NodeSection
Definition: NodeSection.h:55
+
geos::operation::relateng::NodeSection::getPolygonal
const Geometry * getPolygonal() const
+
geos::operation::relateng::NodeSection::compareTo
int compareTo(const NodeSection &o) const
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/NodeSections_8h_source.html b/doxygen/NodeSections_8h_source.html new file mode 100644 index 0000000000..cf95b366c2 --- /dev/null +++ b/doxygen/NodeSections_8h_source.html @@ -0,0 +1,151 @@ + + + + + + + +GEOS: NodeSections.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
NodeSections.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <vector>
+
19 #include <memory>
+
20 #include <geos/operation/relateng/NodeSection.h>
+
21 #include <geos/export.h>
+
22 
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace operation {
+
27 namespace relateng {
+
28 class RelateNode;
+
29 // class NodeSection;
+
30 }
+
31 }
+
32 namespace geom {
+
33  class CoordinateXY;
+
34  class Geometry;
+
35 }
+
36 }
+
37 
+
38 
+
39 using geos::geom::CoordinateXY;
+
40 using geos::geom::Geometry;
+
41 
+
42 
+
43 namespace geos { // geos.
+
44 namespace operation { // geos.operation
+
45 namespace relateng { // geos.operation.relateng
+
46 
+
47 
+
48 class GEOS_DLL NodeSections {
+
49 
+
50 private:
+
51 
+
52  // Members
+
53  const CoordinateXY* nodePt;
+
54  std::vector<std::unique_ptr<NodeSection>> sections;
+
55 
+
56  // Methods
+
57 
+
63  void prepareSections();
+
64 
+
65  static bool hasMultiplePolygonSections(
+
66  std::vector<std::unique_ptr<NodeSection>>& sections,
+
67  std::size_t i);
+
68 
+
69  static std::vector<const NodeSection*> collectPolygonSections(
+
70  std::vector<std::unique_ptr<NodeSection>>& sections,
+
71  std::size_t i);
+
72 
+
73 
+
74 public:
+
75 
+
76  NodeSections(const CoordinateXY* pt)
+
77  : nodePt(pt)
+
78  {};
+
79 
+
80  const CoordinateXY* getCoordinate() const;
+
81 
+
82  void addNodeSection(NodeSection* e);
+
83 
+
84  bool hasInteractionAB() const;
+
85 
+
86  const Geometry* getPolygonal(bool isA) const;
+
87 
+
88  std::unique_ptr<RelateNode> createNode();
+
89 
+
94  NodeSections(const NodeSections&) = delete;
+
95  NodeSections& operator=(const NodeSections&) = delete;
+
96 
+
97 };
+
98 
+
99 } // namespace geos.operation.relateng
+
100 } // namespace geos.operation
+
101 } // namespace geos
+
102 
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/NodingIntersectionFinder_8h_source.html b/doxygen/NodingIntersectionFinder_8h_source.html index c19334a38d..67ca86448d 100644 --- a/doxygen/NodingIntersectionFinder_8h_source.html +++ b/doxygen/NodingIntersectionFinder_8h_source.html @@ -209,7 +209,7 @@
261 
262 
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::NodingIntersectionFinder
Finds non-noded intersections in a set of SegmentStrings, if any exist.
Definition: NodingIntersectionFinder.h:47
geos::noding::NodingIntersectionFinder::setFindAllIntersections
void setFindAllIntersections(bool fAI)
Sets whether all intersections should be computed.
Definition: NodingIntersectionFinder.h:129
geos::noding::NodingIntersectionFinder::setCheckEndSegmentsOnly
void setCheckEndSegmentsOnly(bool isCESO)
Sets whether only end segments should be tested for interior intersection.
Definition: NodingIntersectionFinder.h:112
diff --git a/doxygen/NodingValidator_8h_source.html b/doxygen/NodingValidator_8h_source.html index 083d4f8271..586a82aa25 100644 --- a/doxygen/NodingValidator_8h_source.html +++ b/doxygen/NodingValidator_8h_source.html @@ -134,7 +134,7 @@
108 } // namespace geos
109 
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::NodingValidator
Validates that a collection of SegmentStrings is correctly noded. Throws a TopologyException if a nod...
Definition: NodingValidator.h:45
geos::noding::SegmentString
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:47
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/OffsetCurveBuilder_8h_source.html b/doxygen/OffsetCurveBuilder_8h_source.html index 8ca55c67be..e73bbbee5c 100644 --- a/doxygen/OffsetCurveBuilder_8h_source.html +++ b/doxygen/OffsetCurveBuilder_8h_source.html @@ -196,7 +196,7 @@
256 #endif
257 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
geos::operation::buffer::BufferParameters
Contains the parameters which describe how a buffer should be constructed.
Definition: BufferParameters.h:56
geos::operation::buffer::OffsetCurveBuilder
Computes the raw offset curve for a single Geometry component (ring, line or point).
Definition: OffsetCurveBuilder.h:68
diff --git a/doxygen/OffsetCurveSection_8h_source.html b/doxygen/OffsetCurveSection_8h_source.html index 8310651a2c..2cf00feb69 100644 --- a/doxygen/OffsetCurveSection_8h_source.html +++ b/doxygen/OffsetCurveSection_8h_source.html @@ -139,7 +139,7 @@
110 } // namespace geos
111 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
diff --git a/doxygen/OffsetCurve_8h_source.html b/doxygen/OffsetCurve_8h_source.html index 5424f5d910..cfb4d4688b 100644 --- a/doxygen/OffsetCurve_8h_source.html +++ b/doxygen/OffsetCurve_8h_source.html @@ -238,7 +238,7 @@
327 
328 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
diff --git a/doxygen/OffsetPointGenerator_8h_source.html b/doxygen/OffsetPointGenerator_8h_source.html index 700d9a2a56..e9a98ae756 100644 --- a/doxygen/OffsetPointGenerator_8h_source.html +++ b/doxygen/OffsetPointGenerator_8h_source.html @@ -132,7 +132,7 @@
85 #pragma warning(pop)
86 #endif
87 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
geos::operation::overlay::validate::OffsetPointGenerator
Generates points offset from both sides of all segments in a geometry.
Definition: OffsetPointGenerator.h:52
diff --git a/doxygen/OffsetSegmentGenerator_8h_source.html b/doxygen/OffsetSegmentGenerator_8h_source.html index 3e5d6474b9..8a3aa4db65 100644 --- a/doxygen/OffsetSegmentGenerator_8h_source.html +++ b/doxygen/OffsetSegmentGenerator_8h_source.html @@ -264,7 +264,7 @@
390 
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
geos::operation::buffer::BufferParameters
Contains the parameters which describe how a buffer should be constructed.
Definition: BufferParameters.h:56
diff --git a/doxygen/OffsetSegmentString_8h_source.html b/doxygen/OffsetSegmentString_8h_source.html index da7b0e90fa..0394114e7e 100644 --- a/doxygen/OffsetSegmentString_8h_source.html +++ b/doxygen/OffsetSegmentString_8h_source.html @@ -232,7 +232,7 @@
214 } // namespace geos
215 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
geos::geom::PrecisionModel::makePrecise
double makePrecise(double val) const
Rounds a numeric value to the PrecisionModel grid.
geos::operation::buffer::OffsetSegmentString
Definition: OffsetSegmentString.h:41
diff --git a/doxygen/OverlayEdgeRing_8h_source.html b/doxygen/OverlayEdgeRing_8h_source.html index e0c4cc1c0e..fe42b737ed 100644 --- a/doxygen/OverlayEdgeRing_8h_source.html +++ b/doxygen/OverlayEdgeRing_8h_source.html @@ -155,7 +155,7 @@
152 } // namespace geos
153 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
geos::geom
Definition: Angle.h:26
diff --git a/doxygen/OverlayEdge_8h_source.html b/doxygen/OverlayEdge_8h_source.html index 0b3fd693e8..2e734794af 100644 --- a/doxygen/OverlayEdge_8h_source.html +++ b/doxygen/OverlayEdge_8h_source.html @@ -311,7 +311,7 @@
279 } // namespace geos
geos::edgegraph::HalfEdge
Definition: HalfEdge.h:56
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::overlayng::OverlayEdge
Definition: OverlayEdge.h:52
geos::operation::overlayng::OverlayEdge::directionPt
const CoordinateXYZM & directionPt() const override
Definition: OverlayEdge.h:106
geos::operation::overlayng::OverlayEdge::addCoordinates
void addCoordinates(CoordinateSequence *coords) const
diff --git a/doxygen/OverlayGraph_8h_source.html b/doxygen/OverlayGraph_8h_source.html index d86fdecc4b..78c14a624d 100644 --- a/doxygen/OverlayGraph_8h_source.html +++ b/doxygen/OverlayGraph_8h_source.html @@ -143,7 +143,7 @@
142 } // namespace geos
143 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::overlayng::Edge
Definition: operation/overlayng/Edge.h:55
geos::operation::overlayng::OverlayEdge
Definition: OverlayEdge.h:52
geos::operation::overlayng::OverlayGraph
Definition: OverlayGraph.h:54
diff --git a/doxygen/OverlayLabeller_8h_source.html b/doxygen/OverlayLabeller_8h_source.html index 474b72a4e8..b380d54725 100644 --- a/doxygen/OverlayLabeller_8h_source.html +++ b/doxygen/OverlayLabeller_8h_source.html @@ -148,7 +148,7 @@
205 } // namespace geos.operation
206 } // namespace geos
207 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/OverlayNodeFactory_8h_source.html b/doxygen/OverlayNodeFactory_8h_source.html index f2396f9d83..0937af822e 100644 --- a/doxygen/OverlayNodeFactory_8h_source.html +++ b/doxygen/OverlayNodeFactory_8h_source.html @@ -99,7 +99,7 @@
54 } // namespace geos::operation
55 } // namespace geos
56 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::Node
The node component of a geometry graph.
Definition: geomgraph/Node.h:59
geos::operation::overlay::OverlayNodeFactory
Creates nodes for use in the geomgraph::PlanarGraph constructed during overlay operations....
Definition: OverlayNodeFactory.h:45
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/OverlayResultValidator_8h_source.html b/doxygen/OverlayResultValidator_8h_source.html index afca224a1e..4cc68eb5f1 100644 --- a/doxygen/OverlayResultValidator_8h_source.html +++ b/doxygen/OverlayResultValidator_8h_source.html @@ -161,7 +161,7 @@
129 #pragma warning(pop)
130 #endif
131 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::operation::overlay::validate::FuzzyPointLocator
Finds the most likely Location of a point relative to the polygonal components of a geometry,...
Definition: FuzzyPointLocator.h:57
geos::operation::overlay::validate::OverlayResultValidator
Validates that the result of an overlay operation is geometrically correct within a determined tolera...
Definition: OverlayResultValidator.h:62
diff --git a/doxygen/OverlayUtil_8h_source.html b/doxygen/OverlayUtil_8h_source.html index 54c1d08d5c..70dee2ce75 100644 --- a/doxygen/OverlayUtil_8h_source.html +++ b/doxygen/OverlayUtil_8h_source.html @@ -169,7 +169,7 @@
211 } // namespace geos.operation
212 } // namespace geos
213 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/Point_8h_source.html b/doxygen/Point_8h_source.html index f01384c06a..b8d29d13bf 100644 --- a/doxygen/Point_8h_source.html +++ b/doxygen/Point_8h_source.html @@ -232,7 +232,7 @@
geos::geom::CoordinateFilter
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
geos::geom::CoordinateSequenceFilter
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Dimension::DimensionType
DimensionType
Definition: Dimension.h:29
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryComponentFilter
Definition: GeometryComponentFilter.h:41
diff --git a/doxygen/PolygonEarClipper_8h_source.html b/doxygen/PolygonEarClipper_8h_source.html index a241333747..690e2b64ee 100644 --- a/doxygen/PolygonEarClipper_8h_source.html +++ b/doxygen/PolygonEarClipper_8h_source.html @@ -166,7 +166,7 @@
217 } // namespace geos.triangulate
218 } // namespace geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition: Polygon.h:61
geos::index::VertexSequencePackedRtree
Definition: VertexSequencePackedRtree.h:54
diff --git a/doxygen/PolygonHoleJoiner_8h_source.html b/doxygen/PolygonHoleJoiner_8h_source.html index e96225e752..4bc8f48c21 100644 --- a/doxygen/PolygonHoleJoiner_8h_source.html +++ b/doxygen/PolygonHoleJoiner_8h_source.html @@ -204,7 +204,7 @@
266 } // namespace geos.triangulate
267 } // namespace geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition: Polygon.h:61
geos::noding::BasicSegmentString
Represents a list of contiguous line segments, and supports noding the segments.
Definition: BasicSegmentString.h:44
diff --git a/doxygen/PolygonNodeConverter_8h_source.html b/doxygen/PolygonNodeConverter_8h_source.html new file mode 100644 index 0000000000..f6e42a7a40 --- /dev/null +++ b/doxygen/PolygonNodeConverter_8h_source.html @@ -0,0 +1,139 @@ + + + + + + + +GEOS: PolygonNodeConverter.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
PolygonNodeConverter.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/operation/relateng/NodeSection.h>
+
19 #include <geos/export.h>
+
20 #include <vector>
+
21 #include <memory>
+
22 
+
23 // Forward declarations
+
24 namespace geos {
+
25 namespace operation {
+
26 namespace relateng {
+
27 // class NodeSection;
+
28 }
+
29 }
+
30 }
+
31 
+
32 
+
33 // using geos::geom::CoordinateXY;
+
34 // using geos::geom::Geometry;
+
35 
+
36 
+
37 namespace geos { // geos.
+
38 namespace operation { // geos.operation
+
39 namespace relateng { // geos.operation.relateng
+
40 
+
66 class GEOS_DLL PolygonNodeConverter {
+
67 
+
68 public:
+
69 
+
78  static std::vector<std::unique_ptr<NodeSection>> convert(
+
79  std::vector<const NodeSection*>& polySections);
+
80 
+
81 
+
82 private:
+
83 
+
84  static std::size_t convertShellAndHoles(
+
85  std::vector<const NodeSection*>& sections,
+
86  std::size_t shellIndex,
+
87  std::vector<std::unique_ptr<NodeSection>>& convertedSections);
+
88 
+
89  static std::vector<std::unique_ptr<NodeSection>> convertHoles(
+
90  std::vector<const NodeSection*>& sections);
+
91 
+
92  static NodeSection* createSection(
+
93  const NodeSection* ns,
+
94  const CoordinateXY* v0,
+
95  const CoordinateXY* v1);
+
96 
+
97  static std::vector<const NodeSection*> extractUnique(
+
98  std::vector<const NodeSection*>& sections);
+
99 
+
100  static std::size_t next(
+
101  std::vector<const NodeSection *>& ns, std::size_t i);
+
102 
+
103  static std::size_t findShell(
+
104  std::vector<const NodeSection *>& polySections);
+
105 
+
106 
+
107 };
+
108 
+
109 } // namespace geos.operation.relateng
+
110 } // namespace geos.operation
+
111 } // namespace geos
+
112 
+
geos::operation::relateng::NodeSection
Definition: NodeSection.h:55
+
geos::operation::relateng::PolygonNodeConverter
Definition: PolygonNodeConverter.h:66
+
geos::operation::relateng::PolygonNodeConverter::convert
static std::vector< std::unique_ptr< NodeSection > > convert(std::vector< const NodeSection * > &polySections)
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/PolygonNodeTopology_8h_source.html b/doxygen/PolygonNodeTopology_8h_source.html index 50f9421329..be88d108cd 100644 --- a/doxygen/PolygonNodeTopology_8h_source.html +++ b/doxygen/PolygonNodeTopology_8h_source.html @@ -105,25 +105,35 @@
76  static bool isInteriorSegment(const CoordinateXY* nodePt,
77  const CoordinateXY* a0, const CoordinateXY* a1, const CoordinateXY* b);
78 
-
79 
-
80 private:
-
81 
-
94  static bool isBetween(const CoordinateXY* origin,
-
95  const CoordinateXY* p,
-
96  const CoordinateXY* e0, const CoordinateXY* e1);
-
97 
-
107  static bool isAngleGreater(const CoordinateXY* origin, const CoordinateXY* p, const CoordinateXY* q);
-
108 
-
109  static int quadrant(const CoordinateXY* origin, const CoordinateXY* p);
-
110 
-
111 
-
112 };
-
113 
-
114 
-
115 } // namespace geos::algorithm
-
116 } // namespace geos
-
117 
+
89  static int compareAngle(
+
90  const CoordinateXY* origin,
+
91  const CoordinateXY* p,
+
92  const CoordinateXY* q);
+
93 
+
94 
+
95 private:
+
96 
+
109  static bool isBetween(const CoordinateXY* origin,
+
110  const CoordinateXY* p,
+
111  const CoordinateXY* e0, const CoordinateXY* e1);
+
112 
+
126  static int compareBetween(const CoordinateXY* origin, const CoordinateXY* p,
+
127  const CoordinateXY* e0, const CoordinateXY* e1);
+
128 
+
129 
+
139  static bool isAngleGreater(const CoordinateXY* origin, const CoordinateXY* p, const CoordinateXY* q);
+
140 
+
141  static int quadrant(const CoordinateXY* origin, const CoordinateXY* p);
+
142 
+
143 
+
144 };
+
145 
+
146 
+
147 } // namespace geos::algorithm
+
148 } // namespace geos
+
149 
geos::algorithm::PolygonNodeTopology
Definition: PolygonNodeTopology.h:41
+
geos::algorithm::PolygonNodeTopology::compareAngle
static int compareAngle(const CoordinateXY *origin, const CoordinateXY *p, const CoordinateXY *q)
geos::algorithm::PolygonNodeTopology::isInteriorSegment
static bool isInteriorSegment(const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b)
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/PolygonNoder_8h_source.html b/doxygen/PolygonNoder_8h_source.html index 470438534b..9154eafb04 100644 --- a/doxygen/PolygonNoder_8h_source.html +++ b/doxygen/PolygonNoder_8h_source.html @@ -140,7 +140,7 @@
101 } // namespace geos
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::NodedSegmentString
Represents a list of contiguous line segments, and supports noding the segments.
Definition: NodedSegmentString.h:58
geos::triangulate::polygon::PolygonNoder
Definition: PolygonNoder.h:55
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/PolygonizeDirectedEdge_8h_source.html b/doxygen/PolygonizeDirectedEdge_8h_source.html index 8e7b083094..9c7b4647ed 100644 --- a/doxygen/PolygonizeDirectedEdge_8h_source.html +++ b/doxygen/PolygonizeDirectedEdge_8h_source.html @@ -167,7 +167,7 @@
125 } // namespace geos::operation
126 } // namespace geos
127 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::operation::polygonize::EdgeRing
Represents a ring of PolygonizeDirectedEdge which form a ring of a polygon. The ring may be either an...
Definition: operation/polygonize/EdgeRing.h:59
geos::operation::polygonize::PolygonizeDirectedEdge
A DirectedEdge of a PolygonizeGraph, which represents an edge of a polygon formed by the graph.
Definition: PolygonizeDirectedEdge.h:52
geos::planargraph::DirectedEdge
Represents a directed edge in a PlanarGraph.
Definition: planargraph/DirectedEdge.h:45
diff --git a/doxygen/PolygonizeGraph_8h_source.html b/doxygen/PolygonizeGraph_8h_source.html index 8d5e9a806f..0fadf300ff 100644 --- a/doxygen/PolygonizeGraph_8h_source.html +++ b/doxygen/PolygonizeGraph_8h_source.html @@ -171,7 +171,7 @@
212 #pragma warning(pop)
213 #endif
214 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::LineString
Definition: LineString.h:66
geos::operation::polygonize::EdgeRing
Represents a ring of PolygonizeDirectedEdge which form a ring of a polygon. The ring may be either an...
Definition: operation/polygonize/EdgeRing.h:59
diff --git a/doxygen/PrecisionUtil_8h_source.html b/doxygen/PrecisionUtil_8h_source.html index 28a57ac62d..63a27870f8 100644 --- a/doxygen/PrecisionUtil_8h_source.html +++ b/doxygen/PrecisionUtil_8h_source.html @@ -168,7 +168,7 @@
244 } // namespace geos
245 
geos::geom::CoordinateFilter
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
diff --git a/doxygen/PreparedGeometryFactory_8h_source.html b/doxygen/PreparedGeometryFactory_8h_source.html index 9f19bd67d6..d70d7d64dc 100644 --- a/doxygen/PreparedGeometryFactory_8h_source.html +++ b/doxygen/PreparedGeometryFactory_8h_source.html @@ -116,7 +116,7 @@
geos::geom::prep::PreparedGeometryFactory::create
std::unique_ptr< PreparedGeometry > create(const geom::Geometry *geom) const
geos::geom::prep::PreparedGeometryFactory::destroy
static void destroy(const PreparedGeometry *geom)
Definition: PreparedGeometryFactory.h:75
geos::geom::prep::PreparedGeometryFactory::prepare
static std::unique_ptr< PreparedGeometry > prepare(const geom::Geometry *geom)
Definition: PreparedGeometryFactory.h:63
-
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:56
+
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:58
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/PreparedGeometry_8h_source.html b/doxygen/PreparedGeometry_8h_source.html index f825787e11..4e76b6eb5f 100644 --- a/doxygen/PreparedGeometry_8h_source.html +++ b/doxygen/PreparedGeometry_8h_source.html @@ -69,67 +69,76 @@
20 
21 #include <vector>
22 #include <memory>
-
23 #include <geos/export.h>
-
24 
-
25 // Forward declarations
-
26 namespace geos {
-
27  namespace geom {
-
28  class Geometry;
-
29  class Coordinate;
-
30  class CoordinateSequence;
-
31  }
-
32 }
-
33 
-
34 
-
35 namespace geos {
-
36 namespace geom { // geos::geom
-
37 namespace prep { // geos::geom::prep
-
38 
-
56 class GEOS_DLL PreparedGeometry {
-
57 public:
-
58  virtual
-
59  ~PreparedGeometry() {}
-
60 
-
66  virtual const geom::Geometry& getGeometry() const = 0;
-
67 
-
76  virtual bool contains(const geom::Geometry* geom) const = 0;
-
77 
-
117  virtual bool containsProperly(const geom::Geometry* geom) const = 0;
-
118 
-
127  virtual bool coveredBy(const geom::Geometry* geom) const = 0;
-
128 
-
137  virtual bool covers(const geom::Geometry* geom) const = 0;
-
138 
-
147  virtual bool crosses(const geom::Geometry* geom) const = 0;
-
148 
-
157  virtual bool disjoint(const geom::Geometry* geom) const = 0;
-
158 
-
167  virtual bool intersects(const geom::Geometry* geom) const = 0;
-
168 
-
177  virtual bool overlaps(const geom::Geometry* geom) const = 0;
-
178 
-
187  virtual bool touches(const geom::Geometry* geom) const = 0;
-
188 
-
197  virtual bool within(const geom::Geometry* geom) const = 0;
-
198 
-
207  virtual std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* geom) const = 0;
-
208 
-
217  virtual double distance(const geom::Geometry* geom) const = 0;
-
218 
-
229  virtual bool isWithinDistance(const geom::Geometry* geom, double dist) const = 0;
-
230 };
-
231 
+
23 #include <string>
+
24 #include <geos/export.h>
+
25 
+
26 // Forward declarations
+
27 namespace geos {
+
28  namespace geom {
+
29  class Geometry;
+
30  class Coordinate;
+
31  class CoordinateSequence;
+
32  class IntersectionMatrix;
+
33  }
+
34 }
+
35 
+
36 
+
37 namespace geos {
+
38 namespace geom { // geos::geom
+
39 namespace prep { // geos::geom::prep
+
40 
+
58 class GEOS_DLL PreparedGeometry {
+
59 public:
+
60  virtual
+
61  ~PreparedGeometry() {}
+
62 
+
68  virtual const geom::Geometry& getGeometry() const = 0;
+
69 
+
78  virtual bool contains(const geom::Geometry* geom) const = 0;
+
79 
+
119  virtual bool containsProperly(const geom::Geometry* geom) const = 0;
+
120 
+
129  virtual bool coveredBy(const geom::Geometry* geom) const = 0;
+
130 
+
139  virtual bool covers(const geom::Geometry* geom) const = 0;
+
140 
+
149  virtual bool crosses(const geom::Geometry* geom) const = 0;
+
150 
+
159  virtual bool disjoint(const geom::Geometry* geom) const = 0;
+
160 
+
169  virtual bool intersects(const geom::Geometry* geom) const = 0;
+
170 
+
179  virtual bool overlaps(const geom::Geometry* geom) const = 0;
+
180 
+
189  virtual bool touches(const geom::Geometry* geom) const = 0;
+
190 
+
199  virtual bool within(const geom::Geometry* geom) const = 0;
+
200 
+
209  virtual std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* geom) const = 0;
+
210 
+
219  virtual double distance(const geom::Geometry* geom) const = 0;
+
220 
+
231  virtual bool isWithinDistance(const geom::Geometry* geom, double dist) const = 0;
232 
-
233 } // namespace geos::geom::prep
-
234 } // namespace geos::geom
-
235 } // namespace geos
-
236 
+
240  virtual std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* geom) const = 0;
+
241 
+
252  virtual bool relate(const geom::Geometry* geom, const std::string& pat) const = 0;
+
253 
+
254 };
+
255 
+
256 
+
257 } // namespace geos::geom::prep
+
258 } // namespace geos::geom
+
259 } // namespace geos
+
260 
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
-
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:56
+
geos::geom::prep::PreparedGeometry
An interface for classes which prepare Geometrys in order to optimize the performance of repeated cal...
Definition: PreparedGeometry.h:58
geos::geom::prep::PreparedGeometry::intersects
virtual bool intersects(const geom::Geometry *geom) const =0
Tests whether the base Geometry intersects a given geometry.
geos::geom::prep::PreparedGeometry::contains
virtual bool contains(const geom::Geometry *geom) const =0
Tests whether the base Geometry contains a given geometry.
geos::geom::prep::PreparedGeometry::coveredBy
virtual bool coveredBy(const geom::Geometry *geom) const =0
Tests whether the base Geometry is covered by a given geometry.
geos::geom::prep::PreparedGeometry::overlaps
virtual bool overlaps(const geom::Geometry *geom) const =0
Tests whether the base Geometry overlaps a given geometry.
+
geos::geom::prep::PreparedGeometry::relate
virtual bool relate(const geom::Geometry *geom, const std::string &pat) const =0
Compares the prepared geometry to the given geometry and the provided DE9IM pattern,...
+
geos::geom::prep::PreparedGeometry::relate
virtual std::unique_ptr< IntersectionMatrix > relate(const geom::Geometry *geom) const =0
Compares the prepared geometry to the given geometry and returns the DE9IM intersection matrix as a s...
geos::geom::prep::PreparedGeometry::containsProperly
virtual bool containsProperly(const geom::Geometry *geom) const =0
Tests whether the base Geometry properly contains a given geometry.
geos::geom::prep::PreparedGeometry::isWithinDistance
virtual bool isWithinDistance(const geom::Geometry *geom, double dist) const =0
Tests whether the base Geometry is within a given distance from the given geometry.
geos::geom::prep::PreparedGeometry::nearestPoints
virtual std::unique_ptr< geom::CoordinateSequence > nearestPoints(const geom::Geometry *geom) const =0
Compute the nearest locations on the base Geometry and the given geometry.
diff --git a/doxygen/PreparedPolygon_8h_source.html b/doxygen/PreparedPolygon_8h_source.html index a852133223..e247ffdf02 100644 --- a/doxygen/PreparedPolygon_8h_source.html +++ b/doxygen/PreparedPolygon_8h_source.html @@ -81,7 +81,7 @@
32 }
33 namespace algorithm {
34 namespace locate {
-
35 class PointOnGeometryLocator;
+
35 class PointOnGeometryLocator;
36 }
37 }
38 }
diff --git a/doxygen/QuadEdgeSubdivision_8h_source.html b/doxygen/QuadEdgeSubdivision_8h_source.html index 410584254e..f9f3a10eb3 100644 --- a/doxygen/QuadEdgeSubdivision_8h_source.html +++ b/doxygen/QuadEdgeSubdivision_8h_source.html @@ -235,7 +235,7 @@
512 } //namespace geos.triangulate.quadedge
513 } //namespace geos.triangulate
514 } //namespace goes
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::triangulate::quadedge::QuadEdgeSubdivision
A class that contains the QuadEdges representing a planar subdivision that models a triangulation.
Definition: QuadEdgeSubdivision.h:78
diff --git a/doxygen/RectangleContains_8h_source.html b/doxygen/RectangleContains_8h_source.html index 0522f7fbbb..d9014ffdcd 100644 --- a/doxygen/RectangleContains_8h_source.html +++ b/doxygen/RectangleContains_8h_source.html @@ -130,7 +130,7 @@
117 } // namespace geos::operation::predicate
118 } // namespace geos::operation
119 } // namespace geos
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineString
Definition: LineString.h:66
diff --git a/doxygen/RelateComputer_8h_source.html b/doxygen/RelateComputer_8h_source.html index a7cb465b5e..d49dd9e66b 100644 --- a/doxygen/RelateComputer_8h_source.html +++ b/doxygen/RelateComputer_8h_source.html @@ -172,7 +172,7 @@
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
geos::algorithm::PointLocator
Computes the topological relationship (Location) of a single point to a Geometry.
Definition: PointLocator.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::IntersectionMatrix
Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
Definition: IntersectionMatrix.h:51
geos::geomgraph::Edge
Definition: geomgraph/Edge.h:63
diff --git a/doxygen/RelateEdge_8h_source.html b/doxygen/RelateEdge_8h_source.html new file mode 100644 index 0000000000..ba0fe55aa3 --- /dev/null +++ b/doxygen/RelateEdge_8h_source.html @@ -0,0 +1,223 @@ + + + + + + + +GEOS: RelateEdge.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelateEdge.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/export.h>
+
20 
+
21 #include <memory>
+
22 #include <vector>
+
23 
+
24 // Forward declarations
+
25 namespace geos {
+
26 namespace operation {
+
27 namespace relateng {
+
28 class RelateNode;
+
29 }
+
30 }
+
31 namespace geom {
+
32  class CoordinateXY;
+
33  class Geometry;
+
34 }
+
35 }
+
36 
+
37 
+
38 using geos::geom::CoordinateXY;
+
39 using geos::geom::Geometry;
+
40 using geos::geom::Location;
+
41 
+
42 
+
43 namespace geos { // geos.
+
44 namespace operation { // geos.operation
+
45 namespace relateng { // geos.operation.relateng
+
46 
+
47 
+
48 class GEOS_DLL RelateEdge {
+
49 
+
50 private:
+
51 
+
55  static constexpr Location LOC_UNKNOWN = Location::NONE;
+
56 
+
57  // Members
+
58  const RelateNode* node;
+
59  const CoordinateXY* dirPt;
+
60 
+
61  int aDim = DIM_UNKNOWN;
+
62  Location aLocLeft = LOC_UNKNOWN;
+
63  Location aLocRight = LOC_UNKNOWN;
+
64  Location aLocLine = LOC_UNKNOWN;
+
65 
+
66  int bDim = DIM_UNKNOWN;
+
67  Location bLocLeft = LOC_UNKNOWN;
+
68  Location bLocRight = LOC_UNKNOWN;
+
69  Location bLocLine = LOC_UNKNOWN;
+
70 
+
71 
+
72 public:
+
73 
+
74  // Constants
+
75  static constexpr bool IS_FORWARD = true;
+
76  static constexpr bool IS_REVERSE = false;
+
77  static constexpr int DIM_UNKNOWN = -1;
+
78 
+
79  // Constructors
+
80  RelateEdge(
+
81  const RelateNode* node, const CoordinateXY* pt,
+
82  bool isA, bool isForward);
+
83 
+
84  RelateEdge(
+
85  const RelateNode* node, const CoordinateXY* pt,
+
86  bool isA);
+
87 
+
88  RelateEdge(
+
89  const RelateNode* node, const CoordinateXY* pt,
+
90  bool isA, Location locLeft, Location locRight, Location locLine);
+
91 
+
92  // Methods
+
93  static RelateEdge* create(
+
94  const RelateNode* node,
+
95  const CoordinateXY* dirPt,
+
96  bool isA, int dim, bool isForward);
+
97 
+
98  static std::size_t findKnownEdgeIndex(
+
99  std::vector<std::unique_ptr<RelateEdge>>& edges,
+
100  bool isA);
+
101 
+
102  static void setAreaInterior(
+
103  std::vector<std::unique_ptr<RelateEdge>>& edges,
+
104  bool isA);
+
105 
+
106  bool isInterior(bool isA, int position) const;
+
107 
+
108  Location location(bool isA, int position) const;
+
109 
+
110  int compareToEdge(const CoordinateXY* edgeDirPt) const;
+
111 
+
112  void setDimLocations(bool isA, int dim, Location loc);
+
113 
+
114  void setAreaInterior(bool isA);
+
115 
+
116  void setLocation(bool isA, int pos, Location loc);
+
117 
+
118  void setAllLocations(bool isA, Location loc);
+
119 
+
120  void setUnknownLocations(bool isA, Location loc);
+
121 
+
122  void merge(bool isA, int dim, bool isForward);
+
123 
+
124  std::string toString() const;
+
125 
+
126  friend std::ostream& operator<<(std::ostream& os, const RelateEdge& re);
+
127 
+
128 
+
129 private:
+
130 
+
131  // Methods
+
132  void mergeSideLocation(bool isA, int pos, Location loc);
+
133 
+
144  void mergeDimEdgeLoc(bool isA, Location locEdge);
+
145 
+
146  void setDimension(bool isA, int dimension);
+
147 
+
148  void setLeft(bool isA, Location loc);
+
149 
+
150  void setRight(bool isA, Location loc);
+
151 
+
152  void setOn(bool isA, Location loc);
+
153 
+
154  int dimension(bool isA) const;
+
155 
+
156  bool isKnown(bool isA) const;
+
157 
+
158  bool isKnown(bool isA, int pos) const;
+
159 
+
160  void setLocations(bool isA, Location locLeft, Location locRight, Location locLine);
+
161 
+
162  void setLocationsLine(bool isA);
+
163 
+
164  void setLocationsArea(bool isA, bool isForward);
+
165 
+
166  std::string labelString() const;
+
167 
+
168  std::string locationString(bool isA) const;
+
169 
+
170 
+
171 };
+
172 
+
173 } // namespace geos.operation.relateng
+
174 } // namespace geos.operation
+
175 } // namespace geos
+
176 
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+ +
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelateGeometry_8h_source.html b/doxygen/RelateGeometry_8h_source.html new file mode 100644 index 0000000000..a39397870c --- /dev/null +++ b/doxygen/RelateGeometry_8h_source.html @@ -0,0 +1,254 @@ + + + + + + + +GEOS: RelateGeometry.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelateGeometry.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/algorithm/BoundaryNodeRule.h>
+
19 #include <geos/geom/Coordinate.h>
+
20 #include <geos/geom/Dimension.h>
+
21 #include <geos/geom/Location.h>
+
22 #include <geos/operation/relateng/RelatePointLocator.h>
+
23 #include <geos/operation/relateng/RelateSegmentString.h>
+
24 #include <geos/export.h>
+
25 
+
26 #include <string>
+
27 #include <sstream>
+
28 
+
29 
+
30 // Forward declarations
+
31 namespace geos {
+
32 namespace geom {
+
33  class CoordinateSequence;
+
34  class Envelope;
+
35  class Geometry;
+
36  class LinearRing;
+
37  class LineString;
+
38  class MultiPolygon;
+
39  class Point;
+
40 }
+
41 namespace noding {
+
42  class SegmentString;
+
43 }
+
44 }
+
45 
+
46 
+
47 namespace geos { // geos.
+
48 namespace operation { // geos.operation
+
49 namespace relateng { // geos.operation.relateng
+
50 
+
51 using namespace geos::geom;
+
52 using geos::algorithm::BoundaryNodeRule;
+
53 using geos::noding::SegmentString;
+
54 
+
55 
+
56 class GEOS_DLL RelateGeometry {
+
57 
+
58 private:
+
59 
+
60  // Members
+
61 
+
62  const Geometry* geom;
+
63  bool m_isPrepared = false;
+
64  const Envelope* geomEnv;
+
65  const BoundaryNodeRule& boundaryNodeRule;
+
66  int geomDim = Dimension::False;
+
67  bool isLineZeroLen = false;
+
68  bool isGeomEmpty = false;
+
69 
+
70  Coordinate::ConstXYSet uniquePoints;
+
71  std::unique_ptr<RelatePointLocator> locator;
+
72  int elementId = 0;
+
73  bool hasPoints = false;
+
74  bool hasLines = false;
+
75  bool hasAreas = false;
+
76 
+
77  /*
+
78  * Memory contexts for lower level allocations
+
79  */
+
80  std::vector<std::unique_ptr<const RelateSegmentString>> segStringTempStore;
+
81  std::vector<std::unique_ptr<const RelateSegmentString>> segStringPermStore;
+
82  std::vector<std::unique_ptr<CoordinateSequence>> csStore;
+
83 
+
84 
+
85  // Methods
+
86 
+
87  void analyzeDimensions();
+
88 
+
96  static bool isZeroLength(const Geometry* geom);
+
97 
+
98  static bool isZeroLength(const LineString* line);
+
99 
+
100  RelatePointLocator* getLocator();
+
101 
+
102  Coordinate::ConstXYSet createUniquePoints();
+
103 
+
104  void extractSegmentStringsFromAtomic(bool isA,
+
105  const Geometry* geom, const MultiPolygon* parentPolygonal,
+
106  const Envelope* env,
+
107  std::vector<const SegmentString*>& segStrings,
+
108  std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
109 
+
110  void extractRingToSegmentString(bool isA,
+
111  const LinearRing* ring, int ringId, const Envelope* env,
+
112  const Geometry* parentPoly,
+
113  std::vector<const SegmentString*>& segStrings,
+
114  std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
115 
+
116  void extractSegmentStrings(bool isA,
+
117  const Envelope* env, const Geometry* geom,
+
118  std::vector<const SegmentString*>& segStrings,
+
119  std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
120 
+
121  const CoordinateSequence* orientAndRemoveRepeated(
+
122  const CoordinateSequence* cs, bool orientCW);
+
123 
+
124  const CoordinateSequence* removeRepeated(
+
125  const CoordinateSequence* cs);
+
126 
+
127 public:
+
128 
+
129  static constexpr bool GEOM_A = true;
+
130  static constexpr bool GEOM_B = false;
+
131 
+
132  RelateGeometry(const Geometry* input)
+
133  : RelateGeometry(input, false, BoundaryNodeRule::getBoundaryRuleMod2())
+
134  {};
+
135 
+
136  RelateGeometry(const Geometry* input, const BoundaryNodeRule& bnRule)
+
137  : RelateGeometry(input, false, bnRule)
+
138  {};
+
139 
+
140  RelateGeometry(const Geometry* input, bool p_isPrepared, const BoundaryNodeRule& bnRule);
+
141 
+
142  static std::string name(bool isA);
+
143 
+
144  const Geometry* getGeometry() const;
+
145 
+
146  bool isPrepared() const;
+
147 
+
148  const Envelope* getEnvelope() const;
+
149 
+
150  int getDimension() const;
+
151 
+
152  bool hasDimension(int dim) const;
+
153 
+
160  int getDimensionReal() const;
+
161 
+
162  bool hasEdges() const;
+
163 
+
164  bool isNodeInArea(const CoordinateXY* nodePt, const Geometry* parentPolygonal);
+
165 
+
166  Location locateLineEnd(const CoordinateXY* p) ;
+
167 
+
178  Location locateAreaVertex(const CoordinateXY* pt);
+
179 
+
180  Location locateNode(const CoordinateXY* pt, const Geometry* parentPolygonal);
+
181 
+
182  int locateWithDim(const CoordinateXY* pt);
+
183 
+
184  bool isPointsOrPolygons() const;
+
185 
+
196  bool isPolygonal() const;
+
197 
+
198  bool isEmpty() const;
+
199 
+
200  bool hasBoundary();
+
201 
+
202  Coordinate::ConstXYSet& getUniquePoints();
+
203 
+
204  std::vector<const Point*> getEffectivePoints();
+
205 
+
215  std::vector<const SegmentString*> extractSegmentStrings(bool isA, const Envelope* env);
+
216 
+
217  std::string toString() const;
+
218 
+
219  friend std::ostream& operator<<(std::ostream& os, const RelateGeometry& rg);
+
220 
+
226  RelateGeometry(const RelateGeometry&) = delete;
+
227  RelateGeometry& operator=(const RelateGeometry&) = delete;
+
228 
+
229 };
+
230 
+
231 } // namespace geos.operation.relateng
+
232 } // namespace geos.operation
+
233 } // namespace geos
+
234 
+
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
+
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
+
geos::geom::Dimension::False
@ False
Dimension value of the empty geometry (-1).
Definition: Dimension.h:37
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::LineString
Definition: LineString.h:66
+
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
+
geos::geom::Point
Definition: Point.h:61
+
geos::noding::SegmentString
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:47
+
geos::geom
Definition: Angle.h:26
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelateMatrixPredicate_8h_source.html b/doxygen/RelateMatrixPredicate_8h_source.html new file mode 100644 index 0000000000..7287c93063 --- /dev/null +++ b/doxygen/RelateMatrixPredicate_8h_source.html @@ -0,0 +1,141 @@ + + + + + + + +GEOS: RelateMatrixPredicate.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelateMatrixPredicate.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/geom/Dimension.h>
+
20 #include <geos/geom/IntersectionMatrix.h>
+
21 #include <geos/operation/relateng/IMPredicate.h>
+
22 #include <geos/export.h>
+
23 
+
24 #include <memory>
+
25 #include <vector>
+
26 
+
27 // Forward declarations
+
28 namespace geos {
+
29 namespace geom {
+
30  class Envelope;
+
31 }
+
32 }
+
33 
+
34 
+
35 using geos::geom::Envelope;
+
36 using geos::geom::Location;
+
37 using geos::geom::Dimension;
+
38 using geos::geom::IntersectionMatrix;
+
39 
+
40 
+
41 namespace geos { // geos.
+
42 namespace operation { // geos.operation.
+
43 namespace relateng { // geos.operation.relateng
+
44 
+
45 
+
46 class GEOS_DLL RelateMatrixPredicate : public IMPredicate {
+
47 
+
48 public:
+
49 
+
50  RelateMatrixPredicate() {};
+
51 
+
52  std::string name() const override {
+
53  return "relateMatrix";
+
54  };
+
55 
+
56  bool requireInteraction() const override {
+
57  //-- ensure entire matrix is computed
+
58  return false;
+
59  };
+
60 
+
61  bool isDetermined() const override {
+
62  //-- ensure entire matrix is computed
+
63  return false;
+
64  };
+
65 
+
66  bool valueIM() override {
+
67  //-- indicates full matrix is being evaluated
+
68  return false;
+
69  };
+
70 
+
76  std::unique_ptr<IntersectionMatrix> getIM() {
+
77  return std::unique_ptr<IntersectionMatrix>(new IntersectionMatrix(intMatrix));
+
78  }
+
79 
+
80 };
+
81 
+
82 } // namespace geos.operation.relateng
+
83 } // namespace geos.operation
+
84 } // namespace geos
+
85 
+
geos::geom::Dimension
Definition: Dimension.h:27
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::IntersectionMatrix
Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
Definition: IntersectionMatrix.h:51
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelateNG_8h_source.html b/doxygen/RelateNG_8h_source.html new file mode 100644 index 0000000000..e4412b97a1 --- /dev/null +++ b/doxygen/RelateNG_8h_source.html @@ -0,0 +1,233 @@ + + + + + + + +GEOS: RelateNG.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelateNG.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/export.h>
+
19 #include <geos/geom/Coordinate.h>
+
20 #include <geos/noding/MCIndexSegmentSetMutualIntersector.h>
+
21 #include <geos/operation/relateng/RelateGeometry.h>
+
22 #include <string>
+
23 #include <sstream>
+
24 
+
25 
+
26 // Forward declarations
+
27 namespace geos {
+
28 namespace algorithm {
+
29  class BoundaryNodeRule;
+
30 
+
31 }
+
32 namespace geom {
+
33  class Geometry;
+
34 }
+
35 namespace noding {
+
36 }
+
37 namespace operation {
+
38 namespace relateng {
+
39  class TopologyPredicate;
+
40  class TopologyComputer;
+
41  class EdgeSegmentIntersector;
+
42 }
+
43 }
+
44 }
+
45 
+
46 
+
47 namespace geos { // geos.
+
48 namespace operation { // geos.operation
+
49 namespace relateng { // geos.operation.relateng
+
50 
+
51 
+
52 using geos::geom::CoordinateXY;
+
53 using geos::geom::Geometry;
+
54 using geos::algorithm::BoundaryNodeRule;
+
55 using geos::noding::MCIndexSegmentSetMutualIntersector;
+
56 
+
57 
+
93 class GEOS_DLL RelateNG {
+
94 
+
95 private:
+
96 
+
97  // Members
+
98  const BoundaryNodeRule& boundaryNodeRule;
+
99  RelateGeometry geomA;
+
100  std::unique_ptr<MCIndexSegmentSetMutualIntersector> edgeMutualInt = nullptr;
+
101 
+
102  // Methods
+
103 
+
104  RelateNG(const Geometry* inputA, bool isPrepared, const BoundaryNodeRule& bnRule)
+
105  : boundaryNodeRule(bnRule)
+
106  , geomA(inputA, isPrepared, bnRule)
+
107  {}
+
108 
+
109  RelateNG(const Geometry* inputA, bool isPrepared)
+
110  : RelateNG(inputA, isPrepared, BoundaryNodeRule::getBoundaryRuleMod2())
+
111  {}
+
112 
+
113  bool hasRequiredEnvelopeInteraction(const Geometry* b, TopologyPredicate& predicate);
+
114 
+
115  bool finishValue(TopologyPredicate& predicate);
+
116 
+
117  void computePP(RelateGeometry& geomB, TopologyComputer& topoComputer);
+
118 
+
119  void computeAtPoints(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
120 
+
121  bool computePoints(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
122 
+
123  void computePoint(bool isA, const CoordinateXY* pt, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
124 
+
125  bool computeLineEnds(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
126 
+
127  bool computeLineEnd(RelateGeometry& geom, bool isA, const CoordinateXY* pt, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
128 
+
129  bool computeAreaVertex(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
130 
+
131  bool computeAreaVertex(RelateGeometry& geom, bool isA, const LinearRing* ring, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
+
132 
+
133  void computeAtEdges(RelateGeometry& geomB, TopologyComputer& topoComputer);
+
134 
+
135  void computeEdgesAll(std::vector<const SegmentString*>& edgesB, const Envelope* envInt, EdgeSegmentIntersector& intersector);
+
136 
+
137  void computeEdgesMutual(std::vector<const SegmentString*>& edgesB, const Envelope* envInt, EdgeSegmentIntersector& intersector);
+
138 
+
139 
+
140 
+
141 public:
+
142 
+
152  static bool relate(const Geometry* a, const Geometry* b, TopologyPredicate& pred);
+
153 
+
165  static bool relate(const Geometry* a, const Geometry* b, TopologyPredicate& pred, const BoundaryNodeRule& bnRule);
+
166 
+
178  static bool relate(const Geometry* a, const Geometry* b, const std::string& imPattern);
+
179 
+
188  static std::unique_ptr<IntersectionMatrix> relate(const Geometry* a, const Geometry* b);
+
189 
+
199  static std::unique_ptr<IntersectionMatrix> relate(const Geometry* a, const Geometry* b, const BoundaryNodeRule& bnRule);
+
200 
+
208  static std::unique_ptr<RelateNG> prepare(const Geometry* a);
+
209 
+
219  static std::unique_ptr<RelateNG> prepare(const Geometry* a, const BoundaryNodeRule& bnRule);
+
220 
+
221 
+
228  std::unique_ptr<IntersectionMatrix> evaluate(const Geometry* b);
+
229 
+
230 
+
241  bool evaluate(const Geometry* b, const std::string& imPattern);
+
242 
+
251  bool evaluate(const Geometry* b, TopologyPredicate& predicate);
+
252 
+
253  static bool intersects(const Geometry* a, const Geometry* b);
+
254  static bool crosses(const Geometry* a, const Geometry* b);
+
255  static bool disjoint(const Geometry* a, const Geometry* b);
+
256  static bool touches(const Geometry* a, const Geometry* b);
+
257  static bool within(const Geometry* a, const Geometry* b);
+
258  static bool contains(const Geometry* a, const Geometry* b);
+
259  static bool overlaps(const Geometry* a, const Geometry* b);
+
260  static bool covers(const Geometry* a, const Geometry* b);
+
261  static bool coveredBy(const Geometry* a, const Geometry* b);
+
262  static bool equalsTopo(const Geometry* a, const Geometry* b);
+
263 
+
264  bool intersects(const Geometry* a);
+
265  bool crosses(const Geometry* a);
+
266  bool disjoint(const Geometry* a);
+
267  bool touches(const Geometry* a);
+
268  bool within(const Geometry* a);
+
269  bool contains(const Geometry* a);
+
270  bool overlaps(const Geometry* a);
+
271  bool covers(const Geometry* a);
+
272  bool coveredBy(const Geometry* a);
+
273  bool equalsTopo(const Geometry* a);
+
274  bool relate(const Geometry* a, const std::string& pat);
+
275  std::unique_ptr<IntersectionMatrix> relate(const Geometry* a);
+
276 
+
277 };
+
278 
+
279 } // namespace geos.operation.relateng
+
280 } // namespace geos.operation
+
281 } // namespace geos
+
282 
+
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
+
geos::algorithm::BoundaryNodeRule::getBoundaryRuleMod2
static const BoundaryNodeRule & getBoundaryRuleMod2()
The Mod-2 Boundary Node Rule (which is the rule specified in the OGC SFS).
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
+
geos::noding::MCIndexSegmentSetMutualIntersector
Intersects two sets of SegmentStrings using a index based on MonotoneChains and a SpatialIndex.
Definition: MCIndexSegmentSetMutualIntersector.h:47
+
geos::operation::relateng::RelateNG
Definition: RelateNG.h:93
+
geos::operation::relateng::RelateNG::relate
static bool relate(const Geometry *a, const Geometry *b, TopologyPredicate &pred)
+
geos::operation::relateng::RelateNG::relate
static bool relate(const Geometry *a, const Geometry *b, TopologyPredicate &pred, const BoundaryNodeRule &bnRule)
+
geos::operation::relateng::RelateNG::evaluate
bool evaluate(const Geometry *b, const std::string &imPattern)
+
geos::operation::relateng::RelateNG::evaluate
bool evaluate(const Geometry *b, TopologyPredicate &predicate)
+
geos::operation::relateng::RelateNG::prepare
static std::unique_ptr< RelateNG > prepare(const Geometry *a)
+
geos::operation::relateng::RelateNG::evaluate
std::unique_ptr< IntersectionMatrix > evaluate(const Geometry *b)
+
geos::operation::relateng::RelateNG::relate
static std::unique_ptr< IntersectionMatrix > relate(const Geometry *a, const Geometry *b)
+
geos::operation::relateng::RelateNG::prepare
static std::unique_ptr< RelateNG > prepare(const Geometry *a, const BoundaryNodeRule &bnRule)
+
geos::operation::relateng::RelateNG::relate
static bool relate(const Geometry *a, const Geometry *b, const std::string &imPattern)
+
geos::operation::relateng::RelateNG::relate
static std::unique_ptr< IntersectionMatrix > relate(const Geometry *a, const Geometry *b, const BoundaryNodeRule &bnRule)
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelateNodeFactory_8h_source.html b/doxygen/RelateNodeFactory_8h_source.html index 98f4f5f977..1f3d309c39 100644 --- a/doxygen/RelateNodeFactory_8h_source.html +++ b/doxygen/RelateNodeFactory_8h_source.html @@ -99,7 +99,7 @@
53 } // namespace geos:operation
54 } // namespace geos
55 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::Node
The node component of a geometry graph.
Definition: geomgraph/Node.h:59
geos::operation::relate::RelateNodeFactory
Used by the geomgraph::NodeMap in a RelateNodeGraph to create RelateNode objects.
Definition: RelateNodeFactory.h:43
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/RelatePointLocator_8h_source.html b/doxygen/RelatePointLocator_8h_source.html new file mode 100644 index 0000000000..0cdb956ac2 --- /dev/null +++ b/doxygen/RelatePointLocator_8h_source.html @@ -0,0 +1,229 @@ + + + + + + + +GEOS: RelatePointLocator.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelatePointLocator.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/algorithm/BoundaryNodeRule.h>
+
19 #include <geos/algorithm/locate/PointOnGeometryLocator.h>
+
20 #include <geos/operation/relateng/AdjacentEdgeLocator.h>
+
21 #include <geos/operation/relateng/LinearBoundary.h>
+
22 #include <geos/geom/Coordinate.h>
+
23 #include <geos/geom/Location.h>
+
24 #include <geos/export.h>
+
25 
+
26 #include <memory>
+
27 #include <vector>
+
28 
+
29 // Forward declarations
+
30 namespace geos {
+
31 namespace algorithm {
+
32  namespace locate {
+
33  // class PointOnGeometryLocator;
+
34  }
+
35 }
+
36 namespace operation {
+
37  namespace relateng {
+
38  // class LinearBoundary;
+
39  // class AdjacentEdgeLocator;
+
40  }
+
41 }
+
42 namespace geom {
+
43  class CoordinateXY;
+
44  class Geometry;
+
45  class LineString;
+
46  class Point;
+
47 }
+
48 }
+
49 
+
50 
+
51 using geos::algorithm::BoundaryNodeRule;
+
52 using geos::algorithm::locate::PointOnGeometryLocator;
+
53 using geos::geom::Coordinate;
+
54 using geos::geom::CoordinateXY;
+
55 using geos::geom::Geometry;
+
56 using geos::geom::LineString;
+
57 using geos::geom::Point;
+
58 using geos::geom::Location;
+
59 
+
60 
+
61 namespace geos { // geos.
+
62 namespace operation { // geos.operation
+
63 namespace relateng { // geos.operation.relateng
+
64 
+
65 
+
86 class GEOS_DLL RelatePointLocator {
+
87 
+
88 private:
+
89 
+
90  // Members
+
91 
+
92  const Geometry* geom;
+
93  bool isPrepared = false;
+
94  const BoundaryNodeRule& boundaryRule;
+
95  std::unique_ptr<AdjacentEdgeLocator> adjEdgeLocator;
+
96  Coordinate::ConstXYSet points;
+
97  std::vector<const LineString *> lines;
+
98  std::vector<const Geometry *> polygons;
+
99  std::vector<std::unique_ptr<PointOnGeometryLocator>> polyLocator;
+
100  std::unique_ptr<LinearBoundary> lineBoundary;
+
101  bool isEmpty;
+
102 
+
103 
+
104 public:
+
105 
+
106  // Constructors
+
107 
+
108  RelatePointLocator(const Geometry* p_geom)
+
109  : RelatePointLocator(p_geom, false, BoundaryNodeRule::getBoundaryRuleMod2())
+
110  {};
+
111 
+
112  RelatePointLocator(const Geometry* p_geom, bool p_isPrepared, const BoundaryNodeRule& p_bnRule)
+
113  : geom(p_geom)
+
114  , isPrepared(p_isPrepared)
+
115  , boundaryRule(p_bnRule)
+
116  {
+
117  init(geom);
+
118  };
+
119 
+
120  void init(const Geometry* p_geom);
+
121 
+
122  bool hasBoundary() const;
+
123 
+
124  void extractElements(const Geometry* geom);
+
125 
+
126  void addPoint(const Point* pt);
+
127 
+
128  void addLine(const LineString* line);
+
129 
+
130  void addPolygonal(const Geometry* polygonal);
+
131 
+
132  Location locate(const CoordinateXY* p);
+
133 
+
134  Location locateLineEnd(const CoordinateXY* p) const;
+
135 
+
136  /*
+
137  * Locates a point which is known to be a node of the geometry
+
138  * (i.e. a point or on an edge).
+
139  *
+
140  * @param p the node point to locate
+
141  * @param parentPolygonal the polygon the point is a node of
+
142  * @return the location of the node point
+
143  */
+
144  Location locateNode(const CoordinateXY* p, const Geometry* parentPolygonal);
+
145 
+
154  int locateNodeWithDim(const CoordinateXY* p, const Geometry* parentPolygonal);
+
155 
+
167  int locateWithDim(const CoordinateXY* p);
+
168 
+
169 
+
170 private:
+
171 
+
172  // Methods
+
173 
+
187  int locateWithDim(const CoordinateXY* p, bool isNode, const Geometry* parentPolygonal);
+
188 
+
189  int computeDimLocation(const CoordinateXY* p, bool isNode, const Geometry* parentPolygonal);
+
190 
+
191  Location locateOnPoints(const CoordinateXY* p) const;
+
192 
+
193  Location locateOnLines(const CoordinateXY* p, bool isNode);
+
194 
+
195  Location locateOnLine(const CoordinateXY* p, /*bool isNode,*/ const LineString* l);
+
196 
+
197  Location locateOnPolygons(const CoordinateXY* p, bool isNode, const Geometry* parentPolygonal);
+
198 
+
199  Location locateOnPolygonal(const CoordinateXY* p,
+
200  bool isNode,
+
201  const Geometry* parentPolygonal,
+
202  std::size_t index);
+
203 
+
204  PointOnGeometryLocator * getLocator(std::size_t index);
+
205 
+
206 
+
207 
+
208 };
+
209 
+
210 } // namespace geos.operation.relateng
+
211 } // namespace geos.operation
+
212 } // namespace geos
+
213 
+
geos::algorithm::BoundaryNodeRule
An interface for rules which determine whether node points which are in boundaries of lineal geometry...
Definition: BoundaryNodeRule.h:50
+
geos::algorithm::BoundaryNodeRule::getBoundaryRuleMod2
static const BoundaryNodeRule & getBoundaryRuleMod2()
The Mod-2 Boundary Node Rule (which is the rule specified in the OGC SFS).
+
geos::algorithm::locate::PointOnGeometryLocator
An interface for classes which determine the Location of points in Polygon or MultiPolygon geometries...
Definition: PointOnGeometryLocator.h:36
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::geom::LineString
Definition: LineString.h:66
+
geos::geom::Point
Definition: Point.h:61
+
geos::operation::relateng::RelatePointLocator
Definition: RelatePointLocator.h:86
+
geos::operation::relateng::RelatePointLocator::locateNodeWithDim
int locateNodeWithDim(const CoordinateXY *p, const Geometry *parentPolygonal)
+
geos::operation::relateng::RelatePointLocator::locateWithDim
int locateWithDim(const CoordinateXY *p)
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelatePredicate_8h_source.html b/doxygen/RelatePredicate_8h_source.html new file mode 100644 index 0000000000..ed055ca2c9 --- /dev/null +++ b/doxygen/RelatePredicate_8h_source.html @@ -0,0 +1,711 @@ + + + + + + + +GEOS: RelatePredicate.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelatePredicate.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/operation/relateng/BasicPredicate.h>
+
20 #include <geos/operation/relateng/IMPatternMatcher.h>
+
21 #include <geos/operation/relateng/IMPredicate.h>
+
22 #include <geos/operation/relateng/RelateGeometry.h>
+
23 #include <geos/geom/Envelope.h>
+
24 #include <geos/export.h>
+
25 
+
26 
+
27 using geos::geom::Envelope;
+
28 using geos::geom::Location;
+
29 
+
30 
+
31 namespace geos { // geos.
+
32 namespace operation { // geos.operation.
+
33 namespace relateng { // geos.operation.relateng
+
34 
+
35 
+
36 class GEOS_DLL RelatePredicate {
+
37 
+
38 public:
+
39 
+
40 /************************************************************************
+
41  *
+
42  * Creates a predicate to determine whether two geometries intersect.
+
43  *
+
44  * The intersects predicate has the following equivalent definitions:
+
45  *
+
46  * * The two geometries have at least one point in common
+
47  * * The DE-9IM Intersection Matrix for the two geometries matches
+
48  * at least one of the patterns
+
49  *
+
50  * [T********]
+
51  * [*T*******]
+
52  * [***T*****]
+
53  * [****T****]
+
54  *
+
55  * disjoint() = false
+
56  * (intersects is the inverse of disjoint)
+
57  *
+
58  * @return the predicate instance
+
59  *
+
60  * @see disjoint()
+
61  */
+
62 class IntersectsPredicate : public BasicPredicate {
+
63 
+
64 public:
+
65 
+
66  std::string name() const override {
+
67  return std::string("intersects");
+
68  }
+
69 
+
70  bool requireSelfNoding() const override {
+
71  //-- self-noding is not required to check for a simple interaction
+
72  return false;
+
73  }
+
74 
+
75  bool requireExteriorCheck(bool isSourceA) const override {
+
76  (void)isSourceA;
+
77  //-- intersects only requires testing interaction
+
78  return false;
+
79  }
+
80 
+
81  void init(const Envelope& envA, const Envelope& envB) override {
+
82  require(envA.intersects(envB));
+
83  }
+
84 
+
85  void updateDimension(Location locA, Location locB, int dimension) override {
+
86  (void)dimension;
+
87  setValueIf(true, isIntersection(locA, locB));
+
88  }
+
89 
+
90  void finish() override {
+
91  //-- if no intersecting locations were found
+
92  setValue(false);
+
93  }
+
94 
+
95 };
+
96 
+
97 static std::unique_ptr<BasicPredicate> intersects();
+
98 
+
99 /************************************************************************
+
100  *
+
101  * Creates a predicate to determine whether two geometries are disjoint.
+
102  *
+
103  * The disjoint predicate has the following equivalent definitions:
+
104  *
+
105  * * The two geometries have no point in common
+
106  * * The DE-9IM Intersection Matrix for the two geometries matches
+
107  * [FF*FF****]
+
108  * * intersects() = false
+
109  * (disjoint is the inverse of intersects)
+
110  *
+
111  * @return the predicate instance
+
112  *
+
113  * @see intersects()
+
114  */
+
115 class DisjointPredicate : public BasicPredicate {
+
116 
+
117  std::string name() const override {
+
118  return std::string("disjoint");
+
119  }
+
120 
+
121  bool requireSelfNoding() const override {
+
122  //-- self-noding is not required to check for a simple interaction
+
123  return false;
+
124  }
+
125 
+
126  bool requireInteraction() const override {
+
127  //-- ensure entire matrix is computed
+
128  return false;
+
129  }
+
130 
+
131  bool requireExteriorCheck(bool isSourceA) const override {
+
132  (void)isSourceA;
+
133  //-- intersects only requires testing interaction
+
134  return false;
+
135  }
+
136 
+
137  void init(const Envelope& envA, const Envelope& envB) override {
+
138  setValueIf(true, envA.disjoint(envB));
+
139  }
+
140 
+
141  void updateDimension(Location locA, Location locB, int dimension) override {
+
142  (void)dimension;
+
143  setValueIf(false, isIntersection(locA, locB));
+
144  }
+
145 
+
146  void finish() override {
+
147  //-- if no intersecting locations were found
+
148  setValue(true);
+
149  }
+
150 };
+
151 
+
152 static std::unique_ptr<BasicPredicate> disjoint();
+
153 
+
154 /************************************************************************
+
155  * Creates a predicate to determine whether a geometry contains another geometry.
+
156  *
+
157  * The contains predicate has the following equivalent definitions:
+
158  *
+
159  * * Every point of the other geometry is a point of this geometry,
+
160  * and the interiors of the two geometries have at least one point in common.
+
161  * * The DE-9IM Intersection Matrix for the two geometries matches
+
162  * the pattern
+
163  * [T*****FF*]
+
164  * * within(B, A) = true
+
165  * (contains is the converse of within)
+
166  *
+
167  * An implication of the definition is that "Geometries do not
+
168  * contain their boundary". In other words, if a geometry A is a subset of
+
169  * the points in the boundary of a geometry B, B.contains(A) = false.
+
170  * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
+
171  * For a predicate with similar behavior but avoiding
+
172  * this subtle limitation, see covers().
+
173  *
+
174  * @return the predicate instance
+
175  *
+
176  * @see within()
+
177  */
+
178 class ContainsPredicate : public IMPredicate {
+
179 
+
180  std::string name() const override {
+
181  return std::string("contains");
+
182  }
+
183 
+
184  bool requireCovers(bool isSourceA) override {
+
185  return isSourceA == RelateGeometry::GEOM_A;
+
186  }
+
187 
+
188  bool requireExteriorCheck(bool isSourceA) const override {
+
189  //-- only need to check B against Exterior of A
+
190  return isSourceA == RelateGeometry::GEOM_B;
+
191  }
+
192 
+
193  void init(int _dimA, int _dimB) override {
+
194  IMPredicate::init(_dimA, _dimB);
+
195  require(isDimsCompatibleWithCovers(dimA, dimB));
+
196  }
+
197 
+
198  void init(const Envelope& envA, const Envelope& envB) override {
+
199  BasicPredicate::requireCovers(envA, envB);
+
200  }
+
201 
+
202  bool isDetermined() const override {
+
203  return intersectsExteriorOf(RelateGeometry::GEOM_A);
+
204  }
+
205 
+
206  bool valueIM() override {
+
207  return intMatrix.isContains();
+
208  }
+
209 };
+
210 
+
211 static std::unique_ptr<IMPredicate> contains();
+
212 
+
213 
+
214 
+
215 /************************************************************************
+
216  * Creates a predicate to determine whether a geometry is within another geometry.
+
217  *
+
218  * The within predicate has the following equivalent definitions:
+
219  *
+
220  * * Every point of this geometry is a point of the other geometry,
+
221  * and the interiors of the two geometries have at least one point in common.
+
222  * * The DE-9IM Intersection Matrix for the two geometries matches
+
223  * [T*F**F***]
+
224  * * contains(B, A) = true
+
225  * (within is the converse of contains())
+
226  *
+
227  * An implication of the definition is that
+
228  * "The boundary of a Geometry is not within the Geometry".
+
229  * In other words, if a geometry A is a subset of
+
230  * the points in the boundary of a geometry B, within(B, A) = false
+
231  * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
+
232  * For a predicate with similar behavior but avoiding
+
233  * this subtle limitation, see coveredimBy().
+
234  *
+
235  * @return the predicate instance
+
236  *
+
237  * @see #contains()
+
238  */
+
239 class WithinPredicate : public IMPredicate {
+
240 
+
241  std::string name() const override {
+
242  return std::string("within");
+
243  }
+
244 
+
245  bool requireCovers(bool isSourceA) override {
+
246  return isSourceA == RelateGeometry::GEOM_B;
+
247  }
+
248 
+
249  bool requireExteriorCheck(bool isSourceA) const override {
+
250  //-- only need to check B against Exterior of A
+
251  return isSourceA == RelateGeometry::GEOM_A;
+
252  }
+
253 
+
254  void init(int _dimA, int _dimB) override {
+
255  IMPredicate::init(_dimA, _dimB);
+
256  require(isDimsCompatibleWithCovers(dimB, dimA));
+
257  }
+
258 
+
259  void init(const Envelope& envA, const Envelope& envB) override {
+
260  BasicPredicate::requireCovers(envB, envA);
+
261  }
+
262 
+
263  bool isDetermined() const override {
+
264  return intersectsExteriorOf(RelateGeometry::GEOM_B);
+
265  }
+
266 
+
267  bool valueIM() override {
+
268  return intMatrix.isWithin();
+
269  }
+
270 };
+
271 
+
272 static std::unique_ptr<IMPredicate> within();
+
273 
+
274 
+
275 
+
276 /************************************************************************
+
277  * Creates a predicate to determine whether a geometry covers another geometry.
+
278  *
+
279  * The covers predicate has the following equivalent definitions:
+
280  *
+
281  * Every point of the other geometry is a point of this geometry.
+
282  * The DE-9IM Intersection Matrix for the two geometries matches
+
283  * at least one of the following patterns:
+
284  *
+
285  * * [T*****FF*]
+
286  * * [*T****FF*]
+
287  * * [***T**FF*]
+
288  * * [****T*FF*]
+
289  *
+
290  * coveredimBy(b, a) = true
+
291  * (covers is the converse of coveredimBy())
+
292  *
+
293  * If either geometry is empty, the value of this predicate is false.
+
294  *
+
295  * This predicate is similar to contains(),
+
296  * but is more inclusive (i.e. returns true for more cases).
+
297  * In particular, unlike contains it does not distinguish between
+
298  * points in the boundary and in the interior of geometries.
+
299  * For most cases, covers should be used in preference to contains.
+
300  * As an added benefit, covers is more amenable to optimization,
+
301  * and hence should be more performant.
+
302  *
+
303  * @return the predicate instance
+
304  *
+
305  * @see #coveredimBy()
+
306  */
+
307 class CoversPredicate : public IMPredicate {
+
308 
+
309  std::string name() const override {
+
310  return std::string("covers");
+
311  }
+
312 
+
313  bool requireCovers(bool isSourceA) override {
+
314  return isSourceA == RelateGeometry::GEOM_A;
+
315  }
+
316 
+
317  bool requireExteriorCheck(bool isSourceA) const override {
+
318  //-- only need to check B against Exterior of A
+
319  return isSourceA == RelateGeometry::GEOM_B;
+
320  }
+
321 
+
322  void init(int _dimA, int _dimB) override {
+
323  IMPredicate::init(_dimA, _dimB);
+
324  require(isDimsCompatibleWithCovers(dimA, dimB));
+
325  }
+
326 
+
327  void init(const Envelope& envA, const Envelope& envB) override {
+
328  BasicPredicate::requireCovers(envA, envB);
+
329 
+
330  }
+
331 
+
332  bool isDetermined() const override {
+
333  return intersectsExteriorOf(RelateGeometry::GEOM_A);
+
334  }
+
335 
+
336  bool valueIM() override {
+
337  return intMatrix.isCovers();
+
338  }
+
339 };
+
340 
+
341 static std::unique_ptr<IMPredicate> covers();
+
342 
+
343 
+
344 /************************************************************************
+
345 * Creates a predicate to determine whether a geometry is covered
+
346 * by another geometry.
+
347 *
+
348 * The coveredimBy predicate has the following equivalent definitions:
+
349 *
+
350 * Every point of this geometry is a point of the other geometry.
+
351 * The DE-9IM Intersection Matrix for the two geometries matches
+
352 * at least one of the following patterns:
+
353 *
+
354 * [T*F**F***]
+
355 * [*TF**F***]
+
356 * [**FT*F***]
+
357 * [**F*TF***]
+
358 *
+
359 * covers(B, A) = true
+
360 * (coveredimBy is the converse of covers())
+
361 *
+
362 * If either geometry is empty, the value of this predicate is false.
+
363 *
+
364 * This predicate is similar to within(),
+
365 * but is more inclusive (i.e. returns true for more cases).
+
366 *
+
367 * @return the predicate instance
+
368 *
+
369 * @see #covers()
+
370 */
+
371 class CoveredByPredicate : public IMPredicate {
+
372 
+
373  std::string name() const override {
+
374  return std::string("coveredBy");
+
375  }
+
376 
+
377  bool requireCovers(bool isSourceA) override {
+
378  return isSourceA == RelateGeometry::GEOM_B;
+
379  }
+
380 
+
381  bool requireExteriorCheck(bool isSourceA) const override {
+
382  //-- only need to check B against Exterior of A
+
383  return isSourceA == RelateGeometry::GEOM_A;
+
384  }
+
385 
+
386  void init(int _dimA, int _dimB) override {
+
387  IMPredicate::init(_dimA, _dimB);
+
388  require(isDimsCompatibleWithCovers(dimB, dimA));
+
389  }
+
390 
+
391  void init(const Envelope& envA, const Envelope& envB) override {
+
392  BasicPredicate::requireCovers(envB, envA);
+
393  }
+
394 
+
395  bool isDetermined() const override {
+
396  return intersectsExteriorOf(RelateGeometry::GEOM_B);
+
397  }
+
398 
+
399  bool valueIM() override {
+
400  return intMatrix.isCoveredBy();
+
401  }
+
402 
+
403 };
+
404 
+
405 static std::unique_ptr<IMPredicate> coveredBy();
+
406 
+
407 
+
408 /************************************************************************
+
409 * Creates a predicate to determine whether a geometry crosses another geometry.
+
410 *
+
411 * The crosses predicate has the following equivalent definitions:
+
412 *
+
413 * The geometries have some but not all interior points in common.
+
414 * The DE-9IM Intersection Matrix for the two geometries matches
+
415 * one of the following patterns:
+
416 *
+
417 * [T*T******] (for P/L, P/A, and L/A cases)
+
418 * [T*****T**] (for L/P, A/P, and A/L cases)
+
419 * [0********] (for L/L cases)
+
420 *
+
421 *
+
422 * For the A/A and P/P cases this predicate returns false.
+
423 *
+
424 * The SFS defined this predicate only for P/L, P/A, L/L, and L/A cases.
+
425 * To make the relation symmetric
+
426 * JTS extends the definition to apply to L/P, A/P and A/L cases as well.
+
427 *
+
428 * @return the predicate instance
+
429 */
+
430 
+
431 class CrossesPredicate : public IMPredicate {
+
432 
+
433  std::string name() const override {
+
434  return std::string("crosses");
+
435  }
+
436 
+
437  void init(int _dimA, int _dimB) override {
+
438  IMPredicate::init(_dimA, _dimB);
+
439  bool isBothPointsOrAreas =
+
440  (dimA == Dimension::P && dimB == Dimension::P) ||
+
441  (dimA == Dimension::A && dimB == Dimension::A);
+
442  require(!isBothPointsOrAreas);
+
443  }
+
444 
+
445  bool isDetermined() const override {
+
446  if (dimA == Dimension::L && dimB == Dimension::L) {
+
447  //-- L/L interaction can only be dim = P
+
448  if (getDimension(Location::INTERIOR, Location::INTERIOR) > Dimension::P)
+
449  return true;
+
450  }
+
451  else if (dimA < dimB) {
+
452  if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
+
453  isIntersects(Location::INTERIOR, Location::EXTERIOR)) {
+
454  return true;
+
455  }
+
456  }
+
457  else if (dimA > dimB) {
+
458  if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
+
459  isIntersects(Location::EXTERIOR, Location::INTERIOR)) {
+
460  return true;
+
461  }
+
462  }
+
463  return false;
+
464  }
+
465 
+
466  bool valueIM() override {
+
467  return intMatrix.isCrosses(dimA, dimB);
+
468  }
+
469 };
+
470 
+
471 static std::unique_ptr<IMPredicate> crosses();
+
472 
+
473 
+
474 /************************************************************************
+
475 * Creates a predicate to determine whether two geometries are
+
476 * topologically equal.
+
477 *
+
478 * The equals predicate has the following equivalent definitions:
+
479 *
+
480 * The two geometries have at least one point in common,
+
481 * and no point of either geometry lies in the exterior of the other geometry.
+
482 * The DE-9IM Intersection Matrix for the two geometries matches
+
483 * the pattern T*F**FFF*
+
484 *
+
485 * @return the predicate instance
+
486 */
+
487 class EqualsTopoPredicate : public IMPredicate {
+
488 
+
489  std::string name() const override {
+
490  return std::string("equals");
+
491  }
+
492 
+
493  bool requireInteraction() const override {
+
494  //-- allow EMPTY = EMPTY
+
495  return false;
+
496  };
+
497 
+
498  void init(int _dimA, int _dimB) override {
+
499  IMPredicate::init(_dimA, _dimB);
+
500  //-- don't require equal dims, because EMPTY = EMPTY for all dims
+
501  }
+
502 
+
503  void init(const Envelope& envA, const Envelope& envB) override {
+
504  //-- handle EMPTY = EMPTY cases
+
505  setValueIf(true, envA.isNull() && envB.isNull());
+
506 
+
507  require(envA.equals(&envB));
+
508  }
+
509 
+
510  bool isDetermined() const override {
+
511  bool isEitherExteriorIntersects =
+
512  isIntersects(Location::INTERIOR, Location::EXTERIOR) ||
+
513  isIntersects(Location::BOUNDARY, Location::EXTERIOR) ||
+
514  isIntersects(Location::EXTERIOR, Location::INTERIOR) ||
+
515  isIntersects(Location::EXTERIOR, Location::BOUNDARY);
+
516 
+
517  return isEitherExteriorIntersects;
+
518  }
+
519 
+
520  bool valueIM() override {
+
521  return intMatrix.isEquals(dimA, dimB);
+
522  }
+
523 
+
524 };
+
525 
+
526 static std::unique_ptr<IMPredicate> equalsTopo();
+
527 
+
528 
+
529 /************************************************************************
+
530  * Creates a predicate to determine whether a geometry overlaps another geometry.
+
531  *
+
532  * The overlaps predicate has the following equivalent definitions:
+
533  *
+
534  * The geometries have at least one point each not shared by the other
+
535  * (or equivalently neither covers the other),
+
536  * they have the same dimension,
+
537  * and the intersection of the interiors of the two geometries has
+
538  * the same dimension as the geometries themselves.
+
539  * The DE-9IM Intersection Matrix for the two geometries matches
+
540  * [T*T***T**] (for P/P and A/A cases)
+
541  * or [1*T***T**] (for L/L cases)
+
542  *
+
543  * If the geometries are of different dimension this predicate returns false.
+
544  * This predicate is symmetric.
+
545  *
+
546  * @return the predicate instance
+
547  */
+
548 class OverlapsPredicate : public IMPredicate {
+
549 
+
550  std::string name() const override {
+
551  return std::string("overlaps");
+
552  }
+
553 
+
554  void init(int _dimA, int _dimB) override {
+
555  IMPredicate::init(_dimA, _dimB);
+
556  require(dimA == dimB);
+
557  }
+
558 
+
559  bool isDetermined() const override {
+
560  if (dimA == Dimension::A || dimA == Dimension::P) {
+
561  if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
+
562  isIntersects(Location::INTERIOR, Location::EXTERIOR) &&
+
563  isIntersects(Location::EXTERIOR, Location::INTERIOR))
+
564  return true;
+
565  }
+
566  if (dimA == Dimension::L) {
+
567  if (isDimension(Location::INTERIOR, Location::INTERIOR, Dimension::L) &&
+
568  isIntersects(Location::INTERIOR, Location::EXTERIOR) &&
+
569  isIntersects(Location::EXTERIOR, Location::INTERIOR))
+
570  return true;
+
571  }
+
572  return false;
+
573  }
+
574 
+
575  bool valueIM() override {
+
576  return intMatrix.isOverlaps(dimA, dimB);
+
577  }
+
578 };
+
579 
+
580 static std::unique_ptr<IMPredicate> overlaps();
+
581 
+
582 
+
583 
+
584 
+
585 
+
586 /************************************************************************
+
587 * Creates a predicate to determine whether a geometry touches another geometry.
+
588 *
+
589 * The touches predicate has the following equivalent definitions:
+
590 *
+
591 * The geometries have at least one point in common,
+
592 * but their interiors do not intersect.
+
593 * The DE-9IM Intersection Matrix for the two geometries matches
+
594 * at least one of the following patterns
+
595 *
+
596 * [FT*******]
+
597 * [F**T*****]
+
598 * [F***T****]
+
599 *
+
600 *
+
601 * If both geometries have dimension 0, the predicate returns false,
+
602 * since points have only interiors.
+
603 * This predicate is symmetric.
+
604 *
+
605 * @return the predicate instance
+
606 */
+
607 class TouchesPredicate : public IMPredicate {
+
608 
+
609  std::string name() const override {
+
610  return std::string("touches");
+
611  }
+
612 
+
613  void init(int _dimA, int _dimB) override {
+
614  IMPredicate::init(_dimA, _dimB);
+
615  bool isBothPoints = (dimA == 0 && dimB == 0);
+
616  require(! isBothPoints);
+
617  }
+
618 
+
619  bool isDetermined() const override {
+
620  bool isInteriorsIntersects = isIntersects(Location::INTERIOR, Location::INTERIOR);
+
621  return isInteriorsIntersects;
+
622  }
+
623 
+
624  bool valueIM() override {
+
625  return intMatrix.isTouches(dimA, dimB);
+
626  }
+
627 };
+
628 
+
629 static std::unique_ptr<IMPredicate> touches();
+
630 
+
639 static std::unique_ptr<TopologyPredicate> matches(const std::string& imPattern)
+
640 {
+
641  return std::unique_ptr<TopologyPredicate>(new IMPatternMatcher(imPattern));
+
642 }
+
643 
+
644 
+
645 
+
646 }; // !RelatePredicate
+
647 
+
648 
+
649 } // namespace geos.operation.relateng
+
650 } // namespace geos.operation
+
651 } // namespace geos
+
652 
+
geos::geom::Dimension::A
@ A
Dimension value of a surface (2).
Definition: Dimension.h:46
+
geos::geom::Dimension::L
@ L
Dimension value of a curve (1).
Definition: Dimension.h:43
+
geos::geom::Dimension::P
@ P
Dimension value of a point (0).
Definition: Dimension.h:40
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::Envelope::equals
bool equals(const Envelope *other) const
Returns true if the Envelope other spatially equals this Envelope.
+
geos::geom::Envelope::intersects
static bool intersects(const CoordinateXY &p1, const CoordinateXY &p2, const CoordinateXY &q)
Test the point q to see whether it intersects the Envelope defined by p1-p2.
+
geos::geom::Envelope::isNull
bool isNull(void) const
Returns true if this Envelope is a "null" envelope.
Definition: Envelope.h:252
+
geos::geom::Envelope::disjoint
bool disjoint(const Envelope &other) const
Definition: Envelope.h:596
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+ +
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RelateSegmentString_8h_source.html b/doxygen/RelateSegmentString_8h_source.html new file mode 100644 index 0000000000..39d82ac5e3 --- /dev/null +++ b/doxygen/RelateSegmentString_8h_source.html @@ -0,0 +1,188 @@ + + + + + + + +GEOS: RelateSegmentString.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
RelateSegmentString.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/noding/BasicSegmentString.h>
+
19 #include <geos/export.h>
+
20 
+
21 
+
22 #include <string>
+
23 #include <sstream>
+
24 
+
25 
+
26 // Forward declarations
+
27 namespace geos {
+
28 namespace geom {
+
29  class CoordinateXY;
+
30  class CoordinateSequence;
+
31  class Geometry;
+
32 }
+
33 namespace operation {
+
34 namespace relateng {
+
35  class RelateGeometry;
+
36  class NodeSection;
+
37 }
+
38 }
+
39 }
+
40 
+
41 
+
42 using geos::noding::BasicSegmentString;
+
43 using geos::geom::Geometry;
+
44 using geos::geom::CoordinateXY;
+
45 using geos::geom::CoordinateSequence;
+
46 
+
47 
+
48 namespace geos { // geos.
+
49 namespace operation { // geos.operation
+
50 namespace relateng { // geos.operation.relateng
+
51 
+
52 
+
53 
+
54 class GEOS_DLL RelateSegmentString : public BasicSegmentString {
+
55 
+
56 private:
+
57 
+
58  // Members
+
59  bool m_isA;
+
60  int m_dimension;
+
61  int m_id;
+
62  int m_ringId;
+
63  const RelateGeometry* m_inputGeom;
+
64  const Geometry* m_parentPolygonal = nullptr;
+
65 
+
66  // Constructor
+
67  RelateSegmentString(
+
68  const CoordinateSequence* pts,
+
69  bool isA,
+
70  int dimension,
+
71  int id,
+
72  int ringId,
+
73  const Geometry* poly,
+
74  const RelateGeometry* inputGeom)
+
75  : BasicSegmentString(const_cast<CoordinateSequence*>(pts), nullptr)
+
76  , m_isA(isA)
+
77  , m_dimension(dimension)
+
78  , m_id(id)
+
79  , m_ringId(ringId)
+
80  , m_inputGeom(inputGeom)
+
81  , m_parentPolygonal(poly)
+
82  {}
+
83 
+
84 
+
85  // Methods
+
86 
+
87  static const RelateSegmentString* createSegmentString(
+
88  const CoordinateSequence* pts,
+
89  bool isA, int dim, int elementId, int ringId,
+
90  const Geometry* poly, const RelateGeometry* parent);
+
91 
+
99  const CoordinateXY* prevVertex(
+
100  std::size_t segIndex,
+
101  const CoordinateXY* pt) const;
+
102 
+
109  const CoordinateXY* nextVertex(
+
110  std::size_t segIndex,
+
111  const CoordinateXY* pt) const;
+
112 
+
113 
+
114 public:
+
115 
+
116  static const RelateSegmentString* createLine(
+
117  const CoordinateSequence* pts,
+
118  bool isA, int elementId,
+
119  const RelateGeometry* parent);
+
120 
+
121  static const RelateSegmentString* createRing(
+
122  const CoordinateSequence* pts,
+
123  bool isA, int elementId, int ringId,
+
124  const Geometry* poly, const RelateGeometry* parent);
+
125 
+
126  bool isA() const;
+
127 
+
128  const RelateGeometry* getGeometry() const;
+
129 
+
130  const Geometry* getPolygonal() const;
+
131 
+
132  NodeSection* createNodeSection(std::size_t segIndex, const CoordinateXY intPt) const;
+
133 
+
148  bool isContainingSegment(std::size_t segIndex, const CoordinateXY* pt) const;
+
149 
+
150 };
+
151 
+
152 } // namespace geos.operation.relateng
+
153 } // namespace geos.operation
+
154 } // namespace geos
+
155 
+
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
+
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
+
geos::noding::BasicSegmentString
Represents a list of contiguous line segments, and supports noding the segments.
Definition: BasicSegmentString.h:44
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/RightmostEdgeFinder_8h_source.html b/doxygen/RightmostEdgeFinder_8h_source.html index 1712a9be18..b4a9fa3fba 100644 --- a/doxygen/RightmostEdgeFinder_8h_source.html +++ b/doxygen/RightmostEdgeFinder_8h_source.html @@ -138,7 +138,7 @@
103 } // namespace geos::operation
104 } // namespace geos
105 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geomgraph::DirectedEdge
A directed EdgeEnd.
Definition: geomgraph/DirectedEdge.h:42
geos::operation::buffer::RightmostEdgeFinder
A RightmostEdgeFinder find the geomgraph::DirectedEdge in a list which has the highest coordinate,...
Definition: RightmostEdgeFinder.h:46
geos::operation::buffer::RightmostEdgeFinder::findEdge
void findEdge(std::vector< geomgraph::DirectedEdge * > *dirEdgeList)
Note that only Forward DirectedEdges will be checked.
diff --git a/doxygen/RingClipper_8h_source.html b/doxygen/RingClipper_8h_source.html index 5beceddb38..c1bb8cd61b 100644 --- a/doxygen/RingClipper_8h_source.html +++ b/doxygen/RingClipper_8h_source.html @@ -121,7 +121,7 @@
111 } // namespace geos
112 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::operation::overlayng::RingClipper
Definition: RingClipper.h:64
geos::operation::overlayng::RingClipper::clip
std::unique_ptr< CoordinateSequence > clip(const CoordinateSequence *cs) const
diff --git a/doxygen/RingHull_8h_source.html b/doxygen/RingHull_8h_source.html index e379641bc0..c0c3be650c 100644 --- a/doxygen/RingHull_8h_source.html +++ b/doxygen/RingHull_8h_source.html @@ -229,7 +229,7 @@
208 } // geos::simplify
209 } // geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::LineString
Definition: LineString.h:66
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
diff --git a/doxygen/RobustClipEnvelopeComputer_8h_source.html b/doxygen/RobustClipEnvelopeComputer_8h_source.html index 75d92c0c43..f6b89c8f89 100644 --- a/doxygen/RobustClipEnvelopeComputer_8h_source.html +++ b/doxygen/RobustClipEnvelopeComputer_8h_source.html @@ -122,7 +122,7 @@
82 } // namespace geos.operation
83 } // namespace geos
84 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryCollection
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:51
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/ScaledNoder_8h_source.html b/doxygen/ScaledNoder_8h_source.html index c41ee945a1..ef12177772 100644 --- a/doxygen/ScaledNoder_8h_source.html +++ b/doxygen/ScaledNoder_8h_source.html @@ -169,7 +169,7 @@
130 #pragma warning(pop)
131 #endif
132 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::Noder
Computes all intersections between segments in a set of SegmentString.
Definition: Noder.h:46
geos::noding::ScaledNoder
Wraps a Noder and transforms its input into the integer domain.
Definition: ScaledNoder.h:58
geos::noding::ScaledNoder::computeNodes
void computeNodes(std::vector< SegmentString * > *inputSegStr) override
Computes the noding for a collection of SegmentStrings.
diff --git a/doxygen/SegmentIntersectionDetector_8h_source.html b/doxygen/SegmentIntersectionDetector_8h_source.html index ffdf2955c6..3e9566882d 100644 --- a/doxygen/SegmentIntersectionDetector_8h_source.html +++ b/doxygen/SegmentIntersectionDetector_8h_source.html @@ -179,7 +179,7 @@
177 
geos::algorithm::LineIntersector
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:53
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::SegmentIntersectionDetector
Detects and records an intersection between two SegmentStrings, if one exists.
Definition: SegmentIntersectionDetector.h:41
geos::noding::SegmentIntersectionDetector::hasIntersection
bool hasIntersection() const
Tests whether an intersection was found.
Definition: SegmentIntersectionDetector.h:94
geos::noding::SegmentIntersectionDetector::isDone
bool isDone() const override
Reports whether the client of this class needs to continue testing all intersections in an arrangemen...
Definition: SegmentIntersectionDetector.h:146
diff --git a/doxygen/SegmentPointComparator_8h_source.html b/doxygen/SegmentPointComparator_8h_source.html index fdd447f3ea..b4f0cf4112 100644 --- a/doxygen/SegmentPointComparator_8h_source.html +++ b/doxygen/SegmentPointComparator_8h_source.html @@ -148,7 +148,7 @@
118 } // namespace geos.noding
119 } // namespace geos
120 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::noding::SegmentPointComparator
Implements a robust method of comparing the relative position of two points along the same segment.
Definition: SegmentPointComparator.h:39
geos::noding::SegmentPointComparator::compare
static int compare(int octant, const geom::Coordinate &p0, const geom::Coordinate &p1)
Compares two Coordinates for their relative position along a segment lying in the specified Octant.
Definition: SegmentPointComparator.h:52
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/SegmentString_8h_source.html b/doxygen/SegmentString_8h_source.html index 22bf7b2250..ee16cea978 100644 --- a/doxygen/SegmentString_8h_source.html +++ b/doxygen/SegmentString_8h_source.html @@ -145,41 +145,63 @@
131  return ss.getSegmentOctant(index);
132  }
133 
-
134  bool isClosed() const {
-
135  return seq->front<geom::CoordinateXY>().equals(seq->back<geom::CoordinateXY>());
-
136  }
-
137 
-
138  virtual std::ostream& print(std::ostream& os) const;
-
139 
-
140 protected:
-
141  geom::CoordinateSequence* seq;
-
142 
-
143 private:
-
144  const void* context;
-
145 
-
146  static int safeOctant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
-
147  {
-
148  if(p0.equals2D(p1)) {
-
149  return 0;
-
150  }
-
151  return Octant::octant(p0, p1);
-
152  };
-
153 
-
154  // Declare type as noncopyable
-
155  SegmentString(const SegmentString& other) = delete;
-
156  SegmentString& operator=(const SegmentString& rhs) = delete;
-
157 };
-
158 
-
159 std::ostream& operator<< (std::ostream& os, const SegmentString& ss);
-
160 
-
161 } // namespace geos.noding
-
162 } // namespace geos
-
163 
+
142  const geom::CoordinateXY& nextInRing(std::size_t index) const
+
143  {
+
144  std::size_t nextIndex = index + 1;
+
145  if (nextIndex > size() - 1) {
+
146  nextIndex = 1;
+
147  }
+
148  return getCoordinate(nextIndex);
+
149  }
+
150 
+
159  const geom::CoordinateXY& prevInRing(std::size_t index) const
+
160  {
+
161  std::size_t prevIndex;
+
162  if (index == 0)
+
163  prevIndex = size() - 2;
+
164  else
+
165  prevIndex = index - 1;
+
166  return getCoordinate( prevIndex );
+
167  }
+
168 
+
169 
+
170  bool isClosed() const {
+
171  return seq->front<geom::CoordinateXY>().equals(seq->back<geom::CoordinateXY>());
+
172  }
+
173 
+
174  virtual std::ostream& print(std::ostream& os) const;
+
175 
+
176 protected:
+
177  geom::CoordinateSequence* seq;
+
178 
+
179 private:
+
180  const void* context;
+
181 
+
182  static int safeOctant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+
183  {
+
184  if(p0.equals2D(p1)) {
+
185  return 0;
+
186  }
+
187  return Octant::octant(p0, p1);
+
188  };
+
189 
+
190  // Declare type as noncopyable
+
191  SegmentString(const SegmentString& other) = delete;
+
192  SegmentString& operator=(const SegmentString& rhs) = delete;
+
193 };
+
194 
+
195 std::ostream& operator<< (std::ostream& os, const SegmentString& ss);
+
196 
+
197 } // namespace geos.noding
+
198 } // namespace geos
+
199 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
geos::noding::Octant::octant
static int octant(double dx, double dy)
geos::noding::SegmentString
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:47
geos::noding::SegmentString::SegmentString
SegmentString(const void *newContext, geom::CoordinateSequence *newSeq)
Construct a SegmentString.
Definition: SegmentString.h:60
+
geos::noding::SegmentString::nextInRing
const geom::CoordinateXY & nextInRing(std::size_t index) const
Definition: SegmentString.h:142
geos::noding::SegmentString::getSegmentOctant
int getSegmentOctant(std::size_t index) const
Gets the octant of the segment starting at vertex index.
Definition: SegmentString.h:121
+
geos::noding::SegmentString::prevInRing
const geom::CoordinateXY & prevInRing(std::size_t index) const
Definition: SegmentString.h:159
geos::noding::SegmentString::getCoordinates
const geom::CoordinateSequence * getCoordinates() const
Return a pointer to the CoordinateSequence associated with this SegmentString.
Definition: SegmentString.h:106
geos::noding::SegmentString::getData
const void * getData() const
Gets the user-defined data for this segment string.
Definition: SegmentString.h:75
geos::noding::SegmentString::setData
void setData(const void *data)
Sets the user-defined data for this segment string.
Definition: SegmentString.h:86
diff --git a/doxygen/SimpleEdgeSetIntersector_8h_source.html b/doxygen/SimpleEdgeSetIntersector_8h_source.html index 352dccd0a7..4f37bc26b4 100644 --- a/doxygen/SimpleEdgeSetIntersector_8h_source.html +++ b/doxygen/SimpleEdgeSetIntersector_8h_source.html @@ -107,7 +107,7 @@
63 } // namespace geos
64 
geos::geomgraph::Edge
Definition: geomgraph/Edge.h:63
-
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: EdgeSetIntersector.h:40
+
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: geomgraph/index/EdgeSetIntersector.h:40
geos::geomgraph::index::SegmentIntersector
Computes the intersection of line segments, and adds the intersection to the edges containing the seg...
Definition: geomgraph/index/SegmentIntersector.h:46
geos::geomgraph::index::SimpleEdgeSetIntersector
Finds all intersections in one or two sets of edges, using the straightforward method of comparing al...
Definition: SimpleEdgeSetIntersector.h:42
geos::geomgraph::index::SimpleEdgeSetIntersector::computeIntersections
void computeIntersections(std::vector< Edge * > *edges0, std::vector< Edge * > *edges1, SegmentIntersector *si) override
Computes all mutual intersections between two sets of edges.
diff --git a/doxygen/SimpleMCSweepLineIntersector_8h_source.html b/doxygen/SimpleMCSweepLineIntersector_8h_source.html index 536848e619..abd607812c 100644 --- a/doxygen/SimpleMCSweepLineIntersector_8h_source.html +++ b/doxygen/SimpleMCSweepLineIntersector_8h_source.html @@ -147,7 +147,7 @@
107 #endif
108 
geos::geomgraph::Edge
Definition: geomgraph/Edge.h:63
-
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: EdgeSetIntersector.h:40
+
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: geomgraph/index/EdgeSetIntersector.h:40
geos::geomgraph::index::SegmentIntersector
Computes the intersection of line segments, and adds the intersection to the edges containing the seg...
Definition: geomgraph/index/SegmentIntersector.h:46
geos::geomgraph::index::SimpleMCSweepLineIntersector
Finds all intersections in one or two sets of edges, using an x-axis sweepline algorithm in conjuncti...
Definition: SimpleMCSweepLineIntersector.h:52
geos::geomgraph::index::SimpleMCSweepLineIntersector::computeIntersections
void computeIntersections(std::vector< Edge * > *edges, SegmentIntersector *si, bool testAllSegments) override
Computes all self-intersections between edges in a set of edges, allowing client to choose whether se...
diff --git a/doxygen/SimpleSweepLineIntersector_8h_source.html b/doxygen/SimpleSweepLineIntersector_8h_source.html index 026fa8ca75..e18b647b63 100644 --- a/doxygen/SimpleSweepLineIntersector_8h_source.html +++ b/doxygen/SimpleSweepLineIntersector_8h_source.html @@ -135,7 +135,7 @@
93 #endif
94 
geos::geomgraph::Edge
Definition: geomgraph/Edge.h:63
-
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: EdgeSetIntersector.h:40
+
geos::geomgraph::index::EdgeSetIntersector
An EdgeSetIntersector computes all the intersections between the edges in the set.
Definition: geomgraph/index/EdgeSetIntersector.h:40
geos::geomgraph::index::SegmentIntersector
Computes the intersection of line segments, and adds the intersection to the edges containing the seg...
Definition: geomgraph/index/SegmentIntersector.h:46
geos::geomgraph::index::SimpleSweepLineIntersector
Finds all intersections in one or two sets of edges, using a simple x-axis sweepline algorithm.
Definition: SimpleSweepLineIntersector.h:50
geos::geomgraph::index::SimpleSweepLineIntersector::computeIntersections
void computeIntersections(std::vector< Edge * > *edges, SegmentIntersector *si, bool testAllSegments) override
Computes all self-intersections between edges in a set of edges, allowing client to choose whether se...
diff --git a/doxygen/SubgraphDepthLocater_8h_source.html b/doxygen/SubgraphDepthLocater_8h_source.html index 9595ca3ef2..0af38e3ee5 100644 --- a/doxygen/SubgraphDepthLocater_8h_source.html +++ b/doxygen/SubgraphDepthLocater_8h_source.html @@ -130,7 +130,7 @@
118 } // namespace geos::operation
119 } // namespace geos
120 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::geomgraph::DirectedEdge
A directed EdgeEnd.
Definition: geomgraph/DirectedEdge.h:42
geos::operation::buffer::SubgraphDepthLocater
Locates a subgraph inside a set of subgraphs, in order to determine the outside depth of the subgraph...
Definition: SubgraphDepthLocater.h:58
diff --git a/doxygen/SurfaceImpl_8h_source.html b/doxygen/SurfaceImpl_8h_source.html index 8a45c800d8..70a6ed5598 100644 --- a/doxygen/SurfaceImpl_8h_source.html +++ b/doxygen/SurfaceImpl_8h_source.html @@ -173,7 +173,7 @@
158 }
159 }
geos::geom::Geometry::hasNullElements
static bool hasNullElements(const CoordinateSequence *list)
Returns true if the CoordinateSequence contains any null elements.
-
geos::geom::Geometry::hasNonEmptyElements
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:908
+
geos::geom::Geometry::hasNonEmptyElements
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:904
geos::geom::Geometry::clone
std::unique_ptr< Geometry > clone() const
Make a deep-copy of this Geometry.
Definition: Geometry.h:213
geos::util::IllegalArgumentException
Indicates one or more illegal arguments.
Definition: IllegalArgumentException.h:33
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/TPVWSimplifier_8h_source.html b/doxygen/TPVWSimplifier_8h_source.html index a230fcc425..1a08d31f91 100644 --- a/doxygen/TPVWSimplifier_8h_source.html +++ b/doxygen/TPVWSimplifier_8h_source.html @@ -211,7 +211,7 @@
geos::coverage::TPVWSimplifier::simplify
static std::unique_ptr< MultiLineString > simplify(const MultiLineString *lines, std::vector< bool > &freeRings, const MultiLineString *constraintLines, double distanceTolerance)
geos::coverage::TPVWSimplifier::simplify
static std::unique_ptr< MultiLineString > simplify(const MultiLineString *lines, double distanceTolerance)
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/TaggedLineSegment_8h_source.html b/doxygen/TaggedLineSegment_8h_source.html index 6c6aed5409..1a5e911234 100644 --- a/doxygen/TaggedLineSegment_8h_source.html +++ b/doxygen/TaggedLineSegment_8h_source.html @@ -124,7 +124,7 @@
81 } // namespace geos::simplify
82 } // namespace geos
83 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::simplify::TaggedLineSegment
A geom::LineSegment which is tagged with its location in a geom::Geometry.
Definition: TaggedLineSegment.h:53
diff --git a/doxygen/TaggedLineStringSimplifier_8h_source.html b/doxygen/TaggedLineStringSimplifier_8h_source.html index cc1fed8622..b659adb43b 100644 --- a/doxygen/TaggedLineStringSimplifier_8h_source.html +++ b/doxygen/TaggedLineStringSimplifier_8h_source.html @@ -193,7 +193,7 @@
177 #pragma warning(pop)
178 #endif
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LineSegment
Definition: LineSegment.h:61
geos::simplify::TaggedLineSegment
A geom::LineSegment which is tagged with its location in a geom::Geometry.
Definition: TaggedLineSegment.h:53
geos::simplify::TaggedLineStringSimplifier
Simplifies a TaggedLineString, preserving topology (in the sense that no new intersections are introd...
Definition: TaggedLineStringSimplifier.h:69
diff --git a/doxygen/TaggedLineString_8h_source.html b/doxygen/TaggedLineString_8h_source.html index b31e10082a..979e9a21de 100644 --- a/doxygen/TaggedLineString_8h_source.html +++ b/doxygen/TaggedLineString_8h_source.html @@ -190,7 +190,7 @@
144 #endif
145 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::LineString
Definition: LineString.h:66
geos::simplify::TaggedLineSegment
A geom::LineSegment which is tagged with its location in a geom::Geometry.
Definition: TaggedLineSegment.h:53
geos::simplify::TaggedLineString
Contains and owns a list of TaggedLineSegments.
Definition: TaggedLineString.h:60
diff --git a/doxygen/TopologyComputer_8h_source.html b/doxygen/TopologyComputer_8h_source.html new file mode 100644 index 0000000000..87a79c266a --- /dev/null +++ b/doxygen/TopologyComputer_8h_source.html @@ -0,0 +1,210 @@ + + + + + + + +GEOS: TopologyComputer.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
TopologyComputer.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/operation/relateng/NodeSections.h>
+
19 #include <geos/geom/Coordinate.h>
+
20 #include <geos/geom/Location.h>
+
21 #include <geos/export.h>
+
22 
+
23 // Forward declarations
+
24 namespace geos {
+
25 namespace operation {
+
26 namespace relateng {
+
27  class NodeSection;
+
28  class RelateGeometry;
+
29  class RelateNode;
+
30  class TopologyPredicate;
+
31 }
+
32 }
+
33 }
+
34 
+
35 
+
36 using geos::geom::CoordinateXY;
+
37 using geos::geom::Location;
+
38 using geos::operation::relateng::NodeSection;
+
39 using geos::operation::relateng::NodeSections;
+
40 using geos::operation::relateng::RelateGeometry;
+
41 using geos::operation::relateng::RelateNode;
+
42 using geos::operation::relateng::TopologyPredicate;
+
43 
+
44 
+
45 namespace geos { // geos.
+
46 namespace operation { // geos.operation
+
47 namespace relateng { // geos.operation.relateng
+
48 
+
49 
+
50 class GEOS_DLL TopologyComputer {
+
51 
+
52 private:
+
53 
+
54  // Members
+
55  TopologyPredicate& predicate;
+
56  RelateGeometry& geomA;
+
57  RelateGeometry& geomB;
+
58  std::map<CoordinateXY, NodeSections*> nodeMap;
+
59  std::deque<std::unique_ptr<NodeSections>> nodeSectionsStore;
+
60 
+
61  // Methods
+
62 
+
66  void initExteriorDims();
+
67 
+
68  void initExteriorEmpty(bool geomNonEmpty);
+
69 
+
70  RelateGeometry& getGeometry(bool isA) const;
+
71 
+
72  void updateDim(Location locA, Location locB, int dimension);
+
73 
+
74  void updateDim(bool isAB, Location loc1, Location loc2, int dimension);
+
75 
+
82  void updateIntersectionAB(const NodeSection* a, const NodeSection* b);
+
83 
+
95  void updateAreaAreaCross(const NodeSection* a, const NodeSection* b);
+
96 
+
103  void updateNodeLocation(const NodeSection* a, const NodeSection* b);
+
104 
+
105  void addNodeSections(NodeSection* ns0, NodeSection* ns1);
+
106 
+
107  void addLineEndOnPoint(bool isLineA, Location locLineEnd, Location locPoint, const CoordinateXY* pt);
+
108 
+
109  void addLineEndOnLine(bool isLineA, Location locLineEnd, Location locLine, const CoordinateXY* pt);
+
110 
+
111  void addLineEndOnArea(bool isLineA, Location locLineEnd, Location locArea, const CoordinateXY* pt);
+
112 
+
124  void addAreaVertexOnPoint(bool isAreaA, Location locArea, const CoordinateXY* pt);
+
125 
+
126  void addAreaVertexOnLine(bool isAreaA, Location locArea, Location locTarget, const CoordinateXY* pt);
+
127 
+
128  void evaluateNode(NodeSections* nodeSections);
+
129 
+
130  void evaluateNodeEdges(const RelateNode* node);
+
131 
+
132  NodeSections* getNodeSections(const CoordinateXY& nodePt);
+
133 
+
134 
+
135 
+
136 public:
+
137 
+
138  TopologyComputer(
+
139  TopologyPredicate& p_predicate,
+
140  RelateGeometry& p_geomA,
+
141  RelateGeometry& p_geomB)
+
142  : predicate(p_predicate)
+
143  , geomA(p_geomA)
+
144  , geomB(p_geomB)
+
145  {
+
146  initExteriorDims();
+
147  };
+
148 
+
149  int getDimension(bool isA) const;
+
150 
+
151  bool isAreaArea() const;
+
152 
+
168  bool isSelfNodingRequired() const;
+
169 
+
170  bool isExteriorCheckRequired(bool isA) const;
+
171 
+
172  bool isResultKnown() const;
+
173 
+
174  bool getResult() const;
+
175 
+
179  void finish();
+
180 
+
181  void addIntersection(NodeSection* a, NodeSection* b);
+
182 
+
183  void addPointOnPointInterior(const CoordinateXY* pt);
+
184 
+
185  void addPointOnPointExterior(bool isGeomA, const CoordinateXY* pt);
+
186 
+
187  void addPointOnGeometry(bool isA, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
188 
+
189  void addLineEndOnGeometry(bool isLineA, Location locLineEnd, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
190 
+
207  void addAreaVertex(bool isAreaA, Location locArea, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
208 
+
209  void addAreaVertexOnArea(bool isAreaA, Location locArea, Location locTarget, const CoordinateXY* pt);
+
210 
+
211  void evaluateNodes();
+
212 
+
217  TopologyComputer(const TopologyComputer&) = delete;
+
218  TopologyComputer& operator=(const TopologyComputer&) = delete;
+
219 
+
220 
+
221 };
+
222 
+
223 } // namespace geos.operation.relateng
+
224 } // namespace geos.operation
+
225 } // namespace geos
+
226 
+
geos::operation::relateng::NodeSection
Definition: NodeSection.h:55
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/TopologyException_8h_source.html b/doxygen/TopologyException_8h_source.html index 49718bc511..5cdad607f2 100644 --- a/doxygen/TopologyException_8h_source.html +++ b/doxygen/TopologyException_8h_source.html @@ -104,7 +104,7 @@
62 } // namespace geos::util
63 } // namespace geos
64 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Coordinate::toString
std::string toString() const
Returns a string of the form (x,y,z) .
geos::util::GEOSException
Base class for all GEOS exceptions.
Definition: GEOSException.h:37
geos::util::TopologyException
Indicates an invalid or inconsistent topological situation encountered during processing.
Definition: TopologyException.h:34
diff --git a/doxygen/TopologyPredicate_8h_source.html b/doxygen/TopologyPredicate_8h_source.html new file mode 100644 index 0000000000..0ba8d00285 --- /dev/null +++ b/doxygen/TopologyPredicate_8h_source.html @@ -0,0 +1,158 @@ + + + + + + + +GEOS: TopologyPredicate.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
TopologyPredicate.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (c) 2024 Martin Davis
+
7  * Copyright (C) 2024 Paul Ramsey <pramsey@cleverelephant.ca>
+
8  *
+
9  * This is free software; you can redistribute and/or modify it under
+
10  * the terms of the GNU Lesser General Public Licence as published
+
11  * by the Free Software Foundation.
+
12  * See the COPYING file for more information.
+
13  *
+
14  **********************************************************************/
+
15 
+
16 #pragma once
+
17 
+
18 #include <geos/geom/Location.h>
+
19 #include <geos/export.h>
+
20 
+
21 
+
22 // Forward declarations
+
23 namespace geos {
+
24 namespace geom {
+
25  class Envelope;
+
26 }
+
27 }
+
28 
+
29 
+
30 using geos::geom::Envelope;
+
31 using geos::geom::Location;
+
32 
+
33 
+
34 namespace geos { // geos.
+
35 namespace operation { // geos.operation
+
36 namespace relateng { // geos.operation.relateng
+
37 
+
38 
+
39 class GEOS_DLL TopologyPredicate {
+
40 
+
41 public:
+
42 
+
43  /* Virtual destructor to ensure proper cleanup of derived classes */
+
44  virtual ~TopologyPredicate() {};
+
45 
+
51  virtual std::string name() const = 0;
+
52 
+
57  virtual void finish() = 0;
+
58 
+
64  virtual bool isKnown() const = 0;
+
65 
+
72  virtual bool value() const = 0;
+
73 
+
90  virtual bool requireSelfNoding() const {
+
91  return true;
+
92  };
+
93 
+
106  virtual bool requireInteraction() const {
+
107  return true;
+
108  };
+
109 
+
123  virtual bool requireCovers(bool isSourceA) {
+
124  (void)isSourceA;
+
125  return false;
+
126  }
+
127 
+
140  virtual bool requireExteriorCheck(bool isSourceA) const {
+
141  (void)isSourceA;
+
142  return true;
+
143  }
+
144 
+
155  virtual void init(int dimA, int dimB) {
+
156  (void)dimA;
+
157  (void)dimB;
+
158  };
+
159 
+
168  virtual void init(const Envelope& envA, const Envelope& envB)
+
169  {
+
170  //-- default if envelopes provide no information
+
171  (void)envA;
+
172  (void)envB;
+
173  };
+
174 
+
191  virtual void updateDimension(Location locA, Location locB, int dimension) = 0;
+
192 
+
193 
+
194  friend std::ostream&
+
195  operator<<(std::ostream& os, const TopologyPredicate& ns)
+
196  {
+
197  os << ns.name();
+
198  return os;
+
199  }
+
200 
+
201 };
+
202 
+
203 } // namespace geos.operation.relateng
+
204 } // namespace geos.operation
+
205 } // namespace geos
+
206 
+
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
+
geos::geom::Location
Location
Constants representing the location of a point relative to a geometry.
Definition: Location.h:32
+
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/TriDelaunayImprover_8h_source.html b/doxygen/TriDelaunayImprover_8h_source.html index 9a99f186c6..1626e7bd9f 100644 --- a/doxygen/TriDelaunayImprover_8h_source.html +++ b/doxygen/TriDelaunayImprover_8h_source.html @@ -127,7 +127,7 @@
145 } // namespace geos.triangulate
146 } // namespace geos
147 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::triangulate::polygon::TriDelaunayImprover
Definition: TriDelaunayImprover.h:48
geos::triangulate::polygon::TriDelaunayImprover::improve
static void improve(TriList< Tri > &triList)
geos::triangulate::tri::TriList
Definition: TriList.h:54
diff --git a/doxygen/TriEdge_8h_source.html b/doxygen/TriEdge_8h_source.html index eba2dcb552..facff9c819 100644 --- a/doxygen/TriEdge_8h_source.html +++ b/doxygen/TriEdge_8h_source.html @@ -118,7 +118,7 @@
78 } // namespace geos.triangulate
79 } // namespace geos
80 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::triangulate::tri::TriEdge
Definition: TriEdge.h:44
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/TriList_8h_source.html b/doxygen/TriList_8h_source.html index 38c4ba373c..c2ead7d8c1 100644 --- a/doxygen/TriList_8h_source.html +++ b/doxygen/TriList_8h_source.html @@ -221,7 +221,7 @@
180 } // namespace geos.triangulate
181 } // namespace geos
182 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::GeometryFactory::createGeometryCollection
std::unique_ptr< GeometryCollection > createGeometryCollection() const
Construct an EMPTY GeometryCollection.
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
diff --git a/doxygen/Tri_8h_source.html b/doxygen/Tri_8h_source.html index c867165340..bf5900dd0a 100644 --- a/doxygen/Tri_8h_source.html +++ b/doxygen/Tri_8h_source.html @@ -183,7 +183,7 @@
184 } // namespace geos.triangulate
185 } // namespace geos
186 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryFactory
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition: Polygon.h:61
diff --git a/doxygen/TrianglePredicate_8h_source.html b/doxygen/TrianglePredicate_8h_source.html index d48db01fb1..4f7d7e4a6f 100644 --- a/doxygen/TrianglePredicate_8h_source.html +++ b/doxygen/TrianglePredicate_8h_source.html @@ -107,7 +107,7 @@
121 } // namespace geos
122 
123 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::triangulate::quadedge::TrianglePredicate
Algorithms for computing values and predicates associated with triangles.
Definition: TrianglePredicate.h:50
geos::triangulate::quadedge::TrianglePredicate::isInCircleNonRobust
static bool isInCircleNonRobust(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust
static bool isInCircleRobust(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
diff --git a/doxygen/TriangulationBuilder_8h_source.html b/doxygen/TriangulationBuilder_8h_source.html index aa78dff825..9984f0ccd6 100644 --- a/doxygen/TriangulationBuilder_8h_source.html +++ b/doxygen/TriangulationBuilder_8h_source.html @@ -121,7 +121,7 @@
84 } // namespace geos.triangulate
85 } // namespace geos
86 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::triangulate::tri::Tri
Definition: Tri.h:49
geos::triangulate::tri::TriangulationBuilder
Definition: TriangulationBuilder.h:49
diff --git a/doxygen/VertexRingCounter_8h_source.html b/doxygen/VertexRingCounter_8h_source.html index b114bd3c90..ee0332e23d 100644 --- a/doxygen/VertexRingCounter_8h_source.html +++ b/doxygen/VertexRingCounter_8h_source.html @@ -120,7 +120,7 @@
71 } // geos
geos::geom::CoordinateSequenceFilter
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/VertexSequencePackedRtree_8h_source.html b/doxygen/VertexSequencePackedRtree_8h_source.html index ab89255cc3..2513e1fd89 100644 --- a/doxygen/VertexSequencePackedRtree_8h_source.html +++ b/doxygen/VertexSequencePackedRtree_8h_source.html @@ -152,7 +152,7 @@
152 } // namespace geos
153 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:59
geos::index::VertexSequencePackedRtree
Definition: VertexSequencePackedRtree.h:54
geos::index::VertexSequencePackedRtree::query
void query(const Envelope &queryEnv, std::vector< std::size_t > &result) const
diff --git a/doxygen/Vertex_8h_source.html b/doxygen/Vertex_8h_source.html index 3d99cdb352..2ff30ca93c 100644 --- a/doxygen/Vertex_8h_source.html +++ b/doxygen/Vertex_8h_source.html @@ -258,8 +258,8 @@
310 } //namespace geos.triangulate
311 } //namespace geos
312 
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
-
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:236
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
+
geos::geom::Coordinate::z
double z
z-coordinate
Definition: Coordinate.h:241
geos::triangulate::quadedge::QuadEdge
A class that represents the edge data structure which implements the quadedge algebra.
Definition: QuadEdge.h:53
geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust
static bool isInCircleRobust(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
geos::triangulate::quadedge::Vertex
Models a site (node) in a QuadEdgeSubdivision.
Definition: Vertex.h:60
diff --git a/doxygen/WKTWriter_8h_source.html b/doxygen/WKTWriter_8h_source.html index 07c6b03ec0..8085d291c0 100644 --- a/doxygen/WKTWriter_8h_source.html +++ b/doxygen/WKTWriter_8h_source.html @@ -133,7 +133,7 @@
106 
114  static std::string toLineString(const geom::CoordinateSequence& seq);
115 
-
124  static std::string toLineString(const geom::Coordinate& p0, const geom::Coordinate& p1);
+
124  static std::string toLineString(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
125 
133  static std::string toPoint(const geom::Coordinate& p0);
134  static std::string toPoint(const geom::CoordinateXY& p0);
@@ -316,7 +316,7 @@
341 #endif
342 
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
-
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
+
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:217
geos::geom::GeometryCollection
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:51
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:197
geos::geom::MultiPoint
Definition: MultiPoint.h:50
@@ -324,10 +324,10 @@
geos::geom::Surface
Definition: Surface.h:27
geos::io::WKTWriter
Outputs the textual representation of a Geometry. See also WKTReader.
Definition: WKTWriter.h:87
geos::io::WKTWriter::toPoint
static std::string toPoint(const geom::Coordinate &p0)
-
geos::io::WKTWriter::toLineString
static std::string toLineString(const geom::Coordinate &p0, const geom::Coordinate &p1)
geos::io::WKTWriter::setOld3D
void setOld3D(bool useOld3D)
Definition: WKTWriter.h:176
geos::io::WKTWriter::setTrim
void setTrim(bool p0)
geos::io::WKTWriter::setRoundingPrecision
void setRoundingPrecision(int p0)
+
geos::io::WKTWriter::toLineString
static std::string toLineString(const geom::CoordinateXY &p0, const geom::CoordinateXY &p1)
geos::io::WKTWriter::write
std::string write(const geom::Geometry *geometry)
Returns WKT string for the given Geometry.
geos::io::WKTWriter::setRemoveEmptyDimensions
void setRemoveEmptyDimensions(bool remove)
setRemoveEmptyDimensions
Definition: WKTWriter.h:160
geos::io::WKTWriter::toLineString
static std::string toLineString(const geom::CoordinateSequence &seq)
diff --git a/doxygen/annotated.html b/doxygen/annotated.html index 8b08aa688b..1dbd7ea6c2 100644 --- a/doxygen/annotated.html +++ b/doxygen/annotated.html @@ -125,14 +125,15 @@  CGeometryEditorOperation  CGeometryExtracter  CGeometryFixer - CGeometryMapper - CGeometryTransformerA framework for processes which transform an input Geometry into an output Geometry, possibly changing its structure and type(s) - CLinearComponentExtracter - CPointExtracter - CPolygonalExtracterExtracts the polygonal (Polygon and MultiPolygon) elements from a Geometry - CPolygonExtracter - CShortCircuitedGeometryVisitorA visitor to Geometry elements which can be short-circuited by a given condition - CSineStarFactory + CGeometryLister + CGeometryMapper + CGeometryTransformerA framework for processes which transform an input Geometry into an output Geometry, possibly changing its structure and type(s) + CLinearComponentExtracter + CPointExtracter + CPolygonalExtracterExtracts the polygonal (Polygon and MultiPolygon) elements from a Geometry + CPolygonExtracter + CShortCircuitedGeometryVisitorA visitor to Geometry elements which can be short-circuited by a given condition + CSineStarFactory  CCoordinateCoordinate is the lightweight class used to store coordinates  CCoordinateLessThanStrict weak ordering Functor for Coordinate  CCoordinateFilterGeometry classes support the concept of applying a coordinate filter to every coordinate in the Geometry @@ -402,18 +403,25 @@  CRelateNodeFactoryUsed by the geomgraph::NodeMap in a RelateNodeGraph to create RelateNode objects  CRelateNodeGraphImplements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is required to determine topological relationships between Geometries  CRelateOpImplements the SFS relate() operation on two geom::Geometry objects - ►NsharedpathsFind shared paths among two linear Geometry objects - CSharedPathsOpFind shared paths among two linear Geometry objects - ►NvalidProvides classes for testing the validity of geometries - CConsistentAreaTesterChecks that a geomgraph::GeometryGraph representing an area (a geom::Polygon or geom::MultiPolygon) has consistent semantics for area geometries. This check is required for any reasonable polygonal model (including the OGC-SFS model, as well as models which allow ring self-intersection at single points) - CIsSimpleOp - CIsValidOp - CMakeValidThe function attempts to create a valid representation of a given invalid geometry without losing any of the input vertices - CRepeatedPointRemover - CRepeatedPointTesterImplements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the JTS spec - CTopologyValidationErrorContains information about the nature and location of a geom::Geometry validation error - CBoundaryOp - CGeometryGraphOperationThe base class for operations that require GeometryGraph + ►Nrelateng + CAdjacentEdgeLocator + CEdgeSegmentOverlapActionThe action for the internal iterator for performing overlap queries on a MonotoneChain + CNodeSection + CPolygonNodeConverter + CRelateNG + CRelatePointLocator + ►NsharedpathsFind shared paths among two linear Geometry objects + CSharedPathsOpFind shared paths among two linear Geometry objects + ►NvalidProvides classes for testing the validity of geometries + CConsistentAreaTesterChecks that a geomgraph::GeometryGraph representing an area (a geom::Polygon or geom::MultiPolygon) has consistent semantics for area geometries. This check is required for any reasonable polygonal model (including the OGC-SFS model, as well as models which allow ring self-intersection at single points) + CIsSimpleOp + CIsValidOp + CMakeValidThe function attempts to create a valid representation of a given invalid geometry without losing any of the input vertices + CRepeatedPointRemover + CRepeatedPointTesterImplements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the JTS spec + CTopologyValidationErrorContains information about the nature and location of a geom::Geometry validation error + CBoundaryOp + CGeometryGraphOperationThe base class for operations that require GeometryGraph  ►NplanargraphContains classes to implement a planar graph data structure  ►NalgorithmPlanargraph algorithms  CConnectedSubgraphFinderFinds all connected Subgraphs of a PlanarGraph diff --git a/doxygen/classes.html b/doxygen/classes.html index 63f702a01d..721f61df0f 100644 --- a/doxygen/classes.html +++ b/doxygen/classes.html @@ -47,7 +47,7 @@
A
-
AbstractClusterFinder (geos::operation::cluster)
AbstractNode (geos::index::strtree)
AbstractPreparedPolygonContains (geos::geom::prep)
AbstractSTRtree (geos::index::strtree)
Angle (geos::algorithm)
AssertionFailedException (geos::util)
+
AbstractClusterFinder (geos::operation::cluster)
AbstractNode (geos::index::strtree)
AbstractPreparedPolygonContains (geos::geom::prep)
AbstractSTRtree (geos::index::strtree)
AdjacentEdgeLocator (geos::operation::relateng)
Angle (geos::algorithm)
AssertionFailedException (geos::util)
B
BasicPreparedGeometry (geos::geom::prep)
BasicSegmentString (geos::noding)
Bintree (geos::index::bintree)
Boundable (geos::index::strtree)
BoundablePair (geos::index::strtree)
BoundaryChainNoder (geos::noding)
BoundaryNodeRule (geos::algorithm)
BoundaryOp (geos::operation)
BufferBuilder (geos::operation::buffer)
BufferCurveSetBuilder (geos::operation::buffer)
BufferInputLineSimplifier (geos::operation::buffer)
BufferOp (geos::operation::buffer)
BufferParameters (geos::operation::buffer)
BufferSubgraph (geos::operation::buffer)
BuildArea (geos::operation::polygonize)
ByteOrderDataInStream (geos::io)
ByteOrderValues (geos::io)
@@ -59,13 +59,13 @@
DBSCANClusterFinder (geos::operation::cluster)
DD (geos::math)
DelaunayTriangulationBuilder (geos::triangulate)
Densifier (geos::geom::util)
Depth (geos::geomgraph)
Dimension (geos::geom)
DirectedEdge (geos::geomgraph)
DirectedEdge (geos::planargraph)
DirectedEdgeStar (geos::geomgraph)
DirectedEdgeStar (geos::planargraph)
DiscreteFrechetDistance (geos::algorithm::distance)
DiscreteHausdorffDistance (geos::algorithm::distance)
Distance (geos::algorithm)
DistanceOp (geos::operation::distance)
DistanceToPoint (geos::algorithm::distance)
DouglasPeuckerLineSimplifier (geos::simplify)
DouglasPeuckerSimplifier (geos::simplify)
E
-
Edge (geos::operation::overlayng)
Edge (geos::planargraph)
Edge (geos::geomgraph)
EdgeEnd (geos::geomgraph)
EdgeEndBuilder (geos::operation::relate)
EdgeEndBundle (geos::operation::relate)
EdgeEndBundleStar (geos::operation::relate)
EdgeEndStar (geos::geomgraph)
EdgeGraph (geos::edgegraph)
EdgeGraphBuilder (geos::edgegraph)
EdgeIntersection (geos::geomgraph)
EdgeIntersectionList (geos::geomgraph)
EdgeKey (geos::operation::overlayng)
EdgeList (geos::geomgraph)
EdgeMerger (geos::operation::overlayng)
EdgeNodingBuilder (geos::operation::overlayng)
EdgeNodingValidator (geos::geomgraph)
EdgeRing (geos::geomgraph)
EdgeRing (geos::operation::polygonize)
EdgeSetIntersector (geos::geomgraph::index)
EdgeSourceInfo (geos::operation::overlayng)
EdgeString (geos::operation::linemerge)
ElevationModel (geos::operation::overlayng)
EnhancedPrecisionOp (geos::precision)
Envelope (geos::geom)
EnvelopeDistanceClusterFinder (geos::operation::cluster)
EnvelopeIntersectsClusterFinder (geos::operation::cluster)
ExtractLineByLocation (geos::linearref)
+
Edge (geos::operation::overlayng)
Edge (geos::planargraph)
Edge (geos::geomgraph)
EdgeEnd (geos::geomgraph)
EdgeEndBuilder (geos::operation::relate)
EdgeEndBundle (geos::operation::relate)
EdgeEndBundleStar (geos::operation::relate)
EdgeEndStar (geos::geomgraph)
EdgeGraph (geos::edgegraph)
EdgeGraphBuilder (geos::edgegraph)
EdgeIntersection (geos::geomgraph)
EdgeIntersectionList (geos::geomgraph)
EdgeKey (geos::operation::overlayng)
EdgeList (geos::geomgraph)
EdgeMerger (geos::operation::overlayng)
EdgeNodingBuilder (geos::operation::overlayng)
EdgeNodingValidator (geos::geomgraph)
EdgeRing (geos::geomgraph)
EdgeRing (geos::operation::polygonize)
EdgeSegmentOverlapAction (geos::operation::relateng)
EdgeSetIntersector (geos::geomgraph::index)
EdgeSourceInfo (geos::operation::overlayng)
EdgeString (geos::operation::linemerge)
ElevationModel (geos::operation::overlayng)
EnhancedPrecisionOp (geos::precision)
Envelope (geos::geom)
EnvelopeDistanceClusterFinder (geos::operation::cluster)
EnvelopeIntersectsClusterFinder (geos::operation::cluster)
ExtractLineByLocation (geos::linearref)
F
FastNodingValidator (geos::noding)
FastSegmentSetIntersectionFinder (geos::noding)
FuzzyPointLocator (geos::operation::overlay::validate)
G
-
GeoJSONReader (geos::io)
GeoJSONWriter (geos::io)
GeometricShapeFactory (geos::util)
Geometry (geos::geom)
GeometryCollection (geos::geom)
GeometryCombiner (geos::geom::util)
GeometryComponentFilter (geos::geom)
GeometryDistanceClusterFinder (geos::operation::cluster)
GeometryEditor (geos::geom::util)
GeometryEditorOperation (geos::geom::util)
GeometryExtracter (geos::geom::util)
GeometryFactory (geos::geom)
GeometryFilter (geos::geom)
GeometryFixer (geos::geom::util)
GeometryGraph (geos::geomgraph)
GeometryGraphOperation (geos::operation)
GeometryIntersectsClusterFinder (geos::operation::cluster)
GeometryLocation (geos::operation::distance)
GeometryMapper (geos::geom::util)
GeometryPrecisionReducer (geos::precision)
GeometrySnapper (geos::operation::overlay::snap)
GeometryTransformer (geos::geom::util)
GEOSException (geos::util)
GraphComponent (geos::geomgraph)
GraphComponent (geos::planargraph)
+
GeoJSONReader (geos::io)
GeoJSONWriter (geos::io)
GeometricShapeFactory (geos::util)
Geometry (geos::geom)
GeometryCollection (geos::geom)
GeometryCombiner (geos::geom::util)
GeometryComponentFilter (geos::geom)
GeometryDistanceClusterFinder (geos::operation::cluster)
GeometryEditor (geos::geom::util)
GeometryEditorOperation (geos::geom::util)
GeometryExtracter (geos::geom::util)
GeometryFactory (geos::geom)
GeometryFilter (geos::geom)
GeometryFixer (geos::geom::util)
GeometryGraph (geos::geomgraph)
GeometryGraphOperation (geos::operation)
GeometryIntersectsClusterFinder (geos::operation::cluster)
GeometryLister (geos::geom::util)
GeometryLocation (geos::operation::distance)
GeometryMapper (geos::geom::util)
GeometryPrecisionReducer (geos::precision)
GeometrySnapper (geos::operation::overlay::snap)
GeometryTransformer (geos::geom::util)
GEOSException (geos::util)
GraphComponent (geos::geomgraph)
GraphComponent (geos::planargraph)
H
HalfEdge (geos::edgegraph)
HCoordinate (geos::algorithm)
HilbertCode (geos::shape::fractal)
HoleAssigner (geos::operation::polygonize)
HotPixel (geos::noding::snapround)
@@ -83,19 +83,19 @@
MakeValid (geos::operation::valid)
MaximalEdgeRing (geos::operation::overlay)
MaximumInscribedCircle (geos::algorithm::construct)
MCIndexNoder (geos::noding)
MCIndexPointSnapper (geos::noding::snapround)
MCIndexSegmentSetMutualIntersector (geos::noding)
MCIndexSnapRounder (geos::noding::snapround)
MinimalEdgeRing (geos::operation::overlay)
MinimumAreaRectangle (geos::algorithm)
MinimumClearance (geos::precision)
MinimumDiameter (geos::algorithm)
MonotoneChain (geos::geomgraph::index)
MonotoneChain (geos::index::chain)
MonotoneChainBuilder (geos::index::chain)
MonotoneChainEdge (geos::geomgraph::index)
MonotoneChainIndexer (geos::geomgraph::index)
MonotoneChainOverlapAction (geos::index::chain)
MonotoneChainSelectAction (geos::index::chain)
MortonCode (geos::shape::fractal)
MultiLineString (geos::geom)
MultiPoint (geos::geom)
MultiPolygon (geos::geom)
N
-
UnaryUnionNG::NGUnionStrategy (geos::operation::overlayng)
NodableSegmentString (geos::noding)
Node (geos::geomgraph)
Node (geos::index::bintree)
Node (geos::index::quadtree)
Node (geos::planargraph)
NodeBase (geos::index::bintree)
NodeBase (geos::index::quadtree)
NodedSegmentString (geos::noding)
NodeMap (geos::planargraph)
Noder (geos::noding)
NodingIntersectionFinder (geos::noding)
NodingValidator (geos::noding)
NotRepresentableException (geos::algorithm)
+
UnaryUnionNG::NGUnionStrategy (geos::operation::overlayng)
NodableSegmentString (geos::noding)
Node (geos::geomgraph)
Node (geos::index::bintree)
Node (geos::index::quadtree)
Node (geos::planargraph)
NodeBase (geos::index::bintree)
NodeBase (geos::index::quadtree)
NodedSegmentString (geos::noding)
NodeMap (geos::planargraph)
Noder (geos::noding)
NodeSection (geos::operation::relateng)
NodingIntersectionFinder (geos::noding)
NodingValidator (geos::noding)
NotRepresentableException (geos::algorithm)
O
Octant (geos::noding)
OffsetCurve (geos::operation::buffer)
OffsetCurveBuilder (geos::operation::buffer)
OffsetCurveSection (geos::operation::buffer)
OffsetPointGenerator (geos::operation::overlay::validate)
OffsetSegmentGenerator (geos::operation::buffer)
OffsetSegmentString (geos::operation::buffer)
OrdinateSet (geos::io)
Orientation (geos::algorithm)
OrientedCoordinateArray (geos::noding)
OverlapUnion (geos::operation::geounion)
OverlayEdge (geos::operation::overlayng)
OverlayGraph (geos::operation::overlayng)
OverlayLabel (geos::operation::overlayng)
OverlayMixedPoints (geos::operation::overlayng)
OverlayNG (geos::operation::overlayng)
OverlayNGRobust (geos::operation::overlayng)
OverlayNodeFactory (geos::operation::overlay)
OverlayPoints (geos::operation::overlayng)
OverlayResultValidator (geos::operation::overlay::validate)
OverlayUtil (geos::operation::overlayng)
P
-
ParseException (geos::io)
PlanarGraph (geos::geomgraph)
PlanarGraph (geos::planargraph)
Point (geos::geom)
PointExtracter (geos::geom::util)
PointGeometryUnion (geos::operation::geounion)
PointLocation (geos::algorithm)
PointLocator (geos::algorithm)
PointOnGeometryLocator (geos::algorithm::locate)
PointPairDistance (geos::algorithm::distance)
PointwisePrecisionReducerTransformer (geos::precision)
Polygon (geos::geom)
PolygonalExtracter (geos::geom::util)
PolygonBuilder (geos::operation::overlay)
PolygonEarClipper (geos::triangulate::polygon)
PolygonExtracter (geos::geom::util)
PolygonHoleJoiner (geos::triangulate::polygon)
PolygonHullSimplifier (geos::simplify)
PolygonizeDirectedEdge (geos::operation::polygonize)
PolygonizeEdge (geos::operation::polygonize)
PolygonizeGraph (geos::operation::polygonize)
Polygonizer (geos::operation::polygonize)
PolygonNoder (geos::triangulate::polygon)
PolygonNodeTopology (geos::algorithm)
PolygonTriangulator (geos::triangulate::polygon)
Position (geos::geom)
PrecisionModel (geos::geom)
PrecisionReducer (geos::operation::overlayng)
PrecisionReducerTransformer (geos::precision)
PrecisionUtil (geos::operation::overlayng)
PreparedGeometry (geos::geom::prep)
PreparedGeometryFactory (geos::geom::prep)
PreparedLineString (geos::geom::prep)
PreparedLineStringIntersects (geos::geom::prep)
PreparedPoint (geos::geom::prep)
PreparedPolygon (geos::geom::prep)
PreparedPolygonContains (geos::geom::prep)
PreparedPolygonContainsProperly (geos::geom::prep)
PreparedPolygonCovers (geos::geom::prep)
PreparedPolygonIntersects (geos::geom::prep)
PreparedPolygonPredicate (geos::geom::prep)
+
ParseException (geos::io)
PlanarGraph (geos::geomgraph)
PlanarGraph (geos::planargraph)
Point (geos::geom)
PointExtracter (geos::geom::util)
PointGeometryUnion (geos::operation::geounion)
PointLocation (geos::algorithm)
PointLocator (geos::algorithm)
PointOnGeometryLocator (geos::algorithm::locate)
PointPairDistance (geos::algorithm::distance)
PointwisePrecisionReducerTransformer (geos::precision)
Polygon (geos::geom)
PolygonalExtracter (geos::geom::util)
PolygonBuilder (geos::operation::overlay)
PolygonEarClipper (geos::triangulate::polygon)
PolygonExtracter (geos::geom::util)
PolygonHoleJoiner (geos::triangulate::polygon)
PolygonHullSimplifier (geos::simplify)
PolygonizeDirectedEdge (geos::operation::polygonize)
PolygonizeEdge (geos::operation::polygonize)
PolygonizeGraph (geos::operation::polygonize)
Polygonizer (geos::operation::polygonize)
PolygonNodeConverter (geos::operation::relateng)
PolygonNoder (geos::triangulate::polygon)
PolygonNodeTopology (geos::algorithm)
PolygonTriangulator (geos::triangulate::polygon)
Position (geos::geom)
PrecisionModel (geos::geom)
PrecisionReducer (geos::operation::overlayng)
PrecisionReducerTransformer (geos::precision)
PrecisionUtil (geos::operation::overlayng)
PreparedGeometry (geos::geom::prep)
PreparedGeometryFactory (geos::geom::prep)
PreparedLineString (geos::geom::prep)
PreparedLineStringIntersects (geos::geom::prep)
PreparedPoint (geos::geom::prep)
PreparedPolygon (geos::geom::prep)
PreparedPolygonContains (geos::geom::prep)
PreparedPolygonContainsProperly (geos::geom::prep)
PreparedPolygonCovers (geos::geom::prep)
PreparedPolygonIntersects (geos::geom::prep)
PreparedPolygonPredicate (geos::geom::prep)
Q
QuadEdge (geos::triangulate::quadedge)
QuadEdgeLocator (geos::triangulate::quadedge)
QuadEdgeSubdivision (geos::triangulate::quadedge)
Quadrant (geos::geom)
Quadtree (geos::index::quadtree)
R
-
RayCrossingCounter (geos::algorithm)
Rectangle (geos::operation::intersection)
RectangleContains (geos::operation::predicate)
RectangleIntersection (geos::operation::intersection)
RectangleIntersectionBuilder (geos::operation::intersection)
RectangleIntersects (geos::operation::predicate)
RelateComputer (geos::operation::relate)
RelateNode (geos::operation::relate)
RelateNodeFactory (geos::operation::relate)
RelateNodeGraph (geos::operation::relate)
RelateOp (geos::operation::relate)
RepeatedPointRemover (geos::operation::valid)
RepeatedPointTester (geos::operation::valid)
RightmostEdgeFinder (geos::operation::buffer)
RingClipper (geos::operation::overlayng)
RobustClipEnvelopeComputer (geos::operation::overlayng)
RobustDeterminant (geos::algorithm)
Root (geos::index::bintree)
Root (geos::index::quadtree)
+
RayCrossingCounter (geos::algorithm)
Rectangle (geos::operation::intersection)
RectangleContains (geos::operation::predicate)
RectangleIntersection (geos::operation::intersection)
RectangleIntersectionBuilder (geos::operation::intersection)
RectangleIntersects (geos::operation::predicate)
RelateComputer (geos::operation::relate)
RelateNG (geos::operation::relateng)
RelateNode (geos::operation::relate)
RelateNodeFactory (geos::operation::relate)
RelateNodeGraph (geos::operation::relate)
RelateOp (geos::operation::relate)
RelatePointLocator (geos::operation::relateng)
RepeatedPointRemover (geos::operation::valid)
RepeatedPointTester (geos::operation::valid)
RightmostEdgeFinder (geos::operation::buffer)
RingClipper (geos::operation::overlayng)
RobustClipEnvelopeComputer (geos::operation::overlayng)
RobustDeterminant (geos::algorithm)
Root (geos::index::bintree)
Root (geos::index::quadtree)
S
ScaledNoder (geos::noding)
SegmentExtractingNoder (geos::noding)
SegmentIntersectionDetector (geos::noding)
SegmentIntersectionTester (geos::operation::predicate)
SegmentIntersector (geos::geomgraph::index)
SegmentIntersector (geos::noding)
SegmentNode (geos::noding)
SegmentNodeList (geos::noding)
SegmentPointComparator (geos::noding)
SegmentSetMutualIntersector (geos::noding)
SegmentString (geos::noding)
SegmentStringUtil (geos::noding)
SharedPathsOp (geos::operation::sharedpaths)
ShortCircuitedGeometryVisitor (geos::geom::util)
SimpleEdgeSetIntersector (geos::geomgraph::index)
SimpleGeometryPrecisionReducer (geos::precision)
SimpleMCSweepLineIntersector (geos::geomgraph::index)
SimpleNoder (geos::noding)
SimplePointInAreaLocator (geos::algorithm::locate)
SimpleSTRnode (geos::index::strtree)
SimpleSTRtree (geos::index::strtree)
SimpleSweepLineIntersector (geos::geomgraph::index)
SineStarFactory (geos::geom::util)
SinglePassNoder (geos::noding)
SIRtree (geos::index::strtree)
SnapOverlayOp (geos::operation::overlay::snap)
SnappingNoder (geos::noding::snap)
SnapRoundingIntersectionAdder (geos::noding::snapround)
SnapRoundingNoder (geos::noding::snapround)
SortedPackedIntervalRTree (geos::index::intervalrtree)
SpatialIndex (geos::index)
STRtree (geos::index::strtree)
Subgraph (geos::planargraph)
SubgraphDepthLocater (geos::operation::buffer)
Surface (geos::geom)
SweepLineIndex (geos::index::sweepline)
diff --git a/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology-members.html b/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology-members.html index d6647cdf74..4843f0d798 100644 --- a/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology-members.html +++ b/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology-members.html @@ -50,8 +50,9 @@

This is the complete list of members for geos::algorithm::PolygonNodeTopology, including all inherited members.

- - + + +
isCrossing(const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b0, const CoordinateXY *b1) (defined in geos::algorithm::PolygonNodeTopology)geos::algorithm::PolygonNodeTopologystatic
isInteriorSegment(const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b)geos::algorithm::PolygonNodeTopologystatic
compareAngle(const CoordinateXY *origin, const CoordinateXY *p, const CoordinateXY *q)geos::algorithm::PolygonNodeTopologystatic
isCrossing(const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b0, const CoordinateXY *b1) (defined in geos::algorithm::PolygonNodeTopology)geos::algorithm::PolygonNodeTopologystatic
isInteriorSegment(const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b)geos::algorithm::PolygonNodeTopologystatic
diff --git a/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology.html b/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology.html index adfd40311c..2db647e766 100644 --- a/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology.html +++ b/doxygen/classgeos_1_1algorithm_1_1PolygonNodeTopology.html @@ -60,11 +60,65 @@   static bool isInteriorSegment (const CoordinateXY *nodePt, const CoordinateXY *a0, const CoordinateXY *a1, const CoordinateXY *b)   +static int compareAngle (const CoordinateXY *origin, const CoordinateXY *p, const CoordinateXY *q) + 

Detailed Description

Functions to compute topological information about nodes (ring intersections) in polygonal geometry.

Author
mdavis

Member Function Documentation

+ +

◆ compareAngle()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static int geos::algorithm::PolygonNodeTopology::compareAngle (const CoordinateXY * origin,
const CoordinateXY * p,
const CoordinateXY * q 
)
+ 		+static
+
+

Compares the angles of two vectors relative to the positive X-axis at their origin. Angles increase CCW from the X-axis.

+
Parameters
+ + + + +
originthe origin of the vectors
pthe endpoint of the vector P
qthe endpoint of the vector Q
+
+
+
Returns
a negative integer, zero, or a positive integer as this vector P has angle less than, equal to, or greater than vector Q
+ +
+

◆ isInteriorSegment()

diff --git a/doxygen/classgeos_1_1geom_1_1Coordinate-members.html b/doxygen/classgeos_1_1geom_1_1Coordinate-members.html index 26942317b0..d666649e23 100644 --- a/doxygen/classgeos_1_1geom_1_1Coordinate-members.html +++ b/doxygen/classgeos_1_1geom_1_1Coordinate-members.html @@ -51,9 +51,11 @@

This is the complete list of members for geos::geom::Coordinate, including all inherited members.

- - - + + + + + diff --git a/doxygen/classgeos_1_1geom_1_1Coordinate.html b/doxygen/classgeos_1_1geom_1_1Coordinate.html index 36d6dfc7cc..e269b42ee9 100644 --- a/doxygen/classgeos_1_1geom_1_1Coordinate.html +++ b/doxygen/classgeos_1_1geom_1_1Coordinate.html @@ -69,6 +69,9 @@ typedef std::set< const Coordinate *, CoordinateLessThan >  + + @@ -81,6 +84,10 @@ typedef std::vector< Coordinate >  + + +
compareTo(const CoordinateXY &other) const (defined in geos::geom::CoordinateXY)geos::geom::CoordinateXYinline
ConstSet typedefgeos::geom::Coordinate
ConstStack typedefgeos::geom::Coordinate
ConstVect typedefgeos::geom::Coordinate
ConstIntMap typedefgeos::geom::Coordinate
ConstSet typedefgeos::geom::Coordinate
ConstStack typedefgeos::geom::Coordinate
ConstVect typedefgeos::geom::Coordinate
ConstXYSet typedef (defined in geos::geom::Coordinate)geos::geom::Coordinate
Coordinate() (defined in geos::geom::Coordinate)geos::geom::Coordinateinline
Coordinate(double xNew, double yNew, double zNew=DEFAULT_Z) (defined in geos::geom::Coordinate)geos::geom::Coordinateinline
Coordinate(const CoordinateXY &other) (defined in geos::geom::Coordinate)geos::geom::Coordinateinlineexplicit
ConstSet
 A set of const Coordinate pointers.
 
+typedef std::set< const CoordinateXY *, CoordinateLessThan > ConstXYSet
 
typedef std::vector< const Coordinate * > ConstVect
 A vector of const Coordinate pointers.
Vect
 A vector of Coordinate objects (real object, not pointers)
 
+typedef std::map< const CoordinateXY *, int, CoordinateLessThan > ConstIntMap
 A map of const Coordinate pointers to integers.
 
diff --git a/doxygen/classgeos_1_1geom_1_1Geometry-members.html b/doxygen/classgeos_1_1geom_1_1Geometry-members.html index 8936981f16..4f865437d3 100644 --- a/doxygen/classgeos_1_1geom_1_1Geometry-members.html +++ b/doxygen/classgeos_1_1geom_1_1Geometry-members.html @@ -71,7 +71,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1Geometry.html b/doxygen/classgeos_1_1geom_1_1Geometry.html index 2358e70b7d..026aa86725 100644 --- a/doxygen/classgeos_1_1geom_1_1Geometry.html +++ b/doxygen/classgeos_1_1geom_1_1Geometry.html @@ -744,9 +744,6 @@

-

Public Member Functions

ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
- - - + diff --git a/doxygen/classgeos_1_1geom_1_1IntersectionMatrix-members.html b/doxygen/classgeos_1_1geom_1_1IntersectionMatrix-members.html index 36b0a3e736..351b59cb60 100644 --- a/doxygen/classgeos_1_1geom_1_1IntersectionMatrix-members.html +++ b/doxygen/classgeos_1_1geom_1_1IntersectionMatrix-members.html @@ -51,7 +51,7 @@

This is the complete list of members for geos::geom::IntersectionMatrix, including all inherited members.

@@ -756,11 +753,6 @@

-inline -

-
bool geos::geom::Geometry::coveredBy

Tests whether this geometry is covered by the specified geometry.

@@ -783,8 +775,6 @@

Geometry::covers -

References covers().

-

@@ -823,8 +813,6 @@

Geometry::coveredBy -

Referenced by coveredBy().

- diff --git a/doxygen/classgeos_1_1geom_1_1GeometryCollection-members.html b/doxygen/classgeos_1_1geom_1_1GeometryCollection-members.html index fab94a2d63..1ea06bbadd 100644 --- a/doxygen/classgeos_1_1geom_1_1GeometryCollection-members.html +++ b/doxygen/classgeos_1_1geom_1_1GeometryCollection-members.html @@ -74,7 +74,7 @@

ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
- + diff --git a/doxygen/classgeos_1_1geom_1_1IntersectionMatrix.html b/doxygen/classgeos_1_1geom_1_1IntersectionMatrix.html index 23c35caab2..b471dd329f 100644 --- a/doxygen/classgeos_1_1geom_1_1IntersectionMatrix.html +++ b/doxygen/classgeos_1_1geom_1_1IntersectionMatrix.html @@ -92,9 +92,9 @@ - - - + + + @@ -251,8 +251,8 @@

-

◆ get()

+ +

◆ get()

@@ -263,13 +263,13 @@

int geos::geom::IntersectionMatrix::get

- + - + diff --git a/doxygen/classgeos_1_1geom_1_1LineString-members.html b/doxygen/classgeos_1_1geom_1_1LineString-members.html index 0ac4bf2b75..2556d1e386 100644 --- a/doxygen/classgeos_1_1geom_1_1LineString-members.html +++ b/doxygen/classgeos_1_1geom_1_1LineString-members.html @@ -74,7 +74,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1LinearRing-members.html b/doxygen/classgeos_1_1geom_1_1LinearRing-members.html index d0ac7bbc69..4657700686 100644 --- a/doxygen/classgeos_1_1geom_1_1LinearRing-members.html +++ b/doxygen/classgeos_1_1geom_1_1LinearRing-members.html @@ -74,7 +74,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1MultiLineString-members.html b/doxygen/classgeos_1_1geom_1_1MultiLineString-members.html index d30fc7c47d..ca61d83db7 100644 --- a/doxygen/classgeos_1_1geom_1_1MultiLineString-members.html +++ b/doxygen/classgeos_1_1geom_1_1MultiLineString-members.html @@ -74,7 +74,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1MultiPoint-members.html b/doxygen/classgeos_1_1geom_1_1MultiPoint-members.html index add5298de2..66bc56130c 100644 --- a/doxygen/classgeos_1_1geom_1_1MultiPoint-members.html +++ b/doxygen/classgeos_1_1geom_1_1MultiPoint-members.html @@ -74,7 +74,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1MultiPolygon-members.html b/doxygen/classgeos_1_1geom_1_1MultiPolygon-members.html index 5ca8f86404..fd200444c7 100644 --- a/doxygen/classgeos_1_1geom_1_1MultiPolygon-members.html +++ b/doxygen/classgeos_1_1geom_1_1MultiPolygon-members.html @@ -74,7 +74,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1Point-members.html b/doxygen/classgeos_1_1geom_1_1Point-members.html index 4158a9c342..66e71bfdac 100644 --- a/doxygen/classgeos_1_1geom_1_1Point-members.html +++ b/doxygen/classgeos_1_1geom_1_1Point-members.html @@ -72,7 +72,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1Polygon-members.html b/doxygen/classgeos_1_1geom_1_1Polygon-members.html index bfa74bcbf2..e862b7c370 100644 --- a/doxygen/classgeos_1_1geom_1_1Polygon-members.html +++ b/doxygen/classgeos_1_1geom_1_1Polygon-members.html @@ -71,7 +71,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1Surface-members.html b/doxygen/classgeos_1_1geom_1_1Surface-members.html index e5a1344605..6f60846788 100644 --- a/doxygen/classgeos_1_1geom_1_1Surface-members.html +++ b/doxygen/classgeos_1_1geom_1_1Surface-members.html @@ -71,7 +71,7 @@ - + diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry-members.html b/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry-members.html index 2346be88dc..781f57bb71 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry-members.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry-members.html @@ -67,6 +67,8 @@ + + diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry.html b/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry.html index a59bfb13fc..cc8325559c 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1BasicPreparedGeometry.html @@ -81,6 +81,8 @@ + + @@ -99,8 +101,10 @@ - - + + + + @@ -617,6 +621,74 @@

geos::geom::prep::PreparedGeometry.

+ + + +

◆ relate() [1/2]

+ +
+
+
add(IntersectionMatrix *other)geos::geom::IntersectionMatrix
get(geom::Location row, geom::Location column) constgeos::geom::IntersectionMatrixinline
get(Location row, Location column) constgeos::geom::IntersectionMatrixinline
IntersectionMatrix()geos::geom::IntersectionMatrix
IntersectionMatrix(const std::string &elements)geos::geom::IntersectionMatrix
IntersectionMatrix(const IntersectionMatrix &other)geos::geom::IntersectionMatrix
void setAll (int dimensionValue)
 Changes the elements of this IntersectionMatrix to dimensionValue. More...
 
int get (geom::Location row, geom::Location column) const
 Returns the value of one of this IntersectionMatrixs elements. More...
 
int get (Location row, Location column) const
 Returns the value of one of this IntersectionMatrixs elements. More...
 
bool isDisjoint () const
 Returns true if this IntersectionMatrix is FF*FF****. More...
 
(geom::Location Location  row,
geom::Location Location  column 
ConstVect typedefgeos::geom::LineString
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
Curve(const GeometryFactory &factory) (defined in geos::geom::Curve)geos::geom::Curveinlineprotected
ConstVect typedefgeos::geom::LineString
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
Curve(const GeometryFactory &factory) (defined in geos::geom::Curve)geos::geom::Curveinlineprotected
ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
ConstVect typedefgeos::geom::Point
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() constgeos::geom::Geometryvirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
difference(const Geometry *other) constgeos::geom::Geometry
ConstVect typedefgeos::geom::Polygon
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() const overridegeos::geom::Surfacevirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
createEmptyRing(const GeometryFactory &) (defined in geos::geom::Surface)geos::geom::Surfaceprotectedstatic
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
ConstVect typedefgeos::geom::Geometry
contains(const Geometry *g) constgeos::geom::Geometryvirtual
convexHull() const overridegeos::geom::Surfacevirtual
coveredBy(const Geometry *g) constgeos::geom::Geometryinline
coveredBy(const Geometry *g) constgeos::geom::Geometry
covers(const Geometry *g) constgeos::geom::Geometry
createEmptyRing(const GeometryFactory &) (defined in geos::geom::Surface)geos::geom::Surfaceprotectedstatic
crosses(const Geometry *g) constgeos::geom::Geometryvirtual
isWithinDistance(const geom::Geometry *geom, double dist) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
nearestPoints(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
overlaps(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
relate(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
relate(const geom::Geometry *g, const std::string &pat) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
setGeometry(const geom::Geometry *geom)geos::geom::prep::BasicPreparedGeometryprotected
toString() (defined in geos::geom::prep::BasicPreparedGeometry)geos::geom::prep::BasicPreparedGeometry
touches(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual
 
bool isAnyTargetComponentInTest (const geom::Geometry *testGeom) const
 
bool within (const geom::Geometry *g) const override
 
bool contains (const geom::Geometry *g) const override
 
bool containsProperly (const geom::Geometry *g) const override
 
bool touches (const geom::Geometry *g) const override
 
bool within (const geom::Geometry *g) const override
 
std::unique_ptr< IntersectionMatrix > relate (const geom::Geometry *g) const override
 
bool relate (const geom::Geometry *g, const std::string &pat) const override
 
std::unique_ptr< geom::CoordinateSequence > nearestPoints (const geom::Geometry *g) const override
 
double distance (const geom::Geometry *g) const override
+ + + + +
+ + + + + + + + +
std::unique_ptr<IntersectionMatrix> geos::geom::prep::BasicPreparedGeometry::relate (const geom::Geometry * g) const
+ 		+overridevirtual
+
+

Default implementation.

+ +

Implements geos::geom::prep::PreparedGeometry.

+ +
+ + +

◆ relate() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool geos::geom::prep::BasicPreparedGeometry::relate (const geom::Geometry * g,
const std::string & pat 
) const
+ 		+overridevirtual
+
+

Default implementation.

+ +

Implements geos::geom::prep::PreparedGeometry.

+
diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry-members.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry-members.html index 8ee6ae3f45..32dc919ec6 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry-members.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry-members.html @@ -62,6 +62,8 @@ isWithinDistance(const geom::Geometry *geom, double dist) const =0geos::geom::prep::PreparedGeometrypure virtual nearestPoints(const geom::Geometry *geom) const =0geos::geom::prep::PreparedGeometrypure virtual overlaps(const geom::Geometry *geom) const =0geos::geom::prep::PreparedGeometrypure virtual + relate(const geom::Geometry *geom) const =0geos::geom::prep::PreparedGeometrypure virtual + relate(const geom::Geometry *geom, const std::string &pat) const =0geos::geom::prep::PreparedGeometrypure virtual touches(const geom::Geometry *geom) const =0geos::geom::prep::PreparedGeometrypure virtual within(const geom::Geometry *geom) const =0geos::geom::prep::PreparedGeometrypure virtual ~PreparedGeometry() (defined in geos::geom::prep::PreparedGeometry)geos::geom::prep::PreparedGeometryinlinevirtual diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry.html index f39af8278a..3b6cde2f19 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedGeometry.html @@ -112,6 +112,12 @@ virtual bool isWithinDistance (const geom::Geometry *geom, double dist) const =0  Tests whether the base Geometry is within a given distance from the given geometry. More...
  +virtual std::unique_ptr< IntersectionMatrix > relate (const geom::Geometry *geom) const =0 + Compares the prepared geometry to the given geometry and returns the DE9IM intersection matrix as a string. More...
+  +virtual bool relate (const geom::Geometry *geom, const std::string &pat) const =0 + Compares the prepared geometry to the given geometry and the provided DE9IM pattern, and returns true if the pattern is consistent with the relationship between the prepared and provided geometries. More...
+ 

Detailed Description

An interface for classes which prepare Geometrys in order to optimize the performance of repeated calls to specific geometric operations.

@@ -579,6 +585,91 @@

geos::geom::prep::BasicPreparedGeometry.

+

+ + +

◆ relate() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
virtual std::unique_ptr<IntersectionMatrix> geos::geom::prep::PreparedGeometry::relate (const geom::Geometry * geom) const
+ 		+pure virtual
+
+ +

Compares the prepared geometry to the given geometry and returns the DE9IM intersection matrix as a string.

+
Parameters
+ + +
geomthe Geometry to test the
+
+
+
Returns
the DE9IM matrix
+ +

Implemented in geos::geom::prep::BasicPreparedGeometry.

+ +
+
+ +

◆ relate() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual bool geos::geom::prep::PreparedGeometry::relate (const geom::Geometry * geom,
const std::string & pat 
) const
+ 		+pure virtual
+
+ +

Compares the prepared geometry to the given geometry and the provided DE9IM pattern, and returns true if the pattern is consistent with the relationship between the prepared and provided geometries.

+
Parameters
+ + + +
geomthe Geometry to test the distance to
patthe DE9IM pattern
+
+
+
Returns
true if the patterns are consistent
+ +

Implemented in geos::geom::prep::BasicPreparedGeometry.

+
diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString-members.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString-members.html index 03cb369ff8..7f46541ab0 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString-members.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString-members.html @@ -70,6 +70,8 @@ nearestPoints(const geom::Geometry *g) const overridegeos::geom::prep::PreparedLineStringvirtual overlaps(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual PreparedLineString(const Geometry *geom) (defined in geos::geom::prep::PreparedLineString)geos::geom::prep::PreparedLineStringinline + relate(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual + relate(const geom::Geometry *g, const std::string &pat) const overridegeos::geom::prep::BasicPreparedGeometryvirtual setGeometry(const geom::Geometry *geom)geos::geom::prep::BasicPreparedGeometryprotected toString() (defined in geos::geom::prep::BasicPreparedGeometry)geos::geom::prep::BasicPreparedGeometry touches(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString.html index 6dbc4783a4..197432f39c 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedLineString.html @@ -96,6 +96,8 @@   bool isAnyTargetComponentInTest (const geom::Geometry *testGeom) const   +bool within (const geom::Geometry *g) const override +  bool contains (const geom::Geometry *g) const override   bool containsProperly (const geom::Geometry *g) const override @@ -112,8 +114,10 @@   bool touches (const geom::Geometry *g) const override   -bool within (const geom::Geometry *g) const override -  +std::unique_ptr< IntersectionMatrix > relate (const geom::Geometry *g) const override +  +bool relate (const geom::Geometry *g, const std::string &pat) const override +  std::string toString ()   diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint-members.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint-members.html index 0c5aaa0a83..7a190d36ce 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint-members.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint-members.html @@ -68,6 +68,8 @@ nearestPoints(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual overlaps(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual PreparedPoint(const Geometry *geom) (defined in geos::geom::prep::PreparedPoint)geos::geom::prep::PreparedPointinline + relate(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual + relate(const geom::Geometry *g, const std::string &pat) const overridegeos::geom::prep::BasicPreparedGeometryvirtual setGeometry(const geom::Geometry *geom)geos::geom::prep::BasicPreparedGeometryprotected toString() (defined in geos::geom::prep::BasicPreparedGeometry)geos::geom::prep::BasicPreparedGeometry touches(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint.html index 05f9cd48b4..a93bb4af32 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPoint.html @@ -84,6 +84,8 @@   bool isAnyTargetComponentInTest (const geom::Geometry *testGeom) const   +bool within (const geom::Geometry *g) const override +  bool contains (const geom::Geometry *g) const override   bool containsProperly (const geom::Geometry *g) const override @@ -100,8 +102,10 @@   bool touches (const geom::Geometry *g) const override   -bool within (const geom::Geometry *g) const override -  +std::unique_ptr< IntersectionMatrix > relate (const geom::Geometry *g) const override +  +bool relate (const geom::Geometry *g, const std::string &pat) const override +  std::unique_ptr< geom::CoordinateSequence > nearestPoints (const geom::Geometry *g) const override   double distance (const geom::Geometry *g) const override diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon-members.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon-members.html index e4544dacea..182943b3f5 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon-members.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon-members.html @@ -71,6 +71,8 @@ nearestPoints(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual overlaps(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual PreparedPolygon(const geom::Geometry *geom) (defined in geos::geom::prep::PreparedPolygon)geos::geom::prep::PreparedPolygon + relate(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual + relate(const geom::Geometry *g, const std::string &pat) const overridegeos::geom::prep::BasicPreparedGeometryvirtual setGeometry(const geom::Geometry *geom)geos::geom::prep::BasicPreparedGeometryprotected toString() (defined in geos::geom::prep::BasicPreparedGeometry)geos::geom::prep::BasicPreparedGeometry touches(const geom::Geometry *g) const overridegeos::geom::prep::BasicPreparedGeometryvirtual diff --git a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon.html b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon.html index 0b0cf058d3..05741d9cd3 100644 --- a/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon.html +++ b/doxygen/classgeos_1_1geom_1_1prep_1_1PreparedPolygon.html @@ -103,6 +103,8 @@   bool isAnyTargetComponentInTest (const geom::Geometry *testGeom) const   +bool within (const geom::Geometry *g) const override +  bool coveredBy (const geom::Geometry *g) const override   bool crosses (const geom::Geometry *g) const override @@ -113,8 +115,10 @@   bool touches (const geom::Geometry *g) const override   -bool within (const geom::Geometry *g) const override -  +std::unique_ptr< IntersectionMatrix > relate (const geom::Geometry *g) const override +  +bool relate (const geom::Geometry *g, const std::string &pat) const override +  std::unique_ptr< geom::CoordinateSequence > nearestPoints (const geom::Geometry *g) const override   diff --git a/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister-members.html b/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister-members.html new file mode 100644 index 0000000000..ab179483bc --- /dev/null +++ b/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister-members.html @@ -0,0 +1,60 @@ + + + + + + + +GEOS: Member List + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
geos::geom::util::GeometryLister Member List
+
+
+ +

This is the complete list of members for geos::geom::util::GeometryLister, including all inherited members.

+ + +
list(const Geometry *geom, std::vector< const Geometry * > &lst)geos::geom::util::GeometryListerinlinestatic
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister.html b/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister.html new file mode 100644 index 0000000000..3afb72a9f2 --- /dev/null +++ b/doxygen/classgeos_1_1geom_1_1util_1_1GeometryLister.html @@ -0,0 +1,118 @@ + + + + + + + +GEOS: geos::geom::util::GeometryLister Class Reference + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+Static Public Member Functions | +List of all members
+
+
geos::geom::util::GeometryLister Class Reference
+
+
+ +

#include <GeometryLister.h>

+ + + + +

+Static Public Member Functions

static void list (const Geometry *geom, std::vector< const Geometry * > &lst)
 
+

Detailed Description

+

Extracts all the components of a collection, or just echoes back a pointers to singletons.

+

Member Function Documentation

+ +

◆ list()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void geos::geom::util::GeometryLister::list (const Geometry * geom,
std::vector< const Geometry * > & lst 
)
+ 		+inlinestatic
+
+

Extracts the components from a Geometry and adds them to the provided container.

+

Useful for iterating over components of a collection.

+
Parameters
+ + + +
geomthe geometry from which to extract
lstthe list to add the extracted elements to
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/classgeos_1_1geomgraph_1_1index_1_1EdgeSetIntersector.html b/doxygen/classgeos_1_1geomgraph_1_1index_1_1EdgeSetIntersector.html index 38d7ed285b..c5bf124853 100644 --- a/doxygen/classgeos_1_1geomgraph_1_1index_1_1EdgeSetIntersector.html +++ b/doxygen/classgeos_1_1geomgraph_1_1index_1_1EdgeSetIntersector.html @@ -54,7 +54,7 @@

An EdgeSetIntersector computes all the intersections between the edges in the set. More...

-

#include <EdgeSetIntersector.h>

+

#include <EdgeSetIntersector.h>

Inheritance diagram for geos::geomgraph::index::EdgeSetIntersector:
@@ -136,7 +136,7 @@

EdgeSetIntersector.h +
  • geomgraph/index/EdgeSetIntersector.h

    • diff --git a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain-members.html b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain-members.html index cc3194c5a8..bf3c71e164 100644 --- a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain-members.html +++ b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain-members.html @@ -57,10 +57,12 @@ getEndIndex() const (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChaininline getEnvelope() constgeos::index::chain::MonotoneChain getEnvelope(double expansionDistance) const (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChain - getLineSegment(std::size_t index, geom::LineSegment &ls) constgeos::index::chain::MonotoneChaininline - getStartIndex() const (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChaininline - MonotoneChain(const geom::CoordinateSequence &pts, std::size_t start, std::size_t end, void *context)geos::index::chain::MonotoneChain - select(const geom::Envelope &searchEnv, MonotoneChainSelectAction &mcs) constgeos::index::chain::MonotoneChain + getId() const (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChaininline + getLineSegment(std::size_t index, geom::LineSegment &ls) constgeos::index::chain::MonotoneChaininline + getStartIndex() const (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChaininline + MonotoneChain(const geom::CoordinateSequence &pts, std::size_t start, std::size_t end, void *context)geos::index::chain::MonotoneChain + select(const geom::Envelope &searchEnv, MonotoneChainSelectAction &mcs) constgeos::index::chain::MonotoneChain + setId(int p_id) (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChaininline ~MonotoneChain()=default (defined in geos::index::chain::MonotoneChain)geos::index::chain::MonotoneChain diff --git a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain.html b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain.html index a8f3a71465..0598ca13f2 100644 --- a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain.html +++ b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChain.html @@ -90,6 +90,12 @@ void * getContext () const   + +void setId (int p_id) +  + +int getId () const + 

    Detailed Description

    Monotone Chains are a way of partitioning the segments of a linestring to allow for fast searching of intersections.

    diff --git a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.html b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.html index 2d71dbbc74..bed6617800 100644 --- a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.html +++ b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.html @@ -56,8 +56,15 @@ More...

    #include <MonotoneChainOverlapAction.h>

    - -

    Inherited by geos::noding::MCIndexNoder::SegmentOverlapAction, and geos::noding::MCIndexSegmentSetMutualIntersector::SegmentOverlapAction.

    +
    +Inheritance diagram for geos::index::chain::MonotoneChainOverlapAction:
    +
    +
    + + +geos::operation::relateng::EdgeSegmentOverlapAction + +
    @@ -176,6 +183,8 @@

    geos::operation::relateng::EdgeSegmentOverlapAction.

    +
    The documentation for this class was generated from the following file:
      diff --git a/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.png b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.png new file mode 100644 index 0000000000..538a57a1ac Binary files /dev/null and b/doxygen/classgeos_1_1index_1_1chain_1_1MonotoneChainOverlapAction.png differ diff --git a/doxygen/classgeos_1_1index_1_1strtree_1_1TemplateSTRtreeImpl.html b/doxygen/classgeos_1_1index_1_1strtree_1_1TemplateSTRtreeImpl.html index b0454f13eb..25d0ae7553 100644 --- a/doxygen/classgeos_1_1index_1_1strtree_1_1TemplateSTRtreeImpl.html +++ b/doxygen/classgeos_1_1index_1_1strtree_1_1TemplateSTRtreeImpl.html @@ -60,7 +60,7 @@

      #include <TemplateSTRtree.h>

      -

      Inherited by geos::index::strtree::TemplateSTRtree< const Edge * >, geos::index::strtree::TemplateSTRtree< SegmentView, index::strtree::IntervalTraits >, geos::index::strtree::TemplateSTRtree< const FacetSequence * >, geos::index::strtree::TemplateSTRtree< const geos::index::chain::MonotoneChain * >, geos::index::strtree::TemplateSTRtree< const geos::geom::LinearRing * >, geos::index::strtree::TemplateSTRtree< geos::operation::polygonize::EdgeRing * >, and geos::index::strtree::TemplateSTRtree< IndexedPointInAreaLocator * >.

      +

      Inherited by geos::index::strtree::TemplateSTRtree< const Edge * >, geos::index::strtree::TemplateSTRtree< SegmentView, index::strtree::IntervalTraits >, geos::index::strtree::TemplateSTRtree< const FacetSequence * >, geos::index::strtree::TemplateSTRtree< const geos::index::chain::MonotoneChain * >, geos::index::strtree::TemplateSTRtree< const geos::geom::LinearRing * >, geos::index::strtree::TemplateSTRtree< geos::operation::polygonize::EdgeRing * >, geos::index::strtree::TemplateSTRtree< const MonotoneChain * >, and geos::index::strtree::TemplateSTRtree< IndexedPointInAreaLocator * >.

    Public Member Functions

    diff --git a/doxygen/classgeos_1_1io_1_1WKTWriter-members.html b/doxygen/classgeos_1_1io_1_1WKTWriter-members.html index 4534529648..f2f81fb08f 100644 --- a/doxygen/classgeos_1_1io_1_1WKTWriter-members.html +++ b/doxygen/classgeos_1_1io_1_1WKTWriter-members.html @@ -78,7 +78,7 @@ - + diff --git a/doxygen/classgeos_1_1io_1_1WKTWriter.html b/doxygen/classgeos_1_1io_1_1WKTWriter.html index fd0bca46cc..0ac1c6c5dc 100644 --- a/doxygen/classgeos_1_1io_1_1WKTWriter.html +++ b/doxygen/classgeos_1_1io_1_1WKTWriter.html @@ -97,8 +97,8 @@ Static Public Member Functions - - + + - - - - - - - - - - + + - -

    Public Types

    setRoundingPrecision(int p0)geos::io::WKTWriter
    setTrim(bool p0)geos::io::WKTWriter
    toLineString(const geom::CoordinateSequence &seq)geos::io::WKTWriterstatic
    toLineString(const geom::Coordinate &p0, const geom::Coordinate &p1)geos::io::WKTWriterstatic
    toLineString(const geom::CoordinateXY &p0, const geom::CoordinateXY &p1)geos::io::WKTWriterstatic
    toPoint(const geom::Coordinate &p0)geos::io::WKTWriterstatic
    toPoint(const geom::CoordinateXY &p0) (defined in geos::io::WKTWriter)geos::io::WKTWriterstatic
    WKTWriter() (defined in geos::io::WKTWriter)geos::io::WKTWriter
    static std::string toLineString (const geom::CoordinateSequence &seq)
     
    static std::string toLineString (const geom::Coordinate &p0, const geom::Coordinate &p1)
     
    static std::string toLineString (const geom::CoordinateXY &p0, const geom::CoordinateXY &p1)
     
    static std::string toPoint (const geom::Coordinate &p0)
     
    @@ -309,8 +309,8 @@

    -

    ◆ toLineString() [1/2]

    + +

    ◆ toLineString() [1/2]

    @@ -321,19 +321,9 @@

    static std::string geos::io::WKTWriter::toLineString

    		(const geom::Coordinate & p0,
    const geom::Coordinate & p1 
    const geom::CoordinateSequence & seq) )
    @@ -342,11 +332,10 @@

    -

    Generates the WKT for a 2-point LineString.

    +

    Generates the WKT for a N-point LineString.

    Parameters
    - - +
    p0the first coordinate
    p1the second coordinate
    seqthe sequence to outpout
    @@ -354,8 +343,8 @@

    -

    ◆ toLineString() [2/2]

    + +

    ◆ toLineString() [2/2]

    @@ -366,9 +355,19 @@

    static std::string geos::io::WKTWriter::toLineString ( - const geom::CoordinateSequence &  - seq) + const geom::CoordinateXY &  + p0, + + + + const geom::CoordinateXY &  + p1  + + + + ) + @@ -377,10 +376,11 @@

    -

    Generates the WKT for a N-point LineString.

    +

    Generates the WKT for a 2-point LineString.

    Parameters
    - + +
    seqthe sequence to outpout
    p0the first coordinate
    p1the second coordinate
    diff --git a/doxygen/classgeos_1_1noding_1_1BasicSegmentString-members.html b/doxygen/classgeos_1_1noding_1_1BasicSegmentString-members.html index 4fb692c2fa..df24cd588a 100644 --- a/doxygen/classgeos_1_1noding_1_1BasicSegmentString-members.html +++ b/doxygen/classgeos_1_1noding_1_1BasicSegmentString-members.html @@ -59,7 +59,9 @@     getSegmentOctant(std::size_t index) constgeos::noding::BasicSegmentStringinline getSegmentOctant(const SegmentString &ss, std::size_t index) (defined in geos::noding::SegmentString)geos::noding::SegmentStringinlinestatic isClosed() const (defined in geos::noding::SegmentString)geos::noding::SegmentStringinline - NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + nextInRing(std::size_t index) constgeos::noding::SegmentStringinline + NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + prevInRing(std::size_t index) constgeos::noding::SegmentStringinline print(std::ostream &os) const override (defined in geos::noding::BasicSegmentString)geos::noding::BasicSegmentStringvirtual SegmentString(const void *newContext, geom::CoordinateSequence *newSeq)geos::noding::SegmentStringinline seq (defined in geos::noding::SegmentString)geos::noding::SegmentStringprotected diff --git a/doxygen/classgeos_1_1noding_1_1BasicSegmentString.html b/doxygen/classgeos_1_1noding_1_1BasicSegmentString.html index 84dbd5f033..38a19cd2b1 100644 --- a/doxygen/classgeos_1_1noding_1_1BasicSegmentString.html +++ b/doxygen/classgeos_1_1noding_1_1BasicSegmentString.html @@ -102,6 +102,10 @@ int getSegmentOctant (std::size_t index) const  Gets the octant of the segment starting at vertex index. More...
      +const geom::CoordinateXY & nextInRing (std::size_t index) const +  +const geom::CoordinateXY & prevInRing (std::size_t index) const +  bool isClosed () const   diff --git a/doxygen/classgeos_1_1noding_1_1NodableSegmentString-members.html b/doxygen/classgeos_1_1noding_1_1NodableSegmentString-members.html index dcfce78d1d..8e976ae0ff 100644 --- a/doxygen/classgeos_1_1noding_1_1NodableSegmentString-members.html +++ b/doxygen/classgeos_1_1noding_1_1NodableSegmentString-members.html @@ -58,8 +58,10 @@ getSegmentOctant(std::size_t index) constgeos::noding::SegmentStringinline getSegmentOctant(const SegmentString &ss, std::size_t index) (defined in geos::noding::SegmentString)geos::noding::SegmentStringinlinestatic isClosed() const (defined in geos::noding::SegmentString)geos::noding::SegmentStringinline - NodableSegmentString(const void *newContext, geom::CoordinateSequence *newSeq) (defined in geos::noding::NodableSegmentString)geos::noding::NodableSegmentStringinline - NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + nextInRing(std::size_t index) constgeos::noding::SegmentStringinline + NodableSegmentString(const void *newContext, geom::CoordinateSequence *newSeq) (defined in geos::noding::NodableSegmentString)geos::noding::NodableSegmentStringinline + NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + prevInRing(std::size_t index) constgeos::noding::SegmentStringinline print(std::ostream &os) const (defined in geos::noding::SegmentString)geos::noding::SegmentStringvirtual SegmentString(const void *newContext, geom::CoordinateSequence *newSeq)geos::noding::SegmentStringinline seq (defined in geos::noding::SegmentString)geos::noding::SegmentStringprotected diff --git a/doxygen/classgeos_1_1noding_1_1NodableSegmentString.html b/doxygen/classgeos_1_1noding_1_1NodableSegmentString.html index 6503ff7a1b..31d7c01294 100644 --- a/doxygen/classgeos_1_1noding_1_1NodableSegmentString.html +++ b/doxygen/classgeos_1_1noding_1_1NodableSegmentString.html @@ -97,6 +97,10 @@ int getSegmentOctant (std::size_t index) const  Gets the octant of the segment starting at vertex index. More...
      +const geom::CoordinateXY & nextInRing (std::size_t index) const +  +const geom::CoordinateXY & prevInRing (std::size_t index) const +  bool isClosed () const   diff --git a/doxygen/classgeos_1_1noding_1_1NodedSegmentString-members.html b/doxygen/classgeos_1_1noding_1_1NodedSegmentString-members.html index 655b174180..ef5cc90842 100644 --- a/doxygen/classgeos_1_1noding_1_1NodedSegmentString-members.html +++ b/doxygen/classgeos_1_1noding_1_1NodedSegmentString-members.html @@ -69,10 +69,12 @@ getSegmentOctant(const SegmentString &ss, std::size_t index) (defined in geos::noding::SegmentString)geos::noding::SegmentStringinlinestatic hasNodes() const (defined in geos::noding::NodedSegmentString)geos::noding::NodedSegmentStringinline isClosed() const (defined in geos::noding::SegmentString)geos::noding::SegmentStringinline - NodableSegmentString(const void *newContext, geom::CoordinateSequence *newSeq) (defined in geos::noding::NodableSegmentString)geos::noding::NodableSegmentStringinline - NodedSegmentString(geom::CoordinateSequence *newPts, bool constructZ, bool constructM, const void *newContext)geos::noding::NodedSegmentStringinline - NodedSegmentString(SegmentString *ss, bool constructZ, bool constructM) (defined in geos::noding::NodedSegmentString)geos::noding::NodedSegmentStringinline - NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + nextInRing(std::size_t index) constgeos::noding::SegmentStringinline + NodableSegmentString(const void *newContext, geom::CoordinateSequence *newSeq) (defined in geos::noding::NodableSegmentString)geos::noding::NodableSegmentStringinline + NodedSegmentString(geom::CoordinateSequence *newPts, bool constructZ, bool constructM, const void *newContext)geos::noding::NodedSegmentStringinline + NodedSegmentString(SegmentString *ss, bool constructZ, bool constructM) (defined in geos::noding::NodedSegmentString)geos::noding::NodedSegmentStringinline + NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + prevInRing(std::size_t index) constgeos::noding::SegmentStringinline print(std::ostream &os) const override (defined in geos::noding::NodedSegmentString)geos::noding::NodedSegmentStringvirtual releaseCoordinates() (defined in geos::noding::NodedSegmentString)geos::noding::NodedSegmentString SegmentString(const void *newContext, geom::CoordinateSequence *newSeq)geos::noding::SegmentStringinline diff --git a/doxygen/classgeos_1_1noding_1_1NodedSegmentString.html b/doxygen/classgeos_1_1noding_1_1NodedSegmentString.html index fc387d52eb..2e54a7eb47 100644 --- a/doxygen/classgeos_1_1noding_1_1NodedSegmentString.html +++ b/doxygen/classgeos_1_1noding_1_1NodedSegmentString.html @@ -134,6 +134,10 @@ int getSegmentOctant (std::size_t index) const  Gets the octant of the segment starting at vertex index. More...
      +const geom::CoordinateXY & nextInRing (std::size_t index) const +  +const geom::CoordinateXY & prevInRing (std::size_t index) const +  bool isClosed () const   diff --git a/doxygen/classgeos_1_1noding_1_1SegmentString-members.html b/doxygen/classgeos_1_1noding_1_1SegmentString-members.html index a549a1e606..989b40fd04 100644 --- a/doxygen/classgeos_1_1noding_1_1SegmentString-members.html +++ b/doxygen/classgeos_1_1noding_1_1SegmentString-members.html @@ -58,8 +58,10 @@ getSegmentOctant(std::size_t index) constgeos::noding::SegmentStringinline getSegmentOctant(const SegmentString &ss, std::size_t index) (defined in geos::noding::SegmentString)geos::noding::SegmentStringinlinestatic isClosed() const (defined in geos::noding::SegmentString)geos::noding::SegmentStringinline - NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString - operator<< (defined in geos::noding::SegmentString)geos::noding::SegmentStringfriend + nextInRing(std::size_t index) constgeos::noding::SegmentStringinline + NonConstVect typedef (defined in geos::noding::SegmentString)geos::noding::SegmentString + operator<< (defined in geos::noding::SegmentString)geos::noding::SegmentStringfriend + prevInRing(std::size_t index) constgeos::noding::SegmentStringinline print(std::ostream &os) const (defined in geos::noding::SegmentString)geos::noding::SegmentStringvirtual SegmentString(const void *newContext, geom::CoordinateSequence *newSeq)geos::noding::SegmentStringinline seq (defined in geos::noding::SegmentString)geos::noding::SegmentStringprotected diff --git a/doxygen/classgeos_1_1noding_1_1SegmentString.html b/doxygen/classgeos_1_1noding_1_1SegmentString.html index a0b3012f38..e17d395e2b 100644 --- a/doxygen/classgeos_1_1noding_1_1SegmentString.html +++ b/doxygen/classgeos_1_1noding_1_1SegmentString.html @@ -107,6 +107,10 @@ int getSegmentOctant (std::size_t index) const  Gets the octant of the segment starting at vertex index. More...
      +const geom::CoordinateXY & nextInRing (std::size_t index) const +  +const geom::CoordinateXY & prevInRing (std::size_t index) const +  bool isClosed () const   @@ -272,6 +276,76 @@

    Returns
    the octant of the segment at the vertex
    +

    +
    + +

    ◆ nextInRing()

    + +
    +
    + + + + + +
    + + + + + + + + +
    const geom::CoordinateXY& geos::noding::SegmentString::nextInRing (std::size_t index) const
    +     		+inline
    +
    +

    Gets the next vertex in a ring from a vertex index.

    +
    Parameters
    + + +
    indexthe vertex index
    +
    +
    +
    Returns
    the next vertex in the ring
    +
    See also
    isClosed
    + +
    +
    + +

    ◆ prevInRing()

    + +
    +
    + + + + + +
    + + + + + + + + +
    const geom::CoordinateXY& geos::noding::SegmentString::prevInRing (std::size_t index) const
    +     		+inline
    +
    +

    Gets the previous vertex in a ring from a vertex index.

    +
    Parameters
    + + +
    indexthe vertex index
    +
    +
    +
    Returns
    the previous vertex in the ring
    +
    See also
    isClosed
    +
    diff --git a/doxygen/classgeos_1_1operation_1_1relate_1_1RelateNode.html b/doxygen/classgeos_1_1operation_1_1relate_1_1RelateNode.html index 81c3df1e9b..64381a6bf1 100644 --- a/doxygen/classgeos_1_1operation_1_1relate_1_1RelateNode.html +++ b/doxygen/classgeos_1_1operation_1_1relate_1_1RelateNode.html @@ -55,7 +55,7 @@

    Represents a node in the topological graph used to compute spatial relationships. More...

    -

    #include <RelateNode.h>

    +

    #include <RelateNode.h>

    Inheritance diagram for geos::operation::relate::RelateNode:
    @@ -204,7 +204,7 @@

    RelateNode.h +
  • relate/RelateNode.h

    • diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator-members.html new file mode 100644 index 0000000000..789eb5461f --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator-members.html @@ -0,0 +1,63 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::AdjacentEdgeLocator Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::AdjacentEdgeLocator, including all inherited members.

    + + + + + +
    AdjacentEdgeLocator(const Geometry *geom) (defined in geos::operation::relateng::AdjacentEdgeLocator)geos::operation::relateng::AdjacentEdgeLocatorinline
    AdjacentEdgeLocator(const AdjacentEdgeLocator &)=deletegeos::operation::relateng::AdjacentEdgeLocator
    locate(const CoordinateXY *p) (defined in geos::operation::relateng::AdjacentEdgeLocator)geos::operation::relateng::AdjacentEdgeLocator
    operator=(const AdjacentEdgeLocator &)=delete (defined in geos::operation::relateng::AdjacentEdgeLocator)geos::operation::relateng::AdjacentEdgeLocator
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator.html new file mode 100644 index 0000000000..51477a0055 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1AdjacentEdgeLocator.html @@ -0,0 +1,110 @@ + + + + + + + +GEOS: geos::operation::relateng::AdjacentEdgeLocator Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    geos::operation::relateng::AdjacentEdgeLocator Class Reference
    +
    +
    + +

    #include <AdjacentEdgeLocator.h>

    + + + + + + + + + + +

    +Public Member Functions

    + AdjacentEdgeLocator (const Geometry *geom)
     
    +Location locate (const CoordinateXY *p)
     
     AdjacentEdgeLocator (const AdjacentEdgeLocator &)=delete
     
    +AdjacentEdgeLocator & operator= (const AdjacentEdgeLocator &)=delete
     
    +

    Detailed Description

    +

    Determines the location for a point which is known to lie on at least one edge of a set of polygons. This provides the union-semantics for determining point location in a GeometryCollection, which may have polygons with adjacent edges which are effectively in the interior of the geometry. Note that it is also possible to have adjacent edges which lie on the boundary of the geometry (e.g. a polygon contained within another polygon with adjacent edges).

    +
    Author
    mdavis
    +

    Constructor & Destructor Documentation

    + +

    ◆ AdjacentEdgeLocator()

    + +
    +
    + + + + + +
    + + + + + + + + +
    geos::operation::relateng::AdjacentEdgeLocator::AdjacentEdgeLocator (const AdjacentEdgeLocator & )
    +     		+delete
    +
    +

    Disable copy construction and assignment. Apparently needed to make this class compile under MSVC. (See https://stackoverflow.com/q/29565299)

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction-members.html new file mode 100644 index 0000000000..25ee2d3104 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction-members.html @@ -0,0 +1,66 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::EdgeSegmentOverlapAction Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::EdgeSegmentOverlapAction, including all inherited members.

    + + + + + + + + +
    EdgeSegmentOverlapAction(SegmentIntersector &p_si) (defined in geos::operation::relateng::EdgeSegmentOverlapAction)geos::operation::relateng::EdgeSegmentOverlapActioninline
    MonotoneChainOverlapAction() (defined in geos::index::chain::MonotoneChainOverlapAction)geos::index::chain::MonotoneChainOverlapActioninline
    overlap(const MonotoneChain &mc1, std::size_t start1, const MonotoneChain &mc2, std::size_t start2) overridegeos::operation::relateng::EdgeSegmentOverlapActionvirtual
    geos::index::chain::MonotoneChainOverlapAction::overlap(const geom::LineSegment &, const geom::LineSegment &)geos::index::chain::MonotoneChainOverlapActioninlinevirtual
    overlapSeg1 (defined in geos::index::chain::MonotoneChainOverlapAction)geos::index::chain::MonotoneChainOverlapActionprotected
    overlapSeg2 (defined in geos::index::chain::MonotoneChainOverlapAction)geos::index::chain::MonotoneChainOverlapActionprotected
    ~MonotoneChainOverlapAction() (defined in geos::index::chain::MonotoneChainOverlapAction)geos::index::chain::MonotoneChainOverlapActioninlinevirtual
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.html new file mode 100644 index 0000000000..307f2a99dc --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.html @@ -0,0 +1,164 @@ + + + + + + + +GEOS: geos::operation::relateng::EdgeSegmentOverlapAction Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    geos::operation::relateng::EdgeSegmentOverlapAction Class Reference
    +
    +
    + +

    The action for the internal iterator for performing overlap queries on a MonotoneChain. + More...

    + +

    #include <EdgeSegmentOverlapAction.h>

    +
    +Inheritance diagram for geos::operation::relateng::EdgeSegmentOverlapAction:
    +
    +
    + + +geos::index::chain::MonotoneChainOverlapAction + +
    + + + + + + + + + + + +

    +Public Member Functions

    + EdgeSegmentOverlapAction (SegmentIntersector &p_si)
     
    void overlap (const MonotoneChain &mc1, std::size_t start1, const MonotoneChain &mc2, std::size_t start2) override
     This function can be overridden if the original chains are needed. More...
     
    - Public Member Functions inherited from geos::index::chain::MonotoneChainOverlapAction
    virtual void overlap (const geom::LineSegment &, const geom::LineSegment &)
     This is a convenience function which can be overridden to obtain the actual line segments which overlap. More...
     
    + + + + + + +

    +Additional Inherited Members

    - Protected Attributes inherited from geos::index::chain::MonotoneChainOverlapAction
    +geom::LineSegment overlapSeg1
     
    +geom::LineSegment overlapSeg2
     
    +

    Detailed Description

    +

    The action for the internal iterator for performing overlap queries on a MonotoneChain.

    +

    Member Function Documentation

    + +

    ◆ overlap()

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    void geos::operation::relateng::EdgeSegmentOverlapAction::overlap (const MonotoneChain & mc1,
    std::size_t start1,
    const MonotoneChain & mc2,
    std::size_t start2 
    )
    +     		+overridevirtual
    +
    + +

    This function can be overridden if the original chains are needed.

    +
    Parameters
    + + + + + +
    mc1a MonotoneChain
    mc2a MonotoneChain
    start1the index of the start of the overlapping segment from mc1
    start2the index of the start of the overlapping segment from mc2
    +
    +
    + +

    Reimplemented from geos::index::chain::MonotoneChainOverlapAction.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.png b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.png new file mode 100644 index 0000000000..cd427e6182 Binary files /dev/null and b/doxygen/classgeos_1_1operation_1_1relateng_1_1EdgeSegmentOverlapAction.png differ diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection-members.html new file mode 100644 index 0000000000..c1422cc245 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection-members.html @@ -0,0 +1,80 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::NodeSection Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::NodeSection, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + +
    compareTo(const NodeSection &o) constgeos::operation::relateng::NodeSection
    dimension() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    edgeRep(const CoordinateXY *p0, const CoordinateXY *p1) (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectionstatic
    getPolygonal() constgeos::operation::relateng::NodeSection
    getVertex(int i) const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    id() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isA() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isArea() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isAreaArea(const NodeSection &a, const NodeSection &b) (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectionstatic
    isNodeAtVertex() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isProper() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isProper(const NodeSection &a, const NodeSection &b) (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectionstatic
    isSameGeometry(const NodeSection &ns) const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isSamePolygon(const NodeSection &ns) const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    isShell() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    nodePt() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    NodeSection(bool isA, int dim, int id, int ringId, const Geometry *poly, bool isNodeAtVertex, const CoordinateXY *v0, const CoordinateXY nodePt, const CoordinateXY *v1) (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectioninline
    NodeSection(const NodeSection *ns) (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectioninline
    operator<< (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSectionfriend
    ringId() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    toString() const (defined in geos::operation::relateng::NodeSection)geos::operation::relateng::NodeSection
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection.html new file mode 100644 index 0000000000..015b88247a --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1NodeSection.html @@ -0,0 +1,179 @@ + + + + + + + +GEOS: geos::operation::relateng::NodeSection Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Public Member Functions | +Static Public Member Functions | +Friends | +List of all members
    +
    +
    geos::operation::relateng::NodeSection Class Reference
    +
    +
    + +

    #include <NodeSection.h>

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    + NodeSection (bool isA, int dim, int id, int ringId, const Geometry *poly, bool isNodeAtVertex, const CoordinateXY *v0, const CoordinateXY nodePt, const CoordinateXY *v1)
     
    + NodeSection (const NodeSection *ns)
     
    +const CoordinateXY * getVertex (int i) const
     
    +const CoordinateXY & nodePt () const
     
    +int dimension () const
     
    +int id () const
     
    +int ringId () const
     
    const Geometry * getPolygonal () const
     
    +bool isShell () const
     
    +bool isArea () const
     
    +bool isA () const
     
    +bool isSameGeometry (const NodeSection &ns) const
     
    +bool isSamePolygon (const NodeSection &ns) const
     
    +bool isNodeAtVertex () const
     
    +bool isProper () const
     
    +std::string toString () const
     
    int compareTo (const NodeSection &o) const
     
    + + + + + + + +

    +Static Public Member Functions

    +static bool isAreaArea (const NodeSection &a, const NodeSection &b)
     
    +static bool isProper (const NodeSection &a, const NodeSection &b)
     
    +static std::string edgeRep (const CoordinateXY *p0, const CoordinateXY *p1)
     
    + + + +

    +Friends

    +std::ostream & operator<< (std::ostream &os, const NodeSection &ns)
     
    +

    Detailed Description

    +

    Represents a computed node along with the incident edges on either side of it (if they exist). This captures the information about a node in a geometry component required to determine the component's contribution to the node topology. A node in an area geometry always has edges on both sides of the node. A node in a linear geometry may have one or other incident edge missing, if the node occurs at an endpoint of the line. The edges of an area node are assumed to be provided with CW-shell orientation (as per JTS norm). This must be enforced by the caller.

    +
    Author
    Martin Davis
    +

    Member Function Documentation

    + +

    ◆ compareTo()

    + +
    +
    + + + + + + + + +
    int geos::operation::relateng::NodeSection::compareTo (const NodeSection & o) const
    +
    +

    Compare node sections by parent geometry, dimension, element id and ring id, and edge vertices. Sections are assumed to be at the same node point.

    + +
    +
    + +

    ◆ getPolygonal()

    + +
    +
    + + + + + + + +
    const Geometry* geos::operation::relateng::NodeSection::getPolygonal () const
    +
    +

    Gets the polygon this section is part of. Will be null if section is not on a polygon boundary.

    +
    Returns
    the associated polygon, or null
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter-members.html new file mode 100644 index 0000000000..45639404a2 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter-members.html @@ -0,0 +1,60 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::PolygonNodeConverter Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::PolygonNodeConverter, including all inherited members.

    + + +
    convert(std::vector< const NodeSection * > &polySections)geos::operation::relateng::PolygonNodeConverterstatic
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter.html new file mode 100644 index 0000000000..e41aafcae9 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1PolygonNodeConverter.html @@ -0,0 +1,111 @@ + + + + + + + +GEOS: geos::operation::relateng::PolygonNodeConverter Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Static Public Member Functions | +List of all members
    +
    +
    geos::operation::relateng::PolygonNodeConverter Class Reference
    +
    +
    + +

    #include <PolygonNodeConverter.h>

    + + + + +

    +Static Public Member Functions

    static std::vector< std::unique_ptr< NodeSection > > convert (std::vector< const NodeSection * > &polySections)
     
    +

    Detailed Description

    +

    Converts the node sections at a polygon node where a shell and one or more holes touch, or two or more holes touch. This converts the node topological structure from the OGC "touching-rings" (AKA "minimal-ring") model to the equivalent "self-touch" (AKA "inverted/exverted ring" or "maximal ring") model. In the "self-touch" model the converted NodeSection corners enclose areas which all lies inside the polygon (i.e. they does not enclose hole edges). This allows RelateNode to use simple area-additive semantics for adding edges and propagating edge locations.

    +

    The input node sections are assumed to have canonical orientation (CW shells and CCW holes). The arrangement of shells and holes must be topologically valid. Specifically, the node sections must not cross or be collinear.

    +

    This supports multiple shell-shell touches (including ones containing holes), and hole-hole touches, This generalizes the relate algorithm to support both the OGC model and the self-touch model.

    +
    Author
    Martin Davis
    +
    See also
    RelateNode
    +

    Member Function Documentation

    + +

    ◆ convert()

    + +
    +
    + + + + + +
    + + + + + + + + +
    static std::vector<std::unique_ptr<NodeSection> > geos::operation::relateng::PolygonNodeConverter::convert (std::vector< const NodeSection * > & polySections)
    +     		+static
    +
    +

    Converts a list of sections of valid polygon rings to have "self-touching" structure. There are the same number of output sections as input ones.

    +
    Parameters
    + + +
    polySectionsthe original sections
    +
    +
    +
    Returns
    the converted sections
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG-members.html new file mode 100644 index 0000000000..a5ed2b3796 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG-members.html @@ -0,0 +1,91 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::RelateNG Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::RelateNG, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    contains(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    contains(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    coveredBy(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    coveredBy(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    covers(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    covers(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    crosses(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    crosses(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    disjoint(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    disjoint(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    equalsTopo(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    equalsTopo(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    evaluate(const Geometry *b)geos::operation::relateng::RelateNG
    evaluate(const Geometry *b, const std::string &imPattern)geos::operation::relateng::RelateNG
    evaluate(const Geometry *b, TopologyPredicate &predicate)geos::operation::relateng::RelateNG
    intersects(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    intersects(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    overlaps(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    overlaps(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    prepare(const Geometry *a)geos::operation::relateng::RelateNGstatic
    prepare(const Geometry *a, const BoundaryNodeRule &bnRule)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const Geometry *b, TopologyPredicate &pred)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const Geometry *b, TopologyPredicate &pred, const BoundaryNodeRule &bnRule)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const Geometry *b, const std::string &imPattern)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const Geometry *b)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const Geometry *b, const BoundaryNodeRule &bnRule)geos::operation::relateng::RelateNGstatic
    relate(const Geometry *a, const std::string &pat) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    relate(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    touches(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    touches(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    within(const Geometry *a, const Geometry *b) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNGstatic
    within(const Geometry *a) (defined in geos::operation::relateng::RelateNG)geos::operation::relateng::RelateNG
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG.html new file mode 100644 index 0000000000..78f921c967 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelateNG.html @@ -0,0 +1,623 @@ + + + + + + + +GEOS: geos::operation::relateng::RelateNG Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Public Member Functions | +Static Public Member Functions | +List of all members
    +
    +
    geos::operation::relateng::RelateNG Class Reference
    +
    +
    + +

    #include <RelateNG.h>

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    std::unique_ptr< IntersectionMatrix > evaluate (const Geometry *b)
     
    bool evaluate (const Geometry *b, const std::string &imPattern)
     
    bool evaluate (const Geometry *b, TopologyPredicate &predicate)
     
    +bool intersects (const Geometry *a)
     
    +bool crosses (const Geometry *a)
     
    +bool disjoint (const Geometry *a)
     
    +bool touches (const Geometry *a)
     
    +bool within (const Geometry *a)
     
    +bool contains (const Geometry *a)
     
    +bool overlaps (const Geometry *a)
     
    +bool covers (const Geometry *a)
     
    +bool coveredBy (const Geometry *a)
     
    +bool equalsTopo (const Geometry *a)
     
    +bool relate (const Geometry *a, const std::string &pat)
     
    +std::unique_ptr< IntersectionMatrix > relate (const Geometry *a)
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Static Public Member Functions

    static bool relate (const Geometry *a, const Geometry *b, TopologyPredicate &pred)
     
    static bool relate (const Geometry *a, const Geometry *b, TopologyPredicate &pred, const BoundaryNodeRule &bnRule)
     
    static bool relate (const Geometry *a, const Geometry *b, const std::string &imPattern)
     
    static std::unique_ptr< IntersectionMatrix > relate (const Geometry *a, const Geometry *b)
     
    static std::unique_ptr< IntersectionMatrix > relate (const Geometry *a, const Geometry *b, const BoundaryNodeRule &bnRule)
     
    static std::unique_ptr< RelateNG > prepare (const Geometry *a)
     
    static std::unique_ptr< RelateNG > prepare (const Geometry *a, const BoundaryNodeRule &bnRule)
     
    +static bool intersects (const Geometry *a, const Geometry *b)
     
    +static bool crosses (const Geometry *a, const Geometry *b)
     
    +static bool disjoint (const Geometry *a, const Geometry *b)
     
    +static bool touches (const Geometry *a, const Geometry *b)
     
    +static bool within (const Geometry *a, const Geometry *b)
     
    +static bool contains (const Geometry *a, const Geometry *b)
     
    +static bool overlaps (const Geometry *a, const Geometry *b)
     
    +static bool covers (const Geometry *a, const Geometry *b)
     
    +static bool coveredBy (const Geometry *a, const Geometry *b)
     
    +static bool equalsTopo (const Geometry *a, const Geometry *b)
     
    +

    Detailed Description

    +

    Computes the value of topological predicates between two geometries based on the Dimensionally-Extended 9-Intersection Model https://en.wikipedia.org/wiki/DE-9IM (DE-9IM). Standard and custom topological predicates are provided by RelatePredicate.

    +

    The RelateNG algorithm has the following capabilities:

    +
      +
    • Efficient short-circuited evaluation of topological predicates (including matching custom DE-9IM matrix patterns)
      • +
    • Optimized repeated evaluation of predicates against a single geometry via cached spatial indexes (AKA "prepared mode")
      • +
    • Robust computation (only point-local topology is required, so invalid geometry topology does not cause failures)
      • +
    • GeometryCollection inputs containing mixed types and overlapping polygons are supported, using union semantics.
      • +
    • Zero-length LineStrings are treated as being topologically identical to Points.
      • +
    • Support for BoundaryNodeRule.
      • +
    +

    See IntersectionMatrixPattern for a description of DE-9IM patterns.

    +

    If not specified, the standard BoundaryNodeRule::MOD2_BOUNDARY_RULE is used.

    +

    RelateNG operates in 2D only; it ignores any Z ordinates.

    +

    This implementation replaces RelateOp and PreparedGeometry.

    +

    FUTURE WORK

    +
      +
    • Support for a distance tolerance to provide "approximate" predicate evaluation
      • +
    +
    Author
    Martin Davis
    +
    See also
    RelateOp
    +
    +PreparedGeometry
    +

    Member Function Documentation

    + +

    ◆ evaluate() [1/3]

    + +
    +
    + + + + + + + + +
    std::unique_ptr<IntersectionMatrix> geos::operation::relateng::RelateNG::evaluate (const Geometry * b)
    +
    +

    Computes the DE-9IM matrix for the topological relationship to a geometry.

    +
    Parameters
    + + +
    bthe B geometry to test against
    +
    +
    +
    Returns
    the DE-9IM matrix
    + +
    +
    + +

    ◆ evaluate() [2/3]

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    bool geos::operation::relateng::RelateNG::evaluate (const Geometry * b,
    const std::string & imPattern 
    )
    +
    +

    Tests whether the topological relationship to a geometry matches a DE-9IM matrix pattern.

    +
    Parameters
    + + + +
    bthe B geometry to test against
    imPatternthe DE-9IM pattern to match
    +
    +
    +
    Returns
    true if the geometries' topological relationship matches the DE-9IM pattern
    +
    See also
    IntersectionMatrixPattern
    + +
    +
    + +

    ◆ evaluate() [3/3]

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    bool geos::operation::relateng::RelateNG::evaluate (const Geometry * b,
    TopologyPredicate & predicate 
    )
    +
    +

    Tests whether the topological relationship to a geometry satisfies a topology predicate.

    +
    Parameters
    + + + +
    bthe B geometry to test against
    predicatethe topological predicate
    +
    +
    +
    Returns
    true if the predicate is satisfied
    + +
    +
    + +

    ◆ prepare() [1/2]

    + +
    +
    + + + + + +
    + + + + + + + + +
    static std::unique_ptr<RelateNG> geos::operation::relateng::RelateNG::prepare (const Geometry * a)
    +     		+static
    +
    +

    Creates a prepared RelateNG instance to optimize the evaluation of relationships against a single geometry.

    +
    Parameters
    + + +
    athe A input geometry
    +
    +
    +
    Returns
    a prepared instance
    + +
    +
    + +

    ◆ prepare() [2/2]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    static std::unique_ptr<RelateNG> geos::operation::relateng::RelateNG::prepare (const Geometry * a,
    const BoundaryNodeRule & bnRule 
    )
    +     		+static
    +
    +

    Creates a prepared RelateNG instance to optimize the computation of predicates against a single geometry, using a given BoundaryNodeRule.

    +
    Parameters
    + + + +
    athe A input geometry
    bnRulethe required BoundaryNodeRule
    +
    +
    +
    Returns
    a prepared instance
    + +
    +
    + +

    ◆ relate() [1/5]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    static std::unique_ptr<IntersectionMatrix> geos::operation::relateng::RelateNG::relate (const Geometry * a,
    const Geometry * b 
    )
    +     		+static
    +
    +

    Computes the DE-9IM matrix for the topological relationship between two geometries.

    +
    Parameters
    + + + +
    athe A input geometry
    bthe B input geometry
    +
    +
    +
    Returns
    the DE-9IM matrix for the topological relationship
    + +
    +
    + +

    ◆ relate() [2/5]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    static std::unique_ptr<IntersectionMatrix> geos::operation::relateng::RelateNG::relate (const Geometry * a,
    const Geometry * b,
    const BoundaryNodeRule & bnRule 
    )
    +     		+static
    +
    +

    Computes the DE-9IM matrix for the topological relationship between two geometries.

    +
    Parameters
    + + + + +
    athe A input geometry
    bthe B input geometry
    bnRulethe Boundary Node Rule to use
    +
    +
    +
    Returns
    the DE-9IM matrix for the relationship
    + +
    +
    + +

    ◆ relate() [3/5]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    static bool geos::operation::relateng::RelateNG::relate (const Geometry * a,
    const Geometry * b,
    const std::string & imPattern 
    )
    +     		+static
    +
    +

    Tests whether the topological relationship to a geometry matches a DE-9IM matrix pattern.

    +
    Parameters
    + + + + +
    athe A input geometry
    bthe B input geometry
    imPatternthe DE-9IM pattern to match
    +
    +
    +
    Returns
    true if the geometries relationship matches the DE-9IM pattern
    +
    See also
    IntersectionMatrixPattern
    + +
    +
    + +

    ◆ relate() [4/5]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    static bool geos::operation::relateng::RelateNG::relate (const Geometry * a,
    const Geometry * b,
    TopologyPredicate & pred 
    )
    +     		+static
    +
    +

    Tests whether the topological relationship between two geometries satisfies a topological predicate.

    +
    Parameters
    + + + + +
    athe A input geometry
    bthe B input geometry
    predthe topological predicate
    +
    +
    +
    Returns
    true if the topological relationship is satisfied
    + +
    +
    + +

    ◆ relate() [5/5]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    static bool geos::operation::relateng::RelateNG::relate (const Geometry * a,
    const Geometry * b,
    TopologyPredicate & pred,
    const BoundaryNodeRule & bnRule 
    )
    +     		+static
    +
    +

    Tests whether the topological relationship between two geometries satisfies a topological predicate, using a given BoundaryNodeRule.

    +
    Parameters
    + + + + + +
    athe A input geometry
    bthe B input geometry
    predthe topological predicate
    bnRulethe Boundary Node Rule to use
    +
    +
    +
    Returns
    true if the topological relationship is satisfied
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator-members.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator-members.html new file mode 100644 index 0000000000..fb1d93aceb --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator-members.html @@ -0,0 +1,72 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    geos::operation::relateng::RelatePointLocator Member List
    +
    +
    + +

    This is the complete list of members for geos::operation::relateng::RelatePointLocator, including all inherited members.

    + + + + + + + + + + + + + + +
    addLine(const LineString *line) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    addPoint(const Point *pt) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    addPolygonal(const Geometry *polygonal) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    extractElements(const Geometry *geom) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    hasBoundary() const (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    init(const Geometry *p_geom) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    locate(const CoordinateXY *p) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    locateLineEnd(const CoordinateXY *p) const (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    locateNode(const CoordinateXY *p, const Geometry *parentPolygonal) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocator
    locateNodeWithDim(const CoordinateXY *p, const Geometry *parentPolygonal)geos::operation::relateng::RelatePointLocator
    locateWithDim(const CoordinateXY *p)geos::operation::relateng::RelatePointLocator
    RelatePointLocator(const Geometry *p_geom) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocatorinline
    RelatePointLocator(const Geometry *p_geom, bool p_isPrepared, const BoundaryNodeRule &p_bnRule) (defined in geos::operation::relateng::RelatePointLocator)geos::operation::relateng::RelatePointLocatorinline
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator.html b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator.html new file mode 100644 index 0000000000..5de9e74334 --- /dev/null +++ b/doxygen/classgeos_1_1operation_1_1relateng_1_1RelatePointLocator.html @@ -0,0 +1,178 @@ + + + + + + + +GEOS: geos::operation::relateng::RelatePointLocator Class Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    geos::operation::relateng::RelatePointLocator Class Reference
    +
    +
    + +

    #include <RelatePointLocator.h>

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    + RelatePointLocator (const Geometry *p_geom)
     
    + RelatePointLocator (const Geometry *p_geom, bool p_isPrepared, const BoundaryNodeRule &p_bnRule)
     
    +void init (const Geometry *p_geom)
     
    +bool hasBoundary () const
     
    +void extractElements (const Geometry *geom)
     
    +void addPoint (const Point *pt)
     
    +void addLine (const LineString *line)
     
    +void addPolygonal (const Geometry *polygonal)
     
    +Location locate (const CoordinateXY *p)
     
    +Location locateLineEnd (const CoordinateXY *p) const
     
    +Location locateNode (const CoordinateXY *p, const Geometry *parentPolygonal)
     
    int locateNodeWithDim (const CoordinateXY *p, const Geometry *parentPolygonal)
     
    int locateWithDim (const CoordinateXY *p)
     
    +

    Detailed Description

    +

    Locates a point on a geometry, including mixed-type collections. The dimension of the containing geometry element is also determined. GeometryCollections are handled with union semantics; i.e. the location of a point is that location of that point on the union of the elements of the collection.

    +

    Union semantics for GeometryCollections has the following behaviours:

    +
      +
    • For a mixed-dimension (heterogeneous) collection a point may lie on two geometry elements with different dimensions. In this case the location on the largest-dimension element is reported.
      • +
    • For a collection with overlapping or adjacent polygons, points on polygon element boundaries may lie in the effective interior of the collection geometry.
      • +
    +

    Prepared mode is supported via cached spatial indexes.

    +
    Author
    Martin Davis
    +

    Member Function Documentation

    + +

    ◆ locateNodeWithDim()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int geos::operation::relateng::RelatePointLocator::locateNodeWithDim (const CoordinateXY * p,
    const Geometry * parentPolygonal 
    )
    +
    +

    Locates a point which is known to be a node of the geometry, as a DimensionLocation.

    +
    Parameters
    + + + +
    pthe point to locate
    parentPolygonalthe polygon the point is a node of
    +
    +
    +
    Returns
    the dimension and location of the point
    + +
    +
    + +

    ◆ locateWithDim()

    + +
    +
    + + + + + + + + +
    int geos::operation::relateng::RelatePointLocator::locateWithDim (const CoordinateXY * p)
    +
    +

    Computes the topological location ( Location) of a single point in a Geometry, as well as the dimension of the geometry element the point is located in (if not in the Exterior). It handles both single-element and multi-element Geometries. The algorithm for multi-part Geometries takes into account the SFS Boundary Determination Rule.

    +
    Parameters
    + + +
    pthe point to locate
    +
    +
    +
    Returns
    the Location of the point relative to the input Geometry
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/constants_8h_source.html b/doxygen/constants_8h_source.html index b5556b069d..32b31cd9a9 100644 --- a/doxygen/constants_8h_source.html +++ b/doxygen/constants_8h_source.html @@ -92,9 +92,10 @@
    43 constexpr double DoubleEpsilon = std::numeric_limits<double>::epsilon();
    44 
    45 constexpr std::size_t NO_COORD_INDEX = std::numeric_limits<std::size_t>::max();
    -
    46 
    -
    47 } // namespace geos
    -
    48 
    +
    46 constexpr std::size_t INDEX_UNKNOWN = std::numeric_limits<std::size_t>::max();
    +
    47 
    +
    48 } // namespace geos
    +
    49 
    geos
    Basic namespace for all GEOS functionalities.
    Definition: Angle.h:25

    diff --git a/doxygen/dir_ab47d68f57c64d3c7196af8bb513baca.html b/doxygen/dir_ab47d68f57c64d3c7196af8bb513baca.html new file mode 100644 index 0000000000..e42340be79 --- /dev/null +++ b/doxygen/dir_ab47d68f57c64d3c7196af8bb513baca.html @@ -0,0 +1,56 @@ + + + + + + + +GEOS: relateng Directory Reference + + + + + + +
    +
    + + + + + + +
    +
    GEOS +  3.13.0dev +
    +
    +
    + + + + + + + +
    +
    +
    +
    relateng Directory Reference
    +
    +
    +
    + +
    +Generated by doxygen 1.9.1 +
    + + diff --git a/doxygen/files.html b/doxygen/files.html index bcd23ac2f5..d02373d281 100644 --- a/doxygen/files.html +++ b/doxygen/files.html @@ -49,492 +49,517 @@  AbstractNode.h  AbstractPreparedPolygonContains.h  AbstractSTRtree.h - Angle.h - Area.h - Assert.h - AssertionFailedException.h - BasicPreparedGeometry.h - BasicSegmentString.h - Bintree.h - Boundable.h - BoundablePair.h - BoundaryChainNoder.h - BoundaryNodeRule.h - BoundaryOp.h - BufferBuilder.h - BufferCurveSetBuilder.h - BufferInputLineSimplifier.h - BufferOp.h - BufferParameters.h - BufferSubgraph.h - BuildArea.h - ByteOrderDataInStream.h - ByteOrderValues.h - CascadedPolygonUnion.h - CentralEndpointIntersector.h - Centroid.h - CGAlgorithmsDD.h - CheckOrdinatesFilter.h - CircularArcs.h - CircularString.h - CLocalizer.h - Clusters.h - common.h - CommonBits.h - CommonBitsOp.h - CommonBitsRemover.h - ComponentCoordinateExtracter.h - ComponentJumpChecker.h - CompoundCurve.h - ConcaveHull.h - ConcaveHullOfPolygons.h - ConnectedElementLocationFilter.h - ConnectedElementPointFilter.h - ConnectedSubgraphFinder.h - ConsistentAreaTester.h - constants.h - ConstrainedDelaunayTriangulator.h - ConvexHull.h - Coordinate.h - CoordinateArrayFilter.h - CoordinateFilter.h - CoordinateList.h - CoordinateOperation.h - CoordinateSequence.h - CoordinateSequenceFilter.h - CoordinateSequenceIterator.h - CoordinateSequences.h - Corner.h - CoverageBoundarySegmentFinder.h - CoverageEdge.h - CoverageGapFinder.h - CoveragePolygon.h - CoveragePolygonValidator.h - CoverageRing.h - CoverageRingEdges.h - CoverageSimplifier.h - coverage/CoverageUnion.h - operation/overlayng/CoverageUnion.h - operation/union/CoverageUnion.h - CoverageValidator.h - Curve.h - CurvePolygon.h - d2fixed_full_table.h - d2s_full_table.h - d2s_intrinsics.h - DBSCANClusterFinder.h - DD.h - DelaunayTriangulationBuilder.h - Densifier.h - Depth.h - digit_table.h - Dimension.h - geomgraph/DirectedEdge.h - planargraph/DirectedEdge.h - geomgraph/DirectedEdgeStar.h - planargraph/DirectedEdgeStar.h - DiscreteFrechetDistance.h - DiscreteHausdorffDistance.h - DisjointOperation.h - DisjointSubsetUnion.h - Distance.h - DistanceOp.h - DistanceToPoint.h - DouglasPeuckerLineSimplifier.h - DouglasPeuckerSimplifier.h - geomgraph/Edge.h - operation/overlayng/Edge.h - planargraph/Edge.h - EdgeEnd.h - EdgeEndBuilder.h - EdgeEndBundle.h - EdgeEndBundleStar.h - EdgeEndStar.h - EdgeGraph.h - EdgeGraphBuilder.h - EdgeIntersection.h - EdgeIntersectionList.h - EdgeKey.h - EdgeList.h - EdgeMerger.h - EdgeNodingBuilder.h - EdgeNodingValidator.h - geomgraph/EdgeRing.h - operation/polygonize/EdgeRing.h - EdgeSetIntersector.h - EdgeSourceInfo.h - EdgeString.h - ElevationModel.h - EnhancedPrecisionOp.h - Envelope.h - EnvelopeDistanceClusterFinder.h - EnvelopeIntersectsClusterFinder.h - EnvelopeUtil.h - export.h - ExtractLineByLocation.h - FacetSequence.h - FacetSequenceTreeBuilder.h - FastNodingValidator.h - FastSegmentSetIntersectionFinder.h - FuzzyPointLocator.h - GeoJSON.h - GeoJSONReader.h - GeoJSONWriter.h - geom.h - GeometricShapeFactory.h - Geometry.h - GeometryCollection.h - GeometryCombiner.h - GeometryComponentFilter.h - GeometryDistanceClusterFinder.h - GeometryEditor.h - GeometryEditorOperation.h - GeometryExtracter.h - GeometryFactory.h - GeometryFilter.h - GeometryFixer.h - GeometryFlattener.h - GeometryGraph.h - GeometryGraphOperation.h - GeometryIntersectsClusterFinder.h - GeometryItemDistance.h - GeometryLocation.h - GeometryMapper.h - GeometryNoder.h - GeometryPrecisionReducer.h - GeometrySnapper.h - GeometryTransformer.h - GeometryTypeName.h - geos.h - geos_c.hC API for the GEOS geometry algorithms library - GEOSException.h - geomgraph/GraphComponent.h - planargraph/GraphComponent.h - HalfEdge.h - HCoordinate.h - HeuristicOverlay.h - HilbertCode.h - HilbertEncoder.h - HoleAssigner.h - HotPixel.h - HotPixelIndex.h - HullTri.h - HullTriangulation.h - IllegalArgumentException.h - IllegalStateException.h - IncrementalDelaunayTriangulator.h - IndexedDistanceToPoint.h - IndexedFacetDistance.h - IndexedNestedHoleTester.h - IndexedNestedPolygonTester.h - IndexedPointInAreaLocator.h - IndexedPointInPolygonsLocator.h - IndexedPointOnLineLocator.h - InputGeometry.h - InteriorPointArea.h - InteriorPointLine.h - InteriorPointPoint.h - Interpolate.h - Interrupt.h - Intersection.h - IntersectionAdder.h - IntersectionFinderAdder.h - IntersectionMatrix.h - IntersectionPointBuilder.h - bintree/Interval.h - strtree/Interval.h - IntervalRTreeBranchNode.h - IntervalRTreeLeafNode.h - IntervalRTreeNode.h - IntervalSize.h - InvalidSegmentDetector.h - IsSimpleOp.h - IsValidOp.h - ItemBoundable.h - ItemDistance.h - ItemVisitor.h - IteratedNoder.h - KdNode.h - KdNodeVisitor.h - KdTree.h - bintree/Key.h - quadtree/Key.h - Label.h - LargestEmptyCircle.h - LastFoundQuadEdgeLocator.h - Length.h - LengthIndexedLine.h - LengthIndexOfPoint.h - LengthLocationMap.h - LinearComponentExtracter.h - LinearGeometryBuilder.h - LinearIterator.h - LinearLocation.h - LinearRing.h - LineBuilder.h - LineIntersector.h - LineLimiter.h - LineMergeDirectedEdge.h - LineMergeEdge.h - LineMergeGraph.h - LineMerger.h - LineSegment.h - LineSegmentIndex.h - LineSequencer.h - LineString.h - LineStringSnapper.h - LinkedLine.h - LinkedRing.h - LocateFailureException.h - Location.h - LocationIndexedLine.h - LocationIndexOfLine.h - LocationIndexOfPoint.h - Machine.h - MakeValid.h - MarkHalfEdge.h - math.h - overlay/MaximalEdgeRing.h - overlayng/MaximalEdgeRing.h - MaximumInscribedCircle.h - MCIndexNoder.h - MCIndexPointSnapper.h - MCIndexSegmentSetMutualIntersector.h - MCIndexSnapRounder.h - MinimalEdgeRing.h - MinimumAreaRectangle.h - MinimumBoundingCircle.h - MinimumClearance.h - MinimumDiameter.h - geomgraph/index/MonotoneChain.h - index/chain/MonotoneChain.h - MonotoneChainBuilder.h - MonotoneChainEdge.h - MonotoneChainIndexer.h - MonotoneChainOverlapAction.h - MonotoneChainSelectAction.h - MortonCode.h - MultiCurve.h - MultiLineString.h - MultiPoint.h - MultiPolygon.h - MultiSurface.h - namespaces.h - NodableSegmentString.h - geomgraph/Node.h - index/bintree/Node.h - index/quadtree/Node.h - planargraph/Node.h - bintree/NodeBase.h - quadtree/NodeBase.h - NodedSegmentString.h - NodeFactory.h - geomgraph/NodeMap.h - planargraph/NodeMap.h - Noder.h - NodingIntersectionFinder.h - NodingValidator.h - NoOpGeometryOperation.h - NotRepresentableException.h - Octant.h - OffsetCurve.h - OffsetCurveBuilder.h - OffsetCurveSection.h - OffsetPointGenerator.h - OffsetSegmentGenerator.h - OffsetSegmentString.h - OrdinateSet.h - Orientation.h - OrientedCoordinateArray.h - OverlapUnion.h - OverlayEdge.h - OverlayEdgeRing.h - OverlayGraph.h - OverlayLabel.h - OverlayLabeller.h - OverlayMixedPoints.h - OverlayNG.h - OverlayNGRobust.h - OverlayNodeFactory.h - OverlayPoints.h - OverlayResultValidator.h - OverlayUtil.h - ParseException.h - geomgraph/PlanarGraph.h - planargraph/PlanarGraph.h - Point.h - PointExtracter.h - PointGeometryUnion.h - PointInRing.h - PointLocation.h - PointLocator.h - PointOnGeometryLocator.h - PointPairDistance.h - PointwisePrecisionReducerTransformer.h - Polygon.h - PolygonalExtracter.h - overlay/PolygonBuilder.h - overlayng/PolygonBuilder.h - PolygonEarClipper.h - PolygonExtracter.h - PolygonHoleJoiner.h - PolygonHullSimplifier.h - PolygonIntersectionAnalyzer.h - PolygonizeDirectedEdge.h - PolygonizeEdge.h - PolygonizeGraph.h - Polygonizer.h - PolygonNoder.h - PolygonNodeTopology.h - PolygonRing.h - PolygonRingSelfNode.h - PolygonRingTouch.h - PolygonTopologyAnalyzer.h - PolygonTriangulator.h - Position.h - PrecisionModel.h - PrecisionReducer.h - PrecisionReducerCoordinateOperation.h - PrecisionReducerTransformer.h - PrecisionUtil.h - PreparedGeometry.h - PreparedGeometryFactory.h - PreparedLineString.h - PreparedLineStringDistance.h - PreparedLineStringIntersects.h - PreparedLineStringNearestPoints.h - PreparedPoint.h - PreparedPolygon.h - PreparedPolygonContains.h - PreparedPolygonContainsProperly.h - PreparedPolygonCovers.h - PreparedPolygonDistance.h - PreparedPolygonIntersects.h - PreparedPolygonPredicate.h - profiler.h - QuadEdge.h - QuadEdgeLocator.h - QuadEdgeQuartet.h - QuadEdgeSubdivision.h - Quadrant.h - Quadtree.h - RayCrossingCounter.h - algorithm/Rectangle.h - operation/intersection/Rectangle.h - RectangleContains.h - RectangleIntersection.h - RectangleIntersectionBuilder.h - RectangleIntersects.h - RelateComputer.h - RelateNode.h - RelateNodeFactory.h - RelateNodeGraph.h - RelateOp.h - RepeatedPointRemover.h - RepeatedPointTester.h - RightmostEdgeFinder.h - RingClipper.h - RingHull.h - RingHullIndex.h - RobustClipEnvelopeComputer.h - RobustDeterminant.h - bintree/Root.h - quadtree/Root.h - ryu.h - ScaledNoder.h - SegmentExtractingNoder.h - SegmentIntersectionDetector.h - SegmentIntersectionTester.h - geomgraph/index/SegmentIntersector.h - noding/SegmentIntersector.h - SegmentMCIndex.h - SegmentNode.h - SegmentNodeList.h - SegmentPointComparator.h - SegmentSetMutualIntersector.h - SegmentString.h - SegmentStringUtil.h - SharedPathsOp.h - ShortCircuitedGeometryVisitor.h - SimpleCurve.h - SimpleEdgeSetIntersector.h - SimpleGeometryPrecisionReducer.h - SimpleMCSweepLineIntersector.h - SimpleNoder.h - SimplePointInAreaLocator.h - SimplePointInRing.h - SimpleSTRdistance.h - SimpleSTRnode.h - SimpleSTRtree.h - SimpleSweepLineIntersector.h - SineStarFactory.h - SinglePassNoder.h - SIRtree.h - SnapOverlayOp.h - SnappingIntersectionAdder.h - SnappingNoder.h - SnappingPointIndex.h - SnapRoundingIntersectionAdder.h - SnapRoundingNoder.h - SortedPackedIntervalRTree.h - SpatialIndex.h - string.h - StringTokenizer.h - STRtree.h - Subgraph.h - SubgraphDepthLocater.h - Surface.h - SurfaceImpl.h - geomgraph/index/SweepLineEvent.h - index/sweepline/SweepLineEvent.h - SweepLineEventObj.h - SweepLineIndex.h - SweepLineInterval.h - SweepLineOverlapAction.h - SweepLineSegment.h - TaggedLineSegment.h - TaggedLinesSimplifier.h - TaggedLineString.h - TaggedLineStringSimplifier.h - TemplateSTRNode.h - TemplateSTRNodePair.h - TemplateSTRtree.h - TemplateSTRtreeDistance.h - TopologyException.h - TopologyLocation.h - TopologyPreservingSimplifier.h - TopologyValidationError.h - TPVWSimplifier.h - Tri.h - Triangle.h - TrianglePredicate.h - TriangleVisitor.h - TriangulationBuilder.h - TriDelaunayImprover.h - TriEdge.h - TriList.h - UnaryUnionNG.h - UnaryUnionOp.h - UnionFind.h - UnionStrategy.h - UniqueCoordinateArrayFilter.h - unload.h - UnsupportedOperationException.h - util.h - ValidatingNoder.h - Vertex.h - VertexRingCounter.h - VertexSequencePackedRtree.h - VoronoiDiagramBuilder.h - WKBConstants.h - WKBReader.h - WKBStreamReader.h - WKBWriter.h - WKTFileReader.h - WKTReader.h - WKTStreamReader.h - WKTWriter.h - Writer.h + AdjacentEdgeLocator.h + Angle.h + Area.h + Assert.h + AssertionFailedException.h + BasicPredicate.h + BasicPreparedGeometry.h + BasicSegmentString.h + Bintree.h + Boundable.h + BoundablePair.h + BoundaryChainNoder.h + BoundaryNodeRule.h + BoundaryOp.h + BufferBuilder.h + BufferCurveSetBuilder.h + BufferInputLineSimplifier.h + BufferOp.h + BufferParameters.h + BufferSubgraph.h + BuildArea.h + ByteOrderDataInStream.h + ByteOrderValues.h + CascadedPolygonUnion.h + CentralEndpointIntersector.h + Centroid.h + CGAlgorithmsDD.h + CheckOrdinatesFilter.h + CircularArcs.h + CircularString.h + CLocalizer.h + Clusters.h + common.h + CommonBits.h + CommonBitsOp.h + CommonBitsRemover.h + ComponentCoordinateExtracter.h + ComponentJumpChecker.h + CompoundCurve.h + ConcaveHull.h + ConcaveHullOfPolygons.h + ConnectedElementLocationFilter.h + ConnectedElementPointFilter.h + ConnectedSubgraphFinder.h + ConsistentAreaTester.h + constants.h + ConstrainedDelaunayTriangulator.h + ConvexHull.h + Coordinate.h + CoordinateArrayFilter.h + CoordinateFilter.h + CoordinateList.h + CoordinateOperation.h + CoordinateSequence.h + CoordinateSequenceFilter.h + CoordinateSequenceIterator.h + CoordinateSequences.h + Corner.h + CoverageBoundarySegmentFinder.h + CoverageEdge.h + CoverageGapFinder.h + CoveragePolygon.h + CoveragePolygonValidator.h + CoverageRing.h + CoverageRingEdges.h + CoverageSimplifier.h + coverage/CoverageUnion.h + operation/overlayng/CoverageUnion.h + operation/union/CoverageUnion.h + CoverageValidator.h + Curve.h + CurvePolygon.h + d2fixed_full_table.h + d2s_full_table.h + d2s_intrinsics.h + DBSCANClusterFinder.h + DD.h + DelaunayTriangulationBuilder.h + Densifier.h + Depth.h + digit_table.h + Dimension.h + DimensionLocation.h + geomgraph/DirectedEdge.h + planargraph/DirectedEdge.h + geomgraph/DirectedEdgeStar.h + planargraph/DirectedEdgeStar.h + DiscreteFrechetDistance.h + DiscreteHausdorffDistance.h + DisjointOperation.h + DisjointSubsetUnion.h + Distance.h + DistanceOp.h + DistanceToPoint.h + DouglasPeuckerLineSimplifier.h + DouglasPeuckerSimplifier.h + geomgraph/Edge.h + operation/overlayng/Edge.h + planargraph/Edge.h + EdgeEnd.h + EdgeEndBuilder.h + EdgeEndBundle.h + EdgeEndBundleStar.h + EdgeEndStar.h + EdgeGraph.h + EdgeGraphBuilder.h + EdgeIntersection.h + EdgeIntersectionList.h + EdgeKey.h + EdgeList.h + EdgeMerger.h + EdgeNodingBuilder.h + EdgeNodingValidator.h + geomgraph/EdgeRing.h + operation/polygonize/EdgeRing.h + EdgeSegmentIntersector.h + EdgeSegmentOverlapAction.h + geomgraph/index/EdgeSetIntersector.h + operation/relateng/EdgeSetIntersector.h + EdgeSourceInfo.h + EdgeString.h + ElevationModel.h + EnhancedPrecisionOp.h + Envelope.h + EnvelopeDistanceClusterFinder.h + EnvelopeIntersectsClusterFinder.h + EnvelopeUtil.h + export.h + ExtractLineByLocation.h + FacetSequence.h + FacetSequenceTreeBuilder.h + FastNodingValidator.h + FastSegmentSetIntersectionFinder.h + FuzzyPointLocator.h + GeoJSON.h + GeoJSONReader.h + GeoJSONWriter.h + geom.h + GeometricShapeFactory.h + Geometry.h + GeometryCollection.h + GeometryCombiner.h + GeometryComponentFilter.h + GeometryDistanceClusterFinder.h + GeometryEditor.h + GeometryEditorOperation.h + GeometryExtracter.h + GeometryFactory.h + GeometryFilter.h + GeometryFixer.h + GeometryFlattener.h + GeometryGraph.h + GeometryGraphOperation.h + GeometryIntersectsClusterFinder.h + GeometryItemDistance.h + GeometryLister.h + GeometryLocation.h + GeometryMapper.h + GeometryNoder.h + GeometryPrecisionReducer.h + GeometrySnapper.h + GeometryTransformer.h + GeometryTypeName.h + geos.h + geos_c.hC API for the GEOS geometry algorithms library + GEOSException.h + geomgraph/GraphComponent.h + planargraph/GraphComponent.h + HalfEdge.h + HCoordinate.h + HeuristicOverlay.h + HilbertCode.h + HilbertEncoder.h + HoleAssigner.h + HotPixel.h + HotPixelIndex.h + HullTri.h + HullTriangulation.h + IllegalArgumentException.h + IllegalStateException.h + IMPatternMatcher.h + IMPredicate.h + IncrementalDelaunayTriangulator.h + IndexedDistanceToPoint.h + IndexedFacetDistance.h + IndexedNestedHoleTester.h + IndexedNestedPolygonTester.h + IndexedPointInAreaLocator.h + IndexedPointInPolygonsLocator.h + IndexedPointOnLineLocator.h + InputGeometry.h + InteriorPointArea.h + InteriorPointLine.h + InteriorPointPoint.h + Interpolate.h + Interrupt.h + Intersection.h + IntersectionAdder.h + IntersectionFinderAdder.h + IntersectionMatrix.h + IntersectionMatrixPattern.h + IntersectionPointBuilder.h + bintree/Interval.h + strtree/Interval.h + IntervalRTreeBranchNode.h + IntervalRTreeLeafNode.h + IntervalRTreeNode.h + IntervalSize.h + InvalidSegmentDetector.h + IsSimpleOp.h + IsValidOp.h + ItemBoundable.h + ItemDistance.h + ItemVisitor.h + IteratedNoder.h + KdNode.h + KdNodeVisitor.h + KdTree.h + bintree/Key.h + quadtree/Key.h + Label.h + LargestEmptyCircle.h + LastFoundQuadEdgeLocator.h + Length.h + LengthIndexedLine.h + LengthIndexOfPoint.h + LengthLocationMap.h + LinearBoundary.h + LinearComponentExtracter.h + LinearGeometryBuilder.h + LinearIterator.h + LinearLocation.h + LinearRing.h + LineBuilder.h + LineIntersector.h + LineLimiter.h + LineMergeDirectedEdge.h + LineMergeEdge.h + LineMergeGraph.h + LineMerger.h + LineSegment.h + LineSegmentIndex.h + LineSequencer.h + LineString.h + LineStringExtracter.h + LineStringSnapper.h + LinkedLine.h + LinkedRing.h + LocateFailureException.h + Location.h + LocationIndexedLine.h + LocationIndexOfLine.h + LocationIndexOfPoint.h + Machine.h + MakeValid.h + MarkHalfEdge.h + math.h + overlay/MaximalEdgeRing.h + overlayng/MaximalEdgeRing.h + MaximumInscribedCircle.h + MCIndexNoder.h + MCIndexPointSnapper.h + MCIndexSegmentSetMutualIntersector.h + MCIndexSnapRounder.h + MinimalEdgeRing.h + MinimumAreaRectangle.h + MinimumBoundingCircle.h + MinimumClearance.h + MinimumDiameter.h + geomgraph/index/MonotoneChain.h + index/chain/MonotoneChain.h + MonotoneChainBuilder.h + MonotoneChainEdge.h + MonotoneChainIndexer.h + MonotoneChainOverlapAction.h + MonotoneChainSelectAction.h + MortonCode.h + MultiCurve.h + MultiLineString.h + MultiPoint.h + MultiPolygon.h + MultiSurface.h + namespaces.h + NodableSegmentString.h + geomgraph/Node.h + index/bintree/Node.h + index/quadtree/Node.h + planargraph/Node.h + bintree/NodeBase.h + quadtree/NodeBase.h + NodedSegmentString.h + NodeFactory.h + geomgraph/NodeMap.h + planargraph/NodeMap.h + Noder.h + NodeSection.h + NodeSections.h + NodingIntersectionFinder.h + NodingValidator.h + NoOpGeometryOperation.h + NotRepresentableException.h + Octant.h + OffsetCurve.h + OffsetCurveBuilder.h + OffsetCurveSection.h + OffsetPointGenerator.h + OffsetSegmentGenerator.h + OffsetSegmentString.h + OrdinateSet.h + Orientation.h + OrientedCoordinateArray.h + OverlapUnion.h + OverlayEdge.h + OverlayEdgeRing.h + OverlayGraph.h + OverlayLabel.h + OverlayLabeller.h + OverlayMixedPoints.h + OverlayNG.h + OverlayNGRobust.h + OverlayNodeFactory.h + OverlayPoints.h + OverlayResultValidator.h + OverlayUtil.h + ParseException.h + geomgraph/PlanarGraph.h + planargraph/PlanarGraph.h + Point.h + PointExtracter.h + PointGeometryUnion.h + PointInRing.h + PointLocation.h + PointLocator.h + PointOnGeometryLocator.h + PointPairDistance.h + PointwisePrecisionReducerTransformer.h + Polygon.h + PolygonalExtracter.h + overlay/PolygonBuilder.h + overlayng/PolygonBuilder.h + PolygonEarClipper.h + PolygonExtracter.h + PolygonHoleJoiner.h + PolygonHullSimplifier.h + PolygonIntersectionAnalyzer.h + PolygonizeDirectedEdge.h + PolygonizeEdge.h + PolygonizeGraph.h + Polygonizer.h + PolygonNodeConverter.h + PolygonNoder.h + PolygonNodeTopology.h + PolygonRing.h + PolygonRingSelfNode.h + PolygonRingTouch.h + PolygonTopologyAnalyzer.h + PolygonTriangulator.h + Position.h + PrecisionModel.h + PrecisionReducer.h + PrecisionReducerCoordinateOperation.h + PrecisionReducerTransformer.h + PrecisionUtil.h + PreparedGeometry.h + PreparedGeometryFactory.h + PreparedLineString.h + PreparedLineStringDistance.h + PreparedLineStringIntersects.h + PreparedLineStringNearestPoints.h + PreparedPoint.h + PreparedPolygon.h + PreparedPolygonContains.h + PreparedPolygonContainsProperly.h + PreparedPolygonCovers.h + PreparedPolygonDistance.h + PreparedPolygonIntersects.h + PreparedPolygonPredicate.h + profiler.h + QuadEdge.h + QuadEdgeLocator.h + QuadEdgeQuartet.h + QuadEdgeSubdivision.h + Quadrant.h + Quadtree.h + RayCrossingCounter.h + algorithm/Rectangle.h + operation/intersection/Rectangle.h + RectangleContains.h + RectangleIntersection.h + RectangleIntersectionBuilder.h + RectangleIntersects.h + RelateComputer.h + RelateEdge.h + RelateGeometry.h + RelateMatrixPredicate.h + RelateNG.h + relate/RelateNode.h + relateng/RelateNode.h + RelateNodeFactory.h + RelateNodeGraph.h + RelateOp.h + RelatePointLocator.h + RelatePredicate.h + RelateSegmentString.h + RepeatedPointRemover.h + RepeatedPointTester.h + RightmostEdgeFinder.h + RingClipper.h + RingHull.h + RingHullIndex.h + RobustClipEnvelopeComputer.h + RobustDeterminant.h + bintree/Root.h + quadtree/Root.h + ryu.h + ScaledNoder.h + SegmentExtractingNoder.h + SegmentIntersectionDetector.h + SegmentIntersectionTester.h + geomgraph/index/SegmentIntersector.h + noding/SegmentIntersector.h + SegmentMCIndex.h + SegmentNode.h + SegmentNodeList.h + SegmentPointComparator.h + SegmentSetMutualIntersector.h + SegmentString.h + SegmentStringUtil.h + SharedPathsOp.h + ShortCircuitedGeometryVisitor.h + SimpleCurve.h + SimpleEdgeSetIntersector.h + SimpleGeometryPrecisionReducer.h + SimpleMCSweepLineIntersector.h + SimpleNoder.h + SimplePointInAreaLocator.h + SimplePointInRing.h + SimpleSTRdistance.h + SimpleSTRnode.h + SimpleSTRtree.h + SimpleSweepLineIntersector.h + SineStarFactory.h + SinglePassNoder.h + SIRtree.h + SnapOverlayOp.h + SnappingIntersectionAdder.h + SnappingNoder.h + SnappingPointIndex.h + SnapRoundingIntersectionAdder.h + SnapRoundingNoder.h + SortedPackedIntervalRTree.h + SpatialIndex.h + string.h + StringTokenizer.h + STRtree.h + Subgraph.h + SubgraphDepthLocater.h + Surface.h + SurfaceImpl.h + geomgraph/index/SweepLineEvent.h + index/sweepline/SweepLineEvent.h + SweepLineEventObj.h + SweepLineIndex.h + SweepLineInterval.h + SweepLineOverlapAction.h + SweepLineSegment.h + TaggedLineSegment.h + TaggedLinesSimplifier.h + TaggedLineString.h + TaggedLineStringSimplifier.h + TemplateSTRNode.h + TemplateSTRNodePair.h + TemplateSTRtree.h + TemplateSTRtreeDistance.h + TopologyComputer.h + TopologyException.h + TopologyLocation.h + TopologyPredicate.h + TopologyPreservingSimplifier.h + TopologyValidationError.h + TPVWSimplifier.h + Tri.h + Triangle.h + TrianglePredicate.h + TriangleVisitor.h + TriangulationBuilder.h + TriDelaunayImprover.h + TriEdge.h + TriList.h + UnaryUnionNG.h + UnaryUnionOp.h + UnionFind.h + UnionStrategy.h + UniqueCoordinateArrayFilter.h + unload.h + UnsupportedOperationException.h + util.h + ValidatingNoder.h + Vertex.h + VertexRingCounter.h + VertexSequencePackedRtree.h + VoronoiDiagramBuilder.h + WKBConstants.h + WKBReader.h + WKBStreamReader.h + WKBWriter.h + WKTFileReader.h + WKTReader.h + WKTStreamReader.h + WKTWriter.h + Writer.h diff --git a/doxygen/functions.html b/doxygen/functions.html index fa2bdbd2a0..e8c82ab0ca 100644 --- a/doxygen/functions.html +++ b/doxygen/functions.html @@ -107,7 +107,7 @@

    - a -