57 #ifdef CHECK_MEMORY_LEAKS 59 #endif // CHECK_MEMORY_LEAKS 61 #define DEBUGID "disabled" 89 assert(myTransitions.size() > virtEdge);
91 NBEdge* succEdge = myTransitions[virtEdge];
92 std::vector<unsigned int> lanes;
96 std::map<NBEdge*, std::vector<unsigned int> >::iterator i =
myConnections.find(succEdge);
104 std::vector<unsigned int>::iterator j = find(lanes.begin(), lanes.end(), lane);
105 if (j == lanes.end()) {
107 lanes.push_back(lane);
120 if (outgoing.size() == 0) {
124 assert(outgoing.size() > 0);
129 if (outgoing.back()->getJunctionPriority(to) == 1) {
135 if (outgoing.back()->getPriority() > tmp[0]->getPriority()) {
138 if (outgoing.back()->getNumLanes() > tmp[0]->getNumLanes()) {
147 NBEdge* edge = *(tmp.begin());
160 return myDirs.empty();
166 return find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
186 std::string type,
SUMOReal speed,
unsigned int nolanes,
188 const std::string& streetName,
204 init(nolanes,
false,
"");
209 std::string type,
SUMOReal speed,
unsigned int nolanes,
212 const std::string& streetName,
213 const std::string& origID,
229 init(nolanes, tryIgnoreNodePositions, origID);
258 if (to == tpl->
myTo) {
267 SUMOReal speed,
unsigned int nolanes,
int priority,
269 const std::string& streetName,
271 bool tryIgnoreNodePositions) {
293 const std::vector<Lane> oldLanes =
myLanes;
294 init(nolanes, tryIgnoreNodePositions, oldLanes.empty() ?
"" : oldLanes[0].origID);
295 for (
int i = 0; i < (int)nolanes; ++i) {
297 myLanes[i] = oldLanes[
MIN2(i, (
int)oldLanes.size() - 1)];
316 if (from == 0 || to == 0) {
317 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
334 NBEdge::init(
unsigned int noLanes,
bool tryIgnoreNodePositions,
const std::string& origID) {
339 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
345 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
360 WRITE_ERROR(
"Edge's '" +
myID +
"' from- and to-node are at the same position.");
368 assert(
myGeom.size() >= 2);
369 if (
myLanes.size() > noLanes) {
372 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
373 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
374 (*i)->removeFromConnections(
this, -1, lane);
379 for (
unsigned int i = 0; i < noLanes; i++) {
394 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
395 myLanes[i].shape.add(xoff, yoff, 0);
404 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
408 (*i).shape.mirrorX();
409 (*i).viaShape.mirrorX();
453 if (shape.size() >= 2) {
464 assert(shape.size() >= 2);
465 assert(shape.
length() > 0);
481 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
486 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
487 assert(
myLanes[i].shape.length() > 0);
488 avgLength +=
myLanes[i].shape.length();
504 assert(pbv.size() > 0);
512 ns[0].set(ns[0].x(), ns[0].y(), startNode->
getPosition().
z());
513 assert(ns.size() >= 2);
518 assert(pbv.size() > 0);
572 NBEdge* currentEdge =
this;
573 for (
int i = 1; i < (int)
myGeom.size() - 1; i++) {
575 if (i != (
int)
myGeom.size() - 2) {
576 std::string nodename =
myID +
"_in_between#" +
toString(i);
578 throw ProcessError(
"Error on adding in-between node '" + nodename +
"'.");
586 currentEdge->
myTo = newTo;
589 std::string edgename =
myID +
"[" +
toString(i - 1) +
"]";
593 if (!ec.
insert(currentEdge,
true)) {
594 throw ProcessError(
"Error on adding splitted edge '" + edgename +
"'.");
619 std::vector<SUMOReal> angles;
621 for (
int i = 0; i < (int)
myGeom.size() - 1; ++i) {
626 for (
int i = 0; i < (int)angles.size() - 1; ++i) {
629 if (maxAngle > 0 && relAngle > maxAngle) {
635 if (i == 0 || i == (
int)angles.size() - 2) {
636 const bool start = i == 0;
640 if (minRadius > 0 && r < minRadius) {
643 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
649 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
686 bool mayUseSameDestination,
687 bool mayDefinitelyPass,
702 return setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass, keepClear, contPos);
708 NBEdge* dest,
unsigned int toLane,
710 bool invalidatePrevious,
711 bool mayDefinitelyPass) {
712 if (invalidatePrevious) {
716 for (
unsigned int i = 0; i < no && ok; i++) {
726 bool mayUseSameDestination,
727 bool mayDefinitelyPass,
754 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
761 if (mayDefinitelyPass) {
784 std::vector<NBEdge::Connection>
786 std::vector<NBEdge::Connection> ret;
788 if ((*i).fromLane == static_cast<int>(lane)) {
800 (*i).fromLane == fromLane
802 && (*i).toLane == toLane) {
807 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
838 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
839 outgoing.push_back((*i).toEdge);
844 if (it->fromLane < 0 && it->toLane < 0) {
846 EdgeVector::iterator forbidden = find(outgoing.begin(), outgoing.end(), it->toEdge);
847 if (forbidden != outgoing.end()) {
848 outgoing.erase(forbidden);
853 unsigned int size = (
unsigned int) outgoing.size();
855 edges->reserve(size);
856 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
859 edges->push_back(outedge);
871 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
872 ret.push_back((*i).toEdge);
881 std::vector<int> ret;
884 if ((*i).toEdge == currentOutgoing) {
885 ret.push_back((*i).fromLane);
908 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
913 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
927 && (fromLane < 0 || c.
fromLane == fromLane)
928 && (toLane < 0 || c.
toLane == toLane)) {
952 if (reallowSetting) {
964 if ((*i).toEdge == which) {
966 (*i).toLane += laneOff;
977 std::map<int, int> laneMap;
981 bool wasConnected =
false;
983 if ((*i).toEdge != which) {
987 if ((*i).fromLane != -1) {
988 int fromLane = (*i).fromLane;
989 laneMap[(*i).toLane] = fromLane;
990 if (minLane == -1 || minLane > fromLane) {
993 if (maxLane == -1 || maxLane < fromLane) {
1004 std::vector<NBEdge::Connection> conns = origConns;
1005 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
1006 if ((*i).toEdge == which) {
1009 int fromLane = (*i).fromLane;
1011 if (laneMap.find(fromLane) == laneMap.end()) {
1012 if (fromLane >= 0 && fromLane <= minLane) {
1015 if (fromLane >= 0 && fromLane >= maxLane) {
1019 toUse = laneMap[fromLane];
1047 unsigned int index = 0;
1053 std::vector<Connection>::iterator i =
myConnections.begin() + index;
1076 std::string innerID =
":" + n.
getID();
1078 unsigned int edgeIndex = linkIndex;
1079 unsigned int internalLaneIndex = 0;
1086 if (con.
toEdge != toEdge) {
1089 edgeIndex = linkIndex;
1090 toEdge = (*i).toEdge;
1091 internalLaneIndex = 0;
1094 std::vector<unsigned int> foeInternalLinks;
1104 std::pair<SUMOReal, std::vector<unsigned int> > crossingPositions(-1, std::vector<unsigned int>());
1105 std::set<std::string> tmpFoeIncomingLanes;
1112 unsigned int index = 0;
1114 for (EdgeVector::const_iterator i2 = incoming.begin(); i2 != incoming.end(); ++i2) {
1115 const std::vector<Connection>& elv = (*i2)->getConnections();
1116 for (std::vector<NBEdge::Connection>::const_iterator k2 = elv.begin(); k2 != elv.end(); k2++) {
1117 if ((*k2).toEdge == 0) {
1120 bool needsCont = n.
needsCont(
this, *i2, con, *k2);
1123 crossingPositions.second.push_back(index);
1127 SUMOReal width2 = (*k2).toEdge->getLaneWidth((*k2).toLane);
1128 if ((*k2).toEdge->getPermissions((*k2).toLane) !=
SVC_BICYCLE) {
1134 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1135 crossingPositions.first = minDV;
1140 this, con.
toEdge, con.
fromLane, (*i2), (*k2).toEdge, (*k2).fromLane);
1142 if (n.
foes(
this, con.
toEdge, *i2, (*k2).toEdge) || rightTurnConflict) {
1143 foeInternalLinks.push_back(index);
1147 if ((n.
forbids(*i2, (*k2).toEdge,
this, con.
toEdge, signalised) || rightTurnConflict) && (needsCont || dir ==
LINKDIR_TURN)) {
1148 tmpFoeIncomingLanes.insert((*i2)->getID() +
"_" +
toString((*k2).fromLane));
1154 const std::vector<NBNode::Crossing>& crossings = n.
getCrossings();
1155 for (std::vector<NBNode::Crossing>::const_iterator it_c = crossings.begin(); it_c != crossings.end(); ++it_c) {
1157 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
1158 const NBEdge* edge = *it_e;
1160 if (
this == edge || con.
toEdge == edge) {
1161 foeInternalLinks.push_back(index);
1162 if (con.
toEdge == edge &&
1170 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1171 crossingPositions.first = minDV;
1194 crossingPositions.first = -1;
1197 crossingPositions.first = con.
contPos;
1215 assert(shape.size() >= 2);
1217 if (crossingPositions.first >= 0) {
1218 std::pair<PositionVector, PositionVector>
split = shape.
splitAt(crossingPositions.first);
1219 con.
id = innerID +
"_" +
toString(edgeIndex);
1220 con.
shape = split.first;
1223 con.
viaID = innerID +
"_" +
toString(splitIndex + noInternalNoSplits);
1229 con.
id = innerID +
"_" +
toString(edgeIndex);
1234 ++internalLaneIndex;
1254 if (tmp.size() > 0) {
1255 intersect =
MIN2(intersect, tmp[0]);
1258 if (tmp.size() > 0) {
1259 intersect =
MIN2(intersect, tmp[0]);
1292 assert(atNode ==
myTo);
1307 assert(atNode ==
myTo);
1315 if (!onlyPossible) {
1335 std::vector<SUMOReal> offsets;
1336 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1337 offsets.push_back(0);
1340 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
1342 offsets[i] = offset;
1349 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1355 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1356 offsets[i] += offset;
1360 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1364 WRITE_WARNING(
"In edge '" +
getID() +
"': lane shape could not be determined (" + e.what() +
").");
1419 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1420 if ((*i).permissions !=
SVCAll) {
1430 std::vector<Lane>::const_iterator i =
myLanes.begin();
1433 for (; i !=
myLanes.end(); ++i) {
1434 if (i->permissions != firstLanePermissions) {
1444 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1445 if (i->width !=
myLanes.begin()->width) {
1455 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1466 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1467 if (i->endOffset !=
myLanes.begin()->endOffset) {
1491 for (EdgeVector::const_iterator i = o.begin(); i != o.end(); ++i) {
1529 std::vector<unsigned int> connNumbersPerLane(
myLanes.size(), 0);
1531 if ((*i).toEdge == 0 || (*i).fromLane < 0 || (*i).toLane < 0) {
1534 if ((*i).fromLane >= 0) {
1535 ++connNumbersPerLane[(*i).fromLane];
1546 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1562 }
else if (common == 0) {
1565 const int origToLane = c.
toLane;
1567 int toLane = origToLane;
1580 int toLane = origToLane;
1615 if (outgoing->size() == 0) {
1628 std::vector<int> availableLanes;
1629 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1631 availableLanes.push_back(i);
1634 if (availableLanes.size() > 0) {
1638 availableLanes.clear();
1639 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1644 availableLanes.push_back(i);
1646 if (availableLanes.size() > 0) {
1650 availableLanes.clear();
1651 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1656 availableLanes.push_back(i);
1658 if (availableLanes.size() > 0) {
1662 availableLanes.clear();
1663 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
1668 availableLanes.push_back(i);
1670 if (availableLanes.size() > 0) {
1675 if ((*i).fromLane == -1) {
1694 const int numOutgoing = (int) outgoing->size();
1695 std::vector<SUMOReal> resultingLanes;
1696 resultingLanes.reserve(numOutgoing);
1699 for (
int i = 0; i < numOutgoing; i++) {
1706 if (res > availableLanes.size()) {
1707 res = (
SUMOReal) availableLanes.size();
1710 resultingLanes.push_back(res);
1711 sumResulting += res;
1712 if (minResulting > res && res > 0) {
1721 const int numVirtual = (int)(sumResulting / minResulting + 0.5);
1724 transition.reserve(numOutgoing);
1725 for (
int i = 0; i < numOutgoing; i++) {
1728 assert(i < (
int)resultingLanes.size());
1729 const SUMOReal tmpNum = resultingLanes[i] / minResulting;
1730 for (
SUMOReal j = 0; j < tmpNum; j++) {
1731 transition.push_back((*outgoing)[i]);
1737 Bresenham::compute(&adder, static_cast<unsigned int>(availableLanes.size()), numVirtual);
1738 const std::map<NBEdge*, std::vector<unsigned int> >& l2eConns = adder.
getBuiltConnections();
1739 for (std::map<
NBEdge*, std::vector<unsigned int> >::const_iterator i = l2eConns.begin(); i != l2eConns.end(); ++i) {
1740 NBEdge* target = (*i).first;
1741 const std::vector<unsigned int> lanes = (*i).second;
1742 for (std::vector<unsigned int>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
1743 const int fromIndex = availableLanes[*j];
1762 if (numConsToTarget >= targetLanes) {
1767 for (
unsigned int ii = 0; ii <
myLanes.size(); ++ii) {
1782 std::vector<unsigned int>*
1785 std::vector<unsigned int>* priorities =
new std::vector<unsigned int>();
1786 if (outgoing->size() == 0) {
1789 priorities->reserve(outgoing->size());
1790 EdgeVector::const_iterator i;
1791 for (i = outgoing->begin(); i != outgoing->end(); i++) {
1792 int prio = (*i)->getJunctionPriority(
myTo);
1793 assert((prio + 1) * 2 > 0);
1794 prio = (prio + 1) * 2;
1795 priorities->push_back(prio);
1803 i = find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
1804 unsigned int dist = (
unsigned int) distance(outgoing->begin(), i);
1806 assert(priorities->size() > 0);
1807 (*priorities)[0] /= 2;
1812 if (mainDirections.
empty()) {
1813 assert(dist < priorities->size());
1814 (*priorities)[dist] *= 2;
1818 (*priorities)[dist] *= 2;
1820 (*priorities)[dist] *= 3;
1830 unsigned int sum = 0;
1831 for (std::vector<unsigned int>::const_iterator i = priorities.begin(); i != priorities.end(); i++) {
1849 const int fromLane = (int)
myLanes.size() - 1;
1851 if (checkPermissions) {
1882 if (pos < tolerance) {
1896 for (
unsigned int i = 0; i < lanes; i++) {
1898 for (std::vector<NBEdge::Connection>::iterator j = elv.begin(); j != elv.end(); j++) {
1900 assert(el.
tlID ==
"");
1946 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
1948 if (fromLane >= 0 && toLane >= 0) {
1950 std::vector<Connection>::iterator i =
1958 connection.
tlID = tlID;
1965 unsigned int no = 0;
1966 bool hadError =
false;
1968 if ((*i).toEdge != toEdge) {
1971 if (fromLane >= 0 && fromLane != (*i).fromLane) {
1974 if (toLane >= 0 && toLane != (*i).toLane) {
1977 if ((*i).tlID ==
"") {
1979 (*i).tlLinkNo = tlIndex;
1982 if ((*i).tlID != tlID && (*i).tlLinkNo == tlIndex) {
1983 WRITE_WARNING(
"The lane '" + toString<int>((*i).fromLane) +
"' on edge '" +
getID() +
"' already had a traffic light signal.");
1988 if (hadError && no == 0) {
1989 WRITE_WARNING(
"Could not set any signal of the tlLogic '" + tlID +
"' (unknown group)");
2023 ret =
myLanes.back().shape.reverse();
2041 ret =
myLanes[0].shape.reverse();
2091 if (find(conn.begin(), conn.end(), possContinuation)
2108 if (conns.size() !=
myLanes.size()) {
2124 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2148 if ((*i).toEdge == e && (*i).tlID !=
"") {
2180 assert(distances.size() > 0);
2187 assert(index <=
myLanes.size());
2191 int templateIndex = index > 0 ? index - 1 : index + 1;
2202 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2203 (*i)->invalidateConnections(
true);
2211 unsigned int newLaneNo = (
unsigned int)
myLanes.size() + by;
2212 while (
myLanes.size() < newLaneNo) {
2222 assert(index <
myLanes.size());
2227 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2228 (*i)->invalidateConnections(
true);
2237 unsigned int newLaneNo = (
unsigned int)
myLanes.size() - by;
2238 assert(newLaneNo > 0);
2239 while (
myLanes.size() > newLaneNo) {
2257 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2261 assert(lane < (
int)
myLanes.size());
2262 myLanes[lane].permissions |= vclass;
2270 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2274 assert(lane < (
int)
myLanes.size());
2275 myLanes[lane].permissions &= ~vclass;
2283 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2287 assert(lane < (
int)
myLanes.size());
2288 myLanes[lane].preferred |= vclass;
2298 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2304 assert(lane < (
int)
myLanes.size());
2320 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2337 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2343 assert(lane < (
int)
myLanes.size());
2344 myLanes[lane].endOffset = offset;
2353 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2359 assert(lane < (
int)
myLanes.size());
2367 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2372 assert(lane < (
int)
myLanes.size());
2373 myLanes[lane].permissions = permissions;
2381 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2386 assert(lane < (
int)
myLanes.size());
2387 myLanes[lane].preferred = permissions;
2396 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2401 assert(lane < (
int)
myLanes.size());
2402 return myLanes[lane].permissions;
2415 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2416 (*i).permissions =
SVCAll;
2439 for (
int i = start; i != end; i += direction) {
2461 std::cout <<
getID() <<
" angle=" <<
getAngleAtNode(node) <<
" convAngle=" << angle <<
"\n";
2491 if (
myLanes[0].permissions == vclass) {
2503 myLanes[0].permissions = vclass;
2514 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
2515 (*it)->shiftToLanesToEdge(
this, 1);
2527 if ((*it).toEdge == to && (*it).toLane >= 0) {
2528 (*it).toLane += laneOff;
2537 const int i = (node ==
myTo ? -1 : 0);
2538 const int i2 = (node ==
myTo ? 0 : -1);
2544 if (dist < neededOffset && dist2 < neededOffset2) {
2552 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 invalidateConnections(bool reallowSetting=false)
int tlLinkNo
The index of this connection within the controlling traffic light.
The link is a partial left direction.
const PositionVector & getLaneShape(unsigned int i) const
Returns the shape of the nth lane.
std::vector< Lane > myLanes
Lane information.
bool includes(Direction d) const
PositionVector cutAtIntersection(const PositionVector &old) const
cut shape at the intersection shapes
bool hasConnectionTo(NBEdge *destEdge, unsigned int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
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.
SUMOReal distance(const Position &p, bool perpendicular=false) const
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
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.
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 moveOutgoingConnectionsFrom(NBEdge *e, unsigned int laneOff)
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.
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
void incLaneNo(unsigned int by)
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
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned 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.
const std::vector< Crossing > & getCrossings() const
return this junctions pedestrian crossings
bool addLane2LaneConnections(unsigned int fromLane, NBEdge *dest, unsigned int toLane, unsigned int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false)
Builds no connections starting at the given lanes.
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
void buildInnerEdges(const NBNode &n, unsigned int noInternalNoSplits, unsigned int &linkIndex, unsigned int &splitIndex)
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.
std::string getLaneIDInsecure(unsigned int lane) 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.
PositionVector getSubpartByIndex(int beginIndex, int count) const
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 setConnection(unsigned int lane, NBEdge *destEdge, unsigned 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 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.
std::vector< Connection > getConnectionsFromLane(unsigned int lane) const
Returns connections from a given lane.
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)
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
The connection was computed and validated.
static OptionsCont & getOptions()
Retrieves the options.
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
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.
void moveConnectionToRight(unsigned int lane)
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
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)
void reshiftPosition(SUMOReal xoff, SUMOReal yoff)
Applies an offset to the edge.
const Position & getPosition() const
Returns the position of this node.
void divideSelectedLanesOnEdges(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< unsigned int > *priorities)
static unsigned int computePrioritySum(const std::vector< unsigned int > &priorities)
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
const std::map< NBEdge *, std::vector< unsigned int > > & getBuiltConnections() const
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 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.
std::string getLaneID(unsigned int lane) const
void moveConnectionToLeft(unsigned int lane)
static SUMOReal legacyDegree(const SUMOReal angle, const bool positive=false)
static const int FORWARD
edge directions (for pedestrian related stuff)
void mirrorX()
mirror coordinates along the x-axis
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 add(SUMOReal xoff, SUMOReal yoff, SUMOReal zoff)
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
bool lanesWereAssigned() const
static bool connections_sorter(const Connection &c1, const Connection &c2)
std::vector< unsigned int > foeInternalLinks
unsigned int getNumLanes() const
Returns the number of lanes.
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.
bool canMoveConnection(const Connection &con, unsigned int newFromLane) const
whether the connection can originate on newFromLane
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.
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)
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.
static void compute(BresenhamCallBack *callBack, const unsigned int val1, const unsigned int val2)
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.
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
void decLaneNo(unsigned int by)
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 execute(const unsigned int lane, const unsigned int virtEdge)
executes a bresenham - step
void computeEdgeShape()
Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the f...
void disableConnection4TLS(int fromLane, NBEdge *toEdge, int toLane)
SUMOReal angleAt2D(int pos) const
SUMOReal getMaxLaneOffset()
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
void deleteLane(unsigned int index, bool recompute=true)
std::vector< NBEdge * > EdgeVector
std::vector< unsigned int > * prepareEdgePriorities(const EdgeVector *outgoing)
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.
PositionVector computeLaneShape(unsigned int lane, SUMOReal offset) const
Computes the shape for the given lane.
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.
void replaceInConnections(NBEdge *which, NBEdge *by, unsigned int laneOff)
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)
SUMOReal getLaneSpeed(unsigned int lane) const
void shiftToLanesToEdge(NBEdge *to, unsigned int laneOff)
modifify the toLane for all connections to the given edge
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.
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)
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.
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)
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 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)
unsigned int internalLaneIndex
The lane index of this internal lane within the internal edge.
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
NBEdge(const std::string &id, NBNode *from, NBNode *to, std::string type, SUMOReal speed, unsigned int nolanes, int priority, SUMOReal width, SUMOReal offset, const std::string &streetName="", LaneSpreadFunction spread=LANESPREAD_RIGHT)
Constructor.
#define WRITE_MESSAGE(msg)
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 ...
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.
void addLane(unsigned int index, bool recompute=true)
NBNode * myFrom
The source and the destination node.
bool expandableBy(NBEdge *possContinuation) const
NBEdge * getTurnDestination(bool possibleDestination=false) const
void init(unsigned int noLanes, bool tryIgnoreNodePositions, const std::string &origID)
Initialization routines common to all constructors.
PositionVector getSubpart(SUMOReal beginOffset, SUMOReal endOffset) const
~MainDirections()
destructor
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)
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to)
constructor
void extrapolate(const SUMOReal val, const bool onlyFirst=false)
void copyConnectionsFrom(NBEdge *src)
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, unsigned int nolanes, int priority, PositionVector geom, SUMOReal width, SUMOReal offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
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.