Eclipse SUMO - Simulation of Urban MObility
NIImporter_OpenStreetMap.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2020 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>
32 #include <netbuild/NBPTPlatform.h>
33 
34 
35 // ===========================================================================
36 // class declarations
37 // ===========================================================================
38 class NBEdge;
39 class NBEdgeCont;
40 class NBNetBuilder;
41 class NBNode;
42 class NBNodeCont;
44 class NBTypeCont;
45 class OptionsCont;
46 
47 
48 // ===========================================================================
49 // class definitions
50 // ===========================================================================
57 public:
69  static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb);
70 
71 protected:
74  struct NIOSMNode {
75  NIOSMNode(long long int _id, double _lon, double _lat)
76  :
77  id(_id), lon(_lon), lat(_lat), ele(0),
78  tlsControlled(false),
79  railwayCrossing(false),
80  railwaySignal(false),
81  railwayBufferStop(false),
82  ptStopPosition(false), ptStopLength(0), name(""),
84  positionMeters(std::numeric_limits<double>::max()),
85  node(0) { }
86 
88  const long long int id;
90  const double lon;
92  const double lat;
94  double ele;
106  double ptStopLength;
108  std::string name;
112  std::string position;
117 
118  private:
120  NIOSMNode& operator=(const NIOSMNode& s) = delete;
121 
122 
123  };
124 
125 public:
127  static SUMOVehicleClass interpretTransportType(const std::string& type, NIOSMNode* toSet = nullptr);
128 
129 protected:
130 
131 
135  enum WayType {
136  WAY_NONE = 0,
140  WAY_UNKNOWN = 4
141  };
142 
143  enum ParkingType {
151  PARKING_DIAGONAL = 32
152  };
153 
154 
157  class Edge : public Parameterised {
158  public:
159  explicit Edge(long long int _id) :
160  id(_id), myNoLanes(-1), myNoLanesForward(0),
163  myCyclewayType(WAY_UNKNOWN), // building of extra lane depends on bikelaneWidth of loaded typemap
164  myBuswayType(WAY_NONE), // buslanes are always built when declared
165  mySidewalkType(WAY_UNKNOWN), // building of extra lanes depends on sidewalkWidth of loaded typemap
166  myRailDirection(WAY_UNKNOWN), // store direction(s) of railway usage
167  myParkingType(PARKING_NONE), // parking areas exported optionally
168  myLayer(0), // layer is non-zero only in conflict areas
169  myCurrentIsRoad(false),
170  myCurrentIsPlatform(false),
172  { }
173 
174  virtual ~Edge() {}
175 
177  const long long int id;
179  std::string streetName;
181  std::string ref;
187  double myMaxSpeed;
191  std::string myHighWayType;
193  std::string myIsOneWay;
205  int myLayer;
207  std::vector<long long int> myCurrentNodes;
214 
215  private:
217  Edge& operator=(const Edge& s) = delete;
218  };
219 
220 
222 
224 
225  void load(const OptionsCont& oc, NBNetBuilder& nb);
226 
227 private:
231  class CompareNodes {
232  public:
233  bool operator()(const NIOSMNode* n1, const NIOSMNode* n2) const {
234  return (n1->lat > n2->lat) || (n1->lat == n2->lat && n1->lon > n2->lon);
235  }
236  };
237 
238 
240  static const std::string compoundTypeSeparator;
241 
242  class CompareEdges;
243 
247  std::map<long long int, NIOSMNode*> myOSMNodes;
248 
250  std::set<NIOSMNode*, CompareNodes> myUniqueNodes;
251 
252 
254  std::map<long long int, Edge*> myEdges;
255 
257  std::map<long long int, Edge*> myPlatformShapes;
258 
260  std::map<long long int, std::set<long long int> > myStopAreas;
261 
263  std::set<std::string> myUnusableTypes;
264 
266  std::map<std::string, std::string> myKnownCompoundTypes;
267 
282  NBNode* insertNodeChecking(long long int id, NBNodeCont& nc, NBTrafficLightLogicCont& tlsc);
283 
284 
297  int insertEdge(Edge* e, int index, NBNode* from, NBNode* to,
298  const std::vector<long long int>& passed, NBNetBuilder& nb);
299 
301  void reconstructLayerElevation(double layerElevation, NBNetBuilder& nb);
302 
304  std::map<NBNode*, std::pair<double, double> >
305  getNeighboringNodes(NBNode* node, double maxDist, const std::set<NBNode*>& knownElevation);
306 
308  std::string usableType(const std::string& type, const std::string& id, NBTypeCont& tc);
309 
311  void extendRailwayDistances(Edge* e, NBTypeCont& tc);
312 
314  static double interpretDistance(NIOSMNode* node);
315 
316 protected:
317  static const double MAXSPEED_UNGIVEN;
318  static const long long int INVALID_ID;
319 
324  friend class NodesHandler;
325  class NodesHandler : public SUMOSAXHandler {
326  public:
332  NodesHandler(std::map<long long int, NIOSMNode*>& toFill, std::set<NIOSMNode*,
333  CompareNodes>& uniqueNodes,
334  const OptionsCont& cont);
335 
336 
338  ~NodesHandler() override;
339 
340  int getDuplicateNodes() const {
341  return myDuplicateNodes;
342  }
343 
344  protected:
346 
347 
355  void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
356 
357 
364  void myEndElement(int element) override;
366 
367 
368  private:
369 
371  std::map<long long int, NIOSMNode*>& myToFill;
372 
374  long long int myLastNodeID;
375 
378 
381 
383  std::set<NIOSMNode*, CompareNodes>& myUniqueNodes;
384 
386  const bool myImportElevation;
387 
390 
393 
394 
395  private:
398 
401 
402  };
403 
404 
409  class EdgesHandler : public SUMOSAXHandler {
410  public:
416  EdgesHandler(const std::map<long long int, NIOSMNode*>& osmNodes,
417  std::map<long long int, Edge*>& toFill, std::map<long long int, Edge*>& platformShapes);
418 
419 
421  ~EdgesHandler() override;
422 
423 
424  protected:
426 
427 
435  void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
436 
437 
444  void myEndElement(int element) override;
446 
447  double interpretSpeed(const std::string& key, std::string value);
448 
449  private:
451  const std::map<long long int, NIOSMNode*>& myOSMNodes;
452 
454  std::map<long long int, Edge*>& myEdgeMap;
455 
457  std::map<long long int, Edge*>& myPlatformShapesMap;
458 
461 
463  std::vector<int> myParentElements;
464 
466  std::map<std::string, double> mySpeedMap;
467 
470 
471  private:
474 
477 
478  };
479 
486  public:
492  RelationHandler(const std::map<long long int, NIOSMNode*>& osmNodes,
493  const std::map<long long int, Edge*>& osmEdges, NBPTStopCont* nbptStopCont,
494  const std::map<long long int, Edge*>& platfromShapes, NBPTLineCont* nbptLineCont,
495  const OptionsCont& oc);
496 
497 
499  ~RelationHandler() override;
500 
501  protected:
503 
504 
512  void myStartElement(int element, const SUMOSAXAttributes& attrs) override;
513 
514 
521  void myEndElement(int element) override;
523 
524 
525  private:
527  const std::map<long long int, NIOSMNode*>& myOSMNodes;
528 
530  const std::map<long long int, Edge*>& myOSMEdges;
531 
533  const std::map<long long int, Edge*>& myPlatformShapes;
534 
537 
540 
542  long long int myCurrentRelation;
543 
545  std::vector<int> myParentElements;
546 
549 
551  long long int myFromWay;
552 
554  long long int myToWay;
555 
557  long long int myViaNode;
558  long long int myViaWay;
559 
560 
563 
574  };
576 
578  void resetValues();
579 
581  bool checkEdgeRef(long long int ref) const;
582 
584  bool applyRestriction() const;
585 
587  NBEdge* findEdgeRef(long long int wayRef, const std::vector<NBEdge*>& candidates) const;
588 
589  private:
592 
595 
597  std::vector<long long int> myStops;
598 
599 
600  struct NIIPTPlatform {
601  long long int ref;
602  bool isWay;
603  };
604 
606  std::vector<NIIPTPlatform> myPlatforms;
607 
609  std::vector<long long int> myWays;
610 
613 
615  bool myIsRoute;
616 
618  std::string myPTRouteType;
619 
621  std::string myName;
622 
624  std::string myRef;
625 
628 
630  std::string myNightService;
631  };
632 
633 };
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:91
Instance responsible for building networks.
Definition: NBNetBuilder.h:107
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
Represents a single node (junction) during network building.
Definition: NBNode.h:66
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.
WayType mySidewalkType
Information about the kind of sidwalk along this road.
bool myCurrentIsPlatform
Information whether this is a pt platform.
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
bool myCurrentIsElectrified
Information whether this is railway is electrified.
std::string ref
The edge's track name.
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.
Edge & operator=(const Edge &s)=delete
invalidated assignment operator
int myNoLanes
number of lanes, or -1 if unknown
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.
std::string streetName
The edge's street name.
WayType myRailDirection
Information about the direction(s) of railway usage.
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.
EdgesHandler(const std::map< long long int, NIOSMNode * > &osmNodes, std::map< long long int, Edge * > &toFill, std::map< long long int, Edge * > &platformShapes)
Constructor.
bool myAllAttributes
whether additional way attributes shall be added to the edge
void myEndElement(int element) override
Called when a closing tag occurs.
EdgesHandler & operator=(const EdgesHandler &s)
invalidated assignment operator
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.
std::vector< int > myParentElements
The element stack.
void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
A class which extracts OSM-nodes from a parsed OSM-file.
int myHierarchyLevel
The current hierarchy level.
bool myIsInValidNodeTag
Hierarchy helper for parsing a node's tags.
const bool myImportElevation
whether elevation data should be imported
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(std::map< long long int, NIOSMNode * > &toFill, std::set< NIOSMNode *, CompareNodes > &uniqueNodes, const OptionsCont &cont)
Contructor.
long long int myLastNodeID
ID of the currently parsed node, for reporting mainly.
const OptionsCont & myOptionsCont
the options
void myEndElement(int element) override
Called when a closing tag occurs.
NodesHandler & operator=(const NodesHandler &s)
invalidated assignment operator
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.
RelationHandler & operator=(const RelationHandler &s)
invalidated assignment operator
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
long long int myCurrentRelation
The currently parsed relation.
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
@ RESTRICTION_UNKNOWN
The relation tag was missing.
@ RESTRICTION_NO
The only invalid connection is declared.
@ RESTRICTION_ONLY
The only valid 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
std::vector< int > myParentElements
The element stack.
RelationHandler(const std::map< long long int, NIOSMNode * > &osmNodes, const std::map< long long int, Edge * > &osmEdges, NBPTStopCont *nbptStopCont, const std::map< long long int, Edge * > &platfromShapes, NBPTLineCont *nbptLineCont, const OptionsCont &oc)
Constructor.
int myInterval
service interval of the pt line in minutes
RelationHandler(const RelationHandler &s)
invalidated copy constructor
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)
Builds an NBEdge.
std::map< long long int, Edge * > myEdges
the map from OSM way ids to edge objects
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
static const double MAXSPEED_UNGIVEN
std::map< long long int, std::set< long long int > > myStopAreas
the map from stop_area relations to member node
std::map< long long int, Edge * > myPlatformShapes
the map from OSM way ids to platform shapes
void load(const OptionsCont &oc, NBNetBuilder &nb)
std::set< NIOSMNode *, CompareNodes > myUniqueNodes
the set of unique nodes used in NodesHandler, used when freeing memory
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
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 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
A storage for options typed value containers)
Definition: OptionsCont.h:89
An upper class for objects with additional parameters.
Definition: Parameterised.h:39
Encapsulated SAX-Attributes.
SAX-handler base for SUMO-files.
An internal representation of an OSM-node.
SVCPermissions permissions
type of pt stop
NBNode * node
the NBNode that was instantiated
double positionMeters
position converted to m (using highest precision available)
std::string position
kilometrage/mileage
const long long int id
The node's id.
NIOSMNode & operator=(const NIOSMNode &s)=delete
invalidated assignment operator
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.