57 #ifdef CHECK_MEMORY_LEAKS 59 #endif // CHECK_MEMORY_LEAKS 62 #define DEBUGCOND true 90 assert((
int)myTransitions.size() > virtEdge);
92 NBEdge* succEdge = myTransitions[virtEdge];
93 std::vector<int> lanes;
97 std::map<NBEdge*, std::vector<int> >::iterator i =
myConnections.find(succEdge);
105 std::vector<int>::iterator j = find(lanes.begin(), lanes.end(), lane);
106 if (j == lanes.end()) {
108 lanes.push_back(lane);
121 if (outgoing.size() == 0) {
125 assert(outgoing.size() > 0);
127 #ifdef DEBUG_CONNECTION_GUESSING 129 std::cout <<
" MainDirections edge=" << parent->
getID() <<
" straightest=" << outgoing[indexOfStraightest]->getID() <<
" dir=" <<
toString(straightestDir) <<
"\n";
141 if (outgoing.back()->getJunctionPriority(to) == 1) {
147 if (outgoing.back()->getPriority() > tmp[0]->getPriority()) {
150 if (outgoing.back()->getNumLanes() > tmp[0]->getNumLanes()) {
159 NBEdge* edge = *(tmp.begin());
172 return myDirs.empty();
178 return find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
198 std::string type,
SUMOReal speed,
int nolanes,
200 const std::string& streetName,
216 init(nolanes,
false,
id);
221 std::string type,
SUMOReal speed,
int nolanes,
224 const std::string& streetName,
225 const std::string& origID,
241 init(nolanes, tryIgnoreNodePositions, origID);
271 if (to == tpl->
myTo) {
280 SUMOReal speed,
int nolanes,
int priority,
282 const std::string& streetName,
284 bool tryIgnoreNodePositions) {
306 const std::vector<Lane> oldLanes =
myLanes;
307 init(nolanes, tryIgnoreNodePositions, oldLanes.empty() ?
"" : oldLanes[0].origID);
308 for (
int i = 0; i < (int)nolanes; ++i) {
310 myLanes[i] = oldLanes[
MIN2(i, (
int)oldLanes.size() - 1)];
329 if (from == 0 || to == 0) {
330 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
347 NBEdge::init(
int noLanes,
bool tryIgnoreNodePositions,
const std::string& origID) {
352 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
358 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
373 WRITE_ERROR(
"Edge's '" +
myID +
"' from- and to-node are at the same position.");
381 assert(
myGeom.size() >= 2);
382 if ((
int)
myLanes.size() > noLanes) {
385 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
386 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
387 (*i)->removeFromConnections(
this, -1, lane);
392 for (
int i = 0; i < noLanes; i++) {
407 for (
int i = 0; i < (int)
myLanes.size(); i++) {
408 myLanes[i].shape.add(xoff, yoff, 0);
417 for (
int i = 0; i < (int)
myLanes.size(); i++) {
421 (*i).shape.mirrorX();
422 (*i).viaShape.mirrorX();
466 if (shape.size() >= 2) {
477 assert(shape.size() >= 2);
478 assert(shape.
length() > 0);
494 for (
int i = 0; i < (int)
myLanes.size(); i++) {
499 for (
int i = 0; i < (int)
myLanes.size(); i++) {
500 assert(
myLanes[i].shape.length() > 0);
501 avgLength +=
myLanes[i].shape.length();
517 assert(pbv.size() > 0);
525 ns[0].set(ns[0].x(), ns[0].y(), startNode->
getPosition().
z());
526 assert(ns.size() >= 2);
531 assert(pbv.size() > 0);
585 NBEdge* currentEdge =
this;
586 for (
int i = 1; i < (int)
myGeom.size() - 1; i++) {
588 if (i != (
int)
myGeom.size() - 2) {
589 std::string nodename =
myID +
"_in_between#" +
toString(i);
591 throw ProcessError(
"Error on adding in-between node '" + nodename +
"'.");
599 currentEdge->
myTo = newTo;
602 std::string edgename =
myID +
"[" +
toString(i - 1) +
"]";
606 if (!ec.
insert(currentEdge,
true)) {
607 throw ProcessError(
"Error on adding splitted edge '" + edgename +
"'.");
632 std::vector<SUMOReal> angles;
634 for (
int i = 0; i < (int)
myGeom.size() - 1; ++i) {
639 for (
int i = 0; i < (int)angles.size() - 1; ++i) {
642 if (maxAngle > 0 && relAngle > maxAngle) {
648 if (i == 0 || i == (
int)angles.size() - 2) {
649 const bool start = i == 0;
653 if (minRadius > 0 && r < minRadius) {
656 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
662 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
699 bool mayUseSameDestination,
700 bool mayDefinitelyPass,
715 return setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass, keepClear, contPos);
723 bool invalidatePrevious,
724 bool mayDefinitelyPass) {
725 if (invalidatePrevious) {
729 for (
int i = 0; i < no && ok; i++) {
739 bool mayUseSameDestination,
740 bool mayDefinitelyPass,
767 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
774 if (mayDefinitelyPass) {
797 std::vector<NBEdge::Connection>
799 std::vector<NBEdge::Connection> ret;
801 if ((*i).fromLane == lane) {
813 (*i).fromLane == fromLane
815 && (*i).toLane == toLane) {
820 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
851 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
852 outgoing.push_back((*i).toEdge);
857 if (it->fromLane < 0 && it->toLane < 0) {
859 EdgeVector::iterator forbidden = find(outgoing.begin(), outgoing.end(), it->toEdge);
860 if (forbidden != outgoing.end()) {
861 outgoing.erase(forbidden);
866 int size = (int) outgoing.size();
868 edges->reserve(size);
869 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
872 edges->push_back(outedge);
884 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
885 ret.push_back((*i).toEdge);
894 std::vector<int> ret;
897 if ((*i).toEdge == currentOutgoing) {
898 ret.push_back((*i).fromLane);
921 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
926 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
940 && (fromLane < 0 || c.
fromLane == fromLane)
941 && (toLane < 0 || c.
toLane == toLane)) {
965 if (reallowSetting) {
977 if ((*i).toEdge == which) {
979 (*i).toLane += laneOff;
990 std::map<int, int> laneMap;
994 bool wasConnected =
false;
996 if ((*i).toEdge != which) {
1000 if ((*i).fromLane != -1) {
1001 int fromLane = (*i).fromLane;
1002 laneMap[(*i).toLane] = fromLane;
1003 if (minLane == -1 || minLane > fromLane) {
1006 if (maxLane == -1 || maxLane < fromLane) {
1011 if (!wasConnected) {
1017 std::vector<NBEdge::Connection> conns = origConns;
1018 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
1019 if ((*i).toEdge == which) {
1022 int fromLane = (*i).fromLane;
1024 if (laneMap.find(fromLane) == laneMap.end()) {
1025 if (fromLane >= 0 && fromLane <= minLane) {
1028 if (fromLane >= 0 && fromLane >= maxLane) {
1032 toUse = laneMap[fromLane];
1066 std::vector<Connection>::iterator i =
myConnections.begin() + index;
1089 std::string innerID =
":" + n.
getID();
1091 int edgeIndex = linkIndex;
1092 int internalLaneIndex = 0;
1099 if (con.
toEdge != toEdge) {
1102 edgeIndex = linkIndex;
1103 toEdge = (*i).toEdge;
1104 internalLaneIndex = 0;
1107 std::vector<int> foeInternalLinks;
1117 std::pair<SUMOReal, std::vector<int> > crossingPositions(-1, std::vector<int>());
1118 std::set<std::string> tmpFoeIncomingLanes;
1127 for (EdgeVector::const_iterator i2 = incoming.begin(); i2 != incoming.end(); ++i2) {
1128 const std::vector<Connection>& elv = (*i2)->getConnections();
1129 for (std::vector<NBEdge::Connection>::const_iterator k2 = elv.begin(); k2 != elv.end(); k2++) {
1130 if ((*k2).toEdge == 0) {
1133 bool needsCont = n.
needsCont(
this, *i2, con, *k2);
1136 crossingPositions.second.push_back(index);
1140 SUMOReal width2 = (*k2).toEdge->getLaneWidth((*k2).toLane);
1141 if ((*k2).toEdge->getPermissions((*k2).toLane) !=
SVC_BICYCLE) {
1147 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1148 crossingPositions.first = minDV;
1153 this, con.
toEdge, con.
fromLane, (*i2), (*k2).toEdge, (*k2).fromLane);
1155 if (n.
foes(
this, con.
toEdge, *i2, (*k2).toEdge) || rightTurnConflict) {
1156 foeInternalLinks.push_back(index);
1160 if ((n.
forbids(*i2, (*k2).toEdge,
this, con.
toEdge, signalised) || rightTurnConflict) && (needsCont || dir ==
LINKDIR_TURN)) {
1161 tmpFoeIncomingLanes.insert((*i2)->getID() +
"_" +
toString((*k2).fromLane));
1167 const std::vector<NBNode::Crossing>& crossings = n.
getCrossings();
1168 for (std::vector<NBNode::Crossing>::const_iterator it_c = crossings.begin(); it_c != crossings.end(); ++it_c) {
1170 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
1171 const NBEdge* edge = *it_e;
1173 if (
this == edge || con.
toEdge == edge) {
1174 foeInternalLinks.push_back(index);
1175 if (con.
toEdge == edge &&
1183 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1184 crossingPositions.first = minDV;
1207 crossingPositions.first = -1;
1210 crossingPositions.first = con.
contPos;
1228 assert(shape.size() >= 2);
1230 if (crossingPositions.first >= 0) {
1231 std::pair<PositionVector, PositionVector>
split = shape.
splitAt(crossingPositions.first);
1232 con.
id = innerID +
"_" +
toString(edgeIndex);
1233 con.
shape = split.first;
1236 con.
viaID = innerID +
"_" +
toString(splitIndex + noInternalNoSplits);
1242 con.
id = innerID +
"_" +
toString(edgeIndex);
1247 ++internalLaneIndex;
1267 if (tmp.size() > 0) {
1268 intersect =
MIN2(intersect, tmp[0]);
1271 if (tmp.size() > 0) {
1272 intersect =
MIN2(intersect, tmp[0]);
1305 assert(atNode ==
myTo);
1320 assert(atNode ==
myTo);
1328 if (!onlyPossible) {
1348 std::vector<SUMOReal> offsets(
myLanes.size(), 0.);
1350 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
1352 offsets[i] = offset;
1359 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1365 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1366 offsets[i] += offset;
1370 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1374 WRITE_WARNING(
"In edge '" +
getID() +
"': lane shape could not be determined (" + e.what() +
").");
1445 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1446 if ((*i).permissions !=
SVCAll) {
1456 std::vector<Lane>::const_iterator i =
myLanes.begin();
1459 for (; i !=
myLanes.end(); ++i) {
1460 if (i->permissions != firstLanePermissions) {
1470 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1481 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1482 if (i->width !=
myLanes.begin()->width) {
1492 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1493 if (i->endOffset !=
myLanes.begin()->endOffset) {
1517 for (EdgeVector::const_iterator i = o.begin(); i != o.end(); ++i) {
1555 std::vector<int> connNumbersPerLane(
myLanes.size(), 0);
1557 if ((*i).toEdge == 0 || (*i).fromLane < 0 || (*i).toLane < 0) {
1560 if ((*i).fromLane >= 0) {
1561 ++connNumbersPerLane[(*i).fromLane];
1572 for (
int i = 0; i < (int)
myLanes.size(); i++) {
1588 }
else if (common == 0) {
1591 const int origToLane = c.
toLane;
1593 int toLane = origToLane;
1606 int toLane = origToLane;
1641 if (outgoing->size() == 0) {
1653 #ifdef DEBUG_CONNECTION_GUESSING 1655 std::cout <<
" divideOnEdges " <<
getID() <<
" outgoing=" <<
toString(*outgoing) <<
" prios=" <<
toString(*priorities) <<
"\n";
1660 std::vector<int> availableLanes;
1661 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1663 availableLanes.push_back(i);
1666 if (availableLanes.size() > 0) {
1670 availableLanes.clear();
1671 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1676 availableLanes.push_back(i);
1678 if (availableLanes.size() > 0) {
1682 availableLanes.clear();
1683 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1688 availableLanes.push_back(i);
1690 if (availableLanes.size() > 0) {
1694 availableLanes.clear();
1695 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1700 availableLanes.push_back(i);
1702 if (availableLanes.size() > 0) {
1707 if ((*i).fromLane == -1) {
1726 const int numOutgoing = (int) outgoing->size();
1727 std::vector<SUMOReal> resultingLanes;
1728 resultingLanes.reserve(numOutgoing);
1731 for (
int i = 0; i < numOutgoing; i++) {
1738 if (res > availableLanes.size()) {
1739 res = (
SUMOReal) availableLanes.size();
1742 resultingLanes.push_back(res);
1743 sumResulting += res;
1744 if (minResulting > res && res > 0) {
1756 transition.reserve(numOutgoing);
1757 for (
int i = 0; i < numOutgoing; i++) {
1760 assert(i < (
int)resultingLanes.size());
1761 const int tmpNum = (int)std::ceil(resultingLanes[i] / minResulting);
1762 numVirtual += tmpNum;
1763 for (
SUMOReal j = 0; j < tmpNum; j++) {
1764 transition.push_back((*outgoing)[i]);
1767 #ifdef DEBUG_CONNECTION_GUESSING 1769 std::cout <<
" prioSum=" << prioSum <<
" sumResulting=" << sumResulting <<
" minResulting=" << minResulting <<
" numVirtual=" << numVirtual <<
" availLanes=" <<
toString(availableLanes) <<
" resLanes=" <<
toString(resultingLanes) <<
" transition=" <<
toString(transition) <<
"\n";
1778 for (EdgeVector::const_iterator i = outgoing->begin(); i != outgoing->end(); ++i) {
1780 assert(l2eConns.find(target) != l2eConns.end());
1781 const std::vector<int> lanes = (l2eConns.find(target))->second;
1782 for (std::vector<int>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
1783 const int fromIndex = availableLanes[*j];
1802 if (numConsToTarget >= targetLanes) {
1807 for (
int ii = 0; ii < (int)
myLanes.size(); ++ii) {
1817 #ifdef DEBUG_CONNECTION_GUESSING 1819 std::cout <<
" request connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
1832 const int numOutgoing = (int) outgoing->size();
1834 NBEdge* rightOfTarget = 0;
1835 NBEdge* leftOfTarget = 0;
1837 for (
int i = 0; i < numOutgoing; i++) {
1838 if (maxPrio < (*priorities)[i]) {
1841 maxPrio = (*priorities)[i];
1842 target = (*outgoing)[i];
1843 rightOfTarget = i == 0 ? outgoing->back() : (*outgoing)[i - 1];
1844 leftOfTarget = i + 1 == numOutgoing ? outgoing->front() : (*outgoing)[i + 1];
1856 const int numDesiredConsToTarget =
MIN2(targetLanes, (
int)availableLanes.size());
1857 #ifdef DEBUG_CONNECTION_GUESSING 1859 std::cout <<
" checking extra lanes for target=" << target->
getID() <<
" cons=" << numConsToTarget <<
" desired=" << numDesiredConsToTarget <<
"\n";
1862 std::vector<int>::const_iterator it_avail = availableLanes.begin();
1863 while (numConsToTarget < numDesiredConsToTarget && it_avail != availableLanes.end()) {
1864 const int fromIndex = *it_avail;
1873 #ifdef DEBUG_CONNECTION_GUESSING 1875 std::cout <<
" candidate from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
1884 #ifdef DEBUG_CONNECTION_GUESSING 1886 std::cout <<
" request additional connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
1892 #ifdef DEBUG_CONNECTION_GUESSING 1897 <<
" rightOfTarget=" << rightOfTarget->
getID()
1898 <<
" leftOfTarget=" << leftOfTarget->
getID()
1912 std::vector<int>* priorities =
new std::vector<int>();
1913 if (outgoing->size() == 0) {
1916 priorities->reserve(outgoing->size());
1917 EdgeVector::const_iterator i;
1918 for (i = outgoing->begin(); i != outgoing->end(); i++) {
1921 assert((prio + 1) * 2 > 0);
1922 prio = (prio + 1) * 2;
1923 priorities->push_back(prio);
1930 i = find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
1931 int dist = (int) distance(outgoing->begin(), i);
1933 #ifdef DEBUG_CONNECTION_GUESSING 1935 <<
" outgoing=" <<
toString(*outgoing)
1936 <<
" priorities1=" <<
toString(*priorities)
1943 assert(priorities->size() > 0);
1944 (*priorities)[0] /= 2;
1945 #ifdef DEBUG_CONNECTION_GUESSING 1947 std::cout <<
" priorities2=" <<
toString(*priorities) <<
"\n";
1954 if (mainDirections.
empty()) {
1955 assert(dist < (
int)priorities->size());
1956 (*priorities)[dist] *= 2;
1957 #ifdef DEBUG_CONNECTION_GUESSING 1959 std::cout <<
" priorities3=" <<
toString(*priorities) <<
"\n";
1964 (*priorities)[dist] += 1;
1968 (*priorities)[0] /= 4;
1969 (*priorities)[(int)priorities->size() - 1] /= 2;
1970 #ifdef DEBUG_CONNECTION_GUESSING 1972 std::cout <<
" priorities6=" <<
toString(*priorities) <<
"\n";
1979 (*priorities)[dist] *= 2;
1980 #ifdef DEBUG_CONNECTION_GUESSING 1982 std::cout <<
" priorities4=" <<
toString(*priorities) <<
"\n";
1986 (*priorities)[dist] *= 3;
1987 #ifdef DEBUG_CONNECTION_GUESSING 1989 std::cout <<
" priorities5=" <<
toString(*priorities) <<
"\n";
2002 for (std::vector<int>::const_iterator i = priorities.begin(); i != priorities.end(); i++) {
2020 const int fromLane = (int)
myLanes.size() - 1;
2022 if (checkPermissions) {
2053 if (pos < tolerance) {
2067 for (
int i = 0; i < lanes; i++) {
2069 for (std::vector<NBEdge::Connection>::iterator j = elv.begin(); j != elv.end(); j++) {
2071 assert(el.
tlID ==
"");
2117 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
2119 if (fromLane >= 0 && toLane >= 0) {
2121 std::vector<Connection>::iterator i =
2129 connection.
tlID = tlID;
2137 bool hadError =
false;
2139 if ((*i).toEdge != toEdge) {
2142 if (fromLane >= 0 && fromLane != (*i).fromLane) {
2145 if (toLane >= 0 && toLane != (*i).toLane) {
2148 if ((*i).tlID ==
"") {
2150 (*i).tlLinkNo = tlIndex;
2153 if ((*i).tlID != tlID && (*i).tlLinkNo == tlIndex) {
2154 WRITE_WARNING(
"The lane '" + toString<int>((*i).fromLane) +
"' on edge '" +
getID() +
"' already had a traffic light signal.");
2159 if (hadError && no == 0) {
2160 WRITE_WARNING(
"Could not set any signal of the tlLogic '" + tlID +
"' (unknown group)");
2194 ret =
myLanes.back().shape.reverse();
2212 ret =
myLanes[0].shape.reverse();
2243 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2245 myLanes[i].permissions != possContinuation->
myLanes[i].permissions ||
2271 if (find(conn.begin(), conn.end(), possContinuation) == conn.end()) {
2287 if (conns.size() !=
myLanes.size() - offset) {
2303 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2330 if ((*i).toEdge == e && (*i).tlID !=
"") {
2362 assert(distances.size() > 0);
2369 assert(index <= (
int)
myLanes.size());
2373 int templateIndex = index > 0 ? index - 1 : index + 1;
2384 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2385 (*i)->invalidateConnections(
true);
2393 int newLaneNo = (int)
myLanes.size() + by;
2394 while ((
int)
myLanes.size() < newLaneNo) {
2404 assert(index < (
int)
myLanes.size());
2409 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2410 (*i)->invalidateConnections(
true);
2419 int newLaneNo = (int)
myLanes.size() - by;
2420 assert(newLaneNo > 0);
2421 while ((
int)
myLanes.size() > newLaneNo) {
2439 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2443 assert(lane < (
int)
myLanes.size());
2444 myLanes[lane].permissions |= vclass;
2452 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2456 assert(lane < (
int)
myLanes.size());
2457 myLanes[lane].permissions &= ~vclass;
2465 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2469 assert(lane < (
int)
myLanes.size());
2470 myLanes[lane].preferred |= vclass;
2480 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2486 assert(lane < (
int)
myLanes.size());
2502 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2519 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2525 assert(lane < (
int)
myLanes.size());
2526 myLanes[lane].endOffset = offset;
2535 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2541 assert(lane < (
int)
myLanes.size());
2549 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2554 assert(lane < (
int)
myLanes.size());
2555 myLanes[lane].permissions = permissions;
2563 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2568 assert(lane < (
int)
myLanes.size());
2569 myLanes[lane].preferred = permissions;
2578 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2583 assert(lane < (
int)
myLanes.size());
2584 return myLanes[lane].permissions;
2597 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2598 (*i).permissions =
SVCAll;
2621 for (
int i = start; i != end; i += direction) {
2633 std::set<SVCPermissions>
2635 std::set<SVCPermissions> result;
2639 for (
int i = iStart; i < iEnd; ++i) {
2656 std::cout <<
getID() <<
" angle=" <<
getAngleAtNode(node) <<
" convAngle=" << angle <<
"\n";
2686 if (
myLanes[0].permissions == vclass) {
2698 myLanes[0].permissions = vclass;
2709 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
2710 (*it)->shiftToLanesToEdge(
this, 1);
2722 if ((*it).toEdge == to && (*it).toLane >= 0) {
2723 (*it).toLane += laneOff;
2732 const int i = (node ==
myTo ? -1 : 0);
2733 const int i2 = (node ==
myTo ? 0 : -1);
2739 if (dist < neededOffset && dist2 < neededOffset2) {
2747 WRITE_WARNING(
"Could not avoid overlapping shape at node '" + node->
getID() +
"' for edge '" +
getID() +
"'");
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
bool gDebugFlag1
global utility flags for debugging
void moveConnectionToRight(int lane)
void invalidateConnections(bool reallowSetting=false)
int tlLinkNo
The index of this connection within the controlling traffic light.
void init(int noLanes, bool tryIgnoreNodePositions, const std::string &origID)
Initialization routines common to all constructors.
The link is a partial left direction.
std::vector< Lane > myLanes
Lane information.
bool includes(Direction d) const
PositionVector cutAtIntersection(const PositionVector &old) const
cut shape at the intersection shapes
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges.
const std::string & getTypeID() const
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
void divideOnEdges(const EdgeVector *outgoing)
A structure which describes a connection between edges or lanes.
int toLane
The lane the connections yields in.
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
SUMOReal width
This lane's width.
std::string foeIncomingLanes
const SUMOReal SUMO_const_laneWidth
SUMOReal myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
std::vector< TLSDisabledConnection > myTLSDisabledConnections
static const SUMOReal UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
PositionVector getSubpart2D(SUMOReal beginOffset, SUMOReal endOffset) const
get subpart of a position vector in two dimensions (Z is ignored)
void sortOutgoingConnectionsByAngle()
sorts the outgoing connections by their angle relative to their junction
NBEdge * toEdge
The edge the connections yields in.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset)
patches loaded signal plans by modifying lane indices
void mirrorX()
mirror coordinates along the x-axis
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
The relationships between edges are computed/loaded.
std::vector< Connection > getConnectionsFromLane(int lane) const
Returns connections from a given lane.
bool setConnection(int lane, NBEdge *destEdge, int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS)
Adds a connection to a certain lane of a certain edge.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
void setLaneWidth(int lane, SUMOReal width)
set lane specific width (negative lane implies set for all lanes)
bool isTLControlled() const
Returns whether this node is controlled by any tls.
void setSpeed(int lane, SUMOReal speed)
set lane specific speed (negative lane implies set for all lanes)
Some static methods for string processing.
void moveConnectionToLeft(int lane)
const SUMOReal SUMO_const_laneWidthAndOffset
void addSidewalk(SUMOReal width)
add a pedestrian sidewalk of the given width and shift existing connctions
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
The representation of a single edge during network building.
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
void clearControllingTLInformation()
clears tlID for all connections
Lane2LaneInfoType
Modes of setting connections between lanes.
std::vector< int > * prepareEdgePriorities(const EdgeVector *outgoing)
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
bool hasDefaultGeometryEndpoints() const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
The link is a 180 degree turn.
Position getCentroid() const
Returns the centroid (closes the polygon if unclosed)
int getFromLane() const
returns the from-lane
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node ...
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
const std::vector< Crossing > & getCrossings() const
return this junctions pedestrian crossings
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
std::vector< Direction > myDirs
void markAsInLane2LaneState()
SUMOReal getTotalWidth() const
Returns the combined width of all lanes of this edge.
Lanes to lanes - relationships are computed; should be recheked.
SUMOReal getLaneWidth() const
Returns the default width of lanes of this edge.
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
PositionVector shape
The lane's shape.
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
PositionVector getSubpartByIndex(int beginIndex, int count) const
get subpart of a position vector using index and a cout
SUMOReal getShapeStartAngle() const
Returns the angle at the start of the edge (only using edge shape)
PositionVector myGeom
The geometry for the edge.
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
void remapConnections(const EdgeVector &incoming)
Remaps the connection in a way that allows the removal of it.
SUMOReal distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
static const SUMOReal UNSPECIFIED_CONTPOS
unspecified internal junction position
const SUMOReal SUMO_const_laneOffset
bool around(const Position &p, SUMOReal offset=0) const
Returns the information whether the position vector describes a polygon lying around the given point...
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
const SVCPermissions SVCAll
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
SUMOReal beginEndAngle() const
returns the angle in radians of the line connecting the first and the last position ...
static SUMOReal angleDiff(const SUMOReal angle1, const SUMOReal angle2)
Returns the difference of the second angle to the first angle in radiants.
SUMOReal x() const
Returns the x-position.
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
Position positionAtOffset2D(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
static SUMOReal firstIntersection(const PositionVector &v1, const PositionVector &v2, SUMOReal width2)
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS)
Adds a connection between the specified this edge's lane and an approached one.
SUMOReal getLaneSpeed(int lane) const
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
The connection was computed and validated.
SUMOReal distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector) ...
static OptionsCont & getOptions()
Retrieves the options.
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, int nolanes, int priority, PositionVector geom, SUMOReal width, SUMOReal offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode) const
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane, bool lefthand=false)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
PositionVector reverse() const
reverse position vector
The edge has been loaded, nothing is computed yet.
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
int myToJunctionPriority
The priority normalised for the node the edge is incoming in.
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
The link is a straight direction.
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges.
bool hasPermissions() const
whether at least one lane has restrictions
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
An (internal) definition of a single lane of an edge.
const std::string & getID() const
Returns the id.
SUMOReal length2D() const
Returns the length.
SUMOReal mySpeed
The maximal speed.
std::vector< SUMOReal > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
void addLane(int index, bool recompute=true)
bool needsCont(const NBEdge *fromE, const NBEdge *otherFromE, const NBEdge::Connection &c, const NBEdge::Connection &otherC) const
whether an internal junction should be built at from and respect other
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
bool isConnectedTo(NBEdge *e)
Returns the information whethe a connection to the given edge has been added (or computed) ...
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
void push_front_noDoublePos(const Position &p)
insert in front a non double position
void reshiftPosition(SUMOReal xoff, SUMOReal yoff)
Applies an offset to the edge.
const Position & getPosition() const
Returns the position of this node.
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
Connection getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection This method goes through "myConnections" and returns the specified o...
int operator()(const Connection &c1, const Connection &c2) const
comparing operation
bool hasConnectionTo(NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
int getPriority() const
Returns the priority of the edge.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
void checkGeometry(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix)
Check the angles of successive geometry segments.
static SUMOReal legacyDegree(const SUMOReal angle, const bool positive=false)
static const int FORWARD
edge directions (for pedestrian related stuff)
NBEdge(const std::string &id, NBNode *from, NBNode *to, std::string type, SUMOReal speed, int nolanes, int priority, SUMOReal width, SUMOReal offset, const std::string &streetName="", LaneSpreadFunction spread=LANESPREAD_RIGHT)
Constructor.
std::string tlID
The id of the traffic light that controls this connection.
std::string getInternalLaneID() const
int fromLane
The lane the connections starts at.
A point in 2D or 3D with translation and scaling methods.
void deleteLane(int index, bool recompute=true)
void add(SUMOReal xoff, SUMOReal yoff, SUMOReal zoff)
bool addLane2LaneConnections(int fromLane, NBEdge *dest, int toLane, int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false)
Builds no connections starting at the given lanes.
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
bool lanesWereAssigned() const
static int computePrioritySum(const std::vector< int > &priorities)
static bool connections_sorter(const Connection &c1, const Connection &c2)
const std::map< NBEdge *, std::vector< int > > & getBuiltConnections() const
SUMOReal z() const
Returns the z-position.
SumoXMLNodeType getType() const
Returns the type of this node.
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
PositionVector getCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going clock-wise around the given node
bool hasLoadedLength() const
Returns whether a length was set explicitly.
int getNumLanes() const
Returns the number of lanes.
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
SUMOReal contPos
custom position for internal junction on this connection
SUMOReal myLaneWidth
This width of this edge's lanes.
int myPriority
The priority of the edge.
int getFirstNonPedestrianLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN and 0
Storage for edges, including some functionality operating on multiple edges.
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
The link is a (hard) right direction.
EdgeBuildingStep myStep
The building step.
bool canMoveConnection(const Connection &con, int newFromLane) const
whether the connection can originate on newFromLane
std::string getLaneIDInsecure(int lane) const
void buildInnerEdges(const NBNode &n, int noInternalNoSplits, int &linkIndex, int &splitIndex)
SUMOReal getAngleAtNodeToCenter(const NBNode *const node) const
Returns the angle of from the node shape center to where the edge meets the node shape.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
std::vector< Connection > myConnections
List of connections to following edges.
void setLoadedLength(SUMOReal val)
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
void execute(const int lane, const int virtEdge)
executes a bresenham - step
The connection was given by the user.
const PositionVector & getShape() const
retrieve the junction shape
SUMOReal getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false)
Removes the specified connection(s)
The link is a partial right direction.
SUMOReal getEndOffset() const
Returns the offset to the destination node.
vehicle is a passenger car (a "normal" car)
bool myAmInnerEdge
Information whether this is a junction-inner edge.
bool isLeftMover(const NBEdge *const from, const NBEdge *const to) const
Computes whether the given connection is a left mover across the junction.
Base class for objects which have an id.
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
SUMOReal myLoadedLength
An optional length to use (-1 if not valid)
std::pair< PositionVector, PositionVector > splitAt(SUMOReal where) const
Returns the two lists made when this list vector is splitted at the given point.
static std::string convertUmlaute(std::string str)
Converts german "Umlaute" to their latin-version.
int internalLaneIndex
The lane index of this internal lane within the internal edge.
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
SUMOReal getCrossingAngle(NBNode *node)
return the angle for computing pedestrian crossings at the given node
SUMOReal length() const
Returns the length.
void addRestrictedLane(SUMOReal width, SUMOVehicleClass vclass)
add a lane of the given width, restricted to the given class and shift existing connctions ...
void setTurningDestination(NBEdge *e, bool onlyPossible=false)
Sets the turing destination at the given edge.
static const int BACKWARD
void addBikeLane(SUMOReal width)
add a bicycle lane of the given width and shift existing connctions
std::string myID
The name of the object.
NBNode * getToNode() const
Returns the destination node of the edge.
PositionVector computeInternalLaneShape(NBEdge *fromE, const NBEdge::Connection &con, int numPoints) const
Compute the shape for an internal lane.
std::vector< int > getConnectionLanes(NBEdge *currentOutgoing) const
Returns the list of lanes that may be used to reach the given edge.
void removeDoublePoints(SUMOReal minDist=POSITION_EPS, bool assertLength=false)
Removes positions if too near.
void computeEdgeShape()
Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the f...
void addStraightConnections(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > *priorities)
add some straight connections
void disableConnection4TLS(int fromLane, NBEdge *toEdge, int toLane)
SUMOReal angleAt2D(int pos) const
get angle in certain position of position vector
SUMOReal getMaxLaneOffset()
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
std::vector< NBEdge * > EdgeVector
SUMOReal myLength
The length of the edge.
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
The edge has been loaded and connections shall not be added.
int getToLane() const
returns the to-lane
SUMOReal y() const
Returns the y-position.
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
void reduceGeometry(const SUMOReal minDist)
Removes points with a distance lesser than the given.
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
const EdgeVector * getConnectedSorted()
Returns the list of outgoing edges without the turnaround sorted in clockwise direction.
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
SUMOReal mySignalOffset
the offset of a traffic light signal from the end of this edge (-1 for None)
std::string myType
The type of the edge.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
void append(NBEdge *continuation)
NBEdge * getTo() const
returns the to-edge (end of the connection)
NBNode * tryGetNodeAtPosition(SUMOReal pos, SUMOReal tolerance=5.0) const
Returns the node at the given edges length (using an epsilon) When no node is existing at the given p...
The connection was computed.
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
SUMOReal myStartAngle
The angles of the edge.
EdgeVector edges
The edges being crossed.
Represents a single node (junction) during network building.
PositionVector computeLaneShape(int lane, SUMOReal offset) const
Computes the shape for the given lane.
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to, int indexOfStraightest)
constructor
void dismissVehicleClassInformation()
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=OUTPUT_ACCURACY)
A definition of a pedestrian crossing.
void move2side(SUMOReal amount)
move position vector to side using certain ammount
void replaceInConnections(NBEdge *which, NBEdge *by, int laneOff)
bool hasLaneSpecificWidth() const
whether lanes differ in width
void setEndOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
void appendTurnaround(bool noTLSControlled, bool checkPermissions)
Add a connection to the previously computed turnaround, if wished.
static void compute(BresenhamCallBack *callBack, const int val1, const int val2)
Direction
enum of possible directions
bool isNearEnough2BeJoined2(NBEdge *e, SUMOReal threshold) const
void preferVehicleClass(int lane, SUMOVehicleClass vclass)
void push_back_noDoublePos(const Position &p)
insert in back a non double position
std::string getLaneID(int lane) const
void allowVehicleClass(int lane, SUMOVehicleClass vclass)
set allowed class for the given lane or for all lanes if -1 is given
void addGeometryPoint(int index, const Position &p)
Adds a further geometry point.
void shiftToLanesToEdge(NBEdge *to, int laneOff)
modifify the toLane for all connections to the given edge
SUMOReal getShapeEndAngle() const
Returns the angle at the end of the edge (only using edge shape) The angle is computed in computeAngl...
void computeAngle()
computes the angle of this edge and stores it in myAngle
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Container for nodes during the netbuilding process.
SUMOReal getFinalLength() const
length that will be assigned to the lanes in the final network
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
static T maxValue(const std::vector< T > &v)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
#define WRITE_MESSAGE(msg)
void divideSelectedLanesOnEdges(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > *priorities)
std::vector< SUMOReal > intersectsAtLengths2D(const PositionVector &other) const
For all intersections between this vector and other, return the 2D-length of the subvector from this ...
std::set< SVCPermissions > getPermissionVariants(int iStart, int iEnd) const
return all permission variants within the specified lane range [iStart, iEnd[
Lanes to edges - relationships are computed/loaded.
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
const std::string & getStreetName() const
Returns the street name of this edge.
NBNode * myFrom
The source and the destination node.
bool expandableBy(NBEdge *possContinuation) const
NBEdge * getTurnDestination(bool possibleDestination=false) const
std::vector< int > foeInternalLinks
PositionVector getSubpart(SUMOReal beginOffset, SUMOReal endOffset) const
get subpart of a position vector
~MainDirections()
destructor
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
void shiftPositionAtNode(NBNode *node, NBEdge *opposite)
shift geometry at the given node to avoid overlap
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
SUMOReal angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position ...
void append(const PositionVector &v, SUMOReal sameThreshold=2.0)
void extrapolate(const SUMOReal val, const bool onlyFirst=false)
extrapolate position vector
void copyConnectionsFrom(NBEdge *src)
static const SUMOReal ANGLE_LOOKAHEAD
the distance at which to take the default angle
SUMOReal getLength() const
Returns the computed length of the edge.
SUMOReal getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
NBNode * getFromNode() const
Returns the origin node of the edge.
bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc)
Splits this edge at geometry points.