PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// A list of positions
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// 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 {
public:
    typedef std::vector<Position> ContType;

public:
    PositionVector();


    PositionVector(const std::vector<Position>& v);


    ~PositionVector();



    void push_back(const Position& p);


    void push_back(const PositionVector& p);



    void push_front(const Position& p);

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

    void closePolygon();

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

    size_t size() const;

    Position positionAtLengthPosition(SUMOReal pos) const;

    Position positionAtLengthPosition2D(SUMOReal pos) const;

    SUMOReal rotationDegreeAtLengthPosition(SUMOReal pos) const;

    SUMOReal slopeDegreeAtLengthPosition(SUMOReal pos) const;

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

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

    Boundary getBoxBoundary() const;

    Position getPolygonCenter() const;

    Position getCentroid() const;

    void scaleSize(SUMOReal factor);

    Position getLineCenter() const;

    Position pop_back();
    Position pop_front();

    SUMOReal length() 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);

    ContType::const_iterator begin() const {
        return myCont.begin();
    }

    ContType::const_iterator end() const {
        return myCont.end();
    }

    const Position& front() const {
        return myCont.front();
    }

    const Position& back() const {
        return myCont.back();
    }

    PositionVector getSubpart(SUMOReal begin, SUMOReal end) const;

    PositionVector getSubpart2D(SUMOReal begin, SUMOReal end) const;

    void sortAsPolyCWByAngle();

    void sortByIncreasingXY();

    void extrapolate(SUMOReal val);

    PositionVector reverse() const;

    void move2side(SUMOReal amount);

    Line lineAt(size_t pos) const;

    Line getBegLine() const;

    Line getEndLine() const;


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

    // @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 set(size_t pos, const Position& p);

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

    SUMOReal beginEndAngle() const;

    void eraseAt(int i);

    SUMOReal nearest_position_on_line_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);

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

    bool isClosed() const;

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

    void removeColinearPoints();

private:

    ContType myCont;

};


#endif

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