Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NIXMLPTHandler.cpp
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/****************************************************************************/
18// Importer for static public transport information
19/****************************************************************************/
20#include <config.h>
21
22#include <string>
23#include <iostream>
24#include <map>
25#include <cmath>
35#include <netbuild/NBNodeCont.h>
36#include <netbuild/NBTypeCont.h>
38#include <netbuild/NBPTStop.h>
40#include "NIXMLNodesHandler.h"
41#include "NIXMLPTHandler.h"
42
43
44// ===========================================================================
45// method definitions
46// ===========================================================================
48 SUMOSAXHandler("public transport - file"),
49 myEdgeCont(ec),
50 myStopCont(sc),
51 myLineCont(lc),
52 myCurrentStop(nullptr),
53 myCurrentLine(nullptr),
54 myCurrentCompletion(0),
55 myCurrentStopWasIgnored(false)
56{ }
57
58
60
61
62void
64 const SUMOSAXAttributes& attrs) {
65 switch (element) {
68 case SUMO_TAG_STOP:
69 if (myCurrentRouteID != "") {
70 addRouteStop(attrs);
71 } else if (myCurrentLine == nullptr) {
72 addPTStop(attrs);
73 } else {
74 addPTLineStop(attrs);
75 }
76 break;
77 case SUMO_TAG_ACCESS:
78 addAccess(attrs);
79 break;
81 addPTLine(attrs);
82 break;
83 case SUMO_TAG_ROUTE:
84 if (myCurrentLine == nullptr) {
85 addRoute(attrs);
86 } else {
87 addPTLineRoute(attrs);
88 }
89 break;
90 case SUMO_TAG_FLOW:
91 case SUMO_TAG_TRIP:
92 addPTLineFromFlow(attrs);
93 break;
94 case SUMO_TAG_PARAM: {
95 bool ok = true;
96 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
97 if (myCurrentLine != nullptr) {
98 if (key == "completeness") {
99 myCurrentCompletion = attrs.get<double>(SUMO_ATTR_VALUE, nullptr, ok);
100 } else if (key == "name") {
101 myCurrentLine->setName(attrs.get<std::string>(SUMO_ATTR_VALUE, nullptr, ok));
102 }
103 } else if (myCurrentStop != nullptr) {
104 const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
105 myCurrentStop->setParameter(key, val);
106 }
107 }
108 break;
109 default:
110 break;
111 }
112}
113
114void
116 switch (element) {
119 myCurrentStop = nullptr;
121 break;
122 case SUMO_TAG_PT_LINE:
123 case SUMO_TAG_FLOW:
124 case SUMO_TAG_TRIP:
126 myCurrentLine = nullptr;
127 break;
128 case SUMO_TAG_ROUTE:
129 myCurrentRouteID = "";
130 break;
131 default:
132 break;
133 }
134}
135
136
137void
139 bool ok = true;
140 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "busStop", ok);
141 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
142 const std::string laneID = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), ok);
143 const double startPos = attrs.get<double>(SUMO_ATTR_STARTPOS, id.c_str(), ok);
144 const double endPos = attrs.get<double>(SUMO_ATTR_ENDPOS, id.c_str(), ok);
145 const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), ok, 0);
146 const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok, RGBColor(false));
147 //const std::string lines = attrs.get<std::string>(SUMO_ATTR_LINES, id.c_str(), ok);
148 const int laneIndex = NBEdge::getLaneIndexFromLaneID(laneID);
149 const std::string edgeID = SUMOXMLDefinitions::getEdgeIDFromLane(laneID);
150 NBEdge* edge = myEdgeCont.retrieve(edgeID);
151 if (edge == nullptr) {
152 if (!myEdgeCont.wasIgnored(edgeID)) {
153 WRITE_ERRORF(TL("Edge '%' for stop '%' not found"), edgeID, id);
154 } else {
157 }
158 return;
159 }
160 if (edge->getNumLanes() <= laneIndex) {
161 WRITE_ERRORF(TL("Lane '%' for stop '%' not found"), laneID, id);
162 return;
163 }
164 SVCPermissions permissions = edge->getPermissions(laneIndex);
165 // possibly the stops were written for a different network. If the lane is not a typical public transport stop lane, assume bus as the default
166 if (!isRailway(permissions) && permissions != SVC_SHIP && permissions != SVC_TAXI) {
167 permissions = SVC_BUS;
168 }
169 if (ok) {
170 Position pos = edge->geometryPositionAtOffset((startPos + endPos) / 2);
171 myCurrentStop = std::make_shared<NBPTStop>(id, pos, edgeID, edgeID, endPos - startPos, name, permissions, parkingLength, color, startPos);
173 WRITE_ERRORF(TL("Could not add public transport stop '%' (already exists)"), id);
174 }
175 }
176}
177
178void
180 if (myCurrentStop == nullptr) {
182 return;
183 } else {
184 throw InvalidArgument("Could not add access outside a stopping place.");
185 }
186 }
187 bool ok = true;
188 const std::string laneID = attrs.get<std::string>(SUMO_ATTR_LANE, "access", ok);
189 const std::string edgeID = SUMOXMLDefinitions::getEdgeIDFromLane(laneID);
190 if (myEdgeCont.retrieve(edgeID) == nullptr) {
191 if (!myEdgeCont.wasIgnored(edgeID)) {
192 WRITE_ERRORF(TL("Edge '%' for access to stop '%' not found"), edgeID, myCurrentStop->getID());
193 }
194 return;
195 }
196 const double pos = attrs.get<double>(SUMO_ATTR_POSITION, "access", ok);
197 const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "access", ok, -1);
198 if (ok) {
199 myCurrentStop->addAccess(laneID, pos, length);
200 }
201}
202
203
204void
206 bool ok = true;
207 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "ptLine", ok);
208 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
209 const std::string line = attrs.get<std::string>(SUMO_ATTR_LINE, id.c_str(), ok);
210 const std::string type = attrs.get<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok);
212 if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
213 vClass = getVehicleClassID(attrs.get<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok));
214 }
215 RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok, RGBColor(false));
216 const int intervalS = attrs.getOpt<int>(SUMO_ATTR_PERIOD, id.c_str(), ok, -1);
217 const std::string nightService = attrs.getStringSecure("nightService", "");
218 myCurrentCompletion = StringUtils::toDouble(attrs.getStringSecure("completeness", "1"));
219 if (ok) {
220 myCurrentLine = new NBPTLine(id, name, type, line, intervalS / 60, nightService, vClass, color);
222 WRITE_WARNINGF(TL("Ignoring duplicate PT line '%'."), id);
223 delete myCurrentLine;
224 }
225 }
226}
227
228
229void
231 bool ok = true;
232 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "flow", ok);
233 const std::string line = attrs.get<std::string>(SUMO_ATTR_LINE, id.c_str(), ok);
234 const std::string type = attrs.get<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok);
235 const std::string route = attrs.get<std::string>(SUMO_ATTR_ROUTE, id.c_str(), ok);
237 const int intervalS = attrs.getOpt<int>(SUMO_ATTR_PERIOD, id.c_str(), ok, -1);
238 RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok, RGBColor(false));
239 if (ok) {
240 myCurrentLine = new NBPTLine(id, "", type, line, intervalS / 60, "", vClass, color);
242 for (std::shared_ptr<NBPTStop> stop : myRouteStops[route]) {
244 }
246 }
247}
248
249
250void
252 if (myCurrentLine == nullptr) {
253 WRITE_ERROR(TL("Found route outside line definition"));
254 return;
255 }
256 bool ok = true;
257 const std::vector<std::string>& edgeIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, nullptr, ok);
258 EdgeVector edges;
259 for (const std::string& edgeID : edgeIDs) {
260 NBEdge* edge = myEdgeCont.retrieve(edgeID);
261 if (edge == nullptr) {
262 if (!myEdgeCont.wasIgnored(edgeID)) {
263 WRITE_ERRORF(TL("Edge '%' in route of line '%' not found"), edgeID, myCurrentLine->getName());
264 }
265 } else {
266 edges.push_back(edge);
267 }
268 }
269 myCurrentLine->setEdges(edges);
270}
271
272
273void
275 bool ok = true;
276 myCurrentRouteID = attrs.get<std::string>(SUMO_ATTR_ID, "route", ok);
277 const std::vector<std::string>& edgeIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, myCurrentRouteID.c_str(), ok);
278 EdgeVector edges;
279 for (const std::string& edgeID : edgeIDs) {
280 NBEdge* edge = myEdgeCont.retrieve(edgeID);
281 if (edge == nullptr) {
282 if (!myEdgeCont.wasIgnored(edgeID)) {
283 WRITE_ERRORF(TL("Edge '%' in route of line '%' not found"), edgeID, myCurrentLine->getName());
284 }
285 } else {
286 edges.push_back(edge);
287 }
288 }
290}
291
292
293void
295 bool ok = true;
296 const std::string id = attrs.hasAttribute(SUMO_ATTR_ID)
297 ? attrs.get<std::string>(SUMO_ATTR_ID, "ptLine", ok)
298 : attrs.get<std::string>(SUMO_ATTR_BUS_STOP, "ptline", ok);
299 std::shared_ptr<NBPTStop> stop = myStopCont.get(id);
300 if (stop == nullptr) {
301 if (!NBPTStopCont::wasIgnored(id)) {
302 WRITE_ERRORF(TL("Stop '%' within line '%' not found"), id, toString(myCurrentLine->getLineID()));
303 }
304 return;
305 }
307}
308
309void
311 assert(myCurrentRouteID != "");
312 bool ok = true;
313 const std::string id = attrs.hasAttribute(SUMO_ATTR_ID)
314 ? attrs.get<std::string>(SUMO_ATTR_ID, "ptLine", ok)
315 : attrs.get<std::string>(SUMO_ATTR_BUS_STOP, "ptline", ok);
316 std::shared_ptr<NBPTStop> stop = myStopCont.get(id);
317 if (stop == nullptr) {
318 WRITE_ERRORF(TL("Stop '%' within route '%' not found"), id, toString(myCurrentRouteID));
319 return;
320 }
321 myRouteStops[myCurrentRouteID].push_back(stop);
322}
323
324
325/****************************************************************************/
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_ERROR(msg)
Definition MsgHandler.h:279
#define TL(string)
Definition MsgHandler.h:287
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition NBCont.h:42
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_SHIP
is an arbitrary ship
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_ACCESS
An access point for a train stop.
@ SUMO_TAG_PT_LINE
A pt line.
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_STOP
stop for vehicles
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
@ SUMO_TAG_PARAM
parameter associated to a certain key
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_LANE
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_PARKING_LENGTH
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_LINE
@ SUMO_ATTR_NAME
@ SUMO_ATTR_PERIOD
@ SUMO_ATTR_VCLASS
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_ROUTE
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_ID
@ SUMO_ATTR_KEY
@ SUMO_ATTR_POSITION
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
Storage for edges, including some functionality operating on multiple edges.
Definition NBEdgeCont.h:59
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition NBEdgeCont.h:473
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:4232
int getNumLanes() const
Returns the number of lanes.
Definition NBEdge.h:510
Position geometryPositionAtOffset(double offset) const
return position taking into account loaded length
Definition NBEdge.cpp:4554
static int getLaneIndexFromLaneID(const std::string laneID)
Definition NBEdge.cpp:4671
bool insert(NBPTLine *ptLine)
insert new line
void setName(const std::string &name)
Definition NBPTLine.h:106
const std::string & getName() const
Definition NBPTLine.h:55
const std::string & getLineID() const
Definition NBPTLine.h:51
const std::vector< std::shared_ptr< NBPTStop > > & getStops()
Definition NBPTLine.cpp:65
void setMyNumOfStops(int numStops)
Definition NBPTLine.cpp:157
void addPTStop(std::shared_ptr< NBPTStop > pStop)
Definition NBPTLine.cpp:51
void setEdges(const std::vector< NBEdge * > &edges)
Definition NBPTLine.cpp:132
Container for public transport stops during the net building process.
static void addIgnored(const std::string &stopID)
std::shared_ptr< NBPTStop > get(std::string id) const
Retrieve a previously inserted pt stop.
static bool wasIgnored(const std::string &stopID)
bool insert(std::shared_ptr< NBPTStop > ptStop, bool floating=false)
Inserts a node into the map.
static SUMOVehicleClass interpretTransportType(const std::string &type, NIOSMNode *toSet=nullptr)
translate osm transport designations into sumo vehicle class
NIXMLPTHandler(NBEdgeCont &ec, NBPTStopCont &sc, NBPTLineCont &lc)
Constructor.
void addPTLine(const SUMOSAXAttributes &attrs)
Parses a public transport line.
std::shared_ptr< NBPTStop > myCurrentStop
The currently processed stop.
~NIXMLPTHandler()
Destructor.
std::map< std::string, std::vector< std::shared_ptr< NBPTStop > > > myRouteStops
stand-alone route information
std::string myCurrentRouteID
The currently processed stand-alone route.
void addPTLineStop(const SUMOSAXAttributes &attrs)
Parses an public transport stop reference within a line element.
void addPTLineFromFlow(const SUMOSAXAttributes &attrs)
Parses a public transport line.
NBPTStopCont & myStopCont
The stop container (for loading of stops)
void myEndElement(int element)
Called when a closing tag occurs.
NBEdgeCont & myEdgeCont
The edges container (for retrieving referenced stop edge)
std::map< std::string, EdgeVector > myRouteEdges
NBPTLineCont & myLineCont
The line container (for loading of lines)
bool myCurrentStopWasIgnored
whether the current stop should be discarded
void addPTLineRoute(const SUMOSAXAttributes &attrs)
Parses a route as port of a public transport line.
void addPTStop(const SUMOSAXAttributes &attrs)
Parses an public transport stop.
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
double myCurrentCompletion
the completion level of the current line
void addRoute(const SUMOSAXAttributes &attrs)
Parses a stand-alone route when parsing implicit ptlines from routes and flows.
void addRouteStop(const SUMOSAXAttributes &attrs)
Parses an public transport stop reference within a route element.
void addAccess(const SUMOSAXAttributes &attrs)
Parses an stop access definition.
NBPTLine * myCurrentLine
The currently processed line.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SAX-handler base for SUMO-files.
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter