Index: src/org/openstreetmap/josm/data/validation/tests/Addresses.java =================================================================== --- src/org/openstreetmap/josm/data/validation/tests/Addresses.java (Revision 13765) +++ src/org/openstreetmap/josm/data/validation/tests/Addresses.java (Arbeitskopie) @@ -13,8 +13,11 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.coor.LatLon; import org.openstreetmap.josm.data.osm.Node; import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.Relation; @@ -47,9 +50,17 @@ protected static final String ADDR_NEIGHBOURHOOD = "addr:neighbourhood"; protected static final String ADDR_PLACE = "addr:place"; protected static final String ADDR_STREET = "addr:street"; + protected static final String ADDR_CITY = "addr:city"; + protected static final String ADDR_UNIT = "addr:unit"; + protected static final String ADDR_FLATS = "addr:flats"; + protected static final String ADDR_HOUSE_NAME = "addr:housename"; + protected static final String ADDR_POSTCODE = "addr:postcode"; protected static final String ASSOCIATED_STREET = "associatedStreet"; // CHECKSTYLE.ON: SingleSpaceSeparator + private Map> addresses = null; + private Set ignored_addresses = null; + /** * Constructor */ @@ -102,19 +113,162 @@ } } + private boolean isPOI(OsmPrimitive p) { + return p.hasKey("shop", "amenity", "tourism", "leisure", "emergency", "craft", "name"); + } + + private boolean hasAddress(OsmPrimitive p) { + return (p.hasKey(ADDR_HOUSE_NUMBER) && p.hasKey(ADDR_STREET, ADDR_PLACE)); + } + + /** + * adds the OsmPrimitive to the address map if it complies to the restrictions + * @param p OsmPrimitive that has an address + */ + private void collectAddress(OsmPrimitive p) { + if (isPOI(p)) { + return; + } + String simplified_address = getSimplifiedAddress(p); + if (!ignored_addresses.contains(simplified_address)) { + if (addresses.containsKey(simplified_address)) { + addresses.get(simplified_address).add(p); + } else { + ArrayList objects = new ArrayList<>(); + objects.add(p); + addresses.put(simplified_address, objects); + } + } + } + + protected void initAddressMap(OsmPrimitive primitive) { + addresses = new HashMap<>(); + ignored_addresses = new HashSet<>(); + Collection primitives = primitive.getDataSet().getPrimitives(p -> !p.isDeleted()); + String simplified_address; + for (OsmPrimitive p : primitives) { + if (p.hasKey(ADDR_UNIT, ADDR_FLATS) && p instanceof Node) { + for (OsmPrimitive r : p.getReferrers()) { + if (hasAddress(r)) { + // ignore addresses of buildings that are connected to addr:unit nodes + // it's quite reasonable that there are more buildings with this address + simplified_address = getSimplifiedAddress(r); + if (!ignored_addresses.contains(simplified_address)) { + ignored_addresses.add(simplified_address); + } else if (addresses.containsKey(simplified_address)) { + addresses.remove(simplified_address); + } + } + } + } + if (hasAddress(p)) { + collectAddress(p); + } + } + } + @Override + public void endTest() { + addresses = null; + ignored_addresses = null; + super.endTest(); + } + + protected void checkForDuplicate(OsmPrimitive p) { + if (this.addresses == null) { + initAddressMap(p); + } + if (!isPOI(p) && hasAddress(p)) { + String simplified_address = getSimplifiedAddress(p); + if (ignored_addresses.contains(simplified_address)) { + return; + } + if (addresses.containsKey(simplified_address)) { + for (OsmPrimitive p2 : addresses.get(simplified_address)) { + if (p == p2) { + continue; + } + Severity severity_level = Severity.WARNING; + List primitives = new ArrayList<>(2); + primitives.add(p); + primitives.add(p2); + String city1 = p.get(ADDR_CITY); + String city2 = p2.get(ADDR_CITY); + double distance = getDistance(p, p2); + if (city1 != null && city2 != null) { + if (city1.equals(city2)) { + if (!p.hasKey(ADDR_POSTCODE) || !p2.hasKey(ADDR_POSTCODE) || p.get(ADDR_POSTCODE).equals(p2.get(ADDR_POSTCODE))) { + severity_level = Severity.WARNING; + } else { + // address including city identical but postcode differs + // most likely perfectly fine + severity_level = Severity.OTHER; + } + } else { + // address differs only by city - notify if very close, otherwise ignore + if (distance < 200.0) { + severity_level = Severity.OTHER; + } else { + continue; + } + } + + } else { + // at least one address has no city specified + if (p.hasKey(ADDR_POSTCODE) && p2.hasKey(ADDR_POSTCODE) && p.get(ADDR_POSTCODE).equals(p2.get(ADDR_POSTCODE))) { + // address including postcode identical + severity_level = Severity.WARNING; + } else { + // city/postcode unclear - warn if very close, otherwise only notify + // TODO: get city from surrounding boundaries? + if (distance < 200.0) { + severity_level = Severity.WARNING; + } else { + severity_level = Severity.OTHER; + } + } + } + errors.add(TestError.builder(this, severity_level, DUPLICATE_HOUSE_NUMBER) + .message(tr("Duplicate house numbers"), marktr("''{0}'' ({1}m)"), simplified_address, (int) distance) + .primitives(primitives).build()); + } + addresses.get(simplified_address).remove(p); // otherwise we would get every warning two times + } + } + } + + private String getSimplifiedAddress(OsmPrimitive p) { + String simplified_street_name = p.hasKey(ADDR_STREET) ? p.get(ADDR_STREET) : p.get(ADDR_PLACE); + // ignore whitespaces and dashes in street name, so that "Mozart-Gasse", "Mozart Gasse" and "Mozartgasse" are all seen as equal + simplified_street_name = simplified_street_name.toUpperCase().replaceAll("[ -]", ""); + String simplified_address = Stream.of( + simplified_street_name, + p.get(ADDR_HOUSE_NUMBER), + p.get(ADDR_HOUSE_NAME), + p.get(ADDR_UNIT), + p.get(ADDR_FLATS)) + .map(s -> (s == null ? "" : s)) + .collect(Collectors.joining(" ")); + simplified_address = simplified_address.trim().toUpperCase(); + return simplified_address; + } + + @Override public void visit(Node n) { checkHouseNumbersWithoutStreet(n); + checkForDuplicate(n); } @Override public void visit(Way w) { checkHouseNumbersWithoutStreet(w); + checkForDuplicate(w); } @Override public void visit(Relation r) { checkHouseNumbersWithoutStreet(r); + checkForDuplicate(r); if (r.hasTag("type", ASSOCIATED_STREET)) { // Used to count occurences of each house number in order to find duplicates Map> map = new HashMap<>(); @@ -185,6 +339,18 @@ } } + /** + * returns rough distance between two OsmPrimitives + * @param a primitive a + * @param b primitive b + * @return distance of center of bounding boxes in meters + */ + private double getDistance(OsmPrimitive a, OsmPrimitive b) { + LatLon center_a = a.getBBox().getCenter(); + LatLon center_b = b.getBBox().getCenter(); + return (center_a.greatCircleDistance(center_b)); + } + protected void checkDistance(OsmPrimitive house, Collection street) { EastNorth centroid; if (house instanceof Node) {