77 const
double GNENet::Z_INITIALIZED = 1;
87 myNetBuilder(netBuilder),
88 myEdgeIDSupplier("gneE", netBuilder->getEdgeCont().getAllNames()),
89 myJunctionIDSupplier("gneJ", netBuilder->getNodeCont().getAllNames()),
90 myNeedRecompute(true),
92 myAdditionalsSaved(true),
94 myTLSProgramsSaved(true),
95 myAllowUndoShapes(true) {
100 initJunctionsAndEdges();
103 if (myZBoundary.ymin() != Z_INITIALIZED) {
104 myZBoundary.add(0, 0);
109 for (
auto i : listOfTags) {
110 myAttributeCarriers.additionals.insert(std::make_pair(i, std::map<std::string, GNEAdditional*>()));
113 for (
auto i : listOfTags) {
114 myAttributeCarriers.additionals.insert(std::make_pair(i, std::map<std::string, GNEAdditional*>()));
119 myAttributeCarriers.additionals.at(defaultVehicleType->
getTagProperty().
getTag()).insert(std::make_pair(defaultVehicleType->
getID(), defaultVehicleType));
120 defaultVehicleType->
incRef(
"GNENet::DEFAULT_VEHTYPE");
135 it.second->
decRef(
"GNENet::~GNENet");
137 WRITE_DEBUG(
"Deleting unreferenced " + it.second->getTagStr() +
" '" + it.second->getID() +
"' in GNENet destructor");
142 it.second->decRef(
"GNENet::~GNENet");
144 WRITE_DEBUG(
"Deleting unreferenced " + it.second->getTagStr() +
" '" + it.second->getID() +
"' in GNENet destructor");
149 for (
auto j : it.second) {
153 WRITE_DEBUG(
"Deleting unreferenced " + j.second->getTagStr() +
" '" + j.second->getID() +
"' in GNENet destructor");
158 WRITE_DEBUG(
"Deleting net builder in GNENet destructor");
197 const std::string& imgFile,
bool relativePath,
const PositionVector& shape,
bool geo,
bool fill,
double lineWidth,
bool ) {
201 GNEPoly* poly =
new GNEPoly(
this,
id, type, shape, geo, fill, lineWidth, color, layer, angle, imgFile, relativePath,
false,
false);
209 poly->
incRef(
"addPolygon");
220 const std::string& lane,
double posOverLane,
double posLat,
double layer,
double angle,
221 const std::string& imgFile,
bool relativePath,
double width,
double height,
bool ) {
227 GNEPOI* poi =
new GNEPOI(
this,
id, type, color, pos, geo, layer, angle, imgFile, relativePath, width, height,
false);
240 throw ProcessError(
"Error adding GNEPOI into shapeContainer");
245 GNEPOI* poi =
new GNEPOI(
this,
id, type, color, layer, angle, imgFile, relativePath, retrievedLane, posOverLane, posLat, width, height,
false);
258 throw ProcessError(
"Error adding GNEPOI over lane into shapeContainer");
305 const std::string& suggestedName,
307 bool allowDuplicateGeom,
308 bool recomputeConnections) {
311 for (EdgeVector::const_iterator it = outgoing.begin(); it != outgoing.end(); it++) {
312 if ((*it)->getToNode() == dest->
getNBNode() && (*it)->getGeometry().size() == 2) {
313 if (!allowDuplicateGeom) {
320 if (suggestedName !=
"" && !
retrieveEdge(suggestedName,
false)) {
331 edge =
new GNEEdge(*nbe,
this, wasSplit);
335 double defaultSpeed = oc.
getFloat(
"default.speed");
336 std::string defaultType =
"";
337 int defaultNrLanes = oc.
getInt(
"default.lanenumber");
338 int defaultPriority = oc.
getInt(
"default.priority");
342 defaultType, defaultSpeed,
343 defaultNrLanes, defaultPriority,
346 edge =
new GNEEdge(*nbe,
this, wasSplit);
350 if (recomputeConnections) {
374 std::vector<GNECrossing*> crossingsToRemove;
376 for (
auto i : junctionNeighbours) {
378 for (
auto j : i->getGNECrossings()) {
381 crossingsToRemove.push_back(j);
387 for (
auto i : crossingsToRemove) {
393 for (
auto it : incident) {
418 i->removeLaneOfAdditionalParents(undoList,
false);
419 while (i->getAdditionalChilds().size() > 0) {
425 std::vector<GNEShape*> copyOfLaneShapes = i->getShapeChilds();
426 for (
auto j : copyOfLaneShapes) {
434 if (recomputeConnections) {
468 std::vector<GNEAdditional*> copyOfLaneAdditionals = i->getAdditionalChilds();
469 for (
auto j : copyOfLaneAdditionals) {
475 std::vector<GNEShape*> copyOfLaneShapes = i->getShapeChilds();
476 for (
auto j : copyOfLaneShapes) {
491 for (
auto con : connections) {
508 deleteEdge(edge, undoList, recomputeConnections);
522 if (recomputeConnections) {
531 undoList->add(
new GNEChange_Lane(edge, lane, laneAttrs,
false, recomputeConnections),
true);
556 undoList->
p_begin(
"delete crossing");
586 undoList->add(
new GNEChange_Lane(edge, newLane, laneAttrs,
true, recomputeConnections),
true);
594 bool addRestriction =
true;
600 addRestriction =
false;
609 if (addRestriction) {
626 if (i->isRestricted(vclass)) {
631 if (index >= (
int)edge.
getLanes().size()) {
645 if (i->isRestricted(vclass)) {
658 if (newJunction ==
nullptr) {
664 std::pair<PositionVector, PositionVector> newGeoms = oldGeom.
splitAt(linePos);
670 const std::string::size_type sep_index = baseName.rfind(
'.');
671 if (sep_index != std::string::npos) {
672 std::string posString = baseName.substr(sep_index + 1);
674 posBase = GNEAttributeCarrier::parse<int>(posString.c_str());
675 baseName = baseName.substr(0, sep_index);
683 undoList, baseName +
toString(posBase + (
int)linePos),
true,
false,
false);
687 std::vector<NBNode::Crossing> affectedCrossings;
689 if (crossing->checkEdgeBelong(edge)) {
695 newEdges.push_back(secondPart->
getNBEdge());
697 newEdges.push_back(nbEdge);
700 nbC.
edges = newEdges;
701 affectedCrossings.push_back(nbC);
707 newGeoms.first.pop_back();
708 newGeoms.first.erase(newGeoms.first.begin());
713 newGeoms.second.pop_back();
714 newGeoms.second.erase(newGeoms.second.begin());
717 for (
int i = 0; i < (int)edge->
getLanes().size(); ++i) {
721 for (
const auto& nbC : affectedCrossings) {
734 newJunction =
splitEdge(edge, pos, undoList, newJunction);
736 splitEdge(oppositeEdge, pos, undoList, newJunction);
746 assert(reversed != 0);
761 assert(reversed != 0);
775 reversed =
createEdge(src, dest, edge, undoList,
"-" + edge->
getID(),
false,
true);
776 assert(reversed != 0);
796 for (
NBEdge* edge : incoming) {
808 for (
NBEdge* edge : outgoing) {
828 if (i.second->getPositionInView() == pos) {
841 std::string shapeSaved = (
myShapesSaved ?
"saved" :
"unsaved");
842 WRITE_DEBUG(
"Current saving Status: net unsaved, additionals " + additionalsSaved +
", shapes " + shapeSaved);
890 }
else if (failHard) {
905 }
else if (failHard) {
916 assert((from !=
nullptr) && (to !=
nullptr));
919 if ((i.second->getGNEJunctionSource() == from) && (i.second->getGNEJunctionDestiny() == to)) {
936 }
else if (failHard) {
949 }
else if (failHard) {
963 for (
auto j : i.second->getGNEConnections()) {
964 if (j->getID() == id) {
978 std::vector<GNEConnection*>
980 std::vector<GNEConnection*> result;
984 for (
auto j : i.second->getGNEConnections()) {
985 if (!onlySelected || j->isAttributeCarrierSelected()) {
999 for (
auto j : i.second->getGNECrossings()) {
1000 if (j->getID() == id) {
1014 std::vector<GNECrossing*>
1016 std::vector<GNECrossing*> result;
1020 for (
auto j : i.second->getGNECrossings()) {
1021 if (!onlySelected || j->isAttributeCarrierSelected()) {
1022 result.push_back(j);
1030 std::vector<GNEEdge*>
1032 std::vector<GNEEdge*> result;
1035 if (!onlySelected || i.second->isAttributeCarrierSelected()) {
1036 result.push_back(i.second);
1043 std::vector<GNELane*>
1045 std::vector<GNELane*> result;
1048 for (
auto j : i.second->getLanes()) {
1049 if (!onlySelected || j->isAttributeCarrierSelected()) {
1050 result.push_back(j);
1062 if (edge !=
nullptr) {
1066 if (it->getID() == id) {
1071 if (lane ==
nullptr) {
1083 }
else if (failHard) {
1091 std::vector<GNEJunction*>
1093 std::vector<GNEJunction*> result;
1096 if (!onlySelected || i.second->isAttributeCarrierSelected()) {
1097 result.push_back(i.second);
1104 std::vector<GNEShape*>
1106 std::vector<GNEShape*> result;
1113 result.push_back(shape);
1123 result.push_back(poi);
1132 std::vector<GNEShape*>
1134 std::vector<GNEShape*> result;
1139 result.push_back(poly);
1142 for (
const auto& it :
getPOIs()) {
1145 result.push_back(poi);
1170 if (
object !=
nullptr) {
1175 if (ac ==
nullptr) {
1176 throw ProcessError(
"GUIGlObject does not match the declared type");
1180 }
else if (failHard) {
1181 throw ProcessError(
"Attempted to retrieve non-existant GUIGlObject");
1188 std::vector<GNEAttributeCarrier*>
1190 std::vector<GNEAttributeCarrier*> result;
1194 result.push_back(i.second);
1195 for (
auto j : i.second->getGNECrossings()) {
1196 result.push_back(j);
1200 result.push_back(i.second);
1201 for (
auto j : i.second->getLanes()) {
1202 result.push_back(j);
1204 for (
auto j : i.second->getGNEConnections()) {
1205 result.push_back(j);
1209 for (
auto j : i.second) {
1210 result.push_back(j.second);
1214 result.push_back(dynamic_cast<GNEPoly*>(i.second));
1217 result.push_back(dynamic_cast<GNEPOI*>(i.second));
1222 result.push_back(i.second);
1229 result.push_back(i.second);
1234 result.push_back(i.second);
1239 for (
auto j : i.second->getLanes()) {
1240 result.push_back(j);
1246 for (
auto j : i.second->getGNEConnections()) {
1247 result.push_back(j);
1253 for (
auto j : i.second->getGNECrossings()) {
1254 result.push_back(j);
1260 result.push_back(dynamic_cast<GNEPoly*>(i.second));
1266 result.push_back(dynamic_cast<GNEPOI*>(i.second));
1282 if (volatileOptions) {
1283 window->
setStatusBarText(
"Forced computing junctions with volatile options ...");
1291 if (volatileOptions) {
1298 if (volatileOptions) {
1309 if (additionalPath !=
"") {
1312 for (
auto i : listOfTags) {
1319 defaultVehicleType->
incRef(
"GNENet::DEFAULT_VEHTYPE");
1334 if (shapePath !=
"") {
1344 window->getApp()->endWaitCursor();
1358 for (
auto it : tlsDefs) {
1359 it->setParticipantsInformation();
1360 it->setTLControllingInformation();
1377 if (n.second->getGNECrossings().size() > 0) {
1400 if (selectedJunctions.size() < 2) {
1405 std::set<NBNode*, ComparatorIdLess> cluster;
1406 for (
auto it : selectedJunctions) {
1407 cluster.insert(it->getNBNode());
1408 const EdgeVector& incoming = it->getNBNode()->getIncomingEdges();
1409 allIncoming.insert(allIncoming.end(), incoming.begin(), incoming.end());
1410 const EdgeVector& outgoing = it->getNBNode()->getOutgoingEdges();
1411 allOutgoing.insert(allOutgoing.end(), outgoing.begin(), outgoing.end());
1417 std::string
id =
"cluster";
1426 if ((i.second->getPositionInView() == pos) && (cluster.find(i.second->getNBNode()) == cluster.end())) {
1428 WRITE_DEBUG(
"Opening FXMessageBox 'Join non-selected junction'");
1430 FXuint answer = FXMessageBox::question(
getApp(), MBOX_YES_NO,
1437 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'No'");
1438 }
else if (answer == 4) {
1439 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'ESC'");
1444 WRITE_DEBUG(
"Closed FXMessageBox 'Join non-selected junction' with 'Yes'");
1454 pos.
setx(pos.
x() + 0.1);
1455 pos.
sety(pos.
y() + 0.1);
1473 std::vector<NBNode::Crossing> oldCrossings;
1474 for (
auto i : selectedJunctions) {
1475 while (i->getGNECrossings().size() > 0) {
1476 GNECrossing* crossing = i->getGNECrossings().front();
1483 for (
auto it : selectedJunctions) {
1484 it->setLogicValid(
false, undoList);
1487 for (
auto it : allIncoming) {
1492 for (
auto it : allOutgoing) {
1497 edgesWithin.insert(it);
1505 for (
auto nbc : oldCrossings) {
1507 for (
NBEdge* e : nbc.edges) {
1508 if (edgesWithin.count(e) != 0) {
1516 nbc.customTLIndex, nbc.customTLIndex2, nbc.customShape,
1517 false,
true),
true);
1522 for (
auto it : selectedJunctions) {
1529 if (pos != oldPos) {
1540 std::vector<GNECrossing*> myNetCrossings;
1542 myNetCrossings.reserve(myNetCrossings.size() + it.second->getGNECrossings().size());
1543 myNetCrossings.insert(myNetCrossings.end(), it.second->getGNECrossings().begin(), it.second->getGNECrossings().end());
1546 std::vector<GNECrossing*> myInvalidCrossings;
1547 for (
auto i = myNetCrossings.begin(); i != myNetCrossings.end(); i++) {
1548 if ((*i)->getNBCrossing()->valid ==
false) {
1549 myInvalidCrossings.push_back(*i);
1553 if (myInvalidCrossings.empty()) {
1555 WRITE_DEBUG(
"Opening FXMessageBox 'No crossing to remove'");
1557 FXMessageBox::warning(
getApp(), MBOX_OK,
1561 WRITE_DEBUG(
"Closed FXMessageBox 'No crossing to remove' with 'OK'");
1563 std::string plural = myInvalidCrossings.size() == 1 ? (
"") : (
"s");
1565 WRITE_DEBUG(
"Opening FXMessageBox 'clear crossings'");
1567 FXuint answer = FXMessageBox::question(
getApp(), MBOX_YES_NO,
1573 WRITE_DEBUG(
"Closed FXMessageBox 'clear crossings' with 'No'");
1574 }
else if (answer == 4) {
1575 WRITE_DEBUG(
"Closed FXMessageBox 'clear crossings' with 'ESC'");
1579 for (
auto i = myInvalidCrossings.begin(); i != myInvalidCrossings.end(); i++) {
1592 std::vector<GNEJunction*> toRemove;
1596 toRemove.push_back(junction);
1599 for (
auto it : toRemove) {
1610 undoList->
p_begin(
"Replace junction by geometry");
1616 for (
auto j : toJoin) {
1622 for (
auto con : connections) {
1654 if (endpoints.size() < 2) {
1658 undoList->
p_begin(
"Split junction");
1664 if (e->getNBEdge()->getGeometry().back().almostSame(pos)) {
1670 if (e->getNBEdge()->getGeometry().front().almostSame(pos)) {
1685 undoList->
p_begin(
"clear junction connections");
1688 for (
auto i : connections) {
1697 undoList->
p_begin(
"reset junction connections");
1714 i->updateConnectionIDs();
1735 std::vector<GNEAttributeCarrier*>
1737 std::vector<GNEAttributeCarrier*> result;
1742 result.push_back(AC);
1762 std::string oldID = junction->
getID();
1788 }
else if (hardFail) {
1789 throw ProcessError(
"Attempted to retrieve non-existant additional");
1796 std::vector<GNEAdditional*>
1798 std::vector<GNEAdditional*> result;
1801 for (
auto j : i.second) {
1802 if (!onlySelected || j.second->isAttributeCarrierSelected()) {
1803 result.push_back(j.second);
1811 const std::map<std::string, GNEAdditional*>&
1822 counter += (int)i.second.size();
1847 std::string netSaved = (
myNetSaved ?
"saved" :
"unsaved");
1848 std::string shapeSaved = (
myShapesSaved ?
"saved" :
"unsaved");
1849 WRITE_DEBUG(
"Current saving Status: net " + netSaved +
", additionals unsaved, shapes " + shapeSaved);
1865 std::vector<GNEAdditional*> invalidSingleLaneAdditionals;
1866 std::vector<GNEAdditional*> invalidMultiLaneAdditionals;
1869 for (
auto j : i.second) {
1871 if (j.second->getTagProperty().canBePlacedOverLane() && !j.second->isAdditionalValid()) {
1872 invalidSingleLaneAdditionals.push_back(j.second);
1873 }
else if (j.second->getTagProperty().canBePlacedOverLanes() && !j.second->isAdditionalValid()) {
1874 invalidMultiLaneAdditionals.push_back(j.second);
1879 if (invalidSingleLaneAdditionals.size() > 0 || invalidMultiLaneAdditionals.size() > 0) {
1883 if (fixAdditionalPositionsDialog.execute() == 0) {
1918 for (
auto j : i.second) {
1920 j.second->writeAdditional(device);
1928 for (
auto j : i.second) {
1929 j.second->writeAdditional(device);
1936 for (
auto j : i.second) {
1937 j.second->writeAdditional(device);
1944 for (
auto j : i.second) {
1946 if (j.second->getFirstAdditionalParent() ==
nullptr) {
1947 j.second->writeAdditional(device);
1955 for (
auto j : i.second) {
1957 if (j.second->getFirstAdditionalParent() ==
nullptr) {
1958 j.second->writeAdditional(device);
1967 for (
auto j : i.second) {
1969 if (j.second->getFirstAdditionalParent() ==
nullptr) {
1970 j.second->writeAdditional(device);
1981 if (shape.size() > 0) {
1983 GNEPoly* shapePoly =
new GNEPoly(
this,
"edit_shape",
"edit_shape", shape,
false, fill, 0.3, col,
GLO_POLYGON, 0,
"",
false,
false ,
false);
2003 throw ProcessError(
"Polygon for edit shapes has to be inicializated");
2013 std::string newID =
"poly_" +
toString(counter);
2017 newID =
"poly_" +
toString(counter);
2022 std::string newID =
"POI_" +
toString(counter);
2026 newID =
"POI_" +
toString(counter);
2055 std::string netSaved = (
myNetSaved ?
"saved" :
"unsaved");
2057 WRITE_DEBUG(
"Current saving Status: net " + netSaved +
", additionals " + additionalsSaved +
", shapes unsaved");
2075 dynamic_cast<GNEShape*
>(i.second)->writeShape(device);
2078 for (
const auto& i :
myPOIs) {
2079 dynamic_cast<GNEShape*
>(i.second)->writeShape(device);
2109 device.
openTag(
"additionals");
2132 if (i.second == additional) {
2173 if (i->second == additional) {
2210 for (
auto name_it : nodeContainer.
getAllNames()) {
2221 throw ProcessError(
"Network size exceeds 1 Lightyear. Please reconsider your inputs.\n");
2256 junction->
incRef(
"GNENet::registerJunction");
2280 edge->
incRef(
"GNENet::registerEdge");
2312 junction->
decRef(
"GNENet::deleteSingleJunction");
2331 edge->
decRef(
"GNENet::deleteSingleEdge");
2421 i.second->remakeGNEConnections();
2423 for (
const auto &j : i.second->getGNEConnections()) {
2424 j->updateGeometry(
true);
2433 std::set<std::string> liveExplicitTurnarounds;
2436 liveExplicitTurnarounds.insert(it);
2452 if (oc.
getBool(
"numerical-ids") || oc.
isSet(
"reserved-ids")) {
2453 std::map<std::string, GNEEdge*> newEdgeMap;
2454 std::map<std::string, GNEJunction*> newJunctionMap;
2457 it.second->setMicrosimID(it.second->getNBEdge()->getID());
2458 newEdgeMap[it.second->getNBEdge()->getID()] = it.second;
2461 newJunctionMap[it.second->getNBNode()->getID()] = it.second;
2462 it.second->setMicrosimID(it.second->getNBNode()->getID());
2468 if (!oc.
getBool(
"offset.disable-normalization")) {
2471 it.second->updateGeometry(
true);
2483 if (volatileOptions) {
2491 for (
auto it : copyOfEdges) {
2497 for (
auto it : copyOfJunctions) {
2503 for (
const auto& j : it.second) {
2505 if (j.second->getTagProperty().isDrawable()) {
2519 for (
const auto& it :
myPOIs) {
2530 it.second->remakeGNEConnections();
2536 it.second->setLogicValid(
true,
nullptr);
2540 it.second->updateGeometry(
true);
2548 it.second->updateGeometry(
true);
2560 std::vector<std::string> values = GNEAttributeCarrier::parse<std::vector<std::string> >(ac->
getAttribute(key));
2561 std::vector<std::string> newValues;
2562 for (
auto v : values) {
2563 newValues.push_back(v == which ? by : v);
void setViewNet(GNEViewNet *viewNet)
Set the viewNet to be notified of network changes.
GNEJunction * splitEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList, GNEJunction *newJunction=0)
split edge at position by inserting a new junction
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
void enableSaveTLSProgramsMenu()
enable save TLS Programs
bool addRestrictedLane(SUMOVehicleClass vclass, GNEEdge &edge, int index, GNEUndoList *undoList)
add restricted lane to edge
std::vector< GNEJunction * > retrieveJunctions(bool onlySelected=false)
return all junctions
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
void setResponsible(bool newVal)
set responsibility for deleting internal strctures
std::string getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
std::vector< GNEConnection * > getGNEConnections() const
Returns all GNEConnections vinculated with this junction.
void initJunctionsAndEdges()
Init Junctions and edges.
void insertAdditional(GNEAdditional *additional)
Insert a additional element int GNENet container.
static const TagProperties & getTagProperties(SumoXMLTag tag)
get Tag Properties
std::vector< GNELane * > retrieveLanes(bool onlySelected=false)
return all lanes
void close()
Closes the device and removes it from the dictionary.
GNEViewNet * myViewNet
The viewNet to be notofied of about changes.
SumoXMLTag
Numbers representing SUMO-XML - element names.
const std::set< GUIGlID > & getSelected() const
Returns the set of ids of all selected objects.
GNEInspectorFrame * getInspectorFrame() const
get frame for GNE_MODE_INSPECT
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
the function-object for an editing operation (abstract base)
A structure which describes a connection between edges or lanes.
void addIncomingGNEEdge(GNEEdge *edge)
add incoming GNEEdge
void enableSaveAdditionalsMenu()
enable save additionals
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
void removeInspectedAC(GNEAttributeCarrier *ac)
remove AC from current inspected ACs
IDSupplier myEdgeIDSupplier
description of a vehicle type
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
const std::vector< GNEEdge * > & getGNEOutgoingEdges() const
Returns incoming GNEEdges.
void setStatusBarText(const std::string &statusBarText)
set text of the statusBar
int buildCrossings()
build pedestrian crossings
bool isDrawable() const
return true if tag correspond to a drawable element
void append(const PositionVector &v, double sameThreshold=2.0)
void removeIncomingGNEEdge(GNEEdge *edge)
remove incoming GNEEdge
SUMORTree myGrid
the rtree which contains all GUIGlObjects (so named for historical reasons)
double z() const
Returns the z-position.
begin/end of the description of a junction
begin/end of the description of a single lane
std::map< std::string, GNEEdge * > edges
map with the name and pointer to edges of net
FXApp * getApp()
get pointer to the main App
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
void enableSaveShapesMenu()
enable save shapes
The main window of the Netedit.
bool additionalExist(GNEAdditional *additional)
return true if additional exist (use pointer instead ID)
bool changeID(const std::string &oldId, const std::string &newId)
change ID of a stored object
void removeEdgeFromCrossings(GNEEdge *edge, GNEUndoList *undoList)
removes the given edge from all pedestrian crossings
NBNetBuilder * getNetBuilder() const
get net builder
const AttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
void setMicrosimID(const std::string &newID)
override to also set lane ids
const Polygons & getPolygons() const
Returns all polygons.
A container for traffic light definitions and built programs.
int size() const
Returns the number of stored items within the container.
std::map< SumoXMLTag, std::map< std::string, GNEAdditional * > > additionals
map with the name and pointer to additional elements of net
GNEAttributeCarrier * retrieveAttributeCarrier(const GUIGlID id, bool failHard=true)
get a single attribute carrier based on a GLID
connectio between two lanes
Stores the information about how to visualize structures.
virtual std::string getAttribute(SumoXMLAttr key) const =0
void removeShape(GNEShape *shape)
remove created shape (but NOT delete)
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.
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
GNEViewParent * getViewParent() const
get the net object
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
double y() const
Returns the y-position.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
GNEConnection * retrieveConnection(const std::string &id, bool failHard=true) const
get Connection by id
T get(const std::string &id) const
Retrieves an item.
friend class GNEChange_Lane
The representation of a single edge during network building.
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
Polygons myPolygons
stored Polygons
static void writeJoinedJunctions(const OptionsCont &oc, NBNodeCont &nc)
Writes the joined-juncionts to file.
GNEPOI * retrievePOI(const std::string &id, bool failHard=true) const
get POI by id
void removeAdditionalGLObject(GUIGlObject *o)
Removes an additional object (detector/shape/trigger) from being visualised.
double x() const
Returns the x-position.
void avoid(const std::string &id)
make sure that the given id is never supplied
void reverseEdge(GNEEdge *edge, GNEUndoList *undoList)
reverse edge
void update()
notify myViewNet
void insertJunction(GNEJunction *junction)
inserts a single junction into the net and into the underlying netbuild-container ...
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
static const double UNSPECIFIED_OFFSET
unspecified lane offset
void deleteShape(GNEShape *shape, GNEUndoList *undoList)
remove shape
GNEPoly * retrievePolygon(const std::string &id, bool failHard=true) const
get Polygon by id
static std::vector< SumoXMLTag > allowedTagsByCategory(int tagPropertyCategory, bool onlyDrawables)
get tags of all editable element types using TagProperty Type (TAGPROPERTY_NETELEMENT, TAGPROPERTY_ADDITIONAL, etc.)
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
void deleteConnection(GNEConnection *connection, GNEUndoList *undoList)
remove connection
double getWidth() const
Returns the width of the boudary (x-axis)
void resetJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
reset junction's connections
A NBNetBuilder extended by visualisation and editing capabilities.
GNEEdge * createEdge(GNEJunction *src, GNEJunction *dest, GNEEdge *tpl, 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)
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
std::vector< GNEConnection * > retrieveConnections(bool onlySelected=false) const
return all connections
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
void addExplicitTurnaround(std::string id)
add edge id to the list of explicit turnarounds
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
PositionVector reverse() const
reverse position vector
bool myAllowUndoShapes
flag used to indicate if shaped created can be undo
bool cleanInvalidCrossings(GNEUndoList *undoList)
clear invalid crossings
bool isDetector() const
return true if tag correspond to a shape (Only used to group all detectors in the XML) ...
friend class GNEChange_Shape
int getNumberOfAdditionals(SumoXMLTag type=SUMO_TAG_NOTHING) const
Returns the number of additionals of the net.
Storage for geometrical objects.
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
begin/end of the description of a Point of interest
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
void insertEdge(GNEEdge *edge)
inserts a single edge into the net and into the underlying netbuild-container
const std::string & getID() const
Returns the id.
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
Lane & getLaneStruct(int lane)
const Boundary & getBoundary() const
returns the bounder of the network
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything's ok.
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node's edges clockwise regarding driving direction.
std::vector< GNEAttributeCarrier * > getSelectedAttributeCarriers()
get all selected attribute carriers
const std::string DEFAULT_VTYPE_ID
A RT-tree for efficient storing of SUMO's GL-objects.
bool deleteAdditional(GNEAdditional *additional)
delete additional element of GNENet container
const std::vector< GNEEdge * > & getGNEEdges() const
Returns all GNEEdges vinculated with this Junction.
virtual std::string getAttribute(SumoXMLAttr key) const =0
first coordinate of edge shape
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used, also builds an entry for copying the geo-position.
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
Boundary getBoundary() const
Returns the boundary of the junction.
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
GNEJunction * registerJunction(GNEJunction *junction)
registers a junction with GNENet containers
static const double UNSPECIFIED_WIDTH
unspecified lane width
A class that stores a 2D geometrical boundary.
bool myNeedRecompute
whether the net needs recomputation
void selectAttributeCarrier(bool changeFlag=true)
Builds trigger objects for GNENet (busStops, chargingStations, detectors, etc..)
begin/end of the description of a route
NBNetBuilder * myNetBuilder
The internal netbuilder.
bool netHasGNECrossings() const
check if net has GNECrossings
void setNetObject(GUIGlObject *object)
Sets the given object as the "network" object.
void saveTLSPrograms(const std::string &filename)
save TLS Programs elements of the network
static OptionsCont & getOptions()
Retrieves the options.
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
bool priority
whether the pedestrians have priority
bool add(const std::string &id, T item)
Adds an item.
void disableSaveAdditionalsMenu()
disable save additionals
bool restrictLane(SUMOVehicleClass vclass, GNELane *lane, GNEUndoList *undoList)
transform lane to restricted lane
std::string generateShapeID(SumoXMLTag shapeTag) const
generate Shape ID
GNEAdditionalFrame * getAdditionalFrame() const
get frame for GNE_MODE_ADDITIONAL
bool isList() const
return true if atribute is a list
bool myAdditionalsSaved
Flag to check if additionals has to be saved.
void renameJunction(GNEJunction *junction, const std::string &newID)
updates the map and reserves new id
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
void removeOutgoingGNEEdge(GNEEdge *edge)
remove outgoing GNEEdge
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
IDSupplier myJunctionIDSupplier
std::map< std::string, int > myEdgesAndNumberOfLanes
map with the Edges and their number of lanes
const std::vector< GNECrossing * > & getGNECrossings() const
Returns GNECrossings.
NBEdge::Connection & getNBEdgeConnection() const
get Edge::Connection
An (internal) definition of a single lane of an edge.
the function-object for an editing operation (abstract base)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
void registerJoinedCluster(const NodeSet &cluster)
gets all joined clusters (see doc for myClusters2Join)
std::string getAttribute(SumoXMLAttr key) const
static const double Z_INITIALIZED
marker for whether the z-boundary is initialized
std::string getAttribute(SumoXMLAttr key) const
bool isTLControlled() const
Returns whether this node is controlled by any tls.
GNEUndoList * getUndoList() const
get the undoList object
int getIndex() const
returns the index of the lane
friend class GNEChange_Connection
const std::vector< GNEAdditional * > & getAdditionalParents() const
return vector of additionals that have as Parameter this edge (For example, Rerouters) ...
void updateAdditionalID(const std::string &oldID, GNEAdditional *additional)
update additional ID in container
std::set< NBEdge * > EdgeSet
container for unique edges
void removeConnectionsFrom(GNEEdge *edge, GNEUndoList *undoList, bool updateTLS, int lane=-1)
remove all connections from the given edge
std::string getNext()
Returns the next id.
void splitJunction(GNEJunction *junction, GNEUndoList *undoList)
replace the selected junction by a list of junctions for each unique edge endpoint ...
bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge &edge, GNEUndoList *undoList)
remove restricted lane
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
GNEPoly * addPolygonForEditShapes(GNENetElement *netElement, const PositionVector &shape, bool fill, RGBColor col)
Builds a special polygon used for edit Junctions's shapes.
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
GNEEdge & getParentEdge()
Returns underlying parent edge.
void saveAdditionalsConfirmed(const std::string &filename)
save additionals after confirming invalid objects
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
void deleteLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
removes lane
bool hasDefaultGeometryEndpointAtNode(const NBNode *node) const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
NBEdgeCont & getEdgeCont()
returns the NBEdgeCont of the underlying netbuilder
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
void insertShape(GNEShape *shape)
insert shape
const std::vector< GNEEdge * > & getGNEIncomingEdges() const
Returns incoming GNEEdges.
std::string getLaneID(int lane) const
get Lane ID (Secure)
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
int getNumLanes() const
Returns the number of lanes.
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >())
Writes an XML header with optional configuration.
A point in 2D or 3D with translation and scaling methods.
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise, the sub-group will be added as a new command into parent group. A matching begin() must have been called previously.
GNEJunction * retrieveJunction(const std::string &id, bool failHard=true)
get junction by id
void setx(double x)
set position x
NBEdgeCont & getEdgeCont()
GNEEdge * getEdgeFrom() const
get the name of the edge the vehicles leave
bool joinSelectedJunctions(GNEUndoList *undoList)
join selected junctions
Boundary myZBoundary
the z boundary (stored in the x-coordinate), values of 0 are ignored
void removeGLObjectFromGrid(GUIGlObject *o)
add GL Object into net
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
void replaceIncomingEdge(GNEEdge *which, GNEEdge *by, GNEUndoList *undoList)
replaces edge
void removeLaneOfAdditionalParents(GNEUndoList *undoList, bool allowEmpty)
remove lane of Additional Parent
void selectAttributeCarrier(bool changeFlag=true)
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
void updateGeometry(bool updateGrid)
Update the boundary of the junction.
virtual bool isAttributeCarrierSelected() const =0
check if attribute carrier is selected
bool addPOI(const std::string &id, const std::string &type, const RGBColor &color, const Position &pos, bool geo, const std::string &lane, double posOverLane, double posLat, double layer, double angle, const std::string &imgFile, bool relativePath, double width, double height, bool ignorePruning=false)
Builds a POI using the given values and adds it to the container.
GNEApplicationWindow * getGNEAppWindows() const
get GNE Application Windows
GNEJunction * getGNEJunctionDestiny() const
returns the destination-junction
void removeAdditional(GNEAdditional *additional)
remove an additional element previously added
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
void computeJunction(GNEJunction *junction)
trigger recomputation of junction shape and logic param[in] window The window to inform about delay ...
void requiereSaveAdditionals(bool value)
inform that additionals has to be saved
Storage for edges, including some functionality operating on multiple edges.
void initGNEConnections()
initialize GNEConnections
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
Dialog for edit rerouters.
void save(OptionsCont &oc)
save the network
edge: the shape in xml-definition
void removeConnectionsTo(GNEEdge *edge, GNEUndoList *undoList, bool updateTLS, int lane=-1)
remove all connections to the given edge
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
void deleteCrossing(GNECrossing *crossing, GNEUndoList *undoList)
remove crossing
void addOutgoingGNEEdge(GNEEdge *edge)
add outgoing GNEEdge
const std::string getID() const
function to support debugging
friend class GNEChange_Edge
void clearInspectedAC()
Clear all current inspected ACs.
void changeShapeID(GNEShape *s, const std::string &OldID)
change Shape ID
GNEJunction * createJunction(const Position &pos, GNEUndoList *undoList)
creates a new junction
std::vector< GNEShape * > retrieveShapes(SumoXMLTag shapeTag, bool onlySelected=false)
return shape by type shapes
bool isStoppingPlace() const
return true if tag correspond to a detector (Only used to group all stoppingPlaces in the output XML)...
GNEJunction * getGNEJunctionSource() const
returns the source-junction
void incRef(const std::string &debugMsg="")
Increarse reference.
virtual void updateGeometry(bool updateGrid)=0
update pre-computed geometry information
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
void move2side(double amount)
move position vector to side using certain ammount
SUMORTree & getVisualisationSpeedUp()
Returns the RTree used for visualisation speed-up.
std::vector< GNEAttributeCarrier * > retrieveAttributeCarriers(SumoXMLTag type=SUMO_TAG_NOTHING)
get the attribute carriers based on Type
void selectAttributeCarrier(bool changeFlag=true)
select attribute carrier using GUIGlobalSelection
std::set< std::string > myExplicitTurnarounds
list of edge ids for which turn-arounds must be added explicitly
void decRef(const std::string &debugMsg="")
Decrease reference.
void rename(NBNode *node, const std::string &newID)
Renames the node. Throws exception if newID already exists.
begin/end of the description of an edge
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
bool checkJunctionPosition(const Position &pos)
return true if there are already a Junction in the given position, false in other case ...
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network stored in the given net builder.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
void replaceJunctionByGeometry(GNEJunction *junction, GNEUndoList *undoList)
replace the selected junction by geometry node(s) and merge the edges
A road/street connecting two junctions (netedit-version)
void reserveJunctionID(const std::string &id)
reserve junction ID (To avoid duplicates)
void duplicateLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
duplicates lane
void reset()
Resets the boundary.
void setResponsible(bool newVal)
set responsibility for deleting internal strctures
GNECrossing * retrieveCrossing(const std::string &id, bool failHard=true) const
get Crossing by id
std::vector< std::string > getAllNames() const
get all node names
void deleteSingleJunction(GNEJunction *junction)
deletes a single junction
double width
This crossing's width.
const Boundary & getZBoundary() const
Returns the Z boundary (stored in the x() coordinate) values of 0 do not affect the boundary...
std::string generateAdditionalID(SumoXMLTag type) const
generate additional id
int customTLIndex
the custom traffic light index of this crossing (if controlled)
const std::vector< GNELane * > & getLanes()
returns a reference to the lane vector
void deleteEdge(GNEEdge *edge, GNEUndoList *undoList, bool recomputeConnections)
removes edge
void setShapeEditedElement(GNENetElement *element)
retrieve the netElement of which the shape is being edited
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
std::vector< GNEEdge * > retrieveEdges(bool onlySelected=false)
return all edges
const std::vector< Connection > & getConnections() const
Returns the connections.
NBConnection getNBConnection() const
get NBConnection
GNEEdge * registerEdge(GNEEdge *edge)
registers an edge with GNENet containers
PositionVector customShape
optional customShape for this crossing
virtual void setMicrosimID(const std::string &newID)
Changes the microsimID of the object.
NBNodeCont & getNodeCont()
Returns a reference to the node container.
double getHeight() const
Returns the height of the boundary (y-axis)
void addAdditionalGLObject(GUIGlObject *o)
Adds an additional object (detector/shape/trigger) for visualisation.
bool computeSingleLogic(OptionsCont &oc, NBTrafficLightDefinition *def)
Computes a specific traffic light logic (using by NETEDIT)
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
An Element which don't belongs to GNENet but has influency in the simulation.
std::vector< GNEAdditional * > retrieveAdditionals(bool onlySelected=false) const
return all additionals
Instance responsible for building networks.
static OutputDevice & getDevice(const std::string &name)
Returns the described OutputDevice.
friend class GNEChange_Junction
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node) ...
void removeSolitaryJunctions(GNEUndoList *undoList)
removes junctions that have no edges
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
std::vector< Position > getEndPoints() const
return list of unique endpoint coordinates of all edges at this node
const std::string & getTagStr() const
get tag assigned to this object in string format
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
void disableSaveShapesMenu()
disable save shapes
void requiereSaveNet(bool value)
inform that net has to be saved
AttributeCarriers myAttributeCarriers
AttributeCarriers of net.
void sety(double y)
set position y
A storage for options typed value containers)
class for GNEChange_ReplaceEdgeInTLS
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
void computeEverything(GNEApplicationWindow *window, bool force=false, bool volatileOptions=false, std::string additionalPath="", std::string shapePath="")
trigger full netbuild computation param[in] window The window to inform about delay param[in] force W...
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
void clearJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
clear junction's connections
void computeAndUpdate(OptionsCont &oc, bool volatileOptions)
recompute the network and update lane geometries
int getNumberOfShapes() const
get number of shapes
crossing between edges for pedestrians
void renameEdge(GNEEdge *edge, const std::string &newID)
updates the map and reserves new id
static void replaceInListAttribute(GNEAttributeCarrier *ac, SumoXMLAttr key, const std::string &which, const std::string &by, GNEUndoList *undoList)
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
void replaceIncomingConnections(GNEEdge *which, GNEEdge *by, GNEUndoList *undoList)
replace one edge by another in all tls connections
void deleteJunction(GNEJunction *junction, GNEUndoList *undoList)
removes junction and all incident edges
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
bool myTLSProgramsSaved
Flag to check if shapes has to be saved.
std::map< std::string, GNEJunction * > junctions
map with the name and pointer to junctions of net
std::vector< GNECrossing * > retrieveCrossings(bool onlySelected=false) const
return all crossings
const Position & getPosition() const
void removeExplicitTurnaround(std::string id)
remove edge id from the list of explicit turnarounds
EdgeVector edges
The edges being crossed.
Represents a single node (junction) during network building.
void saveJoined(OptionsCont &oc)
save log of joined junctions (and nothing else)
const std::map< std::string, GNEAdditional * > & getAdditionalByType(SumoXMLTag type) const
get map with IDs and pointers to additionals
A definition of a pedestrian crossing.
GNEEdge * addReversedEdge(GNEEdge *edge, GNEUndoList *undoList)
add reversed edge
Static storage of an output device and its base (abstract) implementation.
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
const std::vector< GNEAdditional * > & getAdditionalChilds() const
return vector of additionals that have as Parent this edge (For example, Calibrators) ...
last coordinate of edge shape
NBNode::Crossing * getNBCrossing() const
get referente to NBode::Crossing
void push_back_noDoublePos(const Position &p)
insert in back a non double position
void unblockObject(GUIGlID id)
Marks an object as unblocked.
void reserveEdgeID(const std::string &id)
reserve edge ID (To avoid duplicates)
void compute(OptionsCont &oc, const std::set< std::string > &explicitTurnarounds=std::set< std::string >(), bool mayAddOrRemove=true)
Performs the network building steps.
NBNode * getFromNode() const
Returns the origin node of the edge.
void deleteSingleEdge(GNEEdge *edge)
deletes a single edge
void analyzeCluster(NodeSet cluster, std::string &id, Position &pos, bool &hasTLS, TrafficLightType &type, SumoXMLNodeType &nodeType)
Container for nodes during the netbuilding process.
void removePolygonForEditShapes(GNEPoly *polygon)
remove Polygon for edit shapes
NBEdge * getNBEdge()
returns the internal NBEdge
std::vector< GNEJunction * > getJunctionNeighbours() const
return GNEJunction neighbours
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
void mergeJunctions(GNEJunction *moved, GNEJunction *target, GNEUndoList *undoList)
merge the given junctions edges between the given junctions will be deleted
void requiereSaveTLSPrograms()
bool remove(const std::string &id, const bool del=true)
Removes an item.
begin/end of the description of a Point of interest over Lane (used by Netedit)
bool extract(NBNode *node, bool remember=false)
Removes the given node but does not delete it.
Boundary getBoundary() const
Returns the street's geometry.
#define WRITE_MESSAGE(msg)
GUIGlObject * getObjectBlocking(GUIGlID id)
Returns the object from the container locking it.
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
bool checkIsRemovable() const
check if node is removable
NBNode * getNBNode() const
Return net build node.
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
void addGLObjectIntoGrid(GUIGlObject *o)
add GL Object into net
GUISelectedStorage gSelected
A global holder of selected objects.
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
bool myShapesSaved
Flag to check if shapes has to be saved.
void setLogicValid(bool valid, GNEUndoList *undoList, const std::string &status=FEATURE_GUESSED)
A window containing a gl-object's parameter.
const std::vector< GNEShape * > & getShapeChilds() const
get shape childs of lane
void changeEdgeEndpoints(GNEEdge *edge, const std::string &newSourceID, const std::string &newDestID)
modifies endpoins of the given edge
NBTrafficLightLogicCont & getTLLogicCont()
returns the tllcont of the underlying netbuilder
bool wasSplit()
whether this edge was created from a split
int getNumberOfTLSPrograms() const
get number of TLS Programs
NBNode * getToNode() const
Returns the destination node of the edge.
void saveAdditionals(const std::string &filename)
save additional elements of the network
bool myNetSaved
Flag to check if net has to be saved.
void savePlain(OptionsCont &oc)
save plain xml representation of the network (and nothing else)
void splitEdgesBidi(GNEEdge *edge, GNEEdge *oppositeEdge, const Position &pos, GNEUndoList *undoList)
split all edges at position by inserting one new junction
void requireRecompute()
inform the net about the need for recomputation
bool isNetSaved() const
return if net has to be saved
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
void removeEdgeOfAdditionalParents(GNEUndoList *undoList)
remove Edge of Additional Parent
bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
void invalidateTLS(GNEUndoList *undoList, const NBConnection &deletedConnection=NBConnection::InvalidConnection, const NBConnection &addedConnection=NBConnection::InvalidConnection)
void requiereSaveShapes(bool value)
inform that shapes has to be saved
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
begin/end of the description of a polygon
void markAsModified(GNEUndoList *undoList)
prevent re-guessing connections at this junction
GNEViewNet * getViewNet() const
get view net
void saveShapes(const std::string &filename)
save shapes elements of the network
GNEJunction * getParentJunction() const
get parent Junction
const POIs & getPOIs() const
Returns all pois.