72 myCrossings(junction->getCrossings()) {
77 myDone.reserve(variations);
78 for (
int i = 0; i < variations; i++) {
83 for (NBConnectionProhibits::const_iterator j = loadedProhibits.begin(); j != loadedProhibits.end(); j++) {
85 bool ok1 = prohibited.
check(ec);
100 for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
102 bool ok2 = sprohibiting.
check(ec);
115 myDone[idx2][idx1] =
true;
116 myDone[idx1][idx2] =
true;
121 std::string ptID = prohibited.
getTo() != 0 ? prohibited.
getTo()->
getID() :
"UNKNOWN";
122 std::string bfID = sprohibiting.
getFrom() != 0 ? sprohibiting.
getFrom()->
getID() :
"UNKNOWN";
123 std::string btID = sprohibiting.
getTo() != 0 ? sprohibiting.
getTo()->
getID() :
"UNKNOWN";
124 WRITE_WARNING(
"could not prohibit " + pfID +
"->" + ptID +
" by " + bfID +
"->" + btID);
131 for (
int s1 = 0; s1 < variations; s1++) {
132 for (
int s2 = s1 + 1; s2 < variations; s2++) {
153 EdgeVector::const_iterator i, j;
169 EdgeVector::const_iterator pfrom = find(
myAll.begin(),
myAll.end(), from);
170 while (*pfrom != to) {
173 EdgeVector::const_iterator pto = find(
myAll.begin(),
myAll.end(), to);
174 while (*pto != from) {
187 EdgeVector::const_iterator pfrom = find(
myAll.begin(),
myAll.end(), from);
188 while (*pfrom != to) {
191 EdgeVector::const_iterator pto = find(
myAll.begin(),
myAll.end(), to);
192 while (*pto != from) {
207 if (to1 == 0 || to2 == 0) {
213 if (idx1 < 0 || idx2 < 0) {
222 myDone[idx1][idx2] =
true;
223 myDone[idx2][idx1] =
true;
247 if (from1p > from2p) {
251 if (from2p > from1p) {
279 EdgeVector::const_iterator c1 = find(
myAll.begin(),
myAll.end(), from1);
282 while (*c1 != from1 && *c1 != from2) {
291 EdgeVector::const_iterator c2 = find(
myAll.begin(),
myAll.end(), from2);
294 while (*c2 != from2 && *c2 != from1) {
307 EdgeVector::const_iterator p = find(
myAll.begin(),
myAll.end(), from);
311 if (p ==
myAll.begin()) {
323 EdgeVector::const_iterator i;
326 int noLanes = (*i)->getNumLanes();
327 for (
int k = 0; k < noLanes; k++) {
332 for (std::vector<NBNode::Crossing>::const_iterator i =
myCrossings.begin(); i !=
myCrossings.end(); i++) {
342 int noLanesEdge1 = (*i11)->getNumLanes();
343 for (
int j1 = 0; j1 < noLanesEdge1; j1++) {
344 std::vector<NBEdge::Connection> el1 = (*i11)->getConnectionsFromLane(j1);
345 for (std::vector<NBEdge::Connection>::iterator i12 = el1.begin(); i12 != el1.end(); ++i12) {
346 int idx1 =
getIndex((*i11), (*i12).toEdge);
352 int noLanesEdge2 = (*i21)->getNumLanes();
353 for (
int j2 = 0; j2 < noLanesEdge2; j2++) {
354 std::vector<NBEdge::Connection> el2 = (*i21)->getConnectionsFromLane(j2);
355 for (std::vector<NBEdge::Connection>::iterator i22 = el2.begin(); i22 != el2.end(); i22++) {
356 int idx2 =
getIndex((*i21), (*i22).toEdge);
362 if ((*i11) == (*i21)) {
369 if (((*i12).tlID ==
"" && (*i22).tlID ==
"")
371 ((*i12).tlID !=
"" && (*i22).tlID !=
"")) {
377 if (!
foes(*i11, (*i12).toEdge, *i21, (*i22).toEdge)) {
382 if ((*i12).tlID !=
"") {
402 for (EdgeVector::const_iterator i =
myIncoming.begin();
404 int noLanesEdge = (*i)->getNumLanes();
405 for (
int j = 0; j < noLanesEdge; j++) {
406 int numConnections = (int)(*i)->getConnectionsFromLane(j).size();
407 noLinks += numConnections;
408 if (numConnections > 0) {
413 return std::make_pair(noLanes, noLinks);
419 const NBEdge*
const from2,
const NBEdge*
const to2)
const {
421 if (to1 == 0 || to2 == 0) {
427 if (idx1 < 0 || idx2 < 0) {
438 const NBEdge*
const possProhibitedFrom,
const NBEdge*
const possProhibitedTo,
439 bool regardNonSignalisedLowerPriority)
const {
441 if (possProhibitorTo == 0 || possProhibitedTo == 0) {
445 int possProhibitorIdx =
getIndex(possProhibitorFrom, possProhibitorTo);
446 int possProhibitedIdx =
getIndex(possProhibitedFrom, possProhibitedTo);
447 if (possProhibitorIdx < 0 || possProhibitedIdx < 0) {
453 if (!regardNonSignalisedLowerPriority) {
454 return myForbids[possProhibitorIdx][possProhibitedIdx];
457 if (!
myForbids[possProhibitorIdx][possProhibitedIdx]) {
470 int fromLane,
int pos,
const bool checkLaneFoes)
const {
472 for (std::vector<NBEdge::Connection>::iterator j = connected.begin(); j != connected.end(); j++) {
473 assert((*j).toEdge != 0);
476 const std::string
foes =
getFoesString(from, (*j).toEdge, fromLane, (*j).toLane, checkLaneFoes);
478 :
getResponseString((*j).tlLinkNo, from, (*j).toEdge, fromLane, (*j).toLane, (*j).mayDefinitelyPass, checkLaneFoes));
499 for (
int j = noLanes; j-- > 0;) {
501 int size = (int) connected.size();
502 for (
int k = size; k-- > 0;) {
503 const NBEdge* to = connected[k].toEdge;
505 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
506 if ((*it_e) == from || (*it_e) == to) {
511 foes += foe ?
'1' :
'0';
528 int fromLane,
int toLane,
bool mayDefinitelyPass,
const bool checkLaneFoes)
const {
536 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
543 int noLanes = (*i)->getNumLanes();
544 for (
int j = noLanes; j-- > 0;) {
545 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
546 int size = (int) connected.size();
547 for (
int k = size; k-- > 0;) {
548 if (mayDefinitelyPass) {
550 }
else if ((*i) == from && fromLane == j) {
554 assert(k < (
int) connected.size());
556 assert(connected[k].toEdge != 0);
560 (!checkLaneFoes ||
laneConflict(from, to, toLane, *i, connected[k].toEdge, connected[k].toLane)))
585 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
587 for (EdgeVector::const_iterator it_e = (*i).edges.begin(); it_e != (*i).edges.end(); ++it_e) {
588 if ((*it_e) == from || (*it_e) == to) {
593 result += foes ?
'1' :
'0';
597 for (EdgeVector::const_reverse_iterator i =
myIncoming.rbegin();
600 for (
int j = (
int)(*i)->getNumLanes() - 1; j >= 0; --j) {
601 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
602 int size = (int) connected.size();
603 for (
int k = size; k-- > 0;) {
604 if ((
foes(from, to, (*i), connected[k].toEdge) &&
605 (!checkLaneFoes ||
laneConflict(from, to, toLane, *i, connected[k].toEdge, connected[k].toLane)))
622 return (from == prohibitorFrom
637 const NBEdge* prohibitorFrom,
const NBEdge* prohibitorTo,
int prohibitorToLane)
const {
638 if (to != prohibitorTo) {
653 return rightOfProhibitor ? toLane >= prohibitorToLane : toLane <= prohibitorToLane;
672 for (
int i = 0; i < variations; i++) {
674 for (
int j = 0; j < variations; j++) {
702 for (
int idx1 = 0; idx1 <
numLinks(); idx1++) {
709 if (includePedCrossings) {
710 for (std::vector<NBNode::Crossing>::const_reverse_iterator i =
myCrossings.rbegin(); i !=
myCrossings.rend(); i++) {
720 const std::vector<NBEdge::Connection>& cons = from->
getConnections();
721 for (std::vector<NBEdge::Connection>::const_iterator i = cons.begin(); i != cons.end(); i++) {
723 from, (*i).toEdge, (*i).fromLane)) {
731 int noLanes = (*i)->getNumLanes();
732 for (
int j = noLanes; j-- > 0;) {
733 std::vector<NBEdge::Connection> connected = (*i)->getConnectionsFromLane(j);
734 const int size = (int) connected.size();
735 for (
int k = size; k-- > 0;) {
736 if ((*i) == from && fromLane != j
751 if (crossing.
priority || mustYield) {
752 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
754 if (((*it_e) == from && crossing.
priority) || (*it_e) == to) {
765 const NBEdge*
const possProhibitedFrom,
const NBEdge*
const possProhibitedTo)
const {
767 int idx1 =
getIndex(possProhibitorFrom, possProhibitorTo);
768 int idx2 =
getIndex(possProhibitedFrom, possProhibitedTo);
785 std::map<NBEdge*, int> incomingCount;
787 std::map<NBEdge*, std::set<int> > approachedLanes;
789 std::map<NBEdge*, EdgeVector> incomingEdges;
791 const std::vector<NBEdge::Connection> connections = (*it_e)->getConnections();
792 for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); ++it_c) {
793 incomingCount[it_c->toEdge]++;
794 approachedLanes[it_c->toEdge].insert(it_c->toLane);
795 incomingEdges[it_c->toEdge].push_back(*it_e);
798 for (std::map<NBEdge*, int>::iterator it = incomingCount.begin(); it != incomingCount.end(); ++it) {
801 if ((
int)approachedLanes[to].size() >= it->second) {
804 for (EdgeVector::iterator it_e1 = incoming.begin(); it_e1 != incoming.end(); ++it_e1) {
805 for (EdgeVector::iterator it_e2 = incoming.begin(); it_e2 != incoming.end(); ++it_e2) {
static double relAngle(double angle1, double angle2)
computes the relative angle between the two angles
std::pair< int, int > getSizes() const
returns the number of the junction's lanes and the number of the junction's links in respect...
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.
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Check if edge has signalised connections.
NBRequest(const NBEdgeCont &ec, NBNode *junction, const EdgeVector &all, const EdgeVector &incoming, const EdgeVector &outgoing, const NBConnectionProhibits &loadedProhibits)
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
The representation of a single edge during network building.
NBNode * myJunction
the node the request is assigned to
void buildBitfieldLogic()
const EdgeVector & myOutgoing
bool rightOnRedConflict(int index, int foeIndex) const
whether the given index must yield to the foeIndex while turing right on a red light ...
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)
NBEdge * getFrom() const
returns the from-edge (start of the connection)
void setBlocking(NBEdge *from1, NBEdge *to1, NBEdge *from2, NBEdge *to2)
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.
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
const EdgeVector & myIncoming
static OptionsCont & getOptions()
Retrieves the options.
int numLinks() const
return to total number of edge-to-edge connections of this request-logic
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)...
int getIndex(const NBEdge *const from, const NBEdge *const to) const
Returns the index to the internal combination container for the given edge combination.
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.
static void reportWarnings()
reports warnings if any occured
std::vector< Connection > getConnectionsFromLane(int lane) const
Returns connections from a given lane.
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.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
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.
int getNumLanes() const
Returns the number of lanes.
int fromLane
The lane the connections starts at.
void computeRightOutgoingLinkCrossings(NBEdge *from, NBEdge *to)
Storage for edges, including some functionality operating on multiple edges.
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.
The link is a (hard) right direction.
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
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 ...
The link is a partial right direction.
description of a logic request within the junction
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
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.
std::vector< NBConnection > NBConnectionVector
Definition of a connection vector.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
NBEdge * getTo() const
returns the to-edge (end of the connection)
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...
Connection getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection This method goes through "myConnections" and returns the specified o...
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
const std::vector< Connection > & getConnections() const
Returns the connections.
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
void writeLogic(std::string key, OutputDevice &into, const bool checkLaneFoes) const
friend std::ostream & operator<<(std::ostream &os, const NBRequest &r)
prints the request
SumoXMLNodeType getType() const
Returns the type of this node.
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::string getFoesString(NBEdge *from, NBEdge *to, int fromLane, int toLane, const bool checkLaneFoes) const
const std::vector< NBNode::Crossing > & myCrossings
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
EdgeVector edges
The edges being crossed.
Represents a single node (junction) during network building.
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.
NBNode * getFromNode() const
Returns the origin node of the edge.
int distanceCounterClockwise(NBEdge *from, NBEdge *to)
NBNode * getToNode() const
Returns the destination node of the edge.
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.