NBEdge.h

Go to the documentation of this file.

/****************************************************************************/
// The representation of a single edge during network building
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2015 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 NBEdge_h
#define NBEdge_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <map>
#include <vector>
#include <string>
#include <set>
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/VectorHelper.h>
#include <utils/geom/Bresenham.h>
#include <utils/geom/PositionVector.h>
#include <utils/geom/Line.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include "NBCont.h"
#include "NBHelpers.h"
#include "NBSign.h"


// ===========================================================================
// class declarations
// ===========================================================================
class NBNode;
class NBConnection;
class NBNodeCont;
class NBEdgeCont;
class OutputDevice;
class GNELane;


// ===========================================================================
// class definitions
// ===========================================================================
class NBEdge : public Named, public Parameterised {
    friend class NBEdgeSuccessorBuilder;
    friend class NBEdgeCont;

    friend class GNELane;
    friend class GNEEdge;

public:

    enum EdgeBuildingStep {
        INIT_REJECT_CONNECTIONS,
        INIT,
        EDGE2EDGES,
        LANES2EDGES,
        LANES2LANES_RECHECK,
        LANES2LANES_DONE,
        LANES2LANES_USER
    };


    enum Lane2LaneInfoType {
        L2L_COMPUTED,
        L2L_USER,
        L2L_VALIDATED
    };


    struct Lane {
        Lane(NBEdge* e) :
            speed(e->getSpeed()), permissions(SVCAll), preferred(0),
            endOffset(e->getEndOffset()), width(e->getLaneWidth()) {}
        PositionVector shape;
        SUMOReal speed;
        SVCPermissions permissions;
        SVCPermissions preferred;
        SUMOReal endOffset;
        SUMOReal width;
        std::string origID;

    };


    struct Connection {
        Connection(int fromLane_, NBEdge* toEdge_, int toLane_)
            : fromLane(fromLane_), toEdge(toEdge_), toLane(toLane_),
              mayDefinitelyPass(false), keepClear(true), haveVia(false) { }

        ~Connection() { }


        int fromLane;
        NBEdge* toEdge;
        int toLane;
        std::string tlID;
        unsigned int tlLinkNo;
        bool mayDefinitelyPass;
        bool keepClear;


        std::string origID;

        std::string id;
        PositionVector shape;
        SUMOReal vmax;

        bool haveVia;
        std::string viaID;
        SUMOReal viaVmax;
        PositionVector viaShape;

        std::vector<unsigned int> foeInternalLinks;
        std::string foeIncomingLanes;

        unsigned int internalLaneIndex;

        std::string getInternalLaneID() const;

    };

    static std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from,
            const Position& to, SUMOReal laneCenterOffset);

    static const SUMOReal UNSPECIFIED_WIDTH;
    static const SUMOReal UNSPECIFIED_OFFSET;
    static const SUMOReal UNSPECIFIED_SPEED;

    static const SUMOReal UNSPECIFIED_LOADED_LENGTH;
    static const SUMOReal UNSPECIFIED_SIGNAL_OFFSET;
    static const SUMOReal ANGLE_LOOKAHEAD;

