source: josm/trunk/src/org/openstreetmap/josm/data/validation/tests/Highways.java @ 13976

Last change on this file since 13976 was 13976, checked in by Don-vip, 6 months ago

fix #16425 - support "zone40" maxspeed context

  • Property svn:eol-style set to native
File size: 12.4 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.validation.tests;
3
4import static org.openstreetmap.josm.data.validation.tests.CrossingWays.HIGHWAY;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.util.ArrayList;
8import java.util.Arrays;
9import java.util.HashMap;
10import java.util.HashSet;
11import java.util.List;
12import java.util.Locale;
13import java.util.Map;
14import java.util.Set;
15import java.util.stream.Collectors;
16
17import org.openstreetmap.josm.command.ChangePropertyCommand;
18import org.openstreetmap.josm.data.osm.Node;
19import org.openstreetmap.josm.data.osm.OsmPrimitive;
20import org.openstreetmap.josm.data.osm.OsmUtils;
21import org.openstreetmap.josm.data.osm.Way;
22import org.openstreetmap.josm.data.validation.Severity;
23import org.openstreetmap.josm.data.validation.Test;
24import org.openstreetmap.josm.data.validation.TestError;
25import org.openstreetmap.josm.tools.Utils;
26
27/**
28 * Test that performs semantic checks on highways.
29 * @since 5902
30 */
31public class Highways extends Test {
32
33    protected static final int WRONG_ROUNDABOUT_HIGHWAY = 2701;
34    protected static final int MISSING_PEDESTRIAN_CROSSING = 2702;
35    protected static final int SOURCE_MAXSPEED_UNKNOWN_COUNTRY_CODE = 2703;
36    protected static final int SOURCE_MAXSPEED_UNKNOWN_CONTEXT = 2704;
37    protected static final int SOURCE_MAXSPEED_CONTEXT_MISMATCH_VS_MAXSPEED = 2705;
38    protected static final int SOURCE_MAXSPEED_CONTEXT_MISMATCH_VS_HIGHWAY = 2706;
39    protected static final int SOURCE_WRONG_LINK = 2707;
40
41    protected static final String SOURCE_MAXSPEED = "source:maxspeed";
42
43    /**
44     * Classified highways in order of importance
45     */
46    // CHECKSTYLE.OFF: SingleSpaceSeparator
47    private static final List<String> CLASSIFIED_HIGHWAYS = Arrays.asList(
48            "motorway",  "motorway_link",
49            "trunk",     "trunk_link",
50            "primary",   "primary_link",
51            "secondary", "secondary_link",
52            "tertiary",  "tertiary_link",
53            "unclassified",
54            "residential",
55            "living_street");
56    // CHECKSTYLE.ON: SingleSpaceSeparator
57
58    private static final Set<String> KNOWN_SOURCE_MAXSPEED_CONTEXTS = new HashSet<>(Arrays.asList(
59            "urban", "rural", "zone", "zone20", "zone:20", "zone30", "zone:30", "zone40",
60            "nsl_single", "nsl_dual", "motorway", "trunk", "living_street", "bicycle_road"));
61
62    private static final Set<String> ISO_COUNTRIES = new HashSet<>(Arrays.asList(Locale.getISOCountries()));
63
64    private boolean leftByPedestrians;
65    private boolean leftByCyclists;
66    private boolean leftByCars;
67    private int pedestrianWays;
68    private int cyclistWays;
69    private int carsWays;
70
71    /**
72     * Constructs a new {@code Highways} test.
73     */
74    public Highways() {
75        super(tr("Highways"), tr("Performs semantic checks on highways."));
76    }
77
78    @Override
79    public void visit(Node n) {
80        if (n.isUsable()) {
81            if (!n.hasTag("crossing", "no")
82             && !(n.hasKey("crossing") && (n.hasTag(HIGHWAY, "crossing")
83                                        || n.hasTag(HIGHWAY, "traffic_signals")))
84             && n.isReferredByWays(2)) {
85                testMissingPedestrianCrossing(n);
86            }
87            if (n.hasKey(SOURCE_MAXSPEED)) {
88                // Check maxspeed but not context against highway for nodes
89                // as maxspeed is not set on highways here but on signs, speed cameras, etc.
90                testSourceMaxspeed(n, false);
91            }
92        }
93    }
94
95    @Override
96    public void visit(Way w) {
97        if (w.isUsable()) {
98            if (w.isClosed() && w.hasTag(HIGHWAY, CLASSIFIED_HIGHWAYS) && w.hasTag("junction", "roundabout")
99                    && IN_DOWNLOADED_AREA_STRICT.test(w)) {
100                // TODO: find out how to handle splitted roundabouts (see #12841)
101                testWrongRoundabout(w);
102            }
103            if (w.hasKey(SOURCE_MAXSPEED)) {
104                // Check maxspeed, including context against highway
105                testSourceMaxspeed(w, true);
106            }
107            testHighwayLink(w);
108        }
109    }
110
111    private void testWrongRoundabout(Way w) {
112        Map<String, List<Way>> map = new HashMap<>();
113        // Count all highways (per type) connected to this roundabout, except correct links
114        // As roundabouts are closed ways, take care of not processing the first/last node twice
115        for (Node n : new HashSet<>(w.getNodes())) {
116            for (Way h : Utils.filteredCollection(n.getReferrers(), Way.class)) {
117                String value = h.get(HIGHWAY);
118                if (h != w && value != null) {
119                    boolean link = value.endsWith("_link");
120                    boolean linkOk = isHighwayLinkOkay(h);
121                    if (link && !linkOk) {
122                        // "Autofix" bad link value to avoid false positive in roundabout check
123                        value = value.replaceAll("_link$", "");
124                    }
125                    if (!link || !linkOk) {
126                        List<Way> list = map.get(value);
127                        if (list == null) {
128                            list = new ArrayList<>();
129                            map.put(value, list);
130                        }
131                        list.add(h);
132                    }
133                }
134            }
135        }
136        // The roundabout should carry the highway tag of its two biggest highways
137        for (String s : CLASSIFIED_HIGHWAYS) {
138            List<Way> list = map.get(s);
139            if (list != null && list.size() >= 2) {
140                // Except when a single road is connected, but with two oneway segments
141                Boolean oneway1 = OsmUtils.getOsmBoolean(list.get(0).get("oneway"));
142                Boolean oneway2 = OsmUtils.getOsmBoolean(list.get(1).get("oneway"));
143                if (list.size() > 2 || oneway1 == null || oneway2 == null || !oneway1 || !oneway2) {
144                    // Error when the highway tags do not match
145                    String value = w.get(HIGHWAY);
146                    if (!value.equals(s)) {
147                        errors.add(TestError.builder(this, Severity.WARNING, WRONG_ROUNDABOUT_HIGHWAY)
148                                .message(tr("Incorrect roundabout (highway: {0} instead of {1})", value, s))
149                                .primitives(w)
150                                .fix(() -> new ChangePropertyCommand(w, HIGHWAY, s))
151                                .build());
152                    }
153                    break;
154                }
155            }
156        }
157    }
158
159    /**
160     * Determines if the given link road is correct, see https://wiki.openstreetmap.org/wiki/Highway_link.
161     * @param way link road
162     * @return {@code true} if the link road is correct or if the check cannot be performed due to missing data
163     */
164    public static boolean isHighwayLinkOkay(final Way way) {
165        final String highway = way.get(HIGHWAY);
166        if (highway == null || !highway.endsWith("_link")
167                || !IN_DOWNLOADED_AREA.test(way.getNode(0)) || !IN_DOWNLOADED_AREA.test(way.getNode(way.getNodesCount()-1))) {
168            return true;
169        }
170
171        final Set<OsmPrimitive> referrers = new HashSet<>();
172
173        if (way.isClosed()) {
174            // for closed way we need to check all adjacent ways
175            for (Node n: way.getNodes()) {
176                referrers.addAll(n.getReferrers());
177            }
178        } else {
179            referrers.addAll(way.firstNode().getReferrers());
180            referrers.addAll(way.lastNode().getReferrers());
181        }
182
183        // Find ways of same class (exact class of class_link)
184        List<Way> sameClass = Utils.filteredCollection(referrers, Way.class).stream().filter(
185                otherWay -> !way.equals(otherWay) && otherWay.hasTag(HIGHWAY, highway, highway.replaceAll("_link$", "")))
186                .collect(Collectors.toList());
187        if (sameClass.size() > 1) {
188            // It is possible to have a class_link between 2 segments of same class
189            // in roundabout designs that physically separate a specific turn from the main roundabout
190            // But if we have more than a single adjacent class, and one of them is a roundabout, that's an error
191            for (Way w : sameClass) {
192                if (w.hasTag("junction", "roundabout")) {
193                    return false;
194                }
195            }
196        }
197        // Link roads should always at least one adjacent segment of same class
198        return !sameClass.isEmpty();
199    }
200
201    private void testHighwayLink(final Way way) {
202        if (!isHighwayLinkOkay(way)) {
203            errors.add(TestError.builder(this, Severity.WARNING, SOURCE_WRONG_LINK)
204                    .message(tr("Highway link is not linked to adequate highway/link"))
205                    .primitives(way)
206                    .build());
207        }
208    }
209
210    private void testMissingPedestrianCrossing(Node n) {
211        leftByPedestrians = false;
212        leftByCyclists = false;
213        leftByCars = false;
214        pedestrianWays = 0;
215        cyclistWays = 0;
216        carsWays = 0;
217
218        for (Way w : n.getParentWays()) {
219            String highway = w.get(HIGHWAY);
220            if (highway != null) {
221                if ("footway".equals(highway) || "path".equals(highway)) {
222                    handlePedestrianWay(n, w);
223                    if (w.hasTag("bicycle", "yes", "designated")) {
224                        handleCyclistWay(n, w);
225                    }
226                } else if ("cycleway".equals(highway)) {
227                    handleCyclistWay(n, w);
228                    if (w.hasTag("foot", "yes", "designated")) {
229                        handlePedestrianWay(n, w);
230                    }
231                } else if (CLASSIFIED_HIGHWAYS.contains(highway)) {
232                    // Only look at classified highways for now:
233                    // - service highways support is TBD (see #9141 comments)
234                    // - roads should be determined first. Another warning is raised anyway
235                    handleCarWay(n, w);
236                }
237                if ((leftByPedestrians || leftByCyclists) && leftByCars) {
238                    errors.add(TestError.builder(this, Severity.OTHER, MISSING_PEDESTRIAN_CROSSING)
239                            .message(tr("Incomplete pedestrian crossing tagging. Required tags are {0} and {1}.",
240                            "highway=crossing|traffic_signals", "crossing=*"))
241                            .primitives(n)
242                            .build());
243                    return;
244                }
245            }
246        }
247    }
248
249    private void handleCarWay(Node n, Way w) {
250        carsWays++;
251        if (!w.isFirstLastNode(n) || carsWays > 1) {
252            leftByCars = true;
253        }
254    }
255
256    private void handleCyclistWay(Node n, Way w) {
257        cyclistWays++;
258        if (!w.isFirstLastNode(n) || cyclistWays > 1) {
259            leftByCyclists = true;
260        }
261    }
262
263    private void handlePedestrianWay(Node n, Way w) {
264        pedestrianWays++;
265        if (!w.isFirstLastNode(n) || pedestrianWays > 1) {
266            leftByPedestrians = true;
267        }
268    }
269
270    private void testSourceMaxspeed(OsmPrimitive p, boolean testContextHighway) {
271        String value = p.get(SOURCE_MAXSPEED);
272        if (value.matches("[A-Z]{2}:.+")) {
273            int index = value.indexOf(':');
274            // Check country
275            String country = value.substring(0, index);
276            if (!ISO_COUNTRIES.contains(country)) {
277                final TestError.Builder error = TestError.builder(this, Severity.WARNING, SOURCE_MAXSPEED_UNKNOWN_COUNTRY_CODE)
278                        .message(tr("Unknown country code: {0}", country))
279                        .primitives(p);
280                if ("UK".equals(country)) {
281                    errors.add(error.fix(() -> new ChangePropertyCommand(p, SOURCE_MAXSPEED, value.replace("UK:", "GB:"))).build());
282                } else {
283                    errors.add(error.build());
284                }
285            }
286            // Check context
287            String context = value.substring(index+1);
288            if (!KNOWN_SOURCE_MAXSPEED_CONTEXTS.contains(context)) {
289                errors.add(TestError.builder(this, Severity.WARNING, SOURCE_MAXSPEED_UNKNOWN_CONTEXT)
290                        .message(tr("Unknown source:maxspeed context: {0}", context))
291                        .primitives(p)
292                        .build());
293            }
294            if (testContextHighway) {
295                // TODO: Check coherence of context against maxspeed
296                // TODO: Check coherence of context against highway
297            }
298        }
299    }
300}
Note: See TracBrowser for help on using the repository browser.