60 myVehicleClasses2Keep(0),
61 myVehicleClasses2Remove(0),
62 myNeedGeoTransformedPruningBoundary(false) {
77 if (oc.
isSet(
"keep-edges.input-file")) {
80 if (oc.
isSet(
"remove-edges.input-file")) {
83 if (oc.
isSet(
"keep-edges.explicit")) {
84 const std::vector<std::string> edges = oc.
getStringVector(
"keep-edges.explicit");
87 if (oc.
isSet(
"remove-edges.explicit")) {
88 const std::vector<std::string> edges = oc.
getStringVector(
"remove-edges.explicit");
91 if (oc.
exists(
"keep-edges.by-vclass") && oc.
isSet(
"keep-edges.by-vclass")) {
94 if (oc.
exists(
"remove-edges.by-vclass") && oc.
isSet(
"remove-edges.by-vclass")) {
97 if (oc.
exists(
"keep-edges.by-type") && oc.
isSet(
"keep-edges.by-type")) {
98 const std::vector<std::string> types = oc.
getStringVector(
"keep-edges.by-type");
101 if (oc.
exists(
"remove-edges.by-type") && oc.
isSet(
"remove-edges.by-type")) {
102 const std::vector<std::string> types = oc.
getStringVector(
"remove-edges.by-type");
106 if (oc.
isSet(
"keep-edges.in-boundary") || oc.
isSet(
"keep-edges.in-geo-boundary")) {
108 "keep-edges.in-boundary" :
"keep-edges.in-geo-boundary");
110 std::vector<double> poly;
111 for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) {
114 if (poly.size() < 4) {
115 throw ProcessError(
"Invalid boundary: need at least 2 coordinates");
116 }
else if (poly.size() % 2 != 0) {
117 throw ProcessError(
"Invalid boundary: malformed coordinate");
118 }
else if (poly.size() == 4) {
125 for (std::vector<double>::iterator j = poly.begin(); j != poly.end();) {
138 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
163 if (oc.
exists(
"dismiss-vclasses") && oc.
getBool(
"dismiss-vclasses")) {
229 WRITE_ERROR(
"Cannot prune edges using a geo-boundary because no projection has been loaded");
246 EdgeCont::const_iterator i =
myEdges.find(
id);
248 if (retrieveExtracted) {
283 if (edge !=
nullptr) {
287 if ((
retrieve(
id +
"[0]") !=
nullptr) && (
retrieve(
id +
"[1]") !=
nullptr)) {
289 if (downstream ==
true) {
303 if (edge !=
nullptr) {
310 if (hintedge ==
nullptr) {
313 hints.push_back(hintedge);
316 for (EdgeVector::iterator i = hints.begin(); i != hints.end(); i++) {
318 for (EdgeVector::iterator j = candidates.begin(); j != candidates.end(); j++) {
319 NBEdge* poss_searched = (*j);
321 ? poss_searched->
myTo : poss_searched->
myFrom;
324 if (find(cont.begin(), cont.end(), hintedge) != cont.end()) {
325 return poss_searched;
337 if (edge !=
nullptr) {
341 std::string tid =
id +
"[";
342 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
343 if ((*i).first.find(tid) == 0) {
344 maxLength =
MAX2(maxLength, (
int)(*i).first.length());
349 std::vector<std::string> names;
350 names.push_back(
id +
"[1]");
351 names.push_back(
id +
"[0]");
352 while (names.size() > 0) {
354 std::string cid = names.back();
359 if (edge ==
nullptr) {
360 if ((
int)cid.length() + 3 < maxLength) {
361 names.push_back(cid +
"[1]");
362 names.push_back(cid +
"[0]");
399 if (
myEdges.count(newID) != 0) {
400 throw ProcessError(
"Attempt to rename edge using existing id '" + newID +
"'");
413 if (splits.size() == 0) {
416 const std::string origID = e->
getID();
417 std::vector<Split>::iterator i;
421 for (i = splits.begin(); i != splits.end(); ++i) {
422 sort((*i).lanes.begin(), (*i).lanes.end());
423 noLanesMax =
MAX2(noLanesMax, (
int)(*i).lanes.size());
426 std::vector<int> currLanes;
428 currLanes.push_back(l);
430 if (e->
getNumLanes() != (int)splits.back().lanes.size()) {
438 std::string firstID =
"";
440 for (i = splits.begin(); i != splits.end(); ++i) {
441 const Split& exp = *i;
442 assert(exp.
lanes.size() != 0);
455 WRITE_WARNING(
"Error on parsing a split (edge '" + origID +
"').");
458 std::vector<int> newLanes = exp.
lanes;
464 int rightMostP = currLanes[0];
465 int rightMostN = newLanes[0];
466 for (
int l = 0; l < (int) rightMostP - (
int) rightMostN; ++l) {
470 int leftMostP = currLanes.back();
471 int leftMostN = newLanes.back();
472 for (
int l = 0; l < (int) leftMostN - (
int) leftMostP; ++l) {
476 for (
int l = 0; l < noLanesMax; ++l) {
477 if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
480 if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
491 in->invalidateConnections(
true);
496 currLanes = newLanes;
497 }
else if (exp.
pos == 0) {
499 if (laneCountDiff < 0) {
504 currLanes = exp.
lanes;
514 if (splits.front().pos != 0) {
518 for (
int lane = 0; lane < (int)e->
getNumLanes(); ++lane) {
519 start.
lanes.push_back(lane);
521 start.
offset = splits.front().offset;
523 splits.insert(splits.begin(), start);
527 for (; i != splits.end(); ++i) {
528 int maxLeft = (*i).lanes.back();
529 double offset = (*i).offset;
530 if (maxLeft < noLanesMax) {
537 int maxRight = (*i).lanes.front();
564 const std::string& firstEdgeName,
565 const std::string& secondEdgeName,
566 int noLanesFirstEdge,
int noLanesSecondEdge,
568 const int changedLeft) {
579 return splitAt(dc, edge, pos, node, firstEdgeName, secondEdgeName,
580 noLanesFirstEdge, noLanesSecondEdge, speed, changedLeft);
587 const std::string& firstEdgeName,
588 const std::string& secondEdgeName,
589 int noLanesFirstEdge,
int noLanesSecondEdge,
591 const int changedLeft
594 assert(changedLeft > -((
int)noLanesFirstEdge));
595 assert(changedLeft < (
int)noLanesSecondEdge);
598 std::pair<PositionVector, PositionVector> geoms =
601 geoms.first.pop_back();
609 NBEdge* one =
new NBEdge(firstEdgeName, edge->
myFrom, node, edge, geoms.first, noLanesFirstEdge);
610 NBEdge* two =
new NBEdge(secondEdgeName, node, edge->
myTo, edge, geoms.second, noLanesSecondEdge);
613 if (firstEdgeName != origID) {
616 if (secondEdgeName != origID) {
629 for (std::set<NBTrafficLightDefinition*>::iterator i = fromTLS.begin(); i != fromTLS.end(); ++i) {
630 (*i)->replaceRemoved(edge, -1, one, -1);
633 for (std::set<NBTrafficLightDefinition*>::iterator i = toTLS.begin(); i != toTLS.end(); ++i) {
634 (*i)->replaceRemoved(edge, -1, two, -1);
645 for (
int i2 = 0; i2 < (int)two->
getNumLanes(); i2++) {
674 std::set<EdgeSet> addLater;
675 for (std::set<EdgeSet>::iterator it = roundabouts.begin(); it != roundabouts.end(); ++it) {
677 if (roundaboutSet.count(orig) > 0) {
678 roundaboutSet.erase(orig);
679 roundaboutSet.insert(part1);
680 roundaboutSet.insert(part2);
682 addLater.insert(roundaboutSet);
685 roundabouts.insert(addLater.begin(), addLater.end());
690 std::vector<std::string>
692 std::vector<std::string> ret;
693 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
694 ret.push_back((*i).first);
704 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
705 NBEdge* edge = (*i).second;
709 toRemove.push_back(edge);
712 for (EdgeVector::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
720 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
721 if ((*i).second->getGeometry().size() < 3) {
724 (*i).second->splitGeometry(*
this, nc);
731 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
732 (*i).second->reduceGeometry(minDist);
739 if (maxAngle > 0 || minRadius > 0) {
740 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
741 (*i).second->checkGeometry(maxAngle, minRadius, fix);
750 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
751 (*i).second->clearControllingTLInformation();
758 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
759 (*i).second->sortOutgoingConnectionsByAngle();
766 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
767 (*i).second->computeEdge2Edges(noLeftMovers);
774 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
775 (*i).second->computeLanes2Edges();
783 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
788 const std::string& oppositeID = edge->
getLanes().back().oppositeID;
789 if (oppositeID !=
"" && oppositeID !=
"-") {
790 NBEdge* oppEdge =
retrieve(oppositeID.substr(0, oppositeID.rfind(
"_")));
792 WRITE_WARNING(
"Removing unknown opposite lane '" + oppositeID +
"' for edge '" + edge->
getID() +
"'.");
797 if (fixOppositeLengths) {
811 WRITE_ERROR(
"Opposite lane '" + oppositeID +
"' does not connect the same nodes as edge '" + edge->
getID() +
"'!");
822 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
823 (*i).second->appendTurnaround(noTLSControlled, onlyDeadends,
true);
830 for (std::set<std::string>::const_iterator it = ids.begin(); it != ids.end(); it++) {
831 myEdges[*it]->appendTurnaround(noTLSControlled,
false,
false);
838 std::set<std::string> stopEdgeIDs;
839 for (
auto& stopItem : sc.
getStops()) {
840 stopEdgeIDs.insert(stopItem.second->getEdgeId());
843 NBEdge* edge = item.second;
845 && (stopEdgeIDs.count(item.first) > 0 ||
859 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
860 (*i).second->computeEdgeShape(smoothElevationThreshold);
867 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
868 (*i).second->computeLaneShapes();
889 NBEdge* tpledge = *(edges.begin());
890 NBNode* from = tpledge->getFromNode();
891 NBNode* to = tpledge->getToNode();
892 EdgeVector::const_iterator i;
893 for (i = edges.begin(); i != edges.end(); i++) {
895 assert((*i)->getFromNode() == from);
896 assert((*i)->getToNode() == to);
898 nolanes += (*i)->getNumLanes();
900 if (i != edges.begin()) {
905 speed += (*i)->getSpeed();
907 priority =
MAX2(priority, (*i)->getPriority());
909 speed /= edges.size();
911 NBEdge* newEdge =
new NBEdge(
id, from, to,
"", speed, nolanes, priority,
913 tpledge->getStreetName(), tpledge->myLaneSpreadFunction);
916 for (i = edges.begin(); i != edges.end(); ++i) {
917 const std::vector<NBEdge::Lane>& lanes = (*i)->
getLanes();
918 for (
int j = 0; j < (int)lanes.size(); ++j) {
932 for (i = edges.begin(); i != edges.end(); i++) {
934 for (EdgeVector::iterator j = ev.begin(); j != ev.end(); j++) {
940 for (i = edges.begin(); i != edges.end(); i++) {
942 currLane += (*i)->getNumLanes();
946 for (i = edges.begin(); i != edges.end(); i++) {
947 int noLanes = (*i)->getNumLanes();
948 for (
int j = 0; j < noLanes; j++, currLane++) {
954 for (i = edges.begin(); i != edges.end(); i++) {
963 const double distanceThreshold = 7;
964 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
970 NBEdge* opposite =
nullptr;
973 if ((*j)->getToNode() == edge->
getFromNode() && !(*j)->getLanes().empty()) {
975 if (distance < distanceThreshold) {
981 if (opposite !=
nullptr) {
992 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
994 if (opposite !=
nullptr) {
1006 const std::string oppositeID = edgeID[0] ==
'-' ? edgeID.substr(1) :
"-" + edgeID;
1007 EdgeCont::const_iterator it =
myEdges.find(oppositeID);
1013 EdgeCont::const_iterator it =
myEdges.find(edgeID);
1020 bool keepClear,
double contPos,
double visibility,
double speed,
1022 myConnections.push_back(
PostProcessConnection(from, fromLane, to, toLane, mayDefinitelyPass, keepClear, contPos, visibility, speed, customShape, warnOnly));
1032 if (from ==
nullptr || to ==
nullptr ||
1034 (*i).keepClear, (*i).contPos, (*i).visibility, (*i).speed, (*i).customShape)) {
1035 const std::string msg =
"Could not insert connection between '" + (*i).from +
"' and '" + (*i).to +
"' after build.";
1036 if (warnOnly || (*i).warnOnly) {
1045 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); ++it) {
1046 NBEdge* edge = it->second;
1049 std::vector<NBEdge::Connection> connections = edge->
getConnections();
1050 for (std::vector<NBEdge::Connection>::iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
1054 "' to edge '" + c.
toEdge->
getID() +
"' via junction '" + to->
getID() +
"'.");
1064 int len = (int)
id.length();
1066 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1067 std::string curr = (*i).first;
1070 if ((
int)curr.length() <= len) {
1075 if (curr.substr(0, len) ==
id && curr[len] ==
'[') {
1076 ret.push_back((*i).second);
1080 std::string::size_type pos = curr.find(
id);
1082 if (pos == std::string::npos) {
1087 if (curr[pos - 1] !=
']' && curr[pos - 1] !=
'+') {
1092 if (pos +
id.length() < curr.length()) {
1093 if (curr[pos +
id.length()] !=
'[' && curr[pos +
id.length()] !=
'+') {
1098 ret.push_back((*i).second);
1107 std::set<NBEdge*> loadedRoundaboutEdges;
1109 loadedRoundaboutEdges.insert(it->begin(), it->end());
1113 std::set<NBEdge*> candidates;
1114 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1118 candidates.insert(e);
1123 std::set<NBEdge*> visited;
1124 for (std::set<NBEdge*>::const_iterator i = candidates.begin(); i != candidates.end(); ++i) {
1131 if (visited.count(e) > 0) {
1135 loopEdges.push_back(e);
1140 if (edges.size() < 2) {
1149 EdgeVector::const_iterator me = find(edges.begin(), edges.end(), e);
1158 EdgeVector::const_iterator loopClosed = find(loopEdges.begin(), loopEdges.end(), left);
1159 const int loopSize = (int)(loopEdges.end() - loopClosed);
1164 }
else if (loopSize < (
int)loopEdges.size()) {
1166 EdgeVector(loopEdges.begin() + (loopEdges.size() - loopSize), loopEdges.end()).swap(loopEdges);
1169 int attachments = 0;
1170 for (EdgeVector::const_iterator j = loopEdges.begin(); j != loopEdges.end(); ++j) {
1171 if ((*j)->getToNode()->getEdges().size() > 2) {
1175 if (attachments < 3) {
1180 if (visited.count(left) > 0) {
1184 loopEdges.push_back(left);
1203 for (EdgeVector::const_iterator it = loopEdges.begin(); it != loopEdges.end(); ++it) {
1204 points.
append((*it)->getGeometry());
1206 double circumference = points.
length2D();
1207 return 4 *
M_PI * points.
area() / (circumference * circumference);
1211 const std::set<EdgeSet>
1221 if (roundabout.size() > 0) {
1234 for (std::set<EdgeSet>::const_iterator it = roundabouts.begin(); it != roundabouts.end(); ++it) {
1235 const EdgeSet roundaboutSet = *it;
1236 for (std::set<NBEdge*>::const_iterator j = roundaboutSet.begin(); j != roundaboutSet.end(); ++j) {
1238 NBNode* node = (*j)->getToNode();
1240 for (EdgeVector::const_iterator k = incoming.begin(); k != incoming.end(); ++k) {
1242 if (roundaboutSet.count(inEdge) > 0) {
1260 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1300 int sidewalksCreated = 0;
1302 std::set<std::string> exclude(edges.begin(), edges.end());
1303 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1304 NBEdge* edge = it->second;
1306 exclude.count(edge->
getID()) == 0
1313 || (!fromPermissions && edge->
getSpeed() > minSpeed && edge->
getSpeed() <= maxSpeed)
1316 sidewalksCreated += 1;
1319 return sidewalksCreated;
1326 std::set<std::string> reserve;
1329 avoid.insert(avoid.end(), reserve.begin(), reserve.end());
1332 std::set<NBEdge*, ComparatorIdLess> toChange;
1333 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1338 toChange.insert(it->second);
1341 if (reservedIDs && reserve.count(it->first) > 0) {
1342 toChange.insert(it->second);
1346 std::map<std::string, std::vector<NBPTStop*> > stopsOnEdge;
1347 for (
const auto& item : sc.
getStops()) {
1348 stopsOnEdge[item.second->getEdgeId()].push_back(item.second);
1352 for (std::set<NBEdge*, ComparatorIdLess>::iterator it = toChange.begin(); it != toChange.end(); ++it) {
1354 const std::string origID = edge->
getID();
1361 for (
NBPTStop* stop : stopsOnEdge[origID]) {
1362 stop->setEdgeId(prefix + edge->
getID(), *
this);
1365 if (prefix.empty()) {
1366 return (
int)toChange.size();
1371 for (
auto item : oldEdges) {
1373 rename(item.second, prefix + item.first);
1384 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1385 const NBEdge* e1 = it->second;
1391 for (EdgeCont::const_iterator it2 = it; it2 !=
myEdges.end(); it2++) {
1392 const NBEdge* e2 = it2->second;
1401 const double overlap = outline1.
getOverlapWith(outline2, zThreshold);
1402 if (overlap > threshold) {
1413 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1414 const NBEdge* edge = it->second;
1415 for (
int i = 0; i < (int)edge->
getNumLanes(); i++) {
1418 if (maxJump > 0.01) {
1420 }
else if (grade > threshold) {
1425 const std::vector<NBEdge::Connection>& connections = edge->
getConnections();
1426 for (std::vector<NBEdge::Connection>::const_iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
1430 if (maxJump > 0.01) {
1432 }
else if (grade > threshold) {
1445 item.second->setNumericalID((
int)result.size());
1446 result.push_back(item.second);
static double relAngle(double angle1, double angle2)
computes the relative angle between the two angles
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
std::vector< Lane > myLanes
Lane information.
double getLength() const
Returns the computed length of the edge.
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
double length2D() const
Returns the length.
A structure which describes a connection between edges or lanes.
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
void setRoundabout()
update the type of this node as a roundabout
A class representing a single street sign.
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
PositionVector shape
The lane's shape.
void append(const PositionVector &v, double sameThreshold=2.0)
void appendTurnarounds(bool noTLSControlled, bool onlyDeadends)
Appends turnarounds to all edges stored in the container.
void addSign(NBSign sign)
add Sign
NBEdge * toEdge
The edge the connections yields in.
void reduceGeometries(const double minDist)
static void loadPrefixedIDsFomFile(const std::string &file, const std::string prefix, std::set< std::string > &into)
Add prefixed ids defined in file.
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
A structure which describes changes of lane number or speed along the road.
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
bool setConnection(int lane, NBEdge *destEdge, int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED)
Adds a connection to a certain lane of a certain edge.
double getMaxGrade(double &maxJump) const
void markAsSplit(const NBNode *node)
mark a node as being created form a split
A container for traffic light definitions and built programs.
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
const std::string & getTypeID() const
get ID of type
std::string nameID
the default node id
const double SUMO_const_halfLaneAndOffset
std::pair< PositionVector, PositionVector > splitAt(double where, bool use2D=false) const
Returns the two lists made when this list vector is splitted at the given point.
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
The representation of a single edge during network building.
const double SUMO_const_laneWidthAndOffset
void guessOpposites()
Sets opposite lane information for geometrically close edges.
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
A container for districts.
static const double UNSPECIFIED_OFFSET
unspecified lane offset
static GeoConvHelper & getLoaded()
the coordinate transformation that was loaded fron an input file
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false)
Removes the specified connection(s)
void removeDoubleEdges()
remove duble edges
NBEdge * getTurnDestination(bool possibleDestination=false) const
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
void setLoadedLength(double val)
set loaded lenght
void generateStreetSigns()
assigns street signs to edges based on toNode types
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
void recheckPostProcessConnections()
Try to set any stored connections.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
std::string idAfter
The id for the edge after the split.
bool getShallBeDiscarded(const std::string &type) const
Returns the information whether edges of this type shall be discarded.
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getID() const
Returns the id.
The representation of a single pt stop.
Lane & getLaneStruct(int lane)
bool overlapsWith(const AbstractPoly &poly, double offset=0) const
Returns whether the boundary overlaps with the given polygon.
std::vector< double > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
static void loadEdgesFromFile(const std::string &file, std::set< std::string > &into)
Add edge ids defined in file (either ID or edge:ID per line) into the given set.
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
std::string getDescription(const NBEdge *parent) const
get string describing this connection
static const double UNSPECIFIED_WIDTH
unspecified lane width
A class that stores a 2D geometrical boundary.
std::vector< PostProcessConnection > myConnections
The list of connections to recheck.
void replaceOutgoing(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of outgoing by the second Connections are remap...
#define WRITE_WARNING(msg)
The connection was computed and validated.
static OptionsCont & getOptions()
Retrieves the options.
void checkGeometries(const double maxAngle, const double minRadius, bool fix)
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
double area() const
Returns the area (0 for non-closed)
void checkGrade(double threshold) const
check whether edges are to steep
PositionVector myPruningBoundary
Boundary within which an edge must be located in order to be kept.
PositionVector shape
shape of Connection
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED)
Adds a connection between the specified this edge's lane and an approached one.
double pos
The position of this change.
NBEdgeCont(NBTypeCont &tc)
Constructor.
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
An (internal) definition of a single lane of an edge.
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
void invalidateTLS(NBTrafficLightLogicCont &tlCont, bool removedConnections, bool addedConnections)
causes the traffic light to be computed anew
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
void incLaneNo(int by)
increment lane
NBNode * node
The new node that is created for this split.
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
bool knows(const std::string &type) const
Returns whether the named type is in the container.
static double nearest_offset_on_line_to_point2D(const Position &lineStart, const Position &lineEnd, const Position &p, bool perpendicular=true)
double myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
std::set< NBEdge * > EdgeSet
container for unique edges
void patchRoundabouts(NBEdge *orig, NBEdge *part1, NBEdge *part2, std::set< EdgeSet > &roundabouts)
fix roundabout information after splitting an edge
std::string getNext()
Returns the next id.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
int offsetFactor
direction in which to apply the offset (used by netgenerate for lefthand networks) ...
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
void decLaneNo(int by)
decrement lane
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter ...
std::string getLaneID(int lane) const
get Lane ID (Secure)
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
int getNumLanes() const
Returns the number of lanes.
A point in 2D or 3D with translation and scaling methods.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void setOrigID(const std::string origID)
set origID for all lanes
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
bool exists(const std::string &name) const
Returns the information whether the named option is known.
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
static double formFactor(const EdgeVector &loopEdges)
compute the form factor for a loop of edges
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
void splitGeometry(NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
EdgeCont myEdges
The instance of the dictionary (id->edge)
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
Boundary & grow(double by)
extends the boundary by the given amount
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
std::vector< int > lanes
The lanes after this change.
void clear()
Deletes all edges.
EdgeCont myExtractedEdges
The extracted nodes which are kept for reference.
The connection was given by the user.
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout) ...
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
double getFinalLength() const
get length that will be assigned to the lanes in the final network
void move2side(double amount)
move position vector to side using certain ammount
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again ...
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
double getSpeed() const
Returns the speed allowed on this edge.
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed) ...
const PositionVector & getGeometry() const
Returns the geometry of the edge.
const std::map< std::string, NBPTStop * > & getStops() const
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
int guessSidewalks(double width, double minSpeed, double maxSpeed, bool fromPermissions)
add sidwalks to edges within the given limits or permissions and return the number of edges affected ...
EdgeVector getAllEdges() const
return all edges
void setID(const std::string &newID)
resets the id
double length() const
Returns the length.
PositionVector viaShape
shape of via
std::string oppositeID
An opposite lane ID, if given.
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
const std::vector< Connection > & getConnections() const
Returns the connections.
void replaceIncoming(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of incoming by the second Connections are remap...
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node) ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass, bool keepClear, double contPos, double visibility, double speed, const PositionVector &customShape, bool warnOnly=false)
Adds a connection which could not be set during loading.
static long long int toLong(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter, which
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
bool myNeedGeoTransformedPruningBoundary
whether a geo transform has been applied to the pruning boundary
A storage for options typed value containers)
SumoXMLNodeType getType() const
Returns the type of this node.
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
const std::string SUMO_PARAM_ORIGID
A structure representing a connection between two lanes.
double speed
The speed after this change.
Sorts splits by their position (increasing)
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
The connection was computed.
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
const Position & getPosition() const
Represents a single node (junction) during network building.
void dismissVehicleClassInformation()
dimiss vehicle class information
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation. ...
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
NBNode * getFromNode() const
Returns the origin node of the edge.
void removeFromSinksAndSources(NBEdge *const e)
Removes the given edge from the lists of sources and sinks in all stored districts.
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Container for nodes during the netbuilding process.
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node ...
static T maxValue(const std::vector< T > &v)
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
double getOverlapWith(const PositionVector &poly, double zThreshold) const
Returns the maximum overlaps between this and the given polygon (when not separated by at least zThre...
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)
Replaces occurences of the removed edge/lane in all definitions by the given edge.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
NBNode * myFrom
The source and the destination node.
NBNode * getToNode() const
Returns the destination node of the edge.
std::string idBefore
The id for the edge before the split.
bool isSimpleContinuation(bool checkLaneNumbers=true) const
check if node is a simple continuation
void copyConnectionsFrom(NBEdge *src)
copy connections from antoher edge
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
A storage for available types of edges.
double offset
lateral offset to edge geometry
int myEdgesSplit
the number of splits of edges during the building
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.