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.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 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 "NBCont.h"
#include <utils/common/Named.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 "NBHelpers.h"


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


// ===========================================================================
// class definitions
// ===========================================================================
class NBEdge : public Named {
    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 {
        PositionVector shape;
        SUMOReal speed;
        SUMOVehicleClasses allowed;
        SUMOVehicleClasses notAllowed;
        SUMOVehicleClasses preferred;
        SUMOReal offset;
        SUMOReal width;
    };


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

        ~Connection() { }


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


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

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

        std::string crossingNames;
        std::string sourceNames;

    };

    static std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from,
            const Position& to, SUMOReal lanewidth, unsigned int lane,
            size_t noLanes, LaneSpreadFunction lsf, bool leftHand);

    static const SUMOReal UNSPECIFIED_WIDTH;
    static const SUMOReal UNSPECIFIED_OFFSET;
    static const SUMOReal UNSPECIFIED_LOADED_LENGTH;


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


    ~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 reshiftPosition(SUMOReal xoff, SUMOReal yoff) ;



    void setLeftHanded() {
        myAmLeftHand = true;
    }




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


    int getPriority() const {
        return myPriority;
    }


    NBNode* getFromNode() const {
        return myFrom;
    }


    NBNode* getToNode() const {
        return myTo;
    }


    SUMOReal getAngle() const {
        return myAngle;
    }


    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 getWidth() const {
        return myWidth;
    }


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

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

    SUMOReal getOffset() const {
        return myOffset;
    }


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


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





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


    const PositionVector& getLaneShape(unsigned int i) const ;


    void setLaneSpreadFunction(LaneSpreadFunction spread) ;


    LaneSpreadFunction getLaneSpreadFunction() const {
        return myLaneSpreadFunction;
    }


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




    bool addEdge2EdgeConnection(NBEdge* dest);


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


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



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


    bool hasConnectionTo(NBEdge* destEdge, unsigned int destLane) 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);

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



    bool isTurningDirectionAt(const NBNode* n, const NBEdge* const edge) const ;
    void setTurningDestination(NBEdge* e);




    void setAsMacroscopicConnector() {
        myAmMacroscopicConnector = true;
    }


    bool isMacroscopicConnector() const {
        return myAmMacroscopicConnector;
    }


    void setIsInnerEdge() {
        myAmInnerEdge = true;
    }


    bool isInnerEdge() const {
        return myAmInnerEdge;
    }




    void computeTurningDirections();


    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 hasRestrictions() const;

    bool hasLaneSpecificAllow() const;

    bool hasLaneSpecificDisallow() const;

    bool hasLaneSpecificSpeed() const;

    bool hasLaneSpecificOffset() 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();

    Position getMinLaneOffsetPositionAt(NBNode* node, SUMOReal width) const;
    Position getMaxLaneOffsetPositionAt(NBNode* node, SUMOReal width) const;


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

    SUMOReal width() const;

    PositionVector getCWBoundaryLine(const NBNode& n, SUMOReal offset) const;
    PositionVector getCCWBoundaryLine(const NBNode& n, SUMOReal offset) const;

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

    bool hasSignalisedConnectionTo(const NBEdge* const e) const ;


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

    NBEdge* getTurnDestination() const;

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

    SUMOReal getLaneSpeed(unsigned int lane) const;

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

    SUMOReal getAngle(const NBNode& atNode) const;

    SUMOReal getNormedAngle(const NBNode& atNode) const;


    void incLaneNo(unsigned int by);

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

    void markAsInLane2LaneState();

    void setVehicleClasses(const SUMOVehicleClasses& allowed, const SUMOVehicleClasses& disallowed, int lane = -1);

    void allowVehicleClass(int lane, SUMOVehicleClass vclass);

    void disallowVehicleClass(int lane, SUMOVehicleClass vclass);

    void preferVehicleClass(int lane, SUMOVehicleClass vclass);

    void setWidth(int lane, SUMOReal width);

    void setOffset(int lane, SUMOReal offset);

    void setSpeed(int lane, SUMOReal offset);

    SUMOVehicleClasses getAllowedVehicleClasses() const;

    SUMOVehicleClasses getDisallowedVehicleClasses() const;

    SUMOVehicleClasses getAllowedVehicleClasses(unsigned int lane) const;

    SUMOVehicleClasses getDisallowedVehicleClasses(unsigned int lane) 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;
    }

    void buildInnerEdges(const NBNode& n, unsigned int noInternalNoSplits, unsigned int& lno, unsigned int& splitNo);


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) throw(InvalidArgument);

    std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from,
            const Position& to, SUMOReal lanewidth, unsigned int lane) throw(InvalidArgument);

    void computeLaneShapes() ;

protected:
    bool acceptBeingTurning(NBEdge* e);


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


    void divideOnEdges(const EdgeVector* outgoing);

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

    unsigned int computePrioritySum(std::vector<unsigned int> *priorities);



    void moveConnectionToLeft(unsigned int lane);

    void moveConnectionToRight(unsigned int lane);


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


private:
    EdgeBuildingStep myStep;

    std::string myType;

    NBNode* myFrom, *myTo;

    SUMOReal myLength;

    SUMOReal myAngle;

    int myPriority;

    SUMOReal mySpeed;

    std::vector<Connection> myConnections;

    NBEdge* myTurnDestination;

    int myFromJunctionPriority;

    int myToJunctionPriority;

    PositionVector myGeom;

    LaneSpreadFunction myLaneSpreadFunction;

    SUMOReal myOffset;

    SUMOReal myWidth;

    std::vector<Lane> myLanes;

    SUMOReal myLoadedLength;

    bool myAmLeftHand;



    SUMOReal myAmTurningWithAngle;
    NBEdge* myAmTurningOf;

    bool myAmInnerEdge;

    bool myAmMacroscopicConnector;

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

    std::vector<TLSDisabledConnection> myTLSDisabledConnections;


    std::string myStreetName;


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) : myEdge2Find(edge2find) { }

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

    private:
        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) : myEdge2Find(edge2find), myLane2Find(lane2find) { }

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

    private:
        NBEdge* const myEdge2Find;
        int myLane2Find;

    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) {
        if (c1.fromLane != c2.fromLane) {
            return c1.fromLane < c2.fromLane;
        }
        if (c1.toEdge != c2.toEdge) {
            return c1.toEdge->getID().compare(c1.toEdge->getID()) < 0;
        }
        return c1.toLane < c2.toLane;
    }

    class connections_relative_edgelane_sorter {
    public:
        explicit connections_relative_edgelane_sorter(NBEdge* e, NBNode* n)
            : myEdge(e), myNode(n) {}

    public:
        int operator()(const Connection& c1, const Connection& c2) const {
            if (c1.toEdge != c2.toEdge) {
                SUMOReal relAngle1 = NBHelpers::normRelAngle(
                                         myEdge->getAngle(), c1.toEdge->getAngle());
                SUMOReal relAngle2 = NBHelpers::normRelAngle(
                                         myEdge->getAngle(), c2.toEdge->getAngle());
                return relAngle1 > relAngle2;
            }
            return c1.toLane < c2.toLane;
        }

    private:
        NBEdge* myEdge;

        NBNode* myNode;

    };

private:
    NBEdge(const NBEdge& s);

    NBEdge& operator=(const NBEdge& s);


};


#endif

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