Eclipse SUMO - Simulation of Urban MObility
NIImporter_SUMO.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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // Importer for networks stored in SUMO format
18 /****************************************************************************/
19 #ifndef NIImporter_SUMO_h
20 #define NIImporter_SUMO_h
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <string>
29 #include <map>
34 #include "NIXMLTypesHandler.h"
35 
36 
37 // ===========================================================================
38 // class declarations
39 // ===========================================================================
40 class NBNetBuilder;
41 class NBEdge;
42 class OptionsCont;
43 
44 
45 // ===========================================================================
46 // class definitions
47 // ===========================================================================
54 public:
70  static void loadNetwork(OptionsCont& oc, NBNetBuilder& nb);
71 
74 
76  static void addPhase(const SUMOSAXAttributes& attrs, NBLoadedSUMOTLDef* currentTL);
77 
79  static GeoConvHelper* loadLocation(const SUMOSAXAttributes& attrs);
80 
81 protected:
86 
89 
91 
92 
103  void myStartElement(int element,
104  const SUMOSAXAttributes& attrs);
105 
106 
113  void myEndElement(int element);
115 
116 
117 private:
119  void _loadNetwork(OptionsCont& oc);
120 
122 
123 
127  void addEdge(const SUMOSAXAttributes& attrs);
128 
129 
133  void addLane(const SUMOSAXAttributes& attrs);
134 
138  void addStopOffsets(const SUMOSAXAttributes& attrs, bool& ok);
139 
143  void addJunction(const SUMOSAXAttributes& attrs);
144 
145 
149  void addRequest(const SUMOSAXAttributes& attrs);
150 
151 
156  void addConnection(const SUMOSAXAttributes& attrs);
157 
161  void addProhibition(const SUMOSAXAttributes& attrs);
162 
166  void addRoundabout(const SUMOSAXAttributes& attrs);
167 
169 
170 
171 
172 private:
177  struct Connection : public Parameterised {
179  std::string toEdgeID;
183  std::string tlID;
189  bool keepClear;
191  double contPos;
193  double visibility;
195  double speed;
200  };
201 
202 
206  struct LaneAttrs : public Parameterised {
208  double maxSpeed;
212  std::vector<Connection> connections;
214  std::string allow;
216  std::string disallow;
218  double width;
220  double endOffset;
222  std::map<SVCPermissions, double> stopOffsets;
224  bool accelRamp;
226  std::string oppositeID;
230  std::string type;
231  };
232 
233 
237  struct EdgeAttrs : public Parameterised {
239  std::string id;
241  std::string streetName;
243  std::string type;
247  std::string fromNode;
249  std::string toNode;
253  double length;
255  int priority;
257  double maxSpeed;
259  std::vector<LaneAttrs*> lanes;
265  std::map<SVCPermissions, double> stopOffsets;
267  double distance;
268  };
269 
270 
274  struct Prohibition {
275  std::string prohibitorFrom;
276  std::string prohibitorTo;
277  std::string prohibitedFrom;
278  std::string prohibitedTo;
279  };
280 
284  struct Crossing {
285  Crossing(const std::string& _edgeID) :
286  edgeID(_edgeID), customTLIndex(-1), customTLIndex2(-1) {}
287 
288  std::string edgeID;
289  std::vector<std::string> crossingEdges;
290  double width;
291  bool priority;
295  };
296 
302  std::vector<std::string> fromEdges;
303  std::vector<std::string> toEdges;
304  std::vector<std::string> fromCrossed;
305  std::vector<std::string> toCrossed;
306  };
307 
311  struct JunctionAttrs {
313  // @the list of internal lanes corresponding to each link
314  std::vector<std::string> intLanes;
315  // @brief the complete response definition for all links
316  std::vector<std::string> response;
317  };
318 
320  std::map<std::string, EdgeAttrs*> myEdges;
321 
323  std::vector<Prohibition> myProhibitions;
324 
327 
330 
333 
336 
339 
342 
345 
348 
351 
353  std::map<std::string, std::vector<Crossing> > myPedestrianCrossings;
354 
356  std::map<std::string, WalkingAreaParsedCustomShape> myWACustomShapes;
357 
359  std::vector<Parameterised*> myLastParameterised;
360 
363 
366 
369 
372 
375 
378 
381 
384 
388 
390  std::vector<std::vector<std::string> > myRoundabouts;
391 
393  std::set<std::string> myRailSignals;
394 
399  LaneAttrs* getLaneAttrsFromID(EdgeAttrs* edge, std::string lane_id);
400 
406  static PositionVector reconstructEdgeShape(const EdgeAttrs* edge, const Position& from, const Position& to);
407 
409  static Position readPosition(const SUMOSAXAttributes& attrs, const std::string& id, bool& ok);
410 
417  void parseProhibitionConnection(const std::string& attr, std::string& from, std::string& to, bool& ok);
418 };
419 
420 
421 #endif
422 
423 /****************************************************************************/
424 
PositionVector customShape
custom shape connection
std::map< std::string, EdgeAttrs * > myEdges
Loaded edge definitions.
LaneAttrs * myCurrentLane
The currently parsed lanes&#39;s definition (to add the shape to)
PositionVector shape
This edges&#39;s shape.
std::vector< Prohibition > myProhibitions
Loaded prohibitions.
static void addPhase(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
adds a phase to the traffic lights logic currently build
bool accelRamp
Whether this lane is an acceleration lane.
bool uncontrolled
if set to true, This connection will not be TLS-controlled despite its node being controlled...
NBNodeCont & myNodeCont
The node container to fill.
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
A loaded (complete) traffic light logic.
std::vector< LaneAttrs * > lanes
This edge&#39;s lanes.
A container for traffic light definitions and built programs.
Describes a pedestrian crossing.
double maxSpeed
The maximum velocity allowed on this lane.
The representation of a single edge during network building.
Definition: NBEdge.h:86
A connection description.
int tlLinkIndex
The index of this connection within the controlling traffic light.
bool myCheckLaneFoesRoundabout
std::vector< std::string > response
double myLimitTurnSpeed
whether turning speed was limited in the network
double width
The width of this lane.
bool myAmLefthand
whether the loaded network was built for lefthand traffic
static NBLoadedSUMOTLDef * initTrafficLightLogic(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
begins the reading of a traffic lights logic
SAX-handler base for SUMO-files.
NIImporter_SUMO(NBNetBuilder &nb)
Constructor.
Describes custom shape for a walking area during parsing.
Describes the values found in a lane&#39;s definition.
LaneAttrs * getLaneAttrsFromID(EdgeAttrs *edge, std::string lane_id)
Parses lane index from lane ID an retrieve lane from EdgeAttrs.
std::string toEdgeID
The id of the target edge.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
double maxSpeed
The maximum velocity allowed on this edge (!!!)
void addStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
parses stop offsets for the current lane or edge
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and stores the values in "myCurrentLane".
NBNetBuilder & myNetBuilder
The network builder to fill.
std::vector< std::vector< std::string > > myRoundabouts
loaded roundabout edges
void addConnection(const SUMOSAXAttributes &attrs)
Parses a connection and saves it into the lane&#39;s definition stored in "myCurrentLane".
std::string toNode
The node this edge ends at.
Describes the values found in an edge&#39;s definition and this edge&#39;s lanes.
int myLinkDetail
the level of geometry detail for internal lanes in the loaded network
JunctionAttrs myCurrentJunction
The currently parsed junction definition to help in reconstructing crossings.
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:56
std::vector< std::string > crossingEdges
std::string allow
This lane&#39;s allowed vehicle classes.
Describes the values found in a junction.
std::vector< Parameterised * > myLastParameterised
element to receive parameters
Encapsulated SAX-Attributes.
static GeoConvHelper * loadLocation(const SUMOSAXAttributes &attrs)
Parses network location description and registers it with GeoConveHelper::setLoaded.
Describes the values found in a prohibition.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
Importer for networks stored in SUMO format.
std::string tlID
The id of the traffic light that controls this connection.
EdgeAttrs * myCurrentEdge
The currently parsed edge&#39;s definition (to add loaded lanes to)
A list of positions.
void parseProhibitionConnection(const std::string &attr, std::string &from, std::string &to, bool &ok)
parses connection string of a prohibition (very old school)
bool myRectLaneCut
whether all lanes of an edge should have the same stop line
double visibility
custom foe visibility for connection
LaneSpreadFunction lsf
The lane spread function.
bool customShape
Whether this lane has a custom shape.
double distance
The position at the start of this edge (kilometrage/mileage)
double length
The length of the edge if set explicitly.
std::string disallow
This lane&#39;s disallowed vehicle classes.
double speed
custom speed for connection
NBEdge * builtEdge
The built edge.
static PositionVector reconstructEdgeShape(const EdgeAttrs *edge, const Position &from, const Position &to)
reconstructs the edge shape from the node positions and the given lane shapes since we do not know th...
SumoXMLEdgeFunc func
This edge&#39;s function.
An upper class for objects with additional parameters.
Definition: Parameterised.h:43
std::map< SVCPermissions, double > stopOffsets
This edge&#39;s vehicle specific stop offsets (used for lanes, that do not have a specified stopOffset) ...
std::string oppositeID
This lane&#39;s opposite lane.
void _loadNetwork(OptionsCont &oc)
load the network
Crossing(const std::string &_edgeID)
bool keepClear
Whether the junction must be kept clear coming from this connection.
NIXMLTypesHandler myTypesHandler
The handler for parsing edge types and restrictions.
std::vector< std::string > intLanes
double endOffset
This lane&#39;s offset from the intersection.
std::string streetName
This edge&#39;s street name.
static void loadNetwork(OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given SUMO file.
std::string type
the type of this lane
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
Importer for edge type information stored in XML.
double myNetworkVersion
the loaded network version
std::vector< Connection > connections
This lane&#39;s connections.
void addJunction(const SUMOSAXAttributes &attrs)
Parses a junction and saves it in the node control.
bool myCheckLaneFoesAll
whether foe-relationships where checked at lane-level
std::string type
This edge&#39;s type.
double contPos
custom position for internal junction on this connection
Instance responsible for building networks.
Definition: NBNetBuilder.h:110
int myCornerDetail
the level of corner detail in the loaded network
static Position readPosition(const SUMOSAXAttributes &attrs, const std::string &id, bool &ok)
read position from the given attributes, attribute errors to id
std::map< std::string, std::vector< Crossing > > myPedestrianCrossings
The pedestrian crossings found in the network.
A storage for options typed value containers)
Definition: OptionsCont.h:90
int priority
This edge&#39;s priority.
std::string id
This edge&#39;s id.
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
void myEndElement(int element)
Called when a closing tag occurs.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge&#39;s lateral offset shal...
std::string fromNode
The node this edge starts at.
Represents a single node (junction) during network building.
Definition: NBNode.h:68
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
~NIImporter_SUMO()
Destructor.
void addRequest(const SUMOSAXAttributes &attrs)
Parses a reques and saves selected attributes in myCurrentJunction.
GeoConvHelper * myLocation
The coordinate transformation which was used to build the loaded network.
PositionVector shape
This lane&#39;s shape (needed to reconstruct edge shape for legacy networks)
NBTrafficLightLogicCont & myTLLCont
The node container to fill.
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:60
std::map< std::string, WalkingAreaParsedCustomShape > myWACustomShapes
Map from walkingArea edge IDs to custom shapes.
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
NBLoadedSUMOTLDef * myCurrentTL
The currently parsed traffic light.
bool myWalkingAreas
whether walkingareas must be built
std::set< std::string > myRailSignals
list of node id with rail signals (no NBTrafficLightDefinition exists)
int toLaneIdx
The index of the target lane.
std::map< SVCPermissions, double > stopOffsets
This lane&#39;s vehicle specific stop offsets.