@crossbind/port-geos-ios 2.0.0-beta.56 → 2.0.0-beta.58

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/linemerge/LineMergeDirectedEdge.h

@@ -59,7 +59,7 @@ public:
      */
     LineMergeDirectedEdge(planargraph::Node* from,
                           planargraph::Node* to,
-                          const geom::Coordinate& directionPt,
+                          const geom::CoordinateXY& directionPt,
                           bool edgeDirection);
 
     /**  \brief

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/linemerge/LineMergeEdge.h

@@ -26,7 +26,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
-class LineString;
+class Curve;
 }
 }
 
@@ -41,18 +41,18 @@ namespace linemerge { // geos::operation::linemerge
  */
 class GEOS_DLL LineMergeEdge: public planargraph::Edge {
 private:
-    const geom::LineString* line;
+    const geom::Curve* line;
 public:
     /**
      * Constructs a LineMergeEdge with vertices given by the specified
-     * LineString.
+     * Curve.
      */
-    LineMergeEdge(const geom::LineString* newLine);
+    LineMergeEdge(const geom::Curve* newCurve);
 
     /**
-     * Returns the LineString specifying the vertices of this edge.
+     * Returns the Curve specifying the vertices of this edge.
      */
-    const geom::LineString* getLine() const;
+    const geom::Curve* getCurve() const;
 };
 
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/linemerge/LineMergeGraph.h

@@ -23,6 +23,7 @@
 #include <geos/export.h>
 #include <geos/planargraph/PlanarGraph.h> // for inheritance
 
+#include <memory>
 #include <vector>
 
 #ifdef _MSC_VER
@@ -33,7 +34,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
-class LineString;
+class Curve;
 class Coordinate;
 }
 namespace planargraph {
@@ -59,27 +60,35 @@ class GEOS_DLL LineMergeGraph: public planargraph::PlanarGraph {
 
 private:
 
-    planargraph::Node* getNode(const geom::Coordinate& coordinate);
+    planargraph::Node* getNode(const geom::CoordinateXY& coordinate);
 
-    std::vector<planargraph::Node*> newNodes;
+    std::vector<std::unique_ptr<planargraph::Node>> newNodes;
 
-    std::vector<planargraph::Edge*> newEdges;
+    std::vector<std::unique_ptr<planargraph::Edge>> newEdges;
 
-    std::vector<planargraph::DirectedEdge*> newDirEdges;
+    std::vector<std::unique_ptr<planargraph::DirectedEdge>> newDirEdges;
 
 public:
 
+    LineMergeGraph();
+
     /** \brief
      * Adds an Edge, DirectedEdges, and Nodes for the given
-     * LineString representation of an edge.
+     * LineString/CircularString/CompoundCurve representation of an edge.
      *
      * Empty lines or lines with all coordinates equal are not added.
      *
-     * @param lineString the linestring to add to the graph
+     * @param curve the curve to add to the graph
      */
-    void addEdge(const geom::LineString* lineString);
+    void addEdge(const geom::Curve* curve);
 
     ~LineMergeGraph() override;
+
+private:
+    // Declared as non-copyable
+    LineMergeGraph(const LineMergeGraph& other) = delete;
+    LineMergeGraph& operator=(const LineMergeGraph& rhs) = delete;
+
 };
 } // namespace geos::operation::linemerge
 } // namespace geos::operation

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/linemerge/LineMerger.h

@@ -80,9 +80,9 @@ private:
 
     bool isDirected;
 
-    std::vector<std::unique_ptr<geom::LineString>> mergedLineStrings;
+    std::vector<std::unique_ptr<geom::Curve>> mergedGeometries;
 
-    std::vector<EdgeString*> edgeStrings;
+    std::vector<std::unique_ptr<EdgeString>> edgeStrings;
 
     const geom::GeometryFactory* factory;
 
@@ -98,7 +98,7 @@ private:
 
     void buildEdgeStringsStartingAt(planargraph::Node* node);
 
