NBEdge.h

Go to the documentation of this file.

/****************************************************************************/
// The representation of a single edge during network building
/****************************************************************************/
// 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 NBEdge_h
#define NBEdge_h


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

#include <map>
#include <vector>
#include <string>
#include <set>
#include "NBCont.h"
#include <utils/common/UtilExceptions.h>
#include <utils/common/VectorHelper.h>
#include <utils/geom/Bresenham.h>
#include <utils/geom/Position2DVector.h>
#include <utils/geom/Line2D.h>
#include <utils/common/SUMOVehicleClass.h>
#include "NBHelpers.h"


// ===========================================================================
// class declarations
// ===========================================================================
class NBNode;
class NBNodeCont;
class NBEdgeCont;
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class NBEdge {
public:
    enum LaneSpreadFunction {
        LANESPREAD_RIGHT,
        LANESPREAD_CENTER
    };


    enum EdgeBuildingStep {
        INIT_REJECT_CONNECTIONS,
        INIT,
        EDGE2EDGES,
        LANES2EDGES,
        LANES2LANES_RECHECK,
        LANES2LANES_DONE,
        LANES2LANES_USER
    };


    enum Lane2LaneInfoType {
        L2L_COMPUTED,
        L2L_USER,
        L2L_VALIDATED
    };


    struct Lane {
        Position2DVector shape;
        SUMOReal speed;
        std::vector<SUMOVehicleClass> allowed;
        std::vector<SUMOVehicleClass> notAllowed;
        std::vector<SUMOVehicleClass> preferred;
    };


    struct Connection {
        Connection(int fromLane_, NBEdge *toEdge_, int toLane_) throw()
                : fromLane(fromLane_), toEdge(toEdge_), toLane(toLane_),
                mayDefinitelyPass(false) { }


        int fromLane;
        NBEdge *toEdge;
        int toLane;
        std::string tlID;
        unsigned int tlLinkNo;
        bool mayDefinitelyPass;

    };


public:
    NBEdge(const std::string &id,
           NBNode *from, NBNode *to, std::string type,
           SUMOReal speed, unsigned int nolanes, int priority,
           LaneSpreadFunction spread=LANESPREAD_RIGHT) throw(ProcessError);


    NBEdge(const std::string &id,
           NBNode *from, NBNode *to, std::string type,
           SUMOReal speed, unsigned int nolanes, int priority,
           Position2DVector geom,
           LaneSpreadFunction spread=LANESPREAD_RIGHT,
           bool tryIgnoreNodePositions=false) throw(ProcessError);


    ~NBEdge() throw();


    void reinit(NBNode *from, NBNode *to, std::string type,
                SUMOReal speed, unsigned int nolanes, int priority,
                Position2DVector geom,
                LaneSpreadFunction spread=LANESPREAD_RIGHT) throw(ProcessError);


    void setLeftHanded() throw() {
        myAmLeftHand = true;
    }




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


    unsigned int getNoLanes() const throw() {
        return (unsigned int) myLanes.size();
    }


    int getPriority() const throw() {
        return myPriority;
    }


    NBNode * const getFromNode() const throw() {
        return myFrom;
    }


    NBNode * const getToNode() const throw() {
        return myTo;
    }


    SUMOReal getAngle() const throw() {
        return myAngle;
    }


    SUMOReal getLength() const throw() {
        return myLength;
    }


    SUMOReal getSpeed() const throw() {
        return mySpeed;
    }


    EdgeBuildingStep getStep() const throw() {
        return myStep;
    }





    const Position2DVector &getGeometry() const throw() {
        return myGeom;
    }


    void setGeometry(const Position2DVector &g) throw();


    void addGeometryPoint(int index, const Position2D &p) throw();


    void computeEdgeShape() throw();


    const Position2DVector &getLaneShape(unsigned int i) const throw();


    void setLaneSpreadFunction(LaneSpreadFunction spread) throw();


    LaneSpreadFunction getLaneSpreadFunction() const throw() {
        return myLaneSpreadFunction;
    }


    void reshiftPosition(SUMOReal xoff, SUMOReal yoff) throw();




    bool addEdge2EdgeConnection(NBEdge *dest) throw();


    bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest,
                                unsigned int toLane, Lane2LaneInfoType type,
                                bool mayUseSameDestination=false,
                                bool mayDefinitelyPass=false) throw();


    bool addLane2LaneConnections(unsigned int fromLane,
                                 NBEdge *dest, unsigned int toLane, unsigned int no,
                                 Lane2LaneInfoType type, bool invalidatePrevious=false,
                                 bool mayDefinitelyPass=false) throw();


    void setConnection(unsigned int lane, NBEdge *destEdge,
                       unsigned int destLane,
                       Lane2LaneInfoType type,
                       bool mayUseSameDestination=false,
                       bool mayDefinitelyPass=false) throw();


    std::vector<Connection> getConnectionsFromLane(unsigned int lane) const throw();


    bool hasConnectionTo(NBEdge *destEdge, unsigned int destLane) const throw();



    void setAsMacroscopicConnector() throw() {
        myAmMacroscopicConnector = true;
    }


    bool isMacroscopicConnector() throw() {
        return myAmMacroscopicConnector;
    }


    void setIsInnerEdge() throw() {
        myAmInnerEdge = true;
    }


    bool isInnerEdge() const throw() {
        return myAmInnerEdge;
    }


    void computeTurningDirections();


    void setJunctionPriority(const NBNode * const node, int prio);


    int getJunctionPriority(const NBNode * const node) const;


    void writeXMLStep1(OutputDevice &into);

    void writeXMLStep2(OutputDevice &into, bool includeInternal);

    bool hasRestrictions() const;
    void writeLanesPlain(OutputDevice &into);
    void setLoadedLength(SUMOReal val);
    void dismissVehicleClassInformation();


    const std::string &getTypeID() const throw() {
        return myType;
    }


    bool computeEdge2Edges();

    bool computeLanes2Edges();

    void sortOutgoingLanesConnections();

    bool recheckLanes();

    void appendTurnaround(bool noTLSControlled) throw();

    std::vector<int> getConnectionLanes(NBEdge *currentOutgoing) const;


    bool isTurningDirectionAt(const NBNode *n, const NBEdge * const edge) const throw();



    NBNode *tryGetNodeAtPosition(SUMOReal pos, SUMOReal tolerance=5.0) const;

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

    SUMOReal getMaxLaneOffset();

    Position2D getMinLaneOffsetPositionAt(NBNode *node, SUMOReal width) const;
    Position2D getMaxLaneOffsetPositionAt(NBNode *node, SUMOReal width) const;
    const std::vector<Connection> &getConnections() const {
        return myConnections;
    }
    std::vector<Connection> &getConnections() {
        return myConnections;
    }

    bool isConnectedTo(NBEdge *e);

    const std::vector<NBEdge*> *getConnectedSorted();

    std::vector<NBEdge*> getConnectedEdges() const throw();

    void remapConnections(const EdgeVector &incoming);

    void removeFromConnections(NBEdge *which, int lane=-1);

    void invalidateConnections(bool reallowSetting=false);

    bool lanesWereAssigned() const;

    bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const throw();
    bool setControllingTLInformation(int fromLane, NBEdge *toEdge, int toLane,
                                     const std::string &tlID, unsigned int tlPos);

    void addCrossingPointsAsIncomingWithGivenOutgoing(NBEdge *o,
            Position2DVector &into);

    SUMOReal width() const;

    Position2DVector getCWBoundaryLine(const NBNode &n, SUMOReal offset) const;
    Position2DVector getCCWBoundaryLine(const NBNode &n, SUMOReal offset) const;

    bool expandableBy(NBEdge *possContinuation) const;
    void append(NBEdge *continuation);
    SUMOReal getNormedAngle() const;

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


    friend class NBEdgeSuccessorBuilder;

    friend class NBEdgeCont;

    void moveOutgoingConnectionsFrom(NBEdge *e, unsigned int laneOff);

    NBEdge *getTurnDestination() const;

    std::string getLaneID(unsigned int lane);

    void setLaneSpeed(unsigned int lane, SUMOReal speed);

    SUMOReal getLaneSpeed(unsigned int lane) const;

    bool isNearEnough2BeJoined2(NBEdge *e);

    SUMOReal getAngle(const NBNode &atNode) const;

    SUMOReal getNormedAngle(const NBNode &atNode) const;


    void incLaneNo(unsigned int by);

    void decLaneNo(unsigned int by, int dir=0);

    void copyConnectionsFrom(NBEdge *src);

    void markAsInLane2LaneState();

    void allowVehicleClass(int lane, SUMOVehicleClass vclass);
    void disallowVehicleClass(int lane, SUMOVehicleClass vclass);
    void preferVehicleClass(int lane, SUMOVehicleClass vclass);
    std::vector<SUMOVehicleClass> getAllowedVehicleClasses() const;
    void setVehicleClasses(const std::vector<SUMOVehicleClass> &allowed, const std::vector<SUMOVehicleClass> &disallowed, int lane=-1);

    void disableConnection4TLS(int fromLane, NBEdge *toEdge, int toLane);


    int getMinConnectedLane(NBEdge *of) const;
    int getMaxConnectedLane(NBEdge *of) const;

    void setTurningDestination(NBEdge *e);

