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 2001-2010 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/common/VectorHelper.h>
#include <utils/geom/Position2D.h>
#include <utils/geom/Line2D.h>
#include <utils/geom/Position2DVector.h>
#include "NBEdge.h"
#include "NBJunctionLogicCont.h"
#include "NBConnection.h"
#include "NBConnectionDefs.h"
#include "NBContHelper.h"
#include "NBMMLDirections.h"
#include <utils/geom/Bresenham.h>


// ===========================================================================
// class declarations
// ===========================================================================
class NBRequest;
class NBDistrict;
class OptionsCont;
class NBTrafficLightDefinition;
class NBTypeCont;
class NBTrafficLightLogicCont;
class NBDistrictCont;
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class NBNode {
public:
    class ApproachingDivider : public Bresenham::BresenhamCallBack {
    private:
        std::vector<NBEdge*> *myApproaching;

        NBEdge *myCurrentOutgoing;

    public:
        ApproachingDivider(std::vector<NBEdge*> *approaching,
                           NBEdge *currentOutgoing) throw();

        ~ApproachingDivider() throw();

        void execute(SUMOReal src, SUMOReal dest) throw();

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

    };


    enum BasicNodeType {
        NODETYPE_UNKNOWN,
        NODETYPE_TRAFFIC_LIGHT,
        NODETYPE_PRIORITY_JUNCTION,
        NODETYPE_RIGHT_BEFORE_LEFT,
        NODETYPE_DISTRICT,
        NODETYPE_NOJUNCTION,
        NODETYPE_DEAD_END
    };


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


    NBNode(const std::string &id, const Position2D &position, BasicNodeType type) throw();


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


    ~NBNode() throw();


    void reinit(const Position2D &position, BasicNodeType type) throw();



    const std::string &getID() const throw() {
        return myID;
    }


    const Position2D &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;
    }


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




    void addTrafficLight(NBTrafficLightDefinition *tld) 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;
    }



    void addIncomingEdge(NBEdge *edge);

    void addOutgoingEdge(NBEdge *edge);

    void writeXMLInternalLinks(OutputDevice &into);
    void writeXMLInternalSuccInfos(OutputDevice &into);
    void writeXMLInternalNodes(OutputDevice &into);



    void writeXML(OutputDevice &into);

    void computeLanes2Lanes();

    void computeLogic(const NBEdgeCont &ec, NBJunctionLogicCont &jc,
                      OptionsCont &oc);

    void sortNodesEdges(bool leftHand, const NBTypeCont &tc);

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

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

    void removeOutgoing(NBEdge *edge);
    void removeIncoming(NBEdge *edge);

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


    NBMMLDirection getMMLDirection(const NBEdge * const incoming, const NBEdge * const outgoing) const throw();

    char stateCode(NBEdge *incoming, NBEdge *outgoing, int fromLane, bool mayDefinitelyPass) const throw();

    void computeNodeShape(bool leftHand);

    friend class NBNodeCont;


    const Position2DVector &getShape() const;

    unsigned int countInternalLanes(bool includeSplits);

    std::string getInternalLaneID(NBEdge *from, unsigned int fromlane,
                                  NBEdge *to, unsigned int tolane) const;


    bool checkIsRemovable() const;


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

    SUMOReal getMaxEdgeWidth() const;

    friend class NBNodeShapeComputer;

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


    std::pair<SUMOReal, std::vector<unsigned int> > getCrossingPosition(NBEdge *fromE, unsigned int fromL,
            NBEdge *toE, unsigned int toL);
    std::string getCrossingNames_dividedBySpace(NBEdge *fromE, unsigned int fromL,
            NBEdge *toE, unsigned int toL);
    std::string getCrossingSourcesNames_dividedBySpace(NBEdge *fromE, unsigned int fromL,
            NBEdge *toE, unsigned int toL);

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


    class nodes_by_id_sorter {
    public:
        explicit nodes_by_id_sorter() { }

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

    };

private:
    void buildBitfieldLogic();

    void sortSmall();

    // computes the junction type
    BasicNodeType computeType(const NBTypeCont &tc) const;
    bool isSimpleContinuation() const;

    void setPriorities();

    void setPriorityJunctionPriorities();

    bool swapWhenReversed(bool leftHand,
                          const std::vector<NBEdge*>::iterator &i1,
                          const std::vector<NBEdge*>::iterator &i2);

    NBEdge* extractAndMarkFirst(std::vector<NBEdge*> &s);

    std::vector<NBEdge*> *getEdgesThatApproach(NBEdge *currentOutgoing);

    void reshiftPosition(SUMOReal xoff, SUMOReal yoff);



    void replaceInConnectionProhibitions(NBEdge *which, NBEdge *by,
                                         unsigned int whichLaneOff, unsigned int byLaneOff);


    void remapRemoved(NBTrafficLightLogicCont &tc,
                      NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing);

    Position2DVector computeInternalLaneShape(NBEdge *fromE,
            int fromL, NBEdge *toE, int toL);

    void writeinternal(EdgeVector *myIncomingEdges, OutputDevice &into, const std::string &id);

private:
    std::string myID;

    Position2D myPosition;

    std::vector<NBEdge*> *myIncomingEdges;

    std::vector<NBEdge*> *myOutgoingEdges;

    std::vector<NBEdge*> myAllEdges;

    BasicNodeType myType;

    NBConnectionProhibits myBlockedConnections;

    NBDistrict *myDistrict;

    Position2DVector myPoly;

    NBRequest *myRequest;

    std::set<NBTrafficLightDefinition*> myTrafficLights;

private:
    NBNode(const NBNode &s);

    NBNode &operator=(const NBNode &s);


};


#endif

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