Changeset 15732 in josm

Timestamp:

2020-01-19T18:57:26+01:00 (4 years ago)

Author:

simon04

Message:

see #18503 - Relation editor: compute wayConnection for type=superroute

This basic implementation only considers route segments without a role
(as specified for public_transport:version=2; no forward/backward)
and does not take roundabouts into account.

Location:

trunk

Files:

• src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionType.java (modified) (2 diffs)
• src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculator.java (modified) (7 diffs)
• src/org/openstreetmap/josm/tools/StreamUtils.java (modified) (2 diffs)
• test/unit/org/openstreetmap/josm/tools/StreamUtilsTest.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionType.java

@@ -80 +80 @@
      */
     public WayConnectionType(boolean invalid) {
+        this.linkPrev = false;
+        this.linkNext = false;
+        this.isLoop = false;
+        this.direction = NONE;
         this.invalid = invalid;
     }
@@ -85 +89 @@
     /** construct invalid instance */
     public WayConnectionType() {
-        this.linkPrev = false;
-        this.linkNext = false;
-        this.isLoop = false;
-        this.direction = NONE;
-        invalid = true;
+        this(true);
     }
 

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculator.java

@@ -8 +8 @@
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.Node;
@@ -14 +15 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType.Direction;
+import org.openstreetmap.josm.tools.StreamUtils;
 import org.openstreetmap.josm.tools.bugreport.BugReport;
 
@@ -43 +45 @@
     public List<WayConnectionType> updateLinks(Relation r, List<RelationMember> members) {
         this.members = members;
-        final List<WayConnectionType> con = new ArrayList<>();
-
-        for (int i = 0; i < members.size(); ++i) {
-            con.add(null);
-        }
+        final List<WayConnectionType> con = members.stream()
+                .map(ignore -> (WayConnectionType) null)
+                .collect(Collectors.toList());
 
         firstGroupIdx = 0;
@@ -65 +65 @@
             }
         }
-        makeLoopIfNeeded(con, members.size()-1);
+        if (!isSuperRoute(r)) {
+            makeLoopIfNeeded(con, members.size() - 1);
+        }
 
         return con;
@@ -72 +74 @@
     private WayConnectionType updateLinksFor(Relation r, List<WayConnectionType> con, WayConnectionType lastWct, int i) {
         final RelationMember m = members.get(i);
-        if (isNoHandleableWay(m)) {
+        if (isSuperRoute(r)) {
+            final WayConnectionType wct;
+            if (!members.get(i).isRelation()) {
+                return new WayConnectionType(true);
+            } else if (i == 0) {
+                return new WayConnectionType(false);
+            } else {
+                final List<RelationMember> previousMembers = members.get(i - 1).getRelation().getMembers();
+                final Way previousLastWay = StreamUtils.reversedStream(previousMembers)
+                        .filter(x -> x.isWay() && !x.hasRole())
+                        .map(RelationMember::getWay)
+                        .findFirst().orElse(null);
+                final Way currentFirstWay = m.getRelation().getMembers().stream()
+                        .filter(x -> x.isWay() && !x.hasRole())
+                        .map(RelationMember::getWay)
+                        .findFirst().orElse(null);
+                final boolean isConnected = isConnected(previousLastWay, currentFirstWay);
+                wct = new WayConnectionType(false);
+                lastWct.linkNext = wct.linkPrev = isConnected;
+            }
+            con.set(i, wct);
+            return wct;
+        } else if (isNoHandleableWay(m)) {
             if (i > 0) {
                 makeLoopIfNeeded(con, i-1);
@@ -139 +163 @@
         con.set(i, wct);
         return wct;
+    }
+
+    private boolean isSuperRoute(Relation r) {
+        return r != null && r.hasTag("type", "superroute");
     }
 
@@ -372 +400 @@
         members = null;
     }
+
+    private boolean isConnected(Way way1, Way way2) {
+        return way1 != null && way2 != null && way1.isUsable() && way2.isUsable()
+                && (way1.isFirstLastNode(way2.firstNode()) || way1.isFirstLastNode(way2.lastNode()));
+    }
 }

trunk/src/org/openstreetmap/josm/tools/StreamUtils.java

@@ -2 +2 @@
 package org.openstreetmap.josm.tools;
 
+import java.util.List;
+import java.util.Objects;
 import java.util.StringJoiner;
 import java.util.stream.Collector;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
@@ -32 +35 @@
 
     /**
+     * Creqates a stream iterating the list in reversed order
+     * @param list the list to iterate over
+     * @param <T> the type of elements in the list
+     * @return a stream iterating the list in reversed order
+     * @since 15732
+     */
+    public static <T> Stream<T> reversedStream(List<T> list) {
+        Objects.requireNonNull(list, "list");
+        final int size = list.size();
+        return IntStream.range(0, size).mapToObj(i -> list.get(size - i - 1));
+    }
+
+    /**
      * Creates a new Collector that collects the items and returns them as HTML unordered list.
      * @return The collector.

trunk/test/unit/org/openstreetmap/josm/tools/StreamUtilsTest.java

@@ -5 +5 @@
 import org.junit.Test;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -29 +34 @@
         UtilityClassTestUtil.assertUtilityClassWellDefined(StreamUtils.class);
     }
+
+    /**
+     * Tests {@link StreamUtils#reversedStream(java.util.List)}
+     */
+    @Test
+    public void testReverseStream() {
+        assertEquals("baz/bar/foo",
+                StreamUtils.reversedStream(Arrays.asList("foo", "bar", "baz")).collect(Collectors.joining("/")));
+    }
 }