60 #define DEBUGCOND (getID() == "disabled") 106 NBEdge::Connection::Connection(
int fromLane_,
NBEdge* toEdge_,
int toLane_,
bool mayDefinitelyPass_,
bool keepClear_,
double contPos_,
double visibility_,
bool haveVia_,
bool uncontrolled_) :
128 connectionsDone(false) {
138 assert((
int)myTransitions.size() > virtEdge);
140 NBEdge* succEdge = myTransitions[virtEdge];
141 std::vector<int> lanes;
145 std::map<NBEdge*, std::vector<int> >::iterator i =
myConnections.find(succEdge);
153 std::vector<int>::iterator j = find(lanes.begin(), lanes.end(), lane);
154 if (j == lanes.end()) {
156 lanes.push_back(lane);
169 if (outgoing.size() == 0) {
173 assert(outgoing.size() > 0);
175 #ifdef DEBUG_CONNECTION_GUESSING 177 std::cout <<
" MainDirections edge=" << parent->
getID() <<
" straightest=" << outgoing[indexOfStraightest]->getID() <<
" dir=" <<
toString(straightestDir) <<
"\n";
189 if (outgoing.back()->getJunctionPriority(to) == 1) {
195 if (outgoing.back()->getPriority() > tmp[0]->getPriority()) {
198 if (outgoing.back()->getNumLanes() > tmp[0]->getNumLanes()) {
207 NBEdge* edge = *(tmp.begin());
220 return myDirs.empty();
226 return find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
246 std::string type,
double speed,
int nolanes,
247 int priority,
double laneWidth,
double offset,
248 const std::string& streetName,
264 init(nolanes,
false,
id);
269 std::string type,
double speed,
int nolanes,
270 int priority,
double laneWidth,
double offset,
272 const std::string& streetName,
273 const std::string& origID,
289 init(nolanes, tryIgnoreNodePositions, origID);
319 if (to == tpl->
myTo) {
328 double speed,
int nolanes,
int priority,
330 const std::string& streetName,
332 bool tryIgnoreNodePositions) {
354 const std::vector<Lane> oldLanes =
myLanes;
355 init(nolanes, tryIgnoreNodePositions, oldLanes.empty() ?
"" : oldLanes[0].origID);
356 for (
int i = 0; i < (int)nolanes; ++i) {
358 myLanes[i] = oldLanes[
MIN2(i, (
int)oldLanes.size() - 1)];
377 if (from == 0 || to == 0) {
378 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
395 NBEdge::init(
int noLanes,
bool tryIgnoreNodePositions,
const std::string& origID) {
400 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
406 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
421 WRITE_ERROR(
"Edge's '" +
myID +
"' from- and to-node are at the same position.");
429 assert(
myGeom.size() >= 2);
430 if ((
int)
myLanes.size() > noLanes) {
432 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
437 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
438 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
439 (*i)->removeFromConnections(
this, -1, lane);
444 for (
int i = 0; i < noLanes; i++) {
459 for (
int i = 0; i < (int)
myLanes.size(); i++) {
460 myLanes[i].shape.add(xoff, yoff, 0);
469 for (
int i = 0; i < (int)
myLanes.size(); i++) {
473 (*i).shape.mirrorX();
474 (*i).viaShape.mirrorX();
506 assert(node ==
myTo);
536 assert(node ==
myTo);
565 if (rectangularCut) {
566 const double extend = 100;
570 border.push_back(p2);
572 if (border.size() == 2) {
573 double edgeWidth = 0;
574 for (
int i = 0; i < (int)
myLanes.size(); i++) {
581 assert(node ==
myTo);
585 #ifdef DEBUG_NODE_BORDER 588 <<
" rect=" << rectangularCut
589 <<
" p=" << p <<
" p2=" << p2
590 <<
" border=" << border
603 assert(node ==
myTo);
613 if (shape.size() < 2) {
615 const double oldLength = old.
length();
624 const double midpoint = old.
length() / 2;
627 assert(shape.size() >= 2);
628 assert(shape.
length() > 0);
636 tmp.push_back(shape[0]);
637 tmp.push_back(shape[-1]);
653 const double midpoint = old.
length() / 2;
656 assert(shape.size() >= 2);
657 assert(shape.
length() > 0);
660 const double midpoint = shape.
length() / 2;
677 for (
int i = 0; i < (int)
myLanes.size(); i++) {
681 double avgLength = 0;
682 for (
int i = 0; i < (int)
myLanes.size(); i++) {
683 assert(
myLanes[i].shape.length() > 0);
684 avgLength +=
myLanes[i].shape.length();
693 if (nodeShape.size() == 0) {
702 assert(pbv.size() > 0);
714 const double dZ = ns.size() >= 2 ? fabs(ns[0].z() - ns[1].z()) : 0;
720 assert(ns.size() >= 2);
725 assert(pbv.size() > 0);
735 const double dZ = result.size() >= 2 ? fabs(result[0].z() - result[1].z()) : 0;
788 NBEdge* currentEdge =
this;
789 for (
int i = 1; i < (int)
myGeom.size() - 1; i++) {
791 if (i != (
int)
myGeom.size() - 2) {
792 std::string nodename =
myID +
"_in_between#" +
toString(i);
794 throw ProcessError(
"Error on adding in-between node '" + nodename +
"'.");
802 currentEdge->
myTo = newTo;
805 std::string edgename =
myID +
"[" +
toString(i - 1) +
"]";
809 if (!ec.
insert(currentEdge,
true)) {
810 throw ProcessError(
"Error on adding splitted edge '" + edgename +
"'.");
835 std::vector<double> angles;
837 for (
int i = 0; i < (int)
myGeom.size() - 1; ++i) {
842 for (
int i = 0; i < (int)angles.size() - 1; ++i) {
845 if (maxAngle > 0 && relAngle > maxAngle) {
851 if (i == 0 || i == (
int)angles.size() - 2) {
852 const bool start = i == 0;
854 const double r = tan(0.5 * (
M_PI - relAngle)) * dist;
856 if (minRadius > 0 && r < minRadius) {
859 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
865 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
902 bool mayUseSameDestination,
903 bool mayDefinitelyPass,
919 return setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass, keepClear, contPos, visibility);
927 bool invalidatePrevious,
928 bool mayDefinitelyPass) {
929 if (invalidatePrevious) {
933 for (
int i = 0; i < no && ok; i++) {
943 bool mayUseSameDestination,
944 bool mayDefinitelyPass,
972 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
979 if (mayDefinitelyPass) {
1009 std::vector<NBEdge::Connection>
1011 std::vector<NBEdge::Connection> ret;
1013 if ((*i).fromLane == lane) {
1025 (*i).fromLane == fromLane
1026 && (*i).toEdge == to
1027 && (*i).toLane == toLane) {
1032 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
1039 (*i).fromLane == fromLane
1040 && (*i).toEdge == to
1041 && (*i).toLane == toLane) {
1046 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
1077 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
1078 outgoing.push_back((*i).toEdge);
1083 if (it->fromLane < 0 && it->toLane < 0) {
1085 EdgeVector::iterator forbidden = find(outgoing.begin(), outgoing.end(), it->toEdge);
1086 if (forbidden != outgoing.end()) {
1087 outgoing.erase(forbidden);
1092 int size = (int) outgoing.size();
1094 edges->reserve(size);
1095 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
1098 edges->push_back(outedge);
1110 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
1111 ret.push_back((*i).toEdge);
1122 for (EdgeVector::const_iterator i = candidates.begin(); i != candidates.end(); i++) {
1123 if ((*i)->isConnectedTo(
this)) {
1133 std::vector<int> ret;
1136 if ((*i).toEdge == currentOutgoing) {
1137 ret.push_back((*i).fromLane);
1160 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
1165 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
1176 const int fromLaneRemoved = adaptToLaneRemoval && fromLane >= 0 ? fromLane : -1;
1177 const int toLaneRemoved = adaptToLaneRemoval && toLane >= 0 ? toLane : -1;
1180 if ((toEdge == 0 || c.
toEdge == toEdge)
1181 && (fromLane < 0 || c.
fromLane == fromLane)
1182 && (toLane < 0 || c.
toLane == toLane)) {
1185 for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
1192 if (fromLaneRemoved >= 0 && c.
fromLane > fromLaneRemoved) {
1196 for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
1197 for (NBConnectionVector::iterator tlcon = (*it)->getControlledLinks().begin(); tlcon != (*it)->getControlledLinks().end(); ++tlcon) {
1198 tlcon->shiftLaneIndex(
this, -1);
1203 if (toLaneRemoved >= 0 && c.
toLane > toLaneRemoved) {
1226 if (((*i).toEdge == connectionToRemove.
toEdge) && ((*i).fromLane == connectionToRemove.
fromLane) && ((*i).toLane == connectionToRemove.
toLane)) {
1241 if (reallowSetting) {
1253 if ((*i).toEdge == which) {
1255 (*i).toLane += laneOff;
1266 std::map<int, int> laneMap;
1270 bool wasConnected =
false;
1272 if ((*i).toEdge != which) {
1275 wasConnected =
true;
1276 if ((*i).fromLane != -1) {
1277 int fromLane = (*i).fromLane;
1278 laneMap[(*i).toLane] = fromLane;
1279 if (minLane == -1 || minLane > fromLane) {
1282 if (maxLane == -1 || maxLane < fromLane) {
1287 if (!wasConnected) {
1293 std::vector<NBEdge::Connection> conns = origConns;
1294 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
1295 if ((*i).toEdge == which) {
1298 int fromLane = (*i).fromLane;
1300 if (laneMap.find(fromLane) == laneMap.end()) {
1301 if (fromLane >= 0 && fromLane <= minLane) {
1304 if (fromLane >= 0 && fromLane >= maxLane) {
1308 toUse = laneMap[fromLane];
1342 std::vector<Connection>::iterator i =
myConnections.begin() + index;
1365 std::string innerID =
":" + n.
getID();
1367 int edgeIndex = linkIndex;
1368 int internalLaneIndex = 0;
1375 if (con.
toEdge != toEdge) {
1378 edgeIndex = linkIndex;
1379 toEdge = (*i).toEdge;
1380 internalLaneIndex = 0;
1383 std::vector<int> foeInternalLinks;
1393 std::pair<double, std::vector<int> > crossingPositions(-1, std::vector<int>());
1394 std::set<std::string> tmpFoeIncomingLanes;
1403 for (EdgeVector::const_iterator i2 = incoming.begin(); i2 != incoming.end(); ++i2) {
1404 const std::vector<Connection>& elv = (*i2)->getConnections();
1405 for (std::vector<NBEdge::Connection>::const_iterator k2 = elv.begin(); k2 != elv.end(); k2++) {
1406 if ((*k2).toEdge == 0) {
1409 bool needsCont = n.
needsCont(
this, *i2, con, *k2);
1412 crossingPositions.second.push_back(index);
1416 double width2 = (*k2).toEdge->getLaneWidth((*k2).toLane);
1417 if ((*k2).toEdge->getPermissions((*k2).toLane) !=
SVC_BICYCLE) {
1423 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1424 crossingPositions.first = minDV;
1429 this, con.
toEdge, con.
fromLane, (*i2), (*k2).toEdge, (*k2).fromLane);
1431 if (n.
foes(
this, con.
toEdge, *i2, (*k2).toEdge) || rightTurnConflict) {
1432 foeInternalLinks.push_back(index);
1436 if ((n.
forbids(*i2, (*k2).toEdge,
this, con.
toEdge, signalised) || rightTurnConflict) && (needsCont || dir ==
LINKDIR_TURN)) {
1437 tmpFoeIncomingLanes.insert((*i2)->getID() +
"_" +
toString((*k2).fromLane));
1443 const std::vector<NBNode::Crossing>& crossings = n.
getCrossings();
1444 for (std::vector<NBNode::Crossing>::const_iterator it_c = crossings.begin(); it_c != crossings.end(); ++it_c) {
1446 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
1447 const NBEdge* edge = *it_e;
1449 if (
this == edge || con.
toEdge == edge) {
1450 foeInternalLinks.push_back(index);
1451 if (con.
toEdge == edge &&
1459 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1460 crossingPositions.first = minDV;
1483 crossingPositions.first = -1;
1486 crossingPositions.first = con.
contPos;
1504 assert(shape.size() >= 2);
1506 if (crossingPositions.first >= 0) {
1507 std::pair<PositionVector, PositionVector>
split = shape.
splitAt(crossingPositions.first);
1508 con.
id = innerID +
"_" +
toString(edgeIndex);
1509 con.
shape = split.first;
1512 con.
viaID = innerID +
"_" +
toString(splitIndex + noInternalNoSplits);
1518 con.
id = innerID +
"_" +
toString(edgeIndex);
1523 ++internalLaneIndex;
1543 if (tmp.size() > 0) {
1544 intersect =
MIN2(intersect, tmp[0]);
1547 if (tmp.size() > 0) {
1548 intersect =
MIN2(intersect, tmp[0]);
1581 assert(atNode ==
myTo);
1596 assert(atNode ==
myTo);
1604 if (!onlyPossible) {
1624 std::vector<double> offsets(
myLanes.size(), 0.);
1626 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
1628 offsets[i] = offset;
1635 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1641 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1642 offsets[i] += offset;
1646 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1650 WRITE_WARNING(
"In edge '" +
getID() +
"': lane shape could not be determined (" + e.what() +
").");
1703 if (
DEBUGCOND) std::cout <<
"computeAngle edge=" <<
getID() <<
" fromCenter=" << fromCenter <<
" toCenter=" << toCenter
1704 <<
" refStart=" << referencePosStart <<
" refEnd=" << referencePosEnd <<
" shape=" << shape
1705 <<
" hasFromShape=" << hasFromShape
1706 <<
" hasToShape=" << hasToShape
1732 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1733 if ((*i).permissions !=
SVCAll) {
1743 std::vector<Lane>::const_iterator i =
myLanes.begin();
1746 for (; i !=
myLanes.end(); ++i) {
1747 if (i->permissions != firstLanePermissions) {
1757 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1768 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1769 if (i->width !=
myLanes.begin()->width) {
1779 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1780 if (i->endOffset !=
myLanes.begin()->endOffset) {
1790 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1818 for (EdgeVector::const_iterator i = o.begin(); i != o.end(); ++i) {
1855 std::vector<int> connNumbersPerLane(
myLanes.size(), 0);
1857 if ((*i).toEdge == 0 || (*i).fromLane < 0 || (*i).toLane < 0) {
1860 if ((*i).fromLane >= 0) {
1861 ++connNumbersPerLane[(*i).fromLane];
1872 for (
int i = 0; i < (int)
myLanes.size(); i++) {
1888 }
else if (common == 0) {
1891 const int origToLane = c.
toLane;
1893 int toLane = origToLane;
1906 int toLane = origToLane;
1941 if (incoming.size() > 1) {
1942 for (
int i = 0; i < (int)
myLanes.size(); i++) {
1944 bool connected =
false;
1945 for (std::vector<NBEdge*>::const_iterator in = incoming.begin(); in != incoming.end(); ++in) {
1946 if ((*in)->hasConnectionTo(
this, i)) {
1964 if (outgoing->size() == 0) {
1976 #ifdef DEBUG_CONNECTION_GUESSING 1978 std::cout <<
" divideOnEdges " <<
getID() <<
" outgoing=" <<
toString(*outgoing) <<
" prios=" <<
toString(*priorities) <<
"\n";
1983 std::vector<int> availableLanes;
1984 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1986 availableLanes.push_back(i);
1989 if (availableLanes.size() > 0) {
1993 availableLanes.clear();
1994 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1999 availableLanes.push_back(i);
2001 if (availableLanes.size() > 0) {
2005 availableLanes.clear();
2006 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
2011 availableLanes.push_back(i);
2013 if (availableLanes.size() > 0) {
2017 availableLanes.clear();
2018 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
2023 availableLanes.push_back(i);
2025 if (availableLanes.size() > 0) {
2030 if ((*i).fromLane == -1) {
2049 const int numOutgoing = (int) outgoing->size();
2050 std::vector<double> resultingLanes;
2051 resultingLanes.reserve(numOutgoing);
2052 double sumResulting = 0.;
2053 double minResulting = 10000.;
2054 for (
int i = 0; i < numOutgoing; i++) {
2058 (double)(*priorities)[i] *
2059 (double) availableLanes.size() / (double) prioSum;
2061 if (res > availableLanes.size()) {
2062 res = (double) availableLanes.size();
2065 resultingLanes.push_back(res);
2066 sumResulting += res;
2067 if (minResulting > res && res > 0) {
2079 transition.reserve(numOutgoing);
2080 for (
int i = 0; i < numOutgoing; i++) {
2083 assert(i < (
int)resultingLanes.size());
2084 const int tmpNum = (int)std::ceil(resultingLanes[i] / minResulting);
2085 numVirtual += tmpNum;
2086 for (
double j = 0; j < tmpNum; j++) {
2087 transition.push_back((*outgoing)[i]);
2090 #ifdef DEBUG_CONNECTION_GUESSING 2092 std::cout <<
" prioSum=" << prioSum <<
" sumResulting=" << sumResulting <<
" minResulting=" << minResulting <<
" numVirtual=" << numVirtual <<
" availLanes=" <<
toString(availableLanes) <<
" resLanes=" <<
toString(resultingLanes) <<
" transition=" <<
toString(transition) <<
"\n";
2101 for (EdgeVector::const_iterator i = outgoing->begin(); i != outgoing->end(); ++i) {
2103 assert(l2eConns.find(target) != l2eConns.end());
2104 const std::vector<int> lanes = (l2eConns.find(target))->second;
2105 for (std::vector<int>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
2106 const int fromIndex = availableLanes[*j];
2125 if (numConsToTarget >= targetLanes) {
2130 for (
int ii = 0; ii < (int)
myLanes.size(); ++ii) {
2138 if (
myLanes[fromIndex].connectionsDone) {
2144 #ifdef DEBUG_CONNECTION_GUESSING 2146 std::cout <<
" request connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
2159 const int numOutgoing = (int) outgoing->size();
2161 NBEdge* rightOfTarget = 0;
2162 NBEdge* leftOfTarget = 0;
2164 for (
int i = 0; i < numOutgoing; i++) {
2165 if (maxPrio < (*priorities)[i]) {
2168 maxPrio = (*priorities)[i];
2169 target = (*outgoing)[i];
2170 rightOfTarget = i == 0 ? outgoing->back() : (*outgoing)[i - 1];
2171 leftOfTarget = i + 1 == numOutgoing ? outgoing->front() : (*outgoing)[i + 1];
2183 const int numDesiredConsToTarget =
MIN2(targetLanes, (
int)availableLanes.size());
2184 #ifdef DEBUG_CONNECTION_GUESSING 2186 std::cout <<
" checking extra lanes for target=" << target->
getID() <<
" cons=" << numConsToTarget <<
" desired=" << numDesiredConsToTarget <<
"\n";
2189 std::vector<int>::const_iterator it_avail = availableLanes.begin();
2190 while (numConsToTarget < numDesiredConsToTarget && it_avail != availableLanes.end()) {
2191 const int fromIndex = *it_avail;
2200 && !
myLanes[fromIndex].connectionsDone
2202 #ifdef DEBUG_CONNECTION_GUESSING 2204 std::cout <<
" candidate from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
2213 #ifdef DEBUG_CONNECTION_GUESSING 2215 std::cout <<
" request additional connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
2221 #ifdef DEBUG_CONNECTION_GUESSING 2226 <<
" rightOfTarget=" << rightOfTarget->
getID()
2227 <<
" leftOfTarget=" << leftOfTarget->
getID()
2241 std::vector<int>* priorities =
new std::vector<int>();
2242 if (outgoing->size() == 0) {
2245 priorities->reserve(outgoing->size());
2246 EdgeVector::const_iterator i;
2247 for (i = outgoing->begin(); i != outgoing->end(); i++) {
2250 assert((prio + 1) * 2 > 0);
2251 prio = (prio + 1) * 2;
2252 priorities->push_back(prio);
2259 i = find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
2260 int dist = (int) distance(outgoing->begin(), i);
2262 #ifdef DEBUG_CONNECTION_GUESSING 2264 <<
" outgoing=" <<
toString(*outgoing)
2265 <<
" priorities1=" <<
toString(*priorities)
2272 assert(priorities->size() > 0);
2273 (*priorities)[0] /= 2;
2274 #ifdef DEBUG_CONNECTION_GUESSING 2276 std::cout <<
" priorities2=" <<
toString(*priorities) <<
"\n";
2283 if (mainDirections.
empty()) {
2284 assert(dist < (
int)priorities->size());
2285 (*priorities)[dist] *= 2;
2286 #ifdef DEBUG_CONNECTION_GUESSING 2288 std::cout <<
" priorities3=" <<
toString(*priorities) <<
"\n";
2293 (*priorities)[dist] += 1;
2297 (*priorities)[0] /= 4;
2298 (*priorities)[(int)priorities->size() - 1] /= 2;
2299 #ifdef DEBUG_CONNECTION_GUESSING 2301 std::cout <<
" priorities6=" <<
toString(*priorities) <<
"\n";
2308 (*priorities)[dist] *= 2;
2309 #ifdef DEBUG_CONNECTION_GUESSING 2311 std::cout <<
" priorities4=" <<
toString(*priorities) <<
"\n";
2315 (*priorities)[dist] *= 3;
2316 #ifdef DEBUG_CONNECTION_GUESSING 2318 std::cout <<
" priorities5=" <<
toString(*priorities) <<
"\n";
2331 for (std::vector<int>::const_iterator i = priorities.begin(); i != priorities.end(); i++) {
2349 const int fromLane = (int)
myLanes.size() - 1;
2351 if (checkPermissions) {
2382 if (pos < tolerance) {
2396 for (
int i = 0; i < lanes; i++) {
2398 for (std::vector<NBEdge::Connection>::iterator j = elv.begin(); j != elv.end(); j++) {
2400 assert(el.
tlID ==
"");
2446 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
2448 if (fromLane >= 0 && toLane >= 0) {
2450 std::vector<Connection>::iterator i =
2458 connection.
tlID = tlID;
2466 bool hadError =
false;
2468 if ((*i).toEdge != toEdge) {
2471 if (fromLane >= 0 && fromLane != (*i).fromLane) {
2474 if (toLane >= 0 && toLane != (*i).toLane) {
2477 if ((*i).tlID ==
"") {
2479 (*i).tlLinkNo = tlIndex;
2482 if ((*i).tlID != tlID && (*i).tlLinkNo == tlIndex) {
2483 WRITE_WARNING(
"The lane '" + toString<int>((*i).fromLane) +
"' on edge '" +
getID() +
"' already had a traffic light signal.");
2488 if (hadError && no == 0) {
2489 WRITE_WARNING(
"Could not set any signal of the tlLogic '" + tlID +
"' (unknown group)");
2523 ret =
myLanes.back().shape.reverse();
2541 ret =
myLanes[0].shape.reverse();
2572 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2574 myLanes[i].permissions != possContinuation->
myLanes[i].permissions ||
2600 if (find(conn.begin(), conn.end(), possContinuation) == conn.end()) {
2616 if (conns.size() !=
myLanes.size() - offset) {
2632 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2661 if ((*i).toEdge == e && (*i).tlID !=
"") {
2693 assert(distances.size() > 0);
2700 assert(index <= (
int)
myLanes.size());
2704 int templateIndex = index > 0 ? index - 1 : index + 1;
2715 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2716 (*i)->invalidateConnections(
true);
2724 int newLaneNo = (int)
myLanes.size() + by;
2725 while ((
int)
myLanes.size() < newLaneNo) {
2735 assert(index < (
int)
myLanes.size());
2740 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2741 (*i)->invalidateConnections(
true);
2750 int newLaneNo = (int)
myLanes.size() - by;
2751 assert(newLaneNo > 0);
2752 while ((
int)
myLanes.size() > newLaneNo) {
2770 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2774 assert(lane < (
int)
myLanes.size());
2775 myLanes[lane].permissions |= vclass;
2783 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2787 assert(lane < (
int)
myLanes.size());
2788 myLanes[lane].permissions &= ~vclass;
2796 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2800 assert(lane < (
int)
myLanes.size());
2801 myLanes[lane].preferred |= vclass;
2811 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2817 assert(lane < (
int)
myLanes.size());
2833 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2850 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2856 assert(lane < (
int)
myLanes.size());
2857 myLanes[lane].endOffset = offset;
2866 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2872 assert(lane < (
int)
myLanes.size());
2879 assert(lane < (
int)
myLanes.size());
2880 myLanes[lane].accelRamp = accelRamp;
2887 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2892 assert(lane < (
int)
myLanes.size());
2893 myLanes[lane].permissions = permissions;
2901 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2906 assert(lane < (
int)
myLanes.size());
2907 myLanes[lane].preferred = permissions;
2916 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2921 assert(lane < (
int)
myLanes.size());
2922 return myLanes[lane].permissions;
2935 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2936 (*i).permissions =
SVCAll;
2959 for (
int i = start; i != end; i += direction) {
2971 std::set<SVCPermissions>
2973 std::set<SVCPermissions> result;
2977 for (
int i = iStart; i < iEnd; ++i) {
2994 std::cout <<
getID() <<
" angle=" <<
getAngleAtNode(node) <<
" convAngle=" << angle <<
"\n";
3036 if (
myLanes[0].permissions == vclass) {
3048 myLanes[0].permissions = vclass;
3059 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
3060 (*it)->shiftToLanesToEdge(
this, 1);
3071 if (
myLanes[0].permissions != vclass) {
3081 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
3082 (*it)->shiftToLanesToEdge(
this, 0);
3095 if ((*it).toEdge == to && (*it).toLane >= 0) {
3096 (*it).toLane += laneOff;
3105 const int i = (node ==
myTo ? -1 : 0);
3106 const int i2 = (node ==
myTo ? 0 : -1);
3112 if (dist < neededOffset && dist2 < neededOffset2) {
3120 WRITE_WARNING(
"Could not avoid overlapping shape at node '" + node->
getID() +
"' for edge '" +
getID() +
"'");
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
return true if certain connection must be controlled by TLS
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
bool gDebugFlag1
global utility flags for debugging
bool around(const Position &p, double offset=0) const
Returns the information whether the position vector describes a polygon lying around the given point...
std::string id
id of Connection
void moveConnectionToRight(int lane)
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
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.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
std::vector< Lane > myLanes
Lane information.
double vmax
maximun velocity
double getLength() const
Returns the computed length of the edge.
double getAngleAtNodeToCenter(const NBNode *const node) const
Returns the angle of from the node shape center to where the edge meets the node shape.
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
double length2D() const
Returns the length.
void divideOnEdges(const EdgeVector *outgoing)
divides the lanes on the outgoing edges
A structure which describes a connection between edges or lanes.
int toLane
The lane the connections yields in.
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.
std::string foeIncomingLanes
FOE Incomings lanes.
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
std::vector< TLSDisabledConnection > myTLSDisabledConnections
vector with the disabled connections
void append(const PositionVector &v, double sameThreshold=2.0)
PositionVector getOrthogonal(const Position &p, double extend, bool before, double length=1.0) const
return orthogonal through p (extending this vector if necessary)
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
double z() const
Returns the z-position.
void sortOutgoingConnectionsByAngle()
sorts the outgoing connections by their angle relative to their junction
std::string viaID
if Connection have a via, ID of it
double 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) ...
NBEdge * toEdge
The edge the connections yields in.
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset)
patches loaded signal plans by modifying lane indices
EdgeVector getIncomingEdges() const
Returns the list of incoming edges unsorted.
void mirrorX()
mirror coordinates along the x-axis
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
The relationships between edges are computed/loaded.
double getLaneSpeed(int lane) const
get lane speed
bool hasPermissions() const
whether at least one lane has restrictions
bool isConnectedTo(const NBEdge *e) const
Returns the information whethe a connection to the given edge has been added (or computed) ...
void reduceGeometry(const double minDist)
Removes points with a distance lesser than the given.
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Check if edge has signalised connections.
double myLaneWidth
This width of this edge's lanes.
double myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drive...
PositionVector computeInternalLaneShape(NBEdge *fromE, const NBEdge::Connection &con, int numPoints, NBNode *recordError=0) const
Compute the shape for an internal lane.
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
double getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
Some static methods for string processing.
static const double ANGLE_LOOKAHEAD
the distance at which to take the default angle
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
void moveConnectionToLeft(int lane)
int getPriority() const
Returns the priority of the edge.
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
const std::string & getTypeID() const
get ID of type
const double SUMO_const_laneWidth
bool empty() const
returns the information whether no following street has a higher priority
void addIncomingEdge(NBEdge *edge)
adds an incoming 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.
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
void setNodeBorder(const NBNode *node, const Position &p, const Position &p2, bool rectangularCut)
Set Node border.
Lane2LaneInfoType
Modes of setting connections between lanes.
std::vector< int > * prepareEdgePriorities(const EdgeVector *outgoing)
recomputes the edge priorities and manipulates them for a distribution of lanes on edges which is mor...
const std::vector< Crossing > & getCrossings() const
return this junctions pedestrian crossings
Lane(NBEdge *e, const std::string &_origID)
constructor
const double SUMO_const_laneWidthAndOffset
The link is a 180 degree turn.
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
static const double UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
std::vector< Direction > myDirs
list of the main direction within the following junction relative to the edge
void markAsInLane2LaneState()
mark edge as in lane to state lane
static const double UNSPECIFIED_OFFSET
unspecified lane offset
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false)
Removes the specified connection(s)
double getMaxLaneOffset()
get max lane offset
TLS Disabled Connections.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position ...
Lanes to lanes - relationships are computed; should be recheked.
Position getCentroid() const
Returns the centroid (closes the polygon if unclosed)
bool hasLoadedLength() const
Returns whether a length was set explicitly.
NBEdge * getTurnDestination(bool possibleDestination=false) const
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.
void setLoadedLength(double val)
set loaded lenght
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
void computeLaneShapes()
compute lane shapes
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
PositionVector reverse() const
reverse position vector
NBEdge(const std::string &id, NBNode *from, NBNode *to, std::string type, double speed, int nolanes, int priority, double width, double offset, const std::string &streetName="", LaneSpreadFunction spread=LANESPREAD_RIGHT)
Constructor.
PositionVector myGeom
The geometry for the edge.
double visibility
custom foe visiblity for connection
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.
const double SUMO_const_laneOffset
const std::string & getID() const
Returns the id.
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
const SVCPermissions SVCAll
all VClasses are allowed
std::vector< int > getConnectionLanes(NBEdge *currentOutgoing) const
Returns the list of lanes that may be used to reach the given edge.
std::vector< double > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
PositionVector myFromBorder
intersection borders (because the node shape might be invalid)
void restoreBikelane(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added BikeLane
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
std::string getDescription(const NBEdge *parent) const
get string describing this connection
std::pair< PositionVector, PositionVector > splitAt(double where) const
Returns the two lists made when this list vector is splitted at the given point.
bool includes(Direction d) const
returns the information whether the street in the given direction has a higher priority ...
double getShapeStartAngle() const
Returns the angle at the start of the edge.
static const double UNSPECIFIED_WIDTH
unspecified lane width
bool expandableBy(NBEdge *possContinuation) const
Check if Node is expandable.
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
The connection was computed and validated.
bool hasDefaultGeometryEndpoints() const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
static OptionsCont & getOptions()
Retrieves the options.
bool setConnection(int lane, NBEdge *destEdge, int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection to a certain lane of a certain edge.
void shortenGeometryAtNode(const NBNode *node, double reduction)
linearly extend the geometry at the given node
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
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...
static double legacyDegree(const double angle, const bool positive=false)
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
PositionVector cutAtIntersection(const PositionVector &old) const
cut shape at the intersection shapes
The edge has been loaded, nothing is computed yet.
NBNode * tryGetNodeAtPosition(double pos, double tolerance=5.0) const
Returns the node at the given edges length (using an epsilon)
int getFirstNonPedestrianLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN and 0
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.
The link is a straight direction.
PositionVector shape
shape of Connection
static const double UNSPECIFIED_SPEED
unspecified lane speed
void restoreSidewalk(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added sidewalk
bool keepClear
whether the junction must be kept clear when using this connection
void addRestrictedLane(double width, SUMOVehicleClass vclass)
add a lane of the given width, restricted to the given class and shift existing connections ...
std::vector< Connection > getConnectionsFromLane(int lane) const
Returns connections from a given lane.
An (internal) definition of a single lane of an edge.
void addLane(int index, bool recompute=true)
add lane
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
void extrapolate2D(const double val, const bool onlyFirst=false)
extrapolate position vector in two dimensions (Z is ignored)
void incLaneNo(int by)
increment lane
bool isTLControlled() const
Returns whether this node is controlled by any tls.
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
void push_front_noDoublePos(const Position &p)
insert in front a non double position
void removeDoublePoints(double minDist=POSITION_EPS, bool assertLength=false)
Removes positions if too near.
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
double myStartAngle
The angles of the edge.
bool hasLaneSpecificWidth() const
whether lanes differ in width
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static const int FORWARD
edge directions (for pedestrian related stuff)
bool hasDefaultGeometryEndpointAtNode(const NBNode *node) const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
void decLaneNo(int by)
decrement lane
std::string tlID
The id of the traffic light that controls this connection.
double beginEndAngle() const
returns the angle in radians of the line connecting the first and the last position ...
std::string getLaneID(int lane) const
get Lane ID (Secure)
int getNumLanes() const
Returns the number of lanes.
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)
delete lane
int operator()(const Connection &c1, const Connection &c2) const
comparing operation
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.
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
static int computePrioritySum(const std::vector< int > &priorities)
computes the sum of the given list's entries (sic!)
static bool connections_sorter(const Connection &c1, const Connection &c2)
connections_sorter sort by fromLane, toEdge and toLane
void resetNodeBorder(const NBNode *node)
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
bool hasConnectionTo(NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
int myPriority
The priority of the edge.
static double firstIntersection(const PositionVector &v1, const PositionVector &v2, double width2)
compute the first intersection point between the given lane geometries considering their rspective wi...
bool geometryLike() const
whether this is structurally similar to a geometry node
Storage for edges, including some functionality operating on multiple edges.
std::string origID
origin ID
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
The link is a (hard) right direction.
Connection(int fromLane_, NBEdge *toEdge_, int toLane_)
Constructor.
EdgeBuildingStep myStep
The building step.
const std::string & getStreetName() const
Returns the street name of this edge.
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
std::vector< double > intersectsAtLengths2D(const PositionVector &other) const
For all intersections between this vector and other, return the 2D-length of the subvector from this ...
Class to sort edges by their angle.
void buildInnerEdges(const NBNode &n, int noInternalNoSplits, int &linkIndex, int &splitIndex)
PositionVector getCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going clock-wise around the given node
PositionVector getSubpart(double beginOffset, double endOffset) const
get subpart of a position vector
double getEndOffset() const
Returns the offset to the destination node.
PositionVector smoothedZFront(double dist=std::numeric_limits< double >::max()) const
returned vector that is smoothed at the front (within dist)
static const double INVALID_OFFSET
a value to signify offsets outside the range of [0, Line.length()]
std::vector< Connection > myConnections
List of connections to following edges.
PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode, PositionVector nodeShape) const
std::string getLaneIDInsecure(int lane) const
get Lane ID (Insecure)
void execute(const int lane, const int virtEdge)
executes a bresenham - step
PositionVector getSubpartByIndex(int beginIndex, int count) const
get subpart of a position vector using index and a cout
The connection was given by the user.
void reinit(NBNode *from, NBNode *to, const std::string &type, double speed, int nolanes, int priority, PositionVector geom, double width, double offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
The link is a partial right direction.
double speed
The speed allowed on this lane.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::set< SVCPermissions > getPermissionVariants(int iStart, int iEnd) const
return all permission variants within the specified lane range [iStart, iEnd[
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
bool lanesWereAssigned() const
Check if lanes were assigned.
double getFinalLength() const
get length that will be assigned to the lanes in the final network
void move2side(double amount)
move position vector to side using certain ammount
vehicle is a passenger car (a "normal" car)
bool myAmInnerEdge
Information whether this is a junction-inner edge.
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
Base class for objects which have an id.
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again ...
double mySpeed
The maximal speed.
static std::string convertUmlaute(std::string str)
Converts german "Umlaute" to their latin-version.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
const PositionVector & getShape() const
retrieve the junction shape
double getSpeed() const
Returns the speed allowed on this edge.
int getToLane() const
returns the to-lane
NBEdge * getTo() const
returns the to-edge (end of the connection)
int internalLaneIndex
The lane index of this internal lane within the internal edge.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
void extendGeometryAtNode(const NBNode *node, double maxExtent)
linearly extend the geometry at the given node
PositionVector getSubpart2D(double beginOffset, double endOffset) const
get subpart of a position vector in two dimensions (Z is ignored)
Connection getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection This method goes through "myConnections" and returns the specified o...
double getLaneWidth() const
Returns the default width of lanes of this edge.
void setTurningDestination(NBEdge *e, bool onlyPossible=false)
Sets the turing destination at the given edge.
static const int BACKWARD
std::string myID
The name of the object.
void extrapolate(const double val, const bool onlyFirst=false, const bool onlyLast=false)
extrapolate position vector
double width
This lane's width.
double length() const
Returns the length.
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)
disable connections for TLS
PositionVector viaShape
shape of via
bool hasAccelLane() const
whether one of the lanes is an acceleration lane
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
PositionVector myToBorder
double getCrossingAngle(NBNode *node)
return the angle for computing pedestrian crossings at the given node
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node) ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
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.
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
static const int UNSPECIFIED_INTERNAL_LANE_INDEX
internal lane computation not yet done
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
double mySignalOffset
the offset of a traffic light signal from the end of this edge (-1 for None)
The edge has been loaded and connections shall not be added.
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
double contPos
custom position for internal junction on this connection
bool uncontrolled
check if Connection is uncontrolled
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
SumoXMLNodeType getType() const
Returns the type of this node.
double angleAt2D(int pos) const
get angle in certain position of position vector
void addBikeLane(double width)
add a bicycle lane of the given width and shift existing connctions
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 restoreRestrictedLane(SUMOVehicleClass vclass, std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore a restricted lane
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
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
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)
append another edge
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge's lane and an approached one.
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
The connection was computed.
const Position & getPosition() const
EdgeVector edges
The edges being crossed.
int getFromLane() const
returns the from-lane
Represents a single node (junction) during network building.
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to, int indexOfStraightest)
constructor
void dismissVehicleClassInformation()
dimiss vehicle class information
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
A definition of a pedestrian crossing.
void replaceInConnections(NBEdge *which, NBEdge *by, int laneOff)
replace in current connections of edge
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
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
void preferVehicleClass(int lane, SUMOVehicleClass vclass)
prefer certain vehicle class
void checkGeometry(const double maxAngle, const double minRadius, bool fix)
Check the angles of successive geometry segments.
void push_back_noDoublePos(const Position &p)
insert in back a non double position
bool isLeftMover(const NBEdge *const from, const NBEdge *const to) const
Computes whether the given connection is a left mover across the junction.
void allowVehicleClass(int lane, SUMOVehicleClass vclass)
set allowed class for the given lane or for all lanes if -1 is given
int getTLIndex() const
returns the index within the controlling tls or InvalidTLIndex if this link is unontrolled ...
void insertConnection(NBEdge::Connection connection)
insert a previously created NBEdge::connection
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
void computeAngle()
computes the angle of this edge and stores it in myAngle
NBNode * getFromNode() const
Returns the origin node of the edge.
Container for nodes during the netbuilding process.
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
std::string getInternalLaneID() const
get ID of internal lane
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node ...
static T maxValue(const std::vector< T > &v)
static double angleDiff(const double angle1, const double angle2)
Returns the difference of the second angle to the first angle in radiants.
bool haveVia
check if Connection have a Via
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
void add(double xoff, double yoff, double zoff)
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
double myLength
The length of the edge.
#define WRITE_MESSAGE(msg)
void divideSelectedLanesOnEdges(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > *priorities)
divide selected lanes on edges
PositionVector computeLaneShape(int lane, double offset) const
Computes the shape for the given lane.
double getShapeEndAngle() const
Returns the angle at the end of the edge.
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
double myLoadedLength
An optional length to use (-1 if not valid)
Lanes to edges - relationships are computed/loaded.
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
double viaVmax
Maximun velocity of via.
NBNode * myFrom
The source and the destination node.
bool canMoveConnection(const Connection &con, int newFromLane) const
whether the connection can originate on newFromLane
Connection & getConnectionRef(int fromLane, const NBEdge *to, int toLane)
Returns reference to the specified connection This method goes through "myConnections" and returns th...
bool isNearEnough2BeJoined2(NBEdge *e, double threshold) const
Check if edge is near enought to be joined to another edge.
NBNode * getToNode() const
Returns the destination node of the edge.
std::vector< int > foeInternalLinks
FOE Internal links.
~MainDirections()
destructor
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
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
void copyConnectionsFrom(NBEdge *src)
copy connections from antoher edge
A class that being a bresenham-callback assigns the incoming lanes to the edges.
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
void reshiftPosition(double xoff, double yoff)
Applies an offset to the edge.
const std::map< NBEdge *, std::vector< int > > & getBuiltConnections() const
get built connections
void setz(double z)
set position z
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
get first non-pedestrian lane
bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc)
Splits this edge at geometry points.