diff --git a/doxygen/Area_8h_source.html b/doxygen/Area_8h_source.html index 0ccc75974..7d78bd144 100644 --- a/doxygen/Area_8h_source.html +++ b/doxygen/Area_8h_source.html @@ -72,26 +72,33 @@
23 #include <geos/geom/CoordinateSequence.h>
24 
25 namespace geos {
-
26 namespace algorithm { // geos::algorithm
-
27 
-
28 
-
29 class GEOS_DLL Area {
-
30 public:
-
31 
-
38  static double ofRing(const std::vector<geom::Coordinate>& ring);
-
39 
-
46  static double ofRing(const geom::CoordinateSequence* ring);
-
47 
-
57  static double ofRingSigned(const std::vector<geom::Coordinate>& ring);
-
58 
-
68  static double ofRingSigned(const geom::CoordinateSequence* ring);
-
69 
-
70 };
-
71 
-
72 
-
73 } // namespace geos::algorithm
-
74 } // namespace geos
-
75 
+
26 
+
27 namespace geom {
+
28 class Curve;
+
29 }
+
30 
+
31 namespace algorithm { // geos::algorithm
+
32 
+
33 
+
34 class GEOS_DLL Area {
+
35 public:
+
36 
+
37  static double ofClosedCurve(const geom::Curve& ring);
+
38 
+
45  static double ofRing(const std::vector<geom::Coordinate>& ring);
+
46 
+
53  static double ofRing(const geom::CoordinateSequence* ring);
+
54 
+
64  static double ofRingSigned(const std::vector<geom::Coordinate>& ring);
+
65 
+
75  static double ofRingSigned(const geom::CoordinateSequence* ring);
+
76 
+
77 };
+
78 
+
79 
+
80 } // namespace geos::algorithm
+
81 } // namespace geos
+
82 
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CGAlgorithmsDD_8h_source.html b/doxygen/CGAlgorithmsDD_8h_source.html index 1e6ab609e..ade6b1752 100644 --- a/doxygen/CGAlgorithmsDD_8h_source.html +++ b/doxygen/CGAlgorithmsDD_8h_source.html @@ -186,7 +186,7 @@
geos::algorithm::CGAlgorithmsDD::orientationIndex
static int orientationIndex(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &q)
Returns the index of the direction of the point q relative to a vector specified by p1-p2.
geos::algorithm::CGAlgorithmsDD::circumcentreDD
static geom::CoordinateXY circumcentreDD(const geom::CoordinateXY &a, const geom::CoordinateXY &b, const geom::CoordinateXY &c)
Computes the circumcentre of a triangle.
geos::algorithm::CGAlgorithmsDD::intersection
static geom::CoordinateXY intersection(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &q1, const geom::CoordinateXY &q2)
-
geos::math::DD
Wrapper for DoubleDouble higher precision mathematics operations.
Definition: DD.h:107
+
geos::math::DD
Wrapper for DoubleDouble higher precision mathematics operations.
Definition: DD.h:108
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/CircularArc_8h_source.html b/doxygen/CircularArc_8h_source.html new file mode 100644 index 000000000..0bb7eabf9 --- /dev/null +++ b/doxygen/CircularArc_8h_source.html @@ -0,0 +1,320 @@ + + + + + + + +GEOS: CircularArc.h Source File + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+
CircularArc.h
+
+
+
1 /**********************************************************************
+
2  *
+
3  * GEOS - Geometry Engine Open Source
+
4  * http://geos.osgeo.org
+
5  *
+
6  * Copyright (C) 2024 ISciences, LLC
+
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 #pragma once
+
16 
+
17 #include <geos/export.h>
+
18 #include <geos/geom/Coordinate.h>
+
19 #include <geos/geom/Quadrant.h>
+
20 #include <geos/algorithm/CircularArcs.h>
+
21 #include <geos/algorithm/Orientation.h>
+
22 #include <geos/triangulate/quadedge/TrianglePredicate.h>
+
23 
+
24 namespace geos {
+
25 namespace geom {
+
26 
+
29 class GEOS_DLL CircularArc {
+
30 public:
+
31 
+
32  using CoordinateXY = geom::CoordinateXY;
+
33 
+
34  CircularArc(const CoordinateXY& q0, const CoordinateXY& q1, const CoordinateXY& q2)
+
35  : p0(q0)
+
36  , p1(q1)
+
37  , p2(q2)
+
38  , m_center_known(false)
+
39  , m_radius_known(false)
+
40  , m_orientation_known(false)
+
41  {}
+
42 
+
43  const CoordinateXY& p0;
+
44  const CoordinateXY& p1;
+
45  const CoordinateXY& p2;
+
46 
+
51  int orientation() const {
+
52  if (!m_orientation_known) {
+
53  m_orientation = algorithm::Orientation::index(p0, p1, p2);
+
54  m_orientation_known = true;
+
55  }
+
56  return m_orientation;
+
57  }
+
58 
+
60  const CoordinateXY& getCenter() const {
+
61  if (!m_center_known) {
+
62  m_center = algorithm::CircularArcs::getCenter(p0, p1, p2);
+
63  m_center_known = true;
+
64  }
+
65 
+
66  return m_center;
+
67  }
+
68 
+
70  double getRadius() const {
+
71  if (!m_radius_known) {
+
72  m_radius = getCenter().distance(p0);
+
73  m_radius_known = true;
+
74  }
+
75 
+
76  return m_radius;
+
77  }
+
78 
+
80  bool isCircle() const {
+
81  return p0.equals(p2);
+
82  }
+
83 
+
85  bool isLinear() const {
+
86  return std::isnan(getRadius());
+
87  }
+
88 
+
90  double getAngle() const {
+
91  if (isCircle()) {
+
92  return 2*MATH_PI;
+
93  }
+
94 
+
100  auto t0 = theta0();
+
101  auto t2 = theta2();
+
102 
+
103  if (orientation() == algorithm::Orientation::COUNTERCLOCKWISE) {
+
104  std::swap(t0, t2);
+
105  }
+
106 
+
107  if (t0 < t2) {
+
108  t0 += 2*MATH_PI;
+
109  }
+
110 
+
111  auto diff = t0-t2;
+
112 
+
113  return diff;
+
114  }
+
115 
+
117  double getLength() const {
+
118  if (isLinear()) {
+
119  return p0.distance(p2);
+
120  }
+
121 
+
122  return getAngle()*getRadius();
+
123  }
+
124 
+
126  double getArea() const {
+
127  if (isLinear()) {
+
128  return 0;
+
129  }
+
130 
+
131  auto R = getRadius();
+
132  auto theta = getAngle();
+
133  return R*R/2*(theta - std::sin(theta));
+
134  }
+
135 
+
137  double theta0() const {
+
138  return std::atan2(p0.y - getCenter().y, p0.x - getCenter().x);
+
139  }
+
140 
+
142  double theta2() const {
+
143  return std::atan2(p2.y - getCenter().y, p2.x - getCenter().x);
+
144  }
+
145 
+
149  bool containsPointOnCircle(const CoordinateXY& q) const {
+
150  double theta = std::atan2(q.y - getCenter().y, q.x - getCenter().x);
+
151  return containsAngle(theta);
+
152  }
+
153 
+
156  bool containsPoint(const CoordinateXY& q) {
+
157  if (q == p0 || q == p1 || q == p2) {
+
158  return true;
+
159  }
+
160 
+
161  auto dist = std::abs(q.distance(getCenter()) - getRadius());
+
162 
+
163  if (dist > 1e-8) {
+
164  return false;
+
165  }
+
166 
+
167  if (triangulate::quadedge::TrianglePredicate::isInCircleNormalized(p0, p1, p2, q) != geom::Location::BOUNDARY) {
+
168  return false;
+
169  }
+
170 
+
171  return containsPointOnCircle(q);
+
172  }
+
173 
+
175  bool containsAngle(double theta) const {
+
176  auto t0 = theta0();
+
177  auto t2 = theta2();
+
178 
+
179  if (theta == t0 || theta == t2) {
+
180  return true;
+
181  }
+
182 
+
183  if (orientation() == algorithm::Orientation::COUNTERCLOCKWISE) {
+
184  std::swap(t0, t2);
+
185  }
+
186 
+
187  t2 -= t0;
+
188  theta -= t0;
+
189 
+
190  if (t2 < 0) {
+
191  t2 += 2*MATH_PI;
+
192  }
+
193  if (theta < 0) {
+
194  theta += 2*MATH_PI;
+
195  }
+
196 
+
197  return theta >= t2;
+
198  }
+
199 
+
203  bool isUpwardAtPoint(const CoordinateXY& q) const {
+
204  auto quad = geom::Quadrant::quadrant(getCenter(), q);
+
205  bool isUpward;
+
206 
+
207  if (orientation() == algorithm::Orientation::CLOCKWISE) {
+
208  isUpward = (quad == geom::Quadrant::SW || quad == geom::Quadrant::NW);
+
209  } else {
+
210  isUpward = (quad == geom::Quadrant::SE || quad == geom::Quadrant::NE);
+
211  }
+
212 
+
213  return isUpward;
+
214  }
+
215 
+
216  class Iterator {
+
217  public:
+
218  using iterator_category = std::forward_iterator_tag;
+
219  using difference_type = std::ptrdiff_t;
+
220  using value_type = geom::CoordinateXY;
+
221  using pointer = const geom::CoordinateXY*;
+
222  using reference = const geom::CoordinateXY&;
+
223 
+
224  Iterator(const CircularArc& arc, int i) : m_arc(arc), m_i(i) {}
+
225 
+
226  reference operator*() const {
+
227  return m_i == 0 ? m_arc.p0 : (m_i == 1 ? m_arc.p1 : m_arc.p2);
+
228  }
+
229 
+
230  Iterator& operator++() {
+
231  m_i++;
+
232  return *this;
+
233  }
+
234 
+
235  Iterator operator++(int) {
+
236  Iterator ret = *this;
+
237  m_i++;
+
238  return ret;
+
239  }
+
240 
+
241  bool operator==(const Iterator& other) const {
+
242  return m_i == other.m_i;
+
243  }
+
244 
+
245  bool operator!=(const Iterator& other) const {
+
246  return !(*this == other);
+
247  }
+
248 
+
249  private:
+
250  const CircularArc& m_arc;
+
251  int m_i;
+
252 
+
253  };
+
254 
+
255  Iterator begin() const {
+
256  return Iterator(*this, 0);
+
257  }
+
258 
+
259  Iterator end() const {
+
260  return Iterator(*this, 3);
+
261  }
+
262 
+
263 private:
+
264  mutable CoordinateXY m_center;
+
265  mutable double m_radius;
+
266  mutable int m_orientation;
+
267  mutable bool m_center_known = false;
+
268  mutable bool m_radius_known = false;
+
269  mutable bool m_orientation_known = false;
+
270 };
+
271 
+
272 }
+
273 }
+
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::CircularArc
Definition: CircularArc.h:29
+
geos::geom::CircularArc::containsPointOnCircle
bool containsPointOnCircle(const CoordinateXY &q) const
Definition: CircularArc.h:149
+
geos::geom::CircularArc::isUpwardAtPoint
bool isUpwardAtPoint(const CoordinateXY &q) const
Definition: CircularArc.h:203
+
geos::geom::CircularArc::isCircle
bool isCircle() const
Return whether this arc forms a complete circle.
Definition: CircularArc.h:80
+
geos::geom::CircularArc::containsAngle
bool containsAngle(double theta) const
Check to see if a given angle lies on this arc.
Definition: CircularArc.h:175
+
geos::geom::CircularArc::orientation
int orientation() const
Definition: CircularArc.h:51
+
geos::geom::CircularArc::isLinear
bool isLinear() const
Returns whether this arc forms a straight line (p0, p1, and p2 are collinear)
Definition: CircularArc.h:85
+
geos::geom::CircularArc::getAngle
double getAngle() const
Return the inner angle of the sector associated with this arc.
Definition: CircularArc.h:90
+
geos::geom::CircularArc::containsPoint
bool containsPoint(const CoordinateXY &q)
Definition: CircularArc.h:156
+
geos::geom::CircularArc::getLength
double getLength() const
Return the length of the arc.
Definition: CircularArc.h:117
+
geos::geom::CircularArc::getArea
double getArea() const
Return the area enclosed by the arc p0-p1-p2 and the line segment p2-p0.
Definition: CircularArc.h:126
+
geos::geom::CircularArc::getRadius
double getRadius() const
Return the radius of the circle associated with this arc.
Definition: CircularArc.h:70
+
geos::geom::CircularArc::getCenter
const CoordinateXY & getCenter() const
Return the center point of the circle associated with this arc.
Definition: CircularArc.h:60
+
geos::geom::CircularArc::theta0
double theta0() const
Return the angle of p0.
Definition: CircularArc.h:137
+
geos::geom::CircularArc::theta2
double theta2() const
Return the angle of p2.
Definition: CircularArc.h:142
+
geos::geom::Quadrant::quadrant
static int quadrant(double dx, double dy)
Definition: Quadrant.h:67
+
geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized
static geom::Location isInCircleNormalized(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
+ +
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/CircularArcs_8h_source.html b/doxygen/CircularArcs_8h_source.html index bf9a0c1af..dea1108de 100644 --- a/doxygen/CircularArcs_8h_source.html +++ b/doxygen/CircularArcs_8h_source.html @@ -65,14 +65,14 @@
16 
17 #include <geos/export.h>
18 #include <geos/geom/Coordinate.h>
-
19 
-
20 #include "geos/geom/Envelope.h"
-
21 
-
22 namespace geos {
-
23 namespace algorithm {
-
24 
-
25 class GEOS_DLL CircularArcs {
-
26 public:
+
19 #include <geos/geom/Envelope.h>
+
20 
+
21 namespace geos {
+
22 namespace algorithm {
+
23 
+
24 class GEOS_DLL CircularArcs {
+
25 public:
+
26 
28  static geom::CoordinateXY getCenter(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
29  const geom::CoordinateXY& p2);
30 
diff --git a/doxygen/CircularString_8h_source.html b/doxygen/CircularString_8h_source.html index 2a3b44682..5c0b8efaa 100644 --- a/doxygen/CircularString_8h_source.html +++ b/doxygen/CircularString_8h_source.html @@ -64,33 +64,33 @@
15 #pragma once
16 
17 #include <geos/geom/SimpleCurve.h>
-
18 #include <geos/util/UnsupportedOperationException.h>
-
19 
-
20 namespace geos {
-
21 namespace geom {
-
22 
-
23 class GEOS_DLL CircularString : public SimpleCurve {
-
24 
-
25 public:
-
26  using SimpleCurve::SimpleCurve;
-
27 
-
28  friend class GeometryFactory;
-
29 
-
30  ~CircularString() override;
-
31 
-
32  std::unique_ptr<CircularString> clone() const;
-
33 
-
34  std::string getGeometryType() const override;
-
35 
-
36  GeometryTypeId getGeometryTypeId() const override;
-
37 
-
38  double getLength() const override
-
39  {
-
40  throw util::UnsupportedOperationException("Cannot calculate length of CircularString");
-
41  }
-
42 
-
43  bool hasCurvedComponents() const override
-
44  {
+
18 
+
19 namespace geos {
+
20 namespace geom {
+
21 
+
22 class GEOS_DLL CircularString : public SimpleCurve {
+
23 
+
24 public:
+
25  using SimpleCurve::SimpleCurve;
+
26 
+
27  friend class GeometryFactory;
+
28 
+
29  ~CircularString() override;
+
30 
+
31  std::unique_ptr<CircularString> clone() const;
+
32 
+
33  std::string getGeometryType() const override;
+
34 
+
35  GeometryTypeId getGeometryTypeId() const override;
+
36 
+
37  double getLength() const override;
+
38 
+
39  bool hasCurvedComponents() const override
+
40  {
+
41  return true;
+
42  }
+
43 
+
44  bool isCurved() const override {
45  return true;
46  }
47 
diff --git a/doxygen/CompoundCurve_8h_source.html b/doxygen/CompoundCurve_8h_source.html index 363c9718e..8b3ae79ba 100644 --- a/doxygen/CompoundCurve_8h_source.html +++ b/doxygen/CompoundCurve_8h_source.html @@ -102,7 +102,7 @@
53 
54  std::unique_ptr<CoordinateSequence> getCoordinates() const override;
55 
-
57  const SimpleCurve* getCurveN(std::size_t) const;
+
57  const SimpleCurve* getCurveN(std::size_t) const override;
58 
59  const Envelope* getEnvelopeInternal() const override
60  {
@@ -115,7 +115,7 @@
67 
68  double getLength() const override;
69 
-
71  std::size_t getNumCurves() const;
+
71  std::size_t getNumCurves() const override;
72 
73  std::size_t getNumPoints() const override;
74 
diff --git a/doxygen/Curve_8h_source.html b/doxygen/Curve_8h_source.html index 4b2522bd2..a86e28c45 100644 --- a/doxygen/Curve_8h_source.html +++ b/doxygen/Curve_8h_source.html @@ -68,42 +68,48 @@
19 namespace geos {
20 namespace geom {
21 
-
22 class GEOS_DLL Curve : public Geometry {
+
22 class SimpleCurve;
23 
-
24 public:
-
25  using Geometry::apply_ro;
-
26  using Geometry::apply_rw;
-
27 
-
28  void apply_ro(GeometryComponentFilter* filter) const override;
+
24 class GEOS_DLL Curve : public Geometry {
+
25 
+
26 public:
+
27  using Geometry::apply_ro;
+
28  using Geometry::apply_rw;
29 
-
30  void apply_ro(GeometryFilter* filter) const override;
+
30  void apply_ro(GeometryComponentFilter* filter) const override;
31 
-
32  void apply_rw(GeometryComponentFilter* filter) override;
+
32  void apply_ro(GeometryFilter* filter) const override;
33 
-
34  void apply_rw(GeometryFilter* filter) override;
+
34  void apply_rw(GeometryComponentFilter* filter) override;
35 
-
41  int
-
42  getBoundaryDimension() const override
-
43  {
-
44  return isClosed() ? Dimension::False : 0;
-
45  }
-
46 
-
48  Dimension::DimensionType getDimension() const override
-
49  {
-
50  return Dimension::L; // line
-
51  }
-
52 
-
54  virtual bool isClosed() const = 0;
-
55 
-
57  bool isRing() const;
-
58 
-
59 protected:
-
60  Curve(const GeometryFactory& factory) : Geometry(&factory) {}
-
61 
-
62 };
-
63 
-
64 }
-
65 }
+
36  void apply_rw(GeometryFilter* filter) override;
+
37 
+
43  int
+
44  getBoundaryDimension() const override
+
45  {
+
46  return isClosed() ? Dimension::False : 0;
+
47  }
+
48 
+
50  Dimension::DimensionType getDimension() const override
+
51  {
+
52  return Dimension::L; // line
+
53  }
+
54 
+
56  virtual bool isClosed() const = 0;
+
57 
+
59  bool isRing() const;
+
60 
+
61  virtual std::size_t getNumCurves() const = 0;
+
62 
+
63  virtual const SimpleCurve* getCurveN(std::size_t) const = 0;
+
64 
+
65 protected:
+
66  Curve(const GeometryFactory& factory) : Geometry(&factory) {}
+
67 
+
68 };
+
69 
+
70 }
+
71 }
geos::geom::Dimension::DimensionType
DimensionType
Definition: Dimension.h:29
geos::geom::Dimension::L
@ L
Dimension value of a curve (1).
Definition: Dimension.h:43
geos::geom::Dimension::False
@ False
Dimension value of the empty geometry (-1).
Definition: Dimension.h:37
diff --git a/doxygen/DD_8h_source.html b/doxygen/DD_8h_source.html index c960340cc..b631b0e16 100644 --- a/doxygen/DD_8h_source.html +++ b/doxygen/DD_8h_source.html @@ -64,104 +64,105 @@
93 #pragma once
94 
95 #include <cmath>
-
96 
-
97 namespace geos {
-
98 namespace math { // geos.math
-
99 
-
107 class GEOS_DLL DD {
-
108  private:
-
109  static constexpr double SPLIT = 134217729.0; // 2^27+1, for IEEE double
-
110  double hi;
-
111  double lo;
-
112 
-
113  int signum() const;
-
114  DD rint() const;
-
115 
+
96 #include <geos/export.h>
+
97 
+
98 namespace geos {
+
99 namespace math { // geos.math
+
100 
+
108 class GEOS_DLL DD {
+
109  private:
+
110  static constexpr double SPLIT = 134217729.0; // 2^27+1, for IEEE double
+
111  double hi;
+
112  double lo;
+
113 
+
114  int signum() const;
+
115  DD rint() const;
116 
-
117  public:
-
118  DD(double p_hi, double p_lo) : hi(p_hi), lo(p_lo) {};
-
119  DD(double x) : hi(x), lo(0.0) {};
-
120  DD() : hi(0.0), lo(0.0) {};
-
121 
-
122  bool operator==(const DD &rhs) const
-
123  {
-
124  return hi == rhs.hi && lo == rhs.lo;
-
125  }
-
126 
-
127  bool operator!=(const DD &rhs) const
-
128  {
-
129  return hi != rhs.hi || lo != rhs.lo;
-
130  }
-
131 
-
132  bool operator<(const DD &rhs) const
-
133  {
-
134  return (hi < rhs.hi) || (hi == rhs.hi && lo < rhs.lo);
-
135  }
-
136 
-
137  bool operator<=(const DD &rhs) const
-
138  {
-
139  return (hi < rhs.hi) || (hi == rhs.hi && lo <= rhs.lo);
-
140  }
-
141 
-
142  bool operator>(const DD &rhs) const
-
143  {
-
144  return (hi > rhs.hi) || (hi == rhs.hi && lo > rhs.lo);
-
145  }
-
146 
-
147  bool operator>=(const DD &rhs) const
-
148  {
-
149  return (hi > rhs.hi) || (hi == rhs.hi && lo >= rhs.lo);
-
150  }
-
151 
-
152  friend GEOS_DLL DD operator+ (const DD &lhs, const DD &rhs);
-
153  friend GEOS_DLL DD operator+ (const DD &lhs, double rhs);
-
154  friend GEOS_DLL DD operator- (const DD &lhs, const DD &rhs);
-
155  friend GEOS_DLL DD operator- (const DD &lhs, double rhs);
-
156  friend GEOS_DLL DD operator* (const DD &lhs, const DD &rhs);
-
157  friend GEOS_DLL DD operator* (const DD &lhs, double rhs);
-
158  friend GEOS_DLL DD operator/ (const DD &lhs, const DD &rhs);
-
159  friend GEOS_DLL DD operator/ (const DD &lhs, double rhs);
-
160 
-
161  static DD determinant(const DD &x1, const DD &y1, const DD &x2, const DD &y2);
-
162  static DD determinant(double x1, double y1, double x2, double y2);
-
163  static DD abs(const DD &d);
-
164  static DD pow(const DD &d, int exp);
-
165  static DD trunc(const DD &d);
-
166 
-
167  bool isNaN() const;
-
168  bool isNegative() const;
-
169  bool isPositive() const;
-
170  bool isZero() const;
-
171  double doubleValue() const;
-
172  double ToDouble() const { return doubleValue(); }
-
173  int intValue() const;
-
174  DD negate() const;
-
175  DD reciprocal() const;
-
176  DD floor() const;
-
177  DD ceil() const;
-
178 
-
179  void selfAdd(const DD &d);
-
180  void selfAdd(double p_hi, double p_lo);
-
181  void selfAdd(double y);
-
182 
-
183  void selfSubtract(const DD &d);
-
184  void selfSubtract(double p_hi, double p_lo);
-
185  void selfSubtract(double y);
-
186 
-
187  void selfMultiply(double p_hi, double p_lo);
-
188  void selfMultiply(const DD &d);
-
189  void selfMultiply(double y);
-
190 
-
191  void selfDivide(double p_hi, double p_lo);
-
192  void selfDivide(const DD &d);
-
193  void selfDivide(double y);
-
194 };
-
195 
+
117 
+
118  public:
+
119  DD(double p_hi, double p_lo) : hi(p_hi), lo(p_lo) {};
+
120  DD(double x) : hi(x), lo(0.0) {};
+
121  DD() : hi(0.0), lo(0.0) {};
+
122 
+
123  bool operator==(const DD &rhs) const
+
124  {
+
125  return hi == rhs.hi && lo == rhs.lo;
+
126  }
+
127 
+
128  bool operator!=(const DD &rhs) const
+
129  {
+
130  return hi != rhs.hi || lo != rhs.lo;
+
131  }
+
132 
+
133  bool operator<(const DD &rhs) const
+
134  {
+
135  return (hi < rhs.hi) || (hi == rhs.hi && lo < rhs.lo);
+
136  }
+
137 
+
138  bool operator<=(const DD &rhs) const
+
139  {
+
140  return (hi < rhs.hi) || (hi == rhs.hi && lo <= rhs.lo);
+
141  }
+
142 
+
143  bool operator>(const DD &rhs) const
+
144  {
+
145  return (hi > rhs.hi) || (hi == rhs.hi && lo > rhs.lo);
+
146  }
+
147 
+
148  bool operator>=(const DD &rhs) const
+
149  {
+
150  return (hi > rhs.hi) || (hi == rhs.hi && lo >= rhs.lo);
+
151  }
+
152 
+
153  friend GEOS_DLL DD operator+ (const DD &lhs, const DD &rhs);
+
154  friend GEOS_DLL DD operator+ (const DD &lhs, double rhs);
+
155  friend GEOS_DLL DD operator- (const DD &lhs, const DD &rhs);
+
156  friend GEOS_DLL DD operator- (const DD &lhs, double rhs);
+
157  friend GEOS_DLL DD operator* (const DD &lhs, const DD &rhs);
+
158  friend GEOS_DLL DD operator* (const DD &lhs, double rhs);
+
159  friend GEOS_DLL DD operator/ (const DD &lhs, const DD &rhs);
+
160  friend GEOS_DLL DD operator/ (const DD &lhs, double rhs);
+
161 
+
162  static DD determinant(const DD &x1, const DD &y1, const DD &x2, const DD &y2);
+
163  static DD determinant(double x1, double y1, double x2, double y2);
+
164  static DD abs(const DD &d);
+
165  static DD pow(const DD &d, int exp);
+
166  static DD trunc(const DD &d);
+
167 
+
168  bool isNaN() const;
+
169  bool isNegative() const;
+
170  bool isPositive() const;
+
171  bool isZero() const;
+
172  double doubleValue() const;
+
173  double ToDouble() const { return doubleValue(); }
+
174  int intValue() const;
+
175  DD negate() const;
+
176  DD reciprocal() const;
+
177  DD floor() const;
+
178  DD ceil() const;
+
179 
+
180  void selfAdd(const DD &d);
+
181  void selfAdd(double p_hi, double p_lo);
+
182  void selfAdd(double y);
+
183 
+
184  void selfSubtract(const DD &d);
+
185  void selfSubtract(double p_hi, double p_lo);
+
186  void selfSubtract(double y);
+
187 
+
188  void selfMultiply(double p_hi, double p_lo);
+
189  void selfMultiply(const DD &d);
+
190  void selfMultiply(double y);
+
191 
+
192  void selfDivide(double p_hi, double p_lo);
+
193  void selfDivide(const DD &d);
+
194  void selfDivide(double y);
+
195 };
196 
-
197 } // namespace geos::math
-
198 } // namespace geos
-
199 
-
geos::math::DD
Wrapper for DoubleDouble higher precision mathematics operations.
Definition: DD.h:107
+
197 
+
198 } // namespace geos::math
+
199 } // namespace geos
+
200 
+
geos::math::DD
Wrapper for DoubleDouble higher precision mathematics operations.
Definition: DD.h:108
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/IndexedPointInAreaLocator_8h_source.html b/doxygen/IndexedPointInAreaLocator_8h_source.html index 4b97e12f7..daf935c6d 100644 --- a/doxygen/IndexedPointInAreaLocator_8h_source.html +++ b/doxygen/IndexedPointInAreaLocator_8h_source.html @@ -97,7 +97,7 @@
60  // p1 follows p0 in a CoordinateSequence, we know that the address
61  // of p1 is 16, 24, or 32 bytes greater than the address of p0.
62  // By packing this offset into the least significant bits of p0,
-
63  // we can retrieve both p0 and p1 while only using 8 byytes.
+
63  // we can retrieve both p0 and p1 while only using 8 bytes.
64  std::size_t os = static_cast<std::size_t>(reinterpret_cast<const double*>(p1) - reinterpret_cast<const double*>(p0)) - 2u;
65  m_p0 = reinterpret_cast<std::size_t>(p0) | os;
66 
diff --git a/doxygen/LineString_8h_source.html b/doxygen/LineString_8h_source.html index 7894a5faf..3d2bfcfa4 100644 --- a/doxygen/LineString_8h_source.html +++ b/doxygen/LineString_8h_source.html @@ -117,62 +117,66 @@
92 
93  double getLength() const override;
94 
-
101  std::unique_ptr<LineString> reverse() const { return std::unique_ptr<LineString>(reverseImpl()); }
-
102 
-
103 protected:
-
104 
-
105  LineString(const LineString& ls);
+
95  bool isCurved() const override {
+
96  return false;
+
97  }
+
98 
+
105  std::unique_ptr<LineString> reverse() const { return std::unique_ptr<LineString>(reverseImpl()); }
106 
-
110  LineString(CoordinateSequence::Ptr && pts,
-
111  const GeometryFactory& newFactory);
-
112 
-
113  LineString* cloneImpl() const override { return new LineString(*this); }
-
114 
-
115  LineString* reverseImpl() const override;
+
107 protected:
+
108 
+
109  LineString(const LineString& ls);
+
110 
+
114  LineString(CoordinateSequence::Ptr && pts,
+
115  const GeometryFactory& newFactory);
116 
-
117  int
-
118  getSortIndex() const override
-
119  {
-
120  return SORTINDEX_LINESTRING;
-
121  };
-
122 
-
123  void geometryChangedAction() override
-
124  {
-
125  envelope = computeEnvelopeInternal(true);
-
126  }
-
127 
-
128 private:
-
129 
-
130  void validateConstruction();
-
131 };
-
132 
-
133 struct GEOS_DLL LineStringLT {
-
134  bool
-
135  operator()(const LineString* ls1, const LineString* ls2) const
-
136  {
-
137  return ls1->compareTo(ls2) < 0;
-
138  }
-
139 };
-
140 
-
141 } // namespace geos::geom
-
142 } // namespace geos
-
143 
-
144 #ifdef _MSC_VER
-
145 #pragma warning(pop)
-
146 #endif
+
117  LineString* cloneImpl() const override { return new LineString(*this); }
+
118 
+
119  LineString* reverseImpl() const override;
+
120 
+
121  int
+
122  getSortIndex() const override
+
123  {
+
124  return SORTINDEX_LINESTRING;
+
125  };
+
126 
+
127  void geometryChangedAction() override
+
128  {
+
129  envelope = computeEnvelopeInternal(true);
+
130  }
+
131 
+
132 private:
+
133 
+
134  void validateConstruction();
+
135 };
+
136 
+
137 struct GEOS_DLL LineStringLT {
+
138  bool
+
139  operator()(const LineString* ls1, const LineString* ls2) const
+
140  {
+
141  return ls1->compareTo(ls2) < 0;
+
142  }
+
143 };
+
144 
+
145 } // namespace geos::geom
+
146 } // namespace geos
147 
+
148 #ifdef _MSC_VER
+
149 #pragma warning(pop)
+
150 #endif
+
151 
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::geom::LineString::reverseImpl
LineString * reverseImpl() const override
Make a geometry with coordinates in reverse order.
-
geos::geom::LineString::cloneImpl
LineString * cloneImpl() const override
Make a deep-copy of this Geometry.
Definition: LineString.h:113
+
geos::geom::LineString::cloneImpl
LineString * cloneImpl() const override
Make a deep-copy of this Geometry.
Definition: LineString.h:117
geos::geom::LineString::getGeometryTypeId
GeometryTypeId getGeometryTypeId() const override
Return an integer representation of this Geometry type.
geos::geom::LineString::ConstVect
std::vector< const LineString * > ConstVect
A vector of const LineString pointers.
Definition: LineString.h:73
geos::geom::LineString::LineString
LineString(CoordinateSequence::Ptr &&pts, const GeometryFactory &newFactory)
Constructs a LineString taking ownership the given CoordinateSequence.
geos::geom::LineString::getLength
double getLength() const override
Returns the length of this Geometry.
geos::geom::LineString::getGeometryType
std::string getGeometryType() const override
Return a string representation of this Geometry type.
geos::geom::LineString::clone
std::unique_ptr< LineString > clone() const
Creates and returns a full copy of this LineString object (including all coordinates contained by it)
Definition: LineString.h:84
-
geos::geom::LineString::reverse
std::unique_ptr< LineString > reverse() const
Definition: LineString.h:101
-
geos::geom::LineString::geometryChangedAction
void geometryChangedAction() override
Notifies this Geometry that its Coordinates have been changed by an external party.
Definition: LineString.h:123
+
geos::geom::LineString::reverse
std::unique_ptr< LineString > reverse() const
Definition: LineString.h:105
+
geos::geom::LineString::geometryChangedAction
void geometryChangedAction() override
Notifies this Geometry that its Coordinates have been changed by an external party.
Definition: LineString.h:127
geos::geom::GeometryTypeId
GeometryTypeId
Geometry types.
Definition: Geometry.h:74
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/PointLocation_8h_source.html b/doxygen/PointLocation_8h_source.html index ea772894e..c6c10fcf5 100644 --- a/doxygen/PointLocation_8h_source.html +++ b/doxygen/PointLocation_8h_source.html @@ -68,33 +68,41 @@
19 #pragma once
20 
21 #include <geos/export.h>
-
22 #include <geos/geom/Coordinate.h>
-
23 #include <geos/geom/CoordinateSequence.h>
-
24 #include <geos/geom/Location.h>
-
25 
-
26 namespace geos {
-
27 namespace algorithm { // geos::algorithm
-
28 
-
36 class GEOS_DLL PointLocation {
-
37 public:
-
38 
-
47  static bool isOnSegment(const geom::CoordinateXY& p, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
-
48 
-
58  static bool isOnLine(const geom::CoordinateXY& p, const geom::CoordinateSequence* line);
-
59 
-
76  static bool isInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
-
77  static bool isInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence* ring);
-
78 
-
91  static geom::Location locateInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
-
92  static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence& ring);
-
93 
-
94 };
-
95 
-
96 
-
97 } // namespace geos::algorithm
-
98 } // namespace geos
-
99 
-
geos::algorithm::PointLocation
Functions for locating points within basic geometric structures such as lines and rings.
Definition: PointLocation.h:36
+
22 #include <geos/geom/Location.h>
+
23 #include <vector>
+
24 
+
25 namespace geos {
+
26 
+
27 namespace geom {
+
28 class Coordinate;
+
29 class CoordinateXY;
+
30 class CoordinateSequence;
+
31 class Curve;
+
32 }
+
33 
+
34 namespace algorithm { // geos::algorithm
+
35 
+
43 class GEOS_DLL PointLocation {
+
44 public:
+
45 
+
54  static bool isOnSegment(const geom::CoordinateXY& p, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
+
55 
+
65  static bool isOnLine(const geom::CoordinateXY& p, const geom::CoordinateSequence* line);
+
66 
+
83  static bool isInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
+
84  static bool isInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence* ring);
+
85 
+
98  static geom::Location locateInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
+
99  static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence& ring);
+
100  static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::Curve& ring);
+
101 
+
102 };
+
103 
+
104 
+
105 } // namespace geos::algorithm
+
106 } // namespace geos
+
107 
+
geos::algorithm::PointLocation
Functions for locating points within basic geometric structures such as lines and rings.
Definition: PointLocation.h:43
geos::algorithm::PointLocation::isOnSegment
static bool isOnSegment(const geom::CoordinateXY &p, const geom::CoordinateXY &p0, const geom::CoordinateXY &p1)
Tests whether a point lies on a line segment.
geos::algorithm::PointLocation::isOnLine
static bool isOnLine(const geom::CoordinateXY &p, const geom::CoordinateSequence *line)
Tests whether a point lies on the line defined by a CoordinateSequence.
geos::algorithm::PointLocation::isInRing
static bool isInRing(const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)
Tests whether a point lies inside or on a ring.
diff --git a/doxygen/QuadEdgeSubdivision_8h_source.html b/doxygen/QuadEdgeSubdivision_8h_source.html index f9f3a10eb..47ce277d1 100644 --- a/doxygen/QuadEdgeSubdivision_8h_source.html +++ b/doxygen/QuadEdgeSubdivision_8h_source.html @@ -89,7 +89,7 @@
40 class GeometryCollection;
41 class MultiLineString;
42 class GeometryFactory;
-
43 class Coordinate;
+
43 class Coordinate;
44 class Geometry;
45 class Envelope;
46 }
diff --git a/doxygen/RayCrossingCounter_8h_source.html b/doxygen/RayCrossingCounter_8h_source.html index 2c20f756f..939665d54 100644 --- a/doxygen/RayCrossingCounter_8h_source.html +++ b/doxygen/RayCrossingCounter_8h_source.html @@ -71,73 +71,92 @@
22 #include <geos/export.h>
23 #include <geos/geom/Location.h>
24 
-
25 #include <vector>
-
26 
-
27 // forward declarations
-
28 namespace geos {
-
29 namespace geom {
-
30 class Coordinate;
-
31 class CoordinateXY;
-
32 class CoordinateSequence;
-
33 }
-
34 }
-
35 
-
36 
-
37 namespace geos {
-
38 namespace algorithm {
+
25 #include <array>
+
26 #include <vector>
+
27 
+
28 // forward declarations
+
29 namespace geos {
+
30 namespace geom {
+
31 class Coordinate;
+
32 class CoordinateXY;
+
33 class CoordinateSequence;
+
34 class CircularArc;
+
35 class Curve;
+
36 }
+
37 }
+
38 
39 
-
65 class GEOS_DLL RayCrossingCounter {
-
66 private:
-
67  const geom::CoordinateXY& point;
-
68 
-
69  std::size_t crossingCount;
-
70 
-
71  // true if the test point lies on an input segment
-
72  bool isPointOnSegment;
+
40 namespace geos {
+
41 namespace algorithm {
+
42 
+
68 class GEOS_DLL RayCrossingCounter {
+
69 private:
+
70  const geom::CoordinateXY& point;
+
71 
+
72  std::size_t crossingCount;
73 
-
74  // Declare type as noncopyable
-
75  RayCrossingCounter(const RayCrossingCounter& other) = delete;
-
76  RayCrossingCounter& operator=(const RayCrossingCounter& rhs) = delete;
-
77 
-
78 public:
-
88  static geom::Location locatePointInRing(const geom::CoordinateXY& p,
-
89  const geom::CoordinateSequence& ring);
-
90 
-
92  static geom::Location locatePointInRing(const geom::CoordinateXY& p,
-
93  const std::vector<const geom::Coordinate*>& ring);
-
94 
-
95  RayCrossingCounter(const geom::CoordinateXY& p_point)
-
96  : point(p_point),
-
97  crossingCount(0),
-
98  isPointOnSegment(false)
-
99  { }
+
74  // true if the test point lies on an input segment
+
75  bool isPointOnSegment;
+
76 
+
77  // Declare type as noncopyable
+
78  RayCrossingCounter(const RayCrossingCounter& other) = delete;
+
79  RayCrossingCounter& operator=(const RayCrossingCounter& rhs) = delete;
+
80 
+
81 public:
+
91  static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+
92  const geom::CoordinateSequence& ring);
+
93 
+
95  static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+
96  const std::vector<const geom::Coordinate*>& ring);
+
97 
+
98  static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+
99  const geom::Curve& ring);
100 
-
107  void countSegment(const geom::CoordinateXY& p1,
-
108  const geom::CoordinateXY& p2);
-
109 
-
119  bool
-
120  isOnSegment() const
-
121  {
-
122  return isPointOnSegment;
-
123  }
+
101  RayCrossingCounter(const geom::CoordinateXY& p_point)
+
102  : point(p_point),
+
103  crossingCount(0),
+
104  isPointOnSegment(false)
+
105  { }
+
106 
+
113  void countSegment(const geom::CoordinateXY& p1,
+
114  const geom::CoordinateXY& p2);
+
115 
+
116  void countArc(const geom::CoordinateXY& p1,
+
117  const geom::CoordinateXY& p2,
+
118  const geom::CoordinateXY& p3);
+
119 
+
123  void processSequence(const geom::CoordinateSequence& seq, bool isLinear);
124 
-
135  geom::Location getLocation() const;
-
136 
-
146  bool isPointInPolygon() const;
-
147 
-
148  std::size_t getCount() const { return crossingCount; };
-
149 
-
150 };
+
134  bool
+
135  isOnSegment() const
+
136  {
+
137  return isPointOnSegment;
+
138  }
+
139 
+
150  geom::Location getLocation() const;
151 
-
152 } // geos::algorithm
-
153 } // geos
-
geos::algorithm::RayCrossingCounter
Counts the number of segments crossed by a horizontal ray extending to the right from a given point,...
Definition: RayCrossingCounter.h:65
+
161  bool isPointInPolygon() const;
+
162 
+
163  std::size_t getCount() const { return crossingCount; };
+
164 
+
165  static bool shouldCountCrossing(const geom::CircularArc& arc, const geom::CoordinateXY& q);
+
166 
+
167  static std::array<geom::CoordinateXY, 2>
+
168  pointsIntersectingHorizontalRay(const geom::CircularArc& arc, const geom::CoordinateXY& origin);
+
169 
+
170 };
+
171 
+
172 } // geos::algorithm
+
173 } // geos
+
geos::algorithm::RayCrossingCounter
Counts the number of segments crossed by a horizontal ray extending to the right from a given point,...
Definition: RayCrossingCounter.h:68
geos::algorithm::RayCrossingCounter::countSegment
void countSegment(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2)
Counts a segment.
geos::algorithm::RayCrossingCounter::locatePointInRing
static geom::Location locatePointInRing(const geom::CoordinateXY &p, const geom::CoordinateSequence &ring)
Determines the Location of a point in a ring.
geos::algorithm::RayCrossingCounter::getLocation
geom::Location getLocation() const
Gets the Location of the point relative to the ring, polygon or multipolygon from which the processed...
geos::algorithm::RayCrossingCounter::locatePointInRing
static geom::Location locatePointInRing(const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)
Semantically equal to the above, just different args encoding.
geos::algorithm::RayCrossingCounter::isPointInPolygon
bool isPointInPolygon() const
Tests whether the point lies in or on the ring, polygon or multipolygon from which the processed segm...
-
geos::algorithm::RayCrossingCounter::isOnSegment
bool isOnSegment() const
Reports whether the point lies exactly on one of the supplied segments.
Definition: RayCrossingCounter.h:120
+
geos::algorithm::RayCrossingCounter::isOnSegment
bool isOnSegment() const
Reports whether the point lies exactly on one of the supplied segments.
Definition: RayCrossingCounter.h:135
+
geos::algorithm::RayCrossingCounter::processSequence
void processSequence(const geom::CoordinateSequence &seq, bool isLinear)
Counts all segments or arcs in the sequence.
+
geos::geom::CircularArc
Definition: CircularArc.h:29
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
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/SimpleCurve_8h_source.html b/doxygen/SimpleCurve_8h_source.html index 467ed0c63..b3ea2965a 100644 --- a/doxygen/SimpleCurve_8h_source.html +++ b/doxygen/SimpleCurve_8h_source.html @@ -103,57 +103,63 @@
60 
62  const CoordinateSequence* getCoordinatesRO() const;
63 
-
68  virtual std::unique_ptr<Point> getEndPoint() const;
-
69 
-
70  const Envelope* getEnvelopeInternal() const override
-
71  {
-
72  return &envelope;
-
73  }
-
74 
-
75  std::size_t getNumPoints() const override;
+
64  const SimpleCurve* getCurveN(std::size_t) const override;
+
65 
+
70  virtual std::unique_ptr<Point> getEndPoint() const;
+
71 
+
72  const Envelope* getEnvelopeInternal() const override
+
73  {
+
74  return &envelope;
+
75  }
76 
-
77  virtual std::unique_ptr<Point> getPointN(std::size_t n) const;
+
77  std::size_t getNumCurves() const override;
78 
-
83  virtual std::unique_ptr<Point> getStartPoint() const;
-
84 
-
85  bool hasM() const override;
-
86 
-
87  bool hasZ() const override;
+
79  std::size_t getNumPoints() const override;
+
80 
+
81  virtual std::unique_ptr<Point> getPointN(std::size_t n) const;
+
82 
+
87  virtual std::unique_ptr<Point> getStartPoint() const;
88 
-
89  bool isClosed() const override;
+
89  bool hasM() const override;
90 
-
91  virtual bool isCoordinate(CoordinateXY& pt) const;
+
91  bool hasZ() const override;
92 
-
93  bool isEmpty() const override;
+
93  bool isClosed() const override;
94 
-
102  void normalize() override;
-
103 
-
111  std::unique_ptr<CoordinateSequence> releaseCoordinates();
-
112 
-
113 protected:
-
114 
-
115  SimpleCurve(const SimpleCurve& other);
-
116 
-
117  SimpleCurve(std::unique_ptr<CoordinateSequence>&& newCoords,
-
118  bool isLinear,
-
119  const GeometryFactory& factory);
+
95  virtual bool isCoordinate(CoordinateXY& pt) const;
+
96 
+
97  virtual bool isCurved() const = 0;
+
98 
+
99  bool isEmpty() const override;
+
100 
+
108  void normalize() override;
+
109 
+
117  std::unique_ptr<CoordinateSequence> releaseCoordinates();
+
118 
+
119 protected:
120 
-
121  int compareToSameClass(const Geometry* ls) const override;
+
121  SimpleCurve(const SimpleCurve& other);
122 
-
123  Envelope computeEnvelopeInternal(bool isLinear) const;
-
124 
-
125  // TODO: hold value or shared_ptr instead of unique_ptr?
-
126  std::unique_ptr<CoordinateSequence> points;
-
127  mutable Envelope envelope;
+
123  SimpleCurve(std::unique_ptr<CoordinateSequence>&& newCoords,
+
124  bool isLinear,
+
125  const GeometryFactory& factory);
+
126 
+
127  int compareToSameClass(const Geometry* ls) const override;
128 
-
129 
-
130 private:
-
131 
-
132  void normalizeClosed();
-
133 };
+
129  Envelope computeEnvelopeInternal(bool isLinear) const;
+
130 
+
131  // TODO: hold value or shared_ptr instead of unique_ptr?
+
132  std::unique_ptr<CoordinateSequence> points;
+
133  mutable Envelope envelope;
134 
-
135 }
-
136 }
+
135 
+
136 private:
+
137 
+
138  void normalizeClosed();
+
139 };
+
140 
+
141 }
+
142 }
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/SimplePointInAreaLocator_8h_source.html b/doxygen/SimplePointInAreaLocator_8h_source.html index b92c8f5fe..75a57ca76 100644 --- a/doxygen/SimplePointInAreaLocator_8h_source.html +++ b/doxygen/SimplePointInAreaLocator_8h_source.html @@ -71,7 +71,7 @@
22 namespace geom {
23 class Geometry;
24 class Coordinate;
-
25 class Polygon;
+
25 class Surface;
26 }
27 }
28 
@@ -86,8 +86,8 @@
50  static geom::Location locate(const geom::CoordinateXY& p,
51  const geom::Geometry* geom);
52 
-
72  static geom::Location locatePointInPolygon(const geom::CoordinateXY& p,
-
73  const geom::Polygon* poly);
+
72  static geom::Location locatePointInSurface(const geom::CoordinateXY& p,
+
73  const geom::Surface& poly);
74 
87  static bool isContained(const geom::CoordinateXY& p,
88  const geom::Geometry* geom);
@@ -124,9 +124,9 @@
geos::algorithm::locate::SimplePointInAreaLocator
Computes the location of points relative to a polygonal Geometry, using a simple O(n) algorithm.
Definition: SimplePointInAreaLocator.h:46
geos::algorithm::locate::SimplePointInAreaLocator::locate
geom::Location locate(const geom::CoordinateXY *p) override
Definition: SimplePointInAreaLocator.h:99
geos::algorithm::locate::SimplePointInAreaLocator::isContained
static bool isContained(const geom::CoordinateXY &p, const geom::Geometry *geom)
Determines whether a point is contained in a Geometry, or lies on its boundary.
-
geos::algorithm::locate::SimplePointInAreaLocator::locatePointInPolygon
static geom::Location locatePointInPolygon(const geom::CoordinateXY &p, const geom::Polygon *poly)
Determines the Location of a point in a Polygon.
+
geos::algorithm::locate::SimplePointInAreaLocator::locatePointInSurface
static geom::Location locatePointInSurface(const geom::CoordinateXY &p, const geom::Surface &poly)
Determines the Location of a point in a Surface.
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::geom::Surface
Definition: Surface.h:27
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/TrianglePredicate_8h_source.html b/doxygen/TrianglePredicate_8h_source.html index 4f7d7e4a6..276f82efa 100644 --- a/doxygen/TrianglePredicate_8h_source.html +++ b/doxygen/TrianglePredicate_8h_source.html @@ -68,50 +68,51 @@
19 #pragma once
20 
21 #include <geos/export.h>
-
22 
-
23 namespace geos {
-
24 namespace geom {
-
25 class Coordinate;
-
26 }
+
22 #include <geos/geom/Location.h>
+
23 
+
24 namespace geos {
+
25 namespace geom {
+
26 class CoordinateXY;
27 }
-
28 
-
29 using geos::geom::Coordinate;
-
30 
-
31 namespace geos {
-
32 namespace triangulate {
-
33 namespace quadedge {
-
34 
-
50 class GEOS_DLL TrianglePredicate {
-
51 public:
-
64  static bool isInCircleNonRobust(
-
65  const Coordinate& a, const Coordinate& b, const Coordinate& c,
-
66  const Coordinate& p);
-
67 
-
85  static bool isInCircleNormalized(
-
86  const Coordinate& a, const Coordinate& b, const Coordinate& c,
-
87  const Coordinate& p);
-
88 
-
89 private:
-
98  static double triArea(const Coordinate& a,
-
99  const Coordinate& b, const Coordinate& c);
-
100 
-
101 public:
-
113  static bool isInCircleRobust(
-
114  const Coordinate& a, const Coordinate& b, const Coordinate& c,
-
115  const Coordinate& p);
-
116 } ;
-
117 
+
28 }
+
29 
+
30 namespace geos {
+
31 namespace triangulate {
+
32 namespace quadedge {
+
33 
+
49 class GEOS_DLL TrianglePredicate {
+
50 public:
+
51  using CoordinateXY = geos::geom::CoordinateXY;
+
52 
+
65  static geom::Location isInCircleNonRobust(
+
66  const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c,
+
67  const CoordinateXY& p);
+
68 
+
86  static geom::Location isInCircleNormalized(
+
87  const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c,
+
88  const CoordinateXY& p);
+
89 
+
90 private:
+
99  static double triArea(const CoordinateXY& a,
+
100  const CoordinateXY& b, const CoordinateXY& c);
+
101 
+
102 public:
+
114  static geom::Location isInCircleRobust(
+
115  const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c,
+
116  const CoordinateXY& p);
+
117 } ;
118 
-
119 } // namespace geos.triangulate.quadedge
-
120 } // namespace geos.triangulate
-
121 } // namespace geos
-
122 
+
119 
+
120 } // namespace geos.triangulate.quadedge
+
121 } // namespace geos.triangulate
+
122 } // namespace geos
123 
-
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)
-
geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized
static bool isInCircleNormalized(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
+
124 
+
geos::triangulate::quadedge::TrianglePredicate
Algorithms for computing values and predicates associated with triangles.
Definition: TrianglePredicate.h:49
+
geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust
static geom::Location isInCircleRobust(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
+
geos::triangulate::quadedge::TrianglePredicate::isInCircleNonRobust
static geom::Location isInCircleNonRobust(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
+
geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized
static geom::Location isInCircleNormalized(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, 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
diff --git a/doxygen/Vertex_8h_source.html b/doxygen/Vertex_8h_source.html index 2ff30ca93..3a0097d5a 100644 --- a/doxygen/Vertex_8h_source.html +++ b/doxygen/Vertex_8h_source.html @@ -209,7 +209,7 @@
196  **********************************************************************************************/
197 
207  bool isInCircle(const Vertex& a, const Vertex& b, const Vertex& c) const {
-
208  return triangulate::quadedge::TrianglePredicate::isInCircleRobust(a.p, b.p, c.p, this->p);
+
208  return triangulate::quadedge::TrianglePredicate::isInCircleRobust(a.p, b.p, c.p, this->p) == geom::Location::INTERIOR;
209  }
210 
219  inline bool
@@ -261,13 +261,14 @@
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::TrianglePredicate::isInCircleRobust
static geom::Location isInCircleRobust(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
geos::triangulate::quadedge::Vertex
Models a site (node) in a QuadEdgeSubdivision.
Definition: Vertex.h:60
geos::triangulate::quadedge::Vertex::crossProduct
double crossProduct(const Vertex &v) const
Definition: Vertex.h:136
geos::triangulate::quadedge::Vertex::times
std::unique_ptr< Vertex > times(double c) const
Definition: Vertex.h:160
geos::triangulate::quadedge::Vertex::dot
double dot(Vertex v) const
Definition: Vertex.h:148
geos::triangulate::quadedge::Vertex::isCCW
bool isCCW(const Vertex &b, const Vertex &c) const
Definition: Vertex.h:220
geos::triangulate::quadedge::Vertex::isInCircle
bool isInCircle(const Vertex &a, const Vertex &b, const Vertex &c) const
Definition: Vertex.h:207
+
geos::geom::Location::INTERIOR
@ INTERIOR
geos
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
diff --git a/doxygen/annotated.html b/doxygen/annotated.html index 1dbd7ea6c..e8893f6a3 100644 --- a/doxygen/annotated.html +++ b/doxygen/annotated.html @@ -134,34 +134,35 @@  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 - CCoordinateListA list of Coordinates, which may be set to prevent repeated coordinates from occurring in the list - CCoordinateSequenceThe internal representation of a list of coordinates inside a Geometry - CCoordinateSequenceFilterInterface for classes which provide operations that can be applied to the coordinates in a CoordinateSequence - CCoordinateSequencesUtility methods to operate on CoordinateSequences. Methods that do not benefit from access to the CoordinateSequence internals can be placed here - CDimension - CEnvelopeAn Envelope defines a rectangulare region of the 2D coordinate plane - CGeometryBasic implementation of Geometry, constructed and destructed by GeometryFactory - CGeometryCollectionRepresents a collection of heterogeneous Geometry objects - CGeometryComponentFilter - CGeometryFactorySupplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geometry objects - CGeometryFilterGeometry classes support the concept of applying a Geometry filter to the Geometry - CIntersectionMatrixImplementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix - CLinearRingModels an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple - CLineSegment - CLineString - CMultiLineStringModels a collection of LineStrings - CMultiPoint - CMultiPolygon - CPoint - CPolygonRepresents a linear polygon, which may include holes - CPositionA Position indicates the position of a Location relative to a graph component (Node, Edge, or Area) - CPrecisionModelSpecifies the precision model of the Coordinate in a Geometry - CQuadrantUtility functions for working with quadrants - CSurface - CTriangleRepresents a planar triangle, and provides methods for calculating various properties of triangles + CCircularArc + 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 + CCoordinateListA list of Coordinates, which may be set to prevent repeated coordinates from occurring in the list + CCoordinateSequenceThe internal representation of a list of coordinates inside a Geometry + CCoordinateSequenceFilterInterface for classes which provide operations that can be applied to the coordinates in a CoordinateSequence + CCoordinateSequencesUtility methods to operate on CoordinateSequences. Methods that do not benefit from access to the CoordinateSequence internals can be placed here + CDimension + CEnvelopeAn Envelope defines a rectangulare region of the 2D coordinate plane + CGeometryBasic implementation of Geometry, constructed and destructed by GeometryFactory + CGeometryCollectionRepresents a collection of heterogeneous Geometry objects + CGeometryComponentFilter + CGeometryFactorySupplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geometry objects + CGeometryFilterGeometry classes support the concept of applying a Geometry filter to the Geometry + CIntersectionMatrixImplementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix + CLinearRingModels an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple + CLineSegment + CLineString + CMultiLineStringModels a collection of LineStrings + CMultiPoint + CMultiPolygon + CPoint + CPolygonRepresents a linear polygon, which may include holes + CPositionA Position indicates the position of a Location relative to a graph component (Node, Edge, or Area) + CPrecisionModelSpecifies the precision model of the Coordinate in a Geometry + CQuadrantUtility functions for working with quadrants + CSurface + CTriangleRepresents a planar triangle, and provides methods for calculating various properties of triangles  ►NgeomgraphContains classes that implement topology graphs  ►NindexContains classes that implement indexes for performing noding on geometry graph edges  CEdgeSetIntersectorAn EdgeSetIntersector computes all the intersections between the edges in the set diff --git a/doxygen/classes.html b/doxygen/classes.html index 721f61df0..b1483bec9 100644 --- a/doxygen/classes.html +++ b/doxygen/classes.html @@ -53,7 +53,7 @@
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)
C
-
CascadedPolygonUnion (geos::operation::geounion)
CentralEndpointIntersector (geos::algorithm)
Centroid (geos::algorithm)
CGAlgorithmsDD (geos::algorithm)
ClassicUnionStrategy (geos::operation::geounion)
CommonBits (geos::precision)
CommonBitsOp (geos::precision)
CommonBitsRemover (geos::precision)
ComponentCoordinateExtracter (geos::geom::util)
ConcaveHull (geos::algorithm::hull)
ConcaveHullOfPolygons (geos::algorithm::hull)
ConnectedElementLocationFilter (geos::operation::distance)
ConnectedElementPointFilter (geos::operation::distance)
ConnectedSubgraphFinder (geos::planargraph::algorithm)
ConsistentAreaTester (geos::operation::valid)
ConstrainedDelaunayTriangulator (geos::triangulate::polygon)
ConvexHull (geos::algorithm)
Coordinate (geos::geom)
CoordinateFilter (geos::geom)
CoordinateLessThan (geos::geom)
CoordinateList (geos::geom)
CoordinateOperation (geos::geom::util)
CoordinateSequence (geos::geom)
CoordinateSequenceFilter (geos::geom)
CoordinateSequences (geos::geom)
CoverageEdge (geos::coverage)
CoverageGapFinder (geos::coverage)
CoveragePolygonValidator (geos::coverage)
CoverageRingEdges (geos::coverage)
CoverageSimplifier (geos::coverage)
CoverageUnion (geos::coverage)
CoverageUnion (geos::operation::overlayng)
CoverageValidator (geos::coverage)
+
CascadedPolygonUnion (geos::operation::geounion)
CentralEndpointIntersector (geos::algorithm)
Centroid (geos::algorithm)
CGAlgorithmsDD (geos::algorithm)
CircularArc (geos::geom)
ClassicUnionStrategy (geos::operation::geounion)
CommonBits (geos::precision)
CommonBitsOp (geos::precision)
CommonBitsRemover (geos::precision)
ComponentCoordinateExtracter (geos::geom::util)
ConcaveHull (geos::algorithm::hull)
ConcaveHullOfPolygons (geos::algorithm::hull)
ConnectedElementLocationFilter (geos::operation::distance)
ConnectedElementPointFilter (geos::operation::distance)
ConnectedSubgraphFinder (geos::planargraph::algorithm)
ConsistentAreaTester (geos::operation::valid)
ConstrainedDelaunayTriangulator (geos::triangulate::polygon)
ConvexHull (geos::algorithm)
Coordinate (geos::geom)
CoordinateFilter (geos::geom)
CoordinateLessThan (geos::geom)
CoordinateList (geos::geom)
CoordinateOperation (geos::geom::util)
CoordinateSequence (geos::geom)
CoordinateSequenceFilter (geos::geom)
CoordinateSequences (geos::geom)
CoverageEdge (geos::coverage)
CoverageGapFinder (geos::coverage)
CoveragePolygonValidator (geos::coverage)
CoverageRingEdges (geos::coverage)
CoverageSimplifier (geos::coverage)
CoverageUnion (geos::coverage)
CoverageUnion (geos::operation::overlayng)
CoverageValidator (geos::coverage)
D
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)
diff --git a/doxygen/classgeos_1_1algorithm_1_1Orientation.html b/doxygen/classgeos_1_1algorithm_1_1Orientation.html index f6f417617..36f77782c 100644 --- a/doxygen/classgeos_1_1algorithm_1_1Orientation.html +++ b/doxygen/classgeos_1_1algorithm_1_1Orientation.html @@ -130,7 +130,7 @@

