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

package/dist/prebuilt/Android-x86_64/include/geos/noding/Octant.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/util.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Methods for computing and working with octants of the Cartesian plane.
+ *
+ * Octants are numbered as follows:
+ *
+ *   2|1
+ * 3  |  0
+ * ---+--
+ * 4  |  7
+ *   5|6
+ *
+ * If line segments lie along a coordinate axis, the octant is the lower of the two
+ * possible values.
+ *
+ * Last port: noding/Octant.java rev. 1.2 (JTS-1.7)
+ */
+class GEOS_DLL Octant {
+private:
+    Octant() {} // Can't instantiate it
+public:
+
+    /**
+     * Returns the octant of a directed line segment (specified
+     * as x and y displacements, which cannot both be 0).
+     */
+    static int octant(double dx, double dy);
+
+    /**
+     * Returns the octant of a directed line segment from p0 to p1.
+     */
+    static int octant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
+
+    static int
+    octant(const geom::CoordinateXY* p0, const geom::CoordinateXY* p1)
+    {
+        ::geos::ignore_unused_variable_warning(p0);
+        return octant(*p0, *p1);
+    }
+};
+
+
+} // namespace geos.noding
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/noding/OrientedCoordinateArray.h

@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009    Sandro Santilli <strk@kbt.io>
+ *
+ * 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: noding/OrientedCoordinateArray.java rev. 1.1 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <cstddef>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+namespace noding {
+//class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Allows comparing {@link geom::CoordinateSequence}s
+ * in an orientation-independent way.
+ */
+class GEOS_DLL OrientedCoordinateArray {
+public:
+
+    /**
+     * Creates a new {@link OrientedCoordinateArray}
+     * for the given {@link geom::CoordinateSequence}.
+     *
+     * @param p_pts the coordinates to orient
+     */
+    OrientedCoordinateArray(const geom::CoordinateSequence& p_pts)
+        :
+        pts(&p_pts),
+        orientationVar(orientation(p_pts))
+    {
+    }
+
+    /** \brief
+     * Compares two {@link OrientedCoordinateArray}s for their
+     * relative order
+     *
+     * @return -1 this one is smaller
+     * @return 0 the two objects are equal
+     * @return 1 this one is greater
+     *
+     * In JTS, this is used automatically by ordered lists.
+     * In C++, operator< would be used instead....
+     */
+    int compareTo(const OrientedCoordinateArray& o1) const;
+
+    bool operator==(const OrientedCoordinateArray& other) const;
+
+    struct GEOS_DLL HashCode {
+        std::size_t operator()(const OrientedCoordinateArray & oca) const;
+    };
+
+private:
+
+    static int compareOriented(const geom::CoordinateSequence& pts1,
+                               bool orientation1,
+                               const geom::CoordinateSequence& pts2,
+                               bool orientation2);
+
+
+    /**
+     * Computes the canonical orientation for a coordinate array.
+     *
+     * @param pts the array to test
+     * @return <code>true</code> if the points are oriented forwards
+     * @return <code>false</code> if the points are oriented in reverse
+     */
+    static bool orientation(const geom::CoordinateSequence& pts);
+
+    /// Externally owned
+    const geom::CoordinateSequence* pts;
+
+    bool orientationVar;
+
+};
+
+/// Strict weak ordering operator for OrientedCoordinateArray
+///
+/// This is the C++ equivalent of JTS's compareTo
+inline bool
+operator< (const OrientedCoordinateArray& oca1,
+           const OrientedCoordinateArray& oca2)
+{
+    return oca1.compareTo(oca2) < 0;
+}
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/ScaledNoder.h

@@ -0,0 +1,132 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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: noding/ScaledNoder.java rev. 1.3 (JTS-1.7.1)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <cassert>
+#include <vector>
+
+#include <geos/noding/Noder.h> // for inheritance
+#include <geos/util.h>
+
+#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 CoordinateSequence;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Wraps a {@link Noder} and transforms its input
+ * into the integer domain.
+ *
+ * This is intended for use with Snap-Rounding noders,
+ * which typically are only intended to work in the integer domain.
+ * Offsets can be provided to increase the number of digits of
+ * available precision.
+ *
+ */
+class GEOS_DLL ScaledNoder : public Noder { // , public geom::CoordinateFilter { // implements Noder
+
+public:
+
+    bool
+    isIntegerPrecision()
+    {
+        return (scaleFactor == 1.0);
+    }
+
+    ScaledNoder(Noder& n, double nScaleFactor,
+                double nOffsetX = 0.0, double nOffsetY = 0.0)
+        :
+        noder(n),
+        scaleFactor(nScaleFactor),
+        offsetX(nOffsetX),
+        offsetY(nOffsetY),
+        isScaled(nScaleFactor != 1.0)
+    {}
+
+    ~ScaledNoder() override;
+
+    std::vector<SegmentString*>* getNodedSubstrings() const override;
+
+    void computeNodes(std::vector<SegmentString*>* inputSegStr) override;
+
+    //void filter(Coordinate& c);
+
+    void
+    filter_ro(const geom::Coordinate* c)
+    {
+        ::geos::ignore_unused_variable_warning(c);
+        assert(0);
+    }
+
+    void filter_rw(geom::Coordinate* c) const;
+
+private:
+
+    Noder& noder;
+
+    double scaleFactor;
+
+    double offsetX;
+
+    double offsetY;
+
+    bool isScaled;
+
+    void rescale(std::vector<SegmentString*>& segStrings) const;
+
+    void scale(std::vector<SegmentString*>& segStrings) const;
+
+    class Scaler;
+
+    class ReScaler;
+
+    friend class ScaledNoder::Scaler;
+
+    friend class ScaledNoder::ReScaler;
+
+    mutable std::vector<geom::CoordinateSequence*> newCoordSeq;
+
+    // Declare type as noncopyable
+    ScaledNoder(const ScaledNoder& other) = delete;
+    ScaledNoder& operator=(const ScaledNoder& rhs) = delete;
+};
+
+} // namespace geos.noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/SegmentExtractingNoder.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * 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/export.h>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Envelope.h>
+#include <geos/noding/Noder.h>
+#include <geos/noding/snap/SnappingPointIndex.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Envelope;
+class PrecisionModel;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/**
+ * A noder which extracts all line segments
+ * as SegmentString.
+ * This enables fast overlay of geometries which are known to be already fully noded.
+ * In particular, it provides fast union of polygonal and linear coverages.
+ * Unioning a noded set of lines is an effective way
+ * to perform line merging and line dissolving.
+ *
+ * No precision reduction is carried out.
+ * If that is required, another noder must be used (such as a snap-rounding noder),
+ * or the input must be precision-reduced beforehand.
+ *
+ */
+class GEOS_DLL SegmentExtractingNoder : public Noder {
+
+private:
+
+    std::vector<SegmentString*>* segList;
+
+    void extractSegments(
+        const std::vector<SegmentString*>& inputSegs,
+        std::vector<SegmentString*>& outputSegs);
+
+    void extractSegments(
+        const SegmentString* ss,
+        std::vector<SegmentString*>& outputSegs);
+
+
+public:
+
+    /**
+    * Creates a new segment-extracting noder.
+    */
+    SegmentExtractingNoder() : segList(nullptr)
+        {};
+
+    void computeNodes(std::vector<SegmentString*>* segStrings) override;
+
+    /**
+    * @return a Collection of SegmentString representing the
+    * substrings. Caller takes ownership over vector and contents.
+    */
+    std::vector<SegmentString*>* getNodedSubstrings() const override;
+
+
+};
+
+
+} // namespace geos::noding
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/noding/SegmentIntersectionDetector.h