private:
    class ToEdgeConnectionsAdder : public Bresenham::BresenhamCallBack {
    private:
        std::map<NBEdge*, std::vector<unsigned int> > myConnections;

        const std::vector<NBEdge*> &myTransitions;

    public:
        ToEdgeConnectionsAdder(const std::vector<NBEdge*> &transitions) throw()
                : myTransitions(transitions) { }

        ~ToEdgeConnectionsAdder() throw() { }

        void execute(SUMOReal lane, SUMOReal virtEdge) throw();

        const std::map<NBEdge*, std::vector<unsigned int> > &getBuiltConnections() const throw() {
            return myConnections;
        }

    private:
        ToEdgeConnectionsAdder(const ToEdgeConnectionsAdder&);

        ToEdgeConnectionsAdder& operator=(const ToEdgeConnectionsAdder&);

    };


    class MainDirections {
    public:
        enum Direction { DIR_RIGHTMOST, DIR_LEFTMOST, DIR_FORWARD };

        std::vector<Direction> myDirs;

    public:
        MainDirections(const std::vector<NBEdge*> &outgoing,
                       NBEdge *parent, NBNode *to);

        ~MainDirections();

        bool empty() const;

        bool includes(Direction d) const;

    private:
        MainDirections(const MainDirections&);

        MainDirections& operator=(const MainDirections&);

    };

    Position2DVector computeLaneShape(unsigned int lane) throw(InvalidArgument);

    std::pair<SUMOReal, SUMOReal> laneOffset(const Position2D &from,
            const Position2D &to, SUMOReal lanewidth, unsigned int lane) throw(InvalidArgument);

    void computeLaneShapes() throw();

    bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc);
