Changeset 5076 in osm for applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/MergeNodesAction.java

Timestamp:

2007-10-19T00:13:15+02:00 (18 years ago)

Author:

gabriel

Message:

utilsplugin: Port to API 0.5.

Location:

applications/editors/josm/plugins/utilsplugin/src

Files:

• . (added)
• UtilsPlugin (added)
• UtilsPlugin/MergeNodesAction.java (copied) (copied from applications/editors/josm/plugins/utilsplugin/UtilsPlugin/MergePointsAction.java ) (3 diffs)

applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/MergeNodesAction.java

@@ -4 +4 @@
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.Collection;
+import java.util.Collections;
 
 import java.awt.event.ActionEvent;
@@ -13 +13 @@
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
+import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.plugins.Plugin;
+import org.openstreetmap.josm.actions.JosmAction;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.command.AddCommand;
@@ -24 +26 @@
 
 import javax.swing.AbstractAction;
+import javax.swing.JOptionPane;
 
-class MergePointsAction extends AbstractAction {
-        public MergePointsAction() {
-                super("Merge Points");
+class MergeNodesAction extends JosmAction {
+        public MergeNodesAction() {
+                super(tr("Merge nodes"), "mergenodes",
+                        tr("Merge nodes"), 0, 0, true);
         }
+
         public void actionPerformed(ActionEvent e) {
                 Collection<OsmPrimitive> sel = Main.ds.getSelected();
-                Collection<OsmPrimitive> nodes = new ArrayList<OsmPrimitive>();
-                Node target = null;
+                Collection<Node> nodes = new ArrayList<Node>();
+
                 for (OsmPrimitive osm : sel)
                         if (osm instanceof Node)
                                 nodes.add((Node)osm);
                 if (nodes.size() < 2) {
-                        javax.swing.JOptionPane.showMessageDialog(Main.parent, tr("Must select at least two nodes."));
+                        JOptionPane.showMessageDialog(Main.parent,
+                                tr("Must select at least two nodes."));
                         return;
                 }
-                for ( OsmPrimitive o : nodes )
-                {
-                        Node n = (Node)o;
-                        if( target == null || target.id == 0 )
-                        {
+
+                // Find the node with the lowest ID.
+                // We're gonna keep our 3-digit node ids.
+                Node target = null;
+                for (Node n : nodes) {
+                        if (target == null || target.id == 0 || n.id < target.id) {
                                 target = n;
-                                continue;
                         }
-                        if( n.id == 0 )
-                                continue;
-                        if( n.id < target.id )
-                                target = n;
                 }
-//              System.out.println( "Selected: "+target.toString() );
+
+                Collection<Command> cmds = new LinkedList<Command>();
+
+                Node newTarget = new Node(target);
+                cmds.add(new ChangeCommand(target, newTarget));
+
+                // Don't place the merged node on one of the former nodes.
+                // Place it right there in the middle.
+                double x = 0, y = 0;
+                for (Node n : nodes) {
+                        x += n.eastNorth.east();
+                        y += n.eastNorth.north();
+                }
+                newTarget.eastNorth = new EastNorth(
+                        x / nodes.size(), y / nodes.size());
+
                 nodes.remove(target);
-                
-                // target is what we're merging into
-                // nodes is the list of nodes to be removed
-                // Since some segment may disappear, we need to track those too
-                Collection<OsmPrimitive> seglist = new ArrayList<OsmPrimitive>();
-                                
-                // Now do the merging
-                Collection<Command> cmds = new LinkedList<Command>();
-                for (final Segment s : Main.ds.segments) 
-                {
-                        if( s.deleted || s.incomplete )
-                                continue;
-                        if( !nodes.contains( s.from ) && !nodes.contains( s.to ) )
-                                continue;
-                                
-                        Segment newseg = new Segment(s);
-                        if( nodes.contains( s.from ) )
-                                newseg.from = target;
-                        if( nodes.contains( s.to ) )
-                                newseg.to = target;
 
-                        // Is this node now a NULL node?
-                        if( newseg.from == newseg.to )
-                                seglist.add(s);
-                        else
-                                cmds.add(new ChangeCommand(s,newseg));
-                }
-                if( seglist.size() > 0 )  // Some segments to be deleted?
-                {
-                        // We really want to delete this, but we must check if it is part of a way first
-                        for (final Way w : Main.ds.ways)
-                        {
-                                Way newway = null;
-                                if( w.deleted )
-                                        continue;
-                                for (final OsmPrimitive o : seglist )
-                                {
-                                        Segment s = (Segment)o;
-                                        if( w.segments.contains(s) )
-                                        {
-                                                if( newway == null )
-                                                        newway = new Way(w);
-                                                newway.segments.remove(s);
-                                        }
-                                }
-                                if( newway != null )   // Made changes?
-                                {
-                                        // If no segments left, delete the way
-                                        if( newway.segments.size() == 0 )
-                                                cmds.add(makeDeleteCommand(w));
-                                        else
-                                                cmds.add(new ChangeCommand(w,newway));
+                cmds.add(new DeleteCommand(nodes));
+
+                for (Way w : Main.ds.ways) {
+                        if (w.deleted || w.incomplete) continue;
+
+                        boolean affected = false;
+                        for (Node n : nodes) {
+                                if (w.nodes.contains(n)) {
+                                        affected = true;
+                                        break;
                                 }
                         }
-                        cmds.add(new DeleteCommand(seglist));
+                        if (!affected) continue;
+
+                        // Replace the old nodes with the merged ones
+                        Way wnew = new Way(w);
+                        for (int i = 0; i < wnew.nodes.size(); i++) {
+                                if (nodes.contains(wnew.nodes.get(i))) {
+                                        wnew.nodes.set(i, newTarget);
+                                }
+                        }
+
+                        // Remove duplicates
+                        Node lastN = null;
+                        for (int i = wnew.nodes.size() - 1; i >= 0; i--) {
+                                if (lastN == wnew.nodes.get(i)) {
+                                        wnew.nodes.remove(i);
+                                        if (i < wnew.nodes.size()) i++;
+                                }
+                        }
+
+                        if (wnew.nodes.size() < 2) {
+                                CollectBackReferencesVisitor backRefV =
+                                        new CollectBackReferencesVisitor(Main.ds, false);
+                                backRefV.visit(w);
+                                if (!backRefV.data.isEmpty()) {
+                                        JOptionPane.showMessageDialog(Main.parent,
+                                                tr("Cannot merge nodes: " +
+                                                        "Would have to delete way that is still used."));
+                                        return;
+                                }
+
+                                cmds.add(new DeleteCommand(Collections.singleton(w)));
+                        } else {
+                                cmds.add(new ChangeCommand(w, wnew));
+                        }
                 }
 
-                cmds.add(new DeleteCommand(nodes));
-                Main.main.editLayer().add(new SequenceCommand(tr("Merge Nodes"), cmds));
+                Main.main.undoRedo.add(new SequenceCommand(tr("Merge Nodes"), cmds));
                 Main.map.repaint();
         }
-        private DeleteCommand makeDeleteCommand(OsmPrimitive obj)
-        {
-          return new DeleteCommand(Arrays.asList(new OsmPrimitive[]{obj}));
-        }
 }
-