Eclipse SUMO - Simulation of Urban MObility
ShapeHandler.cpp
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 /****************************************************************************/
14 // The XML-Handler for network loading
15 /****************************************************************************/
16 // ===========================================================================
17 // included modules
18 // ===========================================================================
19 #include <config.h>
20 
21 #include <string>
24 #include <utils/xml/XMLSubSys.h>
28 #include <utils/common/RGBColor.h>
34 
35 #include "Shape.h"
36 #include "ShapeContainer.h"
37 #include "ShapeHandler.h"
38 
39 
40 // ===========================================================================
41 // method definitions
42 // ===========================================================================
43 
44 ShapeHandler::ShapeHandler(const std::string& file, ShapeContainer& sc, const GeoConvHelper* geoConvHelper) :
45  SUMOSAXHandler(file),
46  myShapeContainer(sc),
47  myPrefix(""),
48  myDefaultColor(RGBColor::RED),
49  myDefaultLayer(0),
50  myDefaultFill(false),
51  myLastParameterised(nullptr),
52  myGeoConvHelper(geoConvHelper) {
53 }
54 
55 
57 
58 
59 void
60 ShapeHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
61  try {
62  switch (element) {
63  case SUMO_TAG_POLY:
64  // default layer is different depending if we're parsing a Poly or a POI, therefore it has to be here defined
66  addPoly(attrs, false, false);
67  break;
68  case SUMO_TAG_POI:
69  // default layer is different depending if we're parsing a Poly or a POI, therefore it has to be here defined
71  addPOI(attrs, false, false);
72  break;
73  case SUMO_TAG_PARAM:
74  if (myLastParameterised != nullptr) {
75  bool ok = true;
76  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
77  // continue if key awas sucesfully loaded
78  if (ok) {
79  // circumventing empty string value
80  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
81  // show warnings if values are invalid
82  if (key.empty()) {
83  WRITE_WARNING("Error parsing key from shape generic parameter. Key cannot be empty");
84  } else if (!SUMOXMLDefinitions::isValidParameterKey(key)) {
85  WRITE_WARNING("Error parsing key from shape generic parameter. Key contains invalid characters");
87  WRITE_WARNING("Error parsing value from shape generic parameter. Value contains invalid characters");
88  } else {
89  WRITE_DEBUG("Inserting generic parameter '" + key + "|" + val + "' into shape.");
91  }
92  }
93  }
94  default:
95  break;
96  }
97  } catch (InvalidArgument& e) {
98  WRITE_ERROR(e.what());
99  }
100 }
101 
102 
103 void
105  if (element != SUMO_TAG_PARAM) {
106  myLastParameterised = nullptr;
107  }
108 }
109 
110 
111 void
112 ShapeHandler::addPOI(const SUMOSAXAttributes& attrs, const bool ignorePruning, const bool useProcessing) {
113  bool ok = true;
114  const double INVALID_POSITION(-1000000);
115  const std::string id = myPrefix + attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
116  double x = attrs.getOpt<double>(SUMO_ATTR_X, id.c_str(), ok, INVALID_POSITION);
117  const double y = attrs.getOpt<double>(SUMO_ATTR_Y, id.c_str(), ok, INVALID_POSITION);
118  double lon = attrs.getOpt<double>(SUMO_ATTR_LON, id.c_str(), ok, INVALID_POSITION);
119  double lat = attrs.getOpt<double>(SUMO_ATTR_LAT, id.c_str(), ok, INVALID_POSITION);
120  const double lanePos = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), ok, 0);
121  const double lanePosLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, id.c_str(), ok, 0);
122  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), ok, myDefaultLayer);
123  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
124  const std::string laneID = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), ok, "");
125  const RGBColor color = attrs.hasAttribute(SUMO_ATTR_COLOR) ? attrs.get<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok) : myDefaultColor;
126  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE);
127  std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE);
128  bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), ok, Shape::DEFAULT_RELATIVEPATH);
129  if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
131  }
132  const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), ok, Shape::DEFAULT_IMG_WIDTH);
133  const double height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, id.c_str(), ok, Shape::DEFAULT_IMG_HEIGHT);
134  // check if ID is valid
135  if (SUMOXMLDefinitions::isValidTypeID(id) == false) {
136  WRITE_WARNING("Invalid characters for PoI ID");
137  ok = false;
138  }
139  // continue
140  if (ok) {
141  const GeoConvHelper* gch;
142  // set GEOConverter
143  if (myGeoConvHelper != nullptr) {
144  gch = myGeoConvHelper;
145  } else if (useProcessing) {
147  } else {
148  gch = &GeoConvHelper::getFinal();
149  }
150  // check if GEOProjection has to be used
151  if (useProcessing && gch->usingGeoProjection()) {
152  if ((lat == INVALID_POSITION) || (lon == INVALID_POSITION)) {
153  lon = x;
154  lat = y;
155  x = INVALID_POSITION;
156  }
157  }
158  Position pos(x, y);
159  bool useGeo = false;
160  if ((x == INVALID_POSITION) || (y == INVALID_POSITION)) {
161  // try computing x,y from lane,pos
162  if (laneID != "") {
163  pos = getLanePos(id, laneID, lanePos, lanePosLat);
164  } else {
165  // try computing x,y from lon,lat
166  if ((lat == INVALID_POSITION) || (lon == INVALID_POSITION)) {
167  WRITE_ERROR("Either (x, y), (lon, lat) or (lane, pos) must be specified for PoI '" + id + "'.");
168  return;
169  } else if (!gch->usingGeoProjection()) {
170  WRITE_ERROR("(lon, lat) is specified for PoI '" + id + "' but no geo-conversion is specified for the network.");
171  return;
172  }
173  pos.set(lon, lat);
174  useGeo = true;
175  bool success = true;
176  if (useProcessing) {
177  success = GeoConvHelper::getProcessing().x2cartesian(pos);
178  } else {
179  success = gch->x2cartesian_const(pos);
180  }
181  if (!success) {
182  WRITE_ERROR("Unable to project coordinates for PoI '" + id + "'.");
183  return;
184  }
185  }
186  }
187  if (!myShapeContainer.addPOI(id, type, color, pos, useGeo, laneID, lanePos, lanePosLat, layer, angle, imgFile, relativePath, width, height, ignorePruning)) {
188  WRITE_ERROR("PoI '" + id + "' already exists.");
189  }
191  if ((laneID != "") && addLanePosParams()) {
195  }
196  }
197 }
198 
199 
200 void
201 ShapeHandler::addPoly(const SUMOSAXAttributes& attrs, const bool ignorePruning, const bool useProcessing) {
202  bool ok = true;
203  const std::string id = myPrefix + attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
204  // check if ID is valid
205  if (SUMOXMLDefinitions::isValidTypeID(id) == false) {
206  WRITE_WARNING("Invalid characters for Poly ID");
207  ok = false;
208  }
209  // get the id, report an error if not given or empty...
210  if (ok) {
211  // continue loading parameters
212  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), ok, myDefaultLayer);
213  const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), ok, myDefaultFill);
214  const double lineWidth = attrs.getOpt<double>(SUMO_ATTR_LINEWIDTH, id.c_str(), ok, Shape::DEFAULT_LINEWIDTH);
215  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, Shape::DEFAULT_TYPE);
216  const RGBColor color = attrs.hasAttribute(SUMO_ATTR_COLOR) ? attrs.get<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok) : myDefaultColor;
217  PositionVector shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
218  const bool geo = attrs.getOpt<bool>(SUMO_ATTR_GEO, id.c_str(), ok, false);
219  // set geo converter
220  const GeoConvHelper* gch;
221  if (myGeoConvHelper != nullptr) {
222  gch = myGeoConvHelper;
223  } else {
224  gch = &GeoConvHelper::getFinal();
225  }
226  // check if poly use geo coordinates
227  if (geo || useProcessing) {
228  bool success = true;
229  for (int i = 0; i < (int)shape.size(); i++) {
230  if (useProcessing) {
231  success &= GeoConvHelper::getProcessing().x2cartesian(shape[i]);
232  } else {
233  success &= gch->x2cartesian_const(shape[i]);
234  }
235  }
236  if (!success) {
237  WRITE_WARNING("Unable to project coordinates for polygon '" + id + "'.");
238  return;
239  }
240  }
241  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE);
242  std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE);
243  bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), ok, Shape::DEFAULT_RELATIVEPATH);
244  if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
246  }
247  // check that shape's size is valid
248  if (shape.size() == 0) {
249  WRITE_ERROR("Polygon's shape cannot be empty.");
250  return;
251  }
252  // check that lineWidth is positive
253  if (lineWidth <= 0) {
254  WRITE_ERROR("Polygon's lineWidth must be greather than 0.");
255  return;
256  }
257  // create polygon, or show an error if polygon already exists
258  if (!myShapeContainer.addPolygon(id, type, color, layer, angle, imgFile, relativePath, shape, geo, fill, lineWidth, ignorePruning)) {
259  WRITE_ERROR("Polygon '" + id + "' already exists.");
260  }
262  }
263 }
264 
265 
268  return myLastParameterised;
269 }
270 
271 
272 bool
273 ShapeHandler::loadFiles(const std::vector<std::string>& files, ShapeHandler& sh) {
274  for (const auto& fileIt : files) {
275  if (!XMLSubSys::runParser(sh, fileIt, false)) {
276  WRITE_MESSAGE("Loading of shapes from " + fileIt + " failed.");
277  return false;
278  }
279  }
280  return true;
281 }
282 
283 
284 void
285 ShapeHandler::setDefaults(const std::string& prefix, const RGBColor& color, const double layer, const bool fill) {
286  myPrefix = prefix;
287  myDefaultColor = color;
288  myDefaultLayer = layer;
289  myDefaultFill = fill;
290 }
291 
292 
293 bool
295  return false;
296 }
297 
298 /****************************************************************************/
SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:381
SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:794
XMLSubSys::runParser
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything's ok.
Definition: XMLSubSys.cpp:112
GUIGlObjectTypes.h
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
ShapeHandler::~ShapeHandler
virtual ~ShapeHandler()
Destructor.
Definition: ShapeHandler.cpp:56
Parameterised
An upper class for objects with additional parameters.
Definition: Parameterised.h:42
ShapeHandler::myLastParameterised
Parameterised * myLastParameterised
element to receive parameters
Definition: ShapeHandler.h:126
SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:57
ShapeHandler::getLastParameterised
Parameterised * getLastParameterised() const
get last parameterised object
Definition: ShapeHandler.cpp:267
SUMOSAXAttributes::getString
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOSAXHandler
SAX-handler base for SUMO-files.
Definition: SUMOSAXHandler.h:41
GeoConvHelper::x2cartesian_const
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation.
Definition: GeoConvHelper.cpp:417
GeomConvHelper.h
ShapeHandler::getLanePos
virtual Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos, double lanePosLat)=0
get position for a given laneID (Has to be implemented in all child)
SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:169
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
MsgHandler.h
FileHelpers::getConfigurationRelative
static std::string getConfigurationRelative(const std::string &configPath, const std::string &path)
Returns the second path as a relative path to the first file.
Definition: FileHelpers.cpp:115
SUMOSAXHandler.h
Shape::DEFAULT_LAYER
static const double DEFAULT_LAYER
Definition: Shape.h:43
ShapeHandler::addPoly
void addPoly(const SUMOSAXAttributes &attrs, const bool ignorePruning, const bool useProcessing)
adds a polygon
Definition: ShapeHandler.cpp:201
GeoConvHelper::getProcessing
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
Definition: GeoConvHelper.h:86
ShapeHandler::myDefaultFill
bool myDefaultFill
Information whether polygons should be filled.
Definition: ShapeHandler.h:123
GeoConvHelper.h
ShapeContainer
Storage for geometrical objects.
Definition: ShapeContainer.h:49
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:53
ShapeHandler::loadFiles
static bool loadFiles(const std::vector< std::string > &files, ShapeHandler &sh)
loads all of the given files
Definition: ShapeHandler.cpp:273
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
ShapeHandler::addLanePosParams
virtual bool addLanePosParams()
Whether some input attributes shall be automatically added as params (Can be implemented in all child...
Definition: ShapeHandler.cpp:294
ShapeHandler::myStartElement
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: ShapeHandler.cpp:60
SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:637
PositionVector
A list of positions.
Definition: PositionVector.h:45
GeoConvHelper
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:55
GeoConvHelper::x2cartesian
bool x2cartesian(Position &from, bool includeInBoundary=true)
Converts the given coordinate into a cartesian and optionally update myConvBoundary.
Definition: GeoConvHelper.cpp:326
GeoConvHelper::usingGeoProjection
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
Definition: GeoConvHelper.cpp:281
ShapeHandler::myGeoConvHelper
const GeoConvHelper * myGeoConvHelper
geo-conversion to use during loading
Definition: ShapeHandler.h:129
RGBColor.h
ShapeHandler::addPOI
void addPOI(const SUMOSAXAttributes &attrs, const bool ignorePruning, const bool useProcessing)
adds a POI
Definition: ShapeHandler.cpp:112
Shape::DEFAULT_IMG_HEIGHT
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:50
INVALID_POSITION
#define INVALID_POSITION
Definition: MSDelayBasedTrafficLightLogic.cpp:34
Shape::DEFAULT_RELATIVEPATH
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:48
RGBColor
Definition: RGBColor.h:39
SUMO_ATTR_LINEWIDTH
Definition: SUMOXMLDefinitions.h:715
Shape.h
SUMOXMLDefinitions::isValidParameterKey
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter
Definition: SUMOXMLDefinitions.cpp:1041
Shape::DEFAULT_LINEWIDTH
static const double DEFAULT_LINEWIDTH
Definition: Shape.h:44
ShapeHandler::setDefaults
void setDefaults(const std::string &prefix, const RGBColor &color, const double layer, const bool fill=false)
set default values
Definition: ShapeHandler.cpp:285
ShapeHandler::myDefaultColor
RGBColor myDefaultColor
The default color to use.
Definition: ShapeHandler.h:117
GeoConvHelper::getFinal
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
Definition: GeoConvHelper.h:105
ShapeHandler::myEndElement
virtual void myEndElement(int element)
Called when a closing tag occurs.
Definition: ShapeHandler.cpp:104
Position::set
void set(double x, double y)
set positions x and y
Definition: Position.h:86
ShapeHandler::myDefaultLayer
double myDefaultLayer
The default layer to use.
Definition: ShapeHandler.h:120
SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
ShapeHandler::ShapeHandler
ShapeHandler(const std::string &file, ShapeContainer &sc, const GeoConvHelper *=nullptr)
Constructor.
Definition: ShapeHandler.cpp:44
SUMO_ATTR_LAYER
A layer number.
Definition: SUMOXMLDefinitions.h:712
OutputDevice.h
SUMOXMLDefinitions::isValidParameterValue
static bool isValidParameterValue(const std::string &value)
whether the given string is a valid value for a parameter
Definition: SUMOXMLDefinitions.cpp:1052
Shape::DEFAULT_TYPE
static const std::string DEFAULT_TYPE
Definition: Shape.h:42
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
UtilExceptions.h
SUMO_ATTR_Y
Definition: SUMOXMLDefinitions.h:399
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:518
SUMO_ATTR_RELATIVEPATH
Definition: SUMOXMLDefinitions.h:793
SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:660
SUMO_ATTR_FILL
Fill the polygon.
Definition: SUMOXMLDefinitions.h:714
ShapeContainer::getPOIs
const POIs & getPOIs() const
Returns all pois.
Definition: ShapeContainer.h:154
ShapeContainer::addPolygon
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
Definition: ShapeContainer.cpp:64
SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
StringUtils.h
SUMOXMLDefinitions::isValidTypeID
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
Definition: SUMOXMLDefinitions.cpp:979
ShapeHandler::myShapeContainer
ShapeContainer & myShapeContainer
reference to shape container in which all Shares are being added
Definition: ShapeHandler.h:111
InvalidArgument
Definition: UtilExceptions.h:56
SUMO_ATTR_LAT
Definition: SUMOXMLDefinitions.h:815
GenericSAXHandler::getFileName
const std::string & getFileName() const
returns the current file name
Definition: GenericSAXHandler.cpp:74
SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:408
NamedObjectCont::get
T get(const std::string &id) const
Retrieves an item.
Definition: NamedObjectCont.h:98
SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:779
SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:661
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:46
FileHelpers::isAbsolute
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
Definition: FileHelpers.cpp:129
ShapeContainer::addPOI
virtual bool addPOI(const std::string &id, const std::string &type, const RGBColor &color, const Position &pos, bool geo, const std::string &lane, double posOverLane, double posLat, double layer, double angle, const std::string &imgFile, bool relativePath, double width, double height, bool ignorePruning=false)
Builds a POI using the given values and adds it to the container.
Definition: ShapeContainer.cpp:145
Shape::DEFAULT_ANGLE
static const double DEFAULT_ANGLE
Definition: Shape.h:46
config.h
ShapeHandler
The XML-Handler for network loading.
Definition: ShapeHandler.h:49
ShapeContainer.h
StringTokenizer.h
ShapeHandler.h
ShapeContainer::getPolygons
const Polygons & getPolygons() const
Returns all polygons.
Definition: ShapeContainer.h:149
Shape::DEFAULT_IMG_FILE
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:47
SUMO_ATTR_LON
Definition: SUMOXMLDefinitions.h:814
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:690
SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:398
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
ShapeHandler::myPrefix
std::string myPrefix
The prefix to use.
Definition: ShapeHandler.h:114
WRITE_MESSAGE
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:277
Shape::DEFAULT_LAYER_POI
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:284
SUMOXMLDefinitions.h
SUMO_ATTR_GEO
Definition: SUMOXMLDefinitions.h:816
XMLSubSys.h
Shape::DEFAULT_IMG_WIDTH
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:49