@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/valid/PolygonTopologyAnalyzer.h

@@ -1,211 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
- * Copyright (C) 2021 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/export.h>
-
-#include <geos/geom/Coordinate.h>
-#include <geos/operation/valid/PolygonIntersectionAnalyzer.h>
-#include <geos/operation/valid/PolygonRing.h>
-#include <geos/noding/BasicSegmentString.h>
-
-#include <memory>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-}
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace valid {     // geos.operation.valid
-
-using geos::geom::CoordinateXY;
-using geos::geom::CoordinateSequence;
-using geos::geom::Geometry;
-using geos::geom::LinearRing;
-
-class GEOS_DLL PolygonTopologyAnalyzer {
-
-private:
-
-    // const Geometry* inputGeom;
-    bool isInvertedRingValid = false;
-    PolygonIntersectionAnalyzer segInt;
-    std::vector<PolygonRing*> polyRings;
-    geom::CoordinateXY disconnectionPt;
-
-
-    // holding area for PolygonRings and SegmentStrings so we
-    // can pass around pointers with abandon
-    std::deque<PolygonRing> polyRingStore;
-    std::deque<noding::BasicSegmentString> segStringStore;
-    // when building SegmentStrings we sometimes want
-    // to use deduped CoordinateSequences so we will
-    // keep the deduped ones here so they get cleaned
-    // up when processing is complete
-    std::vector<std::unique_ptr<CoordinateSequence>> coordSeqStore;
-
-    PolygonRing* createPolygonRing(const LinearRing* p_ring);
-    PolygonRing* createPolygonRing(const LinearRing* p_ring, int p_index, PolygonRing* p_shell);
-
-    static const CoordinateXY&
-    findNonEqualVertex(const LinearRing* ring, const CoordinateXY& p);
-
-    /**
-     * Tests whether a touching segment is interior to a ring.
-     *
-     * Preconditions:
-     *
-     *  * The segment does not cross the ring
-     *  * The segment vertex p0 lies on the ring
-     *  * The ring is valid
-     *
-     * This works for both shells and holes, but the caller must know
-     * the ring role.
-     *
-     * @param p0 the first vertex of the segment
-     * @param p1 the second vertex of the segment
-     * @param ringPts the points of the ring
-     * @return true if the segment is inside the ring.
-     */
-    static bool isIncidentSegmentInRing(const CoordinateXY* p0, const CoordinateXY* p1,
-        const CoordinateSequence* ringPts);
-
-    static const CoordinateXY& findRingVertexPrev(const CoordinateSequence* ringPts,
-        std::size_t index, const CoordinateXY& node);
-
-    static const CoordinateXY& findRingVertexNext(const CoordinateSequence* ringPts,
-        std::size_t index, const CoordinateXY& node);
-
-    static std::size_t ringIndexPrev(const CoordinateSequence* ringPts, std::size_t index);
-
-    static std::size_t ringIndexNext(const CoordinateSequence* ringPts, std::size_t index);
-
-    /**
-     * Computes the index of the segment which intersects a given point.
-     * @param ringPts the ring points
-     * @param pt the intersection point
-     * @return the intersection segment index, or -1 if no intersection is found
-     */
-    static std::size_t intersectingSegIndex(const CoordinateSequence* ringPts, const CoordinateXY* pt);
-
-    std::vector<SegmentString*> createSegmentStrings(const Geometry* geom, bool isInvertedRingValid);
-
-    std::vector<PolygonRing*> getPolygonRings(const std::vector<SegmentString*>& segStrings);
-
-    SegmentString* createSegString(const LinearRing* ring, const PolygonRing* polyRing);
-
-    // Declare type as noncopyable
-    PolygonTopologyAnalyzer(const PolygonTopologyAnalyzer& other) = delete;
-    PolygonTopologyAnalyzer& operator=(const PolygonTopologyAnalyzer& rhs) = delete;
-
-public:
-
-    /* public */
-    PolygonTopologyAnalyzer(const Geometry* geom, bool p_isInvertedRingValid);
-
-    /**
-     * Finds a self-intersection (if any) in a LinearRing.
-     *
-     * @param ring the ring to analyze
-     * @return a self-intersection point if one exists, or null
-     */
-    static CoordinateXY findSelfIntersection(const LinearRing* ring);
-
-    /**
-     * Tests whether a ring is nested inside another ring.
-     *
-     * Preconditions:
-     *
-     * * The rings do not cross (i.e. the test is wholly inside or outside the target)
-     * * The rings may touch at discrete points only
-     * * The target ring does not self-cross, but it may self-touch
-     *
-     * If the test ring start point is properly inside or outside, that provides the result.
-     * Otherwise the start point is on the target ring,
-     * and the incident start segment (accounting for repeated points) is
-     * tested for its topology relative to the target ring.
-     *
-     * @param test the ring to test
-     * @param target the ring to test against
-     * @return true if the test ring lies inside the target ring
-     */
-    static bool
-    isRingNested(const LinearRing* test,
-        const LinearRing* target);
-
-    bool hasInvalidIntersection() {
-        return segInt.isInvalid();
-    }
-
-    int getInvalidCode() {
-        return segInt.getInvalidCode();
-    }
-
-    const CoordinateXY& getInvalidLocation() {
-        return segInt.getInvalidLocation();
-    }
-
-    /**
-    * Tests whether the interior of the polygonal geometry is
-    * disconnected.
-    * If true, the disconnection location is available from
-    * getDisconnectionLocation().
-    *
-    * @return true if the interior is disconnected
-    */
-    bool isInteriorDisconnected();
-
-    const CoordinateXY& getDisconnectionLocation() const
-    {
-        return disconnectionPt;
-    };
-
-
-    /**
-    * Tests whether any polygon with holes has a disconnected interior
-    * by virtue of the holes (and possibly shell) forming a hole cycle.
-    *
-    * This is a global check, which relies on determining
-    * the touching graph of all holes in a polygon.
-    *
-    * If inverted rings disconnect the interior
-    * via a self-touch, this is checked by the PolygonIntersectionAnalyzer.
-    * If inverted rings are part of a hole cycle
-    * this is detected here as well.
-    */
-    void checkInteriorDisconnectedByHoleCycle();
-
-    /**
-    * Tests if an area interior is disconnected by a self-touching ring.
-    * This must be evaluated after other self-intersections have been analyzed
-    * and determined to not exist, since the logic relies on
-    * the rings not self-crossing (winding).
-    * <p>
-    * If self-touching rings are not allowed,
-    * then the self-touch will previously trigger a self-intersection error.
-    */
-    void checkInteriorDisconnectedBySelfTouch();
-
-};
-
-
-} // namespace geos.operation.valid
-} // namespace geos.operation
-} // namespace geos

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/valid/RepeatedPointRemover.h

