Changeset 34932 in osm for applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap

Timestamp:

2019-03-24T06:43:16+01:00 (6 years ago)

Author:

gerdp

Message:

fix #17483: respect active filters in select actions provided by utilsplugin2

Location:

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection

Files:

• NodeWayUtils.java (modified) (19 diffs)
• SelectHighwayAction.java (modified) (1 diff)
• SelectModNodesAction.java (modified) (1 diff)
• SelectModWaysAction.java (modified) (1 diff)
• SelectWayNodesAction.java (modified) (1 diff)
• UndoSelectionAction.java (modified) (1 diff)

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/NodeWayUtils.java

@@ -40 +40 @@
     }
 
+    private static <T extends OsmPrimitive> void filteredAdd(Collection<T> collection, T element) {
+        if (!element.isDisabled()) {
+            collection.add(element);
+        }
+    }
+
+    private static <T extends OsmPrimitive> void filteredAddAll(Collection<T> out, Collection<T> in) {
+        for (T element: in) {
+            filteredAdd(out, element);
+        }
+    }
+
     /**
      * Find the neighbours of node n on the way w and put them in given collection
@@ -56 +68 @@
         // add previous element
         if (idx > 0) {
-            nodes.add(nodeList.get(idx - 1));
+            filteredAdd(nodes, nodeList.get(idx - 1));
         }
         // add next element
         if (idx < nodeList.size() - 1) {
-            nodes.add(nodeList.get(idx + 1));
+            filteredAdd(nodes, nodeList.get(idx + 1));
         }
         if (w.isClosed()) {
             // cyclic neighbours detection
             if (idx == 0) {
-                nodes.add(nodeList.get(nodeList.size() - 2));
+                filteredAdd(nodes, nodeList.get(nodeList.size() - 2));
             }
             if (idx == nodeList.size() - 1) {
-                nodes.add(nodeList.get(1));
+                filteredAdd(nodes, nodeList.get(1));
             }
         }
@@ -84 +96 @@
         boolean flag = ways.contains(w);
         for (Node n: nodes) {
-            ways.addAll(n.getParentWays());
+            filteredAddAll(ways, n.getParentWays());
         }
         if (!flag) ways.remove(w);
@@ -98 +110 @@
     static int addWaysConnectedToNode(Node n, Set<Way> ways) {
         int s = ways.size();
-        ways.addAll(n.getParentWays());
+        filteredAddAll(ways, n.getParentWays());
         return ways.size() - s;
     }
@@ -107 +119 @@
      * @param w way to check intersections
      * @param newWays set to place the ways we found
+     * @param excludeWays set of excluded ways
      * @return number of ways possibly added added to newWays
      */
@@ -113 +126 @@
         int count = 0;
         for (Way anyway: ways) {
+            if (anyway.isDisabled()) continue;
             if (Objects.equals(anyway, w)) continue;
             if (newWays.contains(anyway) || excludeWays.contains(anyway)) continue;
@@ -133 +147 @@
 
     static int addWaysIntersectingWay(Collection<Way> ways, Way w, Set<Way> newWays) {
-        List<Pair<Node, Node>> nodePairs = w.getNodePairs(false);
-        int count = 0;
-        for (Way anyway: ways) {
-            if (Objects.equals(anyway, w)) continue;
-            if (newWays.contains(anyway)) continue;
-            List<Pair<Node, Node>> nodePairs2 = anyway.getNodePairs(false);
-            loop: for (Pair<Node, Node> p1 : nodePairs) {
-                for (Pair<Node, Node> p2 : nodePairs2) {
-                    if (null != Geometry.getSegmentSegmentIntersection(
-                            p1.a.getEastNorth(), p1.b.getEastNorth(),
-                            p2.a.getEastNorth(), p2.b.getEastNorth())) {
-                        newWays.add(anyway);
-                        count++;
-                        break loop;
-                    }
-                }
-            }
-        }
-        return count;
+        Set<Way> excludeWays = new HashSet<Way>();
+        return addWaysIntersectingWay(ways, w, newWays, excludeWays);
     }
 
@@ -162 +159 @@
      */
     public static int addWaysIntersectingWays(Collection<Way> allWays, Collection<Way> initWays, Set<Way> newWays) {
+        // performance improvement - filter everything ahead of time
+        Set<Way> filteredWays = new HashSet<>();
+        filteredAddAll(filteredWays, allWays);
         int count = 0;
         for (Way w : initWays) {
-            count += addWaysIntersectingWay(allWays, w, newWays);
+            count += addWaysIntersectingWay(filteredWays, w, newWays);
         }
         return count;
@@ -196 +196 @@
         newWays.addAll(initWays);
         Set<Way> newFoundWays;
+        // performance improvement - apply filters ahead of time
+        Set<Way> filteredWays = new HashSet<>();
+        filteredAddAll(filteredWays, allWays);
+        filteredWays.removeAll(initWays);
 
         int level = 0, c;
@@ -202 +206 @@
             newFoundWays = new HashSet<>();
             for (Way w : foundWays) {
-                c += addWaysIntersectingWay(allWays, w, newFoundWays, newWays);
+                c += addWaysIntersectingWay(filteredWays, w, newFoundWays);
             }
             foundWays = newFoundWays;
@@ -213 +217 @@
                 return;
             }
-        } while (c > 0 && level < maxLevel);
+            if (level >= maxLevel) {
+                new Notification(
+                        tr("Reached max recursion depth: {0}", level)
+                        ).setIcon(JOptionPane.WARNING_MESSAGE).show();
+                return;
+            }
+        } while (c > 0);
     }
 
