NBNode.h

Go to the documentation of this file.

/****************************************************************************/
// The representation of a single node
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
// Copyright (C) 2001-2013 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/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:
    class ApproachingDivider : public Bresenham::BresenhamCallBack {
    private:
        EdgeVector* myApproaching;

        NBEdge* myCurrentOutgoing;

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

        ~ApproachingDivider();

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

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

    };

public:
    NBNode(const std::string& id, const Position& position);


    NBNode(const std::string& id, const Position& position, SumoXMLNodeType type);


    NBNode(const std::string& id, const Position& position, NBDistrict* district);


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




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




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




    void reshiftPosition(SUMOReal xoff, SUMOReal yoff);



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

    LinkState getLinkState(const NBEdge* incoming, NBEdge* outgoing,
                           int fromLane, bool mayDefinitelyPass, const std::string& tlID) const;

    void computeNodeShape(bool leftHand);


    const PositionVector& getShape() const;

    bool checkIsRemovable() const;


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


    friend class NBNodeShapeComputer;

    bool isNearDistrict() const;
    bool isDistrict() const;

    bool needsCont(NBEdge* fromE, NBEdge* toE, NBEdge* otherFromE, NBEdge* otherToE, const NBEdge::Connection& c) const;

    PositionVector computeInternalLaneShape(
        NBEdge* fromE, int fromL, NBEdge* toE, int toL, int numPoints = 5) 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);

    void buildInnerEdges();

    const NBConnectionProhibits& getProhibitions() {
        return myBlockedConnections;
    }

    bool geometryLike() const;

    void setRoundabout();

    class nodes_by_id_sorter {
    public:
        explicit nodes_by_id_sorter() { }

        int operator()(NBNode* n1, NBNode* n2) const {
            return n1->getID() < n2->getID();
        }

    };

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


private:
    Position myPosition;

    EdgeVector myIncomingEdges;

    EdgeVector myOutgoingEdges;

    EdgeVector myAllEdges;

    SumoXMLNodeType myType;

    NBConnectionProhibits myBlockedConnections;

    NBDistrict* myDistrict;

    PositionVector myPoly;

    NBRequest* myRequest;

    std::set<NBTrafficLightDefinition*> myTrafficLights;

private:
    NBNode(const NBNode& s);

    NBNode& operator=(const NBNode& s);


};


#endif

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