Changeset 23967 in osm

Timestamp:

2010-10-31T17:18:52+01:00 (14 years ago)

Author:

oliverw

Message:

• Bugfix: Address cache did not consider all objects -> moved to NodeFactory
• Bugfix: Process also ways when changing a tag

Location:

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses

Files:

• AddressEditContainer.java (modified) (9 diffs)
• AddressFinderThread.java (modified) (1 diff)
• AddressNode.java (modified) (2 diffs)
• NodeEntityBase.java (modified) (1 diff)
• NodeFactory.java (modified) (2 diffs)
• SelectIncompleteAddressesAction.java (modified) (1 diff)

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressEditContainer.java

@@ -68 +68 @@
         private List<AddressNode> shadowIncompleteAddresses = new ArrayList<AddressNode>(100);
         
-        private HashMap<String, AddressNode> addressCache = new HashMap<String, AddressNode>();
         private HashSet<Node> visitedNodes = new HashSet<Node>();
         private HashSet<Way> visitedWays = new HashSet<Way>();
@@ -135 +134 @@
                 }
 
+                AddressNode aNode = null;
                 // Address nodes are recycled in order to keep instance variables like guessed names
-                String aid = "" + n.getId();
-                AddressNode aNode = null;
-                if (!addressCache.containsKey(aid)) {
-                        aNode = NodeFactory.createNode(n);
-                        if (aNode != null) {
-                                addressCache.put(aid, aNode);
-                        }
-                } else {
-                        aNode = addressCache.get(aid);
-                        aNode.setOsmObject(n);
-                }
-                
+                aNode = NodeFactory.createNode(n);
+                                                
                 if (aNode != null) {
                         addAndClassifyAddress(aNode);
-                } else {
+                } /*else {
                         // check, if node is referred by a way
                         for (OsmPrimitive osm : n.getReferrers()) {
@@ -161 +151 @@
                         }
                         
-                }
+                }*/
                 markNodeAsVisited(n);
         }
+        
+        /* (non-Javadoc)
+         * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Way)
+         */
+        @Override
+        public void visit(Way w) {
+                // This doesn't matter, we just need the street name 
+                //if (w.isIncomplete()) return;
+                
+                if (hasBeenVisited(w)) {
+                        return;
+                }
+                
+                createNodeFromWay(w);
+                markWayAsVisited(w);
+        }
+
 
         private void addAndClassifyAddress(AddressNode aNode) {
@@ -176 +183 @@
         }
         