public:
    NBEdge(const std::string& id,
           NBNode* from, NBNode* to, std::string type,
           SUMOReal speed, unsigned int nolanes, int priority,
           SUMOReal width, SUMOReal offset,
           const std::string& streetName = "",
           LaneSpreadFunction spread = LANESPREAD_RIGHT);


    NBEdge(const std::string& id,
           NBNode* from, NBNode* to, std::string type,
           SUMOReal speed, unsigned int nolanes, int priority,
           SUMOReal width, SUMOReal offset,
           PositionVector geom,
           const std::string& streetName = "",
           LaneSpreadFunction spread = LANESPREAD_RIGHT,
           bool tryIgnoreNodePositions = false);

    NBEdge(const std::string& id,
           NBNode* from, NBNode* to,
           NBEdge* tpl,
           const PositionVector& geom = PositionVector(),
           int numLanes = -1);


    ~NBEdge();


    void reinit(NBNode* from, NBNode* to, const std::string& type,
                SUMOReal speed, unsigned int nolanes, int priority,
                PositionVector geom, SUMOReal width, SUMOReal offset,
                const std::string& streetName,
                LaneSpreadFunction spread = LANESPREAD_RIGHT,
                bool tryIgnoreNodePositions = false);

    void reinitNodes(NBNode* from, NBNode* to);



    void reshiftPosition(SUMOReal xoff, SUMOReal yoff);

    void mirrorX();



    unsigned int getNumLanes() const {
        return (unsigned int) myLanes.size();
    }


    int getPriority() const {
        return myPriority;
    }


    NBNode* getFromNode() const {
        return myFrom;
    }


    NBNode* getToNode() const {
        return myTo;
    }


    inline SUMOReal getStartAngle() const {
        return myStartAngle;
    }


    inline SUMOReal getEndAngle() const {
        return myEndAngle;
    }



    inline SUMOReal getTotalAngle() const {
        return myTotalAngle;
    }

    SUMOReal getLength() const {
        return myLength;
    }


    SUMOReal getLoadedLength() const {
        return myLoadedLength > 0 ? myLoadedLength : myLength;
    }


    bool hasLoadedLength() const {
        return myLoadedLength > 0;
    }


    SUMOReal getSpeed() const {
        return mySpeed;
    }


    EdgeBuildingStep getStep() const {
        return myStep;
    }


    SUMOReal getLaneWidth() const {
        return myLaneWidth;
    }

    SUMOReal getLaneWidth(int lane) const;


    SUMOReal getTotalWidth() const;

    const std::string& getStreetName() const {
        return myStreetName;
    }

    void setStreetName(const std::string& name) {
        myStreetName = name;
    }

    SUMOReal getEndOffset() const {
        return myEndOffset;
    }

    SUMOReal getEndOffset(int lane) const;

    SUMOReal getSignalOffset() const {
        return mySignalOffset;
    }

    void setSignalOffset(SUMOReal offset) {
        mySignalOffset = offset;
    }

    const std::vector<NBEdge::Lane>& getLanes() const {
        return myLanes;
    }

    int getFirstNonPedestrianLaneIndex(int direction, bool exclusive = false) const;
    NBEdge::Lane getFirstNonPedestrianLane(int direction) const;

    SUMOReal getCrossingAngle(NBNode* node);



    const PositionVector& getGeometry() const {
        return myGeom;
    }


    const PositionVector getInnerGeometry() const;


    bool hasDefaultGeometry() const;


    bool hasDefaultGeometryEndpoints() const;


    void setGeometry(const PositionVector& g, bool inner = false);


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

    void shiftPositionAtNode(NBNode* node, NBEdge* opposite);

    void computeEdgeShape();


    const PositionVector& getLaneShape(unsigned int i) const;


    void setLaneSpreadFunction(LaneSpreadFunction spread);


    LaneSpreadFunction getLaneSpreadFunction() const {
        return myLaneSpreadFunction;
    }


    bool splitGeometry(NBEdgeCont& ec, NBNodeCont& nc);


    void reduceGeometry(const SUMOReal minDist);


    void checkGeometry(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix);




    bool addEdge2EdgeConnection(NBEdge* dest);


    bool addLane2LaneConnection(unsigned int fromLane, NBEdge* dest,
                                unsigned int toLane, Lane2LaneInfoType type,
                                bool mayUseSameDestination = false,
                                bool mayDefinitelyPass = false,
                                bool keepClear = true);


    bool addLane2LaneConnections(unsigned int fromLane,
                                 NBEdge* dest, unsigned int toLane, unsigned int no,
                                 Lane2LaneInfoType type, bool invalidatePrevious = false,
                                 bool mayDefinitelyPass = false);


    void setConnection(unsigned int lane, NBEdge* destEdge,
                       unsigned int destLane,
                       Lane2LaneInfoType type,
                       bool mayUseSameDestination = false,
                       bool mayDefinitelyPass = false,
                       bool keepClear = true);



    std::vector<Connection> getConnectionsFromLane(unsigned int lane) const;


    bool hasConnectionTo(NBEdge* destEdge, unsigned int destLane, int fromLane = -1) const;


    bool isConnectedTo(NBEdge* e);


    const std::vector<Connection>& getConnections() const {
        return myConnections;
    }


    std::vector<Connection>& getConnections() {
        return myConnections;
    }


    const EdgeVector* getConnectedSorted();


    EdgeVector getConnectedEdges() const;


    std::vector<int> getConnectionLanes(NBEdge* currentOutgoing) const;


    void sortOutgoingConnectionsByAngle();


    void sortOutgoingConnectionsByIndex();


    void remapConnections(const EdgeVector& incoming);


    void removeFromConnections(NBEdge* toEdge, int fromLane = -1, int toLane = -1, bool tryLater = false);

    void invalidateConnections(bool reallowSetting = false);

    void replaceInConnections(NBEdge* which, NBEdge* by, unsigned int laneOff);
    void replaceInConnections(NBEdge* which, const std::vector<NBEdge::Connection>& origConns);
    void copyConnectionsFrom(NBEdge* src);

    void shiftToLanesToEdge(NBEdge* to, unsigned int laneOff);



    bool isTurningDirectionAt(const NBEdge* const edge) const;


    void setTurningDestination(NBEdge* e, bool onlyPossible = false);




    void setAsMacroscopicConnector() {
        myAmMacroscopicConnector = true;
    }


    bool isMacroscopicConnector() const {
        return myAmMacroscopicConnector;
    }


    void setIsInnerEdge() {
        myAmInnerEdge = true;
    }


    bool isInnerEdge() const {
        return myAmInnerEdge;
    }




    void setJunctionPriority(const NBNode* const node, int prio);


    int getJunctionPriority(const NBNode* const node) const;

    void setLoadedLength(SUMOReal val);
    void dismissVehicleClassInformation();


    const std::string& getTypeID() const {
        return myType;
    }

    bool needsLaneSpecificOutput() const;

    bool hasPermissions() const;

    bool hasLaneSpecificPermissions() const;

    bool hasLaneSpecificSpeed() const;

    bool hasLaneSpecificEndOffset() const;

    bool hasLaneSpecificWidth() const;

    bool computeEdge2Edges(bool noLeftMovers);

    bool computeLanes2Edges();

    bool recheckLanes();

    void appendTurnaround(bool noTLSControlled);



    NBNode* tryGetNodeAtPosition(SUMOReal pos, SUMOReal tolerance = 5.0) const;


    SUMOReal getMaxLaneOffset();

    bool lanesWereAssigned() const;

    bool mayBeTLSControlled(int fromLane, NBEdge* toEdge, int toLane) const;

    bool setControllingTLInformation(const NBConnection& c, const std::string& tlID);

    void clearControllingTLInformation();

    void addCrossingPointsAsIncomingWithGivenOutgoing(NBEdge* o,
            PositionVector& into);

    PositionVector getCWBoundaryLine(const NBNode& n) const;

    PositionVector getCCWBoundaryLine(const NBNode& n) const;

    bool expandableBy(NBEdge* possContinuation) const;
    void append(NBEdge* continuation);

    bool hasSignalisedConnectionTo(const NBEdge* const e) const;


    void moveOutgoingConnectionsFrom(NBEdge* e, unsigned int laneOff);

    /* @brief return the turn destination if it exists
     * @param[in] possibleDestination Wether myPossibleTurnDestination should be returned if no turnaround connection
     * exists
     */
    NBEdge* getTurnDestination(bool possibleDestination = false) const;

    std::string getLaneID(unsigned int lane) const;

    std::string getLaneIDInsecure(unsigned int lane) const;

    SUMOReal getLaneSpeed(unsigned int lane) const;

    bool isNearEnough2BeJoined2(NBEdge* e, SUMOReal threshold) const;


    SUMOReal getAngleAtNode(const NBNode* const node) const;


    SUMOReal getAngleAtNodeToCenter(const NBNode* const node) const;


    void incLaneNo(unsigned int by);

    void decLaneNo(unsigned int by, int dir = 0);

    void markAsInLane2LaneState();

    void addSidewalk(SUMOReal width);

    void addBikeLane(SUMOReal width);

    void setPermissions(SVCPermissions permissions, int lane = -1);

    void setPreferredVehicleClass(SVCPermissions permissions, int lane = -1);

    void allowVehicleClass(int lane, SUMOVehicleClass vclass);
    void disallowVehicleClass(int lane, SUMOVehicleClass vclass);

    void preferVehicleClass(int lane, SUMOVehicleClass vclass);


    void setLaneWidth(int lane, SUMOReal width);

    void setEndOffset(int lane, SUMOReal offset);

    void setSpeed(int lane, SUMOReal speed);

    SVCPermissions getPermissions(int lane = -1) const;

    void disableConnection4TLS(int fromLane, NBEdge* toEdge, int toLane);


    // returns a reference to the internal structure for the convenience of NETEDIT
    Lane& getLaneStruct(unsigned int lane) {
        return myLanes[lane];
    }

    // returns a reference to the internal structure for the convenience of NETEDIT
    const Lane& getLaneStruct(unsigned int lane) const {
        return myLanes[lane];
    }

    /* declares connections as fully loaded. This is needed to avoid recomputing connections
    * if an edge has no connections intentionally. */
    void declareConnectionsAsLoaded() {
        myStep = LANES2LANES_USER;
    }

    /* @brief fill connection attributes shape, viaShape, ...
     *
     * @param[in,out] edgeIndex The number of connections already handled
     * @param[in,out] splitIndex The number of via edges already built
     * @param[in] tryIgnoreNodePositions Does not add node geometries if geom.size()>=2
     */
    void buildInnerEdges(const NBNode& n, unsigned int noInternalNoSplits, unsigned int& linkIndex, unsigned int& splitIndex);

    inline const std::vector<NBSign>& getSigns() const {
        return mySigns;
    }

    inline void addSign(NBSign sign) {
        mySigns.push_back(sign);
    }

    PositionVector cutAtIntersection(const PositionVector& old) const;

