Changeset 24982 in osm

Timestamp:

2011-01-05T16:05:05+01:00 (14 years ago)

Author:

oliverw

Message:

Implemented problem/solution stuff for OSMAddress.

Location:

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

Files:

• AddressEditContainer.java (modified) (4 diffs)
• AddressSolution.java (added)
• IAllKnowingTrashHeap.java (added)
• IOSMEntity.java (modified) (1 diff)
• OSMAddress.java (modified) (6 diffs)
• OSMEntityBase.java (modified) (1 diff)
• gui/actions/AbstractAddressEditAction.java (modified) (1 diff)
• gui/actions/ApplyAllGuessesAction.java (modified) (5 diffs)

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

@@ -71 +71 @@
  */
 
-public class AddressEditContainer implements Visitor, DataSetListener, IAddressEditContainerListener, IProblemVisitor {
+public class AddressEditContainer implements Visitor, DataSetListener, IAddressEditContainerListener, IProblemVisitor, IAllKnowingTrashHeap {
         
         private Collection<? extends OsmPrimitive> workingSet;
@@ -218 +218 @@
                 if (aNode != null) {
                         addAndClassifyAddress(aNode);
-                        aNode.visit(this);
+                        aNode.visit(this, this);
                 } 
                 markNodeAsVisited(n);
@@ -542 +542 @@
                 synchronized (this) {
                         clearData();
+                        clearProblems();
+                        
                         for (OsmPrimitive osmPrimitive : osmData) {
                                 osmPrimitive.visit(this);
@@ -721 +723 @@
                 }
         }
+
+        /* (non-Javadoc)
+         * @see org.openstreetmap.josm.plugins.fixAddresses.IAllKnowingTrashHeap#getClosestStreetName(java.lang.String)
+         */
+        @Override
+        public String getClosestStreetName(String name) {
+                List<String> matches = getClosestStreetNames(name, 1);
+                
+                if (matches != null && matches.size() > 0) {
+                        return matches.get(0);
+                }
+                
+                return null;
+        }
+
+        /* (non-Javadoc)
+         * @see org.openstreetmap.josm.plugins.fixAddresses.IAllKnowingTrashHeap#getClosestStreetNames(java.lang.String, int)
+         */
+        @Override
+        public List<String> getClosestStreetNames(String name, int maxEntries) {
+                CheckParameterUtil.ensureParameterNotNull(name, "name");
+                
+                // ensure right number of entries
+                if (maxEntries < 1) maxEntries = 1;
+                
+                List<StreetScore> scores = new ArrayList<StreetScore>();
+                List<String> matches = new ArrayList<String>();
+                
+                // Find the longest common sub string
+                for (String     streetName : streetDict.keySet()) {
+                        int score = StringUtils.lcsLength(name, streetName);
+                        
+                        if (score > 3) { // reasonable value?
+                                StreetScore sc = new StreetScore(streetName, score);
+                                scores.add(sc);
+                        }
+                }
+                
+                // sort by score
+                Collections.sort(scores);
+                
+                // populate result list
+                int n = Math.min(maxEntries, scores.size());
+                for (int i = 0; i < n; i++) {
+                        matches.add(scores.get(i).getName());
+                }
+                
+                return matches;
+        }
+
+        /* (non-Javadoc)
+         * @see org.openstreetmap.josm.plugins.fixAddresses.IAllKnowingTrashHeap#isValidStreetName(java.lang.String)
+         */
+        @Override
+        public boolean isValidStreetName(String name) {
+                if (streetDict == null) return false;
+                
+                return streetDict.containsKey(name);
+        }
+        
+        /**
+         * Internal class to handle results of {@link AddressEditContainer#getClosestStreetNames(String, int)}.
+         */
+        private class StreetScore implements Comparable<StreetScore> {
+                private String name;
+                private int score;
+                
+                /**
+                 * @param name Name of the street.
+                 * @param score Score of the street (length of longest common substring)
+                 */
+                public StreetScore(String name, int score) {
+                        super();
+                        this.name = name;
+                        this.score = score;
+                }
+
+                /**
+                 * @return the name of the street.
+                 */
+                protected String getName() {
+                        return name;
+                }
+
+                /**
+                 * @return the score of the street.
+                 */
+                protected int getScore() {
+                        return score;
+                }
+
+                @Override
+                public int compareTo(StreetScore arg0) {
+                        if (arg0 == null) return 1;
+                        
+                        return new Integer(score).compareTo(new Integer(arg0.score));
+                }
+        }
 }

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

@@ -74 +74 @@
          * Collects problems and possible solutions.
          *
+         * @param trashHeap the trash heap to ask for possible solutions
          * @param visitor the problem visitor
          */
-        public void visit(IProblemVisitor visitor);
+        public void visit(IAllKnowingTrashHeap trashHeap, IProblemVisitor visitor);
 }

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

