@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/io/WKTReader.h

@@ -0,0 +1,165 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: io/WKTReader.java rev. 1.1 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/Geometry.h>
+#include <geos/io/ParseException.h>
+#include <geos/io/OrdinateSet.h>
+
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace io {
+class StringTokenizer;
+}
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class GeometryCollection;
+class Point;
+class LineString;
+class LinearRing;
+class CircularString;
+class CompoundCurve;
+class Polygon;
+class CurvePolygon;
+class MultiPoint;
+class MultiLineString;
+class MultiCurve;
+class MultiPolygon;
+class MultiSurface;
+class PrecisionModel;
+}
+}
+
+
+namespace geos {
+namespace io {
+
+/**
+ * \class WKTReader
+ * \brief WKT parser class; see also WKTWriter.
+ */
+class GEOS_DLL WKTReader {
+public:
+
+    /**
+     * \brief Initialize parser with given GeometryFactory.
+     *
+     * Note that all Geometry objects created by the
+     * parser will contain a pointer to the given factory
+     * so be sure you'll keep the factory alive for the
+     * whole WKTReader and created Geometry life.
+     */
+    explicit WKTReader(const geom::GeometryFactory& gf)
+        : geometryFactory(&gf)
+        , precisionModel(gf.getPrecisionModel())
+        , fixStructure(false)
+        {};
+
+        /** @deprecated in 3.4.0 */
+    explicit WKTReader(const geom::GeometryFactory* gf)
+        : geometryFactory(gf)
+        , precisionModel(gf->getPrecisionModel())
+        , fixStructure(false)
+        {};
+
+    /**
+     * \brief Initialize parser with default GeometryFactory.
+     *
+     */
+    WKTReader()
+        : geometryFactory(geom::GeometryFactory::getDefaultInstance())
+        , precisionModel(geometryFactory->getPrecisionModel())
+        , fixStructure(false)
+        {};
+
+    ~WKTReader() {};
+
+    void
+    setFixStructure(bool doFixStructure) {
+        fixStructure = doFixStructure;
+    }
+
+    /// Parse a WKT string returning a Geometry
+    template<typename T>
+    std::unique_ptr<T> read(const std::string& wkt) const {
+        auto g = read(wkt);
+        auto gt = dynamic_cast<const T*>(g.get());
+        if (!gt) {
+            // Can improve this message once there's a good way to get a string repr of T
+            throw io::ParseException("Unexpected WKT type");
+        }
+        return std::unique_ptr<T>(static_cast<T*>(g.release()));
+    }
+
+    std::unique_ptr<geom::Geometry> read(const std::string& wellKnownText) const;
+
+protected:
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates(io::StringTokenizer* tokenizer, OrdinateSet& ordinates) const;
+    static double getNextNumber(io::StringTokenizer* tokenizer);
+    static std::string getNextEmptyOrOpener(io::StringTokenizer* tokenizer, OrdinateSet& dim);
+    static std::string getNextCloserOrComma(io::StringTokenizer* tokenizer);
+    static std::string getNextCloser(io::StringTokenizer* tokenizer);
+    static std::string getNextWord(io::StringTokenizer* tokenizer);
+    std::unique_ptr<geom::Geometry> readGeometryTaggedText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags, const geom::GeometryTypeId* emptyType = nullptr) const;
+
+    std::unique_ptr<geom::Point> readPointText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::LineString> readLineStringText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::LinearRing> readLinearRingText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::MultiPoint> readMultiPointText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::Polygon> readPolygonText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::MultiLineString> readMultiLineStringText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::MultiPolygon> readMultiPolygonText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::GeometryCollection> readGeometryCollectionText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::CircularString> readCircularStringText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::CompoundCurve> readCompoundCurveText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::CurvePolygon> readCurvePolygonText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::MultiCurve> readMultiCurveText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+    std::unique_ptr<geom::MultiSurface> readMultiSurfaceText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+
+    /// Read the contents of a LINEARRING, LINESTRING, CIRCULARSTRING, or COMPOUNDCURVE
+    std::unique_ptr<geom::Curve> readCurveText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+
+    /// Read the contents of a POLYGON or a CURVEPOLYGON
+    std::unique_ptr<geom::Geometry> readSurfaceText(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags) const;
+private:
+    const geom::GeometryFactory* geometryFactory;
+    const geom::PrecisionModel* precisionModel;
+    bool fixStructure;
+
+    void getPreciseCoordinate(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags, geom::CoordinateXYZM&) const;
+
+    static bool isNumberNext(io::StringTokenizer* tokenizer);
+    static bool isOpenerNext(io::StringTokenizer* tokenizer);
+
+    static void readOrdinateFlags(const std::string & s, OrdinateSet& ordinateFlags);
+    static bool isTypeName(const std::string & type, const std::string & typeName);
+};
+
+} // namespace io
+} // namespace geos
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/io/WKTStreamReader.h

