57 if (!oc.
isSet(
"output-file")) {
61 std::map<SumoXMLAttr, std::string> attrs;
65 }
else if (oc.
getBool(
"lefthand")) {
70 const int cornerDetail = oc.
getInt(
"junctions.corner-detail");
71 if (cornerDetail > 0) {
74 if (!oc.
isDefault(
"junctions.internal-link-detail")) {
77 if (oc.
getBool(
"rectangular-lane-cut")) {
83 if (oc.
getFloat(
"junctions.limit-turn-speed") > 0) {
86 if (!oc.
isDefault(
"check-lane-foes.all")) {
89 if (!oc.
isDefault(
"check-lane-foes.roundabout")) {
92 if (!oc.
isDefault(
"tls.ignore-internal-junction-jam")) {
95 if (oc.
getString(
"default.spreadtype") !=
"right") {
98 if (oc.
exists(
"geometry.avoid-overlap") && !oc.
getBool(
"geometry.avoid-overlap")) {
101 if (oc.
exists(
"junctions.higher-speed") && oc.
getBool(
"junctions.higher-speed")) {
104 if (oc.
exists(
"internal-junctions.vehicle-width") && !oc.
isDefault(
"internal-junctions.vehicle-width")) {
121 if (!oc.
getBool(
"no-internal-links")) {
123 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
132 bool noNames = !oc.
getBool(
"output.street-names");
133 for (std::map<std::string, NBEdge*>::const_iterator i = ec.
begin(); i != ec.
end(); ++i) {
134 writeEdge(device, *(*i).second, noNames);
142 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
146 const bool includeInternal = !oc.
getBool(
"no-internal-links");
147 if (includeInternal) {
150 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
159 int numConnections = 0;
160 for (std::map<std::string, NBEdge*>::const_iterator it_edge = ec.
begin(); it_edge != ec.
end(); it_edge++) {
161 NBEdge* from = it_edge->second;
162 const std::vector<NBEdge::Connection> connections = from->
getConnections();
163 numConnections += (int)connections.size();
164 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
168 if (numConnections > 0) {
171 if (includeInternal) {
174 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
181 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
182 NBNode* node = (*i).second;
184 std::vector<NBNode::Crossing*> crossings = node->
getCrossings();
185 for (
auto c : crossings) {
190 for (
const std::string& cID : wa.nextCrossings) {
198 if (nextCrossing.
tlID !=
"") {
210 for (
const std::string& sw : wa.nextSidewalks) {
214 for (
const std::string& sw : wa.prevSidewalks) {
222 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
231 WRITE_WARNING(
"Embedding TAZ-data inside the network is deprecated. Use option --taz-output instead");
232 for (std::map<std::string, NBDistrict*>::const_iterator i = dc.
begin(); i != dc.
end(); i++) {
247 #ifdef DEBUG_OPPOSITE_INTERNAL
253 assert(succOpp != 0);
254 assert(predOpp != 0);
255 const std::vector<NBEdge::Connection>& connections = succOpp->
getConnections();
256 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
259 && predOpp == conOpp.
toEdge
265 #ifdef DEBUG_OPPOSITE_INTERNAL
268 oppositeLength = conOpp.
length;
299 std::map<std::string, std::string> oppositeLaneID;
300 std::map<std::string, double> oppositeLengths;
301 for (
NBEdge* e : incoming) {
303 double oppositeLength = 0;
305 oppositeLaneID[c.getInternalLaneID()] = op;
307 oppositeLengths[c.id] = oppositeLength;
311 if (oppositeLengths.size() > 0) {
312 for (
NBEdge* e : incoming) {
314 if (oppositeLengths.count(c.id) > 0) {
315 c.length = (c.length + oppositeLengths[c.id]) / 2;
321 for (
NBEdge* e : incoming) {
322 const std::vector<NBEdge::Connection>& elv = e->getConnections();
323 if (elv.size() > 0) {
324 bool haveVia =
false;
325 std::string edgeID =
"";
328 if (k.toEdge ==
nullptr) {
332 if (edgeID != k.id) {
341 if (k.edgeType !=
"") {
344 if (e->isBidiRail() && k.toEdge->isBidiRail() &&
345 e != k.toEdge->getTurnDestination(
true)) {
348 0, e->getTurnDestination(
true), 0);
351 WRITE_WARNINGF(
"Could not find bidi-connection for edge '%'", edgeID)
358 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
360 successor.
permissions & e->getPermissions(k.fromLane));
364 writeLane(into, k.getInternalLaneID(), k.vmax,
366 changeLeft, changeRight,
369 k.length, k.internalLaneIndex, oppositeLaneID[k.getInternalLaneID()],
"");
370 haveVia = haveVia || k.haveVia;
380 if (k.toEdge ==
nullptr) {
384 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
388 if (k.edgeType !=
"") {
392 successor.
permissions & e->getPermissions(k.fromLane));
397 MAX2(k.viaLength, POSITION_EPS),
413 MAX2(c->shape.length(), POSITION_EPS), 0,
"",
"",
false, c->customShape.size() != 0);
417 const std::vector<NBNode::WalkingArea>& WalkingAreas = n.
getWalkingAreas();
418 for (std::vector<NBNode::WalkingArea>::const_iterator it = WalkingAreas.begin(); it != WalkingAreas.end(); it++) {
469 const std::vector<NBEdge::Lane>& lanes = e.
getLanes();
473 for (
int i = 0; i < (int) lanes.size(); i++) {
496 double startOffset,
double endOffset,
499 const std::string& oppositeID,
500 const std::string& type,
501 bool accelRamp,
bool customShape) {
513 WRITE_WARNINGF(
"Lane '%' has a maximum allowed speed of 0.", lID);
514 }
else if (speed < 0) {
515 throw ProcessError(
"Negative allowed speed (" +
toString(speed) +
") on lane '" + lID +
"', use --speed.minimum to prevent this.");
531 if (endOffset > 0 || startOffset > 0) {
532 if (startOffset + endOffset < shape.
length()) {
556 if (oppositeID !=
"" && oppositeID !=
"-") {
562 if (params !=
nullptr) {
577 std::vector<std::string> incLanes;
579 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
580 int noLanes = (*i)->getNumLanes();
581 for (
int j = 0; j < noLanes; j++) {
582 incLanes.push_back((*i)->getLaneID(j));
585 std::vector<NBNode::Crossing*> crossings = n.
getCrossings();
586 std::set<std::string> prevWAs;
588 for (
auto c : crossings) {
589 if (prevWAs.count(c->prevWalkingArea) == 0) {
590 incLanes.push_back(c->prevWalkingArea +
"_0");
591 prevWAs.insert(c->prevWalkingArea);
596 std::vector<std::string> intLanes;
598 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
599 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
600 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
601 if ((*k).toEdge ==
nullptr) {
605 intLanes.push_back((*k).getInternalLaneID());
607 intLanes.push_back((*k).viaID +
"_0");
613 for (
auto c : crossings) {
614 intLanes.push_back(c->id +
"_0");
651 std::vector<std::string> internalLaneIDs;
652 std::map<std::string, std::string> viaIDs;
653 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
654 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
655 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
656 if ((*k).toEdge !=
nullptr) {
657 internalLaneIDs.push_back((*k).getInternalLaneID());
658 viaIDs[(*k).getInternalLaneID()] = ((*k).viaID);
663 internalLaneIDs.push_back(c->id +
"_0");
666 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
667 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
668 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
669 if ((*k).toEdge ==
nullptr || !(*k).haveVia) {
676 std::string incLanes = (*k).getInternalLaneID();
677 std::vector<std::string> foeIDs;
678 for (std::string incLane : (*k).foeIncomingLanes) {
679 if (incLane[0] ==
':') {
682 incLane = internalLaneIDs[index];
683 if (viaIDs[incLane] !=
"") {
684 foeIDs.push_back(viaIDs[incLane] +
"_0");
687 incLanes +=
" " + incLane;
690 const std::vector<int>& foes = (*k).foeInternalLinks;
691 for (std::vector<int>::const_iterator it = foes.begin(); it != foes.end(); ++it) {
692 foeIDs.push_back(internalLaneIDs[*it]);
756 if (style !=
PLAIN) {
757 if (includeInternal) {
802 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
804 const std::vector<NBEdge::Connection>& connections = from->
getConnections();
805 for (std::vector<NBEdge::Connection>::const_iterator j = connections.begin(); j != connections.end(); ++j) {
811 std::string tlID =
"";
817 writeInternalConnection(into, c.
id, c.
toEdge->
getID(), c.
internalLaneIndex, c.
toLane, c.
viaID +
"_0", dir, tlID, linkIndex2,
false, c.
visibility);
832 const std::string& from,
const std::string& to,
833 int fromLane,
int toLane,
const std::string& via,
835 const std::string& tlID,
int linkIndex,
864 std::vector<std::vector<std::string> > edgeIDs;
865 for (std::set<EdgeSet>::const_iterator i = roundabouts.begin(); i != roundabouts.end(); ++i) {
866 std::vector<std::string> tEdgeIDs;
867 for (EdgeSet::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
870 tEdgeIDs.push_back((*j)->getID());
872 std::sort(tEdgeIDs.begin(), tEdgeIDs.end());
873 edgeIDs.push_back(tEdgeIDs);
875 std::sort(edgeIDs.begin(), edgeIDs.end());
877 for (std::vector<std::vector<std::string> >::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
880 if (roundabouts.size() != 0) {
889 std::vector<std::string> validEdgeIDs;
890 std::vector<std::string> invalidEdgeIDs;
891 std::vector<std::string> nodeIDs;
892 for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
894 if (edge !=
nullptr) {
896 validEdgeIDs.push_back(edge->
getID());
898 invalidEdgeIDs.push_back(*i);
901 std::sort(nodeIDs.begin(), nodeIDs.end());
902 if (validEdgeIDs.size() > 0) {
907 if (invalidEdgeIDs.size() > 0) {
909 +
joinToString(invalidEdgeIDs,
" ") +
"' no longer exist'");
928 for (
int i = 0; i < (int)sources.size(); i++) {
935 for (
int i = 0; i < (int)sinks.size(); i++) {
948 if (time == std::floor(time)) {
958 for (NBConnectionProhibits::const_iterator j = prohibitions.begin(); j != prohibitions.end(); j++) {
961 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
980 std::vector<NBTrafficLightLogic*> logics = tllCont.
getComputed();
984 if (logics.size() > 0) {
1006 if (varPhaseLength) {
1014 if (phase.name !=
"") {
1017 if (phase.next.size() > 0) {
1032 if (ss_vclasses.length() == 0) {
1038 if (ss_vclasses.length() <= ss_exceptions.length()) {
1041 if (ss_exceptions.length() == 0) {
#define WRITE_WARNINGF(...)
#define WRITE_WARNING(msg)
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
std::vector< NBConnection > NBConnectionVector
Definition of a connection vector.
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
const SVCPermissions SVCAll
all VClasses are allowed
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_PHASE
a single phase description
@ SUMO_TAG_STOPOFFSET
Information on vClass specific stop offsets at lane end.
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
@ SUMO_TAG_PROHIBITION
prohibition of circulation between two edges
@ SUMO_TAG_CONNECTION
connectio between two lanes
@ SUMO_TAG_ROUNDABOUT
roundabout defined in junction
@ SUMO_TAG_TLLOGIC
a traffic light logic
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
@ SUMO_TAG_NEIGH
begin/end of the description of a neighboring lane
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
@ STRAIGHT
The link is a straight direction.
@ NODIR
The link has no direction (is a dead end link)
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_MAJOR
This is an uncontrolled, major link, may pass.
@ LINKSTATE_MINOR
This is an uncontrolled, minor link, has to brake.
@ SUMO_ATTR_NODES
a list of node ids, used for controlling joining
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
@ SUMO_ATTR_RADIUS
The turning radius at an intersection in m.
@ SUMO_ATTR_INDIRECT
Whether this connection is an indirect (left) turn.
@ SUMO_ATTR_RECTANGULAR_LANE_CUT
@ SUMO_ATTR_LIMIT_TURN_SPEED
@ SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT
@ SUMO_ATTR_AVOID_OVERLAP
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_FRINGE
Fringe type of node.
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_CHECKLANEFOES_ALL
@ SUMO_ATTR_SPREADTYPE
The information about how to spread the lanes from the given position.
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_MAXDURATION
maximum duration of a phase
@ SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
@ SUMO_ATTR_CROSSING_EDGES
the edges crossed by a pedestrian crossing
@ SUMO_ATTR_DIR
The abstract direction of a link.
@ SUMO_ATTR_TLS_IGNORE_INTERNAL_JUNCTION_JAM
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
@ SUMO_ATTR_INTERNAL_JUNCTIONS_VEHICLE_WIDTH
@ SUMO_ATTR_STATE
The state of a link.
const double NETWORK_VERSION
version for written networks and default version for loading
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static void writeLocation(OutputDevice &into)
writes the location element
NBEdge * getFrom() const
returns the from-edge (start of the connection)
static const int InvalidTlIndex
NBEdge * getTo() const
returns the to-edge (end of the connection)
A container for districts.
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin of the stored districts.
std::map< std::string, NBDistrict * >::const_iterator end() const
Returns the pointer to the end of the stored districts.
int size() const
Returns the number of districts inside the container.
A class representing a single district.
const std::vector< double > & getSourceWeights() const
Returns the weights of the sources.
const std::vector< double > & getSinkWeights() const
Returns the weights of the sinks.
const PositionVector & getShape() const
Returns the shape.
const std::vector< NBEdge * > & getSourceEdges() const
Returns the sources.
const std::vector< NBEdge * > & getSinkEdges() const
Returns the sinks.
Storage for edges, including some functionality operating on multiple edges.
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
The representation of a single edge during network building.
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
const std::string & getStreetName() const
Returns the street name of this edge.
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
bool hasLoadedLength() const
Returns whether a length was set explicitly.
const std::string & getID() const
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
NBNode * getToNode() const
Returns the destination node of the edge.
double getDistance() const
get distance
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
std::string getLaneID(int lane) const
get lane ID
static const double UNSPECIFIED_SPEED
unspecified lane speed
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
NBEdge * getTurnDestination(bool possibleDestination=false) const
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
int getPriority() const
Returns the priority of the edge.
static const double UNSPECIFIED_WIDTH
unspecified lane width
const std::vector< Connection > & getConnections() const
Returns the connections.
const std::string & getTypeID() const
get ID of type
double getEndOffset() const
Returns the offset to the destination node.
static const double UNSPECIFIED_OFFSET
unspecified lane offset
bool isMacroscopicConnector() const
Returns whether this edge was marked as a macroscopic connector.
Connection getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection This method goes through "myConnections" and returns the specified o...
double getFinalLength() const
get length that will be assigned to the lanes in the final network
NBNode * getFromNode() const
Returns the origin node of the edge.
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, int &index)
parses edge-id and index from lane-id
Instance responsible for building networks.
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
NBTypeCont & getTypeCont()
Returns a reference to the type container.
NBEdgeCont & getEdgeCont()
NBNodeCont & getNodeCont()
Returns a reference to the node container.
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
A definition of a pedestrian crossing.
int tlLinkIndex
the traffic light index of this crossing (if controlled)
std::string tlID
The id of the traffic light that controls this connection.
bool priority
whether the pedestrians have priority
Container for nodes during the netbuilding process.
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Represents a single node (junction) during network building.
LinkState getLinkState(const NBEdge *incoming, NBEdge *outgoing, int fromLane, int toLane, bool mayDefinitelyPass, const std::string &tlID) const
get link state
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
static const double UNSPECIFIED_RADIUS
unspecified lane width
Crossing * getCrossing(const std::string &id) const
return the crossing with the given id
FringeType getFringeType() const
Returns fringe type.
SumoXMLNodeType getType() const
Returns the type of this node.
const std::string & getName() const
Returns intersection name.
bool hasCustomShape() const
return whether the shape was set by the user
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
bool brakeForCrossingOnExit(const NBEdge *to) const
whether a connection to the given edge must brake for a crossing when leaving the intersection
std::vector< Crossing * > getCrossings() const
return this junctions pedestrian crossings
bool writeLogic(OutputDevice &into) const
writes the XML-representation of the logic as a bitset-logic XML representation
bool isConstantWidthTransition() const
detects whether a given junction splits or merges lanes while keeping constant road width
const PositionVector & getShape() const
retrieve the junction shape
const Position & getPosition() const
double getRadius() const
Returns the turning radius of this node.
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
static const SUMOTime UNSPECIFIED_DURATION
The definition of a single phase of the logic.
A container for traffic light definitions and built programs.
std::vector< NBTrafficLightLogic * > getComputed() const
Returns a list of all computed logics.
A SUMO-compliant built logic for a traffic light.
SUMOTime getOffset() const
Returns the offset of first switch.
const std::vector< PhaseDefinition > & getPhases() const
Returns the phases.
const std::string & getProgramID() const
Returns the ProgramID.
TrafficLightType getType() const
get the algorithm type (static etc..)
void writeEdgeTypes(OutputDevice &into) const
writes all EdgeTypes (and their lanes) as XML
static void writePositionLong(const Position &pos, OutputDevice &dev)
Writes the given position to device in long format (one attribute per dimension)
static void writeConnection(OutputDevice &into, const NBEdge &from, const NBEdge::Connection &c, bool includeInternal, ConnectionStyle style=SUMONET, bool geoAccuracy=false)
Writes connections outgoing from the given edge (also used in NWWriter_XML)
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into a SUMO-file.
static void writeLane(OutputDevice &into, const std::string &lID, double speed, SVCPermissions permissions, SVCPermissions preferred, SVCPermissions changeLeft, SVCPermissions changeRight, double startOffset, double endOffset, const StopOffset &stopOffset, double width, PositionVector shape, const Parameterised *params, double length, int index, const std::string &oppositeID, const std::string &type, bool accelRamp=false, bool customShape=false)
Writes a lane (<lane ...) of an edge.
static bool writeInternalNodes(OutputDevice &into, const NBNode &n)
Writes internal junctions (<junction with id[0]==':' ...) of the given node.
static void writeProhibitions(OutputDevice &into, const NBConnectionProhibits &prohibitions)
writes the given prohibitions
static void writeEdge(OutputDevice &into, const NBEdge &e, bool noNames)
Writes an edge (<edge ...)
static std::string getOppositeInternalID(const NBEdgeCont &ec, const NBEdge *from, const NBEdge::Connection &con, double &oppositeLength)
retrieve the id of the opposite direction internal lane if it exists
static std::string writeSUMOTime(SUMOTime time)
writes a SUMOTime as int if possible, otherwise as a float
static void writeJunction(OutputDevice &into, const NBNode &n)
Writes a junction (<junction ...)
static bool writeInternalEdges(OutputDevice &into, const NBEdgeCont &ec, const NBNode &n)
Writes internal edges (<edge ... with id[0]==':') of the given node.
static bool writeInternalConnections(OutputDevice &into, const NBNode &n)
Writes inner connections within the node.
static void writeDistrict(OutputDevice &into, const NBDistrict &d)
Writes a district.
static void writeRoundabouts(OutputDevice &into, const std::set< EdgeSet > &roundabouts, const NBEdgeCont &ec)
Writes roundabouts.
static void writeRoundabout(OutputDevice &into, const std::vector< std::string > &r, const NBEdgeCont &ec)
Writes a roundabout.
static void writeStopOffsets(OutputDevice &into, const StopOffset &stopOffset)
Write a stopOffset element into output device.
static void writeInternalConnection(OutputDevice &into, const std::string &from, const std::string &to, int fromLane, int toLane, const std::string &via, LinkDirection dir=LinkDirection::STRAIGHT, const std::string &tlID="", int linkIndex=NBConnection::InvalidTlIndex, bool minor=false, double visibility=NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE)
Writes a single internal connection.
static void writeTrafficLight(OutputDevice &into, const NBTrafficLightLogic *logic)
writes a single traffic light logic to the given device
static std::string prohibitionConnection(const NBConnection &c)
the attribute value for a prohibition
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
const std::string & getID() const
Returns the id.
A storage for options typed value containers)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
void resetWritable()
Resets all options to be writeable.
static OptionsCont & getOptions()
Retrieves the options.
Static storage of an output device and its base (abstract) implementation.
void lf()
writes a line feed if applicable
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
OutputDevice & writePadding(const std::string &val)
writes padding (ignored for binary output)
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >(), bool includeConfig=true)
Writes an XML header with optional configuration.
static OutputDevice & getDevice(const std::string &name)
Returns the described OutputDevice.
An upper class for objects with additional parameters.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
double length() const
Returns the length.
PositionVector simplified() const
return the same shape with intermediate colinear points removed
PositionVector getSubpart(double beginOffset, double endOffset) const
get subpart of a position vector
bool isDefined() const
check if stopOffset was defined
SVCPermissions getPermissions() const
get permissions
double getOffset() const
get offset
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static void normaliseSum(std::vector< T > &v, T msum=1.0)
A structure which describes a connection between edges or lanes.
bool indirectLeft
Whether this connection is an indirect left turn.
int fromLane
The lane the connections starts at.
std::string viaID
if Connection have a via, ID of it
int toLane
The lane the connections yields in.
SVCPermissions permissions
List of vehicle types that are allowed on this connection.
double speed
custom speed for connection
NBEdge * toEdge
The edge the connections yields in.
KeepClear keepClear
whether the junction must be kept clear when using this connection
double customLength
custom length for connection
std::string edgeType
optional type of Connection
bool uncontrolled
check if Connection is uncontrolled
PositionVector customShape
custom shape for connection
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this connections internal lane(s)
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this connections internal lane(s)
std::string getDescription(const NBEdge *parent) const
get string describing this connection
double contPos
custom position for internal junction on this connection
std::string getInternalLaneID() const
get ID of internal lane
int internalLaneIndex
The lane index of this internal lane within the internal edge.
std::string tlID
The id of the traffic light that controls this connection.
double visibility
custom foe visiblity for connection
int tlLinkIndex2
The index of the internal junction within the controlling traffic light (optional)
double length
computed length (average of all internal lane shape lengths that share an internal edge)
std::string id
id of Connection
bool haveVia
check if Connection have a Via
int tlLinkIndex
The index of this connection within the controlling traffic light.
An (internal) definition of a single lane of an edge.
double width
This lane's width.
StopOffset laneStopOffset
stopOffsets.second - The stop offset for vehicles stopping at the lane's end. Applies if vClass is in...
PositionVector customShape
A custom shape for this lane set by the user.
double endOffset
This lane's offset to the intersection begin.
std::string type
the type of this lane
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
double speed
The speed allowed on this lane.
std::string oppositeID
An opposite lane ID, if given.
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this lane.
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this lane.
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
bool accelRamp
Whether this lane is an acceleration lane.
PositionVector shape
The lane's shape.
A definition of a pedestrian walking area.
std::string id
the (edge)-id of this walkingArea
bool hasCustomShape
whether this walkingArea has a custom shape
double width
This lane's width.
PositionVector shape
The polygonal shape.
double length
This lane's width.