Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NIImporter_SUMO.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
21// Importer for networks stored in SUMO format
22/****************************************************************************/
23#include <config.h>
24#include <string>
34#include <utils/xml/XMLSubSys.h>
38#include <netbuild/NBEdge.h>
39#include <netbuild/NBEdgeCont.h>
40#include <netbuild/NBNode.h>
41#include <netbuild/NBNodeCont.h>
44#include "NILoader.h"
45#include "NIXMLTypesHandler.h"
46#include "NIImporter_SUMO.h"
47
48
49// ===========================================================================
50// method definitions
51// ===========================================================================
52// ---------------------------------------------------------------------------
53// static methods (interface in this case)
54// ---------------------------------------------------------------------------
55void
57 NIImporter_SUMO importer(nb);
58 importer._loadNetwork(oc);
59}
60
61
62// ---------------------------------------------------------------------------
63// loader methods
64// ---------------------------------------------------------------------------
66 : SUMOSAXHandler("sumo-network"),
67 myNetBuilder(nb),
68 myNodeCont(nb.getNodeCont()),
69 myTLLCont(nb.getTLLogicCont()),
70 myTypesHandler(nb.getTypeCont()),
71 myCurrentEdge(nullptr),
72 myCurrentLane(nullptr),
73 myCurrentTL(nullptr),
74 myLocation(nullptr),
75 myNetworkVersion(0, 0),
76 myHaveSeenInternalEdge(false),
77 myAmLefthand(false),
78 myChangeLefthand(false),
79 myCornerDetail(0),
80 myLinkDetail(-1),
81 myRectLaneCut(false),
82 myWalkingAreas(false),
83 myLimitTurnSpeed(-1),
84 myCheckLaneFoesAll(false),
85 myCheckLaneFoesRoundabout(true),
86 myTlsIgnoreInternalJunctionJam(false),
87 myDefaultSpreadType(toString(LaneSpreadFunction::RIGHT)),
88 myGeomAvoidOverlap(true),
89 myJunctionsHigherSpeed(false),
90 myInternalJunctionsVehicleWidth(OptionsCont::getOptions().getFloat("internal-junctions.vehicle-width")) {
91}
92
93
95 for (std::map<std::string, EdgeAttrs*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
96 EdgeAttrs* ed = (*i).second;
97 for (std::vector<LaneAttrs*>::const_iterator j = ed->lanes.begin(); j != ed->lanes.end(); ++j) {
98 delete *j;
99 }
100 delete ed;
101 }
102 delete myLocation;
103}
104
105
106void
108 // check whether the option is set (properly)
109 if (!oc.isUsableFileList("sumo-net-file")) {
110 return;
111 }
112 const std::vector<std::string> discardableParams = oc.getStringVector("discard-params");
113 myDiscardableParams.insert(discardableParams.begin(), discardableParams.end());
114 // parse file(s)
115 const std::vector<std::string> files = oc.getStringVector("sumo-net-file");
116 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
117 if (!FileHelpers::isReadable(*file)) {
118 WRITE_ERRORF(TL("Could not open sumo-net-file '%'."), *file);
119 return;
120 }
121 setFileName(*file);
122 const long before = PROGRESS_BEGIN_TIME_MESSAGE("Parsing sumo-net from '" + *file + "'");
123 XMLSubSys::runParser(*this, *file, true);
124 PROGRESS_TIME_MESSAGE(before);
125 }
126 // build edges
127 const double maxSegmentLength = oc.getFloat("geometry.max-segment-length");
128 for (std::map<std::string, EdgeAttrs*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
129 EdgeAttrs* ed = (*i).second;
130 // skip internal edges
132 continue;
133 }
134 // get and check the nodes
135 NBNode* from = myNodeCont.retrieve(ed->fromNode);
136 NBNode* to = myNodeCont.retrieve(ed->toNode);
137 if (from == nullptr) {
138 WRITE_ERRORF(TL("Edge's '%' from-node '%' is not known."), ed->id, ed->fromNode);
139 continue;
140 }
141 if (to == nullptr) {
142 WRITE_ERRORF(TL("Edge's '%' to-node '%' is not known."), ed->id, ed->toNode);
143 continue;
144 }
145 if (from == to) {
146 WRITE_ERRORF(TL("Edge's '%' from-node and to-node '%' are identical."), ed->id, ed->toNode);
147 continue;
148 }
149 if (ed->shape.size() == 0 && maxSegmentLength > 0) {
150 ed->shape.push_back(from->getPosition());
151 ed->shape.push_back(to->getPosition());
152 // shape is already cartesian but we must use a copy because the original will be modified
153 NBNetBuilder::addGeometrySegments(ed->shape, PositionVector(ed->shape), maxSegmentLength);
154 }
155 // build and insert the edge
156 NBEdge* e = new NBEdge(ed->id, from, to,
158 (int) ed->lanes.size(),
160 ed->shape, ed->lsf, ed->streetName, "", true); // always use tryIgnoreNodePositions to keep original shape
161 e->setLoadedLength(ed->length);
163 e->setDistance(ed->distance);
164 if (!myNetBuilder.getEdgeCont().insert(e)) {
165 WRITE_ERRORF(TL("Could not insert edge '%'."), ed->id);
166 delete e;
167 continue;
168 }
170 if (ed->builtEdge != nullptr) {
172 ed->builtEdge->setBidi(ed->bidi != "");
173 }
174 }
175 // assign further lane attributes (edges are built)
176 EdgeVector toRemove;
177 const bool dismissVclasses = oc.getBool("dismiss-vclasses");
178 for (std::map<std::string, EdgeAttrs*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
179 EdgeAttrs* ed = (*i).second;
180 NBEdge* nbe = ed->builtEdge;
181 if (nbe == nullptr) { // inner edge or removed by explicit list, vclass, ...
182 continue;
183 }
184 const SumoXMLNodeType toType = nbe->getToNode()->getType();
185 for (int fromLaneIndex = 0; fromLaneIndex < (int) ed->lanes.size(); ++fromLaneIndex) {
186 LaneAttrs* lane = ed->lanes[fromLaneIndex];
187 // connections
188 const std::vector<Connection>& connections = lane->connections;
189 for (const Connection& c : connections) {
190 if (myEdges.count(c.toEdgeID) == 0) {
191 WRITE_ERRORF(TL("Unknown edge '%' given in connection."), c.toEdgeID);
192 continue;
193 }
194 NBEdge* toEdge = myEdges[c.toEdgeID]->builtEdge;
195 if (toEdge == nullptr) { // removed by explicit list, vclass, ...
196 continue;
197 }
198 if (toEdge->getFromNode() != nbe->getToNode()) { // inconsistency may occur when merging networks
199 WRITE_WARNINGF("Removing invalid connection from edge '%' to edge '%'", nbe->getID(), toEdge->getID());
200 continue;
201 }
202 // patch attribute uncontrolled for legacy networks where it is not set explicitly
203 bool uncontrolled = c.uncontrolled;
204
206 && c.tlLinkIndex == NBConnection::InvalidTlIndex) {
207 uncontrolled = true;
208 }
210 fromLaneIndex, toEdge, c.toLaneIdx, NBEdge::Lane2LaneInfoType::VALIDATED,
211 true, c.mayDefinitelyPass, c.keepClear ? KEEPCLEAR_TRUE : KEEPCLEAR_FALSE,
212 c.contPos, c.visibility, c.speed, c.friction, c.customLength, c.customShape, uncontrolled, c.permissions, c.indirectLeft, c.edgeType, c.changeLeft, c.changeRight);
213 if (c.getParametersMap().size() > 0) {
214 nbe->getConnectionRef(fromLaneIndex, toEdge, c.toLaneIdx).updateParameters(c.getParametersMap());
215 }
216 // maybe we have a tls-controlled connection
217 if (c.tlID != "" && myRailSignals.count(c.tlID) == 0) {
218 const std::map<std::string, NBTrafficLightDefinition*>& programs = myTLLCont.getPrograms(c.tlID);
219 if (programs.size() > 0) {
220 std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
221 for (it = programs.begin(); it != programs.end(); it++) {
222 NBLoadedSUMOTLDef* tlDef = dynamic_cast<NBLoadedSUMOTLDef*>(it->second);
223 if (tlDef) {
224 tlDef->addConnection(nbe, toEdge, fromLaneIndex, c.toLaneIdx, c.tlLinkIndex, c.tlLinkIndex2, false);
225 } else {
226 throw ProcessError("Corrupt traffic light definition '" + c.tlID + "' (program '" + it->first + "')");
227 }
228 }
229 } else {
230 WRITE_ERRORF(TL("The traffic light '%' is not known."), c.tlID);
231 }
232 }
233 }
234 // allow/disallow XXX preferred
235 if (!dismissVclasses) {
236 nbe->setPermissions(parseVehicleClasses(lane->allow, lane->disallow, myNetworkVersion), fromLaneIndex);
237 }
238 nbe->setPermittedChanging(fromLaneIndex, parseVehicleClasses(lane->changeLeft, ""), parseVehicleClasses(lane->changeRight, ""));
239 // width, offset
240 nbe->setLaneWidth(fromLaneIndex, lane->width);
241 nbe->setEndOffset(fromLaneIndex, lane->endOffset);
242 nbe->setSpeed(fromLaneIndex, lane->maxSpeed);
243 nbe->setFriction(fromLaneIndex, lane->friction);
244 nbe->setAcceleration(fromLaneIndex, lane->accelRamp);
245 nbe->getLaneStruct(fromLaneIndex).oppositeID = lane->oppositeID;
246 nbe->getLaneStruct(fromLaneIndex).type = lane->type;
247 nbe->getLaneStruct(fromLaneIndex).updateParameters(lane->getParametersMap());
248 if (lane->customShape) {
249 nbe->setLaneShape(fromLaneIndex, lane->shape);
250 }
251 // stop offset for lane
252 bool stopOffsetSet = false;
253 if (lane->laneStopOffset.isDefined() || nbe->getEdgeStopOffset().isDefined()) {
254 // apply lane-specific stopOffset (might be none as well)
255 stopOffsetSet = nbe->setEdgeStopOffset(fromLaneIndex, lane->laneStopOffset);
256 }
257 if (!stopOffsetSet) {
258 // apply default stop offset to lane
259 nbe->setEdgeStopOffset(fromLaneIndex, nbe->getEdgeStopOffset());
260 }
261 }
263 if (!nbe->hasLaneSpecificWidth() && nbe->getLanes()[0].width != NBEdge::UNSPECIFIED_WIDTH) {
264 nbe->setLaneWidth(-1, nbe->getLaneWidth(0));
265 }
267 nbe->setEndOffset(-1, nbe->getEndOffset(0));
268 }
270 nbe->setEdgeStopOffset(-1, nbe->getEdgeStopOffset());
271 }
272 // check again after permissions are set
275 toRemove.push_back(nbe);
276 }
277 }
278 for (EdgeVector::iterator i = toRemove.begin(); i != toRemove.end(); ++i) {
280 }
281 // insert loaded prohibitions
282 for (std::vector<Prohibition>::const_iterator it = myProhibitions.begin(); it != myProhibitions.end(); it++) {
283 NBEdge* prohibitedFrom = myEdges[it->prohibitedFrom]->builtEdge;
284 NBEdge* prohibitedTo = myEdges[it->prohibitedTo]->builtEdge;
285 NBEdge* prohibitorFrom = myEdges[it->prohibitorFrom]->builtEdge;
286 NBEdge* prohibitorTo = myEdges[it->prohibitorTo]->builtEdge;
287 if (prohibitedFrom == nullptr) {
288 WRITE_WARNINGF(TL("Edge '%' in prohibition was not built."), it->prohibitedFrom);
289 } else if (prohibitedTo == nullptr) {
290 WRITE_WARNINGF(TL("Edge '%' in prohibition was not built."), it->prohibitedTo);
291 } else if (prohibitorFrom == nullptr) {
292 WRITE_WARNINGF(TL("Edge '%' in prohibition was not built."), it->prohibitorFrom);
293 } else if (prohibitorTo == nullptr) {
294 WRITE_WARNINGF(TL("Edge '%' in prohibition was not built."), it->prohibitorTo);
295 } else {
296 NBNode* n = prohibitedFrom->getToNode();
298 NBConnection(prohibitorFrom, prohibitorTo),
299 NBConnection(prohibitedFrom, prohibitedTo));
300 }
301 }
302 if (!myHaveSeenInternalEdge && oc.isWriteable("no-internal-links")) {
303 oc.set("no-internal-links", "true");
304 }
305 if (oc.isWriteable("lefthand")) {
306 oc.set("lefthand", toString(myAmLefthand));
307 }
308 if (oc.isWriteable("junctions.corner-detail")) {
309 oc.set("junctions.corner-detail", toString(myCornerDetail));
310 }
311 if (oc.isWriteable("junctions.internal-link-detail") && myLinkDetail > 0) {
312 oc.set("junctions.internal-link-detail", toString(myLinkDetail));
313 }
314 if (oc.isWriteable("rectangular-lane-cut")) {
315 oc.set("rectangular-lane-cut", toString(myRectLaneCut));
316 }
317 if (oc.isWriteable("walkingareas")) {
318 oc.set("walkingareas", toString(myWalkingAreas));
319 }
320 if (oc.isWriteable("junctions.limit-turn-speed")) {
321 oc.set("junctions.limit-turn-speed", toString(myLimitTurnSpeed));
322 }
323 if (oc.isWriteable("check-lane-foes.all") && oc.getBool("check-lane-foes.all") != myCheckLaneFoesAll) {
324 oc.set("check-lane-foes.all", toString(myCheckLaneFoesAll));
325 }
326 if (oc.isWriteable("check-lane-foes.roundabout") && oc.getBool("check-lane-foes.roundabout") != myCheckLaneFoesRoundabout) {
327 oc.set("check-lane-foes.roundabout", toString(myCheckLaneFoesRoundabout));
328 }
329 if (oc.isWriteable("tls.ignore-internal-junction-jam") && oc.getBool("tls.ignore-internal-junction-jam") != myTlsIgnoreInternalJunctionJam) {
330 oc.set("tls.ignore-internal-junction-jam", toString(myTlsIgnoreInternalJunctionJam));
331 }
332 if (oc.isWriteable("default.spreadtype") && oc.getString("default.spreadtype") != myDefaultSpreadType) {
333 oc.set("default.spreadtype", myDefaultSpreadType);
334 }
335 if (oc.isWriteable("geometry.avoid-overlap") && oc.getBool("geometry.avoid-overlap") != myGeomAvoidOverlap) {
336 oc.set("geometry.avoid-overlap", toString(myGeomAvoidOverlap));
337 }
338 if (oc.isWriteable("junctions.higher-speed") && oc.getBool("junctions.higher-speed") != myJunctionsHigherSpeed) {
339 oc.set("junctions.higher-speed", toString(myJunctionsHigherSpeed));
340 }
341 if (oc.isWriteable("internal-junctions.vehicle-width") && oc.getFloat("internal-junctions.vehicle-width") != myInternalJunctionsVehicleWidth) {
342 oc.set("internal-junctions.vehicle-width", toString(myInternalJunctionsVehicleWidth));
343 }
344 if (!deprecatedVehicleClassesSeen.empty()) {
345 WRITE_WARNINGF(TL("Deprecated vehicle class(es) '%' in input network."), toString(deprecatedVehicleClassesSeen));
347 }
348 if (!oc.getBool("no-internal-links")) {
349 // add loaded crossings
350 for (const auto& crossIt : myPedestrianCrossings) {
351 NBNode* const node = myNodeCont.retrieve(crossIt.first);
352 for (const Crossing& crossing : crossIt.second) {
353 EdgeVector edges;
354 for (const std::string& edgeID : crossing.crossingEdges) {
355 NBEdge* edge = myNetBuilder.getEdgeCont().retrieve(edgeID);
356 // edge might have been removed due to options
357 if (edge != nullptr) {
358 edges.push_back(edge);
359 }
360 }
361 if (!edges.empty()) {
362 node->addCrossing(edges, crossing.width, crossing.priority,
363 crossing.customTLIndex, crossing.customTLIndex2, crossing.customShape, true);
364 }
365 }
366 }
367 // add walking area custom shapes
368 for (const auto& item : myWACustomShapes) {
369 std::string nodeID = SUMOXMLDefinitions::getJunctionIDFromInternalEdge(item.first);
370 NBNode* node = myNodeCont.retrieve(nodeID);
371 std::vector<std::string> edgeIDs;
372 if (item.second.fromEdges.size() + item.second.toEdges.size() == 0) {
373 // must be a split crossing
374 assert(item.second.fromCrossed.size() > 0);
375 assert(item.second.toCrossed.size() > 0);
376 edgeIDs = item.second.fromCrossed;
377 edgeIDs.insert(edgeIDs.end(), item.second.toCrossed.begin(), item.second.toCrossed.end());
378 } else if (item.second.fromEdges.size() > 0) {
379 edgeIDs = item.second.fromEdges;
380 } else {
381 edgeIDs = item.second.toEdges;
382 }
383 EdgeVector edges;
384 for (const std::string& edgeID : edgeIDs) {
385 NBEdge* edge = myNetBuilder.getEdgeCont().retrieve(edgeID);
386 // edge might have been removed due to options
387 if (edge != nullptr) {
388 edges.push_back(edge);
389 }
390 }
391 if (edges.size() > 0) {
392 node->addWalkingAreaShape(edges, item.second.shape, item.second.width);
393 }
394 }
395 }
396 // add roundabouts
397 for (const std::vector<std::string>& ra : myRoundabouts) {
398 EdgeSet roundabout;
399 for (const std::string& edgeID : ra) {
400 NBEdge* edge = myNetBuilder.getEdgeCont().retrieve(edgeID);
401 if (edge == nullptr) {
402 if (!myNetBuilder.getEdgeCont().wasIgnored(edgeID)) {
403 WRITE_ERRORF(TL("Unknown edge '%' in roundabout"), (edgeID));
404 }
405 } else {
406 roundabout.insert(edge);
407 }
408 }
410 }
411}
412
413
414void
416 const SUMOSAXAttributes& attrs) {
417 /* our goal is to reproduce the input net faithfully
418 * there are different types of objects in the netfile:
419 * 1) those which must be loaded into NBNetBuilder-Containers for processing
420 * 2) those which can be ignored because they are recomputed based on group 1
421 * 3) those which are of no concern to NBNetBuilder but should be exposed to
422 * netedit. We will probably have to patch NBNetBuilder to contain them
423 * and hand them over to netedit
424 * alternative idea: those shouldn't really be contained within the
425 * network but rather in separate files. teach netedit how to open those
426 * (POI?)
427 * 4) those which are of concern neither to NBNetBuilder nor netedit and
428 * must be copied over - need to patch NBNetBuilder for this.
429 * copy unknown by default
430 */
431 switch (element) {
432 case SUMO_TAG_NET: {
433 bool ok;
434 myNetworkVersion = StringUtils::toVersion(attrs.get<std::string>(SUMO_ATTR_VERSION, nullptr, ok, false));
435 myAmLefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, nullptr, ok, false);
436 myCornerDetail = attrs.getOpt<int>(SUMO_ATTR_CORNERDETAIL, nullptr, ok, 0);
437 myLinkDetail = attrs.getOpt<int>(SUMO_ATTR_LINKDETAIL, nullptr, ok, -1);
438 myRectLaneCut = attrs.getOpt<bool>(SUMO_ATTR_RECTANGULAR_LANE_CUT, nullptr, ok, false);
439 myWalkingAreas = attrs.getOpt<bool>(SUMO_ATTR_WALKINGAREAS, nullptr, ok, false);
440 myLimitTurnSpeed = attrs.getOpt<double>(SUMO_ATTR_LIMIT_TURN_SPEED, nullptr, ok, -1);
441 myCheckLaneFoesAll = attrs.getOpt<bool>(SUMO_ATTR_CHECKLANEFOES_ALL, nullptr, ok, false);
444 myDefaultSpreadType = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, nullptr, ok, myDefaultSpreadType);
448 // derived
450 myChangeLefthand = !oc.isDefault("lefthand") && (oc.getBool("lefthand") != myAmLefthand);
451
452 break;
453 }
454 case SUMO_TAG_EDGE:
455 addEdge(attrs);
456 break;
457 case SUMO_TAG_LANE:
458 addLane(attrs);
459 break;
460 case SUMO_TAG_STOPOFFSET: {
461 bool ok = true;
462 addStopOffsets(attrs, ok);
463 }
464 break;
465 case SUMO_TAG_NEIGH:
467 break;
469 addJunction(attrs);
470 break;
471 case SUMO_TAG_REQUEST:
472 addRequest(attrs);
473 break;
475 addConnection(attrs);
476 break;
477 case SUMO_TAG_TLLOGIC:
479 if (myCurrentTL) {
481 }
482 break;
483 case SUMO_TAG_PHASE:
484 addPhase(attrs, myCurrentTL);
485 break;
487 delete myLocation;
488 myLocation = loadLocation(attrs);
489 break;
491 addProhibition(attrs);
492 break;
494 addRoundabout(attrs);
495 break;
496 case SUMO_TAG_PARAM:
497 if (myLastParameterised.size() != 0) {
498 bool ok = true;
499 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
500 if (myDiscardableParams.count(key) == 0) {
501 // circumventing empty string test
502 const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
503 myLastParameterised.back()->setParameter(key, val);
504 }
505 }
506 break;
507 default:
508 myTypesHandler.myStartElement(element, attrs);
509 break;
510 }
511}
512
513
514void
516 switch (element) {
517 case SUMO_TAG_EDGE:
518 if (myCurrentEdge != nullptr) {
519 if (myEdges.find(myCurrentEdge->id) != myEdges.end()) {
520 WRITE_WARNINGF(TL("Edge '%' occurred at least twice in the input."), myCurrentEdge->id);
521 for (LaneAttrs* const lane : myCurrentEdge->lanes) {
522 delete lane;
523 }
524 delete myCurrentEdge;
525 } else {
527 }
528 myCurrentEdge = nullptr;
529 myLastParameterised.pop_back();
530 }
531 break;
532 case SUMO_TAG_LANE:
533 if (myCurrentEdge != nullptr && myCurrentLane != nullptr) {
536 myLastParameterised.pop_back();
537 }
538 myCurrentLane = nullptr;
539 break;
540 case SUMO_TAG_TLLOGIC:
541 if (myCurrentTL == nullptr) {
542 WRITE_ERROR(TL("Unmatched closing tag for tl-logic."));
543 } else {
545 WRITE_WARNINGF(TL("Could not add program '%' for traffic light '%'"), myCurrentTL->getProgramID(), myCurrentTL->getID());
546 delete myCurrentTL;
547 }
548 myCurrentTL = nullptr;
549 myLastParameterised.pop_back();
550 }
551 break;
553 if (myCurrentJunction.node != nullptr) {
554 myLastParameterised.pop_back();
555 }
556 break;
558 // !!! this just avoids a crash but is not a real check that it was a connection
559 if (!myLastParameterised.empty()) {
560 myLastParameterised.pop_back();
561 }
562 break;
563 default:
564 break;
565 }
566}
567
568
569void
571 // get the id, report an error if not given or empty...
572 bool ok = true;
573 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
574 if (!ok) {
575 return;
576 }
577 myCurrentEdge = new EdgeAttrs();
579 myCurrentEdge->builtEdge = nullptr;
580 myCurrentEdge->id = id;
581 // get the function
584 // add the crossing but don't do anything else
585 Crossing c(id);
586 c.crossingEdges = attrs.get<std::vector<std::string> >(SUMO_ATTR_CROSSING_EDGES, nullptr, ok);
588 return;
591 return; // skip internal edges
592 }
593 // get the type
594 myCurrentEdge->type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
595 // get the origin and the destination node
596 myCurrentEdge->fromNode = attrs.getOpt<std::string>(SUMO_ATTR_FROM, id.c_str(), ok, "");
597 myCurrentEdge->toNode = attrs.getOpt<std::string>(SUMO_ATTR_TO, id.c_str(), ok, "");
598 myCurrentEdge->priority = attrs.getOpt<int>(SUMO_ATTR_PRIORITY, id.c_str(), ok, -1);
599 myCurrentEdge->type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
604 myCurrentEdge->streetName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
605 myCurrentEdge->distance = attrs.getOpt<double>(SUMO_ATTR_DISTANCE, id.c_str(), ok, 0);
606 myCurrentEdge->bidi = attrs.getOpt<std::string>(SUMO_ATTR_BIDI, id.c_str(), ok, "");
607 if (myCurrentEdge->streetName != "" && OptionsCont::getOptions().isDefault("output.street-names")) {
608 OptionsCont::getOptions().set("output.street-names", "true");
609 }
610
611 std::string lsfS = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, id.c_str(), ok, myDefaultSpreadType);
612 if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
614 } else {
615 WRITE_ERRORF(TL("Unknown spreadType '%' for edge '%'."), lsfS, id);
616 }
617}
618
619
620void
622 bool ok = true;
623 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
624 if (!ok) {
625 return;
626 }
627 if (myCurrentEdge == nullptr) {
628 WRITE_ERRORF(TL("Found lane '%' not within edge element."), id);
629 return;
630 }
631 const std::string expectedID = myCurrentEdge->id + "_" + toString(myCurrentEdge->lanes.size());
632 if (id != expectedID) {
633 WRITE_WARNINGF(TL("Renaming lane '%' to '%'."), id, expectedID);
634 }
635 myCurrentLane = new LaneAttrs();
637 myCurrentLane->customShape = attrs.getOpt<bool>(SUMO_ATTR_CUSTOMSHAPE, nullptr, ok, false);
638 myCurrentLane->shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
639 myCurrentLane->width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), ok, (double) NBEdge::UNSPECIFIED_WIDTH);
640 myCurrentLane->type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
642 // save the width and the lane id of the crossing but don't do anything else
644 assert(crossings.size() > 0);
645 crossings.back().width = attrs.get<double>(SUMO_ATTR_WIDTH, id.c_str(), ok);
647 crossings.back().customShape = myCurrentLane->shape;
648 NBNetBuilder::transformCoordinates(crossings.back().customShape, true, myLocation);
649 }
651 // save custom shape if needed but don't do anything else
654 wacs.shape = myCurrentLane->shape;
655 wacs.width = myCurrentLane->width;
658 }
659 return;
661 return; // skip internal edges
662 }
663 if (attrs.hasAttribute("maxspeed")) {
664 // !!! deprecated
665 myCurrentLane->maxSpeed = attrs.getFloat("maxspeed");
666 } else {
667 myCurrentLane->maxSpeed = attrs.get<double>(SUMO_ATTR_SPEED, id.c_str(), ok);
668 }
669 myCurrentLane->friction = attrs.getOpt<double>(SUMO_ATTR_FRICTION, id.c_str(), ok, NBEdge::UNSPECIFIED_FRICTION, false); //sets 1 on empty
670 try {
671 myCurrentLane->allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, id.c_str(), ok, "", false);
672 } catch (EmptyData&) {
673 // !!! deprecated
674 myCurrentLane->allow = "";
675 }
676 myCurrentLane->disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, id.c_str(), ok, "");
677 myCurrentLane->endOffset = attrs.getOpt<double>(SUMO_ATTR_ENDOFFSET, id.c_str(), ok, (double) NBEdge::UNSPECIFIED_OFFSET);
678 myCurrentLane->accelRamp = attrs.getOpt<bool>(SUMO_ATTR_ACCELERATION, id.c_str(), ok, false);
679 myCurrentLane->changeLeft = attrs.getOpt<std::string>(SUMO_ATTR_CHANGE_LEFT, id.c_str(), ok, "");
680 myCurrentLane->changeRight = attrs.getOpt<std::string>(SUMO_ATTR_CHANGE_RIGHT, id.c_str(), ok, "");
681 if (myChangeLefthand) {
683 }
684
685 // lane coordinates are derived (via lane spread) do not include them in convex boundary
687}
688
689
690void
692 const StopOffset offset(attrs, ok);
693 if (!ok) {
694 return;
695 }
696 // Admissibility of value will be checked in _loadNetwork(), when lengths are known
697 if (myCurrentLane == nullptr) {
699 WRITE_WARNINGF(TL("Duplicate definition of stopOffset for edge %.\nIgnoring duplicate specification."), myCurrentEdge->id);
700 } else {
702 }
703 } else {
705 WRITE_WARNINGF(TL("Duplicate definition of lane's stopOffset on edge %.\nIgnoring duplicate specifications."), myCurrentEdge->id);
706 } else {
708 }
709 }
710}
711
712
713void
715 // get the id, report an error if not given or empty...
716 myCurrentJunction.node = nullptr;
719 bool ok = true;
720 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
721 if (!ok) {
722 return;
723 }
724 if (id[0] == ':') { // internal node
725 return;
726 }
728 if (ok) {
730 // dead end is a computed status. Reset this to unknown so it will
731 // be corrected if additional connections are loaded
733 } else if (type == SumoXMLNodeType::INTERNAL) {
734 WRITE_WARNINGF("Invalid node type '%' for junction '%' in input network", toString(SumoXMLNodeType::INTERNAL), id);
736 }
737 }
738 Position pos = readPosition(attrs, id, ok);
740 NBNode* node = new NBNode(id, pos, type);
741 if (!myNodeCont.insert(node)) {
742 WRITE_WARNINGF(TL("Junction '%' occurred at least twice in the input."), id);
743 delete node;
745 return;
746 } else {
747 myLastParameterised.push_back(node);
748 }
749 myCurrentJunction.node = node;
750 myCurrentJunction.intLanes = attrs.get<std::vector<std::string> >(SUMO_ATTR_INTLANES, nullptr, ok, false);
751 // set optional radius
752 if (attrs.hasAttribute(SUMO_ATTR_RADIUS)) {
753 node->setRadius(attrs.get<double>(SUMO_ATTR_RADIUS, id.c_str(), ok));
754 }
755 // handle custom shape
756 if (attrs.getOpt<bool>(SUMO_ATTR_CUSTOMSHAPE, id.c_str(), ok, false)) {
757 PositionVector shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
759 node->setCustomShape(shape);
760 }
762 // both types of nodes come without a tlLogic
763 myRailSignals.insert(id);
764 }
765 node->setRightOfWay(attrs.getOpt<RightOfWay>(SUMO_ATTR_RIGHT_OF_WAY, id.c_str(), ok, node->getRightOfWay()));
766 node->setFringeType(attrs.getOpt<FringeType>(SUMO_ATTR_FRINGE, id.c_str(), ok, node->getFringeType()));
767 if (attrs.hasAttribute(SUMO_ATTR_NAME)) {
768 node->setName(attrs.get<std::string>(SUMO_ATTR_NAME, id.c_str(), ok));
769 }
770}
771
772
773void
775 if (myCurrentJunction.node != nullptr) {
776 bool ok = true;
777 myCurrentJunction.response.push_back(attrs.get<std::string>(SUMO_ATTR_RESPONSE, nullptr, ok));
778 }
779}
780
781
782void
784 bool ok = true;
785 std::string fromID = attrs.get<std::string>(SUMO_ATTR_FROM, nullptr, ok);
786 if (myEdges.count(fromID) == 0) {
787 WRITE_ERRORF(TL("Unknown edge '%' given in connection."), fromID);
788 return;
789 }
790 EdgeAttrs* from = myEdges[fromID];
791 if (from->func == SumoXMLEdgeFunc::INTERNAL) {
792 // internal junction connection
793 return;
794 }
795 Connection conn;
796 conn.toEdgeID = attrs.get<std::string>(SUMO_ATTR_TO, nullptr, ok);
797 int fromLaneIdx = attrs.get<int>(SUMO_ATTR_FROM_LANE, nullptr, ok);
798 conn.toLaneIdx = attrs.get<int>(SUMO_ATTR_TO_LANE, nullptr, ok);
799 conn.tlID = attrs.getOpt<std::string>(SUMO_ATTR_TLID, nullptr, ok, "");
800 conn.mayDefinitelyPass = attrs.getOpt<bool>(SUMO_ATTR_PASS, nullptr, ok, false);
801 conn.keepClear = attrs.getOpt<bool>(SUMO_ATTR_KEEP_CLEAR, nullptr, ok, true);
802 conn.indirectLeft = attrs.getOpt<bool>(SUMO_ATTR_INDIRECT, nullptr, ok, false);
803 conn.edgeType = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, nullptr, ok, "");
804 conn.contPos = attrs.getOpt<double>(SUMO_ATTR_CONTPOS, nullptr, ok, NBEdge::UNSPECIFIED_CONTPOS);
806 std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, nullptr, ok, "", false);
807 std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, nullptr, ok, "", false);
808 if (allow == "" && disallow == "") {
810 } else {
811 conn.permissions = parseVehicleClasses(allow, disallow, myNetworkVersion);
812 }
814 conn.changeLeft = parseVehicleClasses(attrs.get<std::string>(SUMO_ATTR_CHANGE_LEFT, nullptr, ok), "");
815 } else {
817 }
819 conn.changeRight = parseVehicleClasses(attrs.get<std::string>(SUMO_ATTR_CHANGE_RIGHT, nullptr, ok), "");
820 } else {
822 }
823 if (myChangeLefthand) {
824 std::swap(conn.changeLeft, conn.changeRight);
825 }
826 conn.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, NBEdge::UNSPECIFIED_SPEED);
827 conn.friction = attrs.getOpt<double>(SUMO_ATTR_FRICTION, nullptr, ok, NBEdge::UNSPECIFIED_FRICTION);
828 conn.customLength = attrs.getOpt<double>(SUMO_ATTR_LENGTH, nullptr, ok, NBEdge::UNSPECIFIED_LOADED_LENGTH);
832 if (conn.tlID != "") {
833 conn.tlLinkIndex = attrs.get<int>(SUMO_ATTR_TLLINKINDEX, nullptr, ok);
834 conn.tlLinkIndex2 = attrs.getOpt<int>(SUMO_ATTR_TLLINKINDEX2, nullptr, ok, -1);
835 } else {
837 }
838 if ((int)from->lanes.size() <= fromLaneIdx) {
839 WRITE_ERRORF(TL("Invalid lane index '%' for connection from '%'."), toString(fromLaneIdx), fromID);
840 return;
841 }
842 from->lanes[fromLaneIdx]->connections.push_back(conn);
843 myLastParameterised.push_back(&from->lanes[fromLaneIdx]->connections.back());
844
845 // determine crossing priority and tlIndex
846 if (myPedestrianCrossings.size() > 0) {
848 // connection from walkingArea to crossing
849 std::vector<Crossing>& crossings = myPedestrianCrossings[SUMOXMLDefinitions::getJunctionIDFromInternalEdge(fromID)];
850 for (std::vector<Crossing>::iterator it = crossings.begin(); it != crossings.end(); ++it) {
851 if (conn.toEdgeID == (*it).edgeID) {
852 if (conn.tlID != "") {
853 (*it).priority = true;
854 (*it).customTLIndex = conn.tlLinkIndex;
855 } else {
856 LinkState state = SUMOXMLDefinitions::LinkStates.get(attrs.get<std::string>(SUMO_ATTR_STATE, nullptr, ok));
857 (*it).priority = state == LINKSTATE_MAJOR;
858 }
859 }
860 }
861 } else if (from->func == SumoXMLEdgeFunc::CROSSING && myEdges[conn.toEdgeID]->func == SumoXMLEdgeFunc::WALKINGAREA) {
862 // connection from crossing to walkingArea (set optional linkIndex2)
864 if (fromID == c.edgeID) {
865 c.customTLIndex2 = attrs.getOpt<int>(SUMO_ATTR_TLLINKINDEX, nullptr, ok, -1);
866 }
867 }
868 }
869 }
870 // determine walking area reference edges
871 if (myWACustomShapes.size() > 0) {
872 EdgeAttrs* to = myEdges[conn.toEdgeID];
873 if (from->func == SumoXMLEdgeFunc::WALKINGAREA) {
874 std::map<std::string, WalkingAreaParsedCustomShape>::iterator it = myWACustomShapes.find(fromID);
875 if (it != myWACustomShapes.end()) {
876 if (to->func == SumoXMLEdgeFunc::NORMAL) {
877 // add target sidewalk as reference
878 it->second.toEdges.push_back(conn.toEdgeID);
879 } else if (to->func == SumoXMLEdgeFunc::CROSSING) {
880 // add target crossing edges as reference
882 if (conn.toEdgeID == crossing.edgeID) {
883 it->second.toCrossed.insert(it->second.toCrossed.end(), crossing.crossingEdges.begin(), crossing.crossingEdges.end());
884 }
885 }
886 }
887 }
888 } else if (to->func == SumoXMLEdgeFunc::WALKINGAREA) {
889 std::map<std::string, WalkingAreaParsedCustomShape>::iterator it = myWACustomShapes.find(conn.toEdgeID);
890 if (it != myWACustomShapes.end()) {
891 if (from->func == SumoXMLEdgeFunc::NORMAL) {
892 // add origin sidewalk as reference
893 it->second.fromEdges.push_back(fromID);
894 } else if (from->func == SumoXMLEdgeFunc::CROSSING) {
895 // add origin crossing edges as reference
897 if (fromID == crossing.edgeID) {
898 it->second.fromCrossed.insert(it->second.fromCrossed.end(), crossing.crossingEdges.begin(), crossing.crossingEdges.end());
899 }
900 }
901 }
902 }
903 }
904 }
905}
906
907
908void
910 bool ok = true;
911 std::string prohibitor = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITOR, nullptr, ok, "");
912 std::string prohibited = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITED, nullptr, ok, "");
913 if (!ok) {
914 return;
915 }
916 Prohibition p;
919 if (!ok) {
920 return;
921 }
922 myProhibitions.push_back(p);
923}
924
925
928 if (currentTL) {
929 WRITE_ERRORF(TL("Definition of tl-logic '%' was not finished."), currentTL->getID());
930 return nullptr;
931 }
932 bool ok = true;
933 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
934 SUMOTime offset = TIME2STEPS(attrs.get<double>(SUMO_ATTR_OFFSET, id.c_str(), ok));
935 std::string programID = attrs.getOpt<std::string>(SUMO_ATTR_PROGRAMID, id.c_str(), ok, "<unknown>");
936 std::string typeS = attrs.get<std::string>(SUMO_ATTR_TYPE, nullptr, ok);
937 TrafficLightType type;
938 if (SUMOXMLDefinitions::TrafficLightTypes.hasString(typeS)) {
940 } else {
941 WRITE_ERRORF(TL("Unknown traffic light type '%' for tlLogic '%'."), typeS, id);
942 return nullptr;
943 }
944 if (ok) {
945 return new NBLoadedSUMOTLDef(id, programID, offset, type);
946 } else {
947 return nullptr;
948 }
949}
950
951
952void
954 if (!currentTL) {
955 WRITE_ERROR(TL("found phase without tl-logic"));
956 return;
957 }
958 const std::string& id = currentTL->getID();
959 bool ok = true;
960 std::string state = attrs.get<std::string>(SUMO_ATTR_STATE, id.c_str(), ok);
961 SUMOTime duration = TIME2STEPS(attrs.get<double>(SUMO_ATTR_DURATION, id.c_str(), ok));
962 if (duration < 0) {
963 WRITE_ERRORF(TL("Phase duration for tl-logic '%/%' must be positive."), id, currentTL->getProgramID());
964 return;
965 }
966 // if the traffic light is an actuated traffic light, try to get the minimum and maximum durations and ends
967 std::vector<int> nextPhases = attrs.getOpt<std::vector<int> >(SUMO_ATTR_NEXT, id.c_str(), ok);
968 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, nullptr, ok);
969 // Specific from actuated
974 // specific von NEMA
978 if (ok) {
979 currentTL->addPhase(duration, state, minDuration, maxDuration, earliestEnd, latestEnd, vehExt, yellow, red, nextPhases, name);
980 }
981}
982
983
986 // @todo refactor parsing of location since its duplicated in NLHandler and PCNetProjectionLoader
987 bool ok = true;
988 GeoConvHelper* result = nullptr;
989 PositionVector s = attrs.get<PositionVector>(SUMO_ATTR_NET_OFFSET, nullptr, ok);
990 Boundary convBoundary = attrs.get<Boundary>(SUMO_ATTR_CONV_BOUNDARY, nullptr, ok);
991 Boundary origBoundary = attrs.get<Boundary>(SUMO_ATTR_ORIG_BOUNDARY, nullptr, ok);
992 std::string proj = attrs.get<std::string>(SUMO_ATTR_ORIG_PROJ, nullptr, ok);
993 if (ok) {
994 Position networkOffset = s[0];
995 result = new GeoConvHelper(proj, networkOffset, origBoundary, convBoundary);
997 if (setLoaded) {
999 }
1000 }
1001 return result;
1002}
1003
1004
1006NIImporter_SUMO::readPosition(const SUMOSAXAttributes& attrs, const std::string& id, bool& ok) {
1007 const double x = attrs.get<double>(SUMO_ATTR_X, id.c_str(), ok);
1008 const double y = attrs.get<double>(SUMO_ATTR_Y, id.c_str(), ok);
1009 const double z = attrs.getOpt<double>(SUMO_ATTR_Z, id.c_str(), ok, 0.);
1010 return Position(x, y, z);
1011}
1012
1013
1014void
1015NIImporter_SUMO::parseProhibitionConnection(const std::string& attr, std::string& from, std::string& to, bool& ok) {
1016 // split from/to
1017 const std::string::size_type div = attr.find("->");
1018 if (div == std::string::npos) {
1019 WRITE_ERRORF(TL("Missing connection divider in prohibition attribute '%'"), attr);
1020 ok = false;
1021 }
1022 from = attr.substr(0, div);
1023 to = attr.substr(div + 2);
1024 // check whether the edges are known
1025 if (myEdges.count(from) == 0) {
1026 WRITE_ERRORF(TL("Unknown edge prohibition '%'"), from);
1027 ok = false;
1028 }
1029 if (myEdges.count(to) == 0) {
1030 WRITE_ERRORF(TL("Unknown edge prohibition '%'"), to);
1031 ok = false;
1032 }
1033}
1034
1035
1036void
1038 bool ok = true;
1039 const std::vector<std::string>& edgeIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, nullptr, ok);
1040 if (ok) {
1041 myRoundabouts.push_back(edgeIDs);
1042 }
1043}
1044
1045
1046/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_ERROR(msg)
Definition MsgHandler.h:279
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
Definition MsgHandler.h:276
#define TL(string)
Definition MsgHandler.h:287
#define PROGRESS_TIME_MESSAGE(before)
Definition MsgHandler.h:277
std::set< NBEdge * > EdgeSet
container for unique edges
Definition NBCont.h:50
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition NBCont.h:42
@ KEEPCLEAR_FALSE
Definition NBCont.h:59
@ KEEPCLEAR_TRUE
Definition NBCont.h:60
#define TIME2STEPS(x)
Definition SUMOTime.h:57
std::set< std::string > deprecatedVehicleClassesSeen
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
@ RIGHT
At the rightmost side of the lane.
@ SUMO_TAG_PHASE
a single phase description
@ SUMO_TAG_NET
root element of a network file
@ SUMO_TAG_STOPOFFSET
Information on vClass specific stop offsets at lane end.
@ SUMO_TAG_REQUEST
description of a logic request within the junction
@ SUMO_TAG_PROHIBITION
prohibition of circulation between two edges
@ SUMO_TAG_LOCATION
@ SUMO_TAG_CONNECTION
connectioon between two lanes
@ SUMO_TAG_ROUNDABOUT
roundabout defined in junction
@ SUMO_TAG_TLLOGIC
a traffic light logic
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_PARAM
parameter associated to a certain key
@ SUMO_TAG_NEIGH
begin/end of the description of a neighboring lane
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
FringeType
classifying boundary nodes
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_MAJOR
This is an uncontrolled, major link, may pass.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
RightOfWay
algorithms for computing right of way
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_CONV_BOUNDARY
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_LANE
@ SUMO_ATTR_NET_OFFSET
@ SUMO_ATTR_ORIG_BOUNDARY
@ SUMO_ATTR_LATEST_END
The maximum time within the cycle for switching (for coordinated actuation)
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
@ SUMO_ATTR_RED
red duration of a phase
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_LINKDETAIL
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_CORNERDETAIL
@ SUMO_ATTR_RADIUS
The turning radius at an intersection in m.
@ SUMO_ATTR_INDIRECT
Whether this connection is an indirect (left) turn.
@ SUMO_ATTR_RECTANGULAR_LANE_CUT
@ SUMO_ATTR_Y
@ SUMO_ATTR_FROM_LANE
@ SUMO_ATTR_Z
@ SUMO_ATTR_RESPONSE
@ SUMO_ATTR_LIMIT_TURN_SPEED
@ SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT
@ SUMO_ATTR_OFFSET
@ SUMO_ATTR_X
@ SUMO_ATTR_AVOID_OVERLAP
@ SUMO_ATTR_YELLOW
yellow duration of a phase
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
@ SUMO_ATTR_INTLANES
@ SUMO_ATTR_VEHICLEEXTENSION
vehicle extension time of a phase
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_FRINGE
Fringe type of node.
@ SUMO_ATTR_BIDI
@ SUMO_ATTR_PROHIBITED
@ SUMO_ATTR_PRIORITY
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_LEFTHAND
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_CHANGE_LEFT
@ SUMO_ATTR_NAME
@ SUMO_ATTR_ORIG_PROJ
@ SUMO_ATTR_CHECKLANEFOES_ALL
@ SUMO_ATTR_SPREADTYPE
The information about how to spread the lanes from the given position.
@ SUMO_ATTR_PASS
@ SUMO_ATTR_ENDOFFSET
@ SUMO_ATTR_HIGHER_SPEED
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_ACCELERATION
@ SUMO_ATTR_CHANGE_RIGHT
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_TO_LANE
@ SUMO_ATTR_UNCONTROLLED
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_VERSION
@ SUMO_ATTR_ID
@ SUMO_ATTR_MAXDURATION
maximum duration of a phase
@ SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
@ SUMO_ATTR_PROGRAMID
@ SUMO_ATTR_FUNCTION
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
@ SUMO_ATTR_PROHIBITOR
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_CONTPOS
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_CROSSING_EDGES
the edges crossed by a pedestrian crossing
@ SUMO_ATTR_TLS_IGNORE_INTERNAL_JUNCTION_JAM
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_MINDURATION
@ SUMO_ATTR_KEY
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
@ SUMO_ATTR_INTERNAL_JUNCTIONS_VEHICLE_WIDTH
@ SUMO_ATTR_STATE
The state of a link.
@ SUMO_ATTR_FRICTION
@ SUMO_ATTR_WALKINGAREAS
@ SUMO_ATTR_EARLIEST_END
The minimum time within the cycle for switching (for coordinated actuation)
T MAX2(T a, T b)
Definition StdDefs.h:82
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
static bool isReadable(std::string path)
Checks whether the given file is readable.
void setFileName(const std::string &name)
Sets the current file name.
static methods for processing the coordinates conversion for the current net
void resolveAbstractProjection()
init projString such as 'UTM' in loaded projection
static void setLoaded(const GeoConvHelper &loaded)
sets the coordinate transformation loaded from a location element
static const int InvalidTlIndex
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
void ignore(std::string id)
mark the given edge id as ignored
Definition NBEdgeCont.h:478
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition NBEdgeCont.h:473
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
The representation of a single edge during network building.
Definition NBEdge.h:92
void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight)
set allowed classes for changing to the left and right from the given lane
Definition NBEdge.cpp:4223
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given
Definition NBEdge.cpp:4195
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Definition NBEdge.cpp:4147
double getLaneWidth() const
Returns the default width of lanes of this edge.
Definition NBEdge.h:632
NBNode * getToNode() const
Returns the destination node of the edge.
Definition NBEdge.h:536
Connection & getConnectionRef(int fromLane, const NBEdge *to, int toLane)
Returns reference to the specified connection This method goes through "myConnections" and returns th...
Definition NBEdge.cpp:1247
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Definition NBEdge.h:350
Lane & getLaneStruct(int lane)
Definition NBEdge.h:1415
static const bool UNSPECIFIED_CONNECTION_UNCONTROLLED
TLS-controlled despite its node controlled not specified.
Definition NBEdge.h:371
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, KeepClear keepClear=KEEPCLEAR_UNSPECIFIED, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, double friction=UNSPECIFIED_FRICTION, double length=myDefaultConnectionLength, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED, SVCPermissions permissions=SVC_UNSPECIFIED, const bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED, bool postProcess=false)
Adds a connection between the specified this edge's lane and an approached one.
Definition NBEdge.cpp:1067
void setDistance(double distance)
set kilometrage at start of edge (negative value implies couting down along the edge)
Definition NBEdge.h:1400
bool setEdgeStopOffset(int lane, const StopOffset &offset, bool overwrite=false)
set lane and vehicle class specific stopOffset (negative lane implies set for all lanes)
Definition NBEdge.cpp:4117
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition NBEdge.h:720
bool hasLaneSpecificStopOffsets() const
whether lanes differ in stopOffsets
Definition NBEdge.cpp:2424
const std::string & getID() const
Definition NBEdge.h:1515
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition NBEdge.h:359
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
Definition NBEdge.cpp:4018
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
Definition NBEdge.cpp:4179
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
Definition NBEdge.cpp:4085
void setBidi(bool isBidi)
mark this edge as a bidi edge
Definition NBEdge.h:1405
void setFriction(int lane, double friction)
set lane specific friction (negative lane implies set for all lanes)
Definition NBEdge.cpp:4163
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition NBEdge.h:353
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition NBEdge.h:356
bool hasLaneSpecificWidth() const
whether lanes differ in width
Definition NBEdge.cpp:2391
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition NBEdge.h:347
@ VALIDATED
The connection was computed and validated.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
Definition NBEdge.cpp:2413
void setLaneShape(int lane, const PositionVector &shape)
sets a custom lane shape
Definition NBEdge.cpp:4187
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition NBEdge.h:529
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition NBEdge.h:341
void declareConnectionsAsLoaded(EdgeBuildingStep step=EdgeBuildingStep::LANES2LANES_USER)
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
Definition NBEdge.h:1429
double getEndOffset() const
Returns the offset to the destination node.
Definition NBEdge.h:679
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
Definition NBEdge.cpp:4101
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Definition NBEdge.h:344
void setLoadedLength(double val)
set loaded length
Definition NBEdge.cpp:4247
A loaded (complete) traffic light logic.
void addPhase(const SUMOTime duration, const std::string &state, const SUMOTime minDur, const SUMOTime maxDur, const SUMOTime earliestEnd, const SUMOTime latestEnd, const SUMOTime vehExt, const SUMOTime yellow, const SUMOTime red, const std::vector< int > &next, const std::string &name)
Adds a phase to the logic the new phase is inserted at the end of the list of already added phases.
void addConnection(NBEdge *from, NBEdge *to, int fromLane, int toLane, int linkIndex, int linkIndex2, bool reconstruct=true)
Adds a connection and immediately informs the edges.
Instance responsible for building networks.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
static int addGeometrySegments(PositionVector &from, const PositionVector &cartesian, const double maxLength)
insertion geometry points to ensure maximum segment length between points
NBEdgeCont & getEdgeCont()
NBDistrictCont & getDistrictCont()
Returns a reference the districts 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...
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.
Definition NBNode.h:66
void addWalkingAreaShape(EdgeVector edges, const PositionVector &shape, double width)
add custom shape for walkingArea
Definition NBNode.cpp:3594
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
Definition NBNode.h:298
FringeType getFringeType() const
Returns fringe type.
Definition NBNode.h:303
SumoXMLNodeType getType() const
Returns the type of this node.
Definition NBNode.h:283
void setRightOfWay(RightOfWay rightOfWay)
set method for computing right-of-way
Definition NBNode.h:567
void setCustomShape(const PositionVector &shape)
set the junction shape
Definition NBNode.cpp:2577
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
Definition NBNode.cpp:3825
NBNode::Crossing * addCrossing(EdgeVector edges, double width, bool priority, int tlIndex=-1, int tlIndex2=-1, const PositionVector &customShape=PositionVector::EMPTY, bool fromSumoNet=false)
add a pedestrian crossing to this node
Definition NBNode.cpp:3660
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
add shorted link FOES
Definition NBNode.cpp:1843
void setRadius(double radius)
set the turning radius
Definition NBNode.h:557
void setName(const std::string &name)
set intersection name
Definition NBNode.h:577
const Position & getPosition() const
Definition NBNode.h:258
void setFringeType(FringeType fringeType)
set method for computing right-of-way
Definition NBNode.h:572
const std::string & getProgramID() const
Returns the ProgramID.
static const SUMOTime UNSPECIFIED_DURATION
const std::map< std::string, NBTrafficLightDefinition * > & getPrograms(const std::string &id) const
Returns all programs for the given tl-id.
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
A connection description.
PositionVector customShape
custom shape connection
std::string tlID
The id of the traffic light that controls this connection.
double speed
custom speed for connection
std::string edgeType
optional edge type
std::string toEdgeID
The id of the target edge.
double customLength
custom length for connection
double contPos
custom position for internal junction on this connection
int toLaneIdx
The index of the target lane.
double friction
custom friction for connection
int tlLinkIndex
The index of this connection within the controlling traffic light.
bool indirectLeft
Whether this connection is an indirect left turn.
double visibility
custom foe visibility for connection
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
SVCPermissions changeLeft
custom lane changing permissions for connection
SVCPermissions changeRight
custom lane changing permissions for connection
bool uncontrolled
if set to true, This connection will not be TLS-controlled despite its node being controlled.
SVCPermissions permissions
custom permissions for connection
Describes the values found in an edge's definition and this edge's lanes.
std::string bidi
the bidi edge
LaneSpreadFunction lsf
The lane spread function.
std::vector< LaneAttrs * > lanes
The friction on this edge.
StopOffset edgeStopOffset
This edge's vehicle specific stop offsets (used for lanes, that do not have a specified stopOffset)
PositionVector shape
This edges's shape.
int priority
This edge's priority.
std::string toNode
The node this edge ends at.
std::string type
This edge's type.
double maxSpeed
The maximum velocity allowed on this edge (!!!)
NBEdge * builtEdge
The built edge.
SumoXMLEdgeFunc func
This edge's function.
std::string streetName
This edge's street name.
std::string fromNode
The node this edge starts at.
double length
The length of the edge if set explicitly.
std::string id
This edge's id.
double distance
The position at the start of this edge (kilometrage/mileage)
Describes the values found in a lane's definition.
double maxSpeed
The maximum velocity allowed on this lane.
double friction
The friction on this lane.
std::string changeRight
This lane's vehicle classes allowed to change right.
double endOffset
This lane's offset from the intersection.
bool accelRamp
Whether this lane is an acceleration lane.
std::string oppositeID
This lane's opposite lane.
std::string type
the type of this lane
std::vector< Connection > connections
This lane's connections.
bool customShape
Whether this lane has a custom shape.
StopOffset laneStopOffset
This lane's vehicle specific stop offsets.
PositionVector shape
This lane's shape (may be custom)
std::string changeLeft
This lane's vehicle classes allowed to change left.
double width
The width of this lane.
std::string disallow
This lane's disallowed vehicle classes.
std::string allow
This lane's allowed vehicle classes.
Importer for networks stored in SUMO format.
GeoConvHelper * myLocation
The coordinate transformation which was used to build the loaded network.
static NBLoadedSUMOTLDef * initTrafficLightLogic(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
begins the reading of a traffic lights logic
void parseProhibitionConnection(const std::string &attr, std::string &from, std::string &to, bool &ok)
parses connection string of a prohibition (very old school)
~NIImporter_SUMO()
Destructor.
NIXMLTypesHandler myTypesHandler
The handler for parsing edge types and restrictions.
int myCornerDetail
the level of corner detail in the loaded network
bool myCheckLaneFoesAll
whether foe-relationships where checked at lane-level
double myLimitTurnSpeed
whether turning speed was limited in the network
std::set< std::string > myRailSignals
list of node id with rail signals (no NBTrafficLightDefinition exists)
bool myGeomAvoidOverlap
overlap option for loaded network
std::map< std::string, std::vector< Crossing > > myPedestrianCrossings
The pedestrian crossings found in the network.
JunctionAttrs myCurrentJunction
The currently parsed junction definition to help in reconstructing crossings.
static GeoConvHelper * loadLocation(const SUMOSAXAttributes &attrs, bool setLoaded=true)
Parses network location description and registers it with GeoConveHelper::setLoaded.
void addJunction(const SUMOSAXAttributes &attrs)
Parses a junction and saves it in the node control.
bool myAmLefthand
whether the loaded network was built for lefthand traffic
bool myRectLaneCut
whether all lanes of an edge should have the same stop line
std::vector< Parameterised * > myLastParameterised
element to receive parameters
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
double myInternalJunctionsVehicleWidth
custom settings for internal junction computation
std::string myDefaultSpreadType
default spreadType defined in the network
bool myJunctionsHigherSpeed
higherSpeed option for loaded network
NBLoadedSUMOTLDef * myCurrentTL
The currently parsed traffic light.
static void loadNetwork(OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given SUMO file.
std::vector< std::vector< std::string > > myRoundabouts
loaded roundabout edges
bool myChangeLefthand
whether the the written network should have a different "handedness" (LHT/RHT) than the loaded networ...
void addConnection(const SUMOSAXAttributes &attrs)
Parses a connection and saves it into the lane's definition stored in "myCurrentLane".
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
LaneAttrs * myCurrentLane
The currently parsed lanes's definition (to add the shape to)
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and stores the values in "myCurrentLane".
NBNodeCont & myNodeCont
The node container to fill.
EdgeAttrs * myCurrentEdge
The currently parsed edge's definition (to add loaded lanes to)
NBNetBuilder & myNetBuilder
The network builder to fill.
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
std::vector< Prohibition > myProhibitions
Loaded prohibitions.
MMVersion myNetworkVersion
the loaded network version
void _loadNetwork(OptionsCont &oc)
load the network
void myEndElement(int element)
Called when a closing tag occurs.
bool myTlsIgnoreInternalJunctionJam
whether some right-of-way checks at traffic light junctions should be disabled
void addStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
parses stop offsets for the current lane or edge
static Position readPosition(const SUMOSAXAttributes &attrs, const std::string &id, bool &ok)
read position from the given attributes, attribute errors to id
static void addPhase(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
adds a phase to the traffic lights logic currently build
int myLinkDetail
the level of geometry detail for internal lanes in the loaded network
std::map< std::string, WalkingAreaParsedCustomShape > myWACustomShapes
Map from walkingArea edge IDs to custom shapes.
bool myWalkingAreas
whether walkingareas must be built
NBTrafficLightLogicCont & myTLLCont
The node container to fill.
NIImporter_SUMO(NBNetBuilder &nb)
Constructor.
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
void addRequest(const SUMOSAXAttributes &attrs)
Parses a reques and saves selected attributes in myCurrentJunction.
std::set< std::string > myDiscardableParams
list of parameter keys to discard
std::map< std::string, EdgeAttrs * > myEdges
Loaded edge definitions.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag; Parses edge type information.
const std::string & getID() const
Returns the id.
Definition Named.h:74
A storage for options typed value containers)
Definition OptionsCont.h:89
bool isWriteable(const std::string &name)
Returns the information whether the named option may be 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 isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool set(const std::string &name, const std::string &value, const bool append=false)
Sets the given value for the named option.
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.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file)
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
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.
Definition Position.h:37
A list of positions.
static const PositionVector EMPTY
empty Vector
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
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.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
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.
double getFloat(int id) const
Returns the double-value of the named (by its enum-value) attribute.
SAX-handler base for SUMO-files.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
static StringBijection< LinkState > LinkStates
link states
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea
stop offset
bool isDefined() const
check if stopOffset was defined
T get(const std::string &str) const
static MMVersion toVersion(const std::string &sData)
to version
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false, const bool isRoute=false, const bool isExternal=false, const bool catchExceptions=true)
Runs the given handler on the given file; returns if everything's ok.
NLOHMANN_BASIC_JSON_TPL_DECLARATION void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL &j1, nlohmann::NLOHMANN_BASIC_JSON_TPL &j2) noexcept(//NOLINT(readability-inconsistent-declaration-parameter-name) is_nothrow_move_constructible< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value &&//NOLINT(misc-redundant-expression) is_nothrow_move_assignable< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value)
exchanges the values of two JSON objects
Definition json.hpp:21884
std::string type
the type of this lane
Definition NBEdge.h:192
std::string oppositeID
An opposite lane ID, if given.
Definition NBEdge.h:179
Describes a pedestrian crossing.
std::vector< std::string > crossingEdges
std::vector< std::string > response
std::vector< std::string > intLanes
Describes the values found in a prohibition.
Describes custom shape for a walking area during parsing.