source: josm/trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java @ 12841

Last change on this file since 12841 was 12841, checked in by bastiK, 5 weeks ago

see #15229 - fix deprecations caused by [12840]

  • Property svn:eol-style set to native
File size: 60.2 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.layer.gpx;
3
4import static org.openstreetmap.josm.tools.I18n.marktr;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.AlphaComposite;
8import java.awt.BasicStroke;
9import java.awt.Color;
10import java.awt.Composite;
11import java.awt.Graphics2D;
12import java.awt.LinearGradientPaint;
13import java.awt.MultipleGradientPaint;
14import java.awt.Paint;
15import java.awt.Point;
16import java.awt.Rectangle;
17import java.awt.RenderingHints;
18import java.awt.Stroke;
19import java.awt.image.BufferedImage;
20import java.awt.image.DataBufferInt;
21import java.awt.image.Raster;
22import java.io.BufferedReader;
23import java.io.IOException;
24import java.util.ArrayList;
25import java.util.Arrays;
26import java.util.Collection;
27import java.util.Collections;
28import java.util.Date;
29import java.util.LinkedList;
30import java.util.List;
31import java.util.Random;
32
33import javax.swing.ImageIcon;
34
35import org.openstreetmap.josm.Main;
36import org.openstreetmap.josm.data.Bounds;
37import org.openstreetmap.josm.data.SystemOfMeasurement;
38import org.openstreetmap.josm.data.SystemOfMeasurement.SoMChangeListener;
39import org.openstreetmap.josm.data.coor.LatLon;
40import org.openstreetmap.josm.data.gpx.GpxConstants;
41import org.openstreetmap.josm.data.gpx.GpxData;
42import org.openstreetmap.josm.data.gpx.GpxData.GpxDataChangeEvent;
43import org.openstreetmap.josm.data.gpx.GpxData.GpxDataChangeListener;
44import org.openstreetmap.josm.data.gpx.WayPoint;
45import org.openstreetmap.josm.data.preferences.ColorProperty;
46import org.openstreetmap.josm.gui.MapView;
47import org.openstreetmap.josm.gui.MapViewState;
48import org.openstreetmap.josm.gui.layer.GpxLayer;
49import org.openstreetmap.josm.gui.layer.MapViewGraphics;
50import org.openstreetmap.josm.gui.layer.MapViewPaintable;
51import org.openstreetmap.josm.gui.layer.MapViewPaintable.MapViewEvent;
52import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationEvent;
53import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationListener;
54import org.openstreetmap.josm.io.CachedFile;
55import org.openstreetmap.josm.tools.ColorScale;
56import org.openstreetmap.josm.tools.JosmRuntimeException;
57import org.openstreetmap.josm.tools.Logging;
58import org.openstreetmap.josm.tools.Utils;
59
60/**
61 * Class that helps to draw large set of GPS tracks with different colors and options
62 * @since 7319
63 */
64public class GpxDrawHelper implements SoMChangeListener, MapViewPaintable.LayerPainter, PaintableInvalidationListener, GpxDataChangeListener {
65
66    /**
67     * The color that is used for drawing GPX points.
68     * @since 10824
69     */
70    public static final ColorProperty DEFAULT_COLOR = new ColorProperty(marktr("gps point"), Color.magenta);
71
72    private final GpxData data;
73    private final GpxLayer layer;
74
75    // draw lines between points belonging to different segments
76    private boolean forceLines;
77    // use alpha blending for line draw
78    private boolean alphaLines;
79    // draw direction arrows on the lines
80    private boolean direction;
81    /** width of line for paint **/
82    private int lineWidth;
83    /** don't draw lines if longer than x meters **/
84    private int maxLineLength;
85    // draw lines
86    private boolean lines;
87    /** paint large dots for points **/
88    private boolean large;
89    private int largesize;
90    private boolean hdopCircle;
91    /** paint direction arrow with alternate math. may be faster **/
92    private boolean alternateDirection;
93    /** don't draw arrows nearer to each other than this **/
94    private int delta;
95    private double minTrackDurationForTimeColoring;
96
97    /** maximum value of displayed HDOP, minimum is 0 */
98    private int hdoprange;
99
100    private static final double PHI = Utils.toRadians(15);
101
102    //// Variables used only to check cache validity
103    private boolean computeCacheInSync;
104    private int computeCacheMaxLineLengthUsed;
105    private Color computeCacheColorUsed;
106    private boolean computeCacheColorDynamic;
107    private ColorMode computeCacheColored;
108    private int computeCacheColorTracksTune;
109    private int computeCacheHeatMapDrawColorTableIdx;
110    private boolean computeCacheHeatMapDrawPointMode;
111    private int computeCacheHeatMapDrawGain;
112    private int computeCacheHeatMapDrawLowerLimit;
113
114    //// Color-related fields
115    /** Mode of the line coloring **/
116    private ColorMode colored;
117    /** max speed for coloring - allows to tweak line coloring for different speed levels. **/
118    private int colorTracksTune;
119    private boolean colorModeDynamic;
120    private Color neutralColor;
121    private int largePointAlpha;
122
123    // default access is used to allow changing from plugins
124    private ColorScale velocityScale;
125    /** Colors (without custom alpha channel, if given) for HDOP painting. **/
126    private ColorScale hdopScale;
127    private ColorScale dateScale;
128    private ColorScale directionScale;
129
130    /** Opacity for hdop points **/
131    private int hdopAlpha;
132
133    // lookup array to draw arrows without doing any math
134    private static final int ll0 = 9;
135    private static final int sl4 = 5;
136    private static final int sl9 = 3;
137    private static final int[][] dir = {
138        {+sl4, +ll0, +ll0, +sl4}, {-sl9, +ll0, +sl9, +ll0},
139        {-ll0, +sl4, -sl4, +ll0}, {-ll0, -sl9, -ll0, +sl9},
140        {-sl4, -ll0, -ll0, -sl4}, {+sl9, -ll0, -sl9, -ll0},
141        {+ll0, -sl4, +sl4, -ll0}, {+ll0, +sl9, +ll0, -sl9}
142    };
143
144    /** heat map parameters **/
145
146    // enabled or not (override by settings)
147    private boolean heatMapEnabled;
148    // draw small extra line
149    private boolean heatMapDrawExtraLine;
150    // used index for color table (parameter)
151    private int heatMapDrawColorTableIdx;
152    // use point or line draw mode
153    private boolean heatMapDrawPointMode;
154    // extra gain > 0 or < 0 attenuation, 0 = default
155    private int heatMapDrawGain;
156    // do not draw elements with value lower than this limit
157    private int heatMapDrawLowerLimit;
158
159    // normal buffered image and draw object (cached)
160    private BufferedImage heatMapImgGray;
161    private Graphics2D heatMapGraph2d;
162
163    // some cached values
164    Rectangle heatMapCacheScreenBounds = new Rectangle();
165    MapViewState heatMapMapViewState;
166    int heatMapCacheLineWith;
167
168    // copied value for line drawing
169    private final List<Integer> heatMapPolyX = new ArrayList<>();
170    private final List<Integer> heatMapPolyY = new ArrayList<>();
171
172    // setup color maps used by heat map
173    private static Color[] heatMapLutColorJosmInferno = createColorFromResource("inferno");
174    private static Color[] heatMapLutColorJosmViridis = createColorFromResource("viridis");
175    private static Color[] heatMapLutColorJosmBrown2Green = createColorFromResource("brown2green");
176    private static Color[] heatMapLutColorJosmRed2Blue = createColorFromResource("red2blue");
177
178    // user defined heatmap color
179    private Color[] heatMapLutColor = createColorLut(0, Color.BLACK, Color.WHITE);
180
181    // The heat map was invalidated since the last draw.
182    private boolean gpxLayerInvalidated;
183
184    private void setupColors() {
185        hdopAlpha = Main.pref.getInt("hdop.color.alpha", -1);
186        velocityScale = ColorScale.createHSBScale(256);
187        /** Colors (without custom alpha channel, if given) for HDOP painting. **/
188        hdopScale = ColorScale.createHSBScale(256).makeReversed().addTitle(tr("HDOP"));
189        dateScale = ColorScale.createHSBScale(256).addTitle(tr("Time"));
190        directionScale = ColorScale.createCyclicScale(256).setIntervalCount(4).addTitle(tr("Direction"));
191
192        systemOfMeasurementChanged(null, null);
193    }
194
195    @Override
196    public void systemOfMeasurementChanged(String oldSoM, String newSoM) {
197        SystemOfMeasurement som = SystemOfMeasurement.getSystemOfMeasurement();
198        velocityScale.addTitle(tr("Velocity, {0}", som.speedName));
199        layer.invalidate();
200    }
201
202    /**
203     * Different color modes
204     */
205    public enum ColorMode {
206        /**
207         * No special colors
208         */
209        NONE,
210        /**
211         * Color by velocity
212         */
213        VELOCITY,
214        /**
215         * Color by accuracy
216         */
217        HDOP,
218        /**
219         * Color by traveling direction
220         */
221        DIRECTION,
222        /**
223         * Color by time
224         */
225        TIME,
226        /**
227         * Color using a heatmap instead of normal lines
228         */
229        HEATMAP;
230
231        static ColorMode fromIndex(final int index) {
232            return values()[index];
233        }
234
235        int toIndex() {
236            return Arrays.asList(values()).indexOf(this);
237        }
238    }
239
240    /**
241     * Constructs a new {@code GpxDrawHelper}.
242     * @param gpxLayer The layer to draw
243     * @since 12157
244     */
245    public GpxDrawHelper(GpxLayer gpxLayer) {
246        layer = gpxLayer;
247        data = gpxLayer.data;
248        data.addChangeListener(this);
249
250        layer.addInvalidationListener(this);
251        SystemOfMeasurement.addSoMChangeListener(this);
252        setupColors();
253    }
254
255    private static String specName(String layerName) {
256        return "layer " + layerName;
257    }
258
259    /**
260     * Get the default color for gps tracks for specified layer
261     * @param layerName name of the GpxLayer
262     * @param ignoreCustom do not use preferences
263     * @return the color or null if the color is not constant
264     */
265    public Color getColor(String layerName, boolean ignoreCustom) {
266        if (ignoreCustom || getColorMode(layerName) == ColorMode.NONE) {
267            return DEFAULT_COLOR.getChildColor(specName(layerName)).get();
268        } else {
269            return null;
270        }
271    }
272
273    /**
274     * Read coloring mode for specified layer from preferences
275     * @param layerName name of the GpxLayer
276     * @return coloring mode
277     */
278    public ColorMode getColorMode(String layerName) {
279        try {
280            int i = Main.pref.getInteger("draw.rawgps.colors", specName(layerName), 0);
281            return ColorMode.fromIndex(i);
282        } catch (IndexOutOfBoundsException e) {
283            Logging.warn(e);
284        }
285        return ColorMode.NONE;
286    }
287
288    /** Reads generic color from preferences (usually gray)
289     * @return the color
290     **/
291    public static Color getGenericColor() {
292        return DEFAULT_COLOR.get();
293    }
294
295    /**
296     * Read all drawing-related settings from preferences
297     * @param layerName layer name used to access its specific preferences
298     **/
299    public void readPreferences(String layerName) {
300        String spec = specName(layerName);
301        forceLines = Main.pref.getBoolean("draw.rawgps.lines.force", spec, false);
302        direction = Main.pref.getBoolean("draw.rawgps.direction", spec, false);
303        lineWidth = Main.pref.getInteger("draw.rawgps.linewidth", spec, 0);
304        alphaLines = Main.pref.getBoolean("draw.rawgps.lines.alpha-blend", spec, false);
305
306        if (!data.fromServer) {
307            maxLineLength = Main.pref.getInteger("draw.rawgps.max-line-length.local", spec, -1);
308            lines = Main.pref.getBoolean("draw.rawgps.lines.local", spec, true);
309        } else {
310            maxLineLength = Main.pref.getInteger("draw.rawgps.max-line-length", spec, 200);
311            lines = Main.pref.getBoolean("draw.rawgps.lines", spec, true);
312        }
313        large = Main.pref.getBoolean("draw.rawgps.large", spec, false);
314        largesize = Main.pref.getInteger("draw.rawgps.large.size", spec, 3);
315        hdopCircle = Main.pref.getBoolean("draw.rawgps.hdopcircle", spec, false);
316        colored = getColorMode(layerName);
317        alternateDirection = Main.pref.getBoolean("draw.rawgps.alternatedirection", spec, false);
318        delta = Main.pref.getInteger("draw.rawgps.min-arrow-distance", spec, 40);
319        colorTracksTune = Main.pref.getInteger("draw.rawgps.colorTracksTune", spec, 45);
320        colorModeDynamic = Main.pref.getBoolean("draw.rawgps.colors.dynamic", spec, false);
321        /* good HDOP's are between 1 and 3, very bad HDOP's go into 3 digit values */
322        hdoprange = Main.pref.getInt("hdop.range", 7);
323        minTrackDurationForTimeColoring = Main.pref.getInt("draw.rawgps.date-coloring-min-dt", 60);
324        largePointAlpha = Main.pref.getInt("draw.rawgps.large.alpha", -1) & 0xFF;
325
326        // get heatmap parameters
327        heatMapEnabled = Main.pref.getBoolean("draw.rawgps.heatmap.enabled", spec, false);
328        heatMapDrawExtraLine = Main.pref.getBoolean("draw.rawgps.heatmap.line-extra", spec, false);
329        heatMapDrawColorTableIdx = Main.pref.getInteger("draw.rawgps.heatmap.colormap", spec, 0);
330        heatMapDrawPointMode = Main.pref.getBoolean("draw.rawgps.heatmap.use-points", spec, false);
331        heatMapDrawGain = Main.pref.getInteger("draw.rawgps.heatmap.gain", spec, 0);
332        heatMapDrawLowerLimit = Main.pref.getInteger("draw.rawgps.heatmap.lower-limit", spec, 0);
333
334        // shrink to range
335        heatMapDrawGain = Utils.clamp(heatMapDrawGain, -10, 10);
336
337        neutralColor = getColor(layerName, true);
338        velocityScale.setNoDataColor(neutralColor);
339        dateScale.setNoDataColor(neutralColor);
340        hdopScale.setNoDataColor(neutralColor);
341        directionScale.setNoDataColor(neutralColor);
342
343        largesize += lineWidth;
344    }
345
346    @Override
347    public void paint(MapViewGraphics graphics) {
348        List<WayPoint> visibleSegments = listVisibleSegments(graphics.getClipBounds().getLatLonBoundsBox());
349        if (!visibleSegments.isEmpty()) {
350            readPreferences(layer.getName());
351            drawAll(graphics.getDefaultGraphics(), graphics.getMapView(), visibleSegments);
352            if (graphics.getMapView().getLayerManager().getActiveLayer() == layer) {
353                drawColorBar(graphics.getDefaultGraphics(), graphics.getMapView());
354            }
355        }
356    }
357
358    private List<WayPoint> listVisibleSegments(Bounds box) {
359        WayPoint last = null;
360        LinkedList<WayPoint> visibleSegments = new LinkedList<>();
361
362        ensureTrackVisibilityLength();
363        for (Collection<WayPoint> segment : data.getLinesIterable(layer.trackVisibility)) {
364
365            for (WayPoint pt : segment) {
366                Bounds b = new Bounds(pt.getCoor());
367                if (pt.drawLine && last != null) {
368                    b.extend(last.getCoor());
369                }
370                if (b.intersects(box)) {
371                    if (last != null && (visibleSegments.isEmpty()
372                            || visibleSegments.getLast() != last)) {
373                        if (last.drawLine) {
374                            WayPoint l = new WayPoint(last);
375                            l.drawLine = false;
376                            visibleSegments.add(l);
377                        } else {
378                            visibleSegments.add(last);
379                        }
380                    }
381                    visibleSegments.add(pt);
382                }
383                last = pt;
384            }
385        }
386        return visibleSegments;
387    }
388
389    /** ensures the trackVisibility array has the correct length without losing data.
390     * TODO: Make this nicer by syncing the trackVisibility automatically.
391     * additional entries are initialized to true;
392     */
393    private void ensureTrackVisibilityLength() {
394        final int l = data.getTracks().size();
395        if (l == layer.trackVisibility.length)
396            return;
397        final int m = Math.min(l, layer.trackVisibility.length);
398        layer.trackVisibility = Arrays.copyOf(layer.trackVisibility, l);
399        for (int i = m; i < l; i++) {
400            layer.trackVisibility[i] = true;
401        }
402    }
403
404    /**
405     * Draw all enabled GPX elements of layer.
406     * @param g               the common draw object to use
407     * @param mv              the meta data to current displayed area
408     * @param visibleSegments segments visible in the current scope of mv
409     */
410    public void drawAll(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
411
412        final long timeStart = System.currentTimeMillis();
413
414        checkCache();
415
416        // STEP 2b - RE-COMPUTE CACHE DATA *********************
417        if (!computeCacheInSync) { // don't compute if the cache is good
418            calculateColors();
419        }
420
421        fixColors(visibleSegments);
422
423        // backup the environment
424        Composite oldComposite = g.getComposite();
425        Stroke oldStroke = g.getStroke();
426        Paint oldPaint = g.getPaint();
427
428        // set hints for the render
429        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
430            Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false) ?
431                    RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
432
433        if (lineWidth != 0) {
434            g.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
435        }
436
437        // global enabled or select via color
438        boolean useHeatMap = heatMapEnabled || ColorMode.HEATMAP == colored;
439
440        // default global alpha level
441        float layerAlpha = 1.00f;
442
443        // extract current alpha blending value
444        if (oldComposite instanceof AlphaComposite) {
445            layerAlpha = ((AlphaComposite) oldComposite).getAlpha();
446        }
447
448        // use heatmap background layer
449        if (useHeatMap) {
450            drawHeatMap(g, mv, visibleSegments);
451        } else {
452            // use normal line style or alpha-blending lines
453            if (!alphaLines) {
454                drawLines(g, mv, visibleSegments);
455            } else {
456                drawLinesAlpha(g, mv, visibleSegments, layerAlpha);
457            }
458        }
459
460        // override global alpha settings (smooth overlay)
461        if (alphaLines || useHeatMap) {
462            g.setComposite(AlphaComposite.SrcOver.derive(0.25f * layerAlpha));
463        }
464
465        // normal overlays
466        drawArrows(g, mv, visibleSegments);
467        drawPoints(g, mv, visibleSegments);
468
469        // restore environment
470        g.setPaint(oldPaint);
471        g.setStroke(oldStroke);
472        g.setComposite(oldComposite);
473
474        // show some debug info
475        if (Logging.isDebugEnabled() && !visibleSegments.isEmpty()) {
476            final long timeDiff = System.currentTimeMillis() - timeStart;
477
478            Logging.debug("gpxdraw::draw takes " +
479                         Utils.getDurationString(timeDiff) +
480                         "(" +
481                         "segments= " + visibleSegments.size() +
482                         ", per 10000 = " + Utils.getDurationString(10_000 * timeDiff / visibleSegments.size()) +
483                         ")"
484              );
485        }
486    }
487
488    /**
489     *  Calculate colors of way segments based on latest configuration settings
490     */
491    public void calculateColors() {
492        double minval = +1e10;
493        double maxval = -1e10;
494        WayPoint oldWp = null;
495
496        if (colorModeDynamic) {
497            if (colored == ColorMode.VELOCITY) {
498                final List<Double> velocities = new ArrayList<>();
499                for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
500                    if (!forceLines) {
501                        oldWp = null;
502                    }
503                    for (WayPoint trkPnt : segment) {
504                        if (!trkPnt.isLatLonKnown()) {
505                            continue;
506                        }
507                        if (oldWp != null && trkPnt.time > oldWp.time) {
508                            double vel = trkPnt.getCoor().greatCircleDistance(oldWp.getCoor())
509                                    / (trkPnt.time - oldWp.time);
510                            velocities.add(vel);
511                        }
512                        oldWp = trkPnt;
513                    }
514                }
515                Collections.sort(velocities);
516                if (velocities.isEmpty()) {
517                    velocityScale.setRange(0, 120/3.6);
518                } else {
519                    minval = velocities.get(velocities.size() / 20); // 5% percentile to remove outliers
520                    maxval = velocities.get(velocities.size() * 19 / 20); // 95% percentile to remove outliers
521                    velocityScale.setRange(minval, maxval);
522                }
523            } else if (colored == ColorMode.HDOP) {
524                for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
525                    for (WayPoint trkPnt : segment) {
526                        Object val = trkPnt.get(GpxConstants.PT_HDOP);
527                        if (val != null) {
528                            double hdop = ((Float) val).doubleValue();
529                            if (hdop > maxval) {
530                                maxval = hdop;
531                            }
532                            if (hdop < minval) {
533                                minval = hdop;
534                            }
535                        }
536                    }
537                }
538                if (minval >= maxval) {
539                    hdopScale.setRange(0, 100);
540                } else {
541                    hdopScale.setRange(minval, maxval);
542                }
543            }
544            oldWp = null;
545        } else { // color mode not dynamic
546            velocityScale.setRange(0, colorTracksTune);
547            hdopScale.setRange(0, hdoprange);
548        }
549        double now = System.currentTimeMillis()/1000.0;
550        if (colored == ColorMode.TIME) {
551            Date[] bounds = data.getMinMaxTimeForAllTracks();
552            if (bounds.length >= 2) {
553                minval = bounds[0].getTime()/1000.0;
554                maxval = bounds[1].getTime()/1000.0;
555            } else {
556                minval = 0;
557                maxval = now;
558            }
559            dateScale.setRange(minval, maxval);
560        }
561
562        // Now the colors for all the points will be assigned
563        for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
564            if (!forceLines) { // don't draw lines between segments, unless forced to
565                oldWp = null;
566            }
567            for (WayPoint trkPnt : segment) {
568                LatLon c = trkPnt.getCoor();
569                trkPnt.customColoring = neutralColor;
570                if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
571                    continue;
572                }
573                // now we are sure some color will be assigned
574                Color color = null;
575
576                if (colored == ColorMode.HDOP) {
577                    Float hdop = (Float) trkPnt.get(GpxConstants.PT_HDOP);
578                    color = hdopScale.getColor(hdop);
579                }
580                if (oldWp != null) { // other coloring modes need segment for calcuation
581                    double dist = c.greatCircleDistance(oldWp.getCoor());
582                    boolean noDraw = false;
583                    switch (colored) {
584                    case VELOCITY:
585                        double dtime = trkPnt.time - oldWp.time;
586                        if (dtime > 0) {
587                            color = velocityScale.getColor(dist / dtime);
588                        } else {
589                            color = velocityScale.getNoDataColor();
590                        }
591                        break;
592                    case DIRECTION:
593                        double dirColor = oldWp.getCoor().bearing(trkPnt.getCoor());
594                        color = directionScale.getColor(dirColor);
595                        break;
596                    case TIME:
597                        double t = trkPnt.time;
598                        // skip bad timestamps and very short tracks
599                        if (t > 0 && t <= now && maxval - minval > minTrackDurationForTimeColoring) {
600                            color = dateScale.getColor(t);
601                        } else {
602                            color = dateScale.getNoDataColor();
603                        }
604                        break;
605                    default: // Do nothing
606                    }
607                    if (!noDraw && (maxLineLength == -1 || dist <= maxLineLength)) {
608                        trkPnt.drawLine = true;
609                        double bearing = oldWp.getCoor().bearing(trkPnt.getCoor());
610                        trkPnt.dir = ((int) (bearing / Math.PI * 4 + 1.5)) % 8;
611                    } else {
612                        trkPnt.drawLine = false;
613                    }
614                } else { // make sure we reset outdated data
615                    trkPnt.drawLine = false;
616                    color = neutralColor;
617                }
618                if (color != null) {
619                    trkPnt.customColoring = color;
620                }
621                oldWp = trkPnt;
622            }
623        }
624
625        // heat mode
626        if (ColorMode.HEATMAP == colored) {
627
628            // get new user color map and refresh visibility level
629            heatMapLutColor = createColorLut(heatMapDrawLowerLimit,
630                                             selectColorMap(neutralColor != null ? neutralColor : Color.WHITE, heatMapDrawColorTableIdx));
631
632            // force redraw of image
633            heatMapMapViewState = null;
634        }
635
636        computeCacheInSync = true;
637    }
638
639    /**
640     * Draw all GPX ways segments
641     * @param g               the common draw object to use
642     * @param mv              the meta data to current displayed area
643     * @param visibleSegments segments visible in the current scope of mv
644     */
645    private void drawLines(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
646        if (lines) {
647            Point old = null;
648            for (WayPoint trkPnt : visibleSegments) {
649                if (!trkPnt.isLatLonKnown()) {
650                    old = null;
651                    continue;
652                }
653                Point screen = mv.getPoint(trkPnt);
654                // skip points that are on the same screenposition
655                if (trkPnt.drawLine && old != null && ((old.x != screen.x) || (old.y != screen.y))) {
656                    g.setColor(trkPnt.customColoring);
657                    g.drawLine(old.x, old.y, screen.x, screen.y);
658                }
659                old = screen;
660            }
661        }
662    }
663
664    /**
665     * Draw all GPX arrays
666     * @param g               the common draw object to use
667     * @param mv              the meta data to current displayed area
668     * @param visibleSegments segments visible in the current scope of mv
669     */
670    private void drawArrows(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
671        /****************************************************************
672         ********** STEP 3b - DRAW NICE ARROWS **************************
673         ****************************************************************/
674        if (lines && direction && !alternateDirection) {
675            Point old = null;
676            Point oldA = null; // last arrow painted
677            for (WayPoint trkPnt : visibleSegments) {
678                if (!trkPnt.isLatLonKnown()) {
679                    old = null;
680                    continue;
681                }
682                if (trkPnt.drawLine) {
683                    Point screen = mv.getPoint(trkPnt);
684                    // skip points that are on the same screenposition
685                    if (old != null
686                            && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta
687                            || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) {
688                        g.setColor(trkPnt.customColoring);
689                        double t = Math.atan2((double) screen.y - old.y, (double) screen.x - old.x) + Math.PI;
690                        g.drawLine(screen.x, screen.y, (int) (screen.x + 10 * Math.cos(t - PHI)),
691                                (int) (screen.y + 10 * Math.sin(t - PHI)));
692                        g.drawLine(screen.x, screen.y, (int) (screen.x + 10 * Math.cos(t + PHI)),
693                                (int) (screen.y + 10 * Math.sin(t + PHI)));
694                        oldA = screen;
695                    }
696                    old = screen;
697                }
698            } // end for trkpnt
699        }
700
701        /****************************************************************
702         ********** STEP 3c - DRAW FAST ARROWS **************************
703         ****************************************************************/
704        if (lines && direction && alternateDirection) {
705            Point old = null;
706            Point oldA = null; // last arrow painted
707            for (WayPoint trkPnt : visibleSegments) {
708                LatLon c = trkPnt.getCoor();
709                if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
710                    continue;
711                }
712                if (trkPnt.drawLine) {
713                    Point screen = mv.getPoint(trkPnt);
714                    // skip points that are on the same screenposition
715                    if (old != null
716                            && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta
717                            || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) {
718                        g.setColor(trkPnt.customColoring);
719                        g.drawLine(screen.x, screen.y, screen.x + dir[trkPnt.dir][0], screen.y
720                                + dir[trkPnt.dir][1]);
721                        g.drawLine(screen.x, screen.y, screen.x + dir[trkPnt.dir][2], screen.y
722                                + dir[trkPnt.dir][3]);
723                        oldA = screen;
724                    }
725                    old = screen;
726                }
727            } // end for trkpnt
728        }
729    }
730
731    /**
732     * Draw all GPX points
733     * @param g               the common draw object to use
734     * @param mv              the meta data to current displayed area
735     * @param visibleSegments segments visible in the current scope of mv
736     */
737    private void drawPoints(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
738        /****************************************************************
739         ********** STEP 3d - DRAW LARGE POINTS AND HDOP CIRCLE *********
740         ****************************************************************/
741        if (large || hdopCircle) {
742            final int halfSize = largesize/2;
743            for (WayPoint trkPnt : visibleSegments) {
744                LatLon c = trkPnt.getCoor();
745                if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
746                    continue;
747                }
748                Point screen = mv.getPoint(trkPnt);
749
750                if (hdopCircle && trkPnt.get(GpxConstants.PT_HDOP) != null) {
751                    // hdop value
752                    float hdop = (Float) trkPnt.get(GpxConstants.PT_HDOP);
753                    if (hdop < 0) {
754                        hdop = 0;
755                    }
756                    Color customColoringTransparent = hdopAlpha < 0 ? trkPnt.customColoring :
757                        new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (hdopAlpha << 24), true);
758                    g.setColor(customColoringTransparent);
759                    // hdop circles
760                    int hdopp = mv.getPoint(new LatLon(
761                            trkPnt.getCoor().lat(),
762                            trkPnt.getCoor().lon() + 2d*6*hdop*360/40000000d)).x - screen.x;
763                    g.drawArc(screen.x-hdopp/2, screen.y-hdopp/2, hdopp, hdopp, 0, 360);
764                }
765                if (large) {
766                    // color the large GPS points like the gps lines
767                    if (trkPnt.customColoring != null) {
768                        Color customColoringTransparent = largePointAlpha < 0 ? trkPnt.customColoring :
769                            new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (largePointAlpha << 24), true);
770
771                        g.setColor(customColoringTransparent);
772                    }
773                    g.fillRect(screen.x-halfSize, screen.y-halfSize, largesize, largesize);
774                }
775            } // end for trkpnt
776        } // end if large || hdopcircle
777
778        /****************************************************************
779         ********** STEP 3e - DRAW SMALL POINTS FOR LINES ***************
780         ****************************************************************/
781        if (!large && lines) {
782            g.setColor(neutralColor);
783            for (WayPoint trkPnt : visibleSegments) {
784                LatLon c = trkPnt.getCoor();
785                if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
786                    continue;
787                }
788                if (!trkPnt.drawLine) {
789                    Point screen = mv.getPoint(trkPnt);
790                    g.drawRect(screen.x, screen.y, 0, 0);
791                }
792            } // end for trkpnt
793        } // end if large
794
795        /****************************************************************
796         ********** STEP 3f - DRAW SMALL POINTS INSTEAD OF LINES ********
797         ****************************************************************/
798        if (!large && !lines) {
799            g.setColor(neutralColor);
800            for (WayPoint trkPnt : visibleSegments) {
801                LatLon c = trkPnt.getCoor();
802                if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
803                    continue;
804                }
805                Point screen = mv.getPoint(trkPnt);
806                g.setColor(trkPnt.customColoring);
807                g.drawRect(screen.x, screen.y, 0, 0);
808            } // end for trkpnt
809        } // end if large
810    }
811
812    /**
813     * Draw GPX lines by using alpha blending
814     * @param g               the common draw object to use
815     * @param mv              the meta data to current displayed area
816     * @param visibleSegments segments visible in the current scope of mv
817     * @param layerAlpha      the color alpha value set for that operation
818     */
819    private void drawLinesAlpha(Graphics2D g, MapView mv, List<WayPoint> visibleSegments, float layerAlpha) {
820
821        // 1st. backup the paint environment ----------------------------------
822        Composite oldComposite = g.getComposite();
823        Stroke oldStroke = g.getStroke();
824        Paint oldPaint = g.getPaint();
825
826        // 2nd. determine current scale factors -------------------------------
827
828        // adjust global settings
829        final int globalLineWidth = Utils.clamp(lineWidth, 1, 20);
830
831        // cache scale of view
832        final double zoomScale = mv.getDist100Pixel() / 50.0f;
833
834        // 3rd. determine current paint parameters -----------------------------
835
836        // alpha value is based on zoom and line with combined with global layer alpha
837        float theLineAlpha = (float) Utils.clamp((0.50 / zoomScale) / (globalLineWidth + 1), 0.01, 0.50) * layerAlpha;
838        final int theLineWith = (int) (lineWidth / zoomScale) + 1;
839
840        // 4th setup virtual paint area ----------------------------------------
841
842        // set line format and alpha channel for all overlays (more lines -> few overlap -> more transparency)
843        g.setStroke(new BasicStroke(theLineWith, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
844        g.setComposite(AlphaComposite.SrcOver.derive(theLineAlpha));
845
846        // last used / calculated entries
847        Point lastPaintPnt = null;
848
849        // 5th draw the layer ---------------------------------------------------
850
851        // for all points
852        for (WayPoint trkPnt : visibleSegments) {
853
854            // transform coordinates
855            final Point paintPnt = mv.getPoint(trkPnt);
856
857            // skip single points
858            if (lastPaintPnt != null && trkPnt.drawLine && !lastPaintPnt.equals(paintPnt)) {
859
860                // set different color
861                g.setColor(trkPnt.customColoring);
862
863                // draw it
864                g.drawLine(lastPaintPnt.x, lastPaintPnt.y, paintPnt.x, paintPnt.y);
865            }
866
867            lastPaintPnt = paintPnt;
868        }
869
870        // @last restore modified paint environment -----------------------------
871        g.setPaint(oldPaint);
872        g.setStroke(oldStroke);
873        g.setComposite(oldComposite);
874    }
875
876    /**
877     * Generates a linear gradient map image
878     *
879     * @param width  image width
880     * @param height image height
881     * @param colors 1..n color descriptions
882     * @return image object
883     */
884    protected static BufferedImage createImageGradientMap(int width, int height, Color... colors) {
885
886        // create image an paint object
887        final BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
888        final Graphics2D g = img.createGraphics();
889
890        float[] fract = new float[ colors.length ];
891
892        // distribute fractions (define position of color in map)
893        for (int i = 0; i < colors.length; ++i) {
894            fract[i] = i * (1.0f / colors.length);
895        }
896
897        // draw the gradient map
898        LinearGradientPaint gradient = new LinearGradientPaint(0, 0, width, height, fract, colors,
899                                                               MultipleGradientPaint.CycleMethod.NO_CYCLE);
900        g.setPaint(gradient);
901        g.fillRect(0, 0, width, height);
902        g.dispose();
903
904        // access it via raw interface
905        return img;
906    }
907
908    /**
909     * Creates a distributed colormap by linear blending between colors
910     * @param lowerLimit lower limit for first visible color
911     * @param colors 1..n colors
912     * @return array of Color objects
913     */
914    protected static Color[] createColorLut(int lowerLimit, Color... colors) {
915
916        // number of lookup entries
917        final int tableSize = 256;
918
919        // access it via raw interface
920        final Raster imgRaster = createImageGradientMap(tableSize, 1, colors).getData();
921
922        // the pixel storage
923        int[] pixel = new int[1];
924
925        Color[] colorTable = new Color[tableSize];
926
927        // map the range 0..255 to 0..pi/2
928        final double mapTo90Deg = Math.PI / 2.0 / 255.0;
929
930        // create the lookup table
931        for (int i = 0; i < tableSize; i++) {
932
933            // get next single pixel
934            imgRaster.getDataElements(i, 0, pixel);
935
936            // get color and map
937            Color c = new Color(pixel[0]);
938
939            // smooth alpha like sin curve
940            int alpha = (i > lowerLimit) ? (int) (Math.sin((i-lowerLimit) * mapTo90Deg) * 255) : 0;
941
942            // alpha with pre-offset, first color -> full transparent
943            alpha = alpha > 0 ? (20 + alpha) : 0;
944
945            // shrink to maximum bound
946            if (alpha > 255) {
947                alpha = 255;
948            }
949
950            // increase transparency for higher values ( avoid big saturation )
951            if (i > 240 && 255 == alpha) {
952                alpha -= (i - 240);
953            }
954
955            // fill entry in table, assign a alpha value
956            colorTable[i] = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
957        }
958
959        // transform into lookup table
960        return colorTable;
961    }
962
963    /**
964     * Creates a darker color
965     * @param in        Color object
966     * @param adjust    darker adjustment amount
967     * @return          new Color
968     */
969    protected static Color darkerColor(Color in, float adjust) {
970
971        final float r = (float) in.getRed()/255;
972        final float g = (float) in.getGreen()/255;
973        final float b = (float) in.getBlue()/255;
974
975        return new Color(r*adjust, g*adjust, b*adjust);
976    }
977
978    /**
979     * Creates a colormap by using a static color map with 1..n colors (RGB 0.0 ..1.0)
980     * @param str the filename (without extension) to look for into data/gpx
981     * @return the parsed colormap
982     */
983    protected static Color[] createColorFromResource(String str) {
984
985        // create resource string
986        final String colorFile = "resource://data/gpx/" + str + ".txt";
987
988        List<Color> colorList = new ArrayList<>();
989
990        // try to load the file
991        try (CachedFile cf = new CachedFile(colorFile); BufferedReader br = cf.getContentReader()) {
992
993            String line;
994
995            // process lines
996            while ((line = br.readLine()) != null) {
997
998                // use comma as separator
999                String[] column = line.split(",");
1000
1001                // empty or comment line
1002                if (column.length < 3 || column[0].startsWith("#")) {
1003                    continue;
1004                }
1005
1006                // extract RGB value
1007                float r = Float.parseFloat(column[0]);
1008                float g = Float.parseFloat(column[1]);
1009                float b = Float.parseFloat(column[2]);
1010
1011                // some color tables are 0..1.0 and some 0.255
1012                float scale = (r < 1 && g < 1 && b < 1) ? 1 : 255;
1013
1014                colorList.add(new Color(r/scale, g/scale, b/scale));
1015            }
1016        } catch (IOException e) {
1017            throw new JosmRuntimeException(e);
1018        }
1019
1020        // fallback if empty or failed
1021        if (colorList.isEmpty()) {
1022            colorList.add(Color.BLACK);
1023            colorList.add(Color.WHITE);
1024        } else {
1025            // add additional darker elements to end of list
1026            final Color lastColor = colorList.get(colorList.size() - 1);
1027            colorList.add(darkerColor(lastColor, 0.975f));
1028            colorList.add(darkerColor(lastColor, 0.950f));
1029        }
1030
1031        return createColorLut(0, colorList.toArray(new Color[ colorList.size() ]));
1032    }
1033
1034    /**
1035     * Returns the next user color map
1036     *
1037     * @param userColor - default or fallback user color
1038     * @param tableIdx  - selected user color index
1039     * @return color array
1040     */
1041    protected static Color[] selectColorMap(Color userColor, int tableIdx) {
1042
1043        // generate new user color map ( dark, user color, white )
1044        Color[] userColor1 = createColorLut(0, userColor.darker(), userColor, userColor.brighter(), Color.WHITE);
1045
1046        // generate new user color map ( white -> color )
1047        Color[] userColor2 = createColorLut(0, Color.WHITE, Color.WHITE, userColor);
1048
1049        // generate new user color map
1050        Color[] colorTrafficLights = createColorLut(0, Color.WHITE, Color.GREEN.darker(), Color.YELLOW, Color.RED);
1051
1052        // decide what, keep order is sync with setting on GUI
1053        Color[][] lut = {
1054                userColor1,
1055                userColor2,
1056                colorTrafficLights,
1057                heatMapLutColorJosmInferno,
1058                heatMapLutColorJosmViridis,
1059                heatMapLutColorJosmBrown2Green,
1060                heatMapLutColorJosmRed2Blue
1061        };
1062
1063        // default case
1064        Color[] nextUserColor = userColor1;
1065
1066        // select by index
1067        if (tableIdx < lut.length) {
1068            nextUserColor = lut[ tableIdx ];
1069        }
1070
1071        // adjust color map
1072        return nextUserColor;
1073    }
1074
1075    /**
1076     * Generates a Icon
1077     *
1078     * @param userColor selected user color
1079     * @param tableIdx tabled index
1080     * @param size size of the image
1081     * @return a image icon that shows the
1082     */
1083    public static ImageIcon getColorMapImageIcon(Color userColor, int tableIdx, int size) {
1084        return new ImageIcon(createImageGradientMap(size, size, selectColorMap(userColor, tableIdx)));
1085    }
1086
1087    /**
1088     * Draw gray heat map with current Graphics2D setting
1089     * @param gB              the common draw object to use
1090     * @param mv              the meta data to current displayed area
1091     * @param listSegm        segments visible in the current scope of mv
1092     * @param foreComp        composite use to draw foreground objects
1093     * @param foreStroke      stroke use to draw foreground objects
1094     * @param backComp        composite use to draw background objects
1095     * @param backStroke      stroke use to draw background objects
1096     */
1097    private void drawHeatGrayLineMap(Graphics2D gB, MapView mv, List<WayPoint> listSegm,
1098                                     Composite foreComp, Stroke foreStroke,
1099                                     Composite backComp, Stroke backStroke) {
1100
1101        // draw foreground
1102        boolean drawForeground = foreComp != null && foreStroke != null;
1103
1104        // set initial values
1105        gB.setStroke(backStroke); gB.setComposite(backComp);
1106
1107        // get last point in list
1108        final WayPoint lastPnt = !listSegm.isEmpty() ? listSegm.get(listSegm.size() - 1) : null;
1109
1110        // for all points, draw single lines by using optimized drawing
1111        for (WayPoint trkPnt : listSegm) {
1112
1113            // get transformed coordinates
1114            final Point paintPnt = mv.getPoint(trkPnt);
1115
1116            // end of line segment or end of list reached
1117            if (!trkPnt.drawLine || (lastPnt == trkPnt)) {
1118
1119                // convert to primitive type
1120                final int[] polyXArr = heatMapPolyX.stream().mapToInt(Integer::intValue).toArray();
1121                final int[] polyYArr = heatMapPolyY.stream().mapToInt(Integer::intValue).toArray();
1122
1123                // a.) draw background
1124                gB.drawPolyline(polyXArr, polyYArr, polyXArr.length);
1125
1126                // b.) draw extra foreground
1127                if (drawForeground && heatMapDrawExtraLine) {
1128
1129                    gB.setStroke(foreStroke); gB.setComposite(foreComp);
1130                    gB.drawPolyline(polyXArr, polyYArr, polyXArr.length);
1131                    gB.setStroke(backStroke); gB.setComposite(backComp);
1132                }
1133
1134                // drop used points
1135                heatMapPolyX.clear(); heatMapPolyY.clear();
1136            }
1137
1138            // store only the integer part (make sense because pixel is 1:1 here)
1139            heatMapPolyX.add((int) paintPnt.getX());
1140            heatMapPolyY.add((int) paintPnt.getY());
1141        }
1142    }
1143
1144    /**
1145     * Map the gray map to heat map and draw them with current Graphics2D setting
1146     * @param g               the common draw object to use
1147     * @param imgGray         gray scale input image
1148     * @param sampleRaster    the line with for drawing
1149     * @param outlineWidth     line width for outlines
1150     */
1151    private void drawHeatMapGrayMap(Graphics2D g, BufferedImage imgGray, int sampleRaster, int outlineWidth) {
1152
1153        final int[] imgPixels = ((DataBufferInt) imgGray.getRaster().getDataBuffer()).getData();
1154
1155        // samples offset and bounds are scaled with line width derived from zoom level
1156        final int offX = Math.max(1, sampleRaster);
1157        final int offY = Math.max(1, sampleRaster);
1158
1159        final int maxPixelX = imgGray.getWidth();
1160        final int maxPixelY = imgGray.getHeight();
1161
1162        // always full or outlines at big samples rasters
1163        final boolean drawOutlines = (outlineWidth > 0) && ((0 == sampleRaster) || (sampleRaster > 10));
1164
1165        // backup stroke
1166        final Stroke oldStroke = g.getStroke();
1167
1168        // use basic stroke for outlines and default transparency
1169        g.setStroke(new BasicStroke(outlineWidth));
1170
1171        int lastPixelX = 0;
1172        int lastPixelColor = 0;
1173
1174        // resample gray scale image with line linear weight of next sample in line
1175        // process each line and draw pixels / rectangles with same color with one operations
1176        for (int y = 0; y < maxPixelY; y += offY) {
1177
1178            // the lines offsets
1179            final int lastLineOffset = maxPixelX * (y+0);
1180            final int nextLineOffset = maxPixelX * (y+1);
1181
1182            for (int x = 0; x < maxPixelX; x += offX) {
1183
1184                int thePixelColor = 0; int thePixelCount = 0;
1185
1186                // sample the image (it is gray scale)
1187                int offset = lastLineOffset + x;
1188
1189                // merge next pixels of window of line
1190                for (int k = 0; k < offX && (offset + k) < nextLineOffset; k++) {
1191                    thePixelColor += imgPixels[offset+k] & 0xFF;
1192                    thePixelCount++;
1193                }
1194
1195                // mean value
1196                thePixelColor = thePixelCount > 0 ? (thePixelColor / thePixelCount) : 0;
1197
1198                // restart -> use initial sample
1199                if (0 == x) {
1200                    lastPixelX = 0; lastPixelColor = thePixelColor - 1;
1201                }
1202
1203                boolean bDrawIt = false;
1204
1205                // when one of segment is mapped to black
1206                bDrawIt = bDrawIt || (lastPixelColor == 0) || (thePixelColor == 0);
1207
1208                // different color
1209                bDrawIt = bDrawIt || (Math.abs(lastPixelColor-thePixelColor) > 0);
1210
1211                // when line is finished draw always
1212                bDrawIt = bDrawIt || (y >= (maxPixelY-offY));
1213
1214                if (bDrawIt) {
1215
1216                    // draw only foreground pixels
1217                    if (lastPixelColor > 0) {
1218
1219                        // gray to RGB mapping
1220                        g.setColor(heatMapLutColor[ lastPixelColor ]);
1221
1222                        // box from from last Y pixel to current pixel
1223                        if (drawOutlines) {
1224                            g.drawRect(lastPixelX, y, offX + x - lastPixelX, offY);
1225                        } else {
1226                            g.fillRect(lastPixelX, y, offX + x - lastPixelX, offY);
1227                        }
1228                    }
1229
1230                    // restart detection
1231                    lastPixelX = x; lastPixelColor = thePixelColor;
1232                }
1233            }
1234        }
1235
1236        // recover
1237        g.setStroke(oldStroke);
1238    }
1239
1240    /**
1241     * Collect and draw GPS segments and displays a heat-map
1242     * @param g               the common draw object to use
1243     * @param mv              the meta data to current displayed area
1244     * @param visibleSegments segments visible in the current scope of mv
1245     */
1246    private void drawHeatMap(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
1247
1248        // get bounds of screen image and projection, zoom and adjust input parameters
1249        final Rectangle screenBounds = new Rectangle(mv.getWidth(), mv.getHeight());
1250        final MapViewState mapViewState = mv.getState();
1251        final double zoomScale = mv.getDist100Pixel() / 50.0f;
1252
1253        // adjust global settings ( zero = default line width )
1254        final int globalLineWidth = (0 == lineWidth) ? 1 : Utils.clamp(lineWidth, 1, 20);
1255
1256        // 1st setup virtual paint area ----------------------------------------
1257
1258        // new image buffer needed
1259        final boolean imageSetup = null == heatMapImgGray || !heatMapCacheScreenBounds.equals(screenBounds);
1260
1261        // screen bounds changed, need new image buffer ?
1262        if (imageSetup) {
1263            // we would use a "pure" grayscale image, but there is not efficient way to map gray scale values to RGB)
1264            heatMapImgGray = new BufferedImage(screenBounds.width, screenBounds.height, BufferedImage.TYPE_INT_ARGB);
1265            heatMapGraph2d = heatMapImgGray.createGraphics();
1266            heatMapGraph2d.setBackground(new Color(0, 0, 0, 255));
1267            heatMapGraph2d.setColor(Color.WHITE);
1268
1269            // fast draw ( maybe help or not )
1270            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
1271            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
1272            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
1273            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
1274            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
1275            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
1276            heatMapGraph2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
1277
1278            // cache it
1279            heatMapCacheScreenBounds = screenBounds;
1280        }
1281
1282        // 2nd. determine current scale factors -------------------------------
1283
1284        // the line width (foreground: draw extra small footprint line of track)
1285        int lineWidthB = (int) Math.max(1.5f * (globalLineWidth / zoomScale) + 1, 2);
1286        int lineWidthF = lineWidthB > 2 ? (globalLineWidth - 1) : 0;
1287
1288        // global alpha adjustment
1289        float lineAlpha = (float) Utils.clamp((0.40 / zoomScale) / (globalLineWidth + 1), 0.01, 0.40);
1290
1291        // adjust 0.15 .. 1.85
1292        float scaleAlpha = 1.0f + ((heatMapDrawGain/10.0f) * 0.85f);
1293
1294        // add to calculated values
1295        float lineAlphaBPoint = (float) Utils.clamp((lineAlpha * 0.65) * scaleAlpha, 0.001, 0.90);
1296        float lineAlphaBLine = (float) Utils.clamp((lineAlpha * 1.00) * scaleAlpha, 0.001, 0.90);
1297        float lineAlphaFLine = (float) Utils.clamp((lineAlpha / 1.50) * scaleAlpha, 0.001, 0.90);
1298
1299        // 3rd Calculate the heat map data by draw GPX traces with alpha value ----------
1300
1301        // recalculation of image needed
1302        final boolean imageRecalc = !mapViewState.equalsInWindow(heatMapMapViewState)
1303                || gpxLayerInvalidated
1304                || heatMapCacheLineWith != globalLineWidth;
1305
1306        // need re-generation of gray image ?
1307        if (imageSetup || imageRecalc) {
1308
1309            // clear background
1310            heatMapGraph2d.clearRect(0, 0, heatMapImgGray.getWidth(), heatMapImgGray.getHeight());
1311
1312            // point or line blending
1313            if (heatMapDrawPointMode) {
1314                heatMapGraph2d.setComposite(AlphaComposite.SrcOver.derive(lineAlphaBPoint));
1315                drawHeatGrayDotMap(heatMapGraph2d, mv, visibleSegments, lineWidthB);
1316
1317            } else {
1318                drawHeatGrayLineMap(heatMapGraph2d, mv, visibleSegments,
1319                                    lineWidthF > 1 ? AlphaComposite.SrcOver.derive(lineAlphaFLine) : null,
1320                                    new BasicStroke(lineWidthF, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND),
1321                                    AlphaComposite.SrcOver.derive(lineAlphaBLine),
1322                                    new BasicStroke(lineWidthB, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
1323            }
1324
1325            // remember draw parameter
1326            heatMapMapViewState = mapViewState;
1327            heatMapCacheLineWith = globalLineWidth;
1328            gpxLayerInvalidated = false;
1329        }
1330
1331        // 4th. Draw data on target layer, map data via color lookup table --------------
1332        drawHeatMapGrayMap(g, heatMapImgGray, lineWidthB > 2 ? (int) (lineWidthB*1.25f) : 1, lineWidth > 2 ? (lineWidth - 2) : 1);
1333    }
1334
1335    /**
1336     * Draw a dotted heat map
1337     *
1338     * @param gB              the common draw object to use
1339     * @param mv              the meta data to current displayed area
1340     * @param listSegm        segments visible in the current scope of mv
1341     * @param drawSize        draw size of draw element
1342     */
1343    private static void drawHeatGrayDotMap(Graphics2D gB, MapView mv, List<WayPoint> listSegm, int drawSize) {
1344
1345        // typical rendering rate -> use realtime preview instead of accurate display
1346        final double maxSegm = 25_000, nrSegms = listSegm.size();
1347
1348        // determine random drop rate
1349        final double randomDrop = Math.min(nrSegms > maxSegm ? (nrSegms - maxSegm) / nrSegms : 0, 0.70f);
1350
1351        // http://www.nstb.tc.faa.gov/reports/PAN94_0716.pdf#page=22
1352        // Global Average Position Domain Accuracy, typical -> not worst case !
1353        // < 4.218 m Vertical
1354        // < 2.168 m Horizontal
1355        final double pixelRmsX = (100 / mv.getDist100Pixel()) * 2.168;
1356        final double pixelRmsY = (100 / mv.getDist100Pixel()) * 4.218;
1357
1358        Point lastPnt = null;
1359
1360        // for all points, draw single lines
1361        for (WayPoint trkPnt : listSegm) {
1362
1363            // get transformed coordinates
1364            final Point paintPnt = mv.getPoint(trkPnt);
1365
1366            // end of line segment or end of list reached
1367            if (trkPnt.drawLine && null != lastPnt) {
1368                drawHeatSurfaceLine(gB, paintPnt, lastPnt, drawSize, pixelRmsX, pixelRmsY, randomDrop);
1369            }
1370
1371            // remember
1372            lastPnt = paintPnt;
1373        }
1374    }
1375
1376    /**
1377     * Draw a dotted surface line
1378     *
1379     * @param g                 the common draw object to use
1380     * @param fromPnt           start point
1381     * @param toPnt             end point
1382     * @param drawSize          size of draw elements
1383     * @param rmsSizeX          RMS size of circle for X (width)
1384     * @param rmsSizeY          RMS size of circle for Y (height)
1385     * @param dropRate          Pixel render drop rate
1386     */
1387    private static void drawHeatSurfaceLine(Graphics2D g,
1388            Point fromPnt, Point toPnt, int drawSize, double rmsSizeX, double rmsSizeY, double dropRate) {
1389
1390        // collect frequently used items
1391        final int fromX = (int) fromPnt.getX(); final int deltaX = (int) (toPnt.getX() - fromX);
1392        final int fromY = (int) fromPnt.getY(); final int deltaY = (int) (toPnt.getY() - fromY);
1393
1394        // use same random values for each point
1395        final Random heatMapRandom = new Random(fromX+fromY+deltaX+deltaY);
1396
1397        // cache distance between start and end point
1398        final int dist = (int) Math.abs(fromPnt.distance(toPnt));
1399
1400        // number of increment ( fill wide distance tracks )
1401        double scaleStep = Math.max(1.0f / dist, dist > 100 ? 0.10f : 0.20f);
1402
1403        // number of additional random points
1404        int rounds = Math.min(drawSize/2, 1)+1;
1405
1406        // decrease random noise at high drop rate ( more accurate draw of fewer points )
1407        rmsSizeX *= (1.0d - dropRate);
1408        rmsSizeY *= (1.0d - dropRate);
1409
1410        double scaleVal = 0;
1411
1412        // interpolate line draw ( needs separate point instead of line )
1413        while (scaleVal < (1.0d-0.0001d)) {
1414
1415            // get position
1416            final double pntX = fromX + scaleVal * deltaX;
1417            final double pntY = fromY + scaleVal * deltaY;
1418
1419            // add random distribution around sampled point
1420            for (int k = 0; k < rounds; k++) {
1421
1422                // add error distribution, first point with less error
1423                int x = (int) (pntX + heatMapRandom.nextGaussian() * (k > 0 ? rmsSizeX : rmsSizeX/4));
1424                int y = (int) (pntY + heatMapRandom.nextGaussian() * (k > 0 ? rmsSizeY : rmsSizeY/4));
1425
1426                // draw it, even drop is requested
1427                if (heatMapRandom.nextDouble() >= dropRate) {
1428                    g.fillRect(x-drawSize, y-drawSize, drawSize, drawSize);
1429                }
1430            }
1431            scaleVal += scaleStep;
1432        }
1433    }
1434
1435    /**
1436     * Apply default color configuration to way segments
1437     * @param visibleSegments segments visible in the current scope of mv
1438     */
1439    private void fixColors(List<WayPoint> visibleSegments) {
1440        for (WayPoint trkPnt : visibleSegments) {
1441            if (trkPnt.customColoring == null) {
1442                trkPnt.customColoring = neutralColor;
1443            }
1444        }
1445    }
1446
1447    /**
1448     * Check cache validity set necessary flags
1449     */
1450    private void checkCache() {
1451        // CHECKSTYLE.OFF: BooleanExpressionComplexity
1452        if ((computeCacheMaxLineLengthUsed != maxLineLength)
1453                || (computeCacheColored != colored)
1454                || (computeCacheColorTracksTune != colorTracksTune)
1455                || (computeCacheColorDynamic != colorModeDynamic)
1456                || (computeCacheHeatMapDrawColorTableIdx != heatMapDrawColorTableIdx)
1457                || (!neutralColor.equals(computeCacheColorUsed)
1458                || (computeCacheHeatMapDrawPointMode != heatMapDrawPointMode)
1459                || (computeCacheHeatMapDrawGain != heatMapDrawGain))
1460                || (computeCacheHeatMapDrawLowerLimit != heatMapDrawLowerLimit)
1461        ) {
1462            // CHECKSTYLE.ON: BooleanExpressionComplexity
1463            computeCacheMaxLineLengthUsed = maxLineLength;
1464            computeCacheInSync = false;
1465            computeCacheColorUsed = neutralColor;
1466            computeCacheColored = colored;
1467            computeCacheColorTracksTune = colorTracksTune;
1468            computeCacheColorDynamic = colorModeDynamic;
1469            computeCacheHeatMapDrawColorTableIdx = heatMapDrawColorTableIdx;
1470            computeCacheHeatMapDrawPointMode = heatMapDrawPointMode;
1471            computeCacheHeatMapDrawGain = heatMapDrawGain;
1472            computeCacheHeatMapDrawLowerLimit = heatMapDrawLowerLimit;
1473        }
1474    }
1475
1476    /**
1477     *  callback when data is changed, invalidate cached configuration parameters
1478     */
1479    @Override
1480    public void gpxDataChanged(GpxDataChangeEvent e) {
1481        computeCacheInSync = false;
1482    }
1483
1484    /**
1485     * Draw all GPX arrays
1486     * @param g               the common draw object to use
1487     * @param mv              the meta data to current displayed area
1488     */
1489    public void drawColorBar(Graphics2D g, MapView mv) {
1490        int w = mv.getWidth();
1491
1492        // set do default
1493        g.setComposite(AlphaComposite.SrcOver.derive(1.00f));
1494
1495        if (colored == ColorMode.HDOP) {
1496            hdopScale.drawColorBar(g, w-30, 50, 20, 100, 1.0);
1497        } else if (colored == ColorMode.VELOCITY) {
1498            SystemOfMeasurement som = SystemOfMeasurement.getSystemOfMeasurement();
1499            velocityScale.drawColorBar(g, w-30, 50, 20, 100, som.speedValue);
1500        } else if (colored == ColorMode.DIRECTION) {
1501            directionScale.drawColorBar(g, w-30, 50, 20, 100, 180.0/Math.PI);
1502        }
1503    }
1504
1505    @Override
1506    public void paintableInvalidated(PaintableInvalidationEvent event) {
1507        gpxLayerInvalidated = true;
1508    }
1509
1510    @Override
1511    public void detachFromMapView(MapViewEvent event) {
1512        SystemOfMeasurement.removeSoMChangeListener(this);
1513        layer.removeInvalidationListener(this);
1514        data.removeChangeListener(this);
1515    }
1516}
Note: See TracBrowser for help on using the repository browser.