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

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/overlayng/OverlayLabel.h

@@ -1,404 +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 <cstdint>
-
-#include <geos/geom/Location.h>
-#include <geos/geom/Position.h>
-#include <geos/export.h>
-
-using geos::geom::Location;
-using geos::geom::Position;
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-/**
-* A label for a pair of {@link OverlayEdge}s which records
-* the topological information for the edge
-* in the {@link OverlayGraph} containing it.
-* The label is shared between both OverlayEdges
-* of a symmetric pair.
-* Accessors for orientation-sensitive information
-* require the orientation of the containing OverlayEdge.
-*
-* A label contains the topological {@link geom::Location}s for
-* the two overlay input geometries.
-* A labelled input geometry may be either a Line or an Area.
-* In both cases, the label locations are populated
-* with the locations for the edge {@link geom::Position}s
-* once they are computed by topological evaluation.
-* The label also records the dimension of each geometry,
-* and in the case of area boundary edges, the role
-* of the originating ring (which allows
-* determination of the edge role in collapse cases).
-*
-* For each input geometry, the label indicates that an edge
-* is in one of the following states (identified by the "dim" field).
-* Each state has some additional information about the edge.
-*
-* * A Boundary edge of an input Area (polygon)
-*
-*   * dim = DIM_BOUNDARY
-*   * locLeft, locRight : the locations of the edge sides for the input Area
-*   * isHole : whether the edge was in a shell or a hole
-*
-* * A Collapsed edge of an input Area
-*   (which had two or more parent edges)
-*
-*   * dim = DIM_COLLAPSE
-*   * locLine : the location of the
-*     edge relative to the input Area
-*   * isHole : whether some
-*     contributing edge was in a shell (false),
-*     or otherwise that all were in holes (true)
-*
-* * An edge from an input Line
-*
-*   * dim = DIM_LINE
-*   * locLine : initialized to LOC_UNKNOWN, to simplify logic.
-*
-* * An edge which is Not Part of an input geometry
-*   (and thus must be part of the other geometry).
-*
-*   * dim = NOT_PART
-*
-* Note that:
-*
-* * an edge cannot be both a Collapse edge and a Line edge in the same input geometry,
-*   because each input geometry must be homogeneous.
-* * an edge may be an Boundary edge in one input geometry
-*   and a Line or Collapse edge in the other input.
-*
-* @author Martin Davis
-*/
-class GEOS_DLL OverlayLabel {
-
-private:
-
-    // Members
-    int aDim = DIM_NOT_PART;
-    bool aIsHole = false;
-    Location aLocLeft = LOC_UNKNOWN;
-    Location aLocRight = LOC_UNKNOWN;
-    Location aLocLine = LOC_UNKNOWN;
-    int bDim = DIM_NOT_PART;
-    bool bIsHole = false;
-    Location bLocLeft = LOC_UNKNOWN;
-    Location bLocRight = LOC_UNKNOWN;
-    Location bLocLine = LOC_UNKNOWN;
-
-    std::string dimensionSymbol(int dim) const;
-    void locationString(uint8_t index, bool isForward, std::ostream& os) const;
-
-
-public:
-
-    static constexpr Location LOC_UNKNOWN = Location::NONE;
-
-    enum {
-        DIM_UNKNOWN = -1,
-        DIM_NOT_PART = -1,
-        DIM_LINE = 1,
-        DIM_BOUNDARY = 2,
-        DIM_COLLAPSE = 3
-    };
-
-    OverlayLabel()
-        : aDim(DIM_NOT_PART)
-        , aIsHole(false)
-        , aLocLeft(LOC_UNKNOWN)
-        , aLocRight(LOC_UNKNOWN)
-        , aLocLine(LOC_UNKNOWN)
-        , bDim(DIM_NOT_PART)
-        , bIsHole(false)
-        , bLocLeft(LOC_UNKNOWN)
-        , bLocRight(LOC_UNKNOWN)
-        , bLocLine(LOC_UNKNOWN) {};
-
-    explicit OverlayLabel(uint8_t p_index)
-        : OverlayLabel()
-    {
-        initLine(p_index);
-    };
-
-    OverlayLabel(uint8_t p_index, Location p_locLeft, Location p_locRight, bool p_isHole)
-        : OverlayLabel()
-    {
-        initBoundary(p_index, p_locLeft, p_locRight, p_isHole);
-    };
-
-    int dimension(uint8_t index) const { return index == 0 ? aDim : bDim; };
-    void initBoundary(uint8_t index, Location locLeft, Location locRight, bool p_isHole);
-    void initCollapse(uint8_t index, bool p_isHole);
-    void initLine(uint8_t index);
-    void initNotPart(uint8_t index);
-
-    /**
-    * Sets the line location.
-    *
-    * This is used to set the locations for linear edges
-    * encountered during area label propagation.
-    *
-    * @param index source to update
-    * @param loc location to set
-    */
-    void setLocationLine(uint8_t index, Location loc);
-    void setLocationAll(uint8_t index, Location loc);
-    void setLocationCollapse(uint8_t index);
-
-    /*
-    * Tests whether at least one of the sources is a Line.
-    *
-    * @return true if at least one source is a line
-    */
-    bool isLine() const
-    {
-        return aDim == DIM_LINE || bDim == DIM_LINE;
-    };
-
-    bool isLine(uint8_t index) const
-    {
-        return index == 0 ? aDim == DIM_LINE : bDim == DIM_LINE;
-    };
-
-    bool isLinear(uint8_t index) const
-    {
-        if (index == 0) {
-            return aDim == DIM_LINE || aDim == DIM_COLLAPSE;
-        }
-        return bDim == DIM_LINE || bDim == DIM_COLLAPSE;
-    };
-
-    bool isKnown(uint8_t index) const
-    {
-        if (index == 0) {
-            return aDim != DIM_UNKNOWN;
-        }
-        return bDim != DIM_UNKNOWN;
-    };
-
-    bool isNotPart(uint8_t index) const
-    {
-        if (index == 0) {
-            return aDim == DIM_NOT_PART;
-        }
-        return bDim == DIM_NOT_PART;
-    };
-
-    bool isBoundaryEither() const
-    {
-        return aDim == DIM_BOUNDARY || bDim == DIM_BOUNDARY;
-    };
-
-    bool isBoundaryBoth() const
-    {
-        return aDim == DIM_BOUNDARY && bDim == DIM_BOUNDARY;
-    };
-
-    /**
-    * Tests if the label is for a collapsed
-    * edge of an area
-    * which is coincident with the boundary of the other area.
-    *
-    * @return true if the label is for a collapse coincident with a boundary
-    */
-    bool isBoundaryCollapse() const
-    {
-        if (isLine()) return false;
-        return ! isBoundaryBoth();
-    };
-
-    /**
-    * Tests if a label is for an edge where two
-    * area touch along their boundary.
-    */
-    bool isBoundaryTouch() const
-    {
-        return isBoundaryBoth() &&
-               getLocation(0, Position::RIGHT, true) != getLocation(1, Position::RIGHT, true);
-    };
-
-    bool isBoundary(uint8_t index) const
-    {
-        if (index == 0) {
-            return aDim == DIM_BOUNDARY;
-        }
-        return bDim == DIM_BOUNDARY;
-    };
-
-    bool isLineLocationUnknown(int index) const
-    {
-        if (index == 0) {
-            return aLocLine == LOC_UNKNOWN;
-        }
-        else {
-            return bLocLine == LOC_UNKNOWN;
-        }
-    };
-
-    /**
-    * Tests whether a label is for an edge which is a boundary of one geometry
-    * and not part of the other.
-    */
-    bool isBoundarySingleton() const
-    {
-        if (aDim == DIM_BOUNDARY && bDim == DIM_NOT_PART) {
-            return true;
-        }
-
-        if (bDim == DIM_BOUNDARY && aDim == DIM_NOT_PART) {
-            return true;
-        }
-
-        return false;
-    };
-
-    /**
-    * Tests if a line edge is inside
-    * @param index
-    * @return
-    */
-    bool isLineInArea(int8_t index) const
-    {
-        if (index == 0) {
-            return aLocLine == Location::INTERIOR;
-        }
-        return bLocLine == Location::INTERIOR;
-    };
-
-    bool isHole(uint8_t index) const
-    {
-        if (index == 0) {
-            return aIsHole;
-        }
-        else {
-            return bIsHole;
-        }
-    };
-
-    bool isCollapse(uint8_t index) const
-    {
-        return dimension(index) == DIM_COLLAPSE;
-    };
-
-    Location getLineLocation(uint8_t index) const
-    {
-        if (index == 0) {
-            return aLocLine;
-        }
-        else {
-            return bLocLine;
-        }
-    };
-
-    /**
-    * Tests if a label is a Collapse has location INTERIOR,
-    * to at least one source geometry.
-    */
-    bool isInteriorCollapse() const
-    {
-        if (aDim == DIM_COLLAPSE && aLocLine == Location::INTERIOR)
-            return true;
-        if (bDim == DIM_COLLAPSE && bLocLine == Location::INTERIOR)
-            return true;
-
-        return false;
-    };
-
-    /**
-    * Tests if a label is a Collapse
-    * and NotPart with location INTERIOR for the other geometry.
-    */
-    bool isCollapseAndNotPartInterior() const;
-
-    /**
-    * Tests if a line is in the interior of a source geometry.
-    *
-    * @param index source geometry
-    * @return true if the label is a line and is interior
-    */
-    bool isLineInterior(uint8_t index) const
-    {
-        if (index == 0) {
-            return aLocLine == Location::INTERIOR;
-        }
-        return bLocLine == Location::INTERIOR;
-    };
-
-    /**
-    * Gets the location for this label for either
-    * a Boundary or a Line edge.
-    * This supports a simple determination of
-    * whether the edge should be included as a result edge.
-    *
-    * @param index the source index
-    * @param position the position for a boundary label
-    * @param isForward the direction for a boundary label
-    * @return the location for the specified position
-    */
-    Location getLocationBoundaryOrLine(
-        uint8_t index,
-        int position,
-        bool isForward) const
-    {
-        if (isBoundary(index)) {
-            return getLocation(index, position, isForward);
-        }
-        return getLineLocation(index);
-    };
-
-    /**
-    * Gets the linear location for the given source.
-    *
-    * @param index the source index
-    * @return the linear location for the source
-    */
-    Location getLocation(uint8_t index) const {
-        if (index == 0) {
-            return aLocLine;
-        }
-        return bLocLine;
-    };
-
-    Location getLocation(uint8_t index, int position, bool isForward) const;
-
-    bool hasSides(uint8_t index) const {
-        if (index == 0) {
-            return aLocLeft != LOC_UNKNOWN
-                   || aLocRight != LOC_UNKNOWN;
-        }
-        return bLocLeft != LOC_UNKNOWN
-               || bLocRight != LOC_UNKNOWN;
-    };
-
-    OverlayLabel copy() const
-    {
-        OverlayLabel lbl = *this;
-        return lbl;
-    };
-
-    friend std::ostream& operator<<(std::ostream& os, const OverlayLabel& ol);
-    void toString(bool isForward, std::ostream& os) const;
-
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/overlayng/OverlayLabeller.h

@@ -1,207 +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/geom/Location.h>
-#include <geos/operation/overlayng/OverlayGraph.h>
-
-#include <vector>
-#include <deque>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-namespace operation {
-namespace overlayng {
-class OverlayLabel;
-class OverlayGraph;
-class OverlayEdge;
-class InputGeometry;
-}
-}
-}
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-
-class GEOS_DLL OverlayLabeller {
-
-private:
-
-    // Members
-    OverlayGraph* graph;
-    InputGeometry* inputGeometry;
-    std::vector<OverlayEdge*>& edges;
-
-    /**
-    * Finds a boundary edge for this geom, if one exists.
-    */
-    static OverlayEdge* findPropagationStartEdge(OverlayEdge* nodeEdge, uint8_t geomIndex);
-
-    /**
-    * At this point collapsed edges with unknown location
-    * must be disconnected from the boundary edges of the parent
-    * (because otherwise the location would have
-    * been propagated from them).
-    * This can occur with a collapsed hole or shell.
-    * The edges can be labeled based on their parent ring role (shell or hole).
-    * (This cannot be done earlier, because the location
-    * based on the boundary edges must take precedence.
-    * There are situations where a collapsed edge has a location
-    * which is different to its ring role -
-    * e.g. a narrow gore in a polygon, which is in
-    * the interior of the reduced polygon, but whose
-    * ring role would imply the location EXTERIOR.)
-    *
-    * Note that collapsed edges can NOT have location determined via a PIP location check,
-    * because that is done against the unreduced input geometry,
-    * which may give an invalid result due to topology collapse.
-    *
-    * The labeling is propagated to other connected linear edges,
-    * since there may be NOT_PART edges which are connected,
-    * and they can be labeled in the same way.
-    * (These would get labeled anyway during subsequent disconnected labeling pass,
-    * but may be more efficient and accurate to do it here.)
-    */
-    void labelCollapsedEdges();
-    static void labelCollapsedEdge(OverlayEdge* edge, uint8_t geomIndex);
-
-    /**
-    * There can be edges which have unknown location
-    * but are connected to a Line edge with known location.
-    * In this case line location is propagated to the connected edges.
-    */
-    void labelConnectedLinearEdges();
-    void propagateLinearLocations(uint8_t geomIndex);
-    static void propagateLinearLocationAtNode(OverlayEdge* eNode, uint8_t geomIndex, bool isInputLine, std::deque<OverlayEdge*>& edgeStack);
-
-    /**
-    * Finds all OverlayEdges which are linear
-    * (i.e. line or collapsed) and have a known location
-    * for the given input geometry.
-    */
-    static std::vector<OverlayEdge*> findLinearEdgesWithLocation(const std::vector<OverlayEdge *> &edges, uint8_t geomIndex);
-
-    /**
-    * At this point there may still be edges which have unknown location
-    * relative to an input geometry.
-    * This must be because they are NOT_PART edges for that geometry,
-    * and are disconnected from any edges of that geometry.
-    * An example of this is rings of one geometry wholly contained
-    * in another geometry.
-    * The location must be fully determined to compute a
-    * correct result for all overlay operations.
-    *
-    * If the input geometry is an Area the edge location can
-    * be determined via a PIP test.
-    * If the input is not an Area the location is EXTERIOR.
-    */
-    void labelDisconnectedEdges();
-
-    /**
-    * Determines the location of an edge relative to a target input geometry.
-    * The edge has no location information
-    * because it is disconnected from other
-    * edges that would provide that information.
-    * The location is determined by checking
-    * if the edge lies inside the target geometry area (if any).
-    */
-    void labelDisconnectedEdge(OverlayEdge* edge, uint8_t geomIndex);
-
-    /**
-    * Determines the {@link Location} for an edge within an Area geometry
-    * via point-in-polygon location.
-    *
-    * NOTE this is only safe to use for disconnected edges,
-    * since the test is carried out against the original input geometry,
-    * and precision reduction may cause incorrect results for edges
-    * which are close enough to a boundary to become connected.
-    */
-    geom::Location locateEdge(uint8_t geomIndex, OverlayEdge* edge);
-
-    /**
-    * Determines the {@link Location} for an edge within an Area geometry
-    * via point-in-polygon location,
-    * by checking that both endpoints are interior to the target geometry.
-    * Checking both endpoints ensures correct results in the presence of topology collapse.
-    * <p>
-    * NOTE this is only safe to use for disconnected edges,
-    * since the test is carried out against the original input geometry,
-    * and precision reduction may cause incorrect results for edges
-    * which are close enough to a boundary to become connected.
-    */
-    geom::Location locateEdgeBothEnds(uint8_t geomIndex, OverlayEdge* edge);
-
-    /**
-    * Labels edges around nodes based on the arrangement
-    * of incident area boundary edges.
-    * Also propagates the labelling to connected linear edges.
-    */
-    void labelAreaNodeEdges(std::vector<OverlayEdge*>& nodes);
-
-
-
-public:
-
-    OverlayLabeller(OverlayGraph* p_graph, InputGeometry* p_inputGeometry)
-        : graph(p_graph)
-        , inputGeometry(p_inputGeometry)
-        , edges(p_graph->getEdges())
-    {}
-
-    /**
-    * Computes the topological labelling for the edges in the graph->
-    */
-    void computeLabelling();
-
-    /**
-    * Scans around a node CCW, propagating the side labels
-    * for a given area geometry to all edges (and their sym)
-    * with unknown locations for that geometry.
-    */
-    void propagateAreaLocations(OverlayEdge* nodeEdge, uint8_t geomIndex);
-
-    void markResultAreaEdges(int overlayOpCode);
-
-    /**
-    * Marks an edge which forms part of the boundary of the result area.
-    * This is determined by the overlay operation being executed,
-    * and the location of the edge.
-    * The relevant location is either the right side of a boundary edge,
-    * or the line location of a non-boundary edge.
-    */
-    static void markInResultArea(OverlayEdge* e, int overlayOpCode);
-
-    /**
-    * Unmarks result area edges where the sym edge
-    * is also marked as in the result.
-    * This has the effect of merging edge-adjacent result areas,
-    * as required by polygon validity rules.
-    */
-    void unmarkDuplicateEdgesFromResultArea();
-
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos
-