Ticket #10744: josm-7155-ease-multipolygon-handling-and-creation.patch

src/org/openstreetmap/josm/actions/SplitWayAction.java

@@ -60 +60 @@
          * @param command The command to be performed to split the way (which is saved for later retrieval by the {@link #getCommand} method)
          * @param newSelection The new list of selected primitives ids (which is saved for later retrieval by the {@link #getNewSelection} method)
          * @param originalWay The original way being split (which is saved for later retrieval by the {@link #getOriginalWay} method)
-         * @param newWays The resulting new ways (which is saved for later retrieval by the {@link #getOriginalWay} method)
+         * @param newWays The resulting new ways (which is saved for later retrieval by the {@link #getNewWays} method)
          */
         public SplitWayResult(Command command, List<? extends PrimitiveId> newSelection, Way originalWay, List<Way> newWays) {
             this.command = command;
@@ -100 +100 @@
         public List<Way> getNewWays() {
             return newWays;
         }
+
+        /**
+         * Replies the resulting new ways and the original way
+         * @return All resulting ways
+         */
+        public List<Way> getAllWays() {
+            List<Way> ret = new ArrayList<>();
+            ret.add(originalWay);
+            ret.addAll(newWays);
+            return ret;
+        }
     }
 
     /**
@@ -249 +260 @@
      * Splits the nodes of {@code wayToSplit} into a list of node sequences
      * which are separated at the nodes in {@code splitPoints}.
      *
-     * This method displays warning messages if {@code wayToSplit} and/or
-     * {@code splitPoints} aren't consistent.
+     * This method does not hog the GUI thread.
      *
-     * Returns null, if building the split chunks fails.
-     *
      * @param wayToSplit the way to split. Must not be null.
      * @param splitPoints the nodes where the way is split. Must not be null.
      * @return the list of chunks
      */
-    public static List<List<Node>> buildSplitChunks(Way wayToSplit, List<Node> splitPoints){
+    public static List<List<Node>> buildSplitChunksNoGUI(Way wayToSplit, Collection<Node> splitPoints){
         CheckParameterUtil.ensureParameterNotNull(wayToSplit, "wayToSplit");
         CheckParameterUtil.ensureParameterNotNull(splitPoints, "splitPoints");
 
@@ -289 +297 @@
                 && wayChunks.get(0).get(0) == lastWayChunk.get(lastWayChunk.size() - 1)
                 && !nodeSet.contains(wayChunks.get(0).get(0))) {
             if (wayChunks.size() == 2) {
-                new Notification(
-                        tr("You must select two or more nodes to split a circular way."))
-                        .setIcon(JOptionPane.WARNING_MESSAGE)
-                        .show();
-                return null;
+                wayChunks.get(0).set(wayChunks.get(0).size() - 1, wayChunks.get(0).get(0));
+                wayChunks.remove(1);
+                return wayChunks;
             }
             lastWayChunk.remove(lastWayChunk.size() - 1);
             lastWayChunk.addAll(wayChunks.get(0));
@@ -301 +307 @@
             wayChunks.set(0, lastWayChunk);
         }
 
+        return wayChunks;
+    }
+
+    /**
+     * Splits the nodes of {@code wayToSplit} into a list of node sequences
+     * which are separated at the nodes in {@code splitPoints}.
+     *
+     * This method displays warning messages if {@code wayToSplit} and/or
+     * {@code splitPoints} aren't consistent.
+     *
+     * Returns null, if building the split chunks fails.
+     *
+     * @param wayToSplit the way to split. Must not be null.
+     * @param splitPoints the nodes where the way is split. Must not be null.
+     * @return the list of chunks
+     */
+    public static List<List<Node>> buildSplitChunks(Way wayToSplit, List<Node> splitPoints) {
+        List<List<Node>> wayChunks = buildSplitChunksNoGUI(wayToSplit, splitPoints);
+
         if (wayChunks.size() < 2) {
             if (wayChunks.get(0).get(0) == wayChunks.get(0).get(wayChunks.get(0).size() - 1)) {
                 new Notification(
@@ -313 +338 @@
                         .setIcon(JOptionPane.WARNING_MESSAGE)
                         .show();
             }
-            return null;
         }
-        return wayChunks;
+
+        return (wayChunks.size() < 2) ? null : wayChunks;
     }
 
     /**
@@ -333 +358 @@
      * @return the result from the split operation
      */
     public static SplitWayResult splitWay(OsmDataLayer layer, Way way, List<List<Node>> wayChunks, Collection<? extends OsmPrimitive> selection) {
+        if (selection == null) selection = new ArrayList<>();
+
         // build a list of commands, and also a new selection list
         Collection<Command> commandList = new ArrayList<>(wayChunks.size());
         List<OsmPrimitive> newSelection = new ArrayList<>(selection.size() + wayChunks.size());
@@ -527 +554 @@
     public static SplitWayResult split(OsmDataLayer layer, Way way, List<Node> atNodes, Collection<? extends OsmPrimitive> selection) {
         List<List<Node>> chunks = buildSplitChunks(way, atNodes);
         if (chunks == null) return null;
-        return splitWay(layer,way, chunks, selection);
+        return splitWay(layer, way, chunks, selection);
     }
 
     @Override

src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java

@@ -8 +8 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
@@ -16 +18 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.SplitWayAction;
+import org.openstreetmap.josm.actions.SplitWayAction.SplitWayResult;
+import org.openstreetmap.josm.command.DeleteCommand;
 import org.openstreetmap.josm.tools.Geometry;
 import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
 import org.openstreetmap.josm.tools.MultiMap;
 import org.openstreetmap.josm.tools.Pair;
+import org.openstreetmap.josm.tools.Predicate;
 import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -129 +136 @@
     }
 
     /**
-     * Splits ways into inner and outer JoinedWays. Sets {@link #innerWays} and {@link #outerWays} to the result.
+     * Separate ways into inner and outer JoinedWays. Sets {@link #innerWays} and {@link #outerWays} to the result.
      * TODO: Currently cannot process touching polygons. See code in JoinAreasAction.
      * @param ways ways to analyze
-     * @return error description if the ways cannot be split, {@code null} if all fine.
+     * @return error description if the ways cannot be separated, {@code null} if all fine.
      */
     public String makeFromWays(Collection<Way> ways) {
         try {
             List<JoinedPolygon> joinedWays = joinWays(ways);
-            //analyze witch way is inside witch outside.
+            //analyze which way is inside which outside.
             return makeFromPolygons(joinedWays);
         } catch (JoinedPolygonCreationException ex) {
             return ex.getMessage();
@@ -159 +166 @@
     }
 
     /**
+     * Replies the current dataset
+     *
+     * @return the current dataset. null, if no current dataset exists
+     */
+    protected static DataSet getCurrentDataSet() {
+        return Main.main != null ? Main.main.getCurrentDataSet() : null;
+    }
+
+    /**
      * Joins the given {@code ways} to multipolygon rings.
      * @param ways the ways to join.
      * @return a list of multipolygon rings.
@@ -167 +183 @@
     public static List<JoinedPolygon> joinWays(Collection<Way> ways) throws JoinedPolygonCreationException {
         List<JoinedPolygon> joinedWays = new ArrayList<>();
 
+        { /* code block to ease the pain in MP handling - looks for overlapped ways that
+           * already are in another _MP_ relation and tries its best to reuse segments.
+           * it does auto-splitting and -selection and exclusively deletes unneeded parts
+           * from the original selection. these parts are replaced by reusable way segments.
+           * consecutively used, overlapping ways should disappear for adjacent MP areas.
+           */
+        final Map<Way, Set<Node>> splits = new HashMap<>();
+        final Set<Node> ways_nodes = new HashSet<>();
+        for (final Way w: ways) {
+            ways_nodes.addAll(w.getNodes());
+
+            for (final Pair<Node,Node> p: w.getNodePairs(false)) {
+                Collection<Way> dups = Utils.filter(
+                    OsmPrimitive.getFilteredList(p.b.getReferrers(), Way.class),
+                    new Predicate<Way>() {
+                        public boolean evaluate(final Way v) {
+                            return v.equals(w) || v.containsNode(p.a) && Utils.exists(
+                                OsmPrimitive.getFilteredList(v.getReferrers(), Relation.class),
+                                new Predicate<Relation>() {
+                                    public boolean evaluate(final Relation r) {
+                                        return r.hasTag("type", "multipolygon");
+                                    }
+                                }
+                            );
+                        }
+                    }
+                );
+
+                // TODO: handle (rare?) cases where dups.size() > 2 applies or stop and warn user
+                if (dups.size() > 1) {
+                    for (Way d: dups) {
+                        if (!splits.containsKey(d)) {
+                            splits.put(d, new HashSet<Node>());
+                        }
+                        for (Node n: Pair.toArrayList(p)) {
+                            if (splits.get(d).contains(n)) {
+                                splits.get(d).remove(n);
+                            } else {
+                                splits.get(d).add(n);
+                            }
+                        }
+                    }
+                }
+
+            }
+        }
+
+        ways = new ArrayList<>(ways);
+
+        final List<Way> reuse = new ArrayList<>();
+        for (final Way d: splits.keySet()) {
+            List<List<Node>> chunks =
+                SplitWayAction.buildSplitChunksNoGUI(d, splits.get(d));
+
+            if (chunks.size() > 1) {
+                SplitWayResult r = SplitWayAction.splitWay(Main.main.getEditLayer(), d, chunks, null);
+                Main.main.undoRedo.addNoRedraw(r.getCommand());
+
+                if (ways.contains(r.getOriginalWay())) {
+                    ways.addAll(r.getNewWays());
+                } else {
+                    reuse.addAll(Utils.filter(r.getAllWays(), new Predicate<Way>() {
+                        public boolean evaluate(final Way w) {
+                            return ways_nodes.containsAll(w.getNodes());
+                        }
+                    }));
+                }
+            } else if (!ways.contains(d)) {
+                reuse.add(d);
+            }
+        }
+
+        final Set<Node> reuse_nodes = new HashSet<>();
+        for (final Way w: reuse) {
+            reuse_nodes.addAll(w.getNodes());
+        }
+
+        Collection<Way> dups = new ArrayList<>(Utils.filter(ways, new Predicate<Way>() {
+            public boolean evaluate(final Way w) {
+                return reuse_nodes.containsAll(w.getNodes());
+            }
+        }));
+
+        Main.debug(ways.toString() +"\n  --> original way collection\n");
+        if (!dups.isEmpty()) {
+            Main.debug(dups.toString() +"\n  --> split dups about to be deleted\n");
+            Main.debug(reuse.toString()+"\n  --> reusable ways detected\n");
+
+            ways.removeAll(dups);
+            ways.addAll(reuse);
+            Main.main.undoRedo.addNoRedraw(DeleteCommand.delete(Main.main.getEditLayer(), dups));
+
+            Main.debug(ways.toString() +"\n  --> modified way collection to be joined\n");
+        }
+        } /* end code block to ease the pain in MP handling */
+
         //collect ways connecting to each node.
         MultiMap<Node, Way> nodesWithConnectedWays = new MultiMap<>();
         Set<Way> usedWays = new HashSet<>();