Changeset 10827 in josm for trunk/src/org/openstreetmap

Timestamp:

2016-08-17T20:14:58+02:00 (8 years ago)

Author:

Don-vip

Message:

fix #13306 - Make map paint code use double coordinates (patch by michael2402) - gsoc-core

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/mapmode/DrawAction.java (modified) (8 diffs)
• actions/mapmode/ImproveWayAccuracyAction.java (modified) (6 diffs)
• actions/mapmode/SelectAction.java (modified) (2 diffs)
• data/osm/Node.java (modified) (8 diffs)
• data/osm/visitor/paint/AbstractMapRenderer.java (modified) (8 diffs)
• data/osm/visitor/paint/ArrowPaintHelper.java (added)
• data/osm/visitor/paint/LineClip.java (modified) (9 diffs)
• data/osm/visitor/paint/MapPath2D.java (added)
• data/osm/visitor/paint/StyledMapRenderer.java (modified) (40 diffs)
• data/osm/visitor/paint/WireframeMapRenderer.java (modified) (13 diffs)
• data/projection/Projection.java (modified) (1 diff)
• gui/MapViewState.java (modified) (10 diffs)
• gui/NavigatableComponent.java (modified) (3 diffs)
• gui/dialogs/properties/PropertiesDialog.java (modified) (1 diff)
• gui/mappaint/styleelement/NodeElement.java (modified) (7 diffs)
• gui/mappaint/styleelement/Symbol.java (added)

trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

@@ -17 +17 @@
 import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
-import java.awt.geom.GeneralPath;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -51 +50 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.data.osm.visitor.paint.ArrowPaintHelper;
+import org.openstreetmap.josm.data.osm.visitor.paint.MapPath2D;
 import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
 import org.openstreetmap.josm.gui.MainMenu;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.NavigatableComponent;
 import org.openstreetmap.josm.gui.layer.Layer;
@@ -75 +77 @@
 
     private static final Color ORANGE_TRANSPARENT = new Color(Color.ORANGE.getRed(), Color.ORANGE.getGreen(), Color.ORANGE.getBlue(), 128);
-    private static final double PHI = Math.toRadians(90);
+
+    private static final ArrowPaintHelper START_WAY_INDICATOR = new ArrowPaintHelper(Math.toRadians(90), 8);
 
     private final Cursor cursorJoinNode;
@@ -1139 +1142 @@
         } else if (!snapHelper.drawConstructionGeometry)
             return;
-        GeneralPath b = new GeneralPath();
-        Point p1 = mv.getPoint(getCurrentBaseNode());
-        Point p2 = mv.getPoint(currentMouseEastNorth);
-
-        double t = Math.atan2((double) p2.y - p1.y, (double) p2.x - p1.x) + Math.PI;
-
-        b.moveTo(p1.x, p1.y);
-        b.lineTo(p2.x, p2.y);
+        MapPath2D b = new MapPath2D();
+        MapViewPoint p1 = mv.getState().getPointFor(getCurrentBaseNode());
+        MapViewPoint p2 = mv.getState().getPointFor(currentMouseEastNorth);
+
+        b.moveTo(p1);
+        b.lineTo(p2);
 
         // if alt key is held ("start new way"), draw a little perpendicular line
         if (alt) {
-            b.moveTo((int) (p1.x + 8*Math.cos(t+PHI)), (int) (p1.y + 8*Math.sin(t+PHI)));
-            b.lineTo((int) (p1.x + 8*Math.cos(t-PHI)), (int) (p1.y + 8*Math.sin(t-PHI)));
+            START_WAY_INDICATOR.paintArrowAt(b, p1, p2);
         }
 
@@ -1474 +1474 @@
             if (!snapOn || !active)
                 return;
-            Point p1 = mv.getPoint(getCurrentBaseNode());
-            Point p2 = mv.getPoint(dir2);
-            Point p3 = mv.getPoint(projected);
-            GeneralPath b;
+            MapViewPoint p1 = mv.getState().getPointFor(getCurrentBaseNode());
+            MapViewPoint p2 = mv.getState().getPointFor(dir2);
+            MapViewPoint p3 = mv.getState().getPointFor(projected);
             if (drawConstructionGeometry) {
                 g2.setColor(snapHelperColor);
                 g2.setStroke(helperStroke);
 
-                b = new GeneralPath();
+                MapPath2D b = new MapPath2D();
+                b.moveTo(p2);
                 if (absoluteFix) {
-                    b.moveTo(p2.x, p2.y);
-                    b.lineTo(2d*p1.x-p2.x, 2d*p1.y-p2.y); // bi-directional line
+                    b.lineTo(2d*p1.getInViewX()-p2.getInViewX(), 2d*p1.getInViewY()-p2.getInViewY()); // bi-directional line
                 } else {
-                    b.moveTo(p2.x, p2.y);
-                    b.lineTo(p3.x, p3.y);
+                    b.lineTo(p3);
                 }
                 g2.draw(b);
@@ -1495 +1493 @@
                 g2.setColor(snapHelperColor);
                 g2.setStroke(helperStroke);
-                b = new GeneralPath();
-                b.moveTo(p3.x, p3.y);
-                Point pp = mv.getPoint(projectionSource);
-                b.lineTo(pp.x, pp.y);
+                MapPath2D b = new MapPath2D();
+                b.moveTo(p3);
+                b.lineTo(mv.getState().getPointFor(projectionSource));
                 g2.draw(b);
             }
@@ -1505 +1502 @@
                 g2.setColor(highlightColor);
                 g2.setStroke(highlightStroke);
-                b = new GeneralPath();
-                Point pp1 = mv.getPoint(segmentPoint1);
-                Point pp2 = mv.getPoint(segmentPoint2);
-                b.moveTo(pp1.x, pp1.y);
-                b.lineTo(pp2.x, pp2.y);
+                MapPath2D b = new MapPath2D();
+                b.moveTo(mv.getState().getPointFor(segmentPoint1));
+                b.lineTo(mv.getState().getPointFor(segmentPoint2));
                 g2.draw(b);
             }
@@ -1515 +1510 @@
             g2.setColor(rubberLineColor);
             g2.setStroke(normalStroke);
-            b = new GeneralPath();
-            b.moveTo(p1.x, p1.y);
-            b.lineTo(p3.x, p3.y);
+            MapPath2D b = new MapPath2D();
+            b.moveTo(p1);
+            b.lineTo(p3);
             g2.draw(b);
 
-            g2.drawString(labelText, p3.x-5, p3.y+20);
+            g2.drawString(labelText, (int) p3.getInViewX()-5, (int) p3.getInViewY()+20);
             if (showProjectedPoint) {
                 g2.setStroke(normalStroke);
-                g2.drawOval(p3.x-5, p3.y-5, 10, 10); // projected point
+                g2.drawOval((int) p3.getInViewX()-5, (int) p3.getInViewY()-5, 10, 10); // projected point
             }
 

trunk/src/org/openstreetmap/josm/actions/mapmode/ImproveWayAccuracyAction.java

@@ -13 +13 @@
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
-import java.awt.geom.GeneralPath;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -36 +35 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.data.osm.visitor.paint.MapPath2D;
 import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.layer.AbstractMapViewPaintable;
 import org.openstreetmap.josm.gui.layer.Layer;
@@ -239 +240 @@
             List<Node> nodes = targetWay.getNodes();
 
-            GeneralPath b = new GeneralPath();
+            MapPath2D b = new MapPath2D();
             Point p0 = mv.getPoint(nodes.get(0));
             Point pn;
@@ -297 +298 @@
 
             // Drawing preview lines
-            GeneralPath b = new GeneralPath();
+            MapPath2D b = new MapPath2D();
             if (alt && !ctrl) {
                 // In delete mode
@@ -333 +334 @@
     }
 
