source: osm/applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java@ 36407

Last change on this file since 36407 was 36134, checked in by taylor.smock, 19 months ago

Use DeleteCommand.delete where possible and fix some potential NPEs from its usage
File size: 19.4 KB
Line 
1package mergeoverlap;
2
3import static org.openstreetmap.josm.gui.conflict.tags.TagConflictResolutionUtil.applyAutomaticTagConflictResolution;
4import static org.openstreetmap.josm.gui.conflict.tags.TagConflictResolutionUtil.completeTagCollectionForEditing;
5import static org.openstreetmap.josm.gui.conflict.tags.TagConflictResolutionUtil.normalizeTagCollectionBeforeEditing;
6import static org.openstreetmap.josm.tools.I18n.tr;
7
8import java.awt.event.ActionEvent;
9import java.awt.event.KeyEvent;
10import java.util.ArrayList;
11import java.util.Collection;
12import java.util.Collections;
13import java.util.HashMap;
14import java.util.HashSet;
15import java.util.LinkedHashSet;
16import java.util.LinkedList;
17import java.util.List;
18import java.util.Map;
19import java.util.Set;
20
21import org.openstreetmap.josm.actions.JosmAction;
22import org.openstreetmap.josm.actions.corrector.ReverseWayTagCorrector;
23import org.openstreetmap.josm.command.ChangeCommand;
24import org.openstreetmap.josm.command.Command;
25import org.openstreetmap.josm.command.DeleteCommand;
26import org.openstreetmap.josm.command.SequenceCommand;
27import org.openstreetmap.josm.command.SplitWayCommand;
28import org.openstreetmap.josm.data.UndoRedoHandler;
29import org.openstreetmap.josm.data.osm.Node;
30import org.openstreetmap.josm.data.osm.NodeGraph;
31import org.openstreetmap.josm.data.osm.OsmPrimitive;
32import org.openstreetmap.josm.data.osm.Relation;
33import org.openstreetmap.josm.data.osm.TagCollection;
34import org.openstreetmap.josm.data.osm.Way;
35import org.openstreetmap.josm.gui.MainApplication;
36import org.openstreetmap.josm.tools.Logging;
37import org.openstreetmap.josm.tools.Pair;
38import org.openstreetmap.josm.tools.Shortcut;
39import org.openstreetmap.josm.tools.UserCancelException;
40import org.openstreetmap.josm.tools.Utils;
41
42import mergeoverlap.hack.MyCombinePrimitiveResolverDialog;
43
44/**
45 * Merge overlapping part of ways.
46 */
47public class MergeOverlapAction extends JosmAction {
48
49 Map<Way, List<Relation>> relations = new HashMap<>();
50 Map<Way, Way> oldWays = new HashMap<>();
51 Map<Relation, Relation> newRelations = new HashMap<>();
52 Set<Way> deletes = new HashSet<>();
53
54 /**
55 * Constructs a new {@code MergeOverlapAction}.
56 */
57 public MergeOverlapAction() {
58 super(tr("Merge overlap"), "merge_overlap",
59 tr("Merge overlap of ways."),
60 Shortcut.registerShortcut("tools:mergeoverlap",tr("More tools: {0}", tr("Merge overlap")), KeyEvent.VK_O,
61 Shortcut.ALT_CTRL), true);
62 }
63
64 /**
65 * The action button has been clicked
66 *
67 * @param e
68 * Action Event
69 */
70 @Override
71 public void actionPerformed(ActionEvent e) {
72
73 // List of selected ways
74 List<Way> ways = new ArrayList<>();
75 relations.clear();
76 newRelations.clear();
77
78 // For every selected way
79 for (OsmPrimitive osm : getLayerManager().getEditDataSet().getSelected()) {
80 if (osm instanceof Way && !osm.isDeleted()) {
81 Way way = (Way) osm;
82 ways.add(way);
83 List<Relation> rels = new ArrayList<>(Utils.filteredCollection(way.getReferrers(), Relation.class));
84 relations.put(way, rels);
85 }
86 }
87
88 List<Way> sel = new ArrayList<>(ways);
89 Collection<Command> cmds = new LinkedList<>();
90
91 // *****
92 // split
93 // *****
94 for (Way way : ways) {
95 Set<Node> nodes = new HashSet<>();
96 for (Way opositWay : ways) {
97 if (way != opositWay) {
98 List<NodePos> nodesPos = new LinkedList<>();
99
100 int pos = 0;
101 for (Node node : way.getNodes()) {
102 int opositPos = 0;
103 for (Node opositNode : opositWay.getNodes()) {
104 if (node == opositNode) {
105 if (opositWay.isClosed()) {
106 opositPos %= opositWay.getNodesCount() - 1;
107 }
108 nodesPos.add(new NodePos(node, pos, opositPos));
109 break;
110 }
111 opositPos++;
112 }
113 pos++;
114 }
115
116 NodePos start = null;
117 NodePos end = null;
118 int increment = 0;
119
120 boolean hasFirst = false;
121 for (NodePos node : nodesPos) {
122 if (start == null) {
123 start = node;
124 } else {
125 if (end == null) {
126 if (follows(way, opositWay, start, node, 1)) {
127 end = node;
128 increment = +1;
129 } else if (follows(way, opositWay, start, node, -1)) {
130 end = node;
131 increment = -1;
132 } else {
133 start = node;
134 end = null;
135 }
136 } else {
137 if (follows(way, opositWay, end, node, increment)) {
138 end = node;
139 } else {
140 hasFirst = addNodes(start, end, way, nodes, hasFirst);
141 start = node;
142 end = null;
143 }
144 }
145 }
146 }
147
148 if (start != null && end != null) {
149 hasFirst = addNodes(start, end, way, nodes, hasFirst);
150 start = null;
151 end = null;
152 }
153 }
154 }
155 if (!nodes.isEmpty() && !way.isClosed() || nodes.size() >= 2) {
156 List<List<Node>> wayChunks = SplitWayCommand.buildSplitChunks(way, new ArrayList<>(nodes));
157 SplitWayCommand result = SplitWayCommand.splitWay(way, wayChunks, Collections.emptyList());
158
159 cmds.add(result);
160 sel.remove(way);
161 sel.add(result.getOriginalWay());
162 sel.addAll(result.getNewWays());
163 List<Relation> rels = relations.remove(way);
164 relations.put(result.getOriginalWay(), rels);
165 for (Way w : result.getNewWays()) {
166 relations.put(w, rels);
167 }
168 }
169 }
170
171 // *****
172 // merge
173 // *****
174 ways = new ArrayList<>(sel);
175 while (!ways.isEmpty()) {
176 Way way = ways.get(0);
177 List<Way> combine = new ArrayList<>();
178 combine.add(way);
179 for (Way opositWay : ways) {
180 if (way != opositWay && way.getNodesCount() == opositWay.getNodesCount()) {
181 boolean equals1 = true;
182 for (int i = 0; i < way.getNodesCount(); i++) {
183 if (way.getNode(i) != opositWay.getNode(i)) {
184 equals1 = false;
185 break;
186 }
187 }
188 boolean equals2 = true;
189 for (int i = 0; i < way.getNodesCount(); i++) {
190 if (way.getNode(i) != opositWay.getNode(way.getNodesCount() - i - 1)) {
191 equals2 = false;
192 break;
193 }
194 }
195 if (equals1 || equals2) {
196 combine.add(opositWay);
197 }
198 }
199 }
200 ways.removeAll(combine);
201 if (combine.size() > 1) {
202 sel.removeAll(combine);
203 // combine
204 Pair<Way, List<Command>> combineResult;
205 try {
206 combineResult = combineWaysWorker(combine);
207 } catch (UserCancelException ex) {
208 Logging.trace(ex);
209 return;
210 }
211 sel.add(combineResult.a);
212 cmds.addAll(combineResult.b);
213 }
214 }
215
216 for (Map.Entry<Relation, Relation> entry : newRelations.entrySet()) {
217 cmds.add(new ChangeCommand(entry.getKey(), entry.getValue()));
218 }
219
220 List<Way> del = new LinkedList<>();
221 for (Way w : deletes) {
222 if (w.getDataSet() != null && !w.isDeleted()) {
223 del.add(w);
224 }
225 }
226 if (!del.isEmpty()) {
227 final Command deleteCommand = DeleteCommand.delete(del);
228 if (deleteCommand != null) {
229 cmds.add(deleteCommand);
230 }
231 }
232
233 // Commit
234 if (!cmds.isEmpty()) {
235 UndoRedoHandler.getInstance().add(new SequenceCommand(tr("Merge Overlap (combine)"), cmds));
236 getLayerManager().getEditDataSet().setSelected(sel);
237 MainApplication.getMap().repaint();
238 }
239
240 relations.clear();
241 newRelations.clear();
242 oldWays.clear();
243 }
244
245 private static class NodePos {
246 Node node;
247 int pos;
248 int opositPos;
249
250 NodePos(Node n, int p, int op) {
251 node = n;
252 pos = p;
253 opositPos = op;
254 }
255
256 @Override
257 public String toString() {
258 return "NodePos: " + pos + ", " + opositPos + ", " + node;
259 }
260 }
261
262 private static boolean addNodes(NodePos start, NodePos end, Way way,
263 Set<Node> nodes, boolean hasFirst) {
264 if (way.isClosed() || (start.node != way.getNode(0) && start.node != way.getNode(way.getNodesCount() - 1))) {
265 hasFirst = hasFirst || start.node == way.getNode(0);
266 nodes.add(start.node);
267 }
268 if (way.isClosed() || (end.node != way.getNode(0) && end.node != way.getNode(way.getNodesCount() - 1))) {
269 if (hasFirst && (end.node == way.getNode(way.getNodesCount() - 1))) {
270 nodes.remove(way.getNode(0));
271 } else {
272 nodes.add(end.node);
273 }
274 }
275 return hasFirst;
276 }
277
278 private static boolean follows(Way way1, Way way2, NodePos np1, NodePos np2,
279 int incr) {
280 if (way2.isClosed() && incr == 1 && np1.opositPos == way2.getNodesCount() - 2) {
281 return np2.pos == np1.pos + 1 && np2.opositPos == 0;
282 } else if (way2.isClosed() && incr == 1 && np1.opositPos == 0) {
283 return np2.pos == np1.pos && np2.opositPos == 0
284 || np2.pos == np1.pos + 1 && np2.opositPos == 1;
285 } else if (way2.isClosed() && incr == -1 && np1.opositPos == 0) {
286 return np2.pos == np1.pos && np2.opositPos == 0 || np2.pos == np1.pos + 1
287 && np2.opositPos == way2.getNodesCount() - 2;
288 } else {
289 return np2.pos == np1.pos + 1 && np2.opositPos == np1.opositPos + incr;
290 }
291 }
292
293 /**
294 * @param ways The ways to be combined
295 * @return null if ways cannot be combined. Otherwise returns the combined
296 * ways and the commands to combine
297 * @throws UserCancelException If the user cancelled the operation
298 */
299 private Pair<Way, List<Command>> combineWaysWorker(Collection<Way> ways) throws UserCancelException {
300
301 // prepare and clean the list of ways to combine
302 if (ways == null || ways.isEmpty())
303 return null;
304 ways.remove(null); // just in case - remove all null ways from the collection
305
306 // remove duplicates, preserving order
307 ways = new LinkedHashSet<>(ways);
308
309 // try to build a new way which includes all the combined ways
310 NodeGraph graph = NodeGraph.createUndirectedGraphFromNodeWays(ways);
311 List<Node> path = graph.buildSpanningPath();
312
313 // check whether any ways have been reversed in the process
314 // and build the collection of tags used by the ways to combine
315 TagCollection wayTags = TagCollection.unionOfAllPrimitives(ways);
316
317 List<Way> reversedWays = new LinkedList<>();
318 List<Way> unreversedWays = new LinkedList<>();
319 for (Way w : ways) {
320 if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w.getNode(1))) {
321 unreversedWays.add(w);
322 } else {
323 reversedWays.add(w);
324 }
325 }
326 // reverse path if all ways have been reversed
327 if (unreversedWays.isEmpty()) {
328 Collections.reverse(path);
329 unreversedWays = reversedWays;
330 reversedWays = null;
331 }
332 if ((reversedWays != null) && !reversedWays.isEmpty()) {
333 // filter out ways that have no direction-dependent tags
334 unreversedWays = ReverseWayTagCorrector.irreversibleWays(unreversedWays);
335 reversedWays = ReverseWayTagCorrector.irreversibleWays(reversedWays);
336 // reverse path if there are more reversed than unreversed ways with
337 // direction-dependent tags
338 if (reversedWays.size() > unreversedWays.size()) {
339 Collections.reverse(path);
340 List<Way> tempWays = unreversedWays;
341 unreversedWays = reversedWays;
342 reversedWays = tempWays;
343 }
344 // if there are still reversed ways with direction-dependent tags,
345 // reverse their tags
346 if (!reversedWays.isEmpty()) {
347 List<Way> unreversedTagWays = new ArrayList<>(ways);
348 unreversedTagWays.removeAll(reversedWays);
349 ReverseWayTagCorrector reverseWayTagCorrector = new ReverseWayTagCorrector();
350 List<Way> reversedTagWays = new ArrayList<>();
351 Collection<Command> changePropertyCommands = null;
352 for (Way w : reversedWays) {
353 Way wnew = new Way(w);
354 reversedTagWays.add(wnew);
355 changePropertyCommands = reverseWayTagCorrector.execute(w, wnew);
356 }
357 if ((changePropertyCommands != null) && !changePropertyCommands.isEmpty()) {
358 for (Command c : changePropertyCommands) {
359 c.executeCommand();
360 }
361 }
362 wayTags = TagCollection.unionOfAllPrimitives(reversedTagWays);
363 wayTags.add(TagCollection.unionOfAllPrimitives(unreversedTagWays));
364 }
365 }
366
367 // create the new way and apply the new node list
368 Way targetWay = getTargetWay(ways);
369 Way modifiedTargetWay = new Way(targetWay);
370 modifiedTargetWay.setNodes(path);
371
372 TagCollection completeWayTags = new TagCollection(wayTags);
373 applyAutomaticTagConflictResolution(completeWayTags);
374 normalizeTagCollectionBeforeEditing(completeWayTags, ways);
375 TagCollection tagsToEdit = new TagCollection(completeWayTags);
376 completeTagCollectionForEditing(tagsToEdit);
377
378 MyCombinePrimitiveResolverDialog dialog = MyCombinePrimitiveResolverDialog.getInstance();
379 dialog.getTagConflictResolverModel().populate(tagsToEdit, completeWayTags.getKeysWithMultipleValues());
380 dialog.setTargetPrimitive(targetWay);
381 Set<Relation> parentRelations = getParentRelations(ways);
382 dialog.getRelationMemberConflictResolverModel().populate(parentRelations, ways, oldWays);
383 dialog.prepareDefaultDecisions();
384
385 // resolve tag conflicts if necessary
386 if (askForMergeTag(ways) || duplicateParentRelations(ways)) {
387 dialog.setVisible(true);
388 if (!dialog.isApplied())
389 throw new UserCancelException();
390 }
391
392 List<Command> cmds = new LinkedList<>();
393 deletes.addAll(ways);
394 deletes.remove(targetWay);
395
396 cmds.add(new ChangeCommand(getLayerManager().getEditDataSet(), targetWay, modifiedTargetWay));
397 cmds.addAll(dialog.buildWayResolutionCommands());
398 dialog.buildRelationCorrespondance(newRelations, oldWays);
399
400 return new Pair<>(targetWay, cmds);
401 }
402
403 private static Way getTargetWay(Collection<Way> combinedWays) {
404 // init with an arbitrary way
405 Way targetWay = combinedWays.iterator().next();
406
407 // look for the first way already existing on the server
408 for (Way w : combinedWays) {
409 targetWay = w;
410 if (!w.isNew()) {
411 break;
412 }
413 }
414 return targetWay;
415 }
416
417 /**
418 * @return has tag to be merged (=> ask)
419 */
420 private static boolean askForMergeTag(Collection<Way> ways) {
421 for (Way way : ways) {
422 for (Way oposite : ways) {
423 for (String key : way.getKeys().keySet()) {
424 if (!"source".equals(key) && oposite.hasKey(key)
425 && !way.get(key).equals(oposite.get(key))) {
426 return true;
427 }
428 }
429 }
430 }
431 return false;
432 }
433
434 /**
435 * @return has duplicate parent relation
436 */
437 private boolean duplicateParentRelations(Collection<Way> ways) {
438 Set<Relation> duplicateRelations = new HashSet<>();
439 for (Way w : ways) {
440 List<Relation> rs = getParentRelations(w);
441 for (Relation r : rs) {
442 if (duplicateRelations.contains(r)) {
443 return true;
444 }
445 }
446 duplicateRelations.addAll(rs);
447 }
448 return false;
449 }
450
451 /**
452 * Replies the set of referring relations
453 *
454 * @return the set of referring relations
455 */
456 private List<Relation> getParentRelations(Way way) {
457 List<Relation> rels = new ArrayList<>();
458 for (Relation r : relations.get(way)) {
459 rels.add(newRelations.getOrDefault(r, r));
460 }
461 return rels;
462 }
463
464 public static Relation getNew(Relation r, Map<Relation, Relation> newRelations) {
465 if (newRelations.containsValue(r)) {
466 return r;
467 } else {
468 Relation c = new Relation(r);
469 newRelations.put(r, c);
470 return c;
471 }
472 }
473/*
474 private Way getOld(Way r) {
475 return getOld(r, oldWays);
476 }*/
477
478 public static Way getOld(Way w, Map<Way, Way> oldWays) {
479 return oldWays.getOrDefault(w, w);
480 }
481
482 /**
483 * Replies the set of referring relations
484 *
485 * @return the set of referring relations
486 */
487 private Set<Relation> getParentRelations(Collection<Way> ways) {
488 Set<Relation> ret = new HashSet<>();
489 for (Way w : ways) {
490 ret.addAll(getParentRelations(w));
491 }
492 return ret;
493 }
494
495 /** Enable this action only if something is selected */
496 @Override
497 protected void updateEnabledState() {
498 if (getLayerManager().getEditDataSet() == null) {
499 setEnabled(false);
500 } else {
501 updateEnabledState(getLayerManager().getEditDataSet().getSelected());
502 }
503 }
504
505 /** Enable this action only if something is selected */
506 @Override
507 protected void updateEnabledState(
508 Collection<? extends OsmPrimitive> selection) {
509 if (selection == null) {
510 setEnabled(false);
511 return;
512 }
513 for (OsmPrimitive primitive : selection) {
514 if (!(primitive instanceof Way) || primitive.isDeleted()) {
515 setEnabled(false);
516 return;
517 }
518 }
519 setEnabled(selection.size() >= 2);
520 }
521}
Note: See TracBrowser for help on using the repository browser.