Changeset 1295 in josm

Timestamp:

2009-01-18T17:27:32+01:00 (15 years ago)

Author:

ulfl

Message:

turn restriction display in mappaint (very experimental)

will only work with standard restrictions, selection display still strange, ...

but will display icons rotated according to the direction of the from way :-)))

enable this with mappaint.restriction=true (default disabled)

Location:

trunk

Files:

• src/org/openstreetmap/josm/data/osm/visitor/MapPaintVisitor.java (modified) (7 diffs)
• src/org/openstreetmap/josm/gui/mappaint/ElemStyles.java (modified) (1 diff)
• src/org/openstreetmap/josm/tools/ImageProvider.java (modified) (2 diffs)
• styles/standard/elemstyles.xml (modified) (1 diff)

trunk/src/org/openstreetmap/josm/data/osm/visitor/MapPaintVisitor.java

@@ -9 +9 @@
 import java.awt.Font;
 import java.awt.Graphics2D;
+import java.awt.Image;
 import java.awt.Point;
 import java.awt.Polygon;
@@ -37 +38 @@
 import org.openstreetmap.josm.gui.mappaint.LineElemStyle;
 import org.openstreetmap.josm.gui.mappaint.MapPaintStyles;
+import org.openstreetmap.josm.tools.ImageProvider;
 
 public class MapPaintVisitor extends SimplePaintVisitor {
@@ -43 +45 @@
     protected int fillAreas;
     protected boolean drawMultipolygon;
+    protected boolean drawRestriction;
+    protected boolean restrictionDebug;
     protected int showNames;
     protected int showIcons;
@@ -474 +478 @@
             {
                 if (m.member != null && !m.member.incomplete && !m.member.deleted
-                && m.member instanceof Node)
+                && (drawRestriction || m.member instanceof Node))
                 {
                     drawSelectedMember(m.member, styles != null ? styles.get(m.member) : null, true, true);
@@ -485 +489 @@
         {
             drawMultipolygon(r);
+            return;
+        }
+        
+        if (drawRestriction && r.keys != null && "restriction".equals(r.keys.get("type")))
+        {
+            drawRestriction(r);
             return;
         }
@@ -490 +500 @@
         if(r.selected)
             drawSelectedRelation(r);
+    }
+
+    
+    // this current experimental implementation will only work for standard restrictions:
+    // from(Way) / via(Node) / to(Way)
+    public void drawRestriction(Relation r) {
+        if(restrictionDebug)
+            System.out.println("Restriction: " + r.keys.get("name") + " restriction " + r.keys.get("restriction"));
+     
+        r.clearErrors();
+
+        Way fromWay = null;
+        Way toWay = null;
+        Node via = null;
+
+        // find the "from", "via" and "to" elements
+        for (RelationMember m : r.members)
+        {
+            if(restrictionDebug)
+                System.out.println("member " + m.member + " selected " + r.selected);
+            
+            if(m.member == null) 
+                r.putError(tr("Empty member in relation."), true);
+            else if(m.member.deleted)
+                r.putError(tr("Deleted member ''{0}'' in relation.",
+                m.member.getName()), true);
+            else if(m.member.incomplete)
+            {
+                // TODO: What to do with incomplete members?
+                //incomplete = true;
+                r.putError(tr("incomplete member {0}" + " with role {1}", m.member, m.role), true);
+            }
+            else
+            {
+                if(m.member instanceof Way)
+                {
+                    Way w = (Way) m.member;
+                    ElemStyle style = getPrimitiveStyle(w);
+                    //if(r.selected) {
+                    //    drawWay(w, null /*(LineElemStyle)style*/, selectedColor, true);
+                    //    w.mappaintDrawnCode = paintid;
+                    //}
+                    if(w.nodes.size() < 2)
+                    {
+                        r.putError(tr("Way ''{0}'' with less than two points.",
+                        w.getName()), true);
+                    }
+                    else if("from".equals(m.role)) {
+                        if(fromWay != null)
+                            r.putError(tr("more than one from way found - ignored."), true);
+                        else {
+                            fromWay = w;
+                        }
+                    } else if("to".equals(m.role)) {
+                        if(toWay != null)
+                            r.putError(tr("more than one to way found - ignored."), true);
+                        else {
+                            toWay = w;
+                        }
+                    }
+                    else
+                        r.putError(tr("unknown role {0} - ignored", m.role), true);
+                }
+                else if(m.member instanceof Node)
+                {
+                    Node n = (Node) m.member;
+                    if("via".equals(m.role))
+                        if(via != null)
+                            System.out.println("more than one via found - ignored");
+                        else {
+                            via = n;
+                        }
+                    else
+                        r.putError(tr("unknown role {0} - ignored", m.role), true);
+                }
+                else
+                    r.putError(tr("unknown instanceof member - ignored"), true);
+            }
+        }
+        
+        if (fromWay == null) {
+            r.putError(tr("no from way found"), true);
+            return;
+        }
+        if (toWay == null) {
+            r.putError(tr("no to way found"), true);
+            return;
+        }
+        if (via == null) {
+            r.putError(tr("no via node found"), true);
+            return;
+        }
+
+        // check if "from" way starts or ends at via
+        if(fromWay.nodes.get(0) != via && fromWay.nodes.get(fromWay.nodes.size()-1) != via) {
+            r.putError(tr("from way doesn't start or end at a via node"), true);
+            return;
+        }
+        // check if "to" way starts or ends at via
+        /*if(toWay.nodes.get(0) != via && toWay.nodes.get(toWay.nodes.size()-1) != via) {
+            r.putError(tr("to way doesn't start or end at a via node"), true);
+            //return;
+        }*/
+
+        // find the "direct" nodes before the via node
+        Node fromNode = null;        
+        try
+        {
+            if(fromWay.nodes.get(0) == via) {
+                //System.out.println("From way heading away from via");
+                fromNode = fromWay.nodes.get(1);
+            } else {
+                //System.out.println("From way heading towards via");
+                fromNode = fromWay.nodes.get(fromWay.nodes.size()-2);
+            }
+        } catch (IndexOutOfBoundsException ioobe) {
+            System.out.println("from must contain at least 2 nodes");
+        }
+
+        // find the "direct" node after the via node
+        Node toNode = null;
+        try
+        {
+            if(toWay.nodes.get(0) == via) {
+                if(restrictionDebug)
+                    System.out.println("To way heading away from via");
+                toNode = toWay.nodes.get(1);
+            } else {
+                if(restrictionDebug)
+                    System.out.println("To way heading towards via");
+                toNode = toWay.nodes.get(toWay.nodes.size()-2);
+            }
+        } catch (IndexOutOfBoundsException ioobe) {
+            System.out.println("to must contain at least 2 nodes");
+        }
+        
+        Point pFrom = nc.getPoint(fromNode.eastNorth);
+        Point pVia = nc.getPoint(via.eastNorth);
+        
+        if(restrictionDebug) {
+            Point pTo = nc.getPoint(toNode.eastNorth);
+
+            // debug output of interesting nodes
+            System.out.println("From: " + fromNode);
+            drawNode(fromNode, selectedColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
+            System.out.println("Via: " + via);
+            drawNode(via, selectedColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
+            System.out.println("To: " + toNode);
+            drawNode(toNode, selectedColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
+            System.out.println("From X: " + pFrom.x + " Y " + pFrom.y);
+            System.out.println("Via  X: " + pVia.x  + " Y " + pVia.y);
+            System.out.println("To   X: " + pTo.x   + " Y " + pTo.y);
+        }
+
+        // starting from via, go back the "from" way a few pixels
+        // (calculate the vector vx/vy with the specified length and the direction away from the "via" node along the first segment of the "from" way)
+        double distanceFromVia=14;
+        double dx = (pFrom.x >= pVia.x) ? (pFrom.x - pVia.x) : (pVia.x - pFrom.x);
+        double dy = (pFrom.y >= pVia.y) ? (pFrom.y - pVia.y) : (pVia.y - pFrom.y);
+        
+        if(dx == 0.0) {
+            System.out.println("dx " + dx);
+            return;
+        }
+        double fromAngle = Math.atan(dy / dx);
+        double fromAngleDeg = Math.toDegrees(fromAngle);
+
+        double vx = distanceFromVia * Math.cos(fromAngle);
+        double vy = distanceFromVia * Math.sin(fromAngle);
+        
+        if(pFrom.x < pVia.x) vx = -vx;
+        if(pFrom.y < pVia.y) vy = -vy;
+
+        if(restrictionDebug)
+            System.out.println("vx " + vx + " vy " + vy);
+        
+        // go a few pixels away from the way (in a right angle)
+        // (calculate the vx2/vy2 vector with the specified length and the direction 90degrees away from the first segment of the "from" way)
+        double distanceFromWay=8;
+        double vx2 = 0;
+        double vy2 = 0;
+        double iconAngle = 0;
+
+        if(pFrom.x >= pVia.x && pFrom.y >= pVia.y) {
+            vx2 = distanceFromWay * Math.cos(Math.toRadians(fromAngleDeg - 90));
+            vy2 = distanceFromWay * Math.sin(Math.toRadians(fromAngleDeg - 90));
+            iconAngle = 270+fromAngleDeg;
+        }
+        if(pFrom.x < pVia.x && pFrom.y >= pVia.y) {
+            vx2 = distanceFromWay * Math.sin(Math.toRadians(fromAngleDeg));
+            vy2 = distanceFromWay * Math.cos(Math.toRadians(fromAngleDeg));
+            iconAngle = 90-fromAngleDeg;
+        }
+        if(pFrom.x < pVia.x && pFrom.y < pVia.y) {
+            vx2 = distanceFromWay * Math.cos(Math.toRadians(fromAngleDeg + 90));
+            vy2 = distanceFromWay * Math.sin(Math.toRadians(fromAngleDeg + 90));
+            iconAngle = 90+fromAngleDeg;
+        }
+        if(pFrom.x >= pVia.x && pFrom.y < pVia.y) {
+            vx2 = distanceFromWay * Math.sin(Math.toRadians(fromAngleDeg+180));
+            vy2 = distanceFromWay * Math.cos(Math.toRadians(fromAngleDeg+180));
+            iconAngle = 270-fromAngleDeg;
+        }
+        
+        IconElemStyle nodeStyle = (IconElemStyle)getPrimitiveStyle(r);
+        
+        if (nodeStyle == null) {
+            r.putError(tr("Style for restriction {0} not found", r.keys.get("restriction")), true);
+            return;
+        }
+
+        // rotate icon with direction last node in from to 
+        if(restrictionDebug)
+            System.out.println("Deg1 " + fromAngleDeg + " Deg2 " + (fromAngleDeg + 180) + " Icon " + iconAngle);
+        ImageIcon rotatedIcon = ImageProvider.createRotatedImage(null /*icon2*/, nodeStyle.icon, iconAngle);
+
+        // scale down icon to 16*16 pixels
+        ImageIcon smallIcon = new ImageIcon(rotatedIcon.getImage().getScaledInstance(16 , 16, Image.SCALE_SMOOTH));
+        int w = smallIcon.getIconWidth(), h=smallIcon.getIconHeight();
+        smallIcon.paintIcon ( Main.map.mapView, g, (int)(pVia.x+vx+vx2)-w/2, (int)(pVia.y+vy+vy2)-h/2 );
+
+        if (r.selected)
+        {
+            g.setColor (  selectedColor );
+            g.drawRect ((int)(pVia.x+vx+vx2)-w/2-2,(int)(pVia.y+vy+vy2)-h/2-2, w+4, h+4);
+        }
     }
 
@@ -955 +1191 @@
         styles = MapPaintStyles.getStyles().getStyleSet();
         drawMultipolygon = Main.pref.getBoolean("mappaint.multipolygon",true);
+        drawRestriction = Main.pref.getBoolean("mappaint.restriction",false);
+        restrictionDebug = Main.pref.getBoolean("mappaint.restriction.debug",false);
         orderFont = new Font(Main.pref.get("mappaint.font","Helvetica"), Font.PLAIN, Main.pref.getInteger("mappaint.fontsize", 8));
         String currentLocale = Locale.getDefault().getLanguage();

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

@@ -120 +120 @@
         {
             return (osm.keys == null) ? null :
-            ((osm instanceof Node) ? getNode(osm.keys) : get(osm.keys));
+            ((osm instanceof Node || osm instanceof Relation) ? getNode(osm.keys) : get(osm.keys));
         }
 

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

@@ -2 +2 @@
 package org.openstreetmap.josm.tools;
 
+import java.awt.Component;
 import java.awt.Cursor;
 import java.awt.Graphics;
+import java.awt.Graphics2D;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
 import java.awt.Image;
 import java.awt.Point;
+import java.awt.RenderingHints;
 import java.awt.Toolkit;
 import java.awt.Transparency;
@@ -224 +227 @@
         }
     }
+
+/* from: http://www.jidesoft.com/blog/2008/02/29/rotate-an-icon-in-java/ 
+* License: "feel free to use"
+*/
+final static double DEGREE_90 = 90.0 * Math.PI / 180.0;
+
+    /**
+     * Creates a rotated version of the input image.
+     *
+     * @param c            The component to get properties useful for painting, e.g. the foreground
+     *                     or background color.
+     * @param icon         the image to be rotated.
+     * @param rotatedAngle the rotated angle, in degree, clockwise. It could be any double but we
+     *                     will mod it with 360 before using it.
+     *
+     * @return the image after rotating.
+     */
+    public static ImageIcon createRotatedImage(Component c, Icon icon, double rotatedAngle) {
+        // convert rotatedAngle to a value from 0 to 360
+        double originalAngle = rotatedAngle % 360;
+        if (rotatedAngle != 0 && originalAngle == 0) {
+            originalAngle = 360.0;
+        }
+
+        // convert originalAngle to a value from 0 to 90
+        double angle = originalAngle % 90;
+        if (originalAngle != 0.0 && angle == 0.0) {
+            angle = 90.0;
+        }
+
+        double radian = Math.toRadians(angle);
+
+        int iw = icon.getIconWidth();
+        int ih = icon.getIconHeight();
+        int w;
+        int h;
+
+        if ((originalAngle >= 0 && originalAngle <= 90) || (originalAngle > 180 && originalAngle <= 270)) {
+            w = (int) (iw * Math.sin(DEGREE_90 - radian) + ih * Math.sin(radian));
+            h = (int) (iw * Math.sin(radian) + ih * Math.sin(DEGREE_90 - radian));
+        }
+        else {
+            w = (int) (ih * Math.sin(DEGREE_90 - radian) + iw * Math.sin(radian));
+            h = (int) (ih * Math.sin(radian) + iw * Math.sin(DEGREE_90 - radian));
+        }
+        BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+        Graphics g = image.getGraphics();
+        Graphics2D g2d = (Graphics2D) g.create();
+
+        // calculate the center of the icon.
+        int cx = iw / 2;
+        int cy = ih / 2;
+
+        // move the graphics center point to the center of the icon.
+        g2d.translate(w/2, h/2);
+
+        // rotate the graphics about the center point of the icon
+        g2d.rotate(Math.toRadians(originalAngle));
+
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+        icon.paintIcon(c, g2d, -cx, -cy);
+
+        g2d.dispose();
+        return new ImageIcon(image);
+    }
 }

trunk/styles/standard/elemstyles.xml

@@ -47 +47 @@
 <rules name="standard">
 
+        <rule>
+                <condition k="restriction" v="no_left_turn"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/no_left_turn.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="no_right_turn"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/no_right_turn.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="no_straight_on"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/no_straight_on.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="no_u_turn"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/no_u_turn.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="only_left_turn"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/only_left_turn.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="only_right_turn"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/only_right_turn.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+        <rule>
+                <condition k="restriction" v="only_straight_on"/>
+                <icon annotate="true" src="vehicle/restrictions/turn_restrictions/only_straight_on.png"/>
+                <scale_min>1</scale_min>
+                <scale_max>40000</scale_max>
+        </rule>
+
+
         <!-- mark some specials that should be fixed - they are already the default and therefore shouldn't be tagged -->
         <rule>