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

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/overlayng/IntersectionPointBuilder.h

@@ -1,113 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 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/geom/Point.h>
-#include <geos/operation/overlayng/OverlayNG.h>
-
-#include <geos/export.h>
-#include <vector>
-#include <memory>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class GeometryFactory;
-}
-namespace operation {
-namespace overlayng {
-class OverlayEdge;
-class OverlayGraph;
-class OverlayLabel;
-}
-}
-}
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-/**
- * Extracts Point resultants from an overlay graph
- * created by an Intersection operation
- * between non-Point inputs.
- * Points may be created during intersection
- * if lines or areas touch one another at single points.
- * Intersection is the only overlay operation which can
- * result in Points from non-Point inputs.
- * <p>
- * Overlay operations where one or more inputs
- * are Points are handled via a different code path.
- *
- *
- * @author Martin Davis
- *
- * @see OverlayPoints
- *
- */
-class GEOS_DLL IntersectionPointBuilder {
-
-private:
-
-    // Members
-    OverlayGraph* graph;
-    const geom::GeometryFactory* geometryFactory;
-    std::vector<std::unique_ptr<geom::Point>> points;
-    /**
-    * Controls whether lines created by area topology collapses
-    * to participate in the result computation.
-    * True provides the original JTS semantics.
-    */
-    bool isAllowCollapseLines;
-
-    // Methods
-    void addResultPoints();
-
-    /**
-    * Tests if a node is a result point.
-    * This is the case if the node is incident on edges from both
-    * inputs, and none of the edges are themselves in the result.
-    */
-    bool isResultPoint(OverlayEdge* nodeEdge) const;
-    bool isEdgeOf(const OverlayLabel* label, uint8_t i) const;
-
-
-public:
-
-
-    IntersectionPointBuilder(OverlayGraph* p_graph, const geom::GeometryFactory* geomFact)
-        : graph(p_graph)
-        , geometryFactory(geomFact)
-        , isAllowCollapseLines(!OverlayNG::STRICT_MODE_DEFAULT)
-        {}
-
-    std::vector<std::unique_ptr<geom::Point>> getPoints();
-
-    IntersectionPointBuilder(const IntersectionPointBuilder&) = delete;
-    IntersectionPointBuilder& operator=(const IntersectionPointBuilder&) = delete;
-
-    void setStrictMode(bool p_isStrictMode)
-    {
-        isAllowCollapseLines = ! p_isStrictMode;
-    }
-
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos
-

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

@@ -1,189 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 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/operation/overlayng/InputGeometry.h>
-#include <geos/operation/overlayng/OverlayNG.h>
-#include <geos/geom/Location.h>
-#include <geos/geom/LineString.h>
-
-#include <vector>
-
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class GeometryFactory;
-class LineString;
-}
-namespace operation {
-namespace overlayng {
-class OverlayEdge;
-class OverlayGraph;
-class OverlayLabel;
-class InputGeometry;
-}
-}
-}
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-/**
- * Finds and builds overlay result lines from the overlay graph.
- * Output linework has the following semantics:
- *
- *  - Linework is fully noded
- *  - Lines are as long as possible between nodes
- *
- * Various strategies are possible for how to
- * merge graph edges into lines.
- * This implementation uses the approach
- * of having output lines run contiguously from node to node.
- * For rings a node point is chosen arbitrarily.
- *
- * Another possible strategy would be to preserve input linework
- * as far as possible (i.e. any sections of input lines which are not
- * coincident with other linework would be preserved).
- *
- * It would also be possible to output LinearRings,
- * if the input is a LinearRing and is unchanged.
- * This will require additional info from the input linework.
- *
- * @author Martin Davis
- */
-class GEOS_DLL LineBuilder {
-
-private:
-
-    // Members
-    OverlayGraph* graph;
-    int opCode;
-    const geom::GeometryFactory* geometryFactory;
-    bool hasResultArea;
-    int8_t inputAreaIndex;
-    std::vector<std::unique_ptr<geom::LineString>> lines;
-
-    /**
-    * Indicates whether intersections are allowed to produce
-    * heterogeneous results including proper boundary touches.
-    * This does not control inclusion of touches along collapses.
-    * True provides the original JTS semantics.
-    */
-    bool isAllowMixedResult = ! OverlayNG::STRICT_MODE_DEFAULT;
-
-    /**
-    * Allow lines created by area topology collapses
-    * to appear in the result.
-    * True provides the original JTS semantics.
-    */
-    bool isAllowCollapseLines = ! OverlayNG::STRICT_MODE_DEFAULT;
-
-    void markResultLines();
-
-    /**
-    * Checks if the topology indicated by an edge label
-    * determines that this edge should be part of a result line.
-    *
-    * Note that the logic here relies on the semantic
-    * that for intersection lines are only returned if
-    * there is no result area components.
-    */
-    bool isResultLine(const OverlayLabel* lbl) const;
-
-    /**
-    * Determines the effective location for a line,
-    * for the purpose of overlay operation evaluation.
-    * Line edges and Collapses are reported as INTERIOR
-    * so they may be included in the result
-    * if warranted by the effect of the operation
-    * on the two edges.
-    * (For instance, the intersection of line edge and a collapsed boundary
-    * is included in the result).
-    */
-    static geom::Location effectiveLocation(const OverlayLabel* lbl, uint8_t geomIndex);
-
-    void addResultLines();
-    void addResultLinesMerged();
-
-    std::unique_ptr<geom::LineString> toLine(OverlayEdge* edge) const;
-
-    void addResultLinesForNodes();
-
-    /**
-    * Adds lines which form rings (i.e. have only degree-2 vertices).
-    */
-    void addResultLinesRings();
-
-    /**
-    * Traverses edges from edgeStart which
-    * lie in a single line (have degree = 2).
-    *
-    * The direction of the linework is preserved as far as possible.
-    * Specifically, the direction of the line is determined
-    * by the start edge direction. This implies
-    * that if all edges are reversed, the created line
-    * will be reversed to match.
-    * (Other more complex strategies would be possible.
-    * 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);
-
-    /*
-    * Finds the next edge around a node which forms
-    * part of a result line.
-    */
-    static OverlayEdge* nextLineEdgeUnvisited(OverlayEdge* node) ;
-
-    /**
-    * Computes the degree of the line edges incident on a node
-    */
-    static int degreeOfLines(OverlayEdge* node) ;
-
-
-
-public:
-
-    LineBuilder(const InputGeometry* inputGeom, OverlayGraph* p_graph, bool p_hasResultArea, int p_opCode, const geom::GeometryFactory* geomFact)
-        : graph(p_graph)
-        , opCode(p_opCode)
-        , geometryFactory(geomFact)
-        , hasResultArea(p_hasResultArea)
-        , inputAreaIndex((int8_t)inputGeom->getAreaIndex())
-        , isAllowMixedResult(! OverlayNG::STRICT_MODE_DEFAULT)
-        , isAllowCollapseLines(! OverlayNG::STRICT_MODE_DEFAULT)
-        {}
-
-    LineBuilder(const LineBuilder&) = delete;
-    LineBuilder& operator=(const LineBuilder&) = delete;
-
-    std::vector<std::unique_ptr<geom::LineString>> getLines();
-
-    void setStrictMode(bool p_isStrictResultMode)
-    {
-        isAllowCollapseLines = ! p_isStrictResultMode;
-        isAllowMixedResult = ! p_isStrictResultMode;
-    }
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos

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

@@ -1,91 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 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/geom/CoordinateSequence.h>
-
-#include <geos/export.h>
-#include <array>
-#include <memory>
-#include <vector>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Envelope;
-class Coordinate;
-class CoordinateSequence;
-}
-}
-
-using namespace geos::geom;
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-/**
- * Limits the segments in a list of segments
- * to those which intersect an envelope.
- * This creates zero or more sections of the input segment sequences,
- * containing only line segments which intersect the limit envelope.
- * Segments are not clipped, since that can move
- * line segments enough to alter topology,
- * and it happens in the overlay in any case.
- * This can substantially reduce the number of vertices which need to be
- * processed during overlay.
- *
- * This optimization is only applicable to Line geometries,
- * since it does not maintain the closed topology of rings.
- * Polygonal geometries are optimized using the {@link RingClipper}.
- *
- * @author Martin Davis
- */
-class GEOS_DLL LineLimiter {
-
-private:
-
-    // Members
-    const Envelope* limitEnv;
-    std::unique_ptr<geom::CoordinateSequence> ptList;
-    const Coordinate* lastOutside;
-    std::vector<std::unique_ptr<CoordinateSequence>> sections;
-
-    // Methods
-    void addPoint(const Coordinate* p);
-    void addOutside(const Coordinate* p);
-    bool isLastSegmentIntersecting(const Coordinate* p);
-    bool isSectionOpen();
-    void startSection();
-    void finishSection();
-
-
-public:
-
-    LineLimiter(const Envelope* env)
-        : limitEnv(env)
-        , ptList(nullptr)
-        , lastOutside(nullptr)
-        {};
-
-    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const CoordinateSequence *pts);
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/overlayng/MaximalEdgeRing.h

