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

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

@@ -1,248 +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/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/Emscripten-x86_64/include/geos/linearref/LocationIndexOfLine.h

@@ -1,72 +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/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/Emscripten-x86_64/include/geos/linearref/LocationIndexOfPoint.h

@@ -1,77 +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/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/Emscripten-x86_64/include/geos/linearref/LocationIndexedLine.h

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