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();
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(
TL(
"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->getBidiEdge() && k.toEdge->getBidiEdge() &&
345 e != k.toEdge->getTurnDestination(
true)) {
348 0, e->getTurnDestination(
true), 0);
358 const NBEdge::Lane& successor = k.toEdge->getLanes()[k.toLane];
360 successor.
permissions & e->getPermissions(k.fromLane));
363 const double width = e->getInternalLaneWidth(n, k, successor,
false);
364 writeLane(into, k.getInternalLaneID(), k.vmax, k.friction,
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));
393 const double width = e->getInternalLaneWidth(n, k, successor,
true);
398 MAX2(k.viaLength, POSITION_EPS),
414 MAX2(c->shape.length(), POSITION_EPS), 0,
"",
"",
false, c->customShape.size() != 0);
418 const std::vector<NBNode::WalkingArea>& WalkingAreas = n.
getWalkingAreas();
419 for (std::vector<NBNode::WalkingArea>::const_iterator it = WalkingAreas.begin(); it != WalkingAreas.end(); it++) {
470 const std::vector<NBEdge::Lane>& lanes = e.
getLanes();
474 for (
int i = 0; i < (int) lanes.size(); i++) {
495 double speed,
double friction,
498 double startOffset,
double endOffset,
501 const std::string& oppositeID,
502 const std::string& type,
503 bool accelRamp,
bool customShape) {
516 }
else if (speed < 0) {
517 throw ProcessError(
"Negative allowed speed (" +
toString(speed) +
") on lane '" + lID +
"', use --speed.minimum to prevent this.");
536 if (endOffset > 0 || startOffset > 0) {
537 if (startOffset + endOffset < shape.
length()) {
561 if (oppositeID !=
"" && oppositeID !=
"-") {
567 if (params !=
nullptr) {
582 std::vector<std::string> incLanes;
584 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
585 int noLanes = (*i)->getNumLanes();
586 for (
int j = 0; j < noLanes; j++) {
587 incLanes.push_back((*i)->getLaneID(j));
590 std::vector<NBNode::Crossing*> crossings = n.
getCrossings();
591 std::set<std::string> prevWAs;
593 for (
auto c : crossings) {
594 if (prevWAs.count(c->prevWalkingArea) == 0) {
595 incLanes.push_back(c->prevWalkingArea +
"_0");
596 prevWAs.insert(c->prevWalkingArea);
601 std::vector<std::string> intLanes;
603 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
604 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
605 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
606 if ((*k).toEdge ==
nullptr) {
610 intLanes.push_back((*k).getInternalLaneID());
612 intLanes.push_back((*k).viaID +
"_0");
618 for (
auto c : crossings) {
619 intLanes.push_back(c->id +
"_0");
656 std::vector<std::string> internalLaneIDs;
657 std::map<std::string, std::string> viaIDs;
658 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
659 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
660 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
661 if ((*k).toEdge !=
nullptr) {
662 internalLaneIDs.push_back((*k).getInternalLaneID());
663 viaIDs[(*k).getInternalLaneID()] = ((*k).viaID);
668 internalLaneIDs.push_back(c->id +
"_0");
671 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
672 const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
673 for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
674 if ((*k).toEdge ==
nullptr || !(*k).haveVia) {
681 std::string incLanes = (*k).getInternalLaneID();
682 std::vector<std::string> foeIDs;
683 for (std::string incLane : (*k).foeIncomingLanes) {
684 if (incLane[0] ==
':') {
687 incLane = internalLaneIDs[index];
688 if (viaIDs[incLane] !=
"") {
689 foeIDs.push_back(viaIDs[incLane] +
"_0");
692 incLanes +=
" " + incLane;
695 const std::vector<int>& foes = (*k).foeInternalLinks;
696 for (std::vector<int>::const_iterator it = foes.begin(); it != foes.end(); ++it) {
697 foeIDs.push_back(internalLaneIDs[*it]);
761 if (style !=
PLAIN) {
762 if (includeInternal) {
807 for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
809 const std::vector<NBEdge::Connection>& connections = from->
getConnections();
810 for (std::vector<NBEdge::Connection>::const_iterator j = connections.begin(); j != connections.end(); ++j) {
816 std::string tlID =
"";
822 writeInternalConnection(into, c.
id, c.
toEdge->
getID(), c.
internalLaneIndex, c.
toLane, c.
viaID +
"_0", dir, tlID, linkIndex2,
false, c.
visibility);
837 const std::string& from,
const std::string& to,
838 int fromLane,
int toLane,
const std::string& via,
840 const std::string& tlID,
int linkIndex,
869 std::vector<std::vector<std::string> > edgeIDs;
870 for (std::set<EdgeSet>::const_iterator i = roundabouts.begin(); i != roundabouts.end(); ++i) {
871 std::vector<std::string> tEdgeIDs;
872 for (EdgeSet::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
875 tEdgeIDs.push_back((*j)->getID());
877 std::sort(tEdgeIDs.begin(), tEdgeIDs.end());
878 edgeIDs.push_back(tEdgeIDs);
880 std::sort(edgeIDs.begin(), edgeIDs.end());
882 for (std::vector<std::vector<std::string> >::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
885 if (roundabouts.size() != 0) {
894 std::vector<std::string> validEdgeIDs;
895 std::vector<std::string> invalidEdgeIDs;
896 std::vector<std::string> nodeIDs;
897 for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
899 if (edge !=
nullptr) {
901 validEdgeIDs.push_back(edge->
getID());
903 invalidEdgeIDs.push_back(*i);
906 std::sort(nodeIDs.begin(), nodeIDs.end());
907 if (validEdgeIDs.size() > 0) {
912 if (invalidEdgeIDs.size() > 0) {
914 +
joinToString(invalidEdgeIDs,
" ") +
"' no longer exist'");
933 for (
int i = 0; i < (int)sources.size(); i++) {
940 for (
int i = 0; i < (int)sinks.size(); i++) {
953 if (time == std::floor(time)) {
963 for (NBConnectionProhibits::const_iterator j = prohibitions.begin(); j != prohibitions.end(); j++) {
966 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
985 std::vector<NBTrafficLightLogic*> logics = tllCont.
getComputed();
990 assert(def !=
nullptr);
993 if (logics.size() > 0) {
1015 if (varPhaseLength) {
1039 if (phase.name !=
"") {
1042 if (phase.next.size() > 0) {
1057 if (ss_vclasses.length() == 0) {
1063 if (ss_vclasses.length() <= ss_exceptions.length()) {
1066 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_LATEST_END
The maximum time within the cycle for switching (for coordinated actuation)
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
@ SUMO_ATTR_RED
red duration of a phase
@ 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_YELLOW
yellow duration of a phase
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
@ SUMO_ATTR_VEHICLEEXTENSION
vehicle extension time of a phase
@ 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.
@ SUMO_ATTR_EARLIEST_END
The minimum time within the cycle for switching (for coordinated actuation)
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 end() const
Returns the pointer to the end of the stored districts.
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin 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 * > & getSinkEdges() const
Returns the sinks.
const std::vector< NBEdge * > & getSourceEdges() const
Returns the sources.
Storage for edges, including some functionality operating on multiple edges.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
The representation of a single edge during network building.
const std::vector< Connection > & getConnections() const
Returns the connections.
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
NBNode * getToNode() const
Returns the destination node of the edge.
static const double UNSPECIFIED_FRICTION
unspecified lane friction
const Connection & getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns ...
const PositionVector & getGeometry() const
Returns the geometry of the 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::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
const std::string & getID() const
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.
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)
const std::string & getTypeID() const
get ID of type
const std::string & getStreetName() const
Returns the street name of this edge.
const NBEdge * getBidiEdge() const
NBNode * getFromNode() const
Returns the origin node of the edge.
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
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.
double getFinalLength() const
get length that will be assigned to the lanes in the final network
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.
NBNodeCont & getNodeCont()
Returns a reference to the node container.
NBEdgeCont & getEdgeCont()
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
NBTypeCont & getTypeCont()
Returns a reference to the type 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 EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
bool hasCustomShape() const
return whether the shape was set by the user
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
const std::string & getName() const
Returns intersection name.
bool writeLogic(OutputDevice &into) const
writes the XML-representation of the logic as a bitset-logic XML representation
const Position & getPosition() const
const PositionVector & getShape() const
retrieve the junction shape
double getRadius() const
Returns the turning radius of this node.
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
The base class for traffic light logic definitions.
virtual void finalChecks() const
perform optional final checks
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.
NBTrafficLightDefinition * getDefinition(const std::string &id, const std::string &programID) const
Returns the named definition.
A SUMO-compliant built logic for a traffic light.
SUMOTime getOffset() const
Returns the offset of first switch.
TrafficLightType getType() const
get the algorithm type (static etc..)
const std::string & getProgramID() const
Returns the ProgramID.
const std::vector< PhaseDefinition > & getPhases() const
Returns the phases.
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 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 void writeLane(OutputDevice &into, const std::string &lID, double speed, double friction, 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 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)
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 set(const std::string &name, const std::string &value, const bool append=false)
Sets the given value for the named option.
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
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
OutputDevice & writePadding(const std::string &val)
writes padding (ignored for binary output)
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
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.
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
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.
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.
double friction
The friction on 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.