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

package/dist/prebuilt/Android-x86_64/include/geos/linearref/LinearLocation.h

@@ -0,0 +1,248 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: linearref/LinearLocation.java r463
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <string>
+#include <memory> // for std::unique_ptr
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/LineSegment.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+
+/** \brief
+ * Represents a location along a [LineString](@ref geom::LineString)
+ * or [MultiLineString](@ref geom::MultiLineString).
+ *
+ * The referenced geometry is not maintained within this location, but
+ * must be provided for operations which require it.
+ * Various methods are provided to manipulate the location value and
+ * query the geometry it references.
+ */
+class LinearLocation {
+private:
+    std::size_t componentIndex;
+    std::size_t segmentIndex;
+    double segmentFraction;
+
+    /** \brief
+     * Ensures the individual values are locally valid.
+     *
+     * Does **not** ensure that the indexes are valid for
+     * a particular linear geometry.
+     *
+     * @see clamp
+     */
+    void normalize();
+
+public:
+    /** \brief
+     * Gets a location which refers to the end of a linear
+     * [Geometry](@ref geom::Geometry).
+     *
+     * @param linear the linear geometry
+     * @return a new `LinearLocation`
+     */
+    static LinearLocation getEndLocation(const geom::Geometry* linear);
+
+    /** \brief
+     * Computes the [Coordinate](@ref geom::Coordinate) of a point a given
+     * fraction along the line segment `(p0, p1)`.
+     *
+     * If the fraction is greater than 1.0 the last
+     * point of the segment is returned.
+     * If the fraction is less than or equal to 0.0 the first point
+     * of the segment is returned.
+     * The Z ordinate is interpolated from the Z-ordinates of
+     * the given points, if they are specified.
+     *
+     * @param p0 the first point of the line segment
+     * @param p1 the last point of the line segment
+     * @param frac the length to the desired point
+     * @return the Coordinate of the desired point
+     */
+    static geom::Coordinate pointAlongSegmentByFraction(const geom::Coordinate& p0, const geom::Coordinate& p1,
+            double frac);
+
+
+    /** \brief
+     * Creates a location referring to the start of a linear geometry
+     */
+    LinearLocation(std::size_t segmentIndex = 0, double segmentFraction = 0.0);
+
+    LinearLocation(std::size_t componentIndex, std::size_t segmentIndex, double segmentFraction);
+
+    /** \brief
+     * Ensures the indexes are valid for a given linear [Geometry](@ref geom::Geometry).
+     *
+     * @param linear a linear geometry
+     */
+    void clamp(const geom::Geometry* linear);
+
+    /** \brief
+     * Snaps the value of this location to the nearest vertex on the given linear
+     * [Geometry](@ref geom::Geometry), if the vertex is closer than `minDistance`.
+     *
+     * @param linearGeom a linear geometry
+     * @param minDistance the minimum allowable distance to a vertex
+     */
+    void snapToVertex(const geom::Geometry* linearGeom, double minDistance);
+
+    /** \brief
+     * Gets the length of the segment in the given
+     * Geometry containing this location.
+     *
+     * @param linearGeom a linear geometry
+     * @return the length of the segment
+     */
+    double getSegmentLength(const geom::Geometry* linearGeom) const;
+
+    /** \brief
+     * Sets the value of this location to
+     * refer the end of a linear geometry.
+     *
+     * @param linear the linear geometry to set
+     */
+    void setToEnd(const geom::Geometry* linear);
+
+    /** \brief
+     * Gets the component index for this location.
+     *
+     * @return the component index
+     */
+    std::size_t getComponentIndex() const;
+
+    /** \brief
+     * Gets the segment index for this location.
+     *
+     * @return the segment index
+     */
+    std::size_t getSegmentIndex() const;
+
+    /** \brief
+     * Gets the segment fraction for this location.
+     *
+     * @return the segment fraction
+     */
+    double getSegmentFraction() const;
+
+    /** \brief
+     * Tests whether this location refers to a vertex.
+     *
+     * @return true if the location is a vertex
+     */
+    bool isVertex() const;
+
+    /** \brief
+     * Gets the [Coordinate](@ref geom::Coordinate) along the given linear
+     * [Geometry](@ref geom::Geometry) which is referenced by this location.
+     *
+     * @param linearGeom the linear geometry referenced by this location
+     * @return the Coordinate at the location
+     */
+    geom::Coordinate getCoordinate(const geom::Geometry* linearGeom) const;
+
+    /** \brief
+     * Gets a [LineSegment](@ref geom::LineSegment) representing the segment of the
+     * given linear [Geometry](@ref geom::Geometry) which contains this location.
+     *
+     * @param linearGeom a linear geometry
+     * @return the LineSegment containing the location
+     */
+    std::unique_ptr<geom::LineSegment> getSegment(const geom::Geometry* linearGeom) const;
+
+    /** \brief
+     * Tests whether this location refers to a valid
+     * location on the given linear [Geometry](@ref geom::Geometry).
+     *
+     * @param linearGeom a linear geometry
+     * @return true if this location is valid
+     */
+    bool isValid(const geom::Geometry* linearGeom) const;
+
+    /** \brief
+     * Compares this object with the specified object for order.
+     *
+     * @param  other the LinearLocation with which this Coordinate is being compared
+     * @return a negative integer, zero, or a positive integer as this
+     *         LinearLocation is less than, equal to, or greater than
+     *         the specified LinearLocation
+     */
+    int compareTo(const LinearLocation& other) const;
+
+    /** \brief
+     *  Compares this object with the specified index values for order.
+     *
+     * @param componentIndex1 a component index
+     * @param segmentIndex1 a segment index
+     * @param segmentFraction1 a segment fraction
+     * @return a negative integer, zero, or a positive integer as this LinearLocation
+     *         is less than, equal to, or greater than the specified locationValues
+     */
+    int compareLocationValues(std::size_t componentIndex1, std::size_t segmentIndex1, double segmentFraction1) const;
+
+    /** \brief
+     *  Compares two sets of location values for order.
+     *
+     * @param componentIndex0 a component index
+     * @param segmentIndex0 a segment index
+     * @param segmentFraction0 a segment fraction
+     * @param componentIndex1 another component index
+     * @param segmentIndex1 another segment index
+     * @param segmentFraction1 another segment fraction
+     * @return a negative integer, zero, or a positive integer
+     *         as the first set of location values
+     *         is less than, equal to, or greater than the second set of locationValues
+     */
+    static int compareLocationValues(
+        std::size_t componentIndex0, std::size_t segmentIndex0, double segmentFraction0,
+        std::size_t componentIndex1, std::size_t segmentIndex1, double segmentFraction1);
+
+    /** \brief
+     * Tests whether two locations are on the same
+     * segment in the parent [Geometry](@ref geom::Geometry).
+     *
+     * @param loc a location on the same geometry
+     * @return true if the locations are on the same segment of the parent geometry
+     */
+    bool isOnSameSegment(const LinearLocation& loc) const;
+
+    /**
+     * \brief
+     * Tests whether this location is an endpoint of
+     * the linear component it refers to.
+     *
+     * @param linearGeom the linear geometry referenced by this location
+     * @return true if the location is a component endpoint
+     */
+    bool isEndpoint(const geom::Geometry& linearGeom) const;
+
+    friend std::ostream& operator<< (std::ostream& out, const LinearLocation& obj);
+
+};
+
+
+} // namespace geos.linearref
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/linearref/LocationIndexOfLine.h

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: linearref/LocationIndexOfLine.java r731
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/LinearLocation.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/** \brief
+ * Determines the location of a subline along a linear [Geometry](@ref geom::Geometry).
+ *
+ * The location is reported as a pair of {@link LinearLocation}s.
+ *
+ * @note Currently this algorithm is not guaranteed to
+ *       return the correct substring in some situations where
+ *       an endpoint of the test line occurs more than once in the input line.
+ *       (However, the common case of a ring is always handled correctly).
+ */
+class LocationIndexOfLine {
+    /**
+     * MD - this algorithm has been extracted into a class
+     * because it is intended to validate that the subline truly is a subline,
+     * and also to use the internal vertex information to unambiguously locate the subline.
+     */
+private:
+    const geom::Geometry* linearGeom;
+
+public:
+
+    /** \brief
+     * Determines the location of a subline along a linear [Geometry](@ref geom::Geometry).
+     *
+     * The location is reported as a pair of [LinearLocations](@ref LinearLocation).
+     *
+     * @note Currently this algorithm is not guaranteed to
+     *       return the correct substring in some situations where
+     *       an endpoint of the test line occurs more than once in the input line.
+     *       (However, the common case of a ring is always handled correctly).
+     *
+     * @note Caller must take of releasing with delete[]
+     *
+     */
+    static LinearLocation* indicesOf(const geom::Geometry* linearGeom, const geom::Geometry* subLine);
+
+    LocationIndexOfLine(const geom::Geometry* linearGeom);
+
+    /// Caller must take of releasing with delete[]
+    LinearLocation* indicesOf(const geom::Geometry* subLine) const;
+};
+}
+}
+