@@ -1,134 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 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/operation/overlayng/OverlayEdgeRing.h>
-
-#include <vector>
-#include <memory>
-#include <geos/export.h>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class CoordinateArray;
-class GeometryFactory;
-}
-namespace operation {
-namespace overlayng {
-class OverlayEdge;
-class EdgeRing;
-}
-}
-}
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-using namespace geos::geom;
-
-class GEOS_DLL MaximalEdgeRing {
-
-private:
-
-    // Constants
-    static constexpr int STATE_FIND_INCOMING = 1;
-    static constexpr int STATE_LINK_OUTGOING = 2;
-
-    // Members
-    OverlayEdge* startEdge;
-
-    // Methods
-    void attachEdges(OverlayEdge* startEdge);
-    void linkMinimalRings();
-
-    /**
-    * Links the edges of a {@link MaximalEdgeRing} around this node
-    * into minimal edge rings ({@link OverlayEdgeRing}s).
-    * Minimal ring edges are linked in the opposite orientation (CW)
-    * to the maximal ring.
-    * This changes self-touching rings into a two or more separate rings,
-    * as per the OGC SFS polygon topology semantics.
-    * This relinking must be done to each max ring separately,
-    * rather than all the node result edges, since there may be
-    * more than one max ring incident at the node.
-    *
-    * @param nodeEdge an edge originating at this node
-    * @param maxRing the maximal ring to link
-    */
-    static void linkMinRingEdgesAtNode(OverlayEdge* nodeEdge, MaximalEdgeRing* maxRing);
-
-    /**
-    * Tests if an edge of the maximal edge ring is already linked into
-    * a minimal {@link OverlayEdgeRing}.  If so, this node has already been processed
-    * earlier in the maximal edgering linking scan.
-    *
-    * @param edge an edge of a maximal edgering
-    * @param maxRing the maximal edgering
-    * @return true if the edge has already been linked into a minimal edgering.
-    */
-    static bool isAlreadyLinked(OverlayEdge* edge, MaximalEdgeRing* maxRing);
-
-    static OverlayEdge* selectMaxOutEdge(OverlayEdge* currOut, MaximalEdgeRing* maxEdgeRing);
-    static OverlayEdge* linkMaxInEdge(OverlayEdge* currOut, OverlayEdge* currMaxRingOut, MaximalEdgeRing* maxEdgeRing);
-
-
-public:
-
-    MaximalEdgeRing(OverlayEdge* e)
-        : startEdge(e)
-    {
-        attachEdges(e);
-    };
-
-    std::vector<std::unique_ptr<OverlayEdgeRing>> buildMinimalRings(const GeometryFactory* geometryFactory);
-
-    /**
-    * Traverses the star of edges originating at a node
-    * and links consecutive result edges together
-    * into maximal edge rings.
-    * To link two edges the resultNextMax< pointer
-    * for an incoming< result edge
-    * is set to the next outgoing result edge.
-    *
-    * Edges are linked when:
-    * - they belong to an area (i.e. they have sides)
-    * - they are marked as being in the result
-    *
-    * Edges are linked in CCW order
-    * (which is the order they are linked in the underlying graph).
-    * This means that rings have their face on the Right
-    * (in other words,
-    * the topological location of the face is given by the RHS label of the DirectedEdge).
-    * This produces rings with CW orientation.
-    *
-    * PRECONDITIONS:
-    * - This edge is in the result
-    * - This edge is not yet linked
-    * - The edge and its sym are NOT both marked as being in the result
-    */
-    static void linkResultAreaMaxRingAtNode(OverlayEdge* nodeEdge);
-
-    friend std::ostream& operator<<(std::ostream& os, const MaximalEdgeRing& mer);
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos
-