Update to GEOS 3.9.1

Author: macdrevx

Sources/geos/capi/geos_ts_c.cpp

@@ -2408,22 +2408,31 @@ extern "C" {
         //assert(0 != holes);
 
         return execute(extHandle, [&]() {
-            auto vholes = geos::detail::make_unique<std::vector<LinearRing*>>(nholes);
 
+            std::vector<LinearRing*> tmpholes(nholes);
             for (size_t i = 0; i < nholes; i++) {
-                (*vholes)[i] = dynamic_cast<LinearRing*>(holes[i]);
-                if ((*vholes)[i] == nullptr) {
+                LinearRing* lr = dynamic_cast<LinearRing*>(holes[i]);
+                if (! lr) {
                     throw IllegalArgumentException("Hole is not a LinearRing");
                 }
+                tmpholes[i] = lr;
             }
-
             LinearRing* nshell = dynamic_cast<LinearRing*>(shell);
             if(! nshell) {
                 throw IllegalArgumentException("Shell is not a LinearRing");
             }
-            const GeometryFactory* gf = shell->getFactory();
+            GEOSContextHandleInternal_t* handle = reinterpret_cast<GEOSContextHandleInternal_t*>(extHandle);
+            const GeometryFactory* gf = handle->geomFactory;
+
+            /* Create unique_ptr version for constructor */
+            std::vector<std::unique_ptr<LinearRing>> vholes;
+            vholes.reserve(nholes);
+            for (LinearRing* lr: tmpholes) {
+                vholes.emplace_back(lr);
+            }
+            std::unique_ptr<LinearRing> shell(nshell);
 
-            return gf->createPolygon(nshell, vholes.release());
+            return gf->createPolygon(std::move(shell), std::move(vholes)).release();
         });
     }
 

Sources/geos/include/acconfig.h

@@ -89,6 +89,32 @@ class GEOS_DLL Orientation {
     */
     static bool isCCW(const geom::CoordinateSequence* ring);
 
+    /**
+    * Tests if a ring defined by a CoordinateSequence is
+    * oriented counter-clockwise, using the signed area of the ring.
+    *
+    *  * The list of points is assumed to have the first and last points equal.
+    *  * This handles coordinate lists which contain repeated points.
+    *  * This handles rings which contain collapsed segments
+    *    (in particular, along the top of the ring).
+    *  * This handles rings which are invalid due to self-intersection
+    *
+    * This algorithm is guaranteed to work with valid rings.
+    * For invalid rings (containing self-intersections),
+    * the algorithm determines the orientation of
+    * the largest enclosed area (including overlaps).
+    * This provides a more useful result in some situations, such as buffering.
+    *
+    * However, this approach may be less accurate in the case of
+    * rings with almost zero area.
+    * (Note that the orientation of rings with zero area is essentially
+    * undefined, and hence non-deterministic.)
+    *
+    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
+    * @return true if the ring is oriented counter-clockwise.
+    */
+    static bool isCCWArea(const geom::CoordinateSequence* ring);
+
 };
 
 

Sources/geos/include/geos/algorithm/Orientation.h

@@ -59,32 +59,23 @@ namespace overlayng { // geos.operation.overlayng
  * This ensures that the overlay output line direction will be as consistent
  * as possible with input lines.
  *
+ * The merger also preserves the order of the edges in the input.
+ * This means that for polygon-line overlay
+ * the result lines will be in the same order as in the input
+ * (possibly with multiple result lines for a single input line).
+ *
  * @author mdavis
  *
  */
 class GEOS_DLL EdgeMerger {
 
-private:
-
-
-    // Members
-    std::vector<Edge*>& edges;
-    std::map<EdgeKey, Edge*> edgeMap;
-
 public:
 
-    // Methods
-    EdgeMerger(std::vector<Edge*>& p_edges);
-
     static std::vector<Edge*> merge(std::vector<Edge*>& edges);
 
-    std::vector<Edge*> merge();
-
-
 };
 
 
 } // namespace geos.operation.overlayng
 } // namespace geos.operation
 } // namespace geos
-

Sources/geos/include/geos/algorithm/PointInRing.h

@@ -23,11 +23,11 @@
 #endif
 
 #ifndef GEOS_VERSION_PATCH
-#define GEOS_VERSION_PATCH 0
+#define GEOS_VERSION_PATCH 1
 #endif
 
 #ifndef GEOS_VERSION
-#define GEOS_VERSION "3.9.0"
+#define GEOS_VERSION "3.9.1"
 #endif
 
 #ifndef GEOS_JTS_PORT

Sources/geos/include/geos/algorithm/SimplePointInRing.h

