110 importer.
load(oc, nb);
122 delete myEdge.second;
126 delete myPlatformShape.second;
132 if (!oc.
isSet(
"osm-files")) {
135 const std::vector<std::string> files = oc.
getStringVector(
"osm-files");
136 std::vector<SUMOSAXReader*> readers;
154 for (
const std::string& file : files) {
163 if (!readers.back()->parseFirst(file) || !readers.back()->parseSection(
SUMO_TAG_NODE) ||
176 for (
const std::string& file : files) {
178 readers[idx]->setHandler(edgesHandler);
183 readers[idx] =
nullptr;
190 if (!oc.
getBool(
"osm.skip-duplicates-check")) {
194 std::set<const Edge*, CompareEdges> dupsFinder;
196 if (dupsFinder.count(it->second) > 0) {
201 dupsFinder.insert(it->second);
206 if (numRemoved > 0) {
215 std::map<long long int, int> nodeUsage;
217 for (
const auto& edgeIt :
myEdges) {
218 assert(edgeIt.second->myCurrentIsRoad);
219 for (
const long long int node : edgeIt.second->myCurrentNodes) {
225 if (nodesIt.second->tlsControlled || nodesIt.second->railwaySignal || (nodesIt.second->pedestrianCrossing &&
myImportCrossings) ) {
228 nodeUsage[nodesIt.first]++;
237 for (
const auto& edgeIt :
myEdges) {
238 Edge*
const e = edgeIt.second;
250 NBNode* currentFrom = first;
252 std::vector<long long int> passed;
254 passed.push_back(*j);
257 running =
insertEdge(e, running, currentFrom, currentTo, passed, nb, first, last);
258 currentFrom = currentTo;
260 passed.push_back(*j);
266 insertEdge(e, running, currentFrom, last, passed, nb, first, last);
279 for (
auto item : nodeUsage) {
285 size_t incomingEdgesNo = incomingEdges.size();
286 size_t outgoingEdgesNo = outgoingEdges.size();
288 for (
size_t i = 0; i < incomingEdgesNo; i++) {
296 auto const iEdge = incomingEdges[i];
300 std::string
const& iEdgeId = iEdge->getID();
301 std::size_t
const m = iEdgeId.find_first_of(
"#");
302 std::string
const& iWayId = iEdgeId.substr(0, m);
303 for (
size_t j = 0; j < outgoingEdgesNo; j++) {
304 auto const oEdge = outgoingEdges[j];
307 if (oEdge->getID().find(iWayId) != std::string::npos
309 && oEdge->getID().rfind(iWayId, 0) != 0) {
312 edgeVector.push_back(oEdge);
322 for (
size_t i = 0; i < outgoingEdgesNo; i++) {
324 auto const oEdge = outgoingEdges[i];
328 std::string
const& oEdgeId = oEdge->getID();
329 std::size_t
const m = oEdgeId.find_first_of(
"#");
330 std::string
const& iWayId = oEdgeId.substr(0, m);
331 for (
size_t j = 0; j < incomingEdgesNo; j++) {
332 auto const iEdge = incomingEdges[j];
333 if (iEdge->getID().find(iWayId) != std::string::npos
335 && iEdge->getID().rfind(iWayId, 0) != 0) {
338 edgeVector.push_back(iEdge);
352 const double layerElevation = oc.
getFloat(
"osm.layer-elevation");
353 if (layerElevation > 0) {
365 for (
const std::string& file : files) {
366 if (readers[idx] !=
nullptr) {
368 readers[idx]->setHandler(relationHandler);
378 std::set<std::string> stopNames;
380 stopNames.insert(item.second->getName());
387 WRITE_ERRORF(
"Unable to project coordinates for node '%'.", n->
id);
399 if (node ==
nullptr) {
403 WRITE_ERRORF(
"Unable to project coordinates for junction '%'.",
id);
416 }
else if (n->
getParameter(
"crossing.light") ==
"yes") {
428 if (!tlsc.
insert(tlDef)) {
453 const std::vector<long long int>& passed,
NBNetBuilder& nb,
463 if (from ==
nullptr || to ==
nullptr) {
464 WRITE_ERRORF(
"Discarding edge '%' because the nodes could not be built.",
id);
473 assert(passed.size() >= 2);
474 if (passed.size() == 2) {
475 WRITE_WARNINGF(
TL(
"Discarding edge '%' which connects two identical nodes without geometry."),
id);
479 int intermediateIndex = (int) passed.size() / 2;
481 std::vector<long long int> part1(passed.begin(), passed.begin() + intermediateIndex + 1);
482 std::vector<long long int> part2(passed.begin() + intermediateIndex, passed.end());
483 index =
insertEdge(e, index, from, intermediate, part1, nb, first, last);
484 return insertEdge(e, index, intermediate, to, part2, nb, first, last);
486 const int newIndex = index + 1;
501 extra = extra & ~SVC_BUS;
503 SVCPermissions permissions = (defaultPermissions & ~extraDis) | extra;
504 if (defaultPermissions ==
SVC_SHIP) {
506 permissions = defaultPermissions;
509 defaultsToOneWay =
false;
517 double distanceStart =
myOSMNodes[passed.front()]->positionMeters;
518 double distanceEnd =
myOSMNodes[passed.back()]->positionMeters;
519 const bool useDistance = distanceStart != std::numeric_limits<double>::max() && distanceEnd != std::numeric_limits<double>::max();
522 if (distanceStart < distanceEnd) {
535 std::vector<std::shared_ptr<NBPTStop> > ptStops;
536 for (
long long i : passed) {
540 std::shared_ptr<NBPTStop> existingPtStop = sc.
get(
toString(n->
id));
541 if (existingPtStop !=
nullptr) {
542 existingPtStop->registerAdditionalEdge(
toString(e->
id), id);
546 WRITE_ERRORF(
"Unable to project coordinates for node '%'.", n->
id);
549 sc.
insert(ptStops.back());
556 shape.push_back(pos);
558#ifdef DEBUG_LAYER_ELEVATION
559 if (e->
id ==
"DEBUGID") {
564 <<
" nodeDirection=" << nodeDirection
576 WRITE_ERRORF(
"Unable to project coordinates for edge '%'.",
id);
582 if (streetName == e->
ref) {
599 const std::string& onewayBike = e->
myExtraTags[
"oneway:bicycle"];
600 if (onewayBike ==
"false" || onewayBike ==
"no" || onewayBike ==
"0") {
611 bool addForward =
true;
612 bool addBackward =
true;
613 const bool explicitTwoWay = e->
myIsOneWay ==
"no";
629 if (addBackward && (onewayBike ==
"true" || onewayBike ==
"yes" || onewayBike ==
"1")) {
632 if (addForward && (onewayBike ==
"reverse" || onewayBike ==
"-1")) {
635 if (!addBackward && (onewayBike ==
"false" || onewayBike ==
"no" || onewayBike ==
"0")) {
642 if (addForward && !addBackward) {
644 }
else if (!addForward && addBackward) {
652 numLanesForward = (int) std::ceil(e->
myNoLanes / 2.0);
654 numLanesBackward = e->
myNoLanes - numLanesForward;
657 numLanesForward =
MAX2(1, numLanesForward);
658 numLanesBackward =
MAX2(1, numLanesBackward);
681 numLanesBackward = 1;
684 const int taggedLanes = (addForward ? numLanesForward : 0) + (addBackward ? numLanesBackward : 0);
688 forwardWidth = e->
myWidth / taggedLanes;
689 backwardWidth = forwardWidth;
696 double speedBackward = speed;
700 if (speed <= 0 || speedBackward <= 0) {
707 if (!addForward && (cyclewayType &
WAY_FORWARD) != 0) {
710 forwardWidth = bikeLaneWidth;
715 if (!addBackward && (cyclewayType &
WAY_BACKWARD) != 0) {
718 backwardWidth = bikeLaneWidth;
719 numLanesBackward = 1;
731 if (!addForward && (sidewalkType &
WAY_FORWARD) != 0) {
738 }
else if (addSidewalk && addForward && (sidewalkType &
WAY_BOTH) == 0
739 && numLanesForward == 1 && numLanesBackward <= 1
746 if (!addBackward && (sidewalkType &
WAY_BACKWARD) != 0) {
750 numLanesBackward = 1;
753 }
else if (addSidewalk && addBackward && (sidewalkType &
WAY_BOTH) == 0
754 && numLanesBackward == 1 && numLanesForward <= 1
766 const int offsetFactor = lefthand ? -1 : 1;
778 const std::string reverseID =
"-" + id;
781 assert(numLanesForward > 0);
785 if (markOSMDirection) {
822 if ((
int)nbe->
getLanes().size() != numForwardLanesFromWidthKey) {
823 WRITE_WARNINGF(
TL(
"Forward lanes count for edge '%' ('%') is not matching the number of lanes defined in width:lanes:forward key ('%'). Using default width values."),
824 id, nbe->
getLanes().size(), numForwardLanesFromWidthKey);
826 for (
int i = 0; i < numForwardLanesFromWidthKey; i++) {
828 const int laneIndex = lefthand ? i : numForwardLanesFromWidthKey - i - 1;
840 assert(numLanesBackward > 0);
844 if (markOSMDirection) {
875 if ((
int)nbe->
getLanes().size() != numBackwardLanesFromWidthKey) {
876 WRITE_WARNINGF(
TL(
"Backward lanes count for edge '%' ('%') is not matching the number of lanes defined in width:lanes:backward key ('%'). Using default width values."),
877 id, nbe->
getLanes().size(), numBackwardLanesFromWidthKey);
879 for (
int i = 0; i < numBackwardLanesFromWidthKey; i++) {
881 const int laneIndex = lefthand ? i : numBackwardLanesFromWidthKey - i - 1;
925 std::set<NIOSMNode*, CompareNodes>& uniqueNodes,
const OptionsCont& oc) :
928 myCurrentNode(nullptr),
930 myUniqueNodes(uniqueNodes),
931 myImportElevation(oc.getBool(
"osm.elevation")),
936 if (kv ==
"DEFAULT") {
939 }
else if (kv ==
"ALL") {
956 if (myHierarchyLevel != 2) {
957 WRITE_ERROR(
"Node element on wrong XML hierarchy level (id='" + myLastNodeID +
958 "', level='" +
toString(myHierarchyLevel) +
"').");
962 if (action ==
"delete" || !ok) {
968 myCurrentNode =
nullptr;
969 const auto insertionIt = myToFill.lower_bound(
id);
970 if (insertionIt == myToFill.end() || insertionIt->first !=
id) {
972 const double tlon = attrs.
get<
double>(
SUMO_ATTR_LON, myLastNodeID.c_str(), ok);
973 const double tlat = attrs.
get<
double>(
SUMO_ATTR_LAT, myLastNodeID.c_str(), ok);
977 myCurrentNode =
new NIOSMNode(
id, tlon, tlat);
982 delete myCurrentNode;
983 myCurrentNode = *similarNode;
986 myToFill.emplace_hint(insertionIt,
id, myCurrentNode);
989 WRITE_ERROR(
TL(
"Attribute 'id' in the definition of a node is not of type long long int."));
993 if (element ==
SUMO_TAG_TAG && myCurrentNode !=
nullptr) {
994 if (myHierarchyLevel != 3) {
995 WRITE_ERROR(
TL(
"Tag element on wrong XML hierarchy level."));
999 const std::string& key = attrs.
get<std::string>(
SUMO_ATTR_K, myLastNodeID.c_str(), ok,
false);
1001 if (key ==
"highway" || key ==
"ele" || key ==
"crossing" || key ==
"railway" || key ==
"public_transport"
1002 || key ==
"name" || key ==
"train" || key ==
"bus" || key ==
"tram" || key ==
"light_rail" || key ==
"subway" || key ==
"station" || key ==
"noexit"
1003 || key ==
"crossing:barrier"
1004 || key ==
"crossing:light"
1008 const std::string& value = attrs.
get<std::string>(
SUMO_ATTR_V, myLastNodeID.c_str(), ok,
false);
1009 if (key ==
"highway" && value.find(
"traffic_signal") != std::string::npos) {
1010 myCurrentNode->tlsControlled =
true;
1011 }
else if (key ==
"crossing" && value.find(
"traffic_signals") != std::string::npos) {
1012 myCurrentNode->tlsControlled =
true;
1013 }
else if (key ==
"highway" && value.find(
"crossing") != std::string::npos) {
1014 myCurrentNode->pedestrianCrossing =
true;
1015 }
else if ((key ==
"noexit" && value ==
"yes")
1016 || (key ==
"railway" && value ==
"buffer_stop")) {
1017 myCurrentNode->railwayBufferStop =
true;
1018 }
else if (key ==
"railway" && value.find(
"crossing") != std::string::npos) {
1019 myCurrentNode->railwayCrossing =
true;
1020 }
else if (key ==
"crossing:barrier") {
1021 myCurrentNode->setParameter(
"crossing:barrier", value);
1022 }
else if (key ==
"crossing:light") {
1023 myCurrentNode->setParameter(
"crossing:light", value);
1024 }
else if (key ==
"railway:signal:direction") {
1025 if (value ==
"both") {
1026 myCurrentNode->myRailDirection =
WAY_BOTH;
1027 }
else if (value ==
"backward") {
1029 }
else if (value ==
"forward") {
1033 std::string kv = key +
"=" + value;
1034 std::string kglob = key +
"=";
1035 if ((std::find(myRailSignalRules.begin(), myRailSignalRules.end(), kv) != myRailSignalRules.end())
1036 || (std::find(myRailSignalRules.begin(), myRailSignalRules.end(), kglob) != myRailSignalRules.end())) {
1037 myCurrentNode->railwaySignal =
true;
1039 }
else if (
StringUtils::startsWith(key,
"railway:position") && value.size() > myCurrentNode->position.size()) {
1041 myCurrentNode->position = value;
1042 }
else if ((key ==
"public_transport" && value ==
"stop_position") ||
1043 (key ==
"highway" && value ==
"bus_stop")) {
1044 myCurrentNode->ptStopPosition =
true;
1045 if (myCurrentNode->ptStopLength == 0) {
1047 myCurrentNode->ptStopLength = myOptionsCont.getFloat(
"osm.stop-output.length");
1049 }
else if (key ==
"name") {
1050 myCurrentNode->name = value;
1051 }
else if (myImportElevation && key ==
"ele") {
1054 if (std::isnan(elevation)) {
1055 WRITE_WARNINGF(
TL(
"Value of key '%' is invalid ('%') in node '%'."), key, value, myLastNodeID);
1057 myCurrentNode->ele = elevation;
1060 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in node '%'."), key, value, myLastNodeID);
1062 }
else if (key ==
"station") {
1070 const std::string info =
"node=" +
toString(myCurrentNode->id) +
", k=" + key;
1071 myCurrentNode->setParameter(key, attrs.
get<std::string>(
SUMO_ATTR_V, info.c_str(), ok,
false));
1080 myCurrentNode =
nullptr;
1090 const std::map<long long int, NIOSMNode*>& osmNodes,
1091 std::map<long long int, Edge*>& toFill, std::map<long long int, Edge*>& platformShapes):
1095 myPlatformShapesMap(platformShapes) {
1192 const long long int id = attrs.
get<
long long int>(
SUMO_ATTR_ID,
nullptr, ok);
1194 if (action ==
"delete" || !ok) {
1195 myCurrentEdge =
nullptr;
1198 myCurrentEdge =
new Edge(
id);
1201 if (element ==
SUMO_TAG_ND && myCurrentEdge !=
nullptr) {
1211 ref = node->second->id;
1212 if (myCurrentEdge->myCurrentNodes.empty() ||
1213 myCurrentEdge->myCurrentNodes.back() != ref) {
1214 myCurrentEdge->myCurrentNodes.push_back(ref);
1219 if (element ==
SUMO_TAG_TAG && myCurrentEdge !=
nullptr) {
1224 const std::string buswaySpec = key.substr(7);
1226 if (buswaySpec ==
"right") {
1228 }
else if (buswaySpec ==
"left") {
1230 }
else if (buswaySpec ==
"both") {
1231 myCurrentEdge->myBuswayType = (
WayType)(myCurrentEdge->myBuswayType |
WAY_BOTH);
1237 const std::string info =
"way=" +
toString(myCurrentEdge->id) +
", k=" + key;
1238 myCurrentEdge->setParameter(key, attrs.
get<std::string>(
SUMO_ATTR_V, info.c_str(), ok,
false));
1243 && key !=
"maxspeed" && key !=
"maxspeed:type"
1244 && key !=
"zone:maxspeed"
1245 && key !=
"maxspeed:forward" && key !=
"maxspeed:backward"
1246 && key !=
"junction" && key !=
"name" && key !=
"tracks" && key !=
"layer"
1251 && key !=
"highspeed"
1255 && key !=
"postal_code"
1256 && key !=
"railway:preferred_direction"
1257 && key !=
"railway:bidirectional"
1258 && key !=
"railway:track_ref"
1261 && key !=
"emergency"
1263 && key !=
"electrified"
1264 && key !=
"segregated"
1269 && key !=
"oneway:bicycle"
1270 && key !=
"oneway:bus"
1271 && key !=
"bus:lanes"
1272 && key !=
"bus:lanes:forward"
1273 && key !=
"bus:lanes:backward"
1274 && key !=
"psv:lanes"
1275 && key !=
"psv:lanes:forward"
1276 && key !=
"psv:lanes:backward"
1277 && key !=
"bicycle:lanes"
1278 && key !=
"bicycle:lanes:forward"
1279 && key !=
"bicycle:lanes:backward"
1282 && key !=
"public_transport") {
1285 const std::string value = attrs.
get<std::string>(
SUMO_ATTR_V,
toString(myCurrentEdge->id).c_str(), ok,
false);
1287 if ((key ==
"highway" && value !=
"platform") || key ==
"railway" || key ==
"waterway" ||
StringUtils::startsWith(key,
"cycleway")
1289 || key ==
"aeroway" || key ==
"aerialway" || key ==
"usage" || key ==
"service") {
1291 myCurrentEdge->myCurrentIsRoad =
true;
1293 if (key ==
"cycleway") {
1294 if (value ==
"no" || value ==
"none" || value ==
"separate") {
1295 myCurrentEdge->myCyclewayType =
WAY_NONE;
1296 }
else if (value ==
"both") {
1297 myCurrentEdge->myCyclewayType =
WAY_BOTH;
1298 }
else if (value ==
"right") {
1300 }
else if (value ==
"left") {
1302 }
else if (value ==
"opposite_track") {
1304 }
else if (value ==
"opposite_lane") {
1306 }
else if (value ==
"opposite") {
1311 if (key ==
"cycleway:left") {
1312 if (myCurrentEdge->myCyclewayType ==
WAY_UNKNOWN) {
1313 myCurrentEdge->myCyclewayType =
WAY_NONE;
1315 if (value ==
"yes" || value ==
"lane" || value ==
"track") {
1320 if (key ==
"cycleway:right") {
1321 if (myCurrentEdge->myCyclewayType ==
WAY_UNKNOWN) {
1322 myCurrentEdge->myCyclewayType =
WAY_NONE;
1324 if (value ==
"yes" || value ==
"lane" || value ==
"track") {
1325 myCurrentEdge->myCyclewayType = (
WayType)(myCurrentEdge->myCyclewayType |
WAY_FORWARD);
1329 if (key ==
"cycleway:both") {
1330 if (myCurrentEdge->myCyclewayType ==
WAY_UNKNOWN) {
1331 if (value ==
"no" || value ==
"none" || value ==
"separate") {
1332 myCurrentEdge->myCyclewayType =
WAY_NONE;
1334 if (value ==
"yes" || value ==
"lane" || value ==
"track") {
1335 myCurrentEdge->myCyclewayType =
WAY_BOTH;
1340 if (key ==
"cycleway" && value !=
"lane" && value !=
"track" && value !=
"opposite_track" && value !=
"opposite_lane") {
1349 if (key ==
"sidewalk") {
1350 if (value ==
"no" || value ==
"none" || value ==
"separate") {
1351 myCurrentEdge->mySidewalkType =
WAY_NONE;
1352 }
else if (value ==
"both") {
1353 myCurrentEdge->mySidewalkType =
WAY_BOTH;
1354 }
else if (value ==
"right") {
1356 }
else if (value ==
"left") {
1360 if (key ==
"sidewalk:left") {
1361 if (myCurrentEdge->mySidewalkType ==
WAY_UNKNOWN) {
1362 myCurrentEdge->mySidewalkType =
WAY_NONE;
1364 if (value ==
"yes") {
1368 if (key ==
"sidewalk:right") {
1369 if (myCurrentEdge->mySidewalkType ==
WAY_UNKNOWN) {
1370 myCurrentEdge->mySidewalkType =
WAY_NONE;
1372 if (value ==
"yes") {
1373 myCurrentEdge->mySidewalkType = (
WayType)(myCurrentEdge->mySidewalkType |
WAY_FORWARD);
1376 if (key ==
"sidewalk:both") {
1377 if (myCurrentEdge->mySidewalkType ==
WAY_UNKNOWN) {
1378 if (value ==
"no" || value ==
"none" || value ==
"separate") {
1379 myCurrentEdge->mySidewalkType =
WAY_NONE;
1381 if (value ==
"yes") {
1382 myCurrentEdge->mySidewalkType =
WAY_BOTH;
1391 if (key ==
"busway") {
1392 if (value ==
"no") {
1395 if (value ==
"opposite_track") {
1397 }
else if (value ==
"opposite_lane") {
1403 std::string singleTypeID = key +
"." + value;
1404 if (key ==
"highspeed") {
1405 if (value ==
"no") {
1408 singleTypeID =
"railway.highspeed";
1411 if (!myCurrentEdge->myHighWayType.empty() && singleTypeID !=
"railway.highspeed") {
1412 if (myCurrentEdge->myHighWayType ==
"railway.highspeed") {
1417 std::vector<std::string> types =
StringTokenizer(myCurrentEdge->myHighWayType,
1419 types.push_back(singleTypeID);
1422 myCurrentEdge->myHighWayType = singleTypeID;
1424 }
else if (key ==
"bus" || key ==
"psv") {
1428 myCurrentEdge->myExtraAllowed |=
SVC_BUS;
1430 myCurrentEdge->myExtraDisallowed |=
SVC_BUS;
1433 myCurrentEdge->myExtraAllowed |=
SVC_BUS;
1435 }
else if (key ==
"emergency") {
1443 }
else if (key ==
"access") {
1444 if (value ==
"no") {
1450 std::vector<double> widthLanes;
1451 for (std::string width : values) {
1453 widthLanes.push_back(parsedWidth);
1456 if (key ==
"width:lanes" || key ==
"width:lanes:forward") {
1457 myCurrentEdge->myWidthLanesForward = widthLanes;
1458 }
else if (key ==
"width:lanes:backward") {
1459 myCurrentEdge->myWidthLanesBackward = widthLanes;
1461 WRITE_WARNINGF(
TL(
"Using default lane width for edge '%' as key '%' could not be parsed."),
toString(myCurrentEdge->id), key);
1464 WRITE_WARNINGF(
TL(
"Using default lane width for edge '%' as value '%' could not be parsed."),
toString(myCurrentEdge->id), value);
1466 }
else if (key ==
"width") {
1470 WRITE_WARNINGF(
TL(
"Using default width for edge '%' as value '%' could not be parsed."),
toString(myCurrentEdge->id), value);
1472 }
else if (key ==
"foot") {
1473 if (value ==
"use_sidepath" || value ==
"no") {
1475 }
else if (value ==
"yes" || value ==
"designated" || value ==
"permissive") {
1478 }
else if (key ==
"bicycle") {
1479 if (value ==
"use_sidepath" || value ==
"no") {
1481 }
else if (value ==
"yes" || value ==
"designated" || value ==
"permissive") {
1484 }
else if (key ==
"oneway:bicycle") {
1485 myCurrentEdge->myExtraTags[
"oneway:bicycle"] = value;
1486 }
else if (key ==
"oneway:bus") {
1487 if (value ==
"no") {
1491 }
else if (key ==
"lanes") {
1497 std::vector<std::string> list = st.
getVector();
1498 if (list.size() >= 2) {
1499 int minLanes = std::numeric_limits<int>::max();
1501 for (
auto& i : list) {
1503 minLanes =
MIN2(minLanes, numLanes);
1505 myCurrentEdge->myNoLanes = minLanes;
1508 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1512 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1514 }
else if (key ==
"lanes:forward") {
1517 if (myCurrentEdge->myNoLanesForward < 0 && myCurrentEdge->myNoLanes < 0) {
1519 myCurrentEdge->myNoLanes = numLanes - myCurrentEdge->myNoLanesForward;
1521 myCurrentEdge->myNoLanesForward = numLanes;
1523 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1525 }
else if (key ==
"lanes:backward") {
1528 if (myCurrentEdge->myNoLanesForward > 0 && myCurrentEdge->myNoLanes < 0) {
1530 myCurrentEdge->myNoLanes = numLanes + myCurrentEdge->myNoLanesForward;
1533 myCurrentEdge->myNoLanesForward = -numLanes;
1535 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1538 (key ==
"maxspeed" || key ==
"maxspeed:type" || key ==
"maxspeed:forward" || key ==
"zone:maxspeed")) {
1540 myCurrentEdge->myMaxSpeed = interpretSpeed(key, value);
1541 }
else if (key ==
"maxspeed:backward" && myCurrentEdge->myMaxSpeedBackward ==
MAXSPEED_UNGIVEN) {
1542 myCurrentEdge->myMaxSpeedBackward = interpretSpeed(key, value);
1543 }
else if (key ==
"junction") {
1544 if ((value ==
"roundabout" || value ==
"circular") && myCurrentEdge->myIsOneWay.empty()) {
1545 myCurrentEdge->myIsOneWay =
"yes";
1547 if (value ==
"roundabout") {
1548 myCurrentEdge->myAmInRoundabout =
true;
1550 }
else if (key ==
"oneway") {
1551 myCurrentEdge->myIsOneWay = value;
1552 }
else if (key ==
"name") {
1553 myCurrentEdge->streetName = value;
1554 }
else if (key ==
"ref") {
1555 myCurrentEdge->ref = value;
1556 myCurrentEdge->setParameter(
"ref", value);
1557 }
else if (key ==
"layer") {
1561 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1563 }
else if (key ==
"tracks") {
1566 myCurrentEdge->myIsOneWay =
"true";
1568 WRITE_WARNINGF(
TL(
"Ignoring track count % for edge '%'."), value, myCurrentEdge->id);
1571 WRITE_WARNINGF(
TL(
"Value of key '%' is not numeric ('%') in edge '%'."), key, value, myCurrentEdge->id);
1573 }
else if (key ==
"railway:preferred_direction") {
1574 if (value ==
"both") {
1575 myCurrentEdge->myRailDirection =
WAY_BOTH;
1576 }
else if (myCurrentEdge->myRailDirection ==
WAY_UNKNOWN) {
1577 if (value ==
"backward") {
1579 }
else if (value ==
"forward") {
1583 }
else if (key ==
"railway:bidirectional") {
1584 if (value ==
"regular") {
1585 myCurrentEdge->myRailDirection =
WAY_BOTH;
1587 }
else if (key ==
"electrified" || key ==
"segregated") {
1588 if (value !=
"no") {
1589 myCurrentEdge->myExtraTags[key] = value;
1591 }
else if (key ==
"railway:track_ref") {
1592 myCurrentEdge->setParameter(key, value);
1593 }
else if (key ==
"public_transport" && value ==
"platform") {
1594 myCurrentEdge->myExtraTags[
"platform"] =
"yes";
1601 }
else if (key ==
"change" || key ==
"change:lanes") {
1602 myCurrentEdge->myChangeForward = myCurrentEdge->myChangeBackward = interpretChangeType(value);
1603 }
else if (key ==
"change:forward" || key ==
"change:lanes:forward") {
1604 myCurrentEdge->myChangeForward = interpretChangeType(value);
1605 }
else if (key ==
"change:backward" || key ==
"change:lanes:backward") {
1606 myCurrentEdge->myChangeBackward = interpretChangeType(value);
1607 }
else if (key ==
"vehicle:lanes" || key ==
"vehicle:lanes:forward") {
1610 }
else if (key ==
"vehicle:lanes:backward") {
1613 }
else if (key ==
"bus:lanes" || key ==
"bus:lanes:forward") {
1614 interpretLaneUse(value,
SVC_BUS,
true);
1615 }
else if (key ==
"bus:lanes:backward") {
1616 interpretLaneUse(value,
SVC_BUS,
false);
1617 }
else if (key ==
"psv:lanes" || key ==
"psv:lanes:forward") {
1618 interpretLaneUse(value,
SVC_BUS,
true);
1619 interpretLaneUse(value,
SVC_TAXI,
true);
1620 }
else if (key ==
"psv:lanes:backward") {
1621 interpretLaneUse(value,
SVC_BUS,
false);
1622 interpretLaneUse(value,
SVC_TAXI,
false);
1623 }
else if (key ==
"bicycle:lanes" || key ==
"bicycle:lanes:forward") {
1625 }
else if (key ==
"bicycle:lanes:backward") {
1639 std::vector<int> turnCodes;
1640 for (std::string codeList : values) {
1643 if (codes.size() == 0) {
1646 for (std::string code : codes) {
1647 if (code ==
"" || code ==
"none" || code ==
"through") {
1649 }
else if (code ==
"left" || code ==
"sharp_left") {
1651 }
else if (code ==
"right" || code ==
"sharp_right") {
1653 }
else if (code ==
"slight_left") {
1655 }
else if (code ==
"slight_right") {
1657 }
else if (code ==
"reverse") {
1659 }
else if (code ==
"merge_to_left" || code ==
"merge_to_right") {
1663 turnCodes.push_back(turnCode);
1680 if (mySpeedMap.find(value) != mySpeedMap.end()) {
1681 return mySpeedMap[value];
1684 if (value.size() > 3 && value[2] ==
':') {
1685 if (value.substr(3, 4) ==
"zone") {
1686 value = value.substr(7);
1688 value = value.substr(3);
1694 WRITE_WARNING(
"Value of key '" + key +
"' is not numeric ('" + value +
"') in edge '" +
1695 toString(myCurrentEdge->id) +
"'.");
1706 for (
const std::string& val : values) {
1709 }
else if (val ==
"not_left") {
1711 }
else if (val ==
"not_right") {
1714 result = result << 2;
1717 result = result >> 2;
1719 if (values.size() > 1) {
1730 std::vector<bool>& designated = forward ? myCurrentEdge->myDesignatedLaneForward : myCurrentEdge->myDesignatedLaneBackward;
1731 std::vector<SVCPermissions>& allowed = forward ? myCurrentEdge->myAllowedLaneForward : myCurrentEdge->myAllowedLaneBackward;
1732 std::vector<SVCPermissions>& disallowed = forward ? myCurrentEdge->myDisallowedLaneForward : myCurrentEdge->myDisallowedLaneBackward;
1733 designated.resize(
MAX2(designated.size(), values.size()),
false);
1737 for (
const std::string& val : values) {
1738 if (val ==
"yes" || val ==
"permissive") {
1740 }
else if (val ==
"lane" || val ==
"designated") {
1742 designated[i] =
true;
1743 }
else if (val ==
"no") {
1744 disallowed[i] |= svc;
1746 WRITE_WARNINGF(
TL(
"Unknown lane use specifier '%' ignored for way '%'"), val, myCurrentEdge->id);
1755 if (element ==
SUMO_TAG_WAY && myCurrentEdge !=
nullptr) {
1756 if (myCurrentEdge->myCurrentIsRoad) {
1757 const auto insertionIt = myEdgeMap.lower_bound(myCurrentEdge->id);
1758 if (insertionIt == myEdgeMap.end() || insertionIt->first != myCurrentEdge->id) {
1760 myEdgeMap.emplace_hint(insertionIt, myCurrentEdge->id, myCurrentEdge);
1762 delete myCurrentEdge;
1764 }
else if (myCurrentEdge->myExtraTags.count(
"platform") != 0) {
1765 const auto insertionIt = myPlatformShapesMap.lower_bound(myCurrentEdge->id);
1766 if (insertionIt == myPlatformShapesMap.end() || insertionIt->first != myCurrentEdge->id) {
1768 myPlatformShapesMap.emplace_hint(insertionIt, myCurrentEdge->id, myCurrentEdge);
1770 delete myCurrentEdge;
1773 delete myCurrentEdge;
1775 myCurrentEdge =
nullptr;
1784 const std::map<long long int, NIOSMNode*>& osmNodes,
1785 const std::map<long long int, Edge*>& osmEdges,
NBPTStopCont* nbptStopCont,
1786 const std::map<long long int, Edge*>& platformShapes,
1791 myOSMEdges(osmEdges),
1793 myNBPTStopCont(nbptStopCont),
1794 myNBPTLineCont(nbptLineCont),
1806 myIsRestriction =
false;
1812 myRestrictionType = RestrictionType::UNKNOWN;
1813 myPlatforms.clear();
1815 myPlatformStops.clear();
1817 myIsStopArea =
false;
1820 myRouteColor.setValid(
false);
1828 myCurrentRelation = attrs.
get<
long long int>(
SUMO_ATTR_ID,
nullptr, ok);
1830 if (action ==
"delete" || !ok) {
1836 myNightService =
"";
1845 const long long int ref = attrs.
get<
long long int>(
SUMO_ATTR_REF,
nullptr, ok);
1846 if (role ==
"via") {
1849 if (memberType ==
"way" && checkEdgeRef(ref)) {
1851 }
else if (memberType ==
"node") {
1858 }
else if (role ==
"from" && checkEdgeRef(ref)) {
1860 }
else if (role ==
"to" && checkEdgeRef(ref)) {
1862 }
else if (role ==
"stop") {
1863 myStops.push_back(ref);
1864 }
else if (role ==
"platform") {
1866 if (memberType ==
"way") {
1867 const std::map<long long int, NIImporter_OpenStreetMap::Edge*>::const_iterator& wayIt =
myPlatformShapes.find(ref);
1870 platform.
isWay =
true;
1872 myPlatforms.push_back(platform);
1874 }
else if (memberType ==
"node") {
1876 myStops.push_back(ref);
1877 myPlatformStops.insert(ref);
1879 platform.
isWay =
false;
1881 myPlatforms.push_back(platform);
1884 }
else if (role.empty()) {
1886 if (memberType ==
"way") {
1887 myWays.push_back(ref);
1888 }
else if (memberType ==
"node") {
1889 myStops.push_back(ref);
1899 if (key ==
"type" || key ==
"restriction") {
1901 if (key ==
"type" && value ==
"restriction") {
1902 myIsRestriction =
true;
1905 if (key ==
"type" && value ==
"route") {
1909 if (key ==
"restriction") {
1912 if (value.substr(0, 5) ==
"only_") {
1913 myRestrictionType = RestrictionType::ONLY;
1914 }
else if (value.substr(0, 3) ==
"no_") {
1915 myRestrictionType = RestrictionType::NO;
1921 }
else if (key ==
"except") {
1925 myRestrictionException |=
SVC_BUS;
1926 }
else if (v ==
"bicycle") {
1928 }
else if (v ==
"hgv") {
1930 }
else if (v ==
"motorcar") {
1932 }
else if (v ==
"emergency") {
1936 }
else if (key ==
"public_transport") {
1938 if (value ==
"stop_area") {
1939 myIsStopArea =
true;
1941 }
else if (key ==
"route") {
1943 if (value ==
"train" || value ==
"subway" || value ==
"light_rail" || value ==
"monorail" || value ==
"tram" || value ==
"bus"
1944 || value ==
"trolleybus" || value ==
"aerialway" || value ==
"ferry" || value ==
"share_taxi" || value ==
"minibus") {
1945 myPTRouteType = value;
1948 }
else if (key ==
"name") {
1950 }
else if (key ==
"colour") {
1955 WRITE_WARNINGF(
TL(
"Invalid color value '%' in relation %"), value, myCurrentRelation);
1957 }
else if (key ==
"ref") {
1959 }
else if (key ==
"interval" || key ==
"headway") {
1961 }
else if (key ==
"by_night") {
1970 if (myOSMEdges.find(ref) != myOSMEdges.end()) {
1981 if (myIsRestriction) {
1984 if (myRestrictionType == RestrictionType::UNKNOWN) {
2000 if (ok && !applyRestriction()) {
2003 }
else if (myIsStopArea) {
2004 for (
long long ref : myStops) {
2005 myStopAreas[ref] = myCurrentRelation;
2014 std::shared_ptr<NBPTStop> ptStop = myNBPTStopCont->get(
toString(n->
id));
2015 if (ptStop ==
nullptr) {
2022 if (myPlatform.isWay) {
2026 WRITE_WARNINGF(
TL(
"Platform '%' in relation: '%' is given as polygon, which currently is not supported."), myPlatform.ref, myCurrentRelation);
2041 WRITE_ERRORF(
"Unable to project coordinates for node '%'.", pNode->
id);
2044 p.push_back(pNodePos);
2046 if (p.size() == 0) {
2047 WRITE_WARNINGF(
TL(
"Referenced platform: '%' in relation: '%' is corrupt. Probably OSM file is incomplete."),
2052 ptStop->addPlatformCand(platform);
2063 WRITE_ERRORF(
"Unable to project coordinates for node '%'.", pNode->
id);
2065 NBPTPlatform platform(platformPos, myOptionsCont.getFloat(
"osm.stop-output.length"));
2066 ptStop->addPlatformCand(platform);
2070 ptStop->setIsMultipleStopPositions(myStops.size() > 1, myCurrentRelation);
2072 }
else if (myPTRouteType !=
"" && myIsRoute) {
2073 NBPTLine* ptLine =
new NBPTLine(
toString(myCurrentRelation), myName, myPTRouteType, myRef, myInterval, myNightService,
2075 bool hadGap =
false;
2076 int missingBefore = 0;
2077 int missingAfter = 0;
2078 for (
long long ref : myStops) {
2092 WRITE_WARNINGF(
TL(
"PT line '%' in relation % seems to be split, only keeping first part."), myName, myCurrentRelation);
2093 missingAfter = (int)myStops.size() - missingBefore - (int)ptLine->
getStops().size();
2097 const NIOSMNode*
const n = nodeIt->second;
2098 std::shared_ptr<NBPTStop> ptStop = myNBPTStopCont->get(
toString(n->
id));
2099 if (ptStop ==
nullptr) {
2103 WRITE_ERRORF(
"Unable to project coordinates for node '%'.", n->
id);
2106 myNBPTStopCont->insert(ptStop);
2107 if (myStopAreas.count(n->
id)) {
2108 ptStop->setIsMultipleStopPositions(
false, myStopAreas[n->
id]);
2110 if (myPlatformStops.count(n->
id) > 0) {
2111 ptStop->setIsPlatform();
2116 for (
long long& myWay : myWays) {
2117 auto entr = myOSMEdges.find(myWay);
2118 if (entr != myOSMEdges.end()) {
2119 Edge* edge = entr->second;
2125 ptLine->
setNumOfStops((
int)myStops.size(), missingBefore, missingAfter);
2127 WRITE_WARNINGF(
TL(
"PT line in relation % with no stops ignored. Probably OSM file is incomplete."), myCurrentRelation);
2132 if (!myNBPTLineCont->insert(ptLine)) {
2147 if (viaNode ==
nullptr) {
2153 if (from ==
nullptr) {
2157 if (to ==
nullptr) {
2161 if (myRestrictionType == RestrictionType::ONLY) {
2188 WRITE_WARNINGF(
TL(
"direction of restriction relation could not be determined%"),
"");
2196 const std::vector<NBEdge*>& candidates)
const {
2197 const std::string prefix =
toString(wayRef);
2198 const std::string backPrefix =
"-" + prefix;
2199 NBEdge* result =
nullptr;
2201 for (
auto candidate : candidates) {
2202 if ((candidate->getID().substr(0, prefix.size()) == prefix) ||
2203 (candidate->getID().substr(0, backPrefix.size()) == backPrefix)) {
2209 WRITE_WARNINGF(
TL(
"Ambiguous way reference '%' in restriction relation"), prefix);
2223 std::map<NBNode*, std::vector<std::pair<double, double> > > layerForces;
2226 std::set<NBNode*> knownElevation;
2227 for (
auto& myEdge :
myEdges) {
2228 Edge* e = myEdge.second;
2232 if (node !=
nullptr) {
2233 knownElevation.insert(node);
2234 layerForces[node].emplace_back(e->
myLayer * layerElevation, POSITION_EPS);
2239#ifdef DEBUG_LAYER_ELEVATION
2240 std::cout <<
"known elevations:\n";
2241 for (std::set<NBNode*>::iterator it = knownElevation.begin(); it != knownElevation.end(); ++it) {
2242 const std::vector<std::pair<double, double> >& primaryLayers = layerForces[*it];
2243 std::cout <<
" node=" << (*it)->
getID() <<
" ele=";
2244 for (std::vector<std::pair<double, double> >::const_iterator it_ele = primaryLayers.begin(); it_ele != primaryLayers.end(); ++it_ele) {
2245 std::cout << it_ele->first <<
" ";
2253 std::map<NBNode*, double> knownEleMax;
2254 for (
auto it : knownElevation) {
2255 double eleMax = -std::numeric_limits<double>::max();
2256 const std::vector<std::pair<double, double> >& primaryLayers = layerForces[it];
2257 for (
const auto& primaryLayer : primaryLayers) {
2258 eleMax =
MAX2(eleMax, primaryLayer.first);
2260 knownEleMax[it] = eleMax;
2263 bool changed =
true;
2266 for (
auto it = knownElevation.begin(); it != knownElevation.end(); ++it) {
2269 / gradeThreshold * 3,
2271 for (
auto& neighbor : neighbors) {
2272 if (knownElevation.count(neighbor.first) != 0) {
2273 const double grade = fabs(knownEleMax[*it] - knownEleMax[neighbor.first])
2274 /
MAX2(POSITION_EPS, neighbor.second.first);
2275#ifdef DEBUG_LAYER_ELEVATION
2276 std::cout <<
" grade at node=" << (*it)->getID() <<
" ele=" << knownEleMax[*it] <<
" neigh=" << it_neigh->first->getID() <<
" neighEle=" << knownEleMax[it_neigh->first] <<
" grade=" << grade <<
" dist=" << it_neigh->second.first <<
" speed=" << it_neigh->second.second <<
"\n";
2278 if (grade > gradeThreshold * 50 / 3.6 / neighbor.second.second) {
2280 const double eleMax =
MAX2(knownEleMax[*it], knownEleMax[neighbor.first]);
2281 if (knownEleMax[*it] < eleMax) {
2282 knownEleMax[*it] = eleMax;
2284 knownEleMax[neighbor.first] = eleMax;
2294 std::set<NBNode*> unknownElevation;
2295 for (
auto it = knownElevation.begin(); it != knownElevation.end(); ++it) {
2296 const double eleMax = knownEleMax[*it];
2297 const double maxDist = fabs(eleMax) * 100 / layerElevation;
2298 std::map<NBNode*, std::pair<double, double> > neighbors =
getNeighboringNodes(*it, maxDist, knownElevation);
2299 for (
auto& neighbor : neighbors) {
2300 if (knownElevation.count(neighbor.first) == 0) {
2301 unknownElevation.insert(neighbor.first);
2302 layerForces[neighbor.first].emplace_back(eleMax, neighbor.second.first);
2308 for (
auto it = unknownElevation.begin(); it != unknownElevation.end(); ++it) {
2309 double eleMax = -std::numeric_limits<double>::max();
2310 const std::vector<std::pair<double, double> >& primaryLayers = layerForces[*it];
2311 for (
const auto& primaryLayer : primaryLayers) {
2312 eleMax =
MAX2(eleMax, primaryLayer.first);
2314 const double maxDist = fabs(eleMax) * 100 / layerElevation;
2315 std::map<NBNode*, std::pair<double, double> > neighbors =
getNeighboringNodes(*it, maxDist, knownElevation);
2316 for (
auto& neighbor : neighbors) {
2317 if (knownElevation.count(neighbor.first) == 0 && unknownElevation.count(neighbor.first) == 0) {
2318 layerForces[*it].emplace_back(0, neighbor.second.first);
2323#ifdef DEBUG_LAYER_ELEVATION
2324 std::cout <<
"summation of forces\n";
2326 std::map<NBNode*, double> nodeElevation;
2327 for (
auto& layerForce : layerForces) {
2328 const std::vector<std::pair<double, double> >& forces = layerForce.second;
2329 if (knownElevation.count(layerForce.first) != 0) {
2337#ifdef DEBUG_LAYER_ELEVATION
2338 std::cout <<
" node=" << it->first->getID() <<
" knownElevation=" << knownEleMax[it->first] <<
"\n";
2340 nodeElevation[layerForce.first] = knownEleMax[layerForce.first];
2341 }
else if (forces.size() == 1) {
2342 nodeElevation[layerForce.first] = forces.front().first;
2346 for (
const auto& force : forces) {
2347 distSum += force.second;
2349 double weightSum = 0;
2350 double elevation = 0;
2351#ifdef DEBUG_LAYER_ELEVATION
2352 std::cout <<
" node=" << it->first->getID() <<
" distSum=" << distSum <<
"\n";
2354 for (
const auto& force : forces) {
2355 const double weight = (distSum - force.second) / distSum;
2356 weightSum += weight;
2357 elevation += force.first * weight;
2359#ifdef DEBUG_LAYER_ELEVATION
2360 std::cout <<
" force=" << it_force->first <<
" dist=" << it_force->second <<
" weight=" << weight <<
" ele=" << elevation <<
"\n";
2363 nodeElevation[layerForce.first] = elevation / weightSum;
2366#ifdef DEBUG_LAYER_ELEVATION
2367 std::cout <<
"final elevations:\n";
2368 for (std::map<NBNode*, double>::iterator it = nodeElevation.begin(); it != nodeElevation.end(); ++it) {
2369 std::cout <<
" node=" << (it->first)->getID() <<
" ele=" << it->second <<
"\n";
2373 for (
auto& it : nodeElevation) {
2380 for (
const auto& it : ec) {
2381 NBEdge* edge = it.second;
2383 const double length = geom.
length2D();
2384 const double zFrom = nodeElevation[edge->
getFromNode()];
2385 const double zTo = nodeElevation[edge->
getToNode()];
2390 for (
auto it_pos = geom.begin(); it_pos != geom.end(); ++it_pos) {
2391 if (it_pos != geom.begin()) {
2392 dist += (*it_pos).distanceTo2D(*(it_pos - 1));
2394 newGeom.push_back((*it_pos) +
Position(0, 0, zFrom + (zTo - zFrom) * dist / length));
2400std::map<NBNode*, std::pair<double, double> >
2402 std::map<NBNode*, std::pair<double, double> > result;
2403 std::set<NBNode*> visited;
2404 std::vector<NBNode*> open;
2405 open.push_back(node);
2406 result[node] = std::make_pair(0, 0);
2407 while (!open.empty()) {
2410 if (visited.count(n) != 0) {
2415 for (
auto e : edges) {
2418 s = e->getFromNode();
2422 const double dist = result[n].first + e->getGeometry().length2D();
2423 const double speed =
MAX2(e->getSpeed(), result[n].second);
2424 if (result.count(s) == 0) {
2425 result[s] = std::make_pair(dist, speed);
2427 result[s] = std::make_pair(
MIN2(dist, result[s].first),
MAX2(speed, result[s].second));
2429 if (dist < maxDist && knownElevation.count(s) == 0) {
2441 if (tc.
knows(type)) {
2452 std::vector<std::string> types;
2454 std::string t = tok.
next();
2456 if (std::find(types.begin(), types.end(), t) == types.end()) {
2459 }
else if (tok.
size() > 1) {
2461 WRITE_WARNINGF(
TL(
"Discarding unknown compound '%' in type '%' (first occurrence for edge '%')."), t, type,
id);
2465 if (types.empty()) {
2467 WRITE_WARNINGF(
TL(
"Discarding unusable type '%' (first occurrence for edge '%')."), type,
id);
2473 if (tc.
knows(newType)) {
2481 double maxSpeed = 0;
2486 bool defaultIsOneWay =
true;
2489 bool discard =
true;
2490 bool hadDiscard =
false;
2491 for (
auto& type2 : types) {
2508 if (hadDiscard && permissions == 0) {
2512 WRITE_WARNINGF(
TL(
"Discarding compound type '%' (first occurrence for edge '%')."), newType,
id);
2527 WRITE_MESSAGEF(
TL(
"Adding new type '%' (first occurrence for edge '%')."), type,
id);
2528 tc.
insertEdgeType(newType, numLanes, maxSpeed, prio, permissions, spreadType, width,
2529 defaultIsOneWay, sidewalkWidth, bikelaneWidth, 0, 0, 0);
2530 for (
auto& type3 : types) {
2545 std::vector<NIOSMNode*> nodes;
2546 std::vector<double> usablePositions;
2547 std::vector<int> usableIndex;
2551 if (node->
positionMeters != std::numeric_limits<double>::max()) {
2553 usableIndex.push_back((
int)nodes.size());
2555 nodes.push_back(node);
2557 if (usablePositions.size() == 0) {
2560 bool forward =
true;
2561 if (usablePositions.size() == 1) {
2562 WRITE_WARNINGF(
TL(
"Ambiguous railway kilometrage direction for way '%' (assuming forward)"),
id);
2564 forward = usablePositions.front() < usablePositions.back();
2567 for (
int i = 1; i < (int)usablePositions.size(); i++) {
2568 if ((usablePositions[i - 1] < usablePositions[i]) != forward) {
2569 WRITE_WARNINGF(
TL(
"Inconsistent railway kilometrage direction for way '%': % (skipping)"),
id,
toString(usablePositions));
2573 if (nodes.size() > usablePositions.size()) {
2577 shape.push_back(
Position(node->lon, node->lat, 0));
2582 double sign = forward ? 1 : -1;
2584 for (
int i = usableIndex.front() - 1; i >= 0; i--) {
2585 nodes[i]->positionMeters = nodes[i + 1]->positionMeters - sign * shape[i].distanceTo2D(shape[i + 1]);
2588 for (
int i = usableIndex.front() + 1; i < (int)nodes.size(); i++) {
2589 if (nodes[i]->positionMeters == std::numeric_limits<double>::max()) {
2590 nodes[i]->positionMeters = nodes[i - 1]->positionMeters + sign * shape[i].distanceTo2D(shape[i - 1]);
2617 return std::numeric_limits<double>::max();
2623 if (type ==
"train") {
2625 }
else if (type ==
"subway") {
2627 }
else if (type ==
"aerialway") {
2629 }
else if (type ==
"light_rail" || type ==
"monorail") {
2631 }
else if (type ==
"share_taxi") {
2633 }
else if (type ==
"minibus") {
2635 }
else if (type ==
"trolleybus") {
2640 std::string stop =
"";
2643 }
else if (result ==
SVC_BUS) {
2658 bool multiLane = changeProhibition > 3;
2660 for (
int lane = 0; changeProhibition > 0 && lane < e->
getNumLanes(); lane++) {
2661 int code = changeProhibition % 4;
2666 changeProhibition = changeProhibition >> 2;
2680 for (
int lane = 0; lane < numLanes; lane++) {
2682 const int i = lefthand ? lane : numLanes - 1 - lane;
2687 if (i < (
int)designated.size() && designated[i]) {
2699 if (signs.empty()) {
2700 signs.insert(signs.begin(), signs2.begin(), signs2.end());
2702 for (
int i = 0; i < (int)
MIN2(signs.size(), signs2.size()); i++) {
2703 signs[i] |= signs2[i];
2715 for (
int i = 0; i < (int)turnSigns.size(); i++) {
#define WRITE_WARNINGF(...)
#define WRITE_MESSAGEF(...)
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
#define PROGRESS_TIME_MESSAGE(before)
#define PROGRESS_DONE_MESSAGE()
#define PROGRESS_BEGIN_MESSAGE(msg)
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
SVCPermissions extraDisallowed(SVCPermissions disallowed, const MMVersion &networkVersion)
Interprets disallowed vehicles depending on network version.
const SVCPermissions SVCAll
all VClasses are allowed
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permissions is a railway edge.
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_SHIP
is an arbitrary ship
@ SVC_PRIVATE
private vehicles
@ SVC_TRUCK
vehicle is a large transport vehicle
@ SVC_ROAD_CLASSES
classes which drive on roads
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_RAIL
vehicle is a not electrified rail
@ SVC_RAIL_CLASSES
classes which drive on tracks
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_RAIL_FAST
vehicle that is allowed to drive on high-speed rail tracks
@ SVC_TRAILER
vehicle is a large transport vehicle
@ SVC_RAIL_ELECTRIC
rail vehicle that requires electrified tracks
@ SVC_RAIL_URBAN
vehicle is a city rail
@ SVC_EMERGENCY
public emergency vehicles
@ SVC_AUTHORITY
authorities vehicles
@ SVC_TRAM
vehicle is a light rail
@ SVC_PUBLIC_CLASSES
public transport
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
@ SVC_PEDESTRIAN
pedestrian
@ SUMO_TAG_NODE
alternative definition for junction
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
@ PARTLEFT
The link is a partial left direction.
@ RIGHT
The link is a (hard) right direction.
@ TURN
The link is a 180 degree turn.
@ LEFT
The link is a (hard) left direction.
@ STRAIGHT
The link is a straight direction.
@ PARTRIGHT
The link is a partial right direction.
@ NODIR
The link has no direction (is a dead end link)
const double SUMO_const_laneWidth
std::string joinToStringSorting(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static bool isReadable(std::string path)
Checks whether the given file is readable.
void setFileName(const std::string &name)
Sets the current file name.
bool wasInformed() const
Returns the information whether any messages were added.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Storage for edges, including some functionality operating on multiple edges.
int extractRoundabouts()
Determines which edges have been marked as roundabouts and stores them internally.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
The representation of a single edge during network building.
static const int TURN_SIGN_SHIFT_BUS
shift values for decoding turn signs
static const int TURN_SIGN_SHIFT_BICYCLE
void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight)
set allowed classes for changing to the left and right from the given lane
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given
void addBikeLane(double width)
add a bicycle lane of the given width and shift existing connctions
NBNode * getToNode() const
Returns the destination node of the edge.
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Lane & getLaneStruct(int lane)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
bool addEdge2EdgeConnection(NBEdge *dest, bool overrideRemoval=false, SVCPermissions permission=SVC_UNSPECIFIED)
Adds a connection to another edge.
void setTurnSignTarget(const std::string &target)
void setDistance(double distance)
set kilometrage at start of edge (negative value implies couting down along the edge)
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
const std::string & getID() const
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
int getNumLanes() const
Returns the number of lanes.
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false, const bool keepPossibleTurns=false)
Removes the specified connection(s)
bool isConnectedTo(const NBEdge *e, const bool ignoreTurnaround=false) const
Returns the information whethe a connection to the given edge has been added (or computed)
static const int TURN_SIGN_SHIFT_TAXI
void preferVehicleClass(int lane, SVCPermissions vclasses)
prefer certain vehicle classes for the given lane or for all lanes if -1 is given (ensures also permi...
NBNode * getFromNode() const
Returns the origin node of the edge.
static const double UNSPECIFIED_WIDTH
unspecified lane width
static const double UNSPECIFIED_OFFSET
unspecified lane offset
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
Instance responsible for building networks.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
NBPTLineCont & getPTLineCont()
Returns a reference to the pt line container.
NBParkingCont & getParkingCont()
NBPTStopCont & getPTStopCont()
Returns a reference to the pt stop container.
NBNodeCont & getNodeCont()
Returns a reference to the node container.
NBEdgeCont & getEdgeCont()
NBTypeCont & getTypeCont()
Returns a reference to the type container.
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
static bool transformCoordinate(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
Container for nodes during the netbuilding process.
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Represents a single node (junction) during network building.
bool hasIncoming(const NBEdge *const e) const
Returns whether the given edge ends at this node.
NBNode::Crossing * addCrossing(EdgeVector edges, double width, bool priority, int tlIndex=-1, int tlIndex2=-1, const PositionVector &customShape=PositionVector::EMPTY, bool fromSumoNet=false, const Parameterised *params=nullptr)
add a pedestrian crossing to this node
void reinit(const Position &position, SumoXMLNodeType type, bool updateEdgeGeometries=false)
Resets initial values.
SumoXMLNodeType getType() const
Returns the type of this node.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
bool checkCrossingDuplicated(EdgeVector edges)
return true if there already exist a crossing with the same edges as the input
const Position & getPosition() const
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node)
static const int FORWARD
edge directions (for pedestrian related stuff)
void setFringeType(FringeType fringeType)
set method for computing right-of-way
A traffic light logics which must be computed (only nodes/edges are given)
void setNumOfStops(int numStops, int missingBefore, int missingAfter)
void addWayNode(long long int way, long long int node)
const std::vector< std::shared_ptr< NBPTStop > > & getStops()
void addPTStop(std::shared_ptr< NBPTStop > pStop)
Container for public transport stops during the net building process.
int cleanupDeleted(NBEdgeCont &cont)
remove stops on non existing (removed) edges
const std::map< std::string, std::shared_ptr< NBPTStop > > & getStops() const
Returns an unmodifiable reference to the stored pt stops.
std::shared_ptr< NBPTStop > get(std::string id) const
Retrieve a previously inserted pt stop.
bool insert(std::shared_ptr< NBPTStop > ptStop, bool floating=false)
Inserts a node into the map.
The representation of an imported parking area.
static const std::string OSM_DIRECTION
processing parameter for rail signal edges and nodes
static const std::string OSM_SIGNAL_DIRECTION
A container for traffic light definitions and built programs.
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
A storage for available edgeTypes of edges.
bool getEdgeTypeShallBeDiscarded(const std::string &edgeType) const
Returns the information whether edges of this edgeType shall be discarded.
void insertEdgeType(const std::string &id, int numLanes, double maxSpeed, int prio, SVCPermissions permissions, LaneSpreadFunction spreadType, double width, bool oneWayIsDefault, double sidewalkWidth, double bikeLaneWidth, double widthResolution, double maxWidth, double minWidth)
Adds a edgeType into the list.
bool copyEdgeTypeRestrictionsAndAttrs(const std::string &fromId, const std::string &toId)
Copy restrictions to a edgeType.
double getEdgeTypeSpeed(const std::string &edgeType) const
Returns the maximal velocity for the given edgeType [m/s].
int getEdgeTypePriority(const std::string &edgeType) const
Returns the priority for the given edgeType.
int getEdgeTypeNumLanes(const std::string &edgeType) const
Returns the number of lanes for the given edgeType.
double getEdgeTypeWidth(const std::string &edgeType) const
Returns the lane width for the given edgeType [m].
SVCPermissions getEdgeTypePermissions(const std::string &edgeType) const
Returns allowed vehicle classes for the given edgeType.
bool knows(const std::string &edgeType) const
Returns whether the named edgeType is in the container.
double getEdgeTypeSidewalkWidth(const std::string &edgeType) const
Returns the lane width for a sidewalk to be added [m].
LaneSpreadFunction getEdgeTypeSpreadType(const std::string &edgeType) const
Returns spreadType for the given edgeType.
double getEdgeTypeBikeLaneWidth(const std::string &edgeType) const
Returns the lane width for a bike lane to be added [m].
bool getEdgeTypeIsOneWay(const std::string &edgeType) const
Returns whether edges are one-way per default for the given edgeType.
Functor which compares two Edges.
bool operator()(const Edge *e1, const Edge *e2) const
An internal definition of a loaded edge.
std::vector< SVCPermissions > myDisallowedLaneBackward
(optional) information about additional disallowed SVCs on backward lane(s)
std::map< std::string, std::string > myExtraTags
Additionally tagged information.
std::vector< double > myWidthLanesForward
Information on lane width.
WayType mySidewalkType
Information about the kind of sidwalk along this road.
std::vector< double > myWidthLanesBackward
std::vector< SVCPermissions > myDisallowedLaneForward
(optional) information about additional disallowed SVCs on forward lane(s)
bool myCurrentIsRoad
Information whether this is a road.
WayType myCyclewayType
Information about the kind of cycleway along this road.
std::vector< int > myTurnSignsBackward
int myNoLanesForward
number of lanes in forward direction or 0 if unknown, negative if backwards lanes are meant
double myMaxSpeed
maximum speed in km/h, or MAXSPEED_UNGIVEN
std::string ref
The edge's track name.
std::vector< SVCPermissions > myAllowedLaneForward
(optional) information about additional allowed SVCs on forward lane(s)
std::string myHighWayType
The type, stored in "highway" key.
const long long int id
The edge's id.
bool myAmInRoundabout
Information whether this road is part of a roundabout.
int myLayer
Information about the relative z-ordering of ways.
std::vector< bool > myDesignatedLaneBackward
(optional) information about whether the backward lanes are designated to some SVCs
SVCPermissions myExtraDisallowed
Extra permissions prohibited from tags instead of highway type.
std::vector< SVCPermissions > myAllowedLaneBackward
(optional) information about additional allowed SVCs on backward lane(s)
int myNoLanes
number of lanes, or -1 if unknown
std::vector< int > myTurnSignsForward
turning direction (arrows printed on the road)
std::vector< long long int > myCurrentNodes
The list of nodes this edge is made of.
int myParkingType
Information about road-side parking.
double myMaxSpeedBackward
maximum speed in km/h, or MAXSPEED_UNGIVEN
WayType myBuswayType
Information about the kind of busway along this road.
int myChangeForward
Information about change prohibitions (forward direction.
SVCPermissions myExtraAllowed
Extra permissions added from tags instead of highway type.
int myChangeBackward
Information about change prohibitions (backward direction.
std::string streetName
The edge's street name.
WayType myRailDirection
Information about the direction(s) of railway usage.
std::vector< bool > myDesignatedLaneForward
(optional) information about whether the forward lanes are designated to some SVCs
std::string myIsOneWay
Information whether this is an one-way road.
A class which extracts OSM-edges from a parsed OSM-file.
void interpretLaneUse(const std::string &value, SUMOVehicleClass svc, const bool forward) const
EdgesHandler(const std::map< long long int, NIOSMNode * > &osmNodes, std::map< long long int, Edge * > &toFill, std::map< long long int, Edge * > &platformShapes)
Constructor.
int interpretChangeType(const std::string &value) const
~EdgesHandler() override
Destructor.
void myEndElement(int element) override
Called when a closing tag occurs.
double interpretSpeed(const std::string &key, std::string value)
std::map< std::string, double > mySpeedMap
A map of non-numeric speed descriptions to their numeric values.
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
A class which extracts OSM-nodes from a parsed OSM-file.
~NodesHandler() override
Destructor.
int getDuplicateNodes() const
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
NodesHandler(std::map< long long int, NIOSMNode * > &toFill, std::set< NIOSMNode *, CompareNodes > &uniqueNodes, const OptionsCont &cont)
Constructor.
void myEndElement(int element) override
Called when a closing tag occurs.
StringVector myRailSignalRules
custom requirements for rail signal tagging
A class which extracts relevant relation information from a parsed OSM-file.
void myEndElement(int element) override
Called when a closing tag occurs.
void resetValues()
reset members to their defaults for parsing a new relation
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
~RelationHandler() override
Destructor.
RelationHandler(const std::map< long long int, NIOSMNode * > &osmNodes, const std::map< long long int, Edge * > &osmEdges, NBPTStopCont *nbptStopCont, const std::map< long long int, Edge * > &platfromShapes, NBPTLineCont *nbptLineCont, const OptionsCont &oc)
Constructor.
bool checkEdgeRef(long long int ref) const
check whether a referenced way has a corresponding edge
bool applyRestriction() const
try to apply the parsed restriction and return whether successful
NBEdge * findEdgeRef(long long int wayRef, const std::vector< NBEdge * > &candidates) const
try to find the way segment among candidates
Importer for networks stored in OpenStreetMap format.
int insertEdge(Edge *e, int index, NBNode *from, NBNode *to, const std::vector< long long int > &passed, NBNetBuilder &nb, const NBNode *first, const NBNode *last)
Builds an NBEdge.
std::map< long long int, Edge * > myEdges
the map from OSM way ids to edge objects
bool myImportCrossings
import crossings
std::map< long long int, NIOSMNode * > myOSMNodes
the map from OSM node ids to actual nodes
NIImporter_OpenStreetMap()
static void loadNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given OSM file.
static const long long int INVALID_ID
void applyLaneUse(NBEdge *e, NIImporter_OpenStreetMap::Edge *nie, const bool forward)
Applies lane use information from nie to e.
static const double MAXSPEED_UNGIVEN
~NIImporter_OpenStreetMap()
std::map< long long int, Edge * > myPlatformShapes
the map from OSM way ids to platform shapes
void load(const OptionsCont &oc, NBNetBuilder &nb)
void applyTurnSigns(NBEdge *e, const std::vector< int > &turnSigns)
bool myImportSidewalks
import sidewalks
std::set< NIOSMNode *, CompareNodes > myUniqueNodes
the set of unique nodes used in NodesHandler, used when freeing memory
static bool myAllAttributes
whether additional way and node attributes shall be imported
void reconstructLayerElevation(double layerElevation, NBNetBuilder &nb)
reconstruct elevation from layer info
static SUMOVehicleClass interpretTransportType(const std::string &type, NIOSMNode *toSet=nullptr)
translate osm transport designations into sumo vehicle class
bool myImportLaneAccess
import lane specific access restrictions
bool myImportTurnSigns
import turning signals (turn:lanes) to guide connection building
std::map< std::string, std::string > myKnownCompoundTypes
The compound types that have already been mapped to other known types.
static const std::string compoundTypeSeparator
The separator within newly created compound type names.
std::set< std::string > myUnusableTypes
The compounds types that do not contain known types.
std::map< NBNode *, std::pair< double, double > > getNeighboringNodes(NBNode *node, double maxDist, const std::set< NBNode * > &knownElevation)
collect neighboring nodes with their road distance and maximum between-speed. Search does not continu...
static std::set< std::string > myExtraAttributes
extra attributes to import
bool myImportBikeAccess
import bike path specific permissions and directions
static double interpretDistance(NIOSMNode *node)
read distance value from node and return value in m
NBNode * insertNodeChecking(long long int id, NBNodeCont &nc, NBTrafficLightLogicCont &tlsc)
Builds an NBNode.
static void mergeTurnSigns(std::vector< int > &signs, std::vector< int > signs2)
void extendRailwayDistances(Edge *e, NBTypeCont &tc)
extend kilometrage data for all nodes along railway
std::string usableType(const std::string &type, const std::string &id, NBTypeCont &tc)
check whether the type is known or consists of known type compounds. return empty string otherwise
static void applyChangeProhibition(NBEdge *e, int changeProhibition)
const std::string & getID() const
Returns the id.
A storage for options typed value containers)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
static OptionsCont & getOptions()
Retrieves the options.
void unsetParameter(const std::string &key)
Removes a parameter.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
void updateParameters(const Parameterised::Map &mapArg)
Adds or updates all given parameters from the map.
A point in 2D or 3D with translation and scaling methods.
double length2D() const
Returns the length.
double length() const
Returns the length.
PositionVector reverse() const
reverse position vector
static RGBColor parseColor(std::string coldef)
Parses a color information.
Encapsulated SAX-Attributes.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SAX-handler base for SUMO-files.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
T get(const std::string &str) const
int size() const
returns the number of existing substrings
std::vector< std::string > getVector()
return vector of strings
bool hasNext()
returns the information whether further substrings exist
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
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,...
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
static std::string prune(const std::string &str)
Removes trailing and leading whitechars.
static double parseDist(const std::string &sData)
parse a distance, length or width value with a unit
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
static double parseSpeed(const std::string &sData, const bool defaultKmph=true)
parse a speed value with a unit
static bool endsWith(const std::string &str, const std::string suffix)
Checks whether a given string ends with the suffix.
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
static SUMOSAXReader * getSAXReader(SUMOSAXHandler &handler, const bool isNet=false, const bool isRoute=false)
Builds a reader and assigns the handler to it.
An (internal) definition of a single lane of an edge.
int turnSigns
turning signs printed on the road, bitset of LinkDirection (imported from OSM)
An internal representation of an OSM-node.
SVCPermissions permissions
type of pt stop
NBNode * node
the NBNode that was instantiated
double positionMeters
position converted to m (using highest precision available)
std::string position
kilometrage/mileage
const long long int id
The node's id.
bool pedestrianCrossing
Whether this is a pedestrian crossing.
bool tlsControlled
Whether this is a tls controlled junction.
double ptStopLength
The length of the pt stop.
bool ptStopPosition
Whether this is a public transport stop position.
std::string name
The name of the node.
bool railwayCrossing
Whether this is a railway crossing.
double ele
The elevation of this node.
bool railwayBufferStop
Whether this is a railway buffer stop.
const double lon
The longitude the node is located at.
const double lat
The latitude the node is located at.
bool railwaySignal
Whether this is a railway (main) signal.
WayType myRailDirection
Information about the direction(s) of railway usage.