57 #ifdef CHECK_MEMORY_LEAKS
59 #endif // CHECK_MEMORY_LEAKS
81 std::vector<unsigned int> lanes;
85 std::map<NBEdge*, std::vector<unsigned int> >::iterator i =
myConnections.find(succEdge);
93 std::vector<unsigned int>::iterator j = find(lanes.begin(), lanes.end(), lane);
94 if (j == lanes.end()) {
96 lanes.push_back(lane);
109 if (outgoing.size() == 0) {
113 assert(outgoing.size() > 0);
118 if (outgoing.back()->getJunctionPriority(to) == 1) {
124 if (outgoing.back()->getPriority() > tmp[0]->getPriority()) {
127 if (outgoing.back()->getNumLanes() > tmp[0]->getNumLanes()) {
136 NBEdge* edge = *(tmp.begin());
149 return myDirs.empty();
155 return find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
175 std::string type,
SUMOReal speed,
unsigned int nolanes,
177 const std::string& streetName,
191 init(nolanes,
false);
196 std::string type,
SUMOReal speed,
unsigned int nolanes,
199 const std::string& streetName,
204 myFrom(from), myTo(to),
205 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
206 myPriority(priority), mySpeed(speed),
207 myTurnDestination(0),
208 myFromJunctionPriority(-1), myToJunctionPriority(-1),
209 myGeom(geom), myLaneSpreadFunction(spread), myOffset(offset), myLaneWidth(laneWidth),
210 myLoadedLength(UNSPECIFIED_LOADED_LENGTH), myAmLeftHand(false),
211 myAmInnerEdge(false), myAmMacroscopicConnector(false),
212 myStreetName(streetName) {
213 init(nolanes, tryIgnoreNodePositions);
220 myType(tpl->getTypeID()),
221 myFrom(from), myTo(to),
222 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
223 myPriority(tpl->getPriority()), mySpeed(tpl->getSpeed()),
224 myTurnDestination(0),
225 myFromJunctionPriority(-1), myToJunctionPriority(-1),
226 myLaneSpreadFunction(tpl->getLaneSpreadFunction()),
227 myOffset(tpl->getOffset()),
228 myLaneWidth(tpl->getLaneWidth()),
229 myLoadedLength(UNSPECIFIED_LOADED_LENGTH), myAmLeftHand(false),
230 myAmInnerEdge(false), myAmMacroscopicConnector(false),
231 myStreetName(tpl->getStreetName()) {
242 SUMOReal speed,
unsigned int nolanes,
int priority,
244 const std::string& streetName,
246 bool tryIgnoreNodePositions) {
268 init(nolanes, tryIgnoreNodePositions);
275 if (from == 0 || to == 0) {
276 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
297 throw ProcessError(
"At least one of edge's '" +
myID +
"' nodes is not known.");
303 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
318 WRITE_ERROR(
"Edge's '" +
myID +
"' from- and to-node are at the same position.");
326 assert(
myGeom.size() >= 2);
328 for (
unsigned int i = 0; i < noLanes; i++) {
343 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
344 myLanes[i].shape.reshiftRotate(xoff, yoff, 0);
388 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
392 if (shape.size() >= 2) {
403 assert(shape.size() >= 2);
404 assert(shape.
length() > 0);
409 Line lc(shape[0], shape[-1]);
410 Line lo(old[0], old[-1]);
419 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
420 assert(
myLanes[i].shape.length() > 0);
421 avgLength +=
myLanes[i].shape.length();
436 assert(pbv.size() > 0);
440 ns[0].set(ns[0].x(), ns[0].y(), startNode->
getPosition().
z());
445 assert(pbv.size() > 0);
496 NBEdge* currentEdge =
this;
497 for (
int i = 1; i < (
int)
myGeom.size() - 1; i++) {
499 if (i != (
int)
myGeom.size() - 2) {
500 std::string nodename =
myID +
"_in_between#" +
toString(i);
502 throw ProcessError(
"Error on adding in-between node '" + nodename +
"'.");
510 currentEdge->
myTo = newTo;
513 std::string edgename =
myID +
"[" +
toString(i - 1) +
"]";
517 if (!ec.
insert(currentEdge,
true)) {
518 throw ProcessError(
"Error on adding splitted edge '" + edgename +
"'.");
543 std::vector<SUMOReal> angles;
545 for (
int i = 0; i < (
int)
myGeom.size() - 1; ++i) {
550 for (
int i = 0; i < (
int)angles.size() - 1; ++i) {
553 if (maxAngle > 0 && relAngle > maxAngle) {
559 if (i == 0 || i == (
int)angles.size() - 2) {
560 const bool start = i == 0;
564 if (minRadius > 0 && r < minRadius) {
567 (start ?
"start" :
"end") +
" of edge " +
getID());
573 (start ?
"start" :
"end") +
" of edge " +
getID());
610 bool mayUseSameDestination,
611 bool mayDefinitelyPass) {
624 setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass);
631 NBEdge* dest,
unsigned int toLane,
633 bool invalidatePrevious,
634 bool mayDefinitelyPass) {
635 if (invalidatePrevious) {
639 for (
unsigned int i = 0; i < no && ok; i++) {
649 bool mayUseSameDestination,
650 bool mayDefinitelyPass) {
678 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
685 if (mayDefinitelyPass) {
705 std::vector<NBEdge::Connection>
707 std::vector<NBEdge::Connection> ret;
709 if ((*i).fromLane == static_cast<int>(lane)) {
744 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
745 outgoing.push_back((*i).toEdge);
750 unsigned int size = (
unsigned int) outgoing.size();
752 edges->reserve(size);
753 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
756 edges->push_back(outedge);
768 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
769 ret.push_back((*i).toEdge);
778 std::vector<int> ret;
781 if ((*i).toEdge == currentOutgoing) {
782 ret.push_back((*i).fromLane);
805 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
810 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
824 && (fromLane < 0 || c.
fromLane == fromLane)
825 && (toLane < 0 || c.
toLane == toLane)) {
846 if (reallowSetting) {
859 if ((*i).toEdge == which) {
871 std::map<int, int> laneMap;
875 bool wasConnected =
false;
877 if ((*i).toEdge != which) {
881 if ((*i).fromLane != -1) {
882 int fromLane = (*i).fromLane;
883 laneMap[(*i).toLane] = fromLane;
884 if (minLane == -1 || minLane > fromLane) {
887 if (maxLane == -1 || maxLane < fromLane) {
898 std::vector<NBEdge::Connection> conns = origConns;
899 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
900 if ((*i).toEdge == which) {
903 int fromLane = (*i).fromLane;
905 if (laneMap.find(fromLane) == laneMap.end()) {
906 if (fromLane >= 0 && fromLane <= minLane) {
909 if (fromLane >= 0 && fromLane >= maxLane) {
913 toUse = laneMap[fromLane];
932 unsigned int index = 0;
946 std::vector<Connection>::iterator i =
myConnections.begin() + index;
966 if ((*i).fromLane == static_cast<int>(lane)) {
987 std::string innerID =
":" + n.
getID();
998 std::pair<SUMOReal, std::vector<unsigned int> > crossingPositions(-1, std::vector<unsigned int>());
999 std::string foeInternalLanes;
1000 std::set<std::string> tmpFoeIncomingLanes;
1005 unsigned int index = 0;
1007 for (EdgeVector::const_iterator i2 = incoming.begin(); i2 != incoming.end(); ++i2) {
1008 const std::vector<Connection>& elv = (*i2)->getConnections();
1009 for (std::vector<NBEdge::Connection>::const_iterator k2 = elv.begin(); k2 != elv.end(); k2++) {
1010 if ((*k2).toEdge == 0) {
1013 bool needsCont = n.
needsCont(
this, con.
toEdge, *i2, (*k2).toEdge, *k2);
1016 crossingPositions.second.push_back(index);
1019 if (dv.size() > 0) {
1021 if (minDV < shape.
length() - .1 && minDV > .1) {
1023 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1024 crossingPositions.first = minDV;
1030 if (n.
foes(
this, con.
toEdge, *i2, (*k2).toEdge)) {
1031 if (foeInternalLanes.length() != 0) {
1032 foeInternalLanes +=
" ";
1034 foeInternalLanes += (
":" + n.
getID() +
"_" +
toString(index) +
"_0");
1039 tmpFoeIncomingLanes.insert((*i2)->getID() +
"_" +
toString((*k2).fromLane));
1044 if (dir ==
LINKDIR_TURN && crossingPositions.first < 0 && crossingPositions.second.size() != 0) {
1067 assert(shape.size() >= 2);
1069 if (crossingPositions.first >= 0) {
1070 std::pair<PositionVector, PositionVector> split = shape.
splitAt(crossingPositions.first);
1073 con.
shape = split.first;
1077 for (std::set<std::string>::iterator q = tmpFoeIncomingLanes.begin(); q != tmpFoeIncomingLanes.end(); ++q) {
1083 con.
viaID = innerID +
"_" +
toString(splitNo + noInternalNoSplits);
1126 assert(atNode ==
myTo);
1151 std::vector<SUMOReal> offsets;
1152 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1153 offsets.push_back(0);
1156 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
1158 offsets[i] = offset;
1166 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1172 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1173 offsets[i] += offset;
1180 for (
unsigned int i = 0; i <
myLanes.size(); ++i) {
1184 WRITE_WARNING(
"In edge '" +
getID() +
"': lane shape could not be determined (" + e.what() +
")");
1194 bool haveWarned =
false;
1195 for (
int i = 0; i < (
int)
myGeom.size(); i++) {
1199 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, to, offset,
false);
1202 Position(from.
x() - offsets.first, from.
y() - offsets.second, from.
z()));
1203 }
else if (i == static_cast<int>(
myGeom.size() - 1)) {
1206 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, to, offset,
false);
1209 Position(to.
x() - offsets.first, to.
y() - offsets.second, to.
z()));
1214 std::pair<SUMOReal, SUMOReal> offsets =
laneOffset(from, me, offset,
false);
1215 std::pair<SUMOReal, SUMOReal> offsets2 =
laneOffset(me, to, offset,
false);
1217 Position(from.
x() - offsets.first, from.
y() - offsets.second),
1218 Position(me.
x() - offsets.first, me.
y() - offsets.second));
1221 Position(me.
x() - offsets2.first, me.
y() - offsets2.second),
1222 Position(to.
x() - offsets2.first, to.
y() - offsets2.second));
1224 if (angle < 10. || angle > 350.) {
1227 Position(me.
x() - offsets.first, me.
y() - offsets.second, me.
z()));
1252 std::pair<SUMOReal, SUMOReal>
1256 return std::pair<SUMOReal, SUMOReal>(-offsets.first, -offsets.second);
1258 return std::pair<SUMOReal, SUMOReal>(offsets.first, offsets.second);
1271 referencePosStart.
x(), referencePosStart.
y());
1274 referencePosEnd.x(), referencePosEnd.y(),
1284 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1295 std::vector<Lane>::const_iterator i =
myLanes.begin();
1298 for (; i !=
myLanes.end(); ++i) {
1299 if (i->permissions != firstLanePermissions) {
1309 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1310 if (i->width !=
myLanes.begin()->width) {
1320 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1331 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
1332 if (i->offset !=
myLanes.begin()->offset) {
1356 for (EdgeVector::const_iterator i = o.begin(); i != o.end(); ++i) {
1394 std::vector<unsigned int> connNumbersPerLane(
myLanes.size(), 0);
1396 if ((*i).toEdge == 0 || (*i).fromLane < 0 || (*i).toLane < 0) {
1399 if ((*i).fromLane >= 0) {
1400 ++connNumbersPerLane[(*i).fromLane];
1411 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1412 if (connNumbersPerLane[i] == 0) {
1413 if (i > 0 && connNumbersPerLane[i - 1] > 1) {
1415 }
else if (i <
myLanes.size() - 1 && connNumbersPerLane[i + 1] > 1) {
1431 if (outgoing->size() == 0) {
1444 unsigned int size = (
unsigned int) outgoing->size();
1445 std::vector<SUMOReal> resultingLanes;
1446 resultingLanes.reserve(size);
1450 for (i = 0; i < size; i++) {
1461 resultingLanes.push_back(res);
1462 sumResulting += res;
1463 if (minResulting > res) {
1471 sumResulting += minResulting / (
SUMOReal) 2.;
1472 unsigned int noVirtual = (
unsigned int)(sumResulting / minResulting);
1475 transition.reserve(size);
1476 for (i = 0; i < size; i++) {
1479 assert(i < resultingLanes.size());
1481 for (
SUMOReal j = 0; j < tmpNo; j++) {
1482 assert(outgoing->size() > i);
1483 transition.push_back((*outgoing)[i]);
1491 const std::map<NBEdge*, std::vector<unsigned int> >& l2eConns = adder.
getBuiltConnections();
1493 for (std::map<
NBEdge*, std::vector<unsigned int> >::const_iterator i = l2eConns.begin(); i != l2eConns.end(); ++i) {
1494 const std::vector<unsigned int> lanes = (*i).second;
1495 for (std::vector<unsigned int>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
1507 std::vector<unsigned int>*
1510 std::vector<unsigned int>* priorities =
new std::vector<unsigned int>();
1511 if (outgoing->size() == 0) {
1514 priorities->reserve(outgoing->size());
1515 EdgeVector::const_iterator i;
1516 for (i = outgoing->begin(); i != outgoing->end(); i++) {
1517 int prio = (*i)->getJunctionPriority(
myTo);
1518 assert((prio + 1) * 2 > 0);
1519 prio = (prio + 1) * 2;
1520 priorities->push_back(prio);
1528 i = find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
1529 unsigned int dist = (
unsigned int) distance(outgoing->begin(), i);
1531 assert(priorities->size() > 0);
1532 (*priorities)[0] = (*priorities)[0] / 2;
1537 if (mainDirections.
empty()) {
1538 assert(dist < priorities->size());
1539 (*priorities)[dist] = (*priorities)[dist] * 2;
1542 (*priorities)[dist] = (*priorities)[dist] * 2;
1551 unsigned int sum = 0;
1552 for (std::vector<unsigned int>::iterator i = priorities->begin(); i != priorities->end(); i++) {
1591 if (thisFromAngle2 < otherToAngle2) {
1592 std::swap(thisFromAngle2, otherToAngle2);
1594 if (thisFromAngle2 - otherToAngle2 > 170 && thisFromAngle2 - otherToAngle2 < 190) {
1605 if (pos < tolerance) {
1619 for (
unsigned int i = 0; i < lanes; i++) {
1621 for (std::vector<NBEdge::Connection>::iterator j = elv.begin(); j != elv.end(); j++) {
1623 assert(el.
tlID ==
"");
1670 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
1672 if (fromLane >= 0 && toLane >= 0) {
1674 std::vector<Connection>::iterator i =
1682 connection.
tlID = tlID;
1689 unsigned int no = 0;
1690 bool hadError =
false;
1692 if ((*i).toEdge != toEdge) {
1695 if (fromLane >= 0 && fromLane != (*i).fromLane) {
1698 if (toLane >= 0 && toLane != (*i).toLane) {
1701 if ((*i).tlID ==
"") {
1703 (*i).tlLinkNo = tlIndex;
1706 if ((*i).tlID != tlID && static_cast<int>((*i).tlLinkNo) == tlIndex) {
1707 WRITE_WARNING(
"The lane " + toString<int>((*i).fromLane) +
" on edge " +
getID() +
" already had a traffic light signal.");
1712 if (hadError && no == 0) {
1713 WRITE_WARNING(
"Could not set any signal of the traffic light '" + tlID +
"' (unknown group)");
1806 if (find(conn.begin(), conn.end(), possContinuation)
1823 if (conns.size() !=
myLanes.size()) {
1839 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1859 if ((*i).toEdge == e && (*i).tlID !=
"") {
1875 assert(lane <
myLanes.size());
1889 assert(distances.size() > 0);
1896 unsigned int newLaneNo = (
unsigned int)
myLanes.size() + by;
1897 while (
myLanes.size() < newLaneNo) {
1902 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
1903 (*i)->invalidateConnections(
true);
1911 unsigned int newLaneNo = (
unsigned int)
myLanes.size() - by;
1912 while (
myLanes.size() > newLaneNo) {
1917 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
1918 (*i)->invalidateConnections(
true);
1924 assert(outs.size() == 1);
1945 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1949 assert(lane < (
int)
myLanes.size());
1950 myLanes[lane].permissions |= vclass;
1958 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1962 assert(lane < (
int)
myLanes.size());
1963 myLanes[lane].permissions &= ~vclass;
1971 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1975 assert(lane < (
int)
myLanes.size());
1976 myLanes[lane].preferred |= vclass;
1986 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
1992 assert(lane < (
int)
myLanes.size());
2016 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2022 assert(lane < (
int)
myLanes.size());
2023 myLanes[lane].offset = offset;
2032 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2038 assert(lane < (
int)
myLanes.size());
2046 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2051 assert(lane < (
int)
myLanes.size());
2052 myLanes[lane].permissions = permissions;
2060 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2065 assert(lane < (
int)
myLanes.size());
2066 myLanes[lane].preferred = permissions;
2075 for (
unsigned int i = 0; i <
myLanes.size(); i++) {
2080 assert(lane < (
int)
myLanes.size());
2081 return myLanes[lane].permissions;
2094 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
SUMOReal length2D() const
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
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.
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
std::vector< unsigned int > * preparePriorities(const EdgeVector *outgoing)
std::string foeIncomingLanes
bool insert(const std::string &id, const Position &position, NBDistrict *district)
Inserts a node into the map.
const SUMOReal SUMO_const_laneWidth
std::vector< TLSDisabledConnection > myTLSDisabledConnections
std::string foeInternalLanes
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.
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
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
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 setOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
void moveOutgoingConnectionsFrom(NBEdge *e, unsigned int laneOff)
const SUMOReal SUMO_const_laneWidthAndOffset
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.
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.
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 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.
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
void buildInnerEdges(const NBNode &n, unsigned int noInternalNoSplits, unsigned int &lno, unsigned int &splitNo)
const SUMOReal SUMO_const_laneOffset
bool isTurningDirectionAt(const NBNode *n, const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
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
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
#define UNUSED_PARAMETER(x)
const EdgeVector & myTransitions
the transition from the virtual lane to the edge it belongs to
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 moveConnectionToRight(unsigned int lane)
void setTurningDestination(NBEdge *e)
An (internal) definition of a single lane of an edge.
const std::string & getID() const
Returns the id.
SUMOReal mySpeed
The maximal speed.
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
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)
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
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
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
void moveConnectionToLeft(unsigned int lane)
bool myAmLeftHand
Whether this edge is a left-hand edge.
void reshiftRotate(SUMOReal xoff, SUMOReal yoff, SUMOReal rot)
std::string tlID
The id of the traffic light that controls this connection.
int fromLane
The lane the connections starts at.
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
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.
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)
SUMOReal myOffset
This edges's offset to the intersection begin (will be applied to all lanes)
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
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)
const SVCPermissions SVCFreeForAll
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
std::map< NBEdge *, std::vector< unsigned int > > myConnections
map of edges to this edge's lanes that reach them
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
void extrapolateBy(SUMOReal length)
SUMOReal length() const
Returns the length.
void push_back(const PositionVector &p)
Appends all positions from the given vector.
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)
bool hasLaneSpecificOffset() const
whether lanes differ in offset
SUMOReal getMaxLaneOffset()
static bool connections_sorter(const Connection &c1, const Connection &c2)
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
Position positionAtOffset2D(SUMOReal pos) const
Returns the position at the given length.
std::vector< NBEdge * > EdgeVector
SUMOReal myLength
The length of the edge.
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
The edge has been loaded and connections shall not be added.
int getToLane() const
returns the to-lane
SUMOReal y() const
Returns the y-position.
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
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.
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
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
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.
void move2side(SUMOReal amount)
NBEdge * getTurnDestination() const
bool hasLaneSpecificWidth() const
whether lanes differ in width
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.
bool hasConnectionTo(NBEdge *destEdge, unsigned int destLane) const
Retrieves info about a connection to a certain lane of a certain edge.
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.
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
SUMOReal getOffset() const
Returns the offset to the destination node.
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 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.
bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc)
Splits this edge at geometry points.