NBNode.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 node
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <deque>
#include <utility>
#include <string>
#include <set>
#include <memory>
#include <utils/common/StdDefs.h>
#include <utils/common/Named.h>
#include <utils/geom/Bresenham.h>
#include <utils/geom/GeomHelper.h>
#include <utils/common/VectorHelper.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include "NBEdge.h"
#include "NBConnection.h"
#include "NBConnectionDefs.h"
#include "NBContHelper.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NBRequest;
class NBDistrict;
class OptionsCont;
class NBTrafficLightDefinition;
class NBTypeCont;
class NBTrafficLightLogicCont;
class NBDistrictCont;
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBNode : public Named, public Parameterised {
    friend class NBNodeCont;
    friend class GNEJunction;            // < used for visualization (netedit)
    friend class NBNodesEdgesSorter;     // < sorts the edges
    friend class NBNodeTypeComputer;     // < computes type
    friend class NBEdgePriorityComputer; // < computes priorities of edges per intersection
 
public:
    class ApproachingDivider : public Bresenham::BresenhamCallBack {
    public:
        ApproachingDivider(const EdgeVector& approaching, NBEdge* currentOutgoing);
 
        ~ApproachingDivider();
 
        int numAvailableLanes() const {
            return (int)myAvailableLanes.size();
        }
 
        void execute(const int src, const int dest);
 
        std::deque<int>* spread(int numLanes, int dest) const;
 
    private:
        const EdgeVector& myApproaching;
 
        NBEdge* myCurrentOutgoing;
 
        std::vector<int> myAvailableLanes;
 
        std::vector<LinkDirection> myDirections;
 
        int myNumStraight;
 
        bool myIsBikeEdge;
 
    private:
        ApproachingDivider& operator=(const ApproachingDivider&) = delete;
 
    };
 
    class Crossing final : public Parameterised {
    public:
        Crossing(const NBNode* _node, const EdgeVector& _edges, double _width, bool _priority, int _customTLIndex, int _customTLIndex2, const PositionVector& _customShape);
        const NBNode* node;
        EdgeVector edges;
        PositionVector shape;
        PositionVector outlineShape;
        double customWidth;
        double width;
        std::string id;
        std::string prevWalkingArea;
        std::string nextWalkingArea;
        bool priority;
        PositionVector customShape;
        int tlLinkIndex;
        int tlLinkIndex2;
        int customTLIndex;
        int customTLIndex2;
        std::string tlID;
        bool valid;
    };
 
 
    struct WalkingArea {
        WalkingArea(const std::string& _id, double _width) :
            id(_id),
            width(_width) {
        }
        std::string id;
        double width;
        double length = INVALID_DOUBLE;
        PositionVector shape;
        std::vector<std::string> nextCrossings;
        std::vector<std::string> prevCrossings;
        std::vector<std::string> nextSidewalks;
        std::vector<std::string> prevSidewalks;
        bool hasCustomShape = false;
        int minNextCrossingEdges = std::numeric_limits<int>::max();
        int minPrevCrossingEdges = std::numeric_limits<int>::max();
        std::set<const NBEdge*, ComparatorIdLess> refEdges;
    };
 
    struct WalkingAreaCustomShape {
        std::set<const NBEdge*, ComparatorIdLess> edges;
        PositionVector shape;
        double width;
    };
 
    static const int FORWARD;
    static const int BACKWARD;
 
    static const double UNSPECIFIED_RADIUS;
 
    static const int AVOID_WIDE_RIGHT_TURN;
    static const int AVOID_WIDE_LEFT_TURN;
    static const int FOUR_CONTROL_POINTS;
    static const int AVOID_INTERSECTING_LEFT_TURNS;
    static const int SCURVE_IGNORE;
    static const int INDIRECT_LEFT;
 
public:
    NBNode(const std::string& id, const Position& position, SumoXMLNodeType type);
 
    NBNode(const std::string& id, const Position& position, NBDistrict* district = 0);
 
    ~NBNode();
 
    void reinit(const Position& position, SumoXMLNodeType type,
                bool updateEdgeGeometries = false);
 
    inline const Position& getPosition() const {
        return myPosition;
    }
 
    Position getCenter() const;
 
    inline const EdgeVector& getIncomingEdges() const {
        return myIncomingEdges;
    }
 
    inline const EdgeVector& getOutgoingEdges() const {
        return myOutgoingEdges;
    }
 
    inline const EdgeVector& getEdges() const {
        return myAllEdges;
    }
 
    inline SumoXMLNodeType getType() const {
        return myType;
    }
 
    inline double getRadius() const {
        return myRadius;
    }
 
    inline bool getKeepClear() const {
        return myKeepClear;
    }
 
    inline RightOfWay getRightOfWay() const {
        return myRightOfWay;
    }
 
    inline FringeType getFringeType() const {
        return myFringeType;
    }
 
    inline const std::string& getName() const {
        return myName;
    }
 
 
    void addTrafficLight(NBTrafficLightDefinition* tlDef);
 
    void removeTrafficLight(NBTrafficLightDefinition* tlDef);
 
    void removeTrafficLights(bool setAsPriority = false);
 
    bool isTLControlled() const {
        return myTrafficLights.size() != 0;
    }
 
    const std::set<NBTrafficLightDefinition*>& getControllingTLS() const {
        return myTrafficLights;
    }
 
    void invalidateTLS(NBTrafficLightLogicCont& tlCont, bool removedConnections, bool addedConnections);
 
    void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1);
 
 
 
    int removeSelfLoops(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tc);
 
 
 
    void reshiftPosition(double xoff, double yoff);
 
    void mirrorX();
 
    void addIncomingEdge(NBEdge* edge);
 
    void addOutgoingEdge(NBEdge* edge);
 
    void computeLanes2Lanes();
 
    void computeLogic(const NBEdgeCont& ec);
 
    void computeLogic2(bool checkLaneFoes);
 
    void computeKeepClear();
 
    bool writeLogic(OutputDevice& into) const;
 
    const std::string getFoes(int linkIndex) const;
 
    const std::string getResponse(int linkIndex) const;
 
    bool hasConflict() const;
 
    bool hasConflict(const NBEdge* e) const;
 
    Position getEmptyDir() const;
 
    bool hasIncoming(const NBEdge* const e) const;
 
    bool hasOutgoing(const NBEdge* const e) const;
 
    NBEdge* getOppositeIncoming(NBEdge* e) const;
 
    void invalidateIncomingConnections(bool reallowSetting = false);
 
    void invalidateOutgoingConnections(bool reallowSetting = false);
 
    void removeDoubleEdges();
 
    NBEdge* getConnectionTo(NBNode* n) const;
 
    void addSortedLinkFoes(const NBConnection& mayDrive, const NBConnection& mustStop);
 
    NBEdge* getPossiblySplittedIncoming(const std::string& edgeid);
 
    NBEdge* getPossiblySplittedOutgoing(const std::string& edgeid);
 
    void removeEdge(NBEdge* edge, bool removeFromConnections = true);
 
    bool isLeftMover(const NBEdge* const from, const NBEdge* const to) const;
 
    bool mustBrake(const NBEdge* const from, const NBEdge* const to, int fromLane, int toLane, bool includePedCrossings) const;
 
    bool mustBrakeForCrossing(const NBEdge* const from, const NBEdge* const to, const Crossing& crossing) const;
 
    bool brakeForCrossingOnExit(const NBEdge* to) const;
 
    static bool rightTurnConflict(const NBEdge* from, const NBEdge* to, int fromLane,
                                  const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorFromLane);
 
    bool mergeConflictYields(const NBEdge* from, int fromLane, int fromLaneFoe, NBEdge* to, int toLane) const;
 
    bool mergeConflict(const NBEdge* from, const NBEdge::Connection& con,
                       const NBEdge* prohibitorFrom, const NBEdge::Connection& prohibitorCon, bool foes) const;
 
    bool bidiConflict(const NBEdge* from, const NBEdge::Connection& con,
                      const NBEdge* prohibitorFrom, const NBEdge::Connection& prohibitorCon, bool foes) const;
 
    bool zipperConflict(const NBEdge* incoming, const NBEdge* outgoing, int fromLane, int toLane) const;
 
    bool turnFoes(const NBEdge* from, const NBEdge* to, int fromLane,
                  const NBEdge* from2, const NBEdge* to2, int fromLane2,
                  bool lefthand = false) const;
 
    bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
                 const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
                 bool regardNonSignalisedLowerPriority) const;
 
    bool foes(const NBEdge* const from1, const NBEdge* const to1,
              const NBEdge* const from2, const NBEdge* const to2) const;
 
    LinkDirection getDirection(const NBEdge* const incoming, const NBEdge* const outgoing, bool leftHand = false) const;
 
    LinkState getLinkState(const NBEdge* incoming, const NBEdge* outgoing,
                           int fromLane, int toLane, bool mayDefinitelyPass, const std::string& tlID) const;
 
    void computeNodeShape(double mismatchThreshold);
 
    void updateSurroundingGeometry();
 
    const PositionVector& getShape() const;
 
    void setCustomShape(const PositionVector& shape);
 
    void resetShape() {
        myPoly.clear();
    }
 
    void setRadius(double radius) {
        myRadius = radius;
    }
 
    void setKeepClear(bool keepClear) {
        myKeepClear = keepClear;
    }
 
    void setRightOfWay(RightOfWay rightOfWay) {
        myRightOfWay = rightOfWay;
    }
 
    void setFringeType(FringeType fringeType) {
        myFringeType = fringeType;
    }
 
    void setName(const std::string& name) {
        myName = name;
    }
 
    bool hasCustomShape() const {
        return myHaveCustomPoly;
    }
 
    bool checkIsRemovable() const;
 
    bool checkIsRemovableReporting(std::string& reason) const;
 
    std::vector<std::pair<NBEdge*, NBEdge*> > getEdgesToJoin() const;
 
    bool isNearDistrict() const;
 
    bool isDistrict() const;
 
    bool needsCont(const NBEdge* fromE, const NBEdge* otherFromE,
                   const NBEdge::Connection& c, const NBEdge::Connection& otherC, bool checkOnlyTLS = false) const;
 
    bool tlsContConflict(const NBEdge* from, const NBEdge::Connection& c,
                         const NBEdge* foeFrom, const NBEdge::Connection& foe) const;
 
 
    PositionVector computeInternalLaneShape(const NBEdge* fromE, const NBEdge::Connection& con, int numPoints, NBNode* recordError = 0, int shapeFlag = 0) const;
 
    PositionVector computeSmoothShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints,
                                      bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
                                      NBNode* recordError = 0, int shapeFlag = 0) const;
    static PositionVector bezierControlPoints(const PositionVector& begShape, const PositionVector& endShape,
            bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
            bool& ok, NBNode* recordError = 0, double straightThresh = DEG2RAD(5),
            int shapeFlag = 0);
 
    PositionVector indirectLeftShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints) const;
 
    double getDisplacementError() const {
        return myDisplacementError;
    }
 
    void replaceIncoming(NBEdge* which, NBEdge* by, int laneOff);
 
    void replaceIncoming(const EdgeVector& which, NBEdge* by);
 
    void replaceOutgoing(NBEdge* which, NBEdge* by, int laneOff);
 
    void replaceOutgoing(const EdgeVector& which, NBEdge* by);
 
    int guessCrossings();
 
    /* @brief check whether a crossing should be build for the candiate edges and build 0 to n crossings
     * @param[in] candidates The candidate vector of edges to be crossed
     * @param[in] checkOnly Whether only checking (of user supplied) crossings shall be performed
     * @return The number of crossings built
     * */
    int checkCrossing(EdgeVector candidates, bool checkOnly = false);
 
    bool checkCrossingDuplicated(EdgeVector edges);
 
    double buildInnerEdges();
 
    int buildCrossings();
 
    void buildWalkingAreas(int cornerDetail, double joinMinDist);
 
    void buildCrossingOutlines();
 
    void buildCrossingsAndWalkingAreas();
 
    EdgeVector edgesBetween(const NBEdge* e1, const NBEdge* e2) const;
 
    bool crossingBetween(const NBEdge* e1, const NBEdge* e2) const;
 
    bool alreadyConnectedPaths(const NBEdge* e1, const NBEdge* e2, double dist) const;
 
    bool crossesFringe(const NBEdge* e1, const NBEdge* e2) const;
 
    const NBConnectionProhibits& getProhibitions() {
        return myBlockedConnections;
    }
 
    bool geometryLike() const;
    bool geometryLike(const EdgeVector& incoming, const EdgeVector& outgoing) const;
 
    void setRoundabout();
 
    bool isRoundabout() const;
 
    NBNode::Crossing* addCrossing(EdgeVector edges, double width, bool priority, int tlIndex = -1, int tlIndex2 = -1,
                                  const PositionVector& customShape = PositionVector::EMPTY, bool fromSumoNet = false, const Parameterised* params = nullptr);
 
    void addWalkingAreaShape(EdgeVector edges, const PositionVector& shape, double width);
 
    void removeCrossing(const EdgeVector& edges);
 
    void discardAllCrossings(bool rejectAll);
 
    void discardWalkingareas();
 
    int numCrossingsFromSumoNet() const {
        return myCrossingsLoadedFromSumoNet;
    }
 
    std::vector<Crossing*> getCrossings() const;
    inline const std::vector<std::unique_ptr<Crossing> >& getCrossingsIncludingInvalid() const {
        return myCrossings;
    }
 
    inline const std::vector<WalkingArea>& getWalkingAreas() const {
        return myWalkingAreas;
    }
 
    const std::vector<WalkingAreaCustomShape>& getWalkingAreaCustomShapes() const {
        return myWalkingAreaCustomShapes;
    }
 
    Crossing* getCrossing(const std::string& id) const;
 
    Crossing* getCrossing(const EdgeVector& edges, bool hardFail = true) const;
 
    WalkingArea& getWalkingArea(const std::string& id);
 
    /* @brief set tl indices of this nodes crossing starting at the given index
     * @return Whether a custom index was used
     */
    bool setCrossingTLIndices(const std::string& tlID, int startIndex);
 
    int numNormalConnections() const;
 
    void avoidOverlap();
 
    bool rightOnRedConflict(int index, int foeIndex) const;
 
    void sortEdges(bool useNodeShape);
 
    int getConnectionIndex(const NBEdge* from, const NBEdge::Connection& con) const;
 
    class nodes_by_id_sorter {
    public:
        explicit nodes_by_id_sorter() { }
 
        int operator()(NBNode* n1, NBNode* n2) const {
            return n1->getID() < n2->getID();
        }
    };
 
    class edge_by_direction_sorter {
    public:
        explicit edge_by_direction_sorter(NBNode* n) : myNode(n) {}
 
        int operator()(NBEdge* e1, NBEdge* e2) const {
            UNUSED_PARAMETER(e2);
            return e1->getFromNode() == myNode;
        }
 
    private:
        NBNode* myNode;
 
    };
 
    static bool isTrafficLight(SumoXMLNodeType type);
 
    inline bool isTrafficLight() const {
        return isTrafficLight(myType);
    }
 
    bool isSimpleContinuation(bool checkLaneNumbers = true, bool checkWidth = false) const;
 
    void markBentPriority(bool isBent) {
        myIsBentPriority = isBent;
    }
 
    bool isBentPriority() const {
        return myIsBentPriority;
    }
 
    bool typeWasGuessed() const {
        return myTypeWasGuessed;
    }
 
    bool isConstantWidthTransition() const;
 
    std::vector<std::pair<Position, std::string> > getEndPoints() const;
 
