void
NBTrafficLightLogicCont::computeLogics(NBEdgeCont &ec, OptionsCont &oc) throw() {
unsigned int no = 0;
for (DefinitionContType::iterator i=myDefinitions.begin(); i!=myDefinitions.end(); i++) {
std::string id = (*i).first;
if (myComputed.find(id)!=myComputed.end()) {
WRITE_WARNING("Traffic light '" + id + "' was already built.");
continue;
}
// build program
NBTrafficLightDefinition *def = (*i).second;
NBTrafficLightLogic *built = def->compute(ec, oc);
if (built==0) {
WRITE_WARNING("Could not build traffic lights '" + id + "'");
continue;
}
// compute offset
SUMOTime T = built->getDuration();
if (find(myHalfOffsetTLS.begin(), myHalfOffsetTLS.end(), id)!=myHalfOffsetTLS.end()) {
built->setOffset((SUMOTime)(T/2.));
}
if (find(myQuarterOffsetTLS.begin(), myQuarterOffsetTLS.end(), id)!=myQuarterOffsetTLS.end()) {
built->setOffset((SUMOTime)(T/4.));
}
// and insert the result after computation
myComputed[(*i).first] = built;
no++;
}
WRITE_MESSAGE(toString<int>(no) + " traffic light(s) computed.");
}
long
GNETLSEditorFrame::onCmdDefSwitch(FXObject*, FXSelector, void*) {
assert(myCurrentJunction != 0);
assert((int)myDefinitions.size() == myProgramComboBox->getNumItems());
NBTrafficLightDefinition* tlDef = myDefinitions[myProgramComboBox->getCurrentItem()];
// logic may not have been recomputed yet. recompute to be sure
NBTrafficLightLogicCont& tllCont = myViewNet->getNet()->getTLLogicCont();
myViewNet->getNet()->computeJunction(myCurrentJunction);
NBTrafficLightLogic* tllogic = tllCont.getLogic(tlDef->getID(), tlDef->getProgramID());
if (tllogic != 0) {
// now we can be sure that the tlDef is up to date (i.e. re-guessed)
buildIinternalLanes(tlDef);
// create working copy from original def
delete myEditedDef;
myEditedDef = new NBLoadedSUMOTLDef(tlDef, tllogic);
myOffset->setText(toString(STEPS2TIME(myEditedDef->getLogic()->getOffset())).c_str());
initPhaseTable();
updateCycleDuration();
} else {
// tlDef has no valid logic (probably because id does not control any links
onCmdCancel(0, 0, 0);
myViewNet->setStatusBarText("Traffic light does not control any links");
}
return 1;
}
bool
GNEConnection::isValid(SumoXMLAttr key, const std::string& value) {
// Currently ignored before implementation to avoid warnings
switch (key) {
case SUMO_ATTR_FROM:
case SUMO_ATTR_TO:
case SUMO_ATTR_FROM_LANE:
case SUMO_ATTR_TO_LANE:
return false;
case SUMO_ATTR_PASS:
return canParse<bool>(value);
case SUMO_ATTR_KEEP_CLEAR:
return canParse<bool>(value);
case SUMO_ATTR_CONTPOS:
return canParse<double>(value);
case SUMO_ATTR_UNCONTROLLED:
return canParse<bool>(value);
case SUMO_ATTR_VISIBILITY_DISTANCE:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_TLLINKINDEX:
if (getNBEdgeConnection().uncontrolled == false
&& getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().size() > 0
&& canParse<int>(value)
&& parse<int>(value) >= 0) {
NBTrafficLightDefinition* def = *getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().begin();
return def->getMaxValidIndex() >= parse<int>(value);
} else {
return false;
}
case SUMO_ATTR_SPEED:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_CUSTOMSHAPE: {
// empty custom shapes are allowed
return canParse<PositionVector>(value);
}
case SUMO_ATTR_STATE:
return false;
case SUMO_ATTR_DIR:
return false;
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNENet::computeJunction(GNEJunction* junction) {
// recompute tl-logics
OptionsCont& oc = OptionsCont::getOptions();
NBTrafficLightLogicCont& tllCont = getTLLogicCont();
NBNode* nbn = junction->getNBNode();
std::set<NBTrafficLightDefinition*> tldefs = nbn->getControllingTLS();
for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
NBTrafficLightDefinition* def = *it;
def->setParticipantsInformation();
def->setTLControllingInformation();
tllCont.computeSingleLogic(oc, def);
}
// @todo compute connections etc...
}
long
GNETLSEditorFrame::onCmdOK(FXObject*, FXSelector, void*) {
if (myCurrentJunction != 0) {
if (myHaveModifications) {
NBTrafficLightDefinition* old = myDefinitions[myProgramComboBox->getCurrentItem()];
std::vector<NBNode*> nodes = old->getNodes();
for (std::vector<NBNode*>::iterator it = nodes.begin(); it != nodes.end(); it++) {
GNEJunction* junction = myViewNet->getNet()->retrieveJunction((*it)->getID());
myViewNet->getUndoList()->add(new GNEChange_TLS(junction, old, false), true);
myViewNet->getUndoList()->add(new GNEChange_TLS(junction, myEditedDef, true), true);
}
myEditedDef = 0;
myViewNet->getUndoList()->p_end();
cleanup();
myViewNet->update();
} else {
onCmdCancel(0, 0, 0);
}
}
return 1;
}
NBLoadedSUMOTLDef*
NIXMLTrafficLightsHandler::initTrafficLightLogic(const SUMOSAXAttributes& attrs, NBLoadedSUMOTLDef* currentTL) {
if (currentTL) {
WRITE_ERROR("Definition of tlLogic '" + currentTL->getID() + "' was not finished.");
return 0;
}
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
std::string programID = attrs.getOpt<std::string>(SUMO_ATTR_PROGRAMID, id.c_str(), ok, "<unknown>");
SUMOTime offset = attrs.hasAttribute(SUMO_ATTR_OFFSET) ? TIME2STEPS(attrs.get<SUMOReal>(SUMO_ATTR_OFFSET, id.c_str(), ok)) : 0;
std::string typeS = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, 0, ok,
OptionsCont::getOptions().getString("tls.default-type"));
TrafficLightType type;
if (SUMOXMLDefinitions::TrafficLightTypes.hasString(typeS)) {
type = SUMOXMLDefinitions::TrafficLightTypes.get(typeS);
} else {
WRITE_ERROR("Unknown traffic light type '" + typeS + "' for tlLogic '" + id + "'.");
return 0;
}
// there are two scenarios to consider
// 1) the tll.xml is loaded to update traffic lights defined in a net.xml:
// simply retrieve the loaded definitions and update them
// 2) the tll.xml is loaded to define new traffic lights
// nod.xml will have triggered building of NBOwnTLDef. Replace it with NBLoadedSUMOTLDef
NBLoadedSUMOTLDef* loadedDef = dynamic_cast<NBLoadedSUMOTLDef*>(myTLLCont.getDefinition(id, programID));
if (loadedDef == 0) {
// case 2
NBTrafficLightDefinition* newDef = dynamic_cast<NBOwnTLDef*>(myTLLCont.getDefinition(
id, NBTrafficLightDefinition::DefaultProgramID));
if (newDef == 0) {
// the default program may have already been replaced with a loaded program
newDef = dynamic_cast<NBLoadedSUMOTLDef*>(myTLLCont.getDefinition(
id, NBTrafficLightDefinition::DefaultProgramID));
if (newDef == 0) {
WRITE_ERROR("Cannot load traffic light program for unknown id '" + id + "', programID '" + programID + "'.");
return 0;
}
}
assert(newDef != 0);
loadedDef = new NBLoadedSUMOTLDef(id, programID, offset, type);
// copy nodes and controlled inner edges
std::vector<NBNode*> nodes = newDef->getNodes();
for (std::vector<NBNode*>::iterator it = nodes.begin(); it != nodes.end(); it++) {
loadedDef->addNode(*it);
}
loadedDef->addControlledInnerEdges(newDef->getControlledInnerEdges());
if (programID == NBTrafficLightDefinition::DefaultProgramID) {
// replace default Program
std::vector<NBNode*> nodes = newDef->getNodes();
for (std::vector<NBNode*>::iterator it = nodes.begin(); it != nodes.end(); it++) {
(*it)->removeTrafficLight(newDef);
}
myTLLCont.removeProgram(id, NBTrafficLightDefinition::DefaultProgramID);
}
myTLLCont.insert(loadedDef);
}
if (ok) {
myResetPhases = true;
return loadedDef;
} else {
return 0;
}
}
