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")) {
115 if (!oc.
getBool(
"no-internal-links")) {
117 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
126 bool noNames = !oc.
getBool(
"output.street-names");
127 for (std::map<std::string, NBEdge*>::const_iterator i = ec.
begin(); i != ec.
end(); ++i) {
128 writeEdge(device, *(*i).second, noNames);
136 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
140 const bool includeInternal = !oc.
getBool(
"no-internal-links");
141 if (includeInternal) {
144 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
153 int numConnections = 0;
154 for (std::map<std::string, NBEdge*>::const_iterator it_edge = ec.
begin(); it_edge != ec.
end(); it_edge++) {
155 NBEdge* from = it_edge->second;
156 const std::vector<NBEdge::Connection> connections = from->
getConnections();
157 numConnections += (int)connections.size();
158 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
162 if (numConnections > 0) {
165 if (includeInternal) {
168 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
175 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
176 NBNode* node = (*i).second;
178 std::vector<NBNode::Crossing*> crossings = node->
getCrossings();
179 for (
auto c : crossings) {
184 for (
const std::string& cID : wa.nextCrossings) {
192 if (nextCrossing.
tlID !=
"") {
204 for (
const std::string& sw : wa.nextSidewalks) {
208 for (
const std::string& sw : wa.prevSidewalks) {
216 for (std::map<std::string, NBNode*>::const_iterator i = nc.
begin(); i != nc.
end(); ++i) {
225 WRITE_WARNING(
"Embedding TAZ-data inside the network is deprecated. Use option --taz-output instead");
226 for (std::map<std::string, NBDistrict*>::const_iterator i = dc.
begin(); i != dc.
end(); i++) {
241 #ifdef DEBUG_OPPOSITE_INTERNAL
247 assert(succOpp != 0);
248 assert(predOpp != 0);
249 const std::vector<NBEdge::Connection>& connections = succOpp->
getConnections();
250 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) {
253 && predOpp == conOpp.
toEdge
259 #ifdef DEBUG_OPPOSITE_INTERNAL
262 oppositeLength = conOpp.
length;
293 std::map<std::string, std::string> oppositeLaneID;
294 std::map<std::string, double> oppositeLengths;
295 for (
NBEdge* e : incoming) {
297 double oppositeLength = 0;
299 oppositeLaneID[c.getInternalLaneID()] = op;
301 oppositeLengths[c.id] = oppositeLength;
305 if (oppositeLengths.size() > 0) {
306 for (
NBEdge* e : incoming) {
308 if (oppositeLengths.count(c.id) > 0) {
309 c.length = (c.length + oppositeLengths[c.id]) / 2;
315 for (
NBEdge* e : incoming) {
316 const std::vector<NBEdge::Connection>& elv = e->getConnections();
317 if (elv.size() > 0) {
318 bool haveVia =
false;
319 std::string edgeID =
"";
322 if (k.toEdge ==
nullptr) {
326 if (edgeID != k.id) {
335 if (e->isBidiRail() && k.toEdge->isBidiRail() &&
336 e != k.toEdge->getTurnDestination(
true)) {
339 0, e->getTurnDestination(
true), 0);
342 WRITE_WARNINGF(
"Could not find bidi-connection for edge '%'", edgeID)
349 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
351 successor.
permissions & e->getPermissions(k.fromLane));
353 writeLane(into, k.getInternalLaneID(), k.vmax,
356 std::map<int, double>(), width, k.shape, &k,
357 k.length, k.internalLaneIndex, oppositeLaneID[k.getInternalLaneID()],
"");
358 haveVia = haveVia || k.haveVia;
368 if (k.toEdge ==
nullptr) {
372 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
377 successor.
permissions & e->getPermissions(k.fromLane));
380 std::map<int, double>(), successor.
width, k.viaShape, &k,
381 MAX2(k.viaLength, POSITION_EPS),
396 std::map<int, double>(), c->width, c->shape,
nullptr,
397 MAX2(c->shape.length(), POSITION_EPS), 0,
"",
"",
false, c->customShape.size() != 0);
401 const std::vector<NBNode::WalkingArea>& WalkingAreas = n.
getWalkingAreas();
402 for (std::vector<NBNode::WalkingArea>::const_iterator it = WalkingAreas.begin(); it != WalkingAreas.end(); it++) {
409 std::map<int, double>(), wa.
width, wa.
shape,
nullptr, wa.
length, 0,
"",
"",
false, wa.
hasCustomShape);
453 const std::vector<NBEdge::Lane>& lanes = e.
getLanes();
457 for (
int i = 0; i < (int) lanes.size(); i++) {
459 std::map<int, double> stopOffsets;
478 double startOffset,
double endOffset,
479 std::map<SVCPermissions, double> stopOffsets,
double width,
PositionVector shape,
481 const std::string& oppositeID,
482 const std::string& type,
483 bool accelRamp,
bool customShape) {
495 WRITE_WARNINGF(
"Lane '%' has a maximum allowed speed of 0.", lID);
496 }
else if (speed < 0) {
497 throw ProcessError(
"Negative allowed speed (" +
toString(speed) +
") on lane '" + lID +
"', use --speed.minimum to prevent this.");
513 if (endOffset > 0 || startOffset > 0) {
514 if (startOffset + endOffset < shape.
length()) {
529 if (stopOffsets.size() != 0) {
533 if (oppositeID !=
"" && oppositeID !=
"-") {
539 if (params !=
nullptr) {
554 std::vector<std::string> incLanes;
556 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
557 int noLanes = (*i)->getNumLanes();
558 for (
int j = 0; j < noLanes; j++) {
559 incLanes.push_back((*i)->getLaneID(j));
562 std::vector<NBNode::Crossing*> crossings = n.
getCrossings();
563 std::set<std::string> prevWAs;
565 for (
auto c : crossings) {
566 if (prevWAs.count(c->prevWalkingArea) == 0) {
567 incLanes.push_back(c->prevWalkingArea +
"_0");
568 prevWAs.insert(c->prevWalkingArea);
573 std::vector<std::string> intLanes;
575 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
576 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
577 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
578 if ((*k).toEdge ==
nullptr) {
582 intLanes.push_back((*k).getInternalLaneID());
584 intLanes.push_back((*k).viaID +
"_0");
590 for (
auto c : crossings) {
591 intLanes.push_back(c->id +
"_0");
628 std::vector<std::string> internalLaneIDs;
629 std::map<std::string, std::string> viaIDs;
630 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
631 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
632 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
633 if ((*k).toEdge !=
nullptr) {
634 internalLaneIDs.push_back((*k).getInternalLaneID());
635 viaIDs[(*k).getInternalLaneID()] = ((*k).viaID);
640 internalLaneIDs.push_back(c->id +
"_0");
643 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
644 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
645 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
646 if ((*k).toEdge ==
nullptr || !(*k).haveVia) {
653 std::string incLanes = (*k).getInternalLaneID();
654 std::vector<std::string> foeIDs;
655 for (std::string incLane : (*k).foeIncomingLanes) {
656 incLanes +=
" " + incLane;
657 if (incLane[0] ==
':' && viaIDs[incLane] !=
"") {
659 foeIDs.push_back(viaIDs[incLane] +
"_0");
663 const std::vector<int>& foes = (*k).foeInternalLinks;
664 for (std::vector<int>::const_iterator it = foes.begin(); it != foes.end(); ++it) {
665 foeIDs.push_back(internalLaneIDs[*it]);
717 if (style !=
PLAIN) {
718 if (includeInternal) {
763 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
765 const std::vector<NBEdge::Connection>& connections = from->
getConnections();
766 for (std::vector<NBEdge::Connection>::const_iterator j = connections.begin(); j != connections.end(); ++j) {
772 std::string tlID =
"";
793 const std::string& from,
const std::string& to,
794 int fromLane,
int toLane,
const std::string& via,
819 std::vector<std::vector<std::string> > edgeIDs;
820 for (std::set<EdgeSet>::const_iterator i = roundabouts.begin(); i != roundabouts.end(); ++i) {
821 std::vector<std::string> tEdgeIDs;
822 for (EdgeSet::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
825 tEdgeIDs.push_back((*j)->getID());
827 std::sort(tEdgeIDs.begin(), tEdgeIDs.end());
828 edgeIDs.push_back(tEdgeIDs);
830 std::sort(edgeIDs.begin(), edgeIDs.end());
832 for (std::vector<std::vector<std::string> >::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
835 if (roundabouts.size() != 0) {
844 std::vector<std::string> validEdgeIDs;
845 std::vector<std::string> invalidEdgeIDs;
846 std::vector<std::string> nodeIDs;
847 for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
849 if (edge !=
nullptr) {
851 validEdgeIDs.push_back(edge->
getID());
853 invalidEdgeIDs.push_back(*i);
856 std::sort(nodeIDs.begin(), nodeIDs.end());
857 if (validEdgeIDs.size() > 0) {
862 if (invalidEdgeIDs.size() > 0) {
864 +
joinToString(invalidEdgeIDs,
" ") +
"' no longer exist'");
883 for (
int i = 0; i < (int)sources.size(); i++) {
890 for (
int i = 0; i < (int)sinks.size(); i++) {
903 if (time == std::floor(time)) {
913 for (NBConnectionProhibits::const_iterator j = prohibitions.begin(); j != prohibitions.end(); j++) {
916 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
935 std::vector<NBTrafficLightLogic*> logics = tllCont.
getComputed();
939 if (logics.size() > 0) {
961 if (varPhaseLength) {
969 if (phase.name !=
"") {
972 if (phase.next.size() > 0) {
985 if (stopOffsets.size() == 0) {
988 assert(stopOffsets.size() == 1);
989 std::pair<int, double> offset = *stopOffsets.begin();
991 if (ss_vclasses.length() == 0) {
997 if (ss_vclasses.length() <= ss_exceptions.length()) {
1000 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 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_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_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_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
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
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
const std::map< int, double > & getStopOffsets() const
Returns the stopOffset to the end of the edge.
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)
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 writeLane(OutputDevice &into, const std::string &lID, double speed, SVCPermissions permissions, SVCPermissions preferred, double startOffset, double endOffset, std::map< SVCPermissions, double > stopOffsets, 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 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 writeStopOffsets(OutputDevice &into, const std::map< SVCPermissions, double > &stopOffsets)
Write a stopOffset element into output device.
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into a SUMO-file.
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 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)
Writes a single internal connection.
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 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
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >())
Writes an XML header with optional configuration.
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 precison or resets it to default.
OutputDevice & writePadding(const std::string &val)
writes padding (ignored for binary output)
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
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
static void normaliseSum(std::vector< T > &v, T msum=1.0)
A structure which describes a connection between edges or lanes.
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
bool uncontrolled
check if Connection is uncontrolled
PositionVector customShape
custom shape for connection
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
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.
std::map< int, double > stopOffsets
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 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.