Changeset 27998 in osm for applications/editors/josm/plugins

Timestamp:

2012-03-06T11:17:12+01:00 (13 years ago)

Author:

akks

Message:

'Utilsplugin2: search speed-up, added adjacent and connected keywords (search for ways only)'

Location:

applications/editors/josm/plugins/utilsplugin2

Files:

• build.xml (modified) (1 diff)
• src/utilsplugin2/UtilsPlugin2.java (modified) (8 diffs)
• src/utilsplugin2/selection/AdjacentWaysAction.java (modified) (1 diff)
• src/utilsplugin2/selection/NodeWayUtils.java (modified) (6 diffs)

applications/editors/josm/plugins/utilsplugin2/build.xml

@@ -30 +30 @@
 <project name="utilsplugin2" default="dist" basedir=".">
     <!-- enter the SVN commit message -->
-    <property name="commit.message" value="Utilsplugin2: fixing shortcut conflicts, one better key"/>
+    <property name="commit.message" value="Utilsplugin2: search speed-up, added adjacent and connected keywords (search for ways only)"/>
     <!-- enter the *lowest* JOSM version this plugin is currently compatible with -->
     <property name="plugin.main.version" value="4980"/>

applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/UtilsPlugin2.java

@@ -2 +2 @@
 package utilsplugin2;
 
+import org.openstreetmap.josm.data.osm.Node;
 import utilsplugin2.customurl.ChooseURLAction;
 import utilsplugin2.customurl.OpenPageAction;
@@ -151 +152 @@
     public static class UtilsUnaryMatchFactory implements UnaryMatchFactory {
         private static Collection<String> keywords = Arrays.asList("inside",
-                "intersecting", "allintersecting");
+                "intersecting", "allintersecting", "adjacent", "connected");
         
         @Override
@@ -157 +158 @@
             if ("inside".equals(keyword))
                 return new InsideMatch(matchOperand);
+            else if ("adjacent".equals(keyword))
+                return new ConnectedMatch(matchOperand, false);
+            else if ("connected".equals(keyword))
+                return new ConnectedMatch(matchOperand, true);
             else if ("intersecting".equals(keyword))
                 return new IntersectingMatch(matchOperand, false);
@@ -178 +183 @@
         public InsideMatch(Match match) {
             super(match);
-            init();
+            //init();
         }
         
@@ -185 +190 @@
          */
         private void init() {
+            if (inside==null) init(); // lazy initialization
             Collection<OsmPrimitive> matchedAreas = new HashSet<OsmPrimitive>();
 
@@ -212 +218 @@
     public static class IntersectingMatch extends UnaryMatch {
         private Collection<Way> intersecting = null;
+        boolean all;
         
         public IntersectingMatch(Match match, boolean all) {
             super(match);
-            init(all);
+            this.all=all;
+            //init(all);
         }   
         
@@ -241 +249 @@
         @Override
         public boolean match(OsmPrimitive osm) {
+            if (intersecting==null) init(all); // lazy initialization
             if (osm instanceof Way)
                 return intersecting.contains((Way)osm);
@@ -246 +255 @@
         }
     }
+    
+    public static class ConnectedMatch extends UnaryMatch {
+        private Collection<Way> connected = null;
+        boolean all;
+        
+        public ConnectedMatch(Match match, boolean all) {
+            super(match);
+            this.all=all;
+        }   
+        
+        /**
+         * Find (all) ways intersecting ways which match the expression.
+         */
+        private void init(boolean all) {
+            Collection<Way> matchedWays = new HashSet<Way>();
+            Set<Node> matchedNodes = new HashSet<Node>();
+            
+            // find all ways that match the expression
+            Collection<Way> allWays = Main.main.getCurrentDataSet().getWays();
+            for (Way way : allWays) {
+                if (match.match(way))
+                    matchedWays.add(way);
+            }
+            
+            // find all nodes that match the expression
+            Collection<Node> allNodes = Main.main.getCurrentDataSet().getNodes();
+            for (Node node: allNodes) {
+                if (match.match(node))
+                    matchedNodes.add(node);
+            }
+            
+            Set<Way> newWays = new HashSet<Way>();
+            if (all) {
+                NodeWayUtils.addWaysConnectedToNodes(matchedNodes, newWays);
+                NodeWayUtils.addWaysConnectedToWaysRecursively(matchedWays, newWays);
+            } else {
+                NodeWayUtils.addWaysConnectedToNodes(matchedNodes, newWays);
+                NodeWayUtils.addWaysConnectedToWays(matchedWays, newWays);
+            }
+            connected = newWays;
+        }
+        
+        @Override
+        public boolean match(OsmPrimitive osm) {
+            if (connected==null) init(all); // lazy initialization
+            if (osm instanceof Way)
+                return connected.contains((Way)osm);
+            return false;
+        }
+    }   
+    
 }

applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/selection/AdjacentWaysAction.java

@@ -38 +38 @@
         // select ways attached to already selected ways
         Set<Way> newWays = new HashSet<Way>();
+        NodeWayUtils.addWaysConnectedToWays(selectedWays, newWays);
         newWays.addAll(selectedWays);
-        for (Way w : selectedWays){
-            NodeWayUtils.addWaysConnectedToWay(w, newWays);
-        }
 
         // selecting ways attached to selected nodes

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

@@ -30 +30 @@
 public final class NodeWayUtils {
 
-    static final int maxLevel = Main.pref.getInteger("selection.maxrecursion", 5);
+    static final int maxLevel = Main.pref.getInteger("selection.maxrecursion", 15);
     static final int maxWays = Main.pref.getInteger("selection.maxfoundways", 2000);
     static final int maxWays1 = Main.pref.getInteger("selection.maxfoundways.intersection", 500);
@@ -73 +73 @@
          int s = ways.size();
         List<Node> nodes = w.getNodes();
+        boolean flag = ways.contains(w);
         for (Node n: nodes) {
             ways.addAll(OsmPrimitive.getFilteredList(n.getReferrers(), Way.class));
         }
+        if (!flag) ways.remove(w);
         return ways.size() - s;
     }
@@ -155 +157 @@
         return count;
     }
-
-    static int addWaysConnectedToNodes(Set<Node> selectedNodes, Set<Way> newWays) {
+    
+    public static void addWaysConnectedToWays(Collection<Way> ways, Set<Way> newWays) {
+        for (Way w : ways){
+            NodeWayUtils.addWaysConnectedToWay(w, newWays);
+        }
+    }
+
+    public static int addWaysConnectedToNodes(Set<Node> selectedNodes, Set<Way> newWays) {
         int s = newWays.size();
         for (Node node: selectedNodes) {
@@ -164 +172 @@
     }
 
-    static int addNodesConnectedToWays(Set<Way> initWays, Set<Node> newNodes) {
+    public static int addNodesConnectedToWays(Set<Way> initWays, Set<Node> newNodes) {
         int s = newNodes.size();
         for (Way w: initWays) {
@@ -202 +210 @@
     }
 
- static void addWaysConnectedToWaysRecursively
+    public static void addWaysConnectedToWaysRecursively
             (Collection<Way> initWays, Set<Way> newWays)
     {
@@ -493 +501 @@
 
 
+
 }