Ticket #17332: lane-left-hand-traffic-issue.patch

src/org/openstreetmap/josm/plugins/turnlanes/gui/LaneGui.java

@@ -311 +311 @@
     public Path recalculate(Path inner, Path2D innerLine) {
         area.reset();
 
-        final double W = getContainer().getLaneWidth();
+        double W = road.getContainer().getModel().isLeftDirection() ? -getContainer().getLaneWidth() : getContainer().getLaneWidth();
+
         final double L = getLength();
 
         final double WW = 3 / getContainer().getMpp();

src/org/openstreetmap/josm/plugins/turnlanes/gui/RoadGui.java

@@ -543 +543 @@
     }
 
     private Point2D getLeftCorner(Road.End end) {
-        return getCorner(end, true);
+        if(this.container.getModel().isLeftDirection()) {
+            return getCorner(end, false);
+        } else {
+            return getCorner(end, true);
+        }
     }
 
     private Point2D getRightCorner(Road.End end) {
-        return getCorner(end, false);
+        if(this.container.getModel().isLeftDirection()) {
+            return getCorner(end, true);
+        } else {
+            return getCorner(end, false);
+        }
     }
 
     private Point2D getCorner(Road.End end, boolean left) {
         final JunctionGui j = end.isFromEnd() ? a : b;
-        final double w = left ? getWidth(end, true) : getWidth(end, false);
+
+        double w = left ? getWidth(end, false) : getWidth(end, true);
+        if(!this.container.getModel().isLeftDirection()) {
+            w = left ? getWidth(end, true) : getWidth(end, false);
+        }
+
         final double s = (left ? 1 : -1);
         final double a = getAngle(end) + PI;
         final double t = left ? j.getLeftTrim(end) : j.getRightTrim(end);
@@ -597 +610 @@
 
         g2d.setColor(Color.RED);
         for (Segment s : segments) {
-            g2d.fill(new Ellipse2D.Double(s.from.getX() - 1, s.from.getY() - 1, 2, 2));
+            g2d.fill(new Ellipse2D.Double(s.from.getX() - 0.5, s.from.getY() - 0.5, 1, 1));
         }
 
         return result;
@@ -667 +680 @@
 
             middleArea = new Path2D.Double();
             middleArea.append(middleLines.getPathIterator(null), false);
-            middleArea.append(middlePath(backward).offset(outerMargin, -1, -1, outerMargin).getIterator(), true);
+            if(this.container.getModel().isLeftDirection()) {
+                middleArea.append(middlePath(backward).offset(-outerMargin, -1, -1, -outerMargin).getIterator(), true);
+            } else {
+                middleArea.append(middlePath(backward).offset(outerMargin, -1, -1, outerMargin).getIterator(), true);
+            }
             middleArea.closePath();
             g2d.setColor(Color.GRAY);
         } else {
@@ -706 +723 @@
 
         final Path middle = middlePath(forward);
 
-        Path innerPath = middle.offset(innerMargin, -1, -1, innerMargin);
+        Path innerPath;
+        if(this.container.getModel().isLeftDirection()) {
+            innerPath = middle.offset(-innerMargin, -1, -1, -innerMargin);
+        } else {
+            innerPath = middle.offset(innerMargin, -1, -1, innerMargin);
+        }
+
         final List<Path> linePaths = new ArrayList<>();
         linePaths.add(innerPath);
 
@@ -717 +740 @@
         }
 
         final Path2D area = new Path2D.Double();
-        area(area, middle, innerPath.offset(outerMargin, -1, -1, outerMargin));
+        if(this.container.getModel().isLeftDirection()) {
+            area(area, middle, innerPath.offset(-outerMargin, -1, -1, -outerMargin));
+        } else {
+            area(area, middle, innerPath.offset(outerMargin, -1, -1, outerMargin));
+        }
         g2d.setColor(Color.GRAY);
         g2d.fill(area);
 
@@ -785 +812 @@
 
     public Path getLaneMiddle(boolean forward) {
         final Path mid = middlePath(!forward);
-        final double w = getWidth(forward ? getModel().getFromEnd() : getModel().getToEnd(), true);
-        final double o = (w - outerMargin) / 2;
 
+        double w = getWidth(forward ? getModel().getFromEnd() : getModel().getToEnd(), true);
+        double o = (w + outerMargin) / 2;
+        if(this.container.getModel().isLeftDirection()) {
+            w = -getWidth(forward ? getModel().getFromEnd() : getModel().getToEnd(), false);
+            o = (w + (-outerMargin)) / 2;
+        }
+
         return o > 0 ? mid.offset(-o, -1, -1, -o) : mid;
     }
 

src/org/openstreetmap/josm/plugins/turnlanes/gui/TurnLanesDialog.java

@@ -6 +6 @@
 import java.awt.BorderLayout;
 import java.awt.CardLayout;
 import java.awt.GridLayout;
+import java.awt.GridBagConstraints;
 import java.awt.event.ActionEvent;
 import java.util.Collection;
 import java.util.HashSet;
@@ -14 +15 @@
 import javax.swing.ButtonGroup;
 import javax.swing.JPanel;
 import javax.swing.JToggleButton;
+import javax.swing.JLabel;
+import javax.swing.JCheckBox;
 
 import org.openstreetmap.josm.actions.JosmAction;
 import org.openstreetmap.josm.data.osm.DataSelectionListener;
@@ -131 +134 @@
     private static final String CARD_VALIDATE = "VALIDATE";
 
     private final JPanel body = new JPanel();
+
+
     private final JunctionPane junctionPane = new JunctionPane(GuiContainer.empty());
 
     private final JToggleButton editButton = new JToggleButton(editAction);
