56 #ifdef CHECK_MEMORY_LEAKS
58 #endif // CHECK_MEMORY_LEAKS
80 myNodeCont(nb.getNodeCont()),
81 myTLLCont(nb.getTLLogicCont()),
86 myHaveSeenInternalEdge(false),
94 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
96 for (std::vector<LaneAttrs*>::const_iterator j = ed->
lanes.begin(); j != ed->
lanes.end(); ++j) {
113 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
115 WRITE_ERROR(
"Could not open sumo-net-file '" + *file +
"'.");
124 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
142 WRITE_ERROR(
"Edge's '" + ed->
id +
"' from-node and to-node '" + ed->
toNode +
"' art identical.");
147 if (ed->
shape.size() > 0) {
157 (
int) ed->
lanes.size(),
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 +
"')");
233 toRemove.push_back(nbe);
236 for (EdgeVector::iterator i = toRemove.begin(); i != toRemove.end(); ++i) {
241 NBEdge* prohibitedFrom =
myEdges[it->prohibitedFrom]->builtEdge;
243 NBEdge* prohibitorFrom =
myEdges[it->prohibitorFrom]->builtEdge;
245 if (prohibitedFrom == 0) {
246 WRITE_WARNING(
"Edge '" + it->prohibitedFrom +
"' in prohibition was not built");
247 }
else if (prohibitedTo == 0) {
248 WRITE_WARNING(
"Edge '" + it->prohibitedTo +
"' in prohibition was not built");
249 }
else if (prohibitorFrom == 0) {
250 WRITE_WARNING(
"Edge '" + it->prohibitorFrom +
"' in prohibition was not built");
251 }
else if (prohibitorTo == 0) {
252 WRITE_WARNING(
"Edge '" + it->prohibitorTo +
"' in prohibition was not built");
266 if (oc.
isDefault(
"junctions.corner-detail")) {
277 if (!oc.
getBool(
"no-internal-links")) {
280 for (std::vector<Crossing>::const_iterator it_c = (*it).second.begin(); it_c != (*it).second.end(); ++it_c) {
283 for (std::vector<std::string>::const_iterator it_e = crossing.
crossingEdges.begin(); it_e != crossing.
crossingEdges.end(); ++it_e) {
287 edges.push_back(edge);
290 if (edges.size() > 0) {
299 for (std::vector<std::string>::const_iterator it_r = it->begin(); it_r != it->end(); ++it_r) {
303 WRITE_ERROR(
"Unknown edge '" + (*it_r) +
"' in roundabout");
306 roundabout.insert(edge);
399 WRITE_ERROR(
"Unmatched closing tag for tl-logic.");
458 WRITE_ERROR(
"Unknown spreadType '" + lsfS +
"' for edge '" +
id +
"'.");
471 WRITE_ERROR(
"Found lane '" +
id +
"' not within edge element");
482 assert(crossings.size() > 0);
532 WRITE_WARNING(
"Unknown node type for junction '" +
id +
"'.");
538 WRITE_ERROR(
"Problems on adding junction '" +
id +
"'.");
554 for (NBNode::CustomShapeMap::const_iterator it = customShapes.begin(); it != customShapes.end(); ++it) {
578 if (
myEdges.count(fromID) == 0) {
579 WRITE_ERROR(
"Unknown edge '" + fromID +
"' given in connection.");
592 if (conn.
tlID !=
"") {
595 if ((
int)from->
lanes.size() <= fromLaneIdx) {
596 WRITE_ERROR(
"Invalid lane index '" +
toString(fromLaneIdx) +
"' for connection from '" + fromID +
"'.");
599 from->
lanes[fromLaneIdx]->connections.push_back(conn);
606 for (std::vector<Crossing>::iterator it = crossings.begin(); it != crossings.end(); ++it) {
607 if (conn.
toEdgeID == (*it).edgeID) {
608 if (conn.
tlID !=
"") {
609 (*it).priority =
true;
643 assert(edge->
id == edge_id);
644 if ((
int)edge->
lanes.size() <= index) {
645 WRITE_ERROR(
"Unknown lane '" + lane_id +
"' given in succedge.");
648 return edge->
lanes[index];
656 const std::string::size_type sep_index = lane_id.rfind(
'_');
657 if (sep_index == std::string::npos) {
658 WRITE_ERROR(
"Invalid lane id '" + lane_id +
"' (missing '_').");
660 edge_id = lane_id.substr(0, sep_index);
661 std::string index_string = lane_id.substr(sep_index + 1);
665 WRITE_ERROR(
"Invalid lane index '" + index_string +
"' for lane '" + lane_id +
"'.");
673 WRITE_ERROR(
"Definition of tl-logic '" + currentTL->
getID() +
"' was not finished.");
685 WRITE_ERROR(
"Unknown traffic light type '" + typeS +
"' for tlLogic '" +
id +
"'.");
702 const std::string&
id = currentTL->
getID();
715 currentTL->
addPhase(duration, state);
724 result.push_back(from);
728 const int noLanes = (int)edge->
lanes.size();
735 for (
int i = 1; i < (int)firstLane.size() - 1; i++) {
736 const Position& from = firstLane[i - 1];
738 const Position& to = firstLane[i + 1];
749 WRITE_WARNING(
"Could not reconstruct shape for edge '" + edge->
id +
"'.");
753 result.push_back(to);
769 result =
new GeoConvHelper(proj, networkOffset, origBoundary, convBoundary);
791 const std::string::size_type div = attr.find(
"->");
792 if (div == std::string::npos) {
793 WRITE_ERROR(
"Missing connection divider in prohibition attribute '" + attr +
"'");
796 from = attr.substr(0, div);
797 to = attr.substr(div + 2);
799 if (from.find(
'_') != std::string::npos) {
800 from = from.substr(0, from.find(
'_'));
802 if (to.find(
'_') != std::string::npos) {
803 to = to.substr(0, to.find(
'_'));
806 if (
myEdges.count(from) == 0) {
807 WRITE_ERROR(
"Unknown edge prohibition '" + from +
"'");
811 WRITE_ERROR(
"Unknown edge prohibition '" + to +
"'");
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.
static Position sideOffset(const Position &beg, const Position &end, const SUMOReal amount)
get a side position of position vector using a offset
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) ...
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
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
std::set< std::string > deprecatedVehicleClassesSeen
Whether vehicles must keep the junction clear.
const SUMOReal SUMO_const_laneWidth
whether a given shape is user-defined
static bool transformCoordinates(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
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".
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
SUMOReal maxSpeed
The maximum velocity allowed on this lane.
A loaded (complete) traffic light logic.
std::vector< LaneAttrs * > lanes
This edge's lanes.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
void setLaneWidth(int lane, SUMOReal width)
set lane specific width (negative lane implies set for all lanes)
void setSpeed(int lane, SUMOReal speed)
set lane specific speed (negative lane implies set for all lanes)
Describes a pedestrian crossing.
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea ...
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getProgramID() const
Returns the ProgramID.
The representation of a single edge during network building.
void declareConnectionsAsLoaded()
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
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
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
SUMOReal getLaneWidth() const
Returns the default width of lanes of this edge.
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
bool myAmLefthand
whether the loaded network was built for lefthand traffic
static NBLoadedSUMOTLDef * initTrafficLightLogic(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
begins the reading of a traffic lights logic
static const SUMOReal UNSPECIFIED_CONTPOS
unspecified internal junction position
const SUMOReal SUMO_const_laneOffset
static StringBijection< LinkState > LinkStates
SUMOReal contPos
custom position for internal junction on this connection
Lane & getLaneStruct(int lane)
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
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...
virtual SumoXMLEdgeFunc getEdgeFunc(bool &ok) const =0
Returns the value of the named attribute.
A class that stores a 2D geometrical boundary.
#define WRITE_WARNING(msg)
std::map< std::string, NBNode::CustomShapeMap > myCustomShapeMaps
customLaneShape (cannot be added to the NBNode when parsed since the node doesn't yet exist ...
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.
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
int tlLinkNo
The index of this connection within the controlling traffic light.
std::map< std::string, PositionVector > CustomShapeMap
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and stores the values in "myCurrentLane".
NBNetBuilder & myNetBuilder
The network builder to fill.
const std::string & getID() const
Returns the id.
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".
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.
const Position & getPosition() const
Returns the position of this node.
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.
std::set< NBEdge * > EdgeSet
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.
static methods for processing the coordinates conversion for the current net
bool hasConnectionTo(NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::vector< std::string > crossingEdges
std::string allow
This lane's allowed vehicle classes.
Encapsulated SAX-Attributes.
void setRadius(SUMOReal radius)
set the turning radius
static GeoConvHelper * loadLocation(const SUMOSAXAttributes &attrs)
Parses network location description and registers it with GeoConveHelper::setLoaded.
static StringBijection< TrafficLightType > TrafficLightTypes
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.
std::string tlID
The id of the traffic light that controls this connection.
NBEdgeCont & getEdgeCont()
Returns the edge container.
EdgeAttrs * myCurrentEdge
The currently parsed edge's definition (to add loaded lanes to)
virtual SUMOReal getFloat(int id) const =0
Returns the SUMOReal-value of the named (by its enum-value) attribute.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file) ...
void parseProhibitionConnection(const std::string &attr, std::string &from, std::string &to, bool &ok)
parses connection string of a prohibition (very old school)
void haveLoadedNetworkWithoutInternalEdges()
notify about style of loaded network
static const SUMOReal UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
LaneSpreadFunction lsf
The lane spread function.
std::string prohibitorFrom
const std::map< std::string, NBTrafficLightDefinition * > & getPrograms(const std::string &id) const
Returns all programs for the given tl-id.
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.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
std::string prohibitedFrom
void setCustomLaneShape(const std::string &laneID, const PositionVector &shape)
sets a custom shape for an internal lane
#define PROGRESS_BEGIN_MESSAGE(msg)
std::string disallow
This lane's disallowed vehicle classes.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
void setLoadedLength(SUMOReal val)
set loaded lenght
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
SUMOReal width
The width of this lane.
SUMOReal getEndOffset() const
Returns the offset to the destination node.
bool keepClear
Whether the junction must be kept clear coming from this connection.
std::vector< std::string > intLanes
SUMOReal 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.
SUMOReal maxSpeed
The maximum velocity allowed on this edge (!!!)
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)
static int _2int(const E *const data)
converts a char-type array into the integer value described by it
NBNode * getToNode() const
Returns the destination node of the edge.
std::vector< Connection > connections
This lane's connections.
void addJunction(const SUMOSAXAttributes &attrs)
Parses a junction and saves it in the node control.
void addCrossing(EdgeVector edges, SUMOReal width, bool priority, bool fromSumoNet=false)
add a pedestrian crossing to this node
std::string type
This edge's type.
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, int &index)
parses edge-id and index from lane-id
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
std::string oppositeID
An opposite lane ID, if given.
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
Instance responsible for building networks.
void addPhase(SUMOTime duration, const std::string &state)
Adds a phase to the logic the new phase is inserted at the end of the list of already added phases...
std::vector< NBEdge * > EdgeVector
int myCornerDetail
the level of corner detail in the loaded network
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.
Position intersectionPosition2D(const Position &p1, const Position &p2, const SUMOReal withinDist=0.) const
Returns the position of the intersection.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
std::string id
This edge's id.
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
Represents a single node (junction) during network building.
T get(const std::string &str) const
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)
bool hasLaneSpecificWidth() const
whether lanes differ in width
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
void setEndOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
NBTrafficLightLogicCont & myTLLCont
The node container to fill.
std::string getLaneID(int lane) const
get Lane ID (Secure)
SUMOReal length
The length of the edge if set explicitly.
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.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
#define PROGRESS_DONE_MESSAGE()
SUMOReal visibility
custom foe visibility for connection
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
NBDistrictCont & getDistrictCont()
Returns the districts container.
NBLoadedSUMOTLDef * myCurrentTL
The currently parsed traffic light.
std::set< std::string > myRailSignals
list of node id with rail signals (no NBTrafficLightDefinition exists)
int toLaneIdx
The index of the target lane.
void addConnection(NBEdge *from, NBEdge *to, int fromLane, int toLane, int linkIndex)
Adds a connection and immediately informs the edges.
void extrapolate(const SUMOReal val, const bool onlyFirst=false)
extrapolate position vector
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
static std::string getNodeIDFromInternalLane(const std::string id)
returns the node id for internal lanes, crossings and walkingareas