NBEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// The representation of a single edge during network building
/****************************************************************************/
#pragma once
#include <config.h>
 
#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 NBVehicle;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBRouterEdge {
public:
    virtual ~NBRouterEdge() {}
    virtual const std::string& getID() const = 0;
    virtual double getSpeed() const = 0;
    virtual double getLength() const = 0;
    virtual const NBRouterEdge* getBidiEdge() const = 0;
    virtual int getNumericalID() const = 0;
    virtual const ConstRouterEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const = 0;
    virtual bool isInternal() const {
        return false;
    }
    inline bool prohibits(const NBVehicle* const /*veh*/) const {
        return false;
    }
    inline bool restricts(const NBVehicle* const /*veh*/) const {
        return false;
    }
 
 
    static inline double getTravelTimeStatic(const NBRouterEdge* const edge, const NBVehicle* const /*veh*/, double /*time*/) {
        return edge->getLength() / edge->getSpeed();
    }
};
 
 
class NBEdge : public Named, public Parameterised, public NBRouterEdge {
    friend class NBEdgeCont;
 
    friend class GNELane;
    friend class GNEEdge;
    friend class GNEJunction;
 
public:
 
    enum class EdgeBuildingStep {
        INIT_REJECT_CONNECTIONS,
        INIT,
        EDGE2EDGES,
        LANES2EDGES,
        LANES2LANES_RECHECK,
        LANES2LANES_DONE,
        LANES2LANES_USER
    };
 
 
    enum class Lane2LaneInfoType {
        COMPUTED,
        USER,
        VALIDATED
    };
 
 
    struct Lane final : public Parameterised {
        Lane(NBEdge* e, const std::string& _origID);
 
        PositionVector shape;
 
        double speed;
 
        double friction;
 
        SVCPermissions permissions;
 
        SVCPermissions preferred;
 
        SVCPermissions changeLeft;
 
        SVCPermissions changeRight;
 
        double endOffset;
 
        StopOffset laneStopOffset;
 
        double width;
 
        std::string oppositeID;
 
        bool accelRamp;
 
        // @note (see NIImporter_DlrNavteq::ConnectedLanesHandler)
        bool connectionsDone;
 
        PositionVector customShape;
 
        std::string type;
 
        int turnSigns = 0;
    };
 
    struct Connection final : public Parameterised, public NBRouterEdge {
        Connection(int fromLane_, NBEdge* toEdge_, int toLane_, const bool mayDefinitelyPass_ = false);
 
        int fromLane;
 
        NBEdge* toEdge;
 
        int toLane;
 
        std::string tlID;
 
        int tlLinkIndex = -1;
 
        int tlLinkIndex2 = -1;
 
        bool mayDefinitelyPass;
 
        KeepClear keepClear = KEEPCLEAR_UNSPECIFIED;
 
        double contPos = UNSPECIFIED_CONTPOS;
 
        double visibility = UNSPECIFIED_VISIBILITY_DISTANCE;
 
        double speed = UNSPECIFIED_SPEED;
 
        // @brief custom friction for connection
        double friction = UNSPECIFIED_FRICTION;
 
        double customLength;
 
        PositionVector customShape;
 
        SVCPermissions permissions = SVC_UNSPECIFIED;
 
        SVCPermissions changeLeft = SVC_UNSPECIFIED;
 
        SVCPermissions changeRight = SVC_UNSPECIFIED;
 
        bool indirectLeft = false;
 
        std::string edgeType;
 
        std::string id;
 
        PositionVector shape;
 
        double vmax = UNSPECIFIED_SPEED;
 
        bool haveVia = false;
 
        std::string viaID;
 
        PositionVector viaShape;
 
        double viaLength = 0.;
 
        std::vector<int> foeInternalLinks;
 
        std::vector<std::string> foeIncomingLanes;
 
        int internalLaneIndex = UNSPECIFIED_INTERNAL_LANE_INDEX;
        int internalViaLaneIndex = 0;
 
        bool uncontrolled = false;
 
        std::string getInternalLaneID() const;
 
        std::string getInternalViaLaneID() const;
 
        std::string getDescription(const NBEdge* parent) const;
 
        double length = UNSPECIFIED_LOADED_LENGTH;
 