@@ -233 +243 @@
                 return;
             }
-        } while (c > 0 && level < maxLevel);
+            if (level >= maxLevel) {
+                new Notification(
+                        tr("Reached max recursion depth: {0}", level)
+                        ).setIcon(JOptionPane.WARNING_MESSAGE).show();
+                return;
+            }
+        } while (c > 0);
     }
 
@@ -256 +272 @@
                     if ((i2-i1)*2 <= n) { // i1 ... i2
                         for (int i = i1+1; i != i2; i++) {
-                            newNodes.add(nodes.get(i));
+                            filteredAdd(newNodes, nodes.get(i));
                         }
                     } else { // i2 ... n-1 0 1 ... i1
                         for (int i = i2+1; i != i1; i = (i+1) % n) {
-                            newNodes.add(nodes.get(i));
+                            filteredAdd(newNodes, nodes.get(i));
                         }
                     }
                 } else {
                     for (int i = i1+1; i < i2; i++) {
-                        newNodes.add(nodes.get(i));
+                        filteredAdd(newNodes, nodes.get(i));
                     }
                 }
@@ -331 +347 @@
                 //we came to starting way, but not not the right end
                 if (Objects.equals(otherEnd, firstWay.firstNode())) return false;
-                newWays.addAll(newestWays);
+                filteredAddAll(newWays, newestWays);
                 return true; // correct loop found
             }
@@ -362 +378 @@
             //if (Geometry.nodeInsidePolygon(n, polyNodes)) {
             if (NodeWayUtils.isPointInsidePolygon(n.getEastNorth(), polyPoints)) {
+                // can't filter nodes here, would prevent selecting ways that have filtered nodes
                 newestNodes.add(n);
             }
@@ -369 +386 @@
         for (Way w : searchWays) {
             if (newestNodes.containsAll(w.getNodes())) {
-                newestWays.add(w);
+                filteredAdd(newestWays, w);
             }
         }
@@ -377 +394 @@
         }
 
-        newNodes.addAll(newestNodes);
-        newWays.addAll(newestWays);
+        filteredAddAll(newNodes, newestNodes);
+        newWays.addAll(newestWays); // already filtered
     }
 
@@ -392 +409 @@
             //if (Geometry.nodeInsidePolygon(n, polyNodes)) {
             if (NodeWayUtils.isPointInsidePolygon(n.getEastNorth(), polyPoints)) {
+                // can't filter nodes here, would prevent selecting ways that have filtered nodes
                 newestNodes.add(n);
             }
@@ -399 +417 @@
         for (Way w : searchWays) {
             if (newestNodes.containsAll(w.getNodes())) {
-                newestWays.add(w);
-            }
-        }
-
-        newNodes.addAll(newestNodes);
-        newWays.addAll(newestWays);
+                filteredAdd(newestWays, w);
+            }
+        }
+
+        filteredAddAll(newNodes, newestNodes);
+        newWays.addAll(newestWays); // already filtered
     }
 

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/SelectHighwayAction.java

@@ -65 +65 @@
                 Node node = nodeQueue.remove();
                 for (Way p : node.getParentWays()) {
-                    if (!newWays.contains(p) && p.hasKey(key) && p.get(key).equals(value)) {
+                    if (!p.isDisabled() && !newWays.contains(p) && p.hasKey(key) && p.get(key).equals(value)) {
                         newWays.add(p);
                         nodeQueue.add(p.firstNode().equals(node) ? p.lastNode() : p.firstNode());

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/SelectModNodesAction.java

@@ -60 +60 @@
                     nodes.clear();
                     for (OsmPrimitive p : pp) {  // find all affected ways
-                        if (p instanceof Node && !p.isDeleted()) nodes.add((Node) p);
+                        if (p instanceof Node && !p.isDeleted() && !p.isDisabled())
+                            nodes.add((Node) p);
                     }
                     if (!nodes.isEmpty() && !ds.getSelectedNodes().containsAll(nodes)) {

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/SelectModWaysAction.java

@@ -60 +60 @@
                     for (OsmPrimitive p : pp) {
                         // find all affected ways
-                        if (p instanceof Way && !p.isDeleted()) ways.add((Way) p);
+                        if (p instanceof Way && !p.isDeleted() && !p.isDisabled())
+                            ways.add((Way) p);
                     }
                     if (!ways.isEmpty() && !ds.getSelectedWays().containsAll(ways)) {

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/SelectWayNodesAction.java

@@ -68 +68 @@
                 selectedNodes = new ArrayList<>();
             }
-            selectedNodes.add(n);
+            if (!n.isDisabled()) selectedNodes.add(n);
         }
     }

applications/editors/josm/plugins/utilsplugin2/src/org/openstreetmap/josm/plugins/utilsplugin2/selection/UndoSelectionAction.java

@@ -58 +58 @@
                 newSel.clear();
                 newSel.addAll(histsel);
-                newSel.removeIf(p -> p == null || p.isDeleted());
+                newSel.removeIf(p -> p == null || p.isDeleted() || p.isDisabled());
                 k++;
                 if (!newSel.isEmpty()) {