bool
NBTrafficLightDefinition::mustBrake(const NBConnection& possProhibited,
const NBConnection& possProhibitor,
bool regardNonSignalisedLowerPriority) const {
return forbids(possProhibitor.getFrom(), possProhibitor.getTo(),
possProhibited.getFrom(), possProhibited.getTo(),
regardNonSignalisedLowerPriority);
}
void
NBLoadedSUMOTLDef::removeConnection(const NBConnection& conn, bool reconstruct) {
NBConnectionVector::iterator it = myControlledLinks.begin();
// find the connection but ignore its TLIndex since it might have been
// invalidated by an earlier removal
for (; it != myControlledLinks.end(); ++it) {
if (it->getFrom() == conn.getFrom() &&
it->getTo() == conn.getTo() &&
it->getFromLane() == conn.getFromLane() &&
it->getToLane() == conn.getToLane()) {
break;
}
}
if (it == myControlledLinks.end()) {
// a traffic light doesn't always controll all connections at a junction
// especially when using the option --tls.join
return;
}
const int removed = it->getTLIndex();
// remove the connection
myControlledLinks.erase(it);
if (reconstruct) {
// updating the edge is only needed for immediate use in NETEDIT.
// It may conflict with loading diffs
conn.getFrom()->setControllingTLInformation(conn, "");
// shift link numbers down so there is no gap
for (NBConnectionVector::iterator it = myControlledLinks.begin(); it != myControlledLinks.end(); it++) {
NBConnection& c = *it;
if (c.getTLIndex() > removed) {
c.setTLIndex(c.getTLIndex() - 1);
}
}
// update controlling information with new link numbers
setTLControllingInformation();
// rebuild the logic
const std::vector<NBTrafficLightLogic::PhaseDefinition> phases = myTLLogic->getPhases();
NBTrafficLightLogic* newLogic = new NBTrafficLightLogic(getID(), getProgramID(), 0, myOffset, myType);
for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator it = phases.begin(); it != phases.end(); it++) {
std::string newState = it->state;
newState.erase(newState.begin() + removed);
newLogic->addStep(it->duration, newState);
}
delete myTLLogic;
myTLLogic = newLogic;
}
}
bool
NBLoadedTLDef::addToSignalGroup(const std::string& groupid,
const NBConnection& connection) {
if (mySignalGroups.find(groupid) == mySignalGroups.end()) {
return false;
}
mySignalGroups[groupid]->addConnection(connection);
NBNode* n1 = connection.getFrom()->getToNode();
if (n1 != 0) {
addNode(n1);
n1->addTrafficLight(this);
}
NBNode* n2 = connection.getTo()->getFromNode();
if (n2 != 0) {
addNode(n2);
n2->addTrafficLight(this);
}
return true;
}
bool
NBLoadedTLDef::mustBrake(const NBEdgeCont& ec,
const NBConnection& possProhibited,
const std::string& state,
unsigned int strmpos) const {
// check whether the stream has red
if (state[strmpos] != 'g' && state[strmpos] != 'G') {
return true;
}
// check whether another stream which has green is a higher
// priorised foe to the given
unsigned int pos = 0;
for (SignalGroupCont::const_iterator i = mySignalGroups.begin(); i != mySignalGroups.end(); i++) {
SignalGroup* group = (*i).second;
// get otherlinks that have green
unsigned int linkNo = group->getLinkNo();
for (unsigned int j = 0; j < linkNo; j++) {
// get the current connection (possible foe)
const NBConnection& other = group->getConnection(j);
NBConnection possProhibitor(other);
// if the connction ist still valid ...
if (possProhibitor.check(ec)) {
// ... do nothing if it starts at the same edge
if (possProhibited.getFrom() == possProhibitor.getFrom()) {
pos++;
continue;
}
if (state[pos] == 'g' || state[pos] == 'G') {
if (NBTrafficLightDefinition::mustBrake(possProhibited, possProhibitor, true)) {
return true;
}
}
pos++;
}
}
}
return false;
}
void
NBLoadedTLDef::SignalGroup::addConnection(const NBConnection& c) {
assert(c.getFromLane() < 0 || c.getFrom()->getNumLanes() > (unsigned int)c.getFromLane());
myConnections.push_back(c);
}
// ===========================================================================
// method definitions
// ===========================================================================
NBRequest::NBRequest(const NBEdgeCont& ec,
NBNode* junction,
const EdgeVector& all,
const EdgeVector& incoming,
const EdgeVector& outgoing,
const NBConnectionProhibits& loadedProhibits)
: myJunction(junction),
myAll(all), myIncoming(incoming), myOutgoing(outgoing) {
size_t variations = myIncoming.size() * myOutgoing.size();
// build maps with information which forbidding connection were
// computed and what's in there
myForbids.reserve(variations);
myDone.reserve(variations);
for (size_t i = 0; i < variations; i++) {
myForbids.push_back(LinkInfoCont(variations, false));
myDone.push_back(LinkInfoCont(variations, false));
}
// insert loaded prohibits
for (NBConnectionProhibits::const_iterator j = loadedProhibits.begin(); j != loadedProhibits.end(); j++) {
NBConnection prohibited = (*j).first;
bool ok1 = prohibited.check(ec);
if (find(myIncoming.begin(), myIncoming.end(), prohibited.getFrom()) == myIncoming.end()) {
ok1 = false;
}
if (find(myOutgoing.begin(), myOutgoing.end(), prohibited.getTo()) == myOutgoing.end()) {
ok1 = false;
}
int idx1 = 0;
if (ok1) {
idx1 = getIndex(prohibited.getFrom(), prohibited.getTo());
if (idx1 < 0) {
ok1 = false;
}
}
const NBConnectionVector& prohibiting = (*j).second;
for (NBConnectionVector::const_iterator k = prohibiting.begin(); k != prohibiting.end(); k++) {
NBConnection sprohibiting = *k;
bool ok2 = sprohibiting.check(ec);
if (find(myIncoming.begin(), myIncoming.end(), sprohibiting.getFrom()) == myIncoming.end()) {
ok2 = false;
}
if (find(myOutgoing.begin(), myOutgoing.end(), sprohibiting.getTo()) == myOutgoing.end()) {
ok2 = false;
}
if (ok1 && ok2) {
int idx2 = getIndex(sprohibiting.getFrom(), sprohibiting.getTo());
if (idx2 < 0) {
ok2 = false;
} else {
myForbids[idx2][idx1] = true;
myDone[idx2][idx1] = true;
myDone[idx1][idx2] = true;
myGoodBuilds++;
}
} else {
std::string pfID = prohibited.getFrom() != 0 ? prohibited.getFrom()->getID() : "UNKNOWN";
std::string ptID = prohibited.getTo() != 0 ? prohibited.getTo()->getID() : "UNKNOWN";
std::string bfID = sprohibiting.getFrom() != 0 ? sprohibiting.getFrom()->getID() : "UNKNOWN";
std::string btID = sprohibiting.getTo() != 0 ? sprohibiting.getTo()->getID() : "UNKNOWN";
WRITE_WARNING("could not prohibit " + pfID + "->" + ptID + " by " + bfID + "->" + btID);
myNotBuild++;
}
}
}
// ok, check whether someone has prohibited two links vice versa
// (this happens also in some Vissim-networks, when edges are joined)
size_t no = myIncoming.size() * myOutgoing.size();
for (size_t s1 = 0; s1 < no; s1++) {
for (size_t s2 = s1 + 1; s2 < no; s2++) {
// not set, yet
if (!myDone[s1][s2]) {
continue;
}
// check whether both prohibit vice versa
if (myForbids[s1][s2] && myForbids[s2][s1]) {
// mark unset - let our algorithm fix it later
myDone[s1][s2] = false;
myDone[s2][s1] = false;
}
}
}
}
void
NIXMLConnectionsHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element == SUMO_TAG_DELETE) {
bool ok = true;
std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
std::string to = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
if (!ok) {
return;
}
// these connections were removed when the edge was deleted
if (myEdgeCont.wasRemoved(from) || myEdgeCont.wasRemoved(to)) {
return;
}
NBEdge* fromEdge = myEdgeCont.retrieve(from);
NBEdge* toEdge = myEdgeCont.retrieve(to);
if (fromEdge == 0) {
myErrorMsgHandler->inform("The connection-source edge '" + from + "' to reset is not known.");
return;
}
if (toEdge == 0) {
myErrorMsgHandler->inform("The connection-destination edge '" + to + "' to reset is not known.");
return;
}
if (!fromEdge->isConnectedTo(toEdge) && fromEdge->getStep() >= NBEdge::EDGE2EDGES) {
WRITE_WARNING("Target edge '" + toEdge->getID() + "' is not connected with '" + fromEdge->getID() + "'; the connection cannot be reset.");
return;
}
int fromLane = -1; // Assume all lanes are to be reset.
int toLane = -1;
if (attrs.hasAttribute(SUMO_ATTR_LANE)
|| attrs.hasAttribute(SUMO_ATTR_FROM_LANE)
|| attrs.hasAttribute(SUMO_ATTR_TO_LANE)) {
if (!parseLaneInfo(attrs, fromEdge, toEdge, &fromLane, &toLane)) {
return;
}
// we could be trying to reset a connection loaded from a sumo net and which has become obsolete.
// In this case it's ok to encounter invalid lance indices
if (!fromEdge->hasConnectionTo(toEdge, toLane) && fromEdge->getStep() >= NBEdge::LANES2EDGES) {
WRITE_WARNING("Edge '" + fromEdge->getID() + "' has no connection to lane " + toString(toLane) + " of edge '" + toEdge->getID() + "'; the connection cannot be reset.");
}
}
fromEdge->removeFromConnections(toEdge, fromLane, toLane, true);
}
if (element == SUMO_TAG_CONNECTION) {
bool ok = true;
std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, "connection", ok);
std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "connection", ok, "");
if (!ok || myEdgeCont.wasIgnored(from) || myEdgeCont.wasIgnored(to)) {
return;
}
// extract edges
NBEdge* fromEdge = myEdgeCont.retrieve(from);
NBEdge* toEdge = to.length() != 0 ? myEdgeCont.retrieve(to) : 0;
// check whether they are valid
if (fromEdge == 0) {
myErrorMsgHandler->inform("The connection-source edge '" + from + "' is not known.");
return;
}
if (toEdge == 0 && to.length() != 0) {
myErrorMsgHandler->inform("The connection-destination edge '" + to + "' is not known.");
return;
}
fromEdge->getToNode()->invalidateTLS(myTLLogicCont, true, false);
// parse optional lane information
if (attrs.hasAttribute(SUMO_ATTR_LANE) || attrs.hasAttribute(SUMO_ATTR_FROM_LANE) || attrs.hasAttribute(SUMO_ATTR_TO_LANE)) {
parseLaneBound(attrs, fromEdge, toEdge);
} else {
fromEdge->addEdge2EdgeConnection(toEdge);
}
}
if (element == SUMO_TAG_PROHIBITION) {
bool ok = true;
std::string prohibitor = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITOR, 0, ok, "");
std::string prohibited = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITED, 0, ok, "");
if (!ok) {
return;
}
NBConnection prohibitorC = parseConnection("prohibitor", prohibitor);
NBConnection prohibitedC = parseConnection("prohibited", prohibited);
if (prohibitorC == NBConnection::InvalidConnection || prohibitedC == NBConnection::InvalidConnection) {
// something failed
return;
}
NBNode* n = prohibitorC.getFrom()->getToNode();
n->addSortedLinkFoes(prohibitorC, prohibitedC);
}
if (element == SUMO_TAG_CROSSING) {
addCrossing(attrs);
}
if (element == SUMO_TAG_WALKINGAREA) {
addWalkingArea(attrs);
}
}
std::string
NWWriter_SUMO::prohibitionConnection(const NBConnection& c) {
return c.getFrom()->getID() + "->" + c.getTo()->getID();
}