@@ -14 +14 @@
 package org.openstreetmap.josm.plugins.fixAddresses;
 
+import static org.openstreetmap.josm.tools.I18n.tr;
 import java.util.Collection;
 import java.util.HashMap;
 
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.plugins.fixAddresses.gui.actions.ApplyAllGuessesAction;
+import org.openstreetmap.josm.plugins.fixAddresses.gui.actions.RemoveAddressTagsAction;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
 
@@ -87 +90 @@
         
         /**
-         * Gets the tag value with guess. If the object does not have the given tag, this mehtod looks for
+         * Gets the tag value with guess. If the object does not have the given tag, this method looks for
          * an appropriate guess. If both, real value and guess, are missing, a question mark is returned.
          *
@@ -214 +217 @@
         public void applyAllGuesses() {
                 for (String tag : guessedValues.keySet()) {
+                        applyGuessForTag(tag);
+                }
+                
+                // Clear all guesses
+                guessedValues.clear();
+                guessedObjects.clear();
+        }
+        
+        /**
+         * Apply the guessed value for the given tag.
+         *
+         * @param tag the tag to apply the guessed value for.
+         */
+        public void applyGuessForTag(String tag) {
+                if (guessedValues.containsKey(tag)) {
                         String val = guessedValues.get(tag);
                         if (!StringUtils.isNullOrEmpty(val)) {
@@ -219 +237 @@
                         }
                 }
-                
-                // Clear all guesses
-                guessedValues.clear();
-                guessedObjects.clear();
         }
 
@@ -539 +553 @@
                 if (value != null && osm != null) {
                         guessedValues.put(tag, value);
-                        guessedObjects.put(tag, osm);
+                        if (osm != null) {
+                                guessedObjects.put(tag, osm);
+                        }
                         fireEntityChanged(this);
                 }
@@ -631 +647 @@
          * @see org.openstreetmap.josm.plugins.fixAddresses.OSMEntityBase#visit(org.openstreetmap.josm.plugins.fixAddresses.IProblemVisitor)
          */
-        public void visit(IProblemVisitor visitor) {
+        @Override
+        public void visit(IAllKnowingTrashHeap trashHeap, IProblemVisitor visitor) {
                 CheckParameterUtil.ensureParameterNotNull(visitor, "visitor");
                 
+                // Check for street
                 if (!hasStreetName()) {
+                        AddressProblem p = new AddressProblem(this, tr("Address has no street"));
+                        if (hasGuessedStreetName()) { // guess exists -> add solution entry
+                                String tag = TagUtils.ADDR_STREET_TAG;
+                                addGuessValueSolution(p, tag);
+                        }
+                        addRemoveAddressTagsSolution(p);
+                        visitor.addProblem(p);
+                // Street name exists, but is invalid -> ask the all knowing trash heap
+                } else if (!trashHeap.isValidStreetName(getStreetName())) {
+                        AddressProblem p = new AddressProblem(this, tr("Address has no valid street"));
+                        String match = trashHeap.getClosestStreetName(getStreetName());
                         
-                }
+                        if (!StringUtils.isNullOrEmpty(match)) {
+                                setGuessedStreetName(match, null);
+                                addGuessValueSolution(p, TagUtils.ADDR_STREET_TAG);
+                        }
+                        visitor.addProblem(p);
+                }
+                
+                // Check for postal code
+                if (!hasPostalCode()) {
+                        AddressProblem p = new AddressProblem(this, tr("Address has no post code"));
+                        if (hasGuessedStreetName()) {
+                                String tag = TagUtils.ADDR_POSTCODE_TAG;
+                                addGuessValueSolution(p, tag);
+                        }
+                        addRemoveAddressTagsSolution(p);
+                        visitor.addProblem(p);
+                }
+                
+                // Check for city
+                if (!hasCity()) {
+                        AddressProblem p = new AddressProblem(this, tr("Address has no city"));
+                        if (hasGuessedStreetName()) {
+                                String tag = TagUtils.ADDR_CITY_TAG;
+                                addGuessValueSolution(p, tag);
+                        }
+                        addRemoveAddressTagsSolution(p);
+                        visitor.addProblem(p);
+                }
+                
+                // Check for country
+                if (!hasCountry()) {
+                        // TODO: Add guess for country
+                        AddressProblem p = new AddressProblem(this, tr("Address has no country"));
+                        addRemoveAddressTagsSolution(p);
+                        visitor.addProblem(p);
+                }
+        }
+
+        /**
+         * Adds the guess value solution to a problem.
+         *
+         * @param p the problem to add the solution to.
+         * @param tag the tag to change.
+         */
+        private void addGuessValueSolution(AddressProblem p, String tag) {
+                AddressSolution s = new AddressSolution(
+                                String.format("%s '%s'", tr("Assign to"), getGuessedValue(tag)), 
+                                new ApplyAllGuessesAction(tag),
+                                SolutionType.Change);
+                
+                p.addSolution(s);
+        }
+        
+        /**
+         * Adds the remove address tags solution entry to a problem.
+         *
+         * @param problem the problem
+         */
+        private void addRemoveAddressTagsSolution(IProblem problem) {
+                CheckParameterUtil.ensureParameterNotNull(problem, "problem");
+                
+                AddressSolution s = new AddressSolution(
+                                                tr("Remove all address tags"), 
+                                                new RemoveAddressTagsAction(),
+                                                SolutionType.Remove);
+                problem.addSolution(s);
         }
         

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

