82const
double GNENet::Z_INITIALIZED = 1;
91 myNetBuilder(netBuilder),
92 myAttributeCarriers(new
GNENetHelper::AttributeCarriers(this)),
100 WRITE_GLDEBUG(
"initJunctionsAndEdges function called in GNENet constructor");
102 initJunctionsAndEdges();
104 if (myZBoundary.ymin() != Z_INITIALIZED) {
105 myZBoundary.add(0, 0);
121 WRITE_DEBUG(
"Deleting net builder in GNENet destructor");
168const std::map<std::string, int>&
249 const std::string& suggestedName,
bool wasSplit,
bool allowDuplicateGeom,
bool recomputeConnections) {
256 if (outgoingEdge->getToNode() == dest->
getNBNode() && outgoingEdge->getGeometry().size() == 2) {
257 if (!allowDuplicateGeom) {
267 if (oppositeEdges.size() > 0) {
269 if ((oppositeEdges.front()->getID().size() > 1) && (oppositeEdges.front()->getID().front() ==
'-')) {
270 edgeID = oppositeEdges.front()->getID().substr(1);
272 edgeID =
"-" + oppositeEdges.front()->getID();
281 edgeID = edgeID +
toString(counter);
284 edgeID = suggestedName;
285 }
else if (edgeInfix.size() > 0) {
290 edgeID = src->
getID() + edgeInfix + dest->
getID();
311 edge =
new GNEEdge(
this, nbe, wasSplit);
315 double defaultSpeed = neteditOptions.getFloat(
"default.speed");
316 const std::string defaultType = neteditOptions.getString(
"default.type");
317 const int defaultNrLanes = neteditOptions.getInt(
"default.lanenumber");
318 const int defaultPriority = neteditOptions.getInt(
"default.priority");
325 defaultNrLanes, defaultPriority,
326 defaultWidth, defaultOffset, spread);
328 edge =
new GNEEdge(
this, nbe, wasSplit);
331 undoList->
begin(edge,
TL(
"create edge"));
334 if (recomputeConnections) {
404 std::vector<GNECrossing*> crossingsToRemove;
406 for (
const auto& junctionNeighbour : junctionNeighbours) {
408 for (
const auto& crossing : junctionNeighbour->getGNECrossings()) {
410 if (crossing->checkEdgeBelong(junctionNeighbour->getChildEdges())) {
411 crossingsToRemove.push_back(crossing);
416 for (
const auto& crossing : crossingsToRemove) {
421 for (
const auto& edge : incidentEdges) {
436 for (
const auto& lane : edge->
getLanes()) {
442 while (lane->getChildAdditionals().size() > 0) {
446 while (lane->getChildDemandElements().size() > 0) {
450 while (lane->getChildGenericDatas().size() > 0) {
466 if (planParent->getChildDemandElements().size() == 1) {
483 if (recomputeConnections) {
509 undoList->
begin(which,
TL(
"replace edge"));
512 for (
const auto& lane : which->
getLanes()) {
514 std::vector<GNEAdditional*> copyOfLaneAdditionals = lane->getChildAdditionals();
515 for (
const auto& additional : copyOfLaneAdditionals) {
529 std::vector<GNEDemandElement*> copyOfLaneDemandElements = lane->getChildDemandElements();
530 for (
const auto& demandElement : copyOfLaneDemandElements) {
534 std::vector<GNEGenericData*> copyOfLaneGenericDatas = lane->getChildGenericDatas();
535 for (
const auto& demandElement : copyOfLaneGenericDatas) {
605 deleteEdge(edge, undoList, recomputeConnections);
625 if (recomputeConnections) {
634 undoList->
add(
new GNEChange_Lane(edge, lane, laneAttrs,
false, recomputeConnections),
true);
700 throw ProcessError(
TL(
"Trying to delete a default Vehicle Type"));
728 for (
const auto& dataInterval : copyOfDataIntervalChildren) {
741 for (
const auto& genericData : copyOfGenericDataChildren) {
789 undoList->
begin(lane,
TL(
"duplicate lane"));
792 if (recomputeConnections) {
797 undoList->
add(
new GNEChange_Lane(edge, newLane, laneAttrs,
true, recomputeConnections),
true);
805 bool addRestriction =
true;
808 for (
const auto& edgeLane : edge->
getLanes()) {
811 addRestriction =
false;
820 if (addRestriction) {
832 std::vector<GNEConnection*> cons;
842 for (
auto c : cons) {
859 for (
const auto& lane : edge->
getLanes()) {
860 if (lane->isRestricted(vclass)) {
865 const int numLanes = (int)edge->
getLanes().size();
866 if (index > numLanes) {
876 }
else if (vclass ==
SVC_BUS) {
895 const int numLanes = (int)edge->
getLanes().size();
896 if (index > numLanes) {
912 for (
const auto& lane : edge->
getLanes()) {
913 if (lane->isRestricted(vclass)) {
923std::pair<GNEJunction*, GNEEdge*>
926 undoList->
begin(edge,
TL(
"split edge"));
928 if (newJunction ==
nullptr) {
938 std::pair<PositionVector, PositionVector> newGeoms = oldEdgeGeometry.
splitAt(edgeSplitPosition);
939 const double oldLength = oldEdgeGeometry.
length();
940 const double relativeLength1 = oldLength != 0 ? newGeoms.first.length() / oldLength : 1;
941 const double relativeLength2 = oldLength != 0 ? newGeoms.second.length() / oldLength : 1;
949 const std::string::size_type sep_index = baseName.rfind(
'.');
951 if (sep_index != std::string::npos) {
952 std::string posString = baseName.substr(sep_index + 1);
953 if (GNEAttributeCarrier::canParse<int>(posString.c_str())) {
955 posBase = GNEAttributeCarrier::parse<int>(posString.c_str());
956 baseName = baseName.substr(0, sep_index);
963 undoList, baseName +
toString(posBase + (
int)edgeSplitPosition),
true,
false,
false);
967 std::vector<NBNode::Crossing> affectedCrossings;
969 if (crossing->checkEdgeBelong(edge)) {
975 newEdges.push_back(secondPart->
getNBEdge());
977 newEdges.push_back(nbEdge);
980 nbC.
edges = newEdges;
981 affectedCrossings.push_back(nbC);
987 newGeoms.first.pop_back();
988 newGeoms.first.erase(newGeoms.first.begin());
993 newGeoms.second.pop_back();
994 newGeoms.second.erase(newGeoms.second.begin());
1004 for (
int i = 0; i < (int)edge->
getLanes().size(); ++i) {
1008 for (
const auto& nbC : affectedCrossings) {
1013 for (
const auto& additional : childAdditionals) {
1014 additional->splitEdgeGeometry(edgeSplitPosition, edge, secondPart, undoList);
1017 for (
int i = 0; i < (int)edge->
getLanes().size(); i++) {
1018 for (
const auto& additional : edge->
getLanes().at(i)->getChildAdditionals()) {
1019 additional->splitEdgeGeometry(laneSplitPosition, edge->
getLanes().at(i), secondPart->
getLanes().at(i), undoList);
1024 for (
const auto& demandElement : childDemandElements) {
1025 demandElement->splitEdgeGeometry(edgeSplitPosition, edge, secondPart, undoList);
1028 for (
int i = 0; i < (int)edge->
getLanes().size(); i++) {
1029 for (
const auto& demandElement : edge->
getLanes().at(i)->getChildDemandElements()) {
1030 demandElement->splitEdgeGeometry(laneSplitPosition, edge->
getLanes().at(i), secondPart->
getLanes().at(i), undoList);
1036 return std::make_pair(newJunction, secondPart);
1043 undoList->
begin(edge,
TL(
"split edges"));
1045 auto newStuff =
splitEdge(edge, pos, undoList, newJunction);
1046 newJunction = newStuff.first;
1048 splitEdge(oppositeEdge, pos, undoList, newJunction);
1055 if (nbEdge->guessOpposite(
true)) {
1066 undoList->
begin(edge,
TL(
"reverse edge"));
1069 assert(reversed != 0);
1080 if (reversed !=
nullptr) {
1083 undoList->
begin(edge,
TL(
"add reversed edge"));
1084 if (!disconnected) {
1087 assert(reversed != 0);
1101 reversed =
createEdge(src, dest, edge, undoList,
"-" + edge->
getID(),
false,
true);
1102 assert(reversed != 0);
1117 undoList->
begin(moved,
TL(
"merge junctions"));
1122 for (
const auto& incomingNBEdge : incomingNBEdges) {
1133 for (
const auto& outgoingNBEdge : outgoingNBEdges) {
1151 for (
NBEdge* edge : roundabout) {
1152 if (edge->getFromNode() == junction->
getNBNode()) {
1153 undoList->
begin(junction,
TL(
"select roundabout"));
1154 for (
const auto& roundaboutEdge : roundabout) {
1169 undoList->
begin(junction,
TL(
"create roundabout"));
1183 std::vector<GNEEdge*> edges;
1190 std::reverse(edges.begin(), edges.end());
1192 const double lefthandSign = lefthand ? -1 : 1;
1193 std::vector<GNEJunction*> newJunctions;
1194 GNEEdge* templateEdge =
nullptr;
1195 GNEEdge* prevOpposite =
nullptr;
1197 std::vector<std::pair<NBNode::Crossing, std::vector<std::string>>> oldCrossings;
1199 std::vector<std::string> edgeIDs;
1200 for (
auto e : crossing->getCrossingEdges()) {
1201 edgeIDs.push_back(e->getID());
1203 oldCrossings.push_back(std::make_pair(*crossing->getNBCrossing(), edgeIDs));
1205 std::map<std::string, std::string> edgeRename;
1209 if (edge == prevOpposite) {
1210 newJunction = newJunctions.back();
1213 if (edge->getToJunction() == junction) {
1214 if (templateEdge ==
nullptr) {
1215 templateEdge = edge;
1218 NBEdge* e = edge->getNBEdge();
1222 templateEdge = edge;
1227 prevOpposite = edge->
getOppositeEdges().size() > 0 ? edge->getOppositeEdges().front() :
nullptr;
1228 const double geomLength = edge->getNBEdge()->getGeometry().length2D();
1229 const double splitOffset = (edge->getToJunction() == junction
1230 ?
MAX2(POSITION_EPS, geomLength - radius)
1231 :
MIN2(geomLength - POSITION_EPS, radius));
1232 Position pos = edge->getNBEdge()->getGeometry().positionAtOffset2D(splitOffset);
1233 auto newStuff =
splitEdge(edge, pos, undoList, newJunction);
1234 newJunction = newStuff.first;
1235 if (edge->getFromJunction() == junction) {
1237 edgeRename[newStuff.second->getID()] = edge->
getID();
1239 if (newJunctions.empty() || newJunction != newJunctions.back()) {
1240 newJunctions.push_back(newJunction);
1247 for (
auto item : edgeRename) {
1252 for (
auto nbCItem : oldCrossings) {
1254 nbCItem.first.edges.clear();
1256 for (
const std::string& ce : nbCItem.second) {
1257 bool foundCE =
false;
1258 for (
NBEdge* je : nj->getNBNode()->getEdges()) {
1259 if (je->getID() == ce) {
1261 nbCItem.first.edges.push_back(je);
1269 if (nbCItem.first.edges.size() == nbCItem.second.size()) {
1277 for (
int i = 0; i < (int)newJunctions.size(); i++) {
1278 GNEJunction* from = newJunctions[(i + 1) % newJunctions.size()];
1286 int numSegments =
MAX2(2, (
int)ceil(angleDiff * radius / resolution));
1288 for (
int j = 1; j < numSegments; j++) {
1289 const double angle = angle1 + lefthandSign * j * angleDiff / numSegments;
1290 innerGeom.push_back(center +
Position(cos(angle) * radius, sin(angle) * radius));
1308 if (junction.second->getPositionInView() == pos) {
1321 getApp()->beginWaitCursor();
1324 neteditOptions.set(
"output-file", neteditOptions.getString(
"net-file"));
1325 sumoOptions.resetWritable();
1326 sumoOptions.set(
"net-file", neteditOptions.getString(
"net-file"));
1334 for (
int i = 0; i < (int)edgeType.second->getLaneTypes().size(); i++) {
1336 edgeType.second->getLaneTypes().at(i)->speed,
1337 edgeType.second->getLaneTypes().at(i)->permissions,
1338 edgeType.second->getLaneTypes().at(i)->width,
1339 edgeType.second->getLaneTypes().at(i)->attrs);
1345 sumoOptions.resetWritable();
1346 neteditOptions.resetDefault(
"output-file");
1350 getApp()->endWaitCursor();
1379 edge.second->updateGeometry();
1384 edge.second->updateCenteringBoundary(
true);
1413 if (volatileOptions) {
1414 window->
setStatusBarText(
TL(
"Forced computing junctions with volatile options ..."));
1422 if (volatileOptions) {
1429 getApp()->beginWaitCursor();
1431 if (volatileOptions) {
1445 if (!generalHandler.
parse()) {
1456 if (!generalHandler.
parse()) {
1467 if (!dataHandler.
parse()) {
1478 if (!generalHandler.
parse()) {
1487 getApp()->endWaitCursor();
1505 for (
const auto& demandElement : demandElements.second) {
1506 demandElement.second->computePathElement();
1518 for (
const auto& genericData : genericDataTag.second) {
1519 genericData.second->computePathElement();
1534 for (
auto it : tlsDefs) {
1535 it->setParticipantsInformation();
1536 it->setTLControllingInformation();
1571 if (selectedJunctions.size() < 2) {
1576 std::set<NBNode*, ComparatorIdLess> cluster;
1577 for (
const auto& selectedJunction : selectedJunctions) {
1578 cluster.insert(selectedJunction->getNBNode());
1579 const EdgeVector& incoming = selectedJunction->getNBNode()->getIncomingEdges();
1580 allIncoming.insert(allIncoming.end(), incoming.begin(), incoming.end());
1581 const EdgeVector& outgoing = selectedJunction->getNBNode()->getOutgoingEdges();
1582 allOutgoing.insert(allOutgoing.end(), outgoing.begin(), outgoing.end());
1588 std::string
id =
"cluster";
1596 if ((junction.second->getPositionInView() == pos) && (cluster.find(junction.second->getNBNode()) == cluster.end())) {
1598 WRITE_DEBUG(
"Opening FXMessageBox 'Join non-selected junction'");
1600 const std::string header =
TL(
"Position of joined junction");
1601 const std::string bodyA =
TL(
"There is another unselected junction in the same position of joined junction.");
1602 const std::string bodyB =
TL(
"It will be joined with the other selected junctions. Continue?");
1603 const auto answer = FXMessageBox::question(
getApp(), MBOX_YES_NO, header.c_str(),
"%s", (bodyA + std::string(
"\n") + bodyB).c_str());
1607 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'No'");
1608 }
else if (answer == 4) {
1609 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'ESC'");
1614 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'Yes'");
1623 pos.
setx(pos.
x() + 0.1);
1624 pos.
sety(pos.
y() + 0.1);
1636 std::vector<NBNode::Crossing> oldCrossings;
1637 for (
const auto& selectedJunction : selectedJunctions) {
1638 const auto crossings = selectedJunction->getGNECrossings();
1639 for (
auto crossing : crossings) {
1644 for (
const auto& selectedJunction : selectedJunctions) {
1645 selectedJunction->setLogicValid(
false, undoList);
1648 for (
const auto& incomingEdge : allIncoming) {
1649 if (std::find(allOutgoing.begin(), allOutgoing.end(), incomingEdge) == allOutgoing.end()) {
1654 for (
const auto& outgoingEdge : allOutgoing) {
1658 edgesWithin.insert(outgoingEdge);
1665 for (
const auto& nbc : oldCrossings) {
1667 for (
NBEdge* e : nbc.edges) {
1668 if (edgesWithin.count(e) != 0) {
1676 nbc.customTLIndex, nbc.customTLIndex2, nbc.customShape,
1677 false,
true),
true);
1681 for (
const auto& selectedJunction : selectedJunctions) {
1687 if (pos != oldPos) {
1698 std::vector<GNECrossing*> myNetCrossings;
1700 myNetCrossings.reserve(myNetCrossings.size() + junction.second->getGNECrossings().size());
1701 myNetCrossings.insert(myNetCrossings.end(), junction.second->getGNECrossings().begin(), junction.second->getGNECrossings().end());
1704 std::vector<GNECrossing*> myInvalidCrossings;
1705 for (
auto i = myNetCrossings.begin(); i != myNetCrossings.end(); i++) {
1706 if (!(*i)->getNBCrossing()->valid) {
1707 myInvalidCrossings.push_back(*i);
1711 if (myInvalidCrossings.empty()) {
1713 WRITE_DEBUG(
"Opening FXMessageBox 'No crossing to remove'");
1715 const std::string header =
TL(
"Clear crossings");
1716 const std::string body =
TL(
"There are no invalid crossings to remove.");
1717 FXMessageBox::warning(
getApp(), MBOX_OK, (header).c_str(),
"%s", (body).c_str());
1719 WRITE_DEBUG(
"Closed FXMessageBox 'No crossing to remove' with 'OK'");
1721 std::string plural = myInvalidCrossings.size() == 1 ? (
"") : (
"s");
1723 WRITE_DEBUG(
"Opening FXMessageBox 'clear crossings'");
1725 const std::string header =
TL(
"Clear crossings");
1726 const std::string body =
TL(
"Crossings will be cleared. Continue?");
1727 const auto answer = FXMessageBox::question(
getApp(), MBOX_YES_NO, header.c_str(),
"%s", body.c_str());
1732 WRITE_DEBUG(
"Closed FXMessageBox 'clear crossings' with 'No'");
1733 }
else if (answer == 4) {
1734 WRITE_DEBUG(
"Closed FXMessageBox 'clear crossings' with 'ESC'");
1738 for (
auto i = myInvalidCrossings.begin(); i != myInvalidCrossings.end(); i++) {
1751 std::vector<GNEJunction*> toRemove;
1753 if (junction.second->getNBNode()->getEdges().size() == 0) {
1754 toRemove.push_back(junction.second);
1757 for (
auto junction : toRemove) {
1767 std::vector<GNEDemandElement*> routesWithoutChildren;
1771 if (route.second->getChildDemandElements().empty()) {
1772 routesWithoutChildren.push_back(route.second);
1776 if (routesWithoutChildren.size() > 0) {
1780 for (
const auto& i : routesWithoutChildren) {
1793 std::set<std::pair<std::string, GNEDemandElement*> > mySortedRoutes;
1797 bool hasStops =
false;
1798 for (
const auto& stop : route.second->getChildDemandElements()) {
1799 if (stop->getTagProperty().isVehicleStop()) {
1808 std::vector<std::vector<GNEDemandElement*> > routesToMerge;
1809 auto index = mySortedRoutes.begin();
1811 for (
auto i = mySortedRoutes.begin(); i != mySortedRoutes.end(); i++) {
1812 if (routesToMerge.empty()) {
1813 routesToMerge.push_back({i->second});
1815 if (index->first == i->first) {
1816 routesToMerge.back().push_back(i->second);
1818 routesToMerge.push_back({i->second});
1824 bool thereIsRoutesToMerge =
false;
1825 for (
const auto& i : routesToMerge) {
1827 thereIsRoutesToMerge =
true;
1831 if (thereIsRoutesToMerge) {
1835 for (
const auto& routes : routesToMerge) {
1836 if (routes.size() > 1) {
1838 for (
int i = 1; i < (int)routes.size(); i++) {
1840 while (routes.at(i)->getChildDemandElements().size() > 0) {
1841 routes.at(i)->getChildDemandElements().front()->setAttribute(
SUMO_ATTR_ROUTE, routes.at(0)->getID(), undoList);
1857 std::map<GNEDemandElement*, std::string> personPlanMap;
1859 for (
const auto& persontag : {
1863 if (person.second->getChildDemandElements().size() > 0) {
1867 while (personPlan) {
1885 if (personPlanMap.size() > 0) {
1889 for (
const auto& personPlan : personPlanMap) {
1902 std::vector<GNEDemandElement*> invalidDemandElements;
1909 invalidDemandElements.push_back(route.second);
1915 invalidDemandElements.push_back(flow.second);
1921 invalidDemandElements.push_back(trip.second);
1925 if (invalidDemandElements.size() > 0) {
1929 for (
const auto& invalidDemandElement : invalidDemandElements) {
1942 undoList->
begin(junction,
TL(
"replace junction by geometry"));
1948 for (
auto j : toJoin) {
1954 for (
auto con : connections) {
1995 if (endpoints.size() < 2) {
1999 undoList->
begin(junction,
TL(
"split junction"));
2001 std::map<GNEEdge*, std::vector<NBEdge::Connection>> straightConnections;
2003 for (
const auto& c : e->getNBEdge()->getConnections()) {
2005 straightConnections[e].push_back(c);
2012 for (
const auto& pair : endpoints) {
2014 const std::string& origID = pair.second;
2016 std::string newID = origID !=
"" ? origID : newJunction->
getID();
2023 if (e->getNBEdge()->getGeometry().back().almostSame(pos) || e->getNBEdge()->getParameter(
"origTo") == newID) {
2030 if (e->getNBEdge()->getGeometry().front().almostSame(pos) || e->getNBEdge()->getParameter(
"origFrom") == newID) {
2035 if (newID != newJunction->
getID()) {
2045 for (
const auto& item : straightConnections) {
2047 std::map<NBEdge*, GNEEdge*> newEdges;
2048 for (
auto& c : item.second) {
2054 if (newEdges.count(c.toEdge) == 0) {
2057 newEdges[c.toEdge] = newEdge;
2061 newEdge = newEdges[c.toEdge];
2085 for (
auto i : connections) {
2094 undoList->
begin(junction,
TL(
"reset junction connections"));
2108 while (additionalMap.second.size() > 0) {
2121 while (demandElementsMap.second.size() > 0) {
2145 while (meanDataMap.second.size() > 0) {
2195 std::vector<GNEAdditional*> invalidSingleLaneAdditionals;
2196 std::vector<GNEAdditional*> invalidMultiLaneAdditionals;
2199 for (
const auto& addditional : additionalPair.second) {
2201 if (addditional.second->getTagProperty().hasAttribute(
SUMO_ATTR_LANE) && !addditional.second->isAdditionalValid()) {
2202 invalidSingleLaneAdditionals.push_back(addditional.second);
2203 }
else if (addditional.second->getTagProperty().hasAttribute(
SUMO_ATTR_LANES) && !addditional.second->isAdditionalValid()) {
2204 invalidMultiLaneAdditionals.push_back(addditional.second);
2209 if (invalidSingleLaneAdditionals.size() > 0 || invalidMultiLaneAdditionals.size() > 0) {
2215 if (fixAdditionalElementsDialog.execute() == 0) {
2258 std::vector<GNEDemandElement*> invalidSingleLaneDemandElements;
2261 for (
const auto& demandElement : demandElementSet.second) {
2263 demandElement.second->computePathElement();
2266 invalidSingleLaneDemandElements.push_back(demandElement.second);
2271 if (invalidSingleLaneDemandElements.size() > 0) {
2277 if (fixDemandElementsDialog.execute() == 0) {
2284 WRITE_DEBUG(
"demand elements saved after dialog");
2312 double minimumBegin = 0;
2319 if (interval.second->getAttributeDouble(
SUMO_ATTR_BEGIN) < minimumBegin) {
2323 return minimumBegin;
2329 double maximumEnd = 0;
2336 if (interval.second->getAttributeDouble(
SUMO_ATTR_END) > maximumEnd) {
2337 maximumEnd = interval.second->getAttributeDouble(
SUMO_ATTR_END);
2358 getApp()->beginWaitCursor();
2415 getApp()->endWaitCursor();
2422 getApp()->beginWaitCursor();
2435 std::map<double, std::map<std::pair<SumoXMLTag, std::string>,
GNEDemandElement*> > vehiclesSortedByDepart;
2437 for (
const auto& demandElement : demandElementTag.second) {
2438 if (demandElement.second->getTagProperty().isVehicle() || demandElement.second->getTagProperty().isPerson() || demandElement.second->getTagProperty().isContainer()) {
2439 vehiclesSortedByDepart[demandElement.second->getAttributeDouble(
SUMO_ATTR_DEPART)][std::make_pair(demandElement.second->getTagProperty().getTag(), demandElement.second->getID())] = demandElement.second;
2444 if (vehiclesSortedByDepart.size() > 0) {
2445 device << (
" <!-- Vehicles, persons and containers (sorted by depart) -->\n");
2446 for (
const auto& vehicleTag : vehiclesSortedByDepart) {
2447 for (
const auto& vehicle : vehicleTag.second) {
2448 vehicle.second->writeDemandElement(device);
2457 getApp()->endWaitCursor();
2464 getApp()->beginWaitCursor();
2469 dataSet.second->writeDataSet(device);
2476 getApp()->endWaitCursor();
2483 getApp()->beginWaitCursor();
2498 getApp()->endWaitCursor();
2504 std::map<std::string, GNEAdditional*> sortedAdditionals;
2505 for (
const auto& tag : tags) {
2507 if (sortedAdditionals.count(additional.second->getID()) == 0) {
2508 sortedAdditionals[additional.second->getID()] = additional.second;
2514 for (
const auto& additional : sortedAdditionals) {
2515 additional.second->writeAdditional(device);
2522 std::map<std::string, GNEDemandElement*> sortedDemandElements;
2524 sortedDemandElements[demandElement.second->getID()] = demandElement.second;
2526 for (
const auto& demandElement : sortedDemandElements) {
2527 demandElement.second->writeDemandElement(device);
2534 std::map<std::string, GNEDemandElement*> sortedElements;
2539 if ((additionalFile && (numChildren != 0)) || (!additionalFile && (numChildren == 0))) {
2540 sortedElements[routeDistribution.second->getID()] = routeDistribution.second;
2543 for (
const auto& element : sortedElements) {
2544 element.second->writeDemandElement(device);
2546 sortedElements.clear();
2552 std::map<std::string, GNEDemandElement*> sortedRoutes;
2554 if ((additionalFile && (route.second->getChildAdditionals().size() > 0)) ||
2555 (!additionalFile && (route.second->getChildAdditionals().size() == 0))) {
2556 sortedRoutes[route.second->getID()] = route.second;
2559 for (
const auto& route : sortedRoutes) {
2560 route.second->writeDemandElement(device);
2567 std::map<std::string, GNEDemandElement*> sortedElements;
2572 if ((additionalFile && (numChildren != 0)) || (!additionalFile && (numChildren == 0))) {
2573 sortedElements[vTypeDistribution.second->getID()] = vTypeDistribution.second;
2576 for (
const auto& element : sortedElements) {
2577 element.second->writeDemandElement(device);
2579 sortedElements.clear();
2585 std::map<std::string, GNEDemandElement*> sortedElements;
2589 const auto numChildren = vType.second->getChildAdditionals().size();
2590 if ((additionalFile && (numChildren != 0)) || (!additionalFile && (numChildren == 0))) {
2591 sortedElements[vType.second->getID()] = vType.second;
2594 for (
const auto& element : sortedElements) {
2595 element.second->writeDemandElement(device);
2602 std::map<std::string, GNEMeanData*> sortedMeanDatas;
2604 if (sortedMeanDatas.count(meanData.second->getID()) == 0) {
2605 sortedMeanDatas[meanData.second->getID()] = meanData.second;
2610 for (
const auto& additional : sortedMeanDatas) {
2611 additional.second->writeMeanData(device);
2620 const bool defaultVType = GNEAttributeCarrier::parse<bool>(vType.second->getAttribute(
GNE_ATTR_DEFAULT_VTYPE));
2623 if ((vType.second->getParentDemandElements().size() == 0) && (!defaultVType || (defaultVType && defaultVTypeModified))) {
2624 if (additionalFile && (vType.second->getChildAdditionals().size() != 0)) {
2625 device << (
" <!-- VTypes (used in calibratorFlows) -->\n");
2627 }
else if (!additionalFile && (vType.second->getChildAdditionals().size() == 0)) {
2628 device << (
" <!-- VTypes -->\n");
2640 if (additionalFile && (route.second->getChildAdditionals().size() != 0)) {
2641 device << (
" <!-- Routes (used in RouteProbReroutes and calibratorFlows) -->\n");
2643 }
else if (!additionalFile && (route.second->getChildAdditionals().size() == 0)) {
2644 device << (
" <!-- Routes -->\n");
2655 device << (
" <!-- RouteProbes -->\n");
2666 device << (
" <!-- Calibrators -->\n");
2678 device << (
" <!-- StoppingPlaces -->\n");
2690 device << (
" <!-- Detectors -->\n");
2707 device << (
" <!-- Other additionals -->\n");
2720 (additionals.second.size() > 0)) {
2721 device << (
" <!-- Shapes -->\n");
2733 device << (
" <!-- JuPedSim elements -->\n");
2744 device << (
" <!-- TAZs -->\n");
2754 device << (
" <!-- Wires -->\n");
2764 device << (
" <!-- MeanDataEdges -->\n");
2774 device << (
" <!-- MeanDataLanes -->\n");
2785 device.
openTag(
"additionals");
2809 for (
int i = 0; i < (int)edgeType.second->getLaneTypes().size(); i++) {
2811 edgeType.second->getLaneTypes().at(i)->speed,
2812 edgeType.second->getLaneTypes().at(i)->permissions,
2813 edgeType.second->getLaneTypes().at(i)->width,
2814 edgeType.second->getLaneTypes().at(i)->attrs);
2853 dataInterval.second->updateGenericDataIDs();
2854 dataInterval.second->updateAttributeColors();
2897 throw ProcessError(
TL(
"Network size exceeds 1 Lightyear. Please reconsider your inputs.") + std::string(
"\n"));
2906 for (
const auto& lane : edge.second->getLanes()) {
2907 lane->updateGeometry();
2919 edge.second->remakeGNEConnections();
2921 for (
const auto& connection : edge.second->getGNEConnections()) {
2922 connection->updateGeometry();
2931 std::set<std::string> liveExplicitTurnarounds;
2934 liveExplicitTurnarounds.insert(explicitTurnarounds);
2950 if (neteditOptions.
getBool(
"numerical-ids") || neteditOptions.
isSet(
"reserved-ids")) {
2954 if (!neteditOptions.
getBool(
"offset.disable-normalization")) {
2957 edge.second->updateGeometry();
2968 if (volatileOptions) {
2987 WRITE_GLDEBUG(
"initJunctionsAndEdges function called in computeAndUpdate(...) due recomputing with volatile options");
2994 WRITE_GLDEBUG(
"Add junctions during recomputing after calling myNetBuilder->compute(...)");
2997 junction.second->updateCenteringBoundary(
false);
3002 WRITE_GLDEBUG(
"Add edges during recomputing after calling myNetBuilder->compute(...)");
3005 edge.second->updateCenteringBoundary(
false);
3011 edge.second->remakeGNEConnections(
true);
3016 junction.second->setLogicValid(
true,
nullptr);
3018 junction.second->updateGeometryAfterNetbuild();
3020 junction.second->rebuildGNEWalkingAreas();
3025 edge.second->updateGeometry();
3036 std::vector<std::string> values = GNEAttributeCarrier::parse<std::vector<std::string> >(ac->
getAttribute(key));
3037 std::vector<std::string> newValues;
3038 bool lastBy =
false;
3039 for (
auto v : values) {
3040 if (v == which && !lastBy) {
3042 newValues.push_back(by);
3044 newValues.push_back(v);
@ MID_COPY_VIEW_GEOBOUNDARY
Copy view geo-coordinate boundary - popup entry.
@ GLO_NETWORK
The network - empty.
#define WRITE_WARNINGF(...)
#define WRITE_MESSAGE(msg)
#define WRITE_GLDEBUG(msg)
std::set< NBEdge * > EdgeSet
container for unique edges
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_BUS
vehicle is a bus
@ SVC_PEDESTRIAN
pedestrian
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
@ SUMO_TAG_REROUTER
A rerouter.
@ GNE_TAG_MULTI_LANE_AREA_DETECTOR
an e2 detector over multiple lanes (placed here due create Additional Frame)
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_ACCESS
An access point for a train stop.
@ SUMO_TAG_CONTAINER_STOP
A container stop.
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
@ SUMO_TAG_MEANDATA_LANE
a lane based mean data detector
@ SUMO_TAG_ROUTE_DISTRIBUTION
distribution of a route
@ SUMO_TAG_OVERHEAD_WIRE_CLAMP
An overhead wire clamp (connection of wires in opposite directions)
@ GNE_TAG_POIGEO
Point of interest over view with GEO attributes.
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
@ SUMO_TAG_CONNECTION
connectioon between two lanes
@ SUMO_TAG_PARKING_AREA
A parking area.
@ GNE_TAG_CALIBRATOR_LANE
A calibrator placed over lane.
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_MEANDATA_EDGE
an edge based mean data detector
@ SUMO_TAG_POLY
begin/end of the description of a polygon
@ SUMO_TAG_OVERHEAD_WIRE_SECTION
An overhead wire section.
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
@ GNE_TAG_POILANE
Point of interest over Lane.
@ GNE_TAG_JPS_OBSTACLE
polygon used for draw juPedSim obstacles
@ SUMO_TAG_TYPE
type (edge)
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
@ GNE_TAG_ROUTE_EMBEDDED
embedded route
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
@ GNE_TAG_JPS_WALKABLEAREA
polygon used for draw juPedSim walkable areas
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
@ SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
@ SUMO_TAG_VSS
A variable speed sign.
@ GNE_TAG_STOPPERSON_EDGE
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
@ STRAIGHT
The link is a straight direction.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ GNE_ATTR_OPPOSITE
to busStop (used by personPlans)
@ GNE_ATTR_SELECTED
element is selected
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_EDGES
the edges of a route
@ GNE_ATTR_ADDITIONALCHILDREN
check number of additional children (used in vTypeDistribution)
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
@ GNE_ATTR_MODIFICATION_STATUS
whether a feature has been loaded,guessed,modified or approved
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_TLTYPE
node: the type of traffic light
@ GNE_ATTR_SHAPE_END
last coordinate of edge shape
@ SUMO_ATTR_END
weights: time range end
@ GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
@ GNE_ATTR_SHAPE_START
first coordinate of edge shape
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class that stores a 2D geometrical boundary.
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
void reset()
Resets the boundary.
double getHeight() const
Returns the height of the boundary (y-axis)
double getWidth() const
Returns the width of the boudary (x-axis)
static void drawBoundary(const GUIVisualizationSettings &s, const Boundary &b)
Draw a boundary (used for debugging)
An Element which don't belong to GNENet but has influence in the simulation.
The main window of Netedit.
OptionsCont & getSumoOptions()
get SUMO options container
void setStatusBarText(const std::string &statusBarText)
set text of the statusBar
bool isUndoRedoAllowed() const
const std::string getID() const
get ID (all Attribute Carriers have one)
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
void setInGrid(bool value)
const std::string & getTagStr() const
get tag assigned to this object in string format
static const std::string FEATURE_GUESSED
feature has been reguessed (may still be unchanged be we can't tell (yet)
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
bool inGrid() const
check if this AC was inserted in grid
static std::string parseIDs(const std::vector< T > &ACs)
parses a list of specific Attribute Carriers into a string of IDs
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
virtual std::string getAttribute(SumoXMLAttr key) const =0
virtual GUIGlObject * getGUIGlObject()=0
bool isList() const
return true if attribute is a list
static void changeAttribute(GNEAttributeCarrier *AC, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList, const bool force=false)
change attribute
static void registerJoin(const std::set< NBNode *, ComparatorIdLess > &cluster, NBNodeCont &nc, GNEUndoList *undoList)
change attribute
the function-object for an editing operation (abstract base)
NBConnection getNBConnection() const
get NBConnection
GNEEdge * getEdgeFrom() const
get the name of the edge the vehicles leave
NBEdge::Connection & getNBEdgeConnection() const
get Edge::Connection
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
GNEJunction * getParentJunction() const
get parent Junction
NBNode::Crossing * getNBCrossing() const
get referente to NBode::Crossing
An Element which don't belong to GNENet but has influence in the simulation.
GNEDataSet * getDataSetParent() const
Returns a pointer to GNEDataSet parent.
const std::vector< GNEGenericData * > & getGenericDataChildren() const
get generic data children
const std::map< const double, GNEDataInterval * > & getDataIntervalChildren() const
get data interval children
GNEDemandElement * getNextChildDemandElement(const GNEDemandElement *demandElement) const
get next child demand element to the given demand element
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEDemandElement * getPreviousChildDemandElement(const GNEDemandElement *demandElement) const
get previous child demand element to the given demand element
A road/street connecting two junctions (netedit-version)
NBEdge * getNBEdge() const
returns the internal NBEdge
GNEEdge * getReverseEdge() const
get reverse edge (if exist)
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
std::vector< GNEEdge * > getOppositeEdges() const
get opposite edges
GNEJunction * getFromJunction() const
get from Junction (only used to increase readability)
bool wasSplit()
whether this edge was created from a split
void copyTemplate(const GNEEdgeTemplate *edgeTemplate, GNEUndoList *undoList)
copy edge attributes from edgetemplate
const std::vector< GNEConnection * > & getGNEConnections() const
returns a reference to the GNEConnection vector
std::string getAttribute(SumoXMLAttr key) const
GNEJunction * getToJunction() const
get from Junction (only used to increase readability)
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Dialog for edit rerouters.
Dialog for edit rerouters.
An Element which don't belong to GNENet but has influence in the simulation.
GNEDataInterval * getDataIntervalParent() const
get data interval parent
void addChildElement(T *element)
add child element
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
const std::vector< GNEAdditional * > & getParentAdditionals() const
get parent additionals
const std::vector< GNEAdditional * > & getChildAdditionals() const
return child additionals
const std::vector< GNEGenericData * > & getChildGenericDatas() const
return child generic data elements
void clearInspection()
clear inspection
const std::vector< GNEEdge * > & getGNEIncomingEdges() const
Returns incoming GNEEdges.
const std::vector< GNECrossing * > & getGNECrossings() const
Returns GNECrossings.
std::string getAttribute(SumoXMLAttr key) const
void replaceIncomingConnections(GNEEdge *which, GNEEdge *by, GNEUndoList *undoList)
replace one edge by another in all tls connections
void markAsModified(GNEUndoList *undoList)
prevent re-guessing connections at this junction
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
void invalidateTLS(GNEUndoList *undoList, const NBConnection &deletedConnection=NBConnection::InvalidConnection, const NBConnection &addedConnection=NBConnection::InvalidConnection)
std::vector< GNEConnection * > getGNEConnections() const
Returns all GNEConnections vinculated with this junction.
Position getPositionInView() const
Returns position of hierarchical element in view.
void removeConnectionsFrom(GNEEdge *edge, GNEUndoList *undoList, bool updateTLS, int lane=-1)
remove all connections from the given edge
bool isValid(SumoXMLAttr key, const std::string &value)
const std::vector< GNEEdge * > & getGNEOutgoingEdges() const
Returns incoming GNEEdges.
void removeEdgeFromCrossings(GNEEdge *edge, GNEUndoList *undoList)
removes the given edge from all pedestrian crossings
NBNode * getNBNode() const
Return net build node.
std::vector< GNEJunction * > getJunctionNeighbours() const
return GNEJunction neighbours
void setLogicValid(bool valid, GNEUndoList *undoList, const std::string &status=FEATURE_GUESSED)
void removeConnectionsTo(GNEEdge *edge, GNEUndoList *undoList, bool updateTLS, int lane=-1)
remove all connections to the given edge
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
int getIndex() const
returns the index of the lane
std::vector< GNEConnection * > getGNEOutcomingConnections()
returns a vector with the outgoing GNEConnections of this lane
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
GNEEdge * getParentEdge() const
get parent edge
An Element which don't belong to GNENet but has influence in the simulation.
struct used for saving all attribute carriers of net, in different formats
std::vector< GNEEdge * > retrieveEdges(GNEJunction *from, GNEJunction *to) const
get all edges by from and to GNEJunction
const std::unordered_map< SumoXMLTag, std::unordered_map< const GUIGlObject *, GNEDemandElement * > > & getDemandElements() const
get demand elements
GNEEdgeType * registerEdgeType(GNEEdgeType *edgeType)
registers a edge in containers
GNELane * retrieveLane(const std::string &id, bool hardFail=true, bool checkVolatileChange=false) const
get lane by id
const std::unordered_map< SumoXMLTag, std::unordered_map< const GUIGlObject *, GNEAdditional * > > & getAdditionals() const
get additionals
void clearDemandElements()
clear demand elements
GNEEdge * registerEdge(GNEEdge *edge)
registers an edge with containers
GNECrossing * retrieveCrossing(const GUIGlObject *glObject, bool hardFail=true) const
get Crossing by AC
void remapJunctionAndEdgeIds()
remap junction and edge IDs
void clearAdditionals()
clear additionals
GNEJunction * registerJunction(GNEJunction *junction)
registers a junction in containers
const std::unordered_map< SumoXMLTag, std::unordered_map< const GUIGlObject *, GNEGenericData * > > & getGenericDatas() const
get all generic datas
GNEJunction * retrieveJunction(const std::string &id, bool hardFail=true) const
get junction by id
const std::map< const std::string, GNEDataSet * > & getDataSets() const
get demand elements
const std::map< std::string, GNEEdge * > & getEdges() const
map with the ID and pointer to edges of net
void addDefaultVTypes()
add default VTypes
const std::unordered_map< SumoXMLTag, std::map< const std::string, GNEMeanData * > > & getMeanDatas() const
get meanDatas
std::vector< GNEJunction * > getSelectedJunctions() const
return selected junctions
GNEEdge * retrieveEdge(const std::string &id, bool hardFail=true) const
get edge by id
const std::unordered_map< const GNEAttributeCarrier *, GNEDataInterval * > & getDataIntervals() const
get all data intervals of network
void clearEdges()
clear edges
const std::map< std::string, GNEJunction * > & getJunctions() const
get junctions
const std::map< std::string, GNEEdgeType * > & getEdgeTypes() const
map with the ID and pointer to edgeTypes of net
void clearJunctions()
clear junctions
GNEConnection * retrieveConnection(const std::string &id, bool hardFail=true) const
get Connection by id
class for GNEChange_ReplaceEdgeInTLS
void dataElementsSaved()
mark demand elements as saved
void demandElementsSaved()
mark demand elements as saved
void additionalsSaved()
mark additionals as saved
void TLSSaved()
mark TLS as saved
void meanDatasSaved()
mark mean data elements as saved
void networkSaved()
mark network as saved
A NBNetBuilder extended by visualisation and editing capabilities.
void clearAdditionalElements(GNEUndoList *undoList)
clear additionals
void removeSolitaryJunctions(GNEUndoList *undoList)
removes junctions that have no edges
GNEPathManager * myDataPathManager
Data path manager.
void deleteEdge(GNEEdge *edge, GNEUndoList *undoList, bool recomputeConnections)
removes edge
void writeMeanDatas(OutputDevice &device, SumoXMLTag tag) const
write meanData element by type and sorted by ID
bool joinSelectedJunctions(GNEUndoList *undoList)
join selected junctions
void writeVTypeDistributions(OutputDevice &device, const bool additionalFile) const
write vTypeDistributions sorted by ID
double getDataSetIntervalMaximumEnd() const
get maximum interval
bool writeJuPedSimComment(OutputDevice &device) const
write JuPedSim comment
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
void deleteLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
removes lane
bool writeRouteProbeComment(OutputDevice &device) const
write routeProbe comment
static const double Z_INITIALIZED
marker for whether the z-boundary is initialized
void deleteCrossing(GNECrossing *crossing, GNEUndoList *undoList)
remove crossing
SUMORTree & getGrid()
Returns the RTree used for visualisation speed-up.
GNEViewNet * myViewNet
The net to be notified of about changes.
void deleteAdditional(GNEAdditional *additional, GNEUndoList *undoList)
remove additional
bool saveMeanDatas()
save meanData elements of the network
void disableUpdateGeometry()
disable update geometry of elements after inserting or removing an element in net
void saveDemandElementsConfirmed()
save demand elements after confirming invalid objects
void saveTLSPrograms(const std::string &filename)
save TLS Programs elements of the network
void computeAndUpdate(OptionsCont &neteditOptions, bool volatileOptions)
recompute the network and update lane geometries
NBNetBuilder * getNetBuilder() const
get net builder
void saveAdditionalsConfirmed()
save additionals after confirming invalid objects
void addGLObjectIntoGrid(GNEAttributeCarrier *AC)
add GL Object into net
GNEPathManager * getDataPathManager()
get data path manager
bool writeMeanDataLaneComment(OutputDevice &device) const
write Wire comment
void reverseEdge(GNEEdge *edge, GNEUndoList *undoList)
reverse edge
bool writeTAZComment(OutputDevice &device) const
write TAZ comment
void removeGLObjectFromGrid(GNEAttributeCarrier *AC)
add GL Object into net
void saveJoined(const std::string &filename)
save log of joined junctions (and nothing else)
NBTrafficLightLogicCont & getTLLogicCont()
returns the tllcont of the underlying netbuilder
bool restrictLane(SUMOVehicleClass vclass, GNELane *lane, GNEUndoList *undoList)
transform lane to restricted lane
GNENetHelper::SavingStatus * getSavingStatus() const
get saving status
void setViewNet(GNEViewNet *viewNet)
Set the net to be notified of network changes.
bool writeCalibratorComment(OutputDevice &device) const
write calibrator comment
bool myNeedRecompute
whether the net needs recomputation
void deleteDemandElement(GNEDemandElement *demandElement, GNEUndoList *undoList)
remove demand element
void duplicateLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
duplicates lane
const Boundary & getZBoundary() const
Returns the Z boundary (stored in the x() coordinate) values of 0 do not affect the boundary.
const Boundary & getBoundary() const
returns the bounder of the network
void saveEdgeTypes(const std::string &filename)
save edgeTypes elements of the network
void deleteNetworkElement(GNENetworkElement *networkElement, GNEUndoList *undoList)
delete network element
SUMORTree myGrid
the rtree which contains all GUIGlObjects (so named for historical reasons)
void writeVTypes(OutputDevice &device, const bool additionalFile) const
write vTypes sorted by ID
void clearDataElements(GNEUndoList *undoList)
clear data elements
void deleteDataInterval(GNEDataInterval *dataInterval, GNEUndoList *undoList)
remove data interval
bool saveDataElements()
save data set elements of the network
void deleteConnection(GNEConnection *connection, GNEUndoList *undoList)
remove connection
void clearDemandElements(GNEUndoList *undoList)
clear demand elements
GNEPathManager * getDemandPathManager()
get demand path manager
bool writeMeanDataEdgeComment(OutputDevice &device) const
write meanDataEdge comment
void adjustPersonPlans(GNEUndoList *undoList)
adjust person plans
void computeNetwork(GNEApplicationWindow *window, bool force=false, bool volatileOptions=false)
trigger full netbuild computation param[in] window The window to inform about delay param[in] force W...
void writeRoutes(OutputDevice &device, const bool additionalFile) const
write route sorted by ID
void cleanInvalidDemandElements(GNEUndoList *undoList)
clean invalid demand elements
bool myUpdateDataEnabled
Flag to enable or disable update data elements after inserting or removing element in net.
void cleanUnusedRoutes(GNEUndoList *undoList)
clean unused routes
NBNetBuilder * myNetBuilder
The internal netbuilder.
void removeExplicitTurnaround(std::string id)
remove edge id from the list of explicit turnarounds
void computeJunction(GNEJunction *junction)
trigger recomputation of junction shape and logic param[in] window The window to inform about delay
void resetJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
reset junction's connections
void deleteMeanData(GNEMeanData *meanData, GNEUndoList *undoList)
remove generic data
void replaceIncomingEdge(GNEEdge *which, GNEEdge *by, GNEUndoList *undoList)
replaces edge
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
void deleteGenericData(GNEGenericData *genericData, GNEUndoList *undoList)
remove generic data
std::pair< GNEJunction *, GNEEdge * > splitEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList, GNEJunction *newJunction=0)
split edge at position by inserting a new junction
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
GNEEdge * addReversedEdge(GNEEdge *edge, const bool disconnected, GNEUndoList *undoList)
add reversed edge
void changeEdgeEndpoints(GNEEdge *edge, const std::string &newSourceID, const std::string &newDestID)
modifies endpoins of the given edge
bool myUpdateGeometryEnabled
Flag to enable or disable update geometry of elements after inserting or removing element in net.
void initJunctionsAndEdges()
Init Junctions and edges.
bool writeWireComment(OutputDevice &device) const
write Wire comment
void splitEdgesBidi(GNEEdge *edge, GNEEdge *oppositeEdge, const Position &pos, GNEUndoList *undoList)
split all edges at position by inserting one new junction
GNENetHelper::SavingStatus * mySavingStatus
AttributeCarriers of net.
void clearMeanDataElements(GNEUndoList *undoList)
clear meanDatas
unsigned int myEdgeIDCounter
void expandBoundary(const Boundary &newBoundary)
expand boundary
void disableUpdateData()
disable update data elements after inserting or removing an element in net
bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge *edge, GNEUndoList *undoList)
remove restricted lane
void mergeJunctions(GNEJunction *moved, GNEJunction *target, GNEUndoList *undoList)
merge the given junctions edges between the given junctions will be deleted
GNEEdge * createEdge(GNEJunction *src, GNEJunction *dest, GNEEdge *edgeTemplate, GNEUndoList *undoList, const std::string &suggestedName="", bool wasSplit=false, bool allowDuplicateGeom=false, bool recomputeConnections=true)
creates a new edge (unless an edge with the same geometry already exists)
std::set< std::string > myExplicitTurnarounds
list of edge ids for which turn-arounds must be added explicitly
bool saveAdditionals()
save additional elements
const std::map< std::string, int > & getEdgesAndNumberOfLanes() const
et edges and number of lanes
bool writeStoppingPlaceComment(OutputDevice &device) const
write stoppingPlace comment
void addZValueInBoundary(const double z)
add Z in net boundary
static const std::map< SumoXMLAttr, std::string > EMPTY_HEADER
variable used for write headers in additional, demand and data elements
void writeRouteDistributions(OutputDevice &device, const bool additionalFile) const
write route distributions sorted by ID
bool isUpdateGeometryEnabled() const
check if update geometry after inserting or removing has to be updated
bool addRestrictedLane(SUMOVehicleClass vclass, GNEEdge *edge, int index, GNEUndoList *undoList)
add restricted lane to edge
void saveNetwork()
save the network
bool checkJunctionPosition(const Position &pos)
return true if there are already a Junction in the given position, false in other case
bool addGreenVergeLane(GNEEdge *edge, int index, GNEUndoList *undoList)
add restricted lane to edge
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
bool isNetRecomputed() const
check if net require recomputing
void writeAdditionalByType(OutputDevice &device, const std::vector< SumoXMLTag > tags) const
write additional element by type and sorted by ID
GNEPathManager * myNetworkPathManager
Network path manager.
bool isUpdateDataEnabled() const
check if update data after inserting or removing has to be updated
bool writeShapesComment(OutputDevice &device) const
write shape comment
void deleteDataSet(GNEDataSet *dataSet, GNEUndoList *undoList)
remove data set
static void replaceInListAttribute(GNEAttributeCarrier *ac, SumoXMLAttr key, const std::string &which, const std::string &by, GNEUndoList *undoList)
replace in list attribute
bool cleanInvalidCrossings(GNEUndoList *undoList)
clear invalid crossings
GNEPathManager * getNetworkPathManager()
get network path manager
void splitJunction(GNEJunction *junction, bool reconnect, GNEUndoList *undoList)
replace the selected junction by a list of junctions for each unique edge endpoint
void selectRoundabout(GNEJunction *junction, GNEUndoList *undoList)
select all roundabout edges and junctions for the current roundabout
void joinRoutes(GNEUndoList *undoList)
join routes
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
bool writeRouteComment(OutputDevice &device, const bool additionalFile) const
write route comment
bool writeVTypeComment(OutputDevice &device, const bool additionalFile) const
write vType comment
void replaceJunctionByGeometry(GNEJunction *junction, GNEUndoList *undoList)
replace the selected junction by geometry node(s) and merge the edges
bool writeDetectorComment(OutputDevice &device) const
write detector comment
void createRoundabout(GNEJunction *junction, GNEUndoList *undoList)
transform the given junction into a roundabout
void writeDemandByType(OutputDevice &device, SumoXMLTag tag) const
write demand element by type and sorted by ID
void requireRecompute()
inform the net about the need for recomputation
GNEJunction * createJunction(const Position &pos, GNEUndoList *undoList)
creates a new junction
unsigned int myJunctionIDCounter
bool writeOtherAdditionalsComment(OutputDevice &device) const
write other additional comment
std::map< std::string, int > myEdgesAndNumberOfLanes
map with the Edges and their number of lanes
GNEPathManager * myDemandPathManager
Demand path manager.
void saveMeanDatasConfirmed()
save meanDatas
void addExplicitTurnaround(std::string id)
add edge id to the list of explicit turnarounds
void initGNEConnections()
initialize GNEConnections
void deleteJunction(GNEJunction *junction, GNEUndoList *undoList)
removes junction and all incident edges
NBEdgeCont & getEdgeCont()
returns the NBEdgeCont of the underlying netbuilder
void savePlain(const std::string &prefix)
save plain xml representation of the network (and nothing else)
bool saveDemandElements()
save demand element elements of the network
GNENetHelper::AttributeCarriers * myAttributeCarriers
AttributeCarriers of net.
void computeDataElements(GNEApplicationWindow *window)
compute data elements param[in] window The window to inform about delay
FXApp * getApp()
get pointer to the main App
bool saveJuPedSimElements(const std::string &file)
save JuPedSim elements
int getNumberOfTLSPrograms() const
get number of TLS Programs
GNEViewNet * getViewNet() const
get view net
void saveDataElementsConfirmed()
save data elements after confirming invalid objects
void enableUpdateGeometry()
void clearJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
clear junction's connections
Boundary myZBoundary
the z boundary (stored in the x-coordinate), values of 0 are ignored
double getDataSetIntervalMinimumBegin() const
get minimum interval
void computeDemandElements(GNEApplicationWindow *window)
compute demand elements param[in] window The window to inform about delay
GUIGlObject * getGUIGlObject()
get GUIGlObject associated with this AttributeCarrier
void updatePathCalculator()
update DijkstraRouter (needed a good calculation of dijkstra path after modifying network)
bool isPathCalculatorUpdated() const
check if pathCalculator is updated
PathCalculator * getPathCalculator()
obtain instance of PathCalculator
void invalidateJunctionPath(const GNEJunction *junction)
invalidate junction path
void clearSegments()
clear segments
void invalidateLanePath(const GNELane *lane)
invalidate lane path
bool isShapeElement() const
return true if tag correspond to a shape
const GNEAttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute propety associated with the given Sumo XML Attribute (throw error if doesn't exist)
bool isPlacedInRTree() const
return true if Tag correspond to an element that has to be placed in RTREE
bool isStoppingPlace() const
additional elements
bool isCalibrator() const
return true if tag correspond to a calibrator (Only used to group all detectors in the XML)
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
bool isDetector() const
return true if tag correspond to a shape (Only used to group all detectors in the XML)
bool isJuPedSimElement() const
return true if tag correspond to a JuPedSim element
bool isAdditionalPureElement() const
return true if tag correspond to a pure additional element
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute "attr"
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
GNEViewParent * getViewParent() const
get the net object
GNEUndoList * getUndoList() const
get the undoList object
GNEApplicationWindow * getGNEAppWindows() const
get GNE Application Windows
GNEInspectorFrame * getInspectorFrame() const
get frame for inspect elements
static FXMenuCommand * buildFXMenuCommand(FXComposite *p, const std::string &text, FXIcon *icon, FXObject *tgt, FXSelector sel, const bool disable=false)
build menu command
const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, const GUIMainWindow &app) const
Builds an entry which allows to copy the cursor position if geo projection is used,...
void setNetObject(GUIGlObject *object)
Sets the given object as the "network" object.
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
A window containing a gl-object's parameter.
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
void destroyPopup()
destroys the popup
Stores the information about how to visualize structures.
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
const Boundary & getConvBoundary() const
Returns the converted boundary.
static double angleDiff(const double angle1, const double angle2)
Returns the difference of the second angle to the first angle in radiants.
Storage for edges, including some functionality operating on multiple edges.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
The representation of a single edge during network building.
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
const std::vector< Connection > & getConnections() const
Returns the connections.
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
NBNode * getToNode() const
Returns the destination node of the edge.
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Lane & getLaneStruct(int lane)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
EdgeBuildingStep getStep() const
The building step of this edge.
bool hasLoadedLength() const
Returns whether a length was set explicitly.
@ LANES2LANES_RECHECK
Lanes to lanes - relationships are computed; should be rechecked.
int getNumLanes() const
Returns the number of lanes.
void resetNodeBorder(const NBNode *node)
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
std::string getLaneID(int lane) const
get lane ID
bool hasDefaultGeometryEndpointAtNode(const NBNode *node) const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
int getPriority() const
Returns the priority of the edge.
static const double UNSPECIFIED_WIDTH
unspecified lane width
static const double UNSPECIFIED_OFFSET
unspecified lane offset
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
double getFinalLength() const
get length that will be assigned to the lanes in the final network
Instance responsible for building networks.
NBNodeCont & getNodeCont()
Returns a reference to the node container.
NBEdgeCont & getEdgeCont()
NBTypeCont & getTypeCont()
Returns a reference to the type container.
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
void compute(OptionsCont &oc, const std::set< std::string > &explicitTurnarounds=std::set< std::string >(), bool mayAddOrRemove=true)
Performs the network building steps.
A definition of a pedestrian crossing.
PositionVector customShape
optional customShape for this crossing
int customTLIndex
the custom traffic light index of this crossing (if controlled)
bool priority
whether the pedestrians have priority
EdgeVector edges
The edges being crossed.
double width
This crossing's width.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
std::vector< std::string > getAllNames() const
get all node names
void analyzeCluster(NodeSet cluster, std::string &id, Position &pos, bool &hasTLS, TrafficLightType &type, SumoXMLNodeType &nodeType)
Represents a single node (junction) during network building.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node)
static const double UNSPECIFIED_RADIUS
unspecified lane width
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
std::vector< std::pair< Position, std::string > > getEndPoints() const
return list of unique endpoint coordinates of all edges at this node
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
const Position & getPosition() const
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node)
void updateSurroundingGeometry()
update geometry of node and surrounding edges
double getRadius() const
Returns the turning radius of this node.
bool checkIsRemovable() const
check if node is removable
bool isTLControlled() const
Returns whether this node is controlled by any tls.
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node's edges clockwise regarding driving direction.
A container for traffic light definitions and built programs.
bool computeSingleLogic(OptionsCont &oc, NBTrafficLightDefinition *def)
Computes a specific traffic light logic (using by netedit)
void writeEdgeTypes(OutputDevice &into, const std::set< std::string > &typeIDs=std::set< std::string >()) const
writes all EdgeTypes (and their lanes) as XML
void insertEdgeType(const std::string &id, int numLanes, double maxSpeed, int prio, SVCPermissions permissions, LaneSpreadFunction spreadType, double width, bool oneWayIsDefault, double sidewalkWidth, double bikeLaneWidth, double widthResolution, double maxWidth, double minWidth)
Adds a edgeType into the list.
void clearTypes()
clear types
void insertLaneType(const std::string &edgeTypeID, int index, double maxSpeed, SVCPermissions permissions, double width, const std::set< SumoXMLAttr > &attrs)
Adds a laneType into the list.
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network stored in the given net builder.
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
static void writeJoinedJunctions(const std::string &filename, NBNodeCont &nc)
Writes the joined-juncionts to file.
static void writeNetwork(const OptionsCont &oc, const std::string &prefix, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
A storage for options typed value containers)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
void resetWritable()
Resets all options to be writeable.
static OptionsCont & getOptions()
Retrieves the options.
Static storage of an output device and its base (abstract) implementation.
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >(), bool includeConfig=true)
Writes an XML header with optional configuration.
A point in 2D or 3D with translation and scaling methods.
void setx(double x)
set position x
double x() const
Returns the x-position.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position (in radians bet...
void sety(double y)
set position y
double y() const
Returns the y-position.
void append(const PositionVector &v, double sameThreshold=2.0)
double length() const
Returns the length.
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
std::pair< PositionVector, PositionVector > splitAt(double where, bool use2D=false) const
Returns the two lists made when this list vector is splitted at the given point.
void move2side(double amount, double maxExtension=100)
move position vector to side using certain amount
void push_back_noDoublePos(const Position &p)
insert in back a non double position
PositionVector reverse() const
reverse position vector
A RT-tree for efficient storing of SUMO's GL-objects.
void addAdditionalGLObject(GUIGlObject *o, const double exaggeration=1)
Adds an additional object (detector/shape/trigger) for visualisation.
void removeAdditionalGLObject(GUIGlObject *o, const double exaggeration=1)
Removes an additional object (detector/shape/trigger) from being visualised.
static std::string trim(const std::string s, const std::string &t=" \t\n")
remove leading and trailing whitespace
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
bool isCurrentSupermodeDemand() const
@check if current supermode is Demand
A structure which describes a connection between edges or lanes.
An (internal) definition of a single lane of an edge.