private:
    void setPriorityJunctionPriorities();
 
    void getEdgesThatApproach(NBEdge* currentOutgoing, EdgeVector& approaching);
 
    void replaceInConnectionProhibitions(NBEdge* which, NBEdge* by, int whichLaneOff, int byLaneOff);
 
    void remapRemoved(NBTrafficLightLogicCont& tc, NBEdge* removed, const EdgeVector& incoming, const EdgeVector& outgoing);
 
    bool forbidsPedestriansAfter(std::vector<std::pair<NBEdge*, bool> > normalizedLanes, int startIndex);
 
    EdgeVector getEdgesSortedByAngleAtNodeCenter() const;
 
    static bool isLongEnough(NBEdge* out, double minLength);
 
    void removeJoinedTrafficLights();
 
    void displaceShapeAtWidthChange(const NBEdge* from, const NBEdge::Connection& con, PositionVector& fromShape, PositionVector& toShape) const;
 
    static bool includes(const std::set<const NBEdge*, ComparatorIdLess>& super,
                         const std::set<const NBEdge*, ComparatorIdLess>& sub);
 
    NBEdge* getNextCompatibleOutgoing(const NBEdge* incoming, SVCPermissions vehPerm, EdgeVector::const_iterator start, bool clockwise) const;
 
    void recheckVClassConnections(NBEdge* currentOutgoing);
 
    void getReduction(const NBEdge* in, const NBEdge* out, int& inOffset, int& inEnd, int& outOffset, int& outEnd, int& reduction) const;
 
    SVCPermissions findToLaneForPermissions(NBEdge* currentOutgoing, int fromLane, NBEdge* incoming, SVCPermissions unsatisfied);
 
    int addedLanesRight(NBEdge* out, int addedLanes) const;
 
    bool isStraighter(const NBEdge* const incoming, const double angle, const SVCPermissions vehPerm, const int modeLanes, const NBEdge* const candidate) const;
 
    EdgeVector getPassengerEdges(bool incoming) const;
 
    static bool isExplicitRailNoBidi(const NBEdge* incoming, const NBEdge* outgoing);
 
    PositionVector cutAtShapes(const PositionVector& cut, const PositionVector& border1, const PositionVector& border2, const PositionVector& def);
 
