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

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/CoordinateSequence.h

@@ -50,7 +50,7 @@ namespace geom { // geos::geom
  * stores 2D Coordinates and accesses using the Coordinate type. Sequences used by these parts
  * of the code must be created with constructors without `hasz` and `hasm` arguments.
  *
- * If a high-dimension Coordinate coordinate is read from a low-dimension CoordinateSequence,
+ * If a high-dimension coordinate is read from a low-dimension CoordinateSequence,
  * the higher dimensions will be populated with incorrect values or a segfault may occur.
  *
  */
@@ -222,6 +222,13 @@ public:
         return m_hasm;
     }
 
+    /**
+     * Set the dimensions of the CoordinateSequence.
+     * May cause a reallocation, invalidating any references to coordinates
+     * within this sequence.
+     */
+    void setZM(bool hasZ, bool hasM);
+
     /// Returns true if contains any two consecutive points
     bool hasRepeatedPoints() const;
 
@@ -338,6 +345,80 @@ public:
         return m_vect[index * stride() + 1];
     }
 
+    /**
+     * Returns ordinate Z of the specified coordinate.
+     *
+     * @param index
+     * @return the value of the Z ordinate in the index'th coordinate, or NaN if the
+     *         CoordinateSequence does not store Z values
+     */
+    double getZ(std::size_t index) const
+    {
+        return getOrdinate(index, Z);
+    }
+
+    /**
+     * Returns ordinate M of the specified coordinate.
+     *
+     * @param index
+     * @return the value of the M ordinate in the index'th coordinate, or NaN if the
+     *         CoordinateSequence does not store M values
+     */
+    double getM(std::size_t index) const
+    {
+        return getOrdinate(index, M);
+    }
+
+    /**
+     * Set the X value of the specified coordinate.
+     *
+     * @param index
+     * @param x the new X value
+     */
+    void setX(std::size_t index, double x)
+    {
+        m_vect[index * stride()] = x;
+    }
+
+    /**
+     * Set the Y value of the specified coordinate.
+     *
+     * @param index
+     * @param y the new Y value
+     */
+    void setY(std::size_t index, double y)
+    {
+        m_vect[index * stride() + 1] = y;
+    }
+
+    /**
+     * Set the Z value of the specified coordinate.
+     *
+     * Has no effect if the CoordinateSequence does not store Z values.
+     *
+     * @param index
+     * @param z the new Z value
+     */
+    void setZ(std::size_t index, double z)
+    {
+        if (hasZ())
+            setOrdinate(index, Z, z);
+    }
+
+    /**
+     * Set the M value of the specified coordinate.
+     *
+     * Has no effect if the CoordinateSequence does not store M values.
+     *
+     * @param index
+     * @param m the new M value
+     */
+    void setM(std::size_t index, double m)
+    {
+        if (hasM())
+            setOrdinate(index, M, m);
+    }
+
     /// Return last Coordinate in the sequence
     template<typename T=Coordinate>
     const T& back() const
@@ -506,8 +587,10 @@ public:
 
     void add(const CoordinateSequence& cl, bool allowRepeated, bool forwardDirection);
 
+    /// Add the portion of a CoordinateSequence between the specified indices (inclusive)
     void add(const CoordinateSequence& cs, std::size_t from, std::size_t to);
 
+    /// Add the portion of a CoordinateSequence between the specified indices (inclusive)
     void add(const CoordinateSequence& cs, std::size_t from, std::size_t to, bool allowRepeated);
 
     template<typename T, typename... Args>
@@ -549,9 +632,14 @@ public:
     /// Get a string representation of CoordinateSequence
     std::string toString() const;
 
-    /// Returns lower-left Coordinate in list
+    /// Returns lower-left Coordinate in list, or nullptr if the
+    /// sequence is empty
     const CoordinateXY* minCoordinate() const;
 
