bool
NBRampsComputer::fulfillsRampConstraints(
NBEdge* potHighway, NBEdge* potRamp, NBEdge* other, SUMOReal minHighwaySpeed, SUMOReal maxRampSpeed) {
// do not build ramps on rail edges
if (isRailway(potHighway->getPermissions()) || isRailway(potRamp->getPermissions())) {
return false;
}
// do not build ramps on connectors
if (potHighway->isMacroscopicConnector() || potRamp->isMacroscopicConnector() || other->isMacroscopicConnector()) {
return false;
}
// check whether a lane is missing
if (potHighway->getNumLanes() + potRamp->getNumLanes() <= other->getNumLanes()) {
return false;
}
// check conditions
// is it really a highway?
SUMOReal maxSpeed = MAX3(potHighway->getSpeed(), other->getSpeed(), potRamp->getSpeed());
if (maxSpeed < minHighwaySpeed) {
return false;
}
/*
if (potHighway->getSpeed() < minHighwaySpeed || other->getSpeed() < minHighwaySpeed) {
return false;
}
*/
// is it really a ramp?
if (maxRampSpeed > 0 && maxRampSpeed < potRamp->getSpeed()) {
return false;
}
return true;
}
std::string
NWWriter_OpenDrive::getLaneType(SVCPermissions permissions) {
switch (permissions) {
case SVC_PEDESTRIAN:
return "sidewalk";
//case (SVC_BICYCLE | SVC_PEDESTRIAN):
// WRITE_WARNING("Ambiguous lane type (biking+driving) for road '" + roadID + "'");
// return "sidewalk";
case SVC_BICYCLE:
return "biking";
case 0:
// ambiguous
return "none";
case SVC_RAIL:
case SVC_RAIL_URBAN:
case SVC_RAIL_ELECTRIC:
return "rail";
case SVC_TRAM:
return "tram";
default: {
// complex permissions
if (permissions == SVCAll) {
return "driving";
} else if (isRailway(permissions)) {
return "rail";
} else if ((permissions & SVC_PASSENGER) != 0) {
return "driving";
} else {
return "restricted";
}
}
}
}
bool
NBRampsComputer::fulfillsRampConstraints(
NBEdge* potHighway, NBEdge* potRamp, NBEdge* other, SUMOReal minHighwaySpeed, SUMOReal maxRampSpeed) {
// do not build ramps on rail edges
if (isRailway(potHighway->getPermissions()) || isRailway(potRamp->getPermissions())) {
return false;
}
// do not build ramps on connectors
if (potHighway->isMacroscopicConnector() || potRamp->isMacroscopicConnector() || other->isMacroscopicConnector()) {
return false;
}
// check whether a lane is missing
if (potHighway->getNumLanes() + potRamp->getNumLanes() <= other->getNumLanes()) {
return false;
}
// is it really a highway?
SUMOReal maxSpeed = MAX3(potHighway->getSpeed(), other->getSpeed(), potRamp->getSpeed());
if (maxSpeed < minHighwaySpeed) {
return false;
}
// is any of the connections a turnaround?
if (other->getToNode() == potHighway->getFromNode()) {
// off ramp
if (other->isTurningDirectionAt(potHighway) ||
other->isTurningDirectionAt(potRamp)) {
return false;
}
} else {
// on ramp
if (other->isTurningDirectionAt(potHighway) ||
other->isTurningDirectionAt(potRamp)) {
return false;
}
}
/*
if (potHighway->getSpeed() < minHighwaySpeed || other->getSpeed() < minHighwaySpeed) {
return false;
}
*/
// is it really a ramp?
if (maxRampSpeed > 0 && maxRampSpeed < potRamp->getSpeed()) {
return false;
}
return true;
}
SUMOReal
GNELane::getColorValue(size_t activeScheme) const {
const SVCPermissions myPermissions = myParentEdge.getNBEdge()->getPermissions(myIndex);
switch (activeScheme) {
case 0:
switch (myPermissions) {
case SVC_PEDESTRIAN:
return 1;
case SVC_BICYCLE:
return 2;
case 0:
return 3;
case SVC_SHIP:
return 4;
default:
break;
}
if ((myPermissions & SVC_PASSENGER) != 0 || isRailway(myPermissions)) {
return 0;
} else {
return 5;
}
case 1:
return gSelected.isSelected(getType(), getGlID()) ||
gSelected.isSelected(GLO_EDGE, dynamic_cast<GNEEdge*>(&myParentEdge)->getGlID());
case 2:
return (SUMOReal)myPermissions;
case 3:
return myParentEdge.getNBEdge()->getLaneSpeed(myIndex);
case 4:
return myParentEdge.getNBEdge()->getNumLanes();
case 5: {
return myParentEdge.getNBEdge()->getLoadedLength() / myParentEdge.getNBEdge()->getLength();
}
// case 6: by angle (functional)
case 7: {
return myParentEdge.getNBEdge()->getPriority();
}
case 8: {
// color by z of first shape point
return getShape()[0].z();
}
// case 9: by segment height
case 10: {
// color by incline
return (getShape()[-1].z() - getShape()[0].z()) / myParentEdge.getNBEdge()->getLength();
}
}
return 0;
}
void
MSDevice_Tripinfo::addRideData(double rideLength, SUMOTime rideDuration, SUMOVehicleClass vClass, const std::string& line, SUMOTime waitingTime) {
myRideCount++;
if (rideDuration > 0) {
myTotalRideWaitingTime += waitingTime;
myTotalRideRouteLength += rideLength;
myTotalRideDuration += rideDuration;
if (vClass == SVC_BICYCLE) {
myRideBikeCount++;
} else if (!line.empty()) {
if (isRailway(vClass)) {
myRideRailCount++;
} else {
// some kind of road vehicle
myRideBusCount++;
}
}
} else {
myRideAbortCount++;
}
}
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();
}
}
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
NBTrafficLightDefinition::collectAllLinks() {
myControlledLinks.clear();
int tlIndex = 0;
// build the list of links which are controled by the traffic light
for (EdgeVector::iterator i = myIncomingEdges.begin(); i != myIncomingEdges.end(); i++) {
NBEdge* incoming = *i;
unsigned int noLanes = incoming->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++) {
std::vector<NBEdge::Connection> connected = incoming->getConnectionsFromLane(j);
for (std::vector<NBEdge::Connection>::iterator k = connected.begin(); k != connected.end(); k++) {
const NBEdge::Connection& el = *k;
if (incoming->mayBeTLSControlled(el.fromLane, el.toEdge, el.toLane)) {
if (el.toEdge != 0 && el.toLane >= (int) el.toEdge->getNumLanes()) {
throw ProcessError("Connection '" + incoming->getID() + "_" + toString(j) + "->" + el.toEdge->getID() + "_" + toString(el.toLane) + "' yields in a not existing lane.");
}
if (incoming->getToNode()->getType() != NODETYPE_RAIL_CROSSING || !isRailway(incoming->getPermissions())) {
myControlledLinks.push_back(NBConnection(incoming, el.fromLane, el.toEdge, el.toLane, tlIndex++));
} else {
myControlledLinks.push_back(NBConnection(incoming, el.fromLane, el.toEdge, el.toLane, -1));
}
}
}
}
}
}
bool
GNELane::drawAsRailway(const GUIVisualizationSettings& s) const {
return isRailway(myParentEdge.getNBEdge()->getPermissions(myIndex)) && s.showRails;
}
