NBNodeCont Class Reference

#include <NBNodeCont.h>

---

Detailed Description

Container for nodes during the netbuilding process.

Definition at line 58 of file NBNodeCont.h.

Public Member Functions
void	clear ()
void	computeLanes2Lanes ()
	divides the incoming lanes on outgoing lanes
void	computeLogics (const NBEdgeCont &ec, NBJunctionLogicCont &jc, OptionsCont &oc)
	build the list of outgoing edges and lanes
void	computeNodeShapes (bool leftHand)
std::string	getFreeID ()
void	guessRamps (OptionsCont &oc, NBEdgeCont &ec, NBDistrictCont &dc)
	NBNodeCont () throw ()
	Constructor.
void	printBuiltNodesStatistics () const throw ()
	Prints statistics about built nodes.
void	recheckEdges (NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, NBEdgeCont &ec)
	Joins edges connecting the same nodes.
void	removeDummyEdges (NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
	Removes dummy edges (edges lying completely within a node).
void	removeIsolatedRoads (NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
	Removes sequences of edges that are not connected with a junction. Simple roads without junctions sometimes remain when converting from OpenStreetMake, but they make no sense. Remaining empty nodes are also deleted.
void	removeUnwishedNodes (NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc, bool removeGeometryNodes) throw ()
	Removes "unwished" nodes.
void	reshiftNodePositions (const SUMOReal xoff, const SUMOReal yoff)
	resets the node positions by the specified offset
bool	savePlain (const std::string &file)
unsigned int	size () const throw ()
	Returns the number of known nodes.
void	sortNodesEdges (bool leftHand, const NBTypeCont &tc)
	sorts the nodes' edges
void	writeXML (OutputDevice &into)
	writes the nodes into the given ostream
void	writeXMLInternalLinks (OutputDevice &into)
void	writeXMLInternalNodes (OutputDevice &into)
void	writeXMLInternalSuccInfos (OutputDevice &into)
	~NBNodeCont () throw ()
	Destructor.
Insertion/removal/retrieval of nodes
bool	erase (NBNode *node) throw ()
	Removes the given node, deleting it.
bool	insert (NBNode *node) throw ()
	Inserts a node into the map.
Position2D	insert (const std::string &id) throw ()
	Inserts a node into the map.
bool	insert (const std::string &id, const Position2D &position) throw ()
	Inserts a node into the map.
bool	insert (const std::string &id, const Position2D &position, NBDistrict *district) throw ()
	Inserts a node into the map.
NBNode *	retrieve (const Position2D &position, SUMOReal offset=0.) const throw ()
	Returns the node with the given coordinates.
NBNode *	retrieve (const std::string &id) const throw ()
	Returns the node with the given name.
Methods for guessing/computing traffic lights
void	guessTLs (OptionsCont &oc, NBTrafficLightLogicCont &tlc)
	Guesses which junctions or junction clusters shall be controlled by tls.
void	joinTLS (NBTrafficLightLogicCont &tlc)
	Builds clusters of tls-controlled junctions and joins the control if possible.
void	setAsTLControlled (NBNode *node, NBTrafficLightLogicCont &tlc, std::string id="")
	Sets the given node as being controlled by a tls.
Private Types
typedef std::map< std::string, NBNode * >	NodeCont
	Definition of the map of names to nodes.
Private Member Functions
void	buildOffRamp (OptionsCont &oc, NBNode *cur, NBEdgeCont &ec, NBDistrictCont &dc, std::vector< NBEdge * > &incremented)
bool	buildOnRamp (OptionsCont &oc, NBNode *cur, NBEdgeCont &ec, NBDistrictCont &dc, std::vector< NBEdge * > &incremented)
void	checkHighwayRampOrder (NBEdge *&pot_highway, NBEdge *&pot_ramp)
bool	mayNeedOffRamp (OptionsCont &oc, NBNode *cur) const
bool	mayNeedOnRamp (OptionsCont &oc, NBNode *cur) const
	NBNodeCont (const NBNodeCont &s)
	invalidated copy constructor
NBNodeCont &	operator= (const NBNodeCont &s)
	invalidated assignment operator
Helper methods for guessing/computing traffic lights
void	generateNodeClusters (SUMOReal maxDist, std::vector< std::set< NBNode * > > &into) const throw ()
	Builds node clusters.
bool	shouldBeTLSControlled (const std::set< NBNode * > &c) const throw ()
	Returns whethe the given node cluster should be controlled by a tls.
Private Attributes
int	myInternalID
	The running internal id.
NodeCont	myNodes
	The map of names to nodes.

---

Member Typedef Documentation

typedef std::map<std::string, NBNode*> NBNodeCont::NodeCont [private]

Definition of the map of names to nodes.

Definition at line 272 of file NBNodeCont.h.

---

Constructor & Destructor Documentation

NBNodeCont::NBNodeCont

(

)

throw ()

Constructor.

Definition at line 61 of file NBNodeCont.cpp.

        : myInternalID(1) {}

NBNodeCont::~NBNodeCont

(

)

throw ()

Destructor.

Definition at line 65 of file NBNodeCont.cpp.

References clear().

                                {
    clear();
}

NBNodeCont::NBNodeCont

(

const NBNodeCont &

s

)

[private]

invalidated copy constructor

---

Member Function Documentation

void NBNodeCont::buildOffRamp	(	OptionsCont &	oc,
		NBNode *	cur,
		NBEdgeCont &	ec,
		NBDistrictCont &	dc,
		std::vector< NBEdge * > &	incremented
	)			[private]

Definition at line 891 of file NBNodeCont.cpp.

References NBEdge::addLane2LaneConnections(), MsgHandler::getErrorInstance(), OptionsCont::getFloat(), NBEdge::getGeometry(), NBEdge::getID(), NBNode::getIncomingEdges(), NBEdge::getLaneSpreadFunction(), NBEdge::getNoLanes(), NBNode::getOutgoingEdges(), NBNode::getPosition(), NBEdge::getSpeed(), NBEdge::getToNode(), MsgHandler::getWarningInstance(), NBEdge::incLaneNo(), MsgHandler::inform(), insert(), NBEdge::invalidateConnections(), NBEdge::L2L_VALIDATED, NBEdge::LANESPREAD_CENTER, Position2DVector::length(), MIN2(), Position2DVector::move2side(), Position2DVector::pop_front(), POSITION_EPS, Position2DVector::positionAtLengthPosition(), Position2DVector::push_front(), NBEdgeCont::retrieve(), NBEdge::setGeometry(), NBEdgeCont::splitAt(), SUMO_const_halfLaneAndOffset, SUMO_const_laneWidthAndOffset, and SUMOReal.

Referenced by guessRamps().

                                                          {
    NBEdge *pot_highway = cur->getOutgoingEdges()[0];
    NBEdge *pot_ramp = cur->getOutgoingEdges()[1];
    NBEdge *prev = cur->getIncomingEdges()[0];
    // assign highway/ramp properly
    if (pot_highway->getSpeed()<pot_ramp->getSpeed()) {
        std::swap(pot_highway, pot_ramp);
    } else if (pot_highway->getSpeed()==pot_ramp->getSpeed()
               &&
               pot_highway->getNoLanes()<pot_ramp->getNoLanes()) {

        std::swap(pot_highway, pot_ramp);
    }
    // compute the number of lanes to append
    int toAdd = (pot_ramp->getNoLanes() + pot_highway->getNoLanes()) - prev->getNoLanes();
    if (toAdd<=0) {
        return;
    }
    // append on-ramp
    if (prev->getGeometry().length()-POSITION_EPS<=oc.getFloat("ramp-guess.ramp-length")) {
        // the edge is shorter than the wished ramp
        //  append a lane only
        if (find(incremented.begin(), incremented.end(), prev)==incremented.end()) {
            incremented.push_back(prev);
            prev->incLaneNo(toAdd);
            prev->invalidateConnections(true);
            if (!prev->addLane2LaneConnections(pot_ramp->getNoLanes(), pot_highway, 0,
                                               MIN2(prev->getNoLanes()-1, pot_highway->getNoLanes()), NBEdge::L2L_VALIDATED, true)) {

                throw ProcessError("Could not set connection!");

            }
            if (!prev->addLane2LaneConnections(0, pot_ramp, 0, pot_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, false)) {
                throw ProcessError("Could not set connection!");

            }
            if (prev->getLaneSpreadFunction()==NBEdge::LANESPREAD_CENTER) {
                try {
                    Position2DVector g = prev->getGeometry();
                    g.move2side(SUMO_const_laneWidthAndOffset);
                    prev->setGeometry(g);
                } catch (InvalidArgument &) {
                    MsgHandler::getWarningInstance()->inform("For edge '" + prev->getID() + "': could not compute shape.");
                }
            }
        }
        Position2DVector p = pot_ramp->getGeometry();
        p.pop_front();
        p.push_front(prev->getToNode()->getPosition());//added_ramp->getLaneShape(0).at(-1));
        pot_ramp->setGeometry(p);
    } else {
        Position2D pos =
            prev->getGeometry().positionAtLengthPosition(
                prev->getGeometry().length()-oc.getFloat("ramp-guess.ramp-length"));
        NBNode *rn = new NBNode(prev->getID() + "-AddedOffRampNode", pos);
        if (!insert(rn)) {
            throw ProcessError("Ups - could not build off-ramp for edge '" + pot_highway->getID() + "' (node could not be build)!");

        }
        std::string name = prev->getID();
        bool ok = ec.splitAt(dc, prev, rn,
                             prev->getID(), prev->getID()+"-AddedOffRampEdge",
                             prev->getNoLanes(), prev->getNoLanes()+toAdd);
        if (!ok) {
            MsgHandler::getErrorInstance()->inform("Ups - could not build on-ramp for edge '" + pot_highway->getID() + "'!");
            return;
        } else {
            NBEdge *added_ramp = ec.retrieve(name+"-AddedOffRampEdge");
            NBEdge *added = ec.retrieve(name);
            if (added_ramp->getNoLanes()!=added->getNoLanes()) {
                incremented.push_back(added_ramp);
                int off = added_ramp->getNoLanes()-added->getNoLanes();
                if (!added->addLane2LaneConnections(0, added_ramp, off, added->getNoLanes(), NBEdge::L2L_VALIDATED, true)) {
                    throw ProcessError("Could not set connection!");

                }
                if (added_ramp->getLaneSpreadFunction()==NBEdge::LANESPREAD_CENTER) {
                    try {
                        Position2DVector g = added_ramp->getGeometry();
                        SUMOReal factor = SUMO_const_laneWidthAndOffset * (SUMOReal)(toAdd-1) + SUMO_const_halfLaneAndOffset * (SUMOReal)(toAdd%2);
                        g.move2side(factor);
                        added_ramp->setGeometry(g);
                    } catch (InvalidArgument &) {
                        MsgHandler::getWarningInstance()->inform("For edge '" + added_ramp->getID() + "': could not compute shape.");
                    }
                }
            } else {
                if (!added->addLane2LaneConnections(0, added_ramp, 0, added_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, true)) {
                    throw ProcessError("Could not set connection!");
                }
            }
            if (!added_ramp->addLane2LaneConnections(pot_ramp->getNoLanes(), pot_highway, 0,
                    MIN2(added_ramp->getNoLanes()-pot_ramp->getNoLanes(), pot_highway->getNoLanes()), NBEdge::L2L_VALIDATED, true)) {
                throw ProcessError("Could not set connection!");
            }
            if (!added_ramp->addLane2LaneConnections(0, pot_ramp, 0, pot_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, false)) {
                throw ProcessError("Could not set connection!");

            }
            Position2DVector p = pot_ramp->getGeometry();
            p.pop_front();
            p.push_front(added_ramp->getToNode()->getPosition());//added_ramp->getLaneShape(0).at(-1));
            pot_ramp->setGeometry(p);
        }
    }
}

bool NBNodeCont::buildOnRamp	(	OptionsCont &	oc,
		NBNode *	cur,
		NBEdgeCont &	ec,
		NBDistrictCont &	dc,
		std::vector< NBEdge * > &	incremented
	)			[private]

Definition at line 771 of file NBNodeCont.cpp.

References NBEdge::addLane2LaneConnections(), MsgHandler::getErrorInstance(), OptionsCont::getFloat(), NBEdge::getFromNode(), NBEdge::getGeometry(), NBEdge::getID(), NBNode::getIncomingEdges(), NBEdge::getLaneSpreadFunction(), NBEdge::getNoLanes(), NBNode::getOutgoingEdges(), NBNode::getPosition(), NBEdge::getSpeed(), NBEdge::getToNode(), MsgHandler::getWarningInstance(), NBEdge::incLaneNo(), MsgHandler::inform(), insert(), NBEdge::invalidateConnections(), NBEdge::L2L_VALIDATED, NBEdge::LANESPREAD_CENTER, Position2DVector::length(), MIN2(), Position2DVector::move2side(), Position2DVector::pop_back(), POSITION_EPS, Position2DVector::positionAtLengthPosition(), Position2DVector::push_back(), NBEdgeCont::retrieve(), NBEdge::setGeometry(), NBEdgeCont::splitAt(), SUMO_const_halfLaneAndOffset, SUMO_const_laneWidthAndOffset, and SUMOReal.

Referenced by guessRamps().

                                                         {
    NBEdge *pot_highway = cur->getIncomingEdges()[0];
    NBEdge *pot_ramp = cur->getIncomingEdges()[1];
    NBEdge *cont = cur->getOutgoingEdges()[0];
    bool bEdgeDeleted = false;

    // assign highway/ramp properly
    if (pot_highway->getSpeed()<pot_ramp->getSpeed()) {
        std::swap(pot_highway, pot_ramp);
    } else if (pot_highway->getSpeed()==pot_ramp->getSpeed()
               &&
               pot_highway->getNoLanes()<pot_ramp->getNoLanes()) {

        std::swap(pot_highway, pot_ramp);
    }

    // compute the number of lanes to append
    int toAdd = (pot_ramp->getNoLanes() + pot_highway->getNoLanes()) - cont->getNoLanes();
    if (toAdd<=0) {
        return false;
    }

    //
    if (cont->getGeometry().length()-POSITION_EPS<=oc.getFloat("ramp-guess.ramp-length")) {
        // the edge is shorter than the wished ramp
        //  append a lane only
        if (find(incremented.begin(), incremented.end(), cont)==incremented.end()) {
            cont->incLaneNo(toAdd);
            incremented.push_back(cont);
            if (!pot_highway->addLane2LaneConnections(0, cont, pot_ramp->getNoLanes(),
                    MIN2(cont->getNoLanes()-pot_ramp->getNoLanes(), pot_highway->getNoLanes()), NBEdge::L2L_VALIDATED, true, true)) {
                throw ProcessError("Could not set connection!");
            }
            if (!pot_ramp->addLane2LaneConnections(0, cont, 0, pot_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, true, true)) {
                throw ProcessError("Could not set connection!");
            }
            //
            cont->invalidateConnections(true);
            const EdgeVector &o1 = cont->getToNode()->getOutgoingEdges();
            if (o1.size()==1&&o1[0]->getNoLanes()<cont->getNoLanes()) {
                cont->addLane2LaneConnections(cont->getNoLanes()-o1[0]->getNoLanes(),
                                              o1[0], 0, o1[0]->getNoLanes(), NBEdge::L2L_VALIDATED);
            }
            //
            if (cont->getLaneSpreadFunction()==NBEdge::LANESPREAD_CENTER) {
                try {
                    Position2DVector g = cont->getGeometry();
                    g.move2side(SUMO_const_laneWidthAndOffset);
                    cont->setGeometry(g);
                } catch (InvalidArgument &) {
                    MsgHandler::getWarningInstance()->inform("For edge '" + cont->getID() + "': could not compute shape.");
                }
            }
        }
        Position2DVector p = pot_ramp->getGeometry();
        p.pop_back();
        p.push_back(cont->getFromNode()->getPosition());
        pot_ramp->setGeometry(p);
    } else {
        bEdgeDeleted=true;
        // there is enough place to build a ramp; do it
        NBNode *rn =
            new NBNode(cont->getID() + "-AddedOnRampNode",
                       cont->getGeometry().positionAtLengthPosition(
                           oc.getFloat("ramp-guess.ramp-length")));
        if (!insert(rn)) {
            throw ProcessError("Ups - could not build on-ramp for edge '" + pot_highway->getID() + "' (node could not be build)!");
        }
        std::string name = cont->getID();
        bool ok = ec.splitAt(dc, cont, rn,
                             cont->getID()+"-AddedOnRampEdge", cont->getID(),
                             cont->getNoLanes()+toAdd, cont->getNoLanes());
        if (!ok) {
            MsgHandler::getErrorInstance()->inform("Ups - could not build on-ramp for edge '" + pot_highway->getID() + "'!");
            return true;
        } else {
            NBEdge *added_ramp = ec.retrieve(name+"-AddedOnRampEdge");
            NBEdge *added = ec.retrieve(name);
            incremented.push_back(added_ramp);
            if (added_ramp->getNoLanes()!=added->getNoLanes()) {
                int off = added_ramp->getNoLanes()-added->getNoLanes();
                if (!added_ramp->addLane2LaneConnections(off, added, 0, added->getNoLanes(), NBEdge::L2L_VALIDATED, true)) {
                    throw ProcessError("Could not set connection!");
                }
                if (added_ramp->getLaneSpreadFunction()==NBEdge::LANESPREAD_CENTER) {
                    try {
                        Position2DVector g = added_ramp->getGeometry();
                        SUMOReal factor = SUMO_const_laneWidthAndOffset * (SUMOReal)(toAdd-1) + SUMO_const_halfLaneAndOffset * (SUMOReal)(toAdd%2);
                        g.move2side(factor);
                        added_ramp->setGeometry(g);
                    } catch (InvalidArgument &) {
                        MsgHandler::getWarningInstance()->inform("For edge '" + added_ramp->getID() + "': could not compute shape.");
                    }
                }
            } else {
                if (!added_ramp->addLane2LaneConnections(0, added, 0, added_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, true)) {
                    throw ProcessError("Could not set connection!");
                }
            }
            if (!pot_highway->addLane2LaneConnections(0, added_ramp, pot_ramp->getNoLanes(),
                    MIN2(added_ramp->getNoLanes()-pot_ramp->getNoLanes(), pot_highway->getNoLanes()), NBEdge::L2L_VALIDATED, false, true)) {
                throw ProcessError("Could not set connection!");

            }
            if (!pot_ramp->addLane2LaneConnections(0, added_ramp, 0, pot_ramp->getNoLanes(), NBEdge::L2L_VALIDATED, true, true)) {
                throw ProcessError("Could not set connection!");
            }
            Position2DVector p = pot_ramp->getGeometry();
            p.pop_back();
            p.push_back(added_ramp->getFromNode()->getPosition());//added_ramp->getLaneShape(0).at(0));
            pot_ramp->setGeometry(p);
        }
    }
    return bEdgeDeleted;
}

void NBNodeCont::checkHighwayRampOrder	(	NBEdge *&	pot_highway,
		NBEdge *&	pot_ramp
	)			[private]

Definition at line 1050 of file NBNodeCont.cpp.

References NBEdge::getNoLanes(), and NBEdge::getSpeed().

Referenced by guessRamps().

                                                                         {
    if (pot_highway->getSpeed()<pot_ramp->getSpeed()) {
        std::swap(pot_highway, pot_ramp);
    } else if (pot_highway->getSpeed()==pot_ramp->getSpeed()
               &&
               pot_highway->getNoLanes()<pot_ramp->getNoLanes()) {

        std::swap(pot_highway, pot_ramp);
    }
}

void NBNodeCont::clear

(

)

deletes all nodes

Definition at line 459 of file NBNodeCont.cpp.

References myNodes.

Referenced by ~NBNodeCont().

                  {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        delete((*i).second);
    }
    myNodes.clear();
}

void NBNodeCont::computeLanes2Lanes

(

)

divides the incoming lanes on outgoing lanes

Definition at line 397 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::compute().

                               {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->computeLanes2Lanes();
    }
}

