Ticket #13165: 13165_v1.patch

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

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.validation.tests;
 
+import static org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.FixCommand.evaluateObject;
 import static org.openstreetmap.josm.tools.I18n.tr;
 
 import java.io.BufferedReader;
@@ -575 +576 @@
                 final String description1 = group == null ? description : group;
                 final String description2 = group == null ? null : description;
                 final List<OsmPrimitive> primitives;
+                final Collection<OsmPrimitive> hilite;
                 if (env.child != null) {
                     primitives = Arrays.asList(p, env.child);
                 } else {
                     primitives = Collections.singletonList(p);
                 }
+                hilite = env.hilite != null && !env.hilite.isEmpty() ? env.hilite : primitives;
+
                 final TestError.Builder error = TestError.builder(tester, getSeverity(), 3000)
                         .messageWithManuallyTranslatedDescription(description1, description2, matchingSelector.toString())
-                        .primitives(primitives);
+                        .primitives(primitives)
+                        .highlight(hilite);
+
                 if (fix != null) {
                     return error.fix(() -> fix).build();
                 } else {

src/org/openstreetmap/josm/gui/mappaint/Environment.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.mappaint;
 
+import java.util.Collection;
+
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.gui.mappaint.mapcss.Condition.Context;
@@ -21 +23 @@
     public StyleSource source;
     private Context context = Context.PRIMITIVE;
     public static final String DEFAULT_LAYER = "default";
+    public Collection<OsmPrimitive> hilite;
 
     /**
      * If not null, this is the matching parent object if a condition or an expression
@@ -90 +93 @@
         this.index = other.index;
         this.count = other.count;
         this.context = other.getContext();
+        this.hilite = other.hilite;
     }
 
     /**
@@ -243 +247 @@
         child = null;
         index = null;
         count = null;
+        hilite = null;
     }
 
     public Cascade getCascade(String layer) {

src/org/openstreetmap/josm/gui/mappaint/mapcss/Selector.java

@@ -3 +3 @@
 
 import static org.openstreetmap.josm.data.projection.Ellipsoid.WGS84;
 
+import java.awt.geom.Area;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.Set;
 import java.util.function.IntFunction;
 import java.util.function.IntSupplier;
-import java.util.Set;
 import java.util.regex.PatternSyntaxException;
 
 import org.openstreetmap.josm.Main;
@@ -16 +19 @@
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.PrimitiveId;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
+import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon;
+import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon.PolyData;
 import org.openstreetmap.josm.data.osm.visitor.paint.relations.MultipolygonCache;
 import org.openstreetmap.josm.gui.mappaint.Environment;
 import org.openstreetmap.josm.gui.mappaint.Range;
@@ -26 +32 @@
 import org.openstreetmap.josm.gui.mappaint.mapcss.ConditionFactory.OpenEndPseudoClassCondition;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
 import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
 import org.openstreetmap.josm.tools.Pair;
 import org.openstreetmap.josm.tools.SubclassFilteredCollection;
 import org.openstreetmap.josm.tools.Utils;
@@ -242 +249 @@
         }
 
         private final class CrossingFinder extends AbstractFinder {
+            HashSet<PrimitiveId> checkedPrimitives = new HashSet<>();
+
             private CrossingFinder(Environment e) {
                 super(e);
                 CheckParameterUtil.ensureThat(e.osm instanceof Way, "Only ways are supported");
             }
 
+            /**
+             * Check two areas for intersection, if found, find elements to highlight
+             * @param a1 1st area
+             * @param a2 2nd area
+             * @param p2 primitive that is or contains area a2
+             */
+            void checkIntersection(Area a1, Area a2, OsmPrimitive p2) {
+                PolygonIntersection is = Geometry.polygonIntersection(a1, a2);
+                if (is == PolygonIntersection.CROSSING) {
+                    e.child = p2;
+                }
+            }
+
             @Override
             public void visit(Way w) {
                 if (e.child == null && left.matches(new Environment(w).withParent(e.osm))) {
-                    if (e.osm instanceof Way && Geometry.PolygonIntersection.CROSSING.equals(
-                            Geometry.polygonIntersection(w.getNodes(), ((Way) e.osm).getNodes()))) {
-                        e.child = w;
+                    // check way-way intersection
+                    Area a = Geometry.getArea(w.getNodes());
+                    Area b = Geometry.getArea(((Way) e.osm).getNodes());
+                    checkIntersection(a, b, w);
+                    return;
+                }
+                if (e.parent.isMultipolygon()) {
+                    // check mp-way intersection
+                    if (e.child == null && left.matches(new Environment(w).withParent(e.parent))) {
+                        if (checkedPrimitives.contains(w))
+                            return;
+                        checkedPrimitives.add(w);
+                        for (OsmPrimitive p : w.getReferrers()) {
+                            if (p == e.parent)
+                                return;
+                        }
+                        Multipolygon polygon = MultipolygonCache.getInstance().get(Main.map.mapView, (Relation) e.parent);
+                        if (polygon == null)
+                            return;
+                        Area a1 = Geometry.getArea(w.getNodes());
+                        for (PolyData pd : polygon.getCombinedPolygons()) {
+                            Area a2 = new Area(pd.get());
+                            checkIntersection(a1, a2, w);
+                            if (e.child != null) {
+                                if (e.hilite == null) {
+                                    Set<OsmPrimitive> hilite = new HashSet<>();
+                                    hilite.add(w);
+                                    hilite.addAll(getMpWays(e.parent, pd));
+                                    e.hilite = new ArrayList<>(hilite);
+                                }
+                                return;
+                            }
+                        }
                     }
+                    if (e.child == null) {
+                        // is way member of a matching mp relation ?
+                        for (OsmPrimitive otherParent : w.getReferrers()) {
+                            if (otherParent.isMultipolygon() && !otherParent.isIncomplete() && e.parent != otherParent) {
+                                if (((Relation) otherParent).hasIncompleteMembers())
+                                    continue;
+                                if (left.matches(new Environment(otherParent).withParent(otherParent))) {
+                                    if (checkedPrimitives.contains(otherParent))
+                                        continue;
+                                    checkedPrimitives.add(otherParent);
+                                    // okay, we have two different complete multipolygons, check if they are overlapping
+                                    Multipolygon p1 = MultipolygonCache.getInstance().get(Main.map.mapView, (Relation) e.parent);
+                                    if (p1 == null)
+                                        continue;
+                                    Multipolygon p2 = MultipolygonCache.getInstance().get(Main.map.mapView, (Relation) otherParent);
+                                    if (p2 == null)
+                                        continue;
+                                    for (PolyData pd1 : p1.getCombinedPolygons()) {
+                                        Area a1 = new Area(pd1.get());
+                                        for (PolyData pd2 : p2.getCombinedPolygons()) {
+                                            Area a2 = new Area(pd2.get());
+                                            checkIntersection(a1, a2, otherParent);
+                                            if (e.child != null) {
+                                                if (e.hilite == null) {
+                                                    Set<OsmPrimitive> hilite = new HashSet<>();
+                                                    hilite.addAll(getMpWays(e.parent, pd1));
+                                                    hilite.addAll(getMpWays(otherParent, pd2));
+                                                    e.hilite = new ArrayList<>(hilite);
+                                                }
+                                                return;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                 // check way-mp intersection
+                    for (OsmPrimitive otherParent : w.getReferrers()) {
+                        if (otherParent.isMultipolygon() && ((Relation) otherParent).hasIncompleteMembers() == false) {
+                            if (left.matches(new Environment(otherParent).withParent(otherParent))) {
+                                checkedPrimitives.add(otherParent);
+                                if (e.parent == otherParent || ((Relation) otherParent).hasIncompleteMembers())
+                                    return;
+                                // we have a matching way that might cross a multipolygon, check if they are overlapping
+                                Area a1 = Geometry.getArea(((Way) e.osm).getNodes());
+
+                                Multipolygon p2 = MultipolygonCache.getInstance().get(Main.map.mapView, (Relation) otherParent);
+                                if (p2 == null)
+                                    return;
+                                for (PolyData pd2 : p2.getCombinedPolygons()) {
+                                    Area a2 = new Area(pd2.get());
+                                    checkIntersection(a1, a2, otherParent);
+                                    if (e.child != null) {
+                                        if (e.hilite == null) {
+                                            Set<OsmPrimitive> hilite = new HashSet<>();
+                                            hilite.add(e.osm);
+                                            hilite.addAll(getMpWays(otherParent, pd2));
+                                            e.hilite = new ArrayList<>(hilite);
+                                        }
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
+
+            private Collection<? extends OsmPrimitive> getMpWays(OsmPrimitive mpRelation, PolyData pd) {
+                List<OsmPrimitive> ways = new ArrayList<>();
+                for (Long id : pd.getWayIds()) {
+                    ways.add(mpRelation.getDataSet().getPrimitiveById(id, OsmPrimitiveType.WAY));
+                }
+                return ways;
+            }
         }
 
         private class ContainsFinder extends AbstractFinder {
@@ -350 +477 @@
                     crossingFinder.visit(e.osm.getDataSet().searchWays(e.osm.getBBox()));
                 }
                 return e.child != null;
+            } else if (ChildOrParentSelectorType.CROSSING.equals(type) && e.osm.isMultipolygon()) {
+                Relation r = (Relation) e.osm;
+                if (r.hasIncompleteMembers())
+                    return false;
+                List<RelationMember> members = r.getMembers();
+                for (int i = 0; i < members.size(); i++) {
+                    OsmPrimitive member = members.get(i).getMember();
+                    if (member instanceof Way) {
+                        Environment ew = new Environment(member);
+                        ew.parent = e.osm;
+                        final CrossingFinder crossingFinder = new CrossingFinder(ew);
+                        if (right instanceof OptimizedGeneralSelector
+                                && ((OptimizedGeneralSelector) right).matchesBase(OsmPrimitiveType.WAY)) {
+                            List<Way> nearWays = ew.osm.getDataSet().searchWays(ew.osm.getBBox());
+                            crossingFinder.visit(nearWays);
+                            if (ew.child != null) {
+                                e.child = ew.child;
+                                e.hilite = ew.hilite;
+                                return true;
+                            }
+                        }
+                    }
+                }
+                return e.child != null;
             } else if (ChildOrParentSelectorType.SIBLING.equals(type)) {
                 if (e.osm instanceof Node) {
                     for (Way w : Utils.filteredCollection(e.osm.getReferrers(true), Way.class)) {