private:
    class ToEdgeConnectionsAdder : public Bresenham::BresenhamCallBack {
    private:
        std::map<NBEdge*, std::vector<unsigned int> > myConnections;

        const EdgeVector& myTransitions;

    public:
        ToEdgeConnectionsAdder(const EdgeVector& transitions)
            : myTransitions(transitions) { }

        ~ToEdgeConnectionsAdder() { }

        void execute(const unsigned int lane, const unsigned int virtEdge);

        const std::map<NBEdge*, std::vector<unsigned int> >& getBuiltConnections() const {
            return myConnections;
        }

    private:
        ToEdgeConnectionsAdder(const ToEdgeConnectionsAdder&);

        ToEdgeConnectionsAdder& operator=(const ToEdgeConnectionsAdder&);

    };


    class MainDirections {
    public:
        enum Direction { DIR_RIGHTMOST, DIR_LEFTMOST, DIR_FORWARD };

        std::vector<Direction> myDirs;

    public:
        MainDirections(const EdgeVector& outgoing,
                       NBEdge* parent, NBNode* to);

        ~MainDirections();

        bool empty() const;

        bool includes(Direction d) const;

    private:
        MainDirections(const MainDirections&);

        MainDirections& operator=(const MainDirections&);

    };

    PositionVector computeLaneShape(unsigned int lane, SUMOReal offset) const;

    //std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from, const Position& to, SUMOReal laneCenterOffset);

    void computeLaneShapes();



