56 #ifdef CHECK_MEMORY_LEAKS 58 #endif // CHECK_MEMORY_LEAKS 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) {
143 if (ed->
shape.size() > 0) {
153 (
unsigned int) ed->
lanes.size(),
165 for (std::map<std::string, EdgeAttrs*>::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
171 for (
unsigned int fromLaneIndex = 0; fromLaneIndex < (
unsigned int) ed->
lanes.size(); ++fromLaneIndex) {
174 const std::vector<Connection>& connections = lane->
connections;
175 for (std::vector<Connection>::const_iterator c_it = connections.begin(); c_it != connections.end(); c_it++) {
195 if (programs.size() > 0) {
196 std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
197 for (it = programs.begin(); it != programs.end(); it++) {
202 throw ProcessError(
"Corrupt traffic light definition '" + c.
tlID +
"' (program '" + it->first +
"')");
227 NBEdge* prohibitedFrom =
myEdges[it->prohibitedFrom]->builtEdge;
229 NBEdge* prohibitorFrom =
myEdges[it->prohibitorFrom]->builtEdge;
231 if (prohibitedFrom == 0) {
232 WRITE_WARNING(
"Edge '" + it->prohibitedFrom +
"' in prohibition was not built");
233 }
else if (prohibitedTo == 0) {
234 WRITE_WARNING(
"Edge '" + it->prohibitedTo +
"' in prohibition was not built");
235 }
else if (prohibitorFrom == 0) {
236 WRITE_WARNING(
"Edge '" + it->prohibitorFrom +
"' in prohibition was not built");
237 }
else if (prohibitorTo == 0) {
238 WRITE_WARNING(
"Edge '" + it->prohibitorTo +
"' in prohibition was not built");
252 if (oc.
isDefault(
"junctions.corner-detail")) {
263 if (!oc.
getBool(
"no-internal-links")) {
266 for (std::vector<Crossing>::const_iterator it_c = (*it).second.begin(); it_c != (*it).second.end(); ++it_c) {
269 for (std::vector<std::string>::const_iterator it_e = crossing.
crossingEdges.begin(); it_e != crossing.
crossingEdges.end(); ++it_e) {
273 edges.push_back(edge);
276 if (edges.size() > 0) {
285 for (std::vector<std::string>::const_iterator it_r = it->begin(); it_r != it->end(); ++it_r) {
289 WRITE_ERROR(
"Unknown edge '" + (*it_r) +
"' in roundabout");
292 roundabout.insert(edge);
382 WRITE_ERROR(
"Unmatched closing tag for tl-logic.");
441 WRITE_ERROR(
"Unknown spreadType '" + lsfS +
"' for edge '" +
id +
"'.");
454 WRITE_ERROR(
"Found lane '" +
id +
"' not within edge element");
465 assert(crossings.size() > 0);
474 myCurrentLane->maxSpeed = attrs.
getFloat(
"maxspeed");
482 myCurrentLane->allow =
"";
515 WRITE_WARNING(
"Unknown node type for junction '" +
id +
"'.");
521 WRITE_ERROR(
"Problems on adding junction '" +
id +
"'.");
537 for (NBNode::CustomShapeMap::const_iterator it = customShapes.begin(); it != customShapes.end(); ++it) {
561 if (
myEdges.count(fromID) == 0) {
562 WRITE_ERROR(
"Unknown edge '" + fromID +
"' given in connection.");
574 if (conn.
tlID !=
"") {
577 if (from->
lanes.size() <= (size_t) fromLaneIdx) {
578 WRITE_ERROR(
"Invalid lane index '" +
toString(fromLaneIdx) +
"' for connection from '" + fromID +
"'.");
581 from->
lanes[fromLaneIdx]->connections.push_back(conn);
588 for (std::vector<Crossing>::iterator it = crossings.begin(); it != crossings.end(); ++it) {
589 if (conn.
toEdgeID == (*it).edgeID) {
590 if (conn.
tlID !=
"") {
591 (*it).priority =
true;
625 assert(edge->
id == edge_id);
626 if (edge->
lanes.size() <= (size_t) index) {
627 WRITE_ERROR(
"Unknown lane '" + lane_id +
"' given in succedge.");
630 return edge->
lanes[index];
638 size_t sep_index = lane_id.rfind(
'_');
639 if (sep_index == std::string::npos) {
640 WRITE_ERROR(
"Invalid lane id '" + lane_id +
"' (missing '_').");
642 edge_id = lane_id.substr(0, sep_index);
643 std::string index_string = lane_id.substr(sep_index + 1);
647 WRITE_ERROR(
"Invalid lane index '" + index_string +
"' for lane '" + lane_id +
"'.");
655 WRITE_ERROR(
"Definition of tl-logic '" + currentTL->
getID() +
"' was not finished.");
667 WRITE_ERROR(
"Unknown traffic light type '" + typeS +
"' for tlLogic '" +
id +
"'.");
684 const std::string&
id = currentTL->
getID();
697 currentTL->
addPhase(duration, state);
706 result.push_back(from);
710 const size_t noLanes = edge->
lanes.size();
717 for (
unsigned int i = 1; i < firstLane.size() - 1; i++) {
718 const Position& from = firstLane[i - 1];
720 const Position& to = firstLane[i + 1];
731 WRITE_WARNING(
"Could not reconstruct shape for edge '" + edge->
id +
"'.");
735 result.push_back(to);
751 result =
new GeoConvHelper(proj, networkOffset, origBoundary, convBoundary);
773 size_t div = attr.find(
"->");
774 if (div == std::string::npos) {
775 WRITE_ERROR(
"Missing connection divider in prohibition attribute '" + attr +
"'");
778 from = attr.substr(0, div);
779 to = attr.substr(div + 2);
781 if (from.find(
'_') != std::string::npos) {
782 from = from.substr(0, from.find(
'_'));
784 if (to.find(
'_') != std::string::npos) {
785 to = to.substr(0, to.find(
'_'));
788 if (
myEdges.count(from) == 0) {
789 WRITE_ERROR(
"Unknown edge prohibition '" + from +
"'");
793 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)
bool hasConnectionTo(NBEdge *destEdge, unsigned int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
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()
A connection description.
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
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS)
Adds a connection between the specified this edge's lane and an approached one.
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
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.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
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 insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string getLaneID(unsigned int lane) const
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
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.
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.
unsigned int tlLinkNo
The index of this connection within the controlling traffic light.
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)
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.
void _loadNetwork(OptionsCont &oc)
load the network
SUMOReal width
The width of this lane.
SUMOReal getEndOffset() const
Returns the offset to the destination node.
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, unsigned int &index)
parses edge-id and index from lane-id
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)
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.
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.
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.
unsigned int toLaneIdx
The index of the target lane.
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
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.
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.
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.
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()
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
NBLoadedSUMOTLDef * myCurrentTL
The currently parsed traffic light.
std::set< std::string > myRailSignals
list of node id with rail signals (no NBTrafficLightDefinition exists)
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)
static std::string getNodeIDFromInternalLane(const std::string id)
returns the node id for internal lanes, crossings and walkingareas