void
GUIParameterTracker::GUIParameterTrackerPanel::drawValues() {
// compute which font to use
/*
SUMOReal fontIdx = ((SUMOReal) myWidthInPixels-300.) / 10.;
if(fontIdx<=0) fontIdx = 1;
if(fontIdx>4) fontIdx = 4;
*/
pfSetScale((SUMOReal) 0.1);
pfSetScaleXY((SUMOReal)(.1*300./myWidthInPixels), (SUMOReal)(.1*300./(SUMOReal) myHeightInPixels));
// GUITexturesHelper::getFontRenderer().SetActiveFont(4-fontIdx);
//
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_TEXTURE_2D);
size_t run = 0;
for (TrackedVarsVector::iterator i=myParent->myTracked.begin(); i!=myParent->myTracked.end(); i++) {
TrackerValueDesc *desc = *i;
drawValue(*desc,
(SUMOReal) myWidthInPixels / (SUMOReal) myParent->myTracked.size() *(SUMOReal) run);
run++;
}
// GUITexturesHelper::getFontRenderer().Draw(myWidthInPixels, myHeightInPixels);//this, width, height);
}
int pfSetScaleBoxW(wchar_t *c, SUMOReal w, SUMOReal h)
{
SUMOReal x1, y1, x2, y2;
if (NULL == c)
{
return -1;
}
if (-1 == getStringBoxW(c, &x1, &y1, &x2, &y2))
{
return -1;
}
pfSetScaleXY((w / (x2 - x1)), (h / (y2 - y1)));
return 0;
}
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
GUISUMOAbstractView::displayLegend() {
// compute the scale bar length
size_t length = 1;
const std::string text("10000000000");
size_t noDigits = 1;
size_t pixelSize = (size_t) m2p((SUMOReal) length);
while (pixelSize <= 20) {
length *= 10;
noDigits++;
if (noDigits > text.length()) {
return;
}
pixelSize = (size_t) m2p((SUMOReal) length);
}
SUMOReal lineWidth = 1.0;
glLineWidth((SUMOReal) lineWidth);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
// draw the scale bar
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
SUMOReal len = (SUMOReal) pixelSize / (SUMOReal)(getWidth() - 1) * (SUMOReal) 2.0;
glColor3d(0, 0, 0);
double o = double(15) / double(getHeight());
double o2 = o + o;
double oo = double(5) / double(getHeight());
glBegin(GL_LINES);
// vertical
glVertex2d(-.98, -1. + o);
glVertex2d(-.98 + len, -1. + o);
// tick at begin
glVertex2d(-.98, -1. + o);
glVertex2d(-.98, -1. + o2);
// tick at end
glVertex2d(-.98 + len, -1. + o);
glVertex2d(-.98 + len, -1. + o2);
glEnd();
SUMOReal w = SUMOReal(35) / SUMOReal(getWidth());
SUMOReal h = SUMOReal(35) / SUMOReal(getHeight());
pfSetPosition(SUMOReal(-0.99), SUMOReal(1. - o2 - oo));
pfSetScaleXY(w, h);
glRotated(180, 1, 0, 0);
pfDrawString("0m");
glRotated(-180, 1, 0, 0);
pfSetPosition(SUMOReal(-.99 + len), SUMOReal(1. - o2 - oo));
glRotated(180, 1, 0, 0);
pfDrawString((text.substr(0, noDigits) + "m").c_str());
glRotated(-180, 1, 0, 0);
// restore matrices
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