Referenced by geos::geom::LineSegment::orientationIndex().

+

Referenced by geos::geom::CircularArc::orientation(), and geos::geom::LineSegment::orientationIndex().

diff --git a/doxygen/classgeos_1_1algorithm_1_1PointLocation-members.html b/doxygen/classgeos_1_1algorithm_1_1PointLocation-members.html index ddc19a3f9..c4a28227f 100644 --- a/doxygen/classgeos_1_1algorithm_1_1PointLocation-members.html +++ b/doxygen/classgeos_1_1algorithm_1_1PointLocation-members.html @@ -56,6 +56,7 @@ isOnSegment(const geom::CoordinateXY &p, const geom::CoordinateXY &p0, const geom::CoordinateXY &p1)geos::algorithm::PointLocationstatic locateInRing(const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)geos::algorithm::PointLocationstatic locateInRing(const geom::CoordinateXY &p, const geom::CoordinateSequence &ring) (defined in geos::algorithm::PointLocation)geos::algorithm::PointLocationstatic + locateInRing(const geom::CoordinateXY &p, const geom::Curve &ring) (defined in geos::algorithm::PointLocation)geos::algorithm::PointLocationstatic
diff --git a/doxygen/classgeos_1_1algorithm_1_1PointLocation.html b/doxygen/classgeos_1_1algorithm_1_1PointLocation.html index 9ec2a62d5..1e026cc6f 100644 --- a/doxygen/classgeos_1_1algorithm_1_1PointLocation.html +++ b/doxygen/classgeos_1_1algorithm_1_1PointLocation.html @@ -76,6 +76,9 @@ static geom::Location locateInRing (const geom::CoordinateXY &p, const geom::CoordinateSequence &ring)   + +static geom::Location locateInRing (const geom::CoordinateXY &p, const geom::Curve &ring) + 

