RGBColor
GNEInternalLane::colorForLinksState(FXuint state) {
if (state == LINKSTATE_TL_YELLOW_MINOR) {
// special case (default gui does not distinguish between yellow major/minor
return RGBColor(179, 179, 0, 255);
} else {
return getLinkColor((LinkState)state);
}
}
void
GUITLLogicPhasesTrackerWindow::drawValues(GUITLLogicPhasesTrackerPanel& caller) {
// compute what shall be shown (what is visible)
myFirstPhase2Show = 0;
myFirstPhaseOffset = 0;
size_t leftOffset = 0;
myFirstTime2Show = 0;
if (!myAmInTrackingMode) {
myPhases.clear();
myDurations.clear();
// insert phases
const MSSimpleTrafficLightLogic::Phases& phases = static_cast<MSSimpleTrafficLightLogic*>(myTLLogic)->getPhases();
MSSimpleTrafficLightLogic::Phases::const_iterator j;
myLastTime = 0;
myBeginTime = 0;
for (j = phases.begin(); j != phases.end(); ++j) {
myPhases.push_back(*(*j));
myDurations.push_back((*j)->duration);
myLastTime += (*j)->duration;
}
if (myLastTime <= myBeginTime) {
WRITE_ERROR("Overflow in time computation occured.");
return;
}
} else {
SUMOTime beginOffset = TIME2STEPS(myBeginOffset->getValue());
myBeginTime = myLastTime - beginOffset;
myFirstTime2Show = myBeginTime;
// check whether no phases are known at all
if (myDurations.size() != 0) {
SUMOTime durs = 0;
size_t phaseOffset = myDurations.size() - 1;
DurationsVector::reverse_iterator i = myDurations.rbegin();
while (i != myDurations.rend()) {
if (durs + (*i) > beginOffset) {
myFirstPhase2Show = phaseOffset;
myFirstPhaseOffset = (durs + (*i)) - beginOffset;
break;
}
durs += (*i);
phaseOffset--;
++i;
}
if (i == myDurations.rend()) {
// there are too few information stored;
myFirstPhase2Show = 0;
myFirstPhaseOffset = 0;
leftOffset = beginOffset - durs;
}
}
}
// begin drawing
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(-1, -1, 0);
glScaled(2, 2, 1);
glDisable(GL_TEXTURE_2D);
// draw the horizontal lines dividing the signal groups
glColor3d(1, 1, 1);
// compute some values needed more than once
const SUMOReal height = (SUMOReal) caller.getHeight();
const SUMOReal width = (SUMOReal) caller.getWidth();
pfSetScaleXY((SUMOReal)(.08 * 300. / width), (SUMOReal)(.08 * 300. / height));
const SUMOReal h4 = ((SUMOReal) 4 / height);
const SUMOReal h9 = ((SUMOReal) 9 / height);
const SUMOReal h10 = ((SUMOReal) 10 / height);
const SUMOReal h11 = ((SUMOReal) 11 / height);
const SUMOReal h16 = ((SUMOReal) 16 / height);
const SUMOReal h20 = ((SUMOReal) 20 / height);
// draw the link names and the lines dividing them
SUMOReal h = (SUMOReal)(1.0 - h10);
SUMOReal h2 = 12;
for (size_t i = 0; i < myTLLogic->getLinks().size() + 1; ++i) {
// draw the bar
glBegin(GL_LINES);
glVertex2d(0, h);
glVertex2d((SUMOReal)(30. / width), h);
glEnd();
// draw the name
if (i < myTLLogic->getLinks().size()) {
glRotated(180, 1, 0, 0);
pfSetPosition(0, 0);
glTranslated(0.0, -h + h20 - h4, 0);
pfDrawString(myLinkNames[i].c_str());
glTranslated(-0.0, h - h20 + h4, 0);
glRotated(-180, 1, 0, 0);
h2 += 20;
}
h -= h20;
}
glBegin(GL_LINES);
glVertex2d(0, h + h20);
glVertex2d(1.0, h + h20);
glEnd();
// draw the names closure (vertical line)
h += (SUMOReal) 20 / height;
glColor3d(1, 1, 1);
glBegin(GL_LINES);
glVertex2d((SUMOReal) 30 / width, 1.0);
glVertex2d((SUMOReal) 30 / width, h);
glEnd();
// draw the phases
// disable value addition while drawing
myLock.lock();
// determine the initial offset
SUMOReal x = ((SUMOReal) 31. / width);
SUMOReal ta = (SUMOReal) leftOffset / width;
ta *= (SUMOReal)(((width - 31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
x += ta;
// and the initial phase information
PhasesVector::iterator pi = myPhases.begin() + myFirstPhase2Show;
DurationsVector::iterator pd = myDurations.begin() + myFirstPhase2Show;
size_t fpo = myFirstPhaseOffset;
// start drawing
for (size_t i = 30; pd != myDurations.end();) {
// the first phase may be drawn incompletely
size_t duration = *pd - fpo;
// compute the heigh and the width of the phase
h = (SUMOReal)(1.0 - h10);
SUMOReal a = (SUMOReal) duration / width;
a *= (SUMOReal)(((width - 31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
SUMOReal x2 = x + a;
// go through the links
for (int j = 0; j < (int) myTLLogic->getLinks().size(); ++j) {
// determine the current link's color
LinkState state = pi->getSignalState(j);
// draw the bar (red is drawn as a line)
GLHelper::setColor(getLinkColor(state));
switch (state) {
case LINKSTATE_TL_RED:
case LINKSTATE_TL_REDYELLOW:
// draw a thin line
glBegin(GL_QUADS);
glVertex2d(x, h - h11);
glVertex2d(x, h - h9);
glVertex2d(x2, h - h9);
glVertex2d(x2, h - h11);
glEnd();
break;
default:
// draw a thick block
glBegin(GL_QUADS);
glVertex2d(x, h - h16);
glVertex2d(x, h - h4);
glVertex2d(x2, h - h4);
glVertex2d(x2, h - h16);
glEnd();
break;
}
// proceed to next link
h -= h20;
}
// proceed to next phase
i += duration;
++pi;
++pd;
x = x2;
// all further phases are drawn in full
fpo = 0;
}
// allow value addition
myLock.unlock();
glColor3d(1, 1, 1);
if (myPhases.size() != 0) {
SUMOTime tickDist = TIME2STEPS(10);
// patch distances - hack
SUMOReal t = myBeginOffset != 0 ? (SUMOReal) myBeginOffset->getValue() : STEPS2TIME(myLastTime - myBeginTime);
while (t > (width - 31.) / 4.) {
tickDist += TIME2STEPS(10);
t -= (SUMOReal)((width - 31.) / 4.);
}
// draw time information
//h = (SUMOReal)(myTLLogic->getLinks().size() * 20 + 12);
SUMOReal glh = (SUMOReal)(1.0 - myTLLogic->getLinks().size() * h20 - h10);
// current begin time
pfSetScaleXY((SUMOReal)(.05 * 300. / width), (SUMOReal)(.05 * 300. / height));
// time ticks
SUMOTime currTime = myFirstTime2Show;
int pos = 31;// + /*!!!currTime*/ - myFirstTime2Show;
SUMOReal glpos = (SUMOReal) pos / width;
while (pos < width + 50) {
const std::string timeStr = time2string(currTime);
const SUMOReal w = pfdkGetStringWidth(timeStr.c_str());
glRotated(180, 1, 0, 0);
pfSetPosition(0, 0);
glTranslated(glpos - w / 2., -glh + h20 - h4, 0);
pfDrawString(timeStr.c_str());
glTranslated(-glpos + w / 2., glh - h20 + h4, 0);
glRotated(-180, 1, 0, 0);
glBegin(GL_LINES);
glVertex2d(glpos, glh);
glVertex2d(glpos, glh - h4);
glEnd();
const SUMOReal a = STEPS2TIME(tickDist) * (width - 31.0) / STEPS2TIME(myLastTime - myBeginTime);
pos += (int) a;
glpos += a / width;
currTime += tickDist;
}
}
}
void
GUILane::drawLinkRules(const GUINet& net) const {
unsigned int noLinks = (unsigned int)myLinks.size();
const PositionVector& g = getShape();
const Position& end = g.back();
const Position& f = g[-2];
const Position& s = end;
const SUMOReal rot = RAD2DEG(atan2((s.x() - f.x()), (f.y() - s.y())));
if (noLinks == 0) {
glPushName(getGlID());
GLHelper::setColor(getLinkColor(LINKSTATE_DEADEND));
glPushMatrix();
glTranslated(end.x(), end.y(), 0);
glRotated(rot, 0, 0, 1);
glBegin(GL_QUADS);
glVertex2d(-myHalfLaneWidth, 0.0);
glVertex2d(-myHalfLaneWidth, 0.5);
glVertex2d(myHalfLaneWidth, 0.5);
glVertex2d(myHalfLaneWidth, 0.0);
glEnd();
glPopMatrix();
glPopName();
return;
}
// draw all links
const bool railway = isRailway(myPermissions);
SUMOReal w = myWidth / (SUMOReal) noLinks;
SUMOReal x1 = 0;
glPushMatrix();
glTranslated(end.x(), end.y(), 0);
glRotated(rot, 0, 0, 1);
for (unsigned int i = 0; i < noLinks; ++i) {
SUMOReal x2 = x1 + w;
MSLink* link = myLinks[i];
// select glID
switch (link->getState()) {
case LINKSTATE_TL_GREEN_MAJOR:
case LINKSTATE_TL_GREEN_MINOR:
case LINKSTATE_TL_RED:
case LINKSTATE_TL_YELLOW_MAJOR:
case LINKSTATE_TL_YELLOW_MINOR:
case LINKSTATE_TL_OFF_BLINKING:
glPushName(net.getLinkTLID(link));
break;
case LINKSTATE_MAJOR:
case LINKSTATE_MINOR:
case LINKSTATE_EQUAL:
case LINKSTATE_TL_OFF_NOSIGNAL:
default:
glPushName(getGlID());
break;
}
GLHelper::setColor(getLinkColor(link->getState()));
if (!railway || link->getState() != LINKSTATE_MAJOR) {
// THE WHITE BAR SHOULD BE THE DEFAULT FOR MOST RAILWAY
// LINKS AND LOOKS UGLY SO WE DO NOT DRAW IT
glBegin(GL_QUADS);
glVertex2d(x1 - myHalfLaneWidth, 0.0);
glVertex2d(x1 - myHalfLaneWidth, 0.5);
glVertex2d(x2 - myHalfLaneWidth, 0.5);
glVertex2d(x2 - myHalfLaneWidth, 0.0);
glEnd();
}
glPopName();
x1 = x2;
x2 += w;
}
glPopMatrix();
}
