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

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygon.h

@@ -0,0 +1,81 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygon.java rev 1.7 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/BasicPreparedGeometry.h> // for inheritance
+#include <geos/noding/SegmentString.h>
+#include <geos/operation/distance/IndexedFacetDistance.h>
+
+#include <memory>
+
+namespace geos {
+namespace noding {
+class FastSegmentSetIntersectionFinder;
+}
+namespace algorithm {
+namespace locate {
+class PointOnGeometryLocator;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A prepared version of {@link Polygon} or {@link MultiPolygon} geometries.
+ *
+ * @author mbdavis
+ *
+ */
+class PreparedPolygon : public BasicPreparedGeometry {
+private:
+    bool isRectangle;
+    mutable std::unique_ptr<noding::FastSegmentSetIntersectionFinder> segIntFinder;
+    mutable std::unique_ptr<algorithm::locate::PointOnGeometryLocator> ptOnGeomLoc;
+    mutable std::unique_ptr<algorithm::locate::PointOnGeometryLocator> indexedPtOnGeomLoc;
+    mutable noding::SegmentString::ConstVect segStrings;
+    mutable std::unique_ptr<operation::distance::IndexedFacetDistance> indexedDistance;
+
+protected:
+public:
+    PreparedPolygon(const geom::Geometry* geom);
+    ~PreparedPolygon() override;
+
+    noding::FastSegmentSetIntersectionFinder* getIntersectionFinder() const;
+    algorithm::locate::PointOnGeometryLocator* getPointLocator() const;
+    operation::distance::IndexedFacetDistance* getIndexedFacetDistance() const;
+
+    bool contains(const geom::Geometry* g) const override;
+    bool containsProperly(const geom::Geometry* g) const override;
+    bool covers(const geom::Geometry* g) const override;
+    bool intersects(const geom::Geometry* g) const override;
+    double distance(const geom::Geometry* g) const override;
+    bool isWithinDistance(const geom::Geometry* g, double d) const override;
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonContains.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygonContains.java rev 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/AbstractPreparedPolygonContains.h> // inherited
+
+// forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>contains</tt> spatial relationship predicate
+ * for a {@link PreparedPolygon} relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * It is not possible to short-circuit in all cases, in particular
+ * in the case where the test geometry touches the polygon linework.
+ * In this case full topology must be computed.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedPolygonContains : public AbstractPreparedPolygonContains {
+public:
+
+    /**
+     * Creates an instance of this operation.
+     *
+     * @param prepPoly the PreparedPolygon to evaluate
+     */
+    PreparedPolygonContains(const PreparedPolygon* const prepPoly);
+
+    /**
+     * Tests whether this PreparedPolygon <tt>contains</tt> a given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry is contained
+     */
+    bool
+    contains(const geom::Geometry* geom)
+    {
+        return eval(geom);
+    }
+
+    /**
+     * Computes the <tt>contains</tt> predicate between a {@link PreparedPolygon}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared polygon
+     * @param geom a test geometry
+     * @return true if the polygon contains the geometry
+     */
+    static bool
+    contains(const PreparedPolygon* const prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonContains polyInt(prep);
+        return polyInt.contains(geom);
+    }
+
+protected:
+    /**
+     * Computes the full topological <tt>contains</tt> predicate.
+     * Used when short-circuit tests are not conclusive.
+     *
+     * @param geom the test geometry
+     * @return true if this prepared polygon contains the test geometry
+     */
+    bool fullTopologicalPredicate(const geom::Geometry* geom) override;
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonContainsProperly.h

@@ -0,0 +1,101 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygonContainsProperly.java rev 1.5 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedPolygonPredicate.h> // inherited
+
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>containsProperly</tt> spatial relationship predicate
+ * for {@link PreparedPolygon}s relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * A Geometry A <tt>containsProperly</tt> another Geometry B iff
+ * all points of B are contained in the Interior of A.
+ * Equivalently, B is contained in A AND B does not intersect
+ * the Boundary of A.
+ *
+ * The advantage to using this predicate is that it can be computed
+ * efficiently, with no need to compute topology at individual points.
+ * In a situation with many geometries intersecting the boundary
+ * of the target geometry, this can make a performance difference.
+ *
+ * @author Martin Davis
+ */
+class PreparedPolygonContainsProperly : public PreparedPolygonPredicate {
+private:
+protected:
+public:
+    /** \brief
+     * Computes the <tt>containsProperly</tt> predicate between a {@link PreparedPolygon}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared polygon
+     * @param geom a test geometry
+     * @return true if the polygon properly contains the geometry
+     */
+    static
+    bool
+    containsProperly(const PreparedPolygon* const prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonContainsProperly polyInt(prep);
+        return polyInt.containsProperly(geom);
+    }
+
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param prep the PreparedPolygon to evaluate
+     */
+    PreparedPolygonContainsProperly(const PreparedPolygon* const prep)
+        :	PreparedPolygonPredicate(prep)
+    { }
+
+    /** \brief
+     * Tests whether this PreparedPolygon containsProperly a given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry is contained properly
+     */
+    bool
+    containsProperly(const geom::Geometry* geom);
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonCovers.h

@@ -0,0 +1,108 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygonCovers.java rev 1.2 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/AbstractPreparedPolygonContains.h> // inherited
+
+// forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>covers</tt> spatial relationship predicate
+ * for a {@link PreparedPolygon} relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * It is not possible to short-circuit in all cases, in particular
+ * in the case where the test geometry touches the polygon linework.
+ * In this case full topology must be computed.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedPolygonCovers : public AbstractPreparedPolygonContains {
+private:
+protected:
+    /**
+     * Computes the full topological <tt>covers</tt> predicate.
+     * Used when short-circuit tests are not conclusive.
+     *
+     * @param geom the test geometry
+     * @return true if this prepared polygon covers the test geometry
+     */
+    bool fullTopologicalPredicate(const geom::Geometry* geom) override;
+
+public:
+    /** \brief
+     * Computes the <tt>covers</tt> predicate between a {@link PreparedPolygon}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared polygon
+     * @param geom a test geometry
+     * @return true if the polygon covers the geometry
+     */
+    static bool
+    covers(const PreparedPolygon* const prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonCovers polyInt(prep);
+        return polyInt.covers(geom);
+    }
+
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param prep the PreparedPolygon to evaluate
+     */
+    PreparedPolygonCovers(const PreparedPolygon* const prep)
+        :	AbstractPreparedPolygonContains(prep, false)
+    { }
+
+    /** \brief
+     * Tests whether this PreparedPolygon <tt>covers</tt> a given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry is covered
+     */
+    bool
+    covers(const Geometry* geom)
+    {
+        return eval(geom);
+    }
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonDistance.h

@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Sandro Santilli <strk@kbt.io>
+ *
+ * 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: ORIGINAL WORK
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedPolygonPredicate.h>
+
+// Forward declarations
+namespace geos {
+    namespace geom {
+        class Geometry;
+        namespace prep {
+            class PreparedPolygon;
+        }
+    }
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+class PreparedPolygon;
+
+class PreparedPolygonDistance : public PreparedPolygonPredicate {
+public:
+
+    static double distance(const PreparedPolygon& prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonDistance op(prep);
+        return op.distance(geom);
+    }
+
+    PreparedPolygonDistance(const PreparedPolygon& prep)
+        : PreparedPolygonPredicate(&prep)
+    { }
+
+    double distance(const geom::Geometry* g) const;
+
+    bool isWithinDistance(const geom::Geometry* g, double d) const;
+
+protected:
+
+    // Declare type as noncopyable
+    PreparedPolygonDistance(const PreparedPolygonDistance& other) = delete;
+    PreparedPolygonDistance& operator=(const PreparedPolygonDistance& rhs) = delete;
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonIntersects.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygonIntersects.java rev 1.6 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedPolygonPredicate.h> // inherited
+
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>intersects</tt> spatial relationship predicate
+ * for {@link PreparedPolygon}s relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedPolygonIntersects : public PreparedPolygonPredicate {
+private:
+protected:
+public:
+    /** \brief
+     * Computes the intersects predicate between a {@link PreparedPolygon}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared polygon
+     * @param geom a test geometry
+     * @return true if the polygon intersects the geometry
+     */
+    static bool
+    intersects(const PreparedPolygon* const prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonIntersects polyInt(prep);
+        return polyInt.intersects(geom);
+    }
+
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param prep the PreparedPolygon to evaluate
+     */
+    PreparedPolygonIntersects(const PreparedPolygon* const prep)
+        :	PreparedPolygonPredicate(prep)
+    { }
+
+    /** \brief
+     * Tests whether this PreparedPolygon intersects a given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry intersects
+     */
+    bool intersects(const geom::Geometry* geom);
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/PreparedPolygonPredicate.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: geom/prep/PreparedPolygonPredicate.java rev. 1.4 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Location.h>
+
+// forward declarations
+namespace geos {
+namespace algorithm {
+namespace locate {
+class PointOnGeometryLocator;
+}
+}
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+namespace noding {
+class FastSegmentSetIntersectionFinder;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A base class for predicate operations on {@link PreparedPolygon}s.
+ *
+ * @author mbdavis
+ *
+ */
+class PreparedPolygonPredicate {
+private:
+    // Declare type as noncopyable
+    PreparedPolygonPredicate(const PreparedPolygonPredicate& other) = delete;
+    PreparedPolygonPredicate& operator=(const PreparedPolygonPredicate& rhs) = delete;
+
+protected:
+    const PreparedPolygon* const prepPoly;
+
+    /** \brief
+     * Returns the outermost Location among a test point from each
+     * components of the test geometry.
+     *
+     * @param testGeom a geometry to test
+     * @return the outermost Location
+     */
+    geom::Location getOutermostTestComponentLocation(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether all components of the test Geometry
+     * are contained in the interior of the target geometry.
+     *
+     * Handles both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if all componenta of the argument are contained in
+     *              the target geometry interior
+     */
+    bool isAllTestComponentsInTargetInterior(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether any component of the test Geometry intersects
+     * the area of the target geometry.
+     *
+     * Handles test geometries with both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if any component of the argument intersects the
+     *              prepared geometry
+     */
+    bool isAnyTestComponentInTarget(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether any component of the test Geometry intersects
+     * the interior of the target geometry.
+     *
+     * Handles test geometries with both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if any component of the argument intersects the
+     *              prepared area geometry interior
+     */
+    bool isAnyTestComponentInTargetInterior(const geom::Geometry* testGeom) const;
+
+    /**
+     * Tests whether any component of the target geometry
+     * intersects the test geometry (which must be an areal geometry)
+     *
+     * @param testGeom the test geometry
+     * @param targetRepPts the representative points of the target geometry
+     * @return true if any component intersects the areal test geometry
+     */
+    bool isAnyTargetComponentInAreaTest(const geom::Geometry* testGeom,
+                                        const std::vector<const geom::CoordinateXY*>* targetRepPts) const;
+
+public:
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param p_prepPoly the PreparedPolygon to evaluate
+     */
+    PreparedPolygonPredicate(const PreparedPolygon* const p_prepPoly)
+        :	prepPoly(p_prepPoly)
+    { }
+
+    virtual
+    ~PreparedPolygonPredicate()
+    { }
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+