protected:
    bool acceptBeingTurning(NBEdge *e);


private:
    void init(unsigned int noLanes, bool tryIgnoreNodePositions) throw(ProcessError);


    void divideOnEdges(const std::vector<NBEdge*> *outgoing);

    std::vector<unsigned int> *preparePriorities(
        const std::vector<NBEdge*> *outgoing);

    unsigned int computePrioritySum(std::vector<unsigned int> *priorities);

    void moveConnectionToLeft(unsigned int lane);

    void moveConnectionToRight(unsigned int lane);


    void writeLane(OutputDevice &into, NBEdge::Lane &lane, unsigned int index) const;

    // !!! describe
    void writeSucceeding(OutputDevice &into, unsigned int lane,
                         bool includeInternal);





    // !!! describe
    void writeSingleSucceeding(OutputDevice &into,
                               const NBEdge::Connection &c, bool includeInternal);




private:
    EdgeBuildingStep myStep;

    std::string myID;

    std::string myType;

    NBNode *myFrom, *myTo;

    SUMOReal myLength;

    SUMOReal myAngle;

    int myPriority;

    SUMOReal mySpeed;

    std::vector<Connection> myConnections;

    NBEdge *myTurnDestination;

    int myFromJunctionPriority;

    int myToJunctionPriority;

    Position2DVector myGeom;

    LaneSpreadFunction myLaneSpreadFunction;

    std::vector<Lane> myLanes;

    SUMOReal myLoadedLength;

    bool myAmLeftHand;



    SUMOReal myAmTurningWithAngle;
    NBEdge *myAmTurningOf;

    bool myAmInnerEdge;

    bool myAmMacroscopicConnector;

    struct TLSDisabledConnection {
        int fromLane;
        NBEdge *to;
        int toLane;
    };

    std::vector<TLSDisabledConnection> myTLSDisabledConnections;

