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-2015 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/common/VectorHelper.h>
#include <utils/geom/Position.h>
#include <utils/geom/Line.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

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

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

        NBEdge* myCurrentOutgoing;

        std::vector<unsigned int> myAvailableLanes;

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

        ~ApproachingDivider();

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

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

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

    };

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


    struct WalkingArea {
        WalkingArea(const std::string& _id, SUMOReal _width) :
            id(_id),
            width(_width),
            nextCrossing("")
        {}
        std::string id;
        SUMOReal width;
        SUMOReal 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 SUMOReal DEFAULT_CROSSING_WIDTH;

    static const SUMOReal DEFAULT_RADIUS;

    static const SUMOReal UNSPECIFIED_RADIUS;

public:
    static const int MAX_CONNECTIONS;

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

    SUMOReal 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;
    }


    bool isJoinedTLSControlled() const;


    const std::set<NBTrafficLightDefinition*>& getControllingTLS() const {
        return myTrafficLights;
    }


    void invalidateTLS(NBTrafficLightLogicCont& tlCont);

    void shiftTLConnectionLaneIndex(NBEdge* edge, int offset);




    unsigned int removeSelfLoops(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tc);




    void reshiftPosition(SUMOReal xoff, SUMOReal 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, 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, bool mayDefinitelyPass, const std::string& tlID) const;

    void computeNodeShape(SUMOReal 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(SUMOReal radius) {
        myRadius = radius;
    }

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

    bool hasCustomShape() const {
        return myHaveCustomPoly;
    }

    bool checkIsRemovable() const;


    std::vector<std::pair<NBEdge*, NBEdge*> > getEdgesToJoin() const;


    friend class NBNodeShapeComputer;

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


    PositionVector computeSmoothShape(
        const PositionVector& begShape,
        const PositionVector& endShape,
        int numPoints,
        bool isTurnaround,
        SUMOReal extrapolateBeg,
        SUMOReal extrapolateEnd) const;


    void replaceIncoming(NBEdge* which, NBEdge* by, unsigned int laneOff);

    void replaceIncoming(const EdgeVector& which, NBEdge* by);

    void replaceOutgoing(NBEdge* which, NBEdge* by, unsigned 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);

    void buildInnerEdges();

    /* @brief build pedestrian crossings
     * @return The next index for creating internal lanes
     * */
    unsigned int buildCrossings();

    /* @brief build pedestrian walking areas and set connections from/to walkingAreas
     * @param[in] cornerDetail The detail level when generating the inner curve
     * */
    void buildWalkingAreas(int cornerDetail);

    /* @brief build crossings, and walkingareas. Also removes invalid loaded
     * crossings*/
    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, SUMOReal width, bool priority, bool fromSumoNet = false);

    void removeCrossing(const EdgeVector& edges);

    void discardAllCrossings() {
        myDiscardAllCrossings = true;
    }

    int numCrossingsFromSumoNet() const {
        return myCrossingsLoadedFromSumoNet;
    }

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

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

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

    void setCrossingTLIndices(unsigned int startIndex);

    int numNormalConnections() const;

    void avoidOverlap();


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

private:
    bool isSimpleContinuation() const;

    void setPriorityJunctionPriorities();

    EdgeVector* getEdgesThatApproach(NBEdge* currentOutgoing);




    void replaceInConnectionProhibitions(NBEdge* which, NBEdge* by,
                                         unsigned int whichLaneOff, unsigned 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;

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;

    SUMOReal myRadius;

    bool myKeepClear;

    CustomShapeMap myCustomLaneShapes;

    bool myDiscardAllCrossings;

    int myCrossingsLoadedFromSumoNet;

private:
    NBNode(const NBNode& s);

    NBNode& operator=(const NBNode& s);


};


#endif

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