void
GUIParkingArea::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
RGBColor grey(177, 184, 186, 171);
RGBColor blue(83, 89, 172, 255);
RGBColor red(255, 0, 0, 255);
RGBColor green(0, 255, 0, 255);
// draw the area
glTranslated(0, 0, getType());
GLHelper::setColor(blue);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, myWidth / 2.);
// draw details unless zoomed out to far
const double exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 1) {
// draw the lots
glTranslated(0, 0, .1);
std::map<unsigned int, LotSpaceDefinition >::const_iterator i;
for (i = mySpaceOccupancies.begin(); i != mySpaceOccupancies.end(); i++) {
glPushMatrix();
glTranslated((*i).second.myPosition.x(), (*i).second.myPosition.y(), (*i).second.myPosition.z());
glRotated((*i).second.myRotation, 0, 0, 1);
Position pos = (*i).second.myPosition;
PositionVector geom;
double w = (*i).second.myWidth / 2. - 0.1 * exaggeration;
double h = (*i).second.myLength;
geom.push_back(Position(- w, + 0, 0.));
geom.push_back(Position(+ w, + 0, 0.));
geom.push_back(Position(+ w, + h, 0.));
geom.push_back(Position(- w, + h, 0.));
geom.push_back(Position(- w, + 0, 0.));
/*
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
*/
GLHelper::setColor((*i).second.vehicle == 0 ? green : red);
GLHelper::drawBoxLines(geom, 0.1 * exaggeration);
glPopMatrix();
}
GLHelper::setColor(blue);
// draw the lines
for (size_t i = 0; i != myLines.size(); ++i) {
// push a new matrix for every line
glPushMatrix();
// traslate and rotate
glTranslated(mySignPos.x(), mySignPos.y(), 0);
glRotated(180, 1, 0, 0);
glRotated(mySignRot, 0, 0, 1);
// draw line
GLHelper::drawText(myLines[i].c_str(), Position(1.2, (double)i), .1, 1.f, RGBColor(76, 170, 50), 0, FONS_ALIGN_LEFT);
// pop matrix for every line
glPopMatrix();
}
// draw the sign
glTranslated(mySignPos.x(), mySignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((double) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(grey);
GLHelper::drawFilledCircle((double) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("P", Position(), .1, 1.6, blue, mySignRot);
}
}
glPopMatrix();
if (s.addFullName.show && getMyName() != "") {
GLHelper::drawText(getMyName(), mySignPos, GLO_MAX - getType(), s.addFullName.scaledSize(s.scale), s.addFullName.color, s.getTextAngle(mySignRot));
}
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
for (std::vector<MSTransportable*>::const_iterator i = myWaitingTransportables.begin(); i != myWaitingTransportables.end(); ++i) {
glTranslated(0, 1, 0); // make multiple containers viewable
static_cast<GUIContainer*>(*i)->drawGL(s);
}
// draw parking vehicles (their lane might not be within drawing range. if it is, they are drawn twice)
myLane.getVehiclesSecure();
for (std::set<const MSVehicle*>::const_iterator v = myLane.getParkingVehicles().begin(); v != myLane.getParkingVehicles().end(); ++v) {
static_cast<const GUIVehicle* const>(*v)->drawGL(s);
}
myLane.releaseVehicles();
}
void
GUITriggeredRerouter::GUITriggeredRerouterEdge::drawGL(const GUIVisualizationSettings& s) const {
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 3) {
glPushName(getGlID());
const SUMOReal prob = myParent->getProbability();
if (myAmClosedEdge) {
// draw closing symbol onto all lanes
const RerouteInterval* const ri =
myParent->getCurrentReroute(MSNet::getInstance()->getCurrentTimeStep());
if (ri != 0 && prob > 0) {
// draw only if the edge is closed at this time
if (std::find(ri->closed.begin(), ri->closed.end(), myEdge) != ri->closed.end()) {
const size_t noLanes = myFGPositions.size();
for (size_t j = 0; j < noLanes; ++j) {
Position pos = myFGPositions[j];
SUMOReal rot = myFGRotations[j];
glPushMatrix();
glTranslated(pos.x(), pos.y(), 0);
glRotated(rot, 0, 0, 1);
glTranslated(0, -1.5, 0);
int noPoints = 9;
if (s.scale > 25) {
noPoints = (int)(9.0 + s.scale / 10.0);
if (noPoints > 36) {
noPoints = 36;
}
}
glTranslated(0, 0, getType());
//glScaled(exaggeration, exaggeration, 1);
glColor3d(0.7, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.3, noPoints);
glTranslated(0, 0, .1);
glColor3d(1, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.3, noPoints, 0, prob * 360);
glTranslated(0, 0, .1);
glColor3d(1, 1, 1);
glRotated(-90, 0, 0, 1);
glBegin(GL_TRIANGLES);
glVertex2d(0 - .3, -1.);
glVertex2d(0 - .3, 1.);
glVertex2d(0 + .3, 1.);
glVertex2d(0 + .3, -1.);
glVertex2d(0 - .3, -1.);
glVertex2d(0 + .3, 1.);
glEnd();
glPopMatrix();
}
}
}
} else {
// draw rerouter symbol onto all lanes
for (size_t i = 0; i < myFGPositions.size(); ++i) {
const Position& pos = myFGPositions[i];
SUMOReal rot = myFGRotations[i];
glPushMatrix();
glTranslated(pos.x(), pos.y(), 0);
glRotated(rot, 0, 0, 1);
glTranslated(0, 0, getType());
glScaled(exaggeration, exaggeration, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
glColor3d(1, .8f, 0);
// base
glVertex2d(0 - 1.4, 0);
glVertex2d(0 - 1.4, 6);
glVertex2d(0 + 1.4, 6);
glVertex2d(0 + 1.4, 0);
glVertex2d(0 - 1.4, 0);
glVertex2d(0 + 1.4, 6);
glEnd();
glTranslated(0, 0, .1);
glColor3d(0, 0, 0);
pfSetPosition(0, 0);
pfSetScale(3.f);
SUMOReal w = pfdkGetStringWidth("U");
glRotated(180, 0, 1, 0);
glTranslated(-w / 2., 2, 0);
pfDrawString("U");
glTranslated(w / 2., -2, 0);
std::string str = toString((int)(prob * 100)) + "%";
pfSetPosition(0, 0);
pfSetScale(.7f);
w = pfdkGetStringWidth(str.c_str());
glTranslated(-w / 2., 4, 0);
pfDrawString(str.c_str());
glPopMatrix();
}
}
glPopName();
}
}
void
GNECrossing::drawGL(const GUIVisualizationSettings& s) const {
// only draw if option drawCrossingsAndWalkingareas is enabled and size of shape is greather than 0 and zoom is close enough
if (s.drawCrossingsAndWalkingareas &&
(myShapeRotations.size() > 0) &&
(myShapeLengths.size() > 0) &&
(s.scale > 3.0)) {
auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges);
if (s.editMode != GNE_NMODE_TLS) {
// push first draw matrix
glPushMatrix();
// push name
glPushName(getGlID());
// must draw on top of junction
glTranslated(0, 0, GLO_JUNCTION + 0.1);
// set color depending of selection and priority
if (drawUsingSelectColor()) {
glColor3d(0.118, 0.565, 1.000);
} else if (!crossing->valid) {
glColor3d(1.0, 0.1, 0.1);
} else if (crossing->priority) {
glColor3d(0.9, 0.9, 0.9);
} else {
glColor3d(0.1, 0.1, 0.1);
}
// traslate to front
glTranslated(0, 0, .2);
// set default values
double length = 0.5;
double spacing = 1.0;
double halfWidth = crossing->width * 0.5;
// push second draw matrix
glPushMatrix();
// draw on top of of the white area between the rails
glTranslated(0, 0, 0.1);
for (int i = 0; i < (int)myShape.size() - 1; ++i) {
// push three draw matrix
glPushMatrix();
// translate and rotate
glTranslated(myShape[i].x(), myShape[i].y(), 0.0);
glRotated(myShapeRotations[i], 0, 0, 1);
// draw crossing depending if isn't being drawn for selecting
if (!s.drawForSelecting) {
for (double t = 0; t < myShapeLengths[i]; t += spacing) {
glBegin(GL_QUADS);
glVertex2d(-halfWidth, -t);
glVertex2d(-halfWidth, -t - length);
glVertex2d(halfWidth, -t - length);
glVertex2d(halfWidth, -t);
glEnd();
}
} else {
// only draw a single rectangle if it's being drawn only for selecting
glBegin(GL_QUADS);
glVertex2d(-halfWidth, 0);
glVertex2d(-halfWidth, -myShapeLengths.back());
glVertex2d(halfWidth, -myShapeLengths.back());
glVertex2d(halfWidth, 0);
glEnd();
}
// pop three draw matrix
glPopMatrix();
}
// XXX draw junction index / tls index
// pop second draw matrix
glPopMatrix();
// traslate to back
glTranslated(0, 0, -.2);
// pop name
glPopName();
// pop draw matrix
glPopMatrix();
}
// link indices must be drawn in all edit modes if isn't being drawn for selecting
if (s.drawLinkTLIndex.show && !s.drawForSelecting) {
drawTLSLinkNo(s);
}
// check if dotted contour has to be drawn
if (!s.drawForSelecting && (myNet->getViewNet()->getDottedAC() == this)) {
GLHelper::drawShapeDottedContour(getType(), myShape, crossing->width * 0.5);
}
}
}
void
GNEDetectorE2::drawGL(const GUIVisualizationSettings& s) const {
// Start drawing adding an gl identificator
glPushName(getGlID());
// Add a draw matrix
glPushMatrix();
// Start with the drawing of the area traslating matrix to origin
glTranslated(0, 0, getType());
// Set color of the base
if (drawUsingSelectColor()) {
GLHelper::setColor(s.selectedAdditionalColor);
} else {
// set color depending if is or isn't valid
if (myE2valid) {
GLHelper::setColor(s.SUMO_color_E2);
} else {
GLHelper::setColor(RGBColor::RED);
}
}
// Obtain exaggeration of the draw
const double exaggeration = s.addSize.getExaggeration(s, this);
// check if we have to drawn a E2 single lane or a E2 multiLane
if (myGeometry.shape.size() > 0) {
// Draw the area using shape, shapeRotations, shapeLengths and value of exaggeration
GLHelper::drawBoxLines(myGeometry.shape, myGeometry.shapeRotations, myGeometry.shapeLengths, exaggeration);
} else {
// iterate over multishapes
for (int i = 0; i < (int)myGeometry.multiShape.size(); i++) {
// don't draw shapes over connections if "show connections" is enabled
if (!myViewNet->getViewOptions().showConnections() || (i % 2 == 0)) {
GLHelper::drawBoxLines(myGeometry.multiShape.at(i), myGeometry.multiShapeRotations.at(i), myGeometry.multiShapeLengths.at(i), exaggeration);
}
}
}
// Pop last matrix
glPopMatrix();
// Check if the distance is enougth to draw details and isn't being drawn for selecting
if ((s.scale * exaggeration >= 10) && !s.drawForSelecting) {
// draw logo depending if this is an Multilane E2 detector
if (myTagProperty.getTag() == SUMO_TAG_E2DETECTOR) {
// Push matrix
glPushMatrix();
// Traslate to center of detector
glTranslated(myGeometry.shape.getLineCenter().x(), myGeometry.shape.getLineCenter().y(), getType() + 0.1);
// Rotate depending of myBlockIcon.rotation
glRotated(myBlockIcon.rotation, 0, 0, -1);
//move to logo position
glTranslated(-0.75, 0, 0);
// draw E2 logo
if (drawUsingSelectColor()) {
GLHelper::drawText("E2", Position(), .1, 1.5, s.selectionColor);
} else {
GLHelper::drawText("E2", Position(), .1, 1.5, RGBColor::BLACK);
}
} else {
// Push matrix
glPushMatrix();
// Traslate to center of detector
glTranslated(myBlockIcon.position.x(), myBlockIcon.position.y(), getType() + 0.1);
// Rotate depending of myBlockIcon.rotation
glRotated(myBlockIcon.rotation, 0, 0, -1);
//move to logo position
glTranslated(-1.5, 0, 0);
// draw E2 logo
if (drawUsingSelectColor()) {
GLHelper::drawText("E2", Position(), .1, 1.5, s.selectionColor);
} else {
GLHelper::drawText("E2", Position(), .1, 1.5, RGBColor::BLACK);
}
//move to logo position
glTranslated(1.2, 0, 0);
// Rotate depending of myBlockIcon.rotation
glRotated(90, 0, 0, 1);
if (drawUsingSelectColor()) {
GLHelper::drawText("multi", Position(), .1, 0.9, s.selectedAdditionalColor);
} else {
GLHelper::drawText("multi", Position(), .1, 0.9, RGBColor::BLACK);
}
}
// pop matrix
glPopMatrix();
// Show Lock icon depending of the Edit mode
myBlockIcon.draw();
}
// Draw name if isn't being drawn for selecting
if (!s.drawForSelecting) {
drawName(getPositionInView(), s.scale, s.addName);
}
// check if dotted contour has to be drawn
if (!s.drawForSelecting && (myViewNet->getDottedAC() == this)) {
if (myGeometry.shape.size() > 0) {
GLHelper::drawShapeDottedContour(getType(), myGeometry.shape, exaggeration);
} else {
GLHelper::drawShapeDottedContour(getType(), myGeometry.multiShapeUnified, exaggeration);
}
}
// Pop name
glPopName();
}
void
GUIChargingStation::drawGL(const GUIVisualizationSettings& s) const {
// Draw Charging Station
glPushName(getGlID());
glPushMatrix();
RGBColor blue(114, 210, 252, 255);
RGBColor green(76, 170, 50, 255);
RGBColor yellow(255, 235, 0, 255);
RGBColor yellowCharge(255, 180, 0, 255);
// draw the area depending if the vehicle is charging
glTranslated(0, 0, getType());
if (myChargingVehicle == true) {
GLHelper::setColor(yellowCharge);
} else {
GLHelper::setColor(blue);
}
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
GLHelper::drawBoxLines(myFGShape, myFGShapeRotations, myFGShapeLengths, exaggeration);
// draw details unless zoomed out to far
if (s.scale * exaggeration >= 10) {
// push charging power matrix
glPushMatrix();
// Traslate End positionof signal
glTranslated(myFGSignPos.x(), myFGSignPos.y(), 0);
// Rotate 180 (Eje X -> Mirror)
glRotated(180, 1, 0, 0);
// Rotate again using myBlockIconRotation
glRotated(myFGSignRot, 0, 0, 1);
// Set poligon mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// set polyfront position on 0,0
pfSetPosition(0, 0);
// Set polyfront scale to 1
pfSetScale(1.f);
// traslate matrix
glTranslated(1.2, 0, 0);
// draw charging power
pfDrawString((toString(myChargingPower) + " W").c_str());
// pop charging power matrix
glPopMatrix();
// draw the sign
glTranslated(myFGSignPos.x(), myFGSignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(yellow);
GLHelper::drawFilledCircle((SUMOReal) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("C", Position(), .1, 1.6, blue, myFGSignRot);
}
glTranslated(5, 0, 0);
}
glPopMatrix();
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
}
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();
}
void
GNEDetectorExit::drawGL(const GUIVisualizationSettings& s) const {
// Start drawing adding gl identificator
glPushName(getGlID());
// Push detector matrix
glPushMatrix();
glTranslated(0, 0, getType());
// Set initial values
if (isAttributeCarrierSelected()) {
GLHelper::setColor(myViewNet->getNet()->selectedAdditionalColor);
} else {
GLHelper::setColor(s.SUMO_color_E3Exit);
}
const double exaggeration = s.addSize.getExaggeration(s);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Push polygon matrix
glPushMatrix();
glScaled(exaggeration, exaggeration, 1);
glTranslated(myShape[0].x(), myShape[0].y(), 0);
glRotated(myShapeRotations[0], 0, 0, 1);
// Draw polygon
glBegin(GL_LINES);
glVertex2d(1.7, 0);
glVertex2d(-1.7, 0);
glEnd();
glBegin(GL_QUADS);
glVertex2d(-1.7, .5);
glVertex2d(-1.7, -.5);
glVertex2d(1.7, -.5);
glVertex2d(1.7, .5);
glEnd();
// draw details if isn't being drawn for selecting
if(!s.drawForSelecting) {
// first Arrow
glTranslated(1.5, 0, 0);
GLHelper::drawBoxLine(Position(0, 4), 0, 2, .05);
GLHelper::drawTriangleAtEnd(Position(0, 4), Position(0, 1), (double) 1, (double) .25);
// second Arrow
glTranslated(-3, 0, 0);
GLHelper::drawBoxLine(Position(0, 4), 0, 2, .05);
GLHelper::drawTriangleAtEnd(Position(0, 4), Position(0, 1), (double) 1, (double) .25);
}
// Pop polygon matrix
glPopMatrix();
// Pop detector matrix
glPopMatrix();
// Check if the distance is enought to draw details
if (((s.scale * exaggeration) >= 10)) {
// Push matrix
glPushMatrix();
// Traslate to center of detector
glTranslated(myShape.getLineCenter().x(), myShape.getLineCenter().y(), getType() + 0.1);
// Rotate depending of myBlockIconRotation
glRotated(myBlockIconRotation, 0, 0, -1);
//move to logo position
glTranslated(1.9, 0, 0);
// draw Entry logo if isn't being drawn for selecting
if(s.drawForSelecting) {
GLHelper::setColor(s.SUMO_color_E3Exit);
GLHelper::drawBoxLine(Position(0, 1), 0, 2, 1);
} else if (isAttributeCarrierSelected()) {
GLHelper::drawText("E3", Position(), .1, 2.8, myViewNet->getNet()->selectedAdditionalColor);
} else {
GLHelper::drawText("E3", Position(), .1, 2.8, s.SUMO_color_E3Exit);
}
//move to logo position
glTranslated(1.7, 0, 0);
// Rotate depending of myBlockIconRotation
glRotated(90, 0, 0, 1);
// draw Entry text if isn't being drawn for selecting
if(s.drawForSelecting) {
GLHelper::setColor(s.SUMO_color_E3Exit);
GLHelper::drawBoxLine(Position(0, 1), 0, 2, 1);
} else if (isAttributeCarrierSelected()) {
GLHelper::drawText("Exit", Position(), .1, 1, myViewNet->getNet()->selectedAdditionalColor);
} else {
GLHelper::drawText("Exit", Position(), .1, 1, s.SUMO_color_E3Exit);
}
// pop matrix
glPopMatrix();
// Show Lock icon depending of the Edit mode and if isn't being drawn for selecting
if(!s.drawForSelecting) {
drawLockIcon(0.4);
}
}
// Draw name if isn't being drawn for selecting
if(!s.drawForSelecting) {
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
}
// check if dotted contour has to be drawn
if(!s.drawForSelecting && (myViewNet->getACUnderCursor() == this)) {
GLHelper::drawShapeDottedContour(getType(), myShape[0], 3.4, 5, myShapeRotations[0], 0, 2);
}
// pop gl identificator
glPopName();
}
void
GNEDetectorE1::drawGL(const GUIVisualizationSettings& s) const {
// get values
glPushName(getGlID());
SUMOReal width = (SUMOReal) 2.0 * s.scale;
glLineWidth(1.0);
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
// draw shape
glColor3d(1, 1, 0);
glPushMatrix();
glTranslated(0, 0, getType());
glTranslated(myShape[0].x(), myShape[0].y(), 0);
glRotated(myShapeRotations[0], 0, 0, 1);
glScaled(exaggeration, exaggeration, 1);
glBegin(GL_QUADS);
glVertex2d(-1.0, 2);
glVertex2d(-1.0, -2);
glVertex2d( 1.0, -2);
glVertex2d( 1.0, 2);
glEnd();
glTranslated(0, 0, .01);
glBegin(GL_LINES);
glVertex2d(0, 2 - .1);
glVertex2d(0, -2 + .1);
glEnd();
// outline
if (width * exaggeration > 1) {
glColor3d(1, 1, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_QUADS);
glVertex2f(-1.0, 2);
glVertex2f(-1.0, -2);
glVertex2f( 1.0, -2);
glVertex2f( 1.0, 2);
glEnd();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
// position indicator
if (width * exaggeration > 1) {
glRotated(90, 0, 0, -1);
glColor3d(1, 1, 1);
glBegin(GL_LINES);
glVertex2d(0, 1.7);
glVertex2d(0, -1.7);
glEnd();
}
// Pop shape matrix
glPopMatrix();
// Check if the distance is enought to draw details
if (s.scale * exaggeration >= 10) {
// Add a draw matrix
drawDetectorIcon(GUITextureSubSys::getGif(GNETEXTURE_E1));
// Show Lock icon depending of the Edit mode
drawLockIcon();
}
// Finish draw
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
glPopName();
}
void
GUICalibrator::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
std::string flow = "-";
std::string speed = "-";
if (isActive()) {
if (myCurrentStateInterval->v >= 0) {
speed = toString(myCurrentStateInterval->v) + "m/s";
}
if (myCurrentStateInterval->q >= 0) {
flow = toString((int)myCurrentStateInterval->q) + "v/h";
}
}
for (size_t i = 0; i < myFGPositions.size(); ++i) {
const Position& pos = myFGPositions[i];
SUMOReal rot = myFGRotations[i];
glPushMatrix();
glTranslated(pos.x(), pos.y(), getType());
glRotated(rot, 0, 0, 1);
glTranslated(0, 0, getType());
glScaled(s.addExaggeration, s.addExaggeration, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
glColor3d(1, .8f, 0);
// base
glVertex2d(0 - 1.4, 0);
glVertex2d(0 - 1.4, 6);
glVertex2d(0 + 1.4, 6);
glVertex2d(0 + 1.4, 0);
glVertex2d(0 - 1.4, 0);
glVertex2d(0 + 1.4, 6);
glEnd();
// draw text
if (s.scale * s.addExaggeration >= 1.) {
glTranslated(0, 0, .1);
glColor3d(0, 0, 0);
pfSetPosition(0, 0);
pfSetScale(3.f);
SUMOReal w = pfdkGetStringWidth("C");
glRotated(180, 0, 1, 0);
glTranslated(-w / 2., 2, 0);
pfDrawString("C");
glTranslated(w / 2., -2, 0);
pfSetPosition(0, 0);
pfSetScale(.7f);
w = pfdkGetStringWidth(flow.c_str());
glTranslated(-w / 2., 4, 0);
pfDrawString(flow.c_str());
glTranslated(w / 2., -4, 0);
pfSetPosition(0, 0);
pfSetScale(.7f);
w = pfdkGetStringWidth(speed.c_str());
glTranslated(-w / 2., 5, 0);
pfDrawString(speed.c_str());
glTranslated(-w / 2., -5, 0);
}
glPopMatrix();
}
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
glPopName();
}
void
GNELane::drawGL(const GUIVisualizationSettings& s) const {
glPushMatrix();
glPushName(getGlID());
glTranslated(0, 0, getType());
const bool selectedEdge = gSelected.isSelected(myParentEdge.getType(), myParentEdge.getGlID());
const bool selected = gSelected.isSelected(getType(), getGlID());
if (mySpecialColor != 0) {
GLHelper::setColor(*mySpecialColor);
} else if (selected) {
GLHelper::setColor(GNENet::selectedLaneColor);
} else if (selectedEdge) {
GLHelper::setColor(GNENet::selectionColor);
} else {
const GUIColorer& c = s.laneColorer;
if (!setFunctionalColor(c.getActive()) && !setMultiColor(c)) {
GLHelper::setColor(c.getScheme().getColor(getColorValue(c.getActive())));
}
};
// draw lane
// check whether it is not too small
const SUMOReal selectionScale = selected || selectedEdge ? s.selectionScale : 1;
const SUMOReal exaggeration = selectionScale * s.laneWidthExaggeration; // * s.laneScaler.getScheme().getColor(getScaleValue(s.laneScaler.getActive()));
if (s.scale * exaggeration < 1.) {
if (myShapeColors.size() > 0) {
GLHelper::drawLine(getShape(), myShapeColors);
} else {
GLHelper::drawLine(getShape());
}
glPopMatrix();
} else {
if (drawAsRailway(s)) {
// draw as railway
const SUMOReal halfRailWidth = 0.725 * exaggeration;
if (myShapeColors.size() > 0) {
GLHelper::drawBoxLines(getShape(), myShapeRotations, myShapeLengths, myShapeColors, halfRailWidth);
} else {
GLHelper::drawBoxLines(getShape(), myShapeRotations, myShapeLengths, halfRailWidth);
}
RGBColor current = GLHelper::getColor();
glColor3d(1, 1, 1);
glTranslated(0, 0, .1);
GLHelper::drawBoxLines(getShape(), myShapeRotations, myShapeLengths, halfRailWidth - 0.2);
GLHelper::setColor(current);
drawCrossties(0.3 * exaggeration, 1 * exaggeration, 1 * exaggeration);
} else {
// the actual lane
// reduce lane width to make sure that a selected edge can still be seen
const SUMOReal halfWidth = selectionScale * (myParentEdge.getNBEdge()->getLaneWidth(myIndex) / 2 - (selectedEdge ? .3 : 0));
if (myShapeColors.size() > 0) {
GLHelper::drawBoxLines(getShape(), myShapeRotations, myShapeLengths, myShapeColors, halfWidth);
} else {
GLHelper::drawBoxLines(getShape(), myShapeRotations, myShapeLengths, halfWidth);
}
}
glPopMatrix();
if (exaggeration == 1) {
drawMarkings(selectedEdge, exaggeration);
}
// draw ROWs only if target junction has a valid logic)
if (myParentEdge.getDest()->isLogicValid() && s.scale > 3) {
drawArrows();
}
}
glPopName();
}
void
GUILaneWrapper::drawLinkRules(const GUINet& net) const {
unsigned int noLinks = getLinkNumber();
const PositionVector& g = getShape();
const Position& end = g.back();
const Position& f = g[-2];
const Position& s = end;
SUMOReal rot = (SUMOReal) atan2((s.x() - f.x()), (f.y() - s.y())) * (SUMOReal) 180.0 / (SUMOReal) PI;
if (noLinks == 0) {
glPushName(getGlID());
// draw a grey bar if no links are on the street
glColor3d(0.5, 0.5, 0.5);
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
SUMOReal w = myLane.getWidth() / (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 = getLane().getLinkCont()[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;
}
// select color
switch (link->getState()) {
case LINKSTATE_TL_GREEN_MAJOR:
case LINKSTATE_TL_GREEN_MINOR:
glColor3d(0, 1, 0);
break;
case LINKSTATE_TL_RED:
glColor3d(1, 0, 0);
break;
case LINKSTATE_TL_YELLOW_MAJOR:
case LINKSTATE_TL_YELLOW_MINOR:
glColor3d(1, 1, 0);
break;
case LINKSTATE_TL_OFF_BLINKING:
glColor3d(.7, .7, 0);
break;
case LINKSTATE_TL_OFF_NOSIGNAL:
glColor3d(0, 1, 1);
break;
case LINKSTATE_MAJOR:
glColor3d(1, 1, 1);
break;
case LINKSTATE_MINOR:
glColor3d(.2, .2, .2);
break;
case LINKSTATE_EQUAL:
glColor3d(.5, .5, .5);
break;
case LINKSTATE_DEADEND:
glColor3d(0, 0, 0);
break;
}
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();
}
void
GUILaneSpeedTrigger::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
glTranslated(0, 0, getType());
for (size_t i = 0; i < myFGPositions.size(); ++i) {
const Position& pos = myFGPositions[i];
SUMOReal rot = myFGRotations[i];
glPushMatrix();
glScaled(s.addExaggeration, s.addExaggeration, 1);
glTranslated(pos.x(), pos.y(), 0);
glRotated(rot, 0, 0, 1);
glTranslated(0, -1.5, 0);
int noPoints = 9;
if (s.scale > 25) {
noPoints = (int)(9.0 + s.scale / 10.0);
if (noPoints > 36) {
noPoints = 36;
}
}
glColor3d(1, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.3, noPoints);
if (s.scale >= 5) {
glTranslated(0, 0, .1);
glColor3d(0, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
// draw the speed string
// not if scale to low
// compute
SUMOReal value = (SUMOReal) getCurrentSpeed();
if (myShowAsKMH) {
value *= 3.6f;
if (((int) value + 1) % 10 == 0) {
value = (SUMOReal)(((int) value + 1) / 10 * 10);
}
}
if (value != myLastValue) {
myLastValue = value;
myLastValueString = toString<SUMOReal>(myLastValue);
size_t idx = myLastValueString.find('.');
if (idx != std::string::npos) {
if (idx > myLastValueString.length()) {
idx = myLastValueString.length();
}
myLastValueString = myLastValueString.substr(0, idx);
}
}
//draw
glColor3d(1, 1, 0);
glTranslated(0, 0, .1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
pfSetPosition(0, 0);
pfSetScale(1.2f);
SUMOReal w = pfdkGetStringWidth(myLastValueString.c_str());
glRotated(180, 0, 1, 0);
glTranslated(-w / 2., 0.3, 0);
pfDrawString(myLastValueString.c_str());
}
glPopMatrix();
}
glPopMatrix();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
glPopName();
}
void
GUIEdge::drawGL(const GUIVisualizationSettings& s) const {
if (s.hideConnectors && myFunction == MSEdge::EDGEFUNCTION_CONNECTOR) {
return;
}
if (MSGlobals::gUseMesoSim) {
glPushName(getGlID());
}
// draw the lanes
for (LaneWrapperVector::const_iterator i = myLaneGeoms.begin(); i != myLaneGeoms.end(); ++i) {
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
setColor(s);
}
#endif
(*i)->drawGL(s);
}
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
const GUIVisualizationTextSettings& nameSettings = s.vehicleName;
GUIMEVehicleControl* vehicleControl = GUINet::getGUIInstance()->getGUIMEVehicleControl();
if (vehicleControl != 0) {
// draw the meso vehicles
vehicleControl->secureVehicles();
size_t laneIndex = 0;
MESegment::Queue queue;
for (LaneWrapperVector::const_iterator l = myLaneGeoms.begin(); l != myLaneGeoms.end(); ++l, ++laneIndex) {
const PositionVector& shape = (*l)->getShape();
const std::vector<SUMOReal>& shapeRotations = (*l)->getShapeRotations();
const std::vector<SUMOReal>& shapeLengths = (*l)->getShapeLengths();
const Position& laneBeg = shape[0];
glPushMatrix();
glTranslated(laneBeg.x(), laneBeg.y(), 0);
glRotated(shapeRotations[0], 0, 0, 1);
// go through the vehicles
int shapeIndex = 0;
SUMOReal shapeOffset = 0; // ofset at start of current shape
SUMOReal segmentOffset = 0; // offset at start of current segment
for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this);
segment != 0; segment = segment->getNextSegment()) {
const SUMOReal length = segment->getLength();
if (laneIndex < segment->numQueues()) {
// make a copy so we don't have to worry about synchronization
queue = segment->getQueue(laneIndex);
const SUMOReal avgCarSize = segment->getOccupancy() / segment->getCarNumber();
const size_t queueSize = queue.size();
for (size_t i = 0; i < queueSize; i++) {
MSBaseVehicle* veh = queue[queueSize - i - 1];
setVehicleColor(s, veh);
SUMOReal vehiclePosition = segmentOffset + length - i * avgCarSize;
SUMOReal xOff = 0.f;
while (vehiclePosition < segmentOffset) {
// if there is only a single queue for a
// multi-lane edge shift vehicles and start
// drawing again from the end of the segment
vehiclePosition += length;
xOff += 0.5f;
}
while (shapeIndex < (int)shapeRotations.size() - 1 && vehiclePosition > shapeOffset + shapeLengths[shapeIndex]) {
glPopMatrix();
shapeOffset += shapeLengths[shapeIndex];
shapeIndex++;
glPushMatrix();
glTranslated(shape[shapeIndex].x(), shape[shapeIndex].y(), 0);
glRotated(shapeRotations[shapeIndex], 0, 0, 1);
}
glPushMatrix();
glTranslated(xOff, -(vehiclePosition - shapeOffset), GLO_VEHICLE);
glPushMatrix();
glScaled(1, avgCarSize, 1);
glBegin(GL_TRIANGLES);
glVertex2d(0, 0);
glVertex2d(0 - 1.25, 1);
glVertex2d(0 + 1.25, 1);
glEnd();
glPopMatrix();
glPopMatrix();
if (nameSettings.show) {
GLHelper::drawText(veh->getID(),
Position(xOff, -(vehiclePosition - shapeOffset)),
GLO_MAX, nameSettings.size / s.scale, nameSettings.color, 0);
}
}
}
segmentOffset += length;
}
glPopMatrix();
}
vehicleControl->releaseVehicles();
}
glPopName();
}
#endif
// (optionally) draw the name and/or the street name
const bool drawEdgeName = s.edgeName.show && myFunction == EDGEFUNCTION_NORMAL;
const bool drawInternalEdgeName = s.internalEdgeName.show && myFunction != EDGEFUNCTION_NORMAL;
const bool drawStreetName = s.streetName.show && myStreetName != "";
if (drawEdgeName || drawInternalEdgeName || drawStreetName) {
GUILaneWrapper* lane1 = myLaneGeoms[0];
GUILaneWrapper* lane2 = myLaneGeoms[myLaneGeoms.size() - 1];
Position p = lane1->getShape().positionAtLengthPosition(lane1->getShape().length() / (SUMOReal) 2.);
p.add(lane2->getShape().positionAtLengthPosition(lane2->getShape().length() / (SUMOReal) 2.));
p.mul(.5);
SUMOReal angle = lane1->getShape().rotationDegreeAtLengthPosition(lane1->getShape().length() / (SUMOReal) 2.);
angle += 90;
if (angle > 90 && angle < 270) {
angle -= 180;
}
if (drawEdgeName) {
drawName(p, s.scale, s.edgeName, angle);
} else if (drawInternalEdgeName) {
drawName(p, s.scale, s.internalEdgeName, angle);
}
if (drawStreetName) {
GLHelper::drawText(getStreetName(), p, GLO_MAX,
s.streetName.size / s.scale, s.streetName.color, angle);
}
}
myLock.lock();
for (std::set<MSPerson*>::const_iterator i = myPersons.begin(); i != myPersons.end(); ++i) {
GUIPerson* person = dynamic_cast<GUIPerson*>(*i);
assert(person != 0);
person->drawGL(s);
}
myLock.unlock();
}
void
GNEJunction::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
SUMOReal selectionScale = gSelected.isSelected(getType(), getGlID()) ? s.selectionScale : 1;
if (s.scale * selectionScale * myMaxSize < 1.) {
// draw something simple so that selection still works
GLHelper::drawBoxLine(myNBNode.getPosition(), 0, 1, 1);
} else {
// node shape has been computed and is valid for drawing
const bool drawShape = myNBNode.getShape().size() > 0 && s.drawJunctionShape;
const bool drawBubble = (!drawShape || myNBNode.getShape().area() < 4) && s.drawJunctionShape; // magic threshold
if (drawShape) {
glPushMatrix();
setColor(s, false);
glTranslated(0, 0, getType());
PositionVector shape = myNBNode.getShape();
shape.closePolygon();
if (selectionScale > 1) {
shape.scaleRelative(selectionScale);
}
if (s.scale * selectionScale * myMaxSize < 40.) {
GLHelper::drawFilledPoly(shape, true);
} else {
GLHelper::drawFilledPolyTesselated(shape, true);
}
glPopMatrix();
}
if (drawBubble) {
glPushMatrix();
setColor(s, true);
Position pos = myNBNode.getPosition();
glTranslated(pos.x(), pos.y(), getType() - 0.05);
GLHelper::drawFilledCircle(myMaxSize * selectionScale, 32);
glPopMatrix();
}
if (s.editMode == GNE_MODE_TLS && myNBNode.isTLControlled() && !myAmTLSSelected) {
// decorate in tls mode
if (!TLSDecalInitialized) {
FXImage* i = new FXGIFImage(myNet->getApp(), tlslogo, IMAGE_KEEP | IMAGE_SHMI | IMAGE_SHMP);
TLSDecalGlID = GUITexturesHelper::add(i);
TLSDecalInitialized = true;
delete i;
}
glPushMatrix();
Position pos = myNBNode.getPosition();
glTranslated(pos.x(), pos.y(), getType() + 0.1);
glColor3d(1, 1, 1);
const SUMOReal halfWidth = 32 / s.scale;
const SUMOReal halfHeight = 64 / s.scale;
GUITexturesHelper::drawTexturedBox(TLSDecalGlID, -halfWidth, -halfHeight, halfWidth, halfHeight);
glPopMatrix();
}
// draw crossings
if (s.editMode != GNE_MODE_TLS) {
for (std::vector<GNECrossing*>::const_iterator it = myCrossings.begin(); it != myCrossings.end(); it++) {
(*it)->drawGL(s);
}
}
// (optional) draw name @todo expose this setting
drawName(myNBNode.getPosition(), s.scale, s.junctionName);
}
glPopName();
}
void
GNEVariableSpeedSignal::drawGL(const GUIVisualizationSettings& s) const {
// Start drawing adding an gl identificator
glPushName(getGlID());
// Add a draw matrix for drawing logo
glPushMatrix();
glTranslated(myShape[0].x(), myShape[0].y(), getType());
glColor3d(1, 1, 1);
glRotated(180, 0, 0, 1);
// Draw icon depending of rerouter is or isn't selected
if (isAdditionalSelected()) {
GUITexturesHelper::drawTexturedBox(GUITextureSubSys::getTexture(GNETEXTURE_VARIABLESPEEDSIGNALSELECTED), 1);
} else {
GUITexturesHelper::drawTexturedBox(GUITextureSubSys::getTexture(GNETEXTURE_VARIABLESPEEDSIGNAL), 1);
}
// Pop draw icon matrix
glPopMatrix();
// Show Lock icon depending of the Edit mode
drawLockIcon(0.4);
// Push matrix to draw every symbol over lane
glPushMatrix();
// Traslate to 0,0
glTranslated(0, 0, getType());
// Obtain exaggeration
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
// Iterate over lanes
for (childLanes::const_iterator i = myChildLanes.begin(); i != myChildLanes.end(); i++) {
// Draw every signal over Lane
glPushMatrix();
glScaled(exaggeration, exaggeration, 1);
glTranslated(i->positionOverLane.x(), i->positionOverLane.y(), 0);
glRotated(i->rotationOverLane, 0, 0, 1);
glTranslated(0, -1.5, 0);
int noPoints = 9;
if (s.scale > 25) {
noPoints = (int)(9.0 + s.scale / 10.0);
if (noPoints > 36) {
noPoints = 36;
}
}
glColor3d(1, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.3, noPoints);
if (s.scale >= 5) {
glTranslated(0, 0, .1);
glColor3d(0, 0, 0);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
// Draw speed
SUMOReal speed = i->lane->getSpeed();
// Show as Km/h
speed *= 3.6f;
if (((int) speed + 1) % 10 == 0) {
speed = (SUMOReal)(((int) speed + 1) / 10 * 10);
}
// draw the speed string
std::string speedToDraw = toString<SUMOReal>(speed);
glColor3d(1, 1, 0);
glTranslated(0, 0, .1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
pfSetPosition(0, 0);
pfSetScale(1.2f);
SUMOReal w = pfdkGetStringWidth(speedToDraw.c_str());
glRotated(180, 0, 1, 0);
glTranslated(-w / 2., 0.3, 0);
pfDrawString(speedToDraw.c_str());
}
glPopMatrix();
}
// Pop symbol matrix
glPopMatrix();
// Draw connections
drawConnections();
// Draw name
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
// Pop name
glPopName();
}
void
GNEDetectorEntry::drawGL(const GUIVisualizationSettings& s) const {
// Start drawing adding gl identificator
glPushName(getGlID());
// Push detector matrix
glPushMatrix();
glTranslated(0, 0, getType());
// Set initial values
if (isAdditionalSelected()) {
glColor3d(myBaseColorSelected.red(), myBaseColorSelected.green(), myBaseColorSelected.blue());
} else {
glColor3d(myBaseColor.red(), myBaseColor.green(), myBaseColor.blue());
}
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Push poligon matrix
glPushMatrix();
glScaled(exaggeration, exaggeration, 1);
glTranslated(myShape[0].x(), myShape[0].y(), 0);
glRotated(myShapeRotations[0], 0, 0, 1);
// Draw poligon
glBegin(GL_LINES);
glVertex2d(1.7, 0);
glVertex2d(-1.7, 0);
glEnd();
glBegin(GL_QUADS);
glVertex2d(-1.7, .5);
glVertex2d(-1.7, -.5);
glVertex2d(1.7, -.5);
glVertex2d(1.7, .5);
glEnd();
// first Arrow
glTranslated(1.5, 0, 0);
GLHelper::drawBoxLine(Position(0, 4), 0, 2, .05);
GLHelper::drawTriangleAtEnd(Position(0, 4), Position(0, 1), (SUMOReal) 1, (SUMOReal) .25);
// second Arrow
glTranslated(-3, 0, 0);
GLHelper::drawBoxLine(Position(0, 4), 0, 2, .05);
GLHelper::drawTriangleAtEnd(Position(0, 4), Position(0, 1), (SUMOReal) 1, (SUMOReal) .25);
// Pop poligon matrix
glPopMatrix();
// Pop detector matrix
glPopMatrix();
// Check if the distance is enought to draw details
if (s.scale * exaggeration >= 10) {
// Draw icon
drawDetectorIcon(GUITextureSubSys::getTexture(GNETEXTURE_ENTRY), 1.5, 1);
// Show Lock icon depending of the Edit mode
drawLockIcon(0.4);
}
// Draw name
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
// pop gl identificator
glPopName();
}
void
GUIParkingArea::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
RGBColor grey(177, 184, 186, 171);
RGBColor blue(83, 89, 172, 255);
RGBColor red(255, 0, 0, 255);
RGBColor green(0, 255, 0, 255);
// draw the area
glTranslated(0, 0, getType());
GLHelper::setColor(blue);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, myWidth / 2.);
// draw details unless zoomed out to far
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 10) {
// draw the lots
glTranslated(0, 0, .1);
std::map<unsigned int, LotSpaceDefinition >::const_iterator i;
for (i = mySpaceOccupancies.begin(); i != mySpaceOccupancies.end(); i++) {
glPushMatrix();
glTranslated((*i).second.myPosition.x(), (*i).second.myPosition.y(), (*i).second.myPosition.z());
glRotated((*i).second.myRotation, 0, 0, 1);
Position pos = (*i).second.myPosition;
PositionVector geom;
SUMOReal w = (*i).second.myWidth / 2.;
SUMOReal h = (*i).second.myLength;
geom.push_back(Position(- w, + 0, 0.));
geom.push_back(Position(+ w, + 0, 0.));
geom.push_back(Position(+ w, + h, 0.));
geom.push_back(Position(- w, + h, 0.));
geom.push_back(Position(- w, + 0, 0.));
/*
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
*/
GLHelper::setColor((*i).second.vehicle == 0 ? green : red);
GLHelper::drawBoxLines(geom, 0.1);
glPopMatrix();
}
GLHelper::setColor(blue);
// draw the lines
for (size_t i = 0; i != myLines.size(); ++i) {
glPushMatrix();
glTranslated(mySignPos.x(), mySignPos.y(), 0);
glRotated(180, 1, 0, 0);
glRotated(mySignRot, 0, 0, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
pfSetPosition(0, 0);
pfSetScale(1.f);
glScaled(exaggeration, exaggeration, 1);
glTranslated(1.2, -(double)i, 0);
pfDrawString(myLines[i].c_str());
glPopMatrix();
}
// draw the sign
glTranslated(mySignPos.x(), mySignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(grey);
GLHelper::drawFilledCircle((SUMOReal) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("P", Position(), .1, 1.6 * exaggeration, blue, mySignRot);
}
}
glPopMatrix();
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
for (std::vector<MSTransportable*>::const_iterator i = myWaitingTransportables.begin(); i != myWaitingTransportables.end(); ++i) {
glTranslated(0, 1, 0); // make multiple containers viewable
static_cast<GUIContainer*>(*i)->drawGL(s);
}
}
void
GNEStop::drawGL(const GUIVisualizationSettings& s) const {
// only drawn in super mode demand
if (myViewNet->getViewOptions().showDemandElements()) {
// Obtain exaggeration of the draw
const double exaggeration = s.addSize.getExaggeration(s, this);
// Start drawing adding an gl identificator
glPushName(getGlID());
// Add a draw matrix
glPushMatrix();
// Start with the drawing of the area traslating matrix to origin
glTranslated(0, 0, getType());
// Set color of the base
if (drawUsingSelectColor()) {
GLHelper::setColor(s.selectedAdditionalColor);
} else {
GLHelper::setColor(s.SUMO_color_stops);
}
// draw lines depending if it's placed over a lane or over a stoppingPlace
if (getLaneParents().size() > 0) {
// Draw the area using shape, shapeRotations, shapeLengths and value of exaggeration
GLHelper::drawBoxLines(myGeometry.shape, myGeometry.shapeRotations, myGeometry.shapeLengths, exaggeration * 0.1, 0,
getLaneParents().front()->getParentEdge().getNBEdge()->getLaneWidth(getLaneParents().front()->getIndex()) * 0.5);
GLHelper::drawBoxLines(myGeometry.shape, myGeometry.shapeRotations, myGeometry.shapeLengths, exaggeration * 0.1, 0,
getLaneParents().front()->getParentEdge().getNBEdge()->getLaneWidth(getLaneParents().front()->getIndex()) * -0.5);
} else {
// Draw the area using shape, shapeRotations, shapeLengths and value of exaggeration
GLHelper::drawBoxLines(myGeometry.shape, myGeometry.shapeRotations, myGeometry.shapeLengths, exaggeration * 0.1, 0, exaggeration * -1);
GLHelper::drawBoxLines(myGeometry.shape, myGeometry.shapeRotations, myGeometry.shapeLengths, exaggeration * 0.1, 0, exaggeration);
}
// pop draw matrix
glPopMatrix();
// Add a draw matrix
glPushMatrix();
// move to geometry front
glTranslated(myGeometry.shape.back().x(), myGeometry.shape.back().y(), getType());
glRotated(myGeometry.shapeRotations.back(), 0, 0, 1);
// draw front of Stop depending if it's placed over a lane or over a stoppingPlace
if (getLaneParents().size() > 0) {
// draw front of Stop
GLHelper::drawBoxLine(Position(0, 0), 0, exaggeration * 0.5,
getLaneParents().front()->getParentEdge().getNBEdge()->getLaneWidth(getLaneParents().front()->getIndex()) * 0.5);
} else {
// draw front of Stop
GLHelper::drawBoxLine(Position(0, 0), 0, exaggeration * 0.5, exaggeration);
}
// move to "S" position
glTranslated(0, 1, 0);
// draw "S" symbol
GLHelper::drawText("S", Position(), .1, 2.8, s.SUMO_color_stops);
// move to subtitle positin
glTranslated(0, 1.4, 0);
// draw subtitle depending of tag
if (myTagProperty.getTag() == SUMO_TAG_STOP_BUSSTOP) {
GLHelper::drawText("busStop", Position(), .1, .5, s.SUMO_color_stops, 180);
} else if (myTagProperty.getTag() == SUMO_TAG_STOP_CONTAINERSTOP) {
GLHelper::drawText("container", Position(), .1, .5, s.SUMO_color_stops, 180);
glTranslated(0, 0.5, 0);
GLHelper::drawText("Stop", Position(), .1, .5, s.SUMO_color_stops, 180);
} else if (myTagProperty.getTag() == SUMO_TAG_STOP_CHARGINGSTATION) {
GLHelper::drawText("charging", Position(), .1, .5, s.SUMO_color_stops, 180);
glTranslated(0, 0.5, 0);
GLHelper::drawText("Station", Position(), .1, .5, s.SUMO_color_stops, 180);
} else if (myTagProperty.getTag() == SUMO_TAG_STOP_PARKINGAREA) {
GLHelper::drawText("parking", Position(), .1, .5, s.SUMO_color_stops, 180);
glTranslated(0, 0.5, 0);
GLHelper::drawText("Area", Position(), .1, .5, s.SUMO_color_stops, 180);
} else if (myTagProperty.getTag() == SUMO_TAG_STOP_LANE) {
GLHelper::drawText("lane", Position(), .1, 1, s.SUMO_color_stops, 180);
}
// pop draw matrix
glPopMatrix();
// Draw name if isn't being drawn for selecting
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
// check if dotted contour has to be drawn
if (!s.drawForSelecting && (myViewNet->getDottedAC() == this)) {
// draw dooted contour depending if it's placed over a lane or over a stoppingPlace
if (getLaneParents().size() > 0) {
GLHelper::drawShapeDottedContour(getType(), myGeometry.shape, getLaneParents().front()->getParentEdge().getNBEdge()->getLaneWidth(getLaneParents().front()->getIndex()) * 0.5);
} else {
GLHelper::drawShapeDottedContour(getType(), myGeometry.shape, exaggeration);
}
}
// Pop name
glPopName();
}
}
void
GUILane::drawGL(const GUIVisualizationSettings& s) const {
glPushMatrix();
const bool isInternal = myEdge->getPurpose() == MSEdge::EDGEFUNCTION_INTERNAL;
bool mustDrawMarkings = false;
const bool drawDetails = s.scale * s.laneWidthExaggeration > 5;
if (isInternal) {
// draw internal lanes on top of junctions
glTranslated(0, 0, GLO_JUNCTION + 0.1);
} else {
glTranslated(0, 0, getType());
}
// set lane color
if (!MSGlobals::gUseMesoSim) {
setColor(s);
glPushName(getGlID()); // do not register for clicks in MESOSIM
}
// draw lane
// check whether it is not too small
if (s.scale * s.laneWidthExaggeration < 1.) {
GLHelper::drawLine(myShape);
if (!MSGlobals::gUseMesoSim) {
glPopName();
}
glPopMatrix();
} else {
if (isRailway(myPermissions)) {
// draw as railway
const SUMOReal halfRailWidth = 0.725 * s.laneWidthExaggeration;
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, halfRailWidth);
glColor3d(1, 1, 1);
glTranslated(0, 0, .1);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, halfRailWidth - 0.2);
drawCrossties(s, s.laneWidthExaggeration);
} else {
const SUMOReal laneWidth = isInternal ? myQuarterLaneWidth : myHalfLaneWidth;
mustDrawMarkings = !isInternal;
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, laneWidth * s.laneWidthExaggeration);
}
if (!MSGlobals::gUseMesoSim) {
glPopName();
}
glPopMatrix();
// draw ROWs (not for inner lanes)
if (!isInternal && drawDetails) {
glPushMatrix();
glTranslated(0, 0, GLO_JUNCTION); // must draw on top of junction shape
GUINet* net = (GUINet*) MSNet::getInstance();
glTranslated(0, 0, .2);
drawLinkRules(*net);
if (s.showLinkDecals && !isRailway(myPermissions)) {
drawArrows();
}
if (s.showLane2Lane) {
// this should be independent to the geometry:
// draw from end of first to the begin of second
drawLane2LaneConnections();
}
glTranslated(0, 0, .1);
if (s.drawLinkJunctionIndex) {
drawLinkNo();
}
if (s.drawLinkTLIndex) {
drawTLSLinkNo(*net);
}
glPopMatrix();
}
}
if (mustDrawMarkings && drawDetails) { // needs matrix reset
drawMarkings(s, s.laneWidthExaggeration);
}
// draw vehicles
if (s.scale > s.minVehicleSize) {
// retrieve vehicles from lane; disallow simulation
const MSLane::VehCont& vehicles = getVehiclesSecure();
for (MSLane::VehCont::const_iterator v = vehicles.begin(); v != vehicles.end(); ++v) {
if ((*v)->getLane() == this) {
static_cast<const GUIVehicle* const>(*v)->drawGL(s);
} // else: this is the shadow during a continuous lane change
}
// draw parking vehicles
const std::set<const MSVehicle*> parking = MSVehicleTransfer::getInstance()->getParkingVehicles(this);
for (std::set<const MSVehicle*>::const_iterator v = parking.begin(); v != parking.end(); ++v) {
static_cast<const GUIVehicle* const>(*v)->drawGL(s);
}
// allow lane simulation
releaseVehicles();
}
}
double
GUIVehicle::getColorValue(int activeScheme) const {
switch (activeScheme) {
case 8:
return getSpeed();
case 9:
// color by action step
if (isActionStep(SIMSTEP)) {
// Upcoming simstep is actionstep (t was already increased before drawing)
return 1.;
} else if (isActive()) {
// Completed simstep was actionstep
return 2.;
} else {
// not active
return 0.;
}
case 10:
return getWaitingSeconds();
case 11:
return getAccumulatedWaitingSeconds();
case 12:
return getLastLaneChangeOffset();
case 13:
return getLane()->getVehicleMaxSpeed(this);
case 14:
return getCO2Emissions();
case 15:
return getCOEmissions();
case 16:
return getPMxEmissions();
case 17:
return getNOxEmissions();
case 18:
return getHCEmissions();
case 19:
return getFuelConsumption();
case 20:
return getHarmonoise_NoiseEmissions();
case 21:
if (getNumberReroutes() == 0) {
return -1;
}
return getNumberReroutes();
case 22:
return gSelected.isSelected(GLO_VEHICLE, getGlID());
case 23:
return getLaneChangeModel().isOpposite() ? -100 : getBestLaneOffset();
case 24:
return getAcceleration();
case 25:
return getTimeGapOnLane();
case 26:
return STEPS2TIME(getDepartDelay());
case 27:
return getElectricityConsumption();
case 28:
return getTimeLossSeconds();
case 29:
return getLaneChangeModel().getSpeedLat();
}
return 0;
}
void
GUIPolygon::drawGL(const GUIVisualizationSettings& s) const {
Boundary boundary = myShape.getBoxBoundary();
if (s.scale * MAX2(boundary.getWidth(), boundary.getHeight()) < s.minPolySize) {
return;
}
if (getFill()) {
if (myShape.size() < 3) {
return;
}
} else {
if (myShape.size() < 2) {
return;
}
}
AbstractMutex::ScopedLocker locker(myLock);
//if (myDisplayList == 0 || (!getFill() && myLineWidth != s.polyExaggeration)) {
// storeTesselation(s.polyExaggeration);
//}
glPushName(getGlID());
glPushMatrix();
glTranslated(0, 0, getLayer());
// XXX shape should be rotated around its center when initializing the polygon. do we even need this?
//glRotated(getAngle(), 0, 0, 1);
GLHelper::setColor(getColor());
int textureID = -1;
if (getFill()) {
const std::string& file = getImgFile();
if (file != "") {
textureID = GUITexturesHelper::getTextureID(file);
}
}
// init generation of texture coordinates
if (textureID >= 0) {
glEnable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST); // without DEPTH_TEST vehicles may be drawn below roads
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// http://www.gamedev.net/topic/133564-glutesselation-and-texture-mapping/
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, xPlane);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_T, GL_OBJECT_PLANE, yPlane);
}
// recall tesselation
//glCallList(myDisplayList);
performTesselation(s.polyExaggeration);
// de-init generation of texture coordinates
if (textureID >= 0) {
glEnable(GL_DEPTH_TEST);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
glPopMatrix();
drawName(myShape.getPolygonCenter(), s.scale, s.polyName);
glPopName();
}
bool
GUIVehicle::isSelected() const {
return gSelected.isSelected(GLO_VEHICLE, getGlID());
}
void
GUILaneWrapper::drawGL(const GUIVisualizationSettings &s) const throw() {
// set lane color
#ifdef HAVE_MESOSIM
if (!MSGlobals::gUseMesoSim)
#endif
s.laneColorer.setGlColor(*this);
// (optional) set id
if (s.needsGlID) {
glPushName(getGlID());
}
// draw lane
// check whether it is not too small
if (s.scale<1.) {
GLHelper::drawLine(myShape);
// (optional) clear id
if (s.needsGlID) {
glPopName();
}
} else {
if (getLane().getEdge().getPurpose()!=MSEdge::EDGEFUNCTION_INTERNAL) {
glTranslated(0, 0, .005);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, SUMO_const_halfLaneWidth);
glTranslated(0, 0, -.005);
} else {
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, SUMO_const_quarterLaneWidth);
}
// (optional) clear id
if (s.needsGlID) {
glPopName();
}
// draw ROWs (not for inner lanes)
if (getLane().getEdge().getPurpose()!=MSEdge::EDGEFUNCTION_INTERNAL) {// !!! getPurpose()
glTranslated(0, 0, -.02);
GUINet *net = (GUINet*) MSNet::getInstance();
ROWdrawAction_drawLinkRules(*net, *this, s.needsGlID);
if (s.showLinkDecals) {
ROWdrawAction_drawArrows(*this, s.needsGlID);
}
if (s.showLane2Lane) {
// this should be independent to the geometry:
// draw from end of first to the begin of second
ROWdrawAction_drawLane2LaneConnections(*this);
}
glTranslated(0, 0, .02);
if (s.drawLinkJunctionIndex) {
glTranslated(0, 0, -.03);
ROWdrawAction_drawLinkNo(*this);
glTranslated(0, 0, .03);
}
if (s.drawLinkTLIndex) {
glTranslated(0, 0, -.03);
ROWdrawAction_drawTLSLinkNo(*net, *this);
glTranslated(0, 0, .03);
}
}
}
// draw vehicles
if (s.scale>s.minVehicleSize) {
// retrieve vehicles from lane; disallow simulation
const MSLane::VehCont &vehicles = myLane.getVehiclesSecure();
for (MSLane::VehCont::const_iterator v=vehicles.begin(); v!=vehicles.end(); ++v) {
static_cast<const GUIVehicle*const>(*v)->drawGL(s);
}
// allow lane simulation
myLane.releaseVehicles();
}
glPopMatrix();
}
void
GUIPolygon::drawGL(const GUIVisualizationSettings& s) const {
if (s.polySize.getExaggeration(s) == 0) {
return;
}
Boundary boundary = myShape.getBoxBoundary();
if (s.scale * MAX2(boundary.getWidth(), boundary.getHeight()) < s.polySize.minSize) {
return;
}
if (getFill()) {
if (myShape.size() < 3) {
return;
}
} else {
if (myShape.size() < 2) {
return;
}
}
AbstractMutex::ScopedLocker locker(myLock);
//if (myDisplayList == 0 || (!getFill() && myLineWidth != s.polySize.getExaggeration(s))) {
// storeTesselation(s.polySize.getExaggeration(s));
//}
glPushName(getGlID());
glPushMatrix();
glTranslated(0, 0, getLayer());
glRotated(-getNaviDegree(), 0, 0, 1);
GLHelper::setColor(getColor());
int textureID = -1;
if (getFill()) {
const std::string& file = getImgFile();
if (file != "") {
textureID = GUITexturesHelper::getTextureID(file, true);
}
}
// init generation of texture coordinates
if (textureID >= 0) {
glEnable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST); // without DEPTH_TEST vehicles may be drawn below roads
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// http://www.gamedev.net/topic/133564-glutesselation-and-texture-mapping/
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, xPlane);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_T, GL_OBJECT_PLANE, yPlane);
}
// recall tesselation
//glCallList(myDisplayList);
performTesselation(myLineWidth * s.polySize.getExaggeration(s));
// de-init generation of texture coordinates
if (textureID >= 0) {
glEnable(GL_DEPTH_TEST);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
#ifdef GUIPolygon_DEBUG_DRAW_VERTICES
GLHelper::debugVertices(myShape, 80 / s.scale);
#endif
glPopMatrix();
const Position namePos = myShape.getPolygonCenter();
drawName(namePos, s.scale, s.polyName);
if (s.polyType.show) {
GLHelper::drawText(myType, namePos + Position(0, -0.6 * s.polyType.size / s.scale),
GLO_MAX, s.polyType.size / s.scale, s.polyType.color);
}
glPopName();
}
void
GNEDetectorE1::drawGL(const GUIVisualizationSettings& s) const {
// get values
glPushName(getGlID());
double width = (double) 2.0 * s.scale;
glLineWidth(1.0);
const double exaggeration = s.addSize.getExaggeration(s, this);
// set color
if (drawUsingSelectColor()) {
GLHelper::setColor(s.selectedAdditionalColor);
} else {
GLHelper::setColor(s.SUMO_color_E1);
}
// draw shape
glPushMatrix();
glTranslated(0, 0, getType());
glTranslated(myGeometry.shape[0].x(), myGeometry.shape[0].y(), 0);
glRotated(myGeometry.shapeRotations[0], 0, 0, 1);
glScaled(exaggeration, exaggeration, 1);
glBegin(GL_QUADS);
glVertex2d(-1.0, 2);
glVertex2d(-1.0, -2);
glVertex2d(1.0, -2);
glVertex2d(1.0, 2);
glEnd();
glTranslated(0, 0, .01);
glBegin(GL_LINES);
glVertex2d(0, 2 - .1);
glVertex2d(0, -2 + .1);
glEnd();
// outline if isn't being drawn for selecting
if ((width * exaggeration > 1) && !s.drawForSelecting) {
// set color
if (drawUsingSelectColor()) {
GLHelper::setColor(s.selectionColor);
} else {
GLHelper::setColor(RGBColor::WHITE);
}
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_QUADS);
glVertex2f(-1.0, 2);
glVertex2f(-1.0, -2);
glVertex2f(1.0, -2);
glVertex2f(1.0, 2);
glEnd();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
// position indicator if isn't being drawn for selecting
if ((width * exaggeration > 1) && !s.drawForSelecting) {
// set color
if (drawUsingSelectColor()) {
GLHelper::setColor(s.selectionColor);
} else {
GLHelper::setColor(RGBColor::WHITE);
}
glRotated(90, 0, 0, -1);
glBegin(GL_LINES);
glVertex2d(0, 1.7);
glVertex2d(0, -1.7);
glEnd();
}
// Pop shape matrix
glPopMatrix();
// Check if the distance is enought to draw details and isn't being drawn for selecting
if ((s.scale * exaggeration >= 10) && !s.drawForSelecting) {
// Push matrix
glPushMatrix();
// Traslate to center of detector
glTranslated(myGeometry.shape.getLineCenter().x(), myGeometry.shape.getLineCenter().y(), getType() + 0.1);
// Rotate depending of myBlockIcon.rotation
glRotated(myBlockIcon.rotation, 0, 0, -1);
//move to logo position
glTranslated(-1, 0, 0);
// draw E1 logo
if (drawUsingSelectColor()) {
GLHelper::drawText("E1", Position(), .1, 1.5, s.selectionColor);
} else {
GLHelper::drawText("E1", Position(), .1, 1.5, RGBColor::BLACK);
}
// pop matrix
glPopMatrix();
// Show Lock icon depending of the Edit mode
myBlockIcon.draw();
}
// Finish draw if isn't being drawn for selecting
if (!s.drawForSelecting) {
drawName(getPositionInView(), s.scale, s.addName);
}
// check if dotted contour has to be drawn
if (!s.drawForSelecting && (myViewNet->getDottedAC() == this)) {
GLHelper::drawShapeDottedContour(getType(), myGeometry.shape[0], 2, 4, myGeometry.shapeRotations[0]);
}
// pop name
glPopName();
}
void
GUIJunctionWrapper::updateColor(const GUIVisualizationSettings& s) {
const SUMOReal colorValue = static_cast<SUMOReal>(s.junctionColorer.getActive() == 1 && gSelected.isSelected(getType(), getGlID()));
const RGBColor& col = s.junctionColorer.getScheme().getColor(colorValue);
osg::Vec4ubArray* colors = dynamic_cast<osg::Vec4ubArray*>(myGeom->getColorArray());
(*colors)[0].set(col.red(), col.green(), col.blue(), col.alpha());
myGeom->setColorArray(colors);
}
void
GUIEdge::drawGL(const GUIVisualizationSettings& s) const {
if (s.hideConnectors && myFunction == MSEdge::EDGEFUNCTION_CONNECTOR) {
return;
}
glPushName(getGlID());
// draw the lanes
for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
setColor(s);
}
#endif
GUILane* l = dynamic_cast<GUILane*>(*i);
if (l != 0) {
l->drawGL(s);
}
}
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
if (s.scale * s.vehicleSize.getExaggeration(s) > s.vehicleSize.minSize) {
drawMesoVehicles(s);
}
}
#endif
glPopName();
// (optionally) draw the name and/or the street name
const bool drawEdgeName = s.edgeName.show && myFunction == EDGEFUNCTION_NORMAL;
const bool drawInternalEdgeName = s.internalEdgeName.show && myFunction == EDGEFUNCTION_INTERNAL;
const bool drawCwaEdgeName = s.cwaEdgeName.show && (myFunction == EDGEFUNCTION_CROSSING || myFunction == EDGEFUNCTION_WALKINGAREA);
const bool drawStreetName = s.streetName.show && myStreetName != "";
if (drawEdgeName || drawInternalEdgeName || drawCwaEdgeName || drawStreetName) {
GUILane* lane1 = dynamic_cast<GUILane*>((*myLanes)[0]);
GUILane* lane2 = dynamic_cast<GUILane*>((*myLanes).back());
if (lane1 != 0 && lane2 != 0) {
Position p = lane1->getShape().positionAtOffset(lane1->getShape().length() / (SUMOReal) 2.);
p.add(lane2->getShape().positionAtOffset(lane2->getShape().length() / (SUMOReal) 2.));
p.mul(.5);
SUMOReal angle = lane1->getShape().rotationDegreeAtOffset(lane1->getShape().length() / (SUMOReal) 2.);
angle += 90;
if (angle > 90 && angle < 270) {
angle -= 180;
}
if (drawEdgeName) {
drawName(p, s.scale, s.edgeName, angle);
} else if (drawInternalEdgeName) {
drawName(p, s.scale, s.internalEdgeName, angle);
} else if (drawCwaEdgeName) {
drawName(p, s.scale, s.cwaEdgeName, angle);
}
if (drawStreetName) {
GLHelper::drawText(getStreetName(), p, GLO_MAX,
s.streetName.size / s.scale, s.streetName.color, angle);
}
}
}
if (s.scale * s.personSize.getExaggeration(s) > s.personSize.minSize) {
myLock.lock();
for (std::set<MSPerson*>::const_iterator i = myPersons.begin(); i != myPersons.end(); ++i) {
GUIPerson* person = dynamic_cast<GUIPerson*>(*i);
assert(person != 0);
person->drawGL(s);
}
myLock.unlock();
}
if (s.scale * s.containerSize.getExaggeration(s) > s.containerSize.minSize) {
myLock.lock();
for (std::set<MSContainer*>::const_iterator i = myContainers.begin(); i != myContainers.end(); ++i) {
GUIContainer* container = dynamic_cast<GUIContainer*>(*i);
assert(container != 0);
container->drawGL(s);
}
myLock.unlock();
}
}
void
GNEContainerStop::drawGL(const GUIVisualizationSettings& s) const {
// Start drawing adding an gl identificator
glPushName(getGlID());
// Add a draw matrix
glPushMatrix();
// Start with the drawing of the area traslating matrix to origin
glTranslated(0, 0, getType());
// Set color of the base
if (isAdditionalSelected()) {
GLHelper::setColor(myBaseColorSelected);
} else {
GLHelper::setColor(myBaseColor);
}
// Obtain exaggeration of the draw
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
// Draw the area using shape, shapeRotations, shapeLenghts and value of exaggeration
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, exaggeration);
// Check if the distance is enought to draw details
if (s.scale * exaggeration >= 10) {
// Add a draw matrix
glPushMatrix();
// Obtain rotation of the sing depeding of the option "lefthand"
SUMOReal rotSign = OptionsCont::getOptions().getBool("lefthand");
// Set color of the lines
if (isAdditionalSelected()) {
GLHelper::setColor(myTextColorSelected);
} else {
GLHelper::setColor(myTextColor);
}
// Iterate over every line
for (int i = 0; i < (int)myLines.size(); ++i) {
// Add a new push matrix
glPushMatrix();
// Traslate End positionof signal
glTranslated(mySignPos.x(), mySignPos.y(), 0);
// Rotate 180 (Eje X -> Mirror)
glRotated(180, 1, 0, 0);
// Rotate again depending of the option rotSign
glRotated(rotSign * myBlockIconRotation, 0, 0, 1);
// Set poligon mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// set polyfront position ot 0
pfSetPosition(0, 0);
// Set polyfront scale to 1
pfSetScale(1.f);
// traslate matrix for every line
glTranslated(1.2, -(double)i, 0);
// draw line
pfDrawString(myLines[i].c_str());
// pop matrix
glPopMatrix();
}
// Start drawing sign traslating matrix to signal position
glTranslated(mySignPos.x(), mySignPos.y(), 0);
// Define nº points (for efficiency)
int noPoints = 9;
// If the scale * exaggeration is more than 25, recalculate nº points
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
// scale matrix depending of the exaggeration
glScaled(exaggeration, exaggeration, 1);
// Draw green circle
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
// Traslate to front
glTranslated(0, 0, .1);
// Set color of the lines
if (isAdditionalSelected()) {
GLHelper::setColor(mySignColorSelected);
} else {
GLHelper::setColor(mySignColor);
}
// draw another circle in the same position, but a little bit more small
GLHelper::drawFilledCircle((SUMOReal) 0.9, noPoints);
// If the scale * exageration is equal or more than 4.5, draw H
if (s.scale * exaggeration >= 4.5) {
if (isAdditionalSelected()) {
GLHelper::drawText("C", Position(), .1, 1.6, myBaseColorSelected, myBlockIconRotation);
} else {
GLHelper::drawText("C", Position(), .1, 1.6, myBaseColor, myBlockIconRotation);
}
}
// pop draw matrix
glPopMatrix();
// Show Lock icon depending of the Edit mode
drawLockIcon();
}
// pop draw matrix
glPopMatrix();
// Draw name
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
// Pop name
glPopName();
}
