57 #ifdef CHECK_MEMORY_LEAKS
59 #endif // CHECK_MEMORY_LEAKS
84 assert(myTransitions.size() > virtEdge);
86 NBEdge* succEdge = myTransitions[virtEdge];
87 std::vector<unsigned int> lanes;
91 std::map<NBEdge*, std::vector<unsigned int> >::iterator i =
myConnections.find(succEdge);
99 std::vector<unsigned int>::iterator j = find(lanes.begin(), lanes.end(), lane);
100 if (j == lanes.end()) {
102 lanes.push_back(lane);
115 if (outgoing.size() == 0) {
119 assert(outgoing.size() > 0);
124 if (outgoing.back()->getJunctionPriority(to) == 1) {
130 if (outgoing.back()->getPriority() > tmp[0]->getPriority()) {
133 if (outgoing.back()->getNumLanes() > tmp[0]->getNumLanes()) {
142 NBEdge* edge = *(tmp.begin());
155 return myDirs.empty();
161 return find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
181 std::string type,
SUMOReal speed,
unsigned int nolanes,
183 const std::string& streetName,
198 init(nolanes,
false);
203 std::string type,
SUMOReal speed,
unsigned int nolanes,
206 const std::string& streetName,
211 myFrom(from), myTo(to),
212 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
213 myPriority(priority), mySpeed(speed),
214 myTurnDestination(0),
215 myFromJunctionPriority(-1), myToJunctionPriority(-1),
216 myGeom(geom), myLaneSpreadFunction(spread), myEndOffset(offset), myLaneWidth(laneWidth),
217 myLoadedLength(UNSPECIFIED_LOADED_LENGTH), myAmLeftHand(false),
218 myAmInnerEdge(false), myAmMacroscopicConnector(false),
219 myStreetName(streetName),
220 mySignalOffset(UNSPECIFIED_SIGNAL_OFFSET) {
221 init(nolanes, tryIgnoreNodePositions);
228 myType(tpl->getTypeID()),
229 myFrom(from), myTo(to),
230 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
231 myPriority(tpl->getPriority()), mySpeed(tpl->getSpeed()),
232 myTurnDestination(0),
233 myFromJunctionPriority(-1), myToJunctionPriority(-1),
235 myLaneSpreadFunction(tpl->getLaneSpreadFunction()),
236 myEndOffset(tpl->getEndOffset()),
237 myLaneWidth(tpl->getLaneWidth()),
238 myLoadedLength(UNSPECIFIED_LOADED_LENGTH),
240 myAmInnerEdge(false),
241 myAmMacroscopicConnector(false),
242 myStreetName(tpl->getStreetName()),
243 mySignalOffset(to == tpl->myTo ? tpl->mySignalOffset : UNSPECIFIED_SIGNAL_OFFSET) {
250 if (to == tpl->
myTo) {
259 SUMOReal speed,
unsigned int nolanes,
int priority,
261 const std::string& streetName,
263 bool tryIgnoreNodePositions) {
285 init(nolanes, tryIgnoreNodePositions);
292 if (from == 0 || to == 0) {
293 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
315 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
321 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
336 WRITE_ERROR(
"Edge's '" +
myID +
"' from- and to-node are at the same position.");
344 assert(
myGeom.size() >= 2);
346 for (
unsigned int i = 0; i < noLanes; i++) {
361 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
362 myLanes[i].shape.reshiftRotate(xoff, yoff, 0);
407 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
411 if (shape.size() >= 2) {
422 assert(shape.size() >= 2);
423 assert(shape.
length() > 0);
428 Line lc(shape[0], shape[-1]);
429 Line lo(old[0], old[-1]);
438 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
439 assert(
myLanes[i].shape.length() > 0);
440 avgLength +=
myLanes[i].shape.length();
456 assert(pbv.size() > 0);
460 ns[0].set(ns[0].x(), ns[0].y(), startNode->
getPosition().
z());
465 assert(pbv.size() > 0);
516 NBEdge* currentEdge =
this;
517 for (
int i = 1; i < (
int)
myGeom.size() - 1; i++) {
519 if (i != (
int)
myGeom.size() - 2) {
520 std::string nodename =
myID +
"_in_between#" +
toString(i);
522 throw ProcessError(
"Error on adding in-between node '" + nodename +
"'.");
530 currentEdge->
myTo = newTo;
533 std::string edgename =
myID +
"[" +
toString(i - 1) +
"]";
537 if (!ec.
insert(currentEdge,
true)) {
538 throw ProcessError(
"Error on adding splitted edge '" + edgename +
"'.");
563 std::vector<SUMOReal> angles;
565 for (
int i = 0; i < (
int)
myGeom.size() - 1; ++i) {
570 for (
int i = 0; i < (
int)angles.size() - 1; ++i) {
573 if (maxAngle > 0 && relAngle > maxAngle) {
579 if (i == 0 || i == (
int)angles.size() - 2) {
580 const bool start = i == 0;
584 if (minRadius > 0 && r < minRadius) {
587 (start ?
"start" :
"end") +
" of edge " +
getID());
593 (start ?
"start" :
"end") +
" of edge " +
getID());
630 bool mayUseSameDestination,
631 bool mayDefinitelyPass) {
644 setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass);
651 NBEdge* dest,
unsigned int toLane,
653 bool invalidatePrevious,
654 bool mayDefinitelyPass) {
655 if (invalidatePrevious) {
659 for (
unsigned int i = 0; i < no && ok; i++) {
669 bool mayUseSameDestination,
670 bool mayDefinitelyPass) {
698 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
705 if (mayDefinitelyPass) {
725 std::vector<NBEdge::Connection>
727 std::vector<NBEdge::Connection> ret;
729 if ((*i).fromLane == static_cast<int>(lane)) {
764 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
765 outgoing.push_back((*i).toEdge);
770 unsigned int size = (
unsigned int) outgoing.size();
772 edges->reserve(size);
773 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
776 edges->push_back(outedge);
788 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
789 ret.push_back((*i).toEdge);
798 std::vector<int> ret;
801 if ((*i).toEdge == currentOutgoing) {
802 ret.push_back((*i).fromLane);
825 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
830 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
844 && (fromLane < 0 || c.
fromLane == fromLane)
845 && (toLane < 0 || c.
toLane == toLane)) {
866 if (reallowSetting) {
879 if ((*i).toEdge == which) {
891 std::map<int, int> laneMap;
895 bool wasConnected =
false;
897 if ((*i).toEdge != which) {
901 if ((*i).fromLane != -1) {
902 int fromLane = (*i).fromLane;
903 laneMap[(*i).toLane] = fromLane;
904 if (minLane == -1 || minLane > fromLane) {
907 if (maxLane == -1 || maxLane < fromLane) {
918 std::vector<NBEdge::Connection> conns = origConns;
919 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
920 if ((*i).toEdge == which) {
923 int fromLane = (*i).fromLane;
925 if (laneMap.find(fromLane) == laneMap.end()) {
926 if (fromLane >= 0 && fromLane <= minLane) {
929 if (fromLane >= 0 && fromLane >= maxLane) {
933 toUse = laneMap[fromLane];
955 return (common > 0 && (!buildCrossingsAndWalkingAreas || common !=
SVC_PEDESTRIAN));
961 unsigned int index = 0;
977 std::vector<Connection>::iterator i =
myConnections.begin() + index;
997 if ((*i).fromLane == (
int)lane &&
canMoveConnection(*i, lane - 1, buildCrossingsAndWalkingAreas)) {
1010 std::string innerID =
":" + n.
getID();
1012 unsigned int edgeIndex = linkIndex;
1013 unsigned int internalLaneIndex = 0;
1020 if (con.
toEdge != toEdge) {
1023 edgeIndex = linkIndex;
1024 toEdge = (*i).toEdge;
1025 internalLaneIndex = 0;
1028 std::vector<unsigned int> foeInternalLinks;
1036 std::pair<SUMOReal, std::vector<unsigned int> > crossingPositions(-1, std::vector<unsigned int>());
1037 std::set<std::string> tmpFoeIncomingLanes;
1042 unsigned int index = 0;
1044 for (EdgeVector::const_iterator i2 = incoming.begin(); i2 != incoming.end(); ++i2) {
1045 const std::vector<Connection>& elv = (*i2)->getConnections();
1046 for (std::vector<NBEdge::Connection>::const_iterator k2 = elv.begin(); k2 != elv.end(); k2++) {
1047 if ((*k2).toEdge == 0) {
1050 bool needsCont = n.
needsCont(
this, con.
toEdge, *i2, (*k2).toEdge, *k2);
1053 crossingPositions.second.push_back(index);
1056 if (dv.size() > 0) {
1060 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1061 crossingPositions.first = minDV;
1067 if (n.
foes(
this, con.
toEdge, *i2, (*k2).toEdge)) {
1068 foeInternalLinks.push_back(index);
1073 tmpFoeIncomingLanes.insert((*i2)->getID() +
"_" +
toString((*k2).fromLane));
1079 const std::vector<NBNode::Crossing>& crossings = n.
getCrossings();
1080 for (std::vector<NBNode::Crossing>::const_iterator it_c = crossings.begin(); it_c != crossings.end(); ++it_c) {
1081 for (EdgeVector::const_iterator it_e = (*it_c).edges.begin(); it_e != (*it_c).edges.end(); ++it_e) {
1082 const NBEdge* edge = *it_e;
1084 if (
this == edge || con.
toEdge == edge) {
1085 foeInternalLinks.push_back(index);
1116 assert(shape.size() >= 2);
1118 if (crossingPositions.first >= 0) {
1119 std::pair<PositionVector, PositionVector> split = shape.
splitAt(crossingPositions.first);
1120 con.
id = innerID +
"_" +
toString(edgeIndex);
1121 con.
shape = split.first;
1124 con.
viaID = innerID +
"_" +
toString(splitIndex + noInternalNoSplits);
1130 con.
id = innerID +
"_" +
toString(edgeIndex);
1135 ++internalLaneIndex;
1167 assert(atNode ==
myTo);
1192 std::vector<SUMOReal> offsets;
1193 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1194 offsets.push_back(0);
1197 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
1199 offsets[i] = offset;
1206 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1212 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1213 offsets[i] += offset;
1220 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1224 WRITE_WARNING(
"In edge '" +
getID() +
"': lane shape could not be determined (" + e.what() +
")");
1234 bool haveWarned =
false;
1235 for (
int i = 0; i < (
int)
myGeom.size(); i++) {
1239 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, to, offset,
false);
1242 Position(from.
x() - offsets.first, from.
y() - offsets.second, from.
z()));
1243 }
else if (i == static_cast<int>(
myGeom.size() - 1)) {
1246 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, to, offset,
false);
1249 Position(to.
x() - offsets.first, to.
y() - offsets.second, to.
z()));
1254 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, me, offset,
false);
1255 std::pair<SUMOReal, SUMOReal> offsets2 =
laneOffset(me, to, offset,
false);
1257 Position(from.
x() - offsets.first, from.
y() - offsets.second),
1258 Position(me.
x() - offsets.first, me.
y() - offsets.second));
1261 Position(me.
x() - offsets2.first, me.
y() - offsets2.second),
1262 Position(to.
x() - offsets2.first, to.
y() - offsets2.second));
1264 if (angle < 10. || angle > 350.) {
1267 Position(me.
x() - offsets.first, me.
y() - offsets.second, me.
z()));
1292 std::pair<SUMOReal, SUMOReal>
1296 return std::pair<SUMOReal, SUMOReal>(-offsets.first, -offsets.second);
1298 return std::pair<SUMOReal, SUMOReal>(offsets.first, offsets.second);
1331 fromCenter.
x(), fromCenter.
y(),
1332 referencePosStart.x(), referencePosStart.y());
1335 referencePosEnd.x(), referencePosEnd.y(),
1336 toCenter.
x(), toCenter.
y());
1346 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1347 if ((*i).permissions !=
SVCAll) {
1357 std::vector<Lane>::const_iterator i =
myLanes.begin();
1360 for (; i !=
myLanes.end(); ++i) {
1361 if (i->permissions != firstLanePermissions) {
1371 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1372 if (i->width !=
myLanes.begin()->width) {
1382 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1393 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1394 if (i->endOffset !=
myLanes.begin()->endOffset) {
1418 for (EdgeVector::const_iterator i = o.begin(); i != o.end(); ++i) {
1456 std::vector<unsigned int> connNumbersPerLane(
myLanes.size(), 0);
1458 if ((*i).toEdge == 0 || (*i).fromLane < 0 || (*i).toLane < 0) {
1461 if ((*i).fromLane >= 0) {
1462 ++connNumbersPerLane[(*i).fromLane];
1473 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1475 if (i > 0 && connNumbersPerLane[i - 1] > 1) {
1477 }
else if (i <
myLanes.size() - 1 && connNumbersPerLane[i + 1] > 1) {
1493 if (outgoing->size() == 0) {
1505 std::vector<int> availableLanes;
1506 for (
int i = 0; i < (
int)
myLanes.size(); ++i) {
1511 availableLanes.push_back(i);
1515 unsigned int size = (
unsigned int) outgoing->size();
1516 std::vector<SUMOReal> resultingLanes;
1517 resultingLanes.reserve(size);
1521 for (i = 0; i < size; i++) {
1528 if (res > availableLanes.size()) {
1529 res = (
SUMOReal) availableLanes.size();
1532 resultingLanes.push_back(res);
1533 sumResulting += res;
1534 if (minResulting > res && res > 0) {
1543 sumResulting += minResulting / (
SUMOReal) 2.;
1544 unsigned int noVirtual = (
unsigned int)(sumResulting / minResulting);
1547 transition.reserve(size);
1548 for (i = 0; i < size; i++) {
1551 assert(i < resultingLanes.size());
1553 for (
SUMOReal j = 0; j < tmpNo; j++) {
1554 assert(outgoing->size() > i);
1555 transition.push_back((*outgoing)[i]);
1561 Bresenham::compute(&adder, static_cast<unsigned int>(availableLanes.size()), noVirtual);
1562 const std::map<NBEdge*, std::vector<unsigned int> >& l2eConns = adder.
getBuiltConnections();
1564 for (std::map<
NBEdge*, std::vector<unsigned int> >::const_iterator i = l2eConns.begin(); i != l2eConns.end(); ++i) {
1565 const std::vector<unsigned int> lanes = (*i).second;
1566 for (std::vector<unsigned int>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
1567 const int fromIndex = availableLanes[*j];
1568 if ((
getPermissions(fromIndex) & (*i).first->getPermissions()) == 0) {
1587 std::vector<unsigned int>*
1590 std::vector<unsigned int>* priorities =
new std::vector<unsigned int>();
1591 if (outgoing->size() == 0) {
1594 priorities->reserve(outgoing->size());
1595 EdgeVector::const_iterator i;
1596 for (i = outgoing->begin(); i != outgoing->end(); i++) {
1597 int prio = (*i)->getJunctionPriority(
myTo);
1598 assert((prio + 1) * 2 > 0);
1599 prio = (prio + 1) * 2;
1600 priorities->push_back(prio);
1608 i = find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
1609 unsigned int dist = (
unsigned int) distance(outgoing->begin(), i);
1611 assert(priorities->size() > 0);
1612 (*priorities)[0] = (*priorities)[0] / 2;
1617 if (mainDirections.
empty()) {
1618 assert(dist < priorities->size());
1619 (*priorities)[dist] = (*priorities)[dist] * 2;
1622 (*priorities)[dist] = (*priorities)[dist] * 2;
1631 unsigned int sum = 0;
1632 for (std::vector<unsigned int>::iterator i = priorities->begin(); i != priorities->end(); i++) {
1671 if (thisFromAngle2 < otherToAngle2) {
1672 std::swap(thisFromAngle2, otherToAngle2);
1674 if (thisFromAngle2 - otherToAngle2 > 170 && thisFromAngle2 - otherToAngle2 < 190) {
1685 if (pos < tolerance) {
1699 for (
unsigned int i = 0; i < lanes; i++) {
1701 for (std::vector<NBEdge::Connection>::iterator j = elv.begin(); j != elv.end(); j++) {
1703 assert(el.
tlID ==
"");
1751 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
1753 if (fromLane >= 0 && toLane >= 0) {
1755 std::vector<Connection>::iterator i =
1763 connection.
tlID = tlID;
1770 unsigned int no = 0;
1771 bool hadError =
false;
1773 if ((*i).toEdge != toEdge) {
1776 if (fromLane >= 0 && fromLane != (*i).fromLane) {
1779 if (toLane >= 0 && toLane != (*i).toLane) {
1782 if ((*i).tlID ==
"") {
1784 (*i).tlLinkNo = tlIndex;
1787 if ((*i).tlID != tlID && static_cast<int>((*i).tlLinkNo) == tlIndex) {
1788 WRITE_WARNING(
"The lane " + toString<int>((*i).fromLane) +
" on edge " +
getID() +
" already had a traffic light signal.");
1793 if (hadError && no == 0) {
1794 WRITE_WARNING(
"Could not set any signal of the traffic light '" + tlID +
"' (unknown group)");
1887 if (find(conn.begin(), conn.end(), possContinuation)
1904 if (conns.size() !=
myLanes.size()) {
1920 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1943 if ((*i).toEdge == e && (*i).tlID !=
"") {
1959 assert(lane <
myLanes.size());
1973 assert(distances.size() > 0);
1980 unsigned int newLaneNo = (
unsigned int)
myLanes.size() + by;
1981 while (
myLanes.size() < newLaneNo) {
1986 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
1987 (*i)->invalidateConnections(
true);
1995 unsigned int newLaneNo = (
unsigned int)
myLanes.size() - by;
1996 while (
myLanes.size() > newLaneNo) {
2001 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
2002 (*i)->invalidateConnections(
true);
2008 assert(outs.size() == 1);
2029 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2033 assert(lane < (
int)
myLanes.size());
2034 myLanes[lane].permissions |= vclass;
2042 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2046 assert(lane < (
int)
myLanes.size());
2047 myLanes[lane].permissions &= ~vclass;
2055 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2059 assert(lane < (
int)
myLanes.size());
2060 myLanes[lane].preferred |= vclass;
2070 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2076 assert(lane < (
int)
myLanes.size());
2100 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2106 assert(lane < (
int)
myLanes.size());
2107 myLanes[lane].endOffset = offset;
2116 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2122 assert(lane < (
int)
myLanes.size());
2130 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2135 assert(lane < (
int)
myLanes.size());
2136 myLanes[lane].permissions = permissions;
2144 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2149 assert(lane < (
int)
myLanes.size());
2150 myLanes[lane].preferred = permissions;
2159 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2164 assert(lane < (
int)
myLanes.size());
2165 return myLanes[lane].permissions;
2178 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2179 (*i).permissions =
SVCAll;
2202 for (
int i = start; i != end; i += direction) {
2221 std::cout <<
getID() <<
" angle=" <<
getAngleAtNode(node) <<
" convAngle=" << angle <<
"\n";
2254 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
2255 (*it)->shiftToLanesToEdge(
this, 1);
2267 if ((*it).toEdge == to && (*it).toLane >= 0) {
2268 (*it).toLane += laneOff;
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
SUMOReal length2D() const
bool gDebugFlag1
global utility flags for debugging
void invalidateConnections(bool reallowSetting=false)
The link is a partial left direction.
SUMOReal atan2DegreeAngle() const
const PositionVector & getLaneShape(unsigned int i) const
Returns the shape of the nth lane.
std::vector< Lane > myLanes
Lane information.
static std::pair< SUMOReal, SUMOReal > getNormal90D_CW(const Position &beg, const Position &end, SUMOReal length, SUMOReal wanted_offset)
bool includes(Direction d) const
const Position & p2() const
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.
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
static SUMOReal getCWAngleDiff(SUMOReal angle1, SUMOReal angle2)
Returns the distance of second angle from first angle clockwise.
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
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
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
The relationships between edges are computed/loaded.
void insertAt(int index, const Position &p)
void appendTurnaround(bool noTLSControlled)
Add a connection to the previously computed turnaround, if wished.
PositionVector getCCWBoundaryLine(const NBNode &n, SUMOReal offset) const
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)
std::vector< SUMOReal > distances(const PositionVector &s) const
void moveConnectionToRight(unsigned int lane, const bool buildCrossingsAndWalkingAreas)
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.
PositionVector computeInternalLaneShape(NBEdge *fromE, int fromL, NBEdge *toE, int toL, int numPoints=5) const
Compute the shape for an internal lane.
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.
Position getPositionAtDistance2D(SUMOReal offset) const
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)
bool intersects(const Position &p1, const Position &p2) const
static std::pair< SUMOReal, SUMOReal > laneOffset(const Position &from, const Position &to, SUMOReal laneCenterOffset, bool leftHand)
Computes the offset from the edge shape on the current segment.
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.
void buildInnerEdges(const NBNode &n, unsigned int noInternalNoSplits, unsigned int &linkIndex, unsigned int &splitIndex)
void markAsInLane2LaneState()
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false)
Adds a connection between the specified this edge's lane and an approached one.
Lanes to lanes - relationships are computed; should be recheked.
PositionVector computeLaneShape(unsigned int lane, SUMOReal offset)
Computes the shape for the given lane.
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 ...
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
void computeLaneShapes()
Computes the offset from the edge shape on the current segment.
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
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 isTurningDirectionAt(const NBNode *n, const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
const SVCPermissions SVCAll
void divideOnEdges(const EdgeVector *outgoing, const bool buildCrossingsAndWalkingAreas)
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
PositionVector getCWBoundaryLine(const NBNode &n, SUMOReal offset) const
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
#define UNUSED_PARAMETER(x)
void moveConnectionToLeft(unsigned int lane, const bool buildCrossingsAndWalkingAreas)
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
The connection was computed and validated.
PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode) const
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 setTurningDestination(NBEdge *e)
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.
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
bool recheckLanes(const bool buildCrossingsAndWalkingAreas)
Line lineAt(int pos) const
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)
bool computeLanes2Edges(const bool buildCrossingsAndWalkingAreas)
computes the edge, step2: computation of which lanes approach the edges)
void reshiftPosition(SUMOReal xoff, SUMOReal yoff)
Applies an offset to the edge.
const Position & getPosition() const
Returns the position of this node.
const Position & p1() const
NBEdge * myTurnDestination
The turn destination edge.
const std::map< NBEdge *, std::vector< unsigned int > > & getBuiltConnections() const
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
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
bool myAmLeftHand
Whether this edge is a left-hand edge.
void reshiftRotate(SUMOReal xoff, SUMOReal yoff, SUMOReal rot)
static const int FORWARD
edge directions (for pedestrian related stuff)
std::string tlID
The id of the traffic light that controls this connection.
int getFirstNonPedestrianLaneIndex(int direction) const
return the first lane with permissions other than SVC_PEDESTRIAN
std::string getInternalLaneID() const
int fromLane
The lane the connections starts at.
bool canMoveConnection(const Connection &con, unsigned int newFromLane, const bool buildCrossingsAndWalkingAreas) const
whether the connection can originate on newFromLane
A point in 2D or 3D with translation and scaling methods.
Position pop_front()
Removes and returns the position at the fron of the list.
void add(SUMOReal xoff, SUMOReal yoff, SUMOReal zoff)
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
bool lanesWereAssigned() const
bool needsCont(NBEdge *fromE, NBEdge *toE, NBEdge *otherFromE, NBEdge *otherToE, const NBEdge::Connection &c) const
static bool connections_sorter(const Connection &c1, const Connection &c2)
std::vector< unsigned int > foeInternalLinks
void push_front(const Position &p)
Puts the given position at the front of the list.
unsigned int getNumLanes() const
Returns the number of lanes.
SUMOReal z() const
Returns the z-position.
SUMOReal distance(const Position &p) const
static SUMOReal angle(SUMOReal x1, SUMOReal y1, SUMOReal x2, SUMOReal y2)
SUMOReal myLaneWidth
This width of this edge's lanes.
int myPriority
The priority of the edge.
void init(unsigned int noLanes, bool tryIgnoreNodePositions)
Initialization routines common to all constructors.
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
EdgeBuildingStep myStep
The building step.
unsigned int computePrioritySum(std::vector< unsigned int > *priorities)
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)
static void compute(BresenhamCallBack *callBack, const unsigned int val1, const unsigned int val2)
SUMOReal getEndOffset() const
Returns the offset to the destination node.
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.
bool intersects(const Line &l) const
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.
bool hasRestrictions() const
whether at least one lane has restrictions
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
void extrapolateBy(SUMOReal length)
SUMOReal length() const
Returns the length.
void push_back(const PositionVector &p)
Appends all positions from the given vector.
static const int BACKWARD
std::string myID
The name of the object.
void decLaneNo(unsigned int by, int dir=0)
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 getMaxLaneOffset()
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
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.
static SUMOReal getMinAngleDiff(SUMOReal angle1, SUMOReal angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
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)
unsigned int tlLinkNo
The index of this connection within the controlling traffic light.
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.
SUMOReal myStartAngle
The angles of the edge.
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)
void move2side(SUMOReal amount)
NBEdge * getTurnDestination() const
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)
Direction
enum of possible directions
bool isNearEnough2BeJoined2(NBEdge *e, SUMOReal threshold) const
void preferVehicleClass(int lane, SUMOVehicleClass vclass)
static SUMOReal relAngle(SUMOReal angle1, SUMOReal angle2)
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.
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
static T maxValue(const std::vector< T > &v)
std::vector< SUMOReal > intersectsAtLengths2D(const PositionVector &v)
void setConnection(unsigned int lane, NBEdge *destEdge, unsigned int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false)
Adds a connection to a certain lane of a certain edge.
unsigned int internalLaneIndex
The lane index of this internal lane within the internal edge.
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)
void append(const PositionVector &v)
NBNode * myFrom
The source and the destination node.
bool expandableBy(NBEdge *possContinuation) const
Position intersectsAt(const Line &l) const
PositionVector getSubpart(SUMOReal beginOffset, SUMOReal endOffset) const
~MainDirections()
destructor
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to)
constructor
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 anglen
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.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing) const
Returns the representation of the described stream's direction.
NBNode * getFromNode() const
Returns the origin node of the edge.
bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc)
Splits this edge at geometry points.