60 #ifdef CHECK_MEMORY_LEAKS
62 #endif // CHECK_MEMORY_LEAKS
163 std::map<std::string, OpenDriveEdge*> edges;
166 std::vector<std::string> files = oc.
getStringVector(
"opendrive-files");
167 for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
169 WRITE_ERROR(
"Could not open opendrive file '" + *file +
"'.");
178 std::map<std::string, OpenDriveEdge*> innerEdges, outerEdges;
179 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
180 if ((*i).second->isInner) {
181 innerEdges[(*i).first] = (*i).second;
183 outerEdges[(*i).first] = (*i).second;
198 std::map<std::string, Boundary> posMap;
199 std::map<std::string, std::string> edge2junction;
201 for (std::map<std::string, OpenDriveEdge*>::iterator i = innerEdges.begin(); i != innerEdges.end(); ++i) {
205 if (posMap.find(e->
junction) == posMap.end()) {
211 for (std::map<std::string, Boundary>::iterator i = posMap.begin(); i != posMap.end(); ++i) {
213 throw ProcessError(
"Could not add node '" + (*i).first +
"'.");
217 for (std::map<std::string, OpenDriveEdge*>::iterator i = outerEdges.begin(); i != outerEdges.end(); ++i) {
219 for (std::vector<OpenDriveLink>::iterator j = e->
links.begin(); j != e->
links.end(); ++j) {
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;
344 WRITE_WARNING(
"Edge '" + e->
id +
"' has to be split as it connects same junctions.")
362 std::string
id = e->
id;
363 if (sFrom != e->
from || sTo != e->
to) {
371 if ((*j).rightLaneNumber > 0) {
372 currRight =
new NBEdge(
"-" +
id, sFrom, sTo,
"", defaultSpeed, (*j).rightLaneNumber, priorityR,
379 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
380 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
381 if (lp != (*j).laneMap.end()) {
382 int sumoLaneIndex = lp->second;
393 if (prevRight != 0) {
395 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
399 prevRight = currRight;
404 if ((*j).leftLaneNumber > 0) {
405 currLeft =
new NBEdge(
id, sTo, sFrom,
"", defaultSpeed, (*j).leftLaneNumber, priorityL,
412 for (std::vector<OpenDriveLane>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
413 std::map<int, int>::const_iterator lp = (*j).laneMap.find((*k).id);
414 if (lp != (*j).laneMap.end()) {
415 int sumoLaneIndex = lp->second;
427 std::map<int, int> connections = (*j).getInnerConnections(
OPENDRIVE_TAG_LEFT, *(j - 1));
428 for (std::map<int, int>::const_iterator k = connections.begin(); k != connections.end(); ++k) {
449 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
453 std::vector<Connection> connections2;
454 for (std::map<std::string, OpenDriveEdge*>::iterator j = edges.begin(); j != edges.end(); ++j) {
455 const std::set<Connection>& conns = (*j).second->connections;
457 for (std::set<Connection>::const_iterator i = conns.begin(); i != conns.end(); ++i) {
458 if (innerEdges.find((*i).fromEdge) != innerEdges.end()) {
462 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
465 connections2.push_back(*i);
470 for (std::vector<Connection>::const_iterator i = connections2.begin(); i != connections2.end(); ++i) {
471 std::string fromEdge = (*i).fromEdge;
472 if (edges.find(fromEdge) == edges.end()) {
473 WRITE_WARNING(
"While setting connections: from-edge '" + fromEdge +
"' is not known.");
477 int fromLane = (*i).fromLane;
478 bool fromLast = ((*i).fromCP ==
OPENDRIVE_CP_END) ^ ((*i).fromLane > 0 && !(*i).all);
481 std::string toEdge = (*i).toEdge;
482 if (edges.find(toEdge) == edges.end()) {
483 WRITE_WARNING(
"While setting connections: to-edge '" + toEdge +
"' is not known.");
488 int toLane = (*i).toLane;
493 fromLane = toLast ? odTo->
laneSections.back().laneMap.begin()->first : odTo->
laneSections[0].laneMap.begin()->first;
509 WRITE_WARNING(
"Could not find fromEdge representation of '" + fromEdge +
"' in connection '" + (*i).origID +
"'.");
512 WRITE_WARNING(
"Could not find fromEdge representation of '" + toEdge +
"' in connection '" + (*i).origID +
"'.");
514 if (from == 0 || to == 0) {
520 if ((*i).origID !=
"") {
523 for (std::vector<NBEdge::Connection>::iterator k = cons.begin(); k != cons.end(); ++k) {
524 if ((*k).fromLane == fromLane && (*k).toEdge == to && (*k).toLane == toLane) {
525 (*k).origID = (*i).origID +
" " +
toString((*i).origLane);
536 std::map<std::string, std::string> tlsControlled;
537 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
539 for (std::vector<OpenDriveSignal>::const_iterator j = e->
signals.begin(); j != e->
signals.end(); ++j) {
540 if ((*j).type !=
"1000001") {
543 std::vector<OpenDriveLaneSection>::iterator k = e->
laneSections.begin();
546 if ((*j).s > (*k).s && (*j).s <= (*(k + 1)).s) {
556 std::string
id = (*k).sumoID;
560 std::string fromID, toID;
561 for (std::vector<OpenDriveLink>::const_iterator l = e->
links.begin(); l != e->
links.end(); ++l) {
566 fromID = (*l).elementID;
574 toID = (*l).elementID;
579 id = fromID +
"->" + toID;
581 WRITE_WARNING(
"Found a traffic light signal on an unknown edge (original edge id='" + e->
id +
"').");
586 if ((*j).orientation > 0) {
589 tlsControlled[id] = (*j).name;
593 for (std::map<std::string, std::string>::iterator i = tlsControlled.begin(); i != tlsControlled.end(); ++i) {
594 std::string
id = (*i).first;
595 if (
id.find(
"->") != std::string::npos) {
596 id =
id.substr(0,
id.find(
"->"));
600 WRITE_WARNING(
"Could not find edge '" +
id +
"' while building its traffic light.");
614 static_cast<NBOwnTLDef*
>(tlDef)->setSinglePhase();
623 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
624 oc.
unSet(
"geometry.min-dist");
626 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
641 const std::set<Connection>& conts = dest->
connections;
642 for (std::set<Connection>::const_iterator i = conts.begin(); i != conts.end(); ++i) {
643 if (innerEdges.find((*i).toEdge) != innerEdges.end()) {
644 std::vector<Connection> t;
646 for (std::vector<Connection>::const_iterator j = t.begin(); j != t.end(); ++j) {
656 if ((*i).fromLane == c.
toLane) {
673 for (std::vector<OpenDriveLink>::iterator i = e.
links.begin(); i != e.
links.end(); ++i) {
681 std::string edgeID = e.
id;
684 const std::map<int, int>& laneMap = laneSection.
laneMap;
687 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
704 if (edges.find(c.
fromEdge) == edges.end()) {
705 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
714 for (std::vector<OpenDriveLane>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
731 if (edges.find(c.
fromEdge) == edges.end()) {
732 WRITE_ERROR(
"While setting connections: incoming road '" + c.
fromEdge +
"' is not known.");
755 if (!nc.
insert(
id, pos)) {
769 throw ProcessError(
"Could not find node '" + nodeID +
"'.");
772 if (e.
to != 0 && e.
to != n) {
793 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
795 for (std::vector<OpenDriveGeometry>::iterator j = e.
geometries.begin(); j != e.
geometries.end(); ++j) {
797 std::vector<Position> geom;
816 for (std::vector<Position>::iterator k = geom.begin(); k != geom.end(); ++k) {
820 if (oc.
exists(
"geometry.min-dist") && oc.
isSet(
"geometry.min-dist")) {
823 for (
unsigned int j = 0; j < e.
geom.size(); ++j) {
834 for (std::map<std::string, OpenDriveEdge*>::iterator i = edges.begin(); i != edges.end(); ++i) {
836 std::vector<OpenDriveLaneSection>& laneSections = e.
laneSections;
838 std::vector<OpenDriveLaneSection> newSections;
839 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end(); ++j) {
840 std::vector<OpenDriveLaneSection> splitSections;
841 bool splitBySpeed = (*j).buildSpeedChanges(tc, splitSections);
843 newSections.push_back(*j);
845 std::copy(splitSections.begin(), splitSections.end(), back_inserter(newSections));
854 for (std::vector<OpenDriveLaneSection>::const_iterator j = laneSections.begin(); j != laneSections.end() && sorted; ++j) {
855 if ((*j).s <= lastS) {
861 WRITE_WARNING(
"The sections of edge '" + e.
id +
"' are not sorted properly.");
867 for (std::vector<OpenDriveLaneSection>::iterator j = laneSections.begin(); j != laneSections.end();) {
868 bool simlarToLast = fabs((*j).s - lastS) <
POSITION_EPS;
871 WRITE_WARNING(
"Almost duplicate s-value '" +
toString(lastS) +
"' for lane sections occured at edge '" + e.
id +
"'; second entry was removed.");
872 j = laneSections.erase(j);
881 std::vector<Position>
884 std::vector<Position> ret;
891 std::vector<Position>
894 std::vector<Position> ret;
899 std::vector<Point2D<double> > into;
901 for (std::vector<
Point2D<double> >::iterator i = into.begin(); i != into.end(); ++i) {
902 ret.push_back(
Position((*i).getX(), (*i).getY()));
908 std::vector<Position>
911 std::vector<Position> ret;
929 if (geo_posE - g.
s > g.
length) {
932 if (geo_posE - g.
s > g.
length) {
935 calcPointOnCurve(&endX, &endY, centerX, centerY, radius, geo_posE - geo_posS);
937 dist += (geo_posE - geo_posS);
939 ret.push_back(
Position(startX, startY));
945 if (geo_posE - (g.
s + g.
length) < 0.001 && geo_posE - (g.
s + g.
length) > -0.001) {
953 std::vector<Position>
956 std::vector<Position> ret;
964 ret.push_back(
Position(g.
x + xnew, g.
y + ynew));
974 double x2 = normx * cos(hdg) - normy * sin(hdg);
975 double y2 = normx * sin(hdg) + normy * cos(hdg);
978 return Position(start.
x() + normx, start.
y() + normy);
995 normX = normX * cos(ad_hdg) + normY * sin(ad_hdg);
996 normY = tmpX * sin(ad_hdg) + normY * cos(ad_hdg);
999 normX = turn * normY;
1000 normY = -turn * tmpX;
1002 normX = fabs(ad_radius) * normX;
1003 normY = fabs(ad_radius) * normY;
1013 double rotAngle = ad_length / fabs(ad_r);
1014 double vx = *ad_x - ad_centerX;
1015 double vy = *ad_y - ad_centerY;
1025 vx = vx * cos(rotAngle) + turn * vy * sin(rotAngle);
1026 vy = -1 * turn * tmpx * sin(rotAngle) + vy * cos(rotAngle);
1027 *ad_x = vx + ad_centerX;
1028 *ad_y = vy + ad_centerY;
1044 unsigned int sumoLane = 0;
1045 const std::vector<OpenDriveLane>& dirLanesR = lanesByDir.find(
OPENDRIVE_TAG_RIGHT)->second;
1046 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanesR.rbegin(); i != dirLanesR.rend(); ++i) {
1048 laneMap[(*i).id] = sumoLane++;
1051 rightLaneNumber = sumoLane;
1053 const std::vector<OpenDriveLane>& dirLanesL = lanesByDir.find(
OPENDRIVE_TAG_LEFT)->second;
1054 for (std::vector<OpenDriveLane>::const_iterator i = dirLanesL.begin(); i != dirLanesL.end(); ++i) {
1056 laneMap[(*i).id] = sumoLane++;
1059 leftLaneNumber = sumoLane;
1065 std::map<int, int> ret;
1066 const std::vector<OpenDriveLane>& dirLanes = lanesByDir.find(dir)->second;
1067 for (std::vector<OpenDriveLane>::const_reverse_iterator i = dirLanes.rbegin(); i != dirLanes.rend(); ++i) {
1068 std::map<int, int>::const_iterator toP = laneMap.find((*i).id);
1069 if (toP == laneMap.end()) {
1073 int to = (*toP).second;
1076 from = (*i).predecessor;
1079 std::map<int, int>::const_iterator fromP = prev.
laneMap.find(from);
1080 if (fromP != prev.
laneMap.end()) {
1081 from = (*fromP).second;
1087 if (ret.find(from) != ret.end()) {
1091 std::swap(from, to);
1110 if (i != l.
speeds.end()) {
1111 l.
speed = (*i).second;
1118 if (i != l.
speeds.end()) {
1119 l.
speed = (*i).second;
1128 std::set<SUMOReal> speedChangePositions;
1131 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1132 speedChangePositions.insert((*l).first);
1133 if ((*l).first == 0) {
1134 (*k).speed = (*l).second;
1139 for (std::vector<std::pair<SUMOReal, SUMOReal> >::const_iterator l = (*k).speeds.begin(); l != (*k).speeds.end(); ++l) {
1140 speedChangePositions.insert((*l).first);
1141 if ((*l).first == 0) {
1142 (*k).speed = (*l).second;
1147 if (speedChangePositions.size() == 0) {
1150 if (*speedChangePositions.begin() > 0) {
1151 speedChangePositions.insert(0);
1154 for (std::set<SUMOReal>::iterator i = speedChangePositions.begin(); i != speedChangePositions.end(); ++i) {
1155 if (i == speedChangePositions.begin()) {
1156 newSections.push_back(*
this);
1158 newSections.push_back(buildLaneSection(*i));
1162 for (
int i = 0; i != (
int)newSections.size(); ++i) {
1164 std::map<OpenDriveXMLTag, std::vector<OpenDriveLane> >& lanesByDir = ls.
lanesByDir;
1165 for (std::map<
OpenDriveXMLTag, std::vector<OpenDriveLane> >::iterator k = lanesByDir.begin(); k != lanesByDir.end(); ++k) {
1166 std::vector<OpenDriveLane>& lanes = (*k).second;
1167 for (
int j = 0; j != (
int)lanes.size(); ++j) {
1173 l.
speed = newSections[i - 1].lanesByDir[(*k).first][j].speed;
1191 for (std::vector<OpenDriveSignal>::const_iterator i = signals.begin(); i != signals.end(); ++i) {
1193 if ((*i).type ==
"301" || (*i).type ==
"306") {
1196 if ((*i).type ==
"205") {
1233 if (majorVersion != 1 || minorVersion != 2) {
1287 std::vector<SUMOReal> vals;
1292 std::vector<SUMOReal> vals;
1299 std::vector<SUMOReal> vals;
1305 std::vector<SUMOReal> vals;
1371 WRITE_ERROR(
"In laneLink-element: incoming road '" + c.fromEdge +
"' is not known.");
1383 l.width =
MAX2(l.width, width);
1440 const std::string& elementID,
1441 const std::string& contactPoint) {
1444 if (elementType ==
"road") {
1446 }
else if (elementType ==
"junction") {
1450 if (contactPoint ==
"start") {
1452 }
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 StringBijection< int >::Entry openDriveAttrs[]
The names of openDrive-XML attributes (for passing to GenericSAXHandler)
NBTypeCont & getTypeCont()
Returns the type container.
bool insert(const std::string &id, const Position &position, NBDistrict *district)
Inserts a node into the map.
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
Position positionAtOffset(SUMOReal pos) const
Returns the position at the given length.
void addLink(LinkType lt, const std::string &elementType, const std::string &elementID, const std::string &contactPoint)
Representation of an OpenDrive link.
std::string junction
The id of the junction the edge belongs to.
GeometryType
OpenDrive geometry type enumeration.
static std::vector< Position > geomFromPoly(const OpenDriveEdge &e, const OpenDriveGeometry &g)
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 insert(const std::string &id, int noLanes, SUMOReal maxSpeed, int prio, SUMOReal width, SUMOVehicleClass vClasses=SVC_UNKNOWN, bool oneWayIsDefault=false)
Adds a type into the list. This is a simplified convenience form of insert, if only one allowed vehic...
The base class for traffic light logic definitions.
ContactPoint myCurrentContactPoint
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false)
Adds a connection between the specified this edge's lane and an approached one.
SUMOReal s
The starting offset of this lane section.
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 bool runParser(GenericSAXHandler &handler, const std::string &file)
Runs the given handler on the given file; returns if everything's ok.
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
SUMOReal x() const
Returns the x-position.
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/s].
static NBNode * getOrBuildNode(const std::string &id, const Position &pos, NBNodeCont &nc)
Builds a node or returns the already built.
#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.
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].
bool operator<(const NBConnection &c1, const NBConnection &c2)
const std::string & getFileName() const
returns the current file name
void setFileName(const std::string &name)
Sets 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
static bool exists(std::string path)
Checks whether the given file exists.
SUMOReal width
The lane's width;.
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 StringBijection< int >::Entry openDriveTags[]
The names of openDrive-XML elements (for passing to GenericSAXHandler)
static bool myImportAllTypes
static std::vector< Position > geomFromLine(const OpenDriveEdge &e, const OpenDriveGeometry &g)
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.
T get(const std::string &str)
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)
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.
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)
static std::vector< Position > geomFromArc(const OpenDriveEdge &e, const OpenDriveGeometry &g)
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.
static std::vector< Position > geomFromSpiral(const OpenDriveEdge &e, const OpenDriveGeometry &g)
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.
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.