void NBNodeCont::computeLogics	(	const NBEdgeCont &	ec,
		NBJunctionLogicCont &	jc,
		OptionsCont &	oc
	)

build the list of outgoing edges and lanes

Definition at line 406 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::compute().

                                           {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->computeLogic(ec, jc, oc);
    }
}

void NBNodeCont::computeNodeShapes

(

bool

leftHand

)

Definition at line 656 of file NBNodeCont.cpp.

References OutputDevice::createDeviceByOption(), and myNodes.

Referenced by NBNetBuilder::compute().

                                           {
    OutputDevice::createDeviceByOption("node-geometry-dump", "pois");
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->computeNodeShape(leftHand);
    }
}

bool NBNodeCont::erase

(

NBNode *

node

)

throw ()

Removes the given node, deleting it.

Parameters:

[in]

node

The node to delete and remove

Returns:

Whether the node could be removed (existed)

Definition at line 147 of file NBNodeCont.cpp.

References myNodes.

Referenced by NIVissimEdge::remapOneOfNodes(), removeIsolatedRoads(), and removeUnwishedNodes().

                                      {
    NodeCont::iterator i = myNodes.find(node->getID());
    if (i==myNodes.end()) {
        return false;
    }
    node->removeTrafficLights();
    myNodes.erase(i);
    delete node;
    return true;
}