+    /// Returns the index of the minCoordinate, or the maximum value of
+    /// size_t if the sequence is empty
+    std::size_t minCoordinateIndex() const;
+
     /** \brief
      *  Returns either the given CoordinateSequence if its length
      *  is greater than the given amount, or an empty CoordinateSequence.
@@ -583,6 +671,8 @@ public:
 
     /// Scroll given CoordinateSequence so to start with given Coordinate.
     static void scroll(CoordinateSequence* cl, const CoordinateXY* firstCoordinate);
+    void scroll(const CoordinateXY* firstCoordinate);
+    void scroll(std::size_t firstCoordinateIndex);
 
     /** \brief
      * Determines which orientation of the {@link Coordinate} array
@@ -608,6 +698,8 @@ public:
 
     void sort();
 
+    /// Swap the coordinates at two indices.
+    void swap(std::size_t i, std::size_t j);
 
     /**
      * Expands the given Envelope to include the coordinates in the
@@ -711,6 +803,16 @@ public:
         }
     }
 
+    template<typename F>
+    void forEachSegment(F&& fun) const {
+        switch(getCoordinateType()) {
+            case CoordinateType::XY:    forEachSegmentImpl<CoordinateXY, F>(std::move(fun)); break;
+            case CoordinateType::XYZ:   forEachSegmentImpl<Coordinate, F>(std::move(fun)); break;
+            case CoordinateType::XYM:   forEachSegmentImpl<CoordinateXYM, F>(std::move(fun)); break;
+            case CoordinateType::XYZM:  forEachSegmentImpl<CoordinateXYZM, F>(std::move(fun)); break;
+        }
+    }
+
     template<typename T, typename F>
     void forEach(std::size_t from, std::size_t to, F&& fun) const
     {
@@ -798,6 +900,24 @@ private:
         orig = c;
     }
 
+    template<typename CoordType, typename F>
+    void forEachSegmentImpl(F&& fun) const {
+        auto p0it = items<CoordType>().cbegin();
+        const auto end = items<CoordType>().end();
+
+        if (p0it == end) {
+            return;
+        }
+
+        auto p1it = std::next(p0it);
+
+        while (p1it != end) {
+            fun(*p0it, *p1it);
+            ++p0it;
+            ++p1it;
+        }
+    }
+
     void make_space(std::size_t pos, std::size_t n) {
         m_vect.insert(std::next(m_vect.begin(), static_cast<std::ptrdiff_t>(pos * stride())),
                       m_stride * n,

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/Curve.h

@@ -16,6 +16,10 @@
 
 #include <geos/geom/Geometry.h>
 
+namespace geos::geom {
+    class LineString;
+}
+
 namespace geos {
 namespace geom {
 
@@ -52,6 +56,29 @@ public:
         return Dimension::L; // line
     }
 
+    virtual const CoordinateXY& getEndCoordinate() const = 0;
+
+    /// \brief
+    /// Return the end point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getEndPoint() const = 0;
+
+    /// \brief
+    /// Return the n'th point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getPointN(std::size_t n) const = 0;
+
+    virtual const CoordinateXY& getStartCoordinate() const = 0;
+
+    /// \brief
+    /// Return the start point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getStartPoint() const = 0;
+
+    std::unique_ptr<LineString> getLinearized(const algorithm::CurveToLineParams&) const;
+
+    std::unique_ptr<Curve> getCurved(const algorithm::LineToCurveParams&) const;
+
     /// Returns true if the first and last coordinate in the Curve are the same
     virtual bool isClosed() const = 0;
 
@@ -62,9 +89,14 @@ public:
 
     virtual const SimpleCurve* getCurveN(std::size_t) const = 0;
 
+    std::unique_ptr<Curve> clone() const;
+
+    std::unique_ptr<Curve> reverse() const;
+
 protected:
     Curve(const GeometryFactory& factory) : Geometry(&factory) {}
 
+    Curve* getCurvedImpl(const algorithm::LineToCurveParams&) const override = 0;
 };
 
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/CurvePolygon.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <geos/geom/SurfaceImpl.h>
+#include <geos/geom/Polygon.h>
 
 namespace geos {
 namespace geom {
@@ -35,14 +36,28 @@ public:
 
     GeometryTypeId getGeometryTypeId() const override;
 
+    std::unique_ptr<CurvePolygon> getCurved(const algorithm::LineToCurveParams&) {
+        return std::unique_ptr<CurvePolygon>(cloneImpl());
+    }
+
+    std::unique_ptr<Polygon> getLinearized(const algorithm::CurveToLineParams&) const;
+
     bool hasCurvedComponents() const override;
 
+    bool hasCurvedTypes() const override {
+        return true;
+    }
+
     void normalize() override;
 
 protected:
     using SurfaceImpl::SurfaceImpl;
 
-    Geometry* cloneImpl() const override;
+    CurvePolygon* cloneImpl() const override;
+
+    Polygon* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
+    CurvePolygon* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); }
 
     int
     getSortIndex() const override

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/Envelope.h

@@ -562,6 +562,32 @@ public:
         return covers(x, y);
     }
 
+    /** \brief
+     * Check if the point p lies in the interior of this Envelope.
+     *
+     * @param p the Coordinate to be tested
+     * @return true if the point lies in the interior
+     */
+    bool
+    containsProperly(const CoordinateXY& p) const
+    {
+        return std::isless(p.x, maxx) && std::isgreater(p.x, minx) &&
+                std::isless(p.y, maxy) && std::isgreater(p.y,  miny);
+    }
+
+    /** \brief
+     * Tests if an envelope is properly contained in this one.
+     * The envelope is properly contained if it is contained 
+     * by this one but not equal to it.
+     * 
+     * @param other the envelope to test
+     * @return true if the envelope is properly contained
+     */
+    bool containsProperly(const Envelope& other) const {
+        if (equals(&other)) return false;
+        return covers(other);
+    }
+
     /** \brief
      * Check if the point p intersects (lies inside) the region of this Envelope.
      *

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/Geometry.h

@@ -35,6 +35,7 @@
 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
 #include <geos/geom/GeometryComponentFilter.h> // for inheritance
 #include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
+#include <geos/util/Progress.h>
 
 #include <algorithm>
 #include <string>
@@ -50,6 +51,10 @@
 
 // Forward declarations
 namespace geos {
+namespace algorithm {
+class CurveToLineParams;
+class LineToCurveParams;
+}
 namespace geom {
 class Coordinate;
 class CoordinateFilter;
@@ -308,9 +313,13 @@ public:
     /// Return a string representation of this Geometry type
     virtual std::string getGeometryType() const = 0; //Abstract
 
-    /// Returns whether the Geometry contains curved components
+    /// Returns whether the Geometry contains arcs
     virtual bool hasCurvedComponents() const;
 
+    /// Returns whether the Geometry contains curved geometry types,
+    /// regardless of whether they actually contain any arcs.
+    virtual bool hasCurvedTypes() const;
+
     /// Return an integer representation of this Geometry type
     virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
 
@@ -335,6 +344,20 @@ public:
         return this;
     }
 
+    /// Compute an approximation of the Geometry that contains no arcs.
+    /// If the Geometry already contains no arcs, a copy will be returned.
+    std::unique_ptr<Geometry> getLinearized(const algorithm::CurveToLineParams& params) const
+    {
+        return std::unique_ptr<Geometry>(getLinearizedImpl(params));
+    }
+
+    /// Attempt to replace linear sections of a geometry with arcs, where possible.
+    /// Any arcs that already exist in the Geometry will be retained unmodified.
+    std::unique_ptr<Geometry> getCurved(const algorithm::LineToCurveParams& params) const
+    {
+        return std::unique_ptr<Geometry>(getCurvedImpl(params));
+    }
+
     /**
      * \brief Tests the validity of this <code>Geometry</code>.
      *
@@ -389,7 +412,9 @@ public:
         return t == GEOS_GEOMETRYCOLLECTION ||
                t == GEOS_MULTIPOINT ||
                t == GEOS_MULTILINESTRING ||
-               t == GEOS_MULTIPOLYGON;
+               t == GEOS_MULTIPOLYGON ||
+               t == GEOS_MULTICURVE ||
+               t == GEOS_MULTISURFACE;
     }
 
     static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
@@ -397,6 +422,9 @@ public:
             case GEOS_POINT: return GEOS_MULTIPOINT;
             case GEOS_LINESTRING: return GEOS_MULTILINESTRING;
             case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
+            case GEOS_CIRCULARSTRING:
+            case GEOS_COMPOUNDCURVE: return GEOS_MULTICURVE;
+            case GEOS_CURVEPOLYGON: return GEOS_MULTISURFACE;
             default: return typeId;
         }
     }
@@ -725,9 +753,15 @@ public:
      *
      * @see UnaryUnionOp
      */
