PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// A list of positions
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#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();

    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, SUMOReal offset = 0) const;

    bool overlapsWith(const AbstractPoly& poly, SUMOReal offset = 0) const;

    SUMOReal getOverlapWith(const PositionVector& poly, SUMOReal 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 SUMOReal withinDist = 0.) const;

    std::vector<SUMOReal> intersectsAtLengths2D(const PositionVector& other) const;

    std::vector<SUMOReal> 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(SUMOReal pos, SUMOReal lateralOffset = 0) const;

    Position positionAtOffset2D(SUMOReal pos, SUMOReal lateralOffset = 0) const;

    SUMOReal rotationAtOffset(SUMOReal pos) const;

    SUMOReal rotationDegreeAtOffset(SUMOReal pos) const;

    SUMOReal slopeDegreeAtOffset(SUMOReal pos) const;

    static Position positionAtOffset(const Position& p1, const Position& p2, SUMOReal pos, SUMOReal lateralOffset = 0.);

    static Position positionAtOffset2D(const Position& p1, const Position& p2, SUMOReal pos, SUMOReal lateralOffset = 0.);

    Boundary getBoxBoundary() const;

    Position getPolygonCenter() const;

    Position getCentroid() const;

    void scaleRelative(SUMOReal factor);

    void scaleAbsolute(SUMOReal offset);

    Position getLineCenter() const;

    SUMOReal length() const;

    SUMOReal length2D() const;

    SUMOReal area() const;

    bool partialWithin(const AbstractPoly& poly, SUMOReal offset = 0) const;

    std::pair<PositionVector, PositionVector> splitAt(SUMOReal where) const;

    friend std::ostream& operator<<(std::ostream& os, const PositionVector& geom);

    bool crosses(const Position& p1, const Position& p2) const;

    void add(SUMOReal xoff, SUMOReal yoff, SUMOReal zoff);

    void add(const Position& offset);

    void mirrorX();

    void rotate2D(SUMOReal angle);

    PositionVector convexHull() const;

    void append(const PositionVector& v, SUMOReal sameThreshold = 2.0);

    PositionVector getSubpart(SUMOReal beginOffset, SUMOReal endOffset) const;

    PositionVector getSubpart2D(SUMOReal beginOffset, SUMOReal endOffset) const;

    PositionVector getSubpartByIndex(int beginIndex, int count) const;

    void sortAsPolyCWByAngle();

    void sortByIncreasingXY();

    void extrapolate(const SUMOReal val, const bool onlyFirst = false);

    void extrapolate2D(const SUMOReal val, const bool onlyFirst = false);

    PositionVector reverse() const;

    static Position sideOffset(const Position& beg, const Position& end, const SUMOReal amount);

    void move2side(SUMOReal amount);

    SUMOReal angleAt2D(int pos) const;

    int insertAtClosest(const Position& p);

    int removeClosest(const Position& p);

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

    SUMOReal isLeft(const Position& P0, const Position& P1, const Position& P2) const;

    SUMOReal beginEndAngle() const;

    SUMOReal 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<SUMOReal> distances(const PositionVector& s, bool perpendicular = false) const;

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

    void push_back_noDoublePos(const Position& p);

    void push_front_noDoublePos(const Position& p);

    bool isClosed() const;

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

    bool hasElevation() const;

    PositionVector simplified() const;

    PositionVector getOrthogonal(const Position& p, SUMOReal extend, SUMOReal& distToClosest) const;


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

    SUMOReal offsetAtIndex2D(int index) const;

    SUMOReal getMaxGrade() const;

private:
    static bool intersects(const Position& p11, const Position& p12, const Position& p21, const Position& p22, const SUMOReal withinDist = 0., SUMOReal* x = 0, SUMOReal* y = 0, SUMOReal* mu = 0);
};


#endif

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