GEOS 3.12.0beta1
CoverageRingEdges.h
1/**********************************************************************
2 *
3 * GEOS - Geometry Engine Open Source
4 * http://geos.osgeo.org
5 *
6 * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
7 * Copyright (c) 2023 Martin Davis.
8 *
9 * This is free software; you can redistribute and/or modify it under
10 * the terms of the GNU Lesser General Public Licence as published
11 * by the Free Software Foundation.
12 * See the COPYING file for more information.
13 *
14 **********************************************************************/
15
16#pragma once
17
18#include <geos/geom/Coordinate.h>
19#include <geos/geom/LineSegment.h>
20
21#include <set>
22#include <map>
23
24// Forward declarations
25namespace geos {
26namespace geom {
28class Geometry;
29class LinearRing;
30class MultiPolygon;
31class Polygon;
32}
33namespace coverage {
34class CoverageEdge;
35}
36}
37
45
46namespace geos { // geos
47namespace coverage { // geos.coverage
48
59class GEOS_DLL CoverageRingEdges {
60
61private:
62
63 // Members
64 std::vector<const Geometry*>& m_coverage;
65 std::map<const LinearRing*, std::vector<CoverageEdge*>> m_ringEdgesMap;
66 std::vector<CoverageEdge*> m_edges;
67 std::vector<std::unique_ptr<CoverageEdge>> m_edgeStore;
68
69 /* Turn off copy constructors for MSVC */
70 CoverageRingEdges(const CoverageRingEdges&) = delete;
71 CoverageRingEdges& operator=(const CoverageRingEdges&) = delete;
72
73public:
74
81 // static std::unique_ptr<CoverageRingEdges> create(
82 // std::vector<const Geometry*>& coverage);
83
84
85 CoverageRingEdges(std::vector<const Geometry*>& coverage)
86 : m_coverage(coverage)
87 {
88 build();
89 };
90
91
92 std::vector<CoverageEdge*>& getEdges()
93 {
94 return m_edges;
95 };
96
103 std::vector<CoverageEdge*> selectEdges(
104 std::size_t ringCount) const;
105
111 std::vector<std::unique_ptr<Geometry>> buildCoverage() const;
112
113
114private:
115
116 void build();
117
118 void addRingEdges(
119 const LinearRing* ring,
120 Coordinate::UnorderedSet& nodes,
121 LineSegment::UnorderedSet& boundarySegs,
122 std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
123
124 void addBoundaryInnerNodes(
125 const LinearRing* ring,
126 LineSegment::UnorderedSet& boundarySegs,
127 Coordinate::UnorderedSet& nodes);
128
129 std::vector<CoverageEdge*> extractRingEdges(
130 const LinearRing* ring,
131 std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap,
132 Coordinate::UnorderedSet& nodes);
133
134 CoverageEdge* createEdge(
135 const CoordinateSequence& ring,
136 std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
137
138 CoverageEdge* createEdge(
139 const CoordinateSequence& ring,
140 std::size_t start, std::size_t end,
141 std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
142
143 std::size_t findNextNodeIndex(
144 const CoordinateSequence& ring,
145 std::size_t start,
146 Coordinate::UnorderedSet& nodes) const;
147
148 static std::size_t next(
149 std::size_t index,
150 const CoordinateSequence& ring);
151
152 Coordinate::UnorderedSet findMultiRingNodes(
153 std::vector<const Geometry*>& coverage);
154
155 Coordinate::UnorderedSet findBoundaryNodes(
156 LineSegment::UnorderedSet& lineSegments);
157
158 std::unique_ptr<Geometry> buildPolygonal(
159 const Geometry* geom) const;
160
161 std::unique_ptr<Geometry> buildMultiPolygon(
162 const MultiPolygon* geom) const;
163
164 std::unique_ptr<Polygon> buildPolygon(
165 const Polygon* polygon) const;
166
167 std::unique_ptr<LinearRing> buildRing(
168 const LinearRing* ring) const;
169
170 bool isEdgeDirForward(
171 const std::vector<CoverageEdge*>& ringEdges,
172 std::size_t index,
173 const Coordinate& prevPt) const;
174
175
176};
177
178} // namespace geos.coverage
179} // namespace geos
Definition: CoverageEdge.h:54
Definition: CoverageRingEdges.h:59
std::vector< std::unique_ptr< Geometry > > buildCoverage() const
CoverageRingEdges(std::vector< const Geometry * > &coverage)
Definition: CoverageRingEdges.h:85
std::vector< CoverageEdge * > selectEdges(std::size_t ringCount) const
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:216
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:186
Definition: LineSegment.h:61
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
Definition: MultiPolygon.h:58
Represents a linear polygon, which may include holes.
Definition: Polygon.h:60
Basic namespace for all GEOS functionalities.
Definition: geos.h:39