39 #include <xercesc/sax/HandlerBase.hpp> 40 #include <xercesc/sax/AttributeList.hpp> 41 #include <xercesc/sax/SAXParseException.hpp> 42 #include <xercesc/sax/SAXException.hpp> 58 #ifdef CHECK_MEMORY_LEAKS 60 #endif // CHECK_MEMORY_LEAKS 79 myCurrentEdge(0), myHaveReportedAboutOverwriting(false),
80 myHaveReportedAboutTypeOverride(false),
81 myHaveWarnedAboutDeprecatedLaneId(false),
82 myKeepEdgeShape(!options.getBool(
"plain.extend-edge-shape")) {
291 WRITE_ERROR(
"Additional lane information could not be set - the edge with id '" +
myCurrentID +
"' is not known.");
342 WRITE_WARNING(
"Ignoring 'split' because it cannot be assigned to an edge");
363 std::vector<std::string> lanes;
365 for (std::vector<std::string>::iterator i = lanes.begin(); i != lanes.end(); ++i) {
368 e.
lanes.push_back(lane);
375 if (e.
lanes.empty()) {
377 e.
lanes.push_back(l);
403 std::string oldBegID = begNodeID;
404 std::string oldEndID = endNodeID;
461 std::string lsfS =
toString(result);
514 std::vector<Split>::iterator i;
520 sort((*i).lanes.begin(), (*i).lanes.end());
521 noLanesMax =
MAX2(noLanesMax, (
int)(*i).lanes.size());
524 std::vector<int> currLanes;
526 currLanes.push_back(l);
537 std::string edgeid = e->
getID();
540 const Split& exp = *i;
541 assert(exp.
lanes.size() != 0);
546 std::string pid = e->
getID();
550 std::vector<int> newLanes = exp.
lanes;
556 int rightMostP = currLanes[0];
557 int rightMostN = newLanes[0];
558 for (
int l = 0; l < (int) rightMostP - (
int) rightMostN; ++l) {
562 int leftMostP = currLanes.back();
563 int leftMostN = newLanes.back();
564 for (
int l = 0; l < (int) leftMostN - (
int) leftMostP; ++l) {
568 for (
int l = 0; l < noLanesMax; ++l) {
569 if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
572 if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
579 currLanes = newLanes;
583 }
else if (exp.
pos == 0) {
585 if (laneCountDiff < 0) {
590 currLanes = exp.
lanes;
604 for (
int lane = 0; lane < (int)e->
getNumLanes(); ++lane) {
605 start.
lanes.push_back(lane);
611 int maxLeft = (*i).lanes.back();
613 if (maxLeft < noLanesMax) {
620 int maxRight = (*i).lanes.front();
643 for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
647 WRITE_ERROR(
"Unknown edge '" + (*it) +
"' in roundabout");
650 roundabout.insert(edge);
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
The information about how to spread the lanes from the given position.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
SUMOReal getSpeed(const std::string &type) const
Returns the maximal velocity for the given type [m/s].
SUMOReal getBikeLaneWidth(const std::string &type) const
Returns the lane width for a bike lane to be added [m].
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
LaneSpreadFunction myLanesSpread
Information about how to spread the lanes.
Finds a split at the given position.
static bool transformCoordinates(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
SUMOReal getWidth(const std::string &type) const
Returns the lane width for the given type [m].
std::string myCurrentID
The current edge's id.
const SUMOReal SUMO_const_halfLaneAndOffset
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
void markAsSplit(const NBNode *node)
mark a node as being created form a split
SUMOReal length() const
Returns the length.
PositionVector myShape
The shape of the edge.
A container for traffic light definitions and built programs.
void setLaneWidth(int lane, SUMOReal width)
set lane specific width (negative lane implies set for all lanes)
SUMOReal myBikeLaneWidth
The width of the bike lane that shall be added to the current edge.
void setSpeed(int lane, SUMOReal speed)
set lane specific speed (negative lane implies set for all lanes)
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
SUMOReal mySidewalkWidth
The width of the sidewalk that shall be added to the current edge.
const SUMOReal SUMO_const_laneWidthAndOffset
bool setNodes(const SUMOSAXAttributes &attrs)
Sets from/to node information of the currently parsed edge.
void addSidewalk(SUMOReal width)
add a pedestrian sidewalk of the given width and shift existing connctions
int getPriority() const
Returns the priority of the edge.
const std::string & getTypeID() const
get ID of type
The representation of a single edge during network building.
int getPriority(const std::string &type) const
Returns the priority for the given type.
NBNode * myFromNode
The nodes the edge starts and ends at.
Position positionAtOffset(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
A container for districts.
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
NIXMLEdgesHandler(NBNodeCont &nc, NBEdgeCont &ec, NBTypeCont &tc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, OptionsCont &options)
Constructor.
bool myHaveReportedAboutOverwriting
Information whether at least one edge's attributes were overwritten.
bool hasLoadedLength() const
Returns whether a length was set explicitly.
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
int getNumLanes(const std::string &type) const
Returns the number of lanes for the given type.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getID() const
Returns the id.
NBDistrictCont & myDistrictCont
The districts container (needed if an edge must be split)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
Lane & getLaneStruct(int lane)
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
SAX-handler base for SUMO-files.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
#define WRITE_WARNING(msg)
The connection was computed and validated.
static OptionsCont & getOptions()
Retrieves the options.
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, int nolanes, int priority, PositionVector geom, SUMOReal width, SUMOReal offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
const bool myKeepEdgeShape
Whether the edge shape shall be kept generally.
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges.
bool myReinitKeepEdgeShape
Whether the edge shape shall be kept at reinitilization.
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
~NIXMLEdgesHandler()
Destructor.
void incLaneNo(int by)
increment lane
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
bool knows(const std::string &type) const
Returns whether the named type is in the container.
std::vector< Split > mySplits
The list of this edge's splits.
std::set< NBEdge * > EdgeSet
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
bool myHaveWarnedAboutDeprecatedLaneId
void decLaneNo(int by)
decrement lane
Encapsulated SAX-Attributes.
SUMOReal speed
The speed after this change.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
void deleteEdge(const SUMOSAXAttributes &attrs)
parses delete tag and deletes the specified edge
int getNumLanes() const
Returns the number of lanes.
A structure which describes changes of lane number or speed along the road.
void addSplit(const SUMOSAXAttributes &attrs)
Parses a split and stores it in mySplits. Splits are executed Upon reading the end tag of an edge...
T get(const std::string &str) const
std::string myCurrentType
The current edge's type.
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS, SUMOReal visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge's lane and an approached one.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
SUMOReal myCurrentEndOffset
The current edge's offset till the destination node.
Storage for edges, including some functionality operating on multiple edges.
std::vector< int > lanes
The lanes after this change.
const std::string & getStreetName() const
Returns the street name of this edge.
NBNodeCont & myNodeCont
The nodes container (for retrieval of referenced nodes)
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
NBTrafficLightLogicCont & myTLLogicCont
The traffic lights container to add built tls to (when invalidating tls because of splits) ...
static void processNodeType(const SUMOSAXAttributes &attrs, NBNode *node, const std::string &nodeID, const Position &position, bool updateEdgeGeometries, NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
parses node attributes (not related to positioning)
Sorts splits by their position (increasing)
LaneSpreadFunction tryGetLaneSpread(const SUMOSAXAttributes &attrs)
Tries to parse the spread type.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
void setLoadedLength(SUMOReal val)
set loaded lenght
const PositionVector & getGeometry() const
Returns the geometry of the edge.
virtual std::vector< std::string > getStringVector(int attr) const =0
Tries to read given attribute assuming it is a string vector.
void addBikeLane(SUMOReal width)
add a bicycle lane of the given width and shift existing connctions
static int _2int(const E *const data)
converts a char-type array into the integer value described by it
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.
SVCPermissions myPermissions
Information about lane permissions.
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
bool myIsUpdate
Whether this edge definition is an update of a previously inserted edge.
SUMOReal myCurrentSpeed
The current edge's maximum speed.
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
SUMOReal getSidewalkWidth(const std::string &type) const
Returns the lane width for a sidewalk to be added [m].
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
void myEndElement(int element)
Called when a closing tag occurs.
A storage for options typed value containers)
NBEdge * myCurrentEdge
The currently processed edge.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
OptionsCont & myOptions
A reference to the program's options.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
NBTypeCont & myTypeCont
The types container (for retrieval of type defaults)
const Position & getPosition() const
Returns the position of this node.
Represents a single node (junction) during network building.
void move2side(SUMOReal amount)
move position vector to side using certain ammount
bool myHaveReportedAboutTypeOverride
Information whether at least one edge's type was changed.
void setEndOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
NBNode * getFromNode() const
Returns the origin node of the edge.
NBEdgeCont & myEdgeCont
The edges container (for insertion of build edges)
int myCurrentLaneNo
The current edge's number of lanes.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Container for nodes during the netbuilding process.
SUMOReal myCurrentWidth
The current edge's lane width.
SUMOReal myLength
The current edge's length.
SUMOReal pos
The position of this change.
std::string myCurrentStreetName
The current edge's street name.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
#define WRITE_MESSAGE(msg)
void invalidateTLS(NBTrafficLightLogicCont &tlCont)
causes the traffic light to be computed anew
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and modifies myCurrentEdge according to the given attribures.
NBNode * getToNode() const
Returns the destination node of the edge.
int myCurrentPriority
The current edge's priority.
NBNode * node
The new node that is created for this split.
const SVCPermissions SVC_UNSPECIFIED
SVCPermissions getPermissions(const std::string &type) const
Returns allowed vehicle classes for the given type.
A storage for available types of edges.
PositionVector tryGetShape(const SUMOSAXAttributes &attrs)
Tries to parse the shape definition.