Position2DVector.h

Go to the documentation of this file.

/****************************************************************************/
// A list of 2D-positions
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef Position2DVector_h
#define Position2DVector_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 "Position2D.h"


class Line2D;

// ===========================================================================
// class definitions
// ===========================================================================
class Position2DVector
            : public AbstractPoly {
public:
    typedef std::deque<Position2D> ContType;

public:
    Position2DVector() throw();


    Position2DVector(const std::vector<Position2D> &v) throw();


    ~Position2DVector() throw();



    void push_back(const Position2D &p) throw();


    void push_back(const Position2DVector &p) throw();



    void push_front(const Position2D &p);

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

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

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

    bool intersects(const Position2DVector &v1) const;

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

    Position2DVector intersectsAtPoints(const Position2D &p1,
                                        const Position2D &p2) const; // !!!

    DoubleVector intersectsAtLengths(const Position2DVector &s) const; // !!!

    DoubleVector intersectsAtLengths(const Line2D &s) const; // !!!

    Position2D intersectsAtPoint(const Position2DVector &v1) const; // !!!

    void clear();

    void closePolygon();

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

    size_t size() const;

    Position2D positionAtLengthPosition(SUMOReal pos) const;

    SUMOReal rotationDegreeAtLengthPosition(SUMOReal pos) const;

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

    Boundary getBoxBoundary() const;

    Position2D getPolygonCenter() const;
    Position2D getLineCenter() const;

    Position2D pop_back();
    Position2D pop_front();

    SUMOReal length() const;

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

    const Position2D &getBegin() const;

    const Position2D &getEnd() const;

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

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

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

    void reshiftRotate(SUMOReal xoff, SUMOReal yoff, SUMOReal rot);

    Position2DVector convexHull() const;

    int appendWithCrossingPoint(const Position2DVector &v);


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

    Position2DVector getSubpart(SUMOReal begin, SUMOReal end) const;

    void sortAsPolyCWByAngle();

    void sortByIncreasingXY();

    void extrapolate(SUMOReal val);

    Position2DVector reverse() const;

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

    Line2D lineAt(size_t pos) const;

    Line2D getBegLine() const;

    Line2D getEndLine() const;


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

    class as_poly_cw_sorter {
    public:
        explicit as_poly_cw_sorter(Position2D center);

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

    private:
        Position2D myCenter;

    };

    class increasing_x_y_sorter {
    public:
        explicit increasing_x_y_sorter();

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

    };

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

    void set(size_t pos, const Position2D &p);

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

    SUMOReal beginEndAngle() const;

    void eraseAt(int i);

    SUMOReal nearest_position_on_line_to_point(const Position2D &p) const;

    DoubleVector distances(const Position2DVector &s) const;
    DoubleVector distancesExt(const Position2DVector &s) const;

    SUMOReal distance(const Position2D &p) const;

    void push_back_noDoublePos(const Position2D &p);
    void push_front_noDoublePos(const Position2D &p);

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

    bool isClosed() const;

    void removeDoublePoints();

    void removeColinearPoints();

private:

    ContType myCont;

};


#endif

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