Eclipse SUMO - Simulation of Urban MObility
NWWriter_DlrNavteq.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2012-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/****************************************************************************/
19// Exporter writing networks using DlrNavteq (Elmar) format
20/****************************************************************************/
21#include <config.h>
22#include <algorithm>
23#include <ctime>
24#include <cmath>
26#include <netbuild/NBEdge.h>
27#include <netbuild/NBEdgeCont.h>
28#include <netbuild/NBNode.h>
29#include <netbuild/NBNodeCont.h>
38#include "NWFrame.h"
39#include "NWWriter_DlrNavteq.h"
40
41
42// ---------------------------------------------------------------------------
43// static members
44// ---------------------------------------------------------------------------
45const std::string NWWriter_DlrNavteq::UNDEFINED("-1");
46
47// ---------------------------------------------------------------------------
48// static methods
49// ---------------------------------------------------------------------------
50void
52 // check whether a matsim-file shall be generated
53 if (!oc.isSet("dlr-navteq-output")) {
54 return;
55 }
56 std::map<NBEdge*, std::string> internalNodes;
57 writeNodesUnsplitted(oc, nb.getNodeCont(), nb.getEdgeCont(), internalNodes);
58 writeLinksUnsplitted(oc, nb.getEdgeCont(), internalNodes);
62}
63
64
66 device << "# Format matches Extraction version: V6.5 \n";
67 std::stringstream tmp;
68 oc.writeConfiguration(tmp, true, false, false);
69 tmp.seekg(std::ios_base::beg);
70 std::string line;
71 while (!tmp.eof()) {
72 std::getline(tmp, line);
73 device << "# " << line << "\n";
74 }
75 device << "#\n";
76}
77
78void
79NWWriter_DlrNavteq::writeNodesUnsplitted(const OptionsCont& oc, NBNodeCont& nc, NBEdgeCont& ec, std::map<NBEdge*, std::string>& internalNodes) {
80 // For "real" nodes we simply use the node id.
81 // For internal nodes (geometry vectors describing edge geometry in the parlance of this format)
82 // we use the id of the edge and do not bother with
83 // compression (each direction gets its own internal node).
84 OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_nodes_unsplitted.txt");
85 writeHeader(device, oc);
87 const bool haveGeo = gch.usingGeoProjection();
88 const double geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE
89 device.setPrecision(oc.getInt("dlr-navteq.precision"));
90 if (!haveGeo) {
91 WRITE_WARNING(TL("DlrNavteq node data will be written in (floating point) cartesian coordinates"));
92 }
93 // write format specifier
94 device << "# NODE_ID\tIS_BETWEEN_NODE\tamount_of_geocoordinates\tx1\ty1\t[x2 y2 ... xn yn]\n";
95 // write header
96 Boundary boundary = gch.getConvBoundary();
97 Position min(boundary.xmin(), boundary.ymin());
98 Position max(boundary.xmax(), boundary.ymax());
99 gch.cartesian2geo(min);
100 min.mul(geoScale);
101 gch.cartesian2geo(max);
102 max.mul(geoScale);
103 int multinodes = 0;
104 for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
105 if ((*i).second->getGeometry().size() > 2) {
106 multinodes++;
107 }
108 }
109 device << "# [xmin_region] " << min.x() << "\n";
110 device << "# [xmax_region] " << max.x() << "\n";
111 device << "# [ymin_region] " << min.y() << "\n";
112 device << "# [ymax_region] " << max.y() << "\n";
113 device << "# [elements_multinode] " << multinodes << "\n";
114 device << "# [elements_normalnode] " << nc.size() << "\n";
115 device << "# [xmin] " << min.x() << "\n";
116 device << "# [xmax] " << max.x() << "\n";
117 device << "# [ymin] " << min.y() << "\n";
118 device << "# [ymax] " << max.y() << "\n";
119 // write normal nodes
120 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
121 NBNode* n = (*i).second;
122 Position pos = n->getPosition();
123 gch.cartesian2geo(pos);
124 pos.mul(geoScale);
125 device << n->getID() << "\t0\t1\t" << pos.x() << "\t" << pos.y() << "\n";
126 }
127 // write "internal" nodes
128 std::vector<std::string> avoid;
129 std::set<std::string> reservedNodeIDs;
130 const bool numericalIDs = oc.getBool("numerical-ids");
131 if (oc.isSet("reserved-ids")) {
132 NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "node:", reservedNodeIDs); // backward compatibility
133 NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "junction:", reservedNodeIDs); // selection format
134 }
135 if (numericalIDs) {
136 avoid = nc.getAllNames();
137 std::vector<std::string> avoid2 = ec.getAllNames();
138 avoid.insert(avoid.end(), avoid2.begin(), avoid2.end());
139 avoid.insert(avoid.end(), reservedNodeIDs.begin(), reservedNodeIDs.end());
140 }
141 IDSupplier idSupplier("", avoid);
142 for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
143 NBEdge* e = (*i).second;
144 PositionVector geom = e->getGeometry();
145 if (geom.size() > 2) {
146 // the import NIImporter_DlrNavteq checks for the presence of a
147 // negated edge id to determine spread type. We may need to do some
148 // shifting to make this consistent
149 const bool hasOppositeID = ec.getOppositeByID(e->getID()) != nullptr;
150 if (e->getLaneSpreadFunction() == LaneSpreadFunction::RIGHT && !hasOppositeID) {
151 // need to write center-line geometry instead
152 try {
153 geom.move2side(e->getTotalWidth() / 2);
154 } catch (InvalidArgument& exception) {
155 WRITE_WARNING("Could not reconstruct shape for edge:'" + e->getID() + "' (" + exception.what() + ").");
156 }
157 } else if (e->getLaneSpreadFunction() == LaneSpreadFunction::CENTER && hasOppositeID) {
158 // need to write left-border geometry instead
159 try {
160 geom.move2side(-e->getTotalWidth() / 2);
161 } catch (InvalidArgument& exception) {
162 WRITE_WARNING("Could not reconstruct shape for edge:'" + e->getID() + "' (" + exception.what() + ").");
163 }
164 }
165
166 std::string internalNodeID = e->getID();
167 if (internalNodeID == UNDEFINED
168 || (nc.retrieve(internalNodeID) != nullptr)
169 || reservedNodeIDs.count(internalNodeID) > 0
170 ) {
171 // need to invent a new name to avoid clashing with the id of a 'real' node or a reserved name
172 if (numericalIDs) {
173 internalNodeID = idSupplier.getNext();
174 } else {
175 internalNodeID += "_geometry";
176 }
177 }
178 internalNodes[e] = internalNodeID;
179 device << internalNodeID << "\t1\t" << geom.size() - 2;
180 for (int ii = 1; ii < (int)geom.size() - 1; ++ii) {
181 Position pos = geom[(int)ii];
182 gch.cartesian2geo(pos);
183 pos.mul(geoScale);
184 device << "\t" << pos.x() << "\t" << pos.y();
185 }
186 device << "\n";
187 }
188 }
189 device.close();
190}
191
192
193void
194NWWriter_DlrNavteq::writeLinksUnsplitted(const OptionsCont& oc, NBEdgeCont& ec, std::map<NBEdge*, std::string>& internalNodes) {
195 std::map<const std::string, std::string> nameIDs;
196 OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_links_unsplitted.txt");
197 writeHeader(device, oc);
198 // write format specifier
199 device << "# LINK_ID\tNODE_ID_FROM\tNODE_ID_TO\tBETWEEN_NODE_ID\tLENGTH\tVEHICLE_TYPE\tFORM_OF_WAY\tBRUNNEL_TYPE\tFUNCTIONAL_ROAD_CLASS\tSPEED_CATEGORY\tNUMBER_OF_LANES\tSPEED_LIMIT\tSPEED_RESTRICTION\tNAME_ID1_REGIONAL\tNAME_ID2_LOCAL\tHOUSENUMBERS_RIGHT\tHOUSENUMBERS_LEFT\tZIP_CODE\tAREA_ID\tSUBAREA_ID\tTHROUGH_TRAFFIC\tSPECIAL_RESTRICTIONS\tEXTENDED_NUMBER_OF_LANES\tISRAMP\tCONNECTION\n";
200 // write edges
201 for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
202 NBEdge* e = (*i).second;
203 const int kph = speedInKph(e->getSpeed());
204 const std::string& betweenNodeID = (e->getGeometry().size() > 2) ? internalNodes[e] : UNDEFINED;
205 std::string nameID = UNDEFINED;
206 std::string nameIDRegional = UNDEFINED;
207 if (oc.getBool("output.street-names")) {
208 const std::string& name = e->getStreetName();
209 if (name != "") {
210 if (nameIDs.count(name) == 0) {
211 const int tmp = (int)nameIDs.size();
212 nameIDs[name] = toString(tmp);
213 }
214 nameID = nameIDs[name];
215 }
216 const std::string& name2 = e->getParameter("ref", "");
217 if (name2 != "") {
218 if (nameIDs.count(name2) == 0) {
219 const int tmp = (int)nameIDs.size();
220 nameIDs[name2] = toString(tmp);
221 }
222 nameIDRegional = nameIDs[name2];
223 }
224 }
225 device << e->getID() << "\t"
226 << e->getFromNode()->getID() << "\t"
227 << e->getToNode()->getID() << "\t"
228 << betweenNodeID << "\t"
229 << getGraphLength(e) << "\t"
230 << getAllowedTypes(e->getPermissions()) << "\t"
231 << getFormOfWay(e) << "\t"
232 << getBrunnelType(e) << "\t"
233 << getRoadClass(e) << "\t"
234 << getSpeedCategory(kph) << "\t"
235 << getNavteqLaneCode(e->getNumLanes()) << "\t"
236 << getSpeedCategoryUpperBound(kph) << "\t"
237 << kph << "\t"
238 << nameIDRegional << "\t"
239 << nameID << "\t" // NAME_ID2_LOCAL
240 << UNDEFINED << "\t" // housenumbers_right
241 << UNDEFINED << "\t" // housenumbers_left
242 << getSinglePostalCode(e->getParameter("postal_code", UNDEFINED), e->getID()) << "\t" // ZIP_CODE
243 << UNDEFINED << "\t" // AREA_ID
244 << UNDEFINED << "\t" // SUBAREA_ID
245 << "1\t" // through_traffic (allowed)
246 << UNDEFINED << "\t" // special_restrictions
247 << UNDEFINED << "\t" // extended_number_of_lanes
248 << UNDEFINED << "\t" // isRamp
249 << "0\t" // connection (between nodes always in order)
250 << "\n";
251 }
252 if (oc.getBool("output.street-names")) {
253 OutputDevice& namesDevice = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_names.txt");
254 writeHeader(namesDevice, oc);
255 // write format specifier
256 namesDevice << "# NAME_ID\tPERMANENT_ID_INFO\tName\n";
257 namesDevice << "# [elements] " << nameIDs.size() << "\n";
258 for (std::map<const std::string, std::string>::const_iterator i = nameIDs.begin(); i != nameIDs.end(); ++i) {
259 namesDevice
260 << i->second << "\t"
261 << 0 << "\t"
262 << i->first << "\n";
263 }
264 namesDevice.close();
265 }
266 device.close();
267}
268
269
270std::string
272 if (permissions == SVCAll) {
273 return "100000000000";
274 }
275 std::ostringstream oss;
276 oss << "0";
277 oss << ((permissions & SVC_PASSENGER) > 0 ? 1 : 0);
278 oss << ((permissions & SVC_PASSENGER) > 0 ? 1 : 0); // residential
279 oss << ((permissions & SVC_HOV) > 0 ? 1 : 0);
280 oss << ((permissions & SVC_EMERGENCY) > 0 ? 1 : 0);
281 oss << ((permissions & SVC_TAXI) > 0 ? 1 : 0);
282 oss << ((permissions & (SVC_BUS | SVC_COACH)) > 0 ? 1 : 0);
283 oss << ((permissions & SVC_DELIVERY) > 0 ? 1 : 0);
284 oss << ((permissions & (SVC_TRUCK | SVC_TRAILER)) > 0 ? 1 : 0);
285 oss << ((permissions & SVC_MOTORCYCLE) > 0 ? 1 : 0);
286 oss << ((permissions & SVC_BICYCLE) > 0 ? 1 : 0);
287 oss << ((permissions & SVC_PEDESTRIAN) > 0 ? 1 : 0);
288 return oss.str();
289}
290
291
292int
294 // quoting the navteq manual:
295 // As a general rule, Functional Road Class assignments have no direct
296 // correlation with other road attributes like speed, controlled access, route type, etc.
297 // if the network is based on OSM, we can use the highway types for determining FRC
298 std::string type = edge->getTypeID();
299 if (StringUtils::startsWith(type, "highway.")) {
300 type = type.substr(8);
301 }
302 if (StringUtils::startsWith(type, "motorway")) {
303 return 0;
304 } else if (StringUtils::startsWith(type, "trunk")) {
305 return 1;
306 } else if (StringUtils::startsWith(type, "primary")) {
307 return 1;
308 } else if (StringUtils::startsWith(type, "secondary")) {
309 return 2;
310 } else if (StringUtils::startsWith(type, "tertiary")) {
311 return 3;
312 } else if (type == "unclassified") {
313 return 3;
314 } else if (type == "living_street" || type == "residential" || type == "road" || type == "service" || type == "track" || type == "cycleway" || type == "path" || type == "footway") {
315 return 4;
316 }
317 // as a fallback we do a simple speed / lane-count mapping anyway
318 // the resulting functional road class layers probably won't be connected as required
319 const int kph = speedInKph(edge->getSpeed());
320 if ((kph) > 100) {
321 return 0;
322 }
323 if ((kph) > 70) {
324 return 1;
325 }
326 if ((kph) > 50) {
327 return (edge->getNumLanes() > 1 ? 2 : 3);
328 }
329 if ((kph) > 30) {
330 return 3;
331 }
332 return 4;
333}
334
335
336int
338 if ((kph) > 130) {
339 return 1;
340 }
341 if ((kph) > 100) {
342 return 2;
343 }
344 if ((kph) > 90) {
345 return 3;
346 }
347 if ((kph) > 70) {
348 return 4;
349 }
350 if ((kph) > 50) {
351 return 5;
352 }
353 if ((kph) > 30) {
354 return 6;
355 }
356 if ((kph) > 10) {
357 return 7;
358 }
359 return 8;
360}
361
362
363int
365 if ((kph) > 130) {
366 return 131;
367 }
368 if ((kph) > 100) {
369 return 130;
370 }
371 if ((kph) > 90) {
372 return 100;
373 }
374 if ((kph) > 70) {
375 return 90;
376 }
377 if ((kph) > 50) {
378 return 70;
379 }
380 if ((kph) > 30) {
381 return 50;
382 }
383 if ((kph) > 10) {
384 return 30;
385 }
386 return 10;
387}
388
389
390int
392 const int code = (numLanes == 1 ? 1 :
393 (numLanes < 4 ? 2 : 3));
394 return numLanes * 10 + code;
395}
396
397
398int
400 if (edge->knowsParameter("bridge")) {
401 return 1;
402 } else if (edge->knowsParameter("tunnel")) {
403 return 4;
404 } else if (edge->getTypeID() == "route.ferry") {
405 return 10;
406 }
407 return -1; // UNDEFINED
408}
409
410
411int
413 if (edge->getPermissions() == SVC_PEDESTRIAN) {
414 return 15;
415 } else if (edge->getJunctionPriority(edge->getToNode()) == NBEdge::JunctionPriority::ROUNDABOUT) {
416 return 4;
417 } else if (edge->getTypeID() == "highway.service") {
418 return 14;
419 } else if (edge->getTypeID().find("_link") != std::string::npos) {
420 return 10;
421 }
422 return 3; // speed category 1-8;
423}
424
425
426double
428 PositionVector geom = edge->getGeometry();
431 return geom.length();
432}
433
434
435std::string
436NWWriter_DlrNavteq::getSinglePostalCode(const std::string& zipCode, const std::string edgeID) {
437 // might be multiple codes
438 if (zipCode.find_first_of(" ,;") != std::string::npos) {
439 WRITE_WARNINGF("ambiguous zip code '%' for edge '%'. (using first value)", zipCode, edgeID);
440 StringTokenizer st(zipCode, " ,;", true);
441 std::vector<std::string> ret = st.getVector();
442 return ret[0];
443 } else if (zipCode.size() > 16) {
444 WRITE_WARNINGF("long zip code '%' for edge '%'", zipCode, edgeID);
445 }
446 return zipCode;
447}
448
449void
451 OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_traffic_signals.txt");
452 writeHeader(device, oc);
454 const bool haveGeo = gch.usingGeoProjection();
455 const double geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE
456 device.setPrecision(oc.getInt("dlr-navteq.precision"));
457 // write format specifier
458 device << "#Traffic signal related to LINK_ID and NODE_ID with location relative to driving direction.\n#column format like pointcollection.\n#DESCRIPTION->LOCATION: 1-rechts von LINK; 2-links von LINK; 3-oberhalb LINK -1-keineAngabe\n#RELATREC_ID\tPOICOL_TYPE\tDESCRIPTION\tLONGITUDE\tLATITUDE\tLINK_ID\n";
459 // write record for every edge incoming to a tls controlled node
460 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
461 NBNode* n = (*i).second;
462 if (n->isTLControlled()) {
463 Position pos = n->getPosition();
464 gch.cartesian2geo(pos);
465 pos.mul(geoScale);
466 const EdgeVector& incoming = n->getIncomingEdges();
467 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
468 NBEdge* e = *it;
469 device << e->getID() << "\t"
470 << "12\t" // POICOL_TYPE
471 << "LSA;NODEIDS#" << n->getID() << "#;LOCATION#-1#;\t"
472 << pos.x() << "\t"
473 << pos.y() << "\t"
474 << e->getID() << "\n";
475 }
476 }
477 }
478 device.close();
479}
480
481
482void
484 OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_prohibited_manoeuvres.txt");
485 writeHeader(device, oc);
486 // need to invent id for relation
487 std::set<std::string> reservedRelIDs;
488 if (oc.isSet("reserved-ids")) {
489 NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "rel:", reservedRelIDs);
490 }
491 std::vector<std::string> avoid = ec.getAllNames(); // already used for tls RELATREC_ID
492 avoid.insert(avoid.end(), reservedRelIDs.begin(), reservedRelIDs.end());
493 IDSupplier idSupplier("", avoid); // @note: use a global relRecIDsupplier if this is used more often
494 // write format specifier
495 device << "#No driving allowed from ID1 to ID2 or the complete chain from ID1 to IDn\n";
496 device << "#RELATREC_ID\tPERMANENT_ID_INFO\tVALIDITY_PERIOD\tTHROUGH_TRAFFIC\tVEHICLE_TYPE\tNAVTEQ_LINK_ID1\t[NAVTEQ_LINK_ID2 ...]\n";
497 // write record for every pair of incoming/outgoing edge that are not connected despite having common permissions
498 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
499 NBNode* n = (*i).second;
500 const EdgeVector& incoming = n->getIncomingEdges();
501 const EdgeVector& outgoing = n->getOutgoingEdges();
502 for (EdgeVector::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
503 NBEdge* inEdge = *j;
504 const SVCPermissions inPerm = inEdge->getPermissions();
505 for (EdgeVector::const_iterator k = outgoing.begin(); k != outgoing.end(); ++k) {
506 NBEdge* outEdge = *k;
507 const SVCPermissions outPerm = outEdge->getPermissions();
508 const SVCPermissions commonPerm = inPerm & outPerm;
509 if (commonPerm != 0 && commonPerm != SVC_PEDESTRIAN && !inEdge->isConnectedTo(outEdge)) {
510 device
511 << idSupplier.getNext() << "\t"
512 << 1 << "\t" // permanent id
513 << UNDEFINED << "\t"
514 << 1 << "\t"
515 << getAllowedTypes(SVCAll) << "\t"
516 << inEdge->getID() << "\t" << outEdge->getID() << "\n";
517 }
518 }
519 }
520 }
521 device.close();
522}
523
524
525void
527 OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_connected_lanes.txt");
528 writeHeader(device, oc);
529 // write format specifier
530 device << "#Lane connections related to LINK-IDs and NODE-ID.\n";
531 device << "#column format like pointcollection.\n";
532 device << "#NODE-ID\tVEHICLE-TYPE\tFROM_LANE\tTO_LANE\tTHROUGH_TRAFFIC\tLINK_IDs[2..*]\n";
533 // write record for every connection
534 for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
535 NBNode* n = (*i).second;
536 const EdgeVector& incoming = n->getIncomingEdges();
537 for (EdgeVector::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
538 NBEdge* from = *j;
539 const SVCPermissions fromPerm = from->getPermissions();
540 const std::vector<NBEdge::Connection>& connections = from->getConnections();
541 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
542 const NBEdge::Connection& c = *it_c;
543 device
544 << n->getID() << "\t"
545 << getAllowedTypes(fromPerm & c.toEdge->getPermissions()) << "\t"
546 << c.fromLane + 1 << "\t" // one-based
547 << c.toLane + 1 << "\t" // one-based
548 << 1 << "\t" // no information regarding permissibility of through traffic
549 << from->getID() << "\t"
550 << c.toEdge->getID() << "\t"
551 << "\n";
552 }
553 }
554 }
555 device.close();
556}
557
558
559/****************************************************************************/
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:42
const SVCPermissions SVCAll
all VClasses are allowed
@ SVC_HOV
vehicle is a HOV
@ SVC_TRUCK
vehicle is a large transport vehicle
@ SVC_COACH
vehicle is a coach
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_TRAILER
vehicle is a large transport vehicle
@ SVC_DELIVERY
vehicle is a small delivery vehicle
@ SVC_MOTORCYCLE
vehicle is a motorcycle
@ SVC_EMERGENCY
public emergency vehicles
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
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
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:53
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
const Boundary & getConvBoundary() const
Returns the converted boundary.
std::string getNext()
Returns the next id.
Definition: IDSupplier.cpp:51
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:59
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:170
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:177
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
Definition: NBEdgeCont.cpp:721
The representation of a single edge during network building.
Definition: NBEdge.h:92
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:4137
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition: NBEdge.h:1043
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:552
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
double getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:625
const std::string & getID() const
Definition: NBEdge.h:1526
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:526
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
Definition: NBEdge.cpp:3975
bool isConnectedTo(const NBEdge *e, const bool ignoreTurnaround=false) const
Returns the information whethe a connection to the given edge has been added (or computed)
Definition: NBEdge.cpp:1285
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
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:545
static void loadPrefixedIDsFomFile(const std::string &file, const std::string prefix, std::set< std::string > &into)
Add prefixed ids defined in file.
Definition: NBHelpers.cpp:104
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
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
int size() const
Returns the number of nodes stored in this container.
Definition: NBNodeCont.h:295
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition: NBNodeCont.h:113
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Definition: NBNodeCont.cpp:120
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:118
std::vector< std::string > getAllNames() const
get all node names
Represents a single node (junction) during network building.
Definition: NBNode.h:66
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
Definition: NBNode.h:258
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
Definition: NBNode.h:263
const Position & getPosition() const
Definition: NBNode.h:250
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:321
static std::string getSinglePostalCode(const std::string &zipCode, const std::string edgeID)
static int getSpeedCategoryUpperBound(int kph)
get the SPEED_LIMIT as defined by elmar (upper bound of speed category)
static int getFormOfWay(NBEdge *edge)
get the form of way
static std::string getAllowedTypes(SVCPermissions permissions)
build the ascii-bit-vector for column vehicle_type
static void writeHeader(OutputDevice &device, const OptionsCont &oc)
write header comments (input paramters, date, etc...)
static void writeNodesUnsplitted(const OptionsCont &oc, NBNodeCont &nc, NBEdgeCont &ec, std::map< NBEdge *, std::string > &internalNodes)
Writes the nodes_unsplitted file.
static void writeTrafficSignals(const OptionsCont &oc, NBNodeCont &nc)
Writes the traffic_signals file.
static double getGraphLength(NBEdge *edge)
get the length of the edge when measured up to the junction center
static int getSpeedCategory(int kph)
get the navteq speed class based on the speed in km/h
static void writeLinksUnsplitted(const OptionsCont &oc, NBEdgeCont &ec, std::map< NBEdge *, std::string > &internalNodes)
Writes the links_unsplitted file.
static int getBrunnelType(NBEdge *edge)
get the navteq brunnel type
static int getRoadClass(NBEdge *edge)
get the navteq road class
static int speedInKph(double metersPerSecond)
get edge speed rounded to kmh
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
static const std::string UNDEFINED
magic value for undefined stuff
static void writeConnectedLanes(const OptionsCont &oc, NBNodeCont &nc)
Writes the connected_lanes file.
static int getNavteqLaneCode(const int numLanes)
get the lane number encoding
static void writeProhibitedManoeuvres(const OptionsCont &oc, const NBNodeCont &nc, const NBEdgeCont &ec)
Writes the prohibited_manoeuvres file.
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.
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)
void writeConfiguration(std::ostream &os, const bool filled, const bool complete, const bool addComments, const std::string &relativeTo="", const bool forceRelative=false, const bool inComment=false) const
Writes the configuration.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
void close()
Closes the device and removes it from the dictionary.
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.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double x() const
Returns the x-position.
Definition: Position.h:55
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:105
double y() const
Returns the y-position.
Definition: Position.h:60
A list of positions.
double length() const
Returns the length.
void push_front_noDoublePos(const Position &p)
insert in front a non double position
void move2side(double amount, double maxExtension=100)
move position vector to side using certain ammount
void push_back_noDoublePos(const Position &p)
insert in back a non double position
std::vector< std::string > getVector()
return vector of strings
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:201
int fromLane
The lane the connections starts at.
Definition: NBEdge.h:227
int toLane
The lane the connections yields in.
Definition: NBEdge.h:233
NBEdge * toEdge
The edge the connections yields in.
Definition: NBEdge.h:230