@@ -141 +146 @@
     private boolean editing = true;
     private boolean wasShowing = false;
 
+    private ModelContainer modelContainer;
+    private boolean leftDirection = ModelContainer.empty().isLeftDirection();
+
     public TurnLanesDialog() {
         super(tr("Turn Lanes"), "turnlanes.png", tr("Edit turn lanes"), null, 200);
 
@@ -151 +159 @@
         final ButtonGroup group = new ButtonGroup();
         group.add(editButton);
         group.add(validateButton);
+        addTrafficDirectionCheckBox(buttonPanel);
         buttonPanel.add(editButton);
         buttonPanel.add(validateButton);
 
@@ -165 +174 @@
         editButton.doClick();
     }
 
+    /**
+     * Add label and checkbox for traffic direction and change flag
+     * @param buttonPanel
+     */
+    private void addTrafficDirectionCheckBox(JPanel buttonPanel) {
+        GridBagConstraints constraints = new GridBagConstraints();
+        JLabel aoiLabel = new JLabel(tr("Left-hand traffic direction:"));
+        constraints.gridx = 0;
+        constraints.gridwidth = 1; //next-to-last
+        constraints.fill = GridBagConstraints.NONE;      //reset to default
+        constraints.weightx = 0.0;
+        buttonPanel.add(aoiLabel, constraints);
+
+        constraints.gridx = 1;
+        constraints.gridwidth = GridBagConstraints.REMAINDER;     //end row
+        constraints.fill = GridBagConstraints.HORIZONTAL;
+        constraints.weightx = 1.0;
+        JCheckBox leftDirectionCheckbox = new JCheckBox();
+        leftDirectionCheckbox.setSelected(leftDirection);
+        buttonPanel.add(leftDirectionCheckbox, constraints);
+        leftDirectionCheckbox.addChangeListener(e -> {
+            if(modelContainer == null) {
+                return;
+            }
+            leftDirection = leftDirectionCheckbox.isSelected();
+            refresh();
+        });
+
+    }
+
     @Override
     protected void stateChanged() {
         if (isShowing && !wasShowing) {
@@ -178 +217 @@
             final Collection<Node> nodes = org.openstreetmap.josm.tools.Utils.filteredCollection(selected, Node.class);
             final Collection<Way> ways = org.openstreetmap.josm.tools.Utils.filteredCollection(selected, Way.class);
 
-            final ModelContainer mc = nodes.isEmpty() ? ModelContainer.empty() : ModelContainer
+            modelContainer = nodes.isEmpty() ? ModelContainer.empty() : ModelContainer
                     .createEmpty(nodes, ways);
+            modelContainer.setLeftDirection(leftDirection);
 
-            junctionPane.setJunction(new GuiContainer(mc));
+            junctionPane.setJunction(new GuiContainer(modelContainer));
         }
     }
 

src/org/openstreetmap/josm/plugins/turnlanes/model/ModelContainer.java

@@ -20 +20 @@
 import org.openstreetmap.josm.tools.Pair;
 
 public final class ModelContainer {
+
+    //set default direction of traffic for connecting lanes
+    private static final boolean DEFAULT_LEFT_DIRECTION = false;
+
     private static final ModelContainer EMPTY = new ModelContainer(Collections.<Node>emptySet(),
-            Collections.<Way>emptySet(), false);
+            Collections.<Way>emptySet(), false, DEFAULT_LEFT_DIRECTION);
 
     public static ModelContainer create(Iterable<Node> primaryNodes, Iterable<Way> primaryWays) {
         return new ModelContainer(new HashSet<>(CollectionUtils.toList(primaryNodes)), new HashSet<>(
-                CollectionUtils.toList(primaryWays)), false);
+                CollectionUtils.toList(primaryWays)), false, DEFAULT_LEFT_DIRECTION);
     }
 
     public static ModelContainer createEmpty(Iterable<Node> primaryNodes, Iterable<Way> primaryWays) {
         return new ModelContainer(new HashSet<>(CollectionUtils.toList(primaryNodes)), new HashSet<>(
-                CollectionUtils.toList(primaryWays)), true);
+                CollectionUtils.toList(primaryWays)), true, DEFAULT_LEFT_DIRECTION);
     }
 
     public static ModelContainer empty() {
@@ -121 +125 @@
 
     private final boolean empty;
 
-    private ModelContainer(Set<Node> primaryNodes, Set<Way> primaryWays, boolean empty) {
+    private boolean leftDirection;
+
+    private ModelContainer(Set<Node> primaryNodes, Set<Way> primaryWays, boolean empty, boolean leftDirection) {
         if (empty) {
             this.primaryNodes = Collections.unmodifiableSet(new HashSet<>(primaryNodes));
             this.primaryWays = Collections.unmodifiableSet(new HashSet<>(primaryWays));
@@ -151 +157 @@
 
             this.empty = junctions.isEmpty();
         }
+        this.leftDirection = leftDirection;
     }
 
     private Set<Pair<Way, Junction>> createPrimaryJunctions() {
@@ -282 +289 @@
     }
 
     public ModelContainer recalculate() {
-        return new ModelContainer(primaryNodes, primaryWays, false);
+        return new ModelContainer(primaryNodes, primaryWays, false, leftDirection);
     }
 
     public boolean isPrimary(Junction j) {
@@ -297 +304 @@
         return empty;
     }
 
+    public boolean isLeftDirection() {
+        return leftDirection;
+    }
+
+    public void setLeftDirection(boolean leftDirection) {
+        this.leftDirection = leftDirection;
+    }
+
     public boolean hasRoad(Way w) {
         return roads.containsKey(w);
     }