-    Ptr Union() const;
+    Ptr Union(geos::util::ProgressFunction* progressFunction) const;
     // throw(IllegalArgumentException *, TopologyException *);
 
+    Ptr Union() const
+    {
+        geos::util::ProgressFunction* progressFunction = nullptr;
+        return Union(progressFunction);
+    }
+
     /**
      * \brief
      * Returns a Geometry representing the points making up this
@@ -897,6 +931,10 @@ protected:
     /// Make a geometry with coordinates in reverse order
     virtual Geometry* reverseImpl() const = 0;
 
+    virtual Geometry* getLinearizedImpl(const algorithm::CurveToLineParams&) const = 0;
+
+    virtual Geometry* getCurvedImpl(const algorithm::LineToCurveParams&) const = 0;
+
     /// Returns true if the array contains any non-empty Geometrys.
     template<typename T>
     static bool hasNonEmptyElements(const std::vector<T>* geometries) {

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/GeometryCollection.h

@@ -168,6 +168,14 @@ public:
     /// Returns the number of geometries in this collection
     std::size_t getNumGeometries() const override;
 
+    std::unique_ptr<GeometryCollection> getCurved(const algorithm::LineToCurveParams& params) {
+        return std::unique_ptr<GeometryCollection>(getCurvedImpl(params));
+    }
+
+    std::unique_ptr<GeometryCollection> getLinearized(const algorithm::CurveToLineParams& params) {
+        return std::unique_ptr<GeometryCollection>(getLinearizedImpl(params));
+    }
+
     /// Returns a pointer to the nth Geometry in this collection
     const Geometry* getGeometryN(std::size_t n) const override;
 
@@ -239,6 +247,10 @@ protected:
 
     GeometryCollection* reverseImpl() const override;
 
+    GeometryCollection* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
+    GeometryCollection* getCurvedImpl(const algorithm::LineToCurveParams&) const override;
+
     int
     getSortIndex() const override
     {
@@ -253,6 +265,7 @@ protected:
 
     void geometryChangedAction() override {
         envelope.setToNull();
+        flags.flagsCalculated = false;
     }
 
     int compareToSameClass(const Geometry* gc) const override;

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/GeometryFactory.h

@@ -33,6 +33,7 @@
 #include <vector>
 #include <memory>
 #include <cassert>
+#include <atomic>
 
 namespace geos {
 namespace geom {
@@ -40,6 +41,7 @@ class Coordinate;
 class CircularString;
 class CompoundCurve;
 class CoordinateSequence;
+class Curve;
 class Envelope;
 class Geometry;
 class GeometryCollection;
@@ -190,12 +192,19 @@ public:
     std::unique_ptr<MultiLineString> createMultiLineString(
             std::vector<std::unique_ptr<LineString>> && fromLines) const;
 
+    std::unique_ptr<MultiLineString> createMultiLineString(
+            std::vector<std::unique_ptr<Curve>> && fromLines) const;
+
     std::unique_ptr<MultiLineString> createMultiLineString(
             std::vector<std::unique_ptr<Geometry>> && fromLines) const;
 
     /// Construct an EMPTY MultiCurve
     std::unique_ptr<MultiCurve> createMultiCurve() const;
 
+    /// Construct a MultiCurve with a deep-copy of given arguments
+    std::unique_ptr<MultiCurve> createMultiCurve(
+        const std::vector<const Geometry*>& from) const;
+
     /// Construct a MultiCurve taking ownership of given arguments
     std::unique_ptr<MultiCurve> createMultiCurve(
             std::vector<std::unique_ptr<Geometry>> && fromCurves) const;
@@ -220,6 +229,10 @@ public:
     /// Construct an EMPTY MultiSurface
     std::unique_ptr<MultiSurface> createMultiSurface() const;
 
+    /// Construct a MultiSurface with a deep-copy of given arguments
+    std::unique_ptr<MultiSurface> createMultiSurface(
+        const std::vector<const Geometry*>& from) const;
+
     /// Construct a MultiSurface taking ownership of given arguments
     std::unique_ptr<MultiSurface> createMultiSurface(
             std::vector<std::unique_ptr<Geometry>> && from) const;
@@ -235,6 +248,9 @@ public:
     std::unique_ptr<LinearRing> createLinearRing(
         std::unique_ptr<CoordinateSequence> && newCoords) const;
 
+    std::unique_ptr<LinearRing> createLinearRing(
+        const std::shared_ptr<const CoordinateSequence>& newCoords) const;
+
     /// Construct a LinearRing with a deep-copy of given arguments
     std::unique_ptr<LinearRing> createLinearRing(
         const CoordinateSequence& coordinates) const;
@@ -296,6 +312,15 @@ public:
     std::unique_ptr<CurvePolygon> createCurvePolygon(std::unique_ptr<Curve>&& shell,
                                                      std::vector<std::unique_ptr<Curve>> && holes) const;
 
+
+    /// Construct a Surface, taking ownership of given arguments
+    /// If arguments are LinearRings, a Polygon will be returned.
+    /// Otherwise, a CurvePolygon will be returned.
+    std::unique_ptr<Surface> createSurface(std::unique_ptr<Curve>&& shell) const;
+
+    std::unique_ptr<Surface> createSurface(std::unique_ptr<Curve>&& shell,
+                                           std::vector<std::unique_ptr<Curve>> && holes) const;
+
     /// Construct an EMPTY LineString
     std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;
     std::unique_ptr<LineString> createLineString(bool hasZ, bool hasM) const;
@@ -311,6 +336,10 @@ public:
     std::unique_ptr<LineString> createLineString(
         const CoordinateSequence& coordinates) const;
 
+    /// Construct a LineString with a reference to shared coordinates
+    std::unique_ptr<LineString> createLineString(
+        const std::shared_ptr<const CoordinateSequence>&) const;
+
     /// Construct an EMPTY CircularString
     std::unique_ptr<CircularString> createCircularString(bool hasZ, bool hasM) const;
 
@@ -321,6 +350,10 @@ public:
     std::unique_ptr<CircularString> createCircularString(
         std::unique_ptr<CoordinateSequence> && coordinates) const;
 
+    /// Construct a CircularStrign with a reference to shared coordinates
+    std::unique_ptr<CircularString> createCircularString(
+        const std::shared_ptr<const CoordinateSequence>& coordinates) const;
+
     /// Construct a CircularString with a deep-copy of given argument
     std::unique_ptr<CircularString> createCircularString(
         const CoordinateSequence& coordinates) const;
@@ -387,6 +420,8 @@ public:
 
     std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Polygon>> && geoms) const;
 
+    std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Curve>> && geoms) const;
+
     /// See buildGeometry(std::vector<Geometry *>&) for semantics
     //
     /// Will clone the geometries accessible through the iterator.
@@ -522,7 +557,7 @@ private:
     PrecisionModel precisionModel;
     int SRID;
 
-    mutable int _refCount;
+    mutable std::atomic<int> _refCount;
     bool _autoDestroy;
 
     friend class Geometry;

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/LineSegment.h

@@ -326,6 +326,34 @@ public:
             p0.z + segmentLengthFraction * (p1.z - p0.z));
     };
 
+    static CoordinateXY pointAlong(double segmentLengthFraction, const CoordinateXY& p0, const CoordinateXY& p1)
+    {
+        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
+                 p0.y + segmentLengthFraction * (p1.y - p0.y) };
+    }
+
+    static Coordinate pointAlong(double segmentLengthFraction, const Coordinate& p0, const Coordinate& p1)
+    {
+        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
+                 p0.y + segmentLengthFraction * (p1.y - p0.y),
+                 p0.z + segmentLengthFraction * (p1.z - p0.z) };
+    }
+
+    static CoordinateXYM pointAlong(double segmentLengthFraction, const CoordinateXYM& p0, const CoordinateXYM& p1)
+    {
+        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
+                 p0.y + segmentLengthFraction * (p1.y - p0.y),
+                 p0.m + segmentLengthFraction * (p1.m - p0.m) };
+    }
+
+    static CoordinateXYZM pointAlong(double segmentLengthFraction, const CoordinateXYZM& p0, const CoordinateXYZM& p1)
+    {
+        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
+                 p0.y + segmentLengthFraction * (p1.y - p0.y),
+                 p0.z + segmentLengthFraction * (p1.z - p0.z),
+                 p0.m + segmentLengthFraction * (p1.m - p0.m) };
+    }
+
     /** \brief
      * Computes the {@link Coordinate} that lies a given
      * fraction along the line defined by this segment and offset from
@@ -389,6 +417,8 @@ public:
      */
     double projectionFactor(const CoordinateXY& p) const;
 
