Changeset 2890

Timestamp:

24.01.2010 17:55:56 (6 months ago)

Author:

bastiK

Message:

Reverse Arrows for 'oneway=-1' and similar (see #2387).
More efficient calculation of arrow geometry.
Test file for Arrow direction added.

Location:

trunk

Files:

• data_nodist/direction-arrows.osm (added)
• src/org/openstreetmap/josm/data/osm/OsmPrimitive.java (modified) (9 diffs)
• src/org/openstreetmap/josm/data/osm/visitor/paint/MapPainter.java (modified) (4 diffs)
• src/org/openstreetmap/josm/gui/mappaint/LineElemStyle.java (modified) (4 diffs)

trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

@@ -108 +108 @@
     private static final int FLAG_HAS_DIRECTIONS = 1 << 5;
     private static final int FLAG_TAGGED = 1 << 6;
+    private static final int FLAG_DIRECTION_REVERSED = 1 << 7;
 
     /**
@@ -532 +533 @@
 
     private static volatile Match directionKeys = null;
+    private static volatile Match reversedDirectionKeys = null;
 
     /**
@@ -538 +540 @@
      * Initialized by checkDirectionTagged()
      */
-    public static void initDirectionKeys() {
-        if(directionKeys == null) {
-
-            // Legacy support - convert list of keys to search pattern
-            if (Main.pref.isCollection("tags.direction", false)) {
-                System.out.println("Collection of keys in tags.direction is no longer supported, value will converted to search pattern");
-                Collection<String> keys = Main.pref.getCollection("tags.direction", null);
-                StringBuilder builder = new StringBuilder();
-                for (String key:keys) {
-                    builder.append(key);
-                    builder.append("=* | ");
-                }
-                builder.delete(builder.length() - 3, builder.length());
-                Main.pref.put("tags.direction", builder.toString());
-            }
-
-            String defaultValue = "oneway? | incline=* | incline_steep=* | aerialway=* | waterway=stream | waterway=river | waterway=canal | waterway=drain | \"piste:type\"=downhill | \"piste:type\"=sled | man_made=\"piste:halfpipe\" ";
+    static {
+        // Legacy support - convert list of keys to search pattern
+        if (Main.pref.isCollection("tags.direction", false)) {
+            System.out.println("Collection of keys in tags.direction is no longer supported, value will converted to search pattern");
+            Collection<String> keys = Main.pref.getCollection("tags.direction", null);
+            StringBuilder builder = new StringBuilder();
+            for (String key:keys) {
+                builder.append(key);
+                builder.append("=* | ");
+            }
+            builder.delete(builder.length() - 3, builder.length());
+            Main.pref.put("tags.direction", builder.toString());
+        }
+
+        String reversedDirectionDefault = "oneway=\"-1\" | incline=down | incline=\"-*\"";
+        String directionDefault = "oneway? | incline=* | aerialway=* | waterway=stream | waterway=river | waterway=canal | waterway=drain | waterway=rapids | \"piste:type\"=downhill | \"piste:type\"=sled | man_made=\"piste:halfpipe\" ";
+
+        try {
+            reversedDirectionKeys = SearchCompiler.compile(Main.pref.get("tags.reversed_direction", reversedDirectionDefault), false, false);
+        } catch (ParseError e) {
+            System.err.println("Unable to compile pattern for tags.reversed_direction, trying default pattern: " + e.getMessage());
+
             try {
-                directionKeys = SearchCompiler.compile(Main.pref.get("tags.direction", defaultValue), false, false);
-            } catch (ParseError e) {
-                System.err.println("Unable to compile pattern for tags.direction, trying default pattern: " + e.getMessage());
-
-                try {
-                    directionKeys = SearchCompiler.compile(defaultValue, false, false);
-                } catch (ParseError e2) {
-                    throw new AssertionError("Unable to compile default pattern for direction keys: " + e2.getMessage());
-                }
+                reversedDirectionKeys = SearchCompiler.compile(reversedDirectionDefault, false, false);
+            } catch (ParseError e2) {
+                throw new AssertionError("Unable to compile default pattern for direction keys: " + e2.getMessage());
+            }
+        }
+        try {
+            directionKeys = SearchCompiler.compile(Main.pref.get("tags.direction", directionDefault), false, false);
+        } catch (ParseError e) {
+            System.err.println("Unable to compile pattern for tags.direction, trying default pattern: " + e.getMessage());
+
+            try {
+                directionKeys = SearchCompiler.compile(directionDefault, false, false);
+            } catch (ParseError e2) {
+                throw new AssertionError("Unable to compile default pattern for direction keys: " + e2.getMessage());
             }
         }
@@ -576 +588 @@
      * direction dependent.
      */
+    @Deprecated
     public static Collection<String> getDirectionKeys() {
         return Main.pref.getCollection("tags.direction",
@@ -863 +876 @@
     private void keysChangedImpl(Map<String, String> originalKeys) {
         clearCached();
-        updateHasDirectionKeys();
+        updateDirectionFlags();
         updateTagged();
         if (dataSet != null) {
@@ -1126 +1139 @@
     }
 
-    private void updateHasDirectionKeys() {
-        initDirectionKeys();
+    private void updateDirectionFlags() {
+        boolean hasDirections = false;
+        boolean directionReversed = false;
+        if (reversedDirectionKeys.match(this)) {
+            hasDirections = true;
+            directionReversed = true;
+        }
         if (directionKeys.match(this)) {
+            hasDirections = true;
+        }
+
+        if (directionReversed) {
+            flags |= FLAG_DIRECTION_REVERSED;
+        } else {
+            flags &= ~FLAG_DIRECTION_REVERSED;
+        }
+        if (hasDirections) {
             flags |= FLAG_HAS_DIRECTIONS;
         } else {
@@ -1142 +1169 @@
     }
 
+    public boolean reversedDirection() {
+        return (flags & FLAG_DIRECTION_REVERSED) != 0;
+    }
     /**
      * Replies the name of this primitive. The default implementation replies the value
@@ -1222 +1252 @@
 
     protected String getFlagsAsString() {
-
         StringBuilder builder = new StringBuilder();
 
@@ -1240 +1269 @@
             builder.append("f");
         }
-
-        if (isDeleted()) {
+        if (isDisabled()) {
             builder.append("d");
         }
-
+        if (isTagged()) {
+            builder.append("T");
+        }
+        if (hasDirectionKeys()) {
+            if (reversedDirection()) {
+                builder.append("<");
+            } else {
+                builder.append(">");
+            }
+        }
         return builder.toString();
     }

trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapPainter.java

@@ -27 +27 @@
 
 public class MapPainter {
-    private static final double PHI = Math.toRadians(20);
-
     private final Graphics2D g;
     private final NavigatableComponent nc;
@@ -81 +79 @@
 
     public void drawWay(Way way, Color color, int width, float dashed[], Color dashedColor, boolean showDirection,
-            boolean showHeadArrowOnly) {
+            boolean reversedDirection, boolean showHeadArrowOnly) {
 
         GeneralPath path = new GeneralPath();
@@ -91 +89 @@
             Point p = nc.getPoint(n);
             if(lastPoint != null) {
-                drawSegment(path, lastPoint, p, (showHeadArrowOnly ? !it.hasNext() : showDirection));
+                drawSegment(path, lastPoint, p, showHeadArrowOnly ? !it.hasNext() : showDirection, reversedDirection);
             }
             lastPoint = p;
@@ -128 +126 @@
     }
 
-    private void drawSegment(GeneralPath path, Point p1, Point p2, boolean showDirection) {
+    private static final double PHI = Math.toRadians(20);
+    private static final double cosPHI = Math.cos(PHI);
+    private static final double sinPHI = Math.sin(PHI);
+
+    private void drawSegment(GeneralPath path, Point p1, Point p2, boolean showDirection, boolean reversedDirection) {
         if (isSegmentVisible(p1, p2)) {
+
+            /* draw segment line */
             path.moveTo(p1.x, p1.y);
             path.lineTo(p2.x, p2.y);
 
+            /* draw arrow */
             if (showDirection) {
-                double t = Math.atan2(p2.y-p1.y, p2.x-p1.x) + Math.PI;
-                path.lineTo((int)(p2.x + 10*Math.cos(t-PHI)), (int)(p2.y + 10*Math.sin(t-PHI)));
-                path.moveTo((int)(p2.x + 10*Math.cos(t+PHI)), (int)(p2.y + 10*Math.sin(t+PHI)));
-                path.lineTo(p2.x, p2.y);
+                Point q1 = p1;
+                Point q2 = p2;
+                if (reversedDirection) {
+                    q1 = p2;
+                    q2 = p1;
+                    path.moveTo(q2.x, q2.y);
+                }
+                final double l =  10. / q1.distance(q2);
+
+                final double sx = l * (q1.x - q2.x);
+                final double sy = l * (q1.y - q2.y);
+
+                path.lineTo (q2.x + (int) Math.round(cosPHI * sx - sinPHI * sy), q2.y + (int) Math.round(sinPHI * sx + cosPHI * sy));
+                path.moveTo (q2.x + (int) Math.round(cosPHI * sx + sinPHI * sy), q2.y + (int) Math.round(- sinPHI * sx + cosPHI * sy));
+                path.lineTo(q2.x, q2.y);
             }
         }

trunk/src/org/openstreetmap/josm/gui/mappaint/LineElemStyle.java

@@ -146 +146 @@
         boolean showDirection = selected || ((!paintSettings.isUseRealWidth()) && (paintSettings.isShowDirectionArrow()
                 && (!paintSettings.isShowRelevantDirectionsOnly() || w.hasDirectionKeys())));
+        boolean reversedDirection = w.reversedDirection();
         /* head only takes over control if the option is true,
         the direction should be shown at all and not only because it's selected */
@@ -189 +190 @@
                 if(!s.over) {
                     painter.drawWay(w, s.color != null && selected ? myColor: s.color, s.getWidth(myWidth),
-                            s.getDashed(), s.dashedColor, false, false);
+                            s.getDashed(), s.dashedColor, false, false, false);
                 }
             }
@@ -195 +196 @@
 
         /* draw the way */
-        painter.drawWay(w, myColor, myWidth, dashed, dashedColor, showDirection, showOnlyHeadArrowOnly);
+        painter.drawWay(w, myColor, myWidth, dashed, dashedColor, showDirection, selected ? false : reversedDirection, showOnlyHeadArrowOnly);
 
         /* draw overlays above the way */
@@ -202 +203 @@
                 if(s.over) {
                     painter.drawWay(w, s.color != null && selected ? myColor : s.color, s.getWidth(myWidth),
-                            s.getDashed(), s.dashedColor, false, false);
+                            s.getDashed(), s.dashedColor, false, false, false);
                 }
             }