NBNode.h

Go to the documentation of this file.

/****************************************************************************/
// The representation of a single node
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 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)

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

        NBEdge* myCurrentOutgoing;

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

        ~ApproachingDivider() throw();

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

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

    };

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


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


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


    ~NBNode() throw();


    void reinit(const Position& position, SumoXMLNodeType type,
                bool updateEdgeGeometries=false);



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


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


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


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


    SumoXMLNodeType getType() const throw() {
        return myType;
    }




    void addTrafficLight(NBTrafficLightDefinition* tlDef) throw();

    void removeTrafficLight(NBTrafficLightDefinition* tlDef) throw();

    void removeTrafficLights() throw();


    bool isTLControlled() const throw() {
        return myTrafficLights.size()!=0;
    }


    bool isJoinedTLSControlled() const throw();


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




    unsigned int removeDummyEdges(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;

    void sortNodesEdges(bool leftHand);

    void computeType(const NBTypeCont& tc);

    void computePriorities();

    Position getEmptyDir() const;


    bool hasIncoming(const NBEdge* const e) const throw();


    bool hasOutgoing(const NBEdge* const e) const throw();


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


    bool mustBrake(const NBEdge* const from, const NBEdge* const to, int toLane) const throw();


    bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
                 const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
                 bool regardNonSignalisedLowerPriority) const throw();


    bool foes(const NBEdge* const from1, const NBEdge* const to1,
              const NBEdge* const from2, const NBEdge* const to2) const throw();


    LinkDirection getDirection(const NBEdge* const incoming, const NBEdge* const outgoing) const throw();

    std::string stateCode(const NBEdge* incoming, NBEdge* outgoing, int fromLane, bool mayDefinitelyPass) const throw();

    void computeNodeShape(bool leftHand);


    const PositionVector& getShape() const;

    bool checkIsRemovable() const;


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

    SUMOReal getMaxEdgeWidth() 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;
    }

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

    bool swapWhenReversed(bool leftHand,
                          const EdgeVector::iterator& i1,
                          const EdgeVector::iterator& i2);

    NBEdge* extractAndMarkFirst(EdgeVector& s);

    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

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