PositionVector.h

Go to the documentation of this file.

/****************************************************************************/
// A list of 2D-positions
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2012 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 <queue>
#include <iostream>
#include <utils/common/VectorHelper.h>
#include "AbstractPoly.h"
#include "Boundary.h"
#include "Position.h"


class Line;

// ===========================================================================
// 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;

    DoubleVector intersectsAtLengths2D(const PositionVector& other) const; // !!!

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

    SUMOReal rotationDegreeAtLengthPosition(SUMOReal pos) const;

    static Position positionAtLengthPosition(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;

    const Position& getBegin() const;

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

    PositionVector convexHull() const;

    int appendWithCrossingPoint(const PositionVector& v);


    const ContType& getCont() const {
        return myCont;
    }

    PositionVector getSubpart(SUMOReal begin, SUMOReal end) const;

    void sortAsPolyCWByAngle();

    void sortByIncreasingXY();

    void extrapolate(SUMOReal val);

    PositionVector reverse() const;

    void move2side(SUMOReal amount);
    void move2side(SUMOReal amount, int index);

    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
    void 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_point(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
    DoubleVector 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();

    void removeColinearPoints();

private:

    ContType myCont;

};


#endif

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