void NBNodeCont::generateNodeClusters	(	SUMOReal	maxDist,
		std::vector< std::set< NBNode * > > &	into
	)			const throw () [private]

Builds node clusters.

A node cluster is made up from nodes which are near by (distance<maxDist) and connected.

Parameters:

[in]	maxDist	The maximum distance between two nodes for clustering
	in,filled]	into The container to store the clusters in

Definition at line 161 of file NBNodeCont.cpp.

References Position2D::distanceTo(), NBNode::getEdges(), NBEdge::getFromNode(), NBNode::getPosition(), NBEdge::getToNode(), NBNode::hasIncoming(), and myNodes.

Referenced by guessTLs(), and joinTLS().

                                                                                                 {
    std::set<NBNode*> visited;
    for (NodeCont::const_iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        std::vector<NBNode*> toProc;
        if (visited.find((*i).second)!=visited.end()) {
            continue;
        }
        toProc.push_back((*i).second);
        std::set<NBNode*> c;
        while (!toProc.empty()) {
            NBNode *n = toProc.back();
            toProc.pop_back();
            if (visited.find(n)!=visited.end()) {
                continue;
            }
            c.insert(n);
            visited.insert(n);
            const EdgeVector &edges = n->getEdges();
            for (EdgeVector::const_iterator j=edges.begin(); j!=edges.end(); ++j) {
                NBEdge *e = *j;
                NBNode *s = 0;
                if (n->hasIncoming(e)) {
                    s = e->getFromNode();
                } else {
                    s = e->getToNode();
                }
                if (visited.find(s)!=visited.end()) {
                    continue;
                }
                if (n->getPosition().distanceTo(s->getPosition())<maxDist) {
                    toProc.push_back(s);
                }
            }
        }
        if (c.size()<2) {
            continue;
        }
        into.push_back(c);
    }
}

std::string NBNodeCont::getFreeID

(

)

Definition at line 650 of file NBNodeCont.cpp.

References size().

Referenced by NIXMLEdgesHandler::insertNodeChecking().

                      {
    return "SUMOGenerated" + toString<int>(size());
}

void NBNodeCont::guessRamps	(	OptionsCont &	oc,
		NBEdgeCont &	ec,
		NBDistrictCont &	dc
	)

Definition at line 1063 of file NBNodeCont.cpp.

References NBNode::addIncomingEdge(), buildOffRamp(), buildOnRamp(), checkHighwayRampOrder(), Position2D::distanceTo(), Position2DVector::eraseAt(), OptionsCont::getBool(), OptionsCont::getFloat(), NBEdge::getFromNode(), NBEdge::getGeometry(), NBEdge::getID(), NBNode::getIncomingEdges(), NBEdge::getNoLanes(), NBNode::getOutgoingEdges(), NBNode::getPosition(), OptionsCont::getStringVector(), NBEdge::getToNode(), MsgHandler::getWarningInstance(), MsgHandler::inform(), insert(), OptionsCont::isSet(), mayNeedOffRamp(), mayNeedOnRamp(), myNodes, Position2DVector::nearest_position_on_line_to_point(), Position2DVector::positionAtLengthPosition(), NBNode::removeIncoming(), NBEdgeCont::retrieve(), NBEdge::setGeometry(), NBEdgeCont::splitAt(), and SUMOReal.