@@ -1,60 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2019 Daniel Baston <dbaston@gmail.com>
- *
- * 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/CoordinateSequence.h>
-#include <geos/geom/Geometry.h>
-
-
-namespace geos {
-namespace operation {
-namespace valid {
-
-    /**
-     *  Removes repeated, consecutive equal, coordinates from a CoordinateSequence.
-     */
-    class GEOS_DLL RepeatedPointRemover {
-
-    public:
-
-        /**
-         *  Returns a new CoordinateSequence being a copy of the input
-         *  with any consecutive equal Coordinate removed.
-         *  Equality test is 2D based.
-         *
-         *  \param seq to filter
-         *  \param tolerance to apply
-         *  \return Geometr, ownership of returned object goes to the caller.
-         */
-        static std::unique_ptr<geom::CoordinateSequence>
-            removeRepeatedPoints(
-                const geom::CoordinateSequence* seq,
-                double tolerance = 0.0);
-
-        static std::unique_ptr<geom::CoordinateSequence>
-            removeRepeatedAndInvalidPoints(
-                const geom::CoordinateSequence* seq,
-                double tolerance = 0.0);
-
-        static std::unique_ptr<geom::Geometry>
-            removeRepeatedPoints(
-                const geom::Geometry* geom,
-                double tolerance = 0.0);
-    };
-
-}
-}
-}
-

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/valid/RepeatedPointTester.h

@@ -1,66 +0,0 @@
-/**********************************************************************
- *
- * 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: operation/valid/RepeatedPointTester.java rev. 1.8 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Coordinate.h> // for composition
-
-// Forward declarations
-namespace geos {
-namespace geom {
-//class Coordinate;
-class CoordinateSequence;
-class Geometry;
-class Polygon;
-class MultiPolygon;
-class MultiLineString;
-class GeometryCollection;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace valid { // geos::operation::valid
-
-/** \brief
- * Implements the appropriate checks for repeated points
- * (consecutive identical coordinates) as defined in the
- * JTS spec.
- */
-class GEOS_DLL RepeatedPointTester {
-public:
-    RepeatedPointTester() {}
-    geom::CoordinateXY& getCoordinate();
-    bool hasRepeatedPoint(const geom::Geometry* g);
-    bool hasRepeatedPoint(const geom::CoordinateSequence* coord);
-private:
-    geom::CoordinateXY repeatedCoord;
-    bool hasRepeatedPoint(const geom::Polygon* p);
-    bool hasRepeatedPoint(const geom::GeometryCollection* gc);
-    bool hasRepeatedPoint(const geom::MultiPolygon* gc);
-    bool hasRepeatedPoint(const geom::MultiLineString* gc);
-};
-
-
-} // namespace geos.operation.valid
-} // namespace geos.operation
-} // namespace geos
-

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/valid/TopologyValidationError.h