Detailed Description

Functions for locating points within basic geometric structures such as lines and rings.

diff --git a/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter-members.html b/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter-members.html index 054639824..e1ee8e10c 100644 --- a/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter-members.html +++ b/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter-members.html @@ -50,14 +50,19 @@

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

- - - - - - - + + + + + + + + + + + +
countSegment(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2)geos::algorithm::RayCrossingCounter
getCount() const (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterinline
getLocation() constgeos::algorithm::RayCrossingCounter
isOnSegment() constgeos::algorithm::RayCrossingCounterinline
isPointInPolygon() constgeos::algorithm::RayCrossingCounter
locatePointInRing(const geom::CoordinateXY &p, const geom::CoordinateSequence &ring)geos::algorithm::RayCrossingCounterstatic
locatePointInRing(const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)geos::algorithm::RayCrossingCounterstatic
countArc(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &p3) (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounter
countSegment(const geom::CoordinateXY &p1, const geom::CoordinateXY &p2)geos::algorithm::RayCrossingCounter
getCount() const (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterinline
getLocation() constgeos::algorithm::RayCrossingCounter
isOnSegment() constgeos::algorithm::RayCrossingCounterinline
isPointInPolygon() constgeos::algorithm::RayCrossingCounter
locatePointInRing(const geom::CoordinateXY &p, const geom::CoordinateSequence &ring)geos::algorithm::RayCrossingCounterstatic
locatePointInRing(const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)geos::algorithm::RayCrossingCounterstatic
locatePointInRing(const geom::CoordinateXY &p, const geom::Curve &ring) (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterstatic
pointsIntersectingHorizontalRay(const geom::CircularArc &arc, const geom::CoordinateXY &origin) (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterstatic
processSequence(const geom::CoordinateSequence &seq, bool isLinear)geos::algorithm::RayCrossingCounter
RayCrossingCounter(const geom::CoordinateXY &p_point) (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterinline
shouldCountCrossing(const geom::CircularArc &arc, const geom::CoordinateXY &q) (defined in geos::algorithm::RayCrossingCounter)geos::algorithm::RayCrossingCounterstatic
diff --git a/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter.html b/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter.html index 7799efa3b..7df0aa970 100644 --- a/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter.html +++ b/doxygen/classgeos_1_1algorithm_1_1RayCrossingCounter.html @@ -65,6 +65,13 @@ void countSegment (const geom::CoordinateXY &p1, const geom::CoordinateXY &p2)  Counts a segment. More...
  + +void countArc (const geom::CoordinateXY &p1, const geom::CoordinateXY &p2, const geom::CoordinateXY &p3) +  + +void processSequence (const geom::CoordinateSequence &seq, bool isLinear) + Counts all segments or arcs in the sequence.
+  bool isOnSegment () const  Reports whether the point lies exactly on one of the supplied segments. More...
  @@ -87,6 +94,15 @@ static geom::Location locatePointInRing (const geom::CoordinateXY &p, const std::vector< const geom::Coordinate * > &ring)  Semantically equal to the above, just different args encoding.
  + +static geom::Location locatePointInRing (const geom::CoordinateXY &p, const geom::Curve &ring) +  + +static bool shouldCountCrossing (const geom::CircularArc &arc, const geom::CoordinateXY &q) +  + +static std::array< geom::CoordinateXY, 2 > pointsIntersectingHorizontalRay (const geom::CircularArc &arc, const geom::CoordinateXY &origin) + 

Detailed Description

Counts the number of segments crossed by a horizontal ray extending to the right from a given point, in an incremental fashion.

diff --git a/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator-members.html b/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator-members.html index 63df6a14b..7b61c9dbc 100644 --- a/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator-members.html +++ b/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator-members.html @@ -53,7 +53,7 @@ isContained(const geom::CoordinateXY &p, const geom::Geometry *geom)geos::algorithm::locate::SimplePointInAreaLocatorstatic locate(const geom::CoordinateXY &p, const geom::Geometry *geom) (defined in geos::algorithm::locate::SimplePointInAreaLocator)geos::algorithm::locate::SimplePointInAreaLocatorstatic locate(const geom::CoordinateXY *p) overridegeos::algorithm::locate::SimplePointInAreaLocatorinlinevirtual - locatePointInPolygon(const geom::CoordinateXY &p, const geom::Polygon *poly)geos::algorithm::locate::SimplePointInAreaLocatorstatic + locatePointInSurface(const geom::CoordinateXY &p, const geom::Surface &poly)geos::algorithm::locate::SimplePointInAreaLocatorstatic SimplePointInAreaLocator(const geom::Geometry *p_g) (defined in geos::algorithm::locate::SimplePointInAreaLocator)geos::algorithm::locate::SimplePointInAreaLocatorinline SimplePointInAreaLocator(const geom::Geometry &p_g) (defined in geos::algorithm::locate::SimplePointInAreaLocator)geos::algorithm::locate::SimplePointInAreaLocatorinline ~PointOnGeometryLocator() (defined in geos::algorithm::locate::PointOnGeometryLocator)geos::algorithm::locate::PointOnGeometryLocatorinlinevirtual diff --git a/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator.html b/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator.html index 44b6f397f..d3a154e51 100644 --- a/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator.html +++ b/doxygen/classgeos_1_1algorithm_1_1locate_1_1SimplePointInAreaLocator.html @@ -82,9 +82,9 @@ static geom::Location locate (const geom::CoordinateXY &p, const geom::Geometry *geom)   -static geom::Location locatePointInPolygon (const geom::CoordinateXY &p, const geom::Polygon *poly) - Determines the Location of a point in a Polygon. More...
-  +static geom::Location locatePointInSurface (const geom::CoordinateXY &p, const geom::Surface &poly) + Determines the Location of a point in a Surface. More...
+  static bool isContained (const geom::CoordinateXY &p, const geom::Geometry *geom)  Determines whether a point is contained in a Geometry, or lies on its boundary. More...
  @@ -178,8 +178,8 @@

-

◆ locatePointInPolygon()

+ +

◆ locatePointInSurface()

@@ -188,7 +188,7 @@

- + @@ -196,7 +196,7 @@

- + @@ -212,7 +212,7 @@

-

Determines the Location of a point in a Polygon.

+

Determines the Location of a point in a Surface.

The return value is one of:

  • geom::Location::INTERIOR if the point is in the geometry interior
    • diff --git a/doxygen/classgeos_1_1geom_1_1CircularArc-members.html b/doxygen/classgeos_1_1geom_1_1CircularArc-members.html new file mode 100644 index 000000000..ffb2da29f --- /dev/null +++ b/doxygen/classgeos_1_1geom_1_1CircularArc-members.html @@ -0,0 +1,80 @@ + + + + + + + +GEOS: Member List + + + + + + +
    +
    +

static geom::Location geos::algorithm::locate::SimplePointInAreaLocator::locatePointInPolygon static geom::Location geos::algorithm::locate::SimplePointInAreaLocator::locatePointInSurface ( const geom::CoordinateXY &  p, const geom::Polygon * const geom::Surface &  poly 
+ + + + + +
+
GEOS +  3.13.0dev +
+
+

+ + + + + + + +
+
+
+
geos::geom::CircularArc Member List
+
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + +
begin() const (defined in geos::geom::CircularArc)geos::geom::CircularArcinline
CircularArc(const CoordinateXY &q0, const CoordinateXY &q1, const CoordinateXY &q2) (defined in geos::geom::CircularArc)geos::geom::CircularArcinline
containsAngle(double theta) constgeos::geom::CircularArcinline
containsPoint(const CoordinateXY &q)geos::geom::CircularArcinline
containsPointOnCircle(const CoordinateXY &q) constgeos::geom::CircularArcinline
CoordinateXY typedef (defined in geos::geom::CircularArc)geos::geom::CircularArc
end() const (defined in geos::geom::CircularArc)geos::geom::CircularArcinline
getAngle() constgeos::geom::CircularArcinline
getArea() constgeos::geom::CircularArcinline
getCenter() constgeos::geom::CircularArcinline
getLength() constgeos::geom::CircularArcinline
getRadius() constgeos::geom::CircularArcinline
isCircle() constgeos::geom::CircularArcinline
isLinear() constgeos::geom::CircularArcinline
isUpwardAtPoint(const CoordinateXY &q) constgeos::geom::CircularArcinline
orientation() constgeos::geom::CircularArcinline
p0 (defined in geos::geom::CircularArc)geos::geom::CircularArc
p1 (defined in geos::geom::CircularArc)geos::geom::CircularArc
p2 (defined in geos::geom::CircularArc)geos::geom::CircularArc
theta0() constgeos::geom::CircularArcinline
theta2() constgeos::geom::CircularArcinline
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/classgeos_1_1geom_1_1CircularArc.html b/doxygen/classgeos_1_1geom_1_1CircularArc.html new file mode 100644 index 000000000..90fa6723f --- /dev/null +++ b/doxygen/classgeos_1_1geom_1_1CircularArc.html @@ -0,0 +1,292 @@ + + + + + + + +GEOS: geos::geom::CircularArc Class Reference + + + + + + +
+
+ + + + + + +
+
GEOS +  3.13.0dev +
+
+
+ + + + + + + +
+
+
+Public Types | +Public Member Functions | +Public Attributes | +List of all members
+
+
geos::geom::CircularArc Class Reference
+
+
+ +

#include <CircularArc.h>

+ + + + +

+Public Types

+using CoordinateXY = geom::CoordinateXY
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ CircularArc (const CoordinateXY &q0, const CoordinateXY &q1, const CoordinateXY &q2)
 
int orientation () const
 
+const CoordinateXY & getCenter () const
 Return the center point of the circle associated with this arc.
 
+double getRadius () const
 Return the radius of the circle associated with this arc.
 
+bool isCircle () const
 Return whether this arc forms a complete circle.
 
+bool isLinear () const
 Returns whether this arc forms a straight line (p0, p1, and p2 are collinear)
 
double getAngle () const
 Return the inner angle of the sector associated with this arc. More...
 
+double getLength () const
 Return the length of the arc.
 
+double getArea () const
 Return the area enclosed by the arc p0-p1-p2 and the line segment p2-p0.
 
+double theta0 () const
 Return the angle of p0.
 
+double theta2 () const
 Return the angle of p2.
 
bool containsPointOnCircle (const CoordinateXY &q) const
 
bool containsPoint (const CoordinateXY &q)
 
+bool containsAngle (double theta) const
 Check to see if a given angle lies on this arc.
 
bool isUpwardAtPoint (const CoordinateXY &q) const
 
+Iterator begin () const
 
+Iterator end () const
 
+ + + + + + + +

+Public Attributes

+const CoordinateXY & p0
 
+const CoordinateXY & p1
 
+const CoordinateXY & p2
 
+

Detailed Description

+

A CircularArc is a reference to three points that define a circular arc. It provides for the lazy calculation of various arc properties such as the center, radius, and orientation

+

Member Function Documentation

+ +

◆ containsPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
bool geos::geom::CircularArc::containsPoint (const CoordinateXY & q)
+ 		+inline
+
+

Check to see if a coordinate lies on the arc, after testing whether it lies on the circle.

+ +

References geos::geom::BOUNDARY, and geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized().

+ +
+
+ +

◆ containsPointOnCircle()

+ +
+
+ + + + + +
+ + + + + + + + +
bool geos::geom::CircularArc::containsPointOnCircle (const CoordinateXY & q) const
+ 		+inline
+
+

Check to see if a coordinate lies on the arc Only the angle is checked, so it is assumed that the point lies on the circle of which this arc is a part.

+ +
+
+ +

◆ getAngle()

+ +
+
+ + + + + +
+ + + + + + + +
double geos::geom::CircularArc::getAngle () const
+ 		+inline
+
+ +

Return the inner angle of the sector associated with this arc.

+

Even Rouault: potential optimization?: using crossproduct(p0 - center, p2 - center) = radius * radius * sin(angle) could yield the result by just doing a single asin(), instead of 2 atan2() actually one should also likely compute dotproduct(p0 - center, p2 - center) = radius * radius * cos(angle), and thus angle = atan2(crossproduct(p0 - center, p2 - center) , dotproduct(p0 - center, p2 - center) )

+ +
+
+ +

◆ isUpwardAtPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
bool geos::geom::CircularArc::isUpwardAtPoint (const CoordinateXY & q) const
+ 		+inline
+
+

Return true if the arc is pointing positive in the y direction at the location of a specified point. The point is assumed to be on the arc.

+ +

References geos::geom::Quadrant::quadrant().

+ +
+
+ +

◆ orientation()

+ +
+
+ + + + + +
+ + + + + + + +
int geos::geom::CircularArc::orientation () const
+ 		+inline
+
+

Return the orientation of the arc as one of:

    +
  • algorithm::Orientation::CLOCKWISE,
    • +
  • algorithm::Orientation::COUNTERCLOCKWISE
    • +
  • algorithm::Orientation::COLLINEAR
    • +
+ +

References geos::algorithm::Orientation::index().

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/doxygen/classgeos_1_1geom_1_1LineString-members.html b/doxygen/classgeos_1_1geom_1_1LineString-members.html index 2556d1e38..5fef4fbbd 100644 --- a/doxygen/classgeos_1_1geom_1_1LineString-members.html +++ b/doxygen/classgeos_1_1geom_1_1LineString-members.html @@ -101,16 +101,18 @@ getCoordinateN(std::size_t n) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual getCoordinates() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve getCoordinatesRO() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve - getDimension() const override (defined in geos::geom::Curve)geos::geom::Curveinline - getEndPoint() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual - getEnvelope() constgeos::geom::Geometryvirtual - getEnvelopeInternal() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveinline - getFactory() constgeos::geom::Geometryinline - getGeometryN(std::size_t) constgeos::geom::Geometryinlinevirtual - getGeometryType() const overridegeos::geom::LineStringvirtual - getGeometryTypeId() const overridegeos::geom::LineStringvirtual - getInteriorPoint() constgeos::geom::Geometry - getLength() const overridegeos::geom::LineStringvirtual + getCurveN(std::size_t) const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve + getDimension() const override (defined in geos::geom::Curve)geos::geom::Curveinline + getEndPoint() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual + getEnvelope() constgeos::geom::Geometryvirtual + getEnvelopeInternal() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveinline + getFactory() constgeos::geom::Geometryinline + getGeometryN(std::size_t) constgeos::geom::Geometryinlinevirtual + getGeometryType() const overridegeos::geom::LineStringvirtual + getGeometryTypeId() const overridegeos::geom::LineStringvirtual + getInteriorPoint() constgeos::geom::Geometry + getLength() const overridegeos::geom::LineStringvirtual + getNumCurves() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve getNumGeometries() constgeos::geom::Geometryinlinevirtual getNumPoints() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve getPointN(std::size_t n) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual @@ -131,50 +133,51 @@ isClosed() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve isCollection() const (defined in geos::geom::Geometry)geos::geom::Geometryinline isCoordinate(CoordinateXY &pt) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual - isDimensionStrict(Dimension::DimensionType d) constgeos::geom::Geometryinlinevirtual - isEmpty() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve - isEquivalentClass(const Geometry *other) constgeos::geom::Geometryprotectedvirtual - isLineal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline - isMixedDimension() const (defined in geos::geom::Geometry)geos::geom::Geometry - isMixedDimension(Dimension::DimensionType *baseDim) const (defined in geos::geom::Geometry)geos::geom::Geometry - isPolygonal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline - isPuntal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline - isRectangle() constgeos::geom::Geometryinlinevirtual - isRing() const (defined in geos::geom::Curve)geos::geom::Curve - isSimple() constgeos::geom::Geometryvirtual - isValid() constgeos::geom::Geometryvirtual - isWithinDistance(const Geometry *geom, double cDistance) constgeos::geom::Geometryvirtual - LineString(const LineString &ls) (defined in geos::geom::LineString)geos::geom::LineStringprotected - LineString(CoordinateSequence::Ptr &&pts, const GeometryFactory &newFactory)geos::geom::LineStringprotected - multiTypeId(GeometryTypeId typeId) (defined in geos::geom::Geometry)geos::geom::Geometryinlinestatic - NonConstVect typedefgeos::geom::Geometry - normalize() override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve - overlaps(const Geometry *g) constgeos::geom::Geometryvirtual - points (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected - Ptr typedefgeos::geom::Geometry - relate(const Geometry *g, const std::string &intersectionPattern) constgeos::geom::Geometry - relate(const Geometry &g, const std::string &intersectionPattern) const (defined in geos::geom::Geometry)geos::geom::Geometryinline - relate(const Geometry *g) constgeos::geom::Geometry - relate(const Geometry &g) const (defined in geos::geom::Geometry)geos::geom::Geometry - releaseCoordinates() (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve - reverse() constgeos::geom::LineStringinline - reverseImpl() const overridegeos::geom::LineStringprotectedvirtual - setSRID(int newSRID)geos::geom::Geometryinlinevirtual - setUserData(void *newUserData)geos::geom::Geometryinline - SimpleCurve(const SimpleCurve &other) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected - SimpleCurve(std::unique_ptr< CoordinateSequence > &&newCoords, bool isLinear, const GeometryFactory &factory) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected - SRID (defined in geos::geom::Geometry)geos::geom::Geometryprotected - symDifference(const Geometry *other) constgeos::geom::Geometry - toGeometryArray(std::vector< std::unique_ptr< T >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic - toGeometryArray(std::vector< std::unique_ptr< Geometry >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic - toString() constgeos::geom::Geometryvirtual - toText() const (defined in geos::geom::Geometry)geos::geom::Geometryvirtual - touches(const Geometry *other) constgeos::geom::Geometryvirtual - Union(const Geometry *other) constgeos::geom::Geometry - Union() constgeos::geom::Geometry - within(const Geometry *g) constgeos::geom::Geometryvirtual - ~Geometry()geos::geom::Geometryvirtual - ~LineString() override (defined in geos::geom::LineString)geos::geom::LineString + isCurved() const override (defined in geos::geom::LineString)geos::geom::LineStringinline + isDimensionStrict(Dimension::DimensionType d) constgeos::geom::Geometryinlinevirtual + isEmpty() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve + isEquivalentClass(const Geometry *other) constgeos::geom::Geometryprotectedvirtual + isLineal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline + isMixedDimension() const (defined in geos::geom::Geometry)geos::geom::Geometry + isMixedDimension(Dimension::DimensionType *baseDim) const (defined in geos::geom::Geometry)geos::geom::Geometry + isPolygonal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline + isPuntal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline + isRectangle() constgeos::geom::Geometryinlinevirtual + isRing() const (defined in geos::geom::Curve)geos::geom::Curve + isSimple() constgeos::geom::Geometryvirtual + isValid() constgeos::geom::Geometryvirtual + isWithinDistance(const Geometry *geom, double cDistance) constgeos::geom::Geometryvirtual + LineString(const LineString &ls) (defined in geos::geom::LineString)geos::geom::LineStringprotected + LineString(CoordinateSequence::Ptr &&pts, const GeometryFactory &newFactory)geos::geom::LineStringprotected + multiTypeId(GeometryTypeId typeId) (defined in geos::geom::Geometry)geos::geom::Geometryinlinestatic + NonConstVect typedefgeos::geom::Geometry + normalize() override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve + overlaps(const Geometry *g) constgeos::geom::Geometryvirtual + points (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected + Ptr typedefgeos::geom::Geometry + relate(const Geometry *g, const std::string &intersectionPattern) constgeos::geom::Geometry + relate(const Geometry &g, const std::string &intersectionPattern) const (defined in geos::geom::Geometry)geos::geom::Geometryinline + relate(const Geometry *g) constgeos::geom::Geometry + relate(const Geometry &g) const (defined in geos::geom::Geometry)geos::geom::Geometry + releaseCoordinates() (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve + reverse() constgeos::geom::LineStringinline + reverseImpl() const overridegeos::geom::LineStringprotectedvirtual + setSRID(int newSRID)geos::geom::Geometryinlinevirtual + setUserData(void *newUserData)geos::geom::Geometryinline + SimpleCurve(const SimpleCurve &other) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected + SimpleCurve(std::unique_ptr< CoordinateSequence > &&newCoords, bool isLinear, const GeometryFactory &factory) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected + SRID (defined in geos::geom::Geometry)geos::geom::Geometryprotected + symDifference(const Geometry *other) constgeos::geom::Geometry + toGeometryArray(std::vector< std::unique_ptr< T >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic + toGeometryArray(std::vector< std::unique_ptr< Geometry >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic + toString() constgeos::geom::Geometryvirtual + toText() const (defined in geos::geom::Geometry)geos::geom::Geometryvirtual + touches(const Geometry *other) constgeos::geom::Geometryvirtual + Union(const Geometry *other) constgeos::geom::Geometry + Union() constgeos::geom::Geometry + within(const Geometry *g) constgeos::geom::Geometryvirtual + ~Geometry()geos::geom::Geometryvirtual + ~LineString() override (defined in geos::geom::LineString)geos::geom::LineString

diff --git a/doxygen/classgeos_1_1geom_1_1LineString.html b/doxygen/classgeos_1_1geom_1_1LineString.html index 78248dfdb..a1377f25e 100644 --- a/doxygen/classgeos_1_1geom_1_1LineString.html +++ b/doxygen/classgeos_1_1geom_1_1LineString.html @@ -89,6 +89,9 @@ double getLength () const override  Returns the length of this Geometry.
  + +bool isCurved () const override +  std::unique_ptr< LineString > reverse () const   diff --git a/doxygen/classgeos_1_1geom_1_1LinearRing-members.html b/doxygen/classgeos_1_1geom_1_1LinearRing-members.html index 465770068..636fd5845 100644 --- a/doxygen/classgeos_1_1geom_1_1LinearRing-members.html +++ b/doxygen/classgeos_1_1geom_1_1LinearRing-members.html @@ -100,16 +100,18 @@ - - - - - - - - - - + + + + + + + + + + + + @@ -130,56 +132,57 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getCoordinateN(std::size_t n) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual
getCoordinates() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
getCoordinatesRO() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
getDimension() const override (defined in geos::geom::Curve)geos::geom::Curveinline
getEndPoint() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual
getEnvelope() constgeos::geom::Geometryvirtual
getEnvelopeInternal() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveinline
getFactory() constgeos::geom::Geometryinline
getGeometryN(std::size_t) constgeos::geom::Geometryinlinevirtual
getGeometryType() const overridegeos::geom::LinearRingvirtual
getGeometryTypeId() const overridegeos::geom::LinearRingvirtual
getInteriorPoint() constgeos::geom::Geometry
getLength() const overridegeos::geom::LineStringvirtual
getCurveN(std::size_t) const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
getDimension() const override (defined in geos::geom::Curve)geos::geom::Curveinline
getEndPoint() const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual
getEnvelope() constgeos::geom::Geometryvirtual
getEnvelopeInternal() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveinline
getFactory() constgeos::geom::Geometryinline
getGeometryN(std::size_t) constgeos::geom::Geometryinlinevirtual
getGeometryType() const overridegeos::geom::LinearRingvirtual
getGeometryTypeId() const overridegeos::geom::LinearRingvirtual
getInteriorPoint() constgeos::geom::Geometry
getLength() const overridegeos::geom::LineStringvirtual
getNumCurves() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
getNumGeometries() constgeos::geom::Geometryinlinevirtual
getNumPoints() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
getPointN(std::size_t n) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual
isClosed() const override (defined in geos::geom::LinearRing)geos::geom::LinearRing
isCollection() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isCoordinate(CoordinateXY &pt) const (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurvevirtual
isDimensionStrict(Dimension::DimensionType d) constgeos::geom::Geometryinlinevirtual
isEmpty() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
isEquivalentClass(const Geometry *other) constgeos::geom::Geometryprotectedvirtual
isLineal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isMixedDimension() const (defined in geos::geom::Geometry)geos::geom::Geometry
isMixedDimension(Dimension::DimensionType *baseDim) const (defined in geos::geom::Geometry)geos::geom::Geometry
isPolygonal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isPuntal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isRectangle() constgeos::geom::Geometryinlinevirtual
isRing() const (defined in geos::geom::Curve)geos::geom::Curve
isSimple() constgeos::geom::Geometryvirtual
isValid() constgeos::geom::Geometryvirtual
isWithinDistance(const Geometry *geom, double cDistance) constgeos::geom::Geometryvirtual
LinearRing(const LinearRing &lr) (defined in geos::geom::LinearRing)geos::geom::LinearRing
LinearRing(CoordinateSequence::Ptr &&points, const GeometryFactory &newFactory)geos::geom::LinearRing
LineString(const LineString &ls) (defined in geos::geom::LineString)geos::geom::LineStringprotected
LineString(CoordinateSequence::Ptr &&pts, const GeometryFactory &newFactory)geos::geom::LineStringprotected
MINIMUM_VALID_SIZEgeos::geom::LinearRingstatic
multiTypeId(GeometryTypeId typeId) (defined in geos::geom::Geometry)geos::geom::Geometryinlinestatic
NonConstVect typedefgeos::geom::Geometry
normalize() override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
orient(bool isCW) (defined in geos::geom::LinearRing)geos::geom::LinearRing
overlaps(const Geometry *g) constgeos::geom::Geometryvirtual
points (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
Ptr typedefgeos::geom::Geometry
relate(const Geometry *g, const std::string &intersectionPattern) constgeos::geom::Geometry
relate(const Geometry &g, const std::string &intersectionPattern) const (defined in geos::geom::Geometry)geos::geom::Geometryinline
relate(const Geometry *g) constgeos::geom::Geometry
relate(const Geometry &g) const (defined in geos::geom::Geometry)geos::geom::Geometry
releaseCoordinates() (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
reverse() const (defined in geos::geom::LinearRing)geos::geom::LinearRinginline
reverseImpl() const overridegeos::geom::LinearRingprotectedvirtual
setPoints(const CoordinateSequence *cl) (defined in geos::geom::LinearRing)geos::geom::LinearRing
setSRID(int newSRID)geos::geom::Geometryinlinevirtual
setUserData(void *newUserData)geos::geom::Geometryinline
SimpleCurve(const SimpleCurve &other) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
SimpleCurve(std::unique_ptr< CoordinateSequence > &&newCoords, bool isLinear, const GeometryFactory &factory) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
SRID (defined in geos::geom::Geometry)geos::geom::Geometryprotected
symDifference(const Geometry *other) constgeos::geom::Geometry
toGeometryArray(std::vector< std::unique_ptr< T >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic
toGeometryArray(std::vector< std::unique_ptr< Geometry >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic
toString() constgeos::geom::Geometryvirtual
toText() const (defined in geos::geom::Geometry)geos::geom::Geometryvirtual
touches(const Geometry *other) constgeos::geom::Geometryvirtual
Union(const Geometry *other) constgeos::geom::Geometry
Union() constgeos::geom::Geometry
within(const Geometry *g) constgeos::geom::Geometryvirtual
~Geometry()geos::geom::Geometryvirtual
~LinearRing() override=default (defined in geos::geom::LinearRing)geos::geom::LinearRing
~LineString() override (defined in geos::geom::LineString)geos::geom::LineString
isCurved() const override (defined in geos::geom::LineString)geos::geom::LineStringinline
isDimensionStrict(Dimension::DimensionType d) constgeos::geom::Geometryinlinevirtual
isEmpty() const override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
isEquivalentClass(const Geometry *other) constgeos::geom::Geometryprotectedvirtual
isLineal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isMixedDimension() const (defined in geos::geom::Geometry)geos::geom::Geometry
isMixedDimension(Dimension::DimensionType *baseDim) const (defined in geos::geom::Geometry)geos::geom::Geometry
isPolygonal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isPuntal() const (defined in geos::geom::Geometry)geos::geom::Geometryinline
isRectangle() constgeos::geom::Geometryinlinevirtual
isRing() const (defined in geos::geom::Curve)geos::geom::Curve
isSimple() constgeos::geom::Geometryvirtual
isValid() constgeos::geom::Geometryvirtual
isWithinDistance(const Geometry *geom, double cDistance) constgeos::geom::Geometryvirtual
LinearRing(const LinearRing &lr) (defined in geos::geom::LinearRing)geos::geom::LinearRing
LinearRing(CoordinateSequence::Ptr &&points, const GeometryFactory &newFactory)geos::geom::LinearRing
LineString(const LineString &ls) (defined in geos::geom::LineString)geos::geom::LineStringprotected
LineString(CoordinateSequence::Ptr &&pts, const GeometryFactory &newFactory)geos::geom::LineStringprotected
MINIMUM_VALID_SIZEgeos::geom::LinearRingstatic
multiTypeId(GeometryTypeId typeId) (defined in geos::geom::Geometry)geos::geom::Geometryinlinestatic
NonConstVect typedefgeos::geom::Geometry
normalize() override (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
orient(bool isCW) (defined in geos::geom::LinearRing)geos::geom::LinearRing
overlaps(const Geometry *g) constgeos::geom::Geometryvirtual
points (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
Ptr typedefgeos::geom::Geometry
relate(const Geometry *g, const std::string &intersectionPattern) constgeos::geom::Geometry
relate(const Geometry &g, const std::string &intersectionPattern) const (defined in geos::geom::Geometry)geos::geom::Geometryinline
relate(const Geometry *g) constgeos::geom::Geometry
relate(const Geometry &g) const (defined in geos::geom::Geometry)geos::geom::Geometry
releaseCoordinates() (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurve
reverse() const (defined in geos::geom::LinearRing)geos::geom::LinearRinginline
reverseImpl() const overridegeos::geom::LinearRingprotectedvirtual
setPoints(const CoordinateSequence *cl) (defined in geos::geom::LinearRing)geos::geom::LinearRing
setSRID(int newSRID)geos::geom::Geometryinlinevirtual
setUserData(void *newUserData)geos::geom::Geometryinline
SimpleCurve(const SimpleCurve &other) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
SimpleCurve(std::unique_ptr< CoordinateSequence > &&newCoords, bool isLinear, const GeometryFactory &factory) (defined in geos::geom::SimpleCurve)geos::geom::SimpleCurveprotected
SRID (defined in geos::geom::Geometry)geos::geom::Geometryprotected
symDifference(const Geometry *other) constgeos::geom::Geometry
toGeometryArray(std::vector< std::unique_ptr< T >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic
toGeometryArray(std::vector< std::unique_ptr< Geometry >> &&v) (defined in geos::geom::Geometry)geos::geom::Geometryinlineprotectedstatic
toString() constgeos::geom::Geometryvirtual
toText() const (defined in geos::geom::Geometry)geos::geom::Geometryvirtual
touches(const Geometry *other) constgeos::geom::Geometryvirtual
Union(const Geometry *other) constgeos::geom::Geometry
Union() constgeos::geom::Geometry
within(const Geometry *g) constgeos::geom::Geometryvirtual
~Geometry()geos::geom::Geometryvirtual
~LinearRing() override=default (defined in geos::geom::LinearRing)geos::geom::LinearRing
~LineString() override (defined in geos::geom::LineString)geos::geom::LineString
diff --git a/doxygen/classgeos_1_1geom_1_1LinearRing.html b/doxygen/classgeos_1_1geom_1_1LinearRing.html index 8ea9764e5..e1a5a7c6b 100644 --- a/doxygen/classgeos_1_1geom_1_1LinearRing.html +++ b/doxygen/classgeos_1_1geom_1_1LinearRing.html @@ -117,6 +117,9 @@ double getLength () const override  Returns the length of this Geometry.
  + +bool isCurved () const override +  std::unique_ptr< LineString > reverse () const   diff --git a/doxygen/classgeos_1_1geom_1_1Quadrant.html b/doxygen/classgeos_1_1geom_1_1Quadrant.html index aa1c0e937..5666ae3bc 100644 --- a/doxygen/classgeos_1_1geom_1_1Quadrant.html +++ b/doxygen/classgeos_1_1geom_1_1Quadrant.html @@ -280,6 +280,8 @@

Referenced by geos::geom::CircularArc::isUpwardAtPoint().

+
The documentation for this class was generated from the following file:
    diff --git a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate-members.html b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate-members.html index 0e4675bf9..781da1b67 100644 --- a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate-members.html +++ b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate-members.html @@ -50,9 +50,10 @@

    This is the complete list of members for geos::triangulate::quadedge::TrianglePredicate, including all inherited members.

- - - + + + +
isInCircleNonRobust(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)geos::triangulate::quadedge::TrianglePredicatestatic
isInCircleNormalized(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)geos::triangulate::quadedge::TrianglePredicatestatic
isInCircleRobust(const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)geos::triangulate::quadedge::TrianglePredicatestatic
CoordinateXY typedef (defined in geos::triangulate::quadedge::TrianglePredicate)geos::triangulate::quadedge::TrianglePredicate
isInCircleNonRobust(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)geos::triangulate::quadedge::TrianglePredicatestatic
isInCircleNormalized(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)geos::triangulate::quadedge::TrianglePredicatestatic
isInCircleRobust(const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)geos::triangulate::quadedge::TrianglePredicatestatic
diff --git a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate.html b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate.html index fcc66a5b9..52bc4ff93 100644 --- a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate.html +++ b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1TrianglePredicate.html @@ -44,6 +44,7 @@
+Public Types | Static Public Member Functions | List of all members
@@ -56,14 +57,20 @@

#include <TrianglePredicate.h>

+ + + +

+Public Types

+using CoordinateXY = geos::geom::CoordinateXY
 
- - - - - - + + + + + +

Static Public Member Functions

static bool isInCircleNonRobust (const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
 
static bool isInCircleNormalized (const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
 
static bool isInCircleRobust (const Coordinate &a, const Coordinate &b, const Coordinate &c, const Coordinate &p)
 
static geom::Location isInCircleNonRobust (const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
 
static geom::Location isInCircleNormalized (const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
 
static geom::Location isInCircleRobust (const CoordinateXY &a, const CoordinateXY &b, const CoordinateXY &c, const CoordinateXY &p)
 

Detailed Description

Algorithms for computing values and predicates associated with triangles.

@@ -72,8 +79,8 @@
Benjamin Campbell

Member Function Documentation

- -

◆ isInCircleNonRobust()

+ +

◆ isInCircleNonRobust()

@@ -82,27 +89,27 @@

- + - + - + - + - + @@ -131,8 +138,8 @@

-

◆ isInCircleNormalized()

+ +

◆ isInCircleNormalized()

@@ -141,27 +148,27 @@

static bool geos::triangulate::quadedge::TrianglePredicate::isInCircleNonRobust static geom::Location geos::triangulate::quadedge::TrianglePredicate::isInCircleNonRobust (const Coordinate & const CoordinateXY &  a,
const Coordinate & const CoordinateXY &  b,
const Coordinate & const CoordinateXY &  c,
const Coordinate & const CoordinateXY &  p 
- + - + - + - + - + @@ -189,10 +196,12 @@

Returns
true if this point is inside the circle defined by the points a, b, c
+

Referenced by geos::geom::CircularArc::containsPoint().

+ - -

◆ isInCircleRobust()

+ +

◆ isInCircleRobust()

@@ -201,27 +210,27 @@

static bool geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized static geom::Location geos::triangulate::quadedge::TrianglePredicate::isInCircleNormalized (const Coordinate & const CoordinateXY &  a,
const Coordinate & const CoordinateXY &  b,
const Coordinate & const CoordinateXY &  c,
const Coordinate & const CoordinateXY &  p 
- + - + - + - + - + diff --git a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1Vertex.html b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1Vertex.html index a07f9b540..72b223d31 100644 --- a/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1Vertex.html +++ b/doxygen/classgeos_1_1triangulate_1_1quadedge_1_1Vertex.html @@ -320,7 +320,7 @@

Returns
true if this vertex is in the circumcircle of (a,b,c)
-

References geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust().

+

References geos::geom::INTERIOR, and geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust().

diff --git a/doxygen/files.html b/doxygen/files.html index d02373d28..37ded9fb3 100644 --- a/doxygen/files.html +++ b/doxygen/files.html @@ -77,489 +77,490 @@

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static bool geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust static geom::Location geos::triangulate::quadedge::TrianglePredicate::isInCircleRobust (const Coordinate & const CoordinateXY &  a,
const Coordinate & const CoordinateXY &  b,
const Coordinate & const CoordinateXY &  c,
const Coordinate & const CoordinateXY &  p 
 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
 CircularArc.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_b.html b/doxygen/functions_b.html index 76bd18434..9d4938356 100644 --- a/doxygen/functions_b.html +++ b/doxygen/functions_b.html @@ -80,12 +80,12 @@

- b -

diff --git a/doxygen/namespacegeos_1_1geom.html b/doxygen/namespacegeos_1_1geom.html index 2c71314d7..995757244 100644 --- a/doxygen/namespacegeos_1_1geom.html +++ b/doxygen/namespacegeos_1_1geom.html @@ -64,6 +64,8 @@ + + diff --git a/doxygen/namespaces.html b/doxygen/namespaces.html index f5914c0bf..4c6869513 100644 --- a/doxygen/namespaces.html +++ b/doxygen/namespaces.html @@ -135,34 +135,35 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Classes

class  CircularArc
 
class  Coordinate
 Coordinate is the lightweight class used to store coordinates. More...
 
 ►NgeomgraphContains classes that implement topology graphs