Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NIImporter_OpenStreetMap.h
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/****************************************************************************/
22// Importer for networks stored in OpenStreetMap format
23/****************************************************************************/
24#pragma once
25#include <config.h>
26
27#include <string>
28#include <map>
33
34
35// ===========================================================================
36// class declarations
37// ===========================================================================
38class NBEdge;
39class NBEdgeCont;
40class NBNetBuilder;
41class NBNode;
42class NBNodeCont;
44class NBTypeCont;
45class OptionsCont;
46
47
48// ===========================================================================
49// class definitions
50// ===========================================================================
57public:
69 static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb);
70
71protected:
74 struct NIOSMNode : public Parameterised {
75 NIOSMNode(long long int _id, double _lon, double _lat)
76 :
77 id(_id), lon(_lon), lat(_lat), ele(0.),
78 tlsControlled(false),
79 pedestrianCrossing(false),
80 railwayCrossing(false),
81 railwaySignal(false),
82 railwayBufferStop(false),
83 ptStopPosition(false), ptStopLength(0), name(""),
85 positionMeters(std::numeric_limits<double>::max()),
86 node(nullptr) { }
87
89 const long long int id;
91 const double lon;
93 const double lat;
95 double ele;
111 std::string name;
115 std::string position;
120
121 private:
123 NIOSMNode& operator=(const NIOSMNode& s) = delete;
124
125
126 };
127
128public:
130 static SUMOVehicleClass interpretTransportType(const std::string& type, NIOSMNode* toSet = nullptr);
131
132protected:
133
134
145
156
163
166 class Edge : public Parameterised {
167 public:
168 explicit Edge(long long int _id) :
169 id(_id), myNoLanes(-1), myNoLanesForward(0),
174 myCyclewayType(WAY_UNKNOWN), // building of extra lane depends on bikelaneWidth of loaded typemap
175 myBuswayType(WAY_NONE), // buslanes are always built when declared
176 mySidewalkType(WAY_UNKNOWN), // building of extra lanes depends on sidewalkWidth of loaded typemap
177 myRailDirection(WAY_UNKNOWN), // store direction(s) of railway usage
178 myParkingType(PARKING_NONE), // parking areas exported optionally
181 myLayer(0), // layer is non-zero only in conflict areas
182 myCurrentIsRoad(false)
183 { }
184
185 virtual ~Edge() {}
186
188 const long long int id;
190 std::string streetName;
192 std::string ref;
206 std::string myHighWayType;
208 std::string myIsOneWay;
224 std::vector<bool> myDesignatedLaneForward;
226 std::vector<bool> myDesignatedLaneBackward;
228 std::vector<SVCPermissions> myAllowedLaneForward;
230 std::vector<SVCPermissions> myAllowedLaneBackward;
232 std::vector<SVCPermissions> myDisallowedLaneForward;
234 std::vector<SVCPermissions> myDisallowedLaneBackward;
238 std::vector<long long int> myCurrentNodes;
242 std::map<std::string, std::string> myExtraTags;
244 std::vector<int> myTurnSignsForward;
245 std::vector<int> myTurnSignsBackward;
247 std::vector<double> myWidthLanesForward;
248 std::vector<double> myWidthLanesBackward;
249
250 private:
252 Edge& operator=(const Edge& s) = delete;
253 };
254
255
257
259
260 void load(const OptionsCont& oc, NBNetBuilder& nb);
261
262private:
267 public:
268 bool operator()(const NIOSMNode* n1, const NIOSMNode* n2) const {
269 return (n1->lat > n2->lat) || (n1->lat == n2->lat && n1->lon > n2->lon);
270 }
271 };
272
273
275 static const std::string compoundTypeSeparator;
276
277 class CompareEdges;
278
282 std::map<long long int, NIOSMNode*> myOSMNodes;
283
285 std::set<NIOSMNode*, CompareNodes> myUniqueNodes;
286
287
289 std::map<long long int, Edge*> myEdges;
290
292 std::map<long long int, Edge*> myPlatformShapes;
293
295 std::set<std::string> myUnusableTypes;
296
298 std::map<std::string, std::string> myKnownCompoundTypes;
299
302
305
308
311
314
316 static bool myAllAttributes;
317
319 static std::set<std::string> myExtraAttributes;
320
335 NBNode* insertNodeChecking(long long int id, NBNodeCont& nc, NBTrafficLightLogicCont& tlsc);
336
337
352 int insertEdge(Edge* e, int index, NBNode* from, NBNode* to,
353 const std::vector<long long int>& passed, NBNetBuilder& nb,
354 const NBNode* first, const NBNode* last);
355
357 void reconstructLayerElevation(double layerElevation, NBNetBuilder& nb);
358
360 std::map<NBNode*, std::pair<double, double> >
361 getNeighboringNodes(NBNode* node, double maxDist, const std::set<NBNode*>& knownElevation);
362
364 std::string usableType(const std::string& type, const std::string& id, NBTypeCont& tc);
365
368
370 static double interpretDistance(NIOSMNode* node);
371
372protected:
373 static const double MAXSPEED_UNGIVEN;
374 static const long long int INVALID_ID;
375
376 static void applyChangeProhibition(NBEdge* e, int changeProhibition);
387 void applyLaneUse(NBEdge* e, NIImporter_OpenStreetMap::Edge* nie, const bool forward);
388
389 void applyTurnSigns(NBEdge* e, const std::vector<int>& turnSigns);
390
396 public:
402 NodesHandler(std::map<long long int, NIOSMNode*>& toFill, std::set<NIOSMNode*,
403 CompareNodes>& uniqueNodes,
404 const OptionsCont& cont);
405
406
408 ~NodesHandler() override;
409
410 int getDuplicateNodes() const {
411 return myDuplicateNodes;
412 }
413
416 }
417
418 protected:
420
421
429 void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
430
431
438 void myEndElement(int element) override;
440
441
442 private:
444 std::map<long long int, NIOSMNode*>& myToFill;
445
447 std::string myLastNodeID;
448
451
454
456 std::set<NIOSMNode*, CompareNodes>& myUniqueNodes;
457
460
463
466
467 private:
470
473
474 };
475
476
482 public:
488 EdgesHandler(const std::map<long long int, NIOSMNode*>& osmNodes,
489 std::map<long long int, Edge*>& toFill, std::map<long long int, Edge*>& platformShapes);
490
491
493 ~EdgesHandler() override;
494
495
496 protected:
498
499
507 void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
508
509
516 void myEndElement(int element) override;
518
519 double interpretSpeed(const std::string& key, std::string value);
520
521 int interpretChangeType(const std::string& value) const;
522
523 void interpretLaneUse(const std::string& value, SUMOVehicleClass svc, const bool forward) const;
524
525
526 private:
528 const std::map<long long int, NIOSMNode*>& myOSMNodes;
529
531 std::map<long long int, Edge*>& myEdgeMap;
532
534 std::map<long long int, Edge*>& myPlatformShapesMap;
535
537 Edge* myCurrentEdge = nullptr;
538
540 std::map<std::string, double> mySpeedMap;
541
542 private:
545
548
549 };
550
557 public:
563 RelationHandler(const std::map<long long int, NIOSMNode*>& osmNodes,
564 const std::map<long long int, Edge*>& osmEdges, NBPTStopCont* nbptStopCont,
565 const std::map<long long int, Edge*>& platfromShapes, NBPTLineCont* nbptLineCont,
566 const OptionsCont& oc);
567
568
571
572 protected:
574
575
583 void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
584
585
592 void myEndElement(int element) override;
594
595
596 private:
598 const std::map<long long int, NIOSMNode*>& myOSMNodes;
599
601 const std::map<long long int, Edge*>& myOSMEdges;
602
604 const std::map<long long int, Edge*>& myPlatformShapes;
605
608
611
613 long long int myCurrentRelation;
614
617
620
622 long long int myFromWay;
623
625 long long int myToWay;
626
628 long long int myViaNode;
629 long long int myViaWay;
630
631
634
638 enum class RestrictionType {
640 ONLY,
642 NO,
644 UNKNOWN
645 };
647
649 void resetValues();
650
652 bool checkEdgeRef(long long int ref) const;
653
655 bool applyRestriction() const;
656
658 NBEdge* findEdgeRef(long long int wayRef, const std::vector<NBEdge*>& candidates) const;
659
660 private:
663
666
668 std::vector<long long int> myStops;
669
671 std::set<long long int> myPlatformStops;
672
673
675 long long int ref;
676 bool isWay;
677 };
678
680 std::vector<NIIPTPlatform> myPlatforms;
681
683 std::vector<long long int> myWays;
684
687
690
692 std::string myPTRouteType;
693
696
698 std::string myName;
699
701 std::string myRef;
702
705
707 std::string myNightService;
708
710 std::map<long long int, long long int > myStopAreas;
711
712 };
713
714};
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Storage for edges, including some functionality operating on multiple edges.
Definition NBEdgeCont.h:59
The representation of a single edge during network building.
Definition NBEdge.h:92
Instance responsible for building networks.
Container for nodes during the netbuilding process.
Definition NBNodeCont.h:57
Represents a single node (junction) during network building.
Definition NBNode.h:66
Container for public transport stops during the net building process.
A container for traffic light definitions and built programs.
A storage for available edgeTypes of edges.
Definition NBTypeCont.h:52
Functor which compares two NIOSMNodes according to their coordinates.
bool operator()(const NIOSMNode *n1, const NIOSMNode *n2) const
An internal definition of a loaded edge.
std::vector< SVCPermissions > myDisallowedLaneBackward
(optional) information about additional disallowed SVCs on backward lane(s)
std::map< std::string, std::string > myExtraTags
Additionally tagged information.
std::vector< double > myWidthLanesForward
Information on lane width.
WayType mySidewalkType
Information about the kind of sidwalk along this road.
Edge & operator=(const Edge &s)=delete
invalidated assignment operator
std::vector< SVCPermissions > myDisallowedLaneForward
(optional) information about additional disallowed SVCs on forward lane(s)
bool myCurrentIsRoad
Information whether this is a road.
WayType myCyclewayType
Information about the kind of cycleway along this road.
int myNoLanesForward
number of lanes in forward direction or 0 if unknown, negative if backwards lanes are meant
double myMaxSpeed
maximum speed in km/h, or MAXSPEED_UNGIVEN
std::string ref
The edge's track name.
std::vector< SVCPermissions > myAllowedLaneForward
(optional) information about additional allowed SVCs on forward lane(s)
std::string myHighWayType
The type, stored in "highway" key.
const long long int id
The edge's id.
int myLayer
Information about the relative z-ordering of ways.
std::vector< bool > myDesignatedLaneBackward
(optional) information about whether the backward lanes are designated to some SVCs
SVCPermissions myExtraDisallowed
Extra permissions prohibited from tags instead of highway type.
std::vector< SVCPermissions > myAllowedLaneBackward
(optional) information about additional allowed SVCs on backward lane(s)
int myNoLanes
number of lanes, or -1 if unknown
std::vector< int > myTurnSignsForward
turning direction (arrows printed on the road)
std::vector< long long int > myCurrentNodes
The list of nodes this edge is made of.
int myParkingType
Information about road-side parking.
double myMaxSpeedBackward
maximum speed in km/h, or MAXSPEED_UNGIVEN
WayType myBuswayType
Information about the kind of busway along this road.
int myChangeForward
Information about change prohibitions (forward direction.
SVCPermissions myExtraAllowed
Extra permissions added from tags instead of highway type.
int myChangeBackward
Information about change prohibitions (backward direction.
std::string streetName
The edge's street name.
WayType myRailDirection
Information about the direction(s) of railway usage.
std::vector< bool > myDesignatedLaneForward
(optional) information about whether the forward lanes are designated to some SVCs
std::string myIsOneWay
Information whether this is an one-way road.
A class which extracts OSM-edges from a parsed OSM-file.
Edge * myCurrentEdge
The currently built edge.
const std::map< long long int, NIOSMNode * > & myOSMNodes
The previously parsed nodes.
void interpretLaneUse(const std::string &value, SUMOVehicleClass svc, const bool forward) const
int interpretChangeType(const std::string &value) const
void myEndElement(int element) override
Called when a closing tag occurs.
double interpretSpeed(const std::string &key, std::string value)
EdgesHandler(const EdgesHandler &s)
invalidated copy constructor
std::map< long long int, Edge * > & myEdgeMap
A map of built edges.
std::map< long long int, Edge * > & myPlatformShapesMap
A map of built edges.
std::map< std::string, double > mySpeedMap
A map of non-numeric speed descriptions to their numeric values.
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
EdgesHandler & operator=(const EdgesHandler &s)
invalidated assignment operator
A class which extracts OSM-nodes from a parsed OSM-file.
int myHierarchyLevel
The current hierarchy level.
const bool myImportElevation
whether elevation data should be imported
std::string myLastNodeID
id of the currently parsed node
NodesHandler(const NodesHandler &s)
invalidated copy constructor
std::set< NIOSMNode *, CompareNodes > & myUniqueNodes
the set of unique nodes (used for duplicate detection/substitution)
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
std::map< long long int, NIOSMNode * > & myToFill
The nodes container to fill.
NodesHandler & operator=(const NodesHandler &s)
invalidated assignment operator
void myEndElement(int element) override
Called when a closing tag occurs.
NIOSMNode * myCurrentNode
the currently parsed node
A class which extracts relevant relation information from a parsed OSM-file.
void myEndElement(int element) override
Called when a closing tag occurs.
const std::map< long long int, Edge * > & myPlatformShapes
The previously parsed platform shapes.
long long int myViaNode
the via node/way for the current restriction
bool myIsRestriction
whether the currently parsed relation is a restriction
std::vector< long long int > myWays
ways in pt line references
SVCPermissions myRestrictionException
exceptions to the restriction currenlty being parsed
long long int myCurrentRelation
The currently parsed relation.
std::set< long long int > myPlatformStops
myStops which are actually platforms (in case there is no stop_position)
void resetValues()
reset members to their defaults for parsing a new relation
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
const std::map< long long int, NIOSMNode * > & myOSMNodes
The previously parsed nodes.
const OptionsCont & myOptionsCont
the options cont
RestrictionType
whether the only allowed or the only forbidden connection is defined
@ ONLY
The only valid connection is declared.
@ NO
The only invalid connection is declared.
std::string myNightService
night service information of the pt line
std::string myPTRouteType
indicates whether current relation is a pt route
std::vector< long long int > myStops
bus stop references
NBPTLineCont * myNBPTLineCont
PT Line container to be filled.
std::vector< NIIPTPlatform > myPlatforms
bus stop platforms
bool myIsStopArea
indicates whether current relation is a pt stop area
bool myIsRoute
indicates whether current relation is a route
RelationHandler & operator=(const RelationHandler &s)
invalidated assignment operator
int myInterval
service interval of the pt line in minutes
RelationHandler(const RelationHandler &s)
invalidated copy constructor
std::map< long long int, long long int > myStopAreas
the map from stop area member to stop_area id
NBPTStopCont * myNBPTStopCont
The previously filled pt stop container.
bool checkEdgeRef(long long int ref) const
check whether a referenced way has a corresponding edge
long long int myFromWay
the origination way for the current restriction
long long int myToWay
the destination way for the current restriction
bool applyRestriction() const
try to apply the parsed restriction and return whether successful
NBEdge * findEdgeRef(long long int wayRef, const std::vector< NBEdge * > &candidates) const
try to find the way segment among candidates
const std::map< long long int, Edge * > & myOSMEdges
The previously parsed edges.
Importer for networks stored in OpenStreetMap format.
int insertEdge(Edge *e, int index, NBNode *from, NBNode *to, const std::vector< long long int > &passed, NBNetBuilder &nb, const NBNode *first, const NBNode *last)
Builds an NBEdge.
std::map< long long int, Edge * > myEdges
the map from OSM way ids to edge objects
bool myImportCrossings
import crossings
std::map< long long int, NIOSMNode * > myOSMNodes
the map from OSM node ids to actual nodes
static void loadNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given OSM file.
static const long long int INVALID_ID
void applyLaneUse(NBEdge *e, NIImporter_OpenStreetMap::Edge *nie, const bool forward)
Applies lane use information from nie to e.
std::map< long long int, Edge * > myPlatformShapes
the map from OSM way ids to platform shapes
void load(const OptionsCont &oc, NBNetBuilder &nb)
void applyTurnSigns(NBEdge *e, const std::vector< int > &turnSigns)
bool myImportSidewalks
import sidewalks
std::set< NIOSMNode *, CompareNodes > myUniqueNodes
the set of unique nodes used in NodesHandler, used when freeing memory
static bool myAllAttributes
whether additional way and node attributes shall be imported
void reconstructLayerElevation(double layerElevation, NBNetBuilder &nb)
reconstruct elevation from layer info
static SUMOVehicleClass interpretTransportType(const std::string &type, NIOSMNode *toSet=nullptr)
translate osm transport designations into sumo vehicle class
bool myImportLaneAccess
import lane specific access restrictions
bool myImportTurnSigns
import turning signals (turn:lanes) to guide connection building
std::map< std::string, std::string > myKnownCompoundTypes
The compound types that have already been mapped to other known types.
static const std::string compoundTypeSeparator
The separator within newly created compound type names.
std::set< std::string > myUnusableTypes
The compounds types that do not contain known types.
std::map< NBNode *, std::pair< double, double > > getNeighboringNodes(NBNode *node, double maxDist, const std::set< NBNode * > &knownElevation)
collect neighboring nodes with their road distance and maximum between-speed. Search does not continu...
static std::set< std::string > myExtraAttributes
extra attributes to import
bool myImportBikeAccess
import bike path specific permissions and directions
static double interpretDistance(NIOSMNode *node)
read distance value from node and return value in m
NBNode * insertNodeChecking(long long int id, NBNodeCont &nc, NBTrafficLightLogicCont &tlsc)
Builds an NBNode.
void extendRailwayDistances(Edge *e, NBTypeCont &tc)
extend kilometrage data for all nodes along railway
std::string usableType(const std::string &type, const std::string &id, NBTypeCont &tc)
check whether the type is known or consists of known type compounds. return empty string otherwise
static void applyChangeProhibition(NBEdge *e, int changeProhibition)
A storage for options typed value containers)
Definition OptionsCont.h:89
An upper class for objects with additional parameters.
Encapsulated SAX-Attributes.
SAX-handler base for SUMO-files.
Definition json.hpp:4471
An internal representation of an OSM-node.
SVCPermissions permissions
type of pt stop
NIOSMNode & operator=(const NIOSMNode &s)=delete
invalidated assignment operator
NBNode * node
the NBNode that was instantiated
double positionMeters
position converted to m (using highest precision available)
std::string position
kilometrage/mileage
const long long int id
The node's id.
bool pedestrianCrossing
Whether this is a pedestrian crossing.
bool tlsControlled
Whether this is a tls controlled junction.
double ptStopLength
The length of the pt stop.
NIOSMNode(long long int _id, double _lon, double _lat)
bool ptStopPosition
Whether this is a public transport stop position.
std::string name
The name of the node.
bool railwayCrossing
Whether this is a railway crossing.
double ele
The elevation of this node.
bool railwayBufferStop
Whether this is a railway buffer stop.
const double lon
The longitude the node is located at.
const double lat
The latitude the node is located at.
bool railwaySignal
Whether this is a railway (main) signal.