package/dist/prebuilt/Android-x86_64/include/geos/linearref/LocationIndexOfPoint.h

@@ -0,0 +1,77 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: linearref/LinearGeometryBuilder.java r466
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/LinearLocation.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/** \brief
+ * Computes the LinearLocation of the point on a linear [Geometry](@ref geom::Geometry)
+ * nearest a given [Coordinate](@ref geom::Coordinate).
+ *
+ * The nearest point is not necessarily unique; this class always computes
+ * the nearest point closest to the start of the geometry.
+ */
+class LocationIndexOfPoint {
+
+private:
+    const geom::Geometry* linearGeom;
+
+    LinearLocation indexOfFromStart(const geom::CoordinateXY& inputPt, const LinearLocation* minIndex) const;
+
+public:
+    static LinearLocation indexOf(const geom::Geometry* linearGeom, const geom::CoordinateXY& inputPt);
+
+    static LinearLocation indexOfAfter(const geom::Geometry* linearGeom, const geom::CoordinateXY& inputPt,
+                                       const LinearLocation* minIndex);
+
+    LocationIndexOfPoint(const geom::Geometry* linearGeom);
+
+    /** \brief
+     * Find the nearest location along a linear [Geometry](@ref geom::Geometry)
+     * to a given point.
+     *
+     * @param inputPt the coordinate to locate
+     * @return the location of the nearest point
+     */
+    LinearLocation indexOf(const geom::CoordinateXY& inputPt) const;
+
+    /** \brief
+     * Find the nearest LinearLocation along the linear [Geometry](@ref geom::Geometry)
+     * to a given [Coordinate](@ref geom::Coordinate) after the specified minimum LinearLocation.
+     *
+     * If possible the location returned will be strictly greater than the
+     * `minLocation`.
+     * If this is not possible, the value returned will equal `minLocation`.
+     * (An example where this is not possible is when `minLocation = [end of line]`).
+     *
+     * @param inputPt the coordinate to locate
+     * @param minIndex the minimum location for the point location
+     * @return the location of the nearest point
+     */
+    LinearLocation indexOfAfter(const geom::CoordinateXY& inputPt, const LinearLocation* minIndex) const;
+};
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/linearref/LocationIndexedLine.h

