Ticket #17119: clip-v2.patch

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

@@ -87 +87 @@
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.JosmRuntimeException;
 import org.openstreetmap.josm.tools.Logging;
+import org.openstreetmap.josm.tools.ShapeClipper;
 import org.openstreetmap.josm.tools.Utils;
 import org.openstreetmap.josm.tools.bugreport.BugReport;
 
@@ -485 +486 @@
             Shape clip = shape;
             if (pfClip != null) {
                 clip = pfClip.createTransformedShape(mapState.getAffineTransform());
+            } else if (!mapState.isInsideViewClipRectangle(shape)) {
+                // clip with fast algorithm first
+                Shape clip2 = ShapeClipper.clipShape(shape, mapState.getViewClipRectangle().getInView());
+                if (clip2 != null) {
+                    clip = clip2;
+                }
             }
             g.clip(clip);
             g.setStroke(new BasicStroke(2 * extent, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, mitterLimit));
-            g.draw(shape);
+            if (pfClip == null)
+                g.draw(shape);
+            else
+                g.draw(clip);
             g.setClip(oldClip);
             g.setStroke(new BasicStroke());
         }

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

@@ -3 +3 @@
 
 import java.awt.Container;
 import java.awt.Point;
+import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Path2D;
@@ -304 +305 @@
     }
 
     /**
+     * Gets a rectangle that is several pixel bigger than the view in EastNorth.
+     * @return The rectangle.
+     */
+    public Rectangle2D getEastNorthClipRectangle() {
+        return new Rectangle2D.Double(topLeft.east() - CLIP_BOUNDS, topLeft.north() - (viewHeight + CLIP_BOUNDS),
+                viewWidth + 2 * CLIP_BOUNDS, viewHeight + 2 * CLIP_BOUNDS);
+    }
+
+    /**
+     * Test if the area is inside the view clip rectangle (it may touch it).
+     * @param area The area, interpreted in east/north space.
+     * @return true if it is inside or touches it
+     */
+    public boolean isInsideViewClipRectangle(Shape area) {
+        Rectangle2D bounds = area.getBounds2D();
+        if (bounds.isEmpty()) return false;
+        return (getEastNorthClipRectangle().contains(bounds));
+
+    }
+
+    /**
      * Returns the area for the given bounds.
      * @param bounds bounds
      * @return the area for the given bounds

src/org/openstreetmap/josm/gui/draw/MapViewPath.java

@@ -24 +24 @@
  * @author Michael Zangl
  * @since 10875
  */
