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

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/relateng/RelatePredicate.h

@@ -1,652 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (c) 2024 Martin Davis
- * Copyright (C) 2024 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/Location.h>
-#include <geos/operation/relateng/BasicPredicate.h>
-#include <geos/operation/relateng/IMPatternMatcher.h>
-#include <geos/operation/relateng/IMPredicate.h>
-#include <geos/operation/relateng/RelateGeometry.h>
-#include <geos/geom/Envelope.h>
-#include <geos/export.h>
-
-
-using geos::geom::Envelope;
-using geos::geom::Location;
-
-
-namespace geos {      // geos.
-namespace operation { // geos.operation.
-namespace relateng {  // geos.operation.relateng
-
-
-class GEOS_DLL RelatePredicate {
-
-public:
-
-/************************************************************************
- *
- * Creates a predicate to determine whether two geometries intersect.
- *
- * The intersects predicate has the following equivalent definitions:
- *
- *  * The two geometries have at least one point in common
- *  * The DE-9IM Intersection Matrix for the two geometries matches
- *    at least one of the patterns
- *
- *    [T********]
- *    [*T*******]
- *    [***T*****]
- *    [****T****]
- *
- *  disjoint() = false
- *  (intersects is the inverse of disjoint)
- *
- * @return the predicate instance
- *
- * @see disjoint()
- */
-class IntersectsPredicate : public BasicPredicate {
-
-public:
-
-    std::string name() const override {
-        return std::string("intersects");
-    }
-
-    bool requireSelfNoding() const override {
-        //-- self-noding is not required to check for a simple interaction
-        return false;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        (void)isSourceA;
-        //-- intersects only requires testing interaction
-        return false;
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        require(envA.intersects(envB));
-    }
-
-    void updateDimension(Location locA, Location locB, int dimension) override {
-        (void)dimension;
-        setValueIf(true, isIntersection(locA, locB));
-    }
-
-    void finish() override {
-        //-- if no intersecting locations were found
-        setValue(false);
-    }
-
-};
-
-static std::unique_ptr<BasicPredicate> intersects();
-
-/************************************************************************
- *
- * Creates a predicate to determine whether two geometries are disjoint.
- *
- * The disjoint predicate has the following equivalent definitions:
- *
- *   * The two geometries have no point in common
- *   * The DE-9IM Intersection Matrix for the two geometries matches
- *        [FF*FF****]
- *   * intersects() = false
- *     (disjoint is the inverse of intersects)
- *
- * @return the predicate instance
- *
- * @see intersects()
- */
-class DisjointPredicate : public BasicPredicate {
-
-    std::string name() const override {
-        return std::string("disjoint");
-    }
-
-    bool requireSelfNoding() const override {
-        //-- self-noding is not required to check for a simple interaction
-        return false;
-    }
-
-    bool requireInteraction() const override {
-        //-- ensure entire matrix is computed
-        return false;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        (void)isSourceA;
-        //-- intersects only requires testing interaction
-        return false;
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        setValueIf(true, envA.disjoint(envB));
-    }
-
-    void updateDimension(Location locA, Location locB, int dimension) override {
-        (void)dimension;
-        setValueIf(false, isIntersection(locA, locB));
-    }
-
-    void finish() override {
-        //-- if no intersecting locations were found
-        setValue(true);
-    }
-};
-
-static std::unique_ptr<BasicPredicate> disjoint();
-
-/************************************************************************
- * Creates a predicate to determine whether a geometry contains another geometry.
- *
- * The contains predicate has the following equivalent definitions:
- *
- *   * Every point of the other geometry is a point of this geometry,
- *     and the interiors of the two geometries have at least one point in common.
- *   * The DE-9IM Intersection Matrix for the two geometries matches
- *     the pattern
- *       [T*****FF*]
- *   * within(B, A) = true
- *     (contains is the converse of within)
- *
- * An implication of the definition is that "Geometries do not
- * contain their boundary".  In other words, if a geometry A is a subset of
- * the points in the boundary of a geometry B, B.contains(A) = false.
- * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
- * For a predicate with similar behavior but avoiding
- * this subtle limitation, see covers().
- *
- * @return the predicate instance
- *
- * @see within()
- */
-class ContainsPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("contains");
-    }
-
-    bool requireCovers(bool isSourceA) override {
-        return isSourceA == RelateGeometry::GEOM_A;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        //-- only need to check B against Exterior of A
-        return isSourceA == RelateGeometry::GEOM_B;
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        require(isDimsCompatibleWithCovers(dimA, dimB));
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        BasicPredicate::requireCovers(envA, envB);
-    }
-
-    bool isDetermined() const override {
-        return intersectsExteriorOf(RelateGeometry::GEOM_A);
-    }
-
-    bool valueIM() override {
-        return intMatrix.isContains();
-    }
-};
-
-static std::unique_ptr<IMPredicate> contains();
-
-
-
-/************************************************************************
- * Creates a predicate to determine whether a geometry is within another geometry.
- *
- * The within predicate has the following equivalent definitions:
- *
- *   * Every point of this geometry is a point of the other geometry,
- *     and the interiors of the two geometries have at least one point in common.
- *   * The DE-9IM Intersection Matrix for the two geometries matches
- *     [T*F**F***]
- *   *  contains(B, A) = true
- *      (within is the converse of  contains())
- *
- * An implication of the definition is that
- * "The boundary of a Geometry is not within the Geometry".
- * In other words, if a geometry A is a subset of
- * the points in the boundary of a geometry B, within(B, A) = false
- * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
- * For a predicate with similar behavior but avoiding
- * this subtle limitation, see coveredimBy().
- *
- * @return the predicate instance
- *
- * @see #contains()
- */
-class WithinPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("within");
-    }
-
-    bool requireCovers(bool isSourceA) override {
-        return isSourceA == RelateGeometry::GEOM_B;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        //-- only need to check B against Exterior of A
-        return isSourceA == RelateGeometry::GEOM_A;
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        require(isDimsCompatibleWithCovers(dimB, dimA));
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        BasicPredicate::requireCovers(envB, envA);
-    }
-
-    bool isDetermined() const override {
-        return intersectsExteriorOf(RelateGeometry::GEOM_B);
-    }
-
-    bool valueIM() override {
-        return intMatrix.isWithin();
-    }
-};
-
-static std::unique_ptr<IMPredicate> within();
-
-
-
-/************************************************************************
- * Creates a predicate to determine whether a geometry covers another geometry.
- *
- * The covers predicate has the following equivalent definitions:
- *
- * Every point of the other geometry is a point of this geometry.
- * The DE-9IM Intersection Matrix for the two geometries matches
- * at least one of the following patterns:
- *
- *  * [T*****FF*]
- *  * [*T****FF*]
- *  * [***T**FF*]
- *  * [****T*FF*]
- *
- * coveredimBy(b, a) = true
- * (covers is the converse of coveredimBy())
- *
- * If either geometry is empty, the value of this predicate is false.
- *
- * This predicate is similar to contains(),
- * but is more inclusive (i.e. returns true for more cases).
- * In particular, unlike contains it does not distinguish between
- * points in the boundary and in the interior of geometries.
- * For most cases, covers should be used in preference to contains.
- * As an added benefit, covers is more amenable to optimization,
- * and hence should be more performant.
- *
- * @return the predicate instance
- *
- * @see #coveredimBy()
- */
-class CoversPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("covers");
-    }
-
-    bool requireCovers(bool isSourceA) override {
-        return isSourceA == RelateGeometry::GEOM_A;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        //-- only need to check B against Exterior of A
-        return isSourceA == RelateGeometry::GEOM_B;
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        require(isDimsCompatibleWithCovers(dimA, dimB));
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        BasicPredicate::requireCovers(envA, envB);
-
-    }
-
-    bool isDetermined() const override {
-        return intersectsExteriorOf(RelateGeometry::GEOM_A);
-    }
-
-    bool valueIM() override {
-        return intMatrix.isCovers();
-    }
-};
-
-static std::unique_ptr<IMPredicate> covers();
-
-
-/************************************************************************
-* Creates a predicate to determine whether a geometry is covered
-* by another geometry.
-*
-* The coveredimBy predicate has the following equivalent definitions:
-*
-* Every point of this geometry is a point of the other geometry.
-* The DE-9IM Intersection Matrix for the two geometries matches
-* at least one of the following patterns:
-*
-*   [T*F**F***]
-*   [*TF**F***]
-*   [**FT*F***]
-*   [**F*TF***]
-*
-* covers(B, A) = true
-* (coveredimBy is the converse of covers())
-*
-* If either geometry is empty, the value of this predicate is false.
-*
-* This predicate is similar to within(),
-* but is more inclusive (i.e. returns true for more cases).
-*
-* @return the predicate instance
-*
-* @see #covers()
-*/
-class CoveredByPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("coveredBy");
-    }
-
-    bool requireCovers(bool isSourceA) override {
-        return isSourceA == RelateGeometry::GEOM_B;
-    }
-
-    bool requireExteriorCheck(bool isSourceA) const override {
-        //-- only need to check B against Exterior of A
-        return isSourceA == RelateGeometry::GEOM_A;
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        require(isDimsCompatibleWithCovers(dimB, dimA));
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        BasicPredicate::requireCovers(envB, envA);
-    }
-
-    bool isDetermined() const override {
-        return intersectsExteriorOf(RelateGeometry::GEOM_B);
-    }
-
-    bool valueIM() override {
-        return intMatrix.isCoveredBy();
-    }
-
-};
-
-static std::unique_ptr<IMPredicate> coveredBy();
-
-
-/************************************************************************
-* Creates a predicate to determine whether a geometry crosses another geometry.
-*
-* The crosses predicate has the following equivalent definitions:
-*
-* The geometries have some but not all interior points in common.
-* The DE-9IM Intersection Matrix for the two geometries matches
-* one of the following patterns:
-*
-*    [T*T******] (for P/L, P/A, and L/A cases)
-*    [T*****T**] (for L/P, A/P, and A/L cases)
-*    [0********] (for L/L cases)
-*
-*
-* For the A/A and P/P cases this predicate returns false.
-*
-* The SFS defined this predicate only for P/L, P/A, L/L, and L/A cases.
-* To make the relation symmetric
-* JTS extends the definition to apply to L/P, A/P and A/L cases as well.
-*
-* @return the predicate instance
-*/
-
-class CrossesPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("crosses");
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        bool isBothPointsOrAreas =
-            (dimA == Dimension::P && dimB == Dimension::P) ||
-            (dimA == Dimension::A && dimB == Dimension::A);
-        require(!isBothPointsOrAreas);
-    }
-
-    bool isDetermined() const override {
-        if (dimA == Dimension::L && dimB == Dimension::L) {
-            //-- L/L interaction can only be dim = P
-            if (getDimension(Location::INTERIOR, Location::INTERIOR) > Dimension::P)
-                return true;
-        }
-        else if (dimA < dimB) {
-            if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
-                isIntersects(Location::INTERIOR, Location::EXTERIOR)) {
-                return true;
-            }
-        }
-        else if (dimA > dimB) {
-            if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
-                isIntersects(Location::EXTERIOR, Location::INTERIOR)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool valueIM() override {
-        return intMatrix.isCrosses(dimA, dimB);
-    }
-};
-
-static std::unique_ptr<IMPredicate> crosses();
-
-
-/************************************************************************
-* Creates a predicate to determine whether two geometries are
-* topologically equal.
-*
-* The equals predicate has the following equivalent definitions:
-*
-* The two geometries have at least one point in common,
-* and no point of either geometry lies in the exterior of the other geometry.
-* The DE-9IM Intersection Matrix for the two geometries matches
-* the pattern T*F**FFF*
-*
-* @return the predicate instance
-*/
-class EqualsTopoPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("equals");
-    }
-
-    bool requireInteraction() const override {
-        //-- allow EMPTY = EMPTY
-        return false;
-    };
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        //-- don't require equal dims, because EMPTY = EMPTY for all dims
-    }
-
-    void init(const Envelope& envA, const Envelope& envB) override {
-        //-- handle EMPTY = EMPTY cases
-        setValueIf(true, envA.isNull() && envB.isNull());
-
-        require(envA.equals(&envB));
-    }
-
-    bool isDetermined() const override {
-        bool isEitherExteriorIntersects =
-            isIntersects(Location::INTERIOR, Location::EXTERIOR) ||
-            isIntersects(Location::BOUNDARY, Location::EXTERIOR) ||
-            isIntersects(Location::EXTERIOR, Location::INTERIOR) ||
-            isIntersects(Location::EXTERIOR, Location::BOUNDARY);
-
-        return isEitherExteriorIntersects;
-    }
-
-    bool valueIM() override {
-        return intMatrix.isEquals(dimA, dimB);
-    }
-
-};
-
-static std::unique_ptr<IMPredicate> equalsTopo();
-
-
-/************************************************************************
- * Creates a predicate to determine whether a geometry overlaps another geometry.
- *
- * The overlaps predicate has the following equivalent definitions:
- *
- * The geometries have at least one point each not shared by the other
- *     (or equivalently neither covers the other),
- *     they have the same dimension,
- *     and the intersection of the interiors of the two geometries has
- *     the same dimension as the geometries themselves.
- * The DE-9IM Intersection Matrix for the two geometries matches
- *     [T*T***T**] (for P/P and A/A cases)
- *     or [1*T***T**] (for L/L cases)
- *
- * If the geometries are of different dimension this predicate returns false.
- * This predicate is symmetric.
- *
- * @return the predicate instance
- */
-class OverlapsPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("overlaps");
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        require(dimA == dimB);
-    }
-
-    bool isDetermined() const override {
-        if (dimA == Dimension::A || dimA == Dimension::P) {
-            if (isIntersects(Location::INTERIOR, Location::INTERIOR) &&
-                isIntersects(Location::INTERIOR, Location::EXTERIOR) &&
-                isIntersects(Location::EXTERIOR, Location::INTERIOR))
-            return true;
-        }
-        if (dimA == Dimension::L) {
-            if (isDimension(Location::INTERIOR, Location::INTERIOR, Dimension::L) &&
-                isIntersects(Location::INTERIOR, Location::EXTERIOR) &&
-                isIntersects(Location::EXTERIOR, Location::INTERIOR))
-            return true;
-        }
-        return false;
-    }
-
-    bool valueIM() override {
-        return intMatrix.isOverlaps(dimA, dimB);
-    }
-};
-
-static std::unique_ptr<IMPredicate> overlaps();
-
-
-
-
-
-/************************************************************************
-* Creates a predicate to determine whether a geometry touches another geometry.
-*
-* The touches predicate has the following equivalent definitions:
-*
-* The geometries have at least one point in common,
-* but their interiors do not intersect.
-* The DE-9IM Intersection Matrix for the two geometries matches
-* at least one of the following patterns
-*
-*   [FT*******]
-*   [F**T*****]
-*   [F***T****]
-*
-*
-* If both geometries have dimension 0, the predicate returns false,
-* since points have only interiors.
-* This predicate is symmetric.
-*
-* @return the predicate instance
-*/
-class TouchesPredicate : public IMPredicate {
-
-    std::string name() const override {
-        return std::string("touches");
-    }
-
-    void init(int _dimA, int _dimB) override {
-        IMPredicate::init(_dimA, _dimB);
-        bool isBothPoints = (dimA == 0 && dimB == 0);
-        require(! isBothPoints);
-    }
-
-    bool isDetermined() const override {
-        bool isInteriorsIntersects = isIntersects(Location::INTERIOR, Location::INTERIOR);
-        return isInteriorsIntersects;
-    }
-
-    bool valueIM() override {
-        return intMatrix.isTouches(dimA, dimB);
-    }
-};
-
-static std::unique_ptr<IMPredicate> touches();
-
-/**
- * Creates a predicate that matches a DE-9IM matrix pattern.
- *
- * @param imPattern the pattern to match
- * @return a predicate that matches the pattern
- *
- * @see IntersectionMatrixPattern
- */
-static std::unique_ptr<TopologyPredicate> matches(const std::string& imPattern)
-{
-    return std::unique_ptr<TopologyPredicate>(new IMPatternMatcher(imPattern));
-}
-
-
-
-}; // !RelatePredicate
-
-
-} // namespace geos.operation.relateng
-} // namespace geos.operation
-} // namespace geos
-