73 #ifdef CHECK_MEMORY_LEAKS 75 #endif // CHECK_MEMORY_LEAKS 91 myNetBuilder(netBuilder),
94 myEdgeIDSupplier(
"gneE", netBuilder->getEdgeCont().getAllNames()),
95 myJunctionIDSupplier(
"gneJ", netBuilder->getNodeCont().getAllNames()),
96 myShapeContainer(myGrid),
97 myNeedRecompute(true) {
102 const std::vector<std::string>& edgeNames = ec.
getAllNames();
103 for (std::vector<std::string>::const_iterator name_it = edgeNames.begin(); name_it != edgeNames.end(); ++name_it) {
107 throw ProcessError(
"Network size exceeds 1 Lightyear. Please reconsider your inputs.\n");
113 const std::vector<std::string>& nodeNames = nc.
getAllNames();
114 for (std::vector<std::string>::const_iterator name_it = nodeNames.begin(); name_it != nodeNames.end(); ++name_it) {
160 for (GNEEdges::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
161 it->second->decRef(
"GNENet::~GNENet");
165 it->second->decRef(
"GNENet::~GNENet");
221 const std::string& suggestedName,
223 bool allowDuplicateGeom) {
226 for (EdgeVector::const_iterator it = outgoing.begin(); it != outgoing.end(); it++) {
227 if ((*it)->getToNode() == dest->
getNBNode() && (*it)->getGeometry().size() == 2) {
228 if (!allowDuplicateGeom) {
235 if (suggestedName !=
"" && !
retrieveEdge(suggestedName,
false)) {
246 edge =
new GNEEdge(*nbe,
this, wasSplit);
250 std::string defaultType =
"";
251 int defaultNrLanes = 1;
252 int defaultPriority = 1;
256 defaultType, defaultSpeed,
257 defaultNrLanes, defaultPriority,
260 edge =
new GNEEdge(*nbe,
this, wasSplit);
262 undoList->
p_begin(
"create edge");
278 undoList->
p_begin(
"delete junction");
282 for (EdgeVector::const_iterator it = incident.begin(); it != incident.end(); it++) {
290 std::set<GUIGlID> deselected;
291 deselected.insert(junction->
getGlID());
300 undoList->
p_begin(
"delete edge");
303 std::set<GUIGlID> deselected;
304 deselected.insert(edge->
getGlID());
318 undoList->
p_begin(
"delete lane");
322 undoList->add(
new GNEChange_Lane(edge, lane, laneAttrs,
false),
true);
324 std::set<GUIGlID> deselected;
325 deselected.insert(lane->
getGlID());
341 undoList->
p_begin(
"duplicate lane");
345 undoList->add(
new GNEChange_Lane(edge, newLane, laneAttrs,
true),
true);
361 undoList->
p_begin(
"split edge");
366 std::pair<PositionVector, PositionVector> newGeoms = oldGeom.
splitAt(linePos);
371 size_t sep_index = baseName.rfind(
'.');
372 if (sep_index != std::string::npos) {
373 std::string posString = baseName.substr(sep_index + 1);
376 baseName = baseName.substr(0, sep_index);
383 if (newJunction == 0) {
387 undoList, baseName +
toString(posBase),
true);
389 undoList, baseName +
toString(posBase + (
int)linePos),
true);
393 newGeoms.first.pop_back();
394 newGeoms.first.erase(newGeoms.first.begin());
399 newGeoms.second.pop_back();
400 newGeoms.second.erase(newGeoms.second.begin());
403 std::vector<NBEdge::Connection>& connections = edge->getNBEdge()->getConnections();
404 for (std::vector<NBEdge::Connection>::iterator con_it = connections.begin(); con_it != connections.end(); con_it++) {
406 secondPart, con_it->fromLane, con_it->toEdge->getID(), con_it->toLane,
false,
true),
true);
416 undoList->
p_begin(
"split edges");
417 for (std::set<GNEEdge*>::const_iterator it = edges.begin(); it != edges.end(); ++it) {
418 newJunction =
splitEdge(*it, pos, undoList, newJunction);
426 undoList->
p_begin(
"reverse edge");
429 assert(reversed != 0);
437 undoList->
p_begin(
"add reversed edge");
441 assert(reversed != 0);
454 assert(reversed != 0);
457 std::set<GUIGlID> toSelect;
458 toSelect.insert(reversed->getGlID());
459 toSelect.insert(src->
getGlID());
460 toSelect.insert(dest->getGlID());
470 undoList->
p_begin(
"merge junctions");
477 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); it++) {
483 for (EdgeVector::const_iterator it = outgoing.begin(); it != outgoing.end(); it++) {
532 }
else if (failHard) {
544 }
else if (failHard) {
552 std::vector<GNEEdge*>
554 std::vector<GNEEdge*> result;
555 for (GNEEdges::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); ++it) {
557 result.push_back(it->second);
564 std::vector<GNELane*>
566 std::vector<GNELane*> result;
567 for (GNEEdges::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); ++it) {
569 for (GNEEdge::LaneVector::const_iterator it_lane = lanes.begin(); it_lane != lanes.end(); ++it_lane) {
571 result.push_back(*it_lane);
579 std::vector<GNEJunction*>
581 std::vector<GNEJunction*> result;
584 result.push_back(it->second);
599 std::vector<GNEAttributeCarrier*>
601 std::vector<GNEAttributeCarrier*> result;
602 for (std::set<GUIGlID>::iterator it = ids.begin(); it != ids.end(); it++) {
613 ac =
dynamic_cast<GNEEdge*
>(object);
616 ac =
dynamic_cast<GNELane*
>(object);
622 throw ProcessError(
"GUIGlObject does not match the declared type");
624 result.push_back(ac);
627 throw ProcessError(
"Attempted to retrieve non-existant GUIGlObject");
636 std::set<GUIGlID> result;
639 std::set<GUIGlObjectType> knownTypes;
644 for (std::set<GUIGlObjectType>::const_iterator it = knownTypes.begin(); it != knownTypes.end(); it++) {
645 const std::set<GUIGlID> tmp =
getGlIDs(*it);
646 result.insert(tmp.begin(), tmp.end());
652 result.insert(it->second->getGlID());
656 for (GNEEdges::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
657 result.insert(it->second->getGlID());
661 for (GNEEdges::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
662 const std::set<GUIGlID> laneIDs = it->second->getLaneGlIDs();
663 for (std::set<GUIGlID>::const_iterator lid_it = laneIDs.begin(); lid_it != laneIDs.end(); lid_it++) {
664 result.insert(*lid_it);
673 if (it->second->getNBNode()->isTLControlled()) {
674 result.insert(it->second->getGlID());
702 window->getApp()->endWaitCursor();
716 for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
730 if (selected.size() < 2) {
733 undoList->
p_begin(
"Join selected junctions");
737 std::set<NBNode*> cluster;
738 for (std::vector<GNEJunction*>::iterator it = selected.begin(); it != selected.end(); it++) {
739 cluster.insert((*it)->getNBNode());
740 const EdgeVector& incoming = (*it)->getNBNode()->getIncomingEdges();
741 allIncoming.insert(allIncoming.end(), incoming.begin(), incoming.end());
742 const EdgeVector& outgoing = (*it)->getNBNode()->getOutgoingEdges();
743 allOutgoing.insert(allOutgoing.end(), outgoing.begin(), outgoing.end());
760 for (EdgeVector::const_iterator it = allIncoming.begin(); it != allIncoming.end(); it++) {
764 for (EdgeVector::const_iterator it = allOutgoing.begin(); it != allOutgoing.end(); it++) {
769 for (std::vector<GNEJunction*>::iterator it = selected.begin(); it != selected.end(); it++) {
779 undoList->
p_begin(
"Clean junctions");
780 std::vector<GNEJunction*> toRemove;
784 toRemove.push_back(junction);
787 for (std::vector<GNEJunction*>::iterator it = toRemove.begin(); it != toRemove.end(); ++it) {
796 undoList->
p_begin(
"Replace junction by geometry");
799 for (std::vector<std::pair<NBEdge*, NBEdge*> >::iterator j = toJoin.begin(); j != toJoin.end(); j++) {
857 Position delta = moveDest - moveSrc;
859 std::set<GNEJunction*> junctionSet;
861 for (std::vector<GNEJunction*>::iterator it = junctions.begin(); it != junctions.end(); it++) {
862 Position newPos = (*it)->getNBNode()->getPosition() + delta;
864 junctionSet.insert(*it);
869 for (std::vector<GNEEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
872 if (junctionSet.count(edge->
getSource()) > 0 &&
873 junctionSet.count(edge->
getDest()) > 0) {
887 undoList->
p_begin(
"move selection");
889 std::set<GNEJunction*> junctionSet;
891 for (std::vector<GNEJunction*>::iterator it = junctions.begin(); it != junctions.end(); it++) {
892 (*it)->registerMove(undoList);
893 junctionSet.insert(*it);
898 for (std::vector<GNEEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
932 junction->
incRef(
"GNENet::registerJunction");
949 edge->
incRef(
"GNENet::registerEdge");
964 junction->
decRef(
"GNENet::deleteSingleJunction");
976 edge->
decRef(
"GNENet::deleteSingleEdge");
1006 std::set<std::string> liveExplicitTurnarounds;
1009 liveExplicitTurnarounds.insert(*it);
1014 for (GNEEdges::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1015 it->second->updateLaneGeometries();
1018 it->second->setLogicValid(
true);
1020 it->second->updateBoundary();
GNEJunction * splitEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList, GNEJunction *newJunction=0)
split edge at position by inserting a new junction
void computeAndUpdate(OptionsCont &oc)
recompute the network and update lane geometries
std::vector< GNEJunction * > retrieveJunctions(bool onlySelected=false)
return all junctions
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
void setResponsible(bool newVal)
set responsibility for deleting internal strctures
virtual void setParticipantsInformation()
Builds the list of participating nodes/edges/links.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges.
std::vector< GNELane * > retrieveLanes(bool onlySelected=false)
return all lanes
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
SUMOReal getHeight() const
Returns the height of the boundary.
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
IDSupplier myEdgeIDSupplier
SUMOReal getWidth() const
Returns the width of the boudary.
SUMOReal nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
SUMORTree myGrid
the rtree which contains all GUIGlObjects (so named for historical reasons)
void joinSelectedJunctions(GNEUndoList *undoList)
void refreshElement(GUIGlObject *o)
refreshes boundary information for o and update
The main window of the Netedit.
static const RGBColor selectedLaneColor
void setMicrosimID(const std::string &newID)
override to also set lane ids
A container for traffic light definitions and built programs.
void compute(OptionsCont &oc, const std::set< std::string > &explicitTurnarounds=std::set< std::string >(), bool removeElements=true)
Performs the network building steps.
void setLogicValid(bool valid, GNEUndoList *undoList=0, const std::string &status=GUESSED)
SUMOReal ymin() const
Returns minimum y-coordinate.
Stores the information about how to visualize structures.
std::set< GUIGlID > getGlIDs(GUIGlObjectType type=GLO_MAX)
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
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)
Position moveGeometry(const Position &oldPos, const Position &newPos, bool relative=false)
change the edge geometry without registering undo/redo It is up to the Edge to decide whether an new ...
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
static void writeJoinedJunctions(const OptionsCont &oc, NBNodeCont &nc)
Writes the joined-juncionts to file.
void computeEverything(GNEApplicationWindow *window, bool force=false)
GNEEdge & getParentEdge()
Returns underlying parent edge.
std::vector< GNELane * > LaneVector
Definition of the lane's positions vector.
void removeAdditionalGLObject(GUIGlObject *o)
Removes an additional object (detector/shape/trigger) from being visualised.
void avoid(const std::string &id)
make sure that the given id is never supplied
void reverseEdge(GNEEdge *edge, GNEUndoList *undoList)
reverse edge
The base class for traffic light logic definitions.
void update()
notify myUpdateTarget
void insertJunction(GNEJunction *junction)
inserts a single junction into the net and into the underlying
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
SUMOReal getTotalWidth() const
Returns the combined width of all lanes of this edge.
std::string getAttribute(SumoXMLAttr key) const
void splitEdgesBidi(const std::set< GNEEdge * > &edges, const Position &pos, GNEUndoList *undoList)
split all edges at position by inserting one new junction
NBTrafficLightLogicCont & getTLLogicCont()
returns the tllcont of the underlying netbuilder
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
GNEEdge * createEdge(GNEJunction *src, GNEJunction *dest, GNEEdge *tpl, GNEUndoList *undoList, const std::string &suggestedName="", bool wasSplit=false, bool allowDuplicateGeom=false)
creates a new edge (unless an edge with the same geometry already exists)
void p_begin(const std::string &description)
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.
void insertEdge(GNEEdge *edge)
inserts a single edge into the net and into the underlying
bool checkIsRemovable() const
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
unsigned int getIndex() const
void deleteEdge(GNEEdge *edge, GNEUndoList *undoList)
removes edge
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node's edges clockwise regarding driving direction.
void registerMove(GNEUndoList *undoList)
registers completed movement with the undoList
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
void remapEdge(GNEEdge *oldEdge, GNEJunction *from, GNEJunction *to, GNEUndoList *undoList, bool keepEndpoints=false)
GUIGlID getGlID() const
Returns the numerical id of the object.
GNEJunction * registerJunction(GNEJunction *junction)
registers a junction with GNENet containers
A class that stores a 2D geometrical boundary.
bool myNeedRecompute
whether the net needs recomputation
NBNetBuilder * myNetBuilder
The internal netbuilder.
void setNetObject(GUIGlObject *object)
Sets the given object as the "network" object.
const Boundary & getBoundary() const
returns the bounder of the network
static OptionsCont & getOptions()
Retrieves the options.
PositionVector reverse() const
void renameJunction(GNEJunction *junction, const std::string &newID)
updates the map and reserves new id
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges.
IDSupplier myJunctionIDSupplier
An (internal) definition of a single lane of an edge.
const std::string & getID() const
Returns the id.
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
const Position & getPosition() const
Returns the position of this node.
const std::set< GUIGlID > & getSelected() const
Returns the list of ids of all selected objects.
std::string getNext()
Returns the next id.
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
FXWindow * myUpdateTarget
The window to be notofied of about changes.
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
A point in 2D or 3D with translation and scaling methods.
GNEJunction * retrieveJunction(const std::string &id, bool failHard=true)
get junction by id
NBEdgeCont & getEdgeCont()
Returns the edge container.
Boundary myZBoundary
the z boundary (stored in the x-coordinate), values of 0 are ignored
void deleteLane(GNELane *lane, GNEUndoList *undoList)
removes lane
void deleteGeometryOrEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList)
removes geometry when pos is close to a geometry node, deletes the whole edge otherwise ...
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
Boundary getBoundary() const
Returns the street's geometry.
SUMOReal z() const
Returns the z-position.
void removeFromCrossings(GNEEdge *edge, GNEUndoList *undoList)
removes the given edge from all pedestrian crossings
void computeJunction(GNEJunction *junction)
const EdgeVector & getEdges() const
Returns all edges which participate in this node.
Storage for edges, including some functionality operating on multiple edges.
NBNode * getNBNode()
returns the internal NBNode
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
void save(OptionsCont &oc)
save the network
std::vector< GNEAttributeCarrier * > retrieveAttributeCarriers(const std::set< GUIGlID > &ids, GUIGlObjectType type)
get the attribute carriers based on GlIDs
std::vector< std::string > getAllNames() const
get all node names
friend class GNEChange_Edge
const std::string getID() const
function to support debugging
void moveSelection(const Position &moveSrc, const Position &moveDest)
GNEJunction * createJunction(const Position &pos, GNEUndoList *undoList)
creates a new junction
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
void incRef(const std::string &debugMsg="")
std::set< std::string > myExplicitTurnarounds
list of edge ids for which turn-arounds must be added explicitly
void decRef(const std::string &debugMsg="")
void rename(NBNode *node, const std::string &newID)
Renames the node. Throws exception if newID already exists.
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
NBEdge * getNBEdge()
returns the internal NBEdge
std::pair< PositionVector, PositionVector > splitAt(SUMOReal where) const
Returns the two lists made when this list vector is splitted at the given point.
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network stored in the given net builder.
void replaceJunctionByGeometry(GNEJunction *junction, GNEUndoList *undoList)
A road/street connecting two junctions (netedit-version)
void reserveJunctionID(const std::string &id)
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
void add(SUMOReal x, SUMOReal y)
Makes the boundary include the given coordinate.
void setResponsible(bool newVal)
set responsibility for deleting internal strctures
static int _2int(const E *const data)
void deleteSingleJunction(GNEJunction *junction)
deletes a single junction
NBNode * getToNode() const
Returns the destination node of the edge.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
bool deleteGeometry(const Position &pos, GNEUndoList *undoList)
deletes the closest geometry node within SNAP_RADIUS.
std::vector< GNEEdge * > retrieveEdges(bool onlySelected=false)
return all edges
GNEEdge * registerEdge(GNEEdge *edge)
registers an edge with GNENet containers
virtual void setMicrosimID(const std::string &newID)
Changes the microsimID of the object (happens in NETEDIT)
NBNodeCont & getNodeCont()
Returns the node container.
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)
GNENet(NBNetBuilder *netBuilder)
Constructor.
Boundary getBoundary() const
Returns the boundary of the junction.
Instance responsible for building networks.
friend class GNEChange_Junction
void removeSolitaryJunctions(GNEUndoList *undoList)
std::vector< NBEdge * > EdgeVector
void analyzeCluster(std::set< NBNode * > cluster, std::string &id, Position &pos, bool &hasTLS, TrafficLightType &type)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
void move(Position pos)
reposition the node at pos and informs the edges
A storage for options typed value containers)
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
GNEJunction * getDest() const
returns the destination-junction
void renameEdge(GNEEdge *edge, const std::string &newID)
updates the map and reserves new id
void deleteJunction(GNEJunction *junction, GNEUndoList *undoList)
removes junction and all incident edges
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
void removeExplicitTurnaround(std::string id)
remove edge id from the list of explicit turnarounds
Represents a single node (junction) during network building.
void saveJoined(OptionsCont &oc)
save log of joined junctions (and nothing else)
Lane & getLaneStruct(unsigned int lane)
GNEEdge * addReversedEdge(GNEEdge *edge, GNEUndoList *undoList)
add reversed edge
void move2side(SUMOReal amount)
static const RGBColor selectionColor
void unblockObject(GUIGlID id)
Marks an object as unblocked.
void reserveEdgeID(const std::string &id)
void deleteSingleEdge(GNEEdge *edge)
deletes a single edge
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Container for nodes during the netbuilding process.
void mergeJunctions(GNEJunction *moved, GNEJunction *target, GNEUndoList *undoList)
merge the given junctions edges between the given junctions will be deleted
bool extract(NBNode *node, bool remember=false)
Removes the given node but does not delete it.
#define WRITE_MESSAGE(msg)
GUIGlObject * getObjectBlocking(GUIGlID id)
Returns the object from the container locking it.
NBDistrictCont & getDistrictCont()
Returns the districts container.
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
GUISelectedStorage gSelected
A global holder of selected objects.
A window containing a gl-object's parameter.
void changeEdgeEndpoints(GNEEdge *edge, const std::string &newSourceID, const std::string &newDestID)
modifies endpoins of the given edge
bool wasSplit()
whether this edge was created from a split
void setStatusBarText(const std::string &)
GNEJunction * getSource() const
returns the source-junction
void savePlain(OptionsCont &oc)
save plain xml representation of the network (and nothing else)
void requireRecompute()
inform the net about the need for recomputation
virtual void setTLControllingInformation() const =0
Informs edges about being controlled by a tls.
static const SUMOReal Z_INITIALIZED
marker for whether the z-boundary is initialized
void duplicateLane(GNELane *lane, GNEUndoList *undoList)
duplicates lane
void append(const PositionVector &v, SUMOReal sameThreshold=2.0)
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
void registerJoinedCluster(const std::set< NBNode * > &cluster)
gets all joined clusters (see doc for myClusters2Join)
void finishMoveSelection(GNEUndoList *undoList)
register changes to junction and edge positions with the undoList
NBNode * getFromNode() const
Returns the origin node of the edge.