Referenced by NBNetBuilder::compute().

                                           {
    std::vector<NBEdge*> incremented;
    bool bEdgeDeleted=false;
    // check whether obsure highway connections shall be checked
    if (oc.getBool("guess-obscure-ramps")) {
        for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
            NBNode *cur = (*i).second;
            const EdgeVector &inc = cur->getIncomingEdges();
            const EdgeVector &out = cur->getOutgoingEdges();
            if (inc.size()!=2||out.size()!=2) {
                continue;
            }
            {
                bool hadInHighway = false;
                for (EdgeVector::const_iterator j=inc.begin(); j!=inc.end(); ++j) {
                    if ((*j)->getSpeed()>oc.getFloat("obscure-ramps.min-highway-speed")) {

                        hadInHighway = true;
                    }
                }
                if (!hadInHighway) {
                    continue;
                }
            }
            {
                bool hadOutHighway = false;
                for (EdgeVector::const_iterator j=out.begin(); j!=out.end(); ++j) {
                    if ((*j)->getSpeed()>oc.getFloat("obscure-ramps.min-highway-speed")) {

                        hadOutHighway = true;
                    }
                }
                if (!hadOutHighway) {
                    continue;
                }
            }
            // ok, something is strange:
            //  we do have a highway, here with an off- and an on-ramp on the same node!?
            // try to place the incoming before...
            //  ... determine a possible position, first
            NBEdge *inc_highway = inc[0];
            NBEdge *inc_ramp = inc[1];
            NBEdge *out_highway = out[0];
            NBEdge *out_ramp = out[1];
            checkHighwayRampOrder(inc_highway, inc_ramp);
            checkHighwayRampOrder(out_highway, out_ramp);

            if (100>inc_highway->getToNode()->getPosition().distanceTo(inc_ramp->getGeometry()[-1])) {
                Position2DVector tmp = inc_ramp->getGeometry();
                tmp.eraseAt(-1);
                inc_ramp->setGeometry(tmp);
            }
            SUMOReal pos =
                inc_highway->getGeometry().nearest_position_on_line_to_point(
                    inc_ramp->getGeometry()[-1]);
            if (pos<0) {
                continue;
            }
            Position2D p = inc_highway->getGeometry().positionAtLengthPosition(pos);
            NBNode *rn =
                new NBNode(inc_highway->getID() + "-AddedAntiObscureNode", p);
            if (!insert(rn)) {
                throw ProcessError("Ups - could not build anti-obscure node '" + inc_highway->getID() + "'!");

            }
            std::string name = inc_highway->getID();
            bool ok = ec.splitAt(dc, inc_highway, rn,
                                 inc_highway->getID(), inc_highway->getID()+"-AddedInBetweenEdge",
                                 inc_highway->getNoLanes(), inc_highway->getNoLanes());
            if (!ok) {
                throw ProcessError("Ups - could not build anti-obscure edge '" + inc_highway->getID() + "'!");

            } else {
                NBEdge *added_cont = ec.retrieve(name+"-AddedInBetweenEdge");
                NBEdge *added = ec.retrieve(name);
                added_cont->getToNode()->removeIncoming(out_ramp);
                added->getToNode()->addIncomingEdge(out_ramp);
            }
        }
    }
    // check whether on-off ramps shall be guessed
    if (oc.getBool("guess-ramps")) {
        for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
            NBNode *cur = (*i).second;
            if (mayNeedOnRamp(oc, cur)) {
                buildOnRamp(oc, cur, ec, dc, incremented);
            }
            if (mayNeedOffRamp(oc, cur)) {
                buildOffRamp(oc, cur, ec, dc, incremented);
            }
        }
    }
    // check whether on-off ramps shall be guessed
    if (oc.isSet("ramp-guess.explicite")) {
        std::vector<std::string> edges = oc.getStringVector("ramp-guess.explicite");
        for (std::vector<std::string>::iterator i=edges.begin(); i!=edges.end(); ++i) {
            NBEdge *e = ec.retrieve(*i);
            if (e==0) {
                MsgHandler::getWarningInstance()->inform("Can not build on ramp on edge '" + *i + "' - the edge is not known.");
                continue;
            }
            NBNode *from = e->getFromNode();
            if (from->getIncomingEdges().size()==2&&from->getOutgoingEdges().size()==1) {
                bEdgeDeleted = buildOnRamp(oc, from, ec, dc, incremented);
            }
            // load edge again to check offramps
            e = ec.retrieve(*i);
            if (e==0) {
                MsgHandler::getWarningInstance()->inform("Can not build off ramp on edge '" + *i + "' - the edge is not known.");
                continue;
            }
            NBNode *to = e->getToNode();
            if (to->getIncomingEdges().size()==1&&to->getOutgoingEdges().size()==2) {
                buildOffRamp(oc, to, ec, dc, incremented);
            }
        }
    }
}

void NBNodeCont::guessTLs	(	OptionsCont &	oc,
		NBTrafficLightLogicCont &	tlc
	)

Guesses which junctions or junction clusters shall be controlled by tls.

Parameters:

[in]	oc	The options that steer the guessing process
	filled]	tlc The traffic lights control into which new traffic light definitions shall be stored

Todo:

Recheck exception handling

Definition at line 232 of file NBNodeCont.cpp.

References generateNodeClusters(), OptionsCont::getBool(), NBNode::getControllingTLS(), NBNode::getIncomingEdges(), OptionsCont::getStringVector(), NBTrafficLightLogicCont::insert(), NBNode::isNearDistrict(), OptionsCont::isSet(), NBNode::isTLControlled(), myNodes, NBNode::removeTrafficLights(), retrieve(), setAsTLControlled(), shouldBeTLSControlled(), SUMOReal, toString(), and WRITE_WARNING.

Referenced by NBNetBuilder::compute().

                                                                  {
    // build list of definitely not tls-controlled junctions
    std::vector<NBNode*> ncontrolled;
    if (oc.isSet("explicite-no-tls")) {
        std::vector<std::string> notTLControlledNodes = oc.getStringVector("explicite-no-tls");
        for (std::vector<std::string>::const_iterator i=notTLControlledNodes.begin(); i!=notTLControlledNodes.end(); ++i) {
            NBNode *n = NBNodeCont::retrieve(*i);
            if (n==0) {
                throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known.");
            }
            std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS();
            for (std::set<NBTrafficLightDefinition*>::const_iterator j=tls.begin(); j!=tls.end(); ++j) {
                (*j)->removeNode(n);
            }
            n->removeTrafficLights();
            ncontrolled.push_back(n);
        }
    }

    // loop#1 checking whether the node shall be tls controlled,
    //  because it is assigned to a district
    if (oc.getBool("tls-guess.district-nodes")) {
        for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
            NBNode *cur = (*i).second;
            if (cur->isNearDistrict()&&find(ncontrolled.begin(), ncontrolled.end(), cur)==ncontrolled.end()) {
                setAsTLControlled(cur, tlc);
            }
        }
    }

    // maybe no tls shall be guessed
    if (!oc.getBool("guess-tls")) {
        return;
    }

    // guess joined tls first, if wished
    if (oc.getBool("tls-guess.joining")) {
        // get node clusters
        SUMOReal MAXDIST = 25;
        std::vector<std::set<NBNode*> > cands;
        generateNodeClusters(MAXDIST, cands);
        // check these candidates (clusters) whether they should be controlled by a tls
        for (std::vector<std::set<NBNode*> >::iterator i=cands.begin(); i!=cands.end();) {
            std::set<NBNode*> &c = (*i);
            // regard only junctions which are not yet controlled and are not
            //  forbidden to be controlled
            for (std::set<NBNode*>::iterator j=c.begin(); j!=c.end();) {
                if ((*j)->isTLControlled()||find(ncontrolled.begin(), ncontrolled.end(), *j)!=ncontrolled.end()) {
                    c.erase(j++);
                } else {
                    ++j;
                }
            }
            // check whether the cluster should be controlled
            if (!shouldBeTLSControlled(c)) {
                i = cands.erase(i);
            } else {
                ++i;
            }
        }
        // cands now only contain sets of junctions that shall be joined into being tls-controlled
        unsigned int index = 0;
        for (std::vector<std::set<NBNode*> >::iterator i=cands.begin(); i!=cands.end(); ++i) {
            std::vector<NBNode*> nodes;
            for (std::set<NBNode*>::iterator j=(*i).begin(); j!=(*i).end(); j++) {
                nodes.push_back(*j);
            }
            std::string id = "joinedG_" + toString(index++);
            NBTrafficLightDefinition *tlDef = new NBOwnTLDef(id, nodes);
            if (!tlc.insert(tlDef)) {
                // actually, nothing should fail here
                WRITE_WARNING("Could not build guessed, joined tls");
                delete tlDef;
                return;
            }
        }
    }

    // guess tls
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        NBNode *cur = (*i).second;
        //  do nothing if already is tl-controlled
        if (cur->isTLControlled()) {
            continue;
        }
        // do nothing if in the list of explicite non-controlled junctions
        if (find(ncontrolled.begin(), ncontrolled.end(), cur)!=ncontrolled.end()) {
            continue;
        }
        std::set<NBNode*> c;
        c.insert(cur);
        if (!shouldBeTLSControlled(c)||cur->getIncomingEdges().size()<3) {
            continue;
        }
        setAsTLControlled((*i).second, tlc);
    }
}