-        /* (non-Javadoc)
-         * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Way)
-         */
-        @Override
-        public void visit(Way w) {
-                // This doesn't matter, we just need the street name 
-                //if (w.isIncomplete()) return;
-                
-                createNodeFromWay(w);
-                /*
-        for (Node n : w.getNodes()) {
-            
-        }*/
-        }
 
         /**
@@ -198 +191 @@
         private void createNodeFromWay(Way w) {
                 INodeEntity ne = NodeFactory.createNodeFromWay(w);
-                
-                processNode(ne, w);
-                
-                markWayAsVisited(w);
-                
-                // Look also into nodes for addresses (unlikely, but at least they
-                // get marked as visited).
-                for (Node n : w.getNodes()) {
-                        visit(n);
-                }
-                
-                for (String key : w.keySet()) {
-                        if (!tags.contains(key)) {
-                                tags.add(key);
+
+                
+                if (!processNode(ne, w)) {
+
+                        // Look also into nodes for addresses (unlikely, but at least they
+                        // get marked as visited).
+                        for (Node n : w.getNodes()) {
+                                visit(n);
+                        }
+
+                        for (String key : w.keySet()) {
+                                if (!tags.contains(key)) {
+                                        tags.add(key);
+                                }
                         }
                 }
@@ -219 +212 @@
          * Process a entity node.
          *
-         * @param ne the ne
-         * @param w the w
-         */
-        private void processNode(INodeEntity ne, Way w) {
+         * @param ne the entity node.
+         * @param w the corresponding OSM way
+         * @return true, if node has been processed
+         */
+        private boolean processNode(INodeEntity ne, Way w) {
                 if (ne != null) {
+                        // Node is a street (segment)
                         if (ne instanceof StreetSegmentNode) {
                                 StreetSegmentNode newSegment = (StreetSegmentNode) ne;
@@ -229 +224 @@
                                 if (newSegment != null) {
                                         String name = newSegment.getName();
-                                        if (StringUtils.isNullOrEmpty(name)) return;
+                                        if (StringUtils.isNullOrEmpty(name)) return false;
 
                                         StreetNode sNode = null;
@@ -243 +238 @@
                                                 // names are the same. Then the streets should be split up...
                                                 sNode.addStreetSegment(newSegment);
+                                                return true;
                                         } else {
                                                 throw new RuntimeException("Street node is null!");
@@ -252 +248 @@
                         if (ne instanceof AddressNode) {
                                 AddressNode aNode = (AddressNode) ne;
-                                addAndClassifyAddress(aNode);                   
-                        }
-                }
+                                addAndClassifyAddress(aNode);
+                                return true;
+                        }
+                }
+                return false;
         }
 

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressFinderThread.java

@@ -172 +172 @@
                                 if (nearestName != null) {
                                         progressMonitor.subTask(String.format("%s: %s (%4.1f m)", tr("Guess"), nearestName, minDist));
+                                        System.out.println("Guessed street: " + nearestName + " for node " + aNode);
                                         aNode.setGuessedStreetName(nearestName);
                                         nearestName = null;
+                                } else {
+                                        System.out.println("Did not find a street for " + aNode);
                                 }
                                 // report progress

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressNode.java

@@ -49 +49 @@
         public String getStreet() {
                 if (osmObject == null) return MISSING_TAG;
-                
+                /*
                 if (!TagUtils.hasAddrStreetTag(osmObject)) {
                         // check, if referrers have a street
@@ -62 +62 @@
                         }
                         return MISSING_TAG; // nothing found
-                }
-                return TagUtils.getAddrStreetValue(osmObject);
+                }*/
+                if (!TagUtils.hasAddrStreetTag(osmObject)) {
+                        return MISSING_TAG;
+                } else {
+                        String sName = TagUtils.getAddrStreetValue(osmObject);
+                        if (!StringUtils.isNullOrEmpty(sName)) {
+                                return sName;
+                        } else {
+                                return MISSING_TAG;
+                        }
+                }
         }
         

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/NodeEntityBase.java

@@ -111 +111 @@
          */
         protected void setOSMTag(String tag, String newValue) {
-                Node oldNode = (Node)osmObject;
-                OsmPrimitive newNode = new Node(oldNode);
-                newNode.put(tag, newValue);
-                Main.main.undoRedo.add( new ChangeCommand(oldNode, newNode));
-                fireEntityChanged(this);
+                OsmPrimitive oldObject = osmObject;
+                OsmPrimitive newObject = null;
+                        
+                // I would appreciate a clone method...
+                if (oldObject instanceof Node) {
+                        newObject = new Node();
+                } else if (oldObject instanceof Way) {
+                        newObject = new Way();
+                }
+                
+                if (newObject != null) {
+                        newObject.cloneFrom(oldObject);
+                        newObject.put(tag, newValue);
+                        Main.main.undoRedo.add( new ChangeCommand(oldObject, newObject));
+                        fireEntityChanged(this);
+                } else {
+                        throw new RuntimeException("Cannot modify tag for " + osmObject);
+                }
         }
 

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/NodeFactory.java

@@ -14 +14 @@
 package org.openstreetmap.josm.plugins.fixAddresses;
 
+import java.util.HashMap;
+
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
 
 public class NodeFactory {
+        private static HashMap<String, AddressNode> addressCache = new HashMap<String, AddressNode>();
+        
         /**
          * Creates an address node from an OSM node, if possible.
-         * @param osm
+         * @param node
          * @return
          */
-        public static AddressNode createNode(Node osm) {
-                if (TagUtils.isAddress(osm)) {
-                        return new AddressNode(osm);
+        public static AddressNode createNode(Node node) {
+                if (TagUtils.isAddress(node)) {
+                        String aid = "" + node.getId();
+                        
+                        AddressNode aNode = lookup(aid);
+                        if (aNode == null) {
+                                aNode = new AddressNode(node);
+                                addressCache.put(aid, aNode);
+                        } else {
+                                aNode.setOsmObject(node);
+                        }
+                        return aNode;
                 }
                 
@@ -43 +56 @@
                 // Check for building with address
                 if (way.isClosed() && TagUtils.hasBuildingTag(way)  && TagUtils.isAddress(way)) {
-                        return new AddressNode(way);
+                        String aid = "" + way.getId();
+                        
+                        AddressNode aNode = lookup(aid);
+                        if (aNode == null) {
+                                aNode = new AddressNode(way);
+                                addressCache.put(aid, aNode);
+                        } else {
+                                aNode.setOsmObject(way);
+                        }
+        
+                        return aNode; 
+                }
+                return null;
+        }
+        
+        private static AddressNode lookup(String aid) {                         
+                if (addressCache.containsKey(aid)) {
+                        return addressCache.get(aid);                   
                 }
                 return null;

applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/SelectIncompleteAddressesAction.java

@@ -28 +28 @@
         
         private AddressEditContainer addressEditContainer;
-
-        /**
-         * 
-         */
+        
         public SelectIncompleteAddressesAction() {
                 super(tr("Select incomplete addresses"), "select_invaddr_24",