private:
    void init(unsigned int noLanes, bool tryIgnoreNodePositions);


    void divideOnEdges(const EdgeVector* outgoing);
    void divideSelectedLanesOnEdges(const EdgeVector* outgoing, const std::vector<int>& availableLanes,
                                    const std::vector<unsigned int>* priorities);

    std::vector<unsigned int>* prepareEdgePriorities(
        const EdgeVector* outgoing);

    static unsigned int computePrioritySum(const std::vector<unsigned int>& priorities);



    void moveConnectionToLeft(unsigned int lane);

    void moveConnectionToRight(unsigned int lane);

    bool canMoveConnection(const Connection& con, unsigned int newFromLane) const;


    PositionVector startShapeAt(const PositionVector& laneShape, const NBNode* startNode) const;

    void computeAngle();


    /* @brief compute the first intersection point between the given lane
     * geometries considering their rspective widths */
    static SUMOReal firstIntersection(const PositionVector& v1, const PositionVector& v2, SUMOReal width2);


    void addRestrictedLane(SUMOReal width, SUMOVehicleClass vclass);

private:
    EdgeBuildingStep myStep;

    std::string myType;

    NBNode* myFrom, *myTo;

    SUMOReal myLength;

    SUMOReal myStartAngle;
    SUMOReal myEndAngle;
    SUMOReal myTotalAngle;

    int myPriority;

    SUMOReal mySpeed;

    std::vector<Connection> myConnections;

    std::vector<Connection> myConnectionsToDelete;

    NBEdge* myTurnDestination;
    NBEdge* myPossibleTurnDestination;

    int myFromJunctionPriority;

    int myToJunctionPriority;

    PositionVector myGeom;

    LaneSpreadFunction myLaneSpreadFunction;

    SUMOReal myEndOffset;

    SUMOReal myLaneWidth;

    std::vector<Lane> myLanes;

    SUMOReal myLoadedLength;

    bool myAmInnerEdge;

    bool myAmMacroscopicConnector;

    struct TLSDisabledConnection {
        int fromLane;
        NBEdge* to;
        int toLane;
    };

    std::vector<TLSDisabledConnection> myTLSDisabledConnections;


    std::string myStreetName;


    std::vector<NBSign> mySigns;

    SUMOReal mySignalOffset;