bool NBNodeCont::insert

(

NBNode *

node

)

throw ()

Inserts a node into the map.

Parameters:

[in]

node

The node to insert

Returns:

Whether the node could be added (no other with the same id or position is stored)

Definition at line 111 of file NBNodeCont.cpp.

References myNodes.

                                       {
    std::string id = node->getID();
    NodeCont::iterator i = myNodes.find(id);
    if (i!=myNodes.end()) {
        return false;
    }
    myNodes[id] = node;
    return true;
}

Position2D NBNodeCont::insert

(

const std::string &

id

)

throw ()

Inserts a node into the map.

Parameters:

[in]

id

The node's id

Returns:

Whether the node could be added (no other with the same id is stored)

Definition at line 97 of file NBNodeCont.cpp.

References myNodes.

                                              {
    std::pair<SUMOReal, SUMOReal> ret(-1.0, -1.0);
    NodeCont::iterator i = myNodes.find(id);
    if (i!=myNodes.end()) {
        return (*i).second->getPosition();
    } else {
        NBNode *node = new NBNode(id, Position2D(-1.0, -1.0));
        myNodes[id] = node;
    }
    return Position2D(-1, -1);
}

bool NBNodeCont::insert	(	const std::string &	id,
		const Position2D &	position
	)			throw ()

Inserts a node into the map.

Parameters:

[in]	id	The node's id
[in]	position	The node's position

Returns:

Whether the node could be added (no other with the same id or position is stored)

Definition at line 85 of file NBNodeCont.cpp.

References myNodes.

                                                                          {
    NodeCont::iterator i = myNodes.find(id);
    if (i!=myNodes.end()) {
        return false;
    }
    NBNode *node = new NBNode(id, position);
    myNodes[id] = node;
    return true;
}

bool NBNodeCont::insert	(	const std::string &	id,
		const Position2D &	position,
		NBDistrict *	district
	)			throw ()

Inserts a node into the map.

Parameters:

[in]	id	The node's id
[in]	position	The node's position
[in]	A	district assigned to the node

Returns:

Whether the node could be added (no other with the same id or position is stored)

Definition at line 72 of file NBNodeCont.cpp.

References myNodes.

Referenced by NIImporter_SUMO::addJunction(), NIImporter_VISUM::buildDistrictNode(), NIVissimNodeCluster::buildNBNode(), buildOffRamp(), buildOnRamp(), NIVissimDistrictConnection::dict_BuildDistrictNodes(), NIVissimEdge::getFromNode(), NIVissimEdge::getToNode(), guessRamps(), NIXMLEdgesHandler::insertNodeChecking(), NIImporter_ArcView::load(), NIImporter_OpenDrive::loadNetwork(), NIImporter_RobocupRescue::loadNodes(), NIXMLEdgesHandler::myEndElement(), NIXMLNodesHandler::myStartElement(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_Nodes(), NIVissimEdge::remapOneOfNodes(), NIImporter_DlrNavteq::NodesHandler::report(), NIVissimEdge::resolveSameNode(), NBEdge::splitGeometry(), and NGNet::toNB().

                                                 {
    NodeCont::iterator i = myNodes.find(id);
    if (i!=myNodes.end()) {
        return false;
    }
    NBNode *node = new NBNode(id, position, district);
    myNodes[id] = node;
    return true;
}

void NBNodeCont::joinTLS

(

NBTrafficLightLogicCont &

tlc

)

Builds clusters of tls-controlled junctions and joins the control if possible.

Parameters:

changed]

tlc The traffic lights control for adding/removing new/prior tls

Todo:

Recheck exception handling

Definition at line 332 of file NBNodeCont.cpp.

References generateNodeClusters(), NBTrafficLightLogicCont::insert(), NBTrafficLightLogicCont::remove(), SUMOReal, toString(), and WRITE_WARNING.

Referenced by NBNetBuilder::compute().

                                                {
    SUMOReal MAXDIST = 25;
    std::vector<std::set<NBNode*> > cands;
    generateNodeClusters(MAXDIST, cands);
    unsigned int index = 0;
    for (std::vector<std::set<NBNode*> >::iterator i=cands.begin(); i!=cands.end(); ++i) {
        std::set<NBNode*> &c = (*i);
        for (std::set<NBNode*>::iterator j=c.begin(); j!=c.end();) {
            if (!(*j)->isTLControlled()) {
                c.erase(j++);
            } else {
                ++j;
            }
        }
        if (c.size()<2) {
            continue;
        }
        for (std::set<NBNode*>::iterator j=c.begin(); j!=c.end(); ++j) {
            std::set<NBTrafficLightDefinition*> tls = (*j)->getControllingTLS();
            (*j)->removeTrafficLights();
            for (std::set<NBTrafficLightDefinition*>::iterator k=tls.begin(); k!=tls.end(); ++k) {
                tlc.remove((*j)->getID());
            }
        }
        std::string id = "joinedS_" + toString(index++);
        std::vector<NBNode*> nodes;
        for (std::set<NBNode*>::iterator j=c.begin(); j!=c.end(); j++) {
            nodes.push_back(*j);
        }
        NBTrafficLightDefinition *tlDef = new NBOwnTLDef(id, nodes);
        if (!tlc.insert(tlDef)) {
            // actually, nothing should fail here
            WRITE_WARNING("Could not build a joined tls.");
            delete tlDef;
            return;
        }
    }
}

bool NBNodeCont::mayNeedOffRamp	(	OptionsCont &	oc,
		NBNode *	cur
	)			const [private]

Definition at line 1002 of file NBNodeCont.cpp.

References OptionsCont::getFloat(), NBNode::getIncomingEdges(), NBEdge::getNoLanes(), NBNode::getOutgoingEdges(), NBEdge::getSpeed(), and NBEdge::isMacroscopicConnector().

Referenced by guessRamps().

                                                             {
    if (cur->getIncomingEdges().size()==1&&cur->getOutgoingEdges().size()==2) {
        // may be an off-ramp
        NBEdge *pot_highway = cur->getOutgoingEdges()[0];
        NBEdge *pot_ramp = cur->getOutgoingEdges()[1];
        NBEdge *prev = cur->getIncomingEdges()[0];

        // do not build ramps on connectors
        if (pot_highway->isMacroscopicConnector()||pot_ramp->isMacroscopicConnector()||prev->isMacroscopicConnector()) {
            return false;
        }

        // check whether a lane is missing
        if (pot_highway->getNoLanes()+pot_ramp->getNoLanes()<=prev->getNoLanes()) {
            return false;
        }

        // assign highway/ramp properly
        if (pot_highway->getSpeed()<pot_ramp->getSpeed()) {
            std::swap(pot_highway, pot_ramp);
        } else if (pot_highway->getSpeed()==pot_ramp->getSpeed()
                   &&
                   pot_highway->getNoLanes()<pot_ramp->getNoLanes()) {

            std::swap(pot_highway, pot_ramp);
        }

        // check conditions
        // is it really a highway?
        if (pot_highway->getSpeed()<oc.getFloat("ramp-guess.min-highway-speed")
                ||
                prev->getSpeed()<oc.getFloat("ramp-guess.min-highway-speed")) {
            return false;
        }
        // is it really a ramp?
        if (oc.getFloat("ramp-guess.max-ramp-speed")>0
                &&
                oc.getFloat("ramp-guess.max-ramp-speed")<pot_ramp->getSpeed()) {
            return false;
        }

        return true;
    }
    return false;
}

