source: josm/trunk/src/org/openstreetmap/josm/actions/MergeNodesAction.java@ 5132

Last change on this file since 5132 was 5132, checked in by simon04, 12 years ago

fix #7513 - Warn non-experts when combining ways with conflicting tags or ways being part of relations
  • Property svn:eol-style set to native
File size: 12.9 KB
Line 
1//License: GPL. Copyright 2007 by Immanuel Scholz and others. See LICENSE file for details.
2package org.openstreetmap.josm.actions;
3
4import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.event.ActionEvent;
8import java.awt.event.KeyEvent;
9import java.util.ArrayList;
10import java.util.Collection;
11import java.util.Collections;
12import java.util.HashSet;
13import java.util.LinkedList;
14import java.util.List;
15import java.util.Set;
16
17import javax.swing.JOptionPane;
18
19import org.openstreetmap.josm.Main;
20import org.openstreetmap.josm.command.ChangeCommand;
21import org.openstreetmap.josm.command.ChangeNodesCommand;
22import org.openstreetmap.josm.command.Command;
23import org.openstreetmap.josm.command.DeleteCommand;
24import org.openstreetmap.josm.command.SequenceCommand;
25import org.openstreetmap.josm.corrector.UserCancelException;
26import org.openstreetmap.josm.data.coor.EastNorth;
27import org.openstreetmap.josm.data.coor.LatLon;
28import org.openstreetmap.josm.data.osm.Node;
29import org.openstreetmap.josm.data.osm.OsmPrimitive;
30import org.openstreetmap.josm.data.osm.RelationToChildReference;
31import org.openstreetmap.josm.data.osm.TagCollection;
32import org.openstreetmap.josm.data.osm.Way;
33import org.openstreetmap.josm.gui.DefaultNameFormatter;
34import org.openstreetmap.josm.gui.HelpAwareOptionPane;
35import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
36import org.openstreetmap.josm.gui.conflict.tags.CombinePrimitiveResolverDialog;
37import org.openstreetmap.josm.gui.layer.OsmDataLayer;
38import org.openstreetmap.josm.tools.CheckParameterUtil;
39import org.openstreetmap.josm.tools.ImageProvider;
40import org.openstreetmap.josm.tools.Shortcut;
41
42/**
43 * Merges a collection of nodes into one node.
44 *
45 * The "surviving" node will be the one with the lowest positive id.
46 * (I.e. it was uploaded to the server and is the oldest one.)
47 *
48 * However we use the location of the node that was selected *last*.
49 * The "surviving" node will be moved to that location if it is
50 * different from the last selected node.
51 */
52public class MergeNodesAction extends JosmAction {
53
54 public MergeNodesAction() {
55 super(tr("Merge Nodes"), "mergenodes", tr("Merge nodes into the oldest one."),
56 Shortcut.registerShortcut("tools:mergenodes", tr("Tool: {0}", tr("Merge Nodes")), KeyEvent.VK_M, Shortcut.DIRECT), true);
57 putValue("help", ht("/Action/MergeNodes"));
58 }
59
60 public void actionPerformed(ActionEvent event) {
61 if (!isEnabled())
62 return;
63 Collection<OsmPrimitive> selection = getCurrentDataSet().getSelected();
64 List<Node> selectedNodes = OsmPrimitive.getFilteredList(selection, Node.class);
65
66 if (selectedNodes.size() == 1) {
67 List<Node> nearestNodes = Main.map.mapView.getNearestNodes(Main.map.mapView.getPoint(selectedNodes.get(0)), selectedNodes, OsmPrimitive.isUsablePredicate);
68 if (nearestNodes.isEmpty()) {
69 JOptionPane.showMessageDialog(
70 Main.parent,
71 tr("Please select at least two nodes to merge or a node that is close to another node."),
72 tr("Warning"),
73 JOptionPane.WARNING_MESSAGE
74 );
75
76 return;
77 }
78 selectedNodes.addAll(nearestNodes);
79 }
80
81 Node targetNode = selectTargetNode(selectedNodes);
82 Node targetLocationNode = selectTargetLocationNode(selectedNodes);
83 Command cmd = mergeNodes(Main.main.getEditLayer(), selectedNodes, targetNode, targetLocationNode);
84 if (cmd != null) {
85 Main.main.undoRedo.add(cmd);
86 Main.main.getEditLayer().data.setSelected(targetNode);
87 }
88 }
89
90 /**
91 * Select the location of the target node after merge.
92 *
93 * @param candidates the collection of candidate nodes
94 * @return the coordinates of this node are later used for the target node
95 */
96 public static Node selectTargetLocationNode(List<Node> candidates) {
97 int size = candidates.size();
98 if (size == 0)
99 throw new IllegalArgumentException("empty list");
100
101 switch (Main.pref.getInteger("merge-nodes.mode", 0)) {
102 case 0: {
103 Node targetNode = candidates.get(size - 1);
104 for (final Node n : candidates) { // pick last one
105 targetNode = n;
106 }
107 return targetNode;
108 }
109 case 1: {
110 double east = 0, north = 0;
111 for (final Node n : candidates) {
112 east += n.getEastNorth().east();
113 north += n.getEastNorth().north();
114 }
115
116 return new Node(new EastNorth(east / size, north / size));
117 }
118 case 2: {
119 final double[] weights = new double[size];
120
121 for (int i = 0; i < size; i++) {
122 final LatLon c1 = candidates.get(i).getCoor();
123 for (int j = i + 1; j < size; j++) {
124 final LatLon c2 = candidates.get(j).getCoor();
125 final double d = c1.distance(c2);
126 weights[i] += d;
127 weights[j] += d;
128 }
129 }
130
131 double east = 0, north = 0, weight = 0;
132 for (int i = 0; i < size; i++) {
133 final EastNorth en = candidates.get(i).getEastNorth();
134 final double w = weights[i];
135 east += en.east() * w;
136 north += en.north() * w;
137 weight += w;
138 }
139
140 return new Node(new EastNorth(east / weight, north / weight));
141 }
142 default:
143 throw new RuntimeException("unacceptable merge-nodes.mode");
144 }
145
146 }
147
148 /**
149 * Find which node to merge into (i.e. which one will be left)
150 *
151 * @param candidates the collection of candidate nodes
152 * @return the selected target node
153 */
154 public static Node selectTargetNode(List<Node> candidates) {
155 Node targetNode = null;
156 Node lastNode = null;
157 for (Node n : candidates) {
158 if (!n.isNew()) {
159 if (targetNode == null) {
160 targetNode = n;
161 } else if (n.getId() < targetNode.getId()) {
162 targetNode = n;
163 }
164 }
165 lastNode = n;
166 }
167 if (targetNode == null) {
168 targetNode = lastNode;
169 }
170 return targetNode;
171 }
172
173
174 /**
175 * Fixes the parent ways referring to one of the nodes.
176 *
177 * Replies null, if the ways could not be fixed, i.e. because a way would have to be deleted
178 * which is referred to by a relation.
179 *
180 * @param nodesToDelete the collection of nodes to be deleted
181 * @param targetNode the target node the other nodes are merged to
182 * @return a list of commands; null, if the ways could not be fixed
183 */
184 protected static List<Command> fixParentWays(Collection<Node> nodesToDelete, Node targetNode) {
185 List<Command> cmds = new ArrayList<Command>();
186 Set<Way> waysToDelete = new HashSet<Way>();
187
188 for (Way w: OsmPrimitive.getFilteredList(OsmPrimitive.getReferrer(nodesToDelete), Way.class)) {
189 ArrayList<Node> newNodes = new ArrayList<Node>(w.getNodesCount());
190 for (Node n: w.getNodes()) {
191 if (! nodesToDelete.contains(n) && n != targetNode) {
192 newNodes.add(n);
193 } else if (newNodes.isEmpty()) {
194 newNodes.add(targetNode);
195 } else if (newNodes.get(newNodes.size()-1) != targetNode) {
196 // make sure we collapse a sequence of deleted nodes
197 // to exactly one occurrence of the merged target node
198 //
199 newNodes.add(targetNode);
200 } else {
201 // drop the node
202 }
203 }
204 if (newNodes.size() < 2) {
205 if (w.getReferrers().isEmpty()) {
206 waysToDelete.add(w);
207 } else {
208 ButtonSpec[] options = new ButtonSpec[] {
209 new ButtonSpec(
210 tr("Abort Merging"),
211 ImageProvider.get("cancel"),
212 tr("Click to abort merging nodes"),
213 null /* no special help topic */
214 )
215 };
216 HelpAwareOptionPane.showOptionDialog(
217 Main.parent,
218 tr("Cannot merge nodes: Would have to delete way {0} which is still used by {1}",
219 DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(w),
220 DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(w.getReferrers())),
221 tr("Warning"),
222 JOptionPane.WARNING_MESSAGE,
223 null, /* no icon */
224 options,
225 options[0],
226 ht("/Action/MergeNodes#WaysToDeleteStillInUse")
227 );
228 return null;
229 }
230 } else if(newNodes.size() < 2 && w.getReferrers().isEmpty()) {
231 waysToDelete.add(w);
232 } else {
233 cmds.add(new ChangeNodesCommand(w, newNodes));
234 }
235 }
236 if (!waysToDelete.isEmpty()) {
237 cmds.add(new DeleteCommand(waysToDelete));
238 }
239 return cmds;
240 }
241
242 public static Command mergeNodes(OsmDataLayer layer, Collection<Node> nodes, Node targetNode) {
243 return mergeNodes(layer, nodes, targetNode, targetNode);
244 }
245
246 /**
247 * Merges the nodes in <code>nodes</code> onto one of the nodes. Uses the dataset
248 * managed by <code>layer</code> as reference.
249 *
250 * @param layer layer the reference data layer. Must not be null.
251 * @param nodes the collection of nodes. Ignored if null.
252 * @param targetNode the target node the collection of nodes is merged to. Must not be null.
253 * @param targetLocationNode this node's location will be used for the targetNode.
254 * @throw IllegalArgumentException thrown if layer is null
255 */
256 public static Command mergeNodes(OsmDataLayer layer, Collection<Node> nodes, Node targetNode, Node targetLocationNode) {
257 CheckParameterUtil.ensureParameterNotNull(layer, "layer");
258 CheckParameterUtil.ensureParameterNotNull(targetNode, "targetNode");
259 if (nodes == null) {
260 return null;
261 }
262
263 Set<RelationToChildReference> relationToNodeReferences = RelationToChildReference.getRelationToChildReferences(nodes);
264
265 try {
266 TagCollection nodeTags = TagCollection.unionOfAllPrimitives(nodes);
267 List<Command> resultion = CombinePrimitiveResolverDialog.launchIfNecessary(nodeTags, nodes, Collections.singleton(targetNode));
268 LinkedList<Command> cmds = new LinkedList<Command>();
269
270 // the nodes we will have to delete
271 //
272 Collection<Node> nodesToDelete = new HashSet<Node>(nodes);
273 nodesToDelete.remove(targetNode);
274
275 // fix the ways referring to at least one of the merged nodes
276 //
277 Collection<Way> waysToDelete = new HashSet<Way>();
278 List<Command> wayFixCommands = fixParentWays(
279 nodesToDelete,
280 targetNode);
281 if (wayFixCommands == null) {
282 return null;
283 }
284 cmds.addAll(wayFixCommands);
285
286 // build the commands
287 //
288 if (targetNode != targetLocationNode) {
289 Node newTargetNode = new Node(targetNode);
290 newTargetNode.setCoor(targetLocationNode.getCoor());
291 cmds.add(new ChangeCommand(targetNode, newTargetNode));
292 }
293 cmds.addAll(resultion);
294 if (!nodesToDelete.isEmpty()) {
295 cmds.add(new DeleteCommand(nodesToDelete));
296 }
297 if (!waysToDelete.isEmpty()) {
298 cmds.add(new DeleteCommand(waysToDelete));
299 }
300 Command cmd = new SequenceCommand(tr("Merge {0} nodes", nodes.size()), cmds);
301 return cmd;
302 } catch (UserCancelException ex) {
303 return null;
304 }
305 }
306
307 @Override
308 protected void updateEnabledState() {
309 if (getCurrentDataSet() == null) {
310 setEnabled(false);
311 } else {
312 updateEnabledState(getCurrentDataSet().getSelected());
313 }
314 }
315
316 @Override
317 protected void updateEnabledState(Collection<? extends OsmPrimitive> selection) {
318 if (selection == null || selection.isEmpty()) {
319 setEnabled(false);
320 return;
321 }
322 boolean ok = true;
323 for (OsmPrimitive osm : selection) {
324 if (!(osm instanceof Node)) {
325 ok = false;
326 break;
327 }
328 }
329 setEnabled(ok);
330 }
331}
Note: See TracBrowser for help on using the repository browser.