@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

package/dist/prebuilt/iOS-iphoneos/include/geos/linearref/LengthIndexOfPoint.h

@@ -1,87 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/linearref/LengthIndexedLine.h

@@ -1,211 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/linearref/LengthLocationMap.h

@@ -1,134 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/linearref/LinearGeometryBuilder.h

@@ -1,106 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/linearref/LinearIterator.h

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