-    EdgeString* buildEdgeStringStartingWith(LineMergeDirectedEdge* start);
+    std::unique_ptr<EdgeString> buildEdgeStringStartingWith(LineMergeDirectedEdge* start) const;
 
 public:
     LineMerger(bool directed = false);
@@ -132,7 +132,9 @@ public:
      */
     std::vector<std::unique_ptr<geom::LineString>> getMergedLineStrings();
 
-    void add(const geom::LineString* lineString);
+    std::vector<std::unique_ptr<geom::Curve>> getMergedCurves();
+
+    void add(const geom::Curve* curve);
 
     // Declare type as noncopyable
     LineMerger(const LineMerger& other) = delete;

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlay/snap/GeometrySnapper.h

@@ -24,6 +24,8 @@
 #include <memory>
 #include <vector>
 
+#include "geos/util.h"
+
 // Forward declarations
 namespace geos {
 namespace geom {
@@ -80,11 +82,7 @@ public:
      *
      * @param g the geometry to snap
      */
-    GeometrySnapper(const geom::Geometry& g)
-        :
-        srcGeom(g)
-    {
-    }
+    GeometrySnapper(const geom::Geometry& g);
 
     /** \brief
      * Snaps the vertices in the component {@link geom::LineString}s
@@ -138,7 +136,7 @@ private:
     const geom::Geometry& srcGeom;
 
     /// Extract target (unique) coordinates
-    std::unique_ptr<geom::Coordinate::ConstVect> extractTargetCoordinates(
+    static std::unique_ptr<geom::Coordinate::ConstVect> extractTargetCoordinates(
         const geom::Geometry& g);
 
     // Declare type as noncopyable

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/Edge.h

@@ -17,7 +17,6 @@
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/geom/Dimension.h>
-#include <geos/operation/overlayng/OverlayEdge.h>
 #include <geos/operation/overlayng/OverlayLabel.h>
 #include <geos/operation/overlayng/EdgeSourceInfo.h>
 #include <geos/util/GEOSException.h>
@@ -64,7 +63,8 @@ private:
     int bDim = OverlayLabel::DIM_UNKNOWN;
     int bDepthDelta = 0;
     bool bIsHole = false;
-    std::unique_ptr<geom::CoordinateSequence> pts;
+    std::shared_ptr<const geom::CoordinateSequence> pts;
+    const bool ptsCurved;
 
     // Methods
 
@@ -184,25 +184,18 @@ private:
 
 public:
 
-    Edge()
-        : aDim(OverlayLabel::DIM_UNKNOWN)
-        , aDepthDelta(0)
-        , aIsHole(false)
-        , bDim(OverlayLabel::DIM_UNKNOWN)
-        , bDepthDelta(0)
-        , bIsHole(false)
-        , pts(nullptr)
-        {};
+    Edge(const std::shared_ptr<const geom::CoordinateSequence>& p_pts, const EdgeSourceInfo* info, bool isCurved);
 
     friend std::ostream& operator<<(std::ostream& os, const Edge& e);
 
     static bool isCollapsed(const geom::CoordinateSequence* pts);
 
-    // takes ownership of pts from caller
-    Edge(std::unique_ptr<geom::CoordinateSequence>&& p_pts, const EdgeSourceInfo* info);
+    bool isCurved() const {
+        return ptsCurved;
+    }
 
     // return a clone of the underlying points
-    std::unique_ptr<geom::CoordinateSequence> getCoordinates()
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const
     {
         return pts->clone();
     };
@@ -214,14 +207,14 @@ public:
     };
 
     // release the underlying points to the caller
-    geom::CoordinateSequence* releaseCoordinates()
+    std::shared_ptr<const geom::CoordinateSequence> releaseCoordinates()
     {
-        geom::CoordinateSequence* cs = pts.release();
-        pts.reset(nullptr);
+        auto cs = pts;
+        pts.reset();
         return cs;
     };
 
-    const geom::Coordinate& getCoordinate(std::size_t index)  const
+    const geom::CoordinateXY& getCoordinate(std::size_t index)  const
     {
         return pts->getAt(index);
     };
@@ -237,25 +230,22 @@ public:
             throw util::GEOSException("Edge must have >= 2 points");
         }
 
-        const geom::Coordinate& p0 = pts->getAt(0);
-        const geom::Coordinate& p1 = pts->getAt(1);
-        const geom::Coordinate& pn0 = pts->getAt(pts->size() - 1);
-        const geom::Coordinate& pn1 = pts->getAt(pts->size() - 2);
-
-        int cmp = 0;
-        int cmp0 = p0.compareTo(pn0);
-        if (cmp0 != 0) cmp = cmp0;
+        const geom::CoordinateXY& p0 = getCoordinate(0);
+        const geom::CoordinateXY& pn0 = getCoordinate(pts->size() - 1);
 
-        if (cmp == 0) {
-            int cmp1 = p1.compareTo(pn1);
-            if (cmp1 != 0) cmp = cmp1;
+        const int cmp0 = p0.compareTo(pn0);
+        if (cmp0 != 0) {
+            return cmp0 == -1;
         }
 
-        if (cmp == 0) {
-            throw util::GEOSException("Edge direction cannot be determined because endpoints are equal");
+        const geom::CoordinateXY& p1 = getCoordinate(1);
+        const geom::CoordinateXY& pn1 = getCoordinate(pts->size() - 2);
+        const int cmp1 = p1.compareTo(pn1);
+        if (cmp1 != 0) {
+            return cmp1 == -1;
         }
 
-        return cmp == -1;
+        throw util::GEOSException("Edge direction cannot be determined because endpoints are equal");
     };
 
     /**
@@ -311,8 +301,8 @@ public:
 
     bool compareTo(const Edge& e) const
     {
-        const geom::Coordinate& ca = getCoordinate(0);
-        const geom::Coordinate& cb = e.getCoordinate(0);
+        const geom::CoordinateXY& ca = getCoordinate(0);
+        const geom::CoordinateXY& cb = e.getCoordinate(0);
         if(ca.compareTo(cb) < 0) {
             return true;
         }
@@ -320,8 +310,8 @@ public:
             return false;
         }
         else {
-            const geom::Coordinate& cca = getCoordinate(1);
-            const geom::Coordinate& ccb = e.getCoordinate(1);
+            const geom::CoordinateXY& cca = getCoordinate(1);
+            const geom::CoordinateXY& ccb = e.getCoordinate(1);
             if(cca.compareTo(ccb) < 0) {
                 return true;
             }

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/EdgeKey.h

@@ -61,7 +61,7 @@ private:
         }
     }
 
-    void init(const geom::Coordinate& p0, const geom::Coordinate& p1)
+    void init(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
     {
         p0x = p0.x;
         p0y = p0.y;

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/EdgeNodingBuilder.h

@@ -18,14 +18,18 @@
 
 #pragma once
 
+#include <geos/algorithm/CircularArcIntersector.h>
 #include <geos/algorithm/LineIntersector.h>
 #include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/CircularArc.h>
 #include <geos/geom/Envelope.h>
 #include <geos/geom/Geometry.h>
 #include <geos/geom/GeometryCollection.h>
 #include <geos/geom/LinearRing.h>
 #include <geos/geom/LineString.h>
 #include <geos/geom/Polygon.h>
+#include <geos/geom/SimpleCurve.h>
+#include <geos/noding/ArcIntersectionAdder.h>
 #include <geos/noding/IntersectionAdder.h>
 #include <geos/noding/Noder.h>
 #include <geos/noding/SegmentString.h>
@@ -65,11 +69,16 @@ class GEOS_DLL EdgeNodingBuilder {
     using PrecisionModel = geos::geom::PrecisionModel;
     using Envelope = geos::geom::Envelope;
     using GeometryCollection = geos::geom::GeometryCollection;
+    using Surface = geos::geom::Surface;
     using Polygon = geos::geom::Polygon;
     using CoordinateSequence = geos::geom::CoordinateSequence;
+    using CompoundCurve = geos::geom::CompoundCurve;
+    using CircularString = geos::geom::CircularString;
     using LinearRing = geos::geom::LinearRing;
     using LineString = geos::geom::LineString;
     using Geometry = geos::geom::Geometry;
+    using SimpleCurve = geos::geom::SimpleCurve;
+    using Curve = geos::geom::Curve;
 
 private:
 
@@ -79,7 +88,7 @@ private:
 
     // Members
     const PrecisionModel* pm;
-    std::unique_ptr<std::vector<noding::SegmentString*>> inputEdges;
+    std::vector<noding::PathString*> inputEdges;
     noding::Noder* customNoder;
     std::array<bool, 2> hasEdges;
     const Envelope* clipEnv;
@@ -88,7 +97,9 @@ private:
 
     // For use in createFloatingPrecisionNoder()
     algorithm::LineIntersector lineInt;
+    algorithm::CircularArcIntersector arcInt;
     noding::IntersectionAdder intAdder;
+    noding::ArcIntersectionAdder arcIntAdder;
     std::unique_ptr<noding::Noder> internalNoder;
     std::unique_ptr<noding::Noder> spareInternalNoder;
     // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
@@ -96,6 +107,7 @@ private:
     std::deque<Edge> edgeQue;
     bool inputHasZ;
     bool inputHasM;
+    bool inputHasCurves;
 
     /**
     * Gets a noder appropriate for the precision model supplied.
@@ -112,11 +124,17 @@ private:
 
     void addCollection(const GeometryCollection* gc, uint8_t geomIndex);
     void addGeometryCollection(const GeometryCollection* gc, uint8_t geomIndex, int expectedDim);
-    void addPolygon(const Polygon* poly, uint8_t geomIndex);
-    void addPolygonRing(const LinearRing* ring, bool isHole, uint8_t geomIndex);
-    void addLine(const LineString* line, uint8_t geomIndex);
-    void addLine(std::unique_ptr<CoordinateSequence>& pts, uint8_t geomIndex);
-    void addEdge(std::unique_ptr<CoordinateSequence>& cas, const EdgeSourceInfo* info);
+    void addPolygon(const Surface* poly, uint8_t geomIndex);
+    void addPolygonRing(const Curve* ring, bool isHole, uint8_t geomIndex);
+    void addSimpleCurve(const SimpleCurve* line, uint8_t geomIndex);
+    void addCompoundCurve(const CompoundCurve* line, uint8_t geomIndex);
+
+    void addCurve(const std::shared_ptr<const CoordinateSequence>& pts, const std::vector<geom::CircularArc>& arcs, uint8_t geomIndex);
+    void addLine(const std::shared_ptr<const CoordinateSequence>& pts, uint8_t geomIndex);
+
+    void addEdge(const std::shared_ptr<const CoordinateSequence>& cas, const EdgeSourceInfo* info);
+    void addCurvedEdge(const std::shared_ptr<const CoordinateSequence>& cas, const std::vector<geom::CircularArc>& arcs, const EdgeSourceInfo* info);
+
 
     // Create a EdgeSourceInfo* owned by EdgeNodingBuilder
     const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index, int depthDelta, bool isHole);
@@ -140,7 +158,7 @@ private:
     * limit the line to the clip envelope.
     *
     */
-    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const LineString* line);
+    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const LineString* line) const;
 
     /**
     * If a clipper is present,
@@ -156,7 +174,7 @@ private:
     * @param ring the line to clip
     * @return the points in the clipped line
     */
