NBNode.h

Go to the documentation of this file.

/****************************************************************************/
// The representation of a single node
/****************************************************************************/
// 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 NBNode_h
#define NBNode_h


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

#include <vector>
#include <deque>
#include <utility>
#include <string>
#include <set>
#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 {
    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
    friend class NBNodeShapeComputer;    // < computes node's shape

public:
    typedef std::map<std::string, PositionVector> CustomShapeMap;

    class ApproachingDivider : public Bresenham::BresenhamCallBack {
    private:
        EdgeVector* myApproaching;

        NBEdge* myCurrentOutgoing;

        std::vector<int> myAvailableLanes;

    public:
        ApproachingDivider(EdgeVector* approaching, NBEdge* currentOutgoing);

        ~ApproachingDivider();

        int numAvailableLanes() const {
            return (int)myAvailableLanes.size();
        }

        void execute(const int src, const int dest);

        std::deque<int>* spread(const std::vector<int>& approachingLanes, int dest) const;

    };

    struct Crossing {
        Crossing(const NBNode* _node, const EdgeVector& _edges, double _width, bool _priority) :
            node(_node),
            edges(_edges),
            width(_width),
            priority(_priority),
            tlLinkNo(-1),
            valid(true) {
        }
        const NBNode* node;
        EdgeVector edges;
        PositionVector shape;
        double width;
        std::string id;
        std::string prevWalkingArea;
        std::string nextWalkingArea;
        bool priority;
        int tlLinkNo;
        std::string tlID;
        bool valid;
    };


    struct WalkingArea {
        WalkingArea(const std::string& _id, double _width) :
            id(_id),
            width(_width),
            nextCrossing("") {
        }
        std::string id;
        double width;
        double length;
        PositionVector shape;
        std::string nextCrossing;
        std::vector<std::string> nextSidewalks;
        std::vector<std::string> prevSidewalks;
    };

    static const int FORWARD;
    static const int BACKWARD;
    static const double DEFAULT_CROSSING_WIDTH;

    static const double UNSPECIFIED_RADIUS;

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

    const Position& getPosition() const {
        return myPosition;
    }

    Position getCenter() const;

    const EdgeVector& getIncomingEdges() const {
        return myIncomingEdges;
    }

    const EdgeVector& getOutgoingEdges() const {
        return myOutgoingEdges;
    }

    const EdgeVector& getEdges() const {
        return myAllEdges;
    }

    SumoXMLNodeType getType() const {
        return myType;
    }

    double getRadius() const {
        return myRadius;
    }

    bool getKeepClear() const {
        return myKeepClear;
    }


    void addTrafficLight(NBTrafficLightDefinition* tlDef);

    void removeTrafficLight(NBTrafficLightDefinition* tlDef);

    void removeTrafficLights();

    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 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, OptionsCont& oc);

    bool writeLogic(OutputDevice& into, const bool checkLaneFoes) 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();

    void invalidateOutgoingConnections();

    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;

    static bool rightTurnConflict(const NBEdge* from, const NBEdge* to, int fromLane,
                                  const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorFromLane,
                                  bool lefthand = false);

    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, NBEdge* outgoing,
                           int fromLane, int toLane, bool mayDefinitelyPass, const std::string& tlID) const;

    void computeNodeShape(double mismatchThreshold);

    const PositionVector& getShape() const;

    void setCustomShape(const PositionVector& shape);

    void setCustomLaneShape(const std::string& laneID, const PositionVector& shape);

    const CustomShapeMap& getCustomLaneShapes() const {
        return myCustomLaneShapes;
    }

    void setRadius(double radius) {
        myRadius = radius;
    }

    void setKeepClear(bool keepClear) {
        myKeepClear = keepClear;
    }

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

    PositionVector computeInternalLaneShape(NBEdge* fromE, const NBEdge::Connection& con, int numPoints, NBNode* recordError = 0) const;

    PositionVector computeSmoothShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints,
                                      bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
                                      NBNode* recordError = 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));


    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
     * @return The number of crossings built
     * */
    int checkCrossing(EdgeVector candidates);

    bool checkCrossingDuplicated(EdgeVector edges);

    void buildInnerEdges();

    int buildCrossings();

    void buildWalkingAreas(int cornerDetail);

    void buildCrossingsAndWalkingAreas();

    EdgeVector edgesBetween(const NBEdge* e1, const NBEdge* e2) const;

    bool crossingBetween(const NBEdge* e1, const NBEdge* e2) const;

    const NBConnectionProhibits& getProhibitions() {
        return myBlockedConnections;
    }

    bool geometryLike() const;

    void setRoundabout();

    void addCrossing(EdgeVector edges, double width, bool priority, bool fromSumoNet = false);

    void removeCrossing(const EdgeVector& edges);

    void discardAllCrossings(bool rejectAll);

    int numCrossingsFromSumoNet() const {
        return myCrossingsLoadedFromSumoNet;
    }

    std::vector<Crossing*> getCrossings() const;
    inline const std::vector<Crossing*>& getCrossingsIncludingInvalid() const {
        return myCrossings;
    }

    inline const std::vector<WalkingArea>& getWalkingAreas() const {
        return myWalkingAreas;
    }

    Crossing* getCrossing(const std::string& id) const;

    void 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 std::string getNodeIDFromInternalLane(const std::string id);


    static bool isTrafficLight(SumoXMLNodeType type);

    bool isSimpleContinuation(bool checkLaneNumbers = true) const;


private:
    void setPriorityJunctionPriorities();

    EdgeVector* getEdgesThatApproach(NBEdge* currentOutgoing);

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

private:
    Position myPosition;

    EdgeVector myIncomingEdges;

    EdgeVector myOutgoingEdges;

    EdgeVector myAllEdges;

    std::vector<Crossing*> myCrossings;

    std::vector<WalkingArea> myWalkingAreas;

    SumoXMLNodeType myType;

    NBConnectionProhibits myBlockedConnections;

    NBDistrict* myDistrict;

    PositionVector myPoly;

    bool myHaveCustomPoly;

    NBRequest* myRequest;

    std::set<NBTrafficLightDefinition*> myTrafficLights;

    double myRadius;

    bool myKeepClear;

    CustomShapeMap myCustomLaneShapes;

    bool myDiscardAllCrossings;

    int myCrossingsLoadedFromSumoNet;

    double myDisplacementError;

private:
    NBNode(const NBNode& s);

    NBNode& operator=(const NBNode& s);
};


#endif

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