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/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/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/RoutingHelperAction.java

@@ -0,0 +1,183 @@
+package org.openstreetmap.josm.plugins.pt_assistant.actions.routinghelper;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+
+import javax.swing.JOptionPane;
+
+import com.drew.lang.annotations.NotNull;
+import org.openstreetmap.josm.data.osm.AbstractPrimitive;
+import org.openstreetmap.josm.data.osm.DataSelectionListener;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.MapFrame;
+import org.openstreetmap.josm.gui.Notification;
+import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationMemberTask;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.DialogUtils;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.WayUtils;
+import org.openstreetmap.josm.tools.I18n;
+
+public class RoutingHelperAction implements DataSelectionListener {
+    private static final Set<ITransportMode> TRANSPORT_MODES = new HashSet<>(Arrays.asList(new BicycleTransportMode(), new BusTransportMode()));
+
+    @NotNull
+    private Optional<ITransportMode> activeTransportMode = Optional.empty();
+
+    private final RoutingHelperPanel routingHelperPanel = new RoutingHelperPanel(this);
+
+    @NotNull
+    private Optional<Relation> currentRelation = Optional.empty();
+
+    @NotNull
+    private Optional<RelationMember> currentMember = Optional.empty();
+
+    @Override
+    public void selectionChanged(SelectionChangeEvent event) {
+        final MapFrame mapframe = MainApplication.getMap();
+        if (mapframe != null) {
+            final Optional<Relation> singleRelationSelection = Optional.of(event.getSelection())
+                .filter(selection -> selection.size() == 1)
+                .map(selection -> selection.iterator().next())
+                .map(selectedPrimitive -> selectedPrimitive instanceof Relation ? (Relation) selectedPrimitive : null)
+                .filter(RouteUtils::isRoute);
+            this.currentRelation = singleRelationSelection;
+            this.activeTransportMode = currentRelation.flatMap(relation -> TRANSPORT_MODES.stream().filter(it -> it.canBeUsedForRelation(relation)).findFirst());
+            if (singleRelationSelection.isPresent()) {
+                routingHelperPanel.onRelationChange(singleRelationSelection.get(), activeTransportMode);
+                if (mapframe.getTopPanel(RoutingHelperPanel.class) == null) {
+                    mapframe.addTopPanel(routingHelperPanel);
+                }
+            } else {
+                mapframe.removeTopPanel(RoutingHelperPanel.class);
+            }
+        }
+    }
+
+    public void goToFirstWay() {
+        final Optional<Relation> currentRelation = this.currentRelation;
+        final long missingMembersCount = currentRelation
+            .map(it ->
+                it.getMembers().stream()
+                    .filter(member -> member.getMember().isIncomplete())
+                    .count()
+            )
+            .orElse(0L);
+        if (missingMembersCount > 0) {
+            if (
+                DialogUtils.showYesNoQuestion(
+                    routingHelperPanel,
+                    I18n.tr("Relation is incomplete"),
+                    I18n.trn(
+                        "The relations has {0} missing member. Would you like to download the missing member now?",
+                        "The relations has {0} missing members. Would you like to download the missing members now?",
+                        missingMembersCount,
+                        missingMembersCount
+                    )
+                )
+            ) {
+                final Future<?> f = MainApplication.worker.submit(new DownloadRelationMemberTask(
+                    currentRelation.get(),
+                    currentRelation.get().getMembers().stream()
+                        .map(RelationMember::getMember)
+                        .filter(AbstractPrimitive::isIncomplete)
+                        .collect(Collectors.toSet()),
+                    MainApplication.getLayerManager().getActiveDataLayer()
+                ));
+                new Thread(() -> {
+                    try {
+                        f.get();
+
+                        // try again, now the missingMembersCount should be 0, so we should go to the else-branch this time
+                        goToFirstWay();
+                    } catch (CancellationException | InterruptedException | ExecutionException e) {
+                        JOptionPane.showMessageDialog(
+                            routingHelperPanel,
+                            I18n.tr("The download of missing members has failed!"),
+                            I18n.tr("Download failed"),
+                            JOptionPane.ERROR_MESSAGE
+                        );
+                    }
+
+                }).start();
+            }
+        } else {
+            final List<RelationMember> wayMembers = currentRelation.map(relation -> relation.getMembers().stream().filter(RouteUtils::isRouteWayMember).collect(Collectors.toList())).orElse(Collections.emptyList());
+            this.currentMember = wayMembers.stream().findFirst();
+            if (wayMembers.isEmpty()) {
+                JOptionPane.showMessageDialog(routingHelperPanel, "No way found to traverse", "Could not find a way to traverse", JOptionPane.ERROR_MESSAGE);
+            } else {
+                routingHelperPanel.onCurrentWayChange(
+                    currentRelation.get(),
+                    wayMembers.get(0),
+                    RoutingHelperPanel.ConnectionType.END,
+                    wayMembers.size() == 1
+                        ? RoutingHelperPanel.ConnectionType.END
+                        : (
+                            WayUtils.isTouchingOtherWay(wayMembers.get(0).getWay(), wayMembers.get(1).getWay())
+                                ? RoutingHelperPanel.ConnectionType.CONNECTED
+                                : RoutingHelperPanel.ConnectionType.NOT_CONNECTED
+                        ),
+                    0,
+                    wayMembers.size()
+                );
+            }
+        }
+    }
+
+    public void goToPreviousGap() {
+        JOptionPane.showMessageDialog(routingHelperPanel, "Not implemented yet", "Not implemented", JOptionPane.ERROR_MESSAGE);
+    }
+
+    public void goToPreviousWay() {
+        goNWaysForward(-1);
+    }
+
+    public void goToNextWay() {
+        goNWaysForward(1);
+    }
+
+    private void goNWaysForward(final int n) {
+        currentRelation.ifPresent(relation ->
+            currentMember.ifPresent(member -> {
+                final List<RelationMember> wayMembers = relation.getMembers().stream().filter(RouteUtils::isRouteWayMember).collect(Collectors.toList());
+                final int targetIndex = wayMembers.indexOf(member) + n;
+                if (targetIndex < 0 || targetIndex >= wayMembers.size() - 1) {
+                    new Notification(I18n.tr("You reached the end of the route")).setIcon(JOptionPane.INFORMATION_MESSAGE).setDuration(Notification.TIME_SHORT).show();
+                } else {
+                    currentMember = Optional.of(wayMembers.get(targetIndex));
+                    routingHelperPanel.onCurrentWayChange(
+                        relation,
+                        wayMembers.get(targetIndex),
+                        targetIndex <= 0 ? RoutingHelperPanel.ConnectionType.END : (
+                            WayUtils.isTouchingOtherWay(wayMembers.get(targetIndex).getWay(), wayMembers.get(targetIndex - 1).getWay())
+                                ? RoutingHelperPanel.ConnectionType.CONNECTED
+                                : RoutingHelperPanel.ConnectionType.NOT_CONNECTED
+                        ),
+                        targetIndex >= wayMembers.size() - 1 ? RoutingHelperPanel.ConnectionType.END : (
+                            WayUtils.isTouchingOtherWay(wayMembers.get(targetIndex).getWay(), wayMembers.get(targetIndex + 1).getWay())
+                                ? RoutingHelperPanel.ConnectionType.CONNECTED
+                                : RoutingHelperPanel.ConnectionType.NOT_CONNECTED
+                        ),
+                        targetIndex,
+                        wayMembers.size()
+                    );
+                }
+            })
+        );
+    }
+
+    public void goToNextGap() {
+        JOptionPane.showMessageDialog(routingHelperPanel, "Not implemented yet", "Not implemented", JOptionPane.ERROR_MESSAGE);
+    }
+
+}