-    std::unique_ptr<CoordinateSequence> clip(const LinearRing* line);
+    std::shared_ptr<const CoordinateSequence> clip(const LineString* ring) const;
 
     /**
     * Removes any repeated points from a linear component.
@@ -165,9 +183,9 @@ private:
     * @param line the line to process
     * @return the points of the line with repeated points removed
     */
-    static std::unique_ptr<CoordinateSequence> removeRepeatedPoints(const LineString* line);
+    static std::shared_ptr<const CoordinateSequence> removeRepeatedPoints(const LineString* line);
 
-    static int computeDepthDelta(const LinearRing* ring, bool isHole);
+    static int computeDepthDelta(const CoordinateSequence* ringCoords, bool isHole);
 
     void add(const Geometry* g, uint8_t geomIndex);
 
@@ -177,8 +195,8 @@ private:
     * which is used to provide source topology info to the constructed Edges
     * (and is then discarded).
     */
-    std::vector<Edge*> node(std::vector<noding::SegmentString*>* segStrings);
-    std::vector<Edge*> createEdges(std::vector<noding::SegmentString*>* segStrings);
+    std::vector<Edge*> node(const std::vector<noding::PathString*>& segStrings);
+    std::vector<Edge*> createEdges(std::vector<std::unique_ptr<noding::PathString>> &segStrings);
 
 
 public:
