PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// A list of positions
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
// Copyright (C) 2001-2013 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 "AbstractPoly.h"


// ===========================================================================
// class declarations
// ===========================================================================
class Line;
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();

    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;




    void push_back(const PositionVector& p);


    void push_front(const Position& p);

    Position pop_front();

    void insertAt(int index, const Position& p);

    void replaceAt(int index, const Position& by);

    void eraseAt(int i);

    bool around(const Position& p, SUMOReal offset = 0) const;

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

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

    bool intersects(const PositionVector& v1) const;

    Position intersectsAtPoint(const Position& p1,
                               const Position& p2) const; // !!!

    PositionVector intersectionPoints2D(const Line& line) const;

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

    std::vector<SUMOReal> intersectsAtLengths2D(const Line& line) const; // !!!

    Position intersectsAtPoint(const PositionVector& v1) const; // !!!

    void closePolygon();

    const Position& operator[](int index) const;
    Position& operator[](int index);

    Position positionAtOffset(SUMOReal pos) const;

    Position positionAtOffset2D(SUMOReal pos) const;

    SUMOReal rotationDegreeAtOffset(SUMOReal pos) const;

    SUMOReal slopeDegreeAtOffset(SUMOReal pos) const;

    static Position positionAtOffset(const Position& p1,
                                     const Position& p2, SUMOReal pos);

    static Position positionAtOffset2D(const Position& p1,
                                       const Position& p2, SUMOReal pos);

    Boundary getBoxBoundary() const;

    Position getPolygonCenter() const;

    Position getCentroid() const;

    void scaleSize(SUMOReal factor);

    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 reshiftRotate(SUMOReal xoff, SUMOReal yoff, SUMOReal rot);

    PositionVector convexHull() const;

    int appendWithCrossingPoint(const PositionVector& v);

    // @brief append the given vector to this one
    void append(const PositionVector& v);

    PositionVector getSubpart(SUMOReal beginOffset, SUMOReal endOffset) const;

    PositionVector getSubpart2D(SUMOReal beginOffset, SUMOReal endOffset) const;

    void sortAsPolyCWByAngle();

    void sortByIncreasingXY();

    void extrapolate(SUMOReal val);

    PositionVector reverse() const;

    void move2side(SUMOReal amount);

    Line lineAt(int pos) const;

    Line getBegLine() const;

    Line getEndLine() const;


    // @brief inserts p between the two closest positions and returns the insertion index
    int insertAtClosest(const Position& p);

    bool operator==(const PositionVector& v2) const;

    class as_poly_cw_sorter {
    public:
        as_poly_cw_sorter() {};

    public:
        int operator()(const Position& p1, const Position& p2) const;

    };

    class increasing_x_y_sorter {
    public:
        explicit increasing_x_y_sorter();

    public:
        int operator()(const Position& p1, const Position& p2) const;

    };

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

    void pruneFromBeginAt(const Position& p);
    void pruneFromEndAt(const Position& p);

    SUMOReal beginEndAngle() const;

    SUMOReal nearest_offset_to_point2D(const Position& p, bool perpendicular = true) const;

    /* @brief index of the closest position to p
     * @note: may only be called for a non-empty vector */
    int indexOfClosest(const Position& p) const;

    // distances of all my points to s and all of s points to myself
    std::vector<SUMOReal> distances(const PositionVector& s) const;

    SUMOReal distance(const Position& p) 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);

    void removeColinearPoints();

};


#endif

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