49 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
59 for (std::vector<NBEdge*>::const_iterator k = incoming.begin(); k != incoming.end(); ++k) {
60 (*k)->setTurningDestination(
nullptr);
62 std::vector<Combination> combinations;
63 for (std::vector<NBEdge*>::const_iterator j = outgoing.begin(); j != outgoing.end(); ++j) {
65 for (std::vector<NBEdge*>::const_iterator k = incoming.begin(); k != incoming.end(); ++k) {
69 if (signedAngle > 0 && signedAngle < 177 && e->getGeometry().back().distanceTo2D(outedge->
getGeometry().front()) <
POSITION_EPS) {
74 double angle = fabs(signedAngle);
96 combinations.push_back(c);
101 std::set<NBEdge*> seen;
102 for (std::vector<Combination>::const_iterator j = combinations.begin(); j != combinations.end(); ++j) {
103 if (seen.find((*j).from) != seen.end() || seen.find((*j).to) != seen.end()) {
105 if ((*j).angle > 360 && warn) {
106 WRITE_WARNING(
"Ambiguity in turnarounds computation at junction '" + node->
getID() +
"'.");
112 seen.insert((*j).from);
113 seen.insert((*j).to);
115 bool onlyPossible = (*j).from->getConnections().size() != 0 && !(*j).from->isConnectedTo((*j).to);
117 (*j).from->setTurningDestination((*j).to, onlyPossible);
127 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
128 i->second->sortEdges(useNodeShape);
135 const std::vector<NBEdge*>::iterator& i1,
136 const std::vector<NBEdge*>::iterator& i2) {
154 validateRailCrossings(nc, tlc);
155 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
162 bool waterway =
true;
163 for (EdgeVector::const_iterator i = n->
getEdges().begin(); i != n->
getEdges().end(); ++i) {
187 for (EdgeVector::const_iterator j = i + 1; j != n->
myIncomingEdges.end(); j++) {
194 const double s1 = (*i)->getSpeed() * (double) 3.6;
195 const double s2 = (*j)->getSpeed() * (double) 3.6;
196 const int p1 = (*i)->getPriority();
197 const int p2 = (*j)->getPriority();
198 if (fabs(s1 - s2) > (
double) 9.5 ||
MAX2(s1, s2) >= (
double) 49. || p1 != p2) {
212 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
217 int numNonRailway = 0;
218 int numNonRailwayNonPed = 0;
223 numNonRailwayNonPed++;
234 if (numNonRailway == 0 || numRailway == 0) {
237 }
else if (numNonRailwayNonPed > 2) {
239 WRITE_WARNING(
"Converting invalid rail_crossing to traffic_light at junction '" + n->
getID() +
"'");
259 int numNonRailway = 0;
267 return numRailway > 0 && numNonRailway == 0;
275 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
276 computeEdgePrioritiesSingleNode((*i).second);
296 e->setJunctionPriority(node, e->getPriority());
299 setPriorityJunctionPriorities(*node);
317 NBEdge* best = incoming[0];
318 while (incoming.size() > 0 && samePriority(best, incoming[0])) {
319 bestIncoming.push_back(*incoming.begin());
320 incoming.erase(incoming.begin());
323 assert(outgoing.size() != 0);
327 while (outgoing.size() > 0 && samePriority(best, outgoing[0])) {
328 bestOutgoing.push_back(*outgoing.begin());
329 outgoing.erase(outgoing.begin());
332 const bool mainDirectionExplicit = (
334 && (incoming.size() == 0 || bestIncoming[0]->getPriority() > incoming[0]->getPriority())
336 && (outgoing.size() == 0 || bestOutgoing[0]->getPriority() > outgoing[0]->getPriority())
337 && !bestIncoming[0]->isTurningDirectionAt(bestOutgoing[0]));
341 EdgeVector::iterator i;
342 std::map<NBEdge*, NBEdge*> counterIncomingEdges;
343 std::map<NBEdge*, NBEdge*> counterOutgoingEdges;
346 for (i = bestIncoming.begin(); i != bestIncoming.end(); ++i) {
348 counterIncomingEdges[*i] = *incoming.begin();
350 counterOutgoingEdges[*i] = *outgoing.begin();
355 if (bestIncoming.size() == 1) {
357 NBEdge* best1 = extractAndMarkFirst(n, bestIncoming);
358 if (!mainDirectionExplicit && counterIncomingEdges.find(best1) != counterIncomingEdges.end()) {
362 NBEdge* s = counterIncomingEdges.find(best1)->second;
364 if (minAngleDiff > 180 - 45
365 || (minAngleDiff > 75 && s->
getPriority() == best1->
getPriority() && hasDifferentPriorities(incoming, best1))) {
369 markBestParallel(n, best1,
nullptr);
370 assert(bestOutgoing.size() != 0);
374 NBEdge* bestOut = extractAndMarkFirst(n, bestOutgoing);
375 if (!mainDirectionExplicit && counterOutgoingEdges.find(bestOut) != counterOutgoingEdges.end()) {
376 NBEdge* s = counterOutgoingEdges.find(bestOut)->second;
389 double bestAngle = 0;
390 NBEdge* bestFirst =
nullptr;
391 NBEdge* bestSecond =
nullptr;
392 bool hadBest =
false;
393 for (i = bestIncoming.begin(); i != bestIncoming.end(); ++i) {
394 EdgeVector::iterator j;
400 for (j = i + 1; j != bestIncoming.end(); ++j) {
407 if (!hadBest || angle > bestAngle) {
417 if (bestOutgoing.size() != 0) {
418 extractAndMarkFirst(n, bestOutgoing);
422 if (bestOutgoing.size() != 0) {
423 extractAndMarkFirst(n, bestOutgoing);
426 markBestParallel(n, bestFirst, bestSecond);
433 const double a2 = bestSecond ==
nullptr ? a1 : bestSecond->
getAngleAtNode(&n);
442 && (p1 & perm) == 0 && (p2 & perm) == 0) {
443 e->setJunctionPriority(&n, 1);
478 if (edges.size() < 2) {
481 int prio = edges[0] == excluded ? edges[1]->
getPriority() : edges[0]->getPriority();
482 for (
auto e : edges) {
493 myOrdering = ordering;
496 rotate(myOrdering.begin(), std::find(myOrdering.begin(), myOrdering.end(), ordering.front()), myOrdering.end());
static double getMinAngleDiff(double angle1, double angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
static void validateRailCrossings(NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
Checks rail_crossing for validity.
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
static void markBestParallel(const NBNode &n, NBEdge *bestFirst, NBEdge *bestSecond)
set priority for edges that are parallel to the best edges
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
SumoXMLNodeType myType
The type of the junction.
A container for traffic light definitions and built programs.
int getPriority() const
Returns the priority of the edge.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
The representation of a single edge during network building.
Class to sort edges by their angle in relation to the given edge.
The base class for traffic light logic definitions.
void markBentPriority(bool isBent)
mark whether a priority road turns at this node
const std::string & getID() const
Returns the id.
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node's edges clockwise regarding driving direction.
Stores the information about the angle between an incoming ("from") and an outgoing ("to") edge...
#define WRITE_WARNING(msg)
static OptionsCont & getOptions()
Retrieves the options.
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
The link is a straight direction.
static bool hasDifferentPriorities(const EdgeVector &edges, const NBEdge *excluded)
return whether the priorite attribute can be used to distinguish the edges
EdgeVector myAllEdges
Vector of incoming and outgoing edges.
static void swapWhenReversed(const NBNode *const n, const std::vector< NBEdge *>::iterator &i1, const std::vector< NBEdge *>::iterator &i2)
Assures correct order for same-angle opposite-direction edges.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
int getNumLanes() const
Returns the number of lanes.
classes which drive on tracks
static void computeEdgePriorities(NBNodeCont &nc)
Computes edge priorities within a node.
bool isWaterway(SVCPermissions permissions)
Returns whether an edge with the given permission is a waterway edge.
static bool isRailwayNode(NBNode *n)
whether the given node only has rail edges
T get(const std::string &str) const
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
crossing_by_junction_angle_sorter(const NBNode *node, const EdgeVector &ordering)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
EdgeVector myIncomingEdges
Vector of incoming edges.
static void computeTurnDirectionsForNode(NBNode *node, bool warn)
Computes turnaround destinations for all incoming edges of the given nodes (if any) ...
static bool samePriority(const NBEdge *const e1, const NBEdge *const e2)
Returns whether both edges have the same priority.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
double getSpeed() const
Returns the speed allowed on this edge.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
EdgeVector myOutgoingEdges
Vector of outgoing edges.
static void computeEdgePrioritiesSingleNode(NBNode *node)
Computes edge priorities within a single node.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
SumoXMLNodeType getType() const
Returns the type of this node.
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Represents a single node (junction) during network building.
static void computeTurnDirections(NBNodeCont &nc, bool warn=true)
Computes turnaround destinations for all edges (if exist)
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
static NBEdge * extractAndMarkFirst(NBNode &n, std::vector< NBEdge *> &s, int prio=1)
Sets the priorites in case of a priority junction.
NBEdge * getOppositeIncoming(NBEdge *e) const
returns the opposite incoming edge of certain edge
Sorts "Combination"s by decreasing angle.
static void setPriorityJunctionPriorities(NBNode &n)
Sets the priorites in case of a priority junction.
NBNode * getFromNode() const
Returns the origin node of the edge.
Container for nodes during the netbuilding process.
static void computeNodeTypes(NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
Computes node types.
A traffic light logics which must be computed (only nodes/edges are given)
NBNode * getToNode() const
Returns the destination node of the edge.
bool isSimpleContinuation(bool checkLaneNumbers=true) const
check if node is a simple continuation