private:
    Position myPosition;
 
    EdgeVector myIncomingEdges;
 
    EdgeVector myOutgoingEdges;
 
    EdgeVector myAllEdges;
 
    std::vector<std::unique_ptr<Crossing> > myCrossings;
 
    std::vector<WalkingArea> myWalkingAreas;
 
    std::vector<WalkingAreaCustomShape> myWalkingAreaCustomShapes;
 
    SumoXMLNodeType myType;
 
    NBConnectionProhibits myBlockedConnections;
 
    NBDistrict* myDistrict;
 
    PositionVector myPoly;
 
    bool myHaveCustomPoly;
 
    NBRequest* myRequest;
 
    std::set<NBTrafficLightDefinition*> myTrafficLights;
 
    double myRadius;
 
    bool myKeepClear;
 
    RightOfWay myRightOfWay;
 
    FringeType myFringeType;
 
    std::string myName;
 
    bool myDiscardAllCrossings;
 
    int myCrossingsLoadedFromSumoNet;
 
    double myDisplacementError;
 
    /* @brief whether this junction is a bent priority junction (main direction turns)
     * @note see NBEdgePriorityComputer
     */
    bool myIsBentPriority;
 
    bool myTypeWasGuessed;
 
private:
    NBNode(const NBNode& s);
 
    NBNode& operator=(const NBNode& s);
};