long
GNETLSEditorFrame::onCmdPhaseEdit(FXObject*, FXSelector, void* ptr) {
/* @note: there is a bug when copying/pasting rows: when this handler is
* called the value of the cell is not yet updated. This means you have to
* click inside the cell and hit enter to actually update the value */
FXTablePos* tp = (FXTablePos*)ptr;
FXString value = myPhaseTable->getItemText(tp->row, tp->col);
if (tp->col == 0) {
// duration edited
if (GNEAttributeCarrier::canParse<SUMOReal>(value.text())) {
SUMOTime duration = getSUMOTime(value);
if (duration > 0) {
myEditedDef->getLogic()->setPhaseDuration(tp->row, duration);
myHaveModifications = true;
updateCycleDuration();
return 1;
}
}
// input error, reset value
myPhaseTable->setItemText(tp->row, 0, toString(STEPS2TIME(getPhases()[tp->row].duration)).c_str());
} else {
// state edited
try {
// insert phase with new step and delete the old phase
myEditedDef->getLogic()->addStep(getPhases()[tp->row].duration, value.text(), tp->row);
myEditedDef->getLogic()->deletePhase(tp->row + 1);
myHaveModifications = true;
onCmdPhaseSwitch(0, 0, 0);
} catch (ProcessError) {
// input error, reset value
myPhaseTable->setItemText(tp->row, 1, getPhases()[tp->row].state.c_str());
}
}
return 1;
}
void
GNETLSEditorFrame::initPhaseTable(unsigned int index) {
myPhaseTable->setVisibleRows(1);
myPhaseTable->setVisibleColumns(2);
myPhaseTable->hide();
if (myDefinitions.size() > 0) {
const std::vector<NBTrafficLightLogic::PhaseDefinition>& phases = getPhases();
myPhaseTable->setTableSize((int)phases.size(), 2);
myPhaseTable->setVisibleRows((int)phases.size());
myPhaseTable->setVisibleColumns(2);
for (unsigned int row = 0; row < phases.size(); row++) {
myPhaseTable->setItemText(row, 0, toString(STEPS2TIME(phases[row].duration)).c_str());
myPhaseTable->setItemText(row, 1, phases[row].state.c_str());
myPhaseTable->getItem(row, 1)->setJustify(FXTableItem::LEFT);
}
myPhaseTable->fitColumnsToContents(0, 2);
const int maxWidth = 140 - 4;
int desiredWidth = myPhaseTable->getColumnWidth(0) +
myPhaseTable->getColumnWidth(1) + 3;
int spaceForScrollBar = desiredWidth > maxWidth ? 15 : 0;
myPhaseTable->setHeight((int)phases.size() * 21 + spaceForScrollBar); // experimental
myPhaseTable->setWidth(MIN2(desiredWidth, maxWidth));
myPhaseTable->setCurrentItem(index, 0);
myPhaseTable->selectRow(index, true);
myPhaseTable->show();
myPhaseTable->setFocus();
}
update();
}
void
MSTrafficLightLogic::init(NLDetectorBuilder&) {
const Phases& phases = getPhases();
if (phases.size() > 1) {
bool haveWarnedAboutUnusedStates = false;
// warn about transistions from green to red without intermediate yellow
for (int i = 0; i < (int)phases.size(); ++i) {
const int iNext = (i + 1) % phases.size();
const std::string& state1 = phases[i]->getState();
const std::string& state2 = phases[iNext]->getState();
assert(state1.size() == state2.size());
if (!haveWarnedAboutUnusedStates && state1.size() > myLanes.size()) {
WRITE_WARNING("Unused states in tlLogic '" + getID()
+ "', program '" + getProgramID() + "' in phase " + toString(i)
+ " after tl-index " + toString((int)myLanes.size() - 1));
haveWarnedAboutUnusedStates = true;
}
for (int j = 0; j < (int)MIN3(state1.size(), state2.size(), myLanes.size()); ++j) {
if ((LinkState)state2[j] == LINKSTATE_TL_RED
&& ((LinkState)state1[j] == LINKSTATE_TL_GREEN_MAJOR
|| (LinkState)state1[j] == LINKSTATE_TL_GREEN_MINOR)) {
for (LaneVector::const_iterator it = myLanes[j].begin(); it != myLanes[j].end(); ++it) {
if ((*it)->getPermissions() != SVC_PEDESTRIAN) {
WRITE_WARNING("Missing yellow phase in tlLogic '" + getID()
+ "', program '" + getProgramID() + "' for tl-index " + toString(j)
+ " when switching to phase " + toString(iNext));
return; // one warning per program is enough
}
}
}
}
}
}
}
void
MSSOTLTrafficLightLogic::checkPhases() {
for (int step = 0; step < (int)getPhases().size(); step++) {
if (getPhase(step).isUndefined()) {
MsgHandler::getErrorInstance()->inform("Step " + toString(step) + " of traffic light logic " + myID + " phases declaration has its type undeclared!");
}
}
}
void
GNETLSEditorFrame::updateCycleDuration() {
SUMOTime cycleDuration = 0;
for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator it = getPhases().begin(); it != getPhases().end(); it++) {
cycleDuration += it->duration;
}
std::string text = "Cycle time: " + toString(STEPS2TIME(cycleDuration));
myCycleDuration->setText(text.c_str());
}
void
MSSOTLTrafficLightLogic::setupCTS() {
for (int phaseStep = 0; phaseStep < (int)getPhases().size(); phaseStep++) {
if (getPhase(phaseStep).isTarget()) {
targetPhasesCTS[phaseStep] = 0;
lastCheckForTargetPhase[phaseStep] = MSNet::getInstance()->getCurrentTimeStep();
targetPhasesLastSelection[phaseStep] = 0;
}
}
}
void
MSSOTLTrafficLightLogic::setToATargetPhase() {
for (int step = 0; step < (int)getPhases().size(); step++) {
if (getPhase(step).isTarget()) {
setStep(step);
lastChain = step;
return;
}
}
MsgHandler::getErrorInstance()->inform("No phase of type target found for traffic light logic " + myID + " The logic could malfunction. Check phases declaration.");
}
void
GNETLSEditorFrame::handleChange(GNEInternalLane* lane) {
myHaveModifications = true;
if (myViewNet->changeAllPhases()) {
const std::vector<NBTrafficLightLogic::PhaseDefinition>& phases = getPhases();
for (int row = 0; row < (int)phases.size(); row++) {
myEditedDef->getLogic()->setPhaseState(row, lane->getTLIndex(), lane->getLinkState());
}
} else {
myEditedDef->getLogic()->setPhaseState(myPhaseTable->getCurrentRow(), lane->getTLIndex(), lane->getLinkState());
}
initPhaseTable(myPhaseTable->getCurrentRow());
myPhaseTable->setFocus();
}
long
GNETLSEditorFrame::onCmdPhaseSwitch(FXObject*, FXSelector, void*) {
const int index = myPhaseTable->getCurrentRow();
const NBTrafficLightLogic::PhaseDefinition& phase = getPhases()[index];
myPhaseTable->selectRow(index);
// need not hold since links could have been deleted somewhere else and indices may be reused
// assert(phase.state.size() == myInternalLanes.size());
for (TLIndexMap::iterator it = myInternalLanes.begin(); it != myInternalLanes.end(); it++) {
int tlIndex = it->first;
std::vector<GNEInternalLane*> lanes = it->second;
assert(tlIndex >= 0);
assert(tlIndex < (int)phase.state.size());
for (std::vector<GNEInternalLane*>::iterator it_lane = lanes.begin(); it_lane != lanes.end(); it_lane++) {
(*it_lane)->setLinkState((LinkState)phase.state[tlIndex]);
}
}
myViewNet->update();
return 1;
}
void
GNETLSEditorFrame::initPhaseTable(int index) {
myPhaseTable->setVisibleRows(1);
myPhaseTable->setVisibleColumns(2);
myPhaseTable->hide();
if (myDefinitions.size() > 0) {
const std::vector<NBTrafficLightLogic::PhaseDefinition>& phases = getPhases();
myPhaseTable->setTableSize((int)phases.size(), 2);
myPhaseTable->setVisibleRows((int)phases.size());
myPhaseTable->setVisibleColumns(2);
for (int row = 0; row < (int)phases.size(); row++) {
myPhaseTable->setItemText(row, 0, toString(STEPS2TIME(phases[row].duration)).c_str());
myPhaseTable->setItemText(row, 1, phases[row].state.c_str());
myPhaseTable->getItem(row, 1)->setJustify(FXTableItem::LEFT);
}
myPhaseTable->fitColumnsToContents(0, 2);
myPhaseTable->setHeight((int)phases.size() * 21); // experimental
myPhaseTable->setCurrentItem(index, 0);
myPhaseTable->selectRow(index, true);
myPhaseTable->show();
myPhaseTable->setFocus();
}
update();
}
void EventKnownItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setRenderHint(QPainter::Antialiasing);
QRectF rect = boundingRect();
QColor eventColor = QColor(mData[STATE_COLOR_RED].toInt(),
mData[STATE_COLOR_GREEN].toInt(),
mData[STATE_COLOR_BLUE].toInt());
painter->setPen(Qt::NoPen);
painter->setBrush(eventColor);
painter->drawEllipse(rect);
if(isSelected())
{
painter->setPen(QPen(Painting::mainColorDark, 3.f));
painter->setBrush(Qt::NoBrush);
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
double side = 40.f;
double top = 25.f;
QRectF nameRect(rect.x() + side, rect.y() + top, rect.width() - 2*side, mTitleHeight);
QRectF thumbRect(rect.x() + side, rect.y() + top + mEltsMargin + mTitleHeight, rect.width() - 2*side, mThumbH);
QRectF phasesRect(rect.x() + side, rect.y() + top + 2*mEltsMargin + mTitleHeight + mThumbH, rect.width() - 2*side, mPhasesHeight);
phasesRect.adjust(1, 1, -1, -1);
// Name
QFont font = qApp->font();
painter->setFont(font);
QFontMetrics metrics(font);
QString name = mData[STATE_NAME].toString();
name = metrics.elidedText(name, Qt::ElideRight, nameRect.width());
QColor frontColor = getContrastedColor(eventColor);
painter->setPen(frontColor);
painter->drawText(nameRect, Qt::AlignCenter, name);
// Thumb
painter->drawPixmap(thumbRect, mThumb, mThumb.rect());
// Phases
QJsonArray phases = getPhases();
int numPhases = (int)phases.size();
double w = phasesRect.width()/numPhases;
for(int i=0; i<numPhases; ++i)
{
QJsonObject phase = phases[i].toObject();
QColor c(phase[STATE_COLOR_RED].toInt(),
phase[STATE_COLOR_GREEN].toInt(),
phase[STATE_COLOR_BLUE].toInt());
painter->setPen(c);
painter->setBrush(c);
painter->drawRect(phasesRect.x() + i*w, phasesRect.y(), w, phasesRect.height());
}
if(numPhases == 0)
{
QFont font = qApp->font();
font.setPointSizeF(pointSize(11));
painter->setFont(font);
painter->fillRect(phasesRect, QColor(0, 0, 0, 180));
painter->setPen(QColor(200, 200, 200));
painter->drawText(phasesRect, Qt::AlignCenter, tr("No Phase"));
}
painter->setPen(QColor(0, 0, 0));
painter->setBrush(Qt::NoBrush);
painter->drawRect(phasesRect);
/*if(mGreyedOut)
{
painter->setPen(Painting::greyedOut);
painter->setBrush(Painting::greyedOut);
painter->drawEllipse(boundingRect());
}*/
// Border
painter->setBrush(Qt::NoBrush);
if(mMergeable)
{
painter->setPen(QPen(Qt::white, 5.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
painter->setPen(QPen(Painting::mainColorLight, 3.f, Qt::DashLine));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
else if(isSelected())
{
painter->setPen(QPen(Qt::white, 5.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
painter->setPen(QPen(Qt::red, 3.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
}
void
MSSOTLTrafficLightLogic::init(NLDetectorBuilder& nb) throw(ProcessError) {
MSTrafficLightLogic::init(nb);
if (isDecayThresholdActivated()) {
decayThreshold = 1;
}
if (sensorsSelfBuilt) {
//Building SOTLSensors
switch (SENSORS_TYPE) {
case SENSORS_TYPE_E1:
assert(0); // Throw exception because TLS can only handle E2 sensors
case SENSORS_TYPE_E2:
//Adding Sensors to the ingoing Lanes
LaneVectorVector lvv = getLaneVectors();
DBG(
WRITE_MESSAGE("Listing lanes for TLS " + getID());
for (unsigned int i = 0; i < lvv.size(); i++) {
LaneVector lv = lvv[i];
for (unsigned int j = 0; j < lv.size(); j++) {
MSLane* lane = lv[j];
WRITE_MESSAGE(lane ->getID());
}
}
)
mySensors = new MSSOTLE2Sensors(myID, &(getPhases()));
((MSSOTLE2Sensors*)mySensors)->buildSensors(myLanes, nb, getInputSensorsLength());
mySensors->stepChanged(getCurrentPhaseIndex());
if (getParameter("USE_VEHICLE_TYPES_WEIGHTS", "0") == "1") {
((MSSOTLE2Sensors*) mySensors)->setVehicleWeigths(getParameter("VEHICLE_TYPES_WEIGHTS", ""));
}
//threshold speed param for tuning with irace
((MSSOTLE2Sensors*)mySensors)->setSpeedThresholdParam(getSpeedThreshold());
myCountSensors = new MSSOTLE2Sensors(myID + "Count", &(getPhases()));
myCountSensors->buildCountSensors(myLanes, nb);
myCountSensors->stepChanged(getCurrentPhaseIndex());
//Adding Sensors to the outgoing Lanes
LinkVectorVector myLinks = getLinks();
DBG(
WRITE_MESSAGE("Listing output lanes");
for (unsigned int i = 0; i < myLinks.size(); i++) {
LinkVector oneLink = getLinksAt(i);
for (unsigned int j = 0; j < oneLink.size(); j++) {
MSLane* lane = oneLink[j]->getLane();
WRITE_MESSAGE(lane ->getID());
}
}
)
LaneVectorVector myLaneVector;
LaneVector outLanes;
LinkVectorVector myoutLinks = getLinks();
for (unsigned int i = 0; i < myLinks.size(); i++) {
LinkVector oneLink = getLinksAt(i);
for (unsigned int j = 0; j < oneLink.size(); j++) {
MSLane* lane = oneLink[j]->getLane();
outLanes.push_back(lane);
}
}
if (outLanes.size() > 0) {
myLaneVector.push_back(outLanes);
}
if (myLaneVector.size() > 0) {
((MSSOTLE2Sensors*)mySensors)->buildOutSensors(myLaneVector, nb, getOutputSensorsLength());
myCountSensors->buildCountOutSensors(myLaneVector, nb);
}
}
void Network::read(NetworkProto::Reader& proto)
{
// Clear any previous regions
while (regions_.getCount() > 0)
{
auto pair = regions_.getByIndex(0);
delete pair.second;
regions_.remove(pair.first);
}
// Add regions
for (auto entry : proto.getRegions().getEntries())
{
auto regionProto = entry.getValue();
auto region = addRegionFromProto(entry.getKey().cStr(), regionProto);
// Initialize the phases for the region
std::set<UInt32> phases;
for (auto phase : regionProto.getPhases())
{
phases.insert(phase);
}
setPhases_(region, phases);
}
// Add links. Note that we can't just pass the capnp struct to Link.read
// because the linked input and output need references to the new link.
for (auto linkProto : proto.getLinks())
{
if (!regions_.contains(linkProto.getSrcRegion().cStr()))
{
NTA_THROW << "Link references unknown region: "
<< linkProto.getSrcRegion().cStr();
}
Region* srcRegion = regions_.getByName(linkProto.getSrcRegion().cStr());
Output* srcOutput = srcRegion->getOutput(linkProto.getSrcOutput().cStr());
if (srcOutput == nullptr)
{
NTA_THROW << "Link references unknown source output: "
<< linkProto.getSrcOutput().cStr();
}
if (!regions_.contains(linkProto.getDestRegion().cStr()))
{
NTA_THROW << "Link references unknown region: "
<< linkProto.getDestRegion().cStr();
}
Region* destRegion = regions_.getByName(linkProto.getDestRegion().cStr());
Input* destInput = destRegion->getInput(linkProto.getDestInput().cStr());
if (destInput == nullptr)
{
NTA_THROW << "Link references unknown destination input: "
<< linkProto.getDestInput().cStr();
}
// Actually create the link
destInput->addLink(
linkProto.getType().cStr(), linkProto.getParams().cStr(), srcOutput);
}
initialized_ = false;
}