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) {
798 for (std::vector<OpenDriveGeometry>::iterator j = e.
geometries.begin(); j != e.
geometries.end(); ++j) {
823 if (!e.
geom.back().almostSame(geom.front())) {
824 const int index = (int)(j - e.
geometries.begin());
829 for (PositionVector::iterator k = geom.begin(); k != geom.end(); ++k) {
834 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
837 for (
unsigned int j = 0; j < e.
geom.size(); ++j) {
848 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
850 std::vector<OpenDriveLaneSection>& laneSections = e.
laneSections;
852 std::vector<OpenDriveLaneSection> newSections;
853 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end(); ++j) {
854 std::vector<OpenDriveLaneSection> splitSections;
855 bool splitBySpeed = (*j).buildSpeedChanges(tc, splitSections);
857 newSections.push_back(*j);
859 std::copy(splitSections.begin(), splitSections.end(), back_inserter(newSections));
868 for (std::vector<OpenDriveLaneSection>::const_iterator j = laneSections.begin(); j != laneSections.end() && sorted; ++j) {
869 if ((*j).s <= lastS) {
875 WRITE_WARNING(
"The sections of edge '" + e.
id +
"' are not sorted properly.");
881 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end();) {
882 bool simlarToLast = fabs((*j).s - lastS) <
POSITION_EPS;
885 WRITE_WARNING(
"Almost duplicate s-value '" +
toString(lastS) +
"' for lane sections occured at edge '" + e.
id +
"'; second entry was removed.");
886 j = laneSections.erase(j);
914 std::vector<Point2D<double> > into;
916 for (std::vector<
Point2D<double> >::iterator i = into.begin(); i != into.end(); ++i) {
917 ret.push_back(
Position((*i).getX(), (*i).getY()));
919 }
catch (
const std::runtime_error&
error) {
920 WRITE_WARNING(
"Could not compute spiral geometry for edge '" + e.
id +
"' (" + error.what() +
").");
948 if (geo_posE - g.
s > g.
length) {
951 if (geo_posE - g.
s > g.
length) {
954 calcPointOnCurve(&endX, &endY, centerX, centerY, radius, geo_posE - geo_posS);
956 dist += (geo_posE - geo_posS);
958 ret.push_back(
Position(startX, startY));
964 if (geo_posE - (g.
s + g.
length) < 0.001 && geo_posE - (g.
s + g.
length) > -0.001) {
983 ret.push_back(
Position(g.
x + xnew, g.
y + ynew));
993 double x2 = normx * cos(hdg) - normy * sin(hdg);
994 double y2 = normx * sin(hdg) + normy * cos(hdg);
997 return Position(start.
x() + normx, start.
y() + normy);
1007 if (ad_radius > 0) {
1014 normX = normX * cos(ad_hdg) + normY * sin(ad_hdg);
1015 normY = tmpX * sin(ad_hdg) + normY * cos(ad_hdg);
1018 normX = turn * normY;
1019 normY = -turn * tmpX;
1021 normX = fabs(ad_radius) * normX;
1022 normY = fabs(ad_radius) * normY;
1032 double rotAngle = ad_length / fabs(ad_r);
1033 double vx = *ad_x - ad_centerX;
1034 double vy = *ad_y - ad_centerY;
1044 vx = vx * cos(rotAngle) + turn * vy * sin(rotAngle);
1045 vy = -1 * turn * tmpx * sin(rotAngle) + vy * cos(rotAngle);
1046 *ad_x = vx + ad_centerX;
1047 *ad_y = vy + ad_centerY;
1063 unsigned int sumoLane = 0;
1065 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanesR.rbegin(); i != dirLanesR.rend(); ++i) {
1067 laneMap[(*i).id] = sumoLane++;
1073 for (std::vector<OpenDriveLane>::const_iterator i = dirLanesL.begin(); i != dirLanesL.end(); ++i) {
1075 laneMap[(*i).id] = sumoLane++;
1084 std::map<int, int> ret;
1085 const std::vector<OpenDriveLane>& dirLanes =
lanesByDir.find(dir)->second;
1086 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanes.rbegin(); i != dirLanes.rend(); ++i) {
1087 std::map<int, int>::const_iterator toP =
laneMap.find((*i).id);
1092 int to = (*toP).second;
1095 from = (*i).predecessor;
1098 std::map<int, int>::const_iterator fromP = prev.
laneMap.find(from);
1099 if (fromP != prev.
laneMap.end()) {
1100 from = (*fromP).second;
1106 if (ret.find(from) != ret.end()) {
1110 std::swap(from, to);
1129 if (i != l.
speeds.end()) {
1130 l.
speed = (*i).second;
1137 if (i != l.
speeds.end()) {
1138 l.
speed = (*i).second;
1147 std::set<SUMOReal> speedChangePositions;
1150 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1151 speedChangePositions.insert((*l).first);
1152 if ((*l).first == 0) {
1153 (*k).speed = (*l).second;
1158 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1159 speedChangePositions.insert((*l).first);
1160 if ((*l).first == 0) {
1161 (*k).speed = (*l).second;
1166 if (speedChangePositions.size() == 0) {
1169 if (*speedChangePositions.begin() > 0) {
1170 speedChangePositions.insert(0);
1173 for (std::set<SUMOReal>::iterator i = speedChangePositions.begin(); i != speedChangePositions.end(); ++i) {
1174 if (i == speedChangePositions.begin()) {
1175 newSections.push_back(*
this);
1181 for (
int i = 0; i != (int)newSections.size(); ++i) {
1184 for (std::map<
OpenDriveXMLTag, std::vector<OpenDriveLane> >::iterator k = lanesByDir.begin(); k != lanesByDir.end(); ++k) {
1185 std::vector<OpenDriveLane>& lanes = (*k).second;
1186 for (
int j = 0; j != (int)lanes.size(); ++j) {
1192 l.
speed = newSections[i - 1].lanesByDir[(*k).first][j].speed;
1210 for (std::vector<OpenDriveSignal>::const_iterator i = signals.begin(); i != signals.end(); ++i) {
1212 if ((*i).type ==
"301" || (*i).type ==
"306") {
1215 if ((*i).type ==
"205") {
1252 if (majorVersion != 1 || minorVersion != 2) {
1307 std::vector<SUMOReal> vals;
1312 std::vector<SUMOReal> vals;
1319 std::vector<SUMOReal> vals;
1325 std::vector<SUMOReal> vals;
1391 WRITE_ERROR(
"In laneLink-element: incoming road '" + c.fromEdge +
"' is not known.");
1403 l.width =
MAX2(l.width, width);
1460 const std::string& elementID,
1461 const std::string& contactPoint) {
1464 if (elementType ==
"road") {
1466 }
else if (elementType ==
"junction") {
1470 if (contactPoint ==
"start") {
1472 }
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.