bool NBNodeCont::mayNeedOnRamp	(	OptionsCont &	oc,
		NBNode *	cur
	)			const [private]

Definition at line 722 of file NBNodeCont.cpp.

References OptionsCont::getFloat(), NBNode::getIncomingEdges(), NBEdge::getNoLanes(), NBNode::getOutgoingEdges(), NBEdge::getSpeed(), and NBEdge::isMacroscopicConnector().

Referenced by guessRamps().

                                                            {
    if (cur->getIncomingEdges().size()==2&&cur->getOutgoingEdges().size()==1) {
        // may be an on-ramp
        NBEdge *pot_highway = cur->getIncomingEdges()[0];
        NBEdge *pot_ramp = cur->getIncomingEdges()[1];
        NBEdge *cont = cur->getOutgoingEdges()[0];

        // do not build ramps on connectors
        if (pot_highway->isMacroscopicConnector()||pot_ramp->isMacroscopicConnector()||cont->isMacroscopicConnector()) {
            return false;
        }

        // check whether a lane is missing
        if (pot_highway->getNoLanes()+pot_ramp->getNoLanes()<=cont->getNoLanes()) {
            return false;
        }

        // assign highway/ramp properly
        if (pot_highway->getSpeed()<pot_ramp->getSpeed()) {
            std::swap(pot_highway, pot_ramp);
        } else if (pot_highway->getSpeed()==pot_ramp->getSpeed()
                   &&
                   pot_highway->getNoLanes()<pot_ramp->getNoLanes()) {

            std::swap(pot_highway, pot_ramp);
        }

        // check conditions
        // is it really a highway?
        if (pot_highway->getSpeed()<oc.getFloat("ramp-guess.min-highway-speed")
                ||
                cont->getSpeed()<oc.getFloat("ramp-guess.min-highway-speed")) {
            return false;
        }
        // is it really a ramp?
        if (oc.getFloat("ramp-guess.max-ramp-speed")>0
                &&
                oc.getFloat("ramp-guess.max-ramp-speed")<pot_ramp->getSpeed()) {
            return false;
        }

        // ok, may be
        return true;
    }
    return false;
}

NBNodeCont& NBNodeCont::operator=

(

const NBNodeCont &

s

)

[private]

invalidated assignment operator

void NBNodeCont::printBuiltNodesStatistics

(

)

const throw ()

Prints statistics about built nodes.

Goes through stored nodes, computes the numbers of unregulated, priority and right-before-left junctions and prints them.

Definition at line 1220 of file NBNodeCont.cpp.

References myNodes, NBNode::NODETYPE_DISTRICT, NBNode::NODETYPE_NOJUNCTION, NBNode::NODETYPE_PRIORITY_JUNCTION, NBNode::NODETYPE_RIGHT_BEFORE_LEFT, NBNode::NODETYPE_TRAFFIC_LIGHT, NBNode::NODETYPE_UNKNOWN, toString(), and WRITE_MESSAGE.

Referenced by NBNetBuilder::compute().

                                                    {
    int noDistricts = 0;
    int noUnregulatedJunctions = 0;
    int noPriorityJunctions = 0;
    int noRightBeforeLeftJunctions = 0;
    for (NodeCont::const_iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        switch ((*i).second->getType()) {
        case NBNode::NODETYPE_NOJUNCTION:
            ++noUnregulatedJunctions;
            break;
        case NBNode::NODETYPE_PRIORITY_JUNCTION:
        case NBNode::NODETYPE_TRAFFIC_LIGHT:
            ++noPriorityJunctions;
            break;
        case NBNode::NODETYPE_RIGHT_BEFORE_LEFT:
            ++noRightBeforeLeftJunctions;
            break;
        case NBNode::NODETYPE_DISTRICT:
            ++noRightBeforeLeftJunctions;
            break;
        case NBNode::NODETYPE_UNKNOWN:
            break;
        default:
            break;
        }
    }
    WRITE_MESSAGE(" Node type statistics:");
    WRITE_MESSAGE("  Unregulated junctions       : " + toString(noUnregulatedJunctions));
    WRITE_MESSAGE("  Priority junctions          : " + toString(noPriorityJunctions));
    WRITE_MESSAGE("  Right-before-left junctions : " + toString(noRightBeforeLeftJunctions));
}

void NBNodeCont::recheckEdges	(	NBDistrictCont &	dc,
		NBTrafficLightLogicCont &	tlc,
		NBEdgeCont &	ec
	)

Joins edges connecting the same nodes.

Definition at line 468 of file NBNodeCont.cpp.

References NBEdge::getToNode(), NBEdgeCont::joinSameNodeConnectingEdges(), and myNodes.

Referenced by NBNetBuilder::compute().

                                         {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        // count the edges to other nodes outgoing from the current
        //  node
        std::map<NBNode*, EdgeVector> connectionCount;
        const EdgeVector &outgoing = (*i).second->getOutgoingEdges();
        for (EdgeVector::const_iterator j=outgoing.begin(); j!=outgoing.end(); j++) {
            NBEdge *e = (*j);
            NBNode *connected = e->getToNode();
            if (connectionCount.find(connected)==connectionCount.end()) {
                connectionCount[connected] = EdgeVector();
                connectionCount[connected].push_back(e);
            } else {
                connectionCount[connected].push_back(e);
            }
        }
        // check whether more than a single edge connect another node
        //  and join them
        std::map<NBNode*, EdgeVector>::iterator k;
        for (k=connectionCount.begin(); k!=connectionCount.end(); k++) {
            // possibly we do not have anything to join...
            if ((*k).second.size()<2) {
                continue;
            }
            // for the edges that seem to be a single street,
            //  check whether the geometry is similar
            const EdgeVector &ev = (*k).second;
            typedef std::vector<EdgeVector> EdgeVV;
            EdgeVV geometryCombinations;
            for (EdgeVector::const_iterator l=ev.begin(); l!=ev.end(); ++l) {
                // append the first one simply to the list of really joinable edges
                if (geometryCombinations.size()==0) {
                    EdgeVector tmp;
                    tmp.push_back(*l);
                    geometryCombinations.push_back(tmp);
                    continue;
                }
                // check the lists of really joinable edges
                bool wasPushed = false;
                for (EdgeVV::iterator m=geometryCombinations.begin(); !wasPushed&&m!=geometryCombinations.end();) {
                    for (EdgeVector::iterator n=(*m).begin(); !wasPushed&&n!=(*m).end();) {
                        if ((*n)->isNearEnough2BeJoined2(*l)) {
                            (*m).push_back(*l);
                            wasPushed = true;
                        }
                        if (!wasPushed) {
                            ++n;
                        }
                    }
                    if (!wasPushed) {
                        ++m;
                    }
                }
                if (!wasPushed) {
                    EdgeVector tmp;
                    tmp.push_back(*l);
                    geometryCombinations.push_back(tmp);
                }
            }
        }
        for (k=connectionCount.begin(); k!=connectionCount.end(); k++) {
            // join edges
            if ((*k).second.size()>1) {
                ec.joinSameNodeConnectingEdges(dc, tlc, (*k).second);
            }
        }
    }
}

void NBNodeCont::removeDummyEdges	(	NBDistrictCont &	dc,
		NBEdgeCont &	ec,
		NBTrafficLightLogicCont &	tc
	)

Removes dummy edges (edges lying completely within a node).

Definition at line 637 of file NBNodeCont.cpp.

References myNodes, toString(), and WRITE_WARNING.

Referenced by NBNetBuilder::compute().

                                                          {
    unsigned int no = 0;
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        no += (*i).second->eraseDummies(dc, ec, tc);
    }
    if (no!=0) {
        WRITE_WARNING(toString(no) + " dummy edge(s) removed.");
    }
}

void NBNodeCont::removeIsolatedRoads	(	NBDistrictCont &	dc,
		NBEdgeCont &	ec,
		NBTrafficLightLogicCont &	tc
	)

Removes sequences of edges that are not connected with a junction. Simple roads without junctions sometimes remain when converting from OpenStreetMake, but they make no sense. Remaining empty nodes are also deleted.

Parameters:

[in]	dc	The district container needed if edges shall be removed
[in]	ec	The container with the edge to be tested

Definition at line 540 of file NBNodeCont.cpp.