@@ -203 +203 @@
         }
         
-        @Override
-        public void visit(IProblemVisitor visitor) {
+        /* (non-Javadoc)
+         * @see org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity#visit(org.openstreetmap.josm.plugins.fixAddresses.IAllKnowingTrashHeap, org.openstreetmap.josm.plugins.fixAddresses.IProblemVisitor)
+         */
+        @Override
+        public void visit(IAllKnowingTrashHeap trashHeap, IProblemVisitor visitor) {
                 // do nothing
         }

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

@@ -176 +176 @@
         public void entityChanged(IOSMEntity node) {
                 container.removeProblemsOfSource(node); // clear problems of changed node...
-                node.visit(container);                                  // .. and revisit it.
+                node.visit(container, container);                                       // .. and revisit it.
                 updateEnabledState();           
         }

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

@@ -27 +27 @@
 import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
 import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
+import org.openstreetmap.josm.plugins.fixAddresses.StringUtils;
 import org.openstreetmap.josm.plugins.fixAddresses.gui.AddressEditSelectionEvent;
 import org.openstreetmap.josm.plugins.fixAddresses.gui.AddressEditTableModel;
@@ -38 +39 @@
 @SuppressWarnings("serial")
 public class ApplyAllGuessesAction extends AbstractAddressEditAction implements MouseListener{
-
+        private String tag;
+        /**
+         * Instantiates a new "apply all guesses" action.
+         */
+        public ApplyAllGuessesAction(String tag) {      
+                super(tr("Apply"), "applyguesses_24", tr("Turns all guesses into the corresponding tag values."));
+                this.tag = tag;
+        }
+        
         /**
          * Instantiates a new "apply all guesses" action.
          */
         public ApplyAllGuessesAction() {        
-                super(tr("Apply"), "applyguesses_24", tr("Turns all guesses into the corresponding tag values."));
+                this(null);
         }
 
@@ -54 +63 @@
                 
                 if (ev.getSelectedUnresolvedAddresses() != null) {
-                        // fix SELECTED items only
                         List<OSMAddress> addrToFix = ev.getSelectedUnresolvedAddresses();
                         applyGuesses(addrToFix);
@@ -60 +68 @@
                 
                 if (ev.getSelectedIncompleteAddresses() != null) {
-                        // fix SELECTED items only
                         List<OSMAddress> addrToFix = ev.getSelectedIncompleteAddresses();
                         applyGuesses(addrToFix);
@@ -84 +91 @@
                 for (OSMAddress aNode : addrToFixShadow) {
                         beginObjectTransaction(aNode);
-                        aNode.applyAllGuesses();
+                        
+                        if (StringUtils.isNullOrEmpty(tag)) { // tag given?
+                                aNode.applyAllGuesses(); // no -> apply all guesses
+                        } else { // apply guessed values for single tag only
+                                aNode.applyGuessForTag(tag);
+                        }
                         finishObjectTransaction(aNode);
                 }