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