@@ -1,76 +0,0 @@
-/**********************************************************************
- *
- * 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: operation/valid/TopologyValidationError.java rev. 1.16 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <string>
-
-#include <geos/geom/Coordinate.h> // for composition
-
-// Forward declarations
-// none required
-
-namespace geos {
-namespace operation { // geos::operation
-namespace valid { // geos::operation::valid
-
-/** \brief
- * Contains information about the nature and location of a geom::Geometry
- * validation error
- *
- */
-class GEOS_DLL TopologyValidationError {
-public:
-
-    enum errorEnum {
-        eError,
-        eRepeatedPoint,
-        eHoleOutsideShell,
-        eNestedHoles,
-        eDisconnectedInterior,
-        eSelfIntersection,
-        eRingSelfIntersection,
-        eNestedShells,
-        eDuplicatedRings,
-        eTooFewPoints,
-        eInvalidCoordinate,
-        eRingNotClosed,
-        oNoInvalidIntersection = -1
-    };
-
-    TopologyValidationError(int newErrorType, const geom::CoordinateXY& newPt);
-    TopologyValidationError(int newErrorType);
-    const geom::CoordinateXY& getCoordinate() const;
-    std::string getMessage() const;
-    int getErrorType() const;
-    std::string toString() const;
-
-private:
-    // Used const char* to reduce dynamic allocations
-    static const char* errMsg[];
-    int errorType;
-    const geom::CoordinateXY pt;
-};
-
-
-} // namespace geos.operation.valid
-} // namespace geos.operation
-} // namespace geos
-

package/dist/prebuilt/Emscripten-x86_64/include/geos/planargraph/DirectedEdge.h

