Index: data/defaultpresets.xml
===================================================================
--- data/defaultpresets.xml (revision 15556)
+++ data/defaultpresets.xml (working copy)
@@ -7580,6 +7580,19 @@
+ -
+
+
+
+
+
+
+
+
+
+
+
+
-
Index: images/presets/transport/way/relation_connectivity.svg
===================================================================
--- images/presets/transport/way/relation_connectivity.svg (nonexistent)
+++ images/presets/transport/way/relation_connectivity.svg (working copy)
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
Index: src/org/openstreetmap/josm/data/validation/OsmValidator.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/OsmValidator.java (revision 15556)
+++ src/org/openstreetmap/josm/data/validation/OsmValidator.java (working copy)
@@ -42,6 +42,7 @@
import org.openstreetmap.josm.data.validation.tests.BarriersEntrances;
import org.openstreetmap.josm.data.validation.tests.Coastlines;
import org.openstreetmap.josm.data.validation.tests.ConditionalKeys;
+import org.openstreetmap.josm.data.validation.tests.ConnectivityRelations;
import org.openstreetmap.josm.data.validation.tests.CrossingWays;
import org.openstreetmap.josm.data.validation.tests.DuplicateNode;
import org.openstreetmap.josm.data.validation.tests.DuplicateRelation;
@@ -150,6 +151,7 @@
PublicTransportRouteTest.class, // 3600 .. 3699
RightAngleBuildingTest.class, // 3700 .. 3799
SharpAngles.class, // 3800 .. 3899
+ ConnectivityRelations.class, // 3900 .. 3999
};
/**
Index: src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java (nonexistent)
+++ src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java (working copy)
@@ -0,0 +1,186 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.regex.Pattern;
+
+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.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.Way;
+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.tools.Logging;
+
+/**
+ * Check for inconsistencies in lane information between relation and members.
+ */
+public class ConnectivityRelations extends Test {
+
+ protected static final int INCONSISTENT_LANE_COUNT = 3900;
+
+ protected static final int UNKNOWN_CONNECTIVITY_ROLE = INCONSISTENT_LANE_COUNT + 1;
+
+ protected static final int NO_CONNECTIVITY_TAG = INCONSISTENT_LANE_COUNT + 2;
+
+ protected static final int TOO_MANY_ROLES = INCONSISTENT_LANE_COUNT + 3;
+
+ private static final String CONNECTIVITY_TAG = "connectivity";
+ private static final String VIA = "via";
+ private static final String TO = "to";
+ private static final String FROM = "from";
+ private static final Pattern OPTIONAL_LANE_PATTERN = Pattern.compile("\\([0-9]+\\)");
+ private static final Pattern TO_LANE_PATTERN = Pattern.compile("\\p{Zs}*[,:;]\\p{Zs}*");
+
+ /**
+ * Constructor
+ */
+ public ConnectivityRelations() {
+ super(tr("Connectivity Relation Check"), tr("Checks that lane count of relation matches with lanes of members"));
+ }
+
+ /**
+ * Convert the connectivity tag into a map of values
+ *
+ * @param relation A relation with a {@code connectivity} tag.
+ * @return A Map in the form of {@code Map>} May contain nulls when errors are encountered
+ * @since xxx
+ */
+ public static Map> parseConnectivityTag(Relation relation) {
+ final String joined = relation.get(CONNECTIVITY_TAG);
+
+ if (joined == null) {
+ return Collections.emptyMap();
+ }
+
+ final Map> result = new HashMap<>();
+ String[] lanes = joined.split("\\|", -1);
+ for (int i = 0; i < lanes.length; i++) {
+ String[] lane = lanes[i].split(":", -1);
+ int laneNumber = Integer.parseInt(lane[0].trim());
+ Map connections = new HashMap<>();
+ String[] toLanes = TO_LANE_PATTERN.split(lane[1]);
+ for (int j = 0; j < toLanes.length; j++) {
+ String toLane = toLanes[j].trim();
+ try {
+ if (OPTIONAL_LANE_PATTERN.matcher(toLane).matches()) {
+ toLane = toLane.replace("(", "").replace(")", "").trim();
+ connections.put(Integer.parseInt(toLane), Boolean.TRUE);
+ } else {
+ connections.put(Integer.parseInt(toLane), Boolean.FALSE);
+ }
+ } catch (NumberFormatException e) {
+ Logging.debug(e);
+ connections.put(null, null);
+ }
+
+ }
+ result.put(laneNumber, connections);
+ }
+ return result;
+ }
+
+ @Override
+ public void visit(Relation r) {
+ if (r.hasTag("type", CONNECTIVITY_TAG)) {
+ if (!r.hasKey(CONNECTIVITY_TAG)) {
+ errors.add(TestError.builder(this, Severity.WARNING, NO_CONNECTIVITY_TAG)
+ .message(tr("No connectivity tag in connectivity relation")).primitives(r).build());
+ } else if (!r.hasIncompleteMembers()) {
+ boolean badRole = checkForBadRole(r);
+ if (!badRole)
+ checkForInconsistentLanes(r);
+ }
+ }
+ }
+
+ private void checkForInconsistentLanes(Relation relation) {
+ // Lane count from connectivity tag
+ Map> connTagLanes = parseConnectivityTag(relation);
+ // Lane count from member tags
+ Map roleLanes = new HashMap<>();
+
+ for (RelationMember rM : relation.getMembers()) {
+ // Check lanes
+ if (rM.getType() == OsmPrimitiveType.WAY) {
+ OsmPrimitive prim = rM.getMember();
+ if (prim.hasKey("lanes") && !VIA.equals(rM.getRole())) {
+ roleLanes.put(rM.getRole(), Integer.parseInt(prim.get("lanes")));
+ }
+ }
+ }
+ boolean fromCheck = roleLanes.get(FROM) < Collections
+ .max(connTagLanes.entrySet(), Comparator.comparingInt(Map.Entry::getKey)).getKey();
+ boolean toCheck = false;
+ for (Entry> to : connTagLanes.entrySet()) {
+ toCheck = roleLanes.get(TO) < Collections
+ .max(to.getValue().entrySet(), Comparator.comparingInt(Map.Entry::getKey)).getKey();
+ }
+ if (fromCheck || toCheck) {
+ errors.add(TestError.builder(this, Severity.WARNING, INCONSISTENT_LANE_COUNT)
+ .message(tr("Inconsistent lane numbering between relation and members")).primitives(relation)
+ .build());
+ }
+ }
+
+ private boolean checkForBadRole(Relation relation) {
+ // Check role names
+ int viaWays = 0;
+ int viaNodes = 0;
+ int toWays = 0;
+ int fromWays = 0;
+ for (RelationMember relationMember : relation.getMembers()) {
+ if (relationMember.getMember() instanceof Way) {
+ if (relationMember.hasRole(FROM))
+ fromWays++;
+ else if (relationMember.hasRole(TO))
+ toWays++;
+ else if (relationMember.hasRole(VIA))
+ viaWays++;
+ else {
+ createUnknownRole(relation, relationMember.getMember());
+ return true;
+ }
+ } else if (relationMember.getMember() instanceof Node) {
+ if (!relationMember.hasRole(VIA)) {
+ createUnknownRole(relation, relationMember.getMember());
+ return true;
+ }
+ viaNodes++;
+ }
+ }
+ return mixedViaNodeAndWay(relation, viaWays, viaNodes, toWays, fromWays);
+ }
+
+ private boolean mixedViaNodeAndWay(Relation relation, int viaWays, int viaNodes, int toWays, int fromWays) {
+ String message = "";
+ if ((viaWays != 0 && viaNodes != 0) || viaNodes > 1) {
+ message = tr("Relation contains {1} {0} roles.", VIA, viaWays + viaNodes);
+ } else if (toWays != 1) {
+ message = tr("Relation contains too many {0} roles", TO);
+ } else if (fromWays != 1) {
+ message = tr("Relation contains too many {0} roles", FROM);
+ }
+ if (message.isEmpty()) {
+ return false;
+ } else {
+ errors.add(TestError.builder(this, Severity.WARNING, TOO_MANY_ROLES)
+ .message(message).primitives(relation).build());
+ return true;
+ }
+ }
+
+ private void createUnknownRole(Relation relation, OsmPrimitive primitive) {
+ errors.add(TestError.builder(this, Severity.WARNING, UNKNOWN_CONNECTIVITY_ROLE)
+ .message(tr("Unkown role in connectivity relation")).primitives(relation).highlight(primitive).build());
+ }
+}
Index: test/unit/org/openstreetmap/josm/data/validation/tests/ConnectivityRelationsTest.java
===================================================================
--- test/unit/org/openstreetmap/josm/data/validation/tests/ConnectivityRelationsTest.java (nonexistent)
+++ test/unit/org/openstreetmap/josm/data/validation/tests/ConnectivityRelationsTest.java (working copy)
@@ -0,0 +1,116 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.openstreetmap.josm.JOSMFixture;
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+
+/**
+ * Test the ConnectivityRelations validation test
+ *
+ * @author Taylor Smock
+ */
+public class ConnectivityRelationsTest {
+ private ConnectivityRelations check;
+ private static final String CONNECTIVITY = "connectivity";
+ /**
+ * Setup test.
+ *
+ * @throws Exception if an error occurs
+ */
+ @Before
+ public void setUp() throws Exception {
+ JOSMFixture.createUnitTestFixture().init();
+ check = new ConnectivityRelations();
+ }
+
+ private Relation createDefaultTestRelation() {
+ Node connection = new Node(new LatLon(0, 0));
+ return TestUtils.newRelation("type=connectivity connectivity=1:1",
+ new RelationMember("from", TestUtils.newWay("lanes=4", new Node(new LatLon(-0.1, -0.1)), connection)),
+ new RelationMember("via", connection),
+ new RelationMember("to", TestUtils.newWay("lanes=4", connection, new Node(new LatLon(0.1, 0.1)))));
+ }
+
+ /**
+ * Test for connectivity relations without a connectivity tag
+ */
+ @Test
+ public void testNoConnectivityTag() {
+ Relation relation = createDefaultTestRelation();
+ check.visit(relation);
+
+ Assert.assertEquals(0, check.getErrors().size());
+
+ relation.remove(CONNECTIVITY);
+ check.visit(relation);
+ Assert.assertEquals(1, check.getErrors().size());
+ }
+
+ /**
+ * Check for lanes that don't make sense
+ */
+ @Test
+ public void testMisMatchedLanes() {
+ Relation relation = createDefaultTestRelation();
+ check.visit(relation);
+ int expectedFailures = 0;
+
+ Assert.assertEquals(expectedFailures, check.getErrors().size());
+
+ relation.put(CONNECTIVITY, "45000:1");
+ check.visit(relation);
+ Assert.assertEquals(++expectedFailures, check.getErrors().size());
+
+ relation.put(CONNECTIVITY, "1:45000");
+ check.visit(relation);
+ Assert.assertEquals(++expectedFailures, check.getErrors().size());
+
+ relation.put(CONNECTIVITY, "1:1,2");
+ check.visit(relation);
+ Assert.assertEquals(expectedFailures, check.getErrors().size());
+
+ relation.put(CONNECTIVITY, "1:1,(2)");
+ check.visit(relation);
+ Assert.assertEquals(expectedFailures, check.getErrors().size());
+
+ relation.put(CONNECTIVITY, "1:1,(20000)");
+ check.visit(relation);
+ Assert.assertEquals(++expectedFailures, check.getErrors().size());
+ }
+
+ /**
+ * Check for bad roles (not from/via/to)
+ */
+ @Test
+ public void testForBadRole() {
+ Relation relation = createDefaultTestRelation();
+ check.visit(relation);
+ int expectedFailures = 0;
+
+ Assert.assertEquals(expectedFailures, check.getErrors().size());
+
+ for (int i = 0; i < relation.getMembers().size(); i++) {
+ String tRole = replaceMember(relation, i, "badRole");
+ check.visit(relation);
+ Assert.assertEquals(++expectedFailures, check.getErrors().size());
+ replaceMember(relation, i, tRole);
+ check.visit(relation);
+ Assert.assertEquals(expectedFailures, check.getErrors().size());
+ }
+ }
+
+ private String replaceMember(Relation relation, int index, String replacementRole) {
+ RelationMember relationMember = relation.getMember(index);
+ String currentRole = relationMember.getRole();
+ relation.removeMember(index);
+ relation.addMember(index, new RelationMember(replacementRole, relationMember.getMember()));
+ return currentRole;
+ }
+}