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-2017 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 <cassert>
#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/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 NBEdgeCont;

    friend class GNELane;
    friend class GNEEdge;
    friend class GNEJunction;

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, const std::string& _origID);

        PositionVector shape;

        double speed;

        SVCPermissions permissions;

        SVCPermissions preferred;

        double endOffset;

        double width;

        std::string origID;

        std::string oppositeID;

        bool accelRamp;

        // @note (see NIImporter_DlrNavteq::ConnectedLanesHandler)
        bool connectionsDone;

        PositionVector customShape;
    };


    struct Connection {
        Connection(int fromLane_, NBEdge* toEdge_, int toLane_);

        Connection(int fromLane_, NBEdge* toEdge_, int toLane_, bool mayDefinitelyPass_,
                   bool keepClear_ = true,
                   double contPos_ = UNSPECIFIED_CONTPOS,
                   double visibility_ = UNSPECIFIED_VISIBILITY_DISTANCE,
                   bool haveVia_ = false,
                   bool uncontrolled_ = false);

        ~Connection() { }

        int fromLane;

        NBEdge* toEdge;

        int toLane;

        std::string tlID;

        int tlLinkNo;

        bool mayDefinitelyPass;

        bool keepClear;

        double contPos;

        double visibility;

        std::string origID;

        std::string id;

        PositionVector shape;

        double vmax;

        bool haveVia;

        std::string viaID;

        double viaVmax;

        PositionVector viaShape;

        std::vector<int> foeInternalLinks;

        std::string foeIncomingLanes;

        int internalLaneIndex;

        bool uncontrolled;

        std::string getInternalLaneID() const;

        std::string getDescription(const NBEdge* parent) const;
    };


    static const double UNSPECIFIED_WIDTH;

    static const double UNSPECIFIED_OFFSET;

    static const double UNSPECIFIED_SPEED;

    static const double UNSPECIFIED_CONTPOS;

    static const double UNSPECIFIED_VISIBILITY_DISTANCE;

    static const double UNSPECIFIED_LOADED_LENGTH;

    static const double UNSPECIFIED_SIGNAL_OFFSET;

    static const double ANGLE_LOOKAHEAD;
    static const int UNSPECIFIED_INTERNAL_LANE_INDEX;

    enum JunctionPriority {
        MINOR_ROAD = 0,
        PRIORITY_ROAD = 1,
        ROUNDABOUT = 1000
    };

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


    NBEdge(const std::string& id,
           NBNode* from, NBNode* to, std::string type,
           double speed, int nolanes, int priority,
           double width, double offset,
           PositionVector geom,
           const std::string& streetName = "",
           const std::string& origID = "",
           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,
                double speed, int nolanes, int priority,
                PositionVector geom, double width, double offset,
                const std::string& streetName,
                LaneSpreadFunction spread = LANESPREAD_RIGHT,
                bool tryIgnoreNodePositions = false);

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


    void reshiftPosition(double xoff, double yoff);

    void mirrorX();



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

    int getPriority() const {
        return myPriority;
    }

    NBNode* getFromNode() const {
        return myFrom;
    }

    NBNode* getToNode() const {
        return myTo;
    }

    inline double getStartAngle() const {
        return myStartAngle;
    }

    inline double getEndAngle() const {
        return myEndAngle;
    }

    double getShapeStartAngle() const;


    double getShapeEndAngle() const;

    inline double getTotalAngle() const {
        return myTotalAngle;
    }

    double getLength() const {
        return myLength;
    }


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

    double getFinalLength() const;

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

    double getSpeed() const {
        return mySpeed;
    }

    EdgeBuildingStep getStep() const {
        return myStep;
    }

    double getLaneWidth() const {
        return myLaneWidth;
    }

    double getLaneWidth(int lane) const;

    double getTotalWidth() const;

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

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

    double getEndOffset() const {
        return myEndOffset;
    }

    double getEndOffset(int lane) const;

    double getSignalOffset() const {
        return mySignalOffset;
    }

    void setSignalOffset(double 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;

    std::set<SVCPermissions> getPermissionVariants(int iStart, int iEnd) const;

    double getCrossingAngle(NBNode* node);



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

    const PositionVector getInnerGeometry() const;

    bool hasDefaultGeometry() const;

    bool hasDefaultGeometryEndpoints() const;

    bool hasDefaultGeometryEndpointAtNode(const NBNode* node) const;

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

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

    void extendGeometryAtNode(const NBNode* node, double maxExtent);

    void shortenGeometryAtNode(const NBNode* node, double reduction);

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

    void computeEdgeShape();

    const PositionVector& getLaneShape(int i) const;

    void setLaneSpreadFunction(LaneSpreadFunction spread);

    LaneSpreadFunction getLaneSpreadFunction() const {
        return myLaneSpreadFunction;
    }

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

    void reduceGeometry(const double minDist);

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


    bool addEdge2EdgeConnection(NBEdge* dest);

    bool addLane2LaneConnection(int fromLane, NBEdge* dest,
                                int toLane, Lane2LaneInfoType type,
                                bool mayUseSameDestination = false,
                                bool mayDefinitelyPass = false,
                                bool keepClear = true,
                                double contPos = UNSPECIFIED_CONTPOS,
                                double visibility = UNSPECIFIED_VISIBILITY_DISTANCE);

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

    bool setConnection(int lane, NBEdge* destEdge,
                       int destLane,
                       Lane2LaneInfoType type,
                       bool mayUseSameDestination = false,
                       bool mayDefinitelyPass = false,
                       bool keepClear = true,
                       double contPos = UNSPECIFIED_CONTPOS,
                       double visibility = UNSPECIFIED_VISIBILITY_DISTANCE);

    void insertConnection(NBEdge::Connection connection);

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

    Connection getConnection(int fromLane, const NBEdge* to, int toLane) const;

    Connection& getConnectionRef(int fromLane, const NBEdge* to, int toLane);

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

    bool isConnectedTo(const NBEdge* e) const;

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

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

    const EdgeVector* getConnectedSorted();

    EdgeVector getConnectedEdges() const;

    EdgeVector getIncomingEdges() 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, const bool adaptToLaneRemoval = false);

    bool removeFromConnections(NBEdge::Connection connectionToRemove);

    void invalidateConnections(bool reallowSetting = false);

    void replaceInConnections(NBEdge* which, NBEdge* by, int laneOff);

    void replaceInConnections(NBEdge* which, const std::vector<NBEdge::Connection>& origConns);

    void copyConnectionsFrom(NBEdge* src);

    void shiftToLanesToEdge(NBEdge* to, 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(double val);

    void dismissVehicleClassInformation();

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

    bool needsLaneSpecificOutput() const;

    bool hasPermissions() const;

    bool hasLaneSpecificPermissions() const;

    bool hasLaneSpecificSpeed() const;

    bool hasLaneSpecificWidth() const;

    bool hasLaneSpecificEndOffset() const;

    bool hasAccelLane() const;

    bool hasCustomLaneShape() const;

    bool computeEdge2Edges(bool noLeftMovers);

    bool computeLanes2Edges();

    bool recheckLanes();

    void appendTurnaround(bool noTLSControlled, bool checkPermissions);

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

    double 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, std::string& reason) const;

    void append(NBEdge* continuation);

    bool hasSignalisedConnectionTo(const NBEdge* const e) const;

    void moveOutgoingConnectionsFrom(NBEdge* e, 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(int lane) const;

    std::string getLaneIDInsecure(int lane) const;

    double getLaneSpeed(int lane) const;

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

    double getAngleAtNode(const NBNode* const node) const;

    double getAngleAtNodeToCenter(const NBNode* const node) const;

    void incLaneNo(int by);

    void decLaneNo(int by);

    void deleteLane(int index, bool recompute = true);

    void addLane(int index, bool recompute = true);

    void markAsInLane2LaneState();

    void addSidewalk(double width);

    void restoreSidewalk(std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);

    void addBikeLane(double width);

    void restoreBikelane(std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);

    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, double width);

    void setEndOffset(int lane, double offset);

    void setSpeed(int lane, double speed);

    void setAcceleration(int lane, bool accelRamp);

    void setLaneShape(int lane, const PositionVector& shape);

    SVCPermissions getPermissions(int lane = -1) const;

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

    // @brief returns a reference to the internal structure for the convenience of NETEDIT
    Lane& getLaneStruct(int lane) {
        assert(lane >= 0);
        assert(lane < (int)myLanes.size());
        return myLanes[lane];
    }

    // @brief returns a reference to the internal structure for the convenience of NETEDIT
    const Lane& getLaneStruct(int lane) const {
        assert(lane >= 0);
        assert(lane < (int)myLanes.size());
        return myLanes[lane];
    }

    void declareConnectionsAsLoaded(EdgeBuildingStep step = LANES2LANES_USER) {
        myStep = step;
    }

    /* @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, int noInternalNoSplits, int& linkIndex, 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;

    void setNodeBorder(const NBNode* node, const Position& p, const Position& p2, bool rectangularCut);
    void resetNodeBorder(const NBNode* node);

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

        const EdgeVector& myTransitions;

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

        ~ToEdgeConnectionsAdder() { }

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

        const std::map<NBEdge*, std::vector<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, int indexOfStraightest);

        ~MainDirections();

        bool empty() const;

        bool includes(Direction d) const;

    private:
        MainDirections(const MainDirections&);

        MainDirections& operator=(const MainDirections&);
    };

    PositionVector computeLaneShape(int lane, double offset) const;

    void computeLaneShapes();

private:
    void init(int noLanes, bool tryIgnoreNodePositions, const std::string& origID);

    void divideOnEdges(const EdgeVector* outgoing);

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

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

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

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


    void moveConnectionToLeft(int lane);

    void moveConnectionToRight(int lane);

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

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

    void computeAngle();

    static double firstIntersection(const PositionVector& v1, const PositionVector& v2, double width2);

    void addRestrictedLane(double width, SUMOVehicleClass vclass);

    void restoreRestrictedLane(SUMOVehicleClass vclass, std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);

private:
    EdgeBuildingStep myStep;

    std::string myType;

    NBNode* myFrom, *myTo;

    double myLength;

    double myStartAngle;
    double myEndAngle;
    double myTotalAngle;

    int myPriority;

    double mySpeed;

    std::vector<Connection> myConnections;

    std::vector<Connection> myConnectionsToDelete;

    NBEdge* myTurnDestination;

    NBEdge* myPossibleTurnDestination;

    int myFromJunctionPriority;

    int myToJunctionPriority;

    PositionVector myGeom;

    LaneSpreadFunction myLaneSpreadFunction;

    double myEndOffset;

    double myLaneWidth;

    std::vector<Lane> myLanes;

    double myLoadedLength;

    bool myAmInnerEdge;

    bool myAmMacroscopicConnector;

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

    std::vector<TLSDisabledConnection> myTLSDisabledConnections;

    std::string myStreetName;

    std::vector<NBSign> mySigns;

    double mySignalOffset;

    PositionVector myFromBorder;
    PositionVector myToBorder;

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

        const 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, bool invertEdge2find = false) :
            myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find), myInvertEdge2find(invertEdge2find) { }

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

    private:
        int myFromLane;

        NBEdge* const myEdge2Find;

        int myLane2Find;

        bool myInvertEdge2find;

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

    };

    class connections_conflict_finder {
    public:
        connections_conflict_finder(int fromLane, NBEdge* const edge2find, bool checkRight) :
            myFromLane(fromLane), myEdge2Find(edge2find), myCheckRight(checkRight) { }

        bool operator()(const Connection& c) const {
            return (((myCheckRight && c.fromLane < myFromLane) || (!myCheckRight && c.fromLane > myFromLane))
                    && c.fromLane >= 0 // already assigned
                    && c.toEdge == myEdge2Find);
        }

    private:
        int myFromLane;

        NBEdge* const myEdge2Find;

        bool myCheckRight;

    private:
        connections_conflict_finder& operator=(const connections_conflict_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

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