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

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

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * 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/LengthIndexOfPoint.java rev. 1.10
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <string>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/linearref/LinearLocation.h>
+
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/**
+ * \brief
+ * Computes the length index of the point
+ * on a linear Geometry nearest a given Coordinate.
+ *
+ * The nearest point is not necessarily unique; this class
+ * always computes the nearest point closest to
+ * the start of the geometry.
+ */
+class LengthIndexOfPoint {
+
+private:
+    const geom::Geometry* linearGeom;
+
+    double indexOfFromStart(const geom::Coordinate& inputPt, const double minIndex) const;
+
+    double segmentNearestMeasure(const geom::LineSegment* seg,
+                                 const geom::Coordinate& inputPt,
+                                 double segmentStartMeasure) const;
+public:
+    static double indexOf(const geom::Geometry* linearGeom, const geom::Coordinate& inputPt);
+
+    static double indexOfAfter(const geom::Geometry* linearGeom, const geom::Coordinate& inputPt, double minIndex);
+
+    LengthIndexOfPoint(const geom::Geometry* linearGeom);
+
+    /**
+     * Find the nearest location along a linear Geometry to a given point.
+     *
+     * @param inputPt the coordinate to locate
+     * @return the location of the nearest point
+     */
+    double indexOf(const geom::Coordinate& inputPt) const;
+
+    /** \brief
+     * Finds the nearest index along the linear Geometry
+     * to a given Coordinate after the specified minimum index.
+     *
+     * If possible the location returned will be strictly greater than the
+     * <code>minLocation</code>.
+     * If this is not possible, the
+     * value returned will equal <code>minLocation</code>.
+     * (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
+     */
+    double indexOfAfter(const geom::Coordinate& inputPt, double minIndex) const;
+
+};
+
+}
+}

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

@@ -0,0 +1,211 @@
+/**********************************************************************
+ *
+ * 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/LengthIndexedLine.java r463
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/LinearLocation.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/** \brief
+ * Supports linear referencing along a linear geom::Geometry
+ * using the length along the line as the index.
+ *
+ * Negative length values are taken as measured in the reverse direction
+ * from the end of the geometry.
+ * Out-of-range index values are handled by clamping
+ * them to the valid range of values.
+ * Non-simple lines (i.e. which loop back to cross or touch
+ * themselves) are supported.
+ */
+
+class GEOS_DLL LengthIndexedLine {
+private:
+    const geom::Geometry* linearGeom;
+    LinearLocation locationOf(double index) const;
+    LinearLocation locationOf(double index, bool resolveLower) const;
+    double positiveIndex(double index) const;
+
+public:
+
+    /** \brief
+     * Constructs an object which allows a linear [Geometry](@ref geom::Geometry)
+     * to be linearly referenced using length as an index.
+     *
+     * @param linearGeom the linear geometry to reference along
+     */
+
+    LengthIndexedLine(const geom::Geometry* linearGeom);
+
+    /** \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(double index) const;
+
+
+    /**
+     * \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(double index, double offsetDistance) const;
+
+    /** \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(double startIndex, double endIndex) const;
+
+
+    /** \brief
+     * Computes the minimum index for a point on the line.
+     *
+     * If the line is not simple (i.e. loops back on itself)
+     * a single point may have more than one possible index.
+     * In this case, the smallest index is returned.
+     *
+     * The supplied point does not *necessarily* 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 minimum index of the point
+     *
+     * @see project
+     */
+    double indexOf(const geom::Coordinate& pt) const;
+
+    /** \brief
+     * Finds the index for a point on the line which is
+     * greater than the given index.
+     *
+     * If no such index exists, returns `minIndex`.
+     * 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 `*necessarily* 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
+     */
+    double indexOfAfter(const geom::Coordinate& pt, double minIndex) const;
+
+    /** \brief
+     * Computes the indices for a subline of the line.
+     *
+     * (The subline must **conform** 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.
+     */
+    double* indicesOf(const geom::Geometry* subLine) const;
+
+
+    /** \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
+     */
+    double project(const geom::Coordinate& pt) const;
+
+    /** \brief
+     * Returns the index of the start of the line
+     * @return the start index
+     */
+    double getStartIndex() const;
+
+    /** \brief
+     * Returns the index of the end of the line
+     * @return the end index
+     */
+    double getEndIndex() const;
+
+    /** \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(double index) const;
+
+
+    /** \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
+     */
+    double clampIndex(double index) const;
+};
+
+}
+}

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

