60 #ifdef CHECK_MEMORY_LEAKS 62 #endif // CHECK_MEMORY_LEAKS 166 std::map<std::string, OpenDriveEdge*> edges;
169 std::vector<std::string> files = oc.
getStringVector(
"opendrive-files");
170 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
172 WRITE_ERROR(
"Could not open opendrive file '" + *file +
"'.");
175 handler.setFileName(*file);
181 std::map<std::string, OpenDriveEdge*> innerEdges, outerEdges;
182 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
183 if ((*i).second->isInner) {
184 innerEdges[(*i).first] = (*i).second;
186 outerEdges[(*i).first] = (*i).second;
201 std::map<std::string, Boundary> posMap;
202 std::map<std::string, std::string> edge2junction;
204 for (std::map<std::string, OpenDriveEdge*>::iterator i = innerEdges.begin(); i != innerEdges.end(); ++i) {
208 if (posMap.find(e->
junction) == posMap.end()) {
214 for (std::map<std::string, Boundary>::iterator i = posMap.begin(); i != posMap.end(); ++i) {
216 throw ProcessError(
"Could not add node '" + (*i).first +
"'.");
220 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
222 for (std::vector<OpenDriveLink>::iterator j = e->
links.begin(); j != e->
links.end(); ++j) {
230 throw ProcessError(
"Could not build node '" + nid +
"'.");
237 if (edge2junction.find(l.
elementID) != edge2junction.end()) {
249 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
251 for (std::vector<OpenDriveLink>::iterator j = e->
links.begin(); j != e->
links.end(); ++j) {
258 std::string id1 = e->
id;
263 std::string nid = id1 +
"." + id2;
268 throw ProcessError(
"Could not build node '" + nid +
"'.");
286 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
288 if (e->
to != 0 && e->
from != 0) {
291 for (std::map<std::string, OpenDriveEdge*>::iterator j = innerEdges.begin(); j != innerEdges.end(); ++j) {
293 for (std::vector<OpenDriveLink>::iterator k = ie->
links.begin(); k != ie->
links.end(); ++k) {
299 std::string nid = edge2junction[ie->
id];
311 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
314 const std::string nid = e->
id +
".begin";
318 const std::string nid = e->
id +
".end";
329 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
331 bool lanesBuilt =
false;
357 WRITE_WARNING(
"Edge '" + e->
id +
"' has to be split as it connects same junctions.")
375 std::string
id = e->
id;
376 if (sFrom != e->
from || sTo != e->
to) {
384 if ((*j).rightLaneNumber > 0) {
385 currRight =
new NBEdge(
"-" +
id, sFrom, sTo, (*j).rightType, defaultSpeed, (*j).rightLaneNumber, priorityR,
392 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
393 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
394 if (lp != (*j).laneMap.end()) {
395 int sumoLaneIndex = lp->second;
406 if (prevRight != 0) {
408 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
412 prevRight = currRight;
417 if ((*j).leftLaneNumber > 0) {
418 currLeft =
new NBEdge(
id, sTo, sFrom, (*j).leftType, defaultSpeed, (*j).leftLaneNumber, priorityL,
425 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
426 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
427 if (lp != (*j).laneMap.end()) {
428 int sumoLaneIndex = lp->second;
440 std::map<int, int> connections = (*j).getInnerConnections(
OPENDRIVE_TAG_LEFT, *(j - 1));
441 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
462 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
466 std::vector<Connection> connections2;
467 for (std::map<std::string, OpenDriveEdge*>::iterator j = edges.begin(); j != edges.end(); ++j) {
468 const std::set<Connection>& conns = (*j).second->connections;
470 for (std::set<Connection>::const_iterator i = conns.begin(); i != conns.end(); ++i) {
471 if (innerEdges.find((*i).fromEdge) != innerEdges.end()) {
475 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
478 connections2.push_back(*i);
483 for (std::vector<Connection>::const_iterator i = connections2.begin(); i != connections2.end(); ++i) {
484 std::string fromEdge = (*i).fromEdge;
485 if (edges.find(fromEdge) == edges.end()) {
486 WRITE_WARNING(
"While setting connections: from-edge '" + fromEdge +
"' is not known.");
490 int fromLane = (*i).fromLane;
491 bool fromLast = ((*i).fromCP ==
OPENDRIVE_CP_END) ^ ((*i).fromLane > 0 && !(*i).all);
494 std::string toEdge = (*i).toEdge;
495 if (edges.find(toEdge) == edges.end()) {
496 WRITE_WARNING(
"While setting connections: to-edge '" + toEdge +
"' is not known.");
501 int toLane = (*i).toLane;
506 fromLane = toLast ? odTo->
laneSections.back().laneMap.begin()->first : odTo->
laneSections[0].laneMap.begin()->first;
522 WRITE_WARNING(
"Could not find fromEdge representation of '" + fromEdge +
"' in connection '" + (*i).origID +
"'.");
525 WRITE_WARNING(
"Could not find fromEdge representation of '" + toEdge +
"' in connection '" + (*i).origID +
"'.");
527 if (from == 0 || to == 0) {
533 if ((*i).origID !=
"") {
536 for (std::vector<NBEdge::Connection>::iterator k = cons.begin(); k != cons.end(); ++k) {
537 if ((*k).fromLane == fromLane && (*k).toEdge == to && (*k).toLane == toLane) {
538 (*k).origID = (*i).origID +
" " +
toString((*i).origLane);
549 std::map<std::string, std::string> tlsControlled;
550 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
552 for (std::vector<OpenDriveSignal>::const_iterator j = e->
signals.begin(); j != e->
signals.end(); ++j) {
553 if ((*j).type !=
"1000001") {
556 std::vector<OpenDriveLaneSection>::iterator k = e->
laneSections.begin();
559 if ((*j).s > (*k).s && (*j).s <= (*(k + 1)).s) {
569 std::string
id = (*k).sumoID;
573 std::string fromID, toID;
574 for (std::vector<OpenDriveLink>::const_iterator l = e->
links.begin(); l != e->
links.end(); ++l) {
579 fromID = (*l).elementID;
587 toID = (*l).elementID;
592 id = fromID +
"->" + toID;
594 WRITE_WARNING(
"Found a traffic light signal on an unknown edge (original edge id='" + e->
id +
"').");
599 if ((*j).orientation > 0) {
602 tlsControlled[id] = (*j).name;
606 for (std::map<std::string, std::string>::iterator i = tlsControlled.begin(); i != tlsControlled.end(); ++i) {
607 std::string
id = (*i).first;
608 if (
id.find(
"->") != std::string::npos) {
609 id =
id.substr(0,
id.find(
"->"));
613 WRITE_WARNING(
"Could not find edge '" +
id +
"' while building its traffic light.");
627 static_cast<NBOwnTLDef*
>(tlDef)->setSinglePhase();
636 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
637 oc.
unSet(
"geometry.min-dist");
639 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
654 const std::set<Connection>& conts = dest->
connections;
655 for (std::set<Connection>::const_iterator i = conts.begin(); i != conts.end(); ++i) {
656 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
657 std::vector<Connection> t;
659 for (std::vector<Connection>::const_iterator j = t.begin(); j != t.end(); ++j) {
669 if ((*i).fromLane == c.
toLane) {
686 for (std::vector<OpenDriveLink>::iterator i = e.
links.begin(); i != e.
links.end(); ++i) {
694 std::string edgeID = e.
id;
697 const std::map<int, int>& laneMap = laneSection.
laneMap;
700 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
717 if (edges.find(c.
fromEdge) == edges.end()) {
718 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
727 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
744 if (edges.find(c.
fromEdge) == edges.end()) {
745 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
768 if (!nc.
insert(
id, pos)) {
782 throw ProcessError(
"Could not find node '" + nodeID +
"'.");
785 if (e.
to != 0 && e.
to != n) {
806 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
809 for (std::vector<OpenDriveGeometry>::iterator j = e.
geometries.begin(); j != e.
geometries.end(); ++j) {
837 if (!e.
geom.back().almostSame(geom.front())) {
838 const int index = (int)(j - e.
geometries.begin());
843 for (PositionVector::iterator k = geom.begin(); k != geom.end(); ++k) {
848 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
851 for (
int j = 0; j < (int)e.
geom.size(); ++j) {
859 for (std::vector<OpenDriveElevation>::iterator j = e.
elevations.begin(); j != e.
elevations.end(); ++j) {
862 while (k < (
int)e.
geom.size() && pos < sNext) {
864 const SUMOReal z = el.
a + el.
b * ds + el.
c * ds * ds + el.
d * ds * ds * ds;
868 if (k < (
int)e.
geom.size()) {
871 pos += e.
geom[k - 1].distanceTo2D(e.
geom[k]);
881 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
883 std::vector<OpenDriveLaneSection>& laneSections = e.
laneSections;
885 std::vector<OpenDriveLaneSection> newSections;
886 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end(); ++j) {
887 std::vector<OpenDriveLaneSection> splitSections;
888 bool splitBySpeed = (*j).buildSpeedChanges(tc, splitSections);
890 newSections.push_back(*j);
892 std::copy(splitSections.begin(), splitSections.end(), back_inserter(newSections));
901 for (std::vector<OpenDriveLaneSection>::const_iterator j = laneSections.begin(); j != laneSections.end() && sorted; ++j) {
902 if ((*j).s <= lastS) {
908 WRITE_WARNING(
"The sections of edge '" + e.
id +
"' are not sorted properly.");
914 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end();) {
915 bool simlarToLast = fabs((*j).s - lastS) <
POSITION_EPS;
918 WRITE_WARNING(
"Almost duplicate s-value '" +
toString(lastS) +
"' for lane sections occured at edge '" + e.
id +
"'; second entry was removed.");
919 j = laneSections.erase(j);
947 std::vector<Point2D<double> > into;
949 for (std::vector<
Point2D<double> >::iterator i = into.begin(); i != into.end(); ++i) {
950 ret.push_back(
Position((*i).getX(), (*i).getY()));
952 }
catch (
const std::runtime_error&
error) {
953 WRITE_WARNING(
"Could not compute spiral geometry for edge '" + e.
id +
"' (" + error.what() +
").");
981 if (geo_posE - g.
s > g.
length) {
984 if (geo_posE - g.
s > g.
length) {
987 calcPointOnCurve(&endX, &endY, centerX, centerY, radius, geo_posE - geo_posS);
989 dist += (geo_posE - geo_posS);
991 ret.push_back(
Position(startX, startY));
997 if (geo_posE - (g.
s + g.
length) < 0.001 && geo_posE - (g.
s + g.
length) > -0.001) {
1016 ret.push_back(
Position(g.
x + xnew, g.
y + ynew));
1031 for (
SUMOReal p = 0; p < pMax + pStep; p += pStep) {
1036 ret.push_back(
Position(g.
x + xnew, g.
y + ynew));
1044 double normx = 1.0f;
1045 double normy = 0.0f;
1046 double x2 = normx * cos(hdg) - normy * sin(hdg);
1047 double y2 = normx * sin(hdg) + normy * cos(hdg);
1048 normx = x2 * length;
1049 normy = y2 * length;
1050 return Position(start.
x() + normx, start.
y() + normy);
1060 if (ad_radius > 0) {
1067 normX = normX * cos(ad_hdg) + normY * sin(ad_hdg);
1068 normY = tmpX * sin(ad_hdg) + normY * cos(ad_hdg);
1071 normX = turn * normY;
1072 normY = -turn * tmpX;
1074 normX = fabs(ad_radius) * normX;
1075 normY = fabs(ad_radius) * normY;
1085 double rotAngle = ad_length / fabs(ad_r);
1086 double vx = *ad_x - ad_centerX;
1087 double vy = *ad_y - ad_centerY;
1097 vx = vx * cos(rotAngle) + turn * vy * sin(rotAngle);
1098 vy = -1 * turn * tmpx * sin(rotAngle) + vy * cos(rotAngle);
1099 *ad_x = vx + ad_centerX;
1100 *ad_y = vy + ad_centerY;
1117 bool singleType =
true;
1118 std::vector<std::string> types;
1120 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanesR.rbegin(); i != dirLanesR.rend(); ++i) {
1122 laneMap[(*i).id] = sumoLane++;
1123 types.push_back((*i).type);
1124 if (types.front() != types.back()) {
1135 for (std::vector<OpenDriveLane>::const_iterator i = dirLanesL.begin(); i != dirLanesL.end(); ++i) {
1137 laneMap[(*i).id] = sumoLane++;
1138 types.push_back((*i).type);
1139 if (types.front() != types.back()) {
1151 std::map<int, int> ret;
1152 const std::vector<OpenDriveLane>& dirLanes =
lanesByDir.find(dir)->second;
1153 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanes.rbegin(); i != dirLanes.rend(); ++i) {
1154 std::map<int, int>::const_iterator toP =
laneMap.find((*i).id);
1159 int to = (*toP).second;
1162 from = (*i).predecessor;
1165 std::map<int, int>::const_iterator fromP = prev.
laneMap.find(from);
1166 if (fromP != prev.
laneMap.end()) {
1167 from = (*fromP).second;
1173 if (ret.find(from) != ret.end()) {
1177 std::swap(from, to);
1196 if (i != l.
speeds.end()) {
1197 l.
speed = (*i).second;
1204 if (i != l.
speeds.end()) {
1205 l.
speed = (*i).second;
1214 std::set<SUMOReal> speedChangePositions;
1217 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1218 speedChangePositions.insert((*l).first);
1219 if ((*l).first == 0) {
1220 (*k).speed = (*l).second;
1225 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1226 speedChangePositions.insert((*l).first);
1227 if ((*l).first == 0) {
1228 (*k).speed = (*l).second;
1233 if (speedChangePositions.size() == 0) {
1236 if (*speedChangePositions.begin() > 0) {
1237 speedChangePositions.insert(0);
1240 for (std::set<SUMOReal>::iterator i = speedChangePositions.begin(); i != speedChangePositions.end(); ++i) {
1241 if (i == speedChangePositions.begin()) {
1242 newSections.push_back(*
this);
1248 for (
int i = 0; i != (int)newSections.size(); ++i) {
1251 for (std::map<
OpenDriveXMLTag, std::vector<OpenDriveLane> >::iterator k = lanesByDir.begin(); k != lanesByDir.end(); ++k) {
1252 std::vector<OpenDriveLane>& lanes = (*k).second;
1253 for (
int j = 0; j != (int)lanes.size(); ++j) {
1259 l.
speed = newSections[i - 1].lanesByDir[(*k).first][j].speed;
1277 for (std::vector<OpenDriveSignal>::const_iterator i = signals.begin(); i != signals.end(); ++i) {
1279 if ((*i).type ==
"301" || (*i).type ==
"306") {
1282 if ((*i).type ==
"205") {
1319 if (majorVersion != 1 || minorVersion != 2) {
1383 std::vector<SUMOReal> vals;
1388 std::vector<SUMOReal> vals;
1395 std::vector<SUMOReal> vals;
1401 std::vector<SUMOReal> vals;
1410 std::vector<SUMOReal> vals;
1481 WRITE_ERROR(
"In laneLink-element: incoming road '" + c.fromEdge +
"' is not known.");
1493 l.width =
MAX2(l.width, width);
1550 const std::string& elementID,
1551 const std::string& contactPoint) {
1554 if (elementType ==
"road") {
1556 }
else if (elementType ==
"junction") {
1560 if (contactPoint ==
"start") {
1562 }
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) ...
std::string rightType
the composite type built from all used lane types
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
get subpart of a position vector in two dimensions (Z is ignored)
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.
std::vector< OpenDriveElevation > elevations
GeometryType
OpenDrive geometry type enumeration.
int rightLaneNumber
The number of lanes on the right and on the left side, respectively.
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".
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.
Lane & getLaneStruct(int lane)
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)
bool addLane2LaneConnection(int fromLane, NBEdge *dest, 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.
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
reverse position vector
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.
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.
void add(SUMOReal xoff, SUMOReal yoff, SUMOReal zoff)
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.
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
A class for sorting lane sections by their s-value.
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=OUTPUT_ACCURACY)
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
static PositionVector geomFromParamPoly(const OpenDriveEdge &e, const OpenDriveGeometry &g)
static void setNodeSecure(NBNodeCont &nc, OpenDriveEdge &e, const std::string &nodeID, NIImporter_OpenDrive::LinkType lt)
void push_back_noDoublePos(const Position &p)
insert in back a non double position
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.
Coefficients of an elevation profile (3rd degree polynomial)