        static ConstRouterEdgePairVector myViaSuccessors; // always empty
        const std::string& getID() const {
            return id;
        }
        double getSpeed() const {
            return vmax;
        }
        // @brief needed for NBRouterEdge
        double getLength() const {
            return shape.length() + viaShape.length();
        }
        int getNumericalID() const {
            throw ProcessError("NBEdge::Connection does not implement getNumericalID()");
        }
        const Connection* getBidiEdge() const {
            return nullptr;
        }
        bool isInternal() const {
            return true;
        }
        const ConstRouterEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const {
            UNUSED_PARAMETER(vClass);
            UNUSED_PARAMETER(ignoreTransientPermissions);
            return myViaSuccessors;
        }
    };
 
    static NBEdge DummyEdge;
 
    static const double UNSPECIFIED_WIDTH;
 
    static const double UNSPECIFIED_OFFSET;
 
    static const double UNSPECIFIED_SPEED;
 
    static const double UNSPECIFIED_FRICTION;
 
    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;
 
    static const bool UNSPECIFIED_CONNECTION_UNCONTROLLED;
 
    static const int TURN_SIGN_SHIFT_BUS = 8;
    static const int TURN_SIGN_SHIFT_TAXI = 16;
    static const int TURN_SIGN_SHIFT_BICYCLE = 24;
 
    enum JunctionPriority {
        MINOR_ROAD = 0,
        PRIORITY_ROAD = 1,
        ROUNDABOUT = 1000
    };
 
    static void setDefaultConnectionLength(double length) {
        myDefaultConnectionLength = length;
    }
 
public:
    NBEdge(const std::string& id,
           NBNode* from, NBNode* to, std::string type,
           double speed, double friction, int nolanes, int priority,
           double width, double endOffset,
           LaneSpreadFunction spread,
           const std::string& streetName = "");
 
    NBEdge(const std::string& id,
           NBNode* from, NBNode* to, std::string type,
           double speed, double friction, int nolanes, int priority,
           double width, double endOffset,
           PositionVector geom,
           LaneSpreadFunction spread,
           const std::string& streetName = "",
           const std::string& origID = "",
           bool tryIgnoreNodePositions = false);
 
    NBEdge(const std::string& id,
           NBNode* from, NBNode* to,
           const NBEdge* tpl,
           const PositionVector& geom = PositionVector(),
           int numLanes = -1);
 
    ~NBEdge();
 
 
    void reinit(NBNode* from, NBNode* to, const std::string& type,
                double speed, double friction, int nolanes, int priority,
                PositionVector geom, double width, double endOffset,
                const std::string& streetName,
                LaneSpreadFunction spread,
                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;
    }
 
    void setPriority(int priority) {
        myPriority = priority;
    }
 
    inline NBNode* getFromNode() const {
        return myFrom;
    }
 