@@ -0,0 +1,134 @@
+/**********************************************************************
+ *
+ * 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/LengthLocationMap.java r463
+ *
+ **********************************************************************/
+
+#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 for a given length along a linear
+ * [Geometry](@ref geom::Geometry).
+ *
+ * Negative lengths are measured in reverse from end of the linear geometry.
+ * Out-of-range values are clamped.
+ */
+class LengthLocationMap {
+
+
+private:
+    const geom::Geometry* linearGeom;
+
+    LinearLocation getLocationForward(double length) const;
+
+    LinearLocation resolveHigher(const LinearLocation& loc) const;
+
+public:
+
+    // TODO: cache computed cumulative length for each vertex
+    // TODO: support user-defined measures
+    // TODO: support measure index for fast mapping to a location
+
+    /**
+     * \brief
+     * Computes the LinearLocation for a
+     * given length along a linear [Geometry](@ref geom::Geometry).
+     *
+     * @param linearGeom the linear geometry to use
+     * @param length the length index of the location
+     * @return the LinearLocation for the length
+     */
+    static LinearLocation
+    getLocation(const geom::Geometry* linearGeom, double length)
+    {
+        LengthLocationMap locater(linearGeom);
+        return locater.getLocation(length);
+    }
+
+    /**
+     * \brief
+     * Computes the LinearLocation for a
+     * given length along a linear [Geometry].
+     *
+     * @param linearGeom the linear geometry to use
+     * @param length the length index of the location
+     * @param resolveLower if `true` lengths are resolved to the
+     *                     lowest possible index
+     * @return the LinearLocation for the length
+     */
+    static LinearLocation
+    getLocation(const geom::Geometry* linearGeom, double length, bool resolveLower)
+    {
+        LengthLocationMap locater(linearGeom);
+        return locater.getLocation(length, resolveLower);
+    }
+
+    /**
+     * Computes the length for a given LinearLocation
+     * on a linear [Geometry](@ref geom::Geometry).
+     *
+     * @param linearGeom the linear geometry to use
+     * @param loc the LinearLocation index of the location
+     * @return the length for the LinearLocation
+     */
+    static double getLength(const geom::Geometry* linearGeom, const LinearLocation& loc);
+
+    LengthLocationMap(const geom::Geometry* linearGeom);
+
+    /**
+     * \brief
+     * Compute the LinearLocation corresponding to a length.
+     *
+     * Negative lengths are measured in reverse from end of the linear geometry.
+     * Out-of-range values are clamped.
+     * Ambiguous indexes are resolved to the lowest possible location value,
+     * depending on the value of `resolveLower`.
+     *
+     * @param length the length index
+     * @param resolveLower if `true` lengths are resolved to the
+     *                     lowest possible index
+     * @return the corresponding LinearLocation
+     */
+    LinearLocation getLocation(double length, bool resolveLower) const;
+
+    /**
+     * \brief
+     * Compute the LinearLocation corresponding to a length.
+     *
+     * Negative lengths are measured in reverse from end of the linear geometry.
+     * Out-of-range values are clamped.
+     * Ambiguous indexes are resolved to the lowest possible location value.
+     *
+     * @param length the length index
+     * @return the corresponding LinearLocation
+     */
+    LinearLocation getLocation(double length) const;
+
+    double getLength(const LinearLocation& loc) const;
+
+};
+
+} // geos.linearref
+} // geos
+

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

@@ -0,0 +1,106 @@
+/**********************************************************************
+ *
+ * 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/LinearGeometryBuilder.java rev. 1.1
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateList.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/linearref/LinearLocation.h>
+
+#include <vector>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/** \brief
+ * Builds a linear geometry ([LineString](@ref geom::LineString) or
+ * [MultiLineString](@ref geom::MultiLineString)) incrementally (point-by-point).
+ *
+ * @version 1.7
+ */
+class LinearGeometryBuilder {
+private:
+    const geom::GeometryFactory* geomFact;
+
+    typedef std::vector<std::unique_ptr<geom::Geometry>> GeomPtrVect;
+
+    // Geometry elements owned by this class
+    GeomPtrVect lines;
+
+    bool ignoreInvalidLines;
+    bool fixInvalidLines;
+    std::unique_ptr<geom::CoordinateSequence> coordList;
+
+    geom::Coordinate lastPt;
+
+public:
+    LinearGeometryBuilder(const geom::GeometryFactory* geomFact);
+
+    ~LinearGeometryBuilder();
+
+    /** \brief
+     * Allows invalid lines to be ignored rather than causing Exceptions.
+     *
+     * An invalid line is one which has only one unique point.
+     *
+     * @param ignoreInvalidLines `true` if short lines are
+     *                           to be ignored
+     */
+    void setIgnoreInvalidLines(bool ignoreInvalidLines);
+
+    /** \brief
+     * Allows invalid lines to be ignored rather than causing Exceptions.
+     *
+     * An invalid line is one which has only one unique point.
+     *
+     * @param fixInvalidLines `true` if short lines are
+     *                        to be ignored
+     */
+    void setFixInvalidLines(bool fixInvalidLines);
+
+    /** \brief
+     * Adds a point to the current line.
+     *
+     * @param pt the Coordinate to add
+     */
+    void add(const geom::Coordinate& pt);
+
+    /** \brief
+     * Adds a point to the current line.
+     *
+     * @param pt the Coordinate to add
+     * @param allowRepeatedPoints if set to `false`, repeated coordinates are
+     *                            collapsed
+     */
+    void add(const geom::Coordinate& pt, bool allowRepeatedPoints);
+
+    // NOTE strk: why return by value ?
+    geom::Coordinate getLastCoordinate() const;
+
+    /// Terminate the current LineString.
+    void endLine();
+
+    std::unique_ptr<geom::Geometry> getGeometry();
+};
+
+} // namespace geos.linearref
+} // namespace geos
+

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

