001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.data.osm.visitor.paint;
003
004import java.awt.AlphaComposite;
005import java.awt.BasicStroke;
006import java.awt.Color;
007import java.awt.Component;
008import java.awt.Composite;
009import java.awt.Font;
010import java.awt.FontMetrics;
011import java.awt.Graphics2D;
012import java.awt.Image;
013import java.awt.Point;
014import java.awt.Rectangle;
015import java.awt.RenderingHints;
016import java.awt.Shape;
017import java.awt.TexturePaint;
018import java.awt.font.FontRenderContext;
019import java.awt.font.GlyphVector;
020import java.awt.font.LineMetrics;
021import java.awt.font.TextLayout;
022import java.awt.geom.AffineTransform;
023import java.awt.geom.Path2D;
024import java.awt.geom.Point2D;
025import java.awt.geom.Rectangle2D;
026import java.awt.geom.RoundRectangle2D;
027import java.awt.image.BufferedImage;
028import java.util.ArrayList;
029import java.util.Arrays;
030import java.util.Collection;
031import java.util.HashMap;
032import java.util.Iterator;
033import java.util.List;
034import java.util.Map;
035import java.util.Objects;
036import java.util.Optional;
037import java.util.concurrent.ForkJoinPool;
038import java.util.concurrent.TimeUnit;
039import java.util.concurrent.locks.Lock;
040import java.util.function.BiConsumer;
041import java.util.function.Consumer;
042import java.util.function.Supplier;
043
044import javax.swing.AbstractButton;
045import javax.swing.FocusManager;
046
047import org.openstreetmap.josm.data.Bounds;
048import org.openstreetmap.josm.data.coor.EastNorth;
049import org.openstreetmap.josm.data.osm.BBox;
050import org.openstreetmap.josm.data.osm.INode;
051import org.openstreetmap.josm.data.osm.IPrimitive;
052import org.openstreetmap.josm.data.osm.IRelation;
053import org.openstreetmap.josm.data.osm.IRelationMember;
054import org.openstreetmap.josm.data.osm.IWay;
055import org.openstreetmap.josm.data.osm.OsmData;
056import org.openstreetmap.josm.data.osm.OsmPrimitive;
057import org.openstreetmap.josm.data.osm.OsmUtils;
058import org.openstreetmap.josm.data.osm.Relation;
059import org.openstreetmap.josm.data.osm.WaySegment;
060import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon;
061import org.openstreetmap.josm.data.osm.visitor.paint.relations.Multipolygon.PolyData;
062import org.openstreetmap.josm.data.osm.visitor.paint.relations.MultipolygonCache;
063import org.openstreetmap.josm.data.preferences.AbstractProperty;
064import org.openstreetmap.josm.data.preferences.BooleanProperty;
065import org.openstreetmap.josm.data.preferences.IntegerProperty;
066import org.openstreetmap.josm.data.preferences.StringProperty;
067import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
068import org.openstreetmap.josm.gui.NavigatableComponent;
069import org.openstreetmap.josm.gui.draw.MapViewPath;
070import org.openstreetmap.josm.gui.draw.MapViewPositionAndRotation;
071import org.openstreetmap.josm.gui.mappaint.ElemStyles;
072import org.openstreetmap.josm.gui.mappaint.MapPaintStyles;
073import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement;
074import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.HorizontalTextAlignment;
075import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.VerticalTextAlignment;
076import org.openstreetmap.josm.gui.mappaint.styleelement.DefaultStyles;
077import org.openstreetmap.josm.gui.mappaint.styleelement.MapImage;
078import org.openstreetmap.josm.gui.mappaint.styleelement.RepeatImageElement.LineImageAlignment;
079import org.openstreetmap.josm.gui.mappaint.styleelement.StyleElement;
080import org.openstreetmap.josm.gui.mappaint.styleelement.Symbol;
081import org.openstreetmap.josm.gui.mappaint.styleelement.TextLabel;
082import org.openstreetmap.josm.gui.mappaint.styleelement.placement.PositionForAreaStrategy;
083import org.openstreetmap.josm.spi.preferences.Config;
084import org.openstreetmap.josm.tools.CompositeList;
085import org.openstreetmap.josm.tools.Geometry;
086import org.openstreetmap.josm.tools.Geometry.AreaAndPerimeter;
087import org.openstreetmap.josm.tools.HiDPISupport;
088import org.openstreetmap.josm.tools.JosmRuntimeException;
089import org.openstreetmap.josm.tools.Logging;
090import org.openstreetmap.josm.tools.RotationAngle;
091import org.openstreetmap.josm.tools.ShapeClipper;
092import org.openstreetmap.josm.tools.Utils;
093import org.openstreetmap.josm.tools.bugreport.BugReport;
094
095/**
096 * A map renderer which renders a map according to style rules in a set of style sheets.
097 * @since 486
098 */
099public class StyledMapRenderer extends AbstractMapRenderer {
100
101    private static final ForkJoinPool THREAD_POOL = newForkJoinPool();
102
103    private static ForkJoinPool newForkJoinPool() {
104        try {
105            return Utils.newForkJoinPool(
106                    "mappaint.StyledMapRenderer.style_creation.numberOfThreads", "styled-map-renderer-%d", Thread.NORM_PRIORITY);
107        } catch (SecurityException e) {
108            Logging.log(Logging.LEVEL_ERROR, "Unable to create new ForkJoinPool", e);
109            return null;
110        }
111    }
112
113    /**
114     * This stores a style and a primitive that should be painted with that style.
115     */
116    public static class StyleRecord implements Comparable<StyleRecord> {
117        private final StyleElement style;
118        private final IPrimitive osm;
119        private final int flags;
120        private final long order;
121
122        StyleRecord(StyleElement style, IPrimitive osm, int flags) {
123            this.style = style;
124            this.osm = osm;
125            this.flags = flags;
126
127            long order = 0;
128            if ((this.flags & FLAG_DISABLED) == 0) {
129                order |= 1;
130            }
131
132            order <<= 24;
133            order |= floatToFixed(this.style.majorZIndex, 24);
134
135            // selected on top of member of selected on top of unselected
136            // FLAG_DISABLED bit is the same at this point, but we simply ignore it
137            order <<= 4;
138            order |= this.flags & 0xf;
139
140            order <<= 24;
141            order |= floatToFixed(this.style.zIndex, 24);
142
143            order <<= 1;
144            // simple node on top of icons and shapes
145            if (DefaultStyles.SIMPLE_NODE_ELEMSTYLE.equals(this.style)) {
146                order |= 1;
147            }
148
149            this.order = order;
150        }
151
152        /**
153         * Converts a float to a fixed point decimal so that the order stays the same.
154         *
155         * @param number The float to convert
156         * @param totalBits
157         *            Total number of bits. 1 sign bit. There should be at least 15 bits.
158         * @return The float converted to an integer.
159         */
160        protected static long floatToFixed(float number, int totalBits) {
161            long value = Float.floatToIntBits(number) & 0xffffffffL;
162
163            boolean negative = (value & 0x80000000L) != 0;
164            // Invert the sign bit, so that negative numbers are lower
165            value ^= 0x80000000L;
166            // Now do the shift. Do it before accounting for negative numbers (symmetry)
167            if (totalBits < 32) {
168                value >>= (32 - totalBits);
169            }
170            // positive numbers are sorted now. Negative ones the wrong way.
171            if (negative) {
172                // Negative number: re-map it
173                value = (1L << (totalBits - 1)) - value;
174            }
175            return value;
176        }
177
178        @Override
179        public int compareTo(StyleRecord other) {
180            int d = Long.compare(order, other.order);
181            if (d != 0) {
182                return d;
183            }
184
185            // newer primitives to the front
186            long id = this.osm.getUniqueId() - other.osm.getUniqueId();
187            if (id > 0)
188                return 1;
189            if (id < 0)
190                return -1;
191
192            return Float.compare(this.style.objectZIndex, other.style.objectZIndex);
193        }
194
195        @Override
196        public int hashCode() {
197            return Objects.hash(order, osm, style, flags);
198        }
199
200        @Override
201        public boolean equals(Object obj) {
202            if (this == obj)
203                return true;
204            if (obj == null || getClass() != obj.getClass())
205                return false;
206            StyleRecord other = (StyleRecord) obj;
207            return flags == other.flags
208                && order == other.order
209                && Objects.equals(osm, other.osm)
210                && Objects.equals(style, other.style);
211        }
212
213        /**
214         * Get the style for this style element.
215         * @return The style
216         */
217        public StyleElement getStyle() {
218            return style;
219        }
220
221        /**
222         * Paints the primitive with the style.
223         * @param paintSettings The settings to use.
224         * @param painter The painter to paint the style.
225         */
226        public void paintPrimitive(MapPaintSettings paintSettings, StyledMapRenderer painter) {
227            style.paintPrimitive(
228                    osm,
229                    paintSettings,
230                    painter,
231                    (flags & FLAG_SELECTED) != 0,
232                    (flags & FLAG_OUTERMEMBER_OF_SELECTED) != 0,
233                    (flags & FLAG_MEMBER_OF_SELECTED) != 0
234            );
235        }
236
237        @Override
238        public String toString() {
239            return "StyleRecord [style=" + style + ", osm=" + osm + ", flags=" + flags + "]";
240        }
241    }
242
243    private static final Map<Font, Boolean> IS_GLYPH_VECTOR_DOUBLE_TRANSLATION_BUG = new HashMap<>();
244
245    /**
246     * Check, if this System has the GlyphVector double translation bug.
247     *
248     * With this bug, <code>gv.setGlyphTransform(i, trfm)</code> has a different
249     * effect than on most other systems, namely the translation components
250     * ("m02" &amp; "m12", {@link AffineTransform}) appear to be twice as large, as
251     * they actually are. The rotation is unaffected (scale &amp; shear not tested
252     * so far).
253     *
254     * This bug has only been observed on Mac OS X, see #7841.
255     *
256     * After switch to Java 7, this test is a false positive on Mac OS X (see #10446),
257     * i.e. it returns true, but the real rendering code does not require any special
258     * handling.
259     * It hasn't been further investigated why the test reports a wrong result in
260     * this case, but the method has been changed to simply return false by default.
261     * (This can be changed with a setting in the advanced preferences.)
262     *
263     * @param font The font to check.
264     * @return false by default, but depends on the value of the advanced
265     * preference glyph-bug=false|true|auto, where auto is the automatic detection
266     * method which apparently no longer gives a useful result for Java 7.
267     */
268    public static boolean isGlyphVectorDoubleTranslationBug(Font font) {
269        Boolean cached = IS_GLYPH_VECTOR_DOUBLE_TRANSLATION_BUG.get(font);
270        if (cached != null)
271            return cached;
272        String overridePref = Config.getPref().get("glyph-bug", "auto");
273        if ("auto".equals(overridePref)) {
274            FontRenderContext frc = new FontRenderContext(null, false, false);
275            GlyphVector gv = font.createGlyphVector(frc, "x");
276            gv.setGlyphTransform(0, AffineTransform.getTranslateInstance(1000, 1000));
277            Shape shape = gv.getGlyphOutline(0);
278            if (Logging.isTraceEnabled()) {
279                Logging.trace("#10446: shape: {0}", shape.getBounds());
280            }
281            // x is about 1000 on normal stystems and about 2000 when the bug occurs
282            int x = shape.getBounds().x;
283            boolean isBug = x > 1500;
284            IS_GLYPH_VECTOR_DOUBLE_TRANSLATION_BUG.put(font, isBug);
285            return isBug;
286        } else {
287            boolean override = Boolean.parseBoolean(overridePref);
288            IS_GLYPH_VECTOR_DOUBLE_TRANSLATION_BUG.put(font, override);
289            return override;
290        }
291    }
292
293    private double circum;
294    private double scale;
295
296    private MapPaintSettings paintSettings;
297    private ElemStyles styles;
298
299    private Color highlightColorTransparent;
300
301    /**
302     * Flags used to store the primitive state along with the style. This is the normal style.
303     * <p>
304     * Not used in any public interfaces.
305     */
306    static final int FLAG_NORMAL = 0;
307    /**
308     * A primitive with {@link OsmPrimitive#isDisabled()}
309     */
310    static final int FLAG_DISABLED = 1;
311    /**
312     * A primitive with {@link OsmPrimitive#isMemberOfSelected()}
313     */
314    static final int FLAG_MEMBER_OF_SELECTED = 2;
315    /**
316     * A primitive with {@link OsmPrimitive#isSelected()}
317     */
318    static final int FLAG_SELECTED = 4;
319    /**
320     * A primitive with {@link OsmPrimitive#isOuterMemberOfSelected()}
321     */
322    static final int FLAG_OUTERMEMBER_OF_SELECTED = 8;
323
324    private static final double PHI = Utils.toRadians(20);
325    private static final double cosPHI = Math.cos(PHI);
326    private static final double sinPHI = Math.sin(PHI);
327    /**
328     * If we should use left hand traffic.
329     */
330    private static final AbstractProperty<Boolean> PREFERENCE_LEFT_HAND_TRAFFIC
331            = new BooleanProperty("mappaint.lefthandtraffic", false).cached();
332    /**
333     * Indicates that the renderer should enable anti-aliasing
334     * @since 11758
335     */
336    public static final AbstractProperty<Boolean> PREFERENCE_ANTIALIASING_USE
337            = new BooleanProperty("mappaint.use-antialiasing", true).cached();
338    /**
339     * The mode that is used for anti-aliasing
340     * @since 11758
341     */
342    public static final AbstractProperty<String> PREFERENCE_TEXT_ANTIALIASING
343            = new StringProperty("mappaint.text-antialiasing", "default").cached();
344
345    /**
346     * The line with to use for highlighting
347     */
348    private static final AbstractProperty<Integer> HIGHLIGHT_LINE_WIDTH = new IntegerProperty("mappaint.highlight.width", 4).cached();
349    private static final AbstractProperty<Integer> HIGHLIGHT_POINT_RADIUS = new IntegerProperty("mappaint.highlight.radius", 7).cached();
350    private static final AbstractProperty<Integer> WIDER_HIGHLIGHT = new IntegerProperty("mappaint.highlight.bigger-increment", 5).cached();
351    private static final AbstractProperty<Integer> HIGHLIGHT_STEP = new IntegerProperty("mappaint.highlight.step", 4).cached();
352
353    private Collection<WaySegment> highlightWaySegments;
354
355    //flag that activate wider highlight mode
356    private final boolean useWiderHighlight;
357
358    private boolean useStrokes;
359    private boolean showNames;
360    private boolean showIcons;
361    private boolean isOutlineOnly;
362
363    private boolean leftHandTraffic;
364    private Object antialiasing;
365
366    private Supplier<RenderBenchmarkCollector> benchmarkFactory = RenderBenchmarkCollector.defaultBenchmarkSupplier();
367
368    /**
369     * Constructs a new {@code StyledMapRenderer}.
370     *
371     * @param g the graphics context. Must not be null.
372     * @param nc the map viewport. Must not be null.
373     * @param isInactiveMode if true, the paint visitor shall render OSM objects such that they
374     * look inactive. Example: rendering of data in an inactive layer using light gray as color only.
375     * @throws IllegalArgumentException if {@code g} is null
376     * @throws IllegalArgumentException if {@code nc} is null
377     */
378    public StyledMapRenderer(Graphics2D g, NavigatableComponent nc, boolean isInactiveMode) {
379        super(g, nc, isInactiveMode);
380        Component focusOwner = FocusManager.getCurrentManager().getFocusOwner();
381        useWiderHighlight = !(focusOwner instanceof AbstractButton || focusOwner == nc);
382        this.styles = MapPaintStyles.getStyles();
383    }
384
385    /**
386     * Set the {@link ElemStyles} instance to use for this renderer.
387     * @param styles the {@code ElemStyles} instance to use
388     */
389    public void setStyles(ElemStyles styles) {
390        this.styles = styles;
391    }
392
393    private void displaySegments(MapViewPath path, Path2D orientationArrows, Path2D onewayArrows, Path2D onewayArrowsCasing,
394            Color color, BasicStroke line, BasicStroke dashes, Color dashedColor) {
395        g.setColor(isInactiveMode ? inactiveColor : color);
396        if (useStrokes) {
397            g.setStroke(line);
398        }
399        g.draw(path.computeClippedLine(g.getStroke()));
400
401        if (!isInactiveMode && useStrokes && dashes != null) {
402            g.setColor(dashedColor);
403            g.setStroke(dashes);
404            g.draw(path.computeClippedLine(dashes));
405        }
406
407        if (orientationArrows != null) {
408            g.setColor(isInactiveMode ? inactiveColor : color);
409            g.setStroke(new BasicStroke(line.getLineWidth(), line.getEndCap(), BasicStroke.JOIN_MITER, line.getMiterLimit()));
410            g.draw(orientationArrows);
411        }
412
413        if (onewayArrows != null) {
414            g.setStroke(new BasicStroke(1, line.getEndCap(), BasicStroke.JOIN_MITER, line.getMiterLimit()));
415            g.fill(onewayArrowsCasing);
416            g.setColor(isInactiveMode ? inactiveColor : backgroundColor);
417            g.fill(onewayArrows);
418        }
419
420        if (useStrokes) {
421            g.setStroke(new BasicStroke());
422        }
423    }
424
425    /**
426     * Worker function for drawing areas.
427     *
428     * @param area the path object for the area that should be drawn; in case
429     * of multipolygons, this can path can be a complex shape with one outer
430     * polygon and one or more inner polygons
431     * @param color The color to fill the area with.
432     * @param fillImage The image to fill the area with. Overrides color.
433     * @param extent if not null, area will be filled partially; specifies, how
434     * far to fill from the boundary towards the center of the area;
435     * if null, area will be filled completely
436     * @param pfClip clipping area for partial fill (only needed for unclosed
437     * polygons)
438     * @param disabled If this should be drawn with a special disabled style.
439     */
440    protected void drawArea(MapViewPath area, Color color,
441            MapImage fillImage, Float extent, MapViewPath pfClip, boolean disabled) {
442        if (!isOutlineOnly && color.getAlpha() != 0) {
443            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
444            if (fillImage == null) {
445                if (isInactiveMode) {
446                    g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.33f));
447                }
448                g.setColor(color);
449                computeFill(area, extent, pfClip, 4);
450            } else {
451                // TexturePaint requires BufferedImage -> get base image from possible multi-resolution image
452                Image img = HiDPISupport.getBaseImage(fillImage.getImage(disabled));
453                if (img != null) {
454                    g.setPaint(new TexturePaint((BufferedImage) img,
455                            new Rectangle(0, 0, fillImage.getWidth(), fillImage.getHeight())));
456                } else {
457                    Logging.warn("Unable to get image from " + fillImage);
458                }
459                float alpha = fillImage.getAlphaFloat();
460                if (!Utils.equalsEpsilon(alpha, 1f)) {
461                    g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
462                }
463                computeFill(area, extent, pfClip, 10);
464                g.setPaintMode();
465            }
466            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialiasing);
467        }
468    }
469
470    /**
471     * Fill the given shape. If partial fill is used, computes the clipping.
472     * @param shape the given shape
473     * @param extent if not null, area will be filled partially; specifies, how
474     * far to fill from the boundary towards the center of the area;
475     * if null, area will be filled completely
476     * @param pfClip clipping area for partial fill (only needed for unclosed
477     * polygons)
478     * @param mitterLimit parameter for BasicStroke
479     *
480     */
481    private void computeFill(Shape shape, Float extent, MapViewPath pfClip, float mitterLimit) {
482        if (extent == null) {
483            g.fill(shape);
484        } else {
485            Shape oldClip = g.getClip();
486            Shape clip = shape;
487            if (pfClip != null) {
488                clip = pfClip;
489            }
490            g.clip(clip);
491            g.setStroke(new BasicStroke(2 * extent, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, mitterLimit));
492            g.draw(shape);
493            g.setClip(oldClip);
494            g.setStroke(new BasicStroke());
495        }
496    }
497
498    /**
499     * Draws a multipolygon area.
500     * @param r The multipolygon relation
501     * @param color The color to fill the area with.
502     * @param fillImage The image to fill the area with. Overrides color.
503     * @param extent if not null, area will be filled partially; specifies, how
504     * far to fill from the boundary towards the center of the area;
505     * if null, area will be filled completely
506     * @param extentThreshold if not null, determines if the partial filled should
507     * be replaced by plain fill, when it covers a certain fraction of the total area
508     * @param disabled If this should be drawn with a special disabled style.
509     * @since 12285
510     */
511    public void drawArea(Relation r, Color color, MapImage fillImage, Float extent, Float extentThreshold, boolean disabled) {
512        Multipolygon multipolygon = MultipolygonCache.getInstance().get(r);
513        if (!r.isDisabled() && !multipolygon.getOuterWays().isEmpty()) {
514            for (PolyData pd : multipolygon.getCombinedPolygons()) {
515                if (!isAreaVisible(pd.get())) {
516                    continue;
517                }
518                MapViewPath p = shapeEastNorthToMapView(pd.get());
519                MapViewPath pfClip = null;
520                if (extent != null) {
521                    if (!usePartialFill(pd.getAreaAndPerimeter(null), extent, extentThreshold)) {
522                        extent = null;
523                    } else if (!pd.isClosed()) {
524                        pfClip = shapeEastNorthToMapView(getPFClip(pd, extent * scale));
525                    }
526                }
527                drawArea(p,
528                        pd.isSelected() ? paintSettings.getRelationSelectedColor(color.getAlpha()) : color,
529                        fillImage, extent, pfClip, disabled);
530            }
531        }
532    }
533
534    /**
535     * Convert shape in EastNorth coordinates to MapViewPath and remove invisible parts.
536     * For complex shapes this improves performance drastically because the methods in Graphics2D.clip() and Graphics2D.draw() are rather slow.
537     * @param shape the shape to convert
538     * @return the converted shape
539     */
540    private MapViewPath shapeEastNorthToMapView(Path2D.Double shape) {
541        MapViewPath convertedShape = null;
542        if (shape != null) {
543            convertedShape = new MapViewPath(mapState);
544            convertedShape.appendFromEastNorth(shape);
545            convertedShape.setWindingRule(Path2D.WIND_EVEN_ODD);
546
547            Rectangle2D extViewBBox = mapState.getViewClipRectangle().getInView();
548            if (!extViewBBox.contains(convertedShape.getBounds2D())) {
549                // remove invisible parts of shape
550                Path2D.Double clipped = ShapeClipper.clipShape(convertedShape, extViewBBox);
551                if (clipped != null) {
552                    convertedShape.reset();
553                    convertedShape.append(clipped, false);
554                }
555            }
556        }
557        return convertedShape;
558    }
559
560    /**
561     * Draws an area defined by a way. They way does not need to be closed, but it should.
562     * @param w The way.
563     * @param color The color to fill the area with.
564     * @param fillImage The image to fill the area with. Overrides color.
565     * @param extent if not null, area will be filled partially; specifies, how
566     * far to fill from the boundary towards the center of the area;
567     * if null, area will be filled completely
568     * @param extentThreshold if not null, determines if the partial filled should
569     * be replaced by plain fill, when it covers a certain fraction of the total area
570     * @param disabled If this should be drawn with a special disabled style.
571     * @since 12285
572     */
573    public void drawArea(IWay<?> w, Color color, MapImage fillImage, Float extent, Float extentThreshold, boolean disabled) {
574        MapViewPath pfClip = null;
575        if (extent != null) {
576            if (!usePartialFill(Geometry.getAreaAndPerimeter(w.getNodes()), extent, extentThreshold)) {
577                extent = null;
578            } else if (!w.isClosed()) {
579                pfClip = shapeEastNorthToMapView(getPFClip(w, extent * scale));
580            }
581        }
582        drawArea(getPath(w), color, fillImage, extent, pfClip, disabled);
583    }
584
585    /**
586     * Determine, if partial fill should be turned off for this object, because
587     * only a small unfilled gap in the center of the area would be left.
588     *
589     * This is used to get a cleaner look for urban regions with many small
590     * areas like buildings, etc.
591     * @param ap the area and the perimeter of the object
592     * @param extent the "width" of partial fill
593     * @param threshold when the partial fill covers that much of the total
594     * area, the partial fill is turned off; can be greater than 100% as the
595     * covered area is estimated as <code>perimeter * extent</code>
596     * @return true, if the partial fill should be used, false otherwise
597     */
598    private boolean usePartialFill(AreaAndPerimeter ap, float extent, Float threshold) {
599        if (threshold == null) return true;
600        return ap.getPerimeter() * extent * scale < threshold * ap.getArea();
601    }
602
603    /**
604     * Draw a text onto a node
605     * @param n The node to draw the text on
606     * @param bs The text and it's alignment.
607     */
608    public void drawBoxText(INode n, BoxTextElement bs) {
609        if (!isShowNames() || bs == null)
610            return;
611
612        MapViewPoint p = mapState.getPointFor(n);
613        TextLabel text = bs.text;
614        String s = text.labelCompositionStrategy.compose(n);
615        if (Utils.isEmpty(s)) return;
616
617        Font defaultFont = g.getFont();
618        g.setFont(text.font);
619
620        FontRenderContext frc = g.getFontRenderContext();
621        Rectangle2D bounds = text.font.getStringBounds(s, frc);
622
623        double x = p.getInViewX() + bs.xOffset;
624        double y = p.getInViewY() + bs.yOffset;
625        /**
626         *
627         *       left-above __center-above___ right-above
628         *         left-top|                 |right-top
629         *                 |                 |
630         *      left-center|  center-center  |right-center
631         *                 |                 |
632         *      left-bottom|_________________|right-bottom
633         *       left-below   center-below    right-below
634         *
635         */
636        Rectangle box = bs.getBox();
637        if (bs.hAlign == HorizontalTextAlignment.RIGHT) {
638            x += box.x + box.width + 2;
639        } else {
640            int textWidth = (int) bounds.getWidth();
641            if (bs.hAlign == HorizontalTextAlignment.CENTER) {
642                x -= textWidth / 2d;
643            } else if (bs.hAlign == HorizontalTextAlignment.LEFT) {
644                x -= -box.x + 4 + textWidth;
645            } else throw new AssertionError();
646        }
647
648        if (bs.vAlign == VerticalTextAlignment.BOTTOM) {
649            y += box.y + box.height;
650        } else {
651            LineMetrics metrics = text.font.getLineMetrics(s, frc);
652            if (bs.vAlign == VerticalTextAlignment.ABOVE) {
653                y -= -box.y + (int) metrics.getDescent();
654            } else if (bs.vAlign == VerticalTextAlignment.TOP) {
655                y -= -box.y - (int) metrics.getAscent();
656            } else if (bs.vAlign == VerticalTextAlignment.CENTER) {
657                y += (int) ((metrics.getAscent() - metrics.getDescent()) / 2);
658            } else if (bs.vAlign == VerticalTextAlignment.BELOW) {
659                y += box.y + box.height + (int) metrics.getAscent() + 2;
660            } else throw new AssertionError();
661        }
662
663        final MapViewPoint viewPoint = mapState.getForView(x, y);
664        final AffineTransform at = new AffineTransform();
665        at.setToTranslation(
666                Math.round(viewPoint.getInViewX()),
667                Math.round(viewPoint.getInViewY()));
668        if (!RotationAngle.NO_ROTATION.equals(text.rotationAngle)) {
669            at.rotate(text.rotationAngle.getRotationAngle(n));
670        }
671        displayText(n, text, s, at);
672        g.setFont(defaultFont);
673    }
674
675    /**
676     * Draw an image along a way repeatedly.
677     *
678     * @param way the way
679     * @param pattern the image
680     * @param disabled If this should be drawn with a special disabled style.
681     * @param offset offset from the way
682     * @param spacing spacing between two images
683     * @param phase initial spacing
684     * @param opacity the opacity
685     * @param align alignment of the image. The top, center or bottom edge can be aligned with the way.
686     */
687    public void drawRepeatImage(IWay<?> way, MapImage pattern, boolean disabled, double offset, double spacing, double phase,
688                                float opacity, LineImageAlignment align) {
689        final int imgWidth = pattern.getWidth();
690        final double repeat = imgWidth + spacing;
691        final int imgHeight = pattern.getHeight();
692
693        int dy1 = (int) ((align.getAlignmentOffset() - .5) * imgHeight);
694        int dy2 = dy1 + imgHeight;
695
696        OffsetIterator it = new OffsetIterator(mapState, way.getNodes(), offset);
697        MapViewPath path = new MapViewPath(mapState);
698        if (it.hasNext()) {
699            path.moveTo(it.next());
700        }
701        while (it.hasNext()) {
702            path.lineTo(it.next());
703        }
704
705        double startOffset = computeStartOffset(phase, repeat);
706
707        Image image = pattern.getImage(disabled);
708
709        path.visitClippedLine(repeat, (inLineOffset, start, end, startIsOldEnd) -> {
710            final double segmentLength = start.distanceToInView(end);
711            if (segmentLength < 0.1) {
712                // avoid odd patterns when zoomed out.
713                return;
714            }
715            if (segmentLength > repeat * 500) {
716                // simply skip drawing so many images - something must be wrong.
717                return;
718            }
719            AffineTransform saveTransform = g.getTransform();
720            g.translate(start.getInViewX(), start.getInViewY());
721            double dx = end.getInViewX() - start.getInViewX();
722            double dy = end.getInViewY() - start.getInViewY();
723            g.rotate(Math.atan2(dy, dx));
724
725            // The start of the next image
726            // It is shifted by startOffset.
727            double imageStart = -((inLineOffset - startOffset + repeat) % repeat);
728
729            while (imageStart < segmentLength) {
730                int x = (int) imageStart;
731                int sx1 = Math.max(0, -x);
732                int sx2 = imgWidth - Math.max(0, x + imgWidth - (int) Math.ceil(segmentLength));
733                Composite saveComposite = g.getComposite();
734                g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
735                g.drawImage(image, x + sx1, dy1, x + sx2, dy2, sx1, 0, sx2, imgHeight, null);
736                g.setComposite(saveComposite);
737                imageStart += repeat;
738            }
739
740            g.setTransform(saveTransform);
741        });
742    }
743
744    private static double computeStartOffset(double phase, final double repeat) {
745        double startOffset = phase % repeat;
746        if (startOffset < 0) {
747            startOffset += repeat;
748        }
749        return startOffset;
750    }
751
752    @Override
753    public void drawNode(INode n, Color color, int size, boolean fill) {
754        if (size <= 0 && !n.isHighlighted())
755            return;
756
757        MapViewPoint p = mapState.getPointFor(n);
758
759        if (n.isHighlighted()) {
760            drawPointHighlight(p.getInView(), size);
761        }
762
763        if (size > 1 && p.isInView()) {
764            int radius = size / 2;
765
766            if (isInactiveMode || n.isDisabled()) {
767                g.setColor(inactiveColor);
768            } else {
769                g.setColor(color);
770            }
771            Rectangle2D rect = new Rectangle2D.Double(p.getInViewX()-radius-1d, p.getInViewY()-radius-1d, size + 1d, size + 1d);
772            if (fill) {
773                g.fill(rect);
774            } else {
775                g.draw(rect);
776            }
777        }
778    }
779
780    /**
781     * Draw the icon for a given node.
782     * @param n The node
783     * @param img The icon to draw at the node position
784     * @param disabled {@code} true to render disabled version, {@code false} for the standard version
785     * @param selected {@code} true to render it as selected, {@code false} otherwise
786     * @param member {@code} true to render it as a relation member, {@code false} otherwise
787     * @param theta the angle of rotation in radians
788     */
789    public void drawNodeIcon(INode n, MapImage img, boolean disabled, boolean selected, boolean member, double theta) {
790        MapViewPoint p = mapState.getPointFor(n);
791
792        int w = img.getWidth();
793        int h = img.getHeight();
794        if (n.isHighlighted()) {
795            drawPointHighlight(p.getInView(), Math.max(w, h));
796        }
797
798        drawIcon(p.getInViewX(), p.getInViewY(), img, disabled, selected, member, theta, (g, r) -> {
799            Color color = getSelectionHintColor(disabled, selected);
800            g.setColor(color);
801            g.draw(r);
802        });
803    }
804
805    /**
806     * Draw the icon for a given area. Normally, the icon is drawn around the center of the area.
807     * @param osm The primitive to draw the icon for
808     * @param img The icon to draw
809     * @param disabled {@code} true to render disabled version, {@code false} for the standard version
810     * @param selected {@code} true to render it as selected, {@code false} otherwise
811     * @param member {@code} true to render it as a relation member, {@code false} otherwise
812     * @param theta the angle of rotation in radians
813     * @param iconPosition Where to place the icon.
814     * @since 11670
815     */
816    public void drawAreaIcon(IPrimitive osm, MapImage img, boolean disabled, boolean selected, boolean member, double theta,
817            PositionForAreaStrategy iconPosition) {
818        Rectangle2D.Double iconRect = new Rectangle2D.Double(-img.getWidth() / 2.0, -img.getHeight() / 2.0, img.getWidth(), img.getHeight());
819
820        forEachPolygon(osm, path -> {
821            MapViewPositionAndRotation placement = iconPosition.findLabelPlacement(path, iconRect);
822            if (placement == null) {
823                return;
824            }
825            MapViewPoint p = placement.getPoint();
826            drawIcon(p.getInViewX(), p.getInViewY(), img, disabled, selected, member, theta + placement.getRotation(), (g, r) -> {
827                if (useStrokes) {
828                    g.setStroke(new BasicStroke(2));
829                }
830                // only draw a minor highlighting, so that users do not confuse this for a point.
831                Color color = getSelectionHintColor(disabled, selected);
832                color = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int) (color.getAlpha() * .2));
833                g.setColor(color);
834                g.draw(r);
835            });
836        });
837    }
838
839    private void drawIcon(final double x, final double y, MapImage img, boolean disabled, boolean selected, boolean member, double theta,
840            BiConsumer<Graphics2D, Rectangle2D> selectionDrawer) {
841        float alpha = img.getAlphaFloat();
842
843        Graphics2D temporaryGraphics = (Graphics2D) g.create();
844        if (!Utils.equalsEpsilon(alpha, 1f)) {
845            temporaryGraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
846        }
847
848        temporaryGraphics.translate(Math.round(x), Math.round(y));
849        temporaryGraphics.rotate(theta);
850        int drawX = -img.getWidth() / 2 + img.offsetX;
851        int drawY = -img.getHeight() / 2 + img.offsetY;
852        temporaryGraphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
853        temporaryGraphics.drawImage(img.getImage(disabled), drawX, drawY, nc);
854        if (selected || member) {
855            selectionDrawer.accept(temporaryGraphics, new Rectangle2D.Double(drawX - 2d, drawY - 2d, img.getWidth() + 4d, img.getHeight() + 4d));
856        }
857    }
858
859    private Color getSelectionHintColor(boolean disabled, boolean selected) {
860        Color color;
861        if (disabled) {
862            color = inactiveColor;
863        } else if (selected) {
864            color = selectedColor;
865        } else {
866            color = relationSelectedColor;
867        }
868        return color;
869    }
870
871    /**
872     * Draw the symbol and possibly a highlight marking on a given node.
873     * @param n The position to draw the symbol on
874     * @param s The symbol to draw
875     * @param fillColor The color to fill the symbol with
876     * @param strokeColor The color to use for the outer corner of the symbol
877     */
878    public void drawNodeSymbol(INode n, Symbol s, Color fillColor, Color strokeColor) {
879        MapViewPoint p = mapState.getPointFor(n);
880
881        if (n.isHighlighted()) {
882            drawPointHighlight(p.getInView(), s.size);
883        }
884
885        if (fillColor != null || strokeColor != null) {
886            Shape shape = s.buildShapeAround(p.getInViewX(), p.getInViewY());
887
888            if (fillColor != null) {
889                g.setColor(fillColor);
890                g.fill(shape);
891            }
892            if (s.stroke != null) {
893                g.setStroke(s.stroke);
894                g.setColor(strokeColor);
895                g.draw(shape);
896                g.setStroke(new BasicStroke());
897            }
898        }
899    }
900
901    /**
902     * Draw a number of the order of the two consecutive nodes within the
903     * parents way
904     *
905     * @param n1 First node of the way segment.
906     * @param n2 Second node of the way segment.
907     * @param orderNumber The number of the segment in the way.
908     * @param clr The color to use for drawing the text.
909     */
910    public void drawOrderNumber(INode n1, INode n2, int orderNumber, Color clr) {
911        MapViewPoint p1 = mapState.getPointFor(n1);
912        MapViewPoint p2 = mapState.getPointFor(n2);
913        drawOrderNumber(p1, p2, orderNumber, clr);
914    }
915
916    /**
917     * highlights a given GeneralPath using the settings from BasicStroke to match the line's
918     * style. Width of the highlight can be changed by user preferences
919     * @param path path to draw
920     * @param line line style
921     */
922    private void drawPathHighlight(MapViewPath path, BasicStroke line) {
923        if (path == null)
924            return;
925        g.setColor(highlightColorTransparent);
926        float w = line.getLineWidth() + HIGHLIGHT_LINE_WIDTH.get();
927        if (useWiderHighlight) {
928            w += WIDER_HIGHLIGHT.get();
929        }
930        int step = Math.max(HIGHLIGHT_STEP.get(), 1);
931        while (w >= line.getLineWidth()) {
932            g.setStroke(new BasicStroke(w, line.getEndCap(), line.getLineJoin(), line.getMiterLimit()));
933            g.draw(path);
934            w -= step;
935        }
936    }
937
938    /**
939     * highlights a given point by drawing a rounded rectangle around it. Give the
940     * size of the object you want to be highlighted, width is added automatically.
941     * @param p point
942     * @param size highlight size
943     */
944    private void drawPointHighlight(Point2D p, int size) {
945        g.setColor(highlightColorTransparent);
946        int s = size + HIGHLIGHT_POINT_RADIUS.get();
947        if (useWiderHighlight) {
948            s += WIDER_HIGHLIGHT.get();
949        }
950        int step = Math.max(HIGHLIGHT_STEP.get(), 1);
951        while (s >= size) {
952            int r = (int) Math.floor(s/2d);
953            g.fill(new RoundRectangle2D.Double(p.getX()-r, p.getY()-r, s, s, r, r));
954            s -= step;
955        }
956    }
957
958    /**
959     * Draw a turn restriction
960     * @param r The turn restriction relation
961     * @param icon The icon to draw at the turn point
962     * @param disabled draw using disabled style
963     */
964    public void drawRestriction(IRelation<?> r, MapImage icon, boolean disabled) {
965        IWay<?> fromWay = null;
966        IWay<?> toWay = null;
967        IPrimitive via = null;
968
969        /* find the "from", "via" and "to" elements */
970        for (IRelationMember<?> m : r.getMembers()) {
971            if (m.getMember().isIncomplete())
972                return;
973            else {
974                if (m.isWay()) {
975                    IWay<?> w = (IWay<?>) m.getMember();
976                    if (w.getNodesCount() < 2) {
977                        continue;
978                    }
979
980                    switch(m.getRole()) {
981                    case "from":
982                        if (fromWay == null) {
983                            fromWay = w;
984                        }
985                        break;
986                    case "to":
987                        if (toWay == null) {
988                            toWay = w;
989                        }
990                        break;
991                    case "via":
992                        if (via == null) {
993                            via = w;
994                        }
995                        break;
996                    default: // Do nothing
997                    }
998                } else if (m.isNode()) {
999                    INode n = (INode) m.getMember();
1000                    if (via == null && "via".equals(m.getRole())) {
1001                        via = n;
1002                    }
1003                }
1004            }
1005        }
1006
1007        if (fromWay == null || toWay == null || via == null)
1008            return;
1009
1010        INode viaNode;
1011        if (via instanceof INode) {
1012            viaNode = (INode) via;
1013            if (!fromWay.isFirstLastNode(viaNode))
1014                return;
1015        } else {
1016            IWay<?> viaWay = (IWay<?>) via;
1017            INode firstNode = viaWay.firstNode();
1018            INode lastNode = viaWay.lastNode();
1019            Boolean onewayvia = Boolean.FALSE;
1020
1021            String onewayviastr = viaWay.get("oneway");
1022            if (onewayviastr != null) {
1023                if ("-1".equals(onewayviastr)) {
1024                    onewayvia = Boolean.TRUE;
1025                    INode tmp = firstNode;
1026                    firstNode = lastNode;
1027                    lastNode = tmp;
1028                } else {
1029                    onewayvia = Optional.ofNullable(OsmUtils.getOsmBoolean(onewayviastr)).orElse(Boolean.FALSE);
1030                }
1031            }
1032
1033            if (fromWay.isFirstLastNode(firstNode)) {
1034                viaNode = firstNode;
1035            } else if (!onewayvia && fromWay.isFirstLastNode(lastNode)) {
1036                viaNode = lastNode;
1037            } else
1038                return;
1039        }
1040
1041        /* find the "direct" nodes before the via node */
1042        INode fromNode;
1043        if (fromWay.firstNode() == via) {
1044            fromNode = fromWay.getNode(1);
1045        } else {
1046            fromNode = fromWay.getNode(fromWay.getNodesCount()-2);
1047        }
1048
1049        Point pFrom = nc.getPoint(fromNode);
1050        Point pVia = nc.getPoint(viaNode);
1051
1052        /* starting from via, go back the "from" way a few pixels
1053           (calculate the vector vx/vy with the specified length and the direction
1054           away from the "via" node along the first segment of the "from" way)
1055         */
1056        double distanceFromVia = 14;
1057        double dx = pFrom.x >= pVia.x ? pFrom.x - pVia.x : pVia.x - pFrom.x;
1058        double dy = pFrom.y >= pVia.y ? pFrom.y - pVia.y : pVia.y - pFrom.y;
1059
1060        double fromAngle;
1061        if (dx == 0) {
1062            fromAngle = Math.PI/2;
1063        } else {
1064            fromAngle = Math.atan(dy / dx);
1065        }
1066        double fromAngleDeg = Utils.toDegrees(fromAngle);
1067
1068        double vx = distanceFromVia * Math.cos(fromAngle);
1069        double vy = distanceFromVia * Math.sin(fromAngle);
1070
1071        if (pFrom.x < pVia.x) {
1072            vx = -vx;
1073        }
1074        if (pFrom.y < pVia.y) {
1075            vy = -vy;
1076        }
1077
1078        /* go a few pixels away from the way (in a right angle)
1079           (calculate the vx2/vy2 vector with the specified length and the direction
1080           90degrees away from the first segment of the "from" way)
1081         */
1082        double distanceFromWay = 10;
1083        double vx2 = 0;
1084        double vy2 = 0;
1085        double iconAngle = 0;
1086
1087        if (pFrom.x >= pVia.x && pFrom.y >= pVia.y) {
1088            if (!leftHandTraffic) {
1089                vx2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg - 90));
1090                vy2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg - 90));
1091            } else {
1092                vx2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg + 90));
1093                vy2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg + 90));
1094            }
1095            iconAngle = 270+fromAngleDeg;
1096        }
1097        if (pFrom.x < pVia.x && pFrom.y >= pVia.y) {
1098            if (!leftHandTraffic) {
1099                vx2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg));
1100                vy2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg));
1101            } else {
1102                vx2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg + 180));
1103                vy2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg + 180));
1104            }
1105            iconAngle = 90-fromAngleDeg;
1106        }
1107        if (pFrom.x < pVia.x && pFrom.y < pVia.y) {
1108            if (!leftHandTraffic) {
1109                vx2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg + 90));
1110                vy2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg + 90));
1111            } else {
1112                vx2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg - 90));
1113                vy2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg - 90));
1114            }
1115            iconAngle = 90+fromAngleDeg;
1116        }
1117        if (pFrom.x >= pVia.x && pFrom.y < pVia.y) {
1118            if (!leftHandTraffic) {
1119                vx2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg + 180));
1120                vy2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg + 180));
1121            } else {
1122                vx2 = distanceFromWay * Math.sin(Utils.toRadians(fromAngleDeg));
1123                vy2 = distanceFromWay * Math.cos(Utils.toRadians(fromAngleDeg));
1124            }
1125            iconAngle = 270-fromAngleDeg;
1126        }
1127
1128        drawIcon(
1129                pVia.x + vx + vx2,
1130                pVia.y + vy + vy2,
1131                icon, disabled, false, false, Math.toRadians(iconAngle), (graphics2D, rectangle2D) -> {
1132                });
1133    }
1134
1135    /**
1136     * Draws a text for the given primitive
1137     * @param osm The primitive to draw the text for
1138     * @param text The text definition (font/position/.../text content) to draw
1139     * @param labelPositionStrategy The position of the text
1140     * @since 11722
1141     */
1142    public void drawText(IPrimitive osm, TextLabel text, PositionForAreaStrategy labelPositionStrategy) {
1143        if (!isShowNames()) {
1144            return;
1145        }
1146        String name = text.getString(osm);
1147        if (Utils.isEmpty(name)) {
1148            return;
1149        }
1150
1151        FontMetrics fontMetrics = g.getFontMetrics(text.font); // if slow, use cache
1152        Rectangle2D nb = fontMetrics.getStringBounds(name, g); // if slow, approximate by strlen()*maxcharbounds(font)
1153
1154        Font defaultFont = g.getFont();
1155        forEachPolygon(osm, path -> {
1156            //TODO: Ignore areas that are out of bounds.
1157            PositionForAreaStrategy position = labelPositionStrategy;
1158            MapViewPositionAndRotation center = position.findLabelPlacement(path, nb);
1159            if (center != null) {
1160                displayText(osm, text, name, nb, center);
1161            } else if (position.supportsGlyphVector()) {
1162                List<GlyphVector> gvs = Utils.getGlyphVectorsBidi(name, text.font, g.getFontRenderContext());
1163
1164                List<GlyphVector> translatedGvs = position.generateGlyphVectors(path, nb, gvs, isGlyphVectorDoubleTranslationBug(text.font));
1165                displayText(() -> translatedGvs.forEach(gv -> g.drawGlyphVector(gv, 0, 0)),
1166                        () -> translatedGvs.stream().collect(
1167                                Path2D.Double::new,
1168                                (p, gv) -> p.append(gv.getOutline(0, 0), false),
1169                                (p1, p2) -> p1.append(p2, false)),
1170                        osm.isDisabled(), text);
1171            } else {
1172                Logging.trace("Couldn't find a correct label placement for {0} / {1}", osm, name);
1173            }
1174        });
1175        g.setFont(defaultFont);
1176    }
1177
1178    private void displayText(IPrimitive osm, TextLabel text, String name, Rectangle2D nb,
1179            MapViewPositionAndRotation center) {
1180        AffineTransform at = new AffineTransform();
1181        if (Math.abs(center.getRotation()) < .01) {
1182            // Explicitly no rotation: move to full pixels.
1183            at.setToTranslation(
1184                    Math.round(center.getPoint().getInViewX() - nb.getCenterX()),
1185                    Math.round(center.getPoint().getInViewY() - nb.getCenterY()));
1186        } else {
1187            at.setToTranslation(
1188                    center.getPoint().getInViewX(),
1189                    center.getPoint().getInViewY());
1190            at.rotate(center.getRotation());
1191            at.translate(-nb.getCenterX(), -nb.getCenterY());
1192        }
1193        displayText(osm, text, name, at);
1194    }
1195
1196    private void displayText(IPrimitive osm, TextLabel text, String name, AffineTransform at) {
1197        displayText(() -> {
1198            AffineTransform defaultTransform = g.getTransform();
1199            g.transform(at);
1200            g.setFont(text.font);
1201            g.drawString(name, 0, 0);
1202            g.setTransform(defaultTransform);
1203        }, () -> {
1204            FontRenderContext frc = g.getFontRenderContext();
1205            TextLayout tl = new TextLayout(name, text.font, frc);
1206            return tl.getOutline(at);
1207        }, osm.isDisabled(), text);
1208    }
1209
1210    /**
1211     * Displays text at specified position including its halo, if applicable.
1212     *
1213     * @param fill The function that fills the text
1214     * @param outline The function to draw the outline
1215     * @param disabled {@code true} if element is disabled (filtered out)
1216     * @param text text style to use
1217     */
1218    private void displayText(Runnable fill, Supplier<Shape> outline, boolean disabled, TextLabel text) {
1219        if (isInactiveMode || disabled) {
1220            g.setColor(inactiveColor);
1221            fill.run();
1222        } else if (text.haloRadius != null) {
1223            g.setStroke(new BasicStroke(2*text.haloRadius, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND));
1224            g.setColor(text.haloColor);
1225            Shape textOutline = outline.get();
1226            g.draw(textOutline);
1227            g.setStroke(new BasicStroke());
1228            g.setColor(text.color);
1229            g.fill(textOutline);
1230        } else {
1231            g.setColor(text.color);
1232            fill.run();
1233        }
1234    }
1235
1236    /**
1237     * Calls a consumer for each path of the area shape-
1238     * @param osm A way or a multipolygon
1239     * @param consumer The consumer to call.
1240     */
1241    private void forEachPolygon(IPrimitive osm, Consumer<MapViewPath> consumer) {
1242        if (osm instanceof IWay) {
1243            consumer.accept(getPath((IWay<?>) osm));
1244        } else if (osm instanceof Relation) {
1245            Multipolygon multipolygon = MultipolygonCache.getInstance().get((Relation) osm);
1246            if (!multipolygon.getOuterWays().isEmpty()) {
1247                for (PolyData pd : multipolygon.getCombinedPolygons()) {
1248                    MapViewPath path = new MapViewPath(mapState);
1249                    path.appendFromEastNorth(pd.get());
1250                    path.setWindingRule(MapViewPath.WIND_EVEN_ODD);
1251                    consumer.accept(path);
1252                }
1253            }
1254        }
1255    }
1256
1257    /**
1258     * draw way. This method allows for two draw styles (line using color, dashes using dashedColor) to be passed.
1259     * @param way The way to draw
1260     * @param color The base color to draw the way in
1261     * @param line The line style to use. This is drawn using color.
1262     * @param dashes The dash style to use. This is drawn using dashedColor. <code>null</code> if unused.
1263     * @param dashedColor The color of the dashes.
1264     * @param offset The offset
1265     * @param showOrientation show arrows that indicate the technical orientation of
1266     *              the way (defined by order of nodes)
1267     * @param showHeadArrowOnly True if only the arrow at the end of the line but not those on the segments should be displayed.
1268     * @param showOneway show symbols that indicate the direction of the feature,
1269     *              e.g. oneway street or waterway
1270     * @param onewayReversed for oneway=-1 and similar
1271     */
1272    public void drawWay(IWay<?> way, Color color, BasicStroke line, BasicStroke dashes, Color dashedColor, float offset,
1273            boolean showOrientation, boolean showHeadArrowOnly,
1274            boolean showOneway, boolean onewayReversed) {
1275
1276        MapViewPath path = new MapViewPath(mapState);
1277        MapViewPath orientationArrows = showOrientation ? new MapViewPath(mapState) : null;
1278        MapViewPath onewayArrows;
1279        MapViewPath onewayArrowsCasing;
1280        Rectangle bounds = g.getClipBounds();
1281        if (bounds != null) {
1282            // avoid arrow heads at the border
1283            bounds.grow(100, 100);
1284        }
1285
1286        List<? extends INode> wayNodes = way.getNodes();
1287        if (wayNodes.size() < 2) return;
1288
1289        // only highlight the segment if the way itself is not highlighted
1290        if (!way.isHighlighted() && highlightWaySegments != null) {
1291            MapViewPath highlightSegs = null;
1292            for (WaySegment ws : highlightWaySegments) {
1293                if (ws.getWay() != way || ws.getLowerIndex() < offset || !ws.isUsable()) {
1294                    continue;
1295                }
1296                if (highlightSegs == null) {
1297                    highlightSegs = new MapViewPath(mapState);
1298                }
1299
1300                highlightSegs.moveTo(ws.getFirstNode());
1301                highlightSegs.lineTo(ws.getSecondNode());
1302            }
1303
1304            drawPathHighlight(highlightSegs, line);
1305        }
1306
1307        MapViewPoint lastPoint = null;
1308        Iterator<MapViewPoint> it = new OffsetIterator(mapState, wayNodes, offset);
1309        boolean initialMoveToNeeded = true;
1310        ArrowPaintHelper drawArrowHelper = null;
1311        double minSegmentLenSq = 0;
1312        if (showOrientation) {
1313            drawArrowHelper = new ArrowPaintHelper(PHI, 10 + line.getLineWidth());
1314            minSegmentLenSq = Math.pow(drawArrowHelper.getOnLineLength() * 1.3, 2);
1315        }
1316        while (it.hasNext()) {
1317            MapViewPoint p = it.next();
1318            if (lastPoint != null) {
1319                MapViewPoint p1 = lastPoint;
1320                MapViewPoint p2 = p;
1321
1322                if (initialMoveToNeeded) {
1323                    initialMoveToNeeded = false;
1324                    path.moveTo(p1);
1325                }
1326                path.lineTo(p2);
1327
1328                /* draw arrow */
1329                if (drawArrowHelper != null) {
1330                    final boolean drawArrow;
1331                    if (way.isSelected()) {
1332                        // always draw last arrow - no matter how short the segment is
1333                        drawArrow = !it.hasNext() || p1.distanceToInViewSq(p2) > minSegmentLenSq;
1334                    } else {
1335                        // not selected: only draw arrow when it fits
1336                        drawArrow = (!showHeadArrowOnly || !it.hasNext()) && p1.distanceToInViewSq(p2) > minSegmentLenSq;
1337                    }
1338                    if (drawArrow) {
1339                        drawArrowHelper.paintArrowAt(orientationArrows, p2, p1);
1340                    }
1341                }
1342            }
1343            lastPoint = p;
1344        }
1345        if (showOneway) {
1346            onewayArrows = new MapViewPath(mapState);
1347            onewayArrowsCasing = new MapViewPath(mapState);
1348            double interval = 60;
1349
1350            path.visitClippedLine(60, (inLineOffset, start, end, startIsOldEnd) -> {
1351                double segmentLength = start.distanceToInView(end);
1352                if (segmentLength > 0.001) {
1353                    final double nx = (end.getInViewX() - start.getInViewX()) / segmentLength;
1354                    final double ny = (end.getInViewY() - start.getInViewY()) / segmentLength;
1355
1356                    // distance from p1
1357                    double dist = interval - (inLineOffset % interval);
1358
1359                    while (dist < segmentLength) {
1360                        appendOnewayPath(onewayReversed, start, nx, ny, dist, 3d, onewayArrowsCasing);
1361                        appendOnewayPath(onewayReversed, start, nx, ny, dist, 2d, onewayArrows);
1362                        dist += interval;
1363                    }
1364                }
1365            });
1366        } else {
1367            onewayArrows = null;
1368            onewayArrowsCasing = null;
1369        }
1370
1371        if (way.isHighlighted()) {
1372            drawPathHighlight(path, line);
1373        }
1374        displaySegments(path, orientationArrows, onewayArrows, onewayArrowsCasing, color, line, dashes, dashedColor);
1375    }
1376
1377    private static void appendOnewayPath(boolean onewayReversed, MapViewPoint p1, double nx, double ny, double dist,
1378            double onewaySize, Path2D onewayPath) {
1379        // scale such that border is 1 px
1380        final double fac = -(onewayReversed ? -1 : 1) * onewaySize * (1 + sinPHI) / (sinPHI * cosPHI);
1381        final double sx = nx * fac;
1382        final double sy = ny * fac;
1383
1384        // Attach the triangle at the incenter and not at the tip.
1385        // Makes the border even at all sides.
1386        final double x = p1.getInViewX() + nx * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
1387        final double y = p1.getInViewY() + ny * (dist + (onewayReversed ? -1 : 1) * (onewaySize / sinPHI));
1388
1389        onewayPath.moveTo(x, y);
1390        onewayPath.lineTo(x + cosPHI * sx - sinPHI * sy, y + sinPHI * sx + cosPHI * sy);
1391        onewayPath.lineTo(x + cosPHI * sx + sinPHI * sy, y - sinPHI * sx + cosPHI * sy);
1392        onewayPath.lineTo(x, y);
1393    }
1394
1395    /**
1396     * Gets the "circum". This is the distance on the map in meters that 100 screen pixels represent.
1397     * @return The "circum"
1398     */
1399    public double getCircum() {
1400        return circum;
1401    }
1402
1403    @Override
1404    public void getColors() {
1405        super.getColors();
1406        this.highlightColorTransparent = new Color(highlightColor.getRed(), highlightColor.getGreen(), highlightColor.getBlue(), 100);
1407        this.backgroundColor = styles.getBackgroundColor();
1408    }
1409
1410    @Override
1411    public void getSettings(boolean virtual) {
1412        super.getSettings(virtual);
1413        paintSettings = MapPaintSettings.INSTANCE;
1414
1415        circum = nc.getDist100Pixel();
1416        scale = nc.getScale();
1417
1418        leftHandTraffic = PREFERENCE_LEFT_HAND_TRAFFIC.get();
1419
1420        useStrokes = paintSettings.getUseStrokesDistance() > circum;
1421        showNames = paintSettings.getShowNamesDistance() > circum;
1422        showIcons = paintSettings.getShowIconsDistance() > circum;
1423        isOutlineOnly = paintSettings.isOutlineOnly();
1424
1425        antialiasing = PREFERENCE_ANTIALIASING_USE.get() ?
1426                        RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF;
1427        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialiasing);
1428
1429        Object textAntialiasing;
1430        switch (PREFERENCE_TEXT_ANTIALIASING.get()) {
1431            case "on":
1432                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
1433                break;
1434            case "off":
1435                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
1436                break;
1437            case "gasp":
1438                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
1439                break;
1440            case "lcd-hrgb":
1441                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB;
1442                break;
1443            case "lcd-hbgr":
1444                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR;
1445                break;
1446            case "lcd-vrgb":
1447                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB;
1448                break;
1449            case "lcd-vbgr":
1450                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR;
1451                break;
1452            default:
1453                textAntialiasing = RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT;
1454        }
1455        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, textAntialiasing);
1456    }
1457
1458    private MapViewPath getPath(IWay<?> w) {
1459        MapViewPath path = new MapViewPath(mapState);
1460        if (w.isClosed()) {
1461            path.appendClosed(w.getNodes(), false);
1462        } else {
1463            path.append(w.getNodes(), false);
1464        }
1465        return path;
1466    }
1467
1468    private static Path2D.Double getPFClip(IWay<?> w, double extent) {
1469        Path2D.Double clip = new Path2D.Double();
1470        buildPFClip(clip, w.getNodes(), extent);
1471        return clip;
1472    }
1473
1474    private static Path2D.Double getPFClip(PolyData pd, double extent) {
1475        Path2D.Double clip = new Path2D.Double();
1476        clip.setWindingRule(Path2D.WIND_EVEN_ODD);
1477        buildPFClip(clip, pd.getNodes(), extent);
1478        for (PolyData pdInner : pd.getInners()) {
1479            buildPFClip(clip, pdInner.getNodes(), extent);
1480        }
1481        return clip;
1482    }
1483
1484    /**
1485     * Fix the clipping area of unclosed polygons for partial fill.
1486     *
1487     * The current algorithm for partial fill simply strokes the polygon with a
1488     * large stroke width after masking the outside with a clipping area.
1489     * This works, but for unclosed polygons, the mask can crop the corners at
1490     * both ends (see #12104).
1491     *
1492     * This method fixes the clipping area by sort of adding the corners to the
1493     * clip outline.
1494     *
1495     * @param clip the clipping area to modify (initially empty)
1496     * @param nodes nodes of the polygon
1497     * @param extent the extent
1498     */
1499    private static void buildPFClip(Path2D.Double clip, List<? extends INode> nodes, double extent) {
1500        boolean initial = true;
1501        for (INode n : nodes) {
1502            EastNorth p = n.getEastNorth();
1503            if (p != null) {
1504                if (initial) {
1505                    clip.moveTo(p.getX(), p.getY());
1506                    initial = false;
1507                } else {
1508                    clip.lineTo(p.getX(), p.getY());
1509                }
1510            }
1511        }
1512        if (nodes.size() >= 3) {
1513            EastNorth fst = nodes.get(0).getEastNorth();
1514            EastNorth snd = nodes.get(1).getEastNorth();
1515            EastNorth lst = nodes.get(nodes.size() - 1).getEastNorth();
1516            EastNorth lbo = nodes.get(nodes.size() - 2).getEastNorth();
1517
1518            EastNorth cLst = getPFDisplacedEndPoint(lbo, lst, fst, extent);
1519            EastNorth cFst = getPFDisplacedEndPoint(snd, fst, cLst != null ? cLst : lst, extent);
1520            if (cLst == null && cFst != null) {
1521                cLst = getPFDisplacedEndPoint(lbo, lst, cFst, extent);
1522            }
1523            if (cLst != null) {
1524                clip.lineTo(cLst.getX(), cLst.getY());
1525            }
1526            if (cFst != null) {
1527                clip.lineTo(cFst.getX(), cFst.getY());
1528            }
1529        }
1530    }
1531
1532    /**
1533     * Get the point to add to the clipping area for partial fill of unclosed polygons.
1534     *
1535     * <code>(p1,p2)</code> is the first or last way segment and <code>p3</code> the
1536     * opposite endpoint.
1537     *
1538     * @param p1 1st point
1539     * @param p2 2nd point
1540     * @param p3 3rd point
1541     * @param extent the extent
1542     * @return a point q, such that p1,p2,q form a right angle
1543     * and the distance of q to p2 is <code>extent</code>. The point q lies on
1544     * the same side of the line p1,p2 as the point p3.
1545     * Returns null if p1,p2,p3 forms an angle greater 90 degrees. (In this case
1546     * the corner of the partial fill would not be cut off by the mask, so an
1547     * additional point is not necessary.)
1548     */
1549    private static EastNorth getPFDisplacedEndPoint(EastNorth p1, EastNorth p2, EastNorth p3, double extent) {
1550        double dx1 = p2.getX() - p1.getX();
1551        double dy1 = p2.getY() - p1.getY();
1552        double dx2 = p3.getX() - p2.getX();
1553        double dy2 = p3.getY() - p2.getY();
1554        if (dx1 * dx2 + dy1 * dy2 < 0) {
1555            double len = Math.sqrt(dx1 * dx1 + dy1 * dy1);
1556            if (len == 0) return null;
1557            double dxm = -dy1 * extent / len;
1558            double dym = dx1 * extent / len;
1559            if (dx1 * dy2 - dx2 * dy1 < 0) {
1560                dxm = -dxm;
1561                dym = -dym;
1562            }
1563            return new EastNorth(p2.getX() + dxm, p2.getY() + dym);
1564        }
1565        return null;
1566    }
1567
1568    /**
1569     * Test if the area is visible
1570     * @param area The area, interpreted in east/north space.
1571     * @return true if it is visible.
1572     */
1573    private boolean isAreaVisible(Path2D.Double area) {
1574        Rectangle2D bounds = area.getBounds2D();
1575        if (bounds.isEmpty()) return false;
1576        MapViewPoint p = mapState.getPointFor(new EastNorth(bounds.getX(), bounds.getY()));
1577        if (p.getInViewY() < 0 || p.getInViewX() > mapState.getViewWidth()) return false;
1578        p = mapState.getPointFor(new EastNorth(bounds.getX() + bounds.getWidth(), bounds.getY() + bounds.getHeight()));
1579        return p.getInViewX() >= 0 && p.getInViewY() <= mapState.getViewHeight();
1580    }
1581
1582    /**
1583     * Determines if the paint visitor shall render OSM objects such that they look inactive.
1584     * @return {@code true} if the paint visitor shall render OSM objects such that they look inactive
1585     */
1586    public boolean isInactiveMode() {
1587        return isInactiveMode;
1588    }
1589
1590    /**
1591     * Check if icons should be rendered
1592     * @return <code>true</code> to display icons
1593     */
1594    public boolean isShowIcons() {
1595        return showIcons;
1596    }
1597
1598    /**
1599     * Test if names should be rendered
1600     * @return <code>true</code> to display names
1601     */
1602    public boolean isShowNames() {
1603        return showNames && doSlowOperations;
1604    }
1605
1606    /**
1607     * Computes the flags for a given OSM primitive.
1608     * @param primitive The primititve to compute the flags for.
1609     * @param checkOuterMember <code>true</code> if we should also add {@link #FLAG_OUTERMEMBER_OF_SELECTED}
1610     * @return The flag.
1611     * @since 13676 (signature)
1612     */
1613    public static int computeFlags(IPrimitive primitive, boolean checkOuterMember) {
1614        if (primitive.isDisabled()) {
1615            return FLAG_DISABLED;
1616        } else if (primitive.isSelected()) {
1617            return FLAG_SELECTED;
1618        } else if (checkOuterMember && primitive.isOuterMemberOfSelected()) {
1619            return FLAG_OUTERMEMBER_OF_SELECTED;
1620        } else if (primitive.isMemberOfSelected()) {
1621            return FLAG_MEMBER_OF_SELECTED;
1622        } else {
1623            return FLAG_NORMAL;
1624        }
1625    }
1626
1627    /**
1628     * Sets the factory that creates the benchmark data receivers.
1629     * @param benchmarkFactory The factory.
1630     * @since 10697
1631     */
1632    public void setBenchmarkFactory(Supplier<RenderBenchmarkCollector> benchmarkFactory) {
1633        this.benchmarkFactory = benchmarkFactory;
1634    }
1635
1636    @Override
1637    public void render(final OsmData<?, ?, ?, ?> data, boolean renderVirtualNodes, Bounds bounds) {
1638        RenderBenchmarkCollector benchmark = benchmarkFactory.get();
1639        BBox bbox = bounds.toBBox();
1640        getSettings(renderVirtualNodes);
1641        try {
1642            Lock readLock = data.getReadLock();
1643            if (readLock.tryLock(1, TimeUnit.SECONDS)) {
1644                try {
1645                    paintWithLock(data, renderVirtualNodes, benchmark, bbox);
1646                } finally {
1647                    readLock.unlock();
1648                }
1649            } else {
1650                Logging.warn("Cannot paint layer {0}: It is locked.");
1651            }
1652        } catch (InterruptedException e) {
1653            Logging.warn("Cannot paint layer {0}: Interrupted");
1654        }
1655    }
1656
1657    private void paintWithLock(final OsmData<?, ?, ?, ?> data, boolean renderVirtualNodes, RenderBenchmarkCollector benchmark,
1658            BBox bbox) {
1659        try {
1660            highlightWaySegments = data.getHighlightedWaySegments();
1661
1662            benchmark.renderStart(circum);
1663
1664            List<? extends INode> nodes = data.searchNodes(bbox);
1665            List<? extends IWay<?>> ways = data.searchWays(bbox);
1666            List<? extends IRelation<?>> relations = data.searchRelations(bbox);
1667
1668            final List<StyleRecord> allStyleElems = new ArrayList<>(nodes.size()+ways.size()+relations.size());
1669
1670            // Need to process all relations first.
1671            // Reason: Make sure, ElemStyles.getStyleCacheWithRange is not called for the same primitive in parallel threads.
1672            // (Could be synchronized, but try to avoid this for performance reasons.)
1673            if (THREAD_POOL != null) {
1674                THREAD_POOL.invoke(new ComputeStyleListWorker(circum, nc, relations, allStyleElems,
1675                        Math.max(20, relations.size() / THREAD_POOL.getParallelism() / 3), styles));
1676                THREAD_POOL.invoke(new ComputeStyleListWorker(circum, nc, new CompositeList<>(nodes, ways), allStyleElems,
1677                        Math.max(100, (nodes.size() + ways.size()) / THREAD_POOL.getParallelism() / 3), styles));
1678            } else {
1679                new ComputeStyleListWorker(circum, nc, relations, allStyleElems, 0, styles).computeDirectly();
1680                new ComputeStyleListWorker(circum, nc, new CompositeList<>(nodes, ways), allStyleElems, 0, styles).computeDirectly();
1681            }
1682
1683            if (!benchmark.renderSort()) {
1684                return;
1685            }
1686
1687            // We use parallel sort here. This is only available for arrays.
1688            StyleRecord[] sorted = allStyleElems.toArray(new StyleRecord[0]);
1689            Arrays.parallelSort(sorted, null);
1690
1691            if (!benchmark.renderDraw(allStyleElems)) {
1692                return;
1693            }
1694
1695            for (StyleRecord record : sorted) {
1696                paintRecord(record);
1697            }
1698
1699            drawVirtualNodes(data, bbox);
1700
1701            benchmark.renderDone();
1702        } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
1703            throw BugReport.intercept(e)
1704                    .put("data", data)
1705                    .put("circum", circum)
1706                    .put("scale", scale)
1707                    .put("paintSettings", paintSettings)
1708                    .put("renderVirtualNodes", renderVirtualNodes);
1709        }
1710    }
1711
1712    private void paintRecord(StyleRecord record) {
1713        try {
1714            record.paintPrimitive(paintSettings, this);
1715        } catch (RuntimeException e) {
1716            throw BugReport.intercept(e).put("record", record);
1717        }
1718    }
1719}