Eclipse SUMO - Simulation of Urban MObility
NWWriter_SUMO.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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// Exporter writing networks using the SUMO format
22/****************************************************************************/
23#include <config.h>
24#include <cmath>
25#include <algorithm>
34#include <netbuild/NBEdge.h>
35#include <netbuild/NBEdgeCont.h>
36#include <netbuild/NBNode.h>
37#include <netbuild/NBNodeCont.h>
40#include <netbuild/NBDistrict.h>
41#include <netbuild/NBHelpers.h>
42#include "NWFrame.h"
43#include "NWWriter_SUMO.h"
44
45
46//#define DEBUG_OPPOSITE_INTERNAL
47
48// ===========================================================================
49// method definitions
50// ===========================================================================
51// ---------------------------------------------------------------------------
52// static methods
53// ---------------------------------------------------------------------------
54void
56 // check whether a sumo net-file shall be generated
57 if (!oc.isSet("output-file")) {
58 return;
59 }
60 OutputDevice& device = OutputDevice::getDevice(oc.getString("output-file"));
61 std::map<SumoXMLAttr, std::string> attrs;
63 if (oc.getBool("lefthand") != oc.getBool("flip-y-axis")) {
64 attrs[SUMO_ATTR_LEFTHAND] = "true";
65 } else if (oc.getBool("lefthand")) {
66 // network was flipped, correct written link directions
68 OptionsCont::getOptions().set("lefthand", "false");
69 }
70 const int cornerDetail = oc.getInt("junctions.corner-detail");
71 if (cornerDetail > 0) {
72 attrs[SUMO_ATTR_CORNERDETAIL] = toString(cornerDetail);
73 }
74 if (!oc.isDefault("junctions.internal-link-detail")) {
75 attrs[SUMO_ATTR_LINKDETAIL] = toString(oc.getInt("junctions.internal-link-detail"));
76 }
77 if (oc.getBool("rectangular-lane-cut")) {
78 attrs[SUMO_ATTR_RECTANGULAR_LANE_CUT] = "true";
79 }
80 if (oc.getBool("crossings.guess") || oc.getBool("walkingareas")) {
81 attrs[SUMO_ATTR_WALKINGAREAS] = "true";
82 }
83 if (oc.getFloat("junctions.limit-turn-speed") > 0) {
84 attrs[SUMO_ATTR_LIMIT_TURN_SPEED] = toString(oc.getFloat("junctions.limit-turn-speed"));
85 }
86 if (!oc.isDefault("check-lane-foes.all")) {
87 attrs[SUMO_ATTR_CHECKLANEFOES_ALL] = toString(oc.getBool("check-lane-foes.all"));
88 }
89 if (!oc.isDefault("check-lane-foes.roundabout")) {
90 attrs[SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT] = toString(oc.getBool("check-lane-foes.roundabout"));
91 }
92 if (!oc.isDefault("tls.ignore-internal-junction-jam")) {
93 attrs[SUMO_ATTR_TLS_IGNORE_INTERNAL_JUNCTION_JAM] = toString(oc.getBool("tls.ignore-internal-junction-jam"));
94 }
95 if (oc.getString("default.spreadtype") != "right") {
96 attrs[SUMO_ATTR_SPREADTYPE] = oc.getString("default.spreadtype");
97 }
98 if (oc.exists("geometry.avoid-overlap") && !oc.getBool("geometry.avoid-overlap")) {
99 attrs[SUMO_ATTR_AVOID_OVERLAP] = toString(oc.getBool("geometry.avoid-overlap"));
100 }
101 if (oc.exists("junctions.higher-speed") && oc.getBool("junctions.higher-speed")) {
102 attrs[SUMO_ATTR_HIGHER_SPEED] = toString(oc.getBool("junctions.higher-speed"));
103 }
104 if (oc.exists("internal-junctions.vehicle-width") && !oc.isDefault("internal-junctions.vehicle-width")) {
105 attrs[SUMO_ATTR_INTERNAL_JUNCTIONS_VEHICLE_WIDTH] = toString(oc.getFloat("internal-junctions.vehicle-width"));
106 }
107 device.writeXMLHeader("net", "net_file.xsd", attrs); // street names may contain non-ascii chars
108 device.lf();
109 // get involved container
110 const NBNodeCont& nc = nb.getNodeCont();
111 const NBEdgeCont& ec = nb.getEdgeCont();
112 const NBDistrictCont& dc = nb.getDistrictCont();
113
114 // write network offsets and projection
116
117 // write edge types and restrictions
118 nb.getTypeCont().writeEdgeTypes(device);
119
120 // write inner lanes
121 if (!oc.getBool("no-internal-links")) {
122 bool hadAny = false;
123 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
124 hadAny |= writeInternalEdges(device, ec, *(*i).second);
125 }
126 if (hadAny) {
127 device.lf();
128 }
129 }
130
131 // write edges with lanes and connected edges
132 bool noNames = !oc.getBool("output.street-names");
133 for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
134 writeEdge(device, *(*i).second, noNames);
135 }
136 device.lf();
137
138 // write tls logics
140
141 // write the nodes (junctions)
142 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
143 writeJunction(device, *(*i).second);
144 }
145 device.lf();
146 const bool includeInternal = !oc.getBool("no-internal-links");
147 if (includeInternal) {
148 // ... internal nodes if not unwanted
149 bool hadAny = false;
150 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
151 hadAny |= writeInternalNodes(device, *(*i).second);
152 }
153 if (hadAny) {
154 device.lf();
155 }
156 }
157
158 // write the successors of lanes
159 int numConnections = 0;
160 for (std::map<std::string, NBEdge*>::const_iterator it_edge = ec.begin(); it_edge != ec.end(); it_edge++) {
161 NBEdge* from = it_edge->second;
162 const std::vector<NBEdge::Connection>& connections = from->getConnections();
163 numConnections += (int)connections.size();
164 for (const NBEdge::Connection& con : connections) {
165 writeConnection(device, *from, con, includeInternal);
166 }
167 }
168 if (numConnections > 0) {
169 device.lf();
170 }
171 if (includeInternal) {
172 // ... internal successors if not unwanted
173 bool hadAny = false;
174 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
175 hadAny |= writeInternalConnections(device, *(*i).second);
176 }
177 if (hadAny) {
178 device.lf();
179 }
180 }
181 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
182 NBNode* node = (*i).second;
183 // write connections from pedestrian crossings
184 std::vector<NBNode::Crossing*> crossings = node->getCrossings();
185 for (auto c : crossings) {
186 NWWriter_SUMO::writeInternalConnection(device, c->id, c->nextWalkingArea, 0, 0, "", LinkDirection::STRAIGHT, c->tlID, c->tlLinkIndex2);
187 }
188 // write connections from pedestrian walking areas
189 for (const NBNode::WalkingArea& wa : node->getWalkingAreas()) {
190 for (const std::string& cID : wa.nextCrossings) {
191 const NBNode::Crossing& nextCrossing = *node->getCrossing(cID);
192 // connection to next crossing (may be tls-controlled)
194 device.writeAttr(SUMO_ATTR_FROM, wa.id);
195 device.writeAttr(SUMO_ATTR_TO, cID);
197 device.writeAttr(SUMO_ATTR_TO_LANE, 0);
198 if (nextCrossing.tlID != "") {
199 device.writeAttr(SUMO_ATTR_TLID, nextCrossing.tlID);
200 assert(nextCrossing.tlLinkIndex >= 0);
201 device.writeAttr(SUMO_ATTR_TLLINKINDEX, nextCrossing.tlLinkIndex);
202 }
205 device.closeTag();
206 }
207 // optional connections from/to sidewalk
208 std::string edgeID;
209 int laneIndex;
210 for (const std::string& sw : wa.nextSidewalks) {
211 NBHelpers::interpretLaneID(sw, edgeID, laneIndex);
212 NWWriter_SUMO::writeInternalConnection(device, wa.id, edgeID, 0, laneIndex, "");
213 }
214 for (const std::string& sw : wa.prevSidewalks) {
215 NBHelpers::interpretLaneID(sw, edgeID, laneIndex);
216 NWWriter_SUMO::writeInternalConnection(device, edgeID, wa.id, laneIndex, 0, "");
217 }
218 }
219 }
220
221 // write loaded prohibitions
222 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
223 writeProhibitions(device, i->second->getProhibitions());
224 }
225
226 // write roundabout information
227 writeRoundabouts(device, ec.getRoundabouts(), ec);
228
229 // write the districts
230 if (dc.size() != 0 && oc.isDefault("taz-output")) {
231 WRITE_WARNING(TL("Embedding TAZ-data inside the network is deprecated. Use option --taz-output instead"));
232 for (std::map<std::string, NBDistrict*>::const_iterator i = dc.begin(); i != dc.end(); i++) {
233 writeDistrict(device, *(*i).second);
234 }
235 device.lf();
236 }
237 device.close();
238}
239
240
241std::string
242NWWriter_SUMO::getOppositeInternalID(const NBEdgeCont& ec, const NBEdge* from, const NBEdge::Connection& con, double& oppositeLength) {
243 const NBEdge::Lane& succ = con.toEdge->getLanes()[con.toLane];
244 const NBEdge::Lane& pred = from->getLanes()[con.fromLane];
245 const bool lefthand = OptionsCont::getOptions().getBool("lefthand");
246 if (succ.oppositeID != "" && succ.oppositeID != "-" && pred.oppositeID != "" && pred.oppositeID != "-") {
247#ifdef DEBUG_OPPOSITE_INTERNAL
248 std::cout << "getOppositeInternalID con=" << con.getDescription(from) << " (" << con.getInternalLaneID() << ")\n";
249#endif
250 // find the connection that connects succ.oppositeID to pred.oppositeID
251 const NBEdge* succOpp = ec.retrieve(succ.oppositeID.substr(0, succ.oppositeID.rfind("_")));
252 const NBEdge* predOpp = ec.retrieve(pred.oppositeID.substr(0, pred.oppositeID.rfind("_")));
253 assert(succOpp != 0);
254 assert(predOpp != 0);
255 const std::vector<NBEdge::Connection>& connections = succOpp->getConnections();
256 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
257 const NBEdge::Connection& conOpp = *it_c;
258 if (succOpp != from // turnaround
259 && predOpp == conOpp.toEdge
260 && succOpp->getLaneID(conOpp.fromLane) == succ.oppositeID
261 && predOpp->getLaneID(conOpp.toLane) == pred.oppositeID
262 && from->getToNode()->getDirection(from, con.toEdge, lefthand) == LinkDirection::STRAIGHT
263 && from->getToNode()->getDirection(succOpp, predOpp, lefthand) == LinkDirection::STRAIGHT
264 ) {
265#ifdef DEBUG_OPPOSITE_INTERNAL
266 std::cout << " found " << conOpp.getInternalLaneID() << "\n";
267#endif
268 oppositeLength = conOpp.length;
269 return conOpp.getInternalLaneID();
270 } else {
271 /*
272 #ifdef DEBUG_OPPOSITE_INTERNAL
273 std::cout << " rejected " << conOpp.getInternalLaneID()
274 << "\n succ.oppositeID=" << succ.oppositeID
275 << "\n succOppLane=" << succOpp->getLaneID(conOpp.fromLane)
276 << "\n pred.oppositeID=" << pred.oppositeID
277 << "\n predOppLane=" << predOpp->getLaneID(conOpp.toLane)
278 << "\n predOpp=" << predOpp->getID()
279 << "\n conOppTo=" << conOpp.toEdge->getID()
280 << "\n len1=" << con.shape.length()
281 << "\n len2=" << conOpp.shape.length()
282 << "\n";
283 #endif
284 */
285 }
286 }
287 return "";
288 } else {
289 return "";
290 }
291}
292
293
294bool
296 bool ret = false;
297 const EdgeVector& incoming = n.getIncomingEdges();
298 // first pass: determine opposite internal edges and average their length
299 std::map<std::string, std::string> oppositeLaneID;
300 std::map<std::string, double> oppositeLengths;
301 for (NBEdge* e : incoming) {
302 for (const NBEdge::Connection& c : e->getConnections()) {
303 double oppositeLength = 0;
304 const std::string op = getOppositeInternalID(ec, e, c, oppositeLength);
305 oppositeLaneID[c.getInternalLaneID()] = op;
306 if (op != "") {
307 oppositeLengths[c.id] = oppositeLength;
308 }
309 }
310 }
311 if (oppositeLengths.size() > 0) {
312 for (NBEdge* e : incoming) {
313 for (NBEdge::Connection& c : e->getConnections()) {
314 if (oppositeLengths.count(c.id) > 0) {
315 c.length = (c.length + oppositeLengths[c.id]) / 2;
316 }
317 }
318 }
319 }
320
321 for (NBEdge* e : incoming) {
322 const std::vector<NBEdge::Connection>& elv = e->getConnections();
323 if (elv.size() > 0) {
324 bool haveVia = false;
325 std::string edgeID = "";
326 // second pass: write non-via edges
327 for (const NBEdge::Connection& k : elv) {
328 if (k.toEdge == nullptr) {
329 assert(false); // should never happen. tell me when it does
330 continue;
331 }
332 if (edgeID != k.id) {
333 if (edgeID != "") {
334 // close the previous edge
335 into.closeTag();
336 }
337 edgeID = k.id;
339 into.writeAttr(SUMO_ATTR_ID, edgeID);
341 if (k.edgeType != "") {
342 into.writeAttr(SUMO_ATTR_TYPE, k.edgeType);
343 }
344 if (e->getBidiEdge() && k.toEdge->getBidiEdge() &&
345 e != k.toEdge->getTurnDestination(true)) {
346 try {
348 0, e->getTurnDestination(true), 0);
349 into.writeAttr(SUMO_ATTR_BIDI, bidiCon.id);
350 } catch (ProcessError&) {
351 WRITE_WARNINGF(TL("Could not find bidi-connection for edge '%'"), edgeID)
352 }
353 }
354 // open a new edge
355 }
356 // to avoid changing to an internal lane which has a successor
357 // with the wrong permissions we need to inherit them from the successor
358 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
359 SVCPermissions permissions = (k.permissions != SVC_UNSPECIFIED) ? k.permissions : (
360 successor.permissions & e->getPermissions(k.fromLane));
361 SVCPermissions changeLeft = k.changeLeft != SVC_UNSPECIFIED ? k.changeLeft : SVCAll;
362 SVCPermissions changeRight = k.changeRight != SVC_UNSPECIFIED ? k.changeRight : SVCAll;
363 const double width = e->getInternalLaneWidth(n, k, successor, false);
364 writeLane(into, k.getInternalLaneID(), k.vmax, k.friction,
365 permissions, successor.preferred,
366 changeLeft, changeRight,
368 StopOffset(), width, k.shape, &k,
369 k.length, k.internalLaneIndex, oppositeLaneID[k.getInternalLaneID()], "");
370 haveVia = haveVia || k.haveVia;
371 }
372 ret = true;
373 into.closeTag(); // close the last edge
374 // third pass: write via edges
375 if (haveVia) {
376 for (const NBEdge::Connection& k : elv) {
377 if (!k.haveVia) {
378 continue;
379 }
380 if (k.toEdge == nullptr) {
381 assert(false); // should never happen. tell me when it does
382 continue;
383 }
384 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
386 into.writeAttr(SUMO_ATTR_ID, k.viaID);
388 if (k.edgeType != "") {
389 into.writeAttr(SUMO_ATTR_TYPE, k.edgeType);
390 }
391 SVCPermissions permissions = (k.permissions != SVC_UNSPECIFIED) ? k.permissions : (
392 successor.permissions & e->getPermissions(k.fromLane));
393 const double width = e->getInternalLaneWidth(n, k, successor, true);
394 writeLane(into, k.viaID + "_0", k.vmax, k.friction, permissions, successor.preferred,
395 SVCAll, SVCAll, // #XXX todo
397 StopOffset(), width, k.viaShape, &k,
398 MAX2(k.viaLength, POSITION_EPS), // microsim needs positive length
399 0, "", "");
400 into.closeTag();
401 }
402 }
403 }
404 }
405 // write pedestrian crossings
406 for (auto c : n.getCrossings()) {
408 into.writeAttr(SUMO_ATTR_ID, c->id);
410 into.writeAttr(SUMO_ATTR_CROSSING_EDGES, c->edges);
413 StopOffset(), c->width, c->shape, nullptr,
414 MAX2(c->shape.length(), POSITION_EPS), 0, "", "", false, c->customShape.size() != 0);
415 into.closeTag();
416 }
417 // write pedestrian walking areas
418 const std::vector<NBNode::WalkingArea>& WalkingAreas = n.getWalkingAreas();
419 for (std::vector<NBNode::WalkingArea>::const_iterator it = WalkingAreas.begin(); it != WalkingAreas.end(); it++) {
420 const NBNode::WalkingArea& wa = *it;
422 into.writeAttr(SUMO_ATTR_ID, wa.id);
426 StopOffset(), wa.width, wa.shape, nullptr, wa.length, 0, "", "", false, wa.hasCustomShape);
427 into.closeTag();
428 }
429 return ret;
430}
431
432
433void
434NWWriter_SUMO::writeEdge(OutputDevice& into, const NBEdge& e, bool noNames) {
435 // write the edge's begin
439 if (!noNames && e.getStreetName() != "") {
441 }
443 if (e.getTypeID() != "") {
445 }
446 if (e.isMacroscopicConnector()) {
448 }
449 // write the spread type if not default ("right")
452 }
453 if (e.hasLoadedLength()) {
455 }
456 if (!e.hasDefaultGeometry()) {
458 }
459 if (e.getEdgeStopOffset().isDefined()) {
461 }
462 if (e.getBidiEdge()) {
464 }
465 if (e.getDistance() != 0) {
467 }
468
469 // write the lanes
470 const std::vector<NBEdge::Lane>& lanes = e.getLanes();
471
472 const double length = e.getFinalLength();
473 double startOffset = e.isBidiRail() ? e.getTurnDestination(true)->getEndOffset() : 0;
474 for (int i = 0; i < (int) lanes.size(); i++) {
475 const NBEdge::Lane& l = lanes[i];
476 StopOffset stopOffset;
477 if (l.laneStopOffset != e.getEdgeStopOffset()) {
478 stopOffset = l.laneStopOffset;
479 }
480 writeLane(into, e.getLaneID(i), l.speed, l.friction,
483 startOffset, l.endOffset,
484 stopOffset, l.width, l.shape, &l,
485 length, i, l.oppositeID, l.type, l.accelRamp, l.customShape.size() > 0);
486 }
487 // close the edge
488 e.writeParams(into);
489 into.closeTag();
490}
491
492
493void
494NWWriter_SUMO::writeLane(OutputDevice& into, const std::string& lID,
495 double speed, double friction,
496 SVCPermissions permissions, SVCPermissions preferred,
497 SVCPermissions changeLeft, SVCPermissions changeRight,
498 double startOffset, double endOffset,
499 const StopOffset& stopOffset, double width, PositionVector shape,
500 const Parameterised* params, double length, int index,
501 const std::string& oppositeID,
502 const std::string& type,
503 bool accelRamp, bool customShape) {
504 // output the lane's attributes
506 // the first lane of an edge will be the depart lane
507 into.writeAttr(SUMO_ATTR_INDEX, index);
508 // write the list of allowed/disallowed vehicle classes
509 if (permissions != SVC_UNSPECIFIED) {
510 writePermissions(into, permissions);
511 }
512 writePreferences(into, preferred);
513 // some further information
514 if (speed == 0) {
515 WRITE_WARNINGF(TL("Lane '%' has a maximum allowed speed of 0."), lID);
516 } else if (speed < 0) {
517 throw ProcessError("Negative allowed speed (" + toString(speed) + ") on lane '" + lID + "', use --speed.minimum to prevent this.");
518 }
519 into.writeAttr(SUMO_ATTR_SPEED, speed);
520 if (friction != NBEdge::UNSPECIFIED_FRICTION) {
521 into.writeAttr(SUMO_ATTR_FRICTION, friction);
522 }
523 into.writeAttr(SUMO_ATTR_LENGTH, length);
524 if (endOffset != NBEdge::UNSPECIFIED_OFFSET) {
525 into.writeAttr(SUMO_ATTR_ENDOFFSET, endOffset);
526 }
527 if (width != NBEdge::UNSPECIFIED_WIDTH) {
528 into.writeAttr(SUMO_ATTR_WIDTH, width);
529 }
530 if (accelRamp) {
531 into.writeAttr<bool>(SUMO_ATTR_ACCELERATION, accelRamp);
532 }
533 if (customShape) {
535 }
536 if (endOffset > 0 || startOffset > 0) {
537 if (startOffset + endOffset < shape.length()) {
538 shape = shape.getSubpart(startOffset, shape.length() - endOffset);
539 } else {
540 WRITE_ERROR("Invalid endOffset " + toString(endOffset) + " at lane '" + lID
541 + "' with length " + toString(shape.length()) + " (startOffset " + toString(startOffset) + ")");
542 if (!OptionsCont::getOptions().getBool("ignore-errors")) {
543 throw ProcessError();
544 }
545 }
546 }
547 into.writeAttr(SUMO_ATTR_SHAPE, shape);
548 if (type != "") {
549 into.writeAttr(SUMO_ATTR_TYPE, type);
550 }
551 if (changeLeft != SVC_UNSPECIFIED && changeLeft != SVCAll && changeLeft != SVC_IGNORING) {
553 }
554 if (changeRight != SVC_UNSPECIFIED && changeRight != SVCAll && changeRight != SVC_IGNORING) {
556 }
557 if (stopOffset.isDefined()) {
558 writeStopOffsets(into, stopOffset);
559 }
560
561 if (oppositeID != "" && oppositeID != "-") {
563 into.writeAttr(SUMO_ATTR_LANE, oppositeID);
564 into.closeTag();
565 }
566
567 if (params != nullptr) {
568 params->writeParams(into);
569 }
570
571 into.closeTag();
572}
573
574
575void
577 // write the attributes
581 // write the incoming lanes
582 std::vector<std::string> incLanes;
583 const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
584 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
585 int noLanes = (*i)->getNumLanes();
586 for (int j = 0; j < noLanes; j++) {
587 incLanes.push_back((*i)->getLaneID(j));
588 }
589 }
590 std::vector<NBNode::Crossing*> crossings = n.getCrossings();
591 std::set<std::string> prevWAs;
592 // avoid duplicates
593 for (auto c : crossings) {
594 if (prevWAs.count(c->prevWalkingArea) == 0) {
595 incLanes.push_back(c->prevWalkingArea + "_0");
596 prevWAs.insert(c->prevWalkingArea);
597 }
598 }
599 into.writeAttr(SUMO_ATTR_INCLANES, incLanes);
600 // write the internal lanes
601 std::vector<std::string> intLanes;
602 if (!OptionsCont::getOptions().getBool("no-internal-links")) {
603 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
604 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
605 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
606 if ((*k).toEdge == nullptr) {
607 continue;
608 }
609 if (!(*k).haveVia) {
610 intLanes.push_back((*k).getInternalLaneID());
611 } else {
612 intLanes.push_back((*k).viaID + "_0");
613 }
614 }
615 }
616 }
618 for (auto c : crossings) {
619 intLanes.push_back(c->id + "_0");
620 }
621 }
622 into.writeAttr(SUMO_ATTR_INTLANES, intLanes);
623 // close writing
625 // write optional radius
628 }
629 // specify whether a custom shape was used
630 if (n.hasCustomShape()) {
632 }
635 }
637 into.writeAttr<std::string>(SUMO_ATTR_FRINGE, toString(n.getFringeType()));
638 }
639 if (n.getName() != "") {
641 }
643 // write right-of-way logics
644 n.writeLogic(into);
645 }
646 n.writeParams(into);
647 into.closeTag();
648}
649
650
651bool
653 bool ret = false;
654 const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
655 // build the list of internal lane ids
656 std::vector<std::string> internalLaneIDs;
657 std::map<std::string, std::string> viaIDs;
658 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
659 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
660 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
661 if ((*k).toEdge != nullptr) {
662 internalLaneIDs.push_back((*k).getInternalLaneID());
663 viaIDs[(*k).getInternalLaneID()] = ((*k).viaID);
664 }
665 }
666 }
667 for (auto c : n.getCrossings()) {
668 internalLaneIDs.push_back(c->id + "_0");
669 }
670 // write the internal nodes
671 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
672 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
673 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
674 if ((*k).toEdge == nullptr || !(*k).haveVia) {
675 continue;
676 }
677 Position pos = (*k).shape[-1];
678 into.openTag(SUMO_TAG_JUNCTION).writeAttr(SUMO_ATTR_ID, (*k).viaID + "_0");
681 std::string incLanes = (*k).getInternalLaneID();
682 std::vector<std::string> foeIDs;
683 for (std::string incLane : (*k).foeIncomingLanes) {
684 if (incLane[0] == ':') {
685 // intersecting left turns
686 const int index = StringUtils::toInt(incLane.substr(1));
687 incLane = internalLaneIDs[index];
688 if (viaIDs[incLane] != "") {
689 foeIDs.push_back(viaIDs[incLane] + "_0");
690 }
691 }
692 incLanes += " " + incLane;
693 }
694 into.writeAttr(SUMO_ATTR_INCLANES, incLanes);
695 const std::vector<int>& foes = (*k).foeInternalLinks;
696 for (std::vector<int>::const_iterator it = foes.begin(); it != foes.end(); ++it) {
697 foeIDs.push_back(internalLaneIDs[*it]);
698 }
699 into.writeAttr(SUMO_ATTR_INTLANES, joinToString(foeIDs, " "));
700 into.closeTag();
701 ret = true;
702 }
703 }
704 return ret;
705}
706
707
708void
710 bool includeInternal, ConnectionStyle style, bool geoAccuracy) {
711 assert(c.toEdge != 0);
713 into.writeAttr(SUMO_ATTR_FROM, from.getID());
717 if (style != TLL) {
718 if (c.mayDefinitelyPass) {
720 }
721 if (c.keepClear == KEEPCLEAR_FALSE) {
722 into.writeAttr<bool>(SUMO_ATTR_KEEP_CLEAR, false);
723 }
726 }
727 if (c.permissions != SVC_UNSPECIFIED) {
729 }
732 }
735 }
738 }
741 }
742 if (c.customShape.size() != 0) {
743 if (geoAccuracy) {
745 }
747 if (geoAccuracy) {
748 into.setPrecision();
749 }
750 }
751 if (c.uncontrolled != false) {
753 }
754 if (c.indirectLeft != false) {
756 }
757 if (c.edgeType != "") {
759 }
760 }
761 if (style != PLAIN) {
762 if (includeInternal) {
764 }
765 // set information about the controlling tl if any
766 if (c.tlID != "") {
769 if (c.tlLinkIndex2 >= 0) {
771 }
772 }
773 }
774 if (style != TLL) {
775 if (style == SUMONET) {
776 // write the direction information
777 LinkDirection dir = from.getToNode()->getDirection(&from, c.toEdge, OptionsCont::getOptions().getBool("lefthand"));
778 assert(dir != LinkDirection::NODIR);
779 into.writeAttr(SUMO_ATTR_DIR, toString(dir));
780 // write the state information
781 const LinkState linkState = from.getToNode()->getLinkState(
782 &from, c.toEdge, c.fromLane, c.toLane, c.mayDefinitelyPass, c.tlID);
783 into.writeAttr(SUMO_ATTR_STATE, linkState);
784 if (linkState == LINKSTATE_MINOR
786 && c.toEdge->getJunctionPriority(c.toEdge->getToNode()) == NBEdge::JunctionPriority::ROUNDABOUT) {
787 const double visibilityDistance = OptionsCont::getOptions().getFloat("roundabouts.visibility-distance");
788 if (visibilityDistance != NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE) {
789 into.writeAttr(SUMO_ATTR_VISIBILITY_DISTANCE, visibilityDistance);
790 }
791 }
792 }
795 }
796 }
797 c.writeParams(into);
798 into.closeTag();
799}
800
801
802bool
804 bool ret = false;
805 const bool lefthand = OptionsCont::getOptions().getBool("lefthand");
806 const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
807 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
808 NBEdge* from = *i;
809 const std::vector<NBEdge::Connection>& connections = from->getConnections();
810 for (std::vector<NBEdge::Connection>::const_iterator j = connections.begin(); j != connections.end(); ++j) {
811 const NBEdge::Connection& c = *j;
812 LinkDirection dir = n.getDirection(from, c.toEdge, lefthand);
813 assert(c.toEdge != 0);
814 if (c.haveVia) {
815 // internal split with optional signal
816 std::string tlID = "";
817 int linkIndex2 = NBConnection::InvalidTlIndex;
819 linkIndex2 = c.tlLinkIndex2;
820 tlID = c.tlID;
821 }
822 writeInternalConnection(into, c.id, c.toEdge->getID(), c.internalLaneIndex, c.toLane, c.viaID + "_0", dir, tlID, linkIndex2, false, c.visibility);
824 } else {
825 // no internal split
826 writeInternalConnection(into, c.id, c.toEdge->getID(), c.internalLaneIndex, c.toLane, "", dir);
827 }
828 ret = true;
829 }
830 }
831 return ret;
832}
833
834
835void
837 const std::string& from, const std::string& to,
838 int fromLane, int toLane, const std::string& via,
839 LinkDirection dir,
840 const std::string& tlID, int linkIndex,
841 bool minor,
842 double visibility) {
844 into.writeAttr(SUMO_ATTR_FROM, from);
845 into.writeAttr(SUMO_ATTR_TO, to);
846 into.writeAttr(SUMO_ATTR_FROM_LANE, fromLane);
847 into.writeAttr(SUMO_ATTR_TO_LANE, toLane);
848 if (via != "") {
849 into.writeAttr(SUMO_ATTR_VIA, via);
850 }
851 if (tlID != "" && linkIndex != NBConnection::InvalidTlIndex) {
852 // used for the reverse direction of pedestrian crossings
853 into.writeAttr(SUMO_ATTR_TLID, tlID);
854 into.writeAttr(SUMO_ATTR_TLLINKINDEX, linkIndex);
855 }
856 into.writeAttr(SUMO_ATTR_DIR, dir);
857 into.writeAttr(SUMO_ATTR_STATE, ((via != "" || minor) ? "m" : "M"));
858 if (visibility != NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE) {
860 }
861 into.closeTag();
862}
863
864
865void
866NWWriter_SUMO::writeRoundabouts(OutputDevice& into, const std::set<EdgeSet>& roundabouts,
867 const NBEdgeCont& ec) {
868 // make output deterministic
869 std::vector<std::vector<std::string> > edgeIDs;
870 for (std::set<EdgeSet>::const_iterator i = roundabouts.begin(); i != roundabouts.end(); ++i) {
871 std::vector<std::string> tEdgeIDs;
872 for (EdgeSet::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
873 // the edges may have been erased from NBEdgeCont but their pointers are still valid
874 // we verify their existance in writeRoundabout()
875 tEdgeIDs.push_back((*j)->getID());
876 }
877 std::sort(tEdgeIDs.begin(), tEdgeIDs.end());
878 edgeIDs.push_back(tEdgeIDs);
879 }
880 std::sort(edgeIDs.begin(), edgeIDs.end());
881 // write
882 for (std::vector<std::vector<std::string> >::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
883 writeRoundabout(into, *i, ec);
884 }
885 if (roundabouts.size() != 0) {
886 into.lf();
887 }
888}
889
890
891void
892NWWriter_SUMO::writeRoundabout(OutputDevice& into, const std::vector<std::string>& edgeIDs,
893 const NBEdgeCont& ec) {
894 std::vector<std::string> validEdgeIDs;
895 std::vector<std::string> invalidEdgeIDs;
896 std::vector<std::string> nodeIDs;
897 for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
898 const NBEdge* edge = ec.retrieve(*i);
899 if (edge != nullptr) {
900 nodeIDs.push_back(edge->getToNode()->getID());
901 validEdgeIDs.push_back(edge->getID());
902 } else {
903 invalidEdgeIDs.push_back(*i);
904 }
905 }
906 std::sort(nodeIDs.begin(), nodeIDs.end());
907 if (validEdgeIDs.size() > 0) {
909 into.writeAttr(SUMO_ATTR_NODES, joinToString(nodeIDs, " "));
910 into.writeAttr(SUMO_ATTR_EDGES, joinToString(validEdgeIDs, " "));
911 into.closeTag();
912 if (invalidEdgeIDs.size() > 0) {
913 WRITE_WARNING("Writing incomplete roundabout. Edges: '"
914 + joinToString(invalidEdgeIDs, " ") + "' no longer exist'");
915 }
916 }
917}
918
919
920void
922 std::vector<double> sourceW = d.getSourceWeights();
924 std::vector<double> sinkW = d.getSinkWeights();
926 // write the head and the id of the district
928 if (d.getShape().size() > 0) {
930 }
931 // write all sources
932 const std::vector<NBEdge*>& sources = d.getSourceEdges();
933 for (int i = 0; i < (int)sources.size(); i++) {
934 // write the head and the id of the source
935 into.openTag(SUMO_TAG_TAZSOURCE).writeAttr(SUMO_ATTR_ID, sources[i]->getID()).writeAttr(SUMO_ATTR_WEIGHT, sourceW[i]);
936 into.closeTag();
937 }
938 // write all sinks
939 const std::vector<NBEdge*>& sinks = d.getSinkEdges();
940 for (int i = 0; i < (int)sinks.size(); i++) {
941 // write the head and the id of the sink
942 into.openTag(SUMO_TAG_TAZSINK).writeAttr(SUMO_ATTR_ID, sinks[i]->getID()).writeAttr(SUMO_ATTR_WEIGHT, sinkW[i]);
943 into.closeTag();
944 }
945 // write the tail
946 into.closeTag();
947}
948
949
950std::string
952 double time = STEPS2TIME(steps);
953 if (time == std::floor(time)) {
954 return toString(int(time));
955 } else {
956 return toString(time);
957 }
958}
959
960
961void
963 for (NBConnectionProhibits::const_iterator j = prohibitions.begin(); j != prohibitions.end(); j++) {
964 NBConnection prohibited = (*j).first;
965 const NBConnectionVector& prohibiting = (*j).second;
966 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
967 NBConnection prohibitor = *k;
971 into.closeTag();
972 }
973 }
974}
975
976
977std::string
979 return c.getFrom()->getID() + "->" + c.getTo()->getID();
980}
981
982
983void
985 std::vector<NBTrafficLightLogic*> logics = tllCont.getComputed();
986 for (NBTrafficLightLogic* logic : logics) {
987 writeTrafficLight(into, logic);
988 // only raise warnings on write instead of on compute (to avoid cluttering netedit)
989 NBTrafficLightDefinition* def = tllCont.getDefinition(logic->getID(), logic->getProgramID());
990 assert(def != nullptr);
991 def->finalChecks();
992 }
993 if (logics.size() > 0) {
994 into.lf();
995 }
996}
997
998
999void
1002 into.writeAttr(SUMO_ATTR_ID, logic->getID());
1003 into.writeAttr(SUMO_ATTR_TYPE, logic->getType());
1006 // write the phases
1007 const bool varPhaseLength = logic->getType() != TrafficLightType::STATIC;
1008 for (const NBTrafficLightLogic::PhaseDefinition& phase : logic->getPhases()) {
1009 into.openTag(SUMO_TAG_PHASE);
1010 into.writeAttr(SUMO_ATTR_DURATION, writeSUMOTime(phase.duration));
1011 if (phase.duration < TIME2STEPS(10)) {
1012 into.writePadding(" ");
1013 }
1014 into.writeAttr(SUMO_ATTR_STATE, phase.state);
1015 if (varPhaseLength) {
1017 into.writeAttr(SUMO_ATTR_MINDURATION, writeSUMOTime(phase.minDur));
1018 }
1020 into.writeAttr(SUMO_ATTR_MAXDURATION, writeSUMOTime(phase.maxDur));
1021 }
1022 if (phase.earliestEnd != NBTrafficLightDefinition::UNSPECIFIED_DURATION) {
1023 into.writeAttr(SUMO_ATTR_EARLIEST_END, writeSUMOTime(phase.earliestEnd));
1024 }
1025 if (phase.latestEnd != NBTrafficLightDefinition::UNSPECIFIED_DURATION) {
1026 into.writeAttr(SUMO_ATTR_LATEST_END, writeSUMOTime(phase.latestEnd));
1027 }
1028 // NEMA attributes
1031 }
1033 into.writeAttr(SUMO_ATTR_YELLOW, writeSUMOTime(phase.yellow));
1034 }
1036 into.writeAttr(SUMO_ATTR_RED, writeSUMOTime(phase.red));
1037 }
1038 }
1039 if (phase.name != "") {
1041 }
1042 if (phase.next.size() > 0) {
1043 into.writeAttr(SUMO_ATTR_NEXT, phase.next);
1044 }
1045 into.closeTag();
1046 }
1047 // write params
1048 logic->writeParams(into);
1049 into.closeTag();
1050}
1051
1052
1053void
1055 if (stopOffset.isDefined()) {
1056 const std::string ss_vclasses = getVehicleClassNames(stopOffset.getPermissions());
1057 if (ss_vclasses.length() == 0) {
1058 // This stopOffset would have no effect...
1059 return;
1060 }
1062 const std::string ss_exceptions = getVehicleClassNames(~stopOffset.getPermissions());
1063 if (ss_vclasses.length() <= ss_exceptions.length()) {
1064 into.writeAttr(SUMO_ATTR_VCLASSES, ss_vclasses);
1065 } else {
1066 if (ss_exceptions.length() == 0) {
1067 into.writeAttr(SUMO_ATTR_VCLASSES, "all");
1068 } else {
1069 into.writeAttr(SUMO_ATTR_EXCEPTIONS, ss_exceptions);
1070 }
1071 }
1072 into.writeAttr(SUMO_ATTR_VALUE, stopOffset.getOffset());
1073 into.closeTag();
1074 }
1075}
1076
1077
1078/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
std::vector< NBConnection > NBConnectionVector
Definition of a connection vector.
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:42
@ KEEPCLEAR_FALSE
Definition: NBCont.h:59
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
const SVCPermissions SVCAll
all VClasses are allowed
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_PHASE
a single phase description
@ SUMO_TAG_STOPOFFSET
Information on vClass specific stop offsets at lane end.
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
@ SUMO_TAG_PROHIBITION
prohibition of circulation between two edges
@ SUMO_TAG_CONNECTION
connectio 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_TAZSOURCE
a source within a district (connection road)
@ SUMO_TAG_NEIGH
begin/end of the description of a neighboring lane
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
@ STRAIGHT
The link is a straight direction.
@ NODIR
The link has no direction (is a dead end link)
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.
@ LINKSTATE_MINOR
This is an uncontrolled, minor link, has to brake.
@ SUMO_ATTR_LANE
@ SUMO_ATTR_NODES
a list of node ids, used for controlling joining
@ 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_VIA
@ 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_FROM_LANE
@ SUMO_ATTR_LIMIT_TURN_SPEED
@ SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT
@ SUMO_ATTR_OFFSET
@ 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_WEIGHT
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_INCLANES
@ SUMO_ATTR_CHANGE_LEFT
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_VCLASSES
@ SUMO_ATTR_NAME
@ SUMO_ATTR_EXCEPTIONS
@ 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_DIR
The abstract direction of a link.
@ 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_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)
int gPrecisionGeo
Definition: StdDefs.cpp:26
const double NETWORK_VERSION
version for written networks and default version for loading
Definition: StdDefs.h:63
T MAX2(T a, T b)
Definition: StdDefs.h:77
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:282
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
static void writeLocation(OutputDevice &into)
writes the location element
NBEdge * getFrom() const
returns the from-edge (start of the connection)
static const int InvalidTlIndex
Definition: NBConnection.h:123
NBEdge * getTo() const
returns the to-edge (end of the connection)
A container for districts.
std::map< std::string, NBDistrict * >::const_iterator end() const
Returns the pointer to the end of the stored districts.
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin of the stored districts.
int size() const
Returns the number of districts inside the container.
A class representing a single district.
Definition: NBDistrict.h:62
const std::vector< double > & getSourceWeights() const
Returns the weights of the sources.
Definition: NBDistrict.h:180
const std::vector< double > & getSinkWeights() const
Returns the weights of the sinks.
Definition: NBDistrict.h:196
const PositionVector & getShape() const
Returns the shape.
Definition: NBDistrict.h:212
const std::vector< NBEdge * > & getSinkEdges() const
Returns the sinks.
Definition: NBDistrict.h:204
const std::vector< NBEdge * > & getSourceEdges() const
Returns the sources.
Definition: NBDistrict.h:188
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:59
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:170
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:274
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:177
The representation of a single edge during network building.
Definition: NBEdge.h:92
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition: NBEdge.h:1043
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition: NBEdge.h:608
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:552
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Definition: NBEdge.h:366
const Connection & getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns ...
Definition: NBEdge.cpp:1255
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:787
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition: NBEdge.cpp:974
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
Definition: NBEdge.cpp:762
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:618
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:736
const std::string & getID() const
Definition: NBEdge.h:1526
double getDistance() const
get distance
Definition: NBEdge.h:685
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:375
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
Definition: NBEdge.cpp:3990
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition: NBEdge.h:369
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition: NBEdge.h:372
std::string getLaneID(int lane) const
get lane ID
Definition: NBEdge.cpp:3776
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:363
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
Definition: NBEdge.cpp:2057
const std::string & getTypeID() const
get ID of type
Definition: NBEdge.h:1183
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:675
const NBEdge * getBidiEdge() const
Definition: NBEdge.h:1512
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:545
NBEdge * getTurnDestination(bool possibleDestination=false) const
Definition: NBEdge.cpp:3767
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:621
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:533
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:357
double getEndOffset() const
Returns the offset to the destination node.
Definition: NBEdge.h:695
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:360
bool isMacroscopicConnector() const
Returns whether this edge was marked as a macroscopic connector.
Definition: NBEdge.h:1138
double getFinalLength() const
get length that will be assigned to the lanes in the final network
Definition: NBEdge.cpp:4469
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, int &index)
parses edge-id and index from lane-id
Definition: NBHelpers.cpp:119
Instance responsible for building networks.
Definition: NBNetBuilder.h:107
NBNodeCont & getNodeCont()
Returns a reference to the node container.
Definition: NBNetBuilder.h:144
NBEdgeCont & getEdgeCont()
Definition: NBNetBuilder.h:139
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
Definition: NBNetBuilder.h:159
NBTypeCont & getTypeCont()
Returns a reference to the type container.
Definition: NBNetBuilder.h:149
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
Definition: NBNetBuilder.h:154
A definition of a pedestrian crossing.
Definition: NBNode.h:129
int tlLinkIndex
the traffic light index of this crossing (if controlled)
Definition: NBNode.h:154
std::string tlID
The id of the traffic light that controls this connection.
Definition: NBNode.h:160
bool priority
whether the pedestrians have priority
Definition: NBNode.h:150
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition: NBNodeCont.h:113
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:118
Represents a single node (junction) during network building.
Definition: NBNode.h:66
LinkState getLinkState(const NBEdge *incoming, NBEdge *outgoing, int fromLane, int toLane, bool mayDefinitelyPass, const std::string &tlID) const
get link state
Definition: NBNode.cpp:2294
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
Definition: NBNode.cpp:2229
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
Definition: NBNode.h:290
static const double UNSPECIFIED_RADIUS
unspecified lane width
Definition: NBNode.h:210
Crossing * getCrossing(const std::string &id) const
return the crossing with the given id
Definition: NBNode.cpp:3550
FringeType getFringeType() const
Returns fringe type.
Definition: NBNode.h:295
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:275
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
Definition: NBNode.h:258
bool hasCustomShape() const
return whether the shape was set by the user
Definition: NBNode.h:560
bool brakeForCrossingOnExit(const NBEdge *to) const
whether a connection to the given edge must brake for a crossing when leaving the intersection
Definition: NBNode.cpp:1919
std::vector< Crossing * > getCrossings() const
return this junctions pedestrian crossings
Definition: NBNode.cpp:2777
const std::string & getName() const
Returns intersection name.
Definition: NBNode.h:300
bool writeLogic(OutputDevice &into) const
writes the XML-representation of the logic as a bitset-logic XML representation
Definition: NBNode.cpp:1029
const Position & getPosition() const
Definition: NBNode.h:250
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2447
double getRadius() const
Returns the turning radius of this node.
Definition: NBNode.h:280
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
Definition: NBNode.h:719
The base class for traffic light logic definitions.
virtual void finalChecks() const
perform optional final checks
static const SUMOTime UNSPECIFIED_DURATION
The definition of a single phase of the logic.
A container for traffic light definitions and built programs.
std::vector< NBTrafficLightLogic * > getComputed() const
Returns a list of all computed logics.
NBTrafficLightDefinition * getDefinition(const std::string &id, const std::string &programID) const
Returns the named definition.
A SUMO-compliant built logic for a traffic light.
SUMOTime getOffset() const
Returns the offset of first switch.
TrafficLightType getType() const
get the algorithm type (static etc..)
const std::string & getProgramID() const
Returns the ProgramID.
const std::vector< PhaseDefinition > & getPhases() const
Returns the phases.
void writeEdgeTypes(OutputDevice &into) const
writes all EdgeTypes (and their lanes) as XML
Definition: NBTypeCont.cpp:377
static void writePositionLong(const Position &pos, OutputDevice &dev)
Writes the given position to device in long format (one attribute per dimension)
Definition: NWFrame.cpp:187
static void writeConnection(OutputDevice &into, const NBEdge &from, const NBEdge::Connection &c, bool includeInternal, ConnectionStyle style=SUMONET, bool geoAccuracy=false)
Writes connections outgoing from the given edge (also used in NWWriter_XML)
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into a SUMO-file.
static bool writeInternalNodes(OutputDevice &into, const NBNode &n)
Writes internal junctions (<junction with id[0]==':' ...) of the given node.
static void writeProhibitions(OutputDevice &into, const NBConnectionProhibits &prohibitions)
writes the given prohibitions
static void writeEdge(OutputDevice &into, const NBEdge &e, bool noNames)
Writes an edge (<edge ...)
static std::string getOppositeInternalID(const NBEdgeCont &ec, const NBEdge *from, const NBEdge::Connection &con, double &oppositeLength)
retrieve the id of the opposite direction internal lane if it exists
static std::string writeSUMOTime(SUMOTime time)
writes a SUMOTime as int if possible, otherwise as a float
static void writeJunction(OutputDevice &into, const NBNode &n)
Writes a junction (<junction ...)
static bool writeInternalEdges(OutputDevice &into, const NBEdgeCont &ec, const NBNode &n)
Writes internal edges (<edge ... with id[0]==':') of the given node.
static bool writeInternalConnections(OutputDevice &into, const NBNode &n)
Writes inner connections within the node.
static void writeDistrict(OutputDevice &into, const NBDistrict &d)
Writes a district.
static void writeRoundabouts(OutputDevice &into, const std::set< EdgeSet > &roundabouts, const NBEdgeCont &ec)
Writes roundabouts.
static void writeRoundabout(OutputDevice &into, const std::vector< std::string > &r, const NBEdgeCont &ec)
Writes a roundabout.
static void writeStopOffsets(OutputDevice &into, const StopOffset &stopOffset)
Write a stopOffset element into output device.
static void writeInternalConnection(OutputDevice &into, const std::string &from, const std::string &to, int fromLane, int toLane, const std::string &via, LinkDirection dir=LinkDirection::STRAIGHT, const std::string &tlID="", int linkIndex=NBConnection::InvalidTlIndex, bool minor=false, double visibility=NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE)
Writes a single internal connection.
static void writeTrafficLight(OutputDevice &into, const NBTrafficLightLogic *logic)
writes a single traffic light logic to the given device
static void writeLane(OutputDevice &into, const std::string &lID, double speed, double friction, SVCPermissions permissions, SVCPermissions preferred, SVCPermissions changeLeft, SVCPermissions changeRight, double startOffset, double endOffset, const StopOffset &stopOffset, double width, PositionVector shape, const Parameterised *params, double length, int index, const std::string &oppositeID, const std::string &type, bool accelRamp=false, bool customShape=false)
Writes a lane (<lane ...) of an edge.
static std::string prohibitionConnection(const NBConnection &c)
the attribute value for a prohibition
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A storage for options typed value containers)
Definition: OptionsCont.h:89
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)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
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 exists(const std::string &name) const
Returns the information whether the named option is known.
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)
void resetWritable()
Resets all options to be writeable.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
void lf()
writes a line feed if applicable
Definition: OutputDevice.h:239
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:251
OutputDevice & writePadding(const std::string &val)
writes padding (ignored for binary output)
Definition: OutputDevice.h:314
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >(), bool includeConfig=true)
Writes an XML header with optional configuration.
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
double length() const
Returns the length.
PositionVector simplified() const
return the same shape with intermediate colinear points removed
PositionVector getSubpart(double beginOffset, double endOffset) const
get subpart of a position vector
stop offset
bool isDefined() const
check if stopOffset was defined
SVCPermissions getPermissions() const
get permissions
double getOffset() const
get offset
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static void normaliseSum(std::vector< T > &v, T msum=1.0)
Definition: VectorHelper.h:47
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:201
bool indirectLeft
Whether this connection is an indirect left turn.
Definition: NBEdge.h:278
int fromLane
The lane the connections starts at.
Definition: NBEdge.h:227
std::string viaID
if Connection have a via, ID of it
Definition: NBEdge.h:296
int toLane
The lane the connections yields in.
Definition: NBEdge.h:233
SVCPermissions permissions
List of vehicle types that are allowed on this connection.
Definition: NBEdge.h:269
double speed
custom speed for connection
Definition: NBEdge.h:257
NBEdge * toEdge
The edge the connections yields in.
Definition: NBEdge.h:230
KeepClear keepClear
whether the junction must be kept clear when using this connection
Definition: NBEdge.h:248
double customLength
custom length for connection
Definition: NBEdge.h:263
std::string edgeType
optional type of Connection
Definition: NBEdge.h:281
bool uncontrolled
check if Connection is uncontrolled
Definition: NBEdge.h:314
PositionVector customShape
custom shape for connection
Definition: NBEdge.h:266
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
Definition: NBEdge.h:245
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this connections internal lane(s)
Definition: NBEdge.h:272
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this connections internal lane(s)
Definition: NBEdge.h:275
std::string getDescription(const NBEdge *parent) const
get string describing this connection
Definition: NBEdge.cpp:95
double contPos
custom position for internal junction on this connection
Definition: NBEdge.h:251
std::string getInternalLaneID() const
get ID of internal lane
Definition: NBEdge.cpp:89
int internalLaneIndex
The lane index of this internal lane within the internal edge.
Definition: NBEdge.h:311
std::string tlID
The id of the traffic light that controls this connection.
Definition: NBEdge.h:236
double visibility
custom foe visiblity for connection
Definition: NBEdge.h:254
int tlLinkIndex2
The index of the internal junction within the controlling traffic light (optional)
Definition: NBEdge.h:242
double length
computed length (average of all internal lane shape lengths that share an internal edge)
Definition: NBEdge.h:323
std::string id
id of Connection
Definition: NBEdge.h:284
bool haveVia
check if Connection have a Via
Definition: NBEdge.h:293
int tlLinkIndex
The index of this connection within the controlling traffic light.
Definition: NBEdge.h:239
An (internal) definition of a single lane of an edge.
Definition: NBEdge.h:143
double width
This lane's width.
Definition: NBEdge.h:176
StopOffset laneStopOffset
stopOffsets.second - The stop offset for vehicles stopping at the lane's end. Applies if vClass is in...
Definition: NBEdge.h:173
PositionVector customShape
A custom shape for this lane set by the user.
Definition: NBEdge.h:189
double endOffset
This lane's offset to the intersection begin.
Definition: NBEdge.h:169
std::string type
the type of this lane
Definition: NBEdge.h:192
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
Definition: NBEdge.h:160
double speed
The speed allowed on this lane.
Definition: NBEdge.h:151
std::string oppositeID
An opposite lane ID, if given.
Definition: NBEdge.h:179
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this lane.
Definition: NBEdge.h:166
double friction
The friction on this lane.
Definition: NBEdge.h:154
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this lane.
Definition: NBEdge.h:163
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
Definition: NBEdge.h:157
bool accelRamp
Whether this lane is an acceleration lane.
Definition: NBEdge.h:182
PositionVector shape
The lane's shape.
Definition: NBEdge.h:148
A definition of a pedestrian walking area.
Definition: NBNode.h:169
std::string id
the (edge)-id of this walkingArea
Definition: NBNode.h:176
bool hasCustomShape
whether this walkingArea has a custom shape
Definition: NBNode.h:192
double width
This lane's width.
Definition: NBNode.h:178
PositionVector shape
The polygonal shape.
Definition: NBNode.h:182
double length
This lane's width.
Definition: NBNode.h:180