@@ -0,0 +1,156 @@
+/**********************************************************************
+ *
+ * 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/LinearIterator.java r463
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <string>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/linearref/LinearLocation.h>
+
+namespace geos {
+namespace linearref {
+
+/** \brief
+ * An iterator over the components and coordinates of a linear geometry
+ * (LineString or MultiLineString).
+ *
+ * The standard usage pattern for a LinearIterator is:
+ *
+ * ~~~~~~
+ * for (LinearIterator it = new LinearIterator(...); it.hasNext(); it.next()) {
+ *   ...
+ *   int ci = it.getComponentIndex();   // for example
+ *   int vi = it.getVertexIndex();      // for example
+ *   ...
+ * }
+ * ~~~~~~
+ *
+ * @version 1.7
+ */
+class LinearIterator {
+public:
+    /** \brief
+     * Creates an iterator initialized to the start of a linear Geometry
+     *
+     * @param linear the linear geometry to iterate over
+     */
+    LinearIterator(const geom::Geometry* linear);
+
+    /** \brief
+     * Creates an iterator starting at
+     * a LinearLocation on a linear geom::Geometry
+     *
+     * @param linear the linear geometry to iterate over
+     * @param start the location to start at
+     */
+    LinearIterator(const geom::Geometry* linear, const LinearLocation& start);
+
+    /** \brief
+     * Creates an iterator starting at a component and vertex in a
+     * linear geom::Geometry
+     *
+     * @param linear the linear geometry to iterate over
+     * @param componentIndex the component to start at
+     * @param vertexIndex the vertex to start at
+     */
+    LinearIterator(const geom::Geometry* linear, std::size_t componentIndex, std::size_t vertexIndex);
+
+    /** \brief
+     * Tests whether there are any vertices left to iterator over.
+     * @return `true` if there are more vertices to scan
+     */
+    bool hasNext() const;
+
+
+    /** \brief
+     * Moves the iterator ahead to the next vertex and (possibly) linear component.
+     */
+    void next();
+
+    /** \brief
+     * Checks whether the iterator cursor is pointing to the
+     * endpoint of a component geom::LineString.
+     *
+     * @return `true` if the iterator is at an endpoint
+     */
+    bool isEndOfLine() const;
+
+    /** \brief
+     * The component index of the vertex the iterator is currently at.
+     * @return the current component index
+     */
+    std::size_t getComponentIndex() const;
+
+    /** \brief
+     * The vertex index of the vertex the iterator is currently at.
+     * @return the current vertex index
+     */
+    std::size_t getVertexIndex() const;
+
+    /** \brief
+     * Gets the geom::LineString component the iterator is current at.
+     * @return a linestring
+     */
+    const geom::LineString* getLine() const;
+
+    /** \brief
+     * Gets the first geom::Coordinate of the current segment.
+     * (the coordinate of the current vertex).
+     * @return a Coordinate
+     */
+    geom::Coordinate getSegmentStart() const;
+
+    /** \brief
+     * Gets the second geom::Coordinate of the current segment.
+     * (the coordinate of the next vertex).
+     * If the iterator is at the end of a line, `null` is returned.
+     *
+     * @return a Coordinate or `null`
+     */
+    geom::Coordinate getSegmentEnd() const;
+
+private:
+
+    static std::size_t segmentEndVertexIndex(const LinearLocation& loc);
+
+    const geom::LineString* currentLine;
+    std::size_t vertexIndex;
+    std::size_t componentIndex;
+    const geom::Geometry* linear;
+    const std::size_t numLines;
+
+    /**
+     * Invariant: currentLine <> null if the iterator is pointing
+     *            at a valid coordinate
+     *
+     * @throws IllegalArgumentException if linearGeom is not {@link Lineal}
+     */
+    void loadCurrentLine();
+
+    // Declare type as noncopyable
+    LinearIterator(const LinearIterator& other) = delete;
+    LinearIterator& operator=(const LinearIterator& rhs) = delete;
+};
+
+}
+} // namespace geos::linearref
+