Changeset 10827 in josm for trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java

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

File:

• trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java (modified) (40 diffs)

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)};
         }