public:
    class tls_disable_finder {
    public:
        tls_disable_finder(const TLSDisabledConnection &tpl) : myDefinition(tpl) { }

        bool operator()(const TLSDisabledConnection &e) const {
            if (e.to!=myDefinition.to) {
                return false;
            }
            if (e.fromLane!=myDefinition.fromLane) {
                return false;
            }
            if (e.toLane!=myDefinition.toLane) {
                return false;
            }
            return true;
        }

    private:
        TLSDisabledConnection myDefinition;

    private:
        tls_disable_finder &operator=(const tls_disable_finder &s);

    };



    class connections_toedge_finder {
    public:
        connections_toedge_finder(NBEdge * const edge2find) : myEdge2Find(edge2find) { }

        bool operator()(const Connection &c) const {
            return c.toEdge == myEdge2Find;
        }

    private:
        NBEdge * const myEdge2Find;

    private:
        connections_toedge_finder &operator=(const connections_toedge_finder &s);

    };

    class connections_toedgelane_finder {
    public:
        connections_toedgelane_finder(NBEdge * const edge2find, int lane2find) : myEdge2Find(edge2find), myLane2Find(lane2find) { }

        bool operator()(const Connection &c) const {
            return c.toEdge == myEdge2Find && c.toLane == myLane2Find;
        }

    private:
        NBEdge * const myEdge2Find;
        int myLane2Find;

    private:
        connections_toedgelane_finder &operator=(const connections_toedgelane_finder &s);

    };


    class connections_finder {
    public:
        connections_finder(int fromLane, NBEdge * const edge2find, int lane2find) : myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find) { }

        bool operator()(const Connection &c) const {
            return c.fromLane==myFromLane && c.toEdge == myEdge2Find && c.toLane == myLane2Find;
        }

    private:
        int myFromLane;
        NBEdge * const myEdge2Find;
        int myLane2Find;

    private:
        connections_finder &operator=(const connections_finder &s);

    };

    class connections_fromlane_finder {
    public:
        connections_fromlane_finder(int lane2find) : myLane2Find(lane2find) { }

        bool operator()(const Connection &c) const {
            return c.fromLane == myLane2Find;
        }

    private:
        int myLane2Find;

    private:
        connections_fromlane_finder &operator=(const connections_fromlane_finder &s);

    };

    class connections_sorter {
    public:
        explicit connections_sorter() { }

        int operator()(const Connection &c1, const Connection &c2) const {
            if (c1.fromLane!=c2.fromLane) {
                return c1.fromLane<c2.fromLane;
            }
            return c1.toLane<c2.toLane;
        }

    };

    class connections_relative_edgelane_sorter {
    public:
        explicit connections_relative_edgelane_sorter(NBEdge *e, NBNode *n)
                : myEdge(e), myNode(n) {}

    public:
        int operator()(const Connection &c1, const Connection &c2) const {
            if (c1.toEdge!=c2.toEdge) {
                SUMOReal relAngle1 = NBHelpers::normRelAngle(
                                         myEdge->getAngle(), c1.toEdge->getAngle());
                SUMOReal relAngle2 = NBHelpers::normRelAngle(
                                         myEdge->getAngle(), c2.toEdge->getAngle());
                return relAngle1 > relAngle2;
            }
            return c1.toLane<c2.toLane;
        }

    private:
        NBEdge *myEdge;

        NBNode *myNode;

    };

private:
    NBEdge(const NBEdge &s);

    NBEdge &operator=(const NBEdge &s);


};


#endif

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