    inline 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;
    }
 
    double getFriction() const {
        return myFriction;
    }
 
    EdgeBuildingStep getStep() const {
        return myStep;
    }
 
    double getLaneWidth() const {
        return myLaneWidth;
    }
 
    double getLaneWidth(int lane) const;
 
    double getInternalLaneWidth(
        const NBNode& node,
        const NBEdge::Connection& connection,
        const NBEdge::Lane& successor,
        bool isVia) const;
 
    double getTotalWidth() const;
 
    const std::string& getStreetName() const {
        return myStreetName;
    }
 
    void setStreetName(const std::string& name) {
        myStreetName = name;
    }
 
    double getDistance() const {
        return myDistance;
    }
 
    double getDistancAt(double pos) const;
 
    double getEndOffset() const {
        return myEndOffset;
    }
 
    double getEndOffset(int lane) const;
 
    const StopOffset& getEdgeStopOffset() const;
 
    const StopOffset& getLaneStopOffset(int lane) const;
 
    double getSignalOffset() const;
 
    const Position& getSignalPosition() const {
        return mySignalPosition;
    }
 
    const NBNode* getSignalNode() const {
        return mySignalNode;
    }
 
    void setSignalPosition(const Position& pos, const NBNode* signalNode) {
        mySignalPosition = pos;
        mySignalNode = signalNode;
    }
 
    const std::vector<NBEdge::Lane>& getLanes() const {
        return myLanes;
    }
 
    int getFirstNonPedestrianLaneIndex(int direction, bool exclusive = false) const;
 
    int getFirstNonPedestrianNonBicycleLaneIndex(int direction, bool exclusive = false) const;
 
    int getSpecialLane(SVCPermissions permissions) const;
 
    int getFirstAllowedLaneIndex(int direction) const;
 
    NBEdge::Lane getFirstNonPedestrianLane(int direction) const;
 
    std::set<SVCPermissions> getPermissionVariants(int iStart, int iEnd) const;
 
    /* @brief get lane indices that allow the given permissions
     * @param[in] allPermissions: whether all the given permissions must be allowed (or just some of them)
     */
    int getNumLanesThatAllow(SVCPermissions permissions, bool allPermissions = true) const;
 
    bool allowsChangingLeft(int lane, SUMOVehicleClass vclass) const;
 
    bool allowsChangingRight(int lane, SUMOVehicleClass vclass) const;
 
    double getCrossingAngle(NBNode* node);
 
    std::string getSidewalkID();
 
 
 
    const PositionVector& getGeometry() const {
        return myGeom;
    }
 
    const PositionVector getInnerGeometry() const;
 
    bool hasDefaultGeometry() const;
 
    bool hasDefaultGeometryEndpoints() const;
 
    bool hasDefaultGeometryEndpointAtNode(const NBNode* node) const;
 
    Position getEndpointAtNode(const NBNode* node) const;
 
    void resetEndpointAtNode(const NBNode* node);
 
    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);
 
    Position geometryPositionAtOffset(double offset) const;
 
    void computeEdgeShape(double smoothElevationThreshold = -1);
 
    const PositionVector& getLaneShape(int i) const;
 
    void setLaneSpreadFunction(LaneSpreadFunction spread);
 
    LaneSpreadFunction getLaneSpreadFunction() const;
 
    void reduceGeometry(const double minDist);
 
    void checkGeometry(const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool silent);
 
 
    bool addEdge2EdgeConnection(NBEdge* dest, bool overrideRemoval = false, SVCPermissions permission = SVC_UNSPECIFIED);
 
    bool addLane2LaneConnection(int fromLane, NBEdge* dest,
                                int toLane, Lane2LaneInfoType type,
                                bool mayUseSameDestination = false,
                                bool mayDefinitelyPass = false,
                                KeepClear keepClear = KEEPCLEAR_UNSPECIFIED,
                                double contPos = UNSPECIFIED_CONTPOS,
                                double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
                                double speed = UNSPECIFIED_SPEED,
                                double friction = UNSPECIFIED_FRICTION,
                                double length = myDefaultConnectionLength,
                                const PositionVector& customShape = PositionVector::EMPTY,
                                const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED,
                                SVCPermissions permissions = SVC_UNSPECIFIED,
                                const bool indirectLeft = false,
                                const std::string& edgeType = "",
                                SVCPermissions changeLeft = SVC_UNSPECIFIED,
                                SVCPermissions changeRight = SVC_UNSPECIFIED,
                                bool postProcess = false);
 
    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,
                       KeepClear keepClear = KEEPCLEAR_UNSPECIFIED,
                       double contPos = UNSPECIFIED_CONTPOS,
                       double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
                       double speed = UNSPECIFIED_SPEED,
                       double friction = UNSPECIFIED_FRICTION,
                       double length = myDefaultConnectionLength,
                       const PositionVector& customShape = PositionVector::EMPTY,
                       const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED,
                       SVCPermissions permissions = SVC_UNSPECIFIED,
                       bool indirectLeft = false,
                       const std::string& edgeType = "",
                       SVCPermissions changeLeft = SVC_UNSPECIFIED,
                       SVCPermissions changeRight = SVC_UNSPECIFIED,
                       bool postProcess = false);
 
    std::vector<Connection> getConnectionsFromLane(int lane, const NBEdge* to = nullptr, int toLane = -1) const;
 
    const Connection& getConnection(int fromLane, const NBEdge* to, int toLane) const;
 
    Connection& getConnectionRef(int fromLane, const NBEdge* to, int toLane);
 
    bool hasConnectionTo(const NBEdge* destEdge, int destLane, int fromLane = -1) const;
 
    bool isConnectedTo(const NBEdge* e, const bool ignoreTurnaround = false) 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, bool withBikes = true) 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, const bool keepPossibleTurns = false);
 
    bool removeFromConnections(const 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 setInsideTLS(bool inside) {
        myAmInTLS = inside;
    }
 
    bool isInsideTLS() const {
        return myAmInTLS;
    }
 
    void setJunctionPriority(const NBNode* const node, int prio);
 
    int getJunctionPriority(const NBNode* const node) const;
 
    void setLoadedLength(double val);
 
    void setAverageLengthWithOpposite(double val);
 
    void dismissVehicleClassInformation();
 
    const std::string& getTypeID() const {
        return myType;
    }
 
    bool needsLaneSpecificOutput() const;
 
    bool hasPermissions() const;
 
    bool hasLaneSpecificPermissions() const;
 
    bool hasLaneSpecificSpeed() const;
 
    bool hasLaneSpecificFriction() const;
 
    bool hasLaneSpecificWidth() const;
 
    bool hasLaneSpecificType() const;
 
    bool hasLaneSpecificEndOffset() const;
 
    bool hasLaneSpecificStopOffsets() const;
 
    bool hasAccelLane() const;
 
    bool hasCustomLaneShape() const;
 
    bool hasLaneParams() const;
 
    bool prohibitsChanging() const;
 
    bool computeEdge2Edges(bool noLeftMovers);
 
    bool computeLanes2Edges();
 
    bool recheckLanes();
 
    void appendTurnaround(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike, 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();
 
    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;
 
    double getLaneSpeed(int lane) const;
 
    double getLaneFriction(int lane) const;
 
    bool isNearEnough2BeJoined2(NBEdge* e, double threshold) const;
 
    double getAngleAtNode(const NBNode* const node) const;
 
    double getAngleAtNodeNormalized(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, bool shiftIndices);
 
    void addLane(int index, bool recomputeShape, bool recomputeConnections, bool shiftIndices);
 
    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 addRestrictedLane(double width, SUMOVehicleClass vclass);
 
    void setPermissions(SVCPermissions permissions, int lane = -1);
 
    void setPreferredVehicleClass(SVCPermissions permissions, int lane = -1);
 
    void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight);
 
    void allowVehicleClass(int lane, SUMOVehicleClass vclass);
 
    void disallowVehicleClass(int lane, SUMOVehicleClass vclass);
 
    void preferVehicleClass(int lane, SVCPermissions vclasses);
 
    void setLaneWidth(int lane, double width);
 
    void setLaneType(int lane, const std::string& type);
 
    void setEndOffset(int lane, double offset);
 
    void setSpeed(int lane, double speed);
 
    void setFriction(int lane, double friction);
 
    bool setEdgeStopOffset(int lane, const StopOffset& offset, bool overwrite = false);
 
    void setAcceleration(int lane, bool accelRamp);
 
    void markOffRamp(bool isOffRamp) {
        myIsOffRamp = isOffRamp;
    }
 
    bool isOffRamp() const {
        return myIsOffRamp;
    }
 
    void setLaneShape(int lane, const PositionVector& shape);
 
    SVCPermissions getPermissions(int lane = -1) const;
 
    void setOrigID(const std::string origID, const bool append, const int laneIdx = -1);
 
    void setDistance(double distance) {
        myDistance = distance;
    }
 
    void setBidi(bool isBidi) {
        myIsBidi = isBidi;
    }
 
    bool isBidi() {
        return myIsBidi;
    }
 
    // @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 = EdgeBuildingStep::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
     */
    double 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);
    const PositionVector& getNodeBorder(const NBNode* node) const;
    void resetNodeBorder(const NBNode* node);
 
    bool isBidiRail(bool ignoreSpread = false) const;
 
    bool isBidiEdge(bool checkPotential = false) const;
 
    bool isRailDeadEnd() const;
 
    void debugPrintConnections(bool outgoing = true, bool incoming = false) const;
 
    static double firstIntersection(const PositionVector& v1, const PositionVector& v2, double width1, double width2, const std::string& error = "", bool secondIntersection = false);
 
    static PositionVector startShapeAt(const PositionVector& laneShape, const NBNode* startNode, PositionVector nodeShape);
 
 
 
    static inline double getTravelTimeStatic(const NBEdge* const edge, const NBVehicle* const /*veh*/, double /*time*/) {
        return edge->getLength() / edge->getSpeed();
    }
 
    static int getLaneIndexFromLaneID(const std::string laneID);
 
    void setNumericalID(int index) {
        myIndex = index;
    }
 
    int getNumericalID() const {
        return myIndex;
    }
 
    const NBEdge* getBidiEdge() const {
        return isBidiRail() || isBidiEdge() ? myPossibleTurnDestination : nullptr;
    }
 
    const EdgeVector& getSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;
 
 
    const ConstRouterEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
 
    const std::string& getID() const {
        return Named::getID();
    }
 
    bool joinLanes(SVCPermissions perms);
 
    void resetLaneShapes();
 
    void updateChangeRestrictions(SVCPermissions ignoring);
 
    NBEdge* getStraightContinuation(SVCPermissions permissions) const;
 
    NBEdge* getStraightPredecessor(SVCPermissions permissions) const;
 
    NBEdge* guessOpposite(bool reguess = false);
 
 
    const std::string& getTurnSignTarget() const {
        return myTurnSignTarget;
    }
 
    void setTurnSignTarget(const std::string& target) {
        myTurnSignTarget = target;
    }
 
    static EdgeVector filterByPermissions(const EdgeVector& edges, SVCPermissions permissions);
 
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&) = delete;
 
        ToEdgeConnectionsAdder& operator=(const ToEdgeConnectionsAdder&) = delete;
    };
 
 
    class MainDirections {
    public:
        enum class Direction {
            RIGHTMOST,
            LEFTMOST,
            FORWARD
        };
 
    public:
        MainDirections(const EdgeVector& outgoing, NBEdge* parent, NBNode* to, const std::vector<int>& availableLanes);
 
        ~MainDirections();
 
        int getStraightest() const {
            return myStraightest;
        }
 
        bool empty() const;
 
        bool includes(Direction d) const;
 
    private:
        int myStraightest;
 
        std::vector<Direction> myDirs;
 
        MainDirections(const MainDirections&) = delete;
 
        MainDirections& operator=(const MainDirections&) = delete;
    };
 
    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);
 
    void addStraightConnections(const EdgeVector* outgoing, const std::vector<int>& availableLanes, const std::vector<int>& priorities);
 
    const std::vector<int> prepareEdgePriorities(const EdgeVector* outgoing, const std::vector<int>& availableLanes);
 
 
    void moveConnectionToLeft(int lane);
 
    void moveConnectionToRight(int lane);
 
    bool canMoveConnection(const Connection& con, int newFromLane) const;
 
    void computeAngle();
 
    bool bothLeftTurns(LinkDirection dir, const NBEdge* otherFrom, LinkDirection dir2) const;
    bool haveIntersection(const NBNode& n, const PositionVector& shape, const NBEdge* otherFrom, const NBEdge::Connection& otherCon,
                          int numPoints, double width1, double width2, int shapeFlag = 0) const;
 
    bool hasRestrictedLane(SUMOVehicleClass vclass) const;
 
    void restoreRestrictedLane(SUMOVehicleClass vclass, std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
 
    double assignInternalLaneLength(std::vector<Connection>::iterator i, int numLanes, double lengthSum, bool averageLength);
 
    static std::vector<LinkDirection> decodeTurnSigns(int turnSigns, int shift = 0);
    static void updateTurnPermissions(SVCPermissions& perm, LinkDirection dir, SVCPermissions spec, std::vector<LinkDirection> dirs);
 
    bool applyTurnSigns();
 
    /* @brief remove connections with incompatible permissions (should only be
     * called for guessed connections) */
    void removeInvalidConnections();
 
private:
    EdgeBuildingStep myStep;
 
    std::string myType;
 
    NBNode* myFrom, *myTo;
 
    std::string myTurnSignTarget;
 
    double myLength;
 
    double myStartAngle;
    double myEndAngle;
    double myTotalAngle;
 
    int myPriority;
 
    double mySpeed;
 
    double myFriction;
 
    double myDistance;
 
    std::vector<Connection> myConnections;
 
    std::vector<Connection> myConnectionsToDelete;
 
    NBEdge* myTurnDestination;
 
    NBEdge* myPossibleTurnDestination;
 
    int myFromJunctionPriority;
 
    int myToJunctionPriority;
 
    PositionVector myGeom;
 
    LaneSpreadFunction myLaneSpreadFunction;
 
    double myEndOffset;
 
    StopOffset myEdgeStopOffset;
 
    double myLaneWidth;
 
    std::vector<Lane> myLanes;
 
    double myLoadedLength;
 
    bool myAmInTLS;
 
    bool myAmMacroscopicConnector;
 
    std::string myStreetName;
 
    std::vector<NBSign> mySigns;
 
    Position mySignalPosition;
    const NBNode* mySignalNode;
 
    PositionVector myFromBorder;
    PositionVector myToBorder;
 
    bool myIsOffRamp;
 
    bool myIsBidi;
 
    int myIndex;
 
    // @brief a static list of successor edges. Set by NBEdgeCont and requires reset when the network changes
    mutable EdgeVector mySuccessors;
 
    // @brief a static list of successor edges. Set by NBEdgeCont and requires reset when the network changes
    mutable ConstRouterEdgePairVector myViaSuccessors;
 
    // @brief default length for overriding connection lengths
    static double myDefaultConnectionLength;
 
public:
 
    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;
    };
 
    class connections_toedgelane_finder {
    public:
        connections_toedgelane_finder(const 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:
        const NBEdge* const myEdge2Find;
 
        int myLane2Find;
 
        int myFromLane2Find;
    };
 
    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;
    };
 
    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;
    };
 
    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) = delete;
    };
 
    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) = delete;
 
    NBEdge& operator=(const NBEdge& s) = delete;
 
    NBEdge();
};