-    protected void drawIntersectingWayHelperLines(MapView mv, GeneralPath b) {
+    protected void drawIntersectingWayHelperLines(MapView mv, MapPath2D b) {
         for (final OsmPrimitive referrer : candidateNode.getReferrers()) {
             if (!(referrer instanceof Way) || targetWay.equals(referrer)) {
@@ -344 +345 @@
                 }
                 if (i > 0) {
-                    final Point p = mv.getPoint(nodes.get(i - 1));
+                    final MapViewPoint p = mv.getState().getPointFor(nodes.get(i - 1));
                     b.moveTo(mousePos.x, mousePos.y);
-                    b.lineTo(p.x, p.y);
+                    b.lineTo(p);
                 }
                 if (i < nodes.size() - 1) {
-                    final Point p = mv.getPoint(nodes.get(i + 1));
+                    final MapViewPoint p = mv.getState().getPointFor(nodes.get(i + 1));
                     b.moveTo(mousePos.x, mousePos.y);
-                    b.lineTo(p.x, p.y);
+                    b.lineTo(p);
                 }
             }

trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

@@ -42 +42 @@
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.SelectionManager;
 import org.openstreetmap.josm.gui.SelectionManager.SelectionEnded;
@@ -1192 +1193 @@
                     wnp.a = w.getNode(ws.lowerIndex);
                     wnp.b = w.getNode(ws.lowerIndex + 1);
-                    Point2D p1 = mv.getPoint2D(wnp.a);
-                    Point2D p2 = mv.getPoint2D(wnp.b);
+                    MapViewPoint p1 = mv.getState().getPointFor(wnp.a);
+                    MapViewPoint p2 = mv.getState().getPointFor(wnp.b);
                     if (WireframeMapRenderer.isLargeSegment(p1, p2, virtualSpace)) {
-                        Point2D pc = new Point2D.Double((p1.getX() + p2.getX()) / 2, (p1.getY() + p2.getY()) / 2);
+                        Point2D pc = new Point2D.Double((p1.getInViewX() + p2.getInViewX()) / 2, (p1.getInViewY() + p2.getInViewY()) / 2);
                         if (p.distanceSq(pc) < virtualSnapDistSq2) {
                             // Check that only segments on top of each other get added to the

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

@@ -3 +3 @@
 
 import java.util.Collection;
+import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
@@ -12 +13 @@
 import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
 import org.openstreetmap.josm.data.osm.visitor.Visitor;
+import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.data.projection.Projections;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
@@ -34 +36 @@
     private double east = Double.NaN;
     private double north = Double.NaN;
+    /**
+     * The cache key to use for {@link #east} and {@link #north}.
+     */
+    private Object eastNorthCacheKey;
 
     /**
@@ -79 +85 @@
      * Internally caches the projected coordinates.</p>
      *
-     * <p><strong>Caveat:</strong> doesn't listen to projection changes. Clients must
-     * {@link #invalidateEastNorthCache() invalidate the internal cache}.</p>
-     *
      * <p>Replies {@code null} if this node doesn't know lat/lon-coordinates, i.e. because it is an incomplete node.
      *
@@ -90 +93 @@
     @Override
     public EastNorth getEastNorth() {
+        return getEastNorth(Main.getProjection());
+    }
+
+    /**
+     * Replies the projected east/north coordinates.
+     * <p>
+     * The result of the last conversion is cached. The cache object is used as cache key.
+     * @param projection The projection to use.
+     * @return The projected east/north coordinates
+     * @since 10826
+     */
+    public EastNorth getEastNorth(Projection projection) {
         if (!isLatLonKnown()) return null;
 
-        if (getDataSet() == null)
-            // there is no dataset that listens for projection changes
-            // and invalidates the cache, so we don't use the cache at all
-            return Projections.project(new LatLon(lat, lon));
-
-        if (Double.isNaN(east) || Double.isNaN(north)) {
+        if (Double.isNaN(east) || Double.isNaN(north) || !Objects.equals(projection.getCacheKey(), eastNorthCacheKey)) {
             // projected coordinates haven't been calculated yet,
             // so fill the cache of the projected node coordinates
@@ -103 +113 @@
             this.east = en.east();
             this.north = en.north();
+            this.eastNorthCacheKey = projection.getCacheKey();
         }
         return new EastNorth(east, north);
@@ -123 +134 @@
             this.east = eastNorth.east();
             this.north = eastNorth.north();
+            this.eastNorthCacheKey = Main.getProjection().getCacheKey();
         } else {
             this.lat = Double.NaN;
@@ -346 +358 @@
         this.east = Double.NaN;
         this.north = Double.NaN;
+        this.eastNorthCacheKey = null;
     }
 

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

@@ -4 +4 @@
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.GeneralPath;
-import java.awt.geom.Point2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
 import java.util.Iterator;
 
@@ -15 +15 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.gui.MapViewState;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+import org.openstreetmap.josm.gui.MapViewState.MapViewRectangle;
 import org.openstreetmap.josm.gui.NavigatableComponent;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
@@ -28 +31 @@
     /** the map viewport - provides projection and hit detection functionality */
     protected NavigatableComponent nc;
+
+    /**
+     * The {@link MapViewState} to use to convert between coordinates.
+     */
+    protected final MapViewState mapState;
 
     /** if true, the paint visitor shall render OSM objects such that they
@@ -68 +76 @@
         this.g = g;
         this.nc = nc;
+        this.mapState = nc.getState();
         this.isInactiveMode = isInactiveMode;
     }
@@ -89 +98 @@
      * @param orderNumber The number of the segment in the way.
      * @param clr The color to use for drawing the text.
-     */
-    protected void drawOrderNumber(Point p1, Point p2, int orderNumber, Color clr) {
+     * @since 10826
+     */
+    protected void drawOrderNumber(MapViewPoint p1, MapViewPoint p2, int orderNumber, Color clr) {
         if (isSegmentVisible(p1, p2) && isLargeSegment(p1, p2, segmentNumberSpace)) {
             String on = Integer.toString(orderNumber);
             int strlen = on.length();
-            int x = (p1.x+p2.x)/2 - 4*strlen;
-            int y = (p1.y+p2.y)/2 + 4;
+            double centerX = (p1.getInViewX()+p2.getInViewX())/2;
+            double centerY = (p1.getInViewY()+p2.getInViewY())/2;
+            double x = centerX - 4*strlen;
+            double y = centerY + 4;
 
             if (virtualNodeSize != 0 && isLargeSegment(p1, p2, virtualNodeSpace)) {
-                y = (p1.y+p2.y)/2 - virtualNodeSize - 3;
+                y = centerY - virtualNodeSize - 3;
             }
 
             g.setColor(backgroundColor);
-            g.fillRect(x-1, y-12, 8*strlen+1, 14);
+            g.fill(new Rectangle2D.Double(x-1, y-12, 8*strlen+1, 14));
             g.setColor(clr);
-            g.drawString(on, x, y);
+            g.drawString(on, (int) x, (int) y);
         }
     }
@@ -182 +194 @@
      * @param space The free space to check against.
      * @return <code>true</code> if segment is larger than required space
-     */
-    public static boolean isLargeSegment(Point2D p1, Point2D p2, int space) {
-        double xd = Math.abs(p1.getX()-p2.getX());
-        double yd = Math.abs(p1.getY()-p2.getY());
-        return xd + yd > space;
+     * @since 10826
+     */
+    public static boolean isLargeSegment(MapViewPoint p1, MapViewPoint p2, int space) {
+        return p1.oneNormInView(p2) > space;
     }
 
@@ -194 +205 @@
      * @param p1 First point of the way segment.
      * @param p2 Second point of the way segment.
-     * @return <code>true</code> if segment is visible.
-     */
-    protected boolean isSegmentVisible(Point p1, Point p2) {
-        if ((p1.x < 0) && (p2.x < 0)) return false;
-        if ((p1.y < 0) && (p2.y < 0)) return false;
-        if ((p1.x > nc.getWidth()) && (p2.x > nc.getWidth())) return false;
-        if ((p1.y > nc.getHeight()) && (p2.y > nc.getHeight())) return false;
-        return true;
+     * @return <code>true</code> if segment may be visible.
+     * @since 10826
+     */
+    protected boolean isSegmentVisible(MapViewPoint p1, MapViewPoint p2) {
+        MapViewRectangle view = mapState.getViewArea();
+        // not outside in the same direction
+        return (p1.getOutsideRectangleFlags(view) & p2.getOutsideRectangleFlags(view)) == 0;
     }
 
@@ -209 +219 @@
      * @param path The path to append drawing to.
      * @param w The ways to draw node for.
-     */
-    public void visitVirtual(GeneralPath path, Way w) {
+     * @since 10826
+     */
+    public void visitVirtual(Path2D path, Way w) {
         Iterator<Node> it = w.getNodes().iterator();
         if (it.hasNext()) {
-            Point lastP = nc.getPoint(it.next());
+            MapViewPoint lastP = mapState.getPointFor(it.next());
             while (it.hasNext()) {
-                Point p = nc.getPoint(it.next());
+                MapViewPoint p = mapState.getPointFor(it.next());
                 if (isSegmentVisible(lastP, p) && isLargeSegment(lastP, p, virtualNodeSpace)) {
-                    int x = (p.x+lastP.x)/2;
-                    int y = (p.y+lastP.y)/2;
-                    path.moveTo((double) x-virtualNodeSize, y);
-                    path.lineTo((double) x+virtualNodeSize, y);
-                    path.moveTo(x, (double) y-virtualNodeSize);
-                    path.lineTo(x, (double) y+virtualNodeSize);
+                    double x = (p.getInViewX()+lastP.getInViewX())/2;
+                    double y = (p.getInViewY()+lastP.getInViewY())/2;
+                    path.moveTo(x-virtualNodeSize, y);
+                    path.lineTo(x+virtualNodeSize, y);
+                    path.moveTo(x, y-virtualNodeSize);
+                    path.lineTo(x, y+virtualNodeSize);
                 }
                 lastP = p;

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

@@ -7 +7 @@
 import static java.awt.geom.Rectangle2D.OUT_TOP;
 
-import java.awt.Point;
 import java.awt.Rectangle;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
 
 /**
@@ -15 +16 @@
  */
 public class LineClip {
-    private Point p1, p2;
-    private final Rectangle clipBounds;
+    private Point2D p1, p2;
+    private final Rectangle2D clipBounds;
 
     /**
@@ -23 +24 @@
      * @param p2 end point of the clipped line
      * @param clipBounds Clip bounds
+     * @since 10826
      */
-    public LineClip(Point p1, Point p2, Rectangle clipBounds) {
+    public LineClip(Point2D p1, Point2D p2, Rectangle2D clipBounds) {
         this.p1 = p1;
         this.p2 = p2;
@@ -38 +40 @@
             return false;
         }
-        return cohenSutherland(p1.x, p1.y, p2.x, p2.y, clipBounds.x, clipBounds.y,
-                (long) clipBounds.x + clipBounds.width,
-                (long) clipBounds.y + clipBounds.height);
+        return cohenSutherland(p1.getX(), p1.getY(), p2.getX(), p2.getY(), clipBounds.getMinX(), clipBounds.getMinY(),
+                clipBounds.getMaxX(), clipBounds.getMaxY());
     }
 
     /**
      * @return start point of the clipped line
+     * @since 10826
      */
-    public Point getP1() {
+    public Point2D getP1() {
         return p1;
     }
@@ -52 +54 @@
     /**
      * @return end point of the clipped line
+     * @since 10826
      */
-    public Point getP2() {
+    public Point2D getP2() {
         return p2;
     }
@@ -70 +73 @@
      * @return true, if line is visible in the given clip region
      */
-    private boolean cohenSutherland(long x1, long y1, long x2, long y2, long xmin, long ymin, long xmax, long ymax) {
+    private boolean cohenSutherland(double x1, double y1, double x2, double y2, double xmin, double ymin, double xmax, double ymax) {
         int outcode0, outcode1, outcodeOut;
         boolean accept = false;
@@ -85 +88 @@
                 done = true;
             } else {
-                long x = 0;
-                long y = 0;
+                double x = 0;
+                double y = 0;
                 outcodeOut = outcode0 != 0 ? outcode0 : outcode1;
                 if ((outcodeOut & OUT_TOP) != 0) {
@@ -115 +118 @@
 
         if (accept) {
-            p1 = new Point((int) x1, (int) y1);
-            p2 = new Point((int) x2, (int) y2);
+            p1 = new Point2D.Double(x1, y1);
+            p2 = new Point2D.Double(x2, y2);
             return true;
         }
@@ -133 +136 @@
      * @return outcode
      */
-    private static int computeOutCode(long x, long y, long xmin, long ymin, long xmax, long ymax) {
+    private static int computeOutCode(double x, double y, double xmin, double ymin, double xmax, double ymax) {
         int code = 0;
-        if (y > ymax) {
+        // ignore rounding errors.
+        if (y > ymax + 1e-10) {
             code |= OUT_TOP;
-        } else if (y < ymin) {
+        } else if (y < ymin - 1e-10) {
             code |= OUT_BOTTOM;
         }
-        if (x > xmax) {
+        if (x > xmax + 1e-10) {
             code |= OUT_RIGHT;
-        } else if (x < xmin) {
+        } else if (x < xmin - 1e-10) {
             code |= OUT_LEFT;
         }

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

@@ -12 +12 @@
 import java.awt.Image;
 import java.awt.Point;
-import java.awt.Polygon;
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
@@ -26 +25 @@
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -38 +39 @@
 import java.util.concurrent.RecursiveTask;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import javax.swing.AbstractButton;
@@ -59 +61 @@
 import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon.PolyData;
 import org.openstreetmap.josm.data.osm.visitor.paint.relations.MultipolygonCache;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.NavigatableComponent;
 import org.openstreetmap.josm.gui.mappaint.ElemStyles;
@@ -70 +73 @@
 import org.openstreetmap.josm.gui.mappaint.styleelement.MapImage;
 import org.openstreetmap.josm.gui.mappaint.styleelement.NodeElement;
-import org.openstreetmap.josm.gui.mappaint.styleelement.NodeElement.Symbol;
 import org.openstreetmap.josm.gui.mappaint.styleelement.RepeatImageElement.LineImageAlignment;
 import org.openstreetmap.josm.gui.mappaint.styleelement.StyleElement;
+import org.openstreetmap.josm.gui.mappaint.styleelement.Symbol;
 import org.openstreetmap.josm.gui.mappaint.styleelement.TextLabel;
 import org.openstreetmap.josm.tools.CompositeList;
@@ -97 +100 @@
      * perfect way, but it should not throw an exception.
      */
-    private class OffsetIterator implements Iterator<Point> {
+    private class OffsetIterator implements Iterator<MapViewPoint> {
 
         private final List<Node> nodes;
@@ -103 +106 @@
         private int idx;
 
-        private Point prev;
+        private MapViewPoint prev;
         /* 'prev0' is a point that has distance 'offset' from 'prev' and the
          * line from 'prev' to 'prev0' is perpendicular to the way segment from
          * 'prev' to the next point.
          */
-        private int xPrev0, yPrev0;
+        private double xPrev0;
+        private double yPrev0;
 
         OffsetIterator(List<Node> nodes, double offset) {
@@ -122 +126 @@
 
         @Override
-        public Point next() {
+        public MapViewPoint next() {
             if (!hasNext())
                 throw new NoSuchElementException();
 
-            if (Math.abs(offset) < 0.1d)
-                return nc.getPoint(nodes.get(idx++));
-
-            Point current = nc.getPoint(nodes.get(idx));
+            MapViewPoint current = getForIndex(idx);
+
+            if (Math.abs(offset) < 0.1d) {
+                idx++;
+                return current;
+            }
 
             if (idx == nodes.size() - 1) {
                 ++idx;
                 if (prev != null) {
-                    return new Point(xPrev0 + current.x - prev.x, yPrev0 + current.y - prev.y);
+                    return mapState.getForView(xPrev0 + current.getInViewX() - prev.getInViewX(),
+                                               yPrev0 + current.getInViewY() - prev.getInViewY());
                 } else {
                     return current;
@@ -140 +147 @@
             }
 
-            Point next = nc.getPoint(nodes.get(idx+1));
-
-            int dxNext = next.x - current.x;
-            int dyNext = next.y - current.y;
-            double lenNext = Math.sqrt((double) dxNext*dxNext + (double) dyNext*dyNext);
-
-            if (lenNext == 0) {
+            MapViewPoint next = getForIndex(idx + 1);
+
+            double dxNext = next.getInViewX() - current.getInViewX();
+            double dyNext = next.getInViewY() - current.getInViewY();
+            double lenNext = Math.sqrt(dxNext*dxNext + dyNext*dyNext);
+
+            if (lenNext < 1e-3) {
                 lenNext = 1; // value does not matter, because dy_next and dx_next is 0
             }
 
-            int xCurrent0 = current.x + (int) Math.round(offset * dyNext / lenNext);
-            int yCurrent0 = current.y - (int) Math.round(offset * dxNext / lenNext);
+            double xCurrent0 = current.getInViewX() + offset * dyNext / lenNext;
+            double yCurrent0 = current.getInViewY() - offset * dxNext / lenNext;
 
             if (idx == 0) {
@@ -158 +165 @@
                 xPrev0 = xCurrent0;
                 yPrev0 = yCurrent0;
-                return new Point(xCurrent0, yCurrent0);
+                return mapState.getForView(xCurrent0, yCurrent0);
             } else {
-                int dxPrev = current.x - prev.x;
-                int dyPrev = current.y - prev.y;
+                double dxPrev = current.getInViewX() - prev.getInViewX();
+                double dyPrev = current.getInViewY() - prev.getInViewY();
 
                 // determine intersection of the lines parallel to the two segments
-                int det = dxNext*dyPrev - dxPrev*dyNext;
-
-                if (det == 0) {
+                double det = dxNext*dyPrev - dxPrev*dyNext;
+
+                if (Utils.equalsEpsilon(det, 0)) {
                     ++idx;
                     prev = current;
                     xPrev0 = xCurrent0;
                     yPrev0 = yCurrent0;
-                    return new Point(xCurrent0, yCurrent0);
-                }
-
-                int m = dxNext*(yCurrent0 - yPrev0) - dyNext*(xCurrent0 - xPrev0);
-
-                int cx = xPrev0 + (int) Math.round((double) m * dxPrev / det);
-                int cy = yPrev0 + (int) Math.round((double) m * dyPrev / det);
+                    return mapState.getForView(xCurrent0, yCurrent0);
+                }
+
+                double m = dxNext*(yCurrent0 - yPrev0) - dyNext*(xCurrent0 - xPrev0);
+
+                double cx = xPrev0 + m * dxPrev / det;
+                double cy = yPrev0 + m * dyPrev / det;
                 ++idx;
                 prev = current;
                 xPrev0 = xCurrent0;
                 yPrev0 = yCurrent0;
-                return new Point(cx, cy);
-            }
+                return mapState.getForView(cx, cy);
+            }
+        }
+
+        private MapViewPoint getForIndex(int i) {
+            return mapState.getPointFor(nodes.get(i));
         }
 
@@ -376 +387 @@
     }
 
-    private static Polygon buildPolygon(Point center, int radius, int sides) {
-        return buildPolygon(center, radius, sides, 0.0);
-    }
-
-    private static Polygon buildPolygon(Point center, int radius, int sides, double rotation) {
-        Polygon polygon = new Polygon();
-        for (int i = 0; i < sides; i++) {
-            double angle = ((2 * Math.PI / sides) * i) - rotation;
-            int x = (int) Math.round(center.x + radius * Math.cos(angle));
-            int y = (int) Math.round(center.y + radius * Math.sin(angle));
-            polygon.addPoint(x, y);
-        }
-        return polygon;
-    }
-
-    private void displaySegments(GeneralPath path, GeneralPath orientationArrows, GeneralPath onewayArrows, GeneralPath onewayArrowsCasing,
+    private void displaySegments(Path2D path, Path2D orientationArrows, Path2D onewayArrows, Path2D onewayArrowsCasing,
             Color color, BasicStroke line, BasicStroke dashes, Color dashedColor) {
         g.setColor(isInactiveMode ? inactiveColor : color);
@@ -489 +485 @@
             MapImage fillImage, Float extent, Path2D.Double pfClip, boolean disabled, TextLabel text) {
 
-        Shape area = path.createTransformedShape(nc.getAffineTransform());
+        Shape area = path.createTransformedShape(mapState.getAffineTransform());
 
         if (!isOutlineOnly) {
@@ -504 +500 @@
                     Shape clip = area;
                     if (pfClip != null) {
-                        clip = pfClip.createTransformedShape(nc.getAffineTransform());
+                        clip = pfClip.createTransformedShape(mapState.getAffineTransform());
                     }
                     g.clip(clip);
@@ -527 +523 @@
                     Shape fill = area;
                     if (pfClip != null) {
-                        fill = pfClip.createTransformedShape(nc.getAffineTransform());
+                        fill = pfClip.createTransformedShape(mapState.getAffineTransform());
                     }
                     g.fill(fill);
@@ -699 +695 @@
             return;
 
-        Point p = nc.getPoint(n);
+        MapViewPoint p = mapState.getPointFor(n);
         TextLabel text = bs.text;
         String s = text.labelCompositionStrategy.compose(n);
@@ -707 +703 @@
         g.setFont(text.font);
 
-        int x = p.x + text.xOffset;
-        int y = p.y + text.yOffset;
+        int x = (int) (p.getInViewX() + text.xOffset);
+        int y = (int) (p.getInViewY() + text.yOffset);
         /**
          *
@@ -770 +766 @@
         final int imgHeight = pattern.getHeight();
 
-        Point lastP = null;
         double currentWayLength = phase % repeat;
         if (currentWayLength < 0) {
@@ -794 +789 @@
         }
 
+        MapViewPoint lastP = null;
         OffsetIterator it = new OffsetIterator(way.getNodes(), offset);
         while (it.hasNext()) {
-            Point thisP = it.next();
+            MapViewPoint thisP = it.next();
 
             if (lastP != null) {
-                final double segmentLength = thisP.distance(lastP);
-
-                final double dx = (double) thisP.x - lastP.x;
-                final double dy = (double) thisP.y - lastP.y;
+                final double segmentLength = thisP.distanceToInView(lastP);
+
+                final double dx = thisP.getInViewX() - lastP.getInViewX();
+                final double dy = thisP.getInViewY() - lastP.getInViewY();
 
                 // pos is the position from the beginning of the current segment
@@ -809 +805 @@
 
                 AffineTransform saveTransform = g.getTransform();
-                g.translate(lastP.x, lastP.y);
+                g.translate(lastP.getInViewX(), lastP.getInViewY());
                 g.rotate(Math.atan2(dy, dx));
 
@@ -850 +846 @@
             return;
 
-        Point p = nc.getPoint(n);
+        MapViewPoint p = mapState.getPointFor(n);
 
         if (n.isHighlighted()) {
-            drawPointHighlight(p, size);
-        }
-
-        if (size > 1) {
-            if ((p.x < 0) || (p.y < 0) || (p.x > nc.getWidth()) || (p.y > nc.getHeight())) return;
+            drawPointHighlight(p.getInView(), size);
+        }
+
+        if (size > 1 && p.isInView()) {
             int radius = size / 2;
 
@@ -865 +860 @@
                 g.setColor(color);
             }
+            Rectangle2D rect = new Rectangle2D.Double(p.getInViewX()-radius-1, p.getInViewY()-radius-1, size + 1, size + 1);
             if (fill) {
-                g.fillRect(p.x-radius-1, p.y-radius-1, size + 1, size + 1);
+                g.fill(rect);
             } else {
-                g.drawRect(p.x-radius-1, p.y-radius-1, size, size);
-            }
-        }
-    }
-
+                g.draw(rect);
+            }
+        }
+    }
+
+    /**
+     * Draw the icon for a given node.
+     * @param n The node
+     * @param img The icon to draw at the node position
+     */
     public void drawNodeIcon(Node n, MapImage img, boolean disabled, boolean selected, boolean member, double theta) {
-        Point p = nc.getPoint(n);
-
-        final int w = img.getWidth(), h = img.getHeight();
+        MapViewPoint p = mapState.getPointFor(n);
+
+        int w = img.getWidth();
+        int h = img.getHeight();
         if (n.isHighlighted()) {
-            drawPointHighlight(p, Math.max(w, h));
+            drawPointHighlight(p.getInView(), Math.max(w, h));
         }
 
         float alpha = img.getAlphaFloat();
 
+        Graphics2D temporaryGraphics = (Graphics2D) g.create();
         if (!Utils.equalsEpsilon(alpha, 1f)) {
-            g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
-        }
-        g.rotate(theta, p.x, p.y);
-        g.drawImage(img.getImage(disabled), p.x - w/2 + img.offsetX, p.y - h/2 + img.offsetY, nc);
-        g.rotate(-theta, p.x, p.y);
-        g.setPaintMode();
+            temporaryGraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
+        }
+
+        double x = p.getInViewX();
+        double y = p.getInViewY();
+        temporaryGraphics.translate(-x, -y);
+        temporaryGraphics.rotate(theta);
+        temporaryGraphics.drawImage(img.getImage(disabled), w/2 + img.offsetX, h/2 + img.offsetY, nc);
         if (selected || member) {
             Color color;
@@ -900 +905 @@
             }
             g.setColor(color);
-            g.drawRect(p.x - w/2 + img.offsetX - 2, p.y - h/2 + img.offsetY - 2, w + 4, h + 4);
-        }
-    }
-
+            g.draw(new Rectangle2D.Double(x - w/2 + img.offsetX - 2, y - h/2 + img.offsetY - 2, w + 4, h + 4));
+        }
+    }
+
+    /**
+     * Draw the symbol and possibly a highlight marking on a given node.
+     * @param n The position to draw the symbol on
+     * @param s The symbol to draw
+     * @param fillColor The color to fill the symbol with
+     * @param strokeColor The color to use for the outer corner of the symbol
+     */
     public void drawNodeSymbol(Node n, Symbol s, Color fillColor, Color strokeColor) {
-        Point p = nc.getPoint(n);
-        int radius = s.size / 2;
+        MapViewPoint p = mapState.getPointFor(n);
 
         if (n.isHighlighted()) {
-            drawPointHighlight(p, s.size);
-        }
-
-        if (fillColor != null) {
-            g.setColor(fillColor);
-            switch (s.symbol) {
-            case SQUARE:
-                g.fillRect(p.x - radius, p.y - radius, s.size, s.size);
-                break;
-            case CIRCLE:
-                g.fillOval(p.x - radius, p.y - radius, s.size, s.size);
-                break;
-            case TRIANGLE:
-                g.fillPolygon(buildPolygon(p, radius, 3, Math.PI / 2));
-                break;
-            case PENTAGON:
-                g.fillPolygon(buildPolygon(p, radius, 5, Math.PI / 2));
-                break;
-            case HEXAGON:
-                g.fillPolygon(buildPolygon(p, radius, 6));
-                break;
-            case HEPTAGON:
-                g.fillPolygon(buildPolygon(p, radius, 7, Math.PI / 2));
-                break;
-            case OCTAGON:
-                g.fillPolygon(buildPolygon(p, radius, 8, Math.PI / 8));
-                break;
-            case NONAGON:
-                g.fillPolygon(buildPolygon(p, radius, 9, Math.PI / 2));
-                break;
-            case DECAGON:
-                g.fillPolygon(buildPolygon(p, radius, 10));
-                break;
-            default:
-                throw new AssertionError();
-            }
-        }
-        if (s.stroke != null) {
-            g.setStroke(s.stroke);
-            g.setColor(strokeColor);
-            switch (s.symbol) {
-            case SQUARE:
-                g.drawRect(p.x - radius, p.y - radius, s.size - 1, s.size - 1);
-                break;
-            case CIRCLE:
-                g.drawOval(p.x - radius, p.y - radius, s.size - 1, s.size - 1);
-                break;
-            case TRIANGLE:
-                g.drawPolygon(buildPolygon(p, radius, 3, Math.PI / 2));
-                break;
-            case PENTAGON:
-                g.drawPolygon(buildPolygon(p, radius, 5, Math.PI / 2));
-                break;
-            case HEXAGON:
-                g.drawPolygon(buildPolygon(p, radius, 6));
-                break;
-            case HEPTAGON:
-                g.drawPolygon(buildPolygon(p, radius, 7, Math.PI / 2));
-                break;
-            case OCTAGON:
-                g.drawPolygon(buildPolygon(p, radius, 8, Math.PI / 8));
-                break;
-            case NONAGON:
-                g.drawPolygon(buildPolygon(p, radius, 9, Math.PI / 2));
-                break;
-            case DECAGON:
-                g.drawPolygon(buildPolygon(p, radius, 10));
-                break;
-            default:
-                throw new AssertionError();
-            }
-            g.setStroke(new BasicStroke());
+            drawPointHighlight(p.getInView(), s.size);
+        }
+
+        if (fillColor != null || strokeColor != null) {
+            Shape shape = s.buildShapeAround(p.getInViewX(), p.getInViewY());
+
+            if (fillColor != null) {
+                g.setColor(fillColor);
+                g.fill(shape);
+            }
+            if (s.stroke != null) {
+                g.setStroke(s.stroke);
+                g.setColor(strokeColor);
+                g.draw(shape);
+                g.setStroke(new BasicStroke());
+            }
         }
     }
@@ -994 +949 @@
      */
     public void drawOrderNumber(Node n1, Node n2, int orderNumber, Color clr) {
-        Point p1 = nc.getPoint(n1);
-        Point p2 = nc.getPoint(n2);
+        MapViewPoint p1 = mapState.getPointFor(n1);
+        MapViewPoint p2 = mapState.getPointFor(n2);
         drawOrderNumber(p1, p2, orderNumber, clr);
     }
@@ -1005 +960 @@
      * @param line line style
      */
-    private void drawPathHighlight(GeneralPath path, BasicStroke line) {
+    private void drawPathHighlight(Path2D path, BasicStroke line) {
         if (path == null)
             return;
@@ -1024 +979 @@
      * @param size highlight size
      */
-    private void drawPointHighlight(Point p, int size) {
+    private void drawPointHighlight(Point2D p, int size) {
         g.setColor(highlightColorTransparent);
         int s = size + highlightPointRadius;
@@ -1030 +985 @@
         while (s >= size) {
             int r = (int) Math.floor(s/2d);
-            g.fillRoundRect(p.x-r, p.y-r, s, s, r, r);
+            g.fill(new RoundRectangle2D.Double(p.getX()-r, p.getY()-r, s, s, r, r));
             s -= highlightStep;
         }
@@ -1219 +1174 @@
 
     /**
+     * A half segment that can be used to place text on it. Used in the drawTextOnPath algorithm.
+     * @author Michael Zangl
+     */
+    private static class HalfSegment {
+        /**
+         * start point of half segment (as length along the way)
+         */
+        final double start;
+        /**
+         * end point of half segment (as length along the way)
+         */
+        final double end;
+        /**
+         * quality factor (off screen / partly on screen / fully on screen)
+         */
+        final double quality;
+
+        /**
+         * Create a new half segment
+         * @param start The start along the way
+         * @param end The end of the segment
+         * @param quality A quality factor.
+         */
+        HalfSegment(double start, double end, double quality) {
+            super();
+            this.start = start;
+            this.end = end;
+            this.quality = quality;
+        }
+
+        @Override
+        public String toString() {
+            return "HalfSegment [start=" + start + ", end=" + end + ", quality=" + quality + "]";
+        }
+    }
+
+    /**
      * Draws a text along a given way.
      * @param way The way to draw the text on.
@@ -1235 +1227 @@
         Rectangle bounds = g.getClipBounds();
 
-        Polygon poly = new Polygon();
-        Point lastPoint = null;
-        Iterator<Node> it = way.getNodes().iterator();
-        double pathLength = 0;
-        long dx, dy;
+        List<MapViewPoint> points = way.getNodes().stream().map(mapState::getPointFor).collect(Collectors.toList());
 
         // find half segments that are long enough to draw text on (don't draw text over the cross hair in the center of each segment)
-        List<Double> longHalfSegmentStart = new ArrayList<>(); // start point of half segment (as length along the way)
-        List<Double> longHalfSegmentEnd = new ArrayList<>(); // end point of half segment (as length along the way)
-        List<Double> longHalfsegmentQuality = new ArrayList<>(); // quality factor (off screen / partly on screen / fully on screen)
-
-        while (it.hasNext()) {
-            Node n = it.next();
-            Point p = nc.getPoint(n);
-            poly.addPoint(p.x, p.y);
-
-            if (lastPoint != null) {
-                dx = (long) p.x - lastPoint.x;
-                dy = (long) p.y - lastPoint.y;
-                double segmentLength = Math.sqrt(dx*dx + dy*dy);
-                if (segmentLength > 2*(rec.getWidth()+4)) {
-                    Point center = new Point((lastPoint.x + p.x)/2, (lastPoint.y + p.y)/2);
-                    double q = 0;
-                    if (bounds != null) {
-                        if (bounds.contains(lastPoint) && bounds.contains(center)) {
-                            q = 2;
-                        } else if (bounds.contains(lastPoint) || bounds.contains(center)) {
-                            q = 1;
-                        }
-                    }
-                    longHalfSegmentStart.add(pathLength);
-                    longHalfSegmentEnd.add(pathLength + segmentLength / 2);
-                    longHalfsegmentQuality.add(q);
-
-                    q = 0;
-                    if (bounds != null) {
-                        if (bounds.contains(center) && bounds.contains(p)) {
-                            q = 2;
-                        } else if (bounds.contains(center) || bounds.contains(p)) {
-                            q = 1;
-                        }
-                    }
-                    longHalfSegmentStart.add(pathLength + segmentLength / 2);
-                    longHalfSegmentEnd.add(pathLength + segmentLength);
-                    longHalfsegmentQuality.add(q);
-                }
-                pathLength += segmentLength;
-            }
-            lastPoint = p;
-        }
+        List<HalfSegment> longHalfSegment = new ArrayList<>();
+
+        double pathLength = computePath(2 * (rec.getWidth() + 4), bounds, points, longHalfSegment);
 
         if (rec.getWidth() > pathLength)
@@ -1291 +1239 @@
         double t1, t2;
 
-        if (!longHalfSegmentStart.isEmpty()) {
-            if (way.getNodesCount() == 2) {
-                // For 2 node ways, the two half segments are exactly the same size and distance from the center.
-                // Prefer the first one for consistency.
-                longHalfsegmentQuality.set(0, longHalfsegmentQuality.get(0) + 0.5);
-            }
-
-            // find the long half segment that is closest to the center of the way
-            // candidates with higher quality value are preferred
-            double bestStart = Double.NaN;
-            double bestEnd = Double.NaN;
-            double bestDistanceToCenter = Double.MAX_VALUE;
-            double bestQuality = -1;
-            for (int i = 0; i < longHalfSegmentStart.size(); i++) {
-                double start = longHalfSegmentStart.get(i);
-                double end = longHalfSegmentEnd.get(i);
-                double dist = Math.abs(0.5 * (end + start) - 0.5 * pathLength);
-                if (longHalfsegmentQuality.get(i) > bestQuality
-                        || (dist < bestDistanceToCenter && Utils.equalsEpsilon(longHalfsegmentQuality.get(i), bestQuality))) {
-                    bestStart = start;
-                    bestEnd = end;
-                    bestDistanceToCenter = dist;
-                    bestQuality = longHalfsegmentQuality.get(i);
-                }
-            }
-            double remaining = bestEnd - bestStart - rec.getWidth(); // total space left and right from the text
+        if (!longHalfSegment.isEmpty()) {
+            // find the segment with the best quality. If there are several with best quality, the one close to the center is prefered.
+            HalfSegment best = longHalfSegment.stream().max(
+                    Comparator.comparingDouble(segment ->
+                        segment.quality - 1e-5 * Math.abs(0.5 * (segment.end + segment.start) - 0.5 * pathLength)
+                    )).get();
+            double remaining = best.end - best.start - rec.getWidth(); // total space left and right from the text
             // The space left and right of the text should be distributed 20% - 80% (towards the center),
             // but the smaller space should not be less than 7 px.
             // However, if the total remaining space is less than 14 px, then distribute it evenly.
             double smallerSpace = Math.min(Math.max(0.2 * remaining, 7), 0.5 * remaining);
-            if ((bestEnd + bestStart)/2 < pathLength/2) {
-                t2 = bestEnd - smallerSpace;
+            if ((best.end + best.start)/2 < pathLength/2) {
+                t2 = best.end - smallerSpace;
                 t1 = t2 - rec.getWidth();
             } else {
-                t1 = bestStart + smallerSpace;
+                t1 = best.start + smallerSpace;
                 t2 = t1 + rec.getWidth();
             }
@@ -1336 +1265 @@
         t2 /= pathLength;
 
-        double[] p1 = pointAt(t1, poly, pathLength);
-        double[] p2 = pointAt(t2, poly, pathLength);
+        double[] p1 = pointAt(t1, points, pathLength);
+        double[] p2 = pointAt(t2, points, pathLength);
 
         if (p1 == null || p2 == null)
@@ -1365 +1294 @@
                 Rectangle2D rect = gv.getGlyphLogicalBounds(i).getBounds2D();
                 double t = tStart + offsetSign * (gvOffset + rect.getX() + rect.getWidth()/2) / pathLength;
-                double[] p = pointAt(t, poly, pathLength);
+                double[] p = pointAt(t, points, pathLength);
                 if (p != null) {
                     AffineTransform trfm = AffineTransform.getTranslateInstance(p[0] - rect.getX(), p[1]);
@@ -1383 +1312 @@
             gvOffset += gvWidth;
         }
+    }
+
+    private double computePath(double minSegmentLength, Rectangle bounds, List<MapViewPoint> points,
+            List<HalfSegment> longHalfSegment) {
+        MapViewPoint lastPoint = points.get(0);
+        double pathLength = 0;
+        for (MapViewPoint p : points.subList(1, points.size())) {
+            double segmentLength = p.distanceToInView(lastPoint);
+            if (segmentLength > minSegmentLength) {
+                Point2D center = new Point2D.Double((lastPoint.getInViewX() + p.getInViewX())/2, (lastPoint.getInViewY() + p.getInViewY())/2);
+                double q = computeQuality(bounds, lastPoint, center);
+                // prefer the first one for quality equality.
+                longHalfSegment.add(new HalfSegment(pathLength, pathLength + segmentLength / 2, q));
+
+                q = 0;
+                if (bounds != null) {
+                    if (bounds.contains(center) && bounds.contains(p.getInView())) {
+                        q = 2;
+                    } else if (bounds.contains(center) || bounds.contains(p.getInView())) {
+                        q = 1;
+                    }
+                }
+                longHalfSegment.add(new HalfSegment(pathLength + segmentLength / 2, pathLength + segmentLength, q));
+            }
+            pathLength += segmentLength;
+            lastPoint = p;
+        }
+        return pathLength;
+    }
+
+    private static double computeQuality(Rectangle bounds, MapViewPoint p1, Point2D p2) {
+        double q = 0;
+        if (bounds != null) {
+            if (bounds.contains(p1.getInView())) {
+                q += 1;
+            }
+            if (bounds.contains(p2)) {
+                q += 1;
+            }
+        }
+        return q;
     }
 
@@ -1404 +1374 @@
             boolean showOneway, boolean onewayReversed) {
 
-        GeneralPath path = new GeneralPath();
-        GeneralPath orientationArrows = showOrientation ? new GeneralPath() : null;
-        GeneralPath onewayArrows = showOneway ? new GeneralPath() : null;
-        GeneralPath onewayArrowsCasing = showOneway ? new GeneralPath() : null;
+        MapPath2D path = new MapPath2D();
+        MapPath2D orientationArrows = showOrientation ? new MapPath2D() : null;
+        MapPath2D onewayArrows = showOneway ? new MapPath2D() : null;
+        MapPath2D onewayArrowsCasing = showOneway ? new MapPath2D() : null;
         Rectangle bounds = g.getClipBounds();
         if (bounds != null) {
@@ -1414 +1384 @@
         }
 
-        double wayLength = 0;
-        Point lastPoint = null;
         boolean initialMoveToNeeded = true;
         List<Node> wayNodes = way.getNodes();
@@ -1431 +1399 @@
                 }
 
-                Point p1 = nc.getPoint(ws.getFirstNode());
-                Point p2 = nc.getPoint(ws.getSecondNode());
-                highlightSegs.moveTo(p1.x, p1.y);
-                highlightSegs.lineTo(p2.x, p2.y);
+                Point2D p1 = mapState.getPointFor(ws.getFirstNode()).getInView();
+                Point2D p2 = mapState.getPointFor(ws.getSecondNode()).getInView();
+                highlightSegs.moveTo(p1.getX(), p1.getY());
+                highlightSegs.lineTo(p2.getX(), p2.getY());
             }
 
@@ -1440 +1408 @@
         }
 
-        Iterator<Point> it = new OffsetIterator(wayNodes, offset);
+        MapViewPoint lastPoint = null;
+        double wayLength = 0;
+        Iterator<MapViewPoint> it = new OffsetIterator(wayNodes, offset);
         while (it.hasNext()) {
-            Point p = it.next();
+            MapViewPoint p = it.next();
             if (lastPoint != null) {
-                Point p1 = lastPoint;
-                Point p2 = p;
-
-                /**
-                 * Do custom clipping to work around openjdk bug. It leads to
-                 * drawing artefacts when zooming in a lot. (#4289, #4424)
-                 * (Looks like int overflow.)
-                 */
-                LineClip clip = new LineClip(p1, p2, bounds);
-                if (clip.execute()) {
-                    if (!p1.equals(clip.getP1())) {
-                        p1 = clip.getP1();
-                        path.moveTo(p1.x, p1.y);
-                    } else if (initialMoveToNeeded) {
-                        initialMoveToNeeded = false;
-                        path.moveTo(p1.x, p1.y);
-                    }
-                    p2 = clip.getP2();
-                    path.lineTo(p2.x, p2.y);
-
-                    /* draw arrow */
-                    if (showHeadArrowOnly ? !it.hasNext() : showOrientation) {
-                        final double segmentLength = p1.distance(p2);
-                        if (segmentLength != 0) {
-                            final double l = (10. + line.getLineWidth()) / segmentLength;
-
-                            final double sx = l * (p1.x - p2.x);
-                            final double sy = l * (p1.y - p2.y);
-
-                            orientationArrows.moveTo(p2.x + cosPHI * sx - sinPHI * sy, p2.y + sinPHI * sx + cosPHI * sy);
-                            orientationArrows.lineTo(p2.x, p2.y);
-                            orientationArrows.lineTo(p2.x + cosPHI * sx + sinPHI * sy, p2.y - sinPHI * sx + cosPHI * sy);
+                MapViewPoint p1 = lastPoint;
+                MapViewPoint p2 = p;
+
+                if (initialMoveToNeeded) {
+                    initialMoveToNeeded = false;
+                    path.moveTo(p1);
+                }
+                path.lineTo(p2);
+
+                /* draw arrow */
+                if (showHeadArrowOnly ? !it.hasNext() : showOrientation) {
+                    //TODO: Cache
+                    ArrowPaintHelper drawHelper = new ArrowPaintHelper(PHI, 10 + line.getLineWidth());
+                    drawHelper.paintArrowAt(orientationArrows, p2, p1);
+                }
+                if (showOneway) {
+                    final double segmentLength = p1.distanceToInView(p2);
+                    if (segmentLength != 0) {
+                        final double nx = (p2.getInViewX() - p1.getInViewX()) / segmentLength;
+                        final double ny = (p2.getInViewY() - p1.getInViewY()) / segmentLength;
+
+                        final double interval = 60;
+                        // distance from p1
+                        double dist = interval - (wayLength % interval);
+
+                        while (dist < segmentLength) {
+                            appenOnewayPath(onewayReversed, p1, nx, ny, dist, 3d, onewayArrowsCasing);
+                            appenOnewayPath(onewayReversed, p1, nx, ny, dist, 2d, onewayArrows);
+                            dist += interval;
                         }
                     }
-                    if (showOneway) {
-                        final double segmentLength = p1.distance(p2);
-                        if (segmentLength != 0) {
-                            final double nx = (p2.x - p1.x) / segmentLength;
-                            final double ny = (p2.y - p1.y) / segmentLength;
-
-                            final double interval = 60;
-                            // distance from p1
-                            double dist = interval - (wayLength % interval);
-
-                            while (dist < segmentLength) {
-                                for (int i = 0; i < 2; ++i) {
-                                    double onewaySize = i == 0 ? 3d : 2d;
-                                    GeneralPath onewayPath = i == 0 ? onewayArrowsCasing : onewayArrows;
-
-                                    // scale such that border is 1 px
-                                    final double fac = -(onewayReversed ? -1 : 1) * onewaySize * (1 + sinPHI) / (sinPHI * cosPHI);
-                                    final double sx = nx * fac;
-                                    final double sy = ny * fac;
-
-                                    // Attach the triangle at the incenter and not at the tip.
-                                    // Makes the border even at all sides.
-                                    final double x = p1.x + nx * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
-                                    final double y = p1.y + ny * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
-
-                                    onewayPath.moveTo(x, y);
-                                    onewayPath.lineTo(x + cosPHI * sx - sinPHI * sy, y + sinPHI * sx + cosPHI * sy);
-                                    onewayPath.lineTo(x + cosPHI * sx + sinPHI * sy, y - sinPHI * sx + cosPHI * sy);
-                                    onewayPath.lineTo(x, y);
-                                }
-                                dist += interval;
-                            }
-                        }
-                        wayLength += segmentLength;
-                    }
+                    wayLength += segmentLength;
                 }
             }
@@ -1521 +1454 @@
         }
         displaySegments(path, orientationArrows, onewayArrows, onewayArrowsCasing, color, line, dashes, dashedColor);
+    }
+
+    private void appenOnewayPath(boolean onewayReversed, MapViewPoint p1, double nx, double ny, double dist,
+            double onewaySize, Path2D onewayPath) {
+        // scale such that border is 1 px
+        final double fac = -(onewayReversed ? -1 : 1) * onewaySize * (1 + sinPHI) / (sinPHI * cosPHI);
+        final double sx = nx * fac;
+        final double sy = ny * fac;
+
+        // Attach the triangle at the incenter and not at the tip.
+        // Makes the border even at all sides.
+        final double x = p1.getInViewX() + nx * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
+        final double y = p1.getInViewY() + ny * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
+
+        onewayPath.moveTo(x, y);
+        onewayPath.lineTo(x + cosPHI * sx - sinPHI * sy, y + sinPHI * sx + cosPHI * sy);
+        onewayPath.lineTo(x + cosPHI * sx + sinPHI * sy, y - sinPHI * sx + cosPHI * sy);
+        onewayPath.lineTo(x, y);
     }
 
@@ -1712 +1663 @@
     }
 
+    /**
+     * Test if the area is visible
+     * @param area The area, interpreted in east/north space.
+     * @return true if it is visible.
+     */
     private boolean isAreaVisible(Path2D.Double area) {
         Rectangle2D bounds = area.getBounds2D();
         if (bounds.isEmpty()) return false;
-        Point2D p = nc.getPoint2D(new EastNorth(bounds.getX(), bounds.getY()));
-        if (p.getX() > nc.getWidth()) return false;
-        if (p.getY() < 0) return false;
-        p = nc.getPoint2D(new EastNorth(bounds.getX() + bounds.getWidth(), bounds.getY() + bounds.getHeight()));
-        if (p.getX() < 0) return false;
-        if (p.getY() > nc.getHeight()) return false;
+        MapViewPoint p = mapState.getPointFor(new EastNorth(bounds.getX(), bounds.getY()));
+        if (p.getInViewX() > mapState.getViewWidth()) return false;
+        if (p.getInViewY() < 0) return false;
+        p = mapState.getPointFor(new EastNorth(bounds.getX() + bounds.getWidth(), bounds.getY() + bounds.getHeight()));
+        if (p.getInViewX() < 0) return false;
+        if (p.getInViewY() > mapState.getViewHeight()) return false;
         return true;
     }
@@ -1736 +1692 @@
     }
 
-    private static double[] pointAt(double t, Polygon poly, double pathLength) {
+    private static double[] pointAt(double t, List<MapViewPoint> poly, double pathLength) {
         double totalLen = t * pathLength;
         double curLen = 0;
-        long dx, dy;
+        double dx, dy;
         double segLen;
 
         // Yes, it is inefficient to iterate from the beginning for each glyph.
         // Can be optimized if it turns out to be slow.
-        for (int i = 1; i < poly.npoints; ++i) {
-            dx = (long) poly.xpoints[i] - poly.xpoints[i-1];
-            dy = (long) poly.ypoints[i] - poly.ypoints[i-1];
+        for (int i = 1; i < poly.size(); ++i) {
+            dx = poly.get(i).getInViewX() - poly.get(i - 1).getInViewX();
+            dy = poly.get(i).getInViewY() - poly.get(i - 1).getInViewY();
             segLen = Math.sqrt(dx*dx + dy*dy);
             if (totalLen > curLen + segLen) {
@@ -1753 +1709 @@
             }
             return new double[] {
-                    poly.xpoints[i-1]+(totalLen - curLen)/segLen*dx,
-                    poly.ypoints[i-1]+(totalLen - curLen)/segLen*dy,
+                    poly.get(i - 1).getInViewX() + (totalLen - curLen) / segLen * dx,
+                    poly.get(i - 1).getInViewY() + (totalLen - curLen) / segLen * dy,
                     Math.atan2(dy, dx)};
         }

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

@@ -5 +5 @@
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.Stroke;
+import java.awt.geom.Ellipse2D;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.Rectangle2D.Double;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -26 +28 @@
 import org.openstreetmap.josm.data.osm.WaySegment;
 import org.openstreetmap.josm.data.osm.visitor.Visitor;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.NavigatableComponent;
 
@@ -75 +78 @@
     protected Color currentColor;
     /** Path store to draw subsequent segments of same color as one <code>Path</code>. */
-    protected GeneralPath currentPath = new GeneralPath();
+    protected MapPath2D currentPath = new MapPath2D();
     /**
       * <code>DataSet</code> passed to the @{link render} function to overcome the argument
@@ -83 +86 @@
 
     /** Helper variable for {@link #drawSegment} */
-    private static final double PHI = Math.toRadians(20);
-    /** Helper variable for {@link #drawSegment} */
-    private static final double cosPHI = Math.cos(PHI);
-    /** Helper variable for {@link #drawSegment} */
-    private static final double sinPHI = Math.sin(PHI);
+    private static final ArrowPaintHelper ARROW_PAINT_HELPER = new ArrowPaintHelper(Math.toRadians(20), 10);
 
     /** Helper variable for {@link #visit(Relation)} */
@@ -117 +116 @@
         connectionColor = PaintColors.CONNECTION.get();
 
-        if (taggedColor != nodeColor) {
+        if (!taggedColor.equals(nodeColor)) {
             taggedConnectionColor = taggedColor;
         } else {
@@ -210 +209 @@
         // renderer does not feature any transparency there should be no visual difference.
         for (final WaySegment wseg : data.getHighlightedWaySegments()) {
-            drawSegment(nc.getPoint(wseg.getFirstNode()), nc.getPoint(wseg.getSecondNode()), highlightColor, false);
+            drawSegment(mapState.getPointFor(wseg.getFirstNode()), mapState.getPointFor(wseg.getSecondNode()), highlightColor, false);
         }
         displaySegments();
@@ -315 +314 @@
         Iterator<Node> it = w.getNodes().iterator();
         if (it.hasNext()) {
-            Point lastP = nc.getPoint(it.next());
+            MapViewPoint lastP = mapState.getPointFor(it.next());
             for (int orderNumber = 1; it.hasNext(); orderNumber++) {
-                Point p = nc.getPoint(it.next());
+                MapViewPoint p = mapState.getPointFor(it.next());
                 drawSegment(lastP, p, wayColor,
                         showOnlyHeadArrowOnly ? !it.hasNext() : showThisDirectionArrow);
@@ -354 +353 @@
 
             if (m.isNode()) {
-                Point p = nc.getPoint(m.getNode());
-                if (p.x < 0 || p.y < 0
-                        || p.x > nc.getWidth() || p.y > nc.getHeight()) {
-                    continue;
-                }
-
-                g.drawOval(p.x-4, p.y-4, 9, 9);
+                MapViewPoint p = mapState.getPointFor(m.getNode());
+                if (p.isInView()) {
+                    g.draw(new Ellipse2D.Double(p.getInViewX()-4, p.getInViewY()-4, 9, 9));
+                }
+
             } else if (m.isWay()) {
                 GeneralPath path = new GeneralPath();
@@ -369 +366 @@
                         continue;
                     }
-                    Point p = nc.getPoint(n);
+                    MapViewPoint p = mapState.getPointFor(n);
                     if (first) {
-                        path.moveTo(p.x, p.y);
+                        path.moveTo(p.getInViewX(), p.getInViewY());
                         first = false;
                     } else {
-                        path.lineTo(p.x, p.y);
+                        path.lineTo(p.getInViewX(), p.getInViewY());
                     }
                 }
@@ -393 +390 @@
     public void drawNode(Node n, Color color, int size, boolean fill) {
         if (size > 1) {
+            MapViewPoint p = mapState.getPointFor(n);
+            if (!p.isInView())
+                return;
             int radius = size / 2;
-            Point p = nc.getPoint(n);
-            if ((p.x < 0) || (p.y < 0) || (p.x > nc.getWidth())
-                    || (p.y > nc.getHeight()))
-                return;
+            Double shape = new Rectangle2D.Double(p.getInViewX() - radius, p.getInViewY() - radius, size, size);
             g.setColor(color);
             if (fill) {
-                g.fillRect(p.x - radius, p.y - radius, size, size);
-                g.drawRect(p.x - radius, p.y - radius, size, size);
-            } else {
-                g.drawRect(p.x - radius, p.y - radius, size, size);
-            }
+                g.fill(shape);
+            }
+            g.draw(shape);
         }
     }
@@ -412 +407 @@
      *
      * @param path The path to append this segment.
-     * @param p1 First point of the way segment.
-     * @param p2 Second point of the way segment.
+     * @param mv1 First point of the way segment.
+     * @param mv2 Second point of the way segment.
      * @param showDirection <code>true</code> if segment direction should be indicated
-     */
-    protected void drawSegment(GeneralPath path, Point p1, Point p2, boolean showDirection) {
+     * @since 10826
+     */
+    protected void drawSegment(MapPath2D path, MapViewPoint mv1, MapViewPoint mv2, boolean showDirection) {
         Rectangle bounds = g.getClipBounds();
         bounds.grow(100, 100);                  // avoid arrow heads at the border
-        LineClip clip = new LineClip(p1, p2, bounds);
-        if (clip.execute()) {
-            p1 = clip.getP1();
-            p2 = clip.getP2();
-            path.moveTo(p1.x, p1.y);
-            path.lineTo(p2.x, p2.y);
-
+        if (mv1.rectTo(mv2).isInView()) {
+            path.moveTo(mv1);
+            path.lineTo(mv2);
             if (showDirection) {
-                final double l = 10. / p1.distance(p2);
-
-                final double sx = l * (p1.x - p2.x);
-                final double sy = l * (p1.y - p2.y);
-
-                path.lineTo(p2.x + (double) Math.round(cosPHI * sx - sinPHI * sy), p2.y + (double) Math.round(sinPHI * sx + cosPHI * sy));
-                path.moveTo(p2.x + (double) Math.round(cosPHI * sx + sinPHI * sy), p2.y + (double) Math.round(-sinPHI * sx + cosPHI * sy));
-                path.lineTo(p2.x, p2.y);
+                ARROW_PAINT_HELPER.paintArrowAt(path, mv2, mv1);
             }
         }
@@ -446 +431 @@
      * @param col The color to use for drawing line.
      * @param showDirection <code>true</code> if segment direction should be indicated.
-     */
-    protected void drawSegment(Point p1, Point p2, Color col, boolean showDirection) {
-        if (col != currentColor) {
+     * @since 10826
+     */
+    protected void drawSegment(MapViewPoint p1, MapViewPoint p2, Color col, boolean showDirection) {
+        if (!col.equals(currentColor)) {
             displaySegments(col);
         }
@@ -470 +456 @@
             g.setColor(currentColor);
             g.draw(currentPath);
-            currentPath = new GeneralPath();
+            currentPath = new MapPath2D();
             currentColor = newColor;
         }

trunk/src/org/openstreetmap/josm/data/projection/Projection.java

@@ -103 +103 @@
      */
     boolean switchXY();
+
+    /**
+     * Gets the object used as cache identifier when caching results of this projection.
+     * @return The object to use as cache key
+     * @since 10826
+     */
+    default Object getCacheKey() {
+        return this;
+    }
 }

trunk/src/org/openstreetmap/josm/gui/MapViewState.java

@@ -4 +4 @@
 import java.awt.Container;
 import java.awt.Point;
-import java.awt.Rectangle;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
@@ -19 +18 @@
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.projection.Projecting;
 import org.openstreetmap.josm.data.projection.Projection;
@@ -30 +30 @@
  */
 public final class MapViewState {
+
+    /**
+     * A flag indicating that the point is outside to the top of the map view.
+     * @since 10826
+     */
+    public static final int OUTSIDE_TOP = 1;
+
+    /**
+     * A flag indicating that the point is outside to the bottom of the map view.
+     * @since 10826
+     */
+    public static final int OUTSIDE_BOTTOM = 2;
+
+    /**
+     * A flag indicating that the point is outside to the left of the map view.
+     * @since 10826
+     */
+    public static final int OUTSIDE_LEFT = 3;
+
+    /**
+     * A flag indicating that the point is outside to the right of the map view.
+     * @since 10826
+     */
+    public static final int OUTSIDE_RIGHT = 4;
 
     private final Projecting projecting;
@@ -158 +182 @@
 
     /**
+     * Gets the {@link MapViewPoint} for the given node. This is faster than {@link #getPointFor(LatLon)} because it uses the node east/north
+     * cache.
+     * @param node The node
+     * @return The position of that node.
+     * @since 10826
+     */
+    public MapViewPoint getPointFor(Node node) {
+        return getPointFor(node.getEastNorth(getProjection()));
+    }
+
+    /**
      * Gets a rectangle representing the whole view area.
      * @return The rectangle.
@@ -169 +204 @@
      * @param rectangle The rectangle to get.
      * @return The view area.
-     * @since 10458
-     */
-    public MapViewRectangle getViewArea(Rectangle rectangle) {
+     * @since 10826
+     */
+    public MapViewRectangle getViewArea(Rectangle2D rectangle) {
         return getForView(rectangle.getMinX(), rectangle.getMinY()).rectTo(getForView(rectangle.getMaxX(), rectangle.getMaxY()));
     }
@@ -331 +366 @@
         }
 
-        protected abstract double getInViewX();
-
-        protected abstract double getInViewY();
+        /**
+         * Get the x coordinate in view space without creating an intermediate object.
+         * @return The x coordinate
+         * @since 10826
+         */
+        public abstract double getInViewX();
+
+        /**
+         * Get the y coordinate in view space without creating an intermediate object.
+         * @return The y coordinate
+         * @since 10826
+         */
+        public abstract double getInViewY();
 
         /**
@@ -399 +444 @@
             return new MapViewEastNorthPoint(getEastNorth().add(en));
         }
+
+        /**
+         * Check if this point is inside the view bounds.
+         *
+         * This is the case iff <code>getOutsideRectangleFlags(getViewArea())</code> returns no flags
+         * @return true if it is.
+         * @since 10826
+         */
+        public boolean isInView() {
+            return inRange(getInViewX(), 0, getViewWidth()) && inRange(getInViewY(), 0, getViewHeight());
+        }
+
+        private boolean inRange(double val, int min, double max) {
+            return val >= min && val < max;
+        }
+
+        /**
+         * Gets the direction in which this point is outside of the given view rectangle.
+         * @param rect The rectangle to check agains.
+         * @return The direction in which it is outside of the view, as OUTSIDE_... flags.
+         * @since 10826
+         */
+        public int getOutsideRectangleFlags(MapViewRectangle rect) {
+            Rectangle2D bounds = rect.getInView();
+            int flags = 0;
+            if (getInViewX() < bounds.getMinX()) {
+                flags |= OUTSIDE_LEFT;
+            } else if (getInViewX() > bounds.getMaxX()) {
+                flags |= OUTSIDE_RIGHT;
+            }
+            if (getInViewY() < bounds.getMinY()) {
+                flags |= OUTSIDE_TOP;
+            } else if (getInViewY() > bounds.getMaxY()) {
+                flags |= OUTSIDE_BOTTOM;
+            }
+
+            return flags;
+        }
+
+        /**
+         * Gets the sum of the x/y view distances between the points. |x1 - x2| + |y1 - y2|
+         * @param p2 The other point
+         * @return The norm
+         * @since 10826
+         */
+        public double oneNormInView(MapViewPoint p2) {
+            return Math.abs(getInViewX() - p2.getInViewX()) + Math.abs(getInViewY()) - p2.getInViewY();
+        }
+
+        /**
+         * Gets the squared distance between this point and an other point.
+         * @param p2 The other point
+         * @return The squared distance.
+         * @since 10826
+         */
+        public double distanceToInViewSq(MapViewPoint p2) {
+            double dx = getInViewX() - p2.getInViewX();
+            double dy = getInViewY() - p2.getInViewY();
+            return dx * dx + dy * dy;
+        }
+
+        /**
+         * Gets the distance between this point and an other point.
+         * @param p2 The other point
+         * @return The distance.
+         * @since 10826
+         */
+        public double distanceToInView(MapViewPoint p2) {
+            return Math.sqrt(distanceToInViewSq(p2));
+        }
     }
 
@@ -411 +526 @@
 
         @Override
-        protected double getInViewX() {
+        public double getInViewX() {
             return x;
         }
 
         @Override
-        protected double getInViewY() {
+        public double getInViewY() {
             return y;
         }
@@ -435 +550 @@
 
         @Override
-        protected double getInViewX() {
+        public double getInViewX() {
             return (eastNorth.east() - topLeft.east()) / scale;
         }
 
         @Override
-        protected double getInViewY() {
+        public double getInViewY() {
             return (topLeft.north() - eastNorth.north()) / scale;
         }
@@ -517 +632 @@
             return new Rectangle2D.Double(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2));
         }
+
+        /**
+         * Check if the rectangle intersects the map view area.
+         * @return <code>true</code> if it intersects.
+         * @since 10826
+         */
+        public boolean isInView() {
+            return getInView().intersects(getViewArea().getInView());
+        }
     }
 

trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

@@ -504 +504 @@
     }
 
-    // looses precision, may overflow (depends on p and current scale)
-    //@Deprecated
+    /**
+     * @deprecated looses precision, may overflow (depends on p and current scale)
+     */
+    @Deprecated
     public Point getPoint(EastNorth p) {
         Point2D d = getPoint2D(p);
@@ -511 +513 @@
     }
 
-    // looses precision, may overflow (depends on p and current scale)
-    //@Deprecated
+    /**
+     * @deprecated looses precision, may overflow (depends on p and current scale)
+     */
+    @Deprecated
     public Point getPoint(LatLon latlon) {
         Point2D d = getPoint2D(latlon);
@@ -518 +522 @@
     }
 
-    // looses precision, may overflow (depends on p and current scale)
-    //@Deprecated
+    /**
+     * @deprecated looses precision, may overflow (depends on p and current scale)
+     */
+    @Deprecated
     public Point getPoint(Node n) {
         Point2D d = getPoint2D(n);

trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

@@ -230 +230 @@
                     // Re-load data when display preference change
                     updateSelection();
-                }};
+                }
+            };
 
     private final transient TaggingPresetHandler presetHandler = new TaggingPresetHandler() {

trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/NodeElement.java

@@ -7 +7 @@
 import java.awt.Stroke;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.IntStream;
 
@@ -23 +24 @@
 import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.BoxProvider;
 import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.SimpleBoxProvider;
+import org.openstreetmap.josm.gui.mappaint.styleelement.Symbol.SymbolShape;
 import org.openstreetmap.josm.gui.util.RotationAngle;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
@@ -33 +35 @@
     public final MapImage mapImage;
     public final RotationAngle mapImageAngle;
+    /**
+     * The symbol that should be used for drawing this node.
+     */
     public final Symbol symbol;
-
-    public enum SymbolShape { SQUARE, CIRCLE, TRIANGLE, PENTAGON, HEXAGON, HEPTAGON, OCTAGON, NONAGON, DECAGON }
-
-    public static class Symbol {
-        public SymbolShape symbol;
-        public int size;
-        public Stroke stroke;
-        public Color strokeColor;
-        public Color fillColor;
-
-        public Symbol(SymbolShape symbol, int size, Stroke stroke, Color strokeColor, Color fillColor) {
-            if (stroke != null && strokeColor == null)
-                throw new IllegalArgumentException("Stroke given without color");
-            if (stroke == null && fillColor == null)
-                throw new IllegalArgumentException("Either a stroke or a fill color must be given");
-            this.symbol = symbol;
-            this.size = size;
-            this.stroke = stroke;
-            this.strokeColor = strokeColor;
-            this.fillColor = fillColor;
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            if (obj == null || getClass() != obj.getClass())
-                return false;
-            final Symbol other = (Symbol) obj;
-            return symbol == other.symbol &&
-                    size == other.size &&
-                    Objects.equals(stroke, other.stroke) &&
-                    Objects.equals(strokeColor, other.strokeColor) &&
-                    Objects.equals(fillColor, other.fillColor);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(symbol, size, stroke, strokeColor, fillColor);
-        }
-
-        @Override
-        public String toString() {
-            return "symbol=" + symbol + " size=" + size +
-                    (stroke != null ? " stroke=" + stroke + " strokeColor=" + strokeColor : "") +
-                    (fillColor != null ? " fillColor=" + fillColor : "");
-        }
-    }
 
     private static final String[] ICON_KEYS = {ICON_IMAGE, ICON_WIDTH, ICON_HEIGHT, ICON_OPACITY, ICON_OFFSET_X, ICON_OFFSET_Y};
@@ -194 +153 @@
     private static Symbol createSymbol(Environment env) {
         Cascade c = env.mc.getCascade(env.layer);
-        Cascade cDef = env.mc.getCascade("default");
-
-        SymbolShape shape;
+
         Keyword shapeKW = c.get("symbol-shape", null, Keyword.class);
         if (shapeKW == null)
             return null;
-        if ("square".equals(shapeKW.val)) {
-            shape = SymbolShape.SQUARE;
-        } else if ("circle".equals(shapeKW.val)) {
-            shape = SymbolShape.CIRCLE;
-        } else if ("triangle".equals(shapeKW.val)) {
-            shape = SymbolShape.TRIANGLE;
-        } else if ("pentagon".equals(shapeKW.val)) {
-            shape = SymbolShape.PENTAGON;
-        } else if ("hexagon".equals(shapeKW.val)) {
-            shape = SymbolShape.HEXAGON;
-        } else if ("heptagon".equals(shapeKW.val)) {
-            shape = SymbolShape.HEPTAGON;
-        } else if ("octagon".equals(shapeKW.val)) {
-            shape = SymbolShape.OCTAGON;
-        } else if ("nonagon".equals(shapeKW.val)) {
-            shape = SymbolShape.NONAGON;
-        } else if ("decagon".equals(shapeKW.val)) {
-            shape = SymbolShape.DECAGON;
-        } else
+        Optional<SymbolShape> shape = SymbolShape.forName(shapeKW.val);
+        if (!shape.isPresent()) {
             return null;
-
+        }
+
+        Cascade cDef = env.mc.getCascade("default");
         Float sizeOnDefault = cDef.get("symbol-size", null, Float.class);
         if (sizeOnDefault != null && sizeOnDefault <= 0) {
@@ -268 +210 @@
         }
 
-        return new Symbol(shape, Math.round(size), stroke, strokeColor, fillColor);
+        return new Symbol(shape.get(), Math.round(size), stroke, strokeColor, fillColor);
     }
 
@@ -280 +222 @@
                         mapImageAngle == null ? 0.0 : mapImageAngle.getRotationAngle(primitive));
             } else if (symbol != null) {
-                Color fillColor = symbol.fillColor;
-                if (fillColor != null) {
-                    if (painter.isInactiveMode() || n.isDisabled()) {
-                        fillColor = settings.getInactiveColor();
-                    } else if (defaultSelectedHandling && selected) {
-                        fillColor = settings.getSelectedColor(fillColor.getAlpha());
-                    } else if (member) {
-                        fillColor = settings.getRelationSelectedColor(fillColor.getAlpha());
-                    }
-                }
-                Color strokeColor = symbol.strokeColor;
-                if (strokeColor != null) {
-                    if (painter.isInactiveMode() || n.isDisabled()) {
-                        strokeColor = settings.getInactiveColor();
-                    } else if (defaultSelectedHandling && selected) {
-                        strokeColor = settings.getSelectedColor(strokeColor.getAlpha());
-                    } else if (member) {
-                        strokeColor = settings.getRelationSelectedColor(strokeColor.getAlpha());
-                    }
-                }
-                painter.drawNodeSymbol(n, symbol, fillColor, strokeColor);
+                paintWithSymbol(settings, painter, selected, member, n);
             } else {
                 Color color;
@@ -344 +266 @@
     }
 
+    private void paintWithSymbol(MapPaintSettings settings, StyledMapRenderer painter, boolean selected, boolean member,
+            Node n) {
+        Color fillColor = symbol.fillColor;
+        if (fillColor != null) {
+            if (painter.isInactiveMode() || n.isDisabled()) {
+                fillColor = settings.getInactiveColor();
+            } else if (defaultSelectedHandling && selected) {
+                fillColor = settings.getSelectedColor(fillColor.getAlpha());
+            } else if (member) {
+                fillColor = settings.getRelationSelectedColor(fillColor.getAlpha());
+            }
+        }
+        Color strokeColor = symbol.strokeColor;
+        if (strokeColor != null) {
+            if (painter.isInactiveMode() || n.isDisabled()) {
+                strokeColor = settings.getInactiveColor();
+            } else if (defaultSelectedHandling && selected) {
+                strokeColor = settings.getSelectedColor(strokeColor.getAlpha());
+            } else if (member) {
+                strokeColor = settings.getRelationSelectedColor(strokeColor.getAlpha());
+            }
+        }
+        painter.drawNodeSymbol(n, symbol, fillColor, strokeColor);
+    }
+
     public BoxProvider getBoxProvider() {
         if (mapImage != null)