@@ -0,0 +1,177 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research 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.
+ *
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cstddef>
+#include <geos/noding/SegmentIntersector.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/noding/SegmentString.h>
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Detects and records an intersection between two {@link SegmentString}s,
+ * if one exists.
+ *
+ * This strategy can be configured to search for proper intersections.
+ * In this case, the presence of any intersection will still be recorded,
+ * but searching will continue until either a proper intersection has been found
+ * or no intersections are detected.
+ *
+ * Only a single intersection is recorded.
+ *
+ * @version 1.7
+ */
+class SegmentIntersectionDetector : public SegmentIntersector {
+private:
+    algorithm::LineIntersector* li;
+
+    bool findProper;
+    bool findAllTypes;
+
+    bool _hasIntersection;
+    bool _hasProperIntersection;
+    bool _hasNonProperIntersection;
+
+    const geom::Coordinate* intPt;
+    geom::CoordinateSequence* intSegments;
+
+protected:
+public:
+    SegmentIntersectionDetector(algorithm::LineIntersector* p_li)
+        :
+        li(p_li),
+        findProper(false),
+        findAllTypes(false),
+        _hasIntersection(false),
+        _hasProperIntersection(false),
+        _hasNonProperIntersection(false),
+        intPt(nullptr),
+        intSegments(nullptr)
+    { }
+
+    ~SegmentIntersectionDetector() override
+    {
+        //delete intPt;
+        delete intSegments;
+    }
+
+
+    void
+    setFindProper(bool p_findProper)
+    {
+        this->findProper = p_findProper;
+    }
+
+    void
+    setFindAllIntersectionTypes(bool p_findAllTypes)
+    {
+        this->findAllTypes = p_findAllTypes;
+    }
+
+    /** \brief
+     * Tests whether an intersection was found.
+     *
+     * @return true if an intersection was found
+     */
+    bool
+    hasIntersection() const
+    {
+        return _hasIntersection;
+    }
+
+    /** \brief
+     * Tests whether a proper intersection was found.
+     *
+     * @return `true` if a proper intersection was found
+     */
+    bool
+    hasProperIntersection() const
+    {
+        return _hasProperIntersection;
+    }
+
+    /** \brief
+     * Tests whether a non-proper intersection was found.
+     *
+     * @return true if a non-proper intersection was found
+     */
+    bool
+    hasNonProperIntersection() const
+    {
+        return _hasNonProperIntersection;
+    }
+
+    /** \brief
+    * Gets the computed location of the intersection.
+    * Due to round-off, the location may not be exact.
+    *
+    * @return the coordinate for the intersection location
+    */
+    const geom::Coordinate*
+    getIntersection()  const
+    {
+        return intPt;
+    }
+
+
+    /** \brief
+     * Gets the endpoints of the intersecting segments.
+     *
+     * @return an array of the segment endpoints (p00, p01, p10, p11)
+     */
+    const geom::CoordinateSequence*
+    getIntersectionSegments() const
+    {
+        return intSegments;
+    }
+
+    bool
+    isDone() const override
+    {
+        // If finding all types, we can stop
+        // when both possible types have been found.
+        if(findAllTypes) {
+            return _hasProperIntersection && _hasNonProperIntersection;
+        }
+
+        // If searching for a proper intersection, only stop if one is found
+        if(findProper) {
+            return _hasProperIntersection;
+        }
+
+        return _hasIntersection;
+    }
+
+    /** \brief
+     * This method is called by clients of the SegmentIntersector class to process
+     * intersections for two segments of the {@link SegmentString}s being intersected.
+     *
+     * @note Some clients (such as `MonotoneChains`) may optimize away
+     *       this call for segment pairs which they have determined do not intersect
+     *       (e.g. by an disjoint envelope test).
+     */
+    void processIntersections(noding::SegmentString* e0, std::size_t segIndex0,
+                              noding::SegmentString* e1, std::size_t segIndex1) override;
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/SegmentIntersector.h

@@ -0,0 +1,89 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cstddef>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/**
+ * \brief
+ * Processes possible intersections detected by a Noder.
+ *
+ * The SegmentIntersector is passed to a Noder.
+ * The addIntersections method is called whenever the Noder
+ * detects that two SegmentStrings <i>might</i> intersect.
+ * This class may be used either to find all intersections, or
+ * to detect the presence of an intersection.  In the latter case,
+ * Noders may choose to short-circuit their computation by calling the
+ * isDone method.
+ * This class is an example of the <i>Strategy</i> pattern.
+ *
+ * @version 1.7
+ */
+class GEOS_DLL SegmentIntersector {
+
+public:
+
+    /**
+     * This method is called by clients
+     * of the SegmentIntersector interface to process
+     * intersections for two segments of the SegmentStrings
+     * being intersected.
+     */
+    virtual void processIntersections(
+        SegmentString* e0,  std::size_t segIndex0,
+        SegmentString* e1,  std::size_t segIndex1) = 0;
+
+    /**
+     * \brief
+     * Reports whether the client of this class
+     * needs to continue testing all intersections in an arrangement.
+     *
+     * @return true if there is not need to continue testing segments
+     *
+     * The default implementation always return false (process all intersections).
+     */
+    virtual bool
+    isDone() const
+    {
+        return false;
+    }
+
+    virtual
+    ~SegmentIntersector()
+    { }
+
+protected:
+
+    SegmentIntersector() {}
+
+};
+
+/// Temporary typedef for namespace transition
+typedef SegmentIntersector nodingSegmentIntersector;
+
+} // namespace geos.noding
+} // namespace geos
+