@@ -190,27 +208,20 @@ public:
     */
     EdgeNodingBuilder(const PrecisionModel* p_pm, noding::Noder* p_customNoder)
         : pm(p_pm)
-        , inputEdges(new std::vector<noding::SegmentString*>)
         , customNoder(p_customNoder)
         , hasEdges{{false,false}}
         , clipEnv(nullptr)
         , intAdder(lineInt)
+        , arcIntAdder(arcInt)
         , inputHasZ(false)
         , inputHasM(false)
+        , inputHasCurves(false)
         {};
 
-    ~EdgeNodingBuilder()
-    {
-        for (noding::SegmentString* ss: *inputEdges) {
-            delete ss;
-        }
-    }
+    ~EdgeNodingBuilder();
 
     void setClipEnvelope(const Envelope* clipEnv);
 
-    // returns newly allocated vector and segmentstrings
-    // std::vector<noding::SegmentString*>* node();
-
     /**
     * Reports whether there are noded edges
     * for the given input geometry.
@@ -236,8 +247,9 @@ public:
     */
     std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
 
-
-
+    // Declare type as noncopyable
+    EdgeNodingBuilder(const EdgeNodingBuilder& other) = delete;
+    EdgeNodingBuilder& operator=(const EdgeNodingBuilder& rhs) = delete;
 };
 
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/InputGeometry.h

