Ticket #16188: 0001-Add-support-for-crossing-of-residential-areas-with-s.patch

File 0001-Add-support-for-crossing-of-residential-areas-with-s.patch, 7.4 KB (added by marxin, 6 months ago)

V3 of the patch

  • data/validator/geometry.mapcss

    From 3b518fd8c848cd312e0fbb5633130db89fb25bc2 Mon Sep 17 00:00:00 2001
    From: marxin <mliska@suse.cz>
    Date: Sat, 3 Mar 2018 21:40:22 +0100
    Subject: [PATCH] Add support for crossing of residential areas with something.
    
    ---
     data/validator/geometry.mapcss                     |  3 +-
     .../openstreetmap/josm/data/validation/Test.java   |  9 +++
     .../josm/data/validation/tests/CrossingWays.java   | 81 ++++++++++++++++++----
     3 files changed, 80 insertions(+), 13 deletions(-)
    
    diff --git a/data/validator/geometry.mapcss b/data/validator/geometry.mapcss
    index 971ba7cf7..9dc1831b7 100644
    a b area:closed:areaStyle[tag("natural") = parent_tag("natural")] ⧉ area:closed:ar 
    184184  throwWarning: tr("Overlapping Identical Natural Areas");
    185185}
    186186
    187 area:closed:areaStyle[tag("landuse") = parent_tag("landuse")] ⧉ area:closed:areaStyle[landuse] {
     187area:closed:areaStyle[landuse!=residential][tag("landuse") = parent_tag("landuse")] ⧉
     188 area:closed:areaStyle[landuse!=residential][landuse] {
    188189  throwWarning: tr("Overlapping Identical Landuses");
    189190}
    190191
  • src/org/openstreetmap/josm/data/validation/Test.java

    diff --git a/src/org/openstreetmap/josm/data/validation/Test.java b/src/org/openstreetmap/josm/data/validation/Test.java
    index 8aaf54553..d17163ea1 100644
    a b public class Test implements OsmPrimitiveVisitor, Comparable<Test> { 
    346346        return p.hasTagDifferent("building", "no", "entrance");
    347347    }
    348348
     349    /**
     350     * Determines if the specified primitive denotes a residential area.
     351     * @param p The primitive to be tested
     352     * @return True if landuse key is equal to residential
     353     */
     354    protected static final boolean isResidentialArea(OsmPrimitive p) {
     355        return p.get("landuse") == "residential";
     356    }
     357
    349358    @Override
    350359    public int hashCode() {
    351360        return Objects.hash(name, description);
  • src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

    diff --git a/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java b/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java
    index dd91a119f..d7941d809 100644
    a b import static org.openstreetmap.josm.tools.I18n.tr; 
    55
    66import java.awt.geom.Point2D;
    77import java.util.ArrayList;
     8import java.util.Arrays;
    89import java.util.HashMap;
    910import java.util.List;
    1011import java.util.Map;
    public abstract class CrossingWays extends Test { 
    3435    static final String HIGHWAY = "highway";
    3536    static final String RAILWAY = "railway";
    3637    static final String WATERWAY = "waterway";
     38    static final String LANDUSE = "landuse";
    3739
    3840    /** All way segments, grouped by cells */
    3941    private final Map<Point2D, List<WaySegment>> cellSegments = new HashMap<>(1000);
    public abstract class CrossingWays extends Test { 
    6466                    || w.hasKey(WATERWAY)
    6567                    || isRailway(w)
    6668                    || isCoastline(w)
    67                     || isBuilding(w));
     69                    || isBuilding(w)
     70                    || isResidentialArea(w));
    6871        }
    6972
    7073        @Override
    public abstract class CrossingWays extends Test { 
    7780            if (w1.hasKey(HIGHWAY) && w2.hasKey(HIGHWAY) && !Objects.equals(w1.get("level"), w2.get("level"))) {
    7881                return true;
    7982            }
     83            if ((w1.hasKey(HIGHWAY) && isResidentialArea(w2))
     84             || (w2.hasKey(HIGHWAY) && isResidentialArea(w1)))
     85                return true;
    8086            if (isSubwayOrTramOrRazed(w2)) {
    8187                return true;
    8288            }
    public abstract class CrossingWays extends Test { 
    9096            return isProposedOrAbandoned(w2);
    9197        }
    9298
     99        private String getWayType(Way w) {
     100            if (isBuilding(w))
     101                return "building";
     102            else if (w.hasKey(HIGHWAY))
     103                return "highway";
     104            else if (isResidentialArea(w))
     105                return "residential area";
     106            else if (w.hasKey(WATERWAY))
     107                return "waterway";
     108            else
     109                return "way";
     110        }
     111
    93112        @Override
    94113        String createMessage(Way w1, Way w2) {
    95             if (isBuilding(w1)) {
    96                 return tr("Crossing buildings");
    97             } else if (w1.hasKey(WATERWAY) && w2.hasKey(WATERWAY)) {
    98                 return tr("Crossing waterways");
    99             } else if ((w1.hasKey(HIGHWAY) && w2.hasKey(WATERWAY))
    100                     || (w2.hasKey(HIGHWAY) && w1.hasKey(WATERWAY))) {
    101                 return tr("Crossing waterway/highway");
    102             } else {
    103                 return tr("Crossing ways");
    104             }
     114            String[] types = { getWayType(w1), getWayType(w2) };
     115            Arrays.sort(types);
     116
     117            if (types[0] == types[1])
     118                switch(types[0]) {
     119                    case "building":
     120                        return tr("Crossing buildings");
     121                    case "highway":
     122                        return tr("Crossing highways");
     123                    case "residential area":
     124                        return tr("Crossing residential areas");
     125                    case "waterway":
     126                        return tr("Crossing waterways");
     127                    default:
     128                        return tr("Crossing ways");
     129                }
     130            else
     131                switch (types[0]) {
     132                    case "building":
     133                        switch (types[1]) {
     134                            case "highway":
     135                                return tr("Crossing building/highway");
     136                            case "residential area":
     137                                return tr("Crossing building/residential area");
     138                            case "waterway":
     139                                return tr("Crossing building/waterway");
     140                            default:
     141                                return tr("Crossing building/way");
     142                        }
     143                    case "highway":
     144                        switch (types[1]) {
     145                            case "residential area":
     146                                return tr("Crossing highway/residential area");
     147                            case "waterway":
     148                                return tr("Crossing highway/waterway");
     149                            default:
     150                                return tr("Crossing highway/way");
     151                        }
     152                    case "residential area":
     153                        switch (types[1]) {
     154                            case "waterway":
     155                                return tr("Crossing residential area/waterway");
     156                            default:
     157                                return tr("Crossing residential area/way");
     158                        }
     159                    default:
     160                        return tr("Crossing residential area/waterway");
     161                }
    105162        }
    106163    }
    107164
    public abstract class CrossingWays extends Test { 
    235292    }
    236293
    237294    static boolean isCoastline(OsmPrimitive w) {
    238         return w.hasTag("natural", "water", "coastline") || w.hasTag("landuse", "reservoir");
     295        return w.hasTag("natural", "water", "coastline") || w.hasTag(LANDUSE, "reservoir");
    239296    }
    240297
    241298    static boolean isHighway(OsmPrimitive w) {