60 #ifdef CHECK_MEMORY_LEAKS 62 #endif // CHECK_MEMORY_LEAKS 155 std::map<std::string, OpenDriveEdge*> edges;
158 std::vector<std::string> files = oc.
getStringVector(
"opendrive-files");
159 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
161 WRITE_ERROR(
"Could not open opendrive file '" + *file +
"'.");
164 handler.setFileName(*file);
170 std::map<std::string, OpenDriveEdge*> innerEdges, outerEdges;
171 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
172 if ((*i).second->isInner) {
173 innerEdges[(*i).first] = (*i).second;
175 outerEdges[(*i).first] = (*i).second;
190 std::map<std::string, Boundary> posMap;
191 std::map<std::string, std::string> edge2junction;
193 for (std::map<std::string, OpenDriveEdge*>::iterator i = innerEdges.begin(); i != innerEdges.end(); ++i) {
197 if (posMap.find(e->
junction) == posMap.end()) {
203 for (std::map<std::string, Boundary>::iterator i = posMap.begin(); i != posMap.end(); ++i) {
205 throw ProcessError(
"Could not add node '" + (*i).first +
"'.");
209 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
211 for (std::vector<OpenDriveLink>::iterator j = e->
links.begin(); j != e->
links.end(); ++j) {
219 throw ProcessError(
"Could not build node '" + nid +
"'.");
226 if (edge2junction.find(l.
elementID) != edge2junction.end()) {
238 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
240 for (std::vector<OpenDriveLink>::iterator j = e->
links.begin(); j != e->
links.end(); ++j) {
247 std::string id1 = e->
id;
252 std::string nid = id1 +
"." + id2;
257 throw ProcessError(
"Could not build node '" + nid +
"'.");
275 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
277 if (e->
to != 0 && e->
from != 0) {
280 for (std::map<std::string, OpenDriveEdge*>::iterator j = innerEdges.begin(); j != innerEdges.end(); ++j) {
282 for (std::vector<OpenDriveLink>::iterator k = ie->
links.begin(); k != ie->
links.end(); ++k) {
288 std::string nid = edge2junction[ie->
id];
300 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
303 const std::string nid = e->
id +
".begin";
307 const std::string nid = e->
id +
".end";
318 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
320 bool lanesBuilt =
false;
346 WRITE_WARNING(
"Edge '" + e->
id +
"' has to be split as it connects same junctions.")
364 std::string
id = e->
id;
365 if (sFrom != e->
from || sTo != e->
to) {
373 if ((*j).rightLaneNumber > 0) {
374 currRight =
new NBEdge(
"-" +
id, sFrom, sTo,
"", defaultSpeed, (*j).rightLaneNumber, priorityR,
381 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
382 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
383 if (lp != (*j).laneMap.end()) {
384 int sumoLaneIndex = lp->second;
395 if (prevRight != 0) {
397 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
401 prevRight = currRight;
406 if ((*j).leftLaneNumber > 0) {
407 currLeft =
new NBEdge(
id, sTo, sFrom,
"", defaultSpeed, (*j).leftLaneNumber, priorityL,
414 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
415 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
416 if (lp != (*j).laneMap.end()) {
417 int sumoLaneIndex = lp->second;
429 std::map<int, int> connections = (*j).getInnerConnections(
OPENDRIVE_TAG_LEFT, *(j - 1));
430 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
451 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
455 std::vector<Connection> connections2;
456 for (std::map<std::string, OpenDriveEdge*>::iterator j = edges.begin(); j != edges.end(); ++j) {
457 const std::set<Connection>& conns = (*j).second->connections;
459 for (std::set<Connection>::const_iterator i = conns.begin(); i != conns.end(); ++i) {
460 if (innerEdges.find((*i).fromEdge) != innerEdges.end()) {
464 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
467 connections2.push_back(*i);
472 for (std::vector<Connection>::const_iterator i = connections2.begin(); i != connections2.end(); ++i) {
473 std::string fromEdge = (*i).fromEdge;
474 if (edges.find(fromEdge) == edges.end()) {
475 WRITE_WARNING(
"While setting connections: from-edge '" + fromEdge +
"' is not known.");
479 int fromLane = (*i).fromLane;
480 bool fromLast = ((*i).fromCP ==
OPENDRIVE_CP_END) ^ ((*i).fromLane > 0 && !(*i).all);
483 std::string toEdge = (*i).toEdge;
484 if (edges.find(toEdge) == edges.end()) {
485 WRITE_WARNING(
"While setting connections: to-edge '" + toEdge +
"' is not known.");
490 int toLane = (*i).toLane;
495 fromLane = toLast ? odTo->
laneSections.back().laneMap.begin()->first : odTo->
laneSections[0].laneMap.begin()->first;
511 WRITE_WARNING(
"Could not find fromEdge representation of '" + fromEdge +
"' in connection '" + (*i).origID +
"'.");
514 WRITE_WARNING(
"Could not find fromEdge representation of '" + toEdge +
"' in connection '" + (*i).origID +
"'.");
516 if (from == 0 || to == 0) {
522 if ((*i).origID !=
"") {
525 for (std::vector<NBEdge::Connection>::iterator k = cons.begin(); k != cons.end(); ++k) {
526 if ((*k).fromLane == fromLane && (*k).toEdge == to && (*k).toLane == toLane) {
527 (*k).origID = (*i).origID +
" " +
toString((*i).origLane);
538 std::map<std::string, std::string> tlsControlled;
539 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
541 for (std::vector<OpenDriveSignal>::const_iterator j = e->
signals.begin(); j != e->
signals.end(); ++j) {
542 if ((*j).type !=
"1000001") {
545 std::vector<OpenDriveLaneSection>::iterator k = e->
laneSections.begin();
548 if ((*j).s > (*k).s && (*j).s <= (*(k + 1)).s) {
558 std::string
id = (*k).sumoID;
562 std::string fromID, toID;
563 for (std::vector<OpenDriveLink>::const_iterator l = e->
links.begin(); l != e->
links.end(); ++l) {
568 fromID = (*l).elementID;
576 toID = (*l).elementID;
581 id = fromID +
"->" + toID;
583 WRITE_WARNING(
"Found a traffic light signal on an unknown edge (original edge id='" + e->
id +
"').");
588 if ((*j).orientation > 0) {
591 tlsControlled[id] = (*j).name;
595 for (std::map<std::string, std::string>::iterator i = tlsControlled.begin(); i != tlsControlled.end(); ++i) {
596 std::string
id = (*i).first;
597 if (
id.find(
"->") != std::string::npos) {
598 id =
id.substr(0,
id.find(
"->"));
602 WRITE_WARNING(
"Could not find edge '" +
id +
"' while building its traffic light.");
616 static_cast<NBOwnTLDef*
>(tlDef)->setSinglePhase();
625 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
626 oc.
unSet(
"geometry.min-dist");
628 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
643 const std::set<Connection>& conts = dest->
connections;
644 for (std::set<Connection>::const_iterator i = conts.begin(); i != conts.end(); ++i) {
645 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
646 std::vector<Connection> t;
648 for (std::vector<Connection>::const_iterator j = t.begin(); j != t.end(); ++j) {
658 if ((*i).fromLane == c.
toLane) {
675 for (std::vector<OpenDriveLink>::iterator i = e.
links.begin(); i != e.
links.end(); ++i) {
683 std::string edgeID = e.
id;
686 const std::map<int, int>& laneMap = laneSection.
laneMap;
689 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
706 if (edges.find(c.
fromEdge) == edges.end()) {
707 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
716 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
733 if (edges.find(c.
fromEdge) == edges.end()) {
734 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
757 if (!nc.
insert(
id, pos)) {
771 throw ProcessError(
"Could not find node '" + nodeID +
"'.");
774 if (e.
to != 0 && e.
to != n) {
795 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
797 for (std::vector<OpenDriveGeometry>::iterator j = e.
geometries.begin(); j != e.
geometries.end(); ++j) {
818 for (PositionVector::iterator k = geom.begin(); k != geom.end(); ++k) {
822 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
825 for (
unsigned int j = 0; j < e.
geom.size(); ++j) {
836 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
838 std::vector<OpenDriveLaneSection>& laneSections = e.
laneSections;
840 std::vector<OpenDriveLaneSection> newSections;
841 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end(); ++j) {
842 std::vector<OpenDriveLaneSection> splitSections;
843 bool splitBySpeed = (*j).buildSpeedChanges(tc, splitSections);
845 newSections.push_back(*j);
847 std::copy(splitSections.begin(), splitSections.end(), back_inserter(newSections));
856 for (std::vector<OpenDriveLaneSection>::const_iterator j = laneSections.begin(); j != laneSections.end() && sorted; ++j) {
857 if ((*j).s <= lastS) {
863 WRITE_WARNING(
"The sections of edge '" + e.
id +
"' are not sorted properly.");
869 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end();) {
870 bool simlarToLast = fabs((*j).s - lastS) <
POSITION_EPS;
873 WRITE_WARNING(
"Almost duplicate s-value '" +
toString(lastS) +
"' for lane sections occured at edge '" + e.
id +
"'; second entry was removed.");
874 j = laneSections.erase(j);
902 std::vector<Point2D<double> > into;
904 for (std::vector<
Point2D<double> >::iterator i = into.begin(); i != into.end(); ++i) {
905 ret.push_back(
Position((*i).getX(), (*i).getY()));
907 }
catch (
const std::runtime_error&
error) {
908 WRITE_WARNING(
"Could not compute spiral geometry for edge '" + e.
id +
"' (" + error.what() +
").");
936 if (geo_posE - g.
s > g.
length) {
939 if (geo_posE - g.
s > g.
length) {
942 calcPointOnCurve(&endX, &endY, centerX, centerY, radius, geo_posE - geo_posS);
944 dist += (geo_posE - geo_posS);
946 ret.push_back(
Position(startX, startY));
952 if (geo_posE - (g.
s + g.
length) < 0.001 && geo_posE - (g.
s + g.
length) > -0.001) {
971 ret.push_back(
Position(g.
x + xnew, g.
y + ynew));
981 double x2 = normx * cos(hdg) - normy * sin(hdg);
982 double y2 = normx * sin(hdg) + normy * cos(hdg);
985 return Position(start.
x() + normx, start.
y() + normy);
1002 normX = normX * cos(ad_hdg) + normY * sin(ad_hdg);
1003 normY = tmpX * sin(ad_hdg) + normY * cos(ad_hdg);
1006 normX = turn * normY;
1007 normY = -turn * tmpX;
1009 normX = fabs(ad_radius) * normX;
1010 normY = fabs(ad_radius) * normY;
1020 double rotAngle = ad_length / fabs(ad_r);
1021 double vx = *ad_x - ad_centerX;
1022 double vy = *ad_y - ad_centerY;
1032 vx = vx * cos(rotAngle) + turn * vy * sin(rotAngle);
1033 vy = -1 * turn * tmpx * sin(rotAngle) + vy * cos(rotAngle);
1034 *ad_x = vx + ad_centerX;
1035 *ad_y = vy + ad_centerY;
1051 unsigned int sumoLane = 0;
1053 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanesR.rbegin(); i != dirLanesR.rend(); ++i) {
1055 laneMap[(*i).id] = sumoLane++;
1061 for (std::vector<OpenDriveLane>::const_iterator i = dirLanesL.begin(); i != dirLanesL.end(); ++i) {
1063 laneMap[(*i).id] = sumoLane++;
1072 std::map<int, int> ret;
1073 const std::vector<OpenDriveLane>& dirLanes =
lanesByDir.find(dir)->second;
1074 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanes.rbegin(); i != dirLanes.rend(); ++i) {
1075 std::map<int, int>::const_iterator toP =
laneMap.find((*i).id);
1080 int to = (*toP).second;
1083 from = (*i).predecessor;
1086 std::map<int, int>::const_iterator fromP = prev.
laneMap.find(from);
1087 if (fromP != prev.
laneMap.end()) {
1088 from = (*fromP).second;
1094 if (ret.find(from) != ret.end()) {
1098 std::swap(from, to);
1117 if (i != l.
speeds.end()) {
1118 l.
speed = (*i).second;
1125 if (i != l.
speeds.end()) {
1126 l.
speed = (*i).second;
1135 std::set<SUMOReal> speedChangePositions;
1138 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1139 speedChangePositions.insert((*l).first);
1140 if ((*l).first == 0) {
1141 (*k).speed = (*l).second;
1146 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1147 speedChangePositions.insert((*l).first);
1148 if ((*l).first == 0) {
1149 (*k).speed = (*l).second;
1154 if (speedChangePositions.size() == 0) {
1157 if (*speedChangePositions.begin() > 0) {
1158 speedChangePositions.insert(0);
1161 for (std::set<SUMOReal>::iterator i = speedChangePositions.begin(); i != speedChangePositions.end(); ++i) {
1162 if (i == speedChangePositions.begin()) {
1163 newSections.push_back(*
this);
1169 for (
int i = 0; i != (int)newSections.size(); ++i) {
1172 for (std::map<
OpenDriveXMLTag, std::vector<OpenDriveLane> >::iterator k = lanesByDir.begin(); k != lanesByDir.end(); ++k) {
1173 std::vector<OpenDriveLane>& lanes = (*k).second;
1174 for (
int j = 0; j != (int)lanes.size(); ++j) {
1180 l.
speed = newSections[i - 1].lanesByDir[(*k).first][j].speed;
1198 for (std::vector<OpenDriveSignal>::const_iterator i = signals.begin(); i != signals.end(); ++i) {
1200 if ((*i).type ==
"301" || (*i).type ==
"306") {
1203 if ((*i).type ==
"205") {
1240 if (majorVersion != 1 || minorVersion != 2) {
1295 std::vector<SUMOReal> vals;
1300 std::vector<SUMOReal> vals;
1307 std::vector<SUMOReal> vals;
1313 std::vector<SUMOReal> vals;
1379 WRITE_ERROR(
"In laneLink-element: incoming road '" + c.fromEdge +
"' is not known.");
1391 l.width =
MAX2(l.width, width);
1448 const std::string& elementID,
1449 const std::string& contactPoint) {
1452 if (elementType ==
"road") {
1454 }
else if (elementType ==
"junction") {
1458 if (contactPoint ==
"start") {
1460 }
else if (contactPoint ==
"end") {
std::map< std::string, OpenDriveEdge * > & myEdges
ContactPoint contactPoint
static void calculateCurveCenter(SUMOReal *ad_x, SUMOReal *ad_y, SUMOReal ad_radius, SUMOReal ad_hdg)
std::vector< int > myElementStack
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
static PositionVector geomFromLine(const OpenDriveEdge &e, const OpenDriveGeometry &g)
static StringBijection< int >::Entry openDriveAttrs[]
The names of openDrive-XML attributes (for passing to GenericSAXHandler)
NBTypeCont & getTypeCont()
Returns the type container.
static bool transformCoordinates(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
PositionVector getSubpart2D(SUMOReal beginOffset, SUMOReal endOffset) const
void addLink(LinkType lt, const std::string &elementType, const std::string &elementID, const std::string &contactPoint)
Representation of an OpenDrive link.
static bool isReadable(std::string path)
Checks whether the given file is readable.
std::string junction
The id of the junction the edge belongs to.
GeometryType
OpenDrive geometry type enumeration.
bool isTLControlled() const
Returns whether this node is controlled by any tls.
static void buildConnectionsToOuter(const Connection &c, const std::map< std::string, OpenDriveEdge * > &innerEdges, std::vector< Connection > &into)
void unSet(const std::string &name, bool failOnNonExistant=true) const
Marks the option as unset.
Representation of a lane section.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
The representation of a single edge during network building.
Representation of an openDrive "link".
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS)
Adds a connection between the specified this edge's lane and an approached one.
The base class for traffic light logic definitions.
ContactPoint myCurrentContactPoint
SUMOReal s
The starting offset of this lane section.
static PositionVector geomFromArc(const OpenDriveEdge &e, const OpenDriveGeometry &g)
std::map< OpenDriveXMLTag, std::vector< OpenDriveLane > > lanesByDir
The lanes, sorted by their direction.
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
std::set< Connection > connections
Representation of a signal.
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything's ok.
SUMOReal x() const
Returns the x-position.
friend bool operator<(const Connection &c1, const Connection &c2)
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
#define UNUSED_PARAMETER(x)
OpenDriveEdge myCurrentEdge
A class that stores a 2D geometrical boundary.
SUMOReal getWidth(const std::string &type) const
Returns the lane width for the given type [m].
static NBNode * getOrBuildNode(const std::string &id, const Position &pos, NBNodeCont &nc)
Builds a node or returns the already built.
void error(const XERCES_CPP_NAMESPACE::SAXParseException &exception)
Handler for XML-errors.
#define WRITE_WARNING(msg)
The connection was computed and validated.
static OptionsCont & getOptions()
Retrieves the options.
static std::string revertID(const std::string &id)
std::string myCurrentConnectingRoad
PositionVector reverse() const
Representation of a lane.
SUMOReal speed
The speed allowed on this lane.
OpenDriveXMLTag myCurrentLaneDirection
static void calcPointOnCurve(SUMOReal *ad_x, SUMOReal *ad_y, SUMOReal ad_centerX, SUMOReal ad_centerY, SUMOReal ad_r, SUMOReal ad_length)
An (internal) definition of a single lane of an edge.
const std::string & getID() const
Returns the id.
SUMOReal length2D() const
Returns the length.
unsigned int leftLaneNumber
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
std::vector< OpenDriveLink > links
A handler which converts occuring elements and attributes into enums.
OpenDriveLaneSection buildLaneSection(SUMOReal startPos)
SUMOReal getSpeed(const std::string &type) const
Returns the maximal velocity for the given type [m/s].
const std::string & getFileName() const
returns the current file name
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string type
The lane's type.
int getPriority(OpenDriveXMLTag dir) const
Returns the edge's priority, regarding the direction.
Encapsulated SAX-Attributes.
static StringBijection< TrafficLightType > TrafficLightTypes
static Position calculateStraightEndPoint(double hdg, double length, const Position &start)
A point in 2D or 3D with translation and scaling methods.
NBEdgeCont & getEdgeCont()
Returns the edge container.
void computeSpiral(std::vector< Point2D< double > > &spiral, double ds=0, int NPts=0)
std::string id
The id of the edge.
static void loadNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Loads content of the optionally given SUMO file.
NIImporter_OpenDrive(const NBTypeCont &tc, std::map< std::string, OpenDriveEdge * > &edges)
Constructor.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file) ...
bool buildSpeedChanges(const NBTypeCont &tc, std::vector< OpenDriveLaneSection > &newSections)
const NBTypeCont & myTypeContainer
bool myConnectionWasEmpty
SUMOReal width
The lane's width;.
Position positionAtOffset(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
std::string myCurrentJunctionID
std::vector< OpenDriveLaneSection > laneSections
std::map< int, int > laneMap
A mapping from OpenDrive to SUMO-index (the first is signed, the second unsigned) ...
#define PROGRESS_BEGIN_MESSAGE(msg)
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
OpenDriveXMLTag
Numbers representing openDrive-XML - element names.
static bool myImportWidths
bool knows(const std::string &type) const
Returns whether the named type is in the container.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
The connection was given by the user.
static PositionVector geomFromSpiral(const OpenDriveEdge &e, const OpenDriveGeometry &g)
static PositionVector geomFromPoly(const OpenDriveEdge &e, const OpenDriveGeometry &g)
static StringBijection< int >::Entry openDriveTags[]
The names of openDrive-XML elements (for passing to GenericSAXHandler)
static bool myImportAllTypes
std::string origID
An original ID, if given (.
void buildLaneMapping(const NBTypeCont &tc)
Build the mapping from OpenDrive to SUMO lanes.
std::vector< OpenDriveSignal > signals
LinkType
OpenDrive link type enumeration.
void addParameter(const std::string &key, const std::string &value)
Adds a parameter.
static void computeShapes(std::map< std::string, OpenDriveEdge * > &edges)
Computes a polygon representation of each edge's geometry.
NBNode * getToNode() const
Returns the destination node of the edge.
void addTrafficLight(NBTrafficLightDefinition *tlDef)
Adds a traffic light to the list of traffic lights that control this node.
void removeDoublePoints(SUMOReal minDist=POSITION_EPS, bool assertLength=false)
Removes positions if too near.
~NIImporter_OpenDrive()
Destructor.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
std::map< int, int > getInnerConnections(OpenDriveXMLTag dir, const OpenDriveLaneSection &prev)
Returns the links from the previous to this lane section.
NBNodeCont & getNodeCont()
Returns the node container.
SUMOReal speed
The lane's speed (set in post-processing)
Instance responsible for building networks.
Representation of an OpenDrive geometry part.
bool getShallBeDiscarded(const std::string &type) const
Returns the information whether edges of this type shall be discarded.
SUMOReal y() const
Returns the y-position.
A storage for options typed value containers)
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
NBTrafficLightLogicCont & getTLLogicCont()
Returns the traffic light logics container.
unsigned int rightLaneNumber
The number of lanes on the right and on the left side, respectively.
static void setEdgeLinks2(OpenDriveEdge &e, const std::map< std::string, OpenDriveEdge * > &edges)
std::vector< OpenDriveGeometry > geometries
Represents a single node (junction) during network building.
T get(const std::string &str) const
Lane & getLaneStruct(unsigned int lane)
A class for sorting lane sections by their s-value.
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
static void setNodeSecure(NBNodeCont &nc, OpenDriveEdge &e, const std::string &nodeID, NIImporter_OpenDrive::LinkType lt)
void push_back_noDoublePos(const Position &p)
A connection between two roads.
std::vector< SUMOReal > params
void addGeometryShape(GeometryType type, const std::vector< SUMOReal > &vals)
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
SVCPermissions getPermissions(const std::string &type) const
Returns allowed vehicle classes for the given type.
Container for nodes during the netbuilding process.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOReal length
The length of the edge.
#define PROGRESS_DONE_MESSAGE()
A traffic light logics which must be computed (only nodes/edges are given)
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
const std::vector< Connection > & getConnections() const
Returns the connections.
Importer for networks stored in openDrive format.
std::string myCurrentIncomingRoad
OpenDriveLaneSection(SUMOReal sArg)
Constructor.
std::vector< std::pair< SUMOReal, SUMOReal > > speeds
List of positions/speeds of speed changes.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
SUMOReal width
This lane's width.
A storage for available types of edges.
std::string streetName
The road name of the edge.
void myEndElement(int element)
Called when a closing tag occurs.
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
static void revisitLaneSections(const NBTypeCont &tc, std::map< std::string, OpenDriveEdge * > &edges)
Rechecks lane sections of the given edges.