66 myVehicleClasses2Keep(0),
67 myVehicleClasses2Remove(0),
68 myNeedGeoTransformedPrunningBoundary(false) {
83 if (oc.
isSet(
"keep-edges.input-file")) {
86 if (oc.
isSet(
"remove-edges.input-file")) {
89 if (oc.
isSet(
"keep-edges.explicit")) {
90 const std::vector<std::string> edges = oc.
getStringVector(
"keep-edges.explicit");
93 if (oc.
isSet(
"remove-edges.explicit")) {
94 const std::vector<std::string> edges = oc.
getStringVector(
"remove-edges.explicit");
97 if (oc.
exists(
"keep-edges.by-vclass") && oc.
isSet(
"keep-edges.by-vclass")) {
100 if (oc.
exists(
"remove-edges.by-vclass") && oc.
isSet(
"remove-edges.by-vclass")) {
103 if (oc.
exists(
"keep-edges.by-type") && oc.
isSet(
"keep-edges.by-type")) {
104 const std::vector<std::string> types = oc.
getStringVector(
"keep-edges.by-type");
107 if (oc.
exists(
"remove-edges.by-type") && oc.
isSet(
"remove-edges.by-type")) {
108 const std::vector<std::string> types = oc.
getStringVector(
"remove-edges.by-type");
112 if (oc.
isSet(
"keep-edges.in-boundary") || oc.
isSet(
"keep-edges.in-geo-boundary")) {
114 "keep-edges.in-boundary" :
"keep-edges.in-geo-boundary");
116 std::vector<double> poly;
117 for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) {
120 if (poly.size() < 4) {
121 throw ProcessError(
"Invalid boundary: need at least 2 coordinates");
122 }
else if (poly.size() % 2 != 0) {
123 throw ProcessError(
"Invalid boundary: malformed coordinate");
124 }
else if (poly.size() == 4) {
131 for (std::vector<double>::iterator j = poly.begin(); j != poly.end();) {
144 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
169 if (oc.
exists(
"dismiss-vclasses") && oc.
getBool(
"dismiss-vclasses")) {
235 WRITE_ERROR(
"Cannot prune edges using a geo-boundary because no projection has been loaded");
252 EdgeCont::const_iterator i =
myEdges.find(
id);
254 if (retrieveExtracted) {
295 if (downstream ==
true) {
319 hints.push_back(hintedge);
322 for (EdgeVector::iterator i = hints.begin(); i != hints.end(); i++) {
324 for (EdgeVector::iterator j = candidates.begin(); j != candidates.end(); j++) {
325 NBEdge* poss_searched = (*j);
327 ? poss_searched->
myTo : poss_searched->
myFrom;
330 if (find(cont.begin(), cont.end(), hintedge) != cont.end()) {
331 return poss_searched;
347 std::string tid =
id +
"[";
348 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
349 if ((*i).first.find(tid) == 0) {
350 maxLength =
MAX2(maxLength, (
int)(*i).first.length());
355 std::vector<std::string> names;
356 names.push_back(
id +
"[1]");
357 names.push_back(
id +
"[0]");
358 while (names.size() > 0) {
360 std::string cid = names.back();
366 if ((
int)cid.length() + 3 < maxLength) {
367 names.push_back(cid +
"[1]");
368 names.push_back(cid +
"[0]");
405 if (
myEdges.count(newID) != 0) {
406 throw ProcessError(
"Attempt to rename edge using existing id '" + newID +
"'");
424 const std::string& firstEdgeName,
425 const std::string& secondEdgeName,
426 int noLanesFirstEdge,
int noLanesSecondEdge,
428 const int changedLeft) {
439 return splitAt(dc, edge, pos, node, firstEdgeName, secondEdgeName,
440 noLanesFirstEdge, noLanesSecondEdge, speed, changedLeft);
447 const std::string& firstEdgeName,
448 const std::string& secondEdgeName,
449 int noLanesFirstEdge,
int noLanesSecondEdge,
451 const int changedLeft
454 assert(changedLeft > -((
int)noLanesFirstEdge));
455 assert(changedLeft < (
int)noLanesSecondEdge);
458 std::pair<PositionVector, PositionVector> geoms =
461 geoms.first.pop_back();
469 NBEdge* one =
new NBEdge(firstEdgeName, edge->
myFrom, node, edge, geoms.first, noLanesFirstEdge);
470 NBEdge* two =
new NBEdge(secondEdgeName, node, edge->
myTo, edge, geoms.second, noLanesSecondEdge);
480 for (std::set<NBTrafficLightDefinition*>::iterator i = fromTLS.begin(); i != fromTLS.end(); ++i) {
481 (*i)->replaceRemoved(edge, -1, one, -1);
484 for (std::set<NBTrafficLightDefinition*>::iterator i = toTLS.begin(); i != toTLS.end(); ++i) {
485 (*i)->replaceRemoved(edge, -1, two, -1);
496 for (
int i2 = 0; i2 < (int)two->
getNumLanes(); i2++) {
525 std::set<EdgeSet> addLater;
526 for (std::set<EdgeSet>::iterator it = roundabouts.begin(); it != roundabouts.end(); ++it) {
528 if (roundaboutSet.count(orig) > 0) {
529 roundaboutSet.erase(orig);
530 roundaboutSet.insert(part1);
531 roundaboutSet.insert(part2);
533 addLater.insert(roundaboutSet);
536 roundabouts.insert(addLater.begin(), addLater.end());
541 std::vector<std::string>
543 std::vector<std::string> ret;
544 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
545 ret.push_back((*i).first);
555 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
556 NBEdge* edge = (*i).second;
560 toRemove.push_back(edge);
563 for (EdgeVector::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
571 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
572 if ((*i).second->getGeometry().size() < 3) {
575 (*i).second->splitGeometry(*
this, nc);
582 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
583 (*i).second->reduceGeometry(minDist);
590 if (maxAngle > 0 || minRadius > 0) {
591 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
592 (*i).second->checkGeometry(maxAngle, minRadius, fix);
601 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
602 (*i).second->clearControllingTLInformation();
609 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
610 (*i).second->sortOutgoingConnectionsByAngle();
617 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
618 (*i).second->computeEdge2Edges(noLeftMovers);
625 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
626 (*i).second->computeLanes2Edges();
633 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
638 const std::string& oppositeID = edge->
getLanes().back().oppositeID;
639 if (oppositeID !=
"" && oppositeID !=
"-") {
640 NBEdge* oppEdge =
retrieve(oppositeID.substr(0, oppositeID.rfind(
"_")));
642 WRITE_WARNING(
"Removing unknown opposite lane '" + oppositeID +
"' for edge '" + edge->
getID() +
"'.");
651 throw ProcessError(
"Opposite lane '" + oppositeID +
"' does not connect the same nodes as edge '" + edge->
getID() +
"'!");
661 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
662 (*i).second->appendTurnaround(noTLSControlled,
true);
669 for (std::set<std::string>::const_iterator it = ids.begin(); it != ids.end(); it++) {
670 myEdges[*it]->appendTurnaround(noTLSControlled,
false);
677 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
678 (*i).second->computeEdgeShape();
685 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
686 (*i).second->computeLaneShapes();
707 NBEdge* tpledge = *(edges.begin());
708 NBNode* from = tpledge->getFromNode();
709 NBNode* to = tpledge->getToNode();
710 EdgeVector::const_iterator i;
711 for (i = edges.begin(); i != edges.end(); i++) {
713 assert((*i)->getFromNode() == from);
714 assert((*i)->getToNode() == to);
716 nolanes += (*i)->getNumLanes();
718 if (i != edges.begin()) {
723 speed += (*i)->getSpeed();
725 priority =
MAX2(priority, (*i)->getPriority());
727 speed /= edges.size();
729 NBEdge* newEdge =
new NBEdge(
id, from, to,
"", speed, nolanes, priority,
731 tpledge->getStreetName(), tpledge->myLaneSpreadFunction);
734 for (i = edges.begin(); i != edges.end(); ++i) {
735 const std::vector<NBEdge::Lane>& lanes = (*i)->
getLanes();
736 for (
int j = 0; j < (int)lanes.size(); ++j) {
750 for (i = edges.begin(); i != edges.end(); i++) {
752 for (EdgeVector::iterator j = ev.begin(); j != ev.end(); j++) {
758 for (i = edges.begin(); i != edges.end(); i++) {
760 currLane += (*i)->getNumLanes();
764 for (i = edges.begin(); i != edges.end(); i++) {
765 int noLanes = (*i)->getNumLanes();
766 for (
int j = 0; j < noLanes; j++, currLane++) {
772 for (i = edges.begin(); i != edges.end(); i++) {
781 const double distanceThreshold = 7;
782 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
791 if ((*j)->getToNode() == edge->
getFromNode() && !(*j)->getLanes().empty()) {
793 if (distance < distanceThreshold) {
810 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
824 const std::string oppositeID = edgeID[0] ==
'-' ? edgeID.substr(1) :
"-" + edgeID;
825 EdgeCont::const_iterator it =
myEdges.find(oppositeID);
831 EdgeCont::const_iterator it =
myEdges.find(edgeID);
838 bool keepClear,
double contPos,
double visibility,
bool warnOnly) {
849 if (from == 0 || to == 0 ||
851 const std::string msg =
"Could not insert connection between '" + (*i).from +
"' and '" + (*i).to +
"' after build.";
852 if (warnOnly || (*i).warnOnly) {
861 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); ++it) {
862 NBEdge* edge = it->second;
865 std::vector<NBEdge::Connection> connections = edge->
getConnections();
866 for (std::vector<NBEdge::Connection>::iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
870 "' to edge '" + c.
toEdge->
getID() +
"' via junction '" + to->
getID() +
"'.");
880 int len = (int)
id.length();
882 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
883 std::string curr = (*i).first;
886 if ((
int)curr.length() <= len) {
891 if (curr.substr(0, len) ==
id && curr[len] ==
'[') {
892 ret.push_back((*i).second);
896 std::string::size_type pos = curr.find(
id);
898 if (pos == std::string::npos) {
903 if (curr[pos - 1] !=
']' && curr[pos - 1] !=
'+') {
908 if (pos +
id.length() < curr.length()) {
909 if (curr[pos +
id.length()] !=
'[' && curr[pos +
id.length()] !=
'+') {
914 ret.push_back((*i).second);
923 std::set<NBEdge*> loadedRoundaboutEdges;
925 loadedRoundaboutEdges.insert(it->begin(), it->end());
929 std::set<NBEdge*> candidates;
930 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
934 candidates.insert(e);
939 std::set<NBEdge*> visited;
940 for (std::set<NBEdge*>::const_iterator i = candidates.begin(); i != candidates.end(); ++i) {
947 if (visited.count(e) > 0) {
951 loopEdges.push_back(e);
956 if (edges.size() < 2) {
965 EdgeVector::const_iterator me = find(edges.begin(), edges.end(), e);
974 EdgeVector::const_iterator loopClosed = find(loopEdges.begin(), loopEdges.end(), left);
975 const int loopSize = (int)(loopEdges.end() - loopClosed);
980 }
else if (loopSize < (
int)loopEdges.size()) {
982 EdgeVector(loopEdges.begin() + (loopEdges.size() - loopSize), loopEdges.end()).swap(loopEdges);
986 for (EdgeVector::const_iterator j = loopEdges.begin(); j != loopEdges.end(); ++j) {
987 if ((*j)->getToNode()->getEdges().size() > 2) {
991 if (attachments < 3) {
996 if (visited.count(left) > 0) {
1000 loopEdges.push_back(left);
1019 for (EdgeVector::const_iterator it = loopEdges.begin(); it != loopEdges.end(); ++it) {
1020 points.
append((*it)->getGeometry());
1022 double circumference = points.
length2D();
1023 return 4 *
M_PI * points.
area() / (circumference * circumference);
1027 const std::set<EdgeSet>
1037 if (roundabout.size() > 0) {
1050 for (std::set<EdgeSet>::const_iterator it = roundabouts.begin(); it != roundabouts.end(); ++it) {
1051 const EdgeSet roundaboutSet = *it;
1052 for (std::set<NBEdge*>::const_iterator j = roundaboutSet.begin(); j != roundaboutSet.end(); ++j) {
1054 NBNode* node = (*j)->getToNode();
1056 for (EdgeVector::const_iterator k = incoming.begin(); k != incoming.end(); ++k) {
1058 if (roundaboutSet.count(inEdge) > 0) {
1076 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1116 int sidewalksCreated = 0;
1118 std::set<std::string> exclude(edges.begin(), edges.end());
1119 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1120 NBEdge* edge = it->second;
1122 exclude.count(edge->
getID()) == 0
1129 || (!fromPermissions && edge->
getSpeed() > minSpeed && edge->
getSpeed() <= maxSpeed)
1132 sidewalksCreated += 1;
1135 return sidewalksCreated;
1142 std::set<std::string> reserve;
1145 avoid.insert(avoid.end(), reserve.begin(), reserve.end());
1148 std::set<NBEdge*, Named::ComparatorIdLess> toChange;
1149 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1154 toChange.insert(it->second);
1157 if (reservedIDs && reserve.count(it->first) > 0) {
1158 toChange.insert(it->second);
1161 for (std::set<NBEdge*, Named::ComparatorIdLess>::iterator it = toChange.begin(); it != toChange.end(); ++it) {
1167 return (
int)toChange.size();
1173 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1174 const NBEdge* e1 = it->second;
1180 for (EdgeCont::const_iterator it2 = it; it2 !=
myEdges.end(); it2++) {
1181 const NBEdge* e2 = it2->second;
1190 const double overlap = outline1.
getOverlapWith(outline2, zThreshold);
1191 if (overlap > threshold) {
1202 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1203 const NBEdge* edge = it->second;
1204 for (
int i = 0; i < (int)edge->
getNumLanes(); i++) {
1206 if (grade > threshold) {
1211 const std::vector<NBEdge::Connection>& connections = edge->
getConnections();
1212 for (std::vector<NBEdge::Connection>::const_iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
1215 if (grade > threshold) {
static double relAngle(double angle1, double angle2)
computes the relative angle between the two angles
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass, bool keepClear, double contPos, double visibility, bool warnOnly=false)
Adds a connection which could not be set during loading.
std::vector< Lane > myLanes
Lane information.
double getLength() const
Returns the computed length of the edge.
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
double length2D() const
Returns the length.
A structure which describes a connection between edges or lanes.
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
void setRoundabout()
update the type of this node as a roundabout
A class representing a single street sign.
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
PositionVector shape
The lane's shape.
void append(const PositionVector &v, double sameThreshold=2.0)
void addSign(NBSign sign)
add Sign
NBEdge * toEdge
The edge the connections yields in.
void reduceGeometries(const double minDist)
static void loadPrefixedIDsFomFile(const std::string &file, const std::string prefix, std::set< std::string > &into)
Add prefixed ids defined in file.
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
bool myNeedGeoTransformedPrunningBoundary
whether a geo transform has been applied to the pruning boundary
A container for traffic light definitions and built programs.
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
const std::string & getTypeID() const
get ID of type
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
The representation of a single edge during network building.
void guessOpposites()
Sets opposite lane information for geometrically close edges.
A container for districts.
static const double UNSPECIFIED_OFFSET
unspecified lane offset
static GeoConvHelper & getLoaded()
the coordinate transformation that was loaded fron an input file
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false)
Removes the specified connection(s)
void removeDoubleEdges()
remove duble edges
NBEdge * getTurnDestination(bool possibleDestination=false) const
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
void generateStreetSigns()
assigns street signs to edges based on toNode types
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
void recheckPostProcessConnections()
Try to set any stored connections.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
static long long int _str2long(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter, which
bool getShallBeDiscarded(const std::string &type) const
Returns the information whether edges of this type shall be discarded.
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getID() const
Returns the id.
Lane & getLaneStruct(int lane)
bool overlapsWith(const AbstractPoly &poly, double offset=0) const
Returns whether the boundary overlaps with the given polygon.
std::vector< double > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
static void loadEdgesFromFile(const std::string &file, std::set< std::string > &into)
Add edge ids defined in file (either ID or edge:ID per line) into the given set.
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
std::string getDescription(const NBEdge *parent) const
get string describing this connection
std::pair< PositionVector, PositionVector > splitAt(double where) const
Returns the two lists made when this list vector is splitted at the given point.
static const double UNSPECIFIED_WIDTH
unspecified lane width
A class that stores a 2D geometrical boundary.
std::vector< PostProcessConnection > myConnections
The list of connections to recheck.
void replaceOutgoing(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of outgoing by the second Connections are remap...
#define WRITE_WARNING(msg)
static OptionsCont & getOptions()
Retrieves the options.
void checkGeometries(const double maxAngle, const double minRadius, bool fix)
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
double area() const
Returns the area (0 for non-closed)
void checkGrade(double threshold) const
check whether edges are to steep
PositionVector shape
shape of Connection
NBEdgeCont(NBTypeCont &tc)
Constructor.
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
An (internal) definition of a single lane of an edge.
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
bool knows(const std::string &type) const
Returns whether the named type is in the container.
static double nearest_offset_on_line_to_point2D(const Position &lineStart, const Position &lineEnd, const Position &p, bool perpendicular=true)
double myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
std::set< NBEdge * > EdgeSet
container for unique edges
void patchRoundabouts(NBEdge *orig, NBEdge *part1, NBEdge *part2, std::set< EdgeSet > &roundabouts)
fix roundabout information after splitting an edge
std::string getNext()
Returns the next id.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
std::string getLaneID(int lane) const
get Lane ID (Secure)
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
int getNumLanes() const
Returns the number of lanes.
A point in 2D or 3D with translation and scaling methods.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
bool exists(const std::string &name) const
Returns the information whether the named option is known.
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
static double formFactor(const EdgeVector &loopEdges)
compute the form factor for a loop of edges
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) ...
void splitGeometry(NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
EdgeCont myEdges
The instance of the dictionary (id->edge)
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
Boundary & grow(double by)
extends the boundary by the given amount
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
void clear()
Deletes all edges.
EdgeCont myExtractedEdges
The extracted nodes which are kept for reference.
The connection was given by the user.
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout) ...
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again ...
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
double getSpeed() const
Returns the speed allowed on this edge.
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed) ...
const PositionVector & getGeometry() const
Returns the geometry of the edge.
PositionVector myPrunningBoundary
Boundary within which an edge must be located in order to be kept.
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
int guessSidewalks(double width, double minSpeed, double maxSpeed, bool fromPermissions)
add sidwalks to edges within the given limits or permissions and return the number of edges affected ...
void setID(const std::string &newID)
resets the id
double length() const
Returns the length.
PositionVector viaShape
shape of via
std::string oppositeID
An opposite lane ID, if given.
void appendTurnarounds(bool noTLSControlled)
Appends turnarounds to all edges stored in the container.
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
const std::vector< Connection > & getConnections() const
Returns the connections.
void replaceIncoming(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of incoming by the second Connections are remap...
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node) ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
A storage for options typed value containers)
static double _2double(const E *const data)
converts a char-type array into the double value described by it
SumoXMLNodeType getType() const
Returns the type of this node.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
A structure representing a connection between two lanes.
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge's lane and an approached one.
void computeEdgeShapes()
Computes the shapes of all edges stored in the container.
The connection was computed.
const Position & getPosition() const
Represents a single node (junction) during network building.
void dismissVehicleClassInformation()
dimiss vehicle class information
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation. ...
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
double getMaxGrade() const
return the maximum grade of all segments as a fraction of zRange/length2D
NBNode * getFromNode() const
Returns the origin node of the edge.
void removeFromSinksAndSources(NBEdge *const e)
Removes the given edge from the lists of sources and sinks in all stored districts.
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Container for nodes during the netbuilding process.
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node ...
static T maxValue(const std::vector< T > &v)
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
double getOverlapWith(const PositionVector &poly, double zThreshold) const
Returns the maximum overlaps between this and the given polygon (when not separated by at least zThre...
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)
Replaces occurences of the removed edge/lane in all definitions by the given edge.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
int remapIDs(bool numericaIDs, bool reservedIDs)
remap node IDs accoring to options –numerical-ids and –reserved-ids
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
NBNode * myFrom
The source and the destination node.
NBNode * getToNode() const
Returns the destination node of the edge.
bool isSimpleContinuation(bool checkLaneNumbers=true) const
check if node is a simple continuation
void copyConnectionsFrom(NBEdge *src)
copy connections from antoher edge
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
A storage for available types of edges.
int myEdgesSplit
the number of splits of edges during the building
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.