Ticket #15170: simplifyway2.patch

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

@@ -7 +7 @@
 
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import javax.swing.JOptionPane;
 import javax.swing.SwingUtilities;
@@ -134 +127 @@
      *
      * @param way the way to be simplified
      * @param node the node to check
-     * @return true if <code>node</code> is a required node which can't be removed
+     * @param hist precounted frequencies of nodes in way
+         * @return true if <code>node</code> is a required node which can't be removed
      * in order to simplify the way.
      */
-    protected static boolean isRequiredNode(Way way, Node node) {
-        int frequency = Collections.frequency(way.getNodes(), node);
+    protected static boolean isRequiredNode(Way way, Node node, Map<Node, Integer> hist) {
+
+                // node is more than once in given way
+        int frequency = hist.get(node);
         if ((way.getNode(0) == node) && (way.getNode(way.getNodesCount()-1) == node)) {
             frequency = frequency - 1; // closed way closing node counted only once
         }
-        boolean isRequired = frequency > 1;
-        if (!isRequired) {
-            List<OsmPrimitive> parents = new LinkedList<>();
-            parents.addAll(node.getReferrers());
-            parents.remove(way);
-            isRequired = !parents.isEmpty();
-        }
-        if (!isRequired) {
-            isRequired = node.isTagged();
-        }
-        return isRequired;
+        if (frequency > 1){
+                return true;
+                }
+
+                // other referrers than given way
+                List<OsmPrimitive> parents = new LinkedList<>();
+                parents.addAll(node.getReferrers());
+                parents.remove(way);
+                if (!parents.isEmpty()){
+                        return true;
+                }
+
+                // has tags??
+        return node.isTagged();
     }
 
     /**
@@ -177 +176 @@
     public static SequenceCommand simplifyWay(Way w, double threshold) {
         int lower = 0;
         int i = 0;
+
         List<Node> newNodes = new ArrayList<>(w.getNodesCount());
+                Map<Node, Integer> hist = makeHistogram(w.getNodes());
+
         while (i < w.getNodesCount()) {
-            if (isRequiredNode(w, w.getNode(i))) {
+            if (isRequiredNode(w, w.getNode(i), hist)) {
                 // copy a required node to the list of new nodes. Simplify not possible
                 newNodes.add(w.getNode(i));
                 i++;
@@ -188 +190 @@
             }
             i++;
             // find the longest sequence of not required nodes ...
-            while (i < w.getNodesCount() && !isRequiredNode(w, w.getNode(i))) {
+            while (i < w.getNodesCount() && !isRequiredNode(w, w.getNode(i), hist)) {
                 i++;
             }
             // ... and simplify them
@@ -198 +200 @@
         }
 
         // Closed way, check if the first node could also be simplified ...
-        if (newNodes.size() > 3 && newNodes.get(0) == newNodes.get(newNodes.size() - 1) && !isRequiredNode(w, newNodes.get(0))) {
+        if (newNodes.size() > 3 && newNodes.get(0) == newNodes.get(newNodes.size() - 1) && !isRequiredNode(w, newNodes.get(0), hist)) {
             final List<Node> l1 = Arrays.asList(newNodes.get(newNodes.size() - 2), newNodes.get(0), newNodes.get(1));
             final List<Node> l2 = new ArrayList<>(3);
             buildSimplifiedNodeList(l1, 0, 2, threshold, l2);
@@ -208 +210 @@
             }
         }
 
-        Set<Node> delNodes = new HashSet<>();
-        delNodes.addAll(w.getNodes());
-        delNodes.removeAll(newNodes);
+                Set<Node> delNodes = new HashSet<>(w.getNodes());
+                for (Node n : newNodes) {
+                        delNodes.remove(n);
+                }
 
         if (delNodes.isEmpty()) return null;
 
@@ -224 +227 @@
                 trn("Simplify Way (remove {0} node)", "Simplify Way (remove {0} nodes)", delNodes.size(), delNodes.size()), cmds);
     }
 
-    /**
+        private static Map<Node, Integer> makeHistogram(List<Node> nodes) {
+        Map<Node, Integer> h = new HashMap<>(nodes.size());
+                for (Node node : nodes) {
+                        Integer c = h.get(node);
+                        if (c == null){
+                                h.put(node, 1);
+                        }
+                        else {
+                                h.put(node, c + 1);
+                        }
+                }
+                return h;
+        }
+
+        /**
      * Builds the simplified list of nodes for a way segment given by a lower index <code>from</code>
      * and an upper index <code>to</code>
      *