Index: src/org/openstreetmap/josm/actions/SplitWayAction.java =================================================================== --- src/org/openstreetmap/josm/actions/SplitWayAction.java (Revision 7715) +++ src/org/openstreetmap/josm/actions/SplitWayAction.java (Arbeitskopie) @@ -60,7 +60,7 @@ * @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 newSelection, Way originalWay, List newWays) { this.command = command; @@ -100,6 +100,17 @@ public List getNewWays() { return newWays; } + + /** + * Replies the resulting new ways and the original way + * @return All resulting ways + */ + public List getAllWays() { + List ret = new ArrayList<>(); + ret.add(originalWay); + ret.addAll(newWays); + return ret; + } } /** @@ -249,16 +260,13 @@ * 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> buildSplitChunks(Way wayToSplit, List splitPoints){ + public static List> buildSplitChunksNoGUI(Way wayToSplit, Collection splitPoints){ CheckParameterUtil.ensureParameterNotNull(wayToSplit, "wayToSplit"); CheckParameterUtil.ensureParameterNotNull(splitPoints, "splitPoints"); @@ -289,11 +297,9 @@ && 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,6 +307,25 @@ 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> buildSplitChunks(Way wayToSplit, List splitPoints) { + List> 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,9 +338,9 @@ .setIcon(JOptionPane.WARNING_MESSAGE) .show(); } - return null; } - return wayChunks; + + return (wayChunks.size() < 2) ? null : wayChunks; } /** @@ -333,6 +358,8 @@ * @return the result from the split operation */ public static SplitWayResult splitWay(OsmDataLayer layer, Way way, List> wayChunks, Collection selection) { + if (selection == null) selection = new ArrayList<>(); + // build a list of commands, and also a new selection list Collection commandList = new ArrayList<>(wayChunks.size()); List newSelection = new ArrayList<>(selection.size() + wayChunks.size()); @@ -527,7 +554,7 @@ public static SplitWayResult split(OsmDataLayer layer, Way way, List atNodes, Collection selection) { List> chunks = buildSplitChunks(way, atNodes); if (chunks == null) return null; - return splitWay(layer,way, chunks, selection); + return splitWay(layer, way, chunks, selection); } @Override Index: src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java =================================================================== --- src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java (Revision 7715) +++ src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java (Arbeitskopie) @@ -8,8 +8,10 @@ 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,10 +18,15 @@ 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,15 +136,15 @@ } /** - * 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 ways) { try { List 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,6 +166,15 @@ } /** + * 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,6 +183,102 @@ public static List joinWays(Collection ways) throws JoinedPolygonCreationException { List 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> splits = new HashMap<>(); + final Set ways_nodes = new HashSet<>(); + for (final Way w: ways) { + ways_nodes.addAll(w.getNodes()); + + for (final Pair p: w.getNodePairs(false)) { + Collection dups = Utils.filter( + OsmPrimitive.getFilteredList(p.b.getReferrers(), Way.class), + new Predicate() { + public boolean evaluate(final Way v) { + return v.equals(w) || v.containsNode(p.a) && Utils.exists( + OsmPrimitive.getFilteredList(v.getReferrers(), Relation.class), + new Predicate() { + 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()); + } + 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 reuse = new ArrayList<>(); + for (final Way d: splits.keySet()) { + List> 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() { + public boolean evaluate(final Way w) { + return ways_nodes.containsAll(w.getNodes()); + } + })); + } + } else if (!ways.contains(d)) { + reuse.add(d); + } + } + + final Set reuse_nodes = new HashSet<>(); + for (final Way w: reuse) { + reuse_nodes.addAll(w.getNodes()); + } + + Collection dups = new ArrayList<>(Utils.filter(ways, new Predicate() { + 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 nodesWithConnectedWays = new MultiMap<>(); Set usedWays = new HashSet<>();