Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 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 : /****************************************************************************/
14 : /// @file NIImporter_SUMO.h
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date Mon, 14.04.2008
19 : ///
20 : // Importer for networks stored in SUMO format
21 : /****************************************************************************/
22 : #pragma once
23 : #include <config.h>
24 :
25 : #include <string>
26 : #include <map>
27 : #include <utils/xml/SUMOSAXHandler.h>
28 : #include <utils/geom/GeoConvHelper.h>
29 : #include <utils/common/Parameterised.h>
30 : #include <netbuild/NBLoadedSUMOTLDef.h>
31 : #include "NIXMLTypesHandler.h"
32 :
33 :
34 : // ===========================================================================
35 : // class declarations
36 : // ===========================================================================
37 : class NBNetBuilder;
38 : class NBEdge;
39 : class OptionsCont;
40 :
41 :
42 : // ===========================================================================
43 : // class definitions
44 : // ===========================================================================
45 : /**
46 : * @class NIImporter_SUMO
47 : * @brief Importer for networks stored in SUMO format
48 : *
49 : */
50 : class NIImporter_SUMO : public SUMOSAXHandler {
51 : public:
52 : /** @brief Loads content of the optionally given SUMO file
53 : *
54 : * If the option "sumo-net-file" is set, the file stored therein is read and
55 : * the network definition stored therein is stored within the given network
56 : * builder.
57 : *
58 : * If the option "sumo-net-file" is not set, this method simply returns.
59 : *
60 : * The loading is done by parsing the network definition as an XML file
61 : * using the SAXinterface and handling the incoming data via this class'
62 : * methods.
63 : *
64 : * @param[in,out] oc The options to use (option no-internal-links may be modified)
65 : * @param[in] nb The network builder to fill
66 : */
67 : static void loadNetwork(OptionsCont& oc, NBNetBuilder& nb);
68 :
69 : /// begins the reading of a traffic lights logic
70 : static NBLoadedSUMOTLDef* initTrafficLightLogic(const SUMOSAXAttributes& attrs, NBLoadedSUMOTLDef* currentTL);
71 :
72 : /// adds a phase to the traffic lights logic currently build
73 : static void addPhase(const SUMOSAXAttributes& attrs, NBLoadedSUMOTLDef* currentTL);
74 :
75 : /// Parses network location description and registers it with GeoConveHelper::setLoaded
76 : static GeoConvHelper* loadLocation(const SUMOSAXAttributes& attrs, bool setLoaded = true);
77 :
78 : protected:
79 : /** @brief Constructor
80 : * @param[in] nc The network builder to fill
81 : */
82 : NIImporter_SUMO(NBNetBuilder& nb);
83 :
84 : /// @brief Destructor
85 : ~NIImporter_SUMO();
86 :
87 : /// @name inherited from GenericSAXHandler
88 : //@{
89 :
90 : /** @brief Called on the opening of a tag;
91 : *
92 : * In dependence to the obtained type, an appropriate parsing
93 : * method is called ("addEdge" if an edge encounters, f.e.).
94 : *
95 : * @param[in] element ID of the currently opened element
96 : * @param[in] attrs Attributes within the currently opened element
97 : * @exception ProcessError If something fails
98 : * @see GenericSAXHandler::myStartElement
99 : */
100 : void myStartElement(int element,
101 : const SUMOSAXAttributes& attrs);
102 :
103 :
104 : /** @brief Called when a closing tag occurs
105 : *
106 : * @param[in] element ID of the currently opened element
107 : * @exception ProcessError If something fails
108 : * @see GenericSAXHandler::myEndElement
109 : */
110 : void myEndElement(int element);
111 : //@}
112 :
113 :
114 : private:
115 : /// @brief load the network
116 : void _loadNetwork(OptionsCont& oc);
117 :
118 : /// @name Object instance parsing methods
119 : //@{
120 :
121 : /** @brief Parses an edge and stores the values in "myCurrentEdge"
122 : * @param[in] attrs The attributes to get the edge's values from
123 : */
124 : void addEdge(const SUMOSAXAttributes& attrs);
125 :
126 :
127 : /** @brief Parses a lane and stores the values in "myCurrentLane"
128 : * @param[in] attrs The attributes to get the lane's values from
129 : */
130 : void addLane(const SUMOSAXAttributes& attrs);
131 :
132 : /** @brief parses stop offsets for the current lane or edge
133 : * @param[in] attrs The attributes to get the stop offset specifics from
134 : */
135 : void addStopOffsets(const SUMOSAXAttributes& attrs, bool& ok);
136 :
137 : /** @brief Parses a junction and saves it in the node control
138 : * @param[in] attrs The attributes to get the junction's values from
139 : */
140 : void addJunction(const SUMOSAXAttributes& attrs);
141 :
142 :
143 : /** @brief Parses a request and saves selected attributes in myCurrentJunction
144 : * @param[in] attrs The attributes to get the junction's values from
145 : */
146 : void addRequest(const SUMOSAXAttributes& attrs);
147 :
148 :
149 : /** @brief Parses a connection and saves it
150 : * into the lane's definition stored in "myCurrentLane"
151 : * @param[in] attrs The attributes to get the connection from
152 : */
153 : void addConnection(const SUMOSAXAttributes& attrs);
154 :
155 : /** @brief Parses a prohibition and saves it
156 : * @param[in] attrs The attributes to get the connection from
157 : */
158 : void addProhibition(const SUMOSAXAttributes& attrs);
159 :
160 : /** @brief Parses a roundabout and stores it in myEdgeCont.
161 : * @param[in] attrs The attributes to get the roundabouts values from
162 : */
163 : void addRoundabout(const SUMOSAXAttributes& attrs);
164 :
165 : //@}
166 :
167 :
168 :
169 : private:
170 : /**
171 : * @struct Connection
172 : * @brief A connection description.
173 : */
174 : class Connection final : public Parameterised {
175 : public:
176 : /// @brief The id of the target edge
177 : std::string toEdgeID;
178 : /// @brief The index of the target lane
179 : int toLaneIdx;
180 : /// @brief The id of the traffic light that controls this connection
181 : std::string tlID;
182 : /// @brief The index of this connection within the controlling traffic light
183 : int tlLinkIndex;
184 : int tlLinkIndex2;
185 : /// @brief Information about being definitely free to drive (on-ramps)
186 : bool mayDefinitelyPass;
187 : /* @brief Whether the junction must be kept clear coming from this connection
188 : * @note: The enum NBEdge::KeepClear is not needed here because data
189 : * from a .net.xml is fully specified */
190 : bool keepClear;
191 : /// @brief custom position for internal junction on this connection
192 : double contPos;
193 : /// @brief custom foe visibility for connection
194 : double visibility;
195 : /// @brief custom permissions for connection
196 : SVCPermissions permissions;
197 : /// @brief custom lane changing permissions for connection
198 : SVCPermissions changeLeft;
199 : /// @brief custom lane changing permissions for connection
200 : SVCPermissions changeRight;
201 : /// @brief custom speed for connection
202 : double speed;
203 : /// @brief custom friction for connection
204 : double friction;
205 : /// @brief custom length for connection
206 : double customLength;
207 : /// @brief custom shape connection
208 : PositionVector customShape;
209 : /// @brief if set to true, This connection will not be TLS-controlled despite its node being controlled.
210 : bool uncontrolled;
211 : /// @brief Whether this connection is an indirect left turn
212 : bool indirectLeft;
213 : /// @brief optional edge type
214 : std::string edgeType;
215 : };
216 :
217 :
218 : /** @struct LaneAttrs
219 : * @brief Describes the values found in a lane's definition
220 : */
221 54660 : class LaneAttrs final : public Parameterised {
222 : public:
223 : /// @brief The maximum velocity allowed on this lane
224 : double maxSpeed;
225 : /// @brief The friction on this lane
226 : double friction;
227 : /// @brief This lane's shape (may be custom)
228 : PositionVector shape;
229 : /// @brief This lane's connections
230 : std::vector<Connection> connections;
231 : /// @brief This lane's allowed vehicle classes
232 : std::string allow;
233 : /// @brief This lane's disallowed vehicle classes
234 : std::string disallow;
235 : /// @brief This lane's vehicle classes allowed to change left
236 : std::string changeLeft;
237 : /// @brief This lane's vehicle classes allowed to change right
238 : std::string changeRight;
239 : /// @brief The width of this lane
240 : double width;
241 : /// @brief This lane's offset from the intersection
242 : double endOffset;
243 : /// @brief This lane's vehicle specific stop offsets
244 : StopOffset laneStopOffset;
245 : /// @brief Whether this lane is an acceleration lane
246 : bool accelRamp;
247 : /// @brief This lane's opposite lane
248 : std::string oppositeID;
249 : /// @brief Whether this lane has a custom shape
250 : bool customShape;
251 : /// @brief the type of this lane
252 : std::string type;
253 : };
254 :
255 :
256 : /** @struct EdgeAttrs
257 : * @brief Describes the values found in an edge's definition and this edge's lanes
258 : */
259 44431 : class EdgeAttrs final : public Parameterised {
260 : public:
261 : /// @brief This edge's id
262 : std::string id;
263 : /// @brief This edge's street name
264 : std::string streetName;
265 : /// @brief This edge's type
266 : std::string type;
267 : /// @brief This edge's function
268 : SumoXMLEdgeFunc func;
269 : /// @brief The node this edge starts at
270 : std::string fromNode;
271 : /// @brief The node this edge ends at
272 : std::string toNode;
273 : /// @brief This edges's shape
274 : PositionVector shape;
275 : /// @brief The length of the edge if set explicitly
276 : double length;
277 : /// @brief This edge's priority
278 : int priority;
279 : /// @brief The maximum velocity allowed on this edge (!!!)
280 : double maxSpeed;
281 : /// @brief The friction on this edge
282 : //double friction;
283 : /// @brief This edge's lanes
284 : std::vector<LaneAttrs*> lanes;
285 : /// @brief The built edge
286 : NBEdge* builtEdge;
287 : /// @brief The lane spread function
288 : LaneSpreadFunction lsf;
289 : /// @brief This edge's vehicle specific stop offsets (used for lanes, that do not have a specified stopOffset)
290 : StopOffset edgeStopOffset;
291 : /// @brief The position at the start of this edge (kilometrage/mileage)
292 : double distance;
293 : /// @brief the bidi edge
294 : std::string bidi;
295 : };
296 :
297 :
298 : /** @struct Prohibition
299 : * @brief Describes the values found in a prohibition
300 : */
301 : struct Prohibition {
302 : std::string prohibitorFrom;
303 : std::string prohibitorTo;
304 : std::string prohibitedFrom;
305 : std::string prohibitedTo;
306 : };
307 :
308 : /** @struct Crossing
309 : * @brief Describes a pedestrian crossing
310 : */
311 : struct Crossing : public Parameterised {
312 145 : Crossing(const std::string& _edgeID) :
313 290 : edgeID(_edgeID), customTLIndex(-1), customTLIndex2(-1) {}
314 :
315 : std::string edgeID;
316 : std::vector<std::string> crossingEdges;
317 : double width;
318 : bool priority;
319 : PositionVector customShape;
320 : int customTLIndex;
321 : int customTLIndex2;
322 : };
323 :
324 : /** @struct WalkingAreaParsedCustomShape
325 : * @brief Describes custom shape for a walking area during parsing
326 : */
327 6 : struct WalkingAreaParsedCustomShape {
328 : PositionVector shape;
329 : std::vector<std::string> fromEdges;
330 : std::vector<std::string> toEdges;
331 : std::vector<std::string> fromCrossed;
332 : std::vector<std::string> toCrossed;
333 : double width;
334 : };
335 :
336 : /** @struct JunctionAttrs
337 : * @brief Describes the values found in a junction
338 : */
339 1884 : struct JunctionAttrs {
340 : NBNode* node;
341 : // @the list of internal lanes corresponding to each link
342 : std::vector<std::string> intLanes;
343 : // @brief the complete response definition for all links
344 : std::vector<std::string> response;
345 : };
346 :
347 : /// @brief Loaded edge definitions
348 : std::map<std::string, EdgeAttrs*> myEdges;
349 :
350 : /// @brief Loaded prohibitions
351 : std::vector<Prohibition> myProhibitions;
352 :
353 : /// @brief The network builder to fill
354 : NBNetBuilder& myNetBuilder;
355 :
356 : /// @brief The node container to fill
357 : NBNodeCont& myNodeCont;
358 :
359 : /// @brief The node container to fill
360 : NBTrafficLightLogicCont& myTLLCont;
361 :
362 : /// @brief The handler for parsing edge types and restrictions
363 : NIXMLTypesHandler myTypesHandler;
364 :
365 : /// @brief The currently parsed edge's definition (to add loaded lanes to)
366 : EdgeAttrs* myCurrentEdge;
367 :
368 : /// @brief The currently parsed junction definition to help in reconstructing crossings
369 : JunctionAttrs myCurrentJunction;
370 :
371 : /// @brief The currently parsed lanes's definition (to add the shape to)
372 : LaneAttrs* myCurrentLane;
373 :
374 : /// @brief The currently parsed traffic light
375 : NBLoadedSUMOTLDef* myCurrentTL;
376 :
377 : /// @brief The coordinate transformation which was used to build the loaded network.
378 : GeoConvHelper* myLocation;
379 :
380 : /// @brief The pedestrian crossings found in the network
381 : std::map<std::string, std::vector<Crossing> > myPedestrianCrossings;
382 :
383 : /// @brief Map from walkingArea edge IDs to custom shapes
384 : std::map<std::string, WalkingAreaParsedCustomShape> myWACustomShapes;
385 :
386 : /// @brief element to receive parameters
387 : std::vector<Parameterised*> myLastParameterised;
388 :
389 : /// @brief the loaded network version
390 : MMVersion myNetworkVersion;
391 :
392 : /// @brief whether the loaded network contains internal lanes
393 : bool myHaveSeenInternalEdge;
394 :
395 : /// @brief whether the loaded network was built for lefthand traffic
396 : bool myAmLefthand;
397 :
398 : /// @brief whether the written network should have a different "handedness" (LHT/RHT) than the loaded network
399 : bool myChangeLefthand;
400 :
401 : /// @brief the level of corner detail in the loaded network
402 : int myCornerDetail;
403 :
404 : /// @brief the level of geometry detail for internal lanes in the loaded network
405 : int myLinkDetail;
406 :
407 : /// @brief whether all lanes of an edge should have the same stop line
408 : bool myRectLaneCut;
409 :
410 : /// @brief whether walkingareas must be built
411 : bool myWalkingAreas;
412 :
413 : /// @brief whether turning speed was limited in the network
414 : double myLimitTurnSpeed;
415 :
416 : /// @brief whether foe-relationships where checked at lane-level
417 : bool myCheckLaneFoesAll;
418 : bool myCheckLaneFoesRoundabout;
419 : /// @brief whether some right-of-way checks at traffic light junctions should be disabled
420 : bool myTlsIgnoreInternalJunctionJam;
421 : /// @brief default spreadType defined in the network
422 : std::string myDefaultSpreadType;
423 : /// @brief overlap option for loaded network
424 : bool myGeomAvoidOverlap;
425 : /// @brief higherSpeed option for loaded network
426 : bool myJunctionsHigherSpeed;
427 : /// @brief custom settings for internal junction computation
428 : double myInternalJunctionsVehicleWidth;
429 : /// @brief custom settings for junction shape computation
430 : bool myJunctionsMinimalShape;
431 : bool myJunctionsEndpointShape;
432 :
433 : /// @brief loaded roundabout edges
434 : std::vector<std::vector<std::string> > myRoundabouts;
435 :
436 : /// @brief list of node id with rail signals (no NBTrafficLightDefinition exists)
437 : std::set<std::string> myRailSignals;
438 :
439 : /// @brief list of parameter keys to discard
440 : std::set<std::string> myDiscardableParams;
441 :
442 : private:
443 :
444 : /// @brief read position from the given attributes, attribute errors to id
445 : static Position readPosition(const SUMOSAXAttributes& attrs, const std::string& id, bool& ok);
446 :
447 : /** @brief parses connection string of a prohibition (very old school)
448 : * @param[in] attr The connection attribute
449 : * @param[out] from ID of the source edge
450 : * @param[out] to ID of the destination edge
451 : * @param[out] ok Whether parsing completed successfully
452 : */
453 : void parseProhibitionConnection(const std::string& attr, std::string& from, std::string& to, bool& ok);
454 : };
|
