PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2017 German Aerospace Center (DLR) and others.
/****************************************************************************/
//
//   This program and the accompanying materials
//   are made available under the terms of the Eclipse Public License v2.0
//   which accompanies this distribution, and is available at
//   http://www.eclipse.org/legal/epl-v20.html
//
/****************************************************************************/
// A list of positions
/****************************************************************************/
#ifndef PositionVector_h
#define PositionVector_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#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::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;

    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.);

    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) 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 mirrorX();

    void rotate2D(double angle);

    void append(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 angleAt2D(int pos) const;

    int insertAtClosest(const Position& p);

    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;
    };

    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;

    Position transformToVectorCoordinates(const Position& p, bool extend = false) const;

    int indexOfClosest(const Position& p) const;

    std::vector<double> distances(const PositionVector& s, bool perpendicular = false) const;

    double distance2D(const Position& p, bool perpendicular = false) const;

    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;

    void removeDoublePoints(double minDist = POSITION_EPS, bool assertLength = false);

    bool hasElevation() const;

    PositionVector simplified() const;

    PositionVector getOrthogonal(const Position& p, double extend, bool before, double length = 1.0) const;


    PositionVector smoothedZFront(double dist = std::numeric_limits<double>::max()) const;

    PositionVector interpolateZ(double zStart, double zEnd) const;

    PositionVector resample(double maxLength) const;

    double offsetAtIndex2D(int index) const;

    double getMaxGrade() const;

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);
};


#endif

/****************************************************************************/