@@ -1,237 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- * Copyright (C) 2005-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/planargraph/GraphComponent.h> // for inheritance
-#include <geos/geom/Coordinate.h> // for composition
-
-#include <vector> // for typedefs
-#include <list> // for typedefs
-
-// Forward declarations
-namespace geos {
-namespace planargraph {
-class Edge;
-class Node;
-}
-}
-
-namespace geos {
-namespace planargraph { // geos.planargraph
-
-/**
- * \brief Represents a directed edge in a PlanarGraph.
- *
- * A DirectedEdge may or may not have a reference to a parent Edge
- * (some applications of planar graphs may not require explicit Edge
- * objects to be created). Usually a client using a PlanarGraph
- * will subclass DirectedEdge to add its own application-specific
- * data and methods.
- */
-class GEOS_DLL DirectedEdge: public GraphComponent {
-
-public:
-
-    friend std::ostream& operator << (std::ostream&, const DirectedEdge&);
-
-    typedef std::list<DirectedEdge*> NonConstList;
-    typedef std::list<const DirectedEdge*> ConstList;
-    typedef std::vector<DirectedEdge*> NonConstVect;
-
-protected:
-    Edge* parentEdge;
-    Node* from;
-    Node* to;
-    geom::Coordinate p0, p1;
-    DirectedEdge* sym;  // optional
-    bool edgeDirection;
-    int quadrant;
-    double angle;
-public:
-
-    typedef std::vector<const DirectedEdge*> ConstVect;
-    typedef std::vector<DirectedEdge*> Vect;
-
-    /**
-     * \brief
-     * Returns a List containing the parent Edge (possibly null)
-     * for each of the given DirectedEdges.
-     *
-     * @note Ownership of the returned vector is left to
-     * the caller, see the equivalent function taking a vector
-     * reference to avoid this.
-     */
-    static std::vector<Edge*>* toEdges(
-        std::vector<DirectedEdge*>& dirEdges);
-
-    /**
-     * \brief
-     * Add parent Edge (possibly null) of each of the given DirectedEdges
-     * to the given parentEdges vector.
-     *
-     * @note Parents are pushed to the parentEdges vector, make sure
-     * it is empty if index-based corrispondence is important.
-     */
-    static void toEdges(std::vector<DirectedEdge*>& dirEdges,
-                        std::vector<Edge*>& parentEdges);
-
-    /**
-     * \brief Constructs a DirectedEdge connecting the `from`
-     * node to the `to` node.
-     *
-     * @param newFrom `from` node
-     * @param newTo `to` node
-     * @param directionPt specifies this DirectedEdge's direction
-     *                    (given by an imaginary line from the
-     *                    `from` node to
-     *                    `directionPt`)
-     * @param newEdgeDirection whether this DirectedEdge's direction
-     *                         is the same as or opposite to that of the
-     *                         parent Edge (if any)
-     */
-    DirectedEdge(Node* newFrom, Node* newTo,
-                 const geom::Coordinate& directionPt,
-                 bool newEdgeDirection);
-
-    /**
-     * \brief Returns this DirectedEdge's parent Edge,
-     * or null if it has none.
-     */
-    Edge* getEdge() const;
-
-    /**
-     * \brief Associates this DirectedEdge with an Edge
-     * (possibly null, indicating no associated Edge).
-     */
-    void setEdge(Edge* newParentEdge);
-
-    /**
-     * \brief Returns 0, 1, 2, or 3, indicating the quadrant in which
-     * this DirectedEdge's orientation lies.
-     */
-    int getQuadrant() const;
-
-    /**
-     * \brief Returns a point to which an imaginary line is drawn
-     * from the from-node to specify this DirectedEdge's orientation.
-     */
-    const geom::Coordinate& getDirectionPt() const;
-
-    /**
-     * \brief Returns whether the direction of the parent Edge (if any)
-     * is the same as that of this Directed Edge.
-     */
-    bool getEdgeDirection() const;
-
-    /**
-     * \brief Returns the node from which this DirectedEdge leaves.
-     */
-    Node* getFromNode() const;
-
-    /**
-     * \brief Returns the node to which this DirectedEdge goes.
-     */
-    Node* getToNode() const;
-
-    /**
-     * \brief
-     * Returns the coordinate of the from-node.
-     */
-    geom::Coordinate& getCoordinate() const;
-
-    /**
-     * \brief
-     * Returns the angle that the start of this DirectedEdge makes
-     * with the positive x-axis, in radians.
-     */
-    double getAngle() const;
-
-    /**
-     * \brief
-     * Returns the symmetric DirectedEdge -- the other DirectedEdge
-     * associated with this DirectedEdge's parent Edge.
-     */
-    DirectedEdge* getSym() const;
-
-    /**
-     * \brief
-     * Sets this DirectedEdge's symmetric DirectedEdge, which runs
-     * in the opposite direction.
-     */
-    void setSym(DirectedEdge* newSym);
-
-    /**
-     * \brief
-     * Returns 1 if this DirectedEdge has a greater angle with the
-     * positive x-axis than b", 0 if the DirectedEdges are collinear,
-     * and -1 otherwise.
-     *
-     * Using the obvious algorithm of simply computing the angle is
-     * not robust, since the angle calculation is susceptible to roundoff.
-     * A robust algorithm is:
-     *
-     * - first compare the quadrants.
-     *   If the quadrants are different, it it
-     *   trivial to determine which std::vector is "greater".
-     * - if the vectors lie in the same quadrant, the robust
-     *   Orientation::index(Coordinate, Coordinate, Coordinate)
-     *   function can be used to decide the relative orientation of
-     *   the vectors.
-     *
-     */
-    int compareTo(const DirectedEdge* obj) const;
-
-    /**
-     * \brief
-     * Returns 1 if this DirectedEdge has a greater angle with the
-     * positive x-axis than b", 0 if the DirectedEdges are collinear,
-     * and -1 otherwise.
-     *
-     * Using the obvious algorithm of simply computing the angle is
-     * not robust, since the angle calculation is susceptible to roundoff.
-     * A robust algorithm is:
-     *
-     * - first compare the quadrants.
-     *   If the quadrants are different, it it trivial to determine
-     *   which std::vector is "greater".
-     * - if the vectors lie in the same quadrant, the robust
-     *   Orientation::index(Coordinate, Coordinate, Coordinate)
-     *   function can be used to decide the relative orientation of
-     *   the vectors.
-     *
-     */
-    int compareDirection(const DirectedEdge* e) const;
-
-    /**
-     * \brief
-     * Prints a detailed string representation of this DirectedEdge
-     * to the given PrintStream.
-     */
-    std::string print() const;
-
-};
-
-/// Strict Weak comparator function for containers
-bool pdeLessThan(DirectedEdge* first, DirectedEdge* second);
-
-/// Output operator
-std::ostream& operator << (std::ostream&, const DirectedEdge&);
-
-
-} // namespace geos::planargraph
-} // namespace geos
-