+    static double projectionFactor(const CoordinateXY& p0, const CoordinateXY& p1, const CoordinateXY& q);
+
     /** \brief
      * Computes the fraction of distance (in <tt>[0.0, 1.0]</tt>)
      * that the projection of a point occurs along this line segment.
@@ -418,6 +448,8 @@ public:
 
     CoordinateXY project(const CoordinateXY& p) const;
 
+    static CoordinateXY project(const CoordinateXY& p0, const CoordinateXY& p1, const CoordinateXY& q);
+
     /** \brief
      * Project a line segment onto this line segment and return the resulting
      * line segment.
@@ -443,6 +475,9 @@ public:
     ///
     void closestPoint(const CoordinateXY& p, CoordinateXY& ret) const;
 
+    static CoordinateXY closestPoint(const CoordinateXY& p0, const CoordinateXY& p1,
+                                     const CoordinateXY& q);
+
     /** \brief
      *  Returns <code>true</code> if <code>other</code> is
      *  topologically equal to this LineSegment (e.g. irrespective
@@ -468,6 +503,11 @@ public:
         return closestPoints(*line);
     }
 
+    static std::array<CoordinateXY, 2> closestPoints(const CoordinateXY& p0,
+                                                     const CoordinateXY& p1,
+                                                     const CoordinateXY& q0,
+                                                     const CoordinateXY& q1);
+
     /**
      * Computes an intersection point between two segments,
      * if there is one.
@@ -564,6 +604,8 @@ public:
 
 
 private:
+    static CoordinateXY project(const CoordinateXY& p0, const CoordinateXY& p1, double factor);
+
     void project(double factor, CoordinateXY& ret) const;
 
 };

package/geos_c.xcframework/ios-arm64/Headers/geos/geom/LineString.h

@@ -92,10 +92,20 @@ public:
 
     double getLength() const override;
 
+    std::unique_ptr<Curve> getCurved(const algorithm::LineToCurveParams&) const;
+
     bool isCurved() const override {
         return false;
     }
 
+    /** \brief
+     * Normalizes a LineString.
+     *
+     * A normalized LineString has the first point which is not equal to
+     * its reflected point less than the reflected point.
+     */
+    void normalize() override;
+
     /**
      * Creates a LineString whose coordinates are in the reverse
      * order of this object's
@@ -114,6 +124,13 @@ protected:
     LineString(CoordinateSequence::Ptr && pts,
                const GeometryFactory& newFactory);
 
+    LineString(const std::shared_ptr<const CoordinateSequence> & pts,
+               const GeometryFactory& newFactory);
+
+    LineString* getLinearizedImpl(const algorithm::CurveToLineParams&) const override { return cloneImpl(); }
+
+    Curve* getCurvedImpl(const algorithm::LineToCurveParams&) const override;
+
     LineString* cloneImpl() const override { return new LineString(*this); }
 
     LineString* reverseImpl() const override;
@@ -131,6 +148,8 @@ protected:
 
 private:
 
+    void normalizeClosed();
+
     void validateConstruction();
 };