@@ -42,6 +42,7 @@ class GEOS_DLL InputGeometry {
     using Geometry = geos::geom::Geometry;
     using Envelope = geos::geom::Envelope;
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using Location = geos::geom::Location;
     using PointOnGeometryLocator = geos::algorithm::locate::PointOnGeometryLocator;
 
@@ -91,7 +92,7 @@ public:
     *
     * @see Location
     */
-    Location locatePointInArea(uint8_t geomIndex, const Coordinate& pt);
+    Location locatePointInArea(uint8_t geomIndex, const CoordinateXY& pt);
 
     PointOnGeometryLocator* getLocator(uint8_t geomIndex);
     void setCollapsed(uint8_t geomIndex, bool isGeomCollapsed);

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/LineBuilder.h

@@ -77,7 +77,7 @@ private:
     const geom::GeometryFactory* geometryFactory;
     bool hasResultArea;
     int8_t inputAreaIndex;
-    std::vector<std::unique_ptr<geom::LineString>> lines;
+    std::vector<std::unique_ptr<geom::Curve>> lines;
 
     /**
     * Indicates whether intersections are allowed to produce
@@ -121,7 +121,7 @@ private:
     void addResultLines();
     void addResultLinesMerged();
 
-    std::unique_ptr<geom::LineString> toLine(OverlayEdge* edge) const;
+    std::unique_ptr<geom::Curve> toLine(OverlayEdge* edge) const;
 
     void addResultLinesForNodes();
 
@@ -143,7 +143,7 @@ private:
     * E.g. using the direction of the majority of segments,
     * or preferring the direction of the A edges.)
     */
-    std::unique_ptr<geom::LineString> buildLine(OverlayEdge* node);
+    std::unique_ptr<geom::Curve> buildLine(OverlayEdge* node) const;
 
     /*
     * Finds the next edge around a node which forms
@@ -173,7 +173,7 @@ public:
     LineBuilder(const LineBuilder&) = delete;
     LineBuilder& operator=(const LineBuilder&) = delete;
 
-    std::vector<std::unique_ptr<geom::LineString>> getLines();
+    std::vector<std::unique_ptr<geom::Curve>> getLines();
 
     void setStrictMode(bool p_isStrictResultMode)
     {

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/LineLimiter.h

@@ -54,6 +54,7 @@ namespace overlayng { // geos.operation.overlayng
 class GEOS_DLL LineLimiter {
     using Envelope = geos::geom::Envelope;
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using CoordinateSequence = geos::geom::CoordinateSequence;
 
 private:
@@ -61,14 +62,21 @@ private:
     // Members
     const Envelope* limitEnv;
     std::unique_ptr<geom::CoordinateSequence> ptList;
-    const Coordinate* lastOutside;
+    const CoordinateXY* lastOutside;
     std::vector<std::unique_ptr<CoordinateSequence>> sections;
+    bool hasZ{false};
+    bool hasM{false};
 
     // Methods
-    void addPoint(const Coordinate* p);
-    void addOutside(const Coordinate* p);
-    bool isLastSegmentIntersecting(const Coordinate* p);
-    bool isSectionOpen();
+    template<typename CoordType>
+    void addPoint(const CoordType& p);
+
+    template<typename CoordType>
+    void addOutside(const CoordType& p);
+    bool isLastSegmentIntersecting(const CoordinateXY& p) const;
+    bool isSectionOpen() const;
+
+    template<typename CoordType>
     void startSection();
     void finishSection();
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/overlayng/OverlayEdge.h

@@ -46,6 +46,7 @@ namespace overlayng { // geos.operation.overlayng
 */
 class GEOS_DLL OverlayEdge : public edgegraph::HalfEdge {
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using CoordinateXYZM = geos::geom::CoordinateXYZM;
     using CoordinateSequence = geos::geom::CoordinateSequence;
     using Location = geos::geom::Location;
@@ -53,14 +54,15 @@ class GEOS_DLL OverlayEdge : public edgegraph::HalfEdge {
 private:
 
     // Members
-    const CoordinateSequence* pts;
+    std::shared_ptr<const CoordinateSequence> pts;
     /**
     * 'true' indicates direction is forward along segString
     * 'false' is reverse direction
     * The label must be interpreted accordingly.
     */
     bool direction;
-    CoordinateXYZM dirPt;
+    bool m_isCurved;
+    CoordinateXY dirPt;
     OverlayLabel* label;
     bool m_isInResultArea;
     bool m_isInResultLine;
@@ -78,12 +80,14 @@ private:
 
 public:
 
-    OverlayEdge(const CoordinateXYZM& p_orig, const CoordinateXYZM& p_dirPt,
+    OverlayEdge(const CoordinateXYZM& p_orig, const CoordinateXY& p_dirPt,
                 bool p_direction, OverlayLabel* p_label,
-                const CoordinateSequence* p_pts)
+                const std::shared_ptr<const CoordinateSequence>& p_pts,
+                bool isCurved)
         : HalfEdge(p_orig)
         , pts(p_pts)
         , direction(p_direction)
+        , m_isCurved(isCurved)
         , dirPt(p_dirPt)
         , label(p_label)
         , m_isInResultArea(false)
@@ -102,7 +106,12 @@ public:
         return direction;
     };
 
-    const CoordinateXYZM& directionPt() const override
+    bool isCurved() const
+    {
+        return m_isCurved;
+    }
+
+    const CoordinateXY& directionPt() const override
     {
         return dirPt;
     };
@@ -124,16 +133,10 @@ public:
 
     const CoordinateSequence* getCoordinatesRO() const
     {
-        return pts;
-    };
-
-    std::unique_ptr<CoordinateSequence> getCoordinates()
-    {
-        // return a copy of pts
-        return pts->clone();
+        return pts.get();
     };
 
-    std::unique_ptr<CoordinateSequence> getCoordinatesOriented();
+    std::shared_ptr<const CoordinateSequence> getCoordinatesOriented() const;
 
     /**
     * Adds the coordinates of this edge to the given list,