Index: applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/JoinAreasAction.java =================================================================== --- applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/JoinAreasAction.java (revision 13723) +++ applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/JoinAreasAction.java (revision 13723) @@ -0,0 +1,835 @@ +package UtilsPlugin; + +import static org.openstreetmap.josm.tools.I18n.tr; +import static org.openstreetmap.josm.tools.I18n.trn; + +import java.awt.event.ActionEvent; +import java.awt.event.KeyEvent; +import java.awt.geom.Line2D; +import java.awt.geom.Point2D; +import java.awt.GridBagLayout; +import java.awt.Point; +import java.awt.Polygon; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; + +import javax.swing.Box; +import javax.swing.JComboBox; +import javax.swing.JLabel; +import javax.swing.JOptionPane; +import javax.swing.JPanel; + +import org.openstreetmap.josm.actions.CombineWayAction; +import org.openstreetmap.josm.actions.JosmAction; +import org.openstreetmap.josm.actions.ReverseWayAction; +import org.openstreetmap.josm.actions.SplitWayAction; + +import org.openstreetmap.josm.command.AddCommand; +import org.openstreetmap.josm.command.ChangeCommand; +import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.command.DeleteCommand; +import org.openstreetmap.josm.command.SequenceCommand; + +import org.openstreetmap.josm.data.Bounds; +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.data.osm.DataSource; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.Relation; +import org.openstreetmap.josm.data.osm.RelationMember; +import org.openstreetmap.josm.data.osm.TigerUtils; +import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.osm.WaySegment; +import org.openstreetmap.josm.data.projection.Epsg4326; +import org.openstreetmap.josm.data.projection.Lambert; +import org.openstreetmap.josm.data.projection.Mercator; +import org.openstreetmap.josm.data.UndoRedoHandler; + +import org.openstreetmap.josm.gui.ExtendedDialog; +import org.openstreetmap.josm.gui.layer.OsmDataLayer; +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.tools.GBC; +import org.openstreetmap.josm.tools.Pair; +import org.openstreetmap.josm.tools.Shortcut; + +public class JoinAreasAction extends JosmAction { + // This will be used to commit commands and unite them into one large command sequence at the end + private LinkedList cmds = new LinkedList(); + private int cmdsCount = 0; + + // HelperClass + // Saves a node and two positions where to insert the node into the ways + private class NodeToSegs implements Comparable { + public int pos; + public Node n; + public double dis; + public NodeToSegs(int pos, Node n, LatLon dis) { + this.pos = pos; + this.n = n; + this.dis = n.coor.greatCircleDistance(dis); + } + + public int compareTo(NodeToSegs o) { + if(this.pos == o.pos) + return (this.dis - o.dis) > 0 ? 1 : -1; + return this.pos - o.pos; + } + }; + + // HelperClass + // Saves a relation and a role an OsmPrimitve was part of until it was stripped from all relations + private class RelationRole { + public Relation rel; + public String role; + public RelationRole(Relation rel, String role) { + this.rel = rel; + this.role = role; + } + + public boolean equals(Object other) { + if (!(other instanceof RelationRole)) return false; + RelationRole otherMember = (RelationRole) other; + return otherMember.role.equals(role) && otherMember.rel.equals(rel); + } + } + + // Adds the menu entry, Shortcuts, etc. + public JoinAreasAction() { + super(tr("Join overlapping Areas"), "joinareas", tr("Joins areas that overlap each other"), Shortcut.registerShortcut("tools:joinareas", tr("Tool: {0}", tr("Join overlapping Areas")), + KeyEvent.VK_J, Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true); + } + + /** + * Gets called whenever the shortcut is pressed or the menu entry is selected + * Checks whether the selected objects are suitable to join and joins them if so + */ + public void actionPerformed(ActionEvent e) { + int result = new ExtendedDialog(Main.parent, + tr("Enter values for all conflicts."), + new JLabel(tr("THIS IS EXPERIMENTAL. Save your work and verify before uploading.")), + new String[] {tr("Continue anyway"), tr("Cancel")}, + new String[] {"joinareas.png", "cancel.png"}).getValue(); + if(result != 1) return; + + Collection selection = Main.ds.getSelectedWays(); + + int ways = 0; + Way[] selWays = new Way[2]; + + LinkedList bounds = new LinkedList(); + OsmDataLayer dataLayer = Main.main.editLayer(); + for (DataSource ds : dataLayer.data.dataSources) { + if (ds.bounds != null) + bounds.add(ds.bounds); + } + + boolean askedAlready = false; + for (OsmPrimitive prim : selection) { + Way way = (Way) prim; + + // Too many ways + if(ways == 2) { + JOptionPane.showMessageDialog(Main.parent, tr("Only up to two areas can be joined at the moment.")); + return; + } + + if(!way.isClosed()) { + JOptionPane.showMessageDialog(Main.parent, tr("\"{0}\" is not closed and therefore can't be joined.", way.getName())); + return; + } + + // This is copied from SimplifyAction and should be probably ported to tools + for (Node node : way.nodes) { + if(askedAlready) break; + boolean isInsideOneBoundingBox = false; + for (Bounds b : bounds) { + if (b.contains(node.coor)) { + isInsideOneBoundingBox = true; + break; + } + } + + if (!isInsideOneBoundingBox) { + int option = JOptionPane.showConfirmDialog(Main.parent, + tr("The selected way(s) have nodes outside of the downloaded data region.\n" + + "This can lead to nodes being deleted accidentally.\n" + + "Are you really sure to continue?"), + tr("Please abort if you are not sure"), JOptionPane.YES_NO_OPTION, + JOptionPane.WARNING_MESSAGE); + + if (option != JOptionPane.YES_OPTION) return; + askedAlready = true; + break; + } + } + + selWays[ways] = way; + ways++; + } + + if (ways < 1) { + JOptionPane.showMessageDialog(Main.parent, tr("Please select at least one closed way the should be joined.")); + return; + } + + if(joinAreas(selWays[0], selWays[ways == 2 ? 1 : 0])) { + Main.map.mapView.repaint(); + DataSet.fireSelectionChanged(Main.ds.getSelected()); + } else + JOptionPane.showMessageDialog(Main.parent, tr("No intersections found. Nothing was changed.")); + } + + + /** + * Will join two overlapping areas + * @param Way First way/area + * @param Way Second way/area + * @return boolean Whether to display the "no operation" message + */ + private boolean joinAreas(Way a, Way b) { + // Fix self-overlapping first or other errors + boolean same = a.equals(b); + boolean hadChanges = false; + if(!same) { + if(checkForTagConflicts(a, b)) return true; // User aborted, so don't warn again + hadChanges = joinAreas(a, a); + hadChanges = joinAreas(b, b) || hadChanges; + } + + ArrayList nodes = addIntersections(a, b); + if(nodes.size() == 0) return hadChanges; + commitCommands("Added node on all intersections"); + + // Remove ways from all relations so ways can be combined/split quietly + ArrayList relations = removeFromRelations(a); + if(!same) relations.addAll(removeFromRelations(b)); + + // Don't warn now, because it will really look corrupted + boolean warnAboutRelations = relations.size() > 0; + + Collection allWays = splitWaysOnNodes(a, b, nodes); + + // Find all nodes and inner ways save them to a list + Collection allNodes = getNodesFromWays(allWays); + Collection innerWays = findInnerWays(allWays, allNodes); + + // Join outer ways + Way outerWay = joinOuterWays(allWays, innerWays); + + // Fix Multipolygons if there are any + Collection newInnerWays = fixMultigons(innerWays, outerWay); + + // Delete the remaining inner ways + cmds.add(DeleteCommand.delete(innerWays, true)); + commitCommands("Delete Ways that are not part of an inner multipolygon"); + + // We can attach our new multipolygon relation and pretend it has always been there + addOwnMultigonRelation(newInnerWays, outerWay, relations); + fixRelations(relations, outerWay); + commitCommands("Fix relations"); + + stripTags(newInnerWays); + makeCommitsOneAction( + a.equals(b) + ? "Joined self-overlapping area " + a.getName() + : "Joined overlapping areas " + a.getName() + " and " + b.getName() + ); + + if(warnAboutRelations) + JOptionPane.showMessageDialog(Main.parent, tr("Some of the ways were part of relations that have been modified. Please verify no errors have been introduced.")); + + return true; + } + + /** + * Checks if tags of two given ways differ, and presents the user a dialog to solve conflicts + * @param Way First way to check + * @param Way Second Way to check + * @return boolean True if not all conflicts could be resolved, False if everything's fine + */ + private boolean checkForTagConflicts(Way a, Way b) { + ArrayList ways = new ArrayList(); + ways.add(a); + ways.add(b); + + // This is mostly copied and pasted from CombineWayAction.java and one day should be moved into tools + Map> props = new TreeMap>(); + for (Way w : ways) { + for (Entry e : w.entrySet()) { + if (!props.containsKey(e.getKey())) + props.put(e.getKey(), new TreeSet()); + props.get(e.getKey()).add(e.getValue()); + } + } + + Way ax = new Way(a); + Way bx = new Way(b); + + Map components = new HashMap(); + JPanel p = new JPanel(new GridBagLayout()); + for (Entry> e : props.entrySet()) { + if (TigerUtils.isTigerTag(e.getKey())) { + String combined = TigerUtils.combineTags(e.getKey(), e.getValue()); + ax.put(e.getKey(), combined); + bx.put(e.getKey(), combined); + } else if (e.getValue().size() > 1) { + if("created_by".equals(e.getKey())) + { + ax.put("created_by", "JOSM"); + bx.put("created_by", "JOSM"); + } else { + JComboBox c = new JComboBox(e.getValue().toArray()); + c.setEditable(true); + p.add(new JLabel(e.getKey()), GBC.std()); + p.add(Box.createHorizontalStrut(10), GBC.std()); + p.add(c, GBC.eol()); + components.put(e.getKey(), c); + } + } else { + String val = e.getValue().iterator().next(); + ax.put(e.getKey(), val); + bx.put(e.getKey(), val); + } + } + + if (components.isEmpty()) + return false; // No conflicts found + + int result = new ExtendedDialog(Main.parent, + tr("Enter values for all conflicts."), + p, + new String[] {tr("Solve Conflicts"), tr("Cancel")}, + new String[] {"dialogs/conflict.png", "cancel.png"}).getValue(); + + if (result != 1) return true; // user cancel, unresolvable conflicts + + for (Entry e : components.entrySet()) { + String val = e.getValue().getEditor().getItem().toString(); + ax.put(e.getKey(), val); + bx.put(e.getKey(), val); + } + + cmds.add(new ChangeCommand(a, ax)); + cmds.add(new ChangeCommand(b, bx)); + commitCommands("Fix tag conflicts"); + return false; + } + + /** + * Will find all intersection and add nodes there for two given ways + * @param Way First way + * @param Way Second way + * @return ArrayList List of new nodes + */ + private ArrayList addIntersections(Way a, Way b) { + boolean same = a.equals(b); + int nodesSizeA = a.nodes.size(); + int nodesSizeB = b.nodes.size(); + + // We use OsmPrimitive here instead of Node because we later need to split a way at these nodes. + // With OsmPrimitve we can simply add the way and don't have to loop over the nodes + ArrayList nodes = new ArrayList(); + ArrayList nodesA = new ArrayList(); + ArrayList nodesB = new ArrayList(); + + for (int i = (same ? 1 : 0); i < nodesSizeA - 1; i++) { + for (int j = (same ? i + 2 : 0); j < nodesSizeB - 1; j++) { + // Avoid re-adding nodes that already exist on (some) intersections + if(a.nodes.get(i).equals(b.nodes.get(j)) || a.nodes.get(i+1).equals(b.nodes.get(j))) { + nodes.add(b.nodes.get(j)); + continue; + } else + if(a.nodes.get(i).equals(b.nodes.get(j+1)) || a.nodes.get(i+1).equals(b.nodes.get(j+1))) { + nodes.add(b.nodes.get(j+1)); + continue; + } + LatLon intersection = getLineLineIntersection( + a.nodes.get(i) .eastNorth.east(), a.nodes.get(i) .eastNorth.north(), + a.nodes.get(i+1).eastNorth.east(), a.nodes.get(i+1).eastNorth.north(), + b.nodes.get(j) .eastNorth.east(), b.nodes.get(j) .eastNorth.north(), + b.nodes.get(j+1).eastNorth.east(), b.nodes.get(j+1).eastNorth.north()); + if(intersection == null) continue; + + // Create the node. Adding them to the ways must be delayed because we still loop over them + Node n = new Node(intersection); + cmds.add(new AddCommand(n)); + nodes.add(n); + // The distance is needed to sort and add the nodes in direction of the way + nodesA.add(new NodeToSegs(i, n, a.nodes.get(i).coor)); + if(same) + nodesA.add(new NodeToSegs(j, n, a.nodes.get(j).coor)); + else + nodesB.add(new NodeToSegs(j, n, b.nodes.get(j).coor)); + } + } + + addNodesToWay(a, nodesA); + if(!same) addNodesToWay(b, nodesB); + + return nodes; + } + + /** + * Finds the intersection of two lines + * @return LatLon null if no intersection was found, the LatLon coordinates of the intersection otherwise + */ + static private LatLon getLineLineIntersection( + double x1, double y1, double x2, double y2, + double x3, double y3, double x4, double y4) { + + if (!Line2D.linesIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return null; + + // Convert line from (point, point) form to ax+by=c + double a1 = y2 - y1; + double b1 = x1 - x2; + double c1 = x2*y1 - x1*y2; + + double a2 = y4 - y3; + double b2 = x3 - x4; + double c2 = x4*y3 - x3*y4; + + // Solve the equations + double det = a1*b2 - a2*b1; + if(det == 0) return null; // Lines are parallel + + return Main.proj.eastNorth2latlon(new EastNorth( + (b1*c2 - b2*c1)/det, + (a2*c1 -a1*c2)/det + )); + } + + /** + * Inserts given nodes with positions into the given ways + * @param Way The way to insert the nodes into + * @param Collection The list of nodes with positions to insert + */ + private void addNodesToWay(Way a, ArrayList nodes) { + Way ax=new Way(a); + List newnodes = new ArrayList(); + Collections.sort(nodes); + + int numOfAdds = 1; + for(NodeToSegs n : nodes) { + ax.addNode(n.pos + numOfAdds, n.n); + numOfAdds++; + } + + cmds.add(new ChangeCommand(a, ax)); + } + + /** + * Commits the command list with a description + * @param String The description of what the commands do + */ + private void commitCommands(String description) { + switch(cmds.size()) { + case 0: + return; + case 1: + Main.main.undoRedo.add(cmds.getFirst()); + break; + default: + Command c = new SequenceCommand(tr(description), cmds); + Main.main.undoRedo.add(c); + break; + } + + cmds.clear(); + cmdsCount++; + } + + /** + * Removes a given OsmPrimitive from all relations + * @param OsmPrimitive Element to remove from all relations + * @return ArrayList List of relations with roles the primitives was part of + */ + private ArrayList removeFromRelations(OsmPrimitive osm) { + ArrayList result = new ArrayList(); + for (Relation r : Main.ds.relations) { + if (r.deleted || r.incomplete) continue; + for (RelationMember rm : r.members) { + if (rm.member != osm) continue; + + Relation newRel = new Relation(r); + newRel.members.remove(rm); + + cmds.add(new ChangeCommand(r, newRel)); + RelationRole saverel = new RelationRole(r, rm.role); + if(!result.contains(saverel)) result.add(saverel); + break; + } + } + + commitCommands("Removed Element from Relations"); + return result; + } + + /** + * This is a hacky implementation to make use of the splitWayAction code and + * should be improved. SplitWayAction needs to expose its splitWay function though. + */ + private Collection splitWaysOnNodes(Way a, Way b, Collection nodes) { + ArrayList ways = new ArrayList(); + ways.add(a); + if(!a.equals(b)) ways.add(b); + + List affected = new ArrayList(); + for (Way way : ways) { + nodes.add(way); + Main.ds.setSelected(nodes); + nodes.remove(way); + new SplitWayAction().actionPerformed(null); + cmdsCount++; + affected.addAll(Main.ds.getSelectedWays()); + } + return osmprim2way(affected); + } + + /** + * Converts a list of OsmPrimitives to a list of Ways + * @param Collection The OsmPrimitives list that's needed as a list of Ways + * @return Collection The list as list of Ways + */ + static private Collection osmprim2way(Collection ways) { + Collection result = new ArrayList(); + for(OsmPrimitive w: ways) { + if(w instanceof Way) result.add((Way) w); + } + return result; + } + + /** + * Returns all nodes for given ways + * @param Collection The list of ways which nodes are to be returned + * @return Collection The list of nodes the ways contain + */ + private Collection getNodesFromWays(Collection ways) { + Collection allNodes = new ArrayList(); + for(Way w: ways) allNodes.addAll(w.nodes); + return allNodes; + } + + /** + * Finds all inner ways for a given list of Ways and Nodes from a multigon by constructing a polygon + * for each way, looking for inner nodes that are not part of this way. If a node is found, all ways + * containing this node are added to the list + * @param Collection A list of (splitted) ways that form a multigon + * @param Collection A list of nodes that belong to the multigon + * @return Collection A list of ways that are positioned inside the outer borders of the multigon + */ + private Collection findInnerWays(Collection multigonWays, Collection multigonNodes) { + Collection innerWays = new ArrayList(); + for(Way w: multigonWays) { + Polygon poly = new Polygon(); + for(Node n: ((Way)w).nodes) poly.addPoint(latlonToXY(n.coor.lat()), latlonToXY(n.coor.lon())); + + for(Node n: multigonNodes) { + if(!((Way)w).nodes.contains(n) && poly.contains(latlonToXY(n.coor.lat()), latlonToXY(n.coor.lon()))) { + innerWays.addAll(getWaysByNode(multigonWays, n)); + } + } + } + + return innerWays; + } + + // Polygon only supports int coordinates, so convert them + private int latlonToXY(double val) { + return (int)Math.round(val*1000000); + } + + /** + * Finds all ways that contain the given node. + * @param Collection A collection of OsmPrimitives, but only ways will be honored + * @param Node The node the ways should be checked against + * @return Collection A list of ways that contain the given node + */ + private Collection getWaysByNode(Collection w, Node n) { + Collection deletedWays = new ArrayList(); + for(Way way : w) { + if(!((Way)way).nodes.contains(n)) continue; + if(!deletedWays.contains(way)) deletedWays.add(way); // Will need this later for multigons + } + return deletedWays; + } + + /** + * Joins the two outer ways and deletes all short ways that can't be part of a multipolygon anyway + * @param Collection The list of all ways that belong to that multigon + * @param Collection The list of inner ways that belong to that multigon + * @return Way The newly created outer way + */ + private Way joinOuterWays(Collection multigonWays, Collection innerWays) { + ArrayList join = new ArrayList(); + for(Way w: multigonWays) { + // Skip inner ways + if(innerWays.contains(w)) continue; + + if(w.nodes.size() <= 2) + cmds.add(new DeleteCommand(w)); + else + join.add(w); + } + + commitCommands("Join Areas: Remove Short Ways"); + return joinWays(join); + } + + /** + * Joins a list of ways (using CombineWayAction and ReverseWayAction if necessary to quiet the former) + * @param ArrayList The list of ways to join + * @return Way The newly created way + */ + private Way joinWays(ArrayList ways) { + if(ways.size() < 2) return ways.get(0); + //Main.ds.setSelected(ways); + + // This will turn ways so all of them point in the same direction and CombineAction won't bug + // the user about this. + Way a = null; + for(Way b : ways) { + if(a == null) { + a = b; + continue; + } + if(a.nodes.get(0).equals(b.nodes.get(0)) || + a.nodes.get(a.nodes.size()-1).equals(b.nodes.get(b.nodes.size()-1))) { + Main.ds.setSelected(b); + new ReverseWayAction().actionPerformed(null); + cmdsCount++; + } + a = b; + } + Main.ds.setSelected(ways); + new CombineWayAction().actionPerformed(null); + cmdsCount++; + return (Way)(Main.ds.getSelectedWays().toArray())[0]; + } + + /** + * Finds all ways that may be part of a multipolygon relation and removes them from the given list. + * It will automatically combine "good" ways + * @param Collection The list of inner ways to check + * @param Way The newly created outer way + * @return ArrayList The List of newly created inner ways + */ + private ArrayList fixMultigons(Collection uninterestingWays, Way outerWay) { + Collection innerNodes = getNodesFromWays(uninterestingWays); + Collection outerNodes = outerWay.nodes; + + // The newly created inner ways. uninterestingWays is passed by reference and therefore modified in-place + ArrayList newInnerWays = new ArrayList(); + + // Now we need to find all inner ways that contain a remaining node, but no outer nodes + // Remaining nodes are those that contain to more than one way. All nodes that belong to an + // inner multigon part will have at least two ways, so we can use this to find which ways do + // belong to the multigon. + Collection possibleWays = new ArrayList(); + wayIterator: for(Way w : uninterestingWays) { + boolean hasInnerNodes = false; + for(Node n : w.nodes) { + if(outerNodes.contains(n)) continue wayIterator; + if(!hasInnerNodes && innerNodes.contains(n)) hasInnerNodes = true; + } + if(!hasInnerNodes && w.nodes.size() >= 2) continue; + possibleWays.add(w); + } + + // Join all ways that have one start/ending node in common + Way joined = null; + outerIterator: do { + joined = null; + for(Way w1 : possibleWays) { + if(w1.isClosed()) { + if(!wayIsCollapsed(w1)) { + uninterestingWays.remove(w1); + newInnerWays.add(w1); + } + joined = w1; + possibleWays.remove(w1); + continue outerIterator; + } + for(Way w2 : possibleWays) { + // w2 cannot be closed, otherwise it would have been removed above + if(!waysCanBeCombined(w1, w2)) continue; + + ArrayList joinThem = new ArrayList(); + joinThem.add(w1); + joinThem.add(w2); + uninterestingWays.removeAll(joinThem); + possibleWays.removeAll(joinThem); + + // Although we joined the ways, we cannot simply assume that they are closed + joined = joinWays(joinThem); + uninterestingWays.add(joined); + possibleWays.add(joined); + continue outerIterator; + } + } + } while(joined != null); + return newInnerWays; + } + + /** + * Checks if a way is collapsed (i.e. looks like <---->) + * @param Way A *closed* way to check if it is collapsed + * @return boolean If the closed way is collapsed or not + */ + private boolean wayIsCollapsed(Way w) { + if(w.nodes.size() <= 3) return true; + + // If a way contains more than one node twice, it must be collapsed (only start/end node may be the same) + Way x = new Way(w); + int count = 0; + for(Node n : w.nodes) { + x.nodes.remove(n); + if(x.nodes.contains(n)) count++; + if(count == 2) return true; + } + return false; + } + + /** + * Checks if two ways share one starting/ending node + * @param Way first way + * @param Way second way + * @return boolean Wheter the ways share a starting/ending node or not + */ + private boolean waysCanBeCombined(Way w1, Way w2) { + if(w1.equals(w2)) return false; + + if(w1.nodes.get(0).equals(w2.nodes.get(0))) return true; + if(w1.nodes.get(0).equals(w2.nodes.get(w2.nodes.size()-1))) return true; + + if(w1.nodes.get(w1.nodes.size()-1).equals(w2.nodes.get(0))) return true; + if(w1.nodes.get(w1.nodes.size()-1).equals(w2.nodes.get(w2.nodes.size()-1))) return true; + + return false; + } + + /** + * Will add own multipolygon relation to the "previously existing" relations. Fixup is done by fixRelations + * @param Collection List of already closed inner ways + * @param Way The outer way + * @param ArrayList The list of relation with roles to add own relation to + */ + private void addOwnMultigonRelation(Collection inner, Way outer, ArrayList rels) { + if(inner.size() == 0) return; + // Create new multipolygon relation and add all inner ways to it + Relation newRel = new Relation(); + newRel.put("type", "multipolygon"); + for(Way w : inner) + newRel.members.add(new RelationMember("inner", w)); + cmds.add(new AddCommand(newRel)); + + // We don't add outer to the relation because it will be handed to fixRelations() + // which will then do the remaining work. Collections are passed by reference, so no + // need to return it + rels.add(new RelationRole(newRel, "outer")); + //return rels; + } + + /** + * Adds the previously removed relations again to the outer way. If there are multiple multipolygon + * relations where the joined areas were in "outer" role a new relation is created instead with all + * members of both. This function depends on multigon relations to be valid already, it won't fix them. + * @param ArrayList List of relations with roles the (original) ways were part of + * @param Way The newly created outer area/way + */ + private void fixRelations(ArrayList rels, Way outer) { + ArrayList multiouters = new ArrayList(); + for(RelationRole r : rels) { + if( r.rel.get("type") != null && + r.rel.get("type").equalsIgnoreCase("multipolygon") && + r.role.equalsIgnoreCase("outer") + ) { + multiouters.add(r); + continue; + } + // Add it back! + Relation newRel = new Relation(r.rel); + newRel.members.add(new RelationMember(r.role, outer)); + cmds.add(new ChangeCommand(r.rel, newRel)); + } + + Relation newRel = null; + switch(multiouters.size()) { + case 0: + return; + case 1: + // Found only one to be part of a multipolygon relation, so just add it back as well + newRel = new Relation(multiouters.get(0).rel); + newRel.members.add(new RelationMember(multiouters.get(0).role, outer)); + cmds.add(new ChangeCommand(multiouters.get(0).rel, newRel)); + return; + default: + // Create a new relation with all previous members and (Way)outer as outer. + newRel = new Relation(); + for(RelationRole r : multiouters) { + // Add members + for(RelationMember rm : r.rel.members) + if(!newRel.members.contains(rm)) newRel.members.add(rm); + // Add tags + for (String key : r.rel.keys.keySet()) { + newRel.put(key, r.rel.keys.get(key)); + } + // Delete old relation + cmds.add(new DeleteCommand(r.rel)); + } + newRel.members.add(new RelationMember("outer", outer)); + cmds.add(new AddCommand(newRel)); + } + } + + /** + * @param Collection The List of Ways to remove all tags from + */ + private void stripTags(Collection ways) { + for(Way w: ways) stripTags(w); + commitCommands("Remove tags from inner ways"); + } + + /** + * @param Way The Way to remove all tags from + */ + private void stripTags(Way x) { + if(x.keys == null) return; + Way y = new Way(x); + for (String key : x.keys.keySet()) + y.remove(key); + cmds.add(new ChangeCommand(x, y)); + } + + /** + * Takes the last cmdsCount actions back and combines them into a single action + * (for when the user wants to undo the join action) + * @param String The commit message to display + */ + private void makeCommitsOneAction(String message) { + UndoRedoHandler ur = Main.main.undoRedo; + cmds.clear(); + for(int i = ur.commands.size() - cmdsCount; i < ur.commands.size(); i++) + cmds.add(ur.commands.get(i)); + + for(int i = 0; i < cmdsCount; i++) + ur.undo(); + + commitCommands(message == null ? "Join Areas Function" : message); + cmdsCount = 0; + } +} Index: applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/UtilsPlugin.java =================================================================== --- applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/UtilsPlugin.java (revision 13575) +++ applications/editors/josm/plugins/utilsplugin/src/UtilsPlugin/UtilsPlugin.java (revision 13723) @@ -23,8 +23,10 @@ public class UtilsPlugin extends Plugin { JMenuItem SimplifyWay; + JMenuItem JoinAreas; JumpToAction JumpToAct = new JumpToAction(); public UtilsPlugin() { SimplifyWay = MainMenu.add(Main.main.menu.toolsMenu, new SimplifyWayAction()); + JoinAreas = MainMenu.add(Main.main.menu.toolsMenu, new JoinAreasAction()); SimplifyWay.setEnabled(false); } @@ -34,4 +36,5 @@ if (oldFrame == null && newFrame != null) { SimplifyWay.setEnabled(true); + JoinAreas.setEnabled(true); newFrame.statusLine.addMouseListener(JumpToAct); }