51 #ifdef CHECK_MEMORY_LEAKS
53 #endif // CHECK_MEMORY_LEAKS
76 myCrossings(junction->getCrossings()) {
81 myDone.reserve(variations);
82 for (
int i = 0; i < variations; i++) {
87 for (NBConnectionProhibits::const_iterator j = loadedProhibits.begin(); j != loadedProhibits.end(); j++) {
89 bool ok1 = prohibited.
check(ec);
104 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
106 bool ok2 = sprohibiting.
check(ec);
119 myDone[idx2][idx1] =
true;
120 myDone[idx1][idx2] =
true;
125 std::string ptID = prohibited.
getTo() != 0 ? prohibited.
getTo()->
getID() :
"UNKNOWN";
126 std::string bfID = sprohibiting.
getFrom() != 0 ? sprohibiting.
getFrom()->
getID() :
"UNKNOWN";
127 std::string btID = sprohibiting.
getTo() != 0 ? sprohibiting.
getTo()->
getID() :
"UNKNOWN";
128 WRITE_WARNING(
"could not prohibit " + pfID +
"->" + ptID +
" by " + bfID +
"->" + btID);
135 for (
int s1 = 0; s1 < variations; s1++) {
136 for (
int s2 = s1 + 1; s2 < variations; s2++) {
157 EdgeVector::const_iterator i, j;
173 EdgeVector::const_iterator pfrom = find(
myAll.begin(),
myAll.end(), from);
174 while (*pfrom != to) {
177 EdgeVector::const_iterator pto = find(
myAll.begin(),
myAll.end(), to);
178 while (*pto != from) {
191 EdgeVector::const_iterator pfrom = find(
myAll.begin(),
myAll.end(), from);
192 while (*pfrom != to) {
195 EdgeVector::const_iterator pto = find(
myAll.begin(),
myAll.end(), to);
196 while (*pto != from) {
211 if (to1 == 0 || to2 == 0) {
217 if (idx1 < 0 || idx2 < 0) {
226 myDone[idx1][idx2] =
true;
227 myDone[idx2][idx1] =
true;
251 if (from1p > from2p) {
255 if (from2p > from1p) {
283 EdgeVector::const_iterator c1 = find(
myAll.begin(),
myAll.end(), from1);
286 while (*c1 != from1 && *c1 != from2) {
295 EdgeVector::const_iterator c2 = find(
myAll.begin(),
myAll.end(), from2);
298 while (*c2 != from2 && *c2 != from1) {
311 EdgeVector::const_iterator p = find(
myAll.begin(),
myAll.end(), from);
315 if (p ==
myAll.begin()) {
327 EdgeVector::const_iterator i;
330 int noLanes = (*i)->getNumLanes();
331 for (
int k = 0; k < noLanes; k++) {
336 for (std::vector<NBNode::Crossing>::const_iterator i =
myCrossings.begin(); i !=
myCrossings.end(); i++) {
346 int noLanesEdge1 = (*i11)->getNumLanes();
347 for (
int j1 = 0; j1 < noLanesEdge1; j1++) {
348 std::vector<NBEdge::Connection> el1 = (*i11)->getConnectionsFromLane(j1);
349 for (std::vector<NBEdge::Connection>::iterator i12 = el1.begin(); i12 != el1.end(); ++i12) {
350 int idx1 =
getIndex((*i11), (*i12).toEdge);
356 int noLanesEdge2 = (*i21)->getNumLanes();
357 for (
int j2 = 0; j2 < noLanesEdge2; j2++) {
358 std::vector<NBEdge::Connection> el2 = (*i21)->getConnectionsFromLane(j2);
359 for (std::vector<NBEdge::Connection>::iterator i22 = el2.begin(); i22 != el2.end(); i22++) {
360 int idx2 =
getIndex((*i21), (*i22).toEdge);
366 if ((*i11) == (*i21)) {
373 if (((*i12).tlID ==
"" && (*i22).tlID ==
"")
375 ((*i12).tlID !=
"" && (*i22).tlID !=
"")) {
381 if (!
foes(*i11, (*i12).toEdge, *i21, (*i22).toEdge)) {
386 if ((*i12).tlID !=
"") {
406 for (EdgeVector::const_iterator i =
myIncoming.begin();
408 int noLanesEdge = (*i)->getNumLanes();
409 for (
int j = 0; j < noLanesEdge; j++) {
410 int numConnections = (int)(*i)->getConnectionsFromLane(j).size();
411 noLinks += numConnections;
412 if (numConnections > 0) {
417 return std::make_pair(noLanes, noLinks);
423 const NBEdge*
const from2,
const NBEdge*
const to2)
const {
425 if (to1 == 0 || to2 == 0) {
431 if (idx1 < 0 || idx2 < 0) {
442 const NBEdge*
const possProhibitedFrom,
const NBEdge*
const possProhibitedTo,
443 bool regardNonSignalisedLowerPriority)
const {
445 if (possProhibitorTo == 0 || possProhibitedTo == 0) {
449 int possProhibitorIdx =
getIndex(possProhibitorFrom, possProhibitorTo);
450 int possProhibitedIdx =
getIndex(possProhibitedFrom, possProhibitedTo);
451 if (possProhibitorIdx < 0 || possProhibitedIdx < 0) {
457 if (!regardNonSignalisedLowerPriority) {
458 return myForbids[possProhibitorIdx][possProhibitedIdx];
461 if (!
myForbids[possProhibitorIdx][possProhibitedIdx]) {
474 int fromLane,
int pos,
const bool checkLaneFoes)
const {
476 for (std::vector<NBEdge::Connection>::iterator j = connected.begin(); j != connected.end(); j++) {
477 assert((*j).toEdge != 0);
480 const std::string
foes =
getFoesString(from, (*j).toEdge, fromLane, (*j).toLane, checkLaneFoes);
482 :
getResponseString((*j).tlLinkNo, from, (*j).toEdge, fromLane, (*j).toLane, (*j).mayDefinitelyPass, checkLaneFoes));
503 for (
int j = noLanes; j-- > 0;) {
505 int size = (int) connected.size();
506 for (
int k = size; k-- > 0;) {
507 const NBEdge* to = connected[k].toEdge;
509 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
510 if ((*it_e) == from || (*it_e) == to) {
515 foes += foe ?
'1' :
'0';
532 int fromLane,
int toLane,
bool mayDefinitelyPass,
const bool checkLaneFoes)
const {
540 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
547 int noLanes = (*i)->getNumLanes();
548 for (
int j = noLanes; j-- > 0;) {
549 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
550 int size = (int) connected.size();
551 for (
int k = size; k-- > 0;) {
552 if (mayDefinitelyPass) {
554 }
else if ((*i) == from && fromLane == j) {
558 assert(k < (
int) connected.size());
560 assert(connected[k].toEdge != 0);
564 (!checkLaneFoes ||
laneConflict(from, to, toLane, *i, connected[k].toEdge, connected[k].toLane)))
589 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
591 for (EdgeVector::const_iterator it_e = (*i).edges.begin(); it_e != (*i).edges.end(); ++it_e) {
592 if ((*it_e) == from || (*it_e) == to) {
597 result += foes ?
'1' :
'0';
601 for (EdgeVector::const_reverse_iterator i =
myIncoming.rbegin();
604 for (
int j = (
int)(*i)->getNumLanes() - 1; j >= 0; --j) {
605 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
606 int size = (int) connected.size();
607 for (
int k = size; k-- > 0;) {
608 if ((
foes(from, to, (*i), connected[k].toEdge) &&
609 (!checkLaneFoes ||
laneConflict(from, to, toLane, *i, connected[k].toEdge, connected[k].toLane)))
626 return (from == prohibitorFrom
641 const NBEdge* prohibitorFrom,
const NBEdge* prohibitorTo,
int prohibitorToLane)
const {
642 if (to != prohibitorTo) {
657 return rightOfProhibitor ? toLane >= prohibitorToLane : toLane <= prohibitorToLane;
676 for (
int i = 0; i < variations; i++) {
678 for (
int j = 0; j < variations; j++) {
706 for (
int idx1 = 0; idx1 <
numLinks(); idx1++) {
713 if (includePedCrossings) {
714 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
724 const std::vector<NBEdge::Connection>& cons = from->
getConnections();
725 for (std::vector<NBEdge::Connection>::const_iterator i = cons.begin(); i != cons.end(); i++) {
727 from, (*i).toEdge, (*i).fromLane)) {
735 int noLanes = (*i)->getNumLanes();
736 for (
int j = noLanes; j-- > 0;) {
737 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
738 const int size = (int) connected.size();
739 for (
int k = size; k-- > 0;) {
740 if ((*i) == from && fromLane != j
755 if (crossing.
priority || mustYield) {
756 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
758 if (((*it_e) == from && crossing.
priority) || (*it_e) == to) {
769 const NBEdge*
const possProhibitedFrom,
const NBEdge*
const possProhibitedTo)
const {
771 int idx1 =
getIndex(possProhibitorFrom, possProhibitorTo);
772 int idx2 =
getIndex(possProhibitedFrom, possProhibitedTo);
789 std::map<NBEdge*, int> incomingCount;
791 std::map<NBEdge*, std::set<int> > approachedLanes;
793 std::map<NBEdge*, EdgeVector> incomingEdges;
795 const std::vector<NBEdge::Connection> connections = (*it_e)->getConnections();
796 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); ++it_c) {
797 incomingCount[it_c->toEdge]++;
798 approachedLanes[it_c->toEdge].insert(it_c->toLane);
799 incomingEdges[it_c->toEdge].push_back(*it_e);
802 for (std::map<NBEdge*, int>::iterator it = incomingCount.begin(); it != incomingCount.end(); ++it) {
805 if ((
int)approachedLanes[to].size() >= it->second) {
808 for (EdgeVector::iterator it_e1 = incoming.begin(); it_e1 != incoming.end(); ++it_e1) {
809 for (EdgeVector::iterator it_e2 = incoming.begin(); it_e2 != incoming.end(); ++it_e2) {
int getIndex(const NBEdge *const from, const NBEdge *const to) const
Returns the index to the internal combination container for the given edge combination.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
void computeLeftOutgoingLinkCrossings(NBEdge *from, NBEdge *to)
bool check(const NBEdgeCont &ec)
checks whether the edges are still valid
A structure which describes a connection between edges or lanes.
int toLane
The lane the connections yields in.
std::vector< bool > LinkInfoCont
NBEdge * toEdge
The edge the connections yields in.
int writeCrossingResponse(OutputDevice &od, const NBNode::Crossing &crossing, int pos) const
writes the response of a certain crossing Returns the next link index within the junction ...
NBRequest(const NBEdgeCont &ec, NBNode *junction, const EdgeVector &all, const EdgeVector &incoming, const EdgeVector &outgoing, const NBConnectionProhibits &loadedProhibits)
std::vector< Connection > getConnectionsFromLane(int lane) const
Returns connections from a given lane.
std::ostream & operator<<(std::ostream &os, const NBRequest &r)
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
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.
NBNode * myJunction
the node the request is assigned to
void buildBitfieldLogic()
const EdgeVector & myOutgoing
static bool mergeConflict(const NBEdge *from, const NBEdge::Connection &con, const NBEdge *prohibitorFrom, const NBEdge::Connection &prohibitorCon, bool foes)
whether multple connections from the same edge target the same lane
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
void setBlocking(NBEdge *from1, NBEdge *to1, NBEdge *from2, NBEdge *to2)
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
int numLinks() const
return to total number of edge-to-edge connections of this request-logic
void writeLogic(std::string key, OutputDevice &into, const bool checkLaneFoes) const
NBEdge * getFrom() const
returns the from-edge (start of the connection)
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
const EdgeVector & myIncoming
static OptionsCont & getOptions()
Retrieves the options.
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane, bool lefthand=false)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
bool priority
whether the pedestrians have priority
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
static void reportWarnings()
reports warnings if any occured
static bool mustBrakeForCrossing(const NBNode *node, const NBEdge *const from, const NBEdge *const to, const NBNode::Crossing &crossing)
Returns the information whether the described flow must brake for the given crossing.
const std::string & getID() const
Returns the id.
Connection getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection This method goes through "myConnections" and returns the specified o...
int fromLane
The lane the connections starts at.
std::pair< int, int > getSizes() const
returns the number of the junction's lanes and the number of the junction's links in respect...
bool mustBrake(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
bool laneConflict(const NBEdge *from, const NBEdge *to, int toLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorToLane) const
return whether the given laneToLane connections prohibit each other under the assumption that the edg...
SumoXMLNodeType getType() const
Returns the type of this node.
int getNumLanes() const
Returns the number of lanes.
void computeRightOutgoingLinkCrossings(NBEdge *from, NBEdge *to)
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Information within the junction logic which internal lanes block external.
Storage for edges, including some functionality operating on multiple edges.
The link is a (hard) right direction.
std::string getFoesString(NBEdge *from, NBEdge *to, int fromLane, int toLane, const bool checkLaneFoes) const
bool rightOnRedConflict(int index, int foeIndex) const
whether the given index must yield to the foeIndex while turing right on a red light ...
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
The link is a partial right direction.
std::vector< NBConnection > NBConnectionVector
Definition of a connection vector.
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
NBNode * getToNode() const
Returns the destination node of the edge.
std::string getResponseString(int tlIndex, const NBEdge *const from, const NBEdge *const to, int fromLane, int toLane, bool mayDefinitelyPass, const bool checkLaneFoes) const
Writes the response of a certain link.
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
int writeLaneResponse(OutputDevice &od, NBEdge *from, int lane, int pos, const bool checkLaneFoes) const
writes the response of a certain lane Returns the next link index within the junction ...
std::vector< NBEdge * > EdgeVector
NBEdge * getTo() const
returns the to-edge (end of the connection)
const std::vector< NBNode::Crossing > & myCrossings
EdgeVector edges
The edges being crossed.
Represents a single node (junction) during network building.
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Check if edge has signalised connections.
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
A definition of a pedestrian crossing.
Static storage of an output device and its base (abstract) implementation.
bool closeTag()
Closes the most recently opened tag.
static SUMOReal relAngle(SUMOReal angle1, SUMOReal angle2)
int distanceCounterClockwise(NBEdge *from, NBEdge *to)
Information whether the detector shall be continued on the folowing lanes.
const std::vector< Connection > & getConnections() const
Returns the connections.
void resetCooperating()
reset foes it the number of lanes matches (or exceeds) the number of incoming connections for an edge...
static void nextCCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
CombinationsCont myForbids
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
SUMOReal getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
NBNode * getFromNode() const
Returns the origin node of the edge.