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

package/dist/prebuilt/Android-x86_64/include/geos/operation/relateng/RelatePredicate.h

@@ -0,0 +1,652 @@
+/**********************************************************************
+ *
+ * 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
+