References erase(), NBEdgeCont::erase(), NBEdgeCont::getAllNames(), NBEdge::getFromNode(), NBNode::getIncomingEdges(), OptionsCont::getOptions(), NBNode::getOutgoingEdges(), NBEdge::getToNode(), NBEdgeCont::retrieve(), and WRITE_WARNING.

Referenced by NBNetBuilder::compute().

                                                                                               {
    // Warn of isolated edges, i.e. a single edge with no connection to another edge
    int edgeCounter = 0;
    const std::vector<std::string> &edgeNames = ec.getAllNames();
    for (std::vector<std::string>::const_iterator it = edgeNames.begin(); it != edgeNames.end(); ++it) {
        // Test whether this node starts at a dead end, i.e. it has only one adjacent node
        // to which an edge exists and from which an edge may come.
        NBEdge *e = ec.retrieve(*it);
        if (e == 0) {
            continue;
        }
        NBNode* from = e->getFromNode();
        const EdgeVector &outgoingEdges = from->getOutgoingEdges();
        if (outgoingEdges.size() != 1) {
            // At this node, several edges or no edge start; so, this node is no dead end.
            continue;
        }
        const EdgeVector &incomingEdges = from->getIncomingEdges();
        if (incomingEdges.size() > 1) {
            // At this node, several edges end; so, this node is no dead end.
            continue;
        } else if (incomingEdges.size() == 1) {
            NBNode* fromNodeOfIncomingEdge = incomingEdges[0]->getFromNode();
            NBNode* toNodeOfOutgoingEdge = outgoingEdges[0]->getToNode();
            if (fromNodeOfIncomingEdge != toNodeOfOutgoingEdge) {
                // At this node, an edge ends which is not the inverse direction of
                // the starting node.
                continue;
            }
        }
        // Now we know that the edge e starts a dead end.
        // Next we test if the dead end is isolated, i.e. does not lead to a junction
        bool hasJunction = false;
        std::vector<NBEdge*> road;
        NBEdge* eOld = 0;
        NBNode* to;
        std::set<NBNode*> adjacentNodes;
        do {
            road.push_back(e);
            eOld = e;
            from = e->getFromNode();
            to = e->getToNode();
            const EdgeVector &outgoingEdgesOfToNode = to->getOutgoingEdges();
            const EdgeVector &incomingEdgesOfToNode = to->getIncomingEdges();
            adjacentNodes.clear();
            for (EdgeVector::const_iterator itOfOutgoings=outgoingEdgesOfToNode.begin(); itOfOutgoings!=outgoingEdgesOfToNode.end(); ++itOfOutgoings) {
                if ((*itOfOutgoings)->getToNode() != from        // The back path
                        && (*itOfOutgoings)->getToNode() != to   // A loop / dummy edge
                   ) {
                    e = *itOfOutgoings; // Probably the next edge
                }
                adjacentNodes.insert((*itOfOutgoings)->getToNode());
            }
            for (EdgeVector::const_iterator itOfIncomings=incomingEdgesOfToNode.begin(); itOfIncomings!=incomingEdgesOfToNode.end(); ++itOfIncomings) {
                adjacentNodes.insert((*itOfIncomings)->getFromNode());
            }
            adjacentNodes.erase(to);  // Omit loops / dummy edges
            if (adjacentNodes.size() > 2) {
                hasJunction = true;
            }
        } while (!hasJunction && eOld != e);
        if (!hasJunction) {
            edgeCounter += road.size();
            std::string warningString =
                "Removed a road without junctions: ";
            for (std::vector<NBEdge*>::iterator roadIt = road.begin(); roadIt
                    != road.end(); ++roadIt) {
                if (roadIt == road.begin()) {
                    warningString += (*roadIt)->getID();
                } else {
                    warningString += ", " + (*roadIt)->getID();
                }

                NBNode* fromNode = (*roadIt)->getFromNode();
                NBNode* toNode = (*roadIt)->getToNode();
                ec.erase(dc, *roadIt);
                if (fromNode->getIncomingEdges().size() == 0
                        && fromNode->getOutgoingEdges().size() == 0) {
                    // Node is empty; can be removed
                    erase(fromNode);
                }
                if (toNode->getIncomingEdges().size() == 0
                        && toNode->getOutgoingEdges().size() == 0) {
                    // Node is empty; can be removed
                    erase(toNode);
                }
            }
            WRITE_WARNING(warningString);
        }
    }
    if (edgeCounter > 0 && !OptionsCont::getOptions().getBool("remove-isolated")) {
        WRITE_WARNING("Detected isolated roads. Use the option --remove-isolated to get a list of all affected edges.");
    }
}

void NBNodeCont::removeUnwishedNodes	(	NBDistrictCont &	dc,
		NBEdgeCont &	ec,
		NBTrafficLightLogicCont &	tlc,
		bool	removeGeometryNodes
	)			throw ()

Removes "unwished" nodes.

Removes nodes if a) no incoming/outgoing edges exist or b) if the node is a "geometry" node. In the second case, edges that participate at the node will be joined. Whether the node is a geometry node or not, is determined by a call to NBNode::checkIsRemovable. The node is removed from the list of tls-controlled nodes.

Parameters:

	in,mod]	dc The district container needed if a node shall be removed
	in,mod]	ec The edge container needed for joining edges
	in,mod]	tlc The traffic lights container to remove nodes from
[in]	removeGeometryNodes	Whether geometry nodes shall also be removed

Definition at line 665 of file NBNodeCont.cpp.

References NBEdge::append(), NBJoinedEdgesMap::appended(), NBNode::checkIsRemovable(), erase(), NBNode::getEdgesToJoin(), NBEdge::getID(), NBNode::getIncomingEdges(), NBNode::getOutgoingEdges(), NBEdge::getToNode(), gJoinedEdges, myNodes, NBNode::replaceIncoming(), toString(), and WRITE_MESSAGE.

Referenced by NBNetBuilder::compute().

                                                                  {
    unsigned int no = 0;
    std::vector<NBNode*> toRemove;
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        NBNode *current = (*i).second;
        bool remove = false;
        std::vector<std::pair<NBEdge*, NBEdge*> > toJoin;
        // check for completely empty nodes
        if (current->getOutgoingEdges().size()==0
                &&
                current->getIncomingEdges().size()==0) {

            // remove if empty
            remove = true;
        }
        // check for nodes which are only geometry nodes
        if (removeGeometryNodes) {
            if ((current->getOutgoingEdges().size()==1 && current->getIncomingEdges().size()==1)
                    ||
                    (current->getOutgoingEdges().size()==2 && current->getIncomingEdges().size()==2)) {
                // ok, one in, one out or two in, two out
                //  -> ask the node whether to join
                remove = current->checkIsRemovable();
                if (remove) {
                    toJoin = current->getEdgesToJoin();
                }
            }
        }
        // remove the node and join the geometries when wished
        if (!remove) {
            continue;
        }
        for (std::vector<std::pair<NBEdge*, NBEdge*> >::iterator j=toJoin.begin(); j!=toJoin.end(); j++) {
            NBEdge *begin = (*j).first;
            NBEdge *continuation = (*j).second;
            begin->append(continuation);
            continuation->getToNode()->replaceIncoming(continuation, begin, 0);
            tlc.replaceRemoved(continuation, -1, begin, -1);
            gJoinedEdges.appended(begin->getID(), continuation->getID());
            ec.erase(dc, continuation);
        }
        toRemove.push_back(current);
        no++;
    }
    // erase all
    for (std::vector<NBNode*>::iterator j = toRemove.begin(); j
            != toRemove.end(); j++) {
        erase(*j);
    }
    WRITE_MESSAGE("   " + toString(no) + " nodes removed.");
}

void NBNodeCont::reshiftNodePositions	(	const SUMOReal	xoff,
		const SUMOReal	yoff
	)

resets the node positions by the specified offset

Definition at line 389 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::compute().

                                                                         {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->reshiftPosition(xoff, yoff);
    }
}

NBNode * NBNodeCont::retrieve	(	const Position2D &	position,
		SUMOReal	offset = 0.
	)			const throw ()

Returns the node with the given coordinates.

Parameters:

[in]	position	The position at which the node to retrieve lies
[in]	offset	An offset which can be applied in the case positions are blurred

Returns:

The node at the given position, or 0 if no such node exists

