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