GEOS  3.9.1
EdgeNodingBuilder.h
1 /**********************************************************************
2  *
3  * GEOS - Geometry Engine Open Source
4  * http://geos.osgeo.org
5  *
6  * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
7  *
8  * This is free software; you can redistribute and/or modify it under
9  * the terms of the GNU Lesser General Public Licence as published
10  * by the Free Software Foundation.
11  * See the COPYING file for more information.
12  *
13  **********************************************************************
14  *
15  * Last port: operation/overlayng/EdgeNodingBuilder.java 6ef89b096
16  *
17  **********************************************************************/
18 
19 #pragma once
20 
21 #include <geos/algorithm/LineIntersector.h>
22 #include <geos/algorithm/Orientation.h>
23 #include <geos/geom/Coordinate.h>
24 #include <geos/geom/CoordinateArraySequence.h>
25 #include <geos/geom/CoordinateSequence.h>
26 #include <geos/geom/Envelope.h>
27 #include <geos/geom/Geometry.h>
28 #include <geos/geom/GeometryCollection.h>
29 #include <geos/geom/LinearRing.h>
30 #include <geos/geom/LineString.h>
31 #include <geos/geom/MultiLineString.h>
32 #include <geos/geom/MultiPolygon.h>
33 #include <geos/geom/Polygon.h>
34 #include <geos/noding/IntersectionAdder.h>
35 #include <geos/noding/MCIndexNoder.h>
36 #include <geos/noding/Noder.h>
37 #include <geos/noding/NodedSegmentString.h>
38 #include <geos/noding/SegmentString.h>
39 #include <geos/noding/ValidatingNoder.h>
40 #include <geos/noding/snapround/SnapRoundingNoder.h>
41 #include <geos/operation/overlayng/Edge.h>
42 #include <geos/operation/overlayng/EdgeSourceInfo.h>
43 #include <geos/operation/overlayng/InputGeometry.h>
44 #include <geos/operation/overlayng/LineLimiter.h>
45 #include <geos/operation/overlayng/OverlayUtil.h>
46 #include <geos/operation/overlayng/RingClipper.h>
47 #include <geos/operation/valid/RepeatedPointRemover.h>
48 
49 
50 #include <geos/export.h>
51 #include <array>
52 #include <memory>
53 #include <deque>
54 
55 using namespace geos::geom;
56 using namespace geos::noding;
59 
60 
61 namespace geos { // geos.
62 namespace operation { // geos.operation
63 namespace overlayng { // geos.operation.overlayng
64 
80 class GEOS_DLL EdgeNodingBuilder {
81 
82 private:
83 
84  // Constants
85  static constexpr int MIN_LIMIT_PTS = 20;
86  static constexpr bool IS_NODING_VALIDATED = true;
87 
88  // Members
89  const PrecisionModel* pm;
90  std::unique_ptr<std::vector<SegmentString*>> inputEdges;
91  Noder* customNoder;
92  std::array<bool, 2> hasEdges;
93  const Envelope* clipEnv;
94  std::unique_ptr<RingClipper> clipper;
95  std::unique_ptr<LineLimiter> limiter;
96 
97  // For use in createFloatingPrecisionNoder()
98  LineIntersector lineInt;
99  IntersectionAdder intAdder;
100  std::unique_ptr<Noder> internalNoder;
101  std::unique_ptr<Noder> spareInternalNoder;
102  // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
103  std::deque<EdgeSourceInfo> edgeSourceInfoQue;
104  std::deque<Edge> edgeQue;
105 
114  Noder* getNoder();
115  std::unique_ptr<Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
116  std::unique_ptr<Noder> createFloatingPrecisionNoder(bool doValidation);
117 
118 
119  void addCollection(const GeometryCollection* gc, int geomIndex);
120  void addGeometryCollection(const GeometryCollection* gc, int geomIndex, int expectedDim);
121  void addPolygon(const Polygon* poly, int geomIndex);
122  void addPolygonRing(const LinearRing* ring, bool isHole, int geomIndex);
123  void addLine(const LineString* line, int geomIndex);
124  void addLine(std::unique_ptr<CoordinateArraySequence>& pts, int geomIndex);
125  void addEdge(std::unique_ptr<std::vector<Coordinate>> pts, const EdgeSourceInfo* info);
126  void addEdge(std::unique_ptr<CoordinateArraySequence>& cas, const EdgeSourceInfo* info);
127 
128  // Create a EdgeSourceInfo* owned by EdgeNodingBuilder
129  const EdgeSourceInfo* createEdgeSourceInfo(int index, int depthDelta, bool isHole);
130  const EdgeSourceInfo* createEdgeSourceInfo(int index);
131 
136  bool isClippedCompletely(const Envelope* env);
137 
143  bool isToBeLimited(const LineString* line) const;
144 
150  std::vector<std::unique_ptr<CoordinateArraySequence>>& limit(const LineString* line);
151 
166  std::unique_ptr<CoordinateArraySequence> clip(const LinearRing* line);
167 
175  std::unique_ptr<CoordinateArraySequence> removeRepeatedPoints(const LineString* line);
176 
177  int computeDepthDelta(const LinearRing* ring, bool isHole);
178 
179  void add(const Geometry* g, int geomIndex);
180 
187  std::vector<Edge*> node(std::vector<SegmentString*>* segStrings);
188  std::vector<Edge*> createEdges(std::vector<SegmentString*>* segStrings);
189 
190 
191 public:
192 
198  EdgeNodingBuilder(const PrecisionModel* p_pm, Noder* p_customNoder)
199  : pm(p_pm)
200  , inputEdges(new std::vector<SegmentString*>)
201  , customNoder(p_customNoder)
202  , hasEdges({false,false})
203  , clipEnv(nullptr)
204  , intAdder(lineInt)
205  {};
206 
207  ~EdgeNodingBuilder()
208  {
209  for (SegmentString* ss: *inputEdges) {
210  delete ss;
211  }
212  }
213 
214  void setClipEnvelope(const Envelope* clipEnv);
215 
216  // returns newly allocated vector and segmentstrings
217  // std::vector<SegmentString*>* node();
218 
229  bool hasEdgesFor(int geomIndex) const;
230 
242  std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
243 
244 
245 
246 };
247 
248 
249 } // namespace geos.operation.overlayng
250 } // namespace geos.operation
251 } // namespace geos
252 
A LineIntersector is an algorithm that can both test whether two line segments intersect and compute ...
Definition: LineIntersector.h:49
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:58
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:55
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:188
Definition: LineString.h:68
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
Represents a linear polygon, which may include holes.
Definition: Polygon.h:64
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:87
Computes the intersections between two line segments in SegmentString and adds them to each string.
Definition: IntersectionAdder.h:57
Computes all intersections between segments in a set of SegmentString.
Definition: Noder.h:49
An interface for classes which represent a sequence of contiguous line segments.
Definition: SegmentString.h:46
Definition: SnapRoundingNoder.h:71
Definition: EdgeNodingBuilder.h:80
std::vector< Edge * > build(const Geometry *geom0, const Geometry *geom1)
EdgeNodingBuilder(const PrecisionModel *p_pm, Noder *p_customNoder)
Definition: EdgeNodingBuilder.h:198
Definition: EdgeSourceInfo.h:38
Definition: IndexedNestedRingTester.h:27
Classes to compute nodings for arrangements of line segments and line segment sequences.
Definition: PreparedPolygon.h:31
Basic namespace for all GEOS functionalities.
Definition: IndexedNestedRingTester.h:26