91 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
93 for (std::vector<LaneAttrs*>::const_iterator j = ed->
lanes.begin(); j != ed->
lanes.end(); ++j) {
111 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
113 WRITE_ERROR(
"Could not open sumo-net-file '" + *file +
"'.");
123 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
141 WRITE_ERROR(
"Edge's '" + ed->
id +
"' from-node and to-node '" + ed->
toNode +
"' art identical.");
146 if (ed->
shape.size() > 0) {
156 (
int) ed->
lanes.size(),
160 e->updateParameter(ed->
getMap());
170 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
176 for (
int fromLaneIndex = 0; fromLaneIndex < (int) ed->
lanes.size(); ++fromLaneIndex) {
179 const std::vector<Connection>& connections = lane->
connections;
180 for (std::vector<Connection>::const_iterator c_it = connections.begin(); c_it != connections.end(); c_it++) {
200 if (programs.size() > 0) {
201 std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
202 for (it = programs.begin(); it != programs.end(); it++) {
207 throw ProcessError(
"Corrupt traffic light definition '" + c.
tlID +
"' (program '" + it->first +
"')");
238 toRemove.push_back(nbe);
241 for (EdgeVector::iterator i = toRemove.begin(); i != toRemove.end(); ++i) {
246 NBEdge* prohibitedFrom =
myEdges[it->prohibitedFrom]->builtEdge;
248 NBEdge* prohibitorFrom =
myEdges[it->prohibitorFrom]->builtEdge;
250 if (prohibitedFrom == 0) {
251 WRITE_WARNING(
"Edge '" + it->prohibitedFrom +
"' in prohibition was not built");
252 }
else if (prohibitedTo == 0) {
253 WRITE_WARNING(
"Edge '" + it->prohibitedTo +
"' in prohibition was not built");
254 }
else if (prohibitorFrom == 0) {
255 WRITE_WARNING(
"Edge '" + it->prohibitorFrom +
"' in prohibition was not built");
256 }
else if (prohibitorTo == 0) {
257 WRITE_WARNING(
"Edge '" + it->prohibitorTo +
"' in prohibition was not built");
271 if (oc.
isDefault(
"junctions.corner-detail")) {
277 if (oc.
isDefault(
"rectangular-lane-cut")) {
287 if (!oc.
getBool(
"no-internal-links")) {
291 for (std::vector<Crossing>::const_iterator it_c = (*it).second.begin(); it_c != (*it).second.end(); ++it_c) {
294 for (std::vector<std::string>::const_iterator it_e = crossing.
crossingEdges.begin(); it_e != crossing.
crossingEdges.end(); ++it_e) {
298 edges.push_back(edge);
301 if (edges.size() > 0) {
310 std::vector<std::string> edgeIDs;
311 if (item.second.fromEdges.size() + item.second.toEdges.size() == 0) {
313 assert(item.second.fromCrossed.size() > 0);
314 assert(item.second.toCrossed.size() > 0);
315 edgeIDs = item.second.fromCrossed;
316 edgeIDs.insert(edgeIDs.end(), item.second.toCrossed.begin(), item.second.toCrossed.end());
317 }
else if (item.second.fromEdges.size() > 0) {
318 edgeIDs = item.second.fromEdges;
320 edgeIDs = item.second.toEdges;
323 for (std::string edgeID : edgeIDs) {
327 edges.push_back(edge);
330 if (edges.size() > 0) {
338 for (std::vector<std::string>::const_iterator it_r = it->begin(); it_r != it->end(); ++it_r) {
342 WRITE_ERROR(
"Unknown edge '" + (*it_r) +
"' in roundabout");
345 roundabout.insert(edge);
453 WRITE_ERROR(
"Unmatched closing tag for tl-logic.");
521 WRITE_ERROR(
"Unknown spreadType '" + lsfS +
"' for edge '" +
id +
"'.");
534 WRITE_ERROR(
"Found lane '" +
id +
"' not within edge element");
544 assert(crossings.size() > 0);
603 WRITE_WARNING(
"Unknown node type for junction '" +
id +
"'.");
610 WRITE_ERROR(
"Problems on adding junction '" +
id +
"'.");
644 if (
myEdges.count(fromID) == 0) {
645 WRITE_ERROR(
"Unknown edge '" + fromID +
"' given in connection.");
660 if (conn.
tlID !=
"") {
663 if ((
int)from->
lanes.size() <= fromLaneIdx) {
664 WRITE_ERROR(
"Invalid lane index '" +
toString(fromLaneIdx) +
"' for connection from '" + fromID +
"'.");
667 from->
lanes[fromLaneIdx]->connections.push_back(conn);
674 for (std::vector<Crossing>::iterator it = crossings.begin(); it != crossings.end(); ++it) {
675 if (conn.
toEdgeID == (*it).edgeID) {
676 if (conn.
tlID !=
"") {
677 (*it).priority =
true;
678 (*it).customTLIndex = conn.
tlLinkNo;
690 std::map<std::string, WalkingAreaParsedCustomShape>::iterator it =
myWACustomShapes.find(fromID);
694 it->second.toEdges.push_back(conn.
toEdgeID);
698 if (conn.
toEdgeID == crossing.edgeID) {
699 it->second.toCrossed.insert(it->second.toCrossed.end(), crossing.crossingEdges.begin(), crossing.crossingEdges.end());
709 it->second.fromEdges.push_back(fromID);
713 if (fromID == crossing.edgeID) {
714 it->second.fromCrossed.insert(it->second.fromCrossed.end(), crossing.crossingEdges.begin(), crossing.crossingEdges.end());
747 assert(edge->
id == edge_id);
748 if ((
int)edge->
lanes.size() <= index) {
749 WRITE_ERROR(
"Unknown lane '" + lane_id +
"' given in succedge.");
752 return edge->
lanes[index];
760 WRITE_ERROR(
"Definition of tl-logic '" + currentTL->
getID() +
"' was not finished.");
772 WRITE_ERROR(
"Unknown traffic light type '" + typeS +
"' for tlLogic '" +
id +
"'.");
789 const std::string&
id = currentTL->
getID();
802 currentTL->
addPhase(duration, state, minDuration, maxDuration);
810 result.push_back(from);
812 if (edge->
lanes[0]->customShape) {
814 result.push_back(to);
821 const int noLanes = (int)edge->
lanes.size();
828 for (
int i = 1; i < (int)firstLane.size() - 1; i++) {
829 const Position& from = firstLane[i - 1];
831 const Position& to = firstLane[i + 1];
842 WRITE_WARNING(
"Could not reconstruct shape for edge '" + edge->
id +
"'.");
846 result.push_back(to);
862 result =
new GeoConvHelper(proj, networkOffset, origBoundary, convBoundary);
881 const std::string::size_type div = attr.find(
"->");
882 if (div == std::string::npos) {
883 WRITE_ERROR(
"Missing connection divider in prohibition attribute '" + attr +
"'");
886 from = attr.substr(0, div);
887 to = attr.substr(div + 2);
889 if (from.find(
'_') != std::string::npos) {
890 from = from.substr(0, from.find(
'_'));
892 if (to.find(
'_') != std::string::npos) {
893 to = to.substr(0, to.find(
'_'));
896 if (
myEdges.count(from) == 0) {
897 WRITE_ERROR(
"Unknown edge prohibition '" + from +
"'");
901 WRITE_ERROR(
"Unknown edge prohibition '" + to +
"'");
PositionVector customShape
custom shape connection
void addPhase(SUMOTime duration, const std::string &state, SUMOTime minDur, SUMOTime maxDur)
Adds a phase to the logic the new phase is inserted at the end of the list of already added phases...
static const PositionVector EMPTY
empty Vector
std::map< std::string, EdgeAttrs * > myEdges
Loaded edge definitions.
LaneAttrs * myCurrentLane
The currently parsed lanes's definition (to add the shape to)
The information about how to spread the lanes from the given position.
const std::map< std::string, NBTrafficLightDefinition * > & getPrograms(const std::string &id) const
Returns all programs for the given tl-id.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
PositionVector shape
This edges'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
std::set< std::string > deprecatedVehicleClassesSeen
NBTypeCont & getTypeCont()
Returns a reference to the type container.
Whether vehicles must keep the junction clear.
whether a given shape is user-defined
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
bool accelRamp
Whether this lane is an acceleration lane.
static bool transformCoordinate(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
root element of a network file
begin/end of the description of a junction
begin/end of the description of a single lane
static bool isReadable(std::string path)
Checks whether the given file is readable.
NBNodeCont & myNodeCont
The node container to fill.
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
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's lanes.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Describes a pedestrian crossing.
connectio between two lanes
Position intersectionPosition2D(const Position &p1, const Position &p2, const double withinDist=0.) const
Returns the position of the intersection.
double maxSpeed
The maximum velocity allowed on this lane.
const double SUMO_const_laneWidth
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
The representation of a single edge during network building.
A connection description.
foe visibility distance of a link
std::vector< std::string > response
static void setLoaded(const GeoConvHelper &loaded)
sets the coordinate transformation loaded from a location element
link,node: the traffic light id responsible for this link
static const double UNSPECIFIED_OFFSET
unspecified lane offset
static const SUMOTime UNSPECIFIED_DURATION
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
void setLoadedLength(double val)
set loaded lenght
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
double width
The width of this lane.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
bool myAmLefthand
whether the loaded network was built for lefthand traffic
const double SUMO_const_laneOffset
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static NBLoadedSUMOTLDef * initTrafficLightLogic(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
begins the reading of a traffic lights logic
maximum duration of a phase
const std::string & getID() const
Returns the id.
static StringBijection< LinkState > LinkStates
link states
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
Lane & getLaneStruct(int lane)
void setCustomShape(const PositionVector &shape)
set the junction shape
SAX-handler base for SUMO-files.
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.
NIImporter_SUMO(NBNetBuilder &nb)
Constructor.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
Describes custom shape for a walking area during parsing.
static const double UNSPECIFIED_WIDTH
unspecified lane width
virtual SumoXMLEdgeFunc getEdgeFunc(bool &ok) const =0
Returns the value of the named attribute.
A class that stores a 2D geometrical boundary.
prohibition of circulation between two edges
#define WRITE_WARNING(msg)
Describes the values found in a lane's definition.
The connection was computed and validated.
LaneAttrs * getLaneAttrsFromID(EdgeAttrs *edge, std::string lane_id)
Parses lane index from lane ID an retrieve lane from EdgeAttrs.
static OptionsCont & getOptions()
Retrieves the options.
void setLaneShape(int lane, const PositionVector &shape)
sets a custom lane shape
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
std::string toEdgeID
The id of the target edge.
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
static const double UNSPECIFIED_SPEED
unspecified lane speed
int tlLinkNo
The index of this connection within the controlling traffic light.
double maxSpeed
The maximum velocity allowed on this 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's definition stored in "myCurrentLane".
void setRadius(double radius)
set the turning radius
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
std::string toNode
The node this edge ends at.
The turning radius at an intersection in m.
Describes the values found in an edge's definition and this edge's lanes.
void setFileName(const std::string &name)
Sets the current file name.
bool hasLaneSpecificWidth() const
whether lanes differ in width
std::set< NBEdge * > EdgeSet
container for unique edges
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.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
static methods for processing the coordinates conversion for the current net
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
std::vector< std::string > crossingEdges
void updateParameter(const std::map< std::string, std::string > &mapArg)
Adds or updates all given parameters from the map.
std::string allow
This lane's allowed vehicle classes.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file) ...
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.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
std::string getLaneID(int lane) const
get Lane ID (Secure)
Describes the values found in a prohibition.
A point in 2D or 3D with translation and scaling methods.
Importer for networks stored in SUMO format.
parameter associated to a certain key
std::string tlID
The id of the traffic light that controls this connection.
NBEdgeCont & getEdgeCont()
EdgeAttrs * myCurrentEdge
The currently parsed edge's definition (to add loaded lanes to)
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
void addConnection(NBEdge *from, NBEdge *to, int fromLane, int toLane, int linkIndex, bool reconstruct=true)
Adds a connection and immediately informs the edges.
void haveLoadedNetworkWithoutInternalEdges()
notify about style of loaded network (Without internal edges
double visibility
custom foe visibility for connection
LaneSpreadFunction lsf
The lane spread function.
bool customShape
Whether this lane has a custom shape.
std::string prohibitorFrom
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
T get(const std::string &str) const
bool hasConnectionTo(NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
std::string prohibitedFrom
roundabout defined in junction
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
double length
The length of the edge if set explicitly.
#define PROGRESS_BEGIN_MESSAGE(msg)
std::string disallow
This lane's disallowed vehicle classes.
edge: the shape in xml-definition
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
double getEndOffset() const
Returns the offset to the destination node.
double speed
custom speed for connection
const std::string & getProgramID() const
Returns the ProgramID.
begin/end of the description of a neighboring lane
NBEdge * builtEdge
The built edge.
virtual SumoXMLNodeType getNodeType(bool &ok) const =0
Returns the value of the named attribute.
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's function.
std::string oppositeID
This lane's opposite lane.
void _loadNetwork(OptionsCont &oc)
load the network
description of a logic request within the junction
void addCrossing(EdgeVector edges, double width, bool priority, int tlIndex=-1, const PositionVector &customShape=PositionVector::EMPTY, bool fromSumoNet=false)
add a pedestrian crossing to this node
begin/end of the description of an edge
bool keepClear
Whether the junction must be kept clear coming from this connection.
std::vector< std::string > intLanes
double endOffset
This lane's offset from the intersection.
std::string streetName
This edge's street name.
static void loadNetwork(OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given SUMO file.
virtual std::vector< std::string > getStringVector(int attr) const =0
Tries to read given attribute assuming it is a string vector.
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
void addWalkingAreaShape(EdgeVector edges, const PositionVector &shape)
add custom shape for walkingArea
double getLaneWidth() const
Returns the default width of lanes of this edge.
Importer for edge type information stored in XML.
void extrapolate(const double val, const bool onlyFirst=false, const bool onlyLast=false)
extrapolate position vector
virtual double getFloat(int id) const =0
Returns the double-value of the named (by its enum-value) attribute.
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.
std::vector< Connection > connections
This lane's connections.
void addJunction(const SUMOSAXAttributes &attrs)
Parses a junction and saves it in the node control.
std::string type
This edge's type.
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, const PositionVector &customShape=PositionVector::EMPTY)
Adds a connection between the specified this edge's lane and an approached one.
std::string oppositeID
An opposite lane ID, if given.
the edges crossed by a pedestrian crossing
double contPos
custom position for internal junction on this connection
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
Instance responsible for building networks.
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, int &index)
parses edge-id and index from lane-id
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
int myCornerDetail
the level of corner detail in the loaded network
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
const std::map< std::string, std::string > & getMap() const
Returns the inner key/value map.
static Position sideOffset(const Position &beg, const Position &end, const double amount)
get a side position of position vector using a offset
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
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)
int priority
This edge's priority.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
std::string id
This edge's id.
PositionVector customShape
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
void myEndElement(int element)
Called when a closing tag occurs.
This is an uncontrolled, major link, may pass.
std::string fromNode
The node this edge starts at.
void ignore(std::string id)
mark the given edge id as ignored
void declareConnectionsAsLoaded(EdgeBuildingStep step=LANES2LANES_USER)
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
const Position & getPosition() const
Represents a single node (junction) during network building.
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.
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
PositionVector shape
This lane's shape (needed to reconstruct edge shape for legacy networks)
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
add shorted link FOES
link: the index of the link within the traffic light
NBTrafficLightLogicCont & myTLLCont
The node container to fill.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
#define PROGRESS_DONE_MESSAGE()
std::map< std::string, WalkingAreaParsedCustomShape > myWACustomShapes
Map from walkingArea edge IDs to custom shapes.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
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)
NBNode * getToNode() const
Returns the destination node of the edge.
int toLaneIdx
The index of the target lane.
a single phase description
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.