 |
Eclipse SUMO - Simulation of Urban MObility
|
Go to the documentation of this file.
19 #ifndef NIImporter_SUMO_h
20 #define NIImporter_SUMO_h
std::vector< std::string > response
std::map< std::string, WalkingAreaParsedCustomShape > myWACustomShapes
Map from walkingArea edge IDs to custom shapes.
double distance
The position at the start of this edge (kilometrage/mileage)
An upper class for objects with additional parameters.
std::set< std::string > myRailSignals
list of node id with rail signals (no NBTrafficLightDefinition exists)
static void addPhase(const SUMOSAXAttributes &attrs, NBLoadedSUMOTLDef *currentTL)
adds a phase to the traffic lights logic currently build
Describes custom shape for a walking area during parsing.
std::string id
This edge's id.
Importer for networks stored in SUMO format.
SAX-handler base for SUMO-files.
Instance responsible for building networks.
std::vector< Prohibition > myProhibitions
Loaded prohibitions.
A container for traffic light definitions and built programs.
std::map< SVCPermissions, double > stopOffsets
This edge's vehicle specific stop offsets (used for lanes, that do not have a specified stopOffset)
SumoXMLEdgeFunc func
This edge's function.
std::vector< std::string > toEdges
std::vector< std::string > fromCrossed
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
LaneAttrs * myCurrentLane
The currently parsed lanes's definition (to add the shape to)
PositionVector customShape
double contPos
custom position for internal junction on this connection
LaneAttrs * getLaneAttrsFromID(EdgeAttrs *edge, std::string lane_id)
Parses lane index from lane ID an retrieve lane from EdgeAttrs.
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
int priority
This edge's priority.
NIImporter_SUMO(NBNetBuilder &nb)
Constructor.
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
bool myCheckLaneFoesRoundabout
A connection description.
static methods for processing the coordinates conversion for the current net
double myLimitTurnSpeed
whether turning speed was limited in the network
Crossing(const std::string &_edgeID)
Describes the values found in a junction.
std::vector< std::string > fromEdges
Container for nodes during the netbuilding process.
Describes the values found in a lane's definition.
void addStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
parses stop offsets for the current lane or edge
double speed
custom speed for connection
std::string type
the type of this lane
std::vector< Parameterised * > myLastParameterised
element to receive parameters
bool customShape
Whether this lane has a custom shape.
The representation of a single edge during network building.
std::vector< std::string > toCrossed
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
double width
The width of this lane.
NBEdge * builtEdge
The built edge.
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and stores the values in "myCurrentLane".
void parseProhibitionConnection(const std::string &attr, std::string &from, std::string &to, bool &ok)
parses connection string of a prohibition (very old school)
std::vector< std::vector< std::string > > myRoundabouts
loaded roundabout edges
bool keepClear
Whether the junction must be kept clear coming from this connection.
JunctionAttrs myCurrentJunction
The currently parsed junction definition to help in reconstructing crossings.
std::map< SVCPermissions, double > stopOffsets
This lane's vehicle specific stop offsets.
int tlLinkIndex
The index of this connection within the controlling traffic light.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
double visibility
custom foe visibility for connection
std::string oppositeID
This lane's opposite lane.
bool myRectLaneCut
whether all lanes of an edge should have the same stop line
std::string allow
This lane's allowed vehicle classes.
NBNetBuilder & myNetBuilder
The network builder to fill.
std::string disallow
This lane's disallowed vehicle classes.
double endOffset
This lane's offset from the intersection.
NIXMLTypesHandler myTypesHandler
The handler for parsing edge types and restrictions.
Describes the values found in an edge's definition and this edge's lanes.
void _loadNetwork(OptionsCont &oc)
load the network
Importer for edge type information stored in XML.
int myLinkDetail
the level of geometry detail for internal lanes in the loaded network
static GeoConvHelper * loadLocation(const SUMOSAXAttributes &attrs)
Parses network location description and registers it with GeoConveHelper::setLoaded.
A point in 2D or 3D with translation and scaling methods.
EdgeAttrs * myCurrentEdge
The currently parsed edge's definition (to add loaded lanes to)
PositionVector shape
This edges's shape.
PositionVector customShape
custom shape connection
std::string prohibitorFrom
void addConnection(const SUMOSAXAttributes &attrs)
Parses a connection and saves it into the lane's definition stored in "myCurrentLane".
A storage for options typed value containers)
bool uncontrolled
if set to true, This connection will not be TLS-controlled despite its node being controlled.
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
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...
static void loadNetwork(OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given SUMO file.
std::string streetName
This edge's street name.
std::map< std::string, std::vector< Crossing > > myPedestrianCrossings
The pedestrian crossings found in the network.
Describes a pedestrian crossing.
std::string type
This edge's type.
std::string toEdgeID
The id of the target edge.
int toLaneIdx
The index of the target lane.
std::string toNode
The node this edge ends at.
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
std::string tlID
The id of the traffic light that controls this connection.
void addJunction(const SUMOSAXAttributes &attrs)
Parses a junction and saves it in the node control.
double myNetworkVersion
the loaded network version
~NIImporter_SUMO()
Destructor.
NBTrafficLightLogicCont & myTLLCont
The node container to fill.
std::string prohibitedFrom
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
double maxSpeed
The maximum velocity allowed on this lane.
bool myWalkingAreas
whether walkingareas must be built
LaneSpreadFunction lsf
The lane spread function.
double maxSpeed
The maximum velocity allowed on this edge (!!!)
std::vector< std::string > crossingEdges
std::string fromNode
The node this edge starts at.
Represents a single node (junction) during network building.
std::vector< LaneAttrs * > lanes
This edge's lanes.
bool myCheckLaneFoesAll
whether foe-relationships where checked at lane-level
void addRequest(const SUMOSAXAttributes &attrs)
Parses a reques and saves selected attributes in myCurrentJunction.
int myCornerDetail
the level of corner detail in the loaded network
std::vector< Connection > connections
This lane's connections.
NBLoadedSUMOTLDef * myCurrentTL
The currently parsed traffic light.
double length
The length of the edge if set explicitly.
Encapsulated SAX-Attributes.
void myEndElement(int element)
Called when a closing tag occurs.
PositionVector shape
This lane's shape (needed to reconstruct edge shape for legacy networks)
static Position readPosition(const SUMOSAXAttributes &attrs, const std::string &id, bool &ok)
read position from the given attributes, attribute errors to id
void addProhibition(const SUMOSAXAttributes &attrs)
Parses a prohibition and saves it.
std::map< std::string, EdgeAttrs * > myEdges
Loaded edge definitions.
NBNodeCont & myNodeCont
The node container to fill.
std::vector< std::string > intLanes
GeoConvHelper * myLocation
The coordinate transformation which was used to build the loaded network.
bool accelRamp
Whether this lane is an acceleration lane.
Describes the values found in a prohibition.
A loaded (complete) traffic light logic.