@@ -60,19 +60,19 @@ extern "C" {
 #define GEOS_VERSION_MINOR 9
 #endif
 #ifndef GEOS_VERSION_PATCH
-#define GEOS_VERSION_PATCH 0
+#define GEOS_VERSION_PATCH 1
 #endif
 #ifndef GEOS_VERSION
-#define GEOS_VERSION "3.9.0"
+#define GEOS_VERSION "3.9.1"
 #endif
 #ifndef GEOS_JTS_PORT
 #define GEOS_JTS_PORT "1.17.0"
 #endif
 
 #define GEOS_CAPI_VERSION_MAJOR 1
 #define GEOS_CAPI_VERSION_MINOR 14
-#define GEOS_CAPI_VERSION_PATCH 1
-#define GEOS_CAPI_VERSION "3.9.0-CAPI-1.14.1"
+#define GEOS_CAPI_VERSION_PATCH 2
+#define GEOS_CAPI_VERSION "3.9.1-CAPI-1.14.2"
 
 #define GEOS_CAPI_FIRST_INTERFACE GEOS_CAPI_VERSION_MAJOR
 #define GEOS_CAPI_LAST_INTERFACE (GEOS_CAPI_VERSION_MAJOR+GEOS_CAPI_VERSION_MINOR)

Sources/geos/include/geos/operation/overlayng/EdgeMerger.h

@@ -20,6 +20,7 @@
 #include <cmath>
 #include <vector>
 
+#include <geos/algorithm/Area.h>
 #include <geos/algorithm/Orientation.h>
 #include <geos/algorithm/CGAlgorithmsDD.h>
 #include <geos/geom/CoordinateSequence.h>
@@ -134,92 +135,12 @@ Orientation::isCCW(const geom::CoordinateSequence* ring)
     }
 }
 
-#if 0
 /* public static */
 bool
-Orientation::isCCW(const geom::CoordinateSequence* ring)
+Orientation::isCCWArea(const geom::CoordinateSequence* ring)
 {
-    // sanity check
-    if(ring->getSize() < 4) {
-        throw util::IllegalArgumentException("Ring has fewer than 4 points, so orientation cannot be determined");
-    }
-
-    // # of points without closing endpoint
-    const std::size_t nPts = ring->getSize() - 1;
-    assert(nPts >= 3); // This is here for scan-build
-
-    // find highest point
-    const geom::Coordinate* hiPt = &ring->getAt(0);
-    size_t hiIndex = 0;
-    for(std::size_t i = 1; i <= nPts; ++i) {
-        const geom::Coordinate* p = &ring->getAt(i);
-        if(p->y > hiPt->y) {
-            hiPt = p;
-            hiIndex = i;
-        }
-    }
-
-    // find distinct point before highest point
-    auto iPrev = hiIndex;
-    do {
-        if(iPrev == 0) {
-            iPrev = nPts;
-        }
-        iPrev = iPrev - 1;
-    }
-    while(ring->getAt(iPrev) == *hiPt && iPrev != hiIndex);
-
-    // find distinct point after highest point
-    auto iNext = hiIndex;
-    do {
-        iNext = (iNext + 1) % nPts;
-    }
-    while(ring->getAt(iNext) == *hiPt && iNext != hiIndex);
-
-    const geom::Coordinate* prev = &ring->getAt(iPrev);
-    const geom::Coordinate* next = &ring->getAt(iNext);
-
-    /*
-     * This check catches cases where the ring contains an A-B-A
-     * configuration of points.
-     * This can happen if the ring does not contain 3 distinct points
-     * (including the case where the input array has fewer than 4 elements),
-     * or it contains coincident line segments.
-     */
-    if(prev->equals2D(*hiPt) || next->equals2D(*hiPt) ||
-            prev->equals2D(*next)) {
-        return false;
-        // MD - don't bother throwing exception,
-        // since this isn't a complete check for ring validity
-        //throw  IllegalArgumentException("degenerate ring (does not contain 3 distinct points)");
-    }
-
-    int disc = Orientation::index(*prev, *hiPt, *next);
-
-    /*
-     *  If disc is exactly 0, lines are collinear.
-     * There are two possible cases:
-     *  (1) the lines lie along the x axis in opposite directions
-     *  (2) the lines lie on top of one another
-     *
-     *  (1) is handled by checking if next is left of prev ==> CCW
-     *  (2) should never happen, so we're going to ignore it!
-     *  (Might want to assert this)
-     */
-    bool isCCW = false;
-
-    if(disc == 0) {
-        // poly is CCW if prev x is right of next x
-        isCCW = (prev->x > next->x);
-    }
-    else {
-        // if area is positive, points are ordered CCW
-        isCCW = (disc > 0);
-    }
-
-    return isCCW;
+    return algorithm::Area::ofRingSigned(ring) < 0;
 }
-#endif
 
 
 } // namespace geos.algorithm