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

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

@@ -0,0 +1,260 @@
+/**********************************************************************
+ *
+ * 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/PreparedGeometry.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <string>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+    namespace geom {
+        class Geometry;
+        class Coordinate;
+        class CoordinateSequence;
+        class IntersectionMatrix;
+    }
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \class PreparedGeometry
+ *
+ * \brief
+ * An interface for classes which prepare {@link Geometry}s
+ * in order to optimize the performance
+ * of repeated calls to specific geometric operations.
+ *
+ * A given implementation may provide optimized implementations
+ * for only some of the specified methods,
+ * and delegate the remaining methods to the original {@link Geometry} operations.
+ * An implementation may also only optimize certain situations,
+ * and delegate others.
+ * See the implementing classes for documentation about which methods and situations
+ * they optimize.
+ *
+ */
+class GEOS_DLL PreparedGeometry {
+public:
+    virtual
+    ~PreparedGeometry() {}
+
+    /** \brief
+     * Gets the original {@link Geometry} which has been prepared.
+     *
+     * @return the base geometry
+     */
+    virtual const geom::Geometry& getGeometry() const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} contains a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry contains the given Geometry
+     *
+     * @see Geometry#contains(Geometry)
+     */
+    virtual bool contains(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} properly contains
+     * a given geometry.
+     *
+     * The <code>containsProperly</code> predicate has the following
+     * equivalent definitions:
+     *
+     * - Every point of the other geometry is a point of this
+     *   geometry's interior.
+     * - The DE-9IM Intersection Matrix for the two geometries matches
+     *   <code>[T**FF*FF*]</code>
+     *
+     * In other words, if the test geometry has any interaction with
+     * the boundary of the target
+     * geometry the result of <tt>containsProperly</tt> is <tt>false</tt>.
+     * This is different semantics to the {@link Geometry::contains}
+     * predicate, in which test geometries can intersect the target's
+     * boundary and still be contained.
+     *
+     * The advantage of using this predicate is that it can be computed
+     * efficiently, since it avoids the need to compute the full
+     * topological relationship of the input boundaries in cases where
+     * they intersect.
+     *
+     * An example use case is computing the intersections
+     * of a set of geometries with a large polygonal geometry.
+     * Since <tt>intersection</tt> is a fairly slow operation, it can
+     * be more efficient
+     * to use <tt>containsProperly</tt> to filter out test geometries
+     * which lie
+     * wholly inside the area.  In these cases the intersection is
+     * known <i>a priori</i> to be exactly the original test geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry properly contains the given Geometry
+     *
+     * @see Geometry::contains
+     *
+     */
+    virtual bool containsProperly(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is covered by a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is covered by the given Geometry
+     *
+     * @see Geometry#coveredBy(Geometry)
+     */
+    virtual bool coveredBy(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} covers a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry covers the given Geometry
+     *
+     * @see Geometry#covers(Geometry)
+     */
+    virtual bool covers(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} crosses a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry crosses the given Geometry
+     *
+     * @see Geometry#crosses(Geometry)
+     */
+    virtual bool crosses(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is disjoint from a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is disjoint from the given Geometry
+     *
+     * @see Geometry#disjoint(Geometry)
+     */
+    virtual bool disjoint(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} intersects a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry intersects the given Geometry
+     *
+     * @see Geometry#intersects(Geometry)
+     */
+    virtual bool intersects(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} overlaps a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry overlaps the given Geometry
+     *
+     * @see Geometry#overlaps(Geometry)
+     */
+    virtual bool overlaps(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} touches a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry touches the given Geometry
+     *
+     * @see Geometry#touches(Geometry)
+     */
+    virtual bool touches(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is within a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is within the given Geometry
+     *
+     * @see Geometry#within(Geometry)
+     */
+    virtual bool within(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compute the nearest locations on the base {@link Geometry} and
+     * the given geometry.
+     *
+     * @param geom the Geometry to compute the nearest point to
+     * @return true the nearest points
+     *
+     */
+    virtual std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compute the minimum distance between the base {@link Geometry} and
+     * the given geometry.
+     *
+     * @param geom the Geometry to compute the distance to
+     * @return the minimum distance between the two geometries
+     *
+     */
+    virtual double distance(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is within a given
+     * distance from the given geometry.
+     *
+     * @param geom the Geometry to test the distance to
+     * @param dist the distance value to compare
+     * @return true if this Geometry is within the given distance from
+     * the given Geometry.
+     *
+     */
+    virtual bool isWithinDistance(const geom::Geometry* geom, double dist) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and returns the DE9IM intersection matrix as a string.
+     *
+     * @param geom the Geometry to test the
+     * @return the DE9IM matrix
+     */
+    virtual std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and the provided DE9IM pattern, and returns true if the
+     * pattern is consistent with the relationship between the
+     * prepared and provided geometries.
+     *
+     * @param geom the Geometry to test the distance to
+     * @param pat the DE9IM pattern
+     * @return true if the patterns are consistent
+     */
+    virtual bool relate(const geom::Geometry* geom, const std::string& pat) const = 0;
+
+};
+
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,93 @@
+/**********************************************************************
+ *
+ * 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/PreparedGeometryFactory.java rev. 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/prep/PreparedGeometry.h>
+
+#include <memory>
+
+namespace geos {
+namespace geom {
+namespace prep {
+class PreparedGeometry;
+}
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+
+/**
+ * \brief
+ * A factory for creating {@link PreparedGeometry}s.
+ *
+ * It chooses an appropriate implementation of PreparedGeometry
+ * based on the geoemtric type of the input geometry.
+ * In the future, the factory may accept hints that indicate
+ * special optimizations which can be performed.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL PreparedGeometryFactory {
+public:
+
+    /**
+     * Creates a new {@link PreparedGeometry} appropriate for the argument {@link Geometry}.
+     *
+     * @param geom the geometry to prepare
+     * @return the prepared geometry
+     */
+    static std::unique_ptr<PreparedGeometry>
+    prepare(const geom::Geometry* geom)
+    {
+        PreparedGeometryFactory pf;
+        return pf.create(geom);
+    }
+
+    /**
+     * Destroys {@link PreparedGeometry} allocated with the factory.
+     *
+     * @param geom to be deallocated
+     */
+    static void
+    destroy(const PreparedGeometry* geom)
+    {
+        delete geom;
+    }
+
+    /**
+     * Creates a new {@link PreparedGeometry} appropriate for the argument {@link Geometry}.
+     *
+     * @param geom the geometry to prepare
+     * @return the prepared geometry
+     */
+    std::unique_ptr<PreparedGeometry> create(const geom::Geometry* geom) const;
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,70 @@
+/**********************************************************************
+ *
+ * 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/PreparedLineString.java rev 1.3 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/BasicPreparedGeometry.h> // for inheritance
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/FastSegmentSetIntersectionFinder.h>
+#include <geos/operation/distance/IndexedFacetDistance.h>
+
+#include <memory>
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A prepared version of {@link LinearRing}, {@link LineString} or {@link MultiLineString} geometries.
+ *
+ * @author mbdavis
+ *
+ */
+class PreparedLineString : public BasicPreparedGeometry {
+private:
+    std::unique_ptr<noding::FastSegmentSetIntersectionFinder> segIntFinder;
+    mutable noding::SegmentString::ConstVect segStrings;
+    mutable std::unique_ptr<operation::distance::IndexedFacetDistance> indexedDistance;
+
+protected:
+public:
+    PreparedLineString(const Geometry* geom)
+        :
+        BasicPreparedGeometry(geom),
+        segIntFinder(nullptr)
+    { }
+
+    ~PreparedLineString() override;
+
+    noding::FastSegmentSetIntersectionFinder* getIntersectionFinder();
+
+    bool intersects(const geom::Geometry* g) const override;
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const override;
+    double distance(const geom::Geometry* g) const override;
+    bool isWithinDistance(const geom::Geometry* g, double d) const override;
+    operation::distance::IndexedFacetDistance* getIndexedFacetDistance() const;
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,57 @@
+/**********************************************************************
+ *
+ * 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
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+class PreparedLineString;
+
+class PreparedLineStringDistance {
+public:
+
+    static double distance(const PreparedLineString& prep, const geom::Geometry* geom)
+    {
+        PreparedLineStringDistance op(prep);
+        return op.distance(geom);
+    }
+
+    PreparedLineStringDistance(const PreparedLineString& prep)
+        : prepLine(prep)
+    { }
+
+    double distance(const geom::Geometry* g) const;
+
+    bool isWithinDistance(const geom::Geometry* g, double d) const;
+
+protected:
+
+    const PreparedLineString& prepLine;
+
+    // Declare type as noncopyable
+    PreparedLineStringDistance(const PreparedLineStringDistance& other) = delete;
+    PreparedLineStringDistance& operator=(const PreparedLineStringDistance& rhs) = delete;
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,97 @@
+/**********************************************************************
+ *
+ * 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/PreparedLineStringIntersects.java r338 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedLineString.h>
+#include <geos/algorithm/PointLocator.h>
+#include <geos/geom/util/ComponentCoordinateExtracter.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/noding/SegmentStringUtil.h>
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>intersects</tt> spatial relationship predicate
+ * for a target {@link PreparedLineString} relative to all other
+ * {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedLineStringIntersects {
+public:
+
+    /**
+     * Computes the intersects predicate between a {@link PreparedLineString}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared linestring
+     * @param geom a test geometry
+     * @return true if the linestring intersects the geometry
+     */
+    static bool
+    intersects(PreparedLineString& prep, const geom::Geometry* geom)
+    {
+        PreparedLineStringIntersects op(prep);
+        return op.intersects(geom);
+    }
+
+    /**
+     * \todo FIXME - mloskot: Why not taking linestring through const reference?
+     */
+    PreparedLineStringIntersects(PreparedLineString& prep)
+        : prepLine(prep)
+    { }
+
+    /**
+     * Tests whether this geometry intersects a given geometry.
+     *
+     * @param g the test geometry
+     * @return true if the test geometry intersects
+     */
+    bool intersects(const geom::Geometry* g) const;
+
+protected:
+    PreparedLineString& prepLine;
+
+    /**
+     * Tests whether any representative point of the test Geometry intersects
+     * the target geometry.
+     * Only handles test geometries which are Puntal (dimension 0)
+     *
+     * @param testGeom a Puntal geometry to test
+     * @return true if any point of the argument intersects the prepared geometry
+     */
+    bool isAnyTestPointInTarget(const geom::Geometry* testGeom) const;
+
+    // Declare type as noncopyable
+    PreparedLineStringIntersects(const PreparedLineStringIntersects& other) = delete;
+    PreparedLineStringIntersects& operator=(const PreparedLineStringIntersects& rhs) = delete;
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,54 @@
+/**********************************************************************
+ *
+ * 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
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+class PreparedLineStringNearestPoints {
+public:
+
+    static std::unique_ptr<geom::CoordinateSequence>
+    nearestPoints(const PreparedLineString& prep, const geom::Geometry* geom)
+    {
+        PreparedLineStringNearestPoints op(prep);
+        return op.nearestPoints(geom);
+    }
+
+    PreparedLineStringNearestPoints(const PreparedLineString& prep)
+        : prepLine(prep)
+    { }
+
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const;
+
+protected:
+
+    const PreparedLineString& prepLine;
+
+    // Declare type as noncopyable
+    PreparedLineStringNearestPoints(const PreparedLineStringNearestPoints& other) = delete;
+    PreparedLineStringNearestPoints& operator=(const PreparedLineStringNearestPoints& rhs) = delete;
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

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

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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/PreparedPoint.java rev. 1.2 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/BasicPreparedGeometry.h> // for inheritance
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A prepared version of {@link Point} or {@link MultiPoint} geometries.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedPoint: public BasicPreparedGeometry {
+private:
+protected:
+public:
+    PreparedPoint(const Geometry* geom)
+        : BasicPreparedGeometry(geom)
+    { }
+
+    /**
+     * Tests whether this point intersects a {@link Geometry}.
+     *
+     * The optimization here is that computing topology for the test
+     * geometry is avoided. This can be significant for large geometries.
+     */
+    bool intersects(const geom::Geometry* g) const override;
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+