public:
    class tls_disable_finder {
    public:
        tls_disable_finder(const TLSDisabledConnection& tpl) : myDefinition(tpl) { }

        bool operator()(const TLSDisabledConnection& e) const {
            if (e.to != myDefinition.to) {
                return false;
            }
            if (e.fromLane != myDefinition.fromLane) {
                return false;
            }
            if (e.toLane != myDefinition.toLane) {
                return false;
            }
            return true;
        }

    private:
        TLSDisabledConnection myDefinition;

    private:
        tls_disable_finder& operator=(const tls_disable_finder& s);

    };



    class connections_toedge_finder {
    public:
        connections_toedge_finder(NBEdge* const edge2find, bool hasFromLane = false) :
            myHasFromLane(hasFromLane),
            myEdge2Find(edge2find) { }

        bool operator()(const Connection& c) const {
            return c.toEdge == myEdge2Find && (!myHasFromLane || c.fromLane != -1);
        }

    private:
        const bool myHasFromLane;
        NBEdge* const myEdge2Find;

    private:
        connections_toedge_finder& operator=(const connections_toedge_finder& s);

    };

    class connections_toedgelane_finder {
    public:
        connections_toedgelane_finder(NBEdge* const edge2find, int lane2find, int fromLane2find) :
            myEdge2Find(edge2find),
            myLane2Find(lane2find),
            myFromLane2Find(fromLane2find) { }

        bool operator()(const Connection& c) const {
            return c.toEdge == myEdge2Find && c.toLane == myLane2Find && (myFromLane2Find < 0 || c.fromLane == myFromLane2Find);
        }

    private:
        NBEdge* const myEdge2Find;
        int myLane2Find;
        int myFromLane2Find;

    private:
        connections_toedgelane_finder& operator=(const connections_toedgelane_finder& s);

    };


    class connections_finder {
    public:
        connections_finder(int fromLane, NBEdge* const edge2find, int lane2find) : myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find) { }

        bool operator()(const Connection& c) const {
            return c.fromLane == myFromLane && c.toEdge == myEdge2Find && c.toLane == myLane2Find;
        }

    private:
        int myFromLane;
        NBEdge* const myEdge2Find;
        int myLane2Find;

    private:
        connections_finder& operator=(const connections_finder& s);

    };

    class connections_fromlane_finder {
    public:
        connections_fromlane_finder(int lane2find) : myLane2Find(lane2find) { }

        bool operator()(const Connection& c) const {
            return c.fromLane == myLane2Find;
        }

    private:
        int myLane2Find;

    private:
        connections_fromlane_finder& operator=(const connections_fromlane_finder& s);

    };

    static bool connections_sorter(const Connection& c1, const Connection& c2);

    class connections_relative_edgelane_sorter {
    public:
        explicit connections_relative_edgelane_sorter(NBEdge* e) : myEdge(e) {}

    public:
        int operator()(const Connection& c1, const Connection& c2) const;

    private:
        NBEdge* myEdge;
    };

private:
    NBEdge(const NBEdge& s);

    NBEdge& operator=(const NBEdge& s);


};


#endif

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