Add basic controls for the routing helper reimplementation

gradle.properties

@@ -10,6 +10,6 @@ plugin.canloadatruntime=true
 plugin.icon=images/bus.svg
 
 # Minimum JOSM version (any numeric version)
-plugin.main.version=15238
+plugin.main.version=15418
 # JOSM version to compile against (any numeric version available for download, or the special values "tested" or "latest")
 plugin.compile.version=17084

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/PTAssistantPlugin.java

@@ -39,6 +39,7 @@
 import org.openstreetmap.josm.plugins.pt_assistant.actions.SortPTRouteMembersAction;
 import org.openstreetmap.josm.plugins.pt_assistant.actions.SortPTRouteMembersMenuBar;
 import org.openstreetmap.josm.plugins.pt_assistant.actions.SplitRoundaboutAction;
+import org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper.RoutingHelperAction;
 import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteSegment;
 import org.openstreetmap.josm.plugins.pt_assistant.gui.PTAssistantLayerManager;
 import org.openstreetmap.josm.plugins.pt_assistant.validation.BicycleFootRouteValidatorTest;
@@ -79,6 +80,7 @@ public PTAssistantPlugin(PluginInformation info) {
             .addMenu("File", trc("menu", "Public Transport"), KeyEvent.VK_P, 5, ht("/Menu/Public Transport"));
         addToMenu(PublicTransportMenu);
 
+        SelectionEventManager.getInstance().addSelectionListener(new RoutingHelperAction());
         SelectionEventManager.getInstance().addSelectionListener(PTAssistantLayerManager.PTLM);
         KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(PTAssistantLayerManager.PTLM);
         initialiseWizard();

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/actions/routinghelper/BicycleTransportMode.java

@@ -0,0 +1,76 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.PTIcons;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+public class BicycleTransportMode implements ITransportMode {
+    @Override
+    public boolean canTraverseWay(@NotNull final IWay<?> way, @NotNull final WayTraversalDirection direction) {
+        final String onewayValue = way.get("oneway");
+        List<String> majorHighways = Arrays.asList(
+            "tertiary", "secondary", "primary", "trunk");
+        majorHighways.forEach(v -> majorHighways.add(String.format("%s_link", v)));
+        // This list is ordered from most suitable to least suitable
+        List<String> suitableHighwaysForBicycle = Arrays.asList(
+            "cycleway", "cyclestreet", "path", "residential", "unclassified", "service", "track", "living_street");
+        suitableHighwaysForBicycle.addAll(majorHighways); // TODO do this only once when plugin starts
+        return !way.hasTag("bicycle", "no") &&
+                    (way.hasTag("highway", suitableHighwaysForBicycle) ||
+                    way.hasTag("bicycle", "yes"))
+                && (
+                onewayValue == null || "no".equals(way.get("oneway:bicycle")) ||
+                    ("yes".equals(onewayValue) && direction == WayTraversalDirection.FORWARD) ||
+                    ("-1".equals(onewayValue) && direction == WayTraversalDirection.BACKWARD)
+        );
+    }
+
+    @Override
+    public boolean canBeUsedForRelation(@NotNull final IRelation<?> relation) {
+        return relation.hasTag("type", "route") && relation.hasTag("route", "bicycle");
+    }
+
+    @Override
+    public boolean canTurn(@NotNull final Way from, @NotNull final Node via, @NotNull final Way to) {
+        final Set<Relation> restrictionRelations = from.getReferrers().stream()
+            .map(it -> it.getType() == OsmPrimitiveType.RELATION ? (Relation) it : null)
+            .filter(Objects::nonNull)
+            .filter(it -> "restriction".equals(it.get("type")) || "restriction:bicycle".equals(it.get("type")))
+            .filter(it -> it.findRelationMembers("from").contains(from))
+            .filter(it -> it.findRelationMembers("via").contains(via))
+            .filter(it -> it.findRelationMembers("to").contains(to))
+            .collect(Collectors.toSet());
+        for (Relation restrictionRelation : restrictionRelations) {
+            final String restriction = restrictionRelation.get("restriction");
+            final String except = restrictionRelation.get("except");
+            if (restriction.startsWith("no_") && !except.contains("bicycle")) {
+                return false;
+            }
+        }
+
+        return from.containsNode(via) && to.containsNode(via);
+    }
+
+    @Override
+    public ImageProvider getIcon() {
+        return PTIcons.BICYCLE;
+    }
+
+    @Override
+    public String getName() {
+        return I18n.marktr("bicycle");
+    }
+}

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/actions/routinghelper/BusTransportMode.java

@@ -0,0 +1,78 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import javax.swing.Icon;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.PTIcons;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+public class BusTransportMode implements ITransportMode {
+    @Override
+    public boolean canTraverseWay(@NotNull final IWay<?> way, @NotNull final WayTraversalDirection direction) {
+        final String onewayValue = way.get("oneway");
+        List<String> majorHighways = Arrays.asList(
+            "motorway", "trunk", "primary", "secondary", "tertiary");
+        majorHighways.forEach(v -> majorHighways.add(String.format("%s_link", v)));
+        List<String> suitableHighwaysForBus = Arrays.asList(
+            "unclassified", "residential", "service", "living_street", "cyclestreet");
+        suitableHighwaysForBus.addAll(majorHighways); // TODO do this only once when plugin starts
+        return (way.hasTag("highway", suitableHighwaysForBus) ||
+                    way.hasTag("psv", "yes") || way.hasTag ("bus", "yes"))
+            && (
+            onewayValue == null || "no".equals(way.get("oneway:bus")) ||
+                ("yes".equals(onewayValue) && direction == WayTraversalDirection.FORWARD) ||
+                ("-1".equals(onewayValue) && direction == WayTraversalDirection.BACKWARD)
+        );
+    }
+
+    @Override
+    public boolean canBeUsedForRelation(@NotNull final IRelation<?> relation) {
+        return relation.hasTag("type", "route") && relation.hasTag("route",
+            "bus", "coach", "minibus");
+    }
+
+    @Override
+    public boolean canTurn(@NotNull final Way from, @NotNull final Node via, @NotNull final Way to) {
+        final Set<Relation> restrictionRelations = from.getReferrers().stream()
+            .map(it -> it.getType() == OsmPrimitiveType.RELATION ? (Relation) it : null)
+            .filter(Objects::nonNull)
+            .filter(it -> "restriction".equals(it.get("type")) || "restriction:bus".equals(it.get("type")))
+            .filter(it -> it.findRelationMembers("from").contains(from))
+            .filter(it -> it.findRelationMembers("via").contains(via))
+            .filter(it -> it.findRelationMembers("to").contains(to))
+            .collect(Collectors.toSet());
+        for (Relation restrictionRelation : restrictionRelations) {
+            final String restriction = restrictionRelation.get("restriction");
+            final String except = restrictionRelation.get("except");
+            if (restriction.startsWith("no_") && !except.contains("psv")) {
+                return false;
+            }
+        }
+
+        return from.containsNode(via) && to.containsNode(via);
+    }
+
+    @Override
+    public ImageProvider getIcon() {
+        return PTIcons.BUS;
+    }
+
+    @Override
+    public String getName() {
+        return I18n.marktr("bus");
+    }
+}

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/actions/routinghelper/HorseTransportMode.java

@@ -0,0 +1,75 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.PTIcons;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+public class HorseTransportMode implements ITransportMode {
+    @Override
+    public boolean canTraverseWay(@NotNull final IWay<?> way, @NotNull final WayTraversalDirection direction) {
+        final String onewayValue = way.get("oneway");
+        List<String> majorHighways = Arrays.asList(
+            "tertiary", "secondary", "primary", "trunk");
+        majorHighways.forEach(v -> majorHighways.add(String.format("%s_link", v)));
+        // This list is ordered from most suitable to least suitable
+        List<String> suitableHighwaysForHorseRiders = Arrays.asList(
+            "bridleway", "pedestrian", "footway", "path", "track", "living_street", "residential", "unclassified", "cyclestreet", "service", "cycleway");
+        suitableHighwaysForHorseRiders.addAll(majorHighways); // TODO do this only once when plugin starts
+        return !way.hasTag("horse", "no") &&
+                    (way.hasTag("highway", suitableHighwaysForHorseRiders) ||
+                    way.hasTag("horse", "yes"))
+                && (
+                onewayValue == null ||
+                    ("yes".equals(onewayValue) && direction == WayTraversalDirection.FORWARD) ||
+                    ("-1".equals(onewayValue) && direction == WayTraversalDirection.BACKWARD)
+        );
+    }
+
+    @Override
+    public boolean canBeUsedForRelation(@NotNull final IRelation<?> relation) {
+        return relation.hasTag("type", "route") && relation.hasTag("route", "horse");
+    }
+
+    @Override
+    public boolean canTurn(@NotNull final Way from, @NotNull final Node via, @NotNull final Way to) {
+        final Set<Relation> restrictionRelations = from.getReferrers().stream()
+            .map(it -> it.getType() == OsmPrimitiveType.RELATION ? (Relation) it : null)
+            .filter(Objects::nonNull)
+            .filter(it -> "restriction".equals(it.get("type")))
+            .filter(it -> it.findRelationMembers("from").contains(from))
+            .filter(it -> it.findRelationMembers("via").contains(via))
+            .filter(it -> it.findRelationMembers("to").contains(to))
+            .collect(Collectors.toSet());
+        for (Relation restrictionRelation : restrictionRelations) {
+            final String restriction = restrictionRelation.get("restriction");
+            if (restriction.startsWith("no_")) {
+                return false;
+            }
+        }
+
+        return from.containsNode(via) && to.containsNode(via);
+    }
+
+    @Override
+    public ImageProvider getIcon() {
+        return PTIcons.HORSE;
+    }
+
+    @Override
+    public String getName() {
+        return I18n.marktr("equestrian");
+    }
+}

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/actions/routinghelper/ITransportMode.java

@@ -0,0 +1,55 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+public interface ITransportMode {
+    /**
+     * Just a convenience method for {@link #canTraverseWay(IWay, WayTraversalDirection)} that assumes {@link WayTraversalDirection#FORWARD}
+     * @param way the way for which we check, if it can be traversed by the transport mode
+     * @return {@code true} if the transport mode can travel along the way in the forward direction. Otherwise {@code false}.
+     */
+    default boolean canTraverseWay(final Way way) {
+        return canTraverseWay(way, WayTraversalDirection.FORWARD);
+    }
+
+    /**
+     * @param way the way that is checked, if the transport mode can traverse
+     * @param direction the travel direction for which we check
+     * @return {@code true} iff the transport mode can travel along the given way in the given direction. Otherwise {@code false}.
+     */
+    boolean canTraverseWay(@NotNull IWay<?> way, @NotNull WayTraversalDirection direction);
+
+    /**
+     * Checks if this transport mode should be used for the given relation
+     * @param relation the relation that is checked, if it is suitable for the transport mode
+     * @return {@code true} if the transport mode is suitable for the relation. Otherwise {@code false}.
+     */
+    boolean canBeUsedForRelation(@NotNull final IRelation<?> relation);
+
+    /**
+     * @param from the way from which the vehicle is coming
+     * @param via the node that the vehicle travels through, must be part of {@code from} and {@code to} ways,
+     *            or this method will return false
+     * @param to the way onto which the vehicle makes the turn
+     * @return {@code true} iff the transport mode can make a turn from the given {@code from} way,
+     *         via the given {@code via} node to the given {@code to} way. Otherwise {@code false}.
+     *         This method assumes that both ways can be traversed by the transport mode, it does not check that.
+     */
+    boolean canTurn(@NotNull final Way from, @NotNull final Node via, @NotNull final Way to);
+
+    /**
+     * @return an icon representing the transport mode
+     */
+    ImageProvider getIcon();
+
+    /**
+     * @return a unique name for the transport mode. This string should be translatable, so please use {@link I18n#marktr} on the string that's returned!
+     */
+    String getName();
+}

src/main/java/org/openstreetmap/josm/plugins/pt_assistant/actions/routinghelper/PedestrianTransportMode.java

@@ -0,0 +1,78 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import javax.swing.Icon;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.PTIcons;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+public class PedestrianTransportMode implements ITransportMode {
+    @Override
+    public boolean canTraverseWay(@NotNull final IWay<?> way, @NotNull final WayTraversalDirection direction) {
+        final String onewayValue = way.get("oneway");
+        List<String> majorHighways = Arrays.asList(
+            "tertiary", "secondary", "primary", "trunk");
+        majorHighways.forEach(v -> majorHighways.add(String.format("%s_link", v)));
+        // This list is ordered from most suitable to least suitable
+        List<String> suitableHighwaysForPedestrians = Arrays.asList(
+            "pedestrian", "footway", "path", "track", "living_street", "residential", "unclassified", "cyclestreet", "service", "cycleway", "bridleway");
+        suitableHighwaysForPedestrians.addAll(majorHighways); // TODO do this only once when plugin starts
+        return !way.hasTag("foot", "no") &&
+                    (way.hasTag("highway", suitableHighwaysForPedestrians) ||
+                    way.hasTag("foot", "yes"))
+                && (
+                onewayValue == null || "no".equals(way.get("foot:backward")) || "no".equals(way.get("oneway:foot")) ||
+                    ("yes".equals(onewayValue) && direction == WayTraversalDirection.FORWARD) ||
+                    ("-1".equals(onewayValue) && direction == WayTraversalDirection.BACKWARD)
+        );
+    }
+
+    @Override
+    public boolean canBeUsedForRelation(@NotNull final IRelation<?> relation) {
+        return relation.hasTag("type", "route") && relation.hasTag("route",
+            "foot", "walking", "hiking");
+    }
+
+    @Override
+    public boolean canTurn(@NotNull final Way from, @NotNull final Node via, @NotNull final Way to) {
+        final Set<Relation> restrictionRelations = from.getReferrers().stream()
+            .map(it -> it.getType() == OsmPrimitiveType.RELATION ? (Relation) it : null)
+            .filter(Objects::nonNull)
+            .filter(it -> "restriction".equals(it.get("type")))
+            .filter(it -> it.findRelationMembers("from").contains(from))
+            .filter(it -> it.findRelationMembers("via").contains(via))
+            .filter(it -> it.findRelationMembers("to").contains(to))
+            .collect(Collectors.toSet());
+        for (Relation restrictionRelation : restrictionRelations) {
+            final String restriction = restrictionRelation.get("restriction");
+            if (restriction.startsWith("no_")) {
+                return false;
+            }
+        }
+
+        return from.containsNode(via) && to.containsNode(via);
+    }
+
+    @Override
+    public ImageProvider getIcon() {
+        return PTIcons.PEDESTRIAN;
+    }
+
+    @Override
+    public String getName() {
+        return I18n.marktr("pedestrian");
+    }
+}