reorganize headers

include/geos/operation/overlayng/EdgeMerger.h

@@ -14,11 +14,7 @@
 
 #pragma once
 
-#include <geos/operation/overlayng/OverlayLabel.h>
-#include <geos/operation/overlayng/EdgeKey.h>
-#include <geos/operation/overlayng/Edge.h>
 #include <geos/export.h>
-
 #include <vector>
 #include <map>
 
@@ -31,7 +27,6 @@ class Coordinate;
 namespace operation {
 namespace overlayng {
 class Edge;
-class EdgeKey;
 }
 }
 }

include/geos/operation/overlayng/EdgeNodingBuilder.h

@@ -40,8 +40,6 @@
 #include <memory>
 #include <deque>
 
-using namespace geos::geom;
-using namespace geos::noding;
 
 
 namespace geos {      // geos.
@@ -57,7 +55,7 @@ namespace overlayng { // geos.operation.overlayng
  *  - Extracts input edges, and attaches topological information
  *  - if clipping is enabled, handles clipping or limiting input geometry
  *  - chooses a {@link noding::Noder} based on provided precision model, unless a custom one is supplied
- *  - calls the chosen Noder, with precision model
+ *  - calls the chosen noding::Noder, with precision model
  *  - removes any fully collapsed noded edges
  *  - builds {@link Edge}s and merges them
  *
@@ -73,18 +71,18 @@ class GEOS_DLL EdgeNodingBuilder {
 
     // Members
     const PrecisionModel* pm;
-    std::unique_ptr<std::vector<SegmentString*>> inputEdges;
-    Noder* customNoder;
+    std::unique_ptr<std::vector<noding::SegmentString*>> inputEdges;
+    noding::Noder* customNoder;
     std::array<bool, 2> hasEdges;
     const Envelope* clipEnv;
     std::unique_ptr<RingClipper> clipper;
     std::unique_ptr<LineLimiter> limiter;
 
     // For use in createFloatingPrecisionNoder()
     algorithm::LineIntersector lineInt;
-    IntersectionAdder intAdder;
-    std::unique_ptr<Noder> internalNoder;
-    std::unique_ptr<Noder> spareInternalNoder;
+    noding::IntersectionAdder intAdder;
+    std::unique_ptr<noding::Noder> internalNoder;
+    std::unique_ptr<noding::Noder> spareInternalNoder;
     // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
     std::deque<EdgeSourceInfo> edgeSourceInfoQue;
     std::deque<Edge> edgeQue;
@@ -99,9 +97,9 @@ class GEOS_DLL EdgeNodingBuilder {
     * - Floating precision: a conventional model (which may be non-robust).
     *   In this case, a validation step is applied to the output from the noder.
     */
-    Noder* getNoder();
-    static std::unique_ptr<Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
-    std::unique_ptr<Noder> createFloatingPrecisionNoder(bool doValidation);
+    noding::Noder* getNoder();
+    static std::unique_ptr<noding::Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
+    std::unique_ptr<noding::Noder> createFloatingPrecisionNoder(bool doValidation);
 
 
     void addCollection(const GeometryCollection* gc, uint8_t geomIndex);
@@ -171,8 +169,8 @@ class GEOS_DLL EdgeNodingBuilder {
     * which is used to provide source topology info to the constructed Edges
     * (and is then discarded).
     */
-    std::vector<Edge*> node(std::vector<SegmentString*>* segStrings);
-    std::vector<Edge*> createEdges(std::vector<SegmentString*>* segStrings);
+    std::vector<Edge*> node(std::vector<noding::SegmentString*>* segStrings);
+    std::vector<Edge*> createEdges(std::vector<noding::SegmentString*>* segStrings);
 
 
 public:
@@ -182,9 +180,9 @@ class GEOS_DLL EdgeNodingBuilder {
     * If the noder is not provided, a suitable one will
     * be used based on the supplied precision model.
     */
-    EdgeNodingBuilder(const PrecisionModel* p_pm, Noder* p_customNoder)
+    EdgeNodingBuilder(const PrecisionModel* p_pm, noding::Noder* p_customNoder)
         : pm(p_pm)
-        , inputEdges(new std::vector<SegmentString*>)
+        , inputEdges(new std::vector<noding::SegmentString*>)
         , customNoder(p_customNoder)
         , hasEdges{{false,false}}
         , clipEnv(nullptr)
@@ -195,15 +193,15 @@ class GEOS_DLL EdgeNodingBuilder {
 
     ~EdgeNodingBuilder()
     {
-        for (SegmentString* ss: *inputEdges) {
+        for (noding::SegmentString* ss: *inputEdges) {
             delete ss;
         }
     }
 
     void setClipEnvelope(const Envelope* clipEnv);
 
     // returns newly allocated vector and segmentstrings
-    // std::vector<SegmentString*>* node();
+    // std::vector<noding::SegmentString*>* node();
 
     /**
     * Reports whether there are noded edges

src/operation/overlayng/EdgeMerger.cpp

@@ -17,7 +17,9 @@
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/util/Assert.h>
-
+#include <geos/operation/overlayng/EdgeKey.h>
+#include <geos/operation/overlayng/Edge.h>
+#include <geos/operation/overlayng/OverlayLabel.h>
 
 namespace geos {      // geos
 namespace operation { // geos.operation

src/operation/overlayng/EdgeNodingBuilder.cpp

@@ -19,7 +19,6 @@
 #include <geos/noding/ValidatingNoder.h>
 #include <geos/noding/NodedSegmentString.h>
 #include <geos/noding/MCIndexNoder.h>
-#include <geos/geom/Coordinate.h>
 #include <geos/algorithm/Orientation.h>
 #include <geos/noding/snapround/SnapRoundingNoder.h>
 #include <geos/operation/overlayng/EdgeNodingBuilder.h>
@@ -28,13 +27,20 @@
 #include <geos/operation/overlayng/OverlayUtil.h>
 #include <geos/util.h>
 
-using geos::operation::valid::RepeatedPointRemover;
-using geos::noding::snapround::SnapRoundingNoder;
 
 namespace geos {      // geos
 namespace operation { // geos.operation
 namespace overlayng { // geos.operation.overlayng
 
+using geos::operation::valid::RepeatedPointRemover;
+using geos::noding::snapround::SnapRoundingNoder;
+using geos::noding::Noder;
+using geos::noding::MCIndexNoder;
+using geos::noding::ValidatingNoder;
+using geos::noding::SegmentString;
+using geos::noding::NodedSegmentString;
+
+
 /*private*/
 Noder*
 EdgeNodingBuilder::getNoder()