void NWWriter_XML::writeNodes(const OptionsCont& oc, NBNodeCont& nc) { const GeoConvHelper& gch = GeoConvHelper::getFinal(); bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo"); if (useGeo && !gch.usingGeoProjection()) { WRITE_WARNING("Ignoring option \"proj.plain-geo\" because no geo-conversion has been defined"); useGeo = false; } const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection(); OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".nod.xml"); device.writeXMLHeader("nodes", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/nodes_file.xsd\""); // write network offsets and projection to allow reconstruction of original coordinates if (!useGeo) { NWWriter_SUMO::writeLocation(device); } // write nodes for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) { NBNode* n = (*i).second; device.openTag(SUMO_TAG_NODE); device.writeAttr(SUMO_ATTR_ID, n->getID()); // write position Position pos = n->getPosition(); if (useGeo) { gch.cartesian2geo(pos); } if (geoAccuracy) { device.setPrecision(GEO_OUTPUT_ACCURACY); } NWFrame::writePositionLong(pos, device); if (geoAccuracy) { device.setPrecision(); } device.writeAttr(SUMO_ATTR_TYPE, toString(n->getType())); if (n->isTLControlled()) { const std::set<NBTrafficLightDefinition*>& tlss = n->getControllingTLS(); // set may contain multiple programs for the same id. // make sure ids are unique and sorted std::set<std::string> tlsIDs; for (std::set<NBTrafficLightDefinition*>::const_iterator it_tl = tlss.begin(); it_tl != tlss.end(); it_tl++) { tlsIDs.insert((*it_tl)->getID()); } std::vector<std::string> sortedIDs(tlsIDs.begin(), tlsIDs.end()); sort(sortedIDs.begin(), sortedIDs.end()); device.writeAttr(SUMO_ATTR_TLID, sortedIDs); } device.closeTag(); } device.close(); }
bool GeoConvHelper::init(OptionsCont& oc) { std::string proj = "!"; // the default double scale = oc.getFloat("proj.scale"); double rot = oc.getFloat("proj.rotate"); Position offset = Position(oc.getFloat("offset.x"), oc.getFloat("offset.y")); bool inverse = oc.exists("proj.inverse") && oc.getBool("proj.inverse"); bool flatten = oc.exists("flatten") && oc.getBool("flatten"); if (oc.getBool("simple-projection")) { proj = "-"; } #ifdef PROJ_API_FILE if (oc.getBool("proj.inverse") && oc.getString("proj") == "!") { WRITE_ERROR("Inverse projection works only with explicit proj parameters."); return false; } unsigned numProjections = oc.getBool("simple-projection") + oc.getBool("proj.utm") + oc.getBool("proj.dhdn") + oc.getBool("proj.dhdnutm") + (oc.getString("proj").length() > 1); if (numProjections > 1) { WRITE_ERROR("The projection method needs to be uniquely defined."); return false; } if (oc.getBool("proj.utm")) { proj = "UTM"; } else if (oc.getBool("proj.dhdn")) { proj = "DHDN"; } else if (oc.getBool("proj.dhdnutm")) { proj = "DHDN_UTM"; } else if (!oc.isDefault("proj")) { proj = oc.getString("proj"); } #endif myProcessing = GeoConvHelper(proj, offset, Boundary(), Boundary(), scale, rot, inverse, flatten); myFinal = myProcessing; return true; }
void NBEdgeCont::applyOptions(OptionsCont& oc) { myAmLeftHanded = oc.getBool("lefthand"); // set edges dismiss/accept options myEdgesMinSpeed = oc.isSet("keep-edges.min-speed") ? oc.getFloat("keep-edges.min-speed") : -1; myRemoveEdgesAfterJoining = oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload"); if (oc.isSet("keep-edges.explicit")) { const std::vector<std::string> edges = oc.getStringVector("keep-edges.explicit"); myEdges2Keep.insert(edges.begin(), edges.end()); } if (oc.isSet("remove-edges.explicit")) { const std::vector<std::string> edges = oc.getStringVector("remove-edges.explicit"); myEdges2Remove.insert(edges.begin(), edges.end()); } if (oc.exists("keep-edges.by-vclass") && oc.isSet("keep-edges.by-vclass")) { const std::vector<std::string> classes = oc.getStringVector("keep-edges.by-vclass"); for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) { myVehicleClasses2Keep |= getVehicleClassID(*i); } } if (oc.exists("remove-edges.by-vclass") && oc.isSet("remove-edges.by-vclass")) { const std::vector<std::string> classes = oc.getStringVector("remove-edges.by-vclass"); for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) { myVehicleClasses2Remove |= getVehicleClassID(*i); } } if (oc.exists("keep-edges.by-type") && oc.isSet("keep-edges.by-type")) { const std::vector<std::string> types = oc.getStringVector("keep-edges.by-type"); myTypes2Keep.insert(types.begin(), types.end()); } if (oc.exists("remove-edges.by-type") && oc.isSet("remove-edges.by-type")) { const std::vector<std::string> types = oc.getStringVector("remove-edges.by-type"); myTypes2Remove.insert(types.begin(), types.end()); } if (oc.isSet("keep-edges.in-boundary") || oc.isSet("keep-edges.in-geo-boundary")) { std::vector<std::string> polyS = oc.getStringVector(oc.isSet("keep-edges.in-boundary") ? "keep-edges.in-boundary" : "keep-edges.in-geo-boundary"); // !!! throw something if length<4 || length%2!=0? std::vector<SUMOReal> poly; for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) { poly.push_back(TplConvert::_2SUMOReal((*i).c_str())); // !!! may throw something anyhow... } if (poly.size() < 4) { throw ProcessError("Invalid boundary: need at least 2 coordinates"); } else if (poly.size() % 2 != 0) { throw ProcessError("Invalid boundary: malformed coordinate"); } else if (poly.size() == 4) { // prunning boundary (box) myPrunningBoundary.push_back(Position(poly[0], poly[1])); myPrunningBoundary.push_back(Position(poly[2], poly[1])); myPrunningBoundary.push_back(Position(poly[2], poly[3])); myPrunningBoundary.push_back(Position(poly[0], poly[3])); } else { for (std::vector<SUMOReal>::iterator j = poly.begin(); j != poly.end();) { SUMOReal x = *j++; SUMOReal y = *j++; myPrunningBoundary.push_back(Position(x, y)); } } if (oc.isSet("keep-edges.in-geo-boundary")) { NBNetBuilder::transformCoordinates(myPrunningBoundary, false); } } }
void NBNodeCont::guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc) { // build list of definitely not tls-controlled junctions std::vector<NBNode*> ncontrolled; if (oc.isSet("tls.unset")) { std::vector<std::string> notTLControlledNodes = oc.getStringVector("tls.unset"); for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) { NBNode* n = NBNodeCont::retrieve(*i); if (n == 0) { throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known."); } std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS(); for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) { (*j)->removeNode(n); } n->removeTrafficLights(); ncontrolled.push_back(n); } } TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(OptionsCont::getOptions().getString("tls.default-type")); // loop#1 checking whether the node shall be tls controlled, // because it is assigned to a district if (oc.exists("tls.taz-nodes") && oc.getBool("tls.taz-nodes")) { for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; if (cur->isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) { setAsTLControlled(cur, tlc, type); } } } // maybe no tls shall be guessed if (!oc.getBool("tls.guess")) { return; } // guess joined tls first, if wished if (oc.getBool("tls.join")) { // get node clusters std::vector<std::set<NBNode*> > cands; generateNodeClusters(oc.getFloat("tls.join-dist"), cands); // check these candidates (clusters) whether they should be controlled by a tls for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) { std::set<NBNode*>& c = (*i); // regard only junctions which are not yet controlled and are not // forbidden to be controlled for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) { if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) { c.erase(j++); } else { ++j; } } // check whether the cluster should be controlled if (!shouldBeTLSControlled(c)) { i = cands.erase(i); } else { ++i; } } // cands now only contain sets of junctions that shall be joined into being tls-controlled unsigned int index = 0; for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) { std::vector<NBNode*> nodes; for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) { nodes.push_back(*j); } std::string id = "joinedG_" + toString(index++); NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type); if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build guessed, joined tls"); delete tlDef; return; } } } // guess tls for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; // do nothing if already is tl-controlled if (cur->isTLControlled()) { continue; } // do nothing if in the list of explicit non-controlled junctions if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) { continue; } std::set<NBNode*> c; c.insert(cur); if (!shouldBeTLSControlled(c) || cur->getIncomingEdges().size() < 3) { continue; } setAsTLControlled((*i).second, tlc, type); } }
void ROVehicle::saveAsXML(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const { if (typeos != nullptr && getType() != nullptr && !getType()->saved) { getType()->write(*typeos); getType()->saved = true; } if (getType() != nullptr && !getType()->saved) { getType()->write(os); getType()->saved = asAlternatives; } const bool writeTrip = options.exists("write-trips") && options.getBool("write-trips"); const bool writeGeoTrip = writeTrip && options.getBool("write-trips.geo"); // write the vehicle (new style, with included routes) getParameter().write(os, options, writeTrip ? SUMO_TAG_TRIP : SUMO_TAG_VEHICLE); // save the route if (writeTrip) { const ConstROEdgeVector edges = myRoute->getFirstRoute()->getEdgeVector(); const ROEdge* from = nullptr; const ROEdge* to = nullptr; if (edges.size() > 0) { if (edges.front()->isTazConnector()) { if (edges.size() > 1) { from = edges[1]; } } else { from = edges[0]; } if (edges.back()->isTazConnector()) { if (edges.size() > 1) { to = edges[edges.size() - 2]; } } else { to = edges[edges.size() - 1]; } } if (from != nullptr) { if (writeGeoTrip) { Position fromPos = from->getLanes()[0]->getShape().positionAtOffset2D(0); if (GeoConvHelper::getFinal().usingGeoProjection()) { os.setPrecision(gPrecisionGeo); GeoConvHelper::getFinal().cartesian2geo(fromPos); os.writeAttr(SUMO_ATTR_FROMLONLAT, fromPos); os.setPrecision(gPrecision); } else { os.writeAttr(SUMO_ATTR_FROMXY, fromPos); } } else { os.writeAttr(SUMO_ATTR_FROM, from->getID()); } } if (to != nullptr) { if (writeGeoTrip) { Position toPos = to->getLanes()[0]->getShape().positionAtOffset2D(to->getLanes()[0]->getShape().length2D()); if (GeoConvHelper::getFinal().usingGeoProjection()) { os.setPrecision(gPrecisionGeo); GeoConvHelper::getFinal().cartesian2geo(toPos); os.writeAttr(SUMO_ATTR_TOLONLAT, toPos); os.setPrecision(gPrecision); } else { os.writeAttr(SUMO_ATTR_TOXY, toPos); } } else { os.writeAttr(SUMO_ATTR_TO, to->getID()); } } if (getParameter().via.size() > 0) { if (writeGeoTrip) { PositionVector viaPositions; for (const std::string& viaID : getParameter().via) { const ROEdge* viaEdge = RONet::getInstance()->getEdge(viaID); assert(viaEdge != nullptr); Position viaPos = viaEdge->getLanes()[0]->getShape().positionAtOffset2D(viaEdge->getLanes()[0]->getShape().length2D() / 2); viaPositions.push_back(viaPos); } if (GeoConvHelper::getFinal().usingGeoProjection()) { for (int i = 0; i < (int)viaPositions.size(); i++) { GeoConvHelper::getFinal().cartesian2geo(viaPositions[i]); } os.setPrecision(gPrecisionGeo); os.writeAttr(SUMO_ATTR_VIALONLAT, viaPositions); os.setPrecision(gPrecision); } else { os.writeAttr(SUMO_ATTR_VIAXY, viaPositions); } } else { os.writeAttr(SUMO_ATTR_VIA, getParameter().via); } } } else { myRoute->writeXMLDefinition(os, this, asAlternatives, options.getBool("exit-times")); } for (std::vector<SUMOVehicleParameter::Stop>::const_iterator stop = getParameter().stops.begin(); stop != getParameter().stops.end(); ++stop) { stop->write(os); } getParameter().writeParams(os); os.closeTag(); }
// --------------------------------------------------------------------------- // ROLoader - methods // --------------------------------------------------------------------------- ROLoader::ROLoader(OptionsCont& oc, const bool emptyDestinationsAllowed, const bool logSteps) : myOptions(oc), myEmptyDestinationsAllowed(emptyDestinationsAllowed), myLogSteps(logSteps), myLoaders(oc.exists("unsorted-input") && oc.getBool("unsorted-input") ? 0 : DELTA_T) {}
void NBNetBuilder::compute(OptionsCont& oc, const std::set<std::string>& explicitTurnarounds, bool removeElements) { GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing(); const bool lefthand = oc.getBool("lefthand"); if (lefthand) { mirrorX(); }; // MODIFYING THE SETS OF NODES AND EDGES // Removes edges that are connecting the same node long before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Removing self-loops"); myNodeCont.removeSelfLoops(myDistrictCont, myEdgeCont, myTLLCont); PROGRESS_TIME_MESSAGE(before); // if (oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Finding isolated roads"); myNodeCont.removeIsolatedRoads(myDistrictCont, myEdgeCont, myTLLCont); PROGRESS_TIME_MESSAGE(before); } // if (oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) { if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Removing unwished edges"); myEdgeCont.removeUnwishedEdges(myDistrictCont); PROGRESS_TIME_MESSAGE(before); } } if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) { // preliminary geometry computations to determine the length of edges // This depends on turning directions and sorting of edge list // in case junctions are joined geometry computations have to be repeated // preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); NBNodesEdgesSorter::sortNodesEdges(myNodeCont); myEdgeCont.computeLaneShapes(); myNodeCont.computeNodeShapes(); myEdgeCont.computeEdgeShapes(); if (oc.getBool("roundabouts.guess")) { myEdgeCont.guessRoundabouts(); } const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts(); for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin(); it_round != roundabouts.end(); ++it_round) { std::vector<std::string> nodeIDs; for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) { nodeIDs.push_back((*it_edge)->getToNode()->getID()); } myNodeCont.addJoinExclusion(nodeIDs); } } // join junctions (may create new "geometry"-nodes so it needs to come before removing these if (oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) { myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude")); } unsigned int numJoined = myNodeCont.joinLoadedClusters(myDistrictCont, myEdgeCont, myTLLCont); if (oc.getBool("junctions.join")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Joining junction clusters"); numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont); PROGRESS_TIME_MESSAGE(before); } if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) { // reset geometry to avoid influencing subsequent steps (ramps.guess) myEdgeCont.computeLaneShapes(); } if (numJoined > 0) { // bit of a misnomer since we're already done WRITE_MESSAGE(" Joined " + toString(numJoined) + " junction cluster(s)."); } // if (removeElements) { unsigned int no = 0; const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove"); before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : "")); // removeUnwishedNodes needs turnDirections. @todo: try to call this less often NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); no = myNodeCont.removeUnwishedNodes(myDistrictCont, myEdgeCont, myTLLCont, removeGeometryNodes); PROGRESS_TIME_MESSAGE(before); WRITE_MESSAGE(" " + toString(no) + " nodes removed."); } // MOVE TO ORIGIN // compute new boundary after network modifications have taken place Boundary boundary; for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) { boundary.add(it->second->getPosition()); } for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) { boundary.add(it->second->getGeometry().getBoxBoundary()); } geoConvHelper.setConvBoundary(boundary); if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) { moveToOrigin(geoConvHelper, lefthand); } geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point if (oc.exists("geometry.min-dist") && oc.isSet("geometry.min-dist")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Reducing geometries"); myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist")); PROGRESS_TIME_MESSAGE(before); } // @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards // @note: likewise splitting can destroy similarities so joinSimilarEdges must come before if (removeElements && oc.getBool("edges.join")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Joining similar edges"); myNodeCont.joinSimilarEdges(myDistrictCont, myEdgeCont, myTLLCont); PROGRESS_TIME_MESSAGE(before); } if (oc.getBool("opposites.guess")) { PROGRESS_BEGIN_MESSAGE("guessing opposite direction edges"); myEdgeCont.guessOpposites(); PROGRESS_DONE_MESSAGE(); } // if (oc.exists("geometry.split") && oc.getBool("geometry.split")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Splitting geometry edges"); myEdgeCont.splitGeometry(myNodeCont); PROGRESS_TIME_MESSAGE(before); } // turning direction before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing turning directions"); NBTurningDirectionsComputer::computeTurnDirections(myNodeCont); PROGRESS_TIME_MESSAGE(before); // correct edge geometries to avoid overlap myNodeCont.avoidOverlap(); // guess ramps if ((oc.exists("ramps.guess") && oc.getBool("ramps.guess")) || (oc.exists("ramps.set") && oc.isSet("ramps.set"))) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Guessing and setting on-/off-ramps"); NBNodesEdgesSorter::sortNodesEdges(myNodeCont); NBRampsComputer::computeRamps(*this, oc); PROGRESS_TIME_MESSAGE(before); } // guess sidewalks if (oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")) { const int sidewalks = myEdgeCont.guessSidewalks(oc.getFloat("default.sidewalk-width"), oc.getFloat("sidewalks.guess.min-speed"), oc.getFloat("sidewalks.guess.max-speed"), oc.getBool("sidewalks.guess.from-permissions")); WRITE_MESSAGE("Guessed " + toString(sidewalks) + " sidewalks."); } // check whether any not previously setable connections may be set now myEdgeCont.recheckPostProcessConnections(); // remap ids if wished if (oc.getBool("numerical-ids")) { int numChangedEdges = myEdgeCont.mapToNumericalIDs(); int numChangedNodes = myNodeCont.mapToNumericalIDs(); if (numChangedEdges + numChangedNodes > 0) { WRITE_MESSAGE("Remapped " + toString(numChangedEdges) + " edge IDs and " + toString(numChangedNodes) + " node IDs."); } } // if (oc.exists("geometry.max-angle")) { myEdgeCont.checkGeometries( DEG2RAD(oc.getFloat("geometry.max-angle")), oc.getFloat("geometry.min-radius"), oc.getBool("geometry.min-radius.fix")); } // GEOMETRY COMPUTATION // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Sorting nodes' edges"); NBNodesEdgesSorter::sortNodesEdges(myNodeCont); PROGRESS_TIME_MESSAGE(before); myEdgeCont.computeLaneShapes(); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing node shapes"); if (oc.exists("geometry.junction-mismatch-threshold")) { myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold")); } else { myNodeCont.computeNodeShapes(); } PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing edge shapes"); myEdgeCont.computeEdgeShapes(); PROGRESS_TIME_MESSAGE(before); // resort edges based on the node and edge shapes NBNodesEdgesSorter::sortNodesEdges(myNodeCont, true); NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // APPLY SPEED MODIFICATIONS if (oc.exists("speed.offset")) { const SUMOReal speedOffset = oc.getFloat("speed.offset"); const SUMOReal speedFactor = oc.getFloat("speed.factor"); if (speedOffset != 0 || speedFactor != 1 || oc.isSet("speed.minimum")) { const SUMOReal speedMin = oc.isSet("speed.minimum") ? oc.getFloat("speed.minimum") : -std::numeric_limits<SUMOReal>::infinity(); before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Applying speed modifications"); for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) { (*i).second->setSpeed(-1, MAX2((*i).second->getSpeed() * speedFactor + speedOffset, speedMin)); } PROGRESS_TIME_MESSAGE(before); } } // CONNECTIONS COMPUTATION // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing node types"); NBNodeTypeComputer::computeNodeTypes(myNodeCont); PROGRESS_TIME_MESSAGE(before); // bool haveCrossings = false; if (oc.getBool("crossings.guess")) { haveCrossings = true; int crossings = 0; for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) { crossings += (*i).second->guessCrossings(); } WRITE_MESSAGE("Guessed " + toString(crossings) + " pedestrian crossings."); } if (!haveCrossings) { // recheck whether we had crossings in the input for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) { if (i->second->getCrossings().size() > 0) { haveCrossings = true; break; } } } if (oc.isDefault("no-internal-links") && !haveCrossings && myHaveLoadedNetworkWithoutInternalEdges) { oc.set("no-internal-links", "true"); } // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing priorities"); NBEdgePriorityComputer::computeEdgePriorities(myNodeCont); PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing approached edges"); myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections")); PROGRESS_TIME_MESSAGE(before); // if (oc.getBool("roundabouts.guess")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Guessing and setting roundabouts"); const int numGuessed = myEdgeCont.guessRoundabouts(); if (numGuessed > 0) { WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " roundabout(s)."); } PROGRESS_TIME_MESSAGE(before); } myEdgeCont.markRoundabouts(); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing approaching lanes"); myEdgeCont.computeLanes2Edges(); PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Dividing of lanes on approached lanes"); myNodeCont.computeLanes2Lanes(); myEdgeCont.sortOutgoingLanesConnections(); PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Processing turnarounds"); if (!oc.getBool("no-turnarounds")) { myEdgeCont.appendTurnarounds(oc.getBool("no-turnarounds.tls")); } else { myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls")); } PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Rechecking of lane endings"); myEdgeCont.recheckLanes(); PROGRESS_TIME_MESSAGE(before); if (haveCrossings && !oc.getBool("no-internal-links")) { for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) { i->second->buildCrossingsAndWalkingAreas(); } } // GUESS TLS POSITIONS before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Assigning nodes to traffic lights"); if (oc.isSet("tls.set")) { std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set"); TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(oc.getString("tls.default-type")); for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) { NBNode* node = myNodeCont.retrieve(*i); if (node == 0) { WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known."); } else { myNodeCont.setAsTLControlled(node, myTLLCont, type); } } } myNodeCont.guessTLs(oc, myTLLCont); PROGRESS_TIME_MESSAGE(before); // if (oc.getBool("tls.join")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Joining traffic light nodes"); myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist")); PROGRESS_TIME_MESSAGE(before); } // COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing traffic light control information"); myTLLCont.setTLControllingInformation(myEdgeCont, myNodeCont); PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing node logics"); myNodeCont.computeLogics(myEdgeCont, oc); PROGRESS_TIME_MESSAGE(before); // before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Computing traffic light logics"); std::pair<unsigned int, unsigned int> numbers = myTLLCont.computeLogics(oc); PROGRESS_TIME_MESSAGE(before); std::string progCount = ""; if (numbers.first != numbers.second) { progCount = "(" + toString(numbers.second) + " programs) "; } WRITE_MESSAGE(" " + toString(numbers.first) + " traffic light(s) " + progCount + "computed."); // if (oc.isSet("street-sign-output")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Generating street signs"); myEdgeCont.generateStreetSigns(); PROGRESS_TIME_MESSAGE(before); } // FINISHING INNER EDGES if (!oc.getBool("no-internal-links")) { before = SysUtils::getCurrentMillis(); PROGRESS_BEGIN_MESSAGE("Building inner edges"); for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) { (*i).second->sortOutgoingConnectionsByIndex(); } // walking areas shall only be built if crossings are wished as well for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) { (*i).second->buildInnerEdges(); } PROGRESS_TIME_MESSAGE(before); } if (lefthand) { mirrorX(); }; // report WRITE_MESSAGE("-----------------------------------------------------"); WRITE_MESSAGE("Summary:"); myNodeCont.printBuiltNodesStatistics(); WRITE_MESSAGE(" Network boundaries:"); WRITE_MESSAGE(" Original boundary : " + toString(geoConvHelper.getOrigBoundary())); WRITE_MESSAGE(" Applied offset : " + toString(geoConvHelper.getOffsetBase())); WRITE_MESSAGE(" Converted boundary : " + toString(geoConvHelper.getConvBoundary())); WRITE_MESSAGE("-----------------------------------------------------"); NBRequest::reportWarnings(); // report on very large networks if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 || MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) { WRITE_WARNING("Network contains very large coordinates and will probably flicker in the GUI. Check for outlying nodes and make sure the network is shifted to the coordinate origin"); } }
void NBNodeCont::guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc) { // build list of definitely not tls-controlled junctions std::vector<NBNode*> ncontrolled; if (oc.isSet("tls.unset")) { std::vector<std::string> notTLControlledNodes = oc.getStringVector("tls.unset"); for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) { NBNode* n = NBNodeCont::retrieve(*i); if (n == 0) { throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known."); } std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS(); for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) { (*j)->removeNode(n); } n->removeTrafficLights(); ncontrolled.push_back(n); } } TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(OptionsCont::getOptions().getString("tls.default-type")); // loop#1 checking whether the node shall be tls controlled, // because it is assigned to a district if (oc.exists("tls.taz-nodes") && oc.getBool("tls.taz-nodes")) { for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; if (cur->isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) { setAsTLControlled(cur, tlc, type); } } } // figure out which nodes mark the locations of TLS signals // This assumes nodes are already joined if (oc.exists("tls.guess-signals") && oc.getBool("tls.guess-signals")) { // prepare candidate edges const SUMOReal signalDist = oc.getFloat("tls.guess-signals.dist"); for (std::map<std::string, NBNode*>::const_iterator i = myNodes.begin(); i != myNodes.end(); ++i) { NBNode* node = (*i).second; if (node->isTLControlled() && node->geometryLike()) { const EdgeVector& outgoing = node->getOutgoingEdges(); for (EdgeVector::const_iterator it_o = outgoing.begin(); it_o != outgoing.end(); ++it_o) { (*it_o)->setSignalOffset((*it_o)->getLength()); } } } // check which nodes should be controlled for (std::map<std::string, NBNode*>::const_iterator i = myNodes.begin(); i != myNodes.end(); ++i) { NBNode* node = i->second; const EdgeVector& incoming = node->getIncomingEdges(); if (!node->isTLControlled() && incoming.size() > 1 && !node->geometryLike()) { std::vector<NBNode*> signals; bool isTLS = true; for (EdgeVector::const_iterator it_i = incoming.begin(); it_i != incoming.end(); ++it_i) { const NBEdge* inEdge = *it_i; if (inEdge->getSignalOffset() == NBEdge::UNSPECIFIED_SIGNAL_OFFSET || inEdge->getSignalOffset() > signalDist) { isTLS = false; break; } if (inEdge->getSignalOffset() == inEdge->getLength()) { signals.push_back(inEdge->getFromNode()); } } if (isTLS) { for (std::vector<NBNode*>::iterator j = signals.begin(); j != signals.end(); ++j) { std::set<NBTrafficLightDefinition*> tls = (*j)->getControllingTLS(); (*j)->removeTrafficLights(); for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) { tlc.removeFully((*j)->getID()); } } NBTrafficLightDefinition* tlDef = new NBOwnTLDef("GS_" + node->getID(), node, 0, TLTYPE_STATIC); // @todo patch endOffset for all incoming lanes according to the signal positions if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build joined tls '" + node->getID() + "'."); delete tlDef; return; } } } } } // maybe no tls shall be guessed if (!oc.getBool("tls.guess")) { return; } // guess joined tls first, if wished if (oc.getBool("tls.join")) { // get node clusters std::vector<std::set<NBNode*> > cands; generateNodeClusters(oc.getFloat("tls.join-dist"), cands); // check these candidates (clusters) whether they should be controlled by a tls for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) { std::set<NBNode*>& c = (*i); // regard only junctions which are not yet controlled and are not // forbidden to be controlled for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) { if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) { c.erase(j++); } else { ++j; } } // check whether the cluster should be controlled if (!shouldBeTLSControlled(c)) { i = cands.erase(i); } else { ++i; } } // cands now only contain sets of junctions that shall be joined into being tls-controlled unsigned int index = 0; for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) { std::vector<NBNode*> nodes; for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) { nodes.push_back(*j); } std::string id = "joinedG_" + toString(index++); NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type); if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build guessed, joined tls"); delete tlDef; return; } } } // guess tls for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; // do nothing if already is tl-controlled if (cur->isTLControlled()) { continue; } // do nothing if in the list of explicit non-controlled junctions if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) { continue; } std::set<NBNode*> c; c.insert(cur); if (!shouldBeTLSControlled(c) || cur->getIncomingEdges().size() < 3) { continue; } setAsTLControlled((*i).second, tlc, type); } }
void NWWriter_XML::writeEdgesAndConnections(const OptionsCont& oc, NBNodeCont& nc, NBEdgeCont& ec) { const GeoConvHelper& gch = GeoConvHelper::getFinal(); bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo"); const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection(); OutputDevice& edevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".edg.xml"); edevice.writeXMLHeader("edges", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/edges_file.xsd\""); OutputDevice& cdevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".con.xml"); cdevice.writeXMLHeader("connections", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/connections_file.xsd\""); bool noNames = !oc.getBool("output.street-names"); for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) { // write the edge itself to the edges-files NBEdge* e = (*i).second; edevice.openTag(SUMO_TAG_EDGE); edevice.writeAttr(SUMO_ATTR_ID, e->getID()); edevice.writeAttr(SUMO_ATTR_FROM, e->getFromNode()->getID()); edevice.writeAttr(SUMO_ATTR_TO, e->getToNode()->getID()); if (!noNames && e->getStreetName() != "") { edevice.writeAttr(SUMO_ATTR_NAME, StringUtils::escapeXML(e->getStreetName())); } edevice.writeAttr(SUMO_ATTR_PRIORITY, e->getPriority()); // write the type if given if (e->getTypeID() != "") { edevice.writeAttr(SUMO_ATTR_TYPE, e->getTypeID()); } edevice.writeAttr(SUMO_ATTR_NUMLANES, e->getNumLanes()); if (!e->hasLaneSpecificSpeed()) { edevice.writeAttr(SUMO_ATTR_SPEED, e->getSpeed()); } // write non-default geometry if (!e->hasDefaultGeometry()) { PositionVector geom = e->getGeometry(); if (useGeo) { for (int i = 0; i < (int) geom.size(); i++) { gch.cartesian2geo(geom[i]); } } if (geoAccuracy) { edevice.setPrecision(GEO_OUTPUT_ACCURACY); } edevice.writeAttr(SUMO_ATTR_SHAPE, geom); if (geoAccuracy) { edevice.setPrecision(); } } // write the spread type if not default ("right") if (e->getLaneSpreadFunction() != LANESPREAD_RIGHT) { edevice.writeAttr(SUMO_ATTR_SPREADTYPE, toString(e->getLaneSpreadFunction())); } // write the length if it was specified if (e->hasLoadedLength()) { edevice.writeAttr(SUMO_ATTR_LENGTH, e->getLoadedLength()); } // some attributes can be set by edge default or per lane. Write as default if possible (efficiency) if (e->getLaneWidth() != NBEdge::UNSPECIFIED_WIDTH && !e->hasLaneSpecificWidth()) { edevice.writeAttr(SUMO_ATTR_WIDTH, e->getLaneWidth()); } if (e->getOffset() != NBEdge::UNSPECIFIED_OFFSET && !e->hasLaneSpecificOffset()) { edevice.writeAttr(SUMO_ATTR_OFFSET, e->getOffset()); } if (!e->needsLaneSpecificOutput()) { edevice.closeTag(); } else { for (unsigned int i = 0; i < e->getLanes().size(); ++i) { const NBEdge::Lane& lane = e->getLanes()[i]; edevice.openTag(SUMO_TAG_LANE); edevice.writeAttr(SUMO_ATTR_INDEX, i); // write allowed lanes NWWriter_SUMO::writePermissions(edevice, lane.permissions); NWWriter_SUMO::writePreferences(edevice, lane.preferred); // write other attributes if (lane.width != NBEdge::UNSPECIFIED_WIDTH && e->hasLaneSpecificWidth()) { edevice.writeAttr(SUMO_ATTR_WIDTH, lane.width); } if (lane.offset != NBEdge::UNSPECIFIED_OFFSET && e->hasLaneSpecificOffset()) { edevice.writeAttr(SUMO_ATTR_OFFSET, lane.offset); } if (e->hasLaneSpecificSpeed()) { edevice.writeAttr(SUMO_ATTR_SPEED, lane.speed); } edevice.closeTag(); } edevice.closeTag(); } // write this edge's connections to the connections-files e->sortOutgoingConnectionsByIndex(); const std::vector<NBEdge::Connection> connections = e->getConnections(); for (std::vector<NBEdge::Connection>::const_iterator c = connections.begin(); c != connections.end(); ++c) { NWWriter_SUMO::writeConnection(cdevice, *e, *c, false, NWWriter_SUMO::PLAIN); } if (connections.size() > 0) { cdevice << "\n"; } } // write loaded prohibitions to the connections-file for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) { NWWriter_SUMO::writeProhibitions(cdevice, i->second->getProhibitions()); } edevice.close(); cdevice.close(); }