Definition at line 133 of file NBNodeCont.cpp.

References NBNode::getPosition(), myNodes, Position2D::x(), and Position2D::y().

                                                                              {
    for (NodeCont::const_iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        NBNode *node = (*i).second;
        if (fabs(node->getPosition().x()-position.x())<offset
                &&
                fabs(node->getPosition().y()-position.y())<offset) {
            return node;
        }
    }
    return 0;
}

NBNode * NBNodeCont::retrieve

(

const std::string &

id

)

const throw ()

Returns the node with the given name.

Parameters:

[in]

id

The id of the node to retrieve

Returns:

The node with the given id, or 0 if no such node exists

Definition at line 123 of file NBNodeCont.cpp.

References myNodes.

Referenced by NIVissimDisturbance::addToNode(), NIImporter_VISUM::buildDistrictNode(), NBNetBuilder::compute(), NIVissimNodeCluster::dict_addDisturbances(), NIVissimDistrictConnection::dict_BuildDistricts(), NIImporter_VISUM::getNamedNode(), guessTLs(), NIXMLEdgesHandler::insertNodeChecking(), NIImporter_ArcView::load(), NIImporter_RobocupRescue::loadEdges(), NIImporter_SUMO::loadNetwork(), NIImporter_OpenDrive::loadNetwork(), NIXMLNodesHandler::myStartElement(), NIImporter_VISUM::parse_NodesToTrafficLights(), NIImporter_DlrNavteq::TrafficlightsHandler::report(), NIImporter_DlrNavteq::EdgesHandler::report(), NIVissimEdge::resolveSameNode(), and NBEdge::splitGeometry().

                                                      {
    NodeCont::const_iterator i = myNodes.find(id);
    if (i==myNodes.end()) {
        return 0;
    }
    return (*i).second;
}

bool NBNodeCont::savePlain

(

const std::string &

file

)

Definition at line 1188 of file NBNodeCont.cpp.

References OutputDevice::close(), GEO_OUTPUT_ACCURACY, NBNode::getControllingTLS(), OutputDevice::getDevice(), NBNode::getID(), NBNode::getPosition(), NBNode::isTLControlled(), myNodes, OutputDevice::setPrecision(), GeoConvHelper::usingInverseGeoProjection(), OutputDevice::writeXMLHeader(), Position2D::x(), and Position2D::y().

Referenced by NBNetBuilder::compute().

                                           {
    OutputDevice& device = OutputDevice::getDevice(file);
    device.writeXMLHeader("nodes");
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        NBNode *n = (*i).second;
        device << "   <node id=\"" << n->getID() << "\" ";
        if (GeoConvHelper::usingInverseGeoProjection()) {
            device.setPrecision(GEO_OUTPUT_ACCURACY);
            device << "x=\"" << n->getPosition().x() << "\" y=\"" << n->getPosition().y() << "\"";
            device.setPrecision();
        } else {
            device << "x=\"" << n->getPosition().x() << "\" y=\"" << n->getPosition().y() << "\"";
        }
        if (n->isTLControlled()) {
            device << " type=\"traffic_light\" tl=\"";
            const std::set<NBTrafficLightDefinition*> &tlss = n->getControllingTLS();
            for (std::set<NBTrafficLightDefinition*>::const_iterator t=tlss.begin(); t!=tlss.end(); ++t) {
                if (t!=tlss.begin()) {
                    device << ",";
                }
                device << (*t)->getID();
            }
            device << "\"";
        }
        device << "/>\n";
    }
    device.close();
    return true;
}

void NBNodeCont::setAsTLControlled	(	NBNode *	node,
		NBTrafficLightLogicCont &	tlc,
		std::string	id = ""
	)

Sets the given node as being controlled by a tls.

Parameters:

[in]	node	The node that shall be controlled by a tls
[in]	tlc	The traffic lights control into which the new traffic light definition shall be stored
[in]	id	The id of the tls to add

Todo:

Recheck exception handling

Definition at line 373 of file NBNodeCont.cpp.

References NBNode::getID(), NBTrafficLightLogicCont::insert(), and WRITE_WARNING.

Referenced by NBNetBuilder::compute(), and guessTLs().

                                                                                      {
    if (id=="") {
        id = node->getID();
    }
    NBTrafficLightDefinition *tlDef = new NBOwnTLDef(id, node);
    if (!tlc.insert(tlDef)) {
        // actually, nothing should fail here
        WRITE_WARNING("Building a tl-logic for node '" + id + "' twice is not possible.");
        delete tlDef;
        return;
    }
}

bool NBNodeCont::shouldBeTLSControlled

(

const std::set< NBNode * > &

c

)

const throw () [private]

Returns whethe the given node cluster should be controlled by a tls.

Parameters:

[in]

c

The node cluster

Returns:

Whether this node cluster shall be controlled by a tls

Definition at line 204 of file NBNodeCont.cpp.

References SUMOReal.

Referenced by guessTLs().

                                                                        {
    unsigned int noIncoming = 0;
    unsigned int noOutgoing = 0;
    bool tooFast = false;
    SUMOReal f = 0;
    std::set<NBEdge*> seen;
    for (std::set<NBNode*>::const_iterator j=c.begin(); j!=c.end(); ++j) {
        const EdgeVector &edges = (*j)->getEdges();
        for (EdgeVector::const_iterator k=edges.begin(); k!=edges.end(); ++k) {
            if (c.find((*k)->getFromNode())!=c.end()&&c.find((*k)->getToNode())!=c.end()) {
                continue;
            }
            if ((*j)->hasIncoming(*k)) {
                ++noIncoming;
                f += (SUMOReal)(*k)->getNoLanes() * (*k)->getLaneSpeed(0);
            } else {
                ++noOutgoing;
            }
            if ((*k)->getLaneSpeed(0)*3.6>79) {
                tooFast = true;
            }
        }
    }
    return !tooFast && f>=150./3.6 && c.size()!=0;
}

unsigned int NBNodeCont::size

(

)

const throw () [inline]

Returns the number of known nodes.

Returns:

The number of nodes stored in this container

Definition at line 178 of file NBNodeCont.h.

References myNodes.

Referenced by getFreeID(), NILoader::load(), and main().

                                      {
        return (unsigned int) myNodes.size();
    }

void NBNodeCont::sortNodesEdges	(	bool	leftHand,
		const NBTypeCont &	tc
	)

sorts the nodes' edges

Definition at line 415 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::compute().

                                                              {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->sortNodesEdges(leftHand, tc);
    }
}

void NBNodeCont::writeXML

(

OutputDevice &

into

)

writes the nodes into the given ostream

Definition at line 450 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::save().

                                       {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->writeXML(into);
    }
    into << "\n";
}

void NBNodeCont::writeXMLInternalLinks

(

OutputDevice &

into

)

Definition at line 423 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::save().

                                                    {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->writeXMLInternalLinks(into);
    }
    into << "\n";
}

void NBNodeCont::writeXMLInternalNodes

(

OutputDevice &

into

)

Definition at line 441 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::save().

                                                    {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->writeXMLInternalNodes(into);
    }
    into << "\n";
}

void NBNodeCont::writeXMLInternalSuccInfos

(

OutputDevice &

into

)

Definition at line 432 of file NBNodeCont.cpp.

References myNodes.

Referenced by NBNetBuilder::save().

                                                        {
    for (NodeCont::iterator i=myNodes.begin(); i!=myNodes.end(); i++) {
        (*i).second->writeXMLInternalSuccInfos(into);
    }
    into << "\n";
}

---

Field Documentation

int NBNodeCont::myInternalID [private]

The running internal id.

Definition at line 269 of file NBNodeCont.h.

NodeCont NBNodeCont::myNodes [private]

The map of names to nodes.

Definition at line 275 of file NBNodeCont.h.

Referenced by clear(), computeLanes2Lanes(), computeLogics(), computeNodeShapes(), erase(), generateNodeClusters(), guessRamps(), guessTLs(), insert(), printBuiltNodesStatistics(), recheckEdges(), removeDummyEdges(), removeUnwishedNodes(), reshiftNodePositions(), retrieve(), savePlain(), size(), sortNodesEdges(), writeXML(), writeXMLInternalLinks(), writeXMLInternalNodes(), and writeXMLInternalSuccInfos().

---

The documentation for this class was generated from the following files:

• NBNodeCont.h
• NBNodeCont.cpp