bool
NIVissimTL::NIVissimTLSignal::addTo(NBEdgeCont& ec, NBLoadedTLDef* tl) const {
NIVissimConnection* c = NIVissimConnection::dictionary(myEdgeID);
NBConnectionVector assignedConnections;
if (c == 0) {
// What to do if on an edge? -> close all outgoing connections
NBEdge* edge = ec.retrievePossiblySplit(toString<int>(myEdgeID), myPosition);
if (edge == 0) {
WRITE_WARNING("Could not set tls signal at edge '" + toString(myEdgeID) + "' - the edge was not built.");
return false;
}
// Check whether it is already known, which edges are approached
// by which lanes
// check whether to use the original lanes only
if (edge->lanesWereAssigned()) {
std::vector<NBEdge::Connection> connections = edge->getConnectionsFromLane(myLane - 1);
for (std::vector<NBEdge::Connection>::iterator i = connections.begin(); i != connections.end(); i++) {
const NBEdge::Connection& conn = *i;
assert(myLane - 1 < (int)edge->getNumLanes());
assignedConnections.push_back(NBConnection(edge, myLane - 1, conn.toEdge, conn.toLane));
}
} else {
WRITE_WARNING("Edge : Lanes were not assigned(!)");
for (unsigned int j = 0; j < edge->getNumLanes(); j++) {
std::vector<NBEdge::Connection> connections = edge->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator i = connections.begin(); i != connections.end(); i++) {
const NBEdge::Connection& conn = *i;
assignedConnections.push_back(NBConnection(edge, j, conn.toEdge, conn.toLane));
}
}
}
} else {
// get the edges
NBEdge* tmpFrom = ec.retrievePossiblySplit(toString<int>(c->getFromEdgeID()), toString<int>(c->getToEdgeID()), true);
NBEdge* tmpTo = ec.retrievePossiblySplit(toString<int>(c->getToEdgeID()), toString<int>(c->getFromEdgeID()), false);
// check whether the edges are known
if (tmpFrom != 0 && tmpTo != 0) {
// add connections this signal is responsible for
assignedConnections.push_back(NBConnection(tmpFrom, -1, tmpTo, -1));
} else {
return false;
// !!! one of the edges could not be build
}
}
// add to the group
assert(myGroupIDs.size() != 0);
// @todo just another hack?!
/*
if (myGroupIDs.size() == 1) {
return tl->addToSignalGroup(toString<int>(*(myGroupIDs.begin())),
assignedConnections);
} else {
// !!!
return tl->addToSignalGroup(toString<int>(*(myGroupIDs.begin())),
assignedConnections);
}
*/
return tl->addToSignalGroup(toString<int>(myGroupIDs.front()), assignedConnections);
}
void
GNEConnectorFrame::initTargets() {
// gather potential targets
NBNode* nbn = myCurrentLane->getParentEdge().getGNEJunctionDestiny()->getNBNode();
const EdgeVector& outgoing = nbn->getOutgoingEdges();
for (EdgeVector::const_iterator it = outgoing.begin(); it != outgoing.end(); it++) {
GNEEdge* edge = myViewNet->getNet()->retrieveEdge((*it)->getID());
const GNEEdge::LaneVector& lanes = edge->getLanes();
for (GNEEdge::LaneVector::const_iterator it_lane = lanes.begin(); it_lane != lanes.end(); it_lane++) {
myPotentialTargets.insert(*it_lane);
}
}
// set color for existing connections
const int fromIndex = myCurrentLane->getIndex();
NBEdge* srcEdge = myCurrentLane->getParentEdge().getNBEdge();
std::vector<NBEdge::Connection> connections = srcEdge->getConnectionsFromLane(fromIndex);
for (std::set<GNELane*>::iterator it = myPotentialTargets.begin(); it != myPotentialTargets.end(); it++) {
switch (getLaneStatus(connections, *it)) {
case CONNECTED:
(*it)->setSpecialColor(&targetColor);
break;
case CONNECTED_PASS:
(*it)->setSpecialColor(&targetPassColor);
break;
case CONFLICTED:
(*it)->setSpecialColor(&conflictColor);
break;
case UNCONNECTED:
(*it)->setSpecialColor(&potentialTargetColor);
break;
}
}
}
void
NBTrafficLightDefinition::collectAllLinks() {
myControlledLinks.clear();
int tlIndex = 0;
// build the list of links which are controled by the traffic light
for (EdgeVector::iterator i = myIncomingEdges.begin(); i != myIncomingEdges.end(); i++) {
NBEdge* incoming = *i;
unsigned int noLanes = incoming->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++) {
std::vector<NBEdge::Connection> connected = incoming->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator k = connected.begin(); k != connected.end(); k++) {
const NBEdge::Connection& el = *k;
if (incoming->mayBeTLSControlled(el.fromLane, el.toEdge, el.toLane)) {
if (el.toEdge != 0 && el.toLane >= (int) el.toEdge->getNumLanes()) {
throw ProcessError("Connection '" + incoming->getID() + "_" + toString(j) + "->" + el.toEdge->getID() + "_" + toString(el.toLane) + "' yields in a not existing lane.");
}
if (incoming->getToNode()->getType() != NODETYPE_RAIL_CROSSING || !isRailway(incoming->getPermissions())) {
myControlledLinks.push_back(NBConnection(incoming, el.fromLane, el.toEdge, el.toLane, tlIndex++));
} else {
myControlledLinks.push_back(NBConnection(incoming, el.fromLane, el.toEdge, el.toLane, -1));
}
}
}
}
}
}
void
NBLoadedTLDef::collectLinks() {
myControlledLinks.clear();
// build the list of links which are controled by the traffic light
for (EdgeVector::iterator i = myIncomingEdges.begin(); i != myIncomingEdges.end(); i++) {
NBEdge* incoming = *i;
unsigned int noLanes = incoming->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++) {
std::vector<NBEdge::Connection> elv = incoming->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator k = elv.begin(); k != elv.end(); k++) {
NBEdge::Connection el = *k;
if (el.toEdge != 0) {
myControlledLinks.push_back(NBConnection(incoming, j, el.toEdge, el.toLane));
}
}
}
}
// assign tl-indices to myControlledLinks
unsigned int pos = 0;
for (SignalGroupCont::const_iterator m = mySignalGroups.begin(); m != mySignalGroups.end(); m++) {
SignalGroup* group = (*m).second;
unsigned int linkNo = group->getLinkNo();
for (unsigned int j = 0; j < linkNo; j++) {
const NBConnection& conn = group->getConnection(j);
assert(conn.getFromLane() < 0 || (int) conn.getFrom()->getNumLanes() > conn.getFromLane());
NBConnection tst(conn);
tst.setTLIndex(pos);
if (tst.check(*myEdgeCont)) {
if (tst.getFrom()->mayBeTLSControlled(tst.getFromLane(), tst.getTo(), tst.getToLane())) {
for (NBConnectionVector::iterator it = myControlledLinks.begin(); it != myControlledLinks.end(); it++) {
NBConnection& c = *it;
if (c.getTLIndex() == NBConnection::InvalidTlIndex
&& tst.getFrom() == c.getFrom() && tst.getTo() == c.getTo()
&& (tst.getFromLane() < 0 || tst.getFromLane() == c.getFromLane())
&& (tst.getToLane() < 0 || tst.getToLane() == c.getToLane())) {
c.setTLIndex(pos);
}
}
//std::cout << getID() << " group=" << (*m).first << " tst=" << tst << "\n";
pos++;
}
} else {
WRITE_WARNING("Could not set signal on connection (signal: " + getID() + ", group: " + group->getID() + ")");
}
}
}
}
void
NBLoadedTLDef::collectLinks() {
myControlledLinks.clear();
// build the list of links which are controled by the traffic light
for (EdgeVector::iterator i = myIncomingEdges.begin(); i != myIncomingEdges.end(); i++) {
NBEdge* incoming = *i;
unsigned int noLanes = incoming->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++) {
std::vector<NBEdge::Connection> elv = incoming->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator k = elv.begin(); k != elv.end(); k++) {
NBEdge::Connection el = *k;
if (el.toEdge != 0) {
myControlledLinks.push_back(NBConnection(incoming, j, el.toEdge, el.toLane));
}
}
}
}
}
void
NBOwnTLDef::collectLinks() throw(ProcessError) {
// build the list of links which are controled by the traffic light
for (EdgeVector::iterator i=myIncomingEdges.begin(); i!=myIncomingEdges.end(); i++) {
NBEdge *incoming = *i;
unsigned int noLanes = incoming->getNoLanes();
for (unsigned int j=0; j<noLanes; j++) {
std::vector<NBEdge::Connection> connected = incoming->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator k=connected.begin(); k!=connected.end(); k++) {
const NBEdge::Connection &el = *k;
if (incoming->mayBeTLSControlled(el.fromLane, el.toEdge, el.toLane)) {
if (el.toEdge!=0&&el.toLane>=(int) el.toEdge->getNoLanes()) {
throw ProcessError("Connection '" + incoming->getID() + "_" + toString(j) + "->" + el.toEdge->getID() + "_" + toString(el.toLane) + "' yields in a not existing lane.");
}
myControlledLinks.push_back(NBConnection(incoming, j, el.toEdge, el.toLane));
}
}
}
}
}
NBTrafficLightLogic*
NBOwnTLDef::myCompute(const NBEdgeCont&,
unsigned int brakingTimeSeconds) {
const SUMOTime brakingTime = TIME2STEPS(brakingTimeSeconds);
const SUMOTime leftTurnTime = TIME2STEPS(6); // make configurable ?
// build complete lists first
const EdgeVector& incoming = getIncomingEdges();
EdgeVector fromEdges, toEdges;
std::vector<bool> isLeftMoverV, isTurnaround;
unsigned int noLanesAll = 0;
unsigned int noLinksAll = 0;
for (unsigned int i1 = 0; i1 < incoming.size(); i1++) {
unsigned int noLanes = incoming[i1]->getNumLanes();
noLanesAll += noLanes;
for (unsigned int i2 = 0; i2 < noLanes; i2++) {
NBEdge* fromEdge = incoming[i1];
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
noLinksAll += (unsigned int) approached.size();
for (unsigned int i3 = 0; i3 < approached.size(); i3++) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
--noLinksAll;
continue;
}
assert(i3 < approached.size());
NBEdge* toEdge = approached[i3].toEdge;
fromEdges.push_back(fromEdge);
//myFromLanes.push_back(i2);
toEdges.push_back(toEdge);
if (toEdge != 0) {
isLeftMoverV.push_back(
isLeftMover(fromEdge, toEdge)
||
fromEdge->isTurningDirectionAt(fromEdge->getToNode(), toEdge));
isTurnaround.push_back(
fromEdge->isTurningDirectionAt(
fromEdge->getToNode(), toEdge));
} else {
isLeftMoverV.push_back(true);
isTurnaround.push_back(true);
}
}
}
}
NBTrafficLightLogic* logic = new NBTrafficLightLogic(getID(), getProgramID(), noLinksAll, myOffset, myType);
EdgeVector toProc = incoming;
const SUMOTime greenTime = TIME2STEPS(OptionsCont::getOptions().getInt("tls.green.time"));
// build all phases
while (toProc.size() > 0) {
std::pair<NBEdge*, NBEdge*> chosen;
if (incoming.size() == 2) {
chosen = std::pair<NBEdge*, NBEdge*>(toProc[0], static_cast<NBEdge*>(0));
toProc.erase(toProc.begin());
} else {
chosen = getBestPair(toProc);
}
unsigned int pos = 0;
std::string state((size_t) noLinksAll, 'o');
// plain straight movers
for (unsigned int i1 = 0; i1 < (unsigned int) incoming.size(); ++i1) {
NBEdge* fromEdge = incoming[i1];
const bool inChosen = fromEdge == chosen.first || fromEdge == chosen.second; //chosen.find(fromEdge)!=chosen.end();
const unsigned int numLanes = fromEdge->getNumLanes();
for (unsigned int i2 = 0; i2 < numLanes; i2++) {
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
for (unsigned int i3 = 0; i3 < approached.size(); ++i3) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
continue;
}
if (inChosen) {
state[pos] = 'G';
} else {
state[pos] = 'r';
}
++pos;
}
}
}
// correct behaviour for those that are not in chosen, but may drive, though
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] == 'G') {
continue;
}
bool isForbidden = false;
for (unsigned int i2 = 0; i2 < pos && !isForbidden; ++i2) {
if (state[i2] == 'G' && !isTurnaround[i2] &&
(forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true) || forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2], true))) {
isForbidden = true;
}
}
if (!isForbidden) {
state[i1] = 'G';
}
}
// correct behaviour for those that have to wait (mainly left-mover)
bool haveForbiddenLeftMover = false;
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G') {
continue;
}
for (unsigned int i2 = 0; i2 < pos; ++i2) {
if ((state[i2] == 'G' || state[i2] == 'g') && forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)) {
state[i1] = 'g';
if (!isTurnaround[i1]) {
haveForbiddenLeftMover = true;
}
}
}
}
// add step
logic->addStep(greenTime, state);
if (brakingTime > 0) {
// build yellow (straight)
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G' && state[i1] != 'g') {
continue;
}
if ((state[i1] >= 'a' && state[i1] <= 'z') && haveForbiddenLeftMover) {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(brakingTime, state);
}
if (haveForbiddenLeftMover && !myHaveSinglePhase) {
// build left green
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] == 'Y' || state[i1] == 'y') {
state[i1] = 'r';
continue;
}
if (state[i1] == 'g') {
state[i1] = 'G';
}
}
// add step
logic->addStep(leftTurnTime, state);
// build left yellow
if (brakingTime > 0) {
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G' && state[i1] != 'g') {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(brakingTime, state);
}
}
}
const SUMOTime totalDuration = logic->getDuration();
if (totalDuration > 0) {
if (totalDuration > 3 * (greenTime + 2 * brakingTime + leftTurnTime)) {
WRITE_WARNING("The traffic light '" + getID() + "' has a high cycle time of " + time2string(totalDuration) + ".");
}
return logic;
} else {
delete logic;
return 0;
}
}
NBTrafficLightLogic *
NBOwnTLDef::myCompute(const NBEdgeCont &,
unsigned int brakingTime) throw() {
// build complete lists first
const EdgeVector &incoming = getIncomingEdges();
std::vector<NBEdge*> fromEdges, toEdges;
std::vector<bool> isLeftMoverV, isTurnaround;
unsigned int noLanesAll = 0;
unsigned int noLinksAll = 0;
for (unsigned int i1=0; i1<incoming.size(); i1++) {
unsigned int noLanes = incoming[i1]->getNoLanes();
noLanesAll += noLanes;
for (unsigned int i2=0; i2<noLanes; i2++) {
NBEdge *fromEdge = incoming[i1];
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
noLinksAll += (unsigned int) approached.size();
for (unsigned int i3=0; i3<approached.size(); i3++) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
--noLinksAll;
continue;
}
assert(i3<approached.size());
NBEdge *toEdge = approached[i3].toEdge;
fromEdges.push_back(fromEdge);
//myFromLanes.push_back(i2);
toEdges.push_back(toEdge);
if (toEdge!=0) {
isLeftMoverV.push_back(
isLeftMover(fromEdge, toEdge)
||
fromEdge->isTurningDirectionAt(fromEdge->getToNode(), toEdge));
isTurnaround.push_back(
fromEdge->isTurningDirectionAt(
fromEdge->getToNode(), toEdge));
} else {
isLeftMoverV.push_back(true);
isTurnaround.push_back(true);
}
}
}
}
NBTrafficLightLogic *logic = new NBTrafficLightLogic(getID(), "0", noLinksAll);
std::vector<NBEdge*> toProc = incoming;
// build all phases
while (toProc.size()>0) {
std::pair<NBEdge*, NBEdge*> chosen;
if (incoming.size()==2) {
chosen = std::pair<NBEdge*, NBEdge*>(toProc[0], static_cast<NBEdge*>(0));
toProc.erase(toProc.begin());
} else {
chosen = getBestPair(toProc);
}
unsigned int pos = 0;
unsigned int duration = 31;
if (OptionsCont::getOptions().isSet("traffic-light-green")) {
duration = OptionsCont::getOptions().getInt("traffic-light-green");
}
std::string state((size_t) noLinksAll, 'o');
// plain straight movers
for (unsigned int i1=0; i1<(unsigned int) incoming.size(); ++i1) {
NBEdge *fromEdge = incoming[i1];
bool inChosen = fromEdge==chosen.first||fromEdge==chosen.second;//chosen.find(fromEdge)!=chosen.end();
unsigned int noLanes = fromEdge->getNoLanes();
for (unsigned int i2=0; i2<noLanes; i2++) {
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
for (unsigned int i3=0; i3<approached.size(); ++i3) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
continue;
}
if (inChosen) {
state[pos] = 'G';
} else {
state[pos] = 'r';
}
++pos;
}
}
}
// correct behaviour for those that are not in chosen, but may drive, though
for (unsigned int i1=0; i1<pos; ++i1) {
if (state[i1]=='G') {
continue;
}
bool isForbidden = false;
for (unsigned int i2=0; i2<pos&&!isForbidden; ++i2) {
if (state[i2]=='G'&&!isTurnaround[i2]&&
(forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)||forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2], true))) {
isForbidden = true;
}
}
if (!isForbidden) {
state[i1] = 'G';
}
}
// correct behaviour for those that have to wait (mainly left-mover)
bool haveForbiddenLeftMover = false;
for (unsigned int i1=0; i1<pos; ++i1) {
if (state[i1]!='G') {
continue;
}
for (unsigned int i2=0; i2<pos; ++i2) {
if ((state[i2]=='G'||state[i2]=='g')&&forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)) {
state[i1] = 'g';
if (!isTurnaround[i1]) {
haveForbiddenLeftMover = true;
}
}
}
}
// add step
logic->addStep(duration, state);
if (brakingTime>0) {
// build yellow (straight)
duration = brakingTime;
for (unsigned int i1=0; i1<pos; ++i1) {
if (state[i1]!='G'&&state[i1]!='g') {
continue;
}
if ((state[i1]>='a'&&state[i1]<='z')&&haveForbiddenLeftMover) {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(duration, state);
}
if (haveForbiddenLeftMover) {
// build left green
duration = 6;
for (unsigned int i1=0; i1<pos; ++i1) {
if (state[i1]=='Y'||state[i1]=='y') {
state[i1] = 'r';
continue;
}
if (state[i1]=='g') {
state[i1] = 'G';
}
}
// add step
logic->addStep(duration, state);
// build left yellow
if (brakingTime>0) {
duration = brakingTime;
for (unsigned int i1=0; i1<pos; ++i1) {
if (state[i1]!='G'&&state[i1]!='g') {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(duration, state);
}
}
}
if (logic->getDuration()>0) {
return logic;
} else {
delete logic;
return 0;
}
}