-public class MapViewPath extends MapPath2D {
+public class MapViewPath extends MapPath2D implements Shape {
 
     private final MapViewState state;
 

src/org/openstreetmap/josm/tools/ShapeClipper.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.tools;
+
+import java.awt.Shape;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Rectangle2D;
+import java.util.Arrays;
+
+/**
+ * Tools to clip a shape based on the Sutherland-Hodgman algorithm.
+ * See https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm
+ * @author Gerd Petermann
+ *
+ */
+public final class ShapeClipper {
+    private static final int LEFT = 0;
+    private static final int TOP = 1;
+    private static final int RIGHT = 2;
+    private static final int BOTTOM = 3;
+
+    private ShapeClipper() {
+        // Hide default constructor for utils classes
+    }
+
+    /**
+     * Clip a given (closed) shape with a given rectangle.
+     * @param shape the subject shape to clip
+     * @param clippingRect the clipping rectangle
+     * @return the intersection of the shape and the rectangle
+     * or null if they don't intersect or the shape is not closed.
+     * The intersection may contain dangling edges.
+     */
+    public static Path2D.Double clipShape(Shape shape, Rectangle2D clippingRect) {
+        double minX = Double.POSITIVE_INFINITY, minY = Double.POSITIVE_INFINITY, maxX = Double.NEGATIVE_INFINITY,
+                maxY = Double.NEGATIVE_INFINITY;
+        PathIterator pit = shape.getPathIterator(null);
+        double[] points = new double[512];
+        int num = 0;
+        Path2D.Double result = null;
+        double[] res = new double[6];
+        while (!pit.isDone()) {
+            int type = pit.currentSegment(res);
+            double x = res[0];
+            double y = res[1];
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+            switch (type) {
+            case PathIterator.SEG_LINETO:
+            case PathIterator.SEG_MOVETO:
+                if (num + 2 >= points.length) {
+                    points = Arrays.copyOf(points, points.length * 2);
+                }
+                points[num++] = x;
+                points[num++] = y;
+                break;
+            case PathIterator.SEG_CLOSE:
+                Path2D.Double segment = null;
+                if (!clippingRect.contains(minX, minY) || !clippingRect.contains(maxX, maxY)) {
+                    Rectangle2D.Double bbox = new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
+                    segment = clipSinglePathWithSutherlandHodgman(points, num, clippingRect, bbox);
+                } else
+                    segment = pointsToPath2D(points, num);
+                if (segment != null) {
+                    if (result == null)
+                        result = segment;
+                    else
+                        result.append(segment, false);
+                }
+                num = 0;
+                minX = minY = Double.POSITIVE_INFINITY;
+                maxX = maxY = Double.NEGATIVE_INFINITY;
+                break;
+            default:
+                Logging.error("Unsupported path iterator type " + type + ". This is not supported by " + ShapeClipper.class.getName() + ".");
+            }
+            pit.next();
+        }
+        if (num >= 2) {
+            // last type was not a SEG_CLOSE
+            if (points[0] == points[num - 2] && points[1] == points[num - 1]) {
+                // not closed with closePath() but first and last point are equal
+                Path2D.Double segment = null;
+                if (!clippingRect.contains(minX, minY) || !clippingRect.contains(maxX, maxY)) {
+                    Rectangle2D.Double bbox = new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
+                    segment = clipSinglePathWithSutherlandHodgman(points, num, clippingRect, bbox);
+                } else
+                    segment = pointsToPath2D(points, num);
+                if (segment != null) {
+                    if (result == null)
+                        result = segment;
+                    else
+                        result.append(segment, false);
+                }
+            } else {
+                Logging.warn(ShapeClipper.class.getName() + " shape is not closed.");
+                return null;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Convert a list of points to a Path2D.Double
+     * @param points the pairs
+     * @param num the number of valid values in points
+     * @return the path or null if the path describes a point or line.
+     */
+    private static Path2D.Double pointsToPath2D(double[] points, int num) {
+        if (num < 2)
+            return null;
+        if (points[0] == points[num - 2] && points[1] == points[num - 1])
+            num -= 2;
+        if (num < 6)
+            return null;
+        Path2D.Double path = new Path2D.Double(Path2D.WIND_NON_ZERO, num / 2 + 2);
+        double lastX = points[0], lastY = points[1];
+        path.moveTo(lastX, lastY);
+        int numOut = 1;
+        for (int i = 2; i < num;) {
+            double x = points[i++], y = points[i++];
+            if (x != lastX || y != lastY) {
+                path.lineTo(x, y);
+                lastX = x;
+                lastY = y;
+                ++numOut;
+            }
+        }
+        if (numOut < 3)
+            return null;
+        path.closePath();
+        return path;
+    }
+
+    /**
+     * Clip a single path with a given rectangle using the Sutherland-Hodgman algorithm. This is much faster compared to
+     * the area.intersect method, but may create dangling edges.
+     * @param points a list of longitude+latitude pairs
+     * @param num the number of valid values in points
+     * @param clippingRect the clipping rectangle
+     * @param bbox the bounding box of the path
+     * @return the clipped path as a Path2D.Double or null if the result is empty
+     */
+    private static Path2D.Double clipSinglePathWithSutherlandHodgman(double[] points, int num, Rectangle2D clippingRect,
+            Rectangle2D.Double bbox) {
+        if (num <= 2 || !bbox.intersects(clippingRect)) {
+            return null;
+        }
+
+        int countVals = num;
+        if (points[0] == points[num - 2] && points[1] == points[num - 1]) {
+            countVals -= 2;
+        }
+        double[] outputList = points;
+        double[] input;
+
+        double leftX = clippingRect.getMinX();
+        double rightX = clippingRect.getMaxX();
+        double lowerY = clippingRect.getMinY();
+        double upperY = clippingRect.getMaxY();
+        boolean eIsIn = false, sIsIn = false;
+        for (int side = LEFT; side <= BOTTOM; side++) {
+            if (countVals < 6)
+                return null; // ignore point or line
+
+            boolean skipTestForThisSide;
+            switch (side) {
+            case LEFT:
+                skipTestForThisSide = (bbox.getMinX() >= leftX);
+                break;
+            case TOP:
+                skipTestForThisSide = (bbox.getMaxY() < upperY);
+                break;
+            case RIGHT:
+                skipTestForThisSide = (bbox.getMaxX() < rightX);
+                break;
+            default:
+                skipTestForThisSide = (bbox.getMinY() >= lowerY);
+            }
+            if (skipTestForThisSide)
+                continue;
+
+            input = outputList;
+            outputList = new double[countVals + 16];
+            double sLon = 0, sLat = 0;
+            double pLon = 0, pLat = 0; // intersection
+            int posIn = countVals - 2;
+            int posOut = 0;
+            for (int i = 0; i < countVals + 2; i += 2) {
+                if (posIn >= countVals)
+                    posIn = 0;
+                double eLon = input[posIn++];
+                double eLat = input[posIn++];
+                switch (side) {
+                case LEFT:
+                    eIsIn = (eLon >= leftX);
+                    break;
+                case TOP:
+                    eIsIn = (eLat < upperY);
+                    break;
+                case RIGHT:
+                    eIsIn = (eLon < rightX);
+                    break;
+                default:
+                    eIsIn = (eLat >= lowerY);
+                }
+                if (i > 0) {
+                    if (eIsIn != sIsIn) {
+                        // compute intersection
+                        double slope;
+                        if (eLon != sLon)
+                            slope = (eLat - sLat) / (eLon - sLon);
+                        else
+                            slope = 1;
+
+                        switch (side) {
+                        case LEFT:
+                            pLon = leftX;
+                            pLat = slope * (leftX - sLon) + sLat;
+                            break;
+                        case RIGHT:
+                            pLon = rightX;
+                            pLat = slope * (rightX - sLon) + sLat;
+                            break;
+
+                        case TOP:
+                            if (eLon != sLon)
+                                pLon = sLon + (upperY - sLat) / slope;
+                            else
+                                pLon = sLon;
+                            pLat = upperY;
+                            break;
+                        default: // BOTTOM
+                            if (eLon != sLon)
+                                pLon = sLon + (lowerY - sLat) / slope;
+                            else
+                                pLon = sLon;
+                            pLat = lowerY;
+                            break;
+
+                        }
+                    }
+                    int toAdd = 0;
+                    if (eIsIn) {
+                        if (!sIsIn) {
+                            toAdd += 2;
+                        }
+                        toAdd += 2;
+                    } else {
+                        if (sIsIn) {
+                            toAdd += 2;
+                        }
+                    }
+                    if (posOut + toAdd >= outputList.length) {
+                        // unlikely
+                        outputList = Arrays.copyOf(outputList, outputList.length * 2);
+                    }
+                    if (eIsIn) {
+                        if (!sIsIn) {
+                            outputList[posOut++] = pLon;
+                            outputList[posOut++] = pLat;
+                        }
+                        outputList[posOut++] = eLon;
+                        outputList[posOut++] = eLat;
+                    } else {
+                        if (sIsIn) {
+                            outputList[posOut++] = pLon;
+                            outputList[posOut++] = pLat;
+                        }
+                    }
+                }
+                // S = E
+                sLon = eLon;
+                sLat = eLat;
+                sIsIn = eIsIn;
+            }
+            countVals = posOut;
+        }
+        return pointsToPath2D(outputList, countVals);
+    }
+}