Changeset 23966 in osm

Timestamp:

2010-10-31T16:16:58+01:00 (14 years ago)

Author:

oliverw

Message:

Consider also buildings when looking for address entities.

Location:

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

Files:

• AddressEditContainer.java (modified) (5 diffs)
• AddressNode.java (modified) (1 diff)
• NodeFactory.java (modified) (1 diff)
• gui/AddressEditDialog.java (modified) (1 diff)

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

@@ -134 +134 @@
                         return;
                 }
-        
+
+                // Address nodes are recycled in order to keep instance variables like guessed names
                 String aid = "" + n.getId();
                 AddressNode aNode = null;
@@ -148 +149 @@
                 
                 if (aNode != null) {
-                        if (!assignAddressToStreet(aNode)) {
-                                // Assignment failed: Street is not known (yet) -> add to 'unresolved' list 
-                                shadowUnresolvedAddresses.add(aNode);
-                        }
-
-                        if (!aNode.isComplete()) {
-                                shadowIncompleteAddresses.add(aNode);
-                        }
+                        addAndClassifyAddress(aNode);
                 } else {
                         // check, if node is referred by a way
@@ -170 +164 @@
                 markNodeAsVisited(n);
         }
+
+        private void addAndClassifyAddress(AddressNode aNode) {
+                if (!assignAddressToStreet(aNode)) {
+                        // Assignment failed: Street is not known (yet) -> add to 'unresolved' list 
+                        shadowUnresolvedAddresses.add(aNode);
+                }
+
+                if (!aNode.isComplete()) {
+                        shadowIncompleteAddresses.add(aNode);
+                }
+        }
         
         /* (non-Javadoc)
@@ -192 +197 @@
          */
         private void createNodeFromWay(Way w) {
-                StreetSegmentNode newSegment = NodeFactory.createNodeFromWay(w);
-                
-                if (newSegment != null) {
-                        String name = newSegment.getName();
-                        if (StringUtils.isNullOrEmpty(name)) return;
-                        
-                        StreetNode sNode = null;
-                        if (shadowStreetDict.containsKey(name)) { // street exists?
-                                sNode = shadowStreetDict.get(name);
-                        } else { // new street name -> add to dict
-                                sNode = new StreetNode(w);
-                                shadowStreetDict.put(name, sNode);
-                        }
-                        
-                        if (sNode != null) {
-                                // TODO: Check if segment really belongs to the street, even if the
-                                // names are the same. Then the streets should be split up...
-                                sNode.addStreetSegment(newSegment);
-                        } else {
-                                throw new RuntimeException("Street node is null!");
-                        }
-                }
+                INodeEntity ne = NodeFactory.createNodeFromWay(w);
+                
+                processNode(ne, w);
                 
                 markWayAsVisited(w);
@@ -226 +212 @@
                         if (!tags.contains(key)) {
                                 tags.add(key);
+                        }
+                }
+        }
+
+        /**
+         * Process a entity node.
+         *
+         * @param ne the ne
+         * @param w the w
+         */
+        private void processNode(INodeEntity ne, Way w) {
+                if (ne != null) {
+                        if (ne instanceof StreetSegmentNode) {
+                                StreetSegmentNode newSegment = (StreetSegmentNode) ne;
+
+                                if (newSegment != null) {
+                                        String name = newSegment.getName();
+                                        if (StringUtils.isNullOrEmpty(name)) return;
+
+                                        StreetNode sNode = null;
+                                        if (shadowStreetDict.containsKey(name)) { // street exists?
+                                                sNode = shadowStreetDict.get(name);
+                                        } else { // new street name -> add to dict
+                                                sNode = new StreetNode(w);
+                                                shadowStreetDict.put(name, sNode);
+                                        }
+
+                                        if (sNode != null) {
+                                                // TODO: Check if segment really belongs to the street, even if the
+                                                // names are the same. Then the streets should be split up...
+                                                sNode.addStreetSegment(newSegment);
+                                        } else {
+                                                throw new RuntimeException("Street node is null!");
+                                        }
+                                }
+                        }
+
+                        // Node is an address 
+                        if (ne instanceof AddressNode) {
+                                AddressNode aNode = (AddressNode) ne;
+                                addAndClassifyAddress(aNode);                   
                         }
                 }

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

@@ -48 +48 @@
          */
         public String getStreet() {
+                if (osmObject == null) return MISSING_TAG;
+                
                 if (!TagUtils.hasAddrStreetTag(osmObject)) {
-                        return MISSING_TAG;
+                        // check, if referrers have a street
+                        for (OsmPrimitive osm : osmObject.getReferrers()) {
+                                if (TagUtils.hasAddrStreetTag(osm)) {
+                                        String refStreetName = TagUtils.getAddrStreetValue(osm);
+                                
+                                        if (!StringUtils.isNullOrEmpty(refStreetName)) {
+                                                return refStreetName;
+                                        }
+                                }
+                        }
+                        return MISSING_TAG; // nothing found
                 }
                 return TagUtils.getAddrStreetValue(osmObject);

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

@@ -36 +36 @@
          * @return The new node instance or null; if given way is inappropriate.
          */
-        public static StreetSegmentNode createNodeFromWay(Way way) {
+        public static INodeEntity createNodeFromWay(Way way) {
                 if (TagUtils.hasHighwayTag(way)) {
                         return new StreetSegmentNode(way);
                 }
                 
+                // Check for building with address
+                if (way.isClosed() && TagUtils.hasBuildingTag(way)  && TagUtils.isAddress(way)) {
+                        return new AddressNode(way);
+                }
                 return null;
         }

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

@@ -256 +256 @@
                         List<AddressNode> unrAddresses = ev.getSelectedUnresolvedAddresses();
                         if (unrAddresses != null) {
-                                for (AddressNode aNode : unrAddresses) {
-                                        Node node = (Node) aNode.getOsmObject();
-                                        mapViewer.addMapMarker(new MapMarkerDot(Color.ORANGE, node.getCoor().lat(), node.getCoor().lon()));
+                                for (AddressNode aNode : unrAddresses) {                                        
+                                        mapViewer.addMapMarker(new MapMarkerDot(Color.ORANGE, aNode.getCoor().lat(), aNode.getCoor().lon()));
                                 }
                         }