@@ -0,0 +1,48 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Martin Davis
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/GeometryFactory.h>
+#include <geos/io/WKTReader.h>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+
+class Geometry;
+class PrecisionModel;
+}
+}
+
+namespace geos {
+namespace io {
+
+class GEOS_DLL WKTStreamReader {
+
+public:
+    WKTStreamReader(std::istream& instr);
+    ~WKTStreamReader();
+
+    std::unique_ptr<geos::geom::Geometry> next();
+
+private:
+
+    std::istream& instr;
+    WKTReader rdr;
+};
+
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/io/WKTWriter.h

@@ -0,0 +1,342 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: io/WKTWriter.java rev. 1.34 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/io/OrdinateSet.h>
+
+#include <string>
+#include <cctype>
+#include <cstdint>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateXY;
+class CoordinateXYZM;
+class CoordinateSequence;
+class Curve;
+class CompoundCurve;
+class Geometry;
+class GeometryCollection;
+class Point;
+class LineString;
+class LinearRing;
+class Polygon;
+class MultiPoint;
+class MultiLineString;
+class MultiPolygon;
+class PrecisionModel;
+class SimpleCurve;
+class Surface;
+}
+namespace io {
+class Writer;
+}
+}
+
+
+namespace geos {
+namespace io {
+
+/**
+ * \class WKTWriter
+ *
+ * \brief Outputs the textual representation of a Geometry.
+ * See also WKTReader.
+ *
+ * The WKTWriter outputs coordinates rounded to the precision
+ * model. No more than the maximum number of necessary decimal places will be
+ * output.
+ *
+ * The Well-known Text format is defined in the <A
+ * HREF="http://www.opengis.org/techno/specs.htm">OpenGIS Simple Features
+ * Specification for SQL</A>.
+ *
+ * A non-standard "LINEARRING" tag is used for LinearRings. The WKT spec does
+ * not define a special tag for LinearRings. The standard tag to use is
+ * "LINESTRING".
+ *
+ * See WKTReader for parsing.
+ *
+ */
+class GEOS_DLL WKTWriter {
+public:
+    WKTWriter();
+    ~WKTWriter() = default;
+
+    //string(count, ch) can be used for this
+    //static string stringOfChar(char ch, int count);
+
+    /// Returns WKT string for the given Geometry
+    std::string write(const geom::Geometry* geometry);
+
+    std::string write(const geom::Geometry& geometry);
+
+    // Send Geometry's WKT to the given Writer
+    void write(const geom::Geometry* geometry, Writer* writer);
+
+    std::string writeFormatted(const geom::Geometry* geometry);
+
+    void writeFormatted(const geom::Geometry* geometry, Writer* writer);
+
+    /**
+     * Generates the WKT for a N-point <code>LineString</code>.
+     *
+     * @param seq the sequence to outpout
+     *
+     * @return the WKT
+     */
+    static std::string toLineString(const geom::CoordinateSequence& seq);
+
+    /**
+     * Generates the WKT for a 2-point <code>LineString</code>.
+     *
+     * @param p0 the first coordinate
+     * @param p1 the second coordinate
+     *
+     * @return the WKT
+     */
+    static std::string toLineString(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
+
+    /**
+     * Generates the WKT for a <code>Point</code>.
+     *
+     * @param p0 the point coordinate
+     *
+     * @return the WKT
+     */
+    static std::string toPoint(const geom::Coordinate& p0);
+    static std::string toPoint(const geom::CoordinateXY& p0);
+
+    /**
+     * Sets the rounding precision when writing the WKT
+     * a precision of -1 disables it
+     *
+     * @param p0 the new precision to use
+     *
+     */
+    void setRoundingPrecision(int p0);
+
+    /**
+     * Enables/disables trimming of unnecessary decimals
+     *
+     * @param p0 the trim boolean
+     *
+     */
+    void setTrim(bool p0);
+
+    /**
+     * Enables/disables removal of Z/M dimensions that have
+     * no non-NaN values in a geometry.
+     *
+     * @brief setRemoveEmptyDimensions
+     * @param remove
+     */
+    void setRemoveEmptyDimensions(bool remove)
+    {
+        removeEmptyDimensions = remove;
+    }
+
+    /**
+     * Enable old style 3D/4D WKT generation.
+     *
+     * By default the WKTWriter produces new style 3D/4D WKT
+     * (ie. "POINT Z (10 20 30)") but if this method is used
+     * to turn on old style WKT production then the WKT will
+     * be formatted in the style "POINT (10 20 30)".
+     *
+     * @param useOld3D true or false
+     */
+    void
+    setOld3D(bool useOld3D)
+    {
+        old3D = useOld3D;
+    }
+
+    /*
+     * \brief
+     * Returns the output dimension used by the
+     * <code>WKTWriter</code>.
+     */
+    int
+    getOutputDimension() const
+    {
+        return defaultOutputDimension;
+    }
+
+    /*
+     * Sets the output dimension used by the <code>WKTWriter</code>.
+     *
+     * @param newOutputDimension Supported values are 2, 3 or 4.
+     *        Default since GEOS 3.12 is 4.
+     *        Note that 3 indicates up to 3 dimensions will be
+     *        written but 2D WKT is still produced for 2D geometries.
+     */
+    void setOutputDimension(uint8_t newOutputDimension);
+
+    static std::string writeNumber(double d, bool trim, uint32_t precision);
+    static int writeTrimmedNumber(double d, uint32_t precision, char* buf);
+
+protected:
+
+    int decimalPlaces;
+
+    void appendGeometryTaggedText(
+            const geom::Geometry& geometry,
+            OrdinateSet outputOrdinates,
+            int level,
+            Writer& writer) const;
+
+    void appendTag(
+            const geom::Geometry& geometry,
+            OrdinateSet outputOrdinates,
+            Writer& writer) const;
+
+    void appendPointTaggedText(
+        const geom::Point& point,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendSimpleCurveTaggedText(
+        const geom::SimpleCurve& lineString,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendCompoundCurveTaggedText(
+        const geom::CompoundCurve& lineString,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendSurfaceTaggedText(
+        const geom::Surface& polygon,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendMultiPointTaggedText(
+        const geom::MultiPoint& multipoint,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendMultiCurveTaggedText(
+        const geom::GeometryCollection& multiCurve,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendMultiSurfaceTaggedText(
+        const geom::GeometryCollection& multiSurface,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendGeometryCollectionTaggedText(
+        const geom::GeometryCollection& geometryCollection,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendOrdinateText(OrdinateSet outputOrdinates,
+                            Writer& writer) const;
+
+    void appendSequenceText(const geom::CoordinateSequence& seq,
+                            OrdinateSet outputOrdinates,
+                            int level,
+                            bool doIntent,
+                            Writer& writer) const;
+
+    void appendCoordinate(const geom::CoordinateXYZM& coordinate,
+                          OrdinateSet outputOrdinates,
+                          Writer& writer) const;
+
+    std::string writeNumber(double d) const;
+
+    void appendCurveText(
+        const geom::Curve& lineString,
+        OrdinateSet outputOrdinates,
+        int level, bool doIndent, Writer& writer) const;
+
+    void appendSimpleCurveText(
+        const geom::SimpleCurve& lineString,
+        OrdinateSet outputOrdinates,
+        int level, bool doIndent, Writer& writer) const;
+
+    void appendSurfaceText(
+        const geom::Surface& polygon,
+        OrdinateSet outputOrdinates,
+        int level, bool indentFirst, Writer& writer) const;
+
+    void appendMultiPointText(
+        const geom::MultiPoint& multiPoint,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendMultiCurveText(
+        const geom::GeometryCollection& multiCurve,
+        OrdinateSet outputOrdinates,
+        int level, bool indentFirst, Writer& writer) const;
+
+    void appendMultiSurfaceText(
+        const geom::GeometryCollection& multiSurface,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+    void appendGeometryCollectionText(
+        const geom::GeometryCollection& geometryCollection,
+        OrdinateSet outputOrdinates,
+        int level, Writer& writer) const;
+
+private:
+
+    enum {
+        INDENT = 2
+    };
+
+    bool isFormatted;
+
+    int roundingPrecision;
+
+    bool trim;
+
+    bool removeEmptyDimensions = false;
+
+    static constexpr int coordsPerLine = 10;
+
+    uint8_t defaultOutputDimension;
+    bool old3D;
+
+    void writeFormatted(
+        const geom::Geometry* geometry,
+        bool isFormatted, Writer* writer);
+
+    void indent(int level, Writer* writer) const;
+};
+
+} // namespace geos::io
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/io/Writer.h

@@ -0,0 +1,51 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: ORIGINAL WORK to be used like java.io.Writer
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <string>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+namespace geos {
+namespace io {
+
+class GEOS_DLL Writer {
+public:
+    Writer();
+    void reserve(std::size_t capacity);
+    ~Writer() = default;
+    void write(const std::string& txt);
+    const std::string& toString();
+private:
+    std::string str;
+};
+
+} // namespace geos::io
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/linearref/ExtractLineByLocation.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: linearref/ExtractLineByLocation.java rev. 1.10
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/LinearLocation.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/** \brief
+ * Extracts the subline of a linear [Geometry](@ref geom::Geometry) between
+ * two {@link LinearLocation}s on the line.
+ */
+class ExtractLineByLocation {
+
+private:
+    const geom::Geometry* line;
+    std::unique_ptr<geom::Geometry> reverse(const geom::Geometry* linear);
+
+    /**
+     * Assumes input is valid (e.g. start <= end)
+     *
+     * @param start
+     * @param end
+     * @return a linear geometry
+     */
+    std::unique_ptr<geom::LineString> computeLine(const LinearLocation& start, const LinearLocation& end);
+
+    /**
+     * Assumes input is valid (e.g. start <= end)
+     *
+     * @param start
+     * @param end
+     * @return a linear geometry
+     */
+    std::unique_ptr<geom::Geometry> computeLinear(const LinearLocation& start, const LinearLocation& end);
+
+public:
+    /** \brief
+     * Computes the subline of a [LineString](@ref geom::LineString) between
+     * two {@link LinearLocation}s on the line.
+     *
+     * If the start location is after the end location,
+     * the computed geometry is reversed.
+     *
+     * @param line the line to use as the baseline
+     * @param start the start location
+     * @param end the end location
+     * @return the extracted subline
+     */
+    static std::unique_ptr<geom::Geometry> extract(const geom::Geometry* line, const LinearLocation& start, const LinearLocation& end);
+
+    ExtractLineByLocation(const geom::Geometry* line);
+
+    /** \brief
+     * Extracts a subline of the input.
+     *
+     * If `end < start` the linear geometry computed will be reversed.
+     *
+     * @param start the start location
+     * @param end the end location
+     * @return a linear geometry
+     */
+    std::unique_ptr<geom::Geometry> extract(const LinearLocation& start, const LinearLocation& end);
+
+};
+
+}
+}