@@ -0,0 +1,276 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 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: linearref/LocationIndexedLine.java r466
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/LinearLocation.h>
+#include <geos/linearref/LocationIndexOfPoint.h>
+#include <geos/linearref/LocationIndexOfLine.h>
+#include <geos/util/IllegalArgumentException.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/**
+ * \brief
+ * Supports linear referencing along a linear
+ * [Geometry](@ref geom::Geometry) using
+ * [LinearLocations](@ref LinearLocation) as the index.
+ */
+class GEOS_DLL LocationIndexedLine {
+private:
+    const geom::Geometry* linearGeom;
+
+    void
+    checkGeometryType()
+    {
+        if(!linearGeom->isLineal()) {
+            throw util::IllegalArgumentException("Input geometry must be linear");
+        }
+    }
+
+public:
+
+    /**
+     * \brief
+     * Constructs an object which allows linear referencing along
+     * a given linear [Geometry](@ref geom::Geometry).
+     *
+     * @param p_linearGeom the linear geometry to reference along
+     */
+    LocationIndexedLine(const geom::Geometry* p_linearGeom)
+        : linearGeom(p_linearGeom)
+    {
+        checkGeometryType();
+    }
+
+    /**
+     * \brief
+     * Computes the [Coordinate](@ref geom::Coordinate) for the point
+     * on the line at the given index.
+     *
+     * If the index is out of range the first or last point on the
+     * line will be returned.
+     * The Z-ordinate of the computed point will be interpolated from
+     * the Z-ordinates of the line segment containing it, if they exist.
+     *
+     * @param index the index of the desired point
+     * @return the Coordinate at the given index
+     */
+    geom::Coordinate
+    extractPoint(const LinearLocation& index) const
+    {
+        return index.getCoordinate(linearGeom);
+    }
+
+
+    /**
+     * \brief
+     * Computes the [Coordinate](@ref geom::Coordinate) for the point
+     * on the line at the given index, offset by the given distance.
+     *
+     * If the index is out of range the first or last point on the
+     * line will be returned.
+     * The computed point is offset to the left of the line if the offset
+     * distance is positive, to the right if negative.
+     *
+     * The Z-ordinate of the computed point will be interpolated from
+     * the Z-ordinates of the line segment containing it, if they exist.
+     *
+     * @param index the index of the desired point
+     * @param offsetDistance the distance the point is offset from the segment
+     *                       (positive is to the left, negative is to the right)
+     * @return the Coordinate at the given index
+     */
+    geom::Coordinate
+    extractPoint(const LinearLocation& index,
+                 double offsetDistance) const
+    {
+        geom::Coordinate ret;
+        index.getSegment(linearGeom)->pointAlongOffset(
+            index.getSegmentFraction(), offsetDistance, ret
+        );
+        return ret;
+    }
+
+    /**
+     * \brief
+     * Computes the [LineString](@ref geom::LineString) for the interval
+     * on the line between the given indices.
+     *
+     * If the endIndex lies before the startIndex,
+     * the computed geometry is reversed.
+     *
+     * @param startIndex the index of the start of the interval
+     * @param endIndex the index of the end of the interval
+     * @return the linear interval between the indices
+     */
+    std::unique_ptr<geom::Geometry>
+    extractLine(const LinearLocation& startIndex,
+                const LinearLocation& endIndex) const
+    {
+        return ExtractLineByLocation::extract(linearGeom, startIndex, endIndex);
+    }
+
+
+    /**
+     * \brief
+     * Computes the index for a given point on the line.
+     *
+     * The supplied point does not <i>necessarily</i> have to lie precisely
+     * on the line, but if it is far from the line the accuracy and
+     * performance of this function is not guaranteed.
+     * Use {@link #project} to compute a guaranteed result for points
+     * which may be far from the line.
+     *
+     * @param pt a point on the line
+     * @return the index of the point
+     *
+     * @see project
+     */
+    LinearLocation
+    indexOf(const geom::Coordinate& pt) const
+    {
+        return LocationIndexOfPoint::indexOf(linearGeom, pt);
+    }
+
+    /**
+     * \brief
+     * Finds the index for a point on the line
+     * which is greater than the given index.
+     *
+     * If no such index exists, returns <tt>minIndex</tt>.
+     * This method can be used to determine all indexes for
+     * a point which occurs more than once on a non-simple line.
+     * It can also be used to disambiguate cases where the given point lies
+     * slightly off the line and is equidistant from two different
+     * points on the line.
+     *
+     * The supplied point does not <i>necessarily</i> have to lie precisely
+     * on the line, but if it is far from the line the accuracy and
+     * performance of this function is not guaranteed.
+     * Use {@link #project} to compute a guaranteed result for points
+     * which may be far from the line.
+     *
+     * @param pt a point on the line
+     * @param minIndex the value the returned index must be greater than
+     * @return the index of the point greater than the given minimum index
+     *
+     * @see project
+     */
+    LinearLocation
+    indexOfAfter(const geom::Coordinate& pt,
+                 const LinearLocation& minIndex) const
+    {
+        return LocationIndexOfPoint::indexOfAfter(linearGeom, pt, &minIndex);
+    }
+
+    /**
+     * \brief
+     * Computes the indices for a subline of the line.
+     *
+     * (The subline must <b>conform</b> to the line; that is,
+     * all vertices in the subline (except possibly the first and last)
+     * must be vertices of the line and occur in the same order).
+     *
+     * @param subLine a subLine of the line
+     * @return a pair of indices for the start and end of the subline.
+     */
+    LinearLocation*
+    indicesOf(const geom::Geometry* subLine) const
+    {
+        return LocationIndexOfLine::indicesOf(linearGeom, subLine);
+    }
+
+
+    /**
+     * \brief
+     * Computes the index for the closest point on the line to the given point.
+     *
+     * If more than one point has the closest distance the first one along
+     * the line is returned.
+     * (The point does not necessarily have to lie precisely on the line.)
+     *
+     * @param pt a point on the line
+     * @return the index of the point
+     */
+    LinearLocation
+    project(const geom::Coordinate& pt) const
+    {
+        return LocationIndexOfPoint::indexOf(linearGeom, pt);
+    }
+
+    /**
+     * \brief
+     * Returns the index of the start of the line
+     *
+     * @return the start index
+     */
+    LinearLocation
+    getStartIndex() const
+    {
+        return LinearLocation();
+    }
+
+    /**
+     * \brief
+     * Returns the index of the end of the line
+     *
+     * @return the end index
+     */
+    LinearLocation
+    getEndIndex() const
+    {
+        return LinearLocation::getEndLocation(linearGeom);
+    }
+
+    /**
+     * \brief
+     * Tests whether an index is in the valid index range for the line.
+     *
+     * @param index the index to test
+     * @return `true` if the index is in the valid range
+     */
+    bool
+    isValidIndex(const LinearLocation& index) const
+    {
+        return index.isValid(linearGeom);
+    }
+
+
+    /**
+     * \brief
+     * Computes a valid index for this line
+     * by clamping the given index to the valid range of index values
+     *
+     * @return a valid index value
+     */
+    LinearLocation
+    clampIndex(const LinearLocation& index) const
+    {
+        LinearLocation loc = index;
+        loc.clamp(linearGeom);
+        return loc;
+    }
+};
+
+} // geos::linearref
+} // geos