PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// A list of positions
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <limits>
#include "AbstractPoly.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class Boundary;
 
// ===========================================================================
// class definitions
// ===========================================================================
class PositionVector : public AbstractPoly, private std::vector<Position> {
 
private:
    typedef std::vector<Position> vp;
 
public:
    PositionVector();
 
    PositionVector(const std::vector<Position>& v);
 
    PositionVector(const std::vector<Position>::const_iterator beg, const std::vector<Position>::const_iterator end);
 
    PositionVector(const Position& p1, const Position& p2);
 
    ~PositionVector();
 
    static const PositionVector EMPTY;
 
    using vp::iterator;
 
    using vp::const_iterator;
 
    using vp::const_reference;
 
    using vp::value_type;
 
    using vp::begin;
 
    using vp::end;
 
    using vp::push_back;
 
    using vp::pop_back;
 
    using vp::clear;
 
    using vp::size;
 
    using vp::empty;
 
    using vp::front;
 
    using vp::back;
 
    using vp::reference;
 
    using vp::erase;
 
    using vp::insert;
 
    bool around(const Position& p, double offset = 0) const;
 
    bool overlapsWith(const AbstractPoly& poly, double offset = 0) const;
 
    double getOverlapWith(const PositionVector& poly, double zThreshold) const;
 
    bool intersects(const Position& p1, const Position& p2) const;
 
    bool intersects(const PositionVector& v1) const;
 
    Position intersectionPosition2D(const Position& p1, const Position& p2, const double withinDist = 0.) const;
 
    std::vector<double> intersectsAtLengths2D(const PositionVector& other) const;
 
    std::vector<double> intersectsAtLengths2D(const Position& lp1, const Position& lp2) const;
 
    Position intersectionPosition2D(const PositionVector& v1) const;
 
    void closePolygon();
 
    const Position& operator[](int index) const;
 
    Position& operator[](int index);
 
    Position positionAtOffset(double pos, double lateralOffset = 0) const;
 
    Position positionAtOffset2D(double pos, double lateralOffset = 0) const;
 
    /* @brief Returns position similar to positionAtOffset but instead of applying the
     * lateral offset orthogonal to the shape, apply it orthogonal to the given angle */
    Position sidePositionAtAngle(double pos, double lateralOffset, double angle) const;
 
    double rotationAtOffset(double pos) const;
 
    double rotationDegreeAtOffset(double pos) const;
 
    double slopeDegreeAtOffset(double pos) const;
 
    static Position positionAtOffset(const Position& p1, const Position& p2, double pos, double lateralOffset = 0.);
 
    static Position positionAtOffset2D(const Position& p1, const Position& p2, double pos, double lateralOffset = 0.);
 
    /* @brief Returns position similar to positionAtOffset but instead of applying the
     * lateral offset orthogonal to the shape, apply it orthogonal to the given angle */
    static Position sidePositionAtAngle(const Position& p1, const Position& p2, double pos, double lateralOffset, double angle);
 
    Boundary getBoxBoundary() const;
 
    Position getPolygonCenter() const;
 
    Position getCentroid() const;
 
    void scaleRelative(double factor);
 
    void scaleAbsolute(double offset);
 
    Position getLineCenter() const;
 
    double length() const;
 
    double length2D() const;
 
    double area() const;
 
    bool partialWithin(const AbstractPoly& poly, double offset = 0) const;
 
    std::pair<PositionVector, PositionVector> splitAt(double where, bool use2D = false) const;
 
    friend std::ostream& operator<<(std::ostream& os, const PositionVector& geom);
 
    bool crosses(const Position& p1, const Position& p2) const;
 
    void add(double xoff, double yoff, double zoff);
 
    void add(const Position& offset);
 
    void sub(const Position& offset);
 
    PositionVector added(const Position& offset) const;
 
    void mirrorX();
 
    void rotate2D(double angle);
 
    void rotateAroundFirstElement2D(double angle);
 
    void append(const PositionVector& v, double sameThreshold = 2.0);
 
    void prepend(const PositionVector& v, double sameThreshold = 2.0);
 
    PositionVector getSubpart(double beginOffset, double endOffset) const;
 
    PositionVector getSubpart2D(double beginOffset, double endOffset) const;
 
    PositionVector getSubpartByIndex(int beginIndex, int count) const;
 
    void sortAsPolyCWByAngle();
 
    void sortByIncreasingXY();
 
    void extrapolate(const double val, const bool onlyFirst = false, const bool onlyLast = false);
 
    void extrapolate2D(const double val, const bool onlyFirst = false);
 
    PositionVector reverse() const;
 
    static Position sideOffset(const Position& beg, const Position& end, const double amount);
 
    void move2side(double amount, double maxExtension = 100);
 
    void move2sideCustom(std::vector<double> amount, double maxExtension = 100);
 
    double angleAt2D(int pos) const;
 
    int insertAtClosest(const Position& p, bool interpolateZ);
 
    int removeClosest(const Position& p);
 
    bool operator==(const PositionVector& v2) const;
 
    bool operator!=(const PositionVector& v2) const;
 
    PositionVector operator-(const PositionVector& v2) const;
 
    PositionVector operator+(const PositionVector& v2) const;
 
    class as_poly_cw_sorter {
    public:
        as_poly_cw_sorter();
 
        int operator()(const Position& p1, const Position& p2) const;
 
    private:
        double atAngle2D(const Position& p) const;
    };
 
    class increasing_x_y_sorter {
    public:
        explicit increasing_x_y_sorter();
 
        int operator()(const Position& p1, const Position& p2) const;
    };
 
    double isLeft(const Position& P0, const Position& P1, const Position& P2) const;
 
    double beginEndAngle() const;
 
    double nearest_offset_to_point2D(const Position& p, bool perpendicular = true) const;
 
    double nearest_offset_to_point25D(const Position& p, bool perpendicular = true) const;
 
    Position transformToVectorCoordinates(const Position& p, bool extend = false) const;
 
    /* @brief index of the closest position to p
     * @in twoD whether all positions should be projected onto the plan
       @note: may only be called for a non-empty vector
    */
    int indexOfClosest(const Position& p, bool twoD = false) const;
 
    std::vector<double> distances(const PositionVector& s, bool perpendicular = false) const;
 
    double distance2D(const Position& p, bool perpendicular = false) const;
 
    void push_front(const Position& p);
 
    void pop_front();
 
    void push_back_noDoublePos(const Position& p);
 
    void push_front_noDoublePos(const Position& p);
 
    void insert_noDoublePos(const std::vector<Position>::iterator& at, const Position& p);
 
    bool isClosed() const;
 
    bool isNAN() const;
 
    void removeDoublePoints(double minDist = POSITION_EPS, bool assertLength = false, int beginOffset = 0, int endOffset = 0, bool resample = false);
 
    bool hasElevation() const;
 
    PositionVector simplified() const;
    // test implementation of an alternative check
    const PositionVector simplified2(const bool closed, const double eps = NUMERICAL_EPS) const;
 
    PositionVector getOrthogonal(const Position& p, double extend, bool before, double length = 1.0, double deg = 90) const;
 
    PositionVector smoothedZFront(double dist = std::numeric_limits<double>::max()) const;
 
    PositionVector interpolateZ(double zStart, double zEnd) const;
 
    PositionVector resample(double maxLength, const bool adjustEnd) const;
 
    double offsetAtIndex2D(int index) const;
 
    /* @brief return the maximum grade of all segments as a fraction of zRange/length2D
     * @param[out] maxJump The maximum vertical jump (with grade infinity)
     */
    double getMaxGrade(double& maxJump) const;
 
    double getMinZ() const;
 
    bool almostSame(const PositionVector& v2, double maxDiv = POSITION_EPS) const;
 
    PositionVector bezier(int numPoints);
 
    static double localAngle(const Position& from, const Position& pos, const Position& to);
 
    /* @brief checks if the polygon represented by the PositionVector is clockwise-oriented
       @remark this function works for non-convex polygons
    */
    bool isClockwiseOriented(void);
 
private:
    static bool intersects(const Position& p11, const Position& p12, const Position& p21, const Position& p22, const double withinDist = 0., double* x = 0, double* y = 0, double* mu = 0);
};