Index: /applications/editors/josm/plugins/merge-overlap/.classpath
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/.classpath (revision 26704)
+++ /applications/editors/josm/plugins/merge-overlap/.classpath (revision 26705)
@@ -3,5 +3,5 @@
-
+
Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java (revision 26704)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java (revision 26705)
@@ -8,5 +8,4 @@
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
-import java.rmi.server.RMIClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
@@ -52,222 +51,202 @@
public class MergeOverlapAction extends JosmAction {
- public MergeOverlapAction() {
- super(tr("Merge overlap"), "merge_overlap",
- tr("Merge overlap of ways."), Shortcut.registerShortcut(
- "tools:mergeoverlap", tr("Tool: {0}",
- tr("Merge overlap")), KeyEvent.VK_O,
- Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true);
- }
-
- Map> relations = new HashMap>();
- Map oldWays = new HashMap();
- Map newRelations = new HashMap();
- Set deletes = new HashSet();
-
- /**
- * The action button has been clicked
- *
- * @param e Action Event
- */
- public void actionPerformed(ActionEvent e) {
-
- // List of selected ways
- List ways = new ArrayList();
- relations.clear();
- newRelations.clear();
-
- // For every selected way
- for (OsmPrimitive osm : Main.main.getCurrentDataSet().getSelected()) {
- if (osm instanceof Way && !osm.isDeleted()) {
- Way way = (Way)osm;
- ways.add(way);
- List rels = new ArrayList();
- for (Relation r: OsmPrimitive.getFilteredList(way.getReferrers(), Relation.class)) {
- rels.add(r);
- }
- relations.put(way, rels);
- }
- }
-
- List sel = new ArrayList(ways);
- Collection cmds = new LinkedList();
-
- // *****
- // split
- // *****
- for (Way way : ways) {
- Set nodes = new HashSet();
- for (Way opositWay : ways) {
- if (way != opositWay) {
- List nodesPos = new LinkedList();
-
- int pos = 0;
- for (Node node : way.getNodes()) {
- int opositPos = 0;
- for (Node opositNode : opositWay.getNodes()) {
- if (node == opositNode) {
- if (opositWay.isClosed()) {
- opositPos %= opositWay.getNodesCount() - 1;
- }
- nodesPos.add(new NodePos(node, pos, opositPos));
- break;
- }
- opositPos++;
- }
- pos++;
- }
-
- NodePos start = null;
- NodePos end = null;
- int increment = 0;
-
- boolean hasFirst = false;
- for (NodePos node : nodesPos) {
- if (start == null) {
- start = node;
- }
- else {
- if (end == null) {
- if (follows(way, opositWay, start, node, 1)) {
- end = node;
- increment = +1;
- }
- else if (follows(way, opositWay, start, node, -1)) {
- end = node;
- increment = -1;
- }
- else {
- start = node;
- end = null;
- }
- }
- else {
- if (follows(way, opositWay, end, node, increment)) {
- end = node;
- }
- else {
- hasFirst = addNodes(start, end, way, nodes, hasFirst);
- start = node;
- end = null;
- }
- }
- }
- }
-
- if (start != null && end != null) {
- hasFirst = addNodes(start, end, way, nodes, hasFirst);
- start = null;
- end = null;
- }
- }
- }
- if (!nodes.isEmpty() && !way.isClosed() || nodes.size() >= 2) {
- List> wayChunks = SplitWayAction.buildSplitChunks(way, new ArrayList(nodes));
- SplitWayResult result = splitWay(getEditLayer(), way, wayChunks);
-
- cmds.add(result.getCommand());
- sel.remove(way);
- sel.add(result.getOriginalWay());
- sel.addAll(result.getNewWays());
- List rels = relations.remove(way);
- relations.put(result.getOriginalWay(), rels);
- for (Way w: result.getNewWays()) {
- relations.put(w, rels);
- }
- }
- }
-
- // *****
- // merge
- // *****
- ways = new ArrayList(sel);
- while (!ways.isEmpty()) {
- Way way = ways.get(0);
- List combine = new ArrayList();
- combine.add(way);
- for (Way opositWay : ways) {
- if (way != opositWay && way.getNodesCount() == opositWay.getNodesCount()) {
- boolean equals1 = true;
- for (int i = 0 ; i < way.getNodesCount() ; i++) {
- if (way.getNode(i) != opositWay.getNode(i)) {
- equals1 = false;
- break;
- }
- }
- boolean equals2 = true;
- for (int i = 0 ; i < way.getNodesCount() ; i++) {
- if (way.getNode(i) != opositWay.getNode(way.getNodesCount() - i -1)) {
- equals2 = false;
- break;
- }
- }
- if (equals1 || equals2) {
- combine.add(opositWay);
- }
- }
- }
- ways.removeAll(combine);
- if (combine.size() > 1) {
- sel.removeAll(combine);
- // combine
- Pair> combineResult;
- try {
- combineResult = combineWaysWorker(combine);
- } catch (UserCancelException e1) {
- return;
- }
- sel.add(combineResult.a);
- cmds.addAll(combineResult.b);
- }
- }
-
- for (Relation old: newRelations.keySet()) {
- System.out.println("+++++++++++++");
- System.out.println("old");
- System.out.println(old.getDataSet());
- System.out.println("new");
- System.out.println(newRelations.get(old).getDataSet());
-
-// for (int i=0; i < old.getMembersCount(); i++) {
- for (int i=0; i < newRelations.get(old).getMembersCount(); i++) {
- RelationMember rm = newRelations.get(old).getMember(i);
-// RelationMember rm = old.getMember(i);
- System.out.println("***********");
- System.out.println("old");
- // System.out.println(rm.getMember());
- System.out.println(rm.getWay().getId());
- System.out.println(rm.getWay().getDataSet());
-/* System.out.println("new");
- Way w = newWays.get(rm.getWay());
-// System.out.println(w);
- if (w == null) {
- System.out.println(w);
- }
- else {
- System.out.println(w.getDataSet());
- }*/
- }
- cmds.add(new ChangeCommand(old, newRelations.get(old)));
- }
-
- List del = new LinkedList();
- for (Way w: deletes) {
- if (!w.isDeleted()) {
- del.add(w);
- }
- }
- if (!del.isEmpty()) {
- cmds.add(new DeleteCommand(del));
- }
-
- // Commit
- Main.main.undoRedo.add(new SequenceCommand(tr("Merge Overlap (combine)"), cmds));
- getCurrentDataSet().setSelected(sel);
- Main.map.repaint();
-
- relations.clear();
- newRelations.clear();
- oldWays.clear();
- }
+ public MergeOverlapAction() {
+ super(tr("Merge overlap", null), "merge_overlap", tr(
+ "Merge overlap of ways.", null), Shortcut.registerShortcut(
+ "tools:mergeoverlap",
+ tr("Tool: {0}", tr("Merge overlap", null)), KeyEvent.VK_O,
+ Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true);
+ }
+
+ Map> relations = new HashMap>();
+ Map oldWays = new HashMap();
+ Map newRelations = new HashMap();
+ Set deletes = new HashSet();
+
+ /**
+ * The action button has been clicked
+ *
+ * @param e
+ * Action Event
+ */
+ public void actionPerformed(ActionEvent e) {
+
+ // List of selected ways
+ List ways = new ArrayList();
+ relations.clear();
+ newRelations.clear();
+
+ // For every selected way
+ for (OsmPrimitive osm : Main.main.getCurrentDataSet().getSelected()) {
+ if (osm instanceof Way && !osm.isDeleted()) {
+ Way way = (Way) osm;
+ ways.add(way);
+ List rels = new ArrayList();
+ for (Relation r : OsmPrimitive.getFilteredList(way
+ .getReferrers(), Relation.class)) {
+ rels.add(r);
+ }
+ relations.put(way, rels);
+ }
+ }
+
+ List sel = new ArrayList(ways);
+ Collection cmds = new LinkedList();
+
+ // *****
+ // split
+ // *****
+ for (Way way : ways) {
+ Set nodes = new HashSet();
+ for (Way opositWay : ways) {
+ if (way != opositWay) {
+ List nodesPos = new LinkedList();
+
+ int pos = 0;
+ for (Node node : way.getNodes()) {
+ int opositPos = 0;
+ for (Node opositNode : opositWay.getNodes()) {
+ if (node == opositNode) {
+ if (opositWay.isClosed()) {
+ opositPos %= opositWay.getNodesCount() - 1;
+ }
+ nodesPos.add(new NodePos(node, pos, opositPos));
+ break;
+ }
+ opositPos++;
+ }
+ pos++;
+ }
+
+ NodePos start = null;
+ NodePos end = null;
+ int increment = 0;
+
+ boolean hasFirst = false;
+ for (NodePos node : nodesPos) {
+ if (start == null) {
+ start = node;
+ } else {
+ if (end == null) {
+ if (follows(way, opositWay, start, node, 1)) {
+ end = node;
+ increment = +1;
+ } else if (follows(way, opositWay, start, node,
+ -1)) {
+ end = node;
+ increment = -1;
+ } else {
+ start = node;
+ end = null;
+ }
+ } else {
+ if (follows(way, opositWay, end, node,
+ increment)) {
+ end = node;
+ } else {
+ hasFirst = addNodes(start, end, way, nodes,
+ hasFirst);
+ start = node;
+ end = null;
+ }
+ }
+ }
+ }
+
+ if (start != null && end != null) {
+ hasFirst = addNodes(start, end, way, nodes, hasFirst);
+ start = null;
+ end = null;
+ }
+ }
+ }
+ if (!nodes.isEmpty() && !way.isClosed() || nodes.size() >= 2) {
+ List> wayChunks = SplitWayAction.buildSplitChunks(
+ way, new ArrayList(nodes));
+ SplitWayResult result = splitWay(getEditLayer(), way, wayChunks);
+
+ cmds.add(result.getCommand());
+ sel.remove(way);
+ sel.add(result.getOriginalWay());
+ sel.addAll(result.getNewWays());
+ List rels = relations.remove(way);
+ relations.put(result.getOriginalWay(), rels);
+ for (Way w : result.getNewWays()) {
+ relations.put(w, rels);
+ }
+ }
+ }
+
+ // *****
+ // merge
+ // *****
+ ways = new ArrayList(sel);
+ while (!ways.isEmpty()) {
+ Way way = ways.get(0);
+ List combine = new ArrayList();
+ combine.add(way);
+ for (Way opositWay : ways) {
+ if (way != opositWay
+ && way.getNodesCount() == opositWay.getNodesCount()) {
+ boolean equals1 = true;
+ for (int i = 0; i < way.getNodesCount(); i++) {
+ if (way.getNode(i) != opositWay.getNode(i)) {
+ equals1 = false;
+ break;
+ }
+ }
+ boolean equals2 = true;
+ for (int i = 0; i < way.getNodesCount(); i++) {
+ if (way.getNode(i) != opositWay.getNode(way
+ .getNodesCount()
+ - i - 1)) {
+ equals2 = false;
+ break;
+ }
+ }
+ if (equals1 || equals2) {
+ combine.add(opositWay);
+ }
+ }
+ }
+ ways.removeAll(combine);
+ if (combine.size() > 1) {
+ sel.removeAll(combine);
+ // combine
+ Pair> combineResult;
+ try {
+ combineResult = combineWaysWorker(combine);
+ } catch (UserCancelException e1) {
+ return;
+ }
+ sel.add(combineResult.a);
+ cmds.addAll(combineResult.b);
+ }
+ }
+
+ for (Relation old : newRelations.keySet()) {
+ cmds.add(new ChangeCommand(old, newRelations.get(old)));
+ }
+
+ List del = new LinkedList();
+ for (Way w : deletes) {
+ if (!w.isDeleted()) {
+ del.add(w);
+ }
+ }
+ if (!del.isEmpty()) {
+ cmds.add(new DeleteCommand(del));
+ }
+
+ // Commit
+ Main.main.undoRedo.add(new SequenceCommand(
+ tr("Merge Overlap (combine)", null), cmds));
+ getCurrentDataSet().setSelected(sel);
+ Main.map.repaint();
+
+ relations.clear();
+ newRelations.clear();
+ oldWays.clear();
+ }
private class NodePos {
@@ -275,9 +254,11 @@
int pos;
int opositPos;
- NodePos (Node n, int p, int op) {
+
+ NodePos(Node n, int p, int op) {
node = n;
pos = p;
opositPos = op;
}
+
public String toString() {
return "NodePos: " + pos + ", " + opositPos + ", " + node;
@@ -285,465 +266,482 @@
}
- private boolean addNodes(NodePos start, NodePos end, Way way, Set nodes,
- boolean hasFirst) {
- if (way.isClosed() || (start.node != way.getNode(0)
- && start.node != way.getNode(way.getNodesCount() - 1))) {
+ private boolean addNodes(NodePos start, NodePos end, Way way,
+ Set nodes, boolean hasFirst) {
+ if (way.isClosed()
+ || (start.node != way.getNode(0) && start.node != way
+ .getNode(way.getNodesCount() - 1))) {
hasFirst = hasFirst || start.node == way.getNode(0);
- nodes.add(start.node);
- }
- if (way.isClosed() || (end.node != way.getNode(0)
- && end.node != way.getNode(way.getNodesCount() - 1))) {
- if (hasFirst && (end.node == way.getNode(way.getNodesCount() - 1))) {
- nodes.remove(way.getNode(0));
- }
- else {
- nodes.add(end.node);
- }
+ nodes.add(start.node);
+ }
+ if (way.isClosed()
+ || (end.node != way.getNode(0) && end.node != way.getNode(way
+ .getNodesCount() - 1))) {
+ if (hasFirst && (end.node == way.getNode(way.getNodesCount() - 1))) {
+ nodes.remove(way.getNode(0));
+ } else {
+ nodes.add(end.node);
+ }
}
return hasFirst;
}
- private boolean follows(Way way1, Way way2, NodePos np1, NodePos np2, int incr) {
- if (way2.isClosed() && incr == 1 && np1.opositPos == way2.getNodesCount() - 2) {
- return np2.pos == np1.pos + 1 && np2.opositPos == 0;
- }
- else if (way2.isClosed() && incr == 1 && np1.opositPos == 0) {
- return np2.pos == np1.pos && np2.opositPos == 0
- || np2.pos == np1.pos + 1 && np2.opositPos == 1;
- }
- else if (way2.isClosed() && incr == -1 && np1.opositPos == 0) {
- return np2.pos == np1.pos && np2.opositPos == 0
- || np2.pos == np1.pos + 1 && np2.opositPos == way2.getNodesCount() - 2;
- }
- else {
- return np2.pos == np1.pos + 1 && np2.opositPos == np1.opositPos + incr;
- }
- }
-
- /**
- * Splits a way
- *
- * @param layer
- * @param way
- * @param wayChunks
- * @return
- */
- private SplitWayResult splitWay(OsmDataLayer layer, Way way, List> wayChunks) {
- // build a list of commands, and also a new selection list
- Collection commandList = new ArrayList(wayChunks.size());
-
- Iterator> chunkIt = wayChunks.iterator();
- Collection nowarnroles = Main.pref.getCollection(
- "way.split.roles.nowarn", Arrays.asList(new String[] {
- "outer", "inner", "forward", "backward" }));
-
- // First, change the original way
- Way changedWay = new Way(way);
- oldWays.put(changedWay, way);
- changedWay.setNodes(chunkIt.next());
- commandList.add(new ChangeCommand(way, changedWay));
-
- List newWays = new ArrayList();
- // Second, create new ways
- while (chunkIt.hasNext()) {
- Way wayToAdd = new Way();
- wayToAdd.setKeys(way.getKeys());
- newWays.add(wayToAdd);
- wayToAdd.setNodes(chunkIt.next());
- commandList.add(new AddCommand(layer, wayToAdd));
- }
- boolean warnmerole = false;
- boolean warnme = false;
- // now copy all relations to new way also
-
- for (Relation r : getParentRelations(way)) {
- if (!r.isUsable()) {
- continue;
- }
- Relation c = null;
- String type = r.get("type");
- if (type == null) {
- type = "";
- }
-
- int i_c = 0, i_r = 0;
- List relationMembers = r.getMembers();
- for (RelationMember rm : relationMembers) {
- if (rm.isWay() && rm.getMember() == way) {
- boolean insert = true;
- if ("restriction".equals(type)) {
- /*
- * this code assumes the restriction is correct. No real
- * error checking done
- */
- String role = rm.getRole();
- if ("from".equals(role) || "to".equals(role)) {
- OsmPrimitive via = null;
- for (RelationMember rmv : r.getMembers()) {
- if ("via".equals(rmv.getRole())) {
- via = rmv.getMember();
- }
- }
- List nodes = new ArrayList();
- if (via != null) {
- if (via instanceof Node) {
- nodes.add((Node) via);
- } else if (via instanceof Way) {
- nodes.add(((Way) via).lastNode());
- nodes.add(((Way) via).firstNode());
- }
- }
- Way res = null;
- for (Node n : nodes) {
- if (changedWay.isFirstLastNode(n)) {
- res = way;
- }
- }
- if (res == null) {
- for (Way wayToAdd : newWays) {
- for (Node n : nodes) {
- if (wayToAdd.isFirstLastNode(n)) {
- res = wayToAdd;
- }
- }
- }
- if (res != null) {
- if (c == null) {
- c = getNew(r);
- }
- c.addMember(new RelationMember(role, res));
- c.removeMembersFor(way);
- insert = false;
- }
- } else {
- insert = false;
- }
- } else if (!"via".equals(role)) {
- warnme = true;
- }
- } else if (!("route".equals(type))
- && !("multipolygon".equals(type))) {
- warnme = true;
- }
- if (c == null) {
- c = getNew(r);
- }
-
- if (insert) {
- if (rm.hasRole() && !nowarnroles.contains(rm.getRole())) {
- warnmerole = true;
- }
-
- Boolean backwards = null;
- int k = 1;
- while (i_r - k >= 0 || i_r + k < relationMembers.size()) {
- if ((i_r - k >= 0)
- && relationMembers.get(i_r - k).isWay()) {
- Way w = relationMembers.get(i_r - k).getWay();
- if ((w.lastNode() == way.firstNode())
- || w.firstNode() == way.firstNode()) {
- backwards = false;
- } else if ((w.firstNode() == way.lastNode())
- || w.lastNode() == way.lastNode()) {
- backwards = true;
- }
- break;
- }
- if ((i_r + k < relationMembers.size())
- && relationMembers.get(i_r + k).isWay()) {
- Way w = relationMembers.get(i_r + k).getWay();
- if ((w.lastNode() == way.firstNode())
- || w.firstNode() == way.firstNode()) {
- backwards = true;
- } else if ((w.firstNode() == way.lastNode())
- || w.lastNode() == way.lastNode()) {
- backwards = false;
- }
- break;
- }
- k++;
- }
-
- int j = i_c;
- for (Way wayToAdd : newWays) {
- RelationMember em = new RelationMember(
- rm.getRole(), wayToAdd);
- j++;
- if ((backwards != null) && backwards) {
- c.addMember(i_c, em);
- } else {
- c.addMember(j, em);
- }
- }
- i_c = j;
- }
- }
- i_c++;
- i_r++;
- }
-
- if (c != null) {
- //commandList.add(new ChangeCommand(layer, r, c));
- newRelations.put(r, c);
- }
- }
- if (warnmerole) {
- JOptionPane
- .showMessageDialog(
- Main.parent,
- tr("A role based relation membership was copied to all new ways.
You should verify this and correct it when necessary."),
- tr("Warning"), JOptionPane.WARNING_MESSAGE);
- } else if (warnme) {
- JOptionPane
- .showMessageDialog(
- Main.parent,
- tr("A relation membership was copied to all new ways.
You should verify this and correct it when necessary."),
- tr("Warning"), JOptionPane.WARNING_MESSAGE);
- }
-
- return new SplitWayResult(new SequenceCommand("Split way", commandList), null, changedWay, newWays);
- }
-
- /**
- * @param ways
- * @return null if ways cannot be combined. Otherwise returns the combined
- * ways and the commands to combine
- * @throws UserCancelException
- */
- private Pair> combineWaysWorker(Collection ways) throws UserCancelException {
-
- // prepare and clean the list of ways to combine
- if (ways == null || ways.isEmpty())
- return null;
- ways.remove(null); // just in case - remove all null ways from the collection
-
- // remove duplicates, preserving order
- ways = new LinkedHashSet(ways);
-
- // try to build a new way which includes all the combined ways
- NodeGraph graph = NodeGraph.createUndirectedGraphFromNodeWays(ways);
- List path = graph.buildSpanningPath();
-
- // check whether any ways have been reversed in the process
- // and build the collection of tags used by the ways to combine
- TagCollection wayTags = TagCollection.unionOfAllPrimitives(ways);
-
- List reversedWays = new LinkedList();
- List unreversedWays = new LinkedList();
- for (Way w: ways) {
- if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w.getNode(1))) {
- unreversedWays.add(w);
- } else {
- reversedWays.add(w);
- }
- }
- // reverse path if all ways have been reversed
- if (unreversedWays.isEmpty()) {
- Collections.reverse(path);
- unreversedWays = reversedWays;
- reversedWays = null;
- }
- if ((reversedWays != null) && !reversedWays.isEmpty()) {
- // filter out ways that have no direction-dependent tags
- unreversedWays = ReverseWayTagCorrector.irreversibleWays(unreversedWays);
- reversedWays = ReverseWayTagCorrector.irreversibleWays(reversedWays);
- // reverse path if there are more reversed than unreversed ways with direction-dependent tags
- if (reversedWays.size() > unreversedWays.size()) {
- Collections.reverse(path);
- List tempWays = unreversedWays;
- unreversedWays = reversedWays;
- reversedWays = tempWays;
- }
- // if there are still reversed ways with direction-dependent tags, reverse their tags
- if (!reversedWays.isEmpty()) {
- List unreversedTagWays = new ArrayList(ways);
- unreversedTagWays.removeAll(reversedWays);
- ReverseWayTagCorrector reverseWayTagCorrector = new ReverseWayTagCorrector();
- List reversedTagWays = new ArrayList();
- Collection changePropertyCommands = null;
- for (Way w : reversedWays) {
- Way wnew = new Way(w);
- reversedTagWays.add(wnew);
- changePropertyCommands = reverseWayTagCorrector.execute(w, wnew);
- }
- if ((changePropertyCommands != null) && !changePropertyCommands.isEmpty()) {
- for (Command c : changePropertyCommands) {
- c.executeCommand();
- }
- }
- wayTags = TagCollection.unionOfAllPrimitives(reversedTagWays);
- wayTags.add(TagCollection.unionOfAllPrimitives(unreversedTagWays));
- }
- }
-
- // create the new way and apply the new node list
- Way targetWay = getTargetWay(ways);
- Way modifiedTargetWay = new Way(targetWay);
- modifiedTargetWay.setNodes(path);
-
- TagCollection completeWayTags = new TagCollection(wayTags);
- combineTigerTags(completeWayTags);
- normalizeTagCollectionBeforeEditing(completeWayTags, ways);
- TagCollection tagsToEdit = new TagCollection(completeWayTags);
- completeTagCollectionForEditing(tagsToEdit);
-
- MyCombinePrimitiveResolverDialog dialog = MyCombinePrimitiveResolverDialog.getInstance();
- dialog.getTagConflictResolverModel().populate(tagsToEdit, completeWayTags.getKeysWithMultipleValues());
- dialog.setTargetPrimitive(targetWay);
- Set parentRelations = getParentRelations(ways);
- dialog.getRelationMemberConflictResolverModel().populate(parentRelations, ways, oldWays);
- dialog.prepareDefaultDecisions();
-
- // resolve tag conflicts if necessary
- if (askForMergeTag(ways) || duplicateParentRelations(ways)) {
- dialog.setVisible(true);
- if (dialog.isCancelled())
- throw new UserCancelException();
- }
-
- LinkedList cmds = new LinkedList();
- deletes.addAll(ways);
- deletes.remove(targetWay);
-
- cmds.add(new ChangeCommand(targetWay, modifiedTargetWay));
- cmds.addAll(dialog.buildWayResolutionCommands());
- dialog.buildRelationCorrespondance(newRelations, oldWays);
-
- return new Pair>(targetWay, cmds);
- }
-
- private static Way getTargetWay(Collection combinedWays) {
- // init with an arbitrary way
- Way targetWay = combinedWays.iterator().next();
-
- // look for the first way already existing on
- // the server
- for (Way w : combinedWays) {
- targetWay = w;
- if (!w.isNew()) {
- break;
- }
- }
- return targetWay;
- }
-
- /**
- * @return has tag to be merged (=> ask)
- */
- private static boolean askForMergeTag(Collection ways) {
- for (Way way: ways) {
- for (Way oposite: ways) {
- for (String key: way.getKeys().keySet()) {
- if (!"source".equals(key) && oposite.hasKey(key)
- && !way.get(key).equals(oposite.get(key))) {
- return true;
- }
- }
- }
- }
- return false;
- }
-
- /**
- * @return has duplicate parent relation
- */
- private boolean duplicateParentRelations(Collection ways) {
- Set relations = new HashSet();
- for (Way w: ways) {
- List rs = getParentRelations(w);
- for (Relation r: rs) {
- if (relations.contains(r)) {
- return true;
- }
- }
- relations.addAll(rs);
- }
- return false;
- }
-
- /**
- * Replies the set of referring relations
- *
- * @return the set of referring relations
- */
- private List getParentRelations(Way way) {
- List rels = new ArrayList();
- for (Relation r: relations.get(way)) {
- if (newRelations.containsKey(r)) {
- rels.add(newRelations.get(r));
- }
- else {
- rels.add(r);
- }
- }
- return rels;
- }
-
- private Relation getNew(Relation r) {
- return getNew(r, newRelations);
- }
-
- public static Relation getNew(Relation r, Map newRelations) {
- if (newRelations.containsValue(r)) {
- return r;
- }
- else {
- Relation c = new Relation(r);
- newRelations.put(r, c);
- return c;
- }
- }
-
- private Way getOld(Way r) {
- return getOld(r, oldWays);
- }
-
- public static Way getOld(Way w, Map oldWays) {
- if (oldWays.containsKey(w)) {
- return oldWays.get(w);
- }
- else {
- return w;
- }
- }
-
- /**
- * Replies the set of referring relations
- *
- * @return the set of referring relations
- */
- private Set getParentRelations(Collection ways) {
- HashSet ret = new HashSet();
- for (Way w: ways) {
- ret.addAll(getParentRelations(w));
- }
- return ret;
- }
-
- /** Enable this action only if something is selected */
- @Override
- protected void updateEnabledState() {
- if (getCurrentDataSet() == null) {
- setEnabled(false);
- } else {
- updateEnabledState(getCurrentDataSet().getSelected());
- }
- }
-
- /** Enable this action only if something is selected */
- @Override
- protected void updateEnabledState(
- Collection selection) {
- if (selection == null) {
- setEnabled(false);
- return;
- }
- for (OsmPrimitive primitive: selection) {
- if (!(primitive instanceof Way) || primitive.isDeleted()) {
- setEnabled(false);
- return;
- }
- }
- setEnabled(selection.size() >= 2);
- }
+ private boolean follows(Way way1, Way way2, NodePos np1, NodePos np2,
+ int incr) {
+ if (way2.isClosed() && incr == 1
+ && np1.opositPos == way2.getNodesCount() - 2) {
+ return np2.pos == np1.pos + 1 && np2.opositPos == 0;
+ } else if (way2.isClosed() && incr == 1 && np1.opositPos == 0) {
+ return np2.pos == np1.pos && np2.opositPos == 0
+ || np2.pos == np1.pos + 1 && np2.opositPos == 1;
+ } else if (way2.isClosed() && incr == -1 && np1.opositPos == 0) {
+ return np2.pos == np1.pos && np2.opositPos == 0
+ || np2.pos == np1.pos + 1
+ && np2.opositPos == way2.getNodesCount() - 2;
+ } else {
+ return np2.pos == np1.pos + 1
+ && np2.opositPos == np1.opositPos + incr;
+ }
+ }
+
+ /**
+ * Splits a way
+ *
+ * @param layer
+ * @param way
+ * @param wayChunks
+ * @return
+ */
+ private SplitWayResult splitWay(OsmDataLayer layer, Way way,
+ List> wayChunks) {
+ // build a list of commands, and also a new selection list
+ Collection commandList = new ArrayList(wayChunks
+ .size());
+
+ Iterator> chunkIt = wayChunks.iterator();
+ Collection nowarnroles = Main.pref.getCollection(
+ "way.split.roles.nowarn", Arrays.asList(new String[] { "outer",
+ "inner", "forward", "backward" }));
+
+ // First, change the original way
+ Way changedWay = new Way(way);
+ oldWays.put(changedWay, way);
+ changedWay.setNodes(chunkIt.next());
+ commandList.add(new ChangeCommand(way, changedWay));
+
+ List newWays = new ArrayList();
+ // Second, create new ways
+ while (chunkIt.hasNext()) {
+ Way wayToAdd = new Way();
+ wayToAdd.setKeys(way.getKeys());
+ newWays.add(wayToAdd);
+ wayToAdd.setNodes(chunkIt.next());
+ commandList.add(new AddCommand(layer, wayToAdd));
+ }
+ boolean warnmerole = false;
+ boolean warnme = false;
+ // now copy all relations to new way also
+
+ for (Relation r : getParentRelations(way)) {
+ if (!r.isUsable()) {
+ continue;
+ }
+ Relation c = null;
+ String type = r.get("type");
+ if (type == null) {
+ type = "";
+ }
+
+ int i_c = 0, i_r = 0;
+ List relationMembers = r.getMembers();
+ for (RelationMember rm : relationMembers) {
+ if (rm.isWay() && rm.getMember() == way) {
+ boolean insert = true;
+ if ("restriction".equals(type)) {
+ /*
+ * this code assumes the restriction is correct. No real
+ * error checking done
+ */
+ String role = rm.getRole();
+ if ("from".equals(role) || "to".equals(role)) {
+ OsmPrimitive via = null;
+ for (RelationMember rmv : r.getMembers()) {
+ if ("via".equals(rmv.getRole())) {
+ via = rmv.getMember();
+ }
+ }
+ List nodes = new ArrayList();
+ if (via != null) {
+ if (via instanceof Node) {
+ nodes.add((Node) via);
+ } else if (via instanceof Way) {
+ nodes.add(((Way) via).lastNode());
+ nodes.add(((Way) via).firstNode());
+ }
+ }
+ Way res = null;
+ for (Node n : nodes) {
+ if (changedWay.isFirstLastNode(n)) {
+ res = way;
+ }
+ }
+ if (res == null) {
+ for (Way wayToAdd : newWays) {
+ for (Node n : nodes) {
+ if (wayToAdd.isFirstLastNode(n)) {
+ res = wayToAdd;
+ }
+ }
+ }
+ if (res != null) {
+ if (c == null) {
+ c = getNew(r);
+ }
+ c.addMember(new RelationMember(role, res));
+ c.removeMembersFor(way);
+ insert = false;
+ }
+ } else {
+ insert = false;
+ }
+ } else if (!"via".equals(role)) {
+ warnme = true;
+ }
+ } else if (!("route".equals(type))
+ && !("multipolygon".equals(type))) {
+ warnme = true;
+ }
+ if (c == null) {
+ c = getNew(r);
+ }
+
+ if (insert) {
+ if (rm.hasRole() && !nowarnroles.contains(rm.getRole())) {
+ warnmerole = true;
+ }
+
+ Boolean backwards = null;
+ int k = 1;
+ while (i_r - k >= 0 || i_r + k < relationMembers.size()) {
+ if ((i_r - k >= 0)
+ && relationMembers.get(i_r - k).isWay()) {
+ Way w = relationMembers.get(i_r - k).getWay();
+ if ((w.lastNode() == way.firstNode())
+ || w.firstNode() == way.firstNode()) {
+ backwards = false;
+ } else if ((w.firstNode() == way.lastNode())
+ || w.lastNode() == way.lastNode()) {
+ backwards = true;
+ }
+ break;
+ }
+ if ((i_r + k < relationMembers.size())
+ && relationMembers.get(i_r + k).isWay()) {
+ Way w = relationMembers.get(i_r + k).getWay();
+ if ((w.lastNode() == way.firstNode())
+ || w.firstNode() == way.firstNode()) {
+ backwards = true;
+ } else if ((w.firstNode() == way.lastNode())
+ || w.lastNode() == way.lastNode()) {
+ backwards = false;
+ }
+ break;
+ }
+ k++;
+ }
+
+ int j = i_c;
+ for (Way wayToAdd : newWays) {
+ RelationMember em = new RelationMember(
+ rm.getRole(), wayToAdd);
+ j++;
+ if ((backwards != null) && backwards) {
+ c.addMember(i_c, em);
+ } else {
+ c.addMember(j, em);
+ }
+ }
+ i_c = j;
+ }
+ }
+ i_c++;
+ i_r++;
+ }
+
+ if (c != null) {
+ // commandList.add(new ChangeCommand(layer, r, c));
+ newRelations.put(r, c);
+ }
+ }
+ if (warnmerole) {
+ JOptionPane
+ .showMessageDialog(
+ Main.parent,
+ tr("A role based relation membership was copied to all new ways.
You should verify this and correct it when necessary.", null),
+ tr("Warning", null), JOptionPane.WARNING_MESSAGE);
+ } else if (warnme) {
+ JOptionPane
+ .showMessageDialog(
+ Main.parent,
+ tr("A relation membership was copied to all new ways.
You should verify this and correct it when necessary.", null),
+ tr("Warning", null), JOptionPane.WARNING_MESSAGE);
+ }
+
+ return new SplitWayResult(
+ new SequenceCommand("Split way", commandList), null,
+ changedWay, newWays);
+ }
+
+ /**
+ * @param ways
+ * @return null if ways cannot be combined. Otherwise returns the combined
+ * ways and the commands to combine
+ * @throws UserCancelException
+ */
+ private Pair> combineWaysWorker(Collection ways)
+ throws UserCancelException {
+
+ // prepare and clean the list of ways to combine
+ if (ways == null || ways.isEmpty())
+ return null;
+ ways.remove(null); // just in case - remove all null ways from the
+ // collection
+
+ // remove duplicates, preserving order
+ ways = new LinkedHashSet(ways);
+
+ // try to build a new way which includes all the combined ways
+ NodeGraph graph = NodeGraph.createUndirectedGraphFromNodeWays(ways);
+ List path = graph.buildSpanningPath();
+
+ // check whether any ways have been reversed in the process
+ // and build the collection of tags used by the ways to combine
+ TagCollection wayTags = TagCollection.unionOfAllPrimitives(ways);
+
+ List reversedWays = new LinkedList();
+ List unreversedWays = new LinkedList();
+ for (Way w : ways) {
+ if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w
+ .getNode(1))) {
+ unreversedWays.add(w);
+ } else {
+ reversedWays.add(w);
+ }
+ }
+ // reverse path if all ways have been reversed
+ if (unreversedWays.isEmpty()) {
+ Collections.reverse(path);
+ unreversedWays = reversedWays;
+ reversedWays = null;
+ }
+ if ((reversedWays != null) && !reversedWays.isEmpty()) {
+ // filter out ways that have no direction-dependent tags
+ unreversedWays = ReverseWayTagCorrector
+ .irreversibleWays(unreversedWays);
+ reversedWays = ReverseWayTagCorrector
+ .irreversibleWays(reversedWays);
+ // reverse path if there are more reversed than unreversed ways with
+ // direction-dependent tags
+ if (reversedWays.size() > unreversedWays.size()) {
+ Collections.reverse(path);
+ List tempWays = unreversedWays;
+ unreversedWays = reversedWays;
+ reversedWays = tempWays;
+ }
+ // if there are still reversed ways with direction-dependent tags,
+ // reverse their tags
+ if (!reversedWays.isEmpty()) {
+ List unreversedTagWays = new ArrayList(ways);
+ unreversedTagWays.removeAll(reversedWays);
+ ReverseWayTagCorrector reverseWayTagCorrector = new ReverseWayTagCorrector();
+ List reversedTagWays = new ArrayList();
+ Collection changePropertyCommands = null;
+ for (Way w : reversedWays) {
+ Way wnew = new Way(w);
+ reversedTagWays.add(wnew);
+ changePropertyCommands = reverseWayTagCorrector.execute(w,
+ wnew);
+ }
+ if ((changePropertyCommands != null)
+ && !changePropertyCommands.isEmpty()) {
+ for (Command c : changePropertyCommands) {
+ c.executeCommand();
+ }
+ }
+ wayTags = TagCollection.unionOfAllPrimitives(reversedTagWays);
+ wayTags.add(TagCollection
+ .unionOfAllPrimitives(unreversedTagWays));
+ }
+ }
+
+ // create the new way and apply the new node list
+ Way targetWay = getTargetWay(ways);
+ Way modifiedTargetWay = new Way(targetWay);
+ modifiedTargetWay.setNodes(path);
+
+ TagCollection completeWayTags = new TagCollection(wayTags);
+ combineTigerTags(completeWayTags);
+ normalizeTagCollectionBeforeEditing(completeWayTags, ways);
+ TagCollection tagsToEdit = new TagCollection(completeWayTags);
+ completeTagCollectionForEditing(tagsToEdit);
+
+ MyCombinePrimitiveResolverDialog dialog = MyCombinePrimitiveResolverDialog
+ .getInstance();
+ dialog.getTagConflictResolverModel().populate(tagsToEdit,
+ completeWayTags.getKeysWithMultipleValues());
+ dialog.setTargetPrimitive(targetWay);
+ Set parentRelations = getParentRelations(ways);
+ dialog.getRelationMemberConflictResolverModel().populate(
+ parentRelations, ways, oldWays);
+ dialog.prepareDefaultDecisions();
+
+ // resolve tag conflicts if necessary
+ if (askForMergeTag(ways) || duplicateParentRelations(ways)) {
+ dialog.setVisible(true);
+ if (dialog.isCancelled())
+ throw new UserCancelException();
+ }
+
+ LinkedList cmds = new LinkedList();
+ deletes.addAll(ways);
+ deletes.remove(targetWay);
+
+ cmds.add(new ChangeCommand(targetWay, modifiedTargetWay));
+ cmds.addAll(dialog.buildWayResolutionCommands());
+ dialog.buildRelationCorrespondance(newRelations, oldWays);
+
+ return new Pair>(targetWay, cmds);
+ }
+
+ private static Way getTargetWay(Collection combinedWays) {
+ // init with an arbitrary way
+ Way targetWay = combinedWays.iterator().next();
+
+ // look for the first way already existing on
+ // the server
+ for (Way w : combinedWays) {
+ targetWay = w;
+ if (!w.isNew()) {
+ break;
+ }
+ }
+ return targetWay;
+ }
+
+ /**
+ * @return has tag to be merged (=> ask)
+ */
+ private static boolean askForMergeTag(Collection ways) {
+ for (Way way : ways) {
+ for (Way oposite : ways) {
+ for (String key : way.getKeys().keySet()) {
+ if (!"source".equals(key) && oposite.hasKey(key)
+ && !way.get(key).equals(oposite.get(key))) {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @return has duplicate parent relation
+ */
+ private boolean duplicateParentRelations(Collection ways) {
+ Set relations = new HashSet();
+ for (Way w : ways) {
+ List rs = getParentRelations(w);
+ for (Relation r : rs) {
+ if (relations.contains(r)) {
+ return true;
+ }
+ }
+ relations.addAll(rs);
+ }
+ return false;
+ }
+
+ /**
+ * Replies the set of referring relations
+ *
+ * @return the set of referring relations
+ */
+ private List getParentRelations(Way way) {
+ List rels = new ArrayList();
+ for (Relation r : relations.get(way)) {
+ if (newRelations.containsKey(r)) {
+ rels.add(newRelations.get(r));
+ } else {
+ rels.add(r);
+ }
+ }
+ return rels;
+ }
+
+ private Relation getNew(Relation r) {
+ return getNew(r, newRelations);
+ }
+
+ public static Relation getNew(Relation r,
+ Map newRelations) {
+ if (newRelations.containsValue(r)) {
+ return r;
+ } else {
+ Relation c = new Relation(r);
+ newRelations.put(r, c);
+ return c;
+ }
+ }
+
+ private Way getOld(Way r) {
+ return getOld(r, oldWays);
+ }
+
+ public static Way getOld(Way w, Map oldWays) {
+ if (oldWays.containsKey(w)) {
+ return oldWays.get(w);
+ } else {
+ return w;
+ }
+ }
+
+ /**
+ * Replies the set of referring relations
+ *
+ * @return the set of referring relations
+ */
+ private Set getParentRelations(Collection ways) {
+ HashSet ret = new HashSet();
+ for (Way w : ways) {
+ ret.addAll(getParentRelations(w));
+ }
+ return ret;
+ }
+
+ /** Enable this action only if something is selected */
+ @Override
+ protected void updateEnabledState() {
+ if (getCurrentDataSet() == null) {
+ setEnabled(false);
+ } else {
+ updateEnabledState(getCurrentDataSet().getSelected());
+ }
+ }
+
+ /** Enable this action only if something is selected */
+ @Override
+ protected void updateEnabledState(
+ Collection selection) {
+ if (selection == null) {
+ setEnabled(false);
+ return;
+ }
+ for (OsmPrimitive primitive : selection) {
+ if (!(primitive instanceof Way) || primitive.isDeleted()) {
+ setEnabled(false);
+ return;
+ }
+ }
+ setEnabled(selection.size() >= 2);
+ }
}
Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java (revision 26704)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java (revision 26705)
@@ -19,10 +19,10 @@
public MergeOverlapPlugin(PluginInformation info) {
super(info);
- name = tr("Merge overlap");
+ name = tr("Merge overlap", null);
JMenu toolsMenu = null;
for (int i = 0; i < Main.main.menu.getMenuCount() && toolsMenu == null; i++) {
JMenu menu = Main.main.menu.getMenu(i);
String name = menu.getText();
- if (name != null && name.equals(tr("Tools"))) {
+ if (name != null && name.equals(tr("Tools", null))) {
toolsMenu = menu;
}
Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java (revision 26704)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java (revision 26705)
@@ -173,5 +173,5 @@
protected void updateTitle() {
if (targetPrimitive == null) {
- setTitle(tr("Conflicts when combining primitives"));
+ setTitle(tr("Conflicts when combining primitives", null));
return;
}
@@ -324,5 +324,5 @@
JPanel pnl = new JPanel();
pnl.setLayout(new BorderLayout());
- pnl.add(new JLabel(tr("No conflicts to resolve")));
+ pnl.add(new JLabel(tr("No conflicts to resolve", null)));
return pnl;
}
@@ -386,6 +386,6 @@
public CancelAction() {
- putValue(Action.SHORT_DESCRIPTION, tr("Cancel conflict resolution"));
- putValue(Action.NAME, tr("Cancel"));
+ putValue(Action.SHORT_DESCRIPTION, tr("Cancel conflict resolution", null));
+ putValue(Action.NAME, tr("Cancel", null));
putValue(Action.SMALL_ICON, ImageProvider.get("", "cancel"));
setEnabled(true);
@@ -401,6 +401,6 @@
public ApplyAction() {
- putValue(Action.SHORT_DESCRIPTION, tr("Apply resolved conflicts"));
- putValue(Action.NAME, tr("Apply"));
+ putValue(Action.SHORT_DESCRIPTION, tr("Apply resolved conflicts", null));
+ putValue(Action.NAME, tr("Apply", null));
putValue(Action.SMALL_ICON, ImageProvider.get("ok"));
updateEnabledState();
@@ -800,7 +800,7 @@
JPanel pnl = new JPanel();
pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
- pnl.add(new JLabel(tr("Role:")));
+ pnl.add(new JLabel(tr("Role:", null)));
pnl.add(tfRole = new AutoCompletingTextField(10));
- tfRole.setToolTipText(tr("Enter a role for all relation memberships"));
+ tfRole.setToolTipText(tr("Enter a role for all relation memberships", null));
pnl.add(new JButton(new ApplyRoleAction()));
tfRole.addActionListener(new ApplyRoleAction());
@@ -819,16 +819,16 @@
JPanel pnl = new JPanel();
pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
- cbTagRelations = new JCheckBox(tr("Tag modified relations with "));
+ cbTagRelations = new JCheckBox(tr("Tag modified relations with ", null));
cbTagRelations.addChangeListener(new ToggleTagRelationsAction());
cbTagRelations.setToolTipText(
tr("Select to enable entering a tag which will be applied
"
- + "to all modified relations."));
+ + "to all modified relations.