Changeset 2573 in josm for trunk

Timestamp:

2009-12-04T18:34:31+01:00 (14 years ago)

Author:

stoecker

Message:

applied #4068 - patch by mjulius - fix combine way and way reversing

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/CombineWayAction.java (modified) (3 diffs)
• corrector/ReverseWayTagCorrector.java (modified) (3 diffs)
• data/osm/OsmUtils.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/actions/CombineWayAction.java

@@ -28 +28 @@
 import org.openstreetmap.josm.command.DeleteCommand;
 import org.openstreetmap.josm.command.SequenceCommand;
+import org.openstreetmap.josm.corrector.ReverseWayTagCorrector;
+import org.openstreetmap.josm.corrector.UserCancelException;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
@@ -37 +39 @@
 import org.openstreetmap.josm.tools.Pair;
 import org.openstreetmap.josm.tools.Shortcut;
+
 /**
  * Combines multiple ways into one.
@@ -109 +112 @@
         ways = new HashSet<Way>(ways); // remove duplicates
 
-        // build the collection of tags used by the ways to combine
-        //
-        TagCollection wayTags = TagCollection.unionOfAllPrimitives(ways);
-
         // try to build a new way which includes all the combined
         // ways
         //
-        NodeGraph graph = NodeGraph.createDirectedGraphFromWays(ways);
+        NodeGraph graph = NodeGraph.createUndirectedGraphFromNodeWays(ways);
         List<Node> path = graph.buildSpanningPath();
         if (path == null) {
-            graph = NodeGraph.createUndirectedGraphFromNodeWays(ways);
-            path = graph.buildSpanningPath();
-            if (path != null) {
-                if (!confirmChangeDirectionOfWays())
-                    return;
+            warnCombiningImpossible();
+            return;
+        }
+        // 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<Way> reversedWays = new LinkedList<Way>();
+        List<Way> unreversedWays = new LinkedList<Way>();
+        for (Way w: ways) {
+            if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w.getNode(1))) {
+                unreversedWays.add(w);
             } else {
-                warnCombiningImpossible();
-                return;
-            }
-        }
+                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()) {
+            if (!confirmChangeDirectionOfWays()) return;
+            // 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<Way> tempWays = unreversedWays;
+                unreversedWays = reversedWays;
+                reversedWays = tempWays;
+            }
+            // if there are still reversed ways with direction-dependent tags, reverse their tags
+            if (!reversedWays.isEmpty() && Main.pref.getBoolean("tag-correction.reverse-way", true)) {
+                List<Way> unreversedTagWays = new ArrayList<Way>(ways);
+                unreversedTagWays.removeAll(reversedWays);
+                ReverseWayTagCorrector reverseWayTagCorrector = new ReverseWayTagCorrector();
+                List<Way> reversedTagWays = new ArrayList<Way>();
+                Collection<Command> changePropertyCommands =  null;
+                for (Way w : reversedWays) {
+                    Way wnew = new Way(w);
+                    reversedTagWays.add(wnew);
+                    try {
+                        changePropertyCommands = reverseWayTagCorrector.execute(w, wnew);
+                    }
+                    catch(UserCancelException ex) {
+                        return;
+                    }
+                }
+                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

trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java

@@ -69 +69 @@
     };
 
+    public static boolean isReversible(Way way) {
+        ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
+        primitives.add(way);
+        primitives.addAll(way.getNodes());
+
+        for  (OsmPrimitive primitive : primitives) {
+            for (String key : primitive.keySet()) {
+                if (key.equals("oneway")) return false;
+                for (PrefixSuffixSwitcher prefixSuffixSwitcher : prefixSuffixSwitchers) {
+                    if (!key.equals(prefixSuffixSwitcher.apply(key))) return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static List<Way> irreversibleWays(List<Way> ways) {
+        List<Way> newWays = new ArrayList<Way>(ways);
+        for (Way way : ways) {
+            if (isReversible(way)) {
+                newWays.remove(way);
+            }
+        }
+        return newWays;
+    }
+
     @Override
     public Collection<Command> execute(Way oldway, Way way) throws UserCancelException {
         Map<OsmPrimitive, List<TagCorrection>> tagCorrectionsMap =
-                new HashMap<OsmPrimitive, List<TagCorrection>>();
+            new HashMap<OsmPrimitive, List<TagCorrection>>();
 
         ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
@@ -87 +114 @@
 
                 if (key.equals("oneway")) {
-                    if (value.equals("-1")) {
+                    if (OsmUtils.isReversed(value)) {
                         newValue = OsmUtils.trueval;
                     } else {
                         Boolean boolValue = OsmUtils.getOsmBoolean(value);
                         if (boolValue != null && boolValue.booleanValue()) {
-                            newValue = "-1";
+                            newValue = OsmUtils.reverseval;
                         }
                     }
@@ -112 +139 @@
 
         Map<OsmPrimitive, List<RoleCorrection>> roleCorrectionMap =
-                new HashMap<OsmPrimitive, List<RoleCorrection>>();
+            new HashMap<OsmPrimitive, List<RoleCorrection>>();
         roleCorrectionMap.put(way, new ArrayList<RoleCorrection>());
 

trunk/src/org/openstreetmap/josm/data/osm/OsmUtils.java

@@ -12 +12 @@
     static ArrayList<String> FALSE_VALUES = new ArrayList<String>(Arrays
             .asList(new String[] { "false", "no", "0", "off" }));
+    static ArrayList<String> REVERSE_VALUES = new ArrayList<String>(Arrays
+            .asList(new String[] { "reverse", "-1" }));
 
     public static final String trueval = "yes";
     public static final String falseval = "no";
+    public static final String reverseval = "-1";
 
     public static Boolean getOsmBoolean(String value) {
@@ -23 +26 @@
         return null;
     }
+
     public static String getNamedOsmBoolean(String value) {
         Boolean res = getOsmBoolean(value);
         return res == null ? value : (res ? trueval : falseval);
     }
+
+    public static boolean isReversed(String value) {
+        return REVERSE_VALUES.contains(value);
+    }
 }