Ticket #17011: 17011-v4.patch

src/org/openstreetmap/josm/data/validation/OsmValidator.java

@@ -55 +55 @@
 import org.openstreetmap.josm.data.validation.tests.MultipolygonTest;
 import org.openstreetmap.josm.data.validation.tests.NameMismatch;
 import org.openstreetmap.josm.data.validation.tests.OpeningHourTest;
+import org.openstreetmap.josm.data.validation.tests.OverlappingAreas;
 import org.openstreetmap.josm.data.validation.tests.OverlappingWays;
 import org.openstreetmap.josm.data.validation.tests.PowerLines;
 import org.openstreetmap.josm.data.validation.tests.PublicTransportRouteTest;
@@ -148 +149 @@
         LongSegment.class, // 3500 .. 3599
         PublicTransportRouteTest.class, // 3600 .. 3699
         RightAngleBuildingTest.class, // 3700 .. 3799
+        OverlappingAreas.class, // 3800 .. 3899
     };
 
     /**

src/org/openstreetmap/josm/data/validation/Test.java

@@ -18 +18 @@
 import org.openstreetmap.josm.command.DeleteCommand;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.search.SearchCompiler.InDataSourceArea;
@@ -364 +365 @@
         return p.hasTag("landuse", "residential");
     }
 
+    /**
+     * Determines if the specified primitives are in the same layer.
+     * @param p1 first primitive
+     * @param p2 second primitive
+     * @return True if the objects are in the same layer
+     */
+    protected static final boolean inSameLayer(OsmPrimitive p1, OsmPrimitive p2) {
+        return Objects.equals(OsmUtils.getLayer(p1), OsmUtils.getLayer(p2));
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(name, description);

src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

@@ -13 +13 @@
 
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
@@ -106 +105 @@
         boolean ignoreWaySegmentCombination(Way w1, Way w2) {
             if (w1 == w2)
                 return false;
-            if (!Objects.equals(OsmUtils.getLayer(w1), OsmUtils.getLayer(w2))) {
+            if (!inSameLayer(w1, w2)) {
                 return true;
             }
             if (w1.hasKey(HIGHWAY) && w2.hasKey(HIGHWAY) && !Objects.equals(w1.get("level"), w2.get("level"))) {
@@ -251 +250 @@
 
         @Override
         boolean ignoreWaySegmentCombination(Way w1, Way w2) {
-            return !Objects.equals(OsmUtils.getLayer(w1), OsmUtils.getLayer(w2));
+            return !inSameLayer(w1, w2);
         }
 
     }

src/org/openstreetmap/josm/data/validation/tests/OverlappingAreas.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.geom.Area;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmDataManager;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon;
+import org.openstreetmap.josm.data.osm.visitor.paint.relations.MultipolygonCache;
+import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
+import org.openstreetmap.josm.data.validation.Severity;
+import org.openstreetmap.josm.data.validation.Test;
+import org.openstreetmap.josm.data.validation.TestError;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
+import org.openstreetmap.josm.tools.MultiMap;
+import org.openstreetmap.josm.tools.Pair;
+
+/**
+ * Tests if there are overlapping areas
+ *
+ * @author Gerd Petermann
+ * @since xxx
+ */
+public class OverlappingAreas extends Test {
+    protected static final int OVERLAPPING_AREA = 3800; // allows insideness
+    protected static final int OVERLAPPING_WATER = 3801;
+    protected static final int OVERLAPPING_IDENTICAL_NATURAL = 3802;
+    protected static final int OVERLAPPING_IDENTICAL_LANDLUSE = 3803;
+    protected static final int OVERLAPPING_BUILDINGS = 3804;
+    protected static final int OVERLAPPING_BUILDING_RESIDENTIAL = 3805;
+
+    private String reason;
+    private int code;
+    private Set<Way> seenWays;
+    private MultiMap<Relation, Way> mpWayMap;
+    private DataSet ds;
+    private Set<Relation> seenRelations;
+
+    /** Constructor */
+    public OverlappingAreas() {
+        super(tr("Overlapping areas"),
+                tr("This test checks if two areas intersect in the same layer."));
+    }
+
+    @Override
+    public void startTest(ProgressMonitor monitor) {
+        super.startTest(monitor);
+        super.setShowElements(true);
+        // collections to suppress duplicated tests */
+        seenWays = new HashSet<>();
+        seenRelations = new HashSet<>();
+        mpWayMap = new MultiMap<>();
+        ds = OsmDataManager.getInstance().getEditDataSet();
+    }
+
+    @Override
+    public void endTest() {
+        // clean up references
+        seenRelations = null;
+        seenWays = null;
+        mpWayMap = null;
+        ds = null;
+        super.endTest();
+    }
+
+    /**
+     * Calculate area in east/north space for given primitive.
+     * @param p the primitive, must be a closed way or multipolygon
+     * @return the area in east/north space
+     */
+    private static Area getEastNorthArea(OsmPrimitive p) {
+        if (p instanceof Way) {
+            return Geometry.getArea(((Way) p).getNodes());
+        }
+        Multipolygon mp = MultipolygonCache.getInstance().get((Relation) p);
+        Path2D path = new Path2D.Double();
+        path.setWindingRule(Path2D.WIND_EVEN_ODD);
+        for (Multipolygon.PolyData pd : mp.getCombinedPolygons()) {
+            path.append(pd.get(), false);
+        }
+        return new Area(path);
+    }
+
+    /**
+     * Check intersection between two areas. If empty or extremely small ignore it, else add error
+     * with highlighted area.
+     * @param a1 the first area (EastNorth)
+     * @param a2 the second area (EastNorth)
+     * @param p1 primitive describing 1st polygon
+     * @param p2 primitive describing 2nd polygon
+     */
+    private void checkIntersection(Area a1, Area a2, OsmPrimitive p1, OsmPrimitive p2) {
+        Pair<PolygonIntersection, Area> pair = Geometry.polygonIntersectionResult(a1, a2, Geometry.INTERSECTION_EPS_EAST_NORTH);
+        switch (pair.a) {
+        case OUTSIDE:
+            return;
+        case FIRST_INSIDE_SECOND:
+            if (code == OVERLAPPING_AREA || code == OVERLAPPING_BUILDING_RESIDENTIAL && isBuilding(p1))
+                return;
+            if (code == OVERLAPPING_WATER && p2.hasTag("natural", "wetland"))
+                return;
+            break;
+        case SECOND_INSIDE_FIRST:
+            if (code == OVERLAPPING_AREA || code == OVERLAPPING_BUILDING_RESIDENTIAL && isBuilding(p2))
+                return;
+            if (code == OVERLAPPING_WATER && p1.hasTag("natural", "wetland"))
+                return;
+            break;
+        case CROSSING:
+            break;
+        }
+
+        // we have an intersection, calculate the elements to highlight
+        PathIterator pit = pair.b.getPathIterator(null);
+        double[] res = new double[6];
+        List<List<Node>> hilite = new ArrayList<>();
+        List<Node> nodes = new ArrayList<>();
+        while (!pit.isDone()) {
+            int type = pit.currentSegment(res);
+            Node n = new Node(new EastNorth(res[0], res[1]));
+            switch (type) {
+            case PathIterator.SEG_MOVETO:
+                if (!nodes.isEmpty()) {
+                    hilite.add(nodes);
+                }
+                nodes = new ArrayList<>();
+                nodes.add(n);
+                break;
+            case PathIterator.SEG_LINETO:
+                nodes.add(n);
+                break;
+            case PathIterator.SEG_CLOSE:
+                if (!nodes.isEmpty()) {
+                    hilite.add(nodes);
+                    nodes = new ArrayList<>();
+                }
+                break;
+            default:
+                break;
+            }
+            pit.next();
+        }
+        if (nodes.size() > 1) {
+            hilite.add(nodes);
+        }
+
+        switch (code) {
+        case OVERLAPPING_WATER:
+            reason = tr("Overlapping Water Areas");
+            break;
+        case OVERLAPPING_IDENTICAL_NATURAL:
+            reason = tr("Overlapping identical natural areas");
+            break;
+        case OVERLAPPING_IDENTICAL_LANDLUSE:
+            reason = tr("Overlapping identical landuses");
+            break;
+        case OVERLAPPING_BUILDINGS:
+            if (pair.a == PolygonIntersection.CROSSING)
+                reason = tr("Overlapping buildings");
+            else
+                reason = tr("Building inside building");
+            break;
+        case OVERLAPPING_BUILDING_RESIDENTIAL:
+            reason = tr("Overlapping building/residential area");
+            break;
+        default:
+            reason = tr("Overlapping area");
+
+        }
+        errors.add(TestError
+                .builder(this, code == OVERLAPPING_AREA ? Severity.OTHER : Severity.WARNING, code)
+                .message("OA: " + reason).primitives(p1, p2)
+                .highlightNodePairs(hilite).build());
+    }
+
+    /**
+     * Check if the two objects are allowed to overlap regarding tags.
+     * @param p1 1st primitive
+     * @param p2 2nd primitive
+     * @return the error code if the tags of the objects don't allow that the areas overlap, else 0
+     */
+    private static int tagsAllowOverlap(OsmPrimitive p1, OsmPrimitive p2) {
+        if (!inSameLayer(p1, p2)) {
+            return 0;
+        }
+        // order is significant, highest severity should come first
+        if (isWaterArea(p1) && isWaterArea(p2)) {
+            return OVERLAPPING_WATER;
+        }
+        if (isSetAndEqual(p1, p2, "natural")) {
+            return OVERLAPPING_IDENTICAL_NATURAL;
+        }
+        if (isSetAndEqual(p1, p2, "landuse")) {
+            return OVERLAPPING_IDENTICAL_LANDLUSE;
+        }
+        if (isBuilding(p1) && isBuilding(p2)) {
+            return OVERLAPPING_BUILDINGS;
+        }
+        if (isBuilding(p1) && isResidentialArea(p2) || isBuilding(p2) && isResidentialArea(p1)) {
+            return OVERLAPPING_BUILDING_RESIDENTIAL;
+        }
+        if (ValidatorPrefHelper.PREF_OTHER.get() && p1.concernsArea() && p2.concernsArea()) {
+            return OVERLAPPING_AREA;
+        }
+        return 0;
+    }
+
+    private static boolean isWaterArea(OsmPrimitive p) {
+        return p.hasTag("natural", "water", "wetland") || p.hasTag("landuse", "reservoir");
+    }
+
+    private static boolean isSetAndEqual(OsmPrimitive p1, OsmPrimitive p2, String key) {
+        String v1 = p1.get(key);
+        String v2 = p2.get(key);
+        return v1 != null && v1.equals(v2);
+    }
+
+    private Area checkDetails(Area a1, OsmPrimitive p1, OsmPrimitive p2) {
+        reason = null;
+        code = tagsAllowOverlap(p1, p2);
+        if (code > 0) {
+            // check geometry details
+            if (a1 == null) {
+                a1 = getEastNorthArea(p1);
+            }
+            checkIntersection(a1, getEastNorthArea(p2), p1, p2);
+        }
+        return a1;
+    }
+
+    @Override
+    public void visit(Way w1) {
+        if (w1.isArea()) {
+            /** performance: calculate only if needed and only once */
+            Area a1 = null;
+            BBox bbox1 = w1.getBBox();
+            List<Way> nearWays = ds.searchWays(bbox1);
+            // way-way overlaps
+            for (Way w2 : nearWays) {
+                if (w1 != w2 && w2.isArea() && !seenWays.contains(w2)) {
+                    a1 = checkDetails(a1, w1, w2);
+                }
+            }
+            // way-multipolygon overlaps
+            List<Relation> nearRelations = ds.searchRelations(bbox1);
+            for (Relation rel : nearRelations) {
+                if (rel.isMultipolygon() && w1.referrers(Relation.class).noneMatch(parent -> parent == rel)) {
+                    Set<Way> checkedWays = mpWayMap.get(rel);
+                    if (checkedWays != null && checkedWays.contains(w1))
+                        continue;
+                    mpWayMap.put(rel, w1);
+                    a1 = checkDetails(a1, w1, rel);
+                }
+            }
+            seenWays.add(w1);
+        }
+    }
+
+    @Override
+    public void visit(Relation r1) {
+        if (r1.isMultipolygon()) {
+            BBox bbox1 = r1.getBBox();
+            /** performance: calculate only if needed and only once */
+            Area a1 = null;
+            // multipolygon -way overlaps
+            List<Way> nearWays = ds.searchWays(bbox1);
+            for (Way way : nearWays) {
+                if (!way.isArea() || way.referrers(Relation.class).anyMatch(parent -> parent == r1)) {
+                    // ignore members of multipolygon
+                    continue;
+                }
+                Set<Way> checkedWays = mpWayMap.get(r1);
+                if (checkedWays != null && checkedWays.contains(way))
+                    continue;
+                mpWayMap.put(r1, way);
+                a1 = checkDetails(a1, r1, way);
+            }
+            List<Relation> nearRelations = ds.searchRelations(bbox1);
+            for (Relation r2 : nearRelations) {
+                if (r1 != r2 && r2.isMultipolygon() && !seenRelations.contains(r2)) {
+                    a1 = checkDetails(a1, r1, r2);
+                }
+            }
+            seenRelations.add(r1);
+        }
+    }
+}

src/org/openstreetmap/josm/tools/Geometry.java

@@ -602 +602 @@
      * @return intersection kind
      */
     public static PolygonIntersection polygonIntersection(Area a1, Area a2, double eps) {
+        return polygonIntersectionResult(a1, a2, eps).a;
+    }
 
+    /**
+     * Calculate intersection area and kind of intersection between two polygons.
+     * @param a1 Area of first polygon
+     * @param a2 Area of second polygon
+     * @param eps an area threshold, everything below is considered an empty intersection
+     * @return pair with intersection kind and intersection area (never null, but maybe empty)
+     * @since xxx
+     */
+    public static Pair<PolygonIntersection, Area> polygonIntersectionResult(Area a1, Area a2, double eps) {
         Area inter = new Area(a1);
         inter.intersect(a2);
 
         if (inter.isEmpty() || !checkIntersection(inter, eps)) {
-            return PolygonIntersection.OUTSIDE;
+            return new Pair<>(PolygonIntersection.OUTSIDE, inter);
         } else if (a2.getBounds2D().contains(a1.getBounds2D()) && inter.equals(a1)) {
-            return PolygonIntersection.FIRST_INSIDE_SECOND;
+            return new Pair<>(PolygonIntersection.FIRST_INSIDE_SECOND, inter);
         } else if (a1.getBounds2D().contains(a2.getBounds2D()) && inter.equals(a2)) {
-            return PolygonIntersection.SECOND_INSIDE_FIRST;
+            return new Pair<>(PolygonIntersection.SECOND_INSIDE_FIRST, inter);
         } else {
-            return PolygonIntersection.CROSSING;
+            return